From c99cde65aefbe59d1b1297f7d6237e73542fbc4b Mon Sep 17 00:00:00 2001
From: Kevin Moore <kevmoo@google.com>
Date: Wed, 22 May 2024 15:45:58 -0700
Subject: [PATCH] Update MDN source and doc comments

---
 lib/src/dom/battery_status.dart           |   27 +-
 lib/src/dom/console.dart                  |   16 +-
 lib/src/dom/cookie_store.dart             |   38 +-
 lib/src/dom/credential_management.dart    |   54 +-
 lib/src/dom/css_typed_om.dart             |  118 +-
 lib/src/dom/dom.dart                      |  129 ++-
 lib/src/dom/fetch.dart                    |    2 +-
 lib/src/dom/fileapi.dart                  |   67 +-
 lib/src/dom/fs.dart                       |   16 +
 lib/src/dom/hr_time.dart                  |   10 +-
 lib/src/dom/html.dart                     |  675 ++++++++++-
 lib/src/dom/indexeddb.dart                |   24 +-
 lib/src/dom/mediacapture_streams.dart     |    2 +-
 lib/src/dom/notifications.dart            |    6 +
 lib/src/dom/performance_timeline.dart     |    2 +
 lib/src/dom/permissions.dart              |    8 +-
 lib/src/dom/push_api.dart                 |   14 +
 lib/src/dom/selection_api.dart            |   24 +-
 lib/src/dom/service_workers.dart          |  118 +-
 lib/src/dom/speech_api.dart               |    4 +-
 lib/src/dom/streams.dart                  |    4 +-
 lib/src/dom/trusted_types.dart            |    6 +-
 lib/src/dom/uievents.dart                 |   18 +-
 lib/src/dom/webauthn.dart                 |   11 +
 lib/src/dom/webcodecs.dart                |   86 ++
 lib/src/dom/webcryptoapi.dart             |   15 +-
 lib/src/dom/webrtc.dart                   |  641 +++++------
 lib/src/dom/webrtc_encoded_transform.dart |   14 +
 lib/src/dom/xhr.dart                      |   87 +-
 third_party/mdn/mdn.json                  | 1263 ++++++++++++---------
 30 files changed, 2282 insertions(+), 1217 deletions(-)

diff --git a/lib/src/dom/battery_status.dart b/lib/src/dom/battery_status.dart
index b362c967..527091dc 100644
--- a/lib/src/dom/battery_status.dart
+++ b/lib/src/dom/battery_status.dart
@@ -16,7 +16,7 @@ import 'dart:js_interop';
 import 'dom.dart';
 import 'html.dart';
 
-/// The `BatteryManager` interface of the [Battery Status API] provides
+/// The **`BatteryManager`** interface of the [Battery Status API] provides
 /// information about the system's battery charge level. The
 /// [navigator.getBattery] method returns a promise that resolves with a
 /// `BatteryManager` interface.
@@ -29,19 +29,20 @@ import 'html.dart';
 /// API documentation sourced from
 /// [MDN Web Docs](https://developer.mozilla.org/en-US/docs/Web/API/BatteryManager).
 extension type BatteryManager._(JSObject _) implements EventTarget, JSObject {
-  /// The **`BatteryManager.charging`** property is a Boolean value indicating
-  /// whether or not the device's battery is currently being charged. When its
-  /// value changes, the [BatteryManager.chargingchange_event] event is fired.
+  /// The **`charging`** read-only property of the [BatteryManager] interface is
+  /// a Boolean value indicating whether or not the device's battery is
+  /// currently being charged. When its value changes, the
+  /// [BatteryManager.chargingchange_event] event is fired.
   ///
   /// If the battery is charging or the user agent is unable to report the
   /// battery status information, this value is `true`. Otherwise, it is
   /// `false`.
   external bool get charging;
 
-  /// The **`BatteryManager.chargingTime`** property indicates the amount of
-  /// time, in seconds, that remain until the battery is fully charged, or `0`
-  /// if the battery is already fully charged or the user agent is unable to
-  /// report the battery status information.
+  /// The **`chargingTime`** read-only property of the [BatteryManager]
+  /// interface indicates the amount of time, in seconds, that remain until the
+  /// battery is fully charged, or `0` if the battery is already fully charged
+  /// or the user agent is unable to report the battery status information.
   /// If the battery is currently discharging, its value is `Infinity`.
   /// When its value changes, the [BatteryManager.chargingtimechange_event]
   /// event is fired.
@@ -51,8 +52,9 @@ extension type BatteryManager._(JSObject _) implements EventTarget, JSObject {
   /// > (typically to the closest 15 minutes) for privacy reasons.
   external num get chargingTime;
 
-  /// The **`BatteryManager.dischargingTime`** property indicates the amount of
-  /// time, in seconds, that remains until the battery is fully discharged,
+  /// The **`dischargingTime`** read-only property of the [BatteryManager]
+  /// interface indicates the amount of time, in seconds, that remains until the
+  /// battery is fully discharged,
   /// or `Infinity` if the battery is currently charging rather than discharging
   /// or the user agent is unable to report the battery status information.
   /// When its value changes, the [BatteryManager.dischargingtimechange_event]
@@ -63,8 +65,9 @@ extension type BatteryManager._(JSObject _) implements EventTarget, JSObject {
   /// > interval (typically to the closest 15 minutes) for privacy reasons.
   external num get dischargingTime;
 
-  /// The **`BatteryManager.level`** property indicates the current battery
-  /// charge level as a value between `0.0` and `1.0`.
+  /// The **`level`** read-only property of the [BatteryManager] interface
+  /// indicates the current battery charge level as a value between `0.0` and
+  /// `1.0`.
   /// A value of `0.0` means the battery is empty and the system is about to be
   /// suspended.
   /// A value of `1.0` means the battery is full or the user agent is unable to
diff --git a/lib/src/dom/console.dart b/lib/src/dom/console.dart
index c5a72e8a..d8394921 100644
--- a/lib/src/dom/console.dart
+++ b/lib/src/dom/console.dart
@@ -18,9 +18,13 @@ external $Console get console;
 
 /// The **`console`** object provides access to the debugging console (e.g., the
 /// [Web console](https://firefox-source-docs.mozilla.org/devtools-user/web_console/index.html)
-/// in Firefox). The specifics of how it works vary from browser to browser or
-/// server runtimes (Node.js, for example), but there is a _de facto_ set of
-/// features that are typically provided.
+/// in Firefox).
+///
+/// Implementations of the console API may differ between runtimes. In
+/// particular, some console methods may work differently or not work at all in
+/// some online editors and IDEs. To see the behavior described in this
+/// documentation, try the methods in your browser's developer tools, although
+/// even here, there are some differences between browsers.
 ///
 /// The `console` object can be accessed from any global object. [Window] on
 /// browsing scopes and [WorkerGlobalScope] as specific variants in workers via
@@ -34,12 +38,6 @@ external $Console get console;
 /// This page documents the [Methods](#methods) available on the `console`
 /// object and gives a few [Usage](#usage) examples.
 ///
-/// > **Note:** Certain online IDEs and editors may implement the console API
-/// > differently than the browsers. As a result, certain functionality of the
-/// > console API, such as the timer methods, may not be outputted in the
-/// > console of online IDEs or editors. Always open your browser's DevTools
-/// > console to see the logs as shown in this documentation.
-///
 /// ---
 ///
 /// API documentation sourced from
diff --git a/lib/src/dom/cookie_store.dart b/lib/src/dom/cookie_store.dart
index aacf7b7f..c04abd50 100644
--- a/lib/src/dom/cookie_store.dart
+++ b/lib/src/dom/cookie_store.dart
@@ -21,6 +21,8 @@ import 'service_workers.dart';
 typedef CookieList = JSArray<CookieListItem>;
 typedef CookieSameSite = String;
 
+/// @AvailableInWorkers("window_and_service")
+///
 /// The **`CookieStore`** interface of the [Cookie Store API] provides methods
 /// for getting and setting cookies asynchronously from either a page or a
 /// service worker.
@@ -34,26 +36,34 @@ typedef CookieSameSite = String;
 /// API documentation sourced from
 /// [MDN Web Docs](https://developer.mozilla.org/en-US/docs/Web/API/CookieStore).
 extension type CookieStore._(JSObject _) implements EventTarget, JSObject {
+  /// @AvailableInWorkers("window_and_service")
+  ///
   /// The **`get()`** method of the [CookieStore] interface returns a single
-  /// cookie with the given name or options object. The method will return the
-  /// first matching cookie for the passed parameters.
+  /// cookie with the given `name` or `options` object. The method will return
+  /// the first matching cookie for the passed parameters.
   external JSPromise<CookieListItem?> get([JSAny nameOrOptions]);
 
+  /// @AvailableInWorkers("window_and_service")
+  ///
   /// The **`getAll()`** method of the [CookieStore] interface returns a list of
-  /// cookies that match the name or options passed to it. Passing no parameters
-  /// will return all cookies for the current context.
+  /// cookies that match the `name` or `options` passed to it. Passing no
+  /// parameters will return all cookies for the current context.
   external JSPromise<CookieList> getAll([JSAny nameOrOptions]);
 
+  /// @AvailableInWorkers("window_and_service")
+  ///
   /// The **`set()`** method of the [CookieStore] interface sets a cookie with
-  /// the given name and value or options object.
+  /// the given `name` and `value` or `options` object.
   external JSPromise<JSAny?> set(
     JSAny nameOrOptions, [
     String value,
   ]);
 
+  /// @AvailableInWorkers("window_and_service")
+  ///
   /// The **`delete()`** method of the [CookieStore] interface deletes a cookie
-  /// with the given name or options object. The `delete()` method expires the
-  /// cookie by changing the date to one in the past.
+  /// with the given `name` or `options` object. The `delete()` method expires
+  /// the cookie by changing the date to one in the past.
   external JSPromise<JSAny?> delete(JSAny nameOrOptions);
   external EventHandler get onchange;
   external set onchange(EventHandler value);
@@ -142,6 +152,8 @@ extension type CookieListItem._(JSObject _) implements JSObject {
   external set partitioned(bool value);
 }
 
+/// @AvailableInWorkers("window_and_service")
+///
 /// The **`CookieStoreManager`** interface of the [Cookie Store API] allows
 /// service workers to subscribe to cookie change events. Call
 /// [CookieStoreManager.subscribe] on a particular service worker registration
@@ -160,16 +172,22 @@ extension type CookieListItem._(JSObject _) implements JSObject {
 /// API documentation sourced from
 /// [MDN Web Docs](https://developer.mozilla.org/en-US/docs/Web/API/CookieStoreManager).
 extension type CookieStoreManager._(JSObject _) implements JSObject {
+  /// @AvailableInWorkers("window_and_service")
+  ///
   /// The **`subscribe()`** method of the [CookieStoreManager] interface
   /// subscribes a [ServiceWorkerRegistration] to cookie change events.
   external JSPromise<JSAny?> subscribe(
       JSArray<CookieStoreGetOptions> subscriptions);
 
+  /// @AvailableInWorkers("window_and_service")
+  ///
   /// The **`getSubscriptions()`** method of the [CookieStoreManager] interface
   /// returns a list of all the cookie change subscriptions for this
   /// [ServiceWorkerRegistration].
   external JSPromise<JSArray<CookieStoreGetOptions>> getSubscriptions();
 
+  /// @AvailableInWorkers("window_and_service")
+  ///
   /// The **`unsubscribe()`** method of the [CookieStoreManager] interface stops
   /// the [ServiceWorkerRegistration] from receiving previously subscribed
   /// events.
@@ -229,6 +247,8 @@ extension type CookieChangeEventInit._(JSObject _)
   external set deleted(CookieList value);
 }
 
+/// @AvailableInWorkers("service")
+///
 /// The **`ExtendableCookieChangeEvent`** interface of the [Cookie Store API] is
 /// the event type passed to [ServiceWorkerGlobalScope.cookiechange_event] event
 /// fired at the [ServiceWorkerGlobalScope] when any cookie changes occur which
@@ -259,11 +279,15 @@ extension type ExtendableCookieChangeEvent._(JSObject _)
     ExtendableCookieChangeEventInit eventInitDict,
   ]);
 
+  /// @AvailableInWorkers("service")
+  ///
   /// The **`changed`** read-only property of the [ExtendableCookieChangeEvent]
   /// interface returns any cookies that have been changed by the given
   /// `ExtendableCookieChangeEvent` instance.
   external JSArray<CookieListItem> get changed;
 
+  /// @AvailableInWorkers("service")
+  ///
   /// The **`deleted`** read-only property of the [ExtendableCookieChangeEvent]
   /// interface returns any cookies that have been deleted by the given
   /// `ExtendableCookieChangeEvent` instance.
diff --git a/lib/src/dom/credential_management.dart b/lib/src/dom/credential_management.dart
index b07a6971..0156b43f 100644
--- a/lib/src/dom/credential_management.dart
+++ b/lib/src/dom/credential_management.dart
@@ -99,32 +99,22 @@ extension type CredentialsContainer._(JSObject _) implements JSObject {
   /// > `<iframe>` element will resolve without effect.
   external JSPromise<JSAny?> store(Credential credential);
 
-  /// The **`create()`** method of the [CredentialsContainer] interface returns
-  /// a `Promise` that resolves with a new credential instance based on the
-  /// provided options, the information from which can then be stored and later
-  /// used to authenticate users via [CredentialsContainer.get].
+  /// The **`create()`** method of the [CredentialsContainer] interface creates
+  /// a new , which can then be stored and later used to authenticate users via
+  /// [CredentialsContainer.get].
   ///
-  /// This is used by multiple different credential-related APIs with
-  /// significantly different purposes:
+  /// This method supports three different types of credential:
   ///
-  /// - The
-  ///   [Credential Management API](https://developer.mozilla.org/en-US/docs/Web/API/Credential_Management_API)
-  ///   uses `create()` to create basic federated credentials or
-  ///   username/password credentials.
-  /// - The
-  ///   [Web Authentication API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Authentication_API)
-  ///   uses `create()` to create public key credentials (based on asymmetric
-  ///   cryptography).
-  ///
-  /// The below reference page starts with a syntax section that explains the
-  /// general method call structure and parameters that apply to all the
-  /// different APIs. After that, it is split into separate sections providing
-  /// parameters, return values, and examples specific to each API.
+  /// - A password credential, which enables a user to sign in using a password.
+  /// - A federated credential, which enables a user to sign in using a
+  ///   federated identity provider.
+  /// - A public key credential, which enables a user to sign in with an
+  ///   authenticator such as a biometric reader built into the platform or a
+  ///   removable hardware token.
   ///
-  /// > **Note:** This method is restricted to top-level  (i.e., a document
-  /// > running directly inside a browser tab, and not embedded inside another
-  /// > document). Calls to it from within an `<iframe>` element will resolve
-  /// > without effect.
+  /// Note that the [Federated Credential Management API
+  /// (FedCM)](https://developer.mozilla.org/en-US/docs/Web/API/FedCM_API)
+  /// supersedes the federated credential type.
   external JSPromise<Credential?> create([CredentialCreationOptions options]);
 
   /// The **`preventSilentAccess()`** method of the [CredentialsContainer]
@@ -224,6 +214,24 @@ extension type FederatedCredentialRequestOptions._(JSObject _)
   external JSArray<JSString> get protocols;
   external set protocols(JSArray<JSString> value);
 }
+
+/// The **`FederatedCredentialInit`** dictionary represents the object passed to
+/// [CredentialsContainer.create] as the value of the `federated` option: that
+/// is, when creating a [FederatedCredential] object representing a credential
+/// associated with a federated identify provider.
+///
+/// > **Note:** The [Federated Credential Management API
+/// > (FedCM)](https://developer.mozilla.org/en-US/docs/Web/API/FedCM_API)
+/// > supersedes the [FederatedCredential] interface in favor of the
+/// > [IdentityCredential] interface.
+/// >
+/// > The `FederatedCredentialInit` dictionary is not used when working with the
+/// > `IdentityCredential`interface.
+///
+/// ---
+///
+/// API documentation sourced from
+/// [MDN Web Docs](https://developer.mozilla.org/en-US/docs/Web/API/FederatedCredentialInit).
 extension type FederatedCredentialInit._(JSObject _)
     implements CredentialData, JSObject {
   external factory FederatedCredentialInit({
diff --git a/lib/src/dom/css_typed_om.dart b/lib/src/dom/css_typed_om.dart
index 2bba5c79..4592e147 100644
--- a/lib/src/dom/css_typed_om.dart
+++ b/lib/src/dom/css_typed_om.dart
@@ -110,8 +110,9 @@ extension type StylePropertyMap._(JSObject _)
   external void clear();
 }
 
-/// The **`CSSUnparsedValue`** interface of the  represents property values that
-/// reference
+/// The **`CSSUnparsedValue`** interface of the
+/// [CSS Typed Object Model API](https://developer.mozilla.org/en-US/docs/Web/API/CSS_Object_Model)
+/// represents property values that reference
 /// [custom properties](https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_cascading_variables).
 /// It consists of a list of string fragments and variable references.
 ///
@@ -131,10 +132,11 @@ extension type CSSUnparsedValue._(JSObject _)
   external int get length;
 }
 
-/// The **`CSSVariableReferenceValue`** interface of the  allows you to create a
-/// custom name for a built-in CSS value. This object functionality is sometimes
-/// called a "CSS variable" and serves the same purpose as the `var()` function.
-/// The custom name must begin with two dashes.
+/// The **`CSSVariableReferenceValue`** interface of the
+/// [CSS Typed Object Model API](https://developer.mozilla.org/en-US/docs/Web/API/CSS_Object_Model)
+/// allows you to create a custom name for a built-in CSS value. This object
+/// functionality is sometimes called a "CSS variable" and serves the same
+/// purpose as the `var()` function. The custom name must begin with two dashes.
 ///
 /// ---
 ///
@@ -283,9 +285,10 @@ extension type CSSNumericValue._(JSObject _)
   external CSSNumericType type();
 }
 
-/// The **`CSSUnitValue`** interface of the  represents values that contain a
-/// single unit type. For example, "42px" would be represented by a
-/// `CSSNumericValue`.
+/// The **`CSSUnitValue`** interface of the
+/// [CSS Typed Object Model API](https://developer.mozilla.org/en-US/docs/Web/API/CSS_Object_Model#css_typed_object_model)
+/// represents values that contain a single unit type. For example, "42px" would
+/// be represented by a `CSSNumericValue`.
 ///
 /// ---
 ///
@@ -308,8 +311,9 @@ extension type CSSUnitValue._(JSObject _) implements CSSNumericValue, JSObject {
   external String get unit;
 }
 
-/// The **`CSSMathValue`** interface of the  a base class for classes
-/// representing complex numeric values.
+/// The **`CSSMathValue`** interface of the
+/// [CSS Typed Object Model API](https://developer.mozilla.org/en-US/docs/Web/API/CSS_Object_Model)
+/// a base class for classes representing complex numeric values.
 ///
 /// ---
 ///
@@ -324,9 +328,10 @@ extension type CSSMathValue._(JSObject _) implements CSSNumericValue, JSObject {
   external CSSMathOperator get operator;
 }
 
-/// The **`CSSMathSum`** interface of the  represents the result obtained by
-/// calling [CSSNumericValue.add], [CSSNumericValue.sub], or
-/// [CSSNumericValue.toSum] on [CSSNumericValue].
+/// The **`CSSMathSum`** interface of the
+/// [CSS Typed Object Model API](https://developer.mozilla.org/en-US/docs/Web/API/CSS_Object_Model)
+/// represents the result obtained by calling [CSSNumericValue.add],
+/// [CSSNumericValue.sub], or [CSSNumericValue.toSum] on [CSSNumericValue].
 ///
 /// A CSSMathSum is the object type returned when the
 /// [`StylePropertyMapReadOnly.get()`](https://developer.mozilla.org/en-US/docs/Web/API/StylePropertyMapReadOnly/get)
@@ -344,10 +349,11 @@ extension type CSSMathSum._(JSObject _) implements CSSMathValue, JSObject {
   external CSSNumericArray get values;
 }
 
-/// The **`CSSMathProduct`** interface of the  represents the result obtained by
-/// calling [CSSNumericValue.add], [CSSNumericValue.sub], or
-/// [CSSNumericValue.toSum] on [CSSNumericValue]. It inherits properties and
-/// methods from its parent [CSSNumericValue].
+/// The **`CSSMathProduct`** interface of the
+/// [CSS Typed Object Model API](https://developer.mozilla.org/en-US/docs/Web/API/CSS_Object_Model)
+/// represents the result obtained by calling [CSSNumericValue.add],
+/// [CSSNumericValue.sub], or [CSSNumericValue.toSum] on [CSSNumericValue]. It
+/// inherits properties and methods from its parent [CSSNumericValue].
 ///
 /// ---
 ///
@@ -361,8 +367,10 @@ extension type CSSMathProduct._(JSObject _) implements CSSMathValue, JSObject {
   external CSSNumericArray get values;
 }
 
-/// The **`CSSMathNegate`** interface of the  negates the value passed into it.
-/// It inherits properties and methods from its parent [CSSNumericValue].
+/// The **`CSSMathNegate`** interface of the
+/// [CSS Typed Object Model API](https://developer.mozilla.org/en-US/docs/Web/API/CSS_Object_Model)
+/// negates the value passed into it. It inherits properties and methods from
+/// its parent [CSSNumericValue].
 ///
 /// ---
 ///
@@ -376,9 +384,10 @@ extension type CSSMathNegate._(JSObject _) implements CSSMathValue, JSObject {
   external CSSNumericValue get value;
 }
 
-/// The **`CSSMathInvert`** interface of the  represents a CSS `calc()` used as
-/// `calc(1 / <value>).` It inherits properties and methods from its parent
-/// [CSSNumericValue].
+/// The **`CSSMathInvert`** interface of the
+/// [CSS Typed Object Model API](https://developer.mozilla.org/en-US/docs/Web/API/CSS_Object_Model)
+/// represents a CSS `calc()` used as `calc(1 / <value>).` It inherits
+/// properties and methods from its parent [CSSNumericValue].
 ///
 /// ---
 ///
@@ -392,8 +401,10 @@ extension type CSSMathInvert._(JSObject _) implements CSSMathValue, JSObject {
   external CSSNumericValue get value;
 }
 
-/// The **`CSSMathMin`** interface of the  represents the CSS `min()` function.
-/// It inherits properties and methods from its parent [CSSNumericValue].
+/// The **`CSSMathMin`** interface of the
+/// [CSS Typed Object Model API](https://developer.mozilla.org/en-US/docs/Web/API/CSS_Object_Model)
+/// represents the CSS `min()` function. It inherits properties and methods from
+/// its parent [CSSNumericValue].
 ///
 /// ---
 ///
@@ -406,8 +417,10 @@ extension type CSSMathMin._(JSObject _) implements CSSMathValue, JSObject {
   external CSSNumericArray get values;
 }
 
-/// The **`CSSMathMax`** interface of the  represents the CSS `max()` function.
-/// It inherits properties and methods from its parent [CSSNumericValue].
+/// The **`CSSMathMax`** interface of the
+/// [CSS Typed Object Model API](https://developer.mozilla.org/en-US/docs/Web/API/CSS_Object_Model)
+/// represents the CSS `max()` function. It inherits properties and methods from
+/// its parent [CSSNumericValue].
 ///
 /// ---
 ///
@@ -431,8 +444,9 @@ extension type CSSMathClamp._(JSObject _) implements CSSMathValue, JSObject {
   external CSSNumericValue get upper;
 }
 
-/// The **`CSSNumericArray`** interface of the  contains a list of
-/// [CSSNumericValue] objects.
+/// The **`CSSNumericArray`** interface of the
+/// [CSS Typed Object Model API](https://developer.mozilla.org/en-US/docs/Web/API/CSS_Object_Model)
+/// contains a list of [CSSNumericValue] objects.
 ///
 /// ---
 ///
@@ -445,8 +459,9 @@ extension type CSSNumericArray._(JSObject _) implements JSObject {
   external int get length;
 }
 
-/// The **`CSSTransformValue`** interface of the  represents `transform-list`
-/// values as used by the CSS `transform` property.
+/// The **`CSSTransformValue`** interface of the
+/// [CSS Typed Object Model API](https://developer.mozilla.org/en-US/docs/Web/API/CSS_Object_Model)
+/// represents `transform-list` values as used by the CSS `transform` property.
 ///
 /// ---
 ///
@@ -476,8 +491,9 @@ extension type CSSTransformValue._(JSObject _)
   external bool get is2D;
 }
 
-/// The **`CSSTransformComponent`** interface of the  is part of the
-/// [CSSTransformValue] interface.
+/// The **`CSSTransformComponent`** interface of the
+/// [CSS Typed Object Model API](https://developer.mozilla.org/en-US/docs/Web/API/CSS_Object_Model)
+/// is part of the [CSSTransformValue] interface.
 ///
 /// ---
 ///
@@ -505,7 +521,9 @@ extension type CSSTransformComponent._(JSObject _) implements JSObject {
   external set is2D(bool value);
 }
 
-/// The **`CSSTranslate`** interface of the  represents the
+/// The **`CSSTranslate`** interface of the
+/// [CSS Typed Object Model API](https://developer.mozilla.org/en-US/docs/Web/API/CSS_Object_Model)
+/// represents the
 /// [translate()](https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/translate)
 /// value of the individual `transform` property in CSS. It inherits properties
 /// and methods from its parent [CSSTransformValue].
@@ -547,9 +565,10 @@ extension type CSSTranslate._(JSObject _)
   external set z(CSSNumericValue value);
 }
 
-/// The **`CSSRotate`** interface of the  represents the rotate value of the
-/// individual `transform` property in CSS. It inherits properties and methods
-/// from its parent [CSSTransformValue].
+/// The **`CSSRotate`** interface of the
+/// [CSS Typed Object Model API](https://developer.mozilla.org/en-US/docs/Web/API/CSS_Object_Model)
+/// represents the rotate value of the individual `transform` property in CSS.
+/// It inherits properties and methods from its parent [CSSTransformValue].
 ///
 /// ---
 ///
@@ -592,7 +611,9 @@ extension type CSSRotate._(JSObject _)
   external set angle(CSSNumericValue value);
 }
 
-/// The **`CSSScale`** interface of the  represents the
+/// The **`CSSScale`** interface of the
+/// [CSS Typed Object Model API](https://developer.mozilla.org/en-US/docs/Web/API/CSS_Object_Model)
+/// represents the
 /// [scale()](https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/scale)
 /// and
 /// [scale3d()](https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/scale3d)
@@ -636,8 +657,9 @@ extension type CSSScale._(JSObject _)
   external set z(CSSNumberish value);
 }
 
-/// The **`CSSSkew`** interface of the  is part of the [CSSTransformValue]
-/// interface. It represents the
+/// The **`CSSSkew`** interface of the
+/// [CSS Typed Object Model API](https://developer.mozilla.org/en-US/docs/Web/API/CSS_Object_Model)
+/// is part of the [CSSTransformValue] interface. It represents the
 /// [`skew()`](https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/skew)
 /// value of the individual `transform` property in CSS.
 ///
@@ -665,7 +687,9 @@ extension type CSSSkew._(JSObject _)
   external set ay(CSSNumericValue value);
 }
 
-/// The **`CSSSkewX`** interface of the  represents the
+/// The **`CSSSkewX`** interface of the
+/// [CSS Typed Object Model API](https://developer.mozilla.org/en-US/docs/Web/API/CSS_Object_Model)
+/// represents the
 /// [`skewX()`](https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/skewX)
 /// value of the individual `transform` property in CSS. It inherits properties
 /// and methods from its parent [CSSTransformValue].
@@ -685,7 +709,9 @@ extension type CSSSkewX._(JSObject _)
   external set ax(CSSNumericValue value);
 }
 
-/// The **`CSSSkewY`** interface of the  represents the
+/// The **`CSSSkewY`** interface of the
+/// [CSS Typed Object Model API](https://developer.mozilla.org/en-US/docs/Web/API/CSS_Object_Model)
+/// represents the
 /// [`skewY()`](https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/skewY)
 /// value of the individual `transform` property in CSS. It inherits properties
 /// and methods from its parent [CSSTransformValue].
@@ -705,7 +731,9 @@ extension type CSSSkewY._(JSObject _)
   external set ay(CSSNumericValue value);
 }
 
-/// The **`CSSPerspective`** interface of the  represents the
+/// The **`CSSPerspective`** interface of the
+/// [CSS Typed Object Model API](https://developer.mozilla.org/en-US/docs/Web/API/CSS_Object_Model)
+/// represents the
 /// [perspective()](https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/perspective)
 /// value of the individual `transform` property in CSS. It inherits properties
 /// and methods from its parent [CSSTransformValue].
@@ -728,7 +756,9 @@ extension type CSSPerspective._(JSObject _)
   external set length(CSSPerspectiveValue value);
 }
 
-/// The **`CSSMatrixComponent`** interface of the  represents the
+/// The **`CSSMatrixComponent`** interface of the
+/// [CSS Typed Object Model API](https://developer.mozilla.org/en-US/docs/Web/API/CSS_Object_Model)
+/// represents the
 /// [matrix()](https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/matrix)
 /// and
 /// [matrix3d()](https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/matrix3d)
diff --git a/lib/src/dom/dom.dart b/lib/src/dom/dom.dart
index 78e7c9d5..be3e8d1b 100644
--- a/lib/src/dom/dom.dart
+++ b/lib/src/dom/dom.dart
@@ -347,8 +347,8 @@ extension type CustomEvent._(JSObject _) implements Event, JSObject {
     JSAny? detail,
   ]);
 
-  /// The read-only **`detail`** property of the [CustomEvent] interface
-  /// returns any data passed when initializing the event.
+  /// The read-only **`detail`** property of the [CustomEvent] interface returns
+  /// any data passed when initializing the event.
   external JSAny? get detail;
 }
 extension type CustomEventInit._(JSObject _) implements EventInit, JSObject {
@@ -1639,19 +1639,26 @@ extension type Document._(JSObject _) implements Node, JSObject {
   /// The **`hasStorageAccess()`** method of the [Document] interface returns a
   /// `Promise` that resolves with a boolean value indicating whether the
   /// document has access to
-  /// [third-party](https://developer.mozilla.org/en-US/docs/Web/HTTP/Cookies#third-party_cookies),
+  /// [third-party](https://developer.mozilla.org/en-US/docs/Web/Privacy/Third-party_cookies),
   /// [unpartitioned](https://developer.mozilla.org/en-US/docs/Web/API/Storage_Access_API#unpartitioned_versus_partitioned_cookies)
   /// cookies.
   ///
   /// This method is part of the
   /// [Storage Access API](https://developer.mozilla.org/en-US/docs/Web/API/Storage_Access_API).
+  ///
+  /// > **Note:** This method is another name for
+  /// > [Document.hasUnpartitionedCookieAccess]. There are no current plans to
+  /// > remove this method in favor of [Document.hasUnpartitionedCookieAccess].
   external JSPromise<JSBoolean> hasStorageAccess();
 
   /// The **`requestStorageAccess()`** method of the [Document] interface allows
   /// content loaded in a third-party context (i.e., embedded in an `iframe`) to
-  /// request access to third-party cookies. This is relevant to user agents
-  /// that, by default, block access to
-  /// [third-party](https://developer.mozilla.org/en-US/docs/Web/HTTP/Cookies#third-party_cookies),
+  /// request access to
+  /// [third-party cookies](https://developer.mozilla.org/en-US/docs/Web/Privacy/Third-party_cookies)
+  /// and
+  /// [unpartitioned state](https://developer.mozilla.org/en-US/docs/Web/Privacy/State_Partitioning#state_partitioning).
+  /// This is relevant to user agents that, by default, block access to
+  /// third-party,
   /// [unpartitioned](https://developer.mozilla.org/en-US/docs/Web/API/Storage_Access_API#unpartitioned_versus_partitioned_cookies)
   /// cookies to improve privacy (e.g., to prevent tracking), and is part of the
   /// [Storage Access API](https://developer.mozilla.org/en-US/docs/Web/API/Storage_Access_API).
@@ -1804,19 +1811,6 @@ extension type Document._(JSObject _) implements Node, JSObject {
   /// > **Note:** A "character set" and a "character encoding" are related, but
   /// > different. Despite the
   /// > name of this property, it returns the _encoding_.
-  ///
-  /// Users can override the developer-specified encoding inside the
-  /// [Content-Type](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Type)
-  /// header or inline
-  /// like `<meta charset="utf-8">`, such as with Firefox's <kbd>View → Text
-  /// Encoding</kbd> menu. This override is provided to fix incorrect
-  /// developer-specified
-  /// encodings that result in
-  /// [garbled text](https://en.wikipedia.org/wiki/Mojibake).
-  ///
-  /// > **Note:** The properties `document.charset` and `document.inputEncoding`
-  /// > are legacy aliases for `document.characterSet`. Do not use them any
-  /// > more.
   external String get characterSet;
 
   /// The **`Document.contentType`** read-only property returns the
@@ -1830,13 +1824,9 @@ extension type Document._(JSObject _) implements Node, JSObject {
   /// > elements.
   external String get contentType;
 
-  /// Returns the Document Type Declaration (DTD) associated with current
-  /// document. The
-  /// returned object implements the [DocumentType] interface. Use
-  /// [DOMImplementation.createDocumentType] to create a
-  /// `DocumentType`.
-  ///
-  /// - `doctype` is a read-only property.
+  /// The **`doctype`** read-only property of the [Document] interface is a
+  /// [DocumentType] object representing the the  associated with the current
+  /// document.
   external DocumentType? get doctype;
 
   /// **`Document.documentElement`** returns the
@@ -1955,11 +1945,10 @@ extension type Document._(JSObject _) implements Node, JSObject {
   /// the current document.
   external HTMLHeadElement? get head;
 
-  /// The **`images`** read-only property of
-  /// the [Document] interface returns a
+  /// The **`images`** read-only property of the [Document] interface returns a
   /// [collection](https://developer.mozilla.org/en-US/docs/Web/API/HTMLCollection)
   /// of the
-  /// [images](https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement/Image)
+  /// [images](https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement)
   /// in the current HTML document.
   external HTMLCollection get images;
 
@@ -2714,16 +2703,22 @@ extension type ShadowRoot._(JSObject _) implements DocumentFragment, JSObject {
   /// [Web Animations](https://developer.mozilla.org/en-US/docs/Web/API/Web_Animations_API).
   external JSArray<Animation> getAnimations();
 
-  /// The **`mode`** read-only property of the [ShadowRoot]
-  /// specifies its mode — either `open` or `closed`. This defines
-  /// whether or not the shadow root's internal features are accessible from
-  /// JavaScript.
+  /// The **`mode`** read-only property of the [ShadowRoot] specifies its mode —
+  /// either `open` or `closed`.
+  /// This defines whether or not the shadow root's internal features are
+  /// accessible from JavaScript.
   ///
   /// When the `mode` of a shadow root is "`closed`", the shadow root's
   /// implementation internals are inaccessible and unchangeable from
-  /// JavaScript—in the same
-  /// way the implementation internals of, for example, the `video` element
-  /// are inaccessible and unchangeable from JavaScript.
+  /// JavaScript—in the same way the implementation internals of, for example,
+  /// the `video` element are inaccessible and unchangeable from JavaScript.
+  ///
+  /// The property value is set using the `options.mode` property of the object
+  /// passed to [Element.attachShadow], or using the
+  /// [`shadowrootmode`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/template#shadowrootmode)
+  /// attribute of the
+  /// [`<template>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/template)
+  /// element when a shadow root is created declaratively.
   external ShadowRootMode get mode;
 
   /// The **`delegatesFocus`** read-only property of the [ShadowRoot] interface
@@ -2745,8 +2740,12 @@ extension type ShadowRoot._(JSObject _) implements DocumentFragment, JSObject {
   /// accessibility issues, such as bypassing important content which may go
   /// unnoticed due to focus being set to an element later in the DOM order.
   ///
-  /// The property value is set using the `delegatesFocus` property of the
-  /// object passed to [Element.attachShadow]).
+  /// The property value is originally set using the `delegatesFocus` property
+  /// of the object passed to [Element.attachShadow], or using the
+  /// [`shadowrootdelegatesfocus`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/template#shadowrootclonable)
+  /// attribute of the
+  /// [`<template>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/template)
+  /// element when a shadow root is created declaratively.
   external bool get delegatesFocus;
 
   /// The read-only **`slotAssignment`** property of the [ShadowRoot] interface
@@ -2757,10 +2756,17 @@ extension type ShadowRoot._(JSObject _) implements DocumentFragment, JSObject {
   external SlotAssignmentMode get slotAssignment;
 
   /// The **`clonable`** read-only property of the [ShadowRoot] interface
-  /// returns `true` if the shadow root is clonable, and `false` otherwise. It
-  /// always returns `true` for shadow roots created via declarative shadow DOM.
+  /// returns `true` if the shadow root is clonable, and `false` otherwise.
+  ///
+  /// When the value is `true`, a shadow host cloned with [Node.cloneNode] or
+  /// [Document.importNode] will include a copy of the shadow root.
+  ///
+  /// By default the value is `false`.
   /// It can be set to `true` using the `clonable` option of the
-  /// [Element.attachShadow] method.
+  /// [Element.attachShadow] method or by setting the
+  /// [`shadowrootclonable`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/template#shadowrootclonable)
+  /// attribute of the `<template>` element that is being used to declaratively
+  /// attach a shadow root.
   external bool get clonable;
 
   /// The **`host`** read-only property of
@@ -2966,9 +2972,7 @@ extension type Element._(JSObject _) implements Node, JSObject {
   /// [Element] interface returns the value of a specified attribute on the
   /// element.
   ///
-  /// If the given attribute does not exist, the value returned will
-  /// either be `null` or `""` (the empty string); see
-  /// [Non-existing attributes](#non-existing_attributes) for details.
+  /// If the given attribute does not exist, the value returned will be `null`.
   ///
   /// If you need to inspect the [Attr] node's properties, you can use the
   /// [Element.getAttributeNode] method instead.
@@ -2990,10 +2994,10 @@ extension type Element._(JSObject _) implements Node, JSObject {
     String localName,
   );
 
-  /// Sets the value of an attribute on the specified element. If
-  /// the attribute already exists, the value is updated; otherwise a new
-  /// attribute is added
-  /// with the specified name and value.
+  /// The **`setAttribute()`** method of the [Element] interface sets the value
+  /// of an attribute on the specified element. If the attribute already exists,
+  /// the value is updated; otherwise a new attribute is added with the
+  /// specified name and value.
   ///
   /// To get the current value of an attribute, use [Element.getAttribute]; to
   /// remove an attribute, call [Element.removeAttribute].
@@ -3644,13 +3648,30 @@ extension type Element._(JSObject _) implements Node, JSObject {
   external EventHandler get onfullscreenerror;
   external set onfullscreenerror(EventHandler value);
 
-  /// The [Element] property
-  /// **`innerHTML`** gets or sets the HTML or XML markup contained
-  /// within the element.
+  /// The [Element] property **`innerHTML`** gets or sets the HTML or XML markup
+  /// contained within the element.
+  ///
+  /// More precisely, `innerHTML` gets a serialization of the nested child DOM
+  /// elements within the element, or sets HTML or XML that should be parsed to
+  /// replace the DOM tree within the element.
   ///
   /// To insert the HTML into the document rather than replace the contents of
-  /// an element,
-  /// use the method [Element.insertAdjacentHTML].
+  /// an element, use the method [Element.insertAdjacentHTML].
+  ///
+  /// The serialization of the DOM tree read from the property does not include
+  /// — if you want to get a HTML string that includes shadow roots, you must
+  /// instead use the [Element.getHTML] or [ShadowRoot.getHTML] methods.
+  /// Similarly, when setting element content using `innerHTML`, the HTML string
+  /// is parsed into DOM elements that do not contain shadow roots.
+  ///
+  /// So for example
+  /// [`<template>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/template)
+  /// is parsed into as [HTMLTemplateElement], whether or not the
+  /// [`shadowrootmode`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/template#shadowrootmode)
+  /// attribute is specfied
+  /// In order to set an element's contents from an HTML string that includes
+  /// declarative shadow roots, you must use either [Element.setHTMLUnsafe] or
+  /// [ShadowRoot.setHTMLUnsafe].
   external String get innerHTML;
   external set innerHTML(String value);
 
@@ -4329,7 +4350,7 @@ extension type CharacterData._(JSObject _) implements Node, JSObject {
   /// integer.
   external int get length;
 
-  /// The read-only **`previousElementSibling`** of the [CharacterData]
+  /// The read-only **`previousElementSibling`** property of the [CharacterData]
   /// interface
   /// returns the first [Element] before the current node in its parent's
   /// children list,
diff --git a/lib/src/dom/fetch.dart b/lib/src/dom/fetch.dart
index 9097ffd6..4ffd87c1 100644
--- a/lib/src/dom/fetch.dart
+++ b/lib/src/dom/fetch.dart
@@ -249,7 +249,7 @@ extension type Request._(JSObject _) implements JSObject {
   ///
   /// The string must be one of the `audio`, `audioworklet`,
   /// `document`, `embed`, `fencedframe`, `font`, `frame`,
-  /// `iframe`, `image`, `manifest`, `object`,
+  /// `iframe`, `image`, `json`, `manifest`, `object`,
   /// `paintworklet`, `report`, `script`, `sharedworker`,
   /// `style`, `track`, `video`, `worker`
   /// or `xslt` strings, or the empty string, which is the default value.
diff --git a/lib/src/dom/fileapi.dart b/lib/src/dom/fileapi.dart
index 26e82d64..2c848ce2 100644
--- a/lib/src/dom/fileapi.dart
+++ b/lib/src/dom/fileapi.dart
@@ -21,7 +21,7 @@ import 'webidl.dart';
 typedef BlobPart = JSAny;
 typedef EndingType = String;
 
-/// The **`Blob`** object represents a blob, which is a file-like object of
+/// The **`Blob`** interface represents a blob, which is a file-like object of
 /// immutable, raw data; they can be read as text or binary data, or converted
 /// into a [ReadableStream] so its methods can be used for processing the data.
 ///
@@ -200,7 +200,7 @@ extension type FileList._(JSObject _) implements JSObject {
   external int get length;
 }
 
-/// The **`FileReader`** object lets web applications asynchronously read the
+/// The **`FileReader`** interface lets web applications asynchronously read the
 /// contents of files (or raw data buffers) stored on the user's computer, using
 /// [File] or [Blob] objects to specify the file or data to read.
 ///
@@ -216,7 +216,7 @@ extension type FileList._(JSObject _) implements JSObject {
 /// [File System Access API](https://developer.mozilla.org/en-US/docs/Web/API/File_System_API).
 /// To read server-side files, use [fetch], with
 /// [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) permission if
-/// reading cross-domain.
+/// reading cross-origin.
 ///
 /// ---
 ///
@@ -232,9 +232,9 @@ extension type FileReader._(JSObject _) implements EventTarget, JSObject {
   /// The **`readAsArrayBuffer()`** method of the [FileReader] interface is used
   /// to start reading the
   /// contents of a specified [Blob] or [File]. When the read
-  /// operation is finished, the [FileReader.readyState] becomes
-  /// `DONE`, and the [FileReader.loadend_event] is
-  /// triggered. At that time, the [FileReader.result] attribute
+  /// operation is finished, the [FileReader.readyState] property becomes
+  /// `DONE`, and the [FileReader.loadend_event] event is
+  /// triggered. At that time, the [FileReader.result] property
   /// contains an `ArrayBuffer` representing the file's data.
   ///
   /// > **Note:** The [Blob.arrayBuffer] method is a newer promise-based API to
@@ -245,12 +245,13 @@ extension type FileReader._(JSObject _) implements EventTarget, JSObject {
   /// > **Note:** This method is deprecated in favor of
   /// > [FileReader.readAsArrayBuffer].
   ///
-  /// The **`readAsBinaryString`** method of the [FileReader] interface is used
-  /// to start reading the contents of the
+  /// The **`readAsBinaryString()`** method of the [FileReader] interface is
+  /// used to start reading the contents of the
   /// specified [Blob] or [File]. When the read operation is
-  /// finished, the [FileReader.readyState] becomes
-  /// `DONE`, and the [FileReader.loadend_event] is triggered. At that time, the
-  /// [FileReader.result] attribute contains the raw binary data from
+  /// finished, the [FileReader.readyState] property becomes
+  /// `DONE`, and the [FileReader.loadend_event] event is triggered. At that
+  /// time, the
+  /// [FileReader.result] property contains the raw binary data from
   /// the file.
   ///
   /// Note that this method was once removed from the File API specification,
@@ -261,8 +262,8 @@ extension type FileReader._(JSObject _) implements EventTarget, JSObject {
 
   /// The **`readAsText()`** method of the [FileReader] interface is used to
   /// read the contents of the specified [Blob] or [File].
-  /// When the read operation is complete, the [FileReader.readyState] is
-  /// changed to `DONE`,
+  /// When the read operation is complete, the [FileReader.readyState] property
+  /// is changed to `DONE`,
   /// the [FileReader.loadend_event] event is triggered, and the
   /// [FileReader.result] property contains the contents of the file as a text
   /// string.
@@ -271,19 +272,18 @@ extension type FileReader._(JSObject _) implements EventTarget, JSObject {
   /// > file as text.
   ///
   /// > **Note:** This method loads the entire file's content into memory and is
-  /// > not suitable for large files. Prefer
-  /// > [`readAsArrayBuffer()`](https://developer.mozilla.org/en-US/docs/Web/API/FileReader/readAsArrayBuffer)
-  /// > for large files.
+  /// > not suitable for large files. Prefer [FileReader.readAsArrayBuffer] for
+  /// > large files.
   external void readAsText(
     Blob blob, [
     String encoding,
   ]);
 
-  /// The **`readAsDataURL`** method of the [FileReader] interface is used to
+  /// The **`readAsDataURL()`** method of the [FileReader] interface is used to
   /// read the contents of the specified
   /// [Blob] or [File]. When the read operation is finished, the
-  /// [FileReader.readyState] becomes `DONE`, and the
-  /// [FileReader.loadend_event] is triggered. At that time, the
+  /// [FileReader.readyState] property becomes `DONE`, and the
+  /// [FileReader.loadend_event] event is triggered. At that time, the
   /// [FileReader.result] attribute contains the data as a [data:
   /// URL](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URLs)
   /// representing the
@@ -297,27 +297,14 @@ extension type FileReader._(JSObject _) implements EventTarget, JSObject {
   /// > remove `data:*/*;base64,` from the result.
   external void readAsDataURL(Blob blob);
 
-  /// The **`abort`** method of the [FileReader] interface aborts the read
+  /// The **`abort()`** method of the [FileReader] interface aborts the read
   /// operation. Upon return,
   /// the [FileReader.readyState] will be `DONE`.
   external void abort();
 
   /// The **`readyState`** read-only property of the [FileReader] interface
-  /// provides the current state of the reading operation a `FileReader` is in.
-  /// A `FileReader` exists in one of the following states:
-  ///
-  /// | Value | State     | Description                                                   |
-  /// | ----- | --------- | ------------------------------------------------------------- |
-  /// | `0`   | `EMPTY`   | Reader has been created. None of the read methods called yet. |
-  /// | `1`   | `LOADING` | A read method has been called.                                |
-  /// | `2`   | `DONE`    | The operation is complete.                                    |
-  ///
-  /// - `EMPTY`
-  ///   - : The `FileReader` has been created, but no readAs method was called yet.
-  /// - `LOADING`
-  ///   - : A readAs method was invoked. A [File] or [Blob] is being read, and no error has occurred yet.
-  /// - `DONE`
-  ///   - : The read operation is complete. This could mean that: the entire [File] or [Blob] has been read into memory, a file read error occurred, or [FileReader.abort] was called and the read was cancelled.
+  /// provides the current state of the reading operation.
+  /// This will be one of the states: `EMPTY`, `LOADING`, or `DONE`.
   external int get readyState;
 
   /// The **`result`** read-only property of the [FileReader] interface returns
@@ -347,6 +334,8 @@ extension type FileReader._(JSObject _) implements EventTarget, JSObject {
   external set onloadend(EventHandler value);
 }
 
+/// @AvailableInWorkers("worker_except_service")
+///
 /// The **`FileReaderSync`** interface allows to read [File] or [Blob] objects
 /// synchronously. This interface is
 /// [only available](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Functions_and_classes_available_to_workers)
@@ -360,6 +349,8 @@ extension type FileReader._(JSObject _) implements EventTarget, JSObject {
 extension type FileReaderSync._(JSObject _) implements JSObject {
   external factory FileReaderSync();
 
+  /// @AvailableInWorkers("worker_except_service")
+  ///
   /// The **`readAsArrayBuffer()`** method of the [FileReaderSync] interface
   /// allows to read [File] or [Blob] objects in a synchronous way into an
   /// `ArrayBuffer`. This interface is
@@ -368,6 +359,8 @@ extension type FileReaderSync._(JSObject _) implements JSObject {
   /// it enables synchronous I/O that could potentially block.
   external JSArrayBuffer readAsArrayBuffer(Blob blob);
 
+  /// @AvailableInWorkers("worker_except_service")
+  ///
   /// > **Note:** This method is deprecated in favor of
   /// > [FileReaderSync.readAsArrayBuffer].
   ///
@@ -379,6 +372,8 @@ extension type FileReaderSync._(JSObject _) implements JSObject {
   /// it enables synchronous I/O that could potentially block.
   external String readAsBinaryString(Blob blob);
 
+  /// @AvailableInWorkers("worker_except_service")
+  ///
   /// The **`readAsText()`** method of the [FileReaderSync] interface allows to
   /// read [File] or [Blob] objects in a synchronous way into a string. This
   /// interface is
@@ -390,6 +385,8 @@ extension type FileReaderSync._(JSObject _) implements JSObject {
     String encoding,
   ]);
 
+  /// @AvailableInWorkers("worker_except_service")
+  ///
   /// The **`readAsDataURL()`** method of the [FileReaderSync] interface allows
   /// to read [File] or [Blob] objects in a synchronous way into a string
   /// representing a data URL. This interface is
diff --git a/lib/src/dom/fs.dart b/lib/src/dom/fs.dart
index 3e61d935..f6829b3c 100644
--- a/lib/src/dom/fs.dart
+++ b/lib/src/dom/fs.dart
@@ -97,6 +97,8 @@ extension type FileSystemFileHandle._(JSObject _)
   external JSPromise<FileSystemWritableFileStream> createWritable(
       [FileSystemCreateWritableOptions options]);
 
+  /// @AvailableInWorkers("dedicated")
+  ///
   /// The **`createSyncAccessHandle()`** method of the
   /// [FileSystemFileHandle] interface returns a `Promise` which resolves to a
   /// [FileSystemSyncAccessHandle] object
@@ -248,6 +250,8 @@ extension type FileSystemReadWriteOptions._(JSObject _) implements JSObject {
   external set at(int value);
 }
 
+/// @AvailableInWorkers("dedicated")
+///
 /// The **`FileSystemSyncAccessHandle`** interface of the [File System API]
 /// represents a synchronous handle to a file system entry.
 ///
@@ -280,6 +284,8 @@ extension type FileSystemReadWriteOptions._(JSObject _) implements JSObject {
 /// API documentation sourced from
 /// [MDN Web Docs](https://developer.mozilla.org/en-US/docs/Web/API/FileSystemSyncAccessHandle).
 extension type FileSystemSyncAccessHandle._(JSObject _) implements JSObject {
+  /// @AvailableInWorkers("dedicated")
+  ///
   /// The **`read()`** method of the
   /// [FileSystemSyncAccessHandle] interface reads the content of the file
   /// associated with the handle into a specified buffer, optionally at a given
@@ -289,6 +295,8 @@ extension type FileSystemSyncAccessHandle._(JSObject _) implements JSObject {
     FileSystemReadWriteOptions options,
   ]);
 
+  /// @AvailableInWorkers("dedicated")
+  ///
   /// The **`write()`** method of the
   /// [FileSystemSyncAccessHandle] interface writes the content of a specified
   /// buffer to the file associated with the handle, optionally at a given
@@ -307,6 +315,8 @@ extension type FileSystemSyncAccessHandle._(JSObject _) implements JSObject {
     FileSystemReadWriteOptions options,
   ]);
 
+  /// @AvailableInWorkers("dedicated")
+  ///
   /// The **`truncate()`** method of the
   /// [FileSystemSyncAccessHandle] interface resizes the file associated with
   /// the handle to a specified number of bytes.
@@ -319,6 +329,8 @@ extension type FileSystemSyncAccessHandle._(JSObject _) implements JSObject {
   /// > these methods implement them as synchronous methods.
   external void truncate(int newSize);
 
+  /// @AvailableInWorkers("dedicated")
+  ///
   /// The **`getSize()`** method of the
   /// [FileSystemSyncAccessHandle] interface returns the size of the file
   /// associated with the handle in bytes.
@@ -331,6 +343,8 @@ extension type FileSystemSyncAccessHandle._(JSObject _) implements JSObject {
   /// > these methods implement them as synchronous methods.
   external int getSize();
 
+  /// @AvailableInWorkers("dedicated")
+  ///
   /// The **`flush()`** method of the
   /// [FileSystemSyncAccessHandle] interface persists any changes made to the
   /// file associated with the handle via the [FileSystemSyncAccessHandle.write]
@@ -350,6 +364,8 @@ extension type FileSystemSyncAccessHandle._(JSObject _) implements JSObject {
   /// > implement them as synchronous methods.
   external void flush();
 
+  /// @AvailableInWorkers("dedicated")
+  ///
   /// The **`close()`** method of the
   /// [FileSystemSyncAccessHandle] interface closes an open synchronous file
   /// handle, disabling any further operations on it and releasing the exclusive
diff --git a/lib/src/dom/hr_time.dart b/lib/src/dom/hr_time.dart
index 3444682b..80cd1b83 100644
--- a/lib/src/dom/hr_time.dart
+++ b/lib/src/dom/hr_time.dart
@@ -26,12 +26,10 @@ typedef EpochTimeStamp = int;
 /// The **`Performance`** interface provides access to performance-related
 /// information for the current page.
 ///
-/// An object of this type can be obtained by calling `window.performance` or
-/// `self.performance` in workers. Note that Performance entries are per
-/// context. If you create a mark on the main thread (or other worker), you
-/// cannot see it in a worker thread, and vice versa. See
-/// [`self.performance`](https://developer.mozilla.org/en-US/docs/Web/API/performance_property)
-/// for which APIs are available in window and worker contexts.
+/// Performance entries are specific to each execution context. You can access
+/// performance information for code running in a window via
+/// [Window.performance], and for code running in a worker via
+/// [WorkerGlobalScope.performance].
 ///
 /// ---
 ///
diff --git a/lib/src/dom/html.dart b/lib/src/dom/html.dart
index b9cb3f94..89596761 100644
--- a/lib/src/dom/html.dart
+++ b/lib/src/dom/html.dart
@@ -698,6 +698,26 @@ extension type HTMLElement._(JSObject _) implements Element, JSObject {
   /// HTML global attribute.
   external bool get spellcheck;
   external set spellcheck(bool value);
+
+  /// The **`autocapitalize`** property of the [HTMLElement] interface
+  /// represents the element's capitalization behavior for user input. It is
+  /// available on all HTML elements, though it doesn't affect all of them,
+  /// including:
+  ///
+  /// - `input` and `textarea` elements.
+  /// - Any element with
+  ///   [`contenteditable`](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/contenteditable)
+  ///   set on it.
+  ///
+  /// `autocapitalize` doesn't affect behavior when typing on a physical
+  /// keyboard. It affects the behavior of other input mechanisms such as
+  /// virtual keyboards on mobile devices and voice input. This can assist users
+  /// by making data entry quicker and easier, for example by automatically
+  /// capitalizing the first letter of each sentence.
+  ///
+  /// It reflects the value of the
+  /// [`autocapitalize`](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/autocapitalize)
+  /// HTML global attribute.
   external String get autocapitalize;
   external set autocapitalize(String value);
 
@@ -737,6 +757,26 @@ extension type HTMLElement._(JSObject _) implements Element, JSObject {
   /// global HTML attribute.
   external String? get popover;
   external set popover(String? value);
+
+  /// The **`attributeStyleMap`** read-only property of the [HTMLElement]
+  /// interface returns a live [StylePropertyMap] object that contains a list of
+  /// style properties of the element that are defined in the element's inline
+  /// [`style`](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/style)
+  /// attribute, or assigned using the [HTMLElement.style] property of the
+  /// [HTMLElement] interface via script.
+  ///
+  /// Shorthand properties are expanded. If you set `border-top: 1px solid
+  /// black`, the longhand properties (, , and ) are set instead.
+  ///
+  /// The main difference between [HTMLElement.style] property and
+  /// `attributeStyleMap` property is that, the `style` property will return a
+  /// [CSSStyleDeclaration] object, while the `attributeStyleMap` property will
+  /// return a [StylePropertyMap] object.
+  ///
+  /// Though the property itself is not writable, you could read and write
+  /// inline styles through the [StylePropertyMap] object that it returns, just
+  /// like through the [CSSStyleDeclaration] object that returns via the `style`
+  /// property.
   external StylePropertyMap get attributeStyleMap;
 
   /// The read-only **`style`** property of the [HTMLElement] returns the
@@ -1327,7 +1367,7 @@ extension type HTMLLinkElement._(JSObject _) implements HTMLElement, JSObject {
   external String? get crossOrigin;
   external set crossOrigin(String? value);
 
-  /// The **`HTMLLinkElement.rel`** property reflects the
+  /// The **`rel`** property of the [HTMLLinkElement] interface reflects the
   /// [`rel`](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/rel)
   /// attribute. It is a string containing a space-separated list of link types
   /// indicating the relationship between the resource represented by the `link`
@@ -1361,7 +1401,8 @@ extension type HTMLLinkElement._(JSObject _) implements HTMLElement, JSObject {
   external String get as;
   external set as(String value);
 
-  /// The **`HTMLLinkElement.relList`** read-only property reflects the
+  /// The **`relList`** read-only property of the [HTMLLinkElement] interface
+  /// reflects the
   /// [`rel`](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/rel)
   /// attribute. It is a live [DOMTokenList] containing the set of link types
   /// indicating the relationship between the resource represented by the `link`
@@ -1373,17 +1414,29 @@ extension type HTMLLinkElement._(JSObject _) implements HTMLElement, JSObject {
   external DOMTokenList get relList;
   external String get media;
   external set media(String value);
+
+  /// The **`integrity`** property of the [HTMLLinkElement] interface is a
+  /// string containing inline metadata that a browser can use to verify that a
+  /// fetched resource has been delivered without unexpected manipulation.
+  ///
+  /// It reflects the `integrity` attribute of the `link` element.
   external String get integrity;
   external set integrity(String value);
 
-  /// The **`hreflang`** property of the [HTMLLinkElement] is used to indicate
-  /// the language and the geographical targeting of a page. This hint can be
-  /// used by browsers to select the more appropriate page or to improve .
+  /// The **`hreflang`** property of the [HTMLLinkElement] interface is used to
+  /// indicate the language and the geographical targeting of a page. This hint
+  /// can be used by browsers to select the more appropriate page or to improve
+  /// .
   ///
   /// It reflects the `hreflang` attribute of the `link` element and is the
   /// empty string (`""`) if there is no `hreflang` attribute.
   external String get hreflang;
   external set hreflang(String value);
+
+  /// The **`type`** property of the [HTMLLinkElement] interface is a string
+  /// that reflects the  of the linked resource.
+  ///
+  /// It reflects the `type` attribute of the `link` element.
   external String get type;
   external set type(String value);
   external DOMTokenList get sizes;
@@ -1392,9 +1445,8 @@ extension type HTMLLinkElement._(JSObject _) implements HTMLElement, JSObject {
   external String get imageSizes;
   external set imageSizes(String value);
 
-  /// The
-  /// **`HTMLLinkElement.referrerPolicy`**
-  /// property reflects the HTML
+  /// The **`referrerPolicy`** property of the [HTMLLinkElement] interface
+  /// reflects the HTML
   /// [`referrerpolicy`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#referrerpolicy)
   /// attribute of the
   /// `link` element defining which referrer is sent when fetching the
@@ -1403,6 +1455,18 @@ extension type HTMLLinkElement._(JSObject _) implements HTMLElement, JSObject {
   /// See the HTTP  header for details.
   external String get referrerPolicy;
   external set referrerPolicy(String value);
+
+  /// The **`disabled`** property of the [HTMLLinkElement] interface is a
+  /// boolean value that represents whether the link is disabled. It only has an
+  /// effect with style sheet links (`rel` property set to `stylesheet`).
+  ///
+  /// If `disabled` attribute is specified in the HTML when it is loaded, the
+  /// stylesheet will not be loaded during page load. Instead, the stylesheet
+  /// will be loaded only when the `disabled` property is set to `false` or
+  /// removed. Setting the `disabled` property using JavaScript causes the
+  /// stylesheet to be removed from the document's [Document.styleSheets] list.
+  ///
+  /// It reflects the `disabled` attribute of the `link` element.
   external bool get disabled;
   external set disabled(bool value);
 
@@ -1410,7 +1474,8 @@ extension type HTMLLinkElement._(JSObject _) implements HTMLElement, JSObject {
   /// [HTMLLinkElement] interface represents a hint given to the browser
   /// on how it should prioritize the preload of the given resource relative to
   /// other
-  /// resources of the same type.
+  /// resources of the same
+  /// [type](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/rel/preload#what_types_of_content_can_be_preloaded).
   external String get fetchPriority;
   external set fetchPriority(String value);
   external String get charset;
@@ -1420,7 +1485,7 @@ extension type HTMLLinkElement._(JSObject _) implements HTMLElement, JSObject {
   external String get target;
   external set target(String value);
 
-  /// The read-only **`sheet`** property of the [HTMLLinkElement] interface
+  /// The **`sheet`** read-only property of the [HTMLLinkElement] interface
   /// contains the stylesheet associated with that element.
   ///
   /// A stylesheet is associated to an `HTMLLinkElement` if `rel="stylesheet"`
@@ -2745,7 +2810,31 @@ extension type HTMLIFrameElement._(JSObject _)
   /// indicating the specific name of the `<iframe>` element.
   external String get name;
   external set name(String value);
+
+  /// The **`sandbox`** read-only property of the [HTMLIFrameElement] interface
+  /// returns a [DOMTokenList] indicating extra restrictions on the behavior of
+  /// the nested content.
+  ///
+  /// It reflects the `sandbox` attribute of the `iframe` element.
   external DOMTokenList get sandbox;
+
+  /// The **`allow`** property of the [HTMLIFrameElement] interface indicates
+  /// the
+  /// [Permissions Policy](https://developer.mozilla.org/en-US/docs/Web/HTTP/Permissions_Policy)
+  /// specified for this `<iframe>` element. The policy defines what features
+  /// are available to the `<iframe>` element (for example, access to the
+  /// `microphone`, `camera`, `battery`, `web-share`, etc.) based on the origin
+  /// of the request.
+  ///
+  /// The Permissions Policy specified by the `allow` attribute implements a
+  /// further restriction on top of the policy specified in the  header. It
+  /// doesn't replace it.
+  ///
+  /// See [`<iframe>`'s Permissions Policy
+  /// syntax](/en-US/docs/Web/HTTP/Permissions_Policy#iframe_syntax) for more
+  /// details.
+  ///
+  /// It reflects the `allow` attribute of the `iframe` element.
   external String get allow;
   external set allow(String value);
 
@@ -2840,6 +2929,11 @@ extension type HTMLEmbedElement._(JSObject _) implements HTMLElement, JSObject {
   HTMLEmbedElement() : _ = document.createElement('embed');
 
   external Document? getSVGDocument();
+
+  /// The **`src`** property of the [HTMLEmbedElement] interface returns a
+  /// string that indicates the URL of the resource being embedded.
+  ///
+  /// It reflects the `src` attribute of the `embed` element.
   external String get src;
   external set src(String value);
   external String get type;
@@ -3345,6 +3439,13 @@ extension type HTMLMediaElement._(JSObject _) implements HTMLElement, JSObject {
   /// **`HTMLMediaElement.networkState`** property indicates the
   /// current state of the fetching of media over the network.
   external int get networkState;
+
+  /// The **`preload`** property of the [HTMLMediaElement] interface is a string
+  /// that provides a hint to the browser about what the author thinks will lead
+  /// to the best user experience.
+  ///
+  /// It reflects the `preload` attribute of the `audio` element and the `video`
+  /// element.
   external String get preload;
   external set preload(String value);
 
@@ -3389,7 +3490,8 @@ extension type HTMLMediaElement._(JSObject _) implements HTMLElement, JSObject {
   /// multiplied by this value to obtain the current rate, so a value of 1.0
   /// indicates normal speed.
   ///
-  /// If `playbackRate` is negative, the media is played backwards.
+  /// A negative `playbackRate` value indicates that the media should be played
+  /// backwards, but support for this is not yet widespread.[1](#see-also)
   ///
   /// The audio is muted when the fast forward or slow motion is outside a
   /// useful range (for example, Gecko mutes the sound outside the range `0.25`
@@ -4372,18 +4474,15 @@ extension type HTMLTableElement._(JSObject _) implements HTMLElement, JSObject {
   /// > ones.
   external HTMLTableSectionElement createTBody();
 
-  /// The **`HTMLTableElement.insertRow()`** method inserts a new row
+  /// The **`insertRow()`** method of the [HTMLTableElement] interface inserts a
+  /// new row
   /// (`tr`) in a given `table`, and returns a reference to
   /// the new row.
   ///
   /// If a table has multiple `tbody` elements, by default, the new row is
-  /// inserted into the last `<tbody>`. To insert the row into a specific
-  /// `<tbody>`:
-  ///
-  /// ```js
-  /// let specific_tbody = document.getElementById(tbody_id);
-  /// let row = specific_tbody.insertRow(index);
-  /// ```
+  /// inserted into the last `<tbody>`.
+  /// To insert the row into a specific section, use
+  /// [HTMLTableSectionElement.insertRow]
   ///
   /// > **Note:** `insertRow()` inserts the row directly into the
   /// > table. The row does not need to be appended separately as would be the
@@ -4538,12 +4637,38 @@ extension type HTMLTableColElement._(JSObject _)
   /// Creates an [HTMLTableColElement] using the tag 'col'.
   HTMLTableColElement.col() : _ = document.createElement('col');
 
+  /// The **`span`** read-only property of the [HTMLTableColElement] interface
+  /// represents the number of columns this `col` or `colgroup` must span; this
+  /// lets the column occupy space across multiple columns of the table. It
+  /// reflects the
+  /// [`span`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/col#colspan)
+  /// attribute.
   external int get span;
   external set span(int value);
   external String get align;
   external set align(String value);
+
+  /// The **`ch`** property of the [HTMLTableColElement] interface does nothing.
+  /// It reflects the `char` attribute of the `col` element.
+  ///
+  /// > **Note:** This property was designed to participate to the ability to
+  /// > align table cell content on a specific character (typically the decimal
+  /// > point), but was never implemented by browsers.
+  /// >
+  /// > To achieve such alignment, watch for the support of a string value with
+  /// > the  CSS property.
   external String get ch;
   external set ch(String value);
+
+  /// The **`chOff`** property of the [HTMLTableColElement] interface does
+  /// nothing. It reflects the `charoff` attribute of the `col` element.
+  ///
+  /// > **Note:** This property was designed to participate in an ability to
+  /// > align table cell content on a specific character (typically the decimal
+  /// > point), but was never implemented by browsers.
+  /// >
+  /// > To achieve such alignment, watch for the support of a string value with
+  /// > the  CSS property.
   external String get chOff;
   external set chOff(String value);
   external String get vAlign;
@@ -4573,13 +4698,52 @@ extension type HTMLTableSectionElement._(JSObject _)
   /// Creates an [HTMLTableSectionElement] using the tag 'tfoot'.
   HTMLTableSectionElement.tfoot() : _ = document.createElement('tfoot');
 
+  /// The **`insertRow()`** method of the [HTMLTableSectionElement] interface
+  /// inserts a new row
+  /// (`tr`) in the given `section`, and returns a reference to
+  /// this new row.
+  ///
+  /// > **Note:** `insertRow()` inserts the row directly into the
+  /// > section. The row does not need to be appended separately as would be the
+  /// > case if
+  /// > [Document.createElement] had been used to create the new
+  /// > `<tr>` element.
   external HTMLTableRowElement insertRow([int index]);
+
+  /// The **`deleteRow()`** method of the [HTMLTableSectionElement] interface
+  /// removes a
+  /// specific row (`tr`) from a given `section`.
   external void deleteRow(int index);
+
+  /// The **`rows`** read-only property of the [HTMLTableSectionElement]
+  /// interface returns a live [HTMLCollection] containing the rows in the
+  /// section. The `HTMLCollection` is live and is automatically updated when
+  /// rows are added or removed.
   external HTMLCollection get rows;
   external String get align;
   external set align(String value);
+
+  /// The **`ch`** property of the [HTMLTableSectionElement] interface does
+  /// nothing. It reflects the `char` attribute of the section element.
+  ///
+  /// > **Note:** This property was designed to participate to the ability to
+  /// > align table cell content on a specific character (typically the decimal
+  /// > point), but was never implemented by browsers.
+  /// >
+  /// > To achieve such alignment, watch for the support of a string value with
+  /// > the  CSS property.
   external String get ch;
   external set ch(String value);
+
+  /// The **`chOff`** property of the [HTMLTableSectionElement] interface does
+  /// nothing. It reflects the `charoff` attribute of the section element.
+  ///
+  /// > **Note:** This property was designed to participate in an ability to
+  /// > align table cell content on a specific character (typically the decimal
+  /// > point), but was never implemented by browsers.
+  /// >
+  /// > To achieve such alignment, watch for the support of a string value with
+  /// > the  CSS property.
   external String get chOff;
   external set chOff(String value);
   external String get vAlign;
@@ -4600,7 +4764,8 @@ extension type HTMLTableRowElement._(JSObject _)
   /// Creates an [HTMLTableRowElement] using the tag 'tr'.
   HTMLTableRowElement() : _ = document.createElement('tr');
 
-  /// The **`HTMLTableRowElement.insertCell()`** method inserts a new
+  /// The **`insertCell()`** method of the [HTMLTableRowElement] interface
+  /// inserts a new
   /// cell (`td`) into a table row (`tr`) and returns a
   /// reference to the cell.
   ///
@@ -4613,10 +4778,15 @@ extension type HTMLTableRowElement._(JSObject _)
   /// > You can not use `insertCell()` to create a new `<th>`
   /// > element though.
   external HTMLTableCellElement insertCell([int index]);
+
+  /// The **`deleteCell()`** method of the [HTMLTableRowElement] interface
+  /// removes a
+  /// specific row cell from a given `tr`.
   external void deleteCell(int index);
 
-  /// The **`HTMLTableRowElement.rowIndex`** read-only property
-  /// represents the position of a row in relation to the whole `table`.
+  /// The **`rowIndex`** read-only property of the [HTMLTableRowElement]
+  /// interface
+  /// represents the position of a row within the whole `table`.
   ///
   /// Even when the `thead`, `tbody`, and
   /// `tfoot` elements are out of order in the HTML, browsers render the
@@ -4624,16 +4794,54 @@ extension type HTMLTableRowElement._(JSObject _)
   /// `<tbody>`, from `<tbody>` to
   /// `<tfoot>`.
   external int get rowIndex;
+
+  /// The **`sectionRowIndex`** read-only property of the [HTMLTableRowElement]
+  /// interface
+  /// represents the position of a row within the current section (`thead`,
+  /// `tbody`, or `tfoot`).
   external int get sectionRowIndex;
+
+  /// The **`cells`** read-only property of the [HTMLTableRowElement] interface
+  /// returns a live [HTMLCollection] containing the cells in the row. The
+  /// `HTMLCollection` is live and is automatically updated when cells are added
+  /// or removed.
   external HTMLCollection get cells;
   external String get align;
   external set align(String value);
+
+  /// The **`ch`** property of the [HTMLTableRowElement] interface does nothing.
+  /// It reflects the `char` attribute of the `tr` element.
+  ///
+  /// > **Note:** This property was designed to participate to the ability to
+  /// > align table cell content on a specific character (typically the decimal
+  /// > point), but was never implemented by browsers.
+  /// >
+  /// > To achieve such alignment, watch for the support of a string value with
+  /// > the  CSS property.
   external String get ch;
   external set ch(String value);
+
+  /// The **`chOff`** property of the [HTMLTableRowElement] interface does
+  /// nothing. It reflects the `charoff` attribute of the `tr` element.
+  ///
+  /// > **Note:** This property was designed to participate in an ability to
+  /// > align table cell content on a specific character (typically the decimal
+  /// > point), but was never implemented by browsers.
+  /// >
+  /// > To achieve such alignment, watch for the support of a string value with
+  /// > the  CSS property.
   external String get chOff;
   external set chOff(String value);
   external String get vAlign;
   external set vAlign(String value);
+
+  /// The **`HTMLTableRowElement.bgColor`** property is used to set the
+  /// background color of a row or retrieve the value of the obsolete
+  /// [`bgColor`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/tr#bgcolor)
+  /// attribute, if present.
+  ///
+  /// **Note:** This property is deprecated and CSS should be used to set the
+  /// background color. Use the  property instead.
   external String get bgColor;
   external set bgColor(String value);
 }
@@ -4641,8 +4849,7 @@ extension type HTMLTableRowElement._(JSObject _)
 /// The **`HTMLTableCellElement`** interface provides special properties and
 /// methods (beyond the regular [HTMLElement] interface it also has available to
 /// it by inheritance) for manipulating the layout and presentation of table
-/// cells, either header cells (`th`)) or data cells (`td`), in an HTML
-/// document.
+/// cells, either header cells (`th`) or data cells (`td`), in an HTML document.
 ///
 /// ---
 ///
@@ -4656,17 +4863,70 @@ extension type HTMLTableCellElement._(JSObject _)
   /// Creates an [HTMLTableCellElement] using the tag 'th'.
   HTMLTableCellElement.th() : _ = document.createElement('th');
 
+  /// The **`colSpan`** read-only property of the [HTMLTableCellElement]
+  /// interface represents the number of columns this cell must span; this lets
+  /// the cell occupy space across multiple columns of the table. It reflects
+  /// the
+  /// [`colspan`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/td#colspan)
+  /// attribute.
   external int get colSpan;
   external set colSpan(int value);
+
+  /// The **`rowSpan`** read-only property of the [HTMLTableCellElement]
+  /// interface represents the number of rows this cell must span; this lets the
+  /// cell occupy space across multiple rows of the table. It reflects the
+  /// [`rowspan`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/td#colspan)
+  /// attribute.
   external int get rowSpan;
   external set rowSpan(int value);
+
+  /// The **`headers`** property of the [HTMLTableCellElement] interface
+  /// contains a list of IDs of `th` elements that are _headers_ for this
+  /// specific cell.
   external String get headers;
   external set headers(String value);
+
+  /// The **`cellIndex`** read-only property of the [HTMLTableCellElement]
+  /// interface
+  /// represents the position of a cell within its row (`tr`). The first cell
+  /// has an index of `0`.
   external int get cellIndex;
+
+  /// The **`scope`** property of the [HTMLTableCellElement] interface
+  /// indicates the scope of a `th` cell.
+  ///
+  /// Header cells can be configured, using the `scope` attribute, to apply to a
+  /// specified row or column, or to the not-yet-scoped cells within the current
+  /// row group (that is, the same ancestor `thead`, `tbody`, or `tfoot`
+  /// element). If no value is specified for `scope`, the header is not
+  /// associated directly with cells in this way. Permitted values for `scope`
+  /// are:
+  ///
+  /// > **Note:** this property doesn't have a visual effect in browsers. It
+  /// > adds semantic information to help assistive technology like
+  /// > screenreaders to present the table in a more coherent way.
   external String get scope;
   external set scope(String value);
+
+  /// The **`abbr`** property of the [HTMLTableCellElement] interface
+  /// indicates an abbreviation associated with the cell. If the cell does not
+  /// represent a header cell `th`, it is ignored.
+  ///
+  /// It reflects the `abbr` attribute of the `tr` element.
+  ///
+  /// > **Note:** this property doesn't have a visual effect in browsers. It
+  /// > adds information to help assistive technology like screenreaders that
+  /// > can use this abbreviation
   external String get abbr;
   external set abbr(String value);
+
+  /// The **`align`** property of the [HTMLTableCellElement] interface is a
+  /// string indicating how to horizontally align text in the `th` or `td` table
+  /// cell.
+  ///
+  /// > **Note:** This property is deprecated, and CSS should be used to align
+  /// > text horizontally in a cell. Use the CSS  property, which takes
+  /// > precedence, to horizontally align text in a cell instead.
   external String get align;
   external set align(String value);
   external String get axis;
@@ -4675,14 +4935,56 @@ extension type HTMLTableCellElement._(JSObject _)
   external set height(String value);
   external String get width;
   external set width(String value);
+
+  /// The **`ch`** property of the [HTMLTableCellElement] interface does
+  /// nothing. It reflects the `char` attribute of the cell element.
+  ///
+  /// > **Note:** This property was designed to participate to the ability to
+  /// > align table cell content on a specific character (typically the decimal
+  /// > point), but was never implemented by browsers.
+  /// >
+  /// > To achieve such alignment, watch for the support of a string value with
+  /// > the  CSS property.
   external String get ch;
   external set ch(String value);
+
+  /// The **`chOff`** property of the [HTMLTableCellElement] interface does
+  /// nothing. It reflects the `charoff` attribute of the cell element.
+  ///
+  /// > **Note:** This property was designed to participate in an ability to
+  /// > align table cell content on a specific character (typically the decimal
+  /// > point), but was never implemented by browsers.
+  /// >
+  /// > To achieve such alignment, watch for the support of a string value with
+  /// > the  CSS property.
   external String get chOff;
   external set chOff(String value);
+
+  /// The **`noWrap`** property of the [HTMLTableCellElement] interface returns
+  /// a Boolean value indicating if the text of the cell may be wrapped on
+  /// several lines or not.
+  ///
+  /// > **Note:** This property is deprecated and you should use the CSS
+  /// > property with the value `nowrap` instead.
   external bool get noWrap;
   external set noWrap(bool value);
+
+  /// The **`vAlign`** property of the [HTMLTableCellElement] interface is a
+  /// string indicating how to vertically align text in a `th` or `td` table
+  /// cell.
+  ///
+  /// > **Note:** This property is deprecated. Use the CSS  property to
+  /// > horizontally align text in a cell instead.
   external String get vAlign;
   external set vAlign(String value);
+
+  /// The **`HTMLTableCellElement.bgColor`** property is used to set the
+  /// background color of a cell or get the value of the obsolete
+  /// [`bgColor`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/td#bgcolor)
+  /// attribute, if present.
+  ///
+  /// **Note:** This property is deprecated and CSS should be used to set the
+  /// background color. Use the  property instead.
   external String get bgColor;
   external set bgColor(String value);
 }
@@ -4776,9 +5078,7 @@ extension type HTMLFormElement._(JSObject _) implements HTMLElement, JSObject {
   external String get autocomplete;
   external set autocomplete(String value);
 
-  /// The **`HTMLFormElement.enctype`** property is the
-  /// [MIME type](https://en.wikipedia.org/wiki/Mime_type) of content that is
-  /// used
+  /// The **`HTMLFormElement.enctype`** property is the  of content that is used
   /// to submit the form to the server. Possible values are:
   ///
   /// - `application/x-www-form-urlencoded`: The initial default type.
@@ -5344,7 +5644,7 @@ extension type HTMLInputElement._(JSObject _) implements HTMLElement, JSObject {
   external set step(String value);
 
   /// The **`type`** property of the [HTMLInputElement] interface indicates the
-  /// kind of data allowed in the `input` element, or example a number, a date,
+  /// kind of data allowed in the `input` element, for example a number, a date,
   /// or an email. Browsers will select the appropriate widget and behavior to
   /// help users to enter a valid value.
   ///
@@ -6290,14 +6590,56 @@ extension type HTMLScriptElement._(JSObject _)
   HTMLScriptElement() : _ = document.createElement('script');
 
   external static bool supports(String type);
+
+  /// The **`src`** property of the [HTMLScriptElement] interface is a string
+  /// representing the URL of an external script; this can be used as an
+  /// alternative to embedding a script directly within a document.
+  ///
+  /// It reflects the `src` attribute of the `script` element.
   external String get src;
   external set src(String value);
+
+  /// The **`type`** property of the [HTMLScriptElement] interface is a string
+  /// that reflects the type of the script.
+  ///
+  /// It reflects the `type` attribute of the `script` element.
   external String get type;
   external set type(String value);
+
+  /// The **`noModule`** property of the [HTMLScriptElement] interface is a
+  /// boolean value that indicates whether the script should be executed in
+  /// browsers that support
+  /// [ES modules](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Modules).
+  /// Practically, this can be used to serve fallback scripts to older browsers
+  /// that do not support JavaScript modules.
+  ///
+  /// It reflects the `nomodule` attribute of the `script` element.
   external bool get noModule;
   external set noModule(bool value);
+
+  /// The **`async`** property of the [HTMLScriptElement] interface is a boolean
+  /// value that controls how the script should be executed. For classic
+  /// scripts, if the `async` property is set to `true`, the external script
+  /// will be fetched in parallel to parsing and evaluated as soon as it is
+  /// available. For
+  /// [module scripts](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Modules),
+  /// if the `async` property is set to `true`, the script and all their
+  /// dependencies will be fetched in parallel to parsing and evaluated as soon
+  /// as they are available.
+  ///
+  /// It reflects the `async` attribute of the `script` element.
   external bool get async;
   external set async(bool value);
+
+  /// The **`defer`** property of the [HTMLScriptElement] interface is a boolean
+  /// value that controls how the script should be executed. For classic
+  /// scripts, if the `defer` property is set to `true`, the external script
+  /// will be executed after the document has been parsed, but before firing
+  /// [Document.DOMContentLoaded_event] event. For
+  /// [module scripts](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Modules),
+  /// the `defer` property has no effect.
+  ///
+  /// It reflects the `defer` attribute of the `script` element.
   external bool get defer;
   external set defer(bool value);
 
@@ -6310,8 +6652,20 @@ extension type HTMLScriptElement._(JSObject _)
   /// for details.
   external String? get crossOrigin;
   external set crossOrigin(String? value);
+
+  /// The **`text`** property of the [HTMLScriptElement] interface is a string
+  /// that reflects the text content inside the `script` element. It acts the
+  /// same way as the [Node.textContent] property.
+  ///
+  /// It reflects the `text` attribute of the `script` element.
   external String get text;
   external set text(String value);
+
+  /// The **`integrity`** property of the [HTMLScriptElement] interface is a
+  /// string that contains inline metadata that a browser can use to verify that
+  /// a fetched resource has been delivered without unexpected manipulation.
+  ///
+  /// It reflects the `integrity` attribute of the `script` element.
   external String get integrity;
   external set integrity(String value);
 
@@ -6322,6 +6676,12 @@ extension type HTMLScriptElement._(JSObject _)
   /// fetching the script and any scripts it imports.
   external String get referrerPolicy;
   external set referrerPolicy(String value);
+
+  /// The **`fetchPriority`** property of the [HTMLScriptElement] interface
+  /// represents a hint given to the browser on how it should prioritize
+  /// fetching of an external script relative to other external scripts.
+  ///
+  /// It reflects the `fetchpriority` attribute of the `script` element.
   external String get fetchPriority;
   external set fetchPriority(String value);
   external String get charset;
@@ -6335,6 +6695,14 @@ extension type HTMLScriptElement._(JSObject _)
 /// The **`HTMLTemplateElement`** interface enables access to the contents of an
 /// HTML `template` element.
 ///
+/// > **Note:** An HTML parser can create either an `HTMLTemplateElement` or a
+/// > [ShadowRoot] when it parses a `template` element, depending on the
+/// > `<template>` attributes.
+/// > If an `HTMLTemplateElement` is created the "shadow" attributes are
+/// > reflected from the template.
+/// > However these are not useful, because an `HTMLTemplateElement` is not a
+/// > shadow root and cannot subsequently be changed to a shadow root.
+///
 /// ---
 ///
 /// API documentation sourced from
@@ -6348,6 +6716,21 @@ extension type HTMLTemplateElement._(JSObject _)
   /// `<template>` element's template contents (a
   /// [DocumentFragment]).
   external DocumentFragment get content;
+
+  /// The **`shadowRootMode`** property of the [HTMLTemplateElement] interface
+  /// reflects the value of the
+  /// [`shadowrootmode`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/template#shadowrootmode)
+  /// attribute of the associated
+  /// [`<template>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/template)
+  /// element.
+  ///
+  /// Note that this property is not useful for developers.
+  /// If a `<template>` element is used to declaratively create a
+  /// [`ShadowRoot`](https://developer.mozilla.org/en-US/docs/Web/API/ShadowRoot),
+  /// then this object and property do not exist.
+  /// Otherwise, if an `HTMLTemplateElement` is created, the value of this
+  /// property is irrelevant because the object is not a shadow root and cannot
+  /// subsequently be changed to a shadow root.
   external String get shadowRootMode;
   external set shadowRootMode(String value);
 }
@@ -8003,8 +8386,9 @@ extension type OffscreenCanvas._(JSObject _) implements EventTarget, JSObject {
 ///   `scrollPathIntoView`)
 /// - its `canvas` attribute refers to an `OffscreenCanvas` object rather than a
 ///   `canvas` element
-/// - it has a `commit()` method for pushing rendered images to the context's
-///   `OffscreenCanvas` object's placeholder `canvas` element
+/// - the bitmap for the placeholder `canvas` element belonging to the
+///   `OffscreenCanvas` object is updated during the rendering update of the
+///   `Window` or `Worker` that owns the `OffscreenCanvas`
 ///
 /// ---
 ///
@@ -8016,8 +8400,8 @@ extension type OffscreenCanvasRenderingContext2D._(JSObject _)
   /// **`OffscreenCanvasRenderingContext2D.commit()`**
   /// method of the
   /// [Canvas 2D API](https://developer.mozilla.org/en-US/docs/Web/API/OffscreenCanvasRenderingContext2D)
-  /// copies the rendering context's bitmap to the bitmap of the placeholder
-  /// `canvas` element of the associated `OffscreenCanvas` object.
+  /// was intended to copy the rendering context's bitmap to the bitmap of the
+  /// placeholder `canvas` element of the associated `OffscreenCanvas` object.
   /// The copy operation is synchronous. Calling this method is not needed for
   /// the transfer, since it happens automatically during the event-loop
   /// execution.
@@ -8801,8 +9185,8 @@ extension type ElementInternals._(JSObject _) implements JSObject {
   external String? get ariaReadOnly;
   external set ariaReadOnly(String? value);
 
-  /// The **`ariaRequired`** property of the [Element] interface reflects the
-  /// value of the
+  /// The **`ariaRequired`** property of the [ElementInternals] interface
+  /// reflects the value of the
   /// [`aria-required`](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-required)
   /// attribute, which indicates that user input is required on the element
   /// before a form may be submitted.
@@ -8816,8 +9200,8 @@ extension type ElementInternals._(JSObject _) implements JSObject {
   external String? get ariaRequired;
   external set ariaRequired(String? value);
 
-  /// The **`ariaRoleDescription`** property of the [Element] interface reflects
-  /// the value of the
+  /// The **`ariaRoleDescription`** property of the [ElementInternals] interface
+  /// reflects the value of the
   /// [`aria-roledescription`](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-roledescription)
   /// attribute, which defines a human-readable, author-localized description
   /// for the role of an element.
@@ -10408,14 +10792,79 @@ extension type Window._(JSObject _) implements EventTarget, JSObject {
   external set onunhandledrejection(EventHandler value);
   external EventHandler get onunload;
   external set onunload(EventHandler value);
+
+  /// The **`indexedDB`** read-only property of the [Window] interface provides
+  /// a mechanism for applications to
+  /// asynchronously access the capabilities of indexed databases.
   external IDBFactory get indexedDB;
+
+  /// The **`crypto`** read-only property of the [Window] interface returns the
+  /// [Crypto] object for this window's scope. This object gives web pages
+  /// access to certain cryptographic related services.
+  ///
+  /// Although the property itself is read-only, all of its methods (and the
+  /// methods of its
+  /// child object, [SubtleCrypto]) are not read-only, and therefore vulnerable
+  /// to attack by .
+  ///
+  /// Although `crypto` is available on all windows, the returned `Crypto`
+  /// object only has one usable feature in insecure contexts: the
+  /// [Crypto.getRandomValues] method. In general, you should use this API only
+  /// in secure contexts.
   external Crypto get crypto;
+
+  /// The **`performance`** property of the [Window] interface returns a
+  /// [Performance] object, which can be used to gather performance information
+  /// about code running in the window's scope.
+  ///
+  /// Performance entries are per context. If you create a mark on the main
+  /// thread (or other worker), you cannot see it in a worker thread, and vice
+  /// versa.
   external Performance get performance;
+
+  /// The **`origin`** read-only property of the [Window] interface returns the
+  /// origin of the global scope, serialized as a string.
   external String get origin;
+
+  /// The **`isSecureContext`** read-only property of the [Window] interface
+  /// returns a boolean indicating whether the current
+  /// [context is secure](https://developer.mozilla.org/en-US/docs/Web/Security/Secure_Contexts)
+  /// (`true`) or not (`false`).
   external bool get isSecureContext;
+
+  /// The **`crossOriginIsolated`** read-only property of the [Window] interface
+  /// returns a boolean value that
+  /// indicates whether the website is in a cross-origin isolation state. That
+  /// state mitigates the risk of side-channel attacks and unlocks a few
+  /// capabilities:
+  ///
+  /// - `SharedArrayBuffer` can be created and sent via a [Window.postMessage]
+  ///   or a [MessagePort.postMessage] call.
+  /// - [Performance.now] offers better precision.
+  /// - [Performance.measureUserAgentSpecificMemory] can be accessed.
+  ///
+  /// A website is in a cross-origin isolated state, when the response header
+  /// has the value `same-origin` and the  header has the value `require-corp`
+  /// or `credentialless`.
   external bool get crossOriginIsolated;
+
+  /// The **`scheduler`** read-only property of the [Window] interface is the
+  /// entry point for using the
+  /// [Prioritized Task Scheduling API](https://developer.mozilla.org/en-US/docs/Web/API/Prioritized_Task_Scheduling_API).
+  ///
+  /// The object has a single instance method [Scheduler.postTask] that is used
+  /// to post prioritized tasks for scheduling.
   external Scheduler get scheduler;
+
+  /// The **`caches`** read-only property of the [Window] interface returns the
+  /// [CacheStorage] object associated with the current context.
+  /// This object enables functionality such as storing assets for offline use,
+  /// and generating custom responses to requests.
   external CacheStorage get caches;
+
+  /// The **`trustedTypes`** read-only property of the [Window] interface
+  /// returns the [TrustedTypePolicyFactory] object associated with the global
+  /// object, providing the entry point for using the [Trusted Types API].
   external TrustedTypePolicyFactory get trustedTypes;
 
   /// The read-only **`sessionStorage`**
@@ -10585,7 +11034,7 @@ extension type Location._(JSObject _) implements JSObject {
   external set host(String value);
 
   /// The **`hostname`** property of the [Location]
-  /// interface is a string containing the domain of the URL.
+  /// interface is a string containing the  of the URL.
   external String get hostname;
   external set hostname(String value);
 
@@ -11115,7 +11564,8 @@ extension type Navigator._(JSObject _) implements JSObject {
     NavigatorUserMediaErrorCallback errorCallback,
   );
 
-  /// The **`Navigator.vibrate()`** method pulses the vibration
+  /// The **`vibrate()`** method of the [Navigator] interface pulses the
+  /// vibration
   /// hardware on the device, if such hardware exists. If the device doesn't
   /// support
   /// vibration, this method has no effect. If a vibration pattern is already in
@@ -11130,22 +11580,28 @@ extension type Navigator._(JSObject _) implements JSObject {
   /// implementation.
   external bool vibrate(VibratePattern pattern);
 
-  /// The **`navigator.share()`** method of the
-  /// [Web Share API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Share_API)
-  /// invokes the native sharing mechanism of the device to share data such as
-  /// text, URLs, or files. The available _share targets_ depend on the device,
-  /// but might include the clipboard, contacts and email applications,
-  /// websites, Bluetooth, etc.
+  /// The **`share()`** method of the [Navigator] interface invokes the native
+  /// sharing mechanism of the device to share data such as text, URLs, or
+  /// files. The available _share targets_ depend on the device, but might
+  /// include the clipboard, contacts and email applications, websites,
+  /// Bluetooth, etc.
   ///
   /// The method resolves a `Promise` with `undefined`.
   /// On Windows this happens when the share popup is launched, while on Android
   /// the promise resolves once the data has successfully been passed to the
   /// _share target_.
+  ///
+  /// The
+  /// [Web Share API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Share_API)
+  /// is gated by the
+  /// [web-share](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Permissions-Policy/web-share)
+  /// permission policy.
+  /// The `share()` method will throw exceptions if the permission is supported
+  /// but has not been granted.
   external JSPromise<JSAny?> share([ShareData data]);
 
-  /// The **`Navigator.canShare()`** method of the
-  /// [Web Share API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Share_API)
-  /// returns `true` if the equivalent call to [navigator.share] would succeed.
+  /// The **`canShare()`** method of the [Navigator] interface returns `true` if
+  /// the equivalent call to [navigator.share] would succeed.
   ///
   /// The method returns `false` if the data cannot be _validated_. Reasons the
   /// data might be invalid include:
@@ -11159,11 +11615,13 @@ extension type Navigator._(JSObject _) implements JSObject {
   /// - Sharing the specified data would be considered a "hostile share" by the
   ///   user-agent.
   ///
-  /// The Web Share API is gated by the
+  /// The
+  /// [Web Share API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Share_API)
+  /// is gated by the
   /// [web-share](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Permissions-Policy/web-share)
   /// permission policy.
-  /// The **`canShare()`** method will return `false` if the permission is
-  /// supported but has not been granted.
+  /// The `canShare()` method will return `false` if the permission is supported
+  /// but has not been granted.
   external bool canShare([ShareData data]);
 
   /// The **`requestMIDIAccess()`** method of the [Navigator] interface returns
@@ -11298,7 +11756,8 @@ extension type Navigator._(JSObject _) implements JSObject {
   /// playback.
   external MediaSession get mediaSession;
 
-  /// The **`Navigator.permissions`** read-only property returns a
+  /// The **`permissions`** read-only property of the [Navigator] interface
+  /// returns a
   /// [Permissions] object that can be used to query and update permission
   /// status of APIs covered by the
   /// [Permissions API](https://developer.mozilla.org/en-US/docs/Web/API/Permissions_API).
@@ -11412,8 +11871,8 @@ extension type Navigator._(JSObject _) implements JSObject {
   /// > All browsers return "`Gecko`" as the value of this property.
   external String get product;
 
-  /// The **`Navigator.productSub`** read-only property returns the
-  /// build number of the current browser.
+  /// The **`Navigator.productSub`** read-only property that returns either the
+  /// string "20030107", or the string "20100101".
   external String get productSub;
 
   /// The **`Navigator.userAgent`** read-only property returns the
@@ -12166,17 +12625,97 @@ extension type WorkerGlobalScope._(JSObject _)
   /// This property is part of the
   /// [CSS Font Loading API](https://developer.mozilla.org/en-US/docs/Web/API/CSS_Font_Loading_API).
   external FontFaceSet get fonts;
+
+  /// The **`indexedDB`** read-only property of the [WorkerGlobalScope]
+  /// interface provides a mechanism for workers to
+  /// asynchronously access the capabilities of indexed databases.
   external IDBFactory get indexedDB;
+
+  /// The **`crypto`** read-only property of the [WorkerGlobalScope] interface
+  /// returns the [Crypto] object for this worker. This object gives workers
+  /// access to certain cryptographic related services.
+  ///
+  /// Although the property itself is read-only, all of its methods (and the
+  /// methods of its
+  /// child object, [SubtleCrypto]) are not read-only, and therefore vulnerable
+  /// to attack by .
+  ///
+  /// Although `crypto` is available on all workers, the returned `Crypto`
+  /// object only has one usable feature in insecure contexts: the
+  /// [Crypto.getRandomValues] method. In general, you should use this API only
+  /// in secure contexts.
   external Crypto get crypto;
+
+  /// The **`performance`** property of the [WorkerGlobalScope] interface
+  /// returns a [Performance] object, which can be used to gather performance
+  /// information about code running in the worker's scope.
+  ///
+  /// Performance entries are per context. If you create a mark on a worker
+  /// thread, you will not see it in the main thread or any other workers.
+  ///
+  /// Note that only the following performance interfaces are available in
+  /// worker contexts:
+  ///
+  /// - [Performance]
+  /// - [PerformanceEntry]
+  /// - [PerformanceMark]
+  /// - [PerformanceMeasure]
+  /// - [PerformanceObserver]
+  /// - [PerformanceObserverEntryList]
+  /// - [PerformanceResourceTiming]
+  /// - [PerformanceServerTiming]
   external Performance get performance;
+
+  /// The **`origin`** read-only property of the [WorkerGlobalScope] interface
+  /// returns the origin of the global scope, serialized as a string.
   external String get origin;
+
+  /// The **`isSecureContext`** read-only property of the [WorkerGlobalScope]
+  /// interface returns a boolean indicating whether the current
+  /// [context is secure](https://developer.mozilla.org/en-US/docs/Web/Security/Secure_Contexts)
+  /// (`true`) or not (`false`).
   external bool get isSecureContext;
+
+  /// The **`crossOriginIsolated`** read-only property of the
+  /// [WorkerGlobalScope] interface returns a boolean value that
+  /// indicates whether the website is in a cross-origin isolation state. That
+  /// state mitigates the risk of side-channel attacks and unlocks a few
+  /// capabilities:
+  ///
+  /// - `SharedArrayBuffer` can be created and sent via a
+  ///   [DedicatedWorkerGlobalScope.postMessage] or a [MessagePort.postMessage]
+  ///   call.
+  /// - [Performance.now] offers better precision.
+  /// - [Performance.measureUserAgentSpecificMemory] can be accessed.
+  ///
+  /// A website is in a cross-origin isolated state, when the response header
+  /// has the value `same-origin` and the  header has the value `require-corp`
+  /// or `credentialless`.
   external bool get crossOriginIsolated;
+
+  /// The **`scheduler`** read-only property of the [WorkerGlobalScope]
+  /// interface is the entry point for using the
+  /// [Prioritized Task Scheduling API](https://developer.mozilla.org/en-US/docs/Web/API/Prioritized_Task_Scheduling_API).
+  ///
+  /// The object has a single instance method [Scheduler.postTask] that is used
+  /// to post prioritized tasks for scheduling.
   external Scheduler get scheduler;
+
+  /// The **`caches`** read-only property of the [WorkerGlobalScope] interface
+  /// returns the [CacheStorage] object associated with the current context.
+  /// This object enables functionality such as storing assets for offline use,
+  /// and generating custom responses to requests.
   external CacheStorage get caches;
+
+  /// The **`trustedTypes`** read-only property of the [WorkerGlobalScope]
+  /// interface returns the [TrustedTypePolicyFactory] object associated with
+  /// the global object, providing the entry point for using the
+  /// [Trusted Types API].
   external TrustedTypePolicyFactory get trustedTypes;
 }
 
+/// @AvailableInWorkers("dedicated")
+///
 /// The **`DedicatedWorkerGlobalScope`** object (the [Worker] global scope) is
 /// accessible through the [WorkerGlobalScope.self] keyword. Some additional
 /// global functions, namespaces objects, and constructors, not typically
@@ -12192,6 +12731,8 @@ extension type WorkerGlobalScope._(JSObject _)
 /// [MDN Web Docs](https://developer.mozilla.org/en-US/docs/Web/API/DedicatedWorkerGlobalScope).
 extension type DedicatedWorkerGlobalScope._(JSObject _)
     implements WorkerGlobalScope, JSObject {
+  /// @AvailableInWorkers("dedicated")
+  ///
   /// The **`postMessage()`** method of the [DedicatedWorkerGlobalScope]
   /// interface sends a message to the main thread that spawned it.
   ///
@@ -12216,11 +12757,15 @@ extension type DedicatedWorkerGlobalScope._(JSObject _)
     JSObject optionsOrTransfer,
   ]);
 
+  /// @AvailableInWorkers("dedicated")
+  ///
   /// The **`close()`** method of the [DedicatedWorkerGlobalScope] interface
   /// discards any tasks queued in the `DedicatedWorkerGlobalScope`'s event
   /// loop, effectively closing this particular scope.
   external void close();
 
+  /// @AvailableInWorkers("dedicated")
+  ///
   /// The **`requestAnimationFrame()`** method of the
   /// [DedicatedWorkerGlobalScope] interface tells the browser you wish to
   /// perform an animation frame request and call a user-supplied callback
@@ -12249,6 +12794,8 @@ extension type DedicatedWorkerGlobalScope._(JSObject _)
   /// associated owner [Window].
   external int requestAnimationFrame(FrameRequestCallback callback);
 
+  /// @AvailableInWorkers("dedicated")
+  ///
   /// The **`cancelAnimationFrame()`** method of the
   /// [DedicatedWorkerGlobalScope] interface cancels an animation frame request
   /// previously scheduled through a call to
@@ -12260,6 +12807,8 @@ extension type DedicatedWorkerGlobalScope._(JSObject _)
   /// associated owner [Window].
   external void cancelAnimationFrame(int handle);
 
+  /// @AvailableInWorkers("dedicated")
+  ///
   /// The **`name`** read-only property of the
   /// [DedicatedWorkerGlobalScope] interface returns the name that the
   /// [Worker] was (optionally) given when it was created. This is the name that
@@ -12304,6 +12853,8 @@ extension type SharedWorkerGlobalScope._(JSObject _)
   external set onconnect(EventHandler value);
 }
 
+/// @AvailableInWorkers("window_and_worker_except_service")
+///
 /// The **`Worker`** interface of the
 /// [Web Workers API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API)
 /// represents a background task that can be created via script, which can send
@@ -12331,11 +12882,15 @@ extension type Worker._(JSObject _) implements EventTarget, JSObject {
     WorkerOptions options,
   ]);
 
+  /// @AvailableInWorkers("window_and_worker_except_service")
+  ///
   /// The **`terminate()`** method of the [Worker] interface immediately
   /// terminates the [Worker]. This does not offer the worker an opportunity to
   /// finish its operations; it is stopped at once.
   external void terminate();
 
+  /// @AvailableInWorkers("window_and_worker_except_service")
+  ///
   /// The **`postMessage()`** method of the [Worker] interface sends a message
   /// to the worker. The first parameter is the data to send to the worker. The
   /// data may be any JavaScript object that can be handled by the
@@ -12419,7 +12974,8 @@ extension type WorkerNavigator._(JSObject _) implements JSObject {
   /// [Media Capabilities API](https://developer.mozilla.org/en-US/docs/Web/API/Media_Capabilities_API).
   external MediaCapabilities get mediaCapabilities;
 
-  /// The **`WorkerNavigator.permissions`** read-only property
+  /// The **`permissions`** read-only property of the [WorkerNavigator]
+  /// interface
   /// returns a [Permissions] object that can be used to query and update
   /// permission status of APIs covered by the
   /// [Permissions API](https://developer.mozilla.org/en-US/docs/Web/API/Permissions_API).
@@ -12585,12 +13141,11 @@ extension type WorkerNavigator._(JSObject _) implements JSObject {
   /// computer.
   external int get hardwareConcurrency;
 
-  /// The **`WorkerNavigator.connection`** read-only property returns
-  /// a [NetworkInformation] object containing information about the system's
-  /// connection, such as the current bandwidth of the user's device or whether
-  /// the connection
-  /// is metered. This could be used to select high definition content or low
-  /// definition
+  /// The **`connection`** read-only property of the [WorkerNavigator] interface
+  /// returns a [NetworkInformation] object containing information about the
+  /// system's connection, such as the current bandwidth of the user's device or
+  /// whether the connection is metered.
+  /// This could be used to select high definition content or low definition
   /// content based on the user's connection.
   external JSObject get connection;
 
diff --git a/lib/src/dom/indexeddb.dart b/lib/src/dom/indexeddb.dart
index 50c8e5a1..31e41dbd 100644
--- a/lib/src/dom/indexeddb.dart
+++ b/lib/src/dom/indexeddb.dart
@@ -210,12 +210,14 @@ extension type IDBFactory._(JSObject _) implements JSObject {
   /// event.
   external IDBOpenDBRequest deleteDatabase(String name);
 
-  /// The **`databases`** method of the [IDBFactory] interface returns a list
-  /// representing all the available databases, including their names and
-  /// versions.
+  /// The **`databases`** method of the [IDBFactory] interface returns a
+  /// `Promise` that fulfills with an array of objects containing the name and
+  /// version of all the available databases.
   ///
-  /// > **Note:** This method is introduced in a draft of a specifications and
-  /// > browser compatibility is limited.
+  /// This is is a snapshot of the databases, intended primarily to allow web
+  /// applications to check what databases have been created — in order to, for
+  /// example, clean up databases created by earlier versions of application
+  /// code.
   external JSPromise<JSArray<IDBDatabaseInfo>> databases();
 
   /// The **`cmp()`** method of the [IDBFactory]
@@ -1136,14 +1138,14 @@ extension type IDBTransaction._(JSObject _) implements EventTarget, JSObject {
   /// `readonly`.
   external IDBTransactionMode get mode;
 
-  /// The **`durability`** read-only property of the
-  /// [IDBTransaction] interface returns the durability hint the transaction was
-  /// created with. This is a hint to the user agent of whether to prioritize
-  /// performance or
+  /// The **`durability`** read-only property of the [IDBTransaction] interface
+  /// returns the durability hint the transaction was created with.
+  /// This is a hint to the user agent of whether to prioritize performance or
   /// durability when committing the transaction.
   ///
-  /// The value of this property is defined in the `options` parameter when
-  /// creating a transaction using [IDBDatabase.transaction].
+  /// The value of this property is defined in the
+  /// [`options.durability`](/en-US/docs/Web/API/IDBDatabase/transaction#options)
+  /// parameter when creating a transaction using [IDBDatabase.transaction].
   external IDBTransactionDurability get durability;
 
   /// The **`db`** read-only property of the [IDBTransaction] interface returns
diff --git a/lib/src/dom/mediacapture_streams.dart b/lib/src/dom/mediacapture_streams.dart
index f2560dad..d05e7702 100644
--- a/lib/src/dom/mediacapture_streams.dart
+++ b/lib/src/dom/mediacapture_streams.dart
@@ -1005,7 +1005,7 @@ extension type MediaTrackSettings._(JSObject _) implements JSObject {
   external set height(int value);
 
   /// The [MediaTrackSettings] dictionary's **`aspectRatio`** property is a
-  /// double-precision floating-point number indicating the aspect ratio of the
+  /// double-precision floating-point number indicating the  of the
   /// [MediaStreamTrack] as currently configured.
   /// This lets you determine what value was selected to comply with your
   /// specified constraints for this property's value as described in the
diff --git a/lib/src/dom/notifications.dart b/lib/src/dom/notifications.dart
index 2ec04ece..0b3675d5 100644
--- a/lib/src/dom/notifications.dart
+++ b/lib/src/dom/notifications.dart
@@ -224,6 +224,8 @@ extension type GetNotificationOptions._(JSObject _) implements JSObject {
   external set tag(String value);
 }
 
+/// @AvailableInWorkers("service")
+///
 /// The **`NotificationEvent`** interface of the [Notifications API] represents
 /// a notification event dispatched on the [ServiceWorkerGlobalScope] of a
 /// [ServiceWorker].
@@ -246,6 +248,8 @@ extension type NotificationEvent._(JSObject _)
     NotificationEventInit eventInitDict,
   );
 
+  /// @AvailableInWorkers("service")
+  ///
   /// The **`notification`** read-only property of the [NotificationEvent]
   /// interface returns the instance of the [Notification] that was clicked to
   /// fire the event. The [Notification] provides read-only access to many
@@ -254,6 +258,8 @@ extension type NotificationEvent._(JSObject _)
   /// for deferred use in the `notificationclick` event.
   external Notification get notification;
 
+  /// @AvailableInWorkers("service")
+  ///
   /// The **`action`** read-only property of the [NotificationEvent] interface
   /// returns the string ID of the notification button the user clicked. This
   /// value returns an empty string if the user clicked the notification
diff --git a/lib/src/dom/performance_timeline.dart b/lib/src/dom/performance_timeline.dart
index bc316944..fee64c60 100644
--- a/lib/src/dom/performance_timeline.dart
+++ b/lib/src/dom/performance_timeline.dart
@@ -35,12 +35,14 @@ typedef PerformanceObserverCallback = JSFunction;
 /// - [LargestContentfulPaint]
 /// - [LayoutShift]
 /// - [PerformanceEventTiming]
+/// - [PerformanceLongAnimationFrameTiming]
 /// - [PerformanceLongTaskTiming]
 /// - [PerformanceMark]
 /// - [PerformanceMeasure]
 /// - [PerformanceNavigationTiming]
 /// - [PerformancePaintTiming]
 /// - [PerformanceResourceTiming]
+/// - [PerformanceScriptTiming]
 /// - [PerformanceServerTiming]
 /// - [TaskAttributionTiming]
 /// - [VisibilityStateEntry]
diff --git a/lib/src/dom/permissions.dart b/lib/src/dom/permissions.dart
index e5368139..6069a1dd 100644
--- a/lib/src/dom/permissions.dart
+++ b/lib/src/dom/permissions.dart
@@ -18,7 +18,7 @@ import 'html.dart';
 
 typedef PermissionState = String;
 
-/// The Permissions interface of the
+/// The **`Permissions`** interface of the
 /// [Permissions API](https://developer.mozilla.org/en-US/docs/Web/API/Permissions_API)
 /// provides the core Permission API functionality, such as methods for querying
 /// and revoking permissions
@@ -28,15 +28,15 @@ typedef PermissionState = String;
 /// API documentation sourced from
 /// [MDN Web Docs](https://developer.mozilla.org/en-US/docs/Web/API/Permissions).
 extension type Permissions._(JSObject _) implements JSObject {
-  /// The **`Permissions.revoke()`** method of the
+  /// The **`revoke()`** method of the
   /// [Permissions] interface reverts a currently set permission back to its
   /// default state, which is usually `prompt`.
   /// This method is called on the global [Permissions] object
   /// [navigator.permissions].
   external JSPromise<PermissionStatus> revoke(JSObject permissionDesc);
 
-  /// The **`Permissions.query()`** method of the [Permissions] interface
-  /// returns the state of a user permission on the global scope.
+  /// The **`query()`** method of the [Permissions] interface returns the state
+  /// of a user permission on the global scope.
   external JSPromise<PermissionStatus> query(JSObject permissionDesc);
 }
 
diff --git a/lib/src/dom/push_api.dart b/lib/src/dom/push_api.dart
index ad153731..d2e56941 100644
--- a/lib/src/dom/push_api.dart
+++ b/lib/src/dom/push_api.dart
@@ -170,6 +170,8 @@ extension type PushSubscriptionJSON._(JSObject _) implements JSObject {
   external set keys(JSObject value);
 }
 
+/// @AvailableInWorkers("service")
+///
 /// The **`PushMessageData`** interface of the
 /// [Push API](https://developer.mozilla.org/en-US/docs/Web/API/Push_API)
 /// provides methods which let you retrieve the push data sent by a server in
@@ -189,25 +191,35 @@ extension type PushSubscriptionJSON._(JSObject _) implements JSObject {
 /// API documentation sourced from
 /// [MDN Web Docs](https://developer.mozilla.org/en-US/docs/Web/API/PushMessageData).
 extension type PushMessageData._(JSObject _) implements JSObject {
+  /// @AvailableInWorkers("service")
+  ///
   /// The **`arrayBuffer()`** method of the [PushMessageData] interface extracts
   /// push message data as an `ArrayBuffer` object.
   external JSArrayBuffer arrayBuffer();
 
+  /// @AvailableInWorkers("service")
+  ///
   /// The **`blob()`** method of the [PushMessageData] interface extracts push
   /// message data as a [Blob] object.
   external Blob blob();
 
+  /// @AvailableInWorkers("service")
+  ///
   /// The **`json()`** method of the [PushMessageData] interface extracts push
   /// message data by parsing it as a
   /// [JSON](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON)
   /// string and returning the result.
   external JSAny? json();
 
+  /// @AvailableInWorkers("service")
+  ///
   /// The **`text()`** method of the [PushMessageData] interface extracts push
   /// message data as a plain text string.
   external String text();
 }
 
+/// @AvailableInWorkers("service")
+///
 /// The **`PushEvent`** interface of the
 /// [Push API](https://developer.mozilla.org/en-US/docs/Web/API/Push_API)
 /// represents a push message that has been received. This event is sent to the
@@ -225,6 +237,8 @@ extension type PushEvent._(JSObject _) implements ExtendableEvent, JSObject {
     PushEventInit eventInitDict,
   ]);
 
+  /// @AvailableInWorkers("service")
+  ///
   /// The `data` read-only property of the **`PushEvent`** interface returns a
   /// reference to a [PushMessageData] object containing data sent to the
   /// [PushSubscription].
diff --git a/lib/src/dom/selection_api.dart b/lib/src/dom/selection_api.dart
index 638652f9..d3fd0ac9 100644
--- a/lib/src/dom/selection_api.dart
+++ b/lib/src/dom/selection_api.dart
@@ -35,8 +35,19 @@ import 'dom.dart';
 /// API documentation sourced from
 /// [MDN Web Docs](https://developer.mozilla.org/en-US/docs/Web/API/Selection).
 extension type Selection._(JSObject _) implements JSObject {
-  /// The **`Selection.getRangeAt()`** method returns a range object
-  /// representing one of the ranges currently selected.
+  /// The **`getRangeAt()`** method of the [Selection] interface returns a range
+  /// object representing a currently selected range.
+  ///
+  /// If the endpoints of the selected range are within a  then JavaScript does
+  /// not have visibility of the shadow nodes, and the method should re-scope
+  /// the range to include the host element that contains the end point.
+  /// In practice most browsers do not yet implement this behavior, and the
+  /// returned range is unpredictable.
+  ///
+  /// > **Note:** When selecting within nodes that might contain a shadow root,
+  /// > you can use [Selection.getComposedRanges] (if supported) to get a
+  /// > selection range inside a shadow tree, or to reliably re-scope the
+  /// > selection to the host node.
   external Range getRangeAt(int index);
 
   /// The **`Selection.addRange()`** method adds a
@@ -106,9 +117,12 @@ extension type Selection._(JSObject _) implements JSObject {
     int offset,
   ]);
 
-  /// The **`setBaseAndExtent()`** method of the
-  /// [Selection] interface sets the selection to be a range including all or
-  /// parts of two specified DOM nodes, and any content located between them.
+  /// The **`setBaseAndExtent()`** method of the [Selection] interface sets the
+  /// selection to be a range including all or parts of two specified DOM nodes,
+  /// and any content located between them.
+  ///
+  /// The anchor and focus nodes can be located in a , if supported by the
+  /// browser.
   external void setBaseAndExtent(
     Node anchorNode,
     int anchorOffset,
diff --git a/lib/src/dom/service_workers.dart b/lib/src/dom/service_workers.dart
index 33a2afc5..753b6183 100644
--- a/lib/src/dom/service_workers.dart
+++ b/lib/src/dom/service_workers.dart
@@ -194,19 +194,18 @@ extension type ServiceWorkerRegistration._(JSObject _)
   /// preemptively downloaded in parallel with service worker boot up.
   external NavigationPreloadManager get navigationPreload;
 
-  /// The **`scope`** read-only property of the
-  /// [ServiceWorkerRegistration] interface returns a unique identifier for a
-  /// service worker registration. The service worker must be on the same origin
-  /// as the
-  /// document that registers the [ServiceWorker].
+  /// The **`scope`** read-only property of the [ServiceWorkerRegistration]
+  /// interface returns a string representing a URL that defines a service
+  /// worker's registration scope; that is, the range of URLs a service worker
+  /// can control. This is set using the `scope` parameter specified in the call
+  /// to [ServiceWorkerContainer.register] which registered the service worker.
   external String get scope;
 
   /// The **`updateViaCache`** read-only property of the
-  /// [ServiceWorkerRegistration] interface updates the cache using
-  /// the mode specified in the call to [ServiceWorkerContainer.register].
-  /// Requests for `importScripts` still go via the HTTP cache. `updateViaCache`
-  /// offers
-  /// control over this behavior.
+  /// [ServiceWorkerRegistration] interface returns the value of the setting
+  /// used to determine the circumstances in which the browser will consult the
+  /// HTTP cache when it tries to update the service worker or any scripts that
+  /// are imported via [WorkerGlobalScope.importScripts].
   external ServiceWorkerUpdateViaCache get updateViaCache;
   external EventHandler get onupdatefound;
   external set onupdatefound(EventHandler value);
@@ -384,6 +383,8 @@ extension type NavigationPreloadState._(JSObject _) implements JSObject {
   external set headerValue(String value);
 }
 
+/// @AvailableInWorkers("service")
+///
 /// The **`ServiceWorkerGlobalScope`** interface of the
 /// [Service Worker API](https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API)
 /// represents the global execution context of a service worker.
@@ -411,9 +412,10 @@ extension type NavigationPreloadState._(JSObject _) implements JSObject {
 /// [MDN Web Docs](https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerGlobalScope).
 extension type ServiceWorkerGlobalScope._(JSObject _)
     implements WorkerGlobalScope, JSObject {
-  /// The **`ServiceWorkerGlobalScope.skipWaiting()`** method of the
-  /// [ServiceWorkerGlobalScope] forces the waiting service worker to become the
-  /// active service worker.
+  /// @AvailableInWorkers("service")
+  ///
+  /// The **`skipWaiting()`** method of the [ServiceWorkerGlobalScope] interface
+  /// forces the waiting service worker to become the active service worker.
   ///
   /// Use this method with [Clients.claim] to ensure that updates to the
   /// underlying service worker take effect immediately for both the current
@@ -430,18 +432,24 @@ extension type ServiceWorkerGlobalScope._(JSObject _)
   external EventHandler get onpushsubscriptionchange;
   external set onpushsubscriptionchange(EventHandler value);
 
+  /// @AvailableInWorkers("service")
+  ///
   /// The **`clients`** read-only property of the
   /// [ServiceWorkerGlobalScope] interface returns the
   /// [`Clients`](https://developer.mozilla.org/en-US/docs/Web/API/Clients)
   /// object associated with the service worker.
   external Clients get clients;
 
+  /// @AvailableInWorkers("service")
+  ///
   /// The **`registration`** read-only property of the
   /// [ServiceWorkerGlobalScope] interface returns a reference to the
   /// [ServiceWorkerRegistration] object, which represents the service worker's
   /// registration.
   external ServiceWorkerRegistration get registration;
 
+  /// @AvailableInWorkers("service")
+  ///
   /// The **`serviceWorker`** read-only property of the
   /// [ServiceWorkerGlobalScope] interface returns a reference to the
   /// [ServiceWorker] object, which represents the service worker.
@@ -458,6 +466,8 @@ extension type ServiceWorkerGlobalScope._(JSObject _)
   external set onmessageerror(EventHandler value);
 }
 
+/// @AvailableInWorkers("service")
+///
 /// The `Client` interface represents an executable context such as a [Worker],
 /// or a [SharedWorker]. [Window] clients are represented by the more-specific
 /// [WindowClient]. You can get `Client`/`WindowClient` objects from methods
@@ -468,6 +478,8 @@ extension type ServiceWorkerGlobalScope._(JSObject _)
 /// API documentation sourced from
 /// [MDN Web Docs](https://developer.mozilla.org/en-US/docs/Web/API/Client).
 extension type Client._(JSObject _) implements JSObject {
+  /// @AvailableInWorkers("service")
+  ///
   /// The **`postMessage()`** method of the
   /// [Client] interface allows a service worker to send a message to a client
   /// (a [Window], [Worker], or [SharedWorker]). The
@@ -478,24 +490,34 @@ extension type Client._(JSObject _) implements JSObject {
     JSObject optionsOrTransfer,
   ]);
 
+  /// @AvailableInWorkers("service")
+  ///
   /// The **`url`** read-only property of the [Client]
   /// interface returns the URL of the current service worker client.
   external String get url;
 
+  /// @AvailableInWorkers("service")
+  ///
   /// The **`frameType`** read-only property of the [Client] interface indicates
   /// the type of browsing context of the current [Client]. This value can be
   /// one of `"auxiliary"`, `"top-level"`, `"nested"`, or `"none"`.
   external FrameType get frameType;
 
+  /// @AvailableInWorkers("service")
+  ///
   /// The **`id`** read-only property of the [Client] interface returns the
   /// universally unique identifier of the [Client] object.
   external String get id;
 
+  /// @AvailableInWorkers("service")
+  ///
   /// The **`type`** read-only property of the [Client]
   /// interface indicates the type of client the service worker is controlling.
   external ClientType get type;
 }
 
+/// @AvailableInWorkers("service")
+///
 /// The `WindowClient` interface of the
 /// [ServiceWorker API](https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API)
 /// represents the scope of a service worker client that is a document in a
@@ -508,30 +530,40 @@ extension type Client._(JSObject _) implements JSObject {
 /// API documentation sourced from
 /// [MDN Web Docs](https://developer.mozilla.org/en-US/docs/Web/API/WindowClient).
 extension type WindowClient._(JSObject _) implements Client, JSObject {
+  /// @AvailableInWorkers("service")
+  ///
   /// The **`focus()`** method of the [WindowClient]
   /// interface gives user input focus to the current client and returns a
   /// `Promise` that resolves to the existing
   /// [WindowClient].
   external JSPromise<WindowClient> focus();
 
+  /// @AvailableInWorkers("service")
+  ///
   /// The **`navigate()`** method of the [WindowClient]
   /// interface loads a specified URL into a controlled client page then returns
   /// a
   /// `Promise` that resolves to the existing [WindowClient].
   external JSPromise<WindowClient?> navigate(String url);
 
+  /// @AvailableInWorkers("service")
+  ///
   /// The **`visibilityState`** read-only property of the
   /// [WindowClient] interface indicates the visibility of the current client.
   /// This value can be one of `"hidden"`, `"visible"`, or
   /// `"prerender"`.
   external DocumentVisibilityState get visibilityState;
 
+  /// @AvailableInWorkers("service")
+  ///
   /// The **`focused`** read-only property of the
   /// [WindowClient] interface is a boolean value that indicates whether
   /// the current client has focus.
   external bool get focused;
 }
 
+/// @AvailableInWorkers("service")
+///
 /// The `Clients` interface provides access to [Client] objects. Access it via
 /// `[ServiceWorkerGlobalScope].clients` within a
 /// [service worker](https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API).
@@ -541,11 +573,15 @@ extension type WindowClient._(JSObject _) implements Client, JSObject {
 /// API documentation sourced from
 /// [MDN Web Docs](https://developer.mozilla.org/en-US/docs/Web/API/Clients).
 extension type Clients._(JSObject _) implements JSObject {
+  /// @AvailableInWorkers("service")
+  ///
   /// The **`get()`** method of the
   /// [Clients] interface gets a service worker client matching a given
   /// `id` and returns it in a `Promise`.
   external JSPromise<Client?> get(String id);
 
+  /// @AvailableInWorkers("service")
+  ///
   /// The **`matchAll()`** method of the [Clients]
   /// interface returns a `Promise` for a list of service worker
   /// [Client] objects. Include the `options` parameter to return all service
@@ -557,6 +593,8 @@ extension type Clients._(JSObject _) implements JSObject {
   /// service worker.
   external JSPromise<JSArray<Client>> matchAll([ClientQueryOptions options]);
 
+  /// @AvailableInWorkers("service")
+  ///
   /// The **`openWindow()`** method of the [Clients]
   /// interface creates a new top level browsing context and loads a given URL.
   /// If the calling
@@ -577,6 +615,8 @@ extension type Clients._(JSObject _) implements JSObject {
   /// Chrome for Windows.
   external JSPromise<WindowClient?> openWindow(String url);
 
+  /// @AvailableInWorkers("service")
+  ///
   /// The **`claim()`** method of the [Clients] interface allows an active
   /// service worker to set itself as the [ServiceWorkerContainer.controller]
   /// for all clients within its [ServiceWorkerRegistration.scope].
@@ -604,6 +644,8 @@ extension type ClientQueryOptions._(JSObject _) implements JSObject {
   external set type(ClientType value);
 }
 
+/// @AvailableInWorkers("service")
+///
 /// The **`ExtendableEvent`** interface extends the lifetime of the
 /// [`install`](https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerGlobalScope/install_event)
 /// and
@@ -635,6 +677,8 @@ extension type ExtendableEvent._(JSObject _) implements Event, JSObject {
     ExtendableEventInit eventInitDict,
   ]);
 
+  /// @AvailableInWorkers("service")
+  ///
   /// The **`ExtendableEvent.waitUntil()`**
   /// method tells the event dispatcher that work is ongoing. It can also be
   /// used to detect
@@ -680,6 +724,8 @@ extension type ExtendableEventInit._(JSObject _)
   });
 }
 
+/// @AvailableInWorkers("service")
+///
 /// This is the event type for `fetch` events dispatched on the
 /// [ServiceWorkerGlobalScope]. It contains information about the fetch,
 /// including the request and how the receiver will treat the response. It
@@ -696,6 +742,8 @@ extension type FetchEvent._(JSObject _) implements ExtendableEvent, JSObject {
     FetchEventInit eventInitDict,
   );
 
+  /// @AvailableInWorkers("service")
+  ///
   /// The **`respondWith()`** method of
   /// [FetchEvent] prevents the browser's default fetch handling, and
   /// allows you to provide a promise for a [Response] yourself.
@@ -761,6 +809,8 @@ extension type FetchEvent._(JSObject _) implements ExtendableEvent, JSObject {
   /// user-visible URL.
   external void respondWith(JSPromise<Response> r);
 
+  /// @AvailableInWorkers("service")
+  ///
   /// The **`request`** read-only property of the
   /// [FetchEvent] interface returns the [Request] that triggered
   /// the event handler.
@@ -771,6 +821,8 @@ extension type FetchEvent._(JSObject _) implements ExtendableEvent, JSObject {
   /// contain a request (see [FetchEvent.FetchEvent].)
   external Request get request;
 
+  /// @AvailableInWorkers("service")
+  ///
   /// The **`preloadResponse`** read-only property of the [FetchEvent] interface
   /// returns a `Promise` that resolves to the navigation preload [Response] if
   /// [navigation preload](https://developer.mozilla.org/en-US/docs/Web/API/NavigationPreloadManager)
@@ -786,6 +838,8 @@ extension type FetchEvent._(JSObject _) implements ExtendableEvent, JSObject {
   /// boot.
   external JSPromise<JSAny?> get preloadResponse;
 
+  /// @AvailableInWorkers("service")
+  ///
   /// The **`clientId`** read-only property of the
   /// [FetchEvent] interface returns the id of the [Client] that the
   /// current service worker is controlling.
@@ -794,6 +848,8 @@ extension type FetchEvent._(JSObject _) implements ExtendableEvent, JSObject {
   /// associated client.
   external String get clientId;
 
+  /// @AvailableInWorkers("service")
+  ///
   /// The **`resultingClientId`** read-only property of the
   /// [FetchEvent] interface is the [Client.id] of the
   /// [Client] that replaces the previous client during a page
@@ -808,6 +864,8 @@ extension type FetchEvent._(JSObject _) implements ExtendableEvent, JSObject {
   /// `report`, `resultingClientId` will be an empty string.
   external String get resultingClientId;
 
+  /// @AvailableInWorkers("service")
+  ///
   /// The **`replacesClientId`** read-only property of the
   /// [FetchEvent] interface is the [Client.id] of the
   /// [Client] that is being replaced during a page navigation.
@@ -826,6 +884,8 @@ extension type FetchEvent._(JSObject _) implements ExtendableEvent, JSObject {
   /// imminently be replaced, right before a navigation.
   external String get replacesClientId;
 
+  /// @AvailableInWorkers("service")
+  ///
   /// The **`handled`** property of the [FetchEvent] interface returns a promise
   /// indicating if the event has been handled by the fetch algorithm or not.
   /// This property allows executing code after the browser has consumed a
@@ -861,6 +921,8 @@ extension type FetchEventInit._(JSObject _)
   external set handled(JSPromise<JSAny?> value);
 }
 
+/// @AvailableInWorkers("service")
+///
 /// The **`ExtendableMessageEvent`** interface of the
 /// [Service Worker API](https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API)
 /// represents the event object of a [ServiceWorkerGlobalScope.message_event]
@@ -881,27 +943,37 @@ extension type ExtendableMessageEvent._(JSObject _)
     ExtendableMessageEventInit eventInitDict,
   ]);
 
+  /// @AvailableInWorkers("service")
+  ///
   /// The **`data`** read-only property of the
   /// [ExtendableMessageEvent] interface returns the event's data. It can be any
   /// data type.
   external JSAny? get data;
 
+  /// @AvailableInWorkers("service")
+  ///
   /// The **`origin`** read-only property of the
   /// [ExtendableMessageEvent] interface returns the origin of the
   /// [Client] that sent the message.
   external String get origin;
 
+  /// @AvailableInWorkers("service")
+  ///
   /// The **`lastEventID`** read-only property of the
   /// [ExtendableMessageEvent] interface represents, in
   /// [server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events),
   /// the last event ID of the event source. This is an empty string.
   external String get lastEventId;
 
+  /// @AvailableInWorkers("service")
+  ///
   /// The **`source`** read-only property of the
   /// [ExtendableMessageEvent] interface returns a reference to the
   /// [Client] object from which the message was sent.
   external JSObject? get source;
 
+  /// @AvailableInWorkers("service")
+  ///
   /// The **`ports`** read-only property of the
   /// [ExtendableMessageEvent] interface returns the array containing the
   /// [MessagePort] objects representing the ports of the associated message
@@ -1105,7 +1177,8 @@ extension type CacheQueryOptions._(JSObject _) implements JSObject {
 /// Use [CacheStorage.match] to check if a given [Request] is a key in any of
 /// the [Cache] objects that the `CacheStorage` object tracks.
 ///
-/// You can access `CacheStorage` through the global [caches] property.
+/// You can access `CacheStorage` through the [Window.caches] property in
+/// windows or through the [WorkerGlobalScope.caches] property in workers.
 ///
 /// > **Note:** `CacheStorage` always rejects with a `SecurityError` on
 /// > untrusted origins (i.e. those that aren't using HTTPS, although this
@@ -1130,8 +1203,8 @@ extension type CacheStorage._(JSObject _) implements JSObject {
   /// This method returns a `Promise` for a [Response], or a `Promise` which
   /// resolves to `undefined` if no match is found.
   ///
-  /// You can access `CacheStorage` through the global
-  /// [caches] property.
+  /// You can access `CacheStorage` through the [Window.caches] property in
+  /// windows or through the [WorkerGlobalScope.caches] property in workers.
   ///
   /// `Cache` objects are searched in creation order.
   ///
@@ -1147,15 +1220,16 @@ extension type CacheStorage._(JSObject _) implements JSObject {
   /// interface returns a `Promise` that resolves to `true` if a
   /// [Cache] object matches the `cacheName`.
   ///
-  /// You can access `CacheStorage` through the global [caches] property.
+  /// You can access `CacheStorage` through the [Window.caches] property in
+  /// windows or through the [WorkerGlobalScope.caches] property in workers.
   external JSPromise<JSBoolean> has(String cacheName);
 
   /// The **`open()`** method of the
   /// [CacheStorage] interface returns a `Promise` that resolves to
   /// the [Cache] object matching the `cacheName`.
   ///
-  /// You can access `CacheStorage` through the global
-  /// [caches] property.
+  /// You can access `CacheStorage` through the [Window.caches] property in
+  /// windows or through the [WorkerGlobalScope.caches] property in workers.
   ///
   /// > **Note:** If the specified [Cache] does not exist, a new
   /// > cache is created with that `cacheName` and a `Promise` that
@@ -1167,7 +1241,8 @@ extension type CacheStorage._(JSObject _) implements JSObject {
   /// object and returns a `Promise` that resolves to `true`.
   /// If no [Cache] object is found, it resolves to `false`.
   ///
-  /// You can access `CacheStorage` through the global [caches] property.
+  /// You can access `CacheStorage` through the [Window.caches] property in
+  /// windows or through the [WorkerGlobalScope.caches] property in workers.
   external JSPromise<JSBoolean> delete(String cacheName);
 
   /// The **`keys()`** method of the [CacheStorage] interface returns a
@@ -1176,7 +1251,8 @@ extension type CacheStorage._(JSObject _) implements JSObject {
   /// in the order they were created.
   /// Use this method to iterate over a list of all [Cache] objects.
   ///
-  /// You can access `CacheStorage` through the global [caches] property.
+  /// You can access `CacheStorage` through the [Window.caches] property in
+  /// windows or through the [WorkerGlobalScope.caches] property in workers.
   external JSPromise<JSArray<JSString>> keys();
 }
 extension type MultiCacheQueryOptions._(JSObject _)
diff --git a/lib/src/dom/speech_api.dart b/lib/src/dom/speech_api.dart
index 97bd689d..920b58ce 100644
--- a/lib/src/dom/speech_api.dart
+++ b/lib/src/dom/speech_api.dart
@@ -88,10 +88,10 @@ extension type SpeechRecognition._(JSObject _)
 
   /// The **`interimResults`** property of the
   /// [SpeechRecognition] interface controls whether interim results should be
-  /// returned (`true`) or not (`false`.) Interim results are results
+  /// returned (`true`) or not (`false`). Interim results are results
   /// that are not yet final (e.g. the [SpeechRecognitionResult.isFinal]
   /// property
-  /// is `false`.)
+  /// is `false`).
   ///
   /// The default value for **`interimResults`** is `false`.
   external bool get interimResults;
diff --git a/lib/src/dom/streams.dart b/lib/src/dom/streams.dart
index 16f5df3a..7bd76783 100644
--- a/lib/src/dom/streams.dart
+++ b/lib/src/dom/streams.dart
@@ -286,8 +286,8 @@ extension type ReadableStreamReadResult._(JSObject _) implements JSObject {
 ///
 /// Note that the methods and properties are similar to those for the default
 /// reader ([ReadableStreamDefaultReader]).
-/// The `read()` method differs in that it provide a view into which data should
-/// be written.
+/// The `read()` method differs in that it provides a view into which data
+/// should be written.
 ///
 /// ---
 ///
diff --git a/lib/src/dom/trusted_types.dart b/lib/src/dom/trusted_types.dart
index 3668ed22..b427b74a 100644
--- a/lib/src/dom/trusted_types.dart
+++ b/lib/src/dom/trusted_types.dart
@@ -23,7 +23,7 @@ typedef CreateScriptURLCallback = JSFunction;
 /// that will render it as HTML. These objects are created via
 /// [TrustedTypePolicy.createHTML] and therefore have no constructor.
 ///
-/// The value of a **TrustedHTML** object is set when the object is created and
+/// The value of a `TrustedHTML` object is set when the object is created and
 /// cannot be changed by JavaScript as there is no setter exposed.
 ///
 /// ---
@@ -61,7 +61,7 @@ extension type TrustedScript._(JSObject _) implements JSObject {
 /// that will parse it as a URL of an external script. These objects are created
 /// via [TrustedTypePolicy.createScriptURL] and therefore have no constructor.
 ///
-/// The value of a **TrustedScriptURL** object is set when the object is created
+/// The value of a `TrustedScriptURL` object is set when the object is created
 /// and cannot be changed by JavaScript as there is no setter exposed.
 ///
 /// ---
@@ -178,7 +178,7 @@ extension type TrustedTypePolicyFactory._(JSObject _) implements JSObject {
 }
 
 /// The **`TrustedTypePolicy`** interface of the [Trusted Types API] defines a
-/// group of functions which create [TrustedType] objects.
+/// group of functions which create `TrustedType` objects.
 ///
 /// A `TrustedTypePolicy` object is created by
 /// [TrustedTypePolicyFactory.createPolicy] to define a policy for enforcing
diff --git a/lib/src/dom/uievents.dart b/lib/src/dom/uievents.dart
index 1fef1e4f..7f31b763 100644
--- a/lib/src/dom/uievents.dart
+++ b/lib/src/dom/uievents.dart
@@ -116,8 +116,8 @@ extension type FocusEvent._(JSObject _) implements UIEvent, JSObject {
     FocusEventInit eventInitDict,
   ]);
 
-  /// The **`FocusEvent.relatedTarget`** read-only property is the
-  /// secondary target, depending on the type of event:
+  /// The **`relatedTarget`** read-only property of the [FocusEvent] interface
+  /// is the secondary target, depending on the type of event:
   ///
   /// <table class="no-markdown">
   ///   <thead>
@@ -131,9 +131,7 @@ extension type FocusEvent._(JSObject _) implements UIEvent, JSObject {
   ///     <tr>
   ///       <td>[Element.blur_event]</td>
   ///       <td>The [EventTarget] losing focus</td>
-  ///       <td>
-  /// The [EventTarget] receiving focus (if any).
-  ///       </td>
+  ///       <td>The [EventTarget] receiving focus (if any).</td>
   ///     </tr>
   ///     <tr>
   ///       <td>[Element.focus_event]</td>
@@ -155,9 +153,9 @@ extension type FocusEvent._(JSObject _) implements UIEvent, JSObject {
   ///
   /// Note that [many elements can't have
   /// focus](https://stackoverflow.com/questions/42764494/blur-event-relatedtarget-returns-null/42764495),
-  /// which is a common reason for `relatedTarget` to be
-  /// `null`. `relatedTarget` may also be set to `null` for
-  /// security reasons, like when tabbing in or out of a page.
+  /// which is a common reason for `relatedTarget` to be `null`. `relatedTarget`
+  /// may also be set to `null` for security reasons, like when tabbing in or
+  /// out of a page.
   ///
   /// [MouseEvent.relatedTarget] is a similar property for mouse events.
   external EventTarget? get relatedTarget;
@@ -744,8 +742,8 @@ extension type InputEvent._(JSObject _) implements UIEvent, JSObject {
   ]);
 
   /// The **`getTargetRanges()`** method of the [InputEvent] interface returns
-  /// an array of static ranges that will be affected by a change to the DOM if
-  /// the input event is not canceled.
+  /// an array of [StaticRange] objects that will be affected by a change to the
+  /// DOM if the input event is not canceled.
   ///
   /// This allows web apps to override text edit behavior before the browser
   /// modifies the DOM tree, and provides more control over input events to
diff --git a/lib/src/dom/webauthn.dart b/lib/src/dom/webauthn.dart
index 1bbee1d8..948e1d9e 100644
--- a/lib/src/dom/webauthn.dart
+++ b/lib/src/dom/webauthn.dart
@@ -321,6 +321,17 @@ extension type PublicKeyCredentialParameters._(JSObject _) implements JSObject {
   external COSEAlgorithmIdentifier get alg;
   external set alg(COSEAlgorithmIdentifier value);
 }
+
+/// The **`PublicKeyCredentialCreationOptions`** dictionary represents the
+/// object passed to [CredentialsContainer.create] as the value of the
+/// `publicKey` option: that is, when using `create()` to create a public key
+/// credential using the
+/// [Web Authentication API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Authentication_API).
+///
+/// ---
+///
+/// API documentation sourced from
+/// [MDN Web Docs](https://developer.mozilla.org/en-US/docs/Web/API/PublicKeyCredentialCreationOptions).
 extension type PublicKeyCredentialCreationOptions._(JSObject _)
     implements JSObject {
   external factory PublicKeyCredentialCreationOptions({
diff --git a/lib/src/dom/webcodecs.dart b/lib/src/dom/webcodecs.dart
index dc222a04..55080a8c 100644
--- a/lib/src/dom/webcodecs.dart
+++ b/lib/src/dom/webcodecs.dart
@@ -36,6 +36,8 @@ typedef VideoColorPrimaries = String;
 typedef VideoTransferCharacteristics = String;
 typedef VideoMatrixCoefficients = String;
 
+/// @AvailableInWorkers("window_and_dedicated")
+///
 /// The **`VideoDecoder`** interface of the [WebCodecs API] decodes chunks of
 /// video.
 ///
@@ -49,31 +51,45 @@ extension type VideoDecoder._(JSObject _) implements EventTarget, JSObject {
   external static JSPromise<VideoDecoderSupport> isConfigSupported(
       VideoDecoderConfig config);
 
+  /// @AvailableInWorkers("window_and_dedicated")
+  ///
   /// The **`configure()`** method of the [VideoDecoder] interface enqueues a
   /// control message to configure the video decoder for decoding chunks.
   external void configure(VideoDecoderConfig config);
 
+  /// @AvailableInWorkers("window_and_dedicated")
+  ///
   /// The **`decode()`** method of the [VideoDecoder] interface enqueues a
   /// control message to decode a given chunk of video.
   external void decode(EncodedVideoChunk chunk);
 
+  /// @AvailableInWorkers("window_and_dedicated")
+  ///
   /// The **`flush()`** method of the [VideoDecoder] interface returns a Promise
   /// that resolves once all pending messages in the queue have been completed.
   external JSPromise<JSAny?> flush();
 
+  /// @AvailableInWorkers("window_and_dedicated")
+  ///
   /// The **`reset()`** method of the [VideoDecoder] interface resets all states
   /// including configuration, control messages in the control message queue,
   /// and all pending callbacks.
   external void reset();
 
+  /// @AvailableInWorkers("window_and_dedicated")
+  ///
   /// The **`close()`** method of the [VideoDecoder] interface ends all pending
   /// work and releases system resources.
   external void close();
 
+  /// @AvailableInWorkers("window_and_dedicated")
+  ///
   /// The **`state`** property of the [VideoDecoder] interface returns the
   /// current state of the underlying codec.
   external CodecState get state;
 
+  /// @AvailableInWorkers("window_and_dedicated")
+  ///
   /// The **`decodeQueueSize`** read-only property of the [VideoDecoder]
   /// interface returns the number of pending decode requests in the queue.
   external int get decodeQueueSize;
@@ -92,6 +108,8 @@ extension type VideoDecoderInit._(JSObject _) implements JSObject {
   external set error(WebCodecsErrorCallback value);
 }
 
+/// @AvailableInWorkers("window_and_dedicated")
+///
 /// The **`VideoEncoder`** interface of the [WebCodecs API] encodes [VideoFrame]
 /// objects into [EncodedVideoChunk]s.
 ///
@@ -105,6 +123,8 @@ extension type VideoEncoder._(JSObject _) implements EventTarget, JSObject {
   external static JSPromise<VideoEncoderSupport> isConfigSupported(
       VideoEncoderConfig config);
 
+  /// @AvailableInWorkers("window_and_dedicated")
+  ///
   /// The **`configure()`** method of the [VideoEncoder] interface changes the
   /// [VideoEncoder.state] of the encoder to "configured" and asynchronously
   /// prepares the encoder to accept [VideoEncoder]s for encoding with the
@@ -117,6 +137,8 @@ extension type VideoEncoder._(JSObject _) implements EventTarget, JSObject {
   /// configuration will not be applied until all previous tasks have completed.
   external void configure(VideoEncoderConfig config);
 
+  /// @AvailableInWorkers("window_and_dedicated")
+  ///
   /// The **`encode()`** method of the [VideoEncoder] interface asynchronously
   /// encodes a [VideoFrame].
   /// Encoded data ([EncodedVideoChunk]) or an error will eventually be returned
@@ -126,10 +148,14 @@ extension type VideoEncoder._(JSObject _) implements EventTarget, JSObject {
     VideoEncoderEncodeOptions options,
   ]);
 
+  /// @AvailableInWorkers("window_and_dedicated")
+  ///
   /// The **`flush()`** method of the [VideoEncoder] interface forces all
   /// pending encodes to complete.
   external JSPromise<JSAny?> flush();
 
+  /// @AvailableInWorkers("window_and_dedicated")
+  ///
   /// The **`reset()`** method of the [VideoEncoder] interface synchronously
   /// cancels all pending encodes and callbacks, frees all underlying resources
   /// and sets the [VideoEncoder.state] to "unconfigured".
@@ -141,14 +167,20 @@ extension type VideoEncoder._(JSObject _) implements EventTarget, JSObject {
   /// > [VideoEncoder.reset].
   external void reset();
 
+  /// @AvailableInWorkers("window_and_dedicated")
+  ///
   /// The **`close()`** method of the [VideoEncoder] interface ends all pending
   /// work and releases system resources.
   external void close();
 
+  /// @AvailableInWorkers("window_and_dedicated")
+  ///
   /// The **`state`** read-only property of the [VideoEncoder] interface returns
   /// the current state of the underlying codec.
   external CodecState get state;
 
+  /// @AvailableInWorkers("window_and_dedicated")
+  ///
   /// The **`encodeQueueSize`** read-only property of the [VideoEncoder]
   /// interface returns the number of pending encode requests in the queue.
   external int get encodeQueueSize;
@@ -294,6 +326,8 @@ extension type VideoEncoderEncodeOptions._(JSObject _) implements JSObject {
   external set vp9(VideoEncoderEncodeOptionsForVp9 value);
 }
 
+/// @AvailableInWorkers("window_and_dedicated")
+///
 /// The **`EncodedVideoChunk`** interface of the [WebCodecs API] represents a
 /// chunk of encoded video data.
 ///
@@ -304,24 +338,34 @@ extension type VideoEncoderEncodeOptions._(JSObject _) implements JSObject {
 extension type EncodedVideoChunk._(JSObject _) implements JSObject {
   external factory EncodedVideoChunk(EncodedVideoChunkInit init);
 
+  /// @AvailableInWorkers("window_and_dedicated")
+  ///
   /// The **`copyTo()`** method of the [EncodedVideoChunk] interface copies the
   /// encoded chunk of video data.
   external void copyTo(AllowSharedBufferSource destination);
 
+  /// @AvailableInWorkers("window_and_dedicated")
+  ///
   /// The **`type`** read-only property of the [EncodedVideoChunk] interface
   /// returns a value indicating whether the video chunk is a key chunk, which
   /// does not rely on other frames for decoding.
   external EncodedVideoChunkType get type;
 
+  /// @AvailableInWorkers("window_and_dedicated")
+  ///
   /// The **`timestamp`** read-only property of the [EncodedVideoChunk]
   /// interface returns an integer indicating the timestamp of the video in
   /// microseconds.
   external int get timestamp;
 
+  /// @AvailableInWorkers("window_and_dedicated")
+  ///
   /// The **`duration`** read-only property of the [EncodedVideoChunk] interface
   /// returns an integer indicating the duration of the video in microseconds.
   external int? get duration;
 
+  /// @AvailableInWorkers("window_and_dedicated")
+  ///
   /// The **`byteLength`** read-only property of the [EncodedVideoChunk]
   /// interface returns the length in bytes of the encoded video data.
   external int get byteLength;
@@ -347,6 +391,8 @@ extension type EncodedVideoChunkInit._(JSObject _) implements JSObject {
   external set transfer(JSArray<JSArrayBuffer> value);
 }
 
+/// @AvailableInWorkers("window_and_dedicated")
+///
 /// The **`VideoFrame`** interface of the
 /// [Web Codecs API](https://developer.mozilla.org/en-US/docs/Web/API/WebCodecs_API)
 /// represents a frame of a video.
@@ -364,11 +410,15 @@ extension type VideoFrame._(JSObject _) implements JSObject {
     JSObject init,
   ]);
 
+  /// @AvailableInWorkers("window_and_dedicated")
+  ///
   /// The **`allocationSize()`** method of the [VideoFrame] interface returns
   /// the number of bytes required to hold the video as filtered by options
   /// passed into the method.
   external int allocationSize([VideoFrameCopyToOptions options]);
 
+  /// @AvailableInWorkers("window_and_dedicated")
+  ///
   /// The **`copyTo()`** method of the [VideoFrame] interface copies the
   /// contents of the `VideoFrame` to an `ArrayBuffer`.
   external JSPromise<JSArray<PlaneLayout>> copyTo(
@@ -376,54 +426,78 @@ extension type VideoFrame._(JSObject _) implements JSObject {
     VideoFrameCopyToOptions options,
   ]);
 
+  /// @AvailableInWorkers("window_and_dedicated")
+  ///
   /// The **`clone()`** method of the [VideoFrame] interface creates a new
   /// `VideoFrame` object referencing the same media resource as the original.
   external VideoFrame clone();
 
+  /// @AvailableInWorkers("window_and_dedicated")
+  ///
   /// The **`close()`** method of the [VideoFrame] interface clears all states
   /// and releases the reference to the media resource.
   external void close();
 
+  /// @AvailableInWorkers("window_and_dedicated")
+  ///
   /// The **`format`** property of the [VideoFrame] interface returns the pixel
   /// format of the `VideoFrame`.
   external VideoPixelFormat? get format;
 
+  /// @AvailableInWorkers("window_and_dedicated")
+  ///
   /// The **`codedWidth`** property of the [VideoFrame] interface returns the
   /// width of the `VideoFrame` in pixels, potentially including non-visible
   /// padding, and prior to considering potential ratio adjustments.
   external int get codedWidth;
 
+  /// @AvailableInWorkers("window_and_dedicated")
+  ///
   /// The **`codedHeight`** property of the [VideoFrame] interface returns the
   /// height of the VideoFrame in pixels, potentially including non-visible
   /// padding, and prior to considering potential ratio adjustments.
   external int get codedHeight;
 
+  /// @AvailableInWorkers("window_and_dedicated")
+  ///
   /// The **`codedRect`** property of the [VideoFrame] interface returns a
   /// [DOMRectReadOnly] with the width and height matching
   /// [VideoFrame.codedWidth] and [VideoFrame.codedHeight].
   external DOMRectReadOnly? get codedRect;
 
+  /// @AvailableInWorkers("window_and_dedicated")
+  ///
   /// The **`visibleRect`** property of the [VideoFrame] interface returns a
   /// [DOMRectReadOnly] describing the visible rectangle of pixels for this
   /// `VideoFrame`.
   external DOMRectReadOnly? get visibleRect;
 
+  /// @AvailableInWorkers("window_and_dedicated")
+  ///
   /// The **`displayWidth`** property of the [VideoFrame] interface returns the
   /// width of the `VideoFrame` after applying aspect ratio adjustments.
   external int get displayWidth;
 
+  /// @AvailableInWorkers("window_and_dedicated")
+  ///
   /// The **`displayHeight`** property of the [VideoFrame] interface returns the
   /// height of the `VideoFrame` after applying aspect ratio adjustments.
   external int get displayHeight;
 
+  /// @AvailableInWorkers("window_and_dedicated")
+  ///
   /// The **`duration`** property of the [VideoFrame] interface returns an
   /// integer indicating the duration of the video in microseconds.
   external int? get duration;
 
+  /// @AvailableInWorkers("window_and_dedicated")
+  ///
   /// The **`timestamp`** property of the [VideoFrame] interface returns an
   /// integer indicating the timestamp of the video in microseconds.
   external int get timestamp;
 
+  /// @AvailableInWorkers("window_and_dedicated")
+  ///
   /// The **`colorSpace`** property of the [VideoFrame] interface returns a
   /// [VideoColorSpace] object representing the color space of the video.
   external VideoColorSpace get colorSpace;
@@ -518,6 +592,8 @@ extension type PlaneLayout._(JSObject _) implements JSObject {
   external set stride(int value);
 }
 
+/// @AvailableInWorkers("window_and_dedicated")
+///
 /// The **`VideoColorSpace`** interface of the [WebCodecs API] represents the
 /// color space of a video.
 ///
@@ -528,24 +604,34 @@ extension type PlaneLayout._(JSObject _) implements JSObject {
 extension type VideoColorSpace._(JSObject _) implements JSObject {
   external factory VideoColorSpace([VideoColorSpaceInit init]);
 
+  /// @AvailableInWorkers("window_and_dedicated")
+  ///
   /// The **`toJSON()`** method of the [VideoColorSpace] interface is a
   /// _serializer_ that returns a JSON representation of the `VideoColorSpace`
   /// object.
   external VideoColorSpaceInit toJSON();
 
+  /// @AvailableInWorkers("window_and_dedicated")
+  ///
   /// The **`primaries`** read-only property of the [VideoColorSpace] interface
   /// returns the color  of the video.
   external VideoColorPrimaries? get primaries;
 
+  /// @AvailableInWorkers("window_and_dedicated")
+  ///
   /// The **`transfer`** read-only property of the [VideoColorSpace] interface
   /// returns the opto-electronic transfer characteristics of the video.
   external VideoTransferCharacteristics? get transfer;
 
+  /// @AvailableInWorkers("window_and_dedicated")
+  ///
   /// The **`matrix`** read-only property of the [VideoColorSpace] interface
   /// returns the matrix coefficient of the video. Matrix coefficients describe
   /// the relationship between sample component values and color coordinates.
   external VideoMatrixCoefficients? get matrix;
 
+  /// @AvailableInWorkers("window_and_dedicated")
+  ///
   /// The **`fullRange`** read-only property of the [VideoColorSpace] interface
   /// returns `true` if full-range color values are used.
   external bool? get fullRange;
diff --git a/lib/src/dom/webcryptoapi.dart b/lib/src/dom/webcryptoapi.dart
index 16fe22ed..db3fe2f8 100644
--- a/lib/src/dom/webcryptoapi.dart
+++ b/lib/src/dom/webcryptoapi.dart
@@ -25,10 +25,8 @@ typedef KeyFormat = String;
 /// It allows access to a cryptographically strong random number generator and
 /// to cryptographic primitives.
 ///
-/// The
-/// [Web Crypto API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Crypto_API)
-/// is accessed through the global [crypto_property] property, which is a
-/// `Crypto` object.
+/// The `Crypto` is available in windows using the [Window.crypto] property and
+/// in workers using the the [WorkerGlobalScope.crypto] property.
 ///
 /// ---
 ///
@@ -112,9 +110,12 @@ extension type CryptoKey._(JSObject _) implements JSObject {
 
 /// The **`SubtleCrypto`** interface of the
 /// [Web Crypto API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Crypto_API)
-/// provides a number of low-level cryptographic functions. Access to the
-/// features of `SubtleCrypto` is obtained through the [Crypto.subtle] property
-/// of the [Crypto] object you get from the [crypto_property] property.
+/// provides a number of low-level cryptographic functions.
+///
+/// An instance of `SubtleCrypto` is available as the[Crypto.subtle] property of
+/// the [Crypto] interface, which in turn is available in windows through the
+/// [Window.crypto] property and in workers through the
+/// [WorkerGlobalScope.crypto] property.
 ///
 /// > **Warning:** This API provides a number of low-level cryptographic
 /// > primitives. It's very easy to misuse them, and the pitfalls involved can
diff --git a/lib/src/dom/webrtc.dart b/lib/src/dom/webrtc.dart
index eb7212dd..09b58735 100644
--- a/lib/src/dom/webrtc.dart
+++ b/lib/src/dom/webrtc.dart
@@ -126,94 +126,81 @@ extension type RTCPeerConnection._(JSObject _)
   external static JSPromise<RTCCertificate> generateCertificate(
       AlgorithmIdentifier keygenAlgorithm);
 
-  /// The **`RTCPeerConnection.setIdentityProvider()`** method sets
-  /// the Identity Provider (IdP) to the triplet given in parameter: its name,
-  /// the protocol
-  /// used to communicate with it (optional) and an optional username. The IdP
-  /// will be used
-  /// only when an assertion is needed.
-  ///
-  /// If the [RTCPeerConnection.signalingState] is set to
-  /// `"closed"`, an `InvalidStateError` is raised.
+  /// The **`setIdentityProvider()`** method of the [RTCPeerConnection]
+  /// interface sets the Identity Provider (IdP) to the triplet given in
+  /// parameter: its name, the protocol used to communicate with it (optional)
+  /// and an optional username.
+  /// The IdP will be used only when an assertion is needed.
+  ///
+  /// If the [RTCPeerConnection.signalingState] is set to `"closed"`, an
+  /// `InvalidStateError` is raised.
   external void setIdentityProvider(
     String provider, [
     RTCIdentityProviderOptions options,
   ]);
 
-  /// The **`RTCPeerConnection.getIdentityAssertion()`** method
-  /// initiates the gathering of an identity assertion. This has an effect only
-  /// if the
-  /// [RTCPeerConnection.signalingState] is not
+  /// The **`getIdentityAssertion()`** method of the [RTCPeerConnection]
+  /// interface initiates the gathering of an identity assertion.
+  /// This has an effect only if the [RTCPeerConnection.signalingState] is not
   /// `"closed"`.
   ///
-  /// The method returns a JavaScript `Promise` which resolves to an
-  /// identity assertion encoded as a string.
+  /// The method returns a JavaScript `Promise` which resolves to an identity
+  /// assertion encoded as a string.
   ///
   /// It is not expected for the application dealing with the
-  /// `RTCPeerConnection`:
-  /// this is automatically done; an explicit call only allows to anticipate the
-  /// need.
+  /// `RTCPeerConnection`: this is automatically done; an explicit call only
+  /// allows to anticipate the need.
   external JSPromise<JSString> getIdentityAssertion();
 
-  /// The **`createOffer()`** method
-  /// of the [RTCPeerConnection] interface
-  /// initiates the creation of an  offer
-  /// for the purpose of starting a new WebRTC connection to a remote peer.
-  /// The SDP offer includes information
-  /// about any [MediaStreamTrack] objects
+  /// The **`createOffer()`** method of the [RTCPeerConnection] interface
+  /// initiates the creation of an  offer for the purpose of starting a new
+  /// WebRTC connection to a remote peer.
+  ///
+  /// The SDP offer includes information about any [MediaStreamTrack] objects
   /// already attached to the WebRTC session, codec, and options supported by
-  /// the browser,
-  /// and any candidates already gathered by the  agent,
-  /// for the purpose of being sent over the signaling channel
-  /// to a potential peer
-  /// to request a connection
-  /// or to update the configuration of an existing connection.
+  /// the browser, and any candidates already gathered by the  agent, for the
+  /// purpose of being sent over the signaling channel to a potential peer to
+  /// request a connection or to update the configuration of an existing
+  /// connection.
   ///
   /// The return value is a `Promise` which, when the offer has been created, is
   /// resolved with a [RTCSessionDescription] object containing the
-  /// newly-created
-  /// offer.
+  /// newly-created offer.
   external JSPromise<RTCSessionDescriptionInit?> createOffer([
     JSObject optionsOrSuccessCallback,
     RTCPeerConnectionErrorCallback failureCallback,
     RTCOfferOptions options,
   ]);
 
-  /// The **`createAnswer()`** method on the
-  /// [RTCPeerConnection] interface creates an  answer to an
-  /// offer received from a remote peer during the offer/answer negotiation of a
-  /// WebRTC
-  /// connection. The answer contains information about any media already
-  /// attached to the
-  /// session, codecs and options supported by the browser, and any
-  /// candidates already gathered. The answer is delivered to the returned
-  /// `Promise`, and should then be sent to the source of the offer to continue
-  /// the negotiation process.
+  /// The **`createAnswer()`** method of the [RTCPeerConnection] interface
+  /// creates an  answer to an offer received from a remote peer during the
+  /// offer/answer negotiation of a WebRTC connection.
+  ///
+  /// The answer contains information about any media already attached to the
+  /// session, codecs and options supported by the browser, and any  candidates
+  /// already gathered.
+  /// The answer is delivered to the returned `Promise`, and should then be sent
+  /// to the source of the offer to continue the negotiation process.
   external JSPromise<RTCSessionDescriptionInit?> createAnswer([
     JSObject optionsOrSuccessCallback,
     RTCPeerConnectionErrorCallback failureCallback,
   ]);
 
-  /// The [RTCPeerConnection] method
-  /// [RTCPeerConnection.setLocalDescription] changes
-  /// the local description associated with the connection. This description
-  /// specifies the
-  /// properties of the local end of the connection, including the media format.
+  /// The **`setLocalDescription()`** method of the [RTCPeerConnection]
+  /// interface changes the local description associated with the connection.
+  /// This description specifies the properties of the local end of the
+  /// connection, including the media format.
   /// The method takes a single parameter—the session description—and it returns
-  /// a
-  /// `Promise` which is fulfilled once the description has been changed,
+  /// a `Promise` which is fulfilled once the description has been changed,
   /// asynchronously.
   ///
   /// If `setLocalDescription()` is called while a connection is already in
-  /// place,
-  /// it means renegotiation is underway (possibly to adapt to changing network
-  /// conditions).
+  /// place, it means renegotiation is underway (possibly to adapt to changing
+  /// network conditions).
   /// Because descriptions will be exchanged until the two peers agree on a
-  /// configuration, the
-  /// description submitted by calling `setLocalDescription()` does not
-  /// immediately
-  /// take effect. Instead, the current connection configuration remains in
-  /// place until
+  /// configuration, the description submitted by calling
+  /// `setLocalDescription()` does not immediately take effect.
+  /// Instead, the current connection configuration remains in place until
   /// negotiation is complete. Only then does the agreed-upon configuration take
   /// effect.
   external JSPromise<JSAny?> setLocalDescription([
@@ -222,37 +209,37 @@ extension type RTCPeerConnection._(JSObject _)
     RTCPeerConnectionErrorCallback failureCallback,
   ]);
 
-  /// The [RTCPeerConnection]
-  /// method **`setRemoteDescription()`** sets the specified
-  /// session description as the remote peer's current offer or answer. The
-  /// description
-  /// specifies the properties of the remote end of the connection, including
-  /// the media
-  /// format. The method takes a single parameter—the session description—and it
-  /// returns a `Promise` which is fulfilled once the description has been
-  /// changed, asynchronously.
+  /// The **`setRemoteDescription()`** method of the [RTCPeerConnection]
+  /// interface sets the specified session description as the remote peer's
+  /// current offer or answer.
+  /// The description specifies the properties of the remote end of the
+  /// connection, including the media format.
+  /// The method takes a single parameter—the session description—and it returns
+  /// a `Promise` which is fulfilled once the description has been changed,
+  /// asynchronously.
   ///
   /// This is typically called after receiving an offer or answer from another
-  /// peer over the
-  /// signaling server. Keep in mind that if `setRemoteDescription()` is called
-  /// while a connection is already in place, it means renegotiation is underway
-  /// (possibly
-  /// to adapt to changing network conditions).
+  /// peer over the signaling server.
+  /// Keep in mind that if `setRemoteDescription()` is called while a connection
+  /// is already in place, it means renegotiation is underway (possibly to adapt
+  /// to changing network conditions).
   ///
   /// Because descriptions will be exchanged until the two peers agree on a
-  /// configuration,
-  /// the description submitted by calling `setRemoteDescription()` does not
-  /// immediately take effect. Instead, the current connection configuration
-  /// remains in
-  /// place until negotiation is complete. Only then does the agreed-upon
-  /// configuration take
-  /// effect.
+  /// configuration, the description submitted by calling
+  /// `setRemoteDescription()` does not immediately take effect.
+  /// Instead, the current connection configuration remains in place until
+  /// negotiation is complete.
+  /// Only then does the agreed-upon configuration take effect.
   external JSPromise<JSAny?> setRemoteDescription(
     RTCSessionDescriptionInit description, [
     VoidFunction successCallback,
     RTCPeerConnectionErrorCallback failureCallback,
   ]);
 
+  /// The **`addIceCandidate()`** method of the [RTCPeerConnection] interface
+  /// adds a new remote candidate to the connection's remote description, which
+  /// describes the state of the remote end of the connection.
+  ///
   /// When a website or app using [RTCPeerConnection] receives a new ICE
   /// candidate from the remote peer over its signaling channel, it delivers the
   /// newly-received candidate to the browser's  agent by calling
@@ -284,76 +271,66 @@ extension type RTCPeerConnection._(JSObject _)
     RTCPeerConnectionErrorCallback failureCallback,
   ]);
 
-  /// The [WebRTC](https://developer.mozilla.org/en-US/docs/Web/API/WebRTC_API)
-  /// API's
-  /// [RTCPeerConnection] interface offers the
-  /// **`restartIce()`** method to allow a web application to easily
-  /// request that  candidate gathering be redone on both ends of the
-  /// connection.
-  /// This simplifies the process by allowing the same method to be used
-  /// by either the caller or the receiver to trigger an ICE restart.
+  /// The **`restartIce()`** method of the [RTCPeerConnection] interface allows
+  /// a web application to request that  candidate gathering be redone on both
+  /// ends of the connection.
+  /// This simplifies the process by allowing the same method to be used by
+  /// either the caller or the receiver to trigger an ICE restart.
   ///
   /// After `restartIce()` returns, the offer returned by the next call to
-  /// [RTCPeerConnection.createOffer] is automatically
-  /// configured to trigger ICE restart on both the local peer (once the local
-  /// peer has been
-  /// set) and on the remote peer, once the offer is sent across your signaling
-  /// mechanism and
-  /// the remote peer has set its description as well.
+  /// [RTCPeerConnection.createOffer] is automatically configured to trigger ICE
+  /// restart on both the local peer (once the local peer has been set) and on
+  /// the remote peer, once the offer is sent across your signaling mechanism
+  /// and the remote peer has set its description as well.
   ///
   /// `restartIce()` causes the
-  /// [RTCPeerConnection.negotiationneeded_event] event to
-  /// be fired on the `RTCPeerConnection` to inform the application that it
-  /// should
-  /// perform negotiation using its signaling channel.
+  /// [RTCPeerConnection.negotiationneeded_event] event to be fired on the
+  /// `RTCPeerConnection` to inform the application that it should perform
+  /// negotiation using its signaling channel.
   ///
   /// If negotiation fails to complete—either due to rollback or because
-  /// incoming offers are
-  /// in the process of being negotiated—the [RTCPeerConnection] will remember
-  /// that you requested ICE restart. The next time the connection's
-  /// [RTCPeerConnection.signalingState] changes to
-  /// `stable`, the connection will fire the
+  /// incoming offers are in the process of being negotiated—the
+  /// [RTCPeerConnection] will remember that you requested ICE restart.
+  /// The next time the connection's [RTCPeerConnection.signalingState] changes
+  /// to `stable`, the connection will fire the
   /// [RTCPeerConnection.negotiationneeded_event] event.
   /// This process continues until an ICE restart has been successfully
   /// completed.
   external void restartIce();
 
-  /// The **`RTCPeerConnection.getConfiguration()`** method returns
-  /// an object which indicates the current configuration of
-  /// the [RTCPeerConnection] on which the method is called.
+  /// The **`getConfiguration()`** method of the [RTCPeerConnection] interface
+  /// returns an object which indicates the current configuration of the
+  /// [RTCPeerConnection] on which the method is called.
   ///
   /// The returned configuration is the last configuration applied via
   /// [RTCPeerConnection.setConfiguration], or if
   /// `setConfiguration()` hasn't been called, the configuration the
-  /// `RTCPeerConnection` was constructed with. The configuration includes a
-  /// list
-  /// of the ICE servers used by the connection, information about transport
-  /// policies, and
-  /// identity information.
+  /// `RTCPeerConnection` was constructed with.
+  /// The configuration includes a list of the ICE servers used by the
+  /// connection, information about transport policies, and identity
+  /// information.
   external RTCConfiguration getConfiguration();
 
-  /// The **`RTCPeerConnection.setConfiguration()`** method sets the
-  /// current configuration of the [RTCPeerConnection] based on the values
-  /// included in the specified object. This lets you change
-  /// the ICE servers used by the connection and which transport policies to
-  /// use.
+  /// The **`setConfiguration()`** method of the [RTCPeerConnection] interface
+  /// sets the current configuration of the connection based on the values
+  /// included in the specified object.
+  /// This lets you change the ICE servers used by the connection and which
+  /// transport policies to use.
   ///
   /// The most common use case for this method (and even then, probably not a
-  /// very common use
-  /// case) is to replace the set of ICE servers to be used. Two potential
-  /// scenarios in which
-  /// this might be done:
+  /// very common use case) is to replace the set of ICE servers to be used. Two
+  /// potential scenarios in which this might be done:
   ///
   /// - The [RTCPeerConnection] was instantiated without specifying any ICE
-  /// servers. If, for example, the [RTCPeerConnection.RTCPeerConnection]
-  /// constructor was called with no parameters, you would have to
-  /// then call `setConfiguration()` to add ICE servers before ICE negotiation
-  /// could begin.
+  ///   servers.
+  /// If, for example, the [RTCPeerConnection.RTCPeerConnection] constructor was
+  /// called with no parameters, you would have to then call
+  /// `setConfiguration()` to add ICE servers before ICE negotiation could
+  /// begin.
   /// - Renegotiation of the connection is needed, and a different set of ICE
-  ///   servers needs
-  /// to be used for some reason. Perhaps the user has moved into a new region,
-  /// so using new
-  /// regional ICE servers is necessary, for example.
+  ///   servers needs to be used for some reason.
+  /// Perhaps the user has moved into a new region, so using new regional ICE
+  /// servers is necessary, for example.
   /// In this situation, one might call `setConfiguration()` to switch to new
   /// regional ICE servers, then initiate an
   /// [ICE restart](https://developer.mozilla.org/en-US/docs/Web/API/WebRTC_API/Session_lifetime#ice_restart).
@@ -362,30 +339,32 @@ extension type RTCPeerConnection._(JSObject _)
   /// > once it's already been set.
   external void setConfiguration([RTCConfiguration configuration]);
 
-  /// The **`RTCPeerConnection.close()`** method closes the current
-  /// peer connection.
+  /// The **`close()`** method of the [RTCPeerConnection] interface closes the
+  /// current peer connection.
   external void close();
 
-  /// The [RTCPeerConnection] method **`getSenders()`** returns an array of
-  /// [RTCRtpSender] objects, each of which represents the RTP sender
-  /// responsible for transmitting one track's data.
+  /// The **`getSenders()`** method of the [RTCPeerConnection] interface returns
+  /// an array of [RTCRtpSender] objects, each of which represents the RTP
+  /// sender responsible for transmitting one track's data.
   /// A sender object provides methods and properties for examining and
   /// controlling the encoding and transmission of the track's data.
   external JSArray<RTCRtpSender> getSenders();
 
-  /// The **`RTCPeerConnection.getReceivers()`** method returns an array of
-  /// [RTCRtpReceiver] objects, each of which represents one RTP receiver.
+  /// The **`getReceivers()`** method of the [RTCPeerConnection] interface
+  /// returns an array of [RTCRtpReceiver] objects, each of which represents one
+  /// RTP receiver.
   /// Each RTP receiver manages the reception and decoding of data for a
   /// [MediaStreamTrack] on an [RTCPeerConnection].
   external JSArray<RTCRtpReceiver> getReceivers();
 
-  /// The [RTCPeerConnection] interface's **`getTransceivers()`** method returns
-  /// a list of the [RTCRtpTransceiver] objects being used to send and receive
-  /// data on the connection.
+  /// The **`getTransceivers()`** method of the [RTCPeerConnection] interface
+  /// returns a list of the [RTCRtpTransceiver] objects being used to send and
+  /// receive data on the connection.
   external JSArray<RTCRtpTransceiver> getTransceivers();
 
-  /// The [RTCPeerConnection] method **`addTrack()`** adds a new media track to
-  /// the set of tracks which will be transmitted to the other peer.
+  /// The **`addTrack()`** method of the [RTCPeerConnection] interface adds a
+  /// new media track to the set of tracks which will be transmitted to the
+  /// other peer.
   ///
   /// > **Note:** Adding a track to a connection triggers renegotiation by
   /// > firing a [RTCPeerConnection.negotiationneeded_event] event.
@@ -397,28 +376,24 @@ extension type RTCPeerConnection._(JSObject _)
     MediaStream streams,
   );
 
-  /// The
-  /// **`RTCPeerConnection.removeTrack()`** method tells the local
-  /// end of the connection to stop sending media from the specified track,
-  /// without actually
-  /// removing the corresponding [RTCRtpSender] from the list of senders as
-  /// reported by [RTCPeerConnection.getSenders]. If the track is
-  /// already stopped, or is not in the connection's senders list, this method
-  /// has no effect.
+  /// The **`removeTrack()`** method of the [RTCPeerConnection] interface tells
+  /// the local end of the connection to stop sending media from the specified
+  /// track, without actually removing the corresponding [RTCRtpSender] from the
+  /// list of senders as reported by [RTCPeerConnection.getSenders].
+  /// If the track is already stopped, or is not in the connection's senders
+  /// list, this method has no effect.
   ///
   /// If the connection has already been negotiated
-  /// ([RTCPeerConnection.signalingState] is set to
-  /// `"stable"`), it is marked as needing to be negotiated again; the remote
-  /// peer
-  /// won't experience the change until this negotiation occurs. A
-  /// [RTCPeerConnection.negotiationneeded_event] event is sent to the
-  /// [RTCPeerConnection] to
-  /// let the local end know this negotiation must occur.
+  /// ([RTCPeerConnection.signalingState] is set to `"stable"`), it is marked as
+  /// needing to be negotiated again; the remote peer won't experience the
+  /// change until this negotiation occurs.
+  /// A [RTCPeerConnection.negotiationneeded_event] event is sent to the
+  /// [RTCPeerConnection] to let the local end know this negotiation must occur.
   external void removeTrack(RTCRtpSender sender);
 
-  /// The [RTCPeerConnection] method **`addTransceiver()`** creates a new
-  /// [RTCRtpTransceiver] and adds it to the set of transceivers associated with
-  /// the `RTCPeerConnection`.
+  /// The **`addTransceiver()`** method of the [RTCPeerConnection] interface
+  /// creates a new [RTCRtpTransceiver] and adds it to the set of transceivers
+  /// associated with the `RTCPeerConnection`.
   /// Each transceiver represents a bidirectional stream, with both an
   /// [RTCRtpSender] and an [RTCRtpReceiver] associated with it.
   external RTCRtpTransceiver addTransceiver(
@@ -426,194 +401,184 @@ extension type RTCPeerConnection._(JSObject _)
     RTCRtpTransceiverInit init,
   ]);
 
-  /// The **`createDataChannel()`** method
-  /// on the [RTCPeerConnection] interface
-  /// creates a new channel linked with the remote peer,
-  /// over which any kind of data may be transmitted.
-  /// This can be useful for back-channel content,
-  /// such as images, file transfer, text chat, game update
-  /// packets, and so forth.
+  /// The **`createDataChannel()`** method of the [RTCPeerConnection] interface
+  /// creates a new channel linked with the remote peer, over which any kind of
+  /// data may be transmitted.
+  /// This can be useful for back-channel content, such as images, file
+  /// transfer, text chat, game update packets, and so forth.
   ///
   /// If the new data channel is the first one added to the connection,
-  /// renegotiation is
-  /// started by delivering a [RTCPeerConnection.negotiationneeded_event] event.
+  /// renegotiation is started by delivering a
+  /// [RTCPeerConnection.negotiationneeded_event] event.
   external RTCDataChannel createDataChannel(
     String label, [
     RTCDataChannelInit dataChannelDict,
   ]);
 
-  /// The [RTCPeerConnection] method
-  /// **`getStats()`** returns a promise which resolves with data
-  /// providing statistics about either the overall connection or about the
-  /// specified
-  /// [MediaStreamTrack].
+  /// The **`getStats()`** method of the [RTCPeerConnection] interface returns a
+  /// promise which resolves with data providing statistics about either the
+  /// overall connection or about the specified [MediaStreamTrack].
   external JSPromise<RTCStatsReport> getStats([MediaStreamTrack? selector]);
 
-  /// The read-only [RTCPeerConnection] property
-  /// **`peerIdentity`** returns a JavaScript `Promise`
-  /// that resolves to an [RTCIdentityAssertion] which contains a
-  /// string identifying the remote peer. Once this promise
-  /// resolves successfully, the resulting identity is the **target peer
-  /// identity** and cannot change for the duration of the connection.
+  /// The **`peerIdentity`** read-only property of the [RTCPeerConnection]
+  /// interface returns a JavaScript `Promise` that resolves to an
+  /// [RTCIdentityAssertion] which contains a string identifying the remote
+  /// peer.
+  /// Once this promise resolves successfully, the resulting identity is the
+  /// **target peer identity** and cannot change for the duration of the
+  /// connection.
   external JSPromise<JSObject> get peerIdentity;
   external String? get idpLoginUrl;
 
-  /// The read-only property **`RTCPeerConnection.localDescription`** returns an
-  /// [RTCSessionDescription] describing the session for the local end of the
-  /// connection.
+  /// The **`localDescription`** read-only property of the [RTCPeerConnection]
+  /// interface returns an [RTCSessionDescription] describing the session for
+  /// the local end of the connection.
   /// If it has not yet been set, this is `null`.
   external RTCSessionDescription? get localDescription;
 
-  /// The read-only property
-  /// **`RTCPeerConnection.currentLocalDescription`** returns an
-  /// [RTCSessionDescription] object describing the local end of the connection
-  /// as it was most recently successfully negotiated since the last time the
-  /// [RTCPeerConnection] finished negotiating and connecting to a remote peer.
+  /// The **`currentLocalDescription`** read-only property of the
+  /// [RTCPeerConnection] interface returns an [RTCSessionDescription] object
+  /// describing the local end of the connection as it was most recently
+  /// successfully negotiated since the last time the [RTCPeerConnection]
+  /// finished negotiating and connecting to a remote peer.
   /// Also included is a list of any ICE candidates that may already have been
-  /// generated by
-  /// the ICE agent since the offer or answer represented by the description was
-  /// first
-  /// instantiated.
+  /// generated by the ICE agent since the offer or answer represented by the
+  /// description was first instantiated.
   ///
   /// To change the `currentLocalDescription`, call
-  /// [RTCPeerConnection.setLocalDescription], which triggers a series of
-  /// events which leads to this value being set. For details on what exactly
-  /// happens and why
-  /// the change isn't necessarily instantaneous, see
+  /// [RTCPeerConnection.setLocalDescription], which triggers a series of events
+  /// which leads to this value being set.
+  /// For details on what exactly happens and why the change isn't necessarily
+  /// instantaneous, see
   /// [Pending and current descriptions](https://developer.mozilla.org/en-US/docs/Web/API/WebRTC_API/Connectivity#pending_and_current_descriptions)
   /// in the WebRTC Connectivity page.
   ///
   /// > **Note:** Unlike [RTCPeerConnection.localDescription], this value
-  /// > represents the
-  /// > actual current state of the local end of the connection;
-  /// > `localDescription`
-  /// > may specify a description which the connection is currently in the
-  /// > process of
-  /// > switching over to.
+  /// > represents the actual current state of the local end of the connection;
+  /// > `localDescription` may specify a description which the connection is
+  /// > currently in the process of switching over to.
   external RTCSessionDescription? get currentLocalDescription;
 
-  /// The read-only property
-  /// **`RTCPeerConnection.pendingLocalDescription`** returns an
-  /// [RTCSessionDescription] object describing a pending configuration change
-  /// for the local end of the connection. This does not describe the connection
-  /// as it
-  /// currently stands, but as it may exist in the near future. Use
-  /// [RTCPeerConnection.currentLocalDescription] or
+  /// The **`pendingLocalDescription`** read-only property of the
+  /// [RTCPeerConnection] interface returns an [RTCSessionDescription] object
+  /// describing a pending configuration change for the local end of the
+  /// connection.
+  ///
+  /// This does not describe the connection as it currently stands, but as it
+  /// may exist in the near future.
+  /// Use [RTCPeerConnection.currentLocalDescription] or
   /// [RTCPeerConnection.localDescription] to get the current state of the
-  /// endpoint. For details on the difference, see
+  /// endpoint.
+  /// For details on the difference, see
   /// [Pending and current descriptions](https://developer.mozilla.org/en-US/docs/Web/API/WebRTC_API/Connectivity#pending_and_current_descriptions)
   /// in the WebRTC Connectivity page.
   external RTCSessionDescription? get pendingLocalDescription;
 
-  /// The read-only property
-  /// **`RTCPeerConnection.remoteDescription`** returns a
-  /// [RTCSessionDescription] describing the session (which includes
-  /// configuration and media information) for the remote end of the connection.
-  /// If this
-  /// hasn't been set yet, this is `null`.
+  /// The **`remoteDescription`** read-only property of the [RTCPeerConnection]
+  /// interface returns a [RTCSessionDescription] describing the session (which
+  /// includes configuration and media information) for the remote end of the
+  /// connection.
+  /// If this hasn't been set yet, this is `null`.
   ///
   /// The returned value typically reflects a remote description which has been
-  /// received over
-  /// the signaling server (as either an offer or an answer) and then put into
-  /// effect by your
-  /// code calling [RTCPeerConnection.setRemoteDescription] in response.
+  /// received over the signaling server (as either an offer or an answer) and
+  /// then put into effect by your code calling
+  /// [RTCPeerConnection.setRemoteDescription] in response.
   external RTCSessionDescription? get remoteDescription;
 
-  /// The read-only property
-  /// **`RTCPeerConnection.currentRemoteDescription`** returns an
+  /// The **`currentRemoteDescription`** read-only property of the
+  /// [RTCPeerConnection] interface returns an
   /// [RTCSessionDescription] object describing the remote end of the connection
   /// as it was most recently successfully negotiated since the last time the
   /// [RTCPeerConnection] finished negotiating and connecting to a remote peer.
   /// Also included is a list of any ICE candidates that may already have been
-  /// generated by
-  /// the ICE agent since the offer or answer represented by the description was
-  /// first
-  /// instantiated.
+  /// generated by the ICE agent since the offer or answer represented by the
+  /// description was first instantiated.
   ///
   /// To change the `currentRemoteDescription`, call
   /// [RTCPeerConnection.setRemoteDescription], which triggers a series of
-  /// events which leads to this value being set. For details on what exactly
-  /// happens and why
-  /// the change isn't necessarily instantaneous, see
+  /// events which leads to this value being set.
+  /// For details on what exactly happens and why the change isn't necessarily
+  /// instantaneous, see
   /// [Pending and current descriptions](https://developer.mozilla.org/en-US/docs/Web/API/WebRTC_API/Connectivity#pending_and_current_descriptions)
   /// in the WebRTC Connectivity page.
   ///
   /// > **Note:** Unlike [RTCPeerConnection.remoteDescription], this value
-  /// > represents the
-  /// > actual current state of the local end of the connection;
+  /// > represents the actual current state of the local end of the connection;
   /// > `remoteDescription` may specify a description which the connection is
   /// > currently in the process of switching over to.
   external RTCSessionDescription? get currentRemoteDescription;
 
-  /// The read-only property
-  /// **`RTCPeerConnection.pendingRemoteDescription`** returns an
-  /// [RTCSessionDescription] object describing a pending configuration change
-  /// for the remote end of the connection. This does not describe the
-  /// connection as it
-  /// currently stands, but as it may exist in the near future. Use
-  /// [RTCPeerConnection.currentRemoteDescription] or
+  /// The **`pendingRemoteDescription`** read-only property of the
+  /// [RTCPeerConnection] interface returns an [RTCSessionDescription] object
+  /// describing a pending configuration change for the remote end of the
+  /// connection.
+  ///
+  /// This does not describe the connection as it currently stands, but as it
+  /// may exist in the near future.
+  /// Use [RTCPeerConnection.currentRemoteDescription] or
   /// [RTCPeerConnection.remoteDescription] to get the current session
-  /// description for the remote endpoint. For details on the difference, see
+  /// description for the remote endpoint.
+  /// For details on the difference, see
   /// [Pending and current descriptions](https://developer.mozilla.org/en-US/docs/Web/API/WebRTC_API/Connectivity#pending_and_current_descriptions)
   /// in the WebRTC Connectivity page.
   external RTCSessionDescription? get pendingRemoteDescription;
 
-  /// The read-only **`signalingState`** property on the
-  /// [RTCPeerConnection] interface returns a string value
-  /// describing the state of the signaling process
-  /// on the local end of the connection
-  /// while connecting or reconnecting to another peer.
+  /// The **`signalingState`** read-only property of the [RTCPeerConnection]
+  /// interface returns a string value describing the state of the signaling
+  /// process on the local end of the connection while connecting or
+  /// reconnecting to another peer.
   /// See
   /// [Signaling](https://developer.mozilla.org/en-US/docs/Web/API/WebRTC_API/Session_lifetime#signaling)
   /// in our WebRTC session lifetime page.
   ///
   /// Because the signaling process is a state machine, being able to verify
-  /// that your code
-  /// is in the expected state when messages arrive can help avoid unexpected
-  /// and avoidable
-  /// failures. For example, if you receive an answer while the `signalingState`
-  /// isn't `"have-local-offer"`, you know that something is wrong, since you
-  /// should only receive answers after creating an offer but before an answer
-  /// has been
+  /// that your code is in the expected state when messages arrive can help
+  /// avoid unexpected and avoidable failures.
+  /// For example, if you receive an answer while the `signalingState` isn't
+  /// `"have-local-offer"`, you know that something is wrong, since you should
+  /// only receive answers after creating an offer but before an answer has been
   /// received and passed into [RTCPeerConnection.setLocalDescription]. Your
   /// code will be more reliable if you watch for mismatched states like this
-  /// and handle them
-  /// gracefully.
+  /// and handle them gracefully.
   ///
   /// This value may also be useful during debugging, for example.
   ///
   /// In addition, when the value of this property changes, a
   /// [RTCPeerConnection.signalingstatechange_event] event is sent to the
-  /// [RTCPeerConnection]
-  /// instance.
+  /// [RTCPeerConnection] instance.
   external RTCSignalingState get signalingState;
 
-  /// The read-only property **`RTCPeerConnection.iceGatheringState`** returns a
-  /// string
-  /// that describes the connection's ICE gathering state.
+  /// The **`iceGatheringState`** read-only property of the [RTCPeerConnection]
+  /// interface returns a string that describes the overall ICE gathering state
+  /// for this connection.
   /// This lets you detect, for example, when collection of ICE candidates has
   /// finished.
   ///
   /// You can detect when the value of this property changes by watching for an
-  /// event of type
-  /// [RTCPeerConnection.icegatheringstatechange_event].
+  /// event of type [RTCPeerConnection.icegatheringstatechange_event].
+  ///
+  /// Note that **`iceGatheringState`** represents the overall gathering state
+  /// of the connection, including every [RTCIceTransport] used by every
+  /// [RTCRtpSender] and every [RTCRtpReceiver] on the entire connection.
+  /// This contrasts with [RTCIceTransport.gatheringState], which represents the
+  /// gathering state for a single transport.
   external RTCIceGatheringState get iceGatheringState;
 
-  /// The read-only property **`RTCPeerConnection.iceConnectionState`** returns
-  /// a string which state of the  agent associated with the
-  /// [RTCPeerConnection]:
-  /// `new`, `checking`, `connected`, `completed`,
+  /// The **`iceConnectionState`** read-only property of the [RTCPeerConnection]
+  /// interface returns a string which state of the  agent associated with the
+  /// [RTCPeerConnection]: `new`, `checking`, `connected`, `completed`,
   /// `failed`, `disconnected`, and `closed`.
   ///
-  /// It describes the current state of the ICE agent
-  /// and its connection to the ICE server;
+  /// It describes the current state of the ICE agent and its connection to the
+  /// ICE server;
   /// that is, the  or  server.
   ///
   /// You can detect when this value has changed by watching for the
   /// [RTCPeerConnection.iceconnectionstatechange_event] event.
   external RTCIceConnectionState get iceConnectionState;
 
-  /// The read-only **`connectionState`** property of the [RTCPeerConnection]
+  /// The **`connectionState`** read-only property of the [RTCPeerConnection]
   /// interface indicates the current state of the peer connection by returning
   /// one of the following string values: `new`, `connecting`, `connected`,
   /// `disconnected`, `failed`, or `closed`.
@@ -627,27 +592,24 @@ extension type RTCPeerConnection._(JSObject _)
   /// [RTCPeerConnection] instance.
   external RTCPeerConnectionState get connectionState;
 
-  /// The read-only **[RTCPeerConnection]** property
-  /// **`canTrickleIceCandidates`**
-  /// returns a boolean value which indicates whether or not the remote peer can
-  /// accept
+  /// The **`canTrickleIceCandidates`** read-only property of the
+  /// [RTCPeerConnection] interface returns a boolean value which indicates
+  /// whether or not the remote peer can accept
   /// [trickled ICE candidates](https://datatracker.ietf.org/doc/html/draft-ietf-mmusic-trickle-ice).
   ///
   /// **ICE trickling** is the process of continuing to send candidates after
   /// the initial offer or answer has already been sent to the other peer.
   ///
   /// This property is only set after having called
-  /// [RTCPeerConnection.setRemoteDescription]. Ideally, your signaling
-  /// protocol provides a way to detect trickling support, so that you don't
-  /// need to rely on
-  /// this property. A WebRTC browser will always support trickle ICE. If
-  /// trickling isn't
+  /// [RTCPeerConnection.setRemoteDescription]. Ideally, your signaling protocol
+  /// provides a way to detect trickling support, so that you don't need to rely
+  /// on this property.
+  /// A WebRTC browser will always support trickle ICE. If trickling isn't
   /// supported, or you aren't able to tell, you can check for a falsy value for
-  /// this
-  /// property and then wait until the value of
-  /// [RTCPeerConnection.iceGatheringState] changes to
-  /// `"completed"` before creating and sending the initial offer. That way, the
-  /// offer contains all of the candidates.
+  /// this property and then wait until the value of
+  /// [RTCPeerConnection.iceGatheringState] changes to `"completed"` before
+  /// creating and sending the initial offer.
+  /// That way, the offer contains all of the candidates.
   external bool? get canTrickleIceCandidates;
   external EventHandler get onnegotiationneeded;
   external set onnegotiationneeded(EventHandler value);
@@ -666,10 +628,9 @@ extension type RTCPeerConnection._(JSObject _)
   external EventHandler get ontrack;
   external set ontrack(EventHandler value);
 
-  /// The read-only **`sctp`** property on the [RTCPeerConnection] interface
+  /// The **`sctp`** read-only property of the [RTCPeerConnection] interface
   /// returns an [RTCSctpTransport] describing the  transport over which SCTP
-  /// data is being sent and
-  /// received.
+  /// data is being sent and received.
   /// If SCTP hasn't been negotiated, this value is `null`.
   ///
   /// The SCTP transport is used for transmitting and receiving data for any and
@@ -901,9 +862,8 @@ extension type RTCIceCandidate._(JSObject _) implements JSObject {
   external RTCIceTcpCandidateType? get tcpType;
 
   /// The **[RTCIceCandidate]** interface's read-only **`relatedAddress`**
-  /// property is a
-  /// string indicating the **related address** of a relay or reflexive
-  /// candidate.
+  /// property is a string indicating the **related address** of a relay or
+  /// reflexive candidate.
   ///
   /// If the candidate is a host candidate (that is, its
   /// [RTCIceCandidate.address] is in fact the real IP address of the remote
@@ -916,10 +876,9 @@ extension type RTCIceCandidate._(JSObject _) implements JSObject {
   /// `candidate` a-line if it's formatted properly(the `rel-address` field).
   ///
   /// The related address and port ([RTCIceCandidate.relatedPort]) are not used
-  /// at all by  itself; they are provided
-  /// for analysis and diagnostic purposes only, and their inclusion may be
-  /// blocked by security systems, so do not rely on them having non-`null`
-  /// values.
+  /// at all by  itself; they are provided for analysis and diagnostic purposes
+  /// only, and their inclusion may be blocked by security systems, so do not
+  /// rely on them having non-`null` values.
   external String? get relatedAddress;
 
   /// The **[RTCIceCandidate]** interface's read-only **`relatedPort`** property
@@ -1609,9 +1568,8 @@ extension type RTCRtpTransceiver._(JSObject _) implements JSObject {
 extension type RTCDtlsTransport._(JSObject _) implements EventTarget, JSObject {
   external JSArray<JSArrayBuffer> getRemoteCertificates();
 
-  /// The read-only **[RTCDtlsTransport]**
-  /// property **`iceTransport`** contains a reference
-  /// to the underlying [RTCIceTransport].
+  /// The **`iceTransport`** read-only property of the **[RTCDtlsTransport]**
+  /// interface contains a reference to the underlying [RTCIceTransport].
   external RTCIceTransport get iceTransport;
 
   /// The **`state`** read-only property of the
@@ -1645,56 +1603,48 @@ extension type RTCDtlsFingerprint._(JSObject _) implements JSObject {
 /// API documentation sourced from
 /// [MDN Web Docs](https://developer.mozilla.org/en-US/docs/Web/API/RTCIceTransport).
 extension type RTCIceTransport._(JSObject _) implements EventTarget, JSObject {
-  /// The **[RTCIceTransport]** method
-  /// **`getLocalCandidates()`** returns an array of
-  /// [RTCIceCandidate] objects, one for each of the candidates that have been
-  /// gathered by the local device during the current  agent
-  /// session.
+  /// The **`getLocalCandidates()`** method of the [RTCIceTransport] interface
+  /// returns an array of [RTCIceCandidate] objects, one for each of the
+  /// candidates that have been gathered by the local device during the current
+  /// agent session.
   ///
   /// The local candidates are placed in this list by the ICE agent prior to
-  /// being delivered
-  /// to the local client's code in an [RTCPeerConnection.icecandidate_event]
-  /// event so that the client can
+  /// being delivered to the local client's code in an
+  /// [RTCPeerConnection.icecandidate_event] event so that the client can
   /// forward the candidates to the remote peer.
   external JSArray<RTCIceCandidate> getLocalCandidates();
 
-  /// The **[RTCIceTransport]** method
-  /// **`getRemoteCandidates()`** returns an array which contains
-  /// one [RTCIceCandidate] for each of the candidates that have been received
-  /// from the remote peer so far during the current  gathering
-  /// session.
+  /// The **`getRemoteCandidates()`** method of the [RTCIceTransport] interface
+  /// returns an array that contains one [RTCIceCandidate] for each of the
+  /// candidates that have been received from the remote peer so far during the
+  /// current  gathering session.
   ///
-  /// Each time your signaling code calls [RTCPeerConnection.addIceCandidate]
-  /// to add a received candidate to the ICE session, the ICE agent places it in
-  /// the list
-  /// returned by this function.
+  /// Each time your signaling code calls [RTCPeerConnection.addIceCandidate] to
+  /// add a received candidate to the ICE session, the ICE agent places it in
+  /// the list returned by this function.
   external JSArray<RTCIceCandidate> getRemoteCandidates();
 
-  /// The [RTCIceTransport] method
-  /// **`getSelectedCandidatePair()`** returns an
-  /// [RTCIceCandidatePair] object containing the current best-choice pair
-  /// of  candidates describing the configuration of the endpoints of the
-  /// transport.
+  /// The **`getSelectedCandidatePair()`** method of the [RTCIceTransport]
+  /// interface returns an [RTCIceCandidatePair] object containing the current
+  /// best-choice pair of  candidates describing the configuration of the
+  /// endpoints of the transport.
   external RTCIceCandidatePair? getSelectedCandidatePair();
 
-  /// The **[RTCIceTransport]** method
-  /// **`getLocalParameters()`** returns an
-  /// [RTCIceParameters] object which provides information uniquely identifying
-  /// the local peer for the duration of the ICE session.
+  /// The **`getLocalParameters()`** method of the [RTCIceTransport] interface
+  /// returns an [RTCIceParameters] object that provides information uniquely
+  /// identifying the local peer for the duration of the ICE session.
   ///
   /// The local peer's parameters are obtained during ICE signaling and
-  /// delivered to the
-  /// transport when the client calls [RTCPeerConnection.setLocalDescription].
+  /// delivered to the transport when the client calls
+  /// [RTCPeerConnection.setLocalDescription].
   external RTCIceParameters? getLocalParameters();
 
-  /// The **[RTCIceTransport]** method
-  /// **`getRemoteParameters()`** returns an
-  /// [RTCIceParameters] object which provides information uniquely
+  /// The **`getRemoteParameters()`** method of the [RTCIceTransport] interface
+  /// returns an [RTCIceParameters] object that provides information uniquely
   /// identifying the remote peer for the duration of the ICE session.
   ///
   /// The remote peer's parameters are received during ICE signaling and
-  /// delivered to the
-  /// transport when the client calls
+  /// delivered to the transport when the client calls
   /// [RTCPeerConnection.setRemoteDescription].
   external RTCIceParameters? getRemoteParameters();
   external EventHandler get onerror;
@@ -1702,29 +1652,37 @@ extension type RTCIceTransport._(JSObject _) implements EventTarget, JSObject {
   external EventHandler get onicecandidate;
   external set onicecandidate(EventHandler value);
 
-  /// The read-only **[RTCIceTransport]**
-  /// property **`role`** indicates which  role
-  /// the transport is fulfilling: that of the controlling agent, or the agent
-  /// that is being
-  /// controlled.
+  /// The **`role`** read-only property of the [RTCIceTransport] interface
+  /// indicates which  role the transport is fulfilling: that of the controlling
+  /// agent, or the agent that is being controlled.
   ///
   /// You can learn more about ICE roles in
   /// [Choosing a candidate pair](https://developer.mozilla.org/en-US/docs/Web/API/WebRTC_API/Connectivity#choosing_a_candidate_pair).
   external RTCIceRole get role;
 
-  /// The read-only **[RTCIceTransport]**
-  /// property **`state`** returns the current state of the ICE
-  /// transport, so you can determine the state of ICE gathering in which the
-  /// ICE agent
-  /// currently is operating.
+  /// The **`state`** read-only property of the [RTCIceTransport] interface
+  /// returns the current state of the ICE transport, so you can determine the
+  /// state of ICE gathering in which the ICE agent currently is operating.
   ///
-  /// This differs from the [RTCIceTransport.gatheringState],
-  /// which only indicates whether or not ICE gathering is currently underway.
+  /// This differs from the [RTCIceTransport.gatheringState], which only
+  /// indicates whether or not ICE gathering is currently underway.
+  /// It also differs from [RTCPeerConnection.connectionState], which aggregates
+  /// the states across every [RTCIceTransport] used by every [RTCRtpSender] and
+  /// every [RTCRtpReceiver] on the entire connection.
   external RTCIceTransportState get state;
 
-  /// The read-only property **`gatheringState`** property of the
-  /// [RTCIceTransport] interface returns a string that indicates the current
-  /// gathering state of the ICE agent: `"new"`, `"gathering"`, or `"complete"`.
+  /// The **`gatheringState`** read-only property of the [RTCIceTransport]
+  /// interface returns a string that indicates the current gathering state of
+  /// the ICE agent for this transport: `"new"`, `"gathering"`, or `"complete"`.
+  ///
+  /// You can detect when the value of this property changes by watching for an
+  /// event of type [RTCIceTransport.gatheringstatechange_event].
+  ///
+  /// Note that **`gatheringState`** represents the gathering state of just this
+  /// transport, while [RTCPeerConnection.iceGatheringState] represents the
+  /// overall gathering state of the whole connection, including every
+  /// [RTCIceTransport] used by every [RTCRtpSender] and every [RTCRtpReceiver]
+  /// on the entire connection.
   external RTCIceGathererState get gatheringState;
   external EventHandler get onstatechange;
   external set onstatechange(EventHandler value);
@@ -1789,10 +1747,9 @@ extension type RTCIceCandidatePair._(JSObject _) implements JSObject {
     RTCIceCandidate remote,
   });
 
-  /// The **`local`** property of the
-  /// **[RTCIceCandidatePair]** dictionary specifies the
-  /// [RTCIceCandidate] which describes the configuration of the local end of a
-  /// viable WebRTC connection.
+  /// The **`local`** property of the **[RTCIceCandidatePair]** dictionary
+  /// specifies the [RTCIceCandidate] which describes the configuration of the
+  /// local end of a viable WebRTC connection.
   external RTCIceCandidate get local;
   external set local(RTCIceCandidate value);
 
diff --git a/lib/src/dom/webrtc_encoded_transform.dart b/lib/src/dom/webrtc_encoded_transform.dart
index b7cf6aca..7ffb4252 100644
--- a/lib/src/dom/webrtc_encoded_transform.dart
+++ b/lib/src/dom/webrtc_encoded_transform.dart
@@ -61,6 +61,8 @@ extension type RTCEncodedVideoFrameMetadata._(JSObject _) implements JSObject {
   external set mimeType(String value);
 }
 
+/// @AvailableInWorkers("window_and_dedicated")
+///
 /// The **`RTCEncodedVideoFrame`** of the
 /// [WebRTC API](https://developer.mozilla.org/en-US/docs/Web/API/WebRTC_API)
 /// represents an encoded video frame in the WebRTC receiver or sender pipeline,
@@ -75,6 +77,8 @@ extension type RTCEncodedVideoFrameMetadata._(JSObject _) implements JSObject {
 /// API documentation sourced from
 /// [MDN Web Docs](https://developer.mozilla.org/en-US/docs/Web/API/RTCEncodedVideoFrame).
 extension type RTCEncodedVideoFrame._(JSObject _) implements JSObject {
+  /// @AvailableInWorkers("window_and_dedicated")
+  ///
   /// The **`getMetadata()`** method of the [RTCEncodedVideoFrame] interface
   /// returns an object containing the metadata associated with the frame.
   ///
@@ -83,10 +87,14 @@ extension type RTCEncodedVideoFrame._(JSObject _) implements JSObject {
   /// other information.
   external RTCEncodedVideoFrameMetadata getMetadata();
 
+  /// @AvailableInWorkers("window_and_dedicated")
+  ///
   /// The readonly **`type`** property of the [RTCEncodedVideoFrame] interface
   /// indicates whether this frame is a key frame, delta frame, or empty frame.
   external RTCEncodedVideoFrameType get type;
 
+  /// @AvailableInWorkers("window_and_dedicated")
+  ///
   /// The **`data`** property of the [RTCEncodedVideoFrame] interface returns a
   /// buffer containing the frame data.
   external JSArrayBuffer get data;
@@ -116,6 +124,8 @@ extension type RTCEncodedAudioFrameMetadata._(JSObject _) implements JSObject {
   external set mimeType(String value);
 }
 
+/// @AvailableInWorkers("window_and_dedicated")
+///
 /// The **`RTCEncodedAudioFrame`** of the
 /// [WebRTC API](https://developer.mozilla.org/en-US/docs/Web/API/WebRTC_API)
 /// represents an encoded audio frame in the WebRTC receiver or sender pipeline,
@@ -136,6 +146,8 @@ extension type RTCEncodedAudioFrameMetadata._(JSObject _) implements JSObject {
 /// API documentation sourced from
 /// [MDN Web Docs](https://developer.mozilla.org/en-US/docs/Web/API/RTCEncodedAudioFrame).
 extension type RTCEncodedAudioFrame._(JSObject _) implements JSObject {
+  /// @AvailableInWorkers("window_and_dedicated")
+  ///
   /// The **`getMetadata()`** method of the [RTCEncodedAudioFrame] interface
   /// returns an object containing the metadata associated with the frame.
   ///
@@ -144,6 +156,8 @@ extension type RTCEncodedAudioFrame._(JSObject _) implements JSObject {
   /// sequence number (for incoming frames).
   external RTCEncodedAudioFrameMetadata getMetadata();
 
+  /// @AvailableInWorkers("window_and_dedicated")
+  ///
   /// The **`data`** property of the [RTCEncodedAudioFrame] interface returns a
   /// buffer containing the data for an encoded frame.
   external JSArrayBuffer get data;
diff --git a/lib/src/dom/xhr.dart b/lib/src/dom/xhr.dart
index 2b25c137..701b5d47 100644
--- a/lib/src/dom/xhr.dart
+++ b/lib/src/dom/xhr.dart
@@ -19,6 +19,8 @@ import 'html.dart';
 typedef FormDataEntryValue = JSAny;
 typedef XMLHttpRequestResponseType = String;
 
+/// @AvailableInWorkers("window_and_worker_except_service")
+///
 /// `XMLHttpRequestEventTarget` is the interface that describes the event
 /// handlers shared on [XMLHttpRequest] and [XMLHttpRequestUpload].
 ///
@@ -47,7 +49,7 @@ extension type XMLHttpRequestEventTarget._(JSObject _)
   external set onloadend(EventHandler value);
 }
 
-/// @AvailableInWorkers("notservice")
+/// @AvailableInWorkers("window_and_worker_except_service")
 ///
 /// The **`XMLHttpRequestUpload`** interface represents the upload process for a
 /// specific [XMLHttpRequest]. It is an _opaque_ object that represents the
@@ -62,7 +64,7 @@ extension type XMLHttpRequestEventTarget._(JSObject _)
 extension type XMLHttpRequestUpload._(JSObject _)
     implements XMLHttpRequestEventTarget, JSObject {}
 
-/// @AvailableInWorkers("notservice")
+/// @AvailableInWorkers("window_and_worker_except_service")
 ///
 /// `XMLHttpRequest` (XHR) objects are used to interact with servers. You can
 /// retrieve data from a URL without having to do a full page refresh. This
@@ -93,6 +95,8 @@ extension type XMLHttpRequest._(JSObject _)
   external static int get LOADING;
   external static int get DONE;
 
+  /// @AvailableInWorkers("window_and_worker_except_service")
+  ///
   /// The [XMLHttpRequest] method **`open()`**
   /// initializes a newly-created request, or re-initializes an existing one.
   ///
@@ -108,6 +112,8 @@ extension type XMLHttpRequest._(JSObject _)
     String? password,
   ]);
 
+  /// @AvailableInWorkers("window_and_worker_except_service")
+  ///
   /// The [XMLHttpRequest] method **`setRequestHeader()`** sets the value of an
   /// HTTP request header.
   /// When using `setRequestHeader()`, you must call it after calling
@@ -142,6 +148,8 @@ extension type XMLHttpRequest._(JSObject _)
     String value,
   );
 
+  /// @AvailableInWorkers("window_and_worker_except_service")
+  ///
   /// The [XMLHttpRequest] method
   /// **`send()`** sends the request to the server.
   ///
@@ -163,6 +171,8 @@ extension type XMLHttpRequest._(JSObject _)
   /// `Accept` header with the type `"*/*"` (any type) is sent.
   external void send([JSAny? body]);
 
+  /// @AvailableInWorkers("window_and_worker_except_service")
+  ///
   /// The **`XMLHttpRequest.abort()`** method aborts the request if
   /// it has already been sent. When a request is aborted, its
   /// [XMLHttpRequest.readyState] is changed to
@@ -170,6 +180,8 @@ extension type XMLHttpRequest._(JSObject _)
   /// [XMLHttpRequest.status] code is set to 0.
   external void abort();
 
+  /// @AvailableInWorkers("window_and_worker_except_service")
+  ///
   /// The [XMLHttpRequest] method
   /// **`getResponseHeader()`** returns the string containing the
   /// text of a particular header's value.
@@ -188,6 +200,8 @@ extension type XMLHttpRequest._(JSObject _)
   /// which returns the entire raw header string.
   external String? getResponseHeader(String name);
 
+  /// @AvailableInWorkers("window_and_worker_except_service")
+  ///
   /// The [XMLHttpRequest] method
   /// **`getAllResponseHeaders()`** returns all the response
   /// headers, separated by , as a string, or returns `null`
@@ -200,6 +214,8 @@ extension type XMLHttpRequest._(JSObject _)
   /// > _current_ part of the request, not from the original channel.
   external String getAllResponseHeaders();
 
+  /// @AvailableInWorkers("window_and_worker_except_service")
+  ///
   /// The [XMLHttpRequest] method
   /// **`overrideMimeType()`** specifies a MIME type other than the
   /// one provided by the server to be used instead when interpreting the data
@@ -214,6 +230,8 @@ extension type XMLHttpRequest._(JSObject _)
   external EventHandler get onreadystatechange;
   external set onreadystatechange(EventHandler value);
 
+  /// @AvailableInWorkers("window_and_worker_except_service")
+  ///
   /// The **XMLHttpRequest.readyState** property returns the state an
   /// XMLHttpRequest client is in. An XHR client exists in one of the following
   /// states:
@@ -238,6 +256,8 @@ extension type XMLHttpRequest._(JSObject _)
   ///   - : The fetch operation is complete. This could mean that either the data transfer has been completed successfully or failed.
   external int get readyState;
 
+  /// @AvailableInWorkers("window_and_worker_except_service")
+  ///
   /// The **`XMLHttpRequest.timeout`** property is an `unsigned long`
   /// representing the number of milliseconds a request can take before
   /// automatically being terminated. The default value is 0, which means there
@@ -254,9 +274,11 @@ extension type XMLHttpRequest._(JSObject _)
   external int get timeout;
   external set timeout(int value);
 
+  /// @AvailableInWorkers("window_and_worker_except_service")
+  ///
   /// The **`XMLHttpRequest.withCredentials`** property is a boolean value that
   /// indicates whether or not cross-site `Access-Control` requests should be
-  /// made using credentials such as cookies, authorization headers or TLS
+  /// made using credentials such as cookies, authentication headers or TLS
   /// client certificates. Setting `withCredentials` has no effect on
   /// same-origin requests.
   ///
@@ -264,9 +286,11 @@ extension type XMLHttpRequest._(JSObject _)
   /// ignored in the response. The default is `false`. `XMLHttpRequest`
   /// responses from a different domain cannot set cookie values for their own
   /// domain unless `withCredentials` is set to `true` before making the
-  /// request. The third-party cookies obtained by setting `withCredentials` to
-  /// true will still honor same-origin policy and hence can not be accessed by
-  /// the requesting script through
+  /// request. The
+  /// [third-party cookies](https://developer.mozilla.org/en-US/docs/Web/Privacy/Third-party_cookies)
+  /// obtained by setting `withCredentials` to `true` will still honor
+  /// same-origin policy and hence can not be accessed by the requesting script
+  /// through
   /// [document.cookie](https://developer.mozilla.org/en-US/docs/Web/API/Document/cookie)
   /// or from response headers.
   ///
@@ -279,6 +303,8 @@ extension type XMLHttpRequest._(JSObject _)
   external bool get withCredentials;
   external set withCredentials(bool value);
 
+  /// @AvailableInWorkers("window_and_worker_except_service")
+  ///
   /// The [XMLHttpRequest] `upload` property returns an [XMLHttpRequestUpload]
   /// object that can be observed to monitor an upload's progress.
   ///
@@ -353,6 +379,8 @@ extension type XMLHttpRequest._(JSObject _)
   /// </table>
   external XMLHttpRequestUpload get upload;
 
+  /// @AvailableInWorkers("window_and_worker_except_service")
+  ///
   /// The read-only **`XMLHttpRequest.responseURL`** property returns the
   /// serialized URL of the response or the empty string if the URL is `null`.
   /// If the URL is returned, any URL fragment present in the URL will be
@@ -360,6 +388,8 @@ extension type XMLHttpRequest._(JSObject _)
   /// after any redirects.
   external String get responseURL;
 
+  /// @AvailableInWorkers("window_and_worker_except_service")
+  ///
   /// The read-only **`XMLHttpRequest.status`** property returns the numerical
   /// HTTP
   /// [status code](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status) of
@@ -369,6 +399,8 @@ extension type XMLHttpRequest._(JSObject _)
   /// report a status of 0 in case of `XMLHttpRequest` errors.
   external int get status;
 
+  /// @AvailableInWorkers("window_and_worker_except_service")
+  ///
   /// The read-only **`XMLHttpRequest.statusText`** property returns a string
   /// containing the response's status message as returned by the HTTP server.
   /// Unlike
@@ -386,6 +418,8 @@ extension type XMLHttpRequest._(JSObject _)
   /// > string as status message as HTTP/2 does not support them.
   external String get statusText;
 
+  /// @AvailableInWorkers("window_and_worker_except_service")
+  ///
   /// The [XMLHttpRequest] property
   /// **`responseType`** is an enumerated string value specifying
   /// the type of data contained in the response.
@@ -397,6 +431,8 @@ extension type XMLHttpRequest._(JSObject _)
   external XMLHttpRequestResponseType get responseType;
   external set responseType(XMLHttpRequestResponseType value);
 
+  /// @AvailableInWorkers("window_and_worker_except_service")
+  ///
   /// The [XMLHttpRequest]
   /// **`response`** property returns the response's body content as
   /// an `ArrayBuffer`, a [Blob], a [Document],
@@ -405,11 +441,15 @@ extension type XMLHttpRequest._(JSObject _)
   /// property.
   external JSAny? get response;
 
+  /// @AvailableInWorkers("window_and_worker_except_service")
+  ///
   /// The read-only [XMLHttpRequest] property
   /// **`responseText`** returns the text received from a server
   /// following a request being sent.
   external String get responseText;
 
+  /// @AvailableInWorkers("window_and_worker_except_service")
+  ///
   /// The **`XMLHttpRequest.responseXML`** read-only property returns
   /// a [Document] containing the HTML or XML retrieved by the request; or
   /// `null` if the request was unsuccessful, has not yet been sent, or if the
@@ -529,23 +569,28 @@ extension type ProgressEvent._(JSObject _) implements Event, JSObject {
   /// [ProgressEvent.total] property has no significant value.
   external bool get lengthComputable;
 
-  /// The **`ProgressEvent.loaded`** read-only property is an integer
-  /// representing the amount of work already performed by the underlying
-  /// process. The ratio
-  /// of work done can be calculated with the property and
-  /// `ProgressEvent.total`.
-  /// When downloading a resource using HTTP, this value is specified in bytes
-  /// (not bits), and only represents the part of the content
-  /// itself, not headers and other overhead.
+  /// The **`ProgressEvent.loaded`** read-only property is a 64-bit unsigned
+  /// integer
+  /// indicating the size, in bytes, of the data already transmitted or
+  /// processed. The ratio can be calculated by dividing `ProgressEvent.total`
+  /// by the value of this property.
+  /// When downloading a resource using HTTP, this only counts the body of the
+  /// HTTP message, and doesn't include headers and other overhead.
+  ///
+  /// Note that for compressed requests of unknown total size, `loaded` might
+  /// contain the size of the compressed, or decompressed, data, depending on
+  /// the browser. As of 2024, it contains the size of the compressed data in
+  /// Firefox, and the size of the uncompressed data in Chrome.
   external int get loaded;
 
-  /// The **`ProgressEvent.total`** read-only property is an unsigned
-  /// 64-bit integer value indicating the total size of the data being processed
-  /// or
-  /// transmitted. In the case of an HTTP transmission, this is the size of the
-  /// body of the
-  /// message (the `Content-Length`), and does not include headers and other
-  /// overhead.
+  /// The **`ProgressEvent.total`** read-only property is a 64-bit unsigned
+  /// integer
+  /// indicating the total size, in bytes, of the data being transmitted or
+  /// processed.
+  ///
+  /// When downloading a resource using HTTP, this value is taken from the
+  /// `Content-Length` response header. It only counts the body of the HTTP
+  /// message, and doesn't include headers and other overhead.
   ///
   /// If the event's [ProgressEvent.lengthComputable]
   /// property is `false`, this value is meaningless and should be ignored.
diff --git a/third_party/mdn/mdn.json b/third_party/mdn/mdn.json
index 8c3e2c15..a4650c0c 100644
--- a/third_party/mdn/mdn.json
+++ b/third_party/mdn/mdn.json
@@ -207,34 +207,34 @@
     }
   },
   "AudioData": {
-    "docs": "The **`AudioData`** interface of the [WebCodecs API](https://developer.mozilla.org/en-US/docs/Web/API/WebCodecs_API) represents an audio sample.\n\n`AudioData` is a [transferable object](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Transferable_objects).",
+    "docs": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`AudioData`** interface of the [WebCodecs API](https://developer.mozilla.org/en-US/docs/Web/API/WebCodecs_API) represents an audio sample.\n\n`AudioData` is a [transferable object](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Transferable_objects).",
     "properties": {
-      "allocationsize": "The **`allocationSize()`** method of the [AudioData] interface returns the size in bytes required to hold the current sample as filtered by options passed into the method.",
-      "audiodata": "The **`AudioData()`** constructor creates a new [AudioData] object which represents an individual audio sample.",
-      "clone": "The **`clone()`** method of the [AudioData] interface creates a new `AudioData` object with reference to the same media resource as the original.",
-      "close": "The **`close()`** method of the [AudioData] interface clears all states and releases the reference to the media resource.",
-      "copyto": "The **`copyTo()`** method of the [AudioData] interface copies a plane of an `AudioData` object to a destination buffer.",
-      "duration": "The **`duration`** read-only property of the [AudioData] interface returns the duration in microseconds of this `AudioData` object.",
-      "format": "The **`format`** read-only property of the [AudioData] interface returns the sample format of the `AudioData` object.",
-      "numberofchannels": "The **`numberOfChannels`** read-only property of the [AudioData] interface returns the number of channels in the `AudioData` object.",
-      "numberofframes": "The **`numberOfFrames`** read-only property of the [AudioData] interface returns the number of frames in the `AudioData` object.",
-      "samplerate": "The **`sampleRate`** read-only property of the [AudioData] interface returns the sample rate in Hz.",
-      "timestamp": "The **`duration`** read-only property of the [AudioData] interface returns the timestamp of this `AudioData` object."
+      "allocationsize": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`allocationSize()`** method of the [AudioData] interface returns the size in bytes required to hold the current sample as filtered by options passed into the method.",
+      "audiodata": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`AudioData()`** constructor creates a new [AudioData] object which represents an individual audio sample.",
+      "clone": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`clone()`** method of the [AudioData] interface creates a new `AudioData` object with reference to the same media resource as the original.",
+      "close": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`close()`** method of the [AudioData] interface clears all states and releases the reference to the media resource.",
+      "copyto": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`copyTo()`** method of the [AudioData] interface copies a plane of an `AudioData` object to a destination buffer.",
+      "duration": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`duration`** read-only property of the [AudioData] interface returns the duration in microseconds of this `AudioData` object.",
+      "format": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`format`** read-only property of the [AudioData] interface returns the sample format of the `AudioData` object.",
+      "numberofchannels": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`numberOfChannels`** read-only property of the [AudioData] interface returns the number of channels in the `AudioData` object.",
+      "numberofframes": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`numberOfFrames`** read-only property of the [AudioData] interface returns the number of frames in the `AudioData` object.",
+      "samplerate": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`sampleRate`** read-only property of the [AudioData] interface returns the sample rate in Hz.",
+      "timestamp": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`duration`** read-only property of the [AudioData] interface returns the timestamp of this `AudioData` object."
     }
   },
   "AudioDecoder": {
-    "docs": "The **`AudioDecoder`** interface of the [WebCodecs API] decodes chunks of audio.",
+    "docs": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`AudioDecoder`** interface of the [WebCodecs API] decodes chunks of audio.",
     "properties": {
-      "audiodecoder": "The **`AudioDecoder()`** constructor creates a new [AudioDecoder] object with the provided `init.output` callback assigned as the output callback, the provided `init.error` callback as the error callback, and the [AudioDecoder.state] set to `\"unconfigured\"`.",
-      "close": "The **`close()`** method of the [AudioDecoder] interface ends all pending work and releases system resources.",
-      "configure": "The **`configure()`** method of the [AudioDecoder] interface enqueues a control message to configure the audio decoder for decoding chunks.",
-      "decode": "The **`decode()`** method of the [AudioDecoder] interface enqueues a control message to decode a given chunk of audio.",
-      "decodequeuesize": "The **`decodeQueueSize`** read-only property of the [AudioDecoder] interface returns the number of pending decode requests in the queue.",
-      "dequeue_event": "The **`dequeue`** event of the [AudioDecoder] interface fires to signal a decrease in [AudioDecoder.decodeQueueSize].\n\nThis eliminates the need for developers to use a [setTimeout] poll to determine when the queue has decreased, and more work should be queued up.",
-      "flush": "The **`flush()`** method of the [AudioDecoder] interface returns a Promise that resolves once all pending messages in the queue have been completed.",
-      "isconfigsupported_static": "The **`isConfigSupported()`** static method of the [AudioDecoder] interface checks if the given config is supported (that is, if [AudioDecoder] objects can be successfully configured with the given config).",
-      "reset": "The **`reset()`** method of the [AudioDecoder] interface resets all states including configuration, control messages in the control message queue, and all pending callbacks.",
-      "state": "The **`state`** read-only property of the [AudioDecoder] interface returns the current state of the underlying codec."
+      "audiodecoder": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`AudioDecoder()`** constructor creates a new [AudioDecoder] object with the provided `init.output` callback assigned as the output callback, the provided `init.error` callback as the error callback, and the [AudioDecoder.state] set to `\"unconfigured\"`.",
+      "close": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`close()`** method of the [AudioDecoder] interface ends all pending work and releases system resources.",
+      "configure": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`configure()`** method of the [AudioDecoder] interface enqueues a control message to configure the audio decoder for decoding chunks.",
+      "decode": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`decode()`** method of the [AudioDecoder] interface enqueues a control message to decode a given chunk of audio.",
+      "decodequeuesize": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`decodeQueueSize`** read-only property of the [AudioDecoder] interface returns the number of pending decode requests in the queue.",
+      "dequeue_event": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`dequeue`** event of the [AudioDecoder] interface fires to signal a decrease in [AudioDecoder.decodeQueueSize].\n\nThis eliminates the need for developers to use a [setTimeout] poll to determine when the queue has decreased, and more work should be queued up.",
+      "flush": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`flush()`** method of the [AudioDecoder] interface returns a Promise that resolves once all pending messages in the queue have been completed.",
+      "isconfigsupported_static": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`isConfigSupported()`** static method of the [AudioDecoder] interface checks if the given config is supported (that is, if [AudioDecoder] objects can be successfully configured with the given config).",
+      "reset": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`reset()`** method of the [AudioDecoder] interface resets all states including configuration, control messages in the control message queue, and all pending callbacks.",
+      "state": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`state`** read-only property of the [AudioDecoder] interface returns the current state of the underlying codec."
     }
   },
   "AudioDestinationNode": {
@@ -244,18 +244,18 @@
     }
   },
   "AudioEncoder": {
-    "docs": "The **`AudioEncoder`** interface of the [WebCodecs API](https://developer.mozilla.org/en-US/docs/Web/API/WebCodecs_API) encodes [AudioData] objects.",
+    "docs": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`AudioEncoder`** interface of the [WebCodecs API](https://developer.mozilla.org/en-US/docs/Web/API/WebCodecs_API) encodes [AudioData] objects.",
     "properties": {
-      "audioencoder": "The **`AudioEncoder()`** constructor creates a new [AudioEncoder] object with the provided `init.output` callback assigned as the output callback, the provided `init.error` callback as the error callback, and the [AudioEncoder.state] set to `\"unconfigured\"`.",
-      "close": "The **`close()`** method of the [AudioEncoder] interface ends all pending work and releases system resources.",
-      "configure": "The **`configure()`** method of the [AudioEncoder] interface enqueues a control message to configure the audio encoder for encoding chunks.",
-      "dequeue_event": "The **`dequeue`** event of the [AudioEncoder] interface fires to signal a decrease in [AudioEncoder.encodeQueueSize].\n\nThis eliminates the need for developers to use a [setTimeout] poll to determine when the queue has decreased, and more work should be queued up.",
-      "encode": "The **`encode()`** method of the [AudioEncoder] interface enqueues a control message to encode a given [AudioData] object.",
-      "encodequeuesize": "The **`encodeQueueSize`** read-only property of the [AudioEncoder] interface returns the number of pending encode requests in the queue.",
-      "flush": "The **`flush()`** method of the [AudioEncoder] interface returns a Promise that resolves once all pending messages in the queue have been completed.",
-      "isconfigsupported_static": "The **`isConfigSupported()`** static method of the [AudioEncoder] interface checks if the given config is supported (that is, if [AudioEncoder] objects can be successfully configured with the given config).",
-      "reset": "The **`reset()`** method of the [AudioEncoder] interface resets all states including configuration, control messages in the control message queue, and all pending callbacks.",
-      "state": "The **`state`** read-only property of the [AudioEncoder] interface returns the current state of the underlying codec."
+      "audioencoder": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`AudioEncoder()`** constructor creates a new [AudioEncoder] object with the provided `init.output` callback assigned as the output callback, the provided `init.error` callback as the error callback, and the [AudioEncoder.state] set to `\"unconfigured\"`.",
+      "close": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`close()`** method of the [AudioEncoder] interface ends all pending work and releases system resources.",
+      "configure": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`configure()`** method of the [AudioEncoder] interface enqueues a control message to configure the audio encoder for encoding chunks.",
+      "dequeue_event": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`dequeue`** event of the [AudioEncoder] interface fires to signal a decrease in [AudioEncoder.encodeQueueSize].\n\nThis eliminates the need for developers to use a [setTimeout] poll to determine when the queue has decreased, and more work should be queued up.",
+      "encode": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`encode()`** method of the [AudioEncoder] interface enqueues a control message to encode a given [AudioData] object.",
+      "encodequeuesize": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`encodeQueueSize`** read-only property of the [AudioEncoder] interface returns the number of pending encode requests in the queue.",
+      "flush": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`flush()`** method of the [AudioEncoder] interface returns a Promise that resolves once all pending messages in the queue have been completed.",
+      "isconfigsupported_static": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`isConfigSupported()`** static method of the [AudioEncoder] interface checks if the given config is supported (that is, if [AudioEncoder] objects can be successfully configured with the given config).",
+      "reset": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`reset()`** method of the [AudioEncoder] interface resets all states including configuration, control messages in the control message queue, and all pending callbacks.",
+      "state": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`state`** read-only property of the [AudioEncoder] interface returns the current state of the underlying codec."
     }
   },
   "AudioListener": {
@@ -408,10 +408,10 @@
     }
   },
   "BackgroundFetchEvent": {
-    "docs": "The **`BackgroundFetchEvent`** interface of the [Background Fetch API] is the event type for background fetch events dispatched on the [ServiceWorkerGlobalScope].\n\nIt is the event type passed to `onbackgroundfetchabort` and `onbackgroundfetchclick`.",
+    "docs": "@AvailableInWorkers(\"service\")\n\nThe **`BackgroundFetchEvent`** interface of the [Background Fetch API] is the event type for background fetch events dispatched on the [ServiceWorkerGlobalScope].\n\nIt is the event type passed to [ServiceWorkerGlobalScope.backgroundfetchclick_event] event and [ServiceWorkerGlobalScope.backgroundfetchabort_event] event.",
     "properties": {
-      "backgroundfetchevent": "The **`BackgroundFetchEvent()`** constructor creates a new [BackgroundFetchEvent] object. This constructor is not typically used as the browser creates these objects itself and provides them to background fetch event callbacks.",
-      "registration": "The **`registration`** read-only property of the [BackgroundFetchEvent] interface returns a [BackgroundFetchRegistration] object."
+      "backgroundfetchevent": "@AvailableInWorkers(\"service\")\n\nThe **`BackgroundFetchEvent()`** constructor creates a new [BackgroundFetchEvent] object. This constructor is not typically used as the browser creates these objects itself and provides them to background fetch event callbacks.",
+      "registration": "@AvailableInWorkers(\"service\")\n\nThe **`registration`** read-only property of the [BackgroundFetchEvent] interface returns a [BackgroundFetchRegistration] object."
     }
   },
   "BackgroundFetchManager": {
@@ -440,17 +440,17 @@
       "match": "The **`match()`** method of the [BackgroundFetchRegistration] interface returns the first matching [BackgroundFetchRecord].",
       "matchall": "The **`matchAll()`** method of the [BackgroundFetchRegistration] interface returns an array of matching [BackgroundFetchRecord] objects.",
       "progress_event": "The **`progress`** event of the [BackgroundFetchRegistration] interface thrown when the associated background fetch progresses.\n\nPractically, this event is fired when any of the following properties will return a new value:\n\n- [BackgroundFetchRegistration.uploaded],\n- [BackgroundFetchRegistration.downloaded],\n- [BackgroundFetchRegistration.result], or\n- [BackgroundFetchRegistration.failureReason].",
-      "recordsavailable": "The **`recordsAvailable`** read-only property of the [BackgroundFetchRegistration] interface returns `true` if there are requests and responses to be accessed. If this returns false then [BackgroundFetchRegistration.match] and [BackgroundFetchRegistration.matchAll] can't be used.",
+      "recordsavailable": "The **`recordsAvailable`** read-only property of the [BackgroundFetchRegistration] interface returns `true` if there are requests and responses to be accessed. If this returns `false`, then [BackgroundFetchRegistration.match] and [BackgroundFetchRegistration.matchAll] can't be used.",
       "result": "The **`result`** read-only property of the [BackgroundFetchRegistration] interface returns a string indicating whether the background fetch was successful or failed.\n\nIf the value of this property changes, the [progress](https://developer.mozilla.org/en-US/docs/Web/API/BackgroundFetchRegistration/progress_event) event is fired at the associated [BackgroundFetchRegistration] object.",
       "uploaded": "The **`uploaded`** read-only property of the [BackgroundFetchRegistration] interface returns the size in bytes successfully sent, initially `0`.\n\nIf the value of this property changes, the [progress](https://developer.mozilla.org/en-US/docs/Web/API/BackgroundFetchRegistration/progress_event) event is fired at the associated [BackgroundFetchRegistration] object.",
       "uploadtotal": "The **`uploadTotal`** read-only property of the [BackgroundFetchRegistration] interface returns the total number of bytes to be sent to the server."
     }
   },
   "BackgroundFetchUpdateUIEvent": {
-    "docs": "The **`BackgroundFetchUpdateUIEvent`** interface of the [Background Fetch API] is an event type for the [ServiceWorkerGlobalScope.backgroundfetchsuccess_event] and [ServiceWorkerGlobalScope.backgroundfetchfail_event] events, and provides a method for updating the title and icon of the app to inform a user of the success or failure of a background fetch.",
+    "docs": "@AvailableInWorkers(\"service\")\n\nThe **`BackgroundFetchUpdateUIEvent`** interface of the [Background Fetch API] is an event type for the [ServiceWorkerGlobalScope.backgroundfetchsuccess_event] and [ServiceWorkerGlobalScope.backgroundfetchfail_event] events, and provides a method for updating the title and icon of the app to inform a user of the success or failure of a background fetch.",
     "properties": {
-      "backgroundfetchupdateuievent": "The **`BackgroundFetchUpdateUIEvent()`** constructor creates a new [BackgroundFetchUpdateUIEvent] object. This constructor is not typically used as the browser creates these objects itself and provides them to background fetch event callbacks.",
-      "updateui": "The **`updateUI()`** method of the [BackgroundFetchUpdateUIEvent] interface updates the title and icon in the user interface to show the status of a background fetch.\n\nThis method may only be run once, to notify the user on a failed or a successful fetch."
+      "backgroundfetchupdateuievent": "@AvailableInWorkers(\"service\")\n\nThe **`BackgroundFetchUpdateUIEvent()`** constructor creates a new [BackgroundFetchUpdateUIEvent] object. This constructor is not typically used as the browser creates these objects itself and provides them to background fetch event callbacks.",
+      "updateui": "@AvailableInWorkers(\"service\")\n\nThe **`updateUI()`** method of the [BackgroundFetchUpdateUIEvent] interface updates the title and icon in the user interface to show the status of a background fetch.\n\nThis method may only be run once, to notify the user on a failed or a successful fetch."
     }
   },
   "BarProp": {
@@ -499,16 +499,16 @@
     }
   },
   "BatteryManager": {
-    "docs": "The `BatteryManager` interface of the [Battery Status API] provides information about the system's battery charge level. The [navigator.getBattery] method returns a promise that resolves with a `BatteryManager` interface.\n\nSince Chrome 103, the `BatteryManager` interface of [Battery Status API] only expose to secure context.",
+    "docs": "The **`BatteryManager`** interface of the [Battery Status API] provides information about the system's battery charge level. The [navigator.getBattery] method returns a promise that resolves with a `BatteryManager` interface.\n\nSince Chrome 103, the `BatteryManager` interface of [Battery Status API] only expose to secure context.",
     "properties": {
-      "charging": "The **`BatteryManager.charging`** property is a Boolean value indicating whether or not the device's battery is currently being charged. When its value changes, the [BatteryManager.chargingchange_event] event is fired.\n\nIf the battery is charging or the user agent is unable to report the battery status information, this value is `true`. Otherwise, it is `false`.",
-      "chargingchange_event": "The **`chargingchange`** event of the [Battery Status API] is fired when the battery [BatteryManager.charging] property is updated.",
-      "chargingtime": "The **`BatteryManager.chargingTime`** property indicates the amount of time, in seconds, that remain until the battery is fully charged, or `0` if the battery is already fully charged or the user agent is unable to report the battery status information.\nIf the battery is currently discharging, its value is `Infinity`.\nWhen its value changes, the [BatteryManager.chargingtimechange_event] event is fired.\n\n> **Note:** Even if the time returned is precise to the second,\n> browsers round them to a higher interval\n> (typically to the closest 15 minutes) for privacy reasons.",
-      "chargingtimechange_event": "The **`chargingtimechange`** event of the [Battery Status API] is fired when the battery [BatteryManager.chargingTime] property is updated.",
-      "dischargingtime": "The **`BatteryManager.dischargingTime`** property indicates the amount of time, in seconds, that remains until the battery is fully discharged,\nor `Infinity` if the battery is currently charging rather than discharging or the user agent is unable to report the battery status information.\nWhen its value changes, the [BatteryManager.dischargingtimechange_event] event is fired.\n\n> **Note:** Even if the time returned is precise to the second, browsers round them to a higher\n> interval (typically to the closest 15 minutes) for privacy reasons.",
-      "dischargingtimechange_event": "The **`dischargingtimechange`** event of the [Battery Status API] is fired when the battery [BatteryManager.dischargingTime] property is updated.",
-      "level": "The **`BatteryManager.level`** property indicates the current battery charge level as a value between `0.0` and `1.0`.\nA value of `0.0` means the battery is empty and the system is about to be suspended.\nA value of `1.0` means the battery is full or the user agent is unable to report the battery status information.\nWhen its value changes, the [BatteryManager.levelchange_event] event is fired.",
-      "levelchange_event": "The **`levelchange`** event of the [Battery Status API] is fired when the battery [BatteryManager.level] property is updated."
+      "charging": "The **`charging`** read-only property of the [BatteryManager] interface is a Boolean value indicating whether or not the device's battery is currently being charged. When its value changes, the [BatteryManager.chargingchange_event] event is fired.\n\nIf the battery is charging or the user agent is unable to report the battery status information, this value is `true`. Otherwise, it is `false`.",
+      "chargingchange_event": "The **`chargingchange`** event of the [BatteryManager] interface is fired when the battery [BatteryManager.charging] property is updated.",
+      "chargingtime": "The **`chargingTime`** read-only property of the [BatteryManager] interface indicates the amount of time, in seconds, that remain until the battery is fully charged, or `0` if the battery is already fully charged or the user agent is unable to report the battery status information.\nIf the battery is currently discharging, its value is `Infinity`.\nWhen its value changes, the [BatteryManager.chargingtimechange_event] event is fired.\n\n> **Note:** Even if the time returned is precise to the second,\n> browsers round them to a higher interval\n> (typically to the closest 15 minutes) for privacy reasons.",
+      "chargingtimechange_event": "The **`chargingtimechange`** event of the [BatteryManager] interface is fired when the battery [BatteryManager.chargingTime] property is updated.",
+      "dischargingtime": "The **`dischargingTime`** read-only property of the [BatteryManager] interface indicates the amount of time, in seconds, that remains until the battery is fully discharged,\nor `Infinity` if the battery is currently charging rather than discharging or the user agent is unable to report the battery status information.\nWhen its value changes, the [BatteryManager.dischargingtimechange_event] event is fired.\n\n> **Note:** Even if the time returned is precise to the second, browsers round them to a higher\n> interval (typically to the closest 15 minutes) for privacy reasons.",
+      "dischargingtimechange_event": "The **`dischargingtimechange`** event of the [BatteryManager] interface is fired when the battery [BatteryManager.dischargingTime] property is updated.",
+      "level": "The **`level`** read-only property of the [BatteryManager] interface indicates the current battery charge level as a value between `0.0` and `1.0`.\nA value of `0.0` means the battery is empty and the system is about to be suspended.\nA value of `1.0` means the battery is full or the user agent is unable to report the battery status information.\nWhen its value changes, the [BatteryManager.levelchange_event] event is fired.",
+      "levelchange_event": "The **`levelchange`** event of the [BatteryManager] interface is fired when the battery [BatteryManager.level] property is updated."
     }
   },
   "BeforeInstallPromptEvent": {
@@ -539,7 +539,7 @@
     }
   },
   "Blob": {
-    "docs": "The **`Blob`** object represents a blob, which is a file-like object of immutable, raw data; they can be read as text or binary data, or converted into a [ReadableStream] so its methods can be used for processing the data.\n\nBlobs can represent data that isn't necessarily in a JavaScript-native format. The [File] interface is based on `Blob`, inheriting blob functionality and expanding it to support files on the user's system.",
+    "docs": "The **`Blob`** interface represents a blob, which is a file-like object of immutable, raw data; they can be read as text or binary data, or converted into a [ReadableStream] so its methods can be used for processing the data.\n\nBlobs can represent data that isn't necessarily in a JavaScript-native format. The [File] interface is based on `Blob`, inheriting blob functionality and expanding it to support files on the user's system.",
     "properties": {
       "arraybuffer": "The **`arrayBuffer()`** method of the [Blob]\ninterface returns a `Promise` that resolves with the contents of the blob as\nbinary data contained in an `ArrayBuffer`.",
       "blob": "The **`Blob()`** constructor returns a\nnew [Blob] object. The content of the blob consists of the concatenation\nof the values given in the parameter `array`.",
@@ -795,55 +795,55 @@
     }
   },
   "CSSMathInvert": {
-    "docs": "The **`CSSMathInvert`** interface of the  represents a CSS `calc()` used as `calc(1 / <value>).` It inherits properties and methods from its parent [CSSNumericValue].",
+    "docs": "The **`CSSMathInvert`** interface of the [CSS Typed Object Model API](https://developer.mozilla.org/en-US/docs/Web/API/CSS_Object_Model) represents a CSS `calc()` used as `calc(1 / <value>).` It inherits properties and methods from its parent [CSSNumericValue].",
     "properties": {
       "cssmathinvert": "The **`CSSMathInvert()`** constructor creates a\nnew [CSSMathInvert] object which represents a CSS\n`calc()` used as `calc(1 / value)`",
       "value": "The CSSMathInvert.value read-only property of the\n[CSSMathInvert] interface returns a [CSSNumericValue] object."
     }
   },
   "CSSMathMax": {
-    "docs": "The **`CSSMathMax`** interface of the  represents the CSS `max()` function. It inherits properties and methods from its parent [CSSNumericValue].",
+    "docs": "The **`CSSMathMax`** interface of the [CSS Typed Object Model API](https://developer.mozilla.org/en-US/docs/Web/API/CSS_Object_Model) represents the CSS `max()` function. It inherits properties and methods from its parent [CSSNumericValue].",
     "properties": {
       "cssmathmax": "The **`CSSMathMax()`** constructor creates a\nnew [CSSMathMax] object which represents the CSS `max()` function.",
       "values": "The CSSMathMax.values read-only property of the\n[CSSMathMax] interface returns a [CSSNumericArray] object\nwhich contains one or more [CSSNumericValue] objects."
     }
   },
   "CSSMathMin": {
-    "docs": "The **`CSSMathMin`** interface of the  represents the CSS `min()` function. It inherits properties and methods from its parent [CSSNumericValue].",
+    "docs": "The **`CSSMathMin`** interface of the [CSS Typed Object Model API](https://developer.mozilla.org/en-US/docs/Web/API/CSS_Object_Model) represents the CSS `min()` function. It inherits properties and methods from its parent [CSSNumericValue].",
     "properties": {
       "cssmathmin": "The **`CSSMathMin()`** constructor creates a\nnew [CSSMathMin] object which represents the CSS\n`min()` function.",
       "values": "The CSSMathMin.values read-only property of the\n[CSSMathMin] interface returns a [CSSNumericArray] object\nwhich contains one or more [CSSNumericValue] objects."
     }
   },
   "CSSMathNegate": {
-    "docs": "The **`CSSMathNegate`** interface of the  negates the value passed into it. It inherits properties and methods from its parent [CSSNumericValue].",
+    "docs": "The **`CSSMathNegate`** interface of the [CSS Typed Object Model API](https://developer.mozilla.org/en-US/docs/Web/API/CSS_Object_Model) negates the value passed into it. It inherits properties and methods from its parent [CSSNumericValue].",
     "properties": {
       "cssmathnegate": "The **`CSSMathNegate()`** constructor creates a\nnew [CSSMathNegate] object which negates the value passed into it.",
       "value": "The CSSMathNegate.value read-only property of the\n[CSSMathNegate] interface returns a [CSSNumericValue] object."
     }
   },
   "CSSMathProduct": {
-    "docs": "The **`CSSMathProduct`** interface of the  represents the result obtained by calling [CSSNumericValue.add], [CSSNumericValue.sub], or [CSSNumericValue.toSum] on [CSSNumericValue]. It inherits properties and methods from its parent [CSSNumericValue].",
+    "docs": "The **`CSSMathProduct`** interface of the [CSS Typed Object Model API](https://developer.mozilla.org/en-US/docs/Web/API/CSS_Object_Model) represents the result obtained by calling [CSSNumericValue.add], [CSSNumericValue.sub], or [CSSNumericValue.toSum] on [CSSNumericValue]. It inherits properties and methods from its parent [CSSNumericValue].",
     "properties": {
       "cssmathproduct": "The **`CSSMathProduct()`** constructor creates\na new [CSSMathProduct] object which creates a new\n[CSSMathProduct] object which multiplies the arguments passed into it.",
       "values": "The **`CSSMathProduct.values`** read-only\nproperty of the [CSSMathProduct] interface returns a\n[CSSNumericArray] object which contains one or more\n[CSSNumericValue] objects."
     }
   },
   "CSSMathSum": {
-    "docs": "The **`CSSMathSum`** interface of the  represents the result obtained by calling [CSSNumericValue.add], [CSSNumericValue.sub], or [CSSNumericValue.toSum] on [CSSNumericValue].\n\nA CSSMathSum is the object type returned when the [`StylePropertyMapReadOnly.get()`](https://developer.mozilla.org/en-US/docs/Web/API/StylePropertyMapReadOnly/get) method is used on a CSS property whose value is created with a [`calc()`](https://developer.mozilla.org/en-US/docs/Web/CSS/calc) function.",
+    "docs": "The **`CSSMathSum`** interface of the [CSS Typed Object Model API](https://developer.mozilla.org/en-US/docs/Web/API/CSS_Object_Model) represents the result obtained by calling [CSSNumericValue.add], [CSSNumericValue.sub], or [CSSNumericValue.toSum] on [CSSNumericValue].\n\nA CSSMathSum is the object type returned when the [`StylePropertyMapReadOnly.get()`](https://developer.mozilla.org/en-US/docs/Web/API/StylePropertyMapReadOnly/get) method is used on a CSS property whose value is created with a [`calc()`](https://developer.mozilla.org/en-US/docs/Web/CSS/calc) function.",
     "properties": {
       "cssmathsum": "The **`CSSMathSum()`** constructor creates a\nnew [CSSMathSum] object which creates a new [CSSKeywordValue]\nobject which represents the result obtained by calling\n[CSSNumericValue.add], [CSSNumericValue.sub],\nor [CSSNumericValue.toSum] on [CSSNumericValue].",
       "values": "The **`CSSMathSum.values`** read-only property\nof the [CSSMathSum] interface returns a [CSSNumericArray]\nobject which contains one or more [CSSNumericValue] objects."
     }
   },
   "CSSMathValue": {
-    "docs": "The **`CSSMathValue`** interface of the  a base class for classes representing complex numeric values.",
+    "docs": "The **`CSSMathValue`** interface of the [CSS Typed Object Model API](https://developer.mozilla.org/en-US/docs/Web/API/CSS_Object_Model) a base class for classes representing complex numeric values.",
     "properties": {
       "operator": "The **`CSSMathValue.operator`** read-only\nproperty of the [CSSMathValue] interface indicates the operator that the\ncurrent subtype represents. For example, if the current `CSSMathValue`\nsubtype is `CSSMathSum`, this property will return the string\n`\"sum\"`."
     }
   },
   "CSSMatrixComponent": {
-    "docs": "The **`CSSMatrixComponent`** interface of the  represents the [matrix()](https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/matrix) and [matrix3d()](https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/matrix3d) values of the individual `transform` property in CSS. It inherits properties and methods from its parent [CSSTransformValue].",
+    "docs": "The **`CSSMatrixComponent`** interface of the [CSS Typed Object Model API](https://developer.mozilla.org/en-US/docs/Web/API/CSS_Object_Model) represents the [matrix()](https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/matrix) and [matrix3d()](https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/matrix3d) values of the individual `transform` property in CSS. It inherits properties and methods from its parent [CSSTransformValue].",
     "properties": {
       "cssmatrixcomponent": "The **`CSSMatrixComponent()`** constructor\ncreates a new [CSSMatrixComponent] object representing the [matrix()](https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/matrix) and [matrix3d()](https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/matrix3d) values of the\nindividual `transform` property in CSS.",
       "matrix": "The **`matrix`** property of the\n[CSSMatrixComponent] interface gets and sets a 2d or 3d matrix.\n\nSee the [matrix()](https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/matrix) and [matrix3d()](https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/matrix3d) pages for\nexamples."
@@ -863,7 +863,7 @@
     }
   },
   "CSSNumericArray": {
-    "docs": "The **`CSSNumericArray`** interface of the  contains a list of [CSSNumericValue] objects.",
+    "docs": "The **`CSSNumericArray`** interface of the [CSS Typed Object Model API](https://developer.mozilla.org/en-US/docs/Web/API/CSS_Object_Model) contains a list of [CSSNumericValue] objects.",
     "properties": {
       "length": "The read-only **`length`** property of the\n[CSSNumericArray] interface returns the number of\n[CSSNumericValue] objects in the list."
     }
@@ -892,7 +892,7 @@
     }
   },
   "CSSPerspective": {
-    "docs": "The **`CSSPerspective`** interface of the  represents the [perspective()](https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/perspective) value of the individual `transform` property in CSS. It inherits properties and methods from its parent [CSSTransformValue].",
+    "docs": "The **`CSSPerspective`** interface of the [CSS Typed Object Model API](https://developer.mozilla.org/en-US/docs/Web/API/CSS_Object_Model) represents the [perspective()](https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/perspective) value of the individual `transform` property in CSS. It inherits properties and methods from its parent [CSSTransformValue].",
     "properties": {
       "cssperspective": "The **`CSSPerspective()`** constructor creates\na new [CSSPerspective] object representing the [perspective()](https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/perspective) value of\nthe individual `transform` property in CSS.",
       "length": "The **`length`** property of the\n[CSSPerspective] interface sets the distance from z=0.\n\nIt is used to apply a perspective transform to the element and its content. If the\nvalue is 0 or a negative number, no perspective transform is applied."
@@ -936,7 +936,7 @@
     }
   },
   "CSSRotate": {
-    "docs": "The **`CSSRotate`** interface of the  represents the rotate value of the individual `transform` property in CSS. It inherits properties and methods from its parent [CSSTransformValue].",
+    "docs": "The **`CSSRotate`** interface of the [CSS Typed Object Model API](https://developer.mozilla.org/en-US/docs/Web/API/CSS_Object_Model) represents the rotate value of the individual `transform` property in CSS. It inherits properties and methods from its parent [CSSTransformValue].",
     "properties": {
       "angle": "The **`angle`** property of the\n[CSSRotate] interface gets and sets the angle of rotation. A positive angle\ndenotes a clockwise rotation, a negative angle a counter-clockwise one.",
       "cssrotate": "The **`CSSRotate()`** constructor creates a new\n[CSSRotate] object representing the [rotate()](https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/rotate) value of the\nindividual `transform` property in CSS.",
@@ -962,7 +962,7 @@
     }
   },
   "CSSScale": {
-    "docs": "The **`CSSScale`** interface of the  represents the [scale()](https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/scale) and [scale3d()](https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/scale3d) values of the individual `transform` property in CSS. It inherits properties and methods from its parent [CSSTransformValue].",
+    "docs": "The **`CSSScale`** interface of the [CSS Typed Object Model API](https://developer.mozilla.org/en-US/docs/Web/API/CSS_Object_Model) represents the [scale()](https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/scale) and [scale3d()](https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/scale3d) values of the individual `transform` property in CSS. It inherits properties and methods from its parent [CSSTransformValue].",
     "properties": {
       "cssscale": "The **`CSSScale()`** constructor creates a new\n[CSSScale] object representing the [scale()](https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/scale) and [scale3d()](https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/scale3d) values of the\nindividual `transform` property in CSS.",
       "x": "The **`x`** property of the\n[CSSScale] interface gets and sets the abscissa or x-axis of the\ntranslating vector.",
@@ -978,7 +978,7 @@
     }
   },
   "CSSSkew": {
-    "docs": "The **`CSSSkew`** interface of the  is part of the [CSSTransformValue] interface. It represents the [`skew()`](https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/skew) value of the individual `transform` property in CSS.",
+    "docs": "The **`CSSSkew`** interface of the [CSS Typed Object Model API](https://developer.mozilla.org/en-US/docs/Web/API/CSS_Object_Model) is part of the [CSSTransformValue] interface. It represents the [`skew()`](https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/skew) value of the individual `transform` property in CSS.",
     "properties": {
       "ax": "The **`ax`** property of the\n[CSSSkew] interface gets and sets the angle used to distort the element\nalong the x-axis (or abscissa).",
       "ay": "The **`ay`** property of the\n[CSSSkew] interface gets and sets the angle used to distort the element\nalong the y-axis (or ordinate).",
@@ -986,14 +986,14 @@
     }
   },
   "CSSSkewX": {
-    "docs": "The **`CSSSkewX`** interface of the  represents the [`skewX()`](https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/skewX) value of the individual `transform` property in CSS. It inherits properties and methods from its parent [CSSTransformValue].",
+    "docs": "The **`CSSSkewX`** interface of the [CSS Typed Object Model API](https://developer.mozilla.org/en-US/docs/Web/API/CSS_Object_Model) represents the [`skewX()`](https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/skewX) value of the individual `transform` property in CSS. It inherits properties and methods from its parent [CSSTransformValue].",
     "properties": {
       "ax": "The **`ax`** property of the\n[CSSSkewX] interface gets and sets the angle used to distort the element\nalong the x-axis (or abscissa).",
       "cssskewx": "The **`CSSSkewX()`** constructor creates a new\n[CSSSkewX] object which represents the\n[`skewX()`](https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/skewX)\nvalue of the individual `transform` property in CSS."
     }
   },
   "CSSSkewY": {
-    "docs": "The **`CSSSkewY`** interface of the  represents the [`skewY()`](https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/skewY) value of the individual `transform` property in CSS. It inherits properties and methods from its parent [CSSTransformValue].",
+    "docs": "The **`CSSSkewY`** interface of the [CSS Typed Object Model API](https://developer.mozilla.org/en-US/docs/Web/API/CSS_Object_Model) represents the [`skewY()`](https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/skewY) value of the individual `transform` property in CSS. It inherits properties and methods from its parent [CSSTransformValue].",
     "properties": {
       "ay": "The **`ay`** property of the\n[CSSSkewY] interface gets and sets the angle used to distort the element\nalong the y-axis (or ordinate).",
       "cssskewy": "The **`CSSSkewY()`** constructor creates a new\n[CSSSkewY] object which represents the\n[`skewY()`](https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/skewY) value\nof the individual `transform` property in CSS."
@@ -1051,7 +1051,7 @@
     "docs": "The **`CSSSupportsRule`** interface represents a single CSS  [at-rule](https://developer.mozilla.org/en-US/docs/Web/CSS/At-rule)."
   },
   "CSSTransformComponent": {
-    "docs": "The **`CSSTransformComponent`** interface of the  is part of the [CSSTransformValue] interface.",
+    "docs": "The **`CSSTransformComponent`** interface of the [CSS Typed Object Model API](https://developer.mozilla.org/en-US/docs/Web/API/CSS_Object_Model) is part of the [CSSTransformValue] interface.",
     "properties": {
       "is2d": "The **`is2D`** read-only property of the [CSSTransformComponent] interface indicates where the transform is 2D or 3D.",
       "tomatrix": "The **`toMatrix()`** method of the\n[CSSTransformComponent] interface returns a [DOMMatrix]\nobject.\n\nAll transform functions can be represented mathematically as a 4x4 transformation matrix. This is explained in detail in [Understanding the CSS Transforms matrix](https://dev.opera.com/articles/understanding-the-css-transforms-matrix/).\n\n> **Note:** The `is2D` property affects what transform, and therefore type of matrix that will be returned. CSS 2D and 3D transforms are different for legacy reasons. A brief explanation of 2D vs. 3D transforms can be found in [Using CSS transforms](https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_transforms/Using_CSS_transforms).",
@@ -1059,7 +1059,7 @@
     }
   },
   "CSSTransformValue": {
-    "docs": "The **`CSSTransformValue`** interface of the  represents `transform-list` values as used by the CSS `transform` property.",
+    "docs": "The **`CSSTransformValue`** interface of the [CSS Typed Object Model API](https://developer.mozilla.org/en-US/docs/Web/API/CSS_Object_Model) represents `transform-list` values as used by the CSS `transform` property.",
     "properties": {
       "csstransformvalue": "The **`CSSTransformValue()`** constructor\ncreates a new [CSSTransformValue] object which represents a list of\nindividual transform objects.",
       "entries": "The **`CSSTransformValue.entries()`** method\nreturns an array of a given object's own enumerable\nproperty `[key, value]` pairs in the same order as that provided by a\n[`for...in`](/en-US/docs/Web/JavaScript/Reference/Statements/for...in) loop (the difference being that a for-in loop enumerates\nproperties in the prototype chain as well).",
@@ -1078,7 +1078,7 @@
     }
   },
   "CSSTranslate": {
-    "docs": "The **`CSSTranslate`** interface of the  represents the [translate()](https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/translate) value of the individual `transform` property in CSS. It inherits properties and methods from its parent [CSSTransformValue].",
+    "docs": "The **`CSSTranslate`** interface of the [CSS Typed Object Model API](https://developer.mozilla.org/en-US/docs/Web/API/CSS_Object_Model) represents the [translate()](https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/translate) value of the individual `transform` property in CSS. It inherits properties and methods from its parent [CSSTransformValue].",
     "properties": {
       "csstranslate": "The **`CSSTranslate()`** constructor creates a\nnew [CSSTranslate] object representing the [translate()](https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/translate) value of the\nindividual `transform` property in CSS.",
       "x": "The **`x`** property of the\n[CSSTranslate] interface gets and sets the abscissa or x-axis of the\ntranslating vector.",
@@ -1087,7 +1087,7 @@
     }
   },
   "CSSUnitValue": {
-    "docs": "The **`CSSUnitValue`** interface of the  represents values that contain a single unit type. For example, \"42px\" would be represented by a `CSSNumericValue`.",
+    "docs": "The **`CSSUnitValue`** interface of the [CSS Typed Object Model API](/en-US/docs/Web/API/CSS_Object_Model#css_typed_object_model) represents values that contain a single unit type. For example, \"42px\" would be represented by a `CSSNumericValue`.",
     "properties": {
       "cssunitvalue": "The **`CSSUnitValue()`** constructor creates a\nnew [CSSUnitValue] object which returns a new [CSSUnitValue]\nobject which represents values that contain a single unit type. For example, \"42px\"\nwould be represented by a `CSSNumericValue`.",
       "unit": "The **`CSSUnitValue.unit`** read-only property\nof the [CSSUnitValue] interface returns a string\nindicating the type of unit.",
@@ -1095,7 +1095,7 @@
     }
   },
   "CSSUnparsedValue": {
-    "docs": "The **`CSSUnparsedValue`** interface of the  represents property values that reference [custom properties](https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_cascading_variables). It consists of a list of string fragments and variable references.\n\nCustom properties are represented by `CSSUnparsedValue` and `var()` references are represented using [CSSVariableReferenceValue].",
+    "docs": "The **`CSSUnparsedValue`** interface of the [CSS Typed Object Model API](https://developer.mozilla.org/en-US/docs/Web/API/CSS_Object_Model) represents property values that reference [custom properties](https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_cascading_variables). It consists of a list of string fragments and variable references.\n\nCustom properties are represented by `CSSUnparsedValue` and `var()` references are represented using [CSSVariableReferenceValue].",
     "properties": {
       "cssunparsedvalue": "The **`CSSUnparsedValue()`** constructor\ncreates a new [CSSUnparsedValue] object which represents property values\nthat reference custom properties.",
       "entries": "The **`CSSUnparsedValue.entries()`** method\nreturns an array of a given object's own enumerable property `[key, value]`\npairs in the same order as that provided by a `for...in` loop (the difference being that a for-in loop enumerates properties in the prototype chain as well).",
@@ -1120,7 +1120,7 @@
     }
   },
   "CSSVariableReferenceValue": {
-    "docs": "The **`CSSVariableReferenceValue`** interface of the  allows you to create a custom name for a built-in CSS value. This object functionality is sometimes called a \"CSS variable\" and serves the same purpose as the `var()` function. The custom name must begin with two dashes.",
+    "docs": "The **`CSSVariableReferenceValue`** interface of the [CSS Typed Object Model API](https://developer.mozilla.org/en-US/docs/Web/API/CSS_Object_Model) allows you to create a custom name for a built-in CSS value. This object functionality is sometimes called a \"CSS variable\" and serves the same purpose as the `var()` function. The custom name must begin with two dashes.",
     "properties": {
       "cssvariablereferencevalue": "Creates a new [CSSVariableReferenceValue].",
       "fallback": "The **`fallback`** read-only property of the\n[CSSVariableReferenceValue] interface returns the [custom property fallback value](/en-US/docs/Web/CSS/Using_CSS_custom_properties#custom_property_fallback_values) of the [CSSVariableReferenceValue].",
@@ -1140,20 +1140,20 @@
     }
   },
   "CacheStorage": {
-    "docs": "The **`CacheStorage`** interface represents the storage for [Cache] objects.\n\nThe interface:\n\n- Provides a master directory of all the named caches that can be accessed by a [ServiceWorker] or other type of worker or [window] scope (you're not limited to only using it with service workers).\n- Maintains a mapping of string names to corresponding [Cache] objects.\n\nUse [CacheStorage.open] to obtain a [Cache] instance.\n\nUse [CacheStorage.match] to check if a given [Request] is a key in any of the [Cache] objects that the `CacheStorage` object tracks.\n\nYou can access `CacheStorage` through the global [caches] property.\n\n> **Note:** `CacheStorage` always rejects with a `SecurityError` on untrusted origins (i.e. those that aren't using HTTPS, although this definition will likely become more complex in the future.) When testing on Firefox, you can get around this by checking the **Enable Service Workers over HTTP (when toolbox is open)** option in the Firefox Devtools options/gear menu. Furthermore, because `CacheStorage` requires file-system access, it may be unavailable in private mode in Firefox.\n\n> **Note:** [CacheStorage.match] is a convenience method. Equivalent functionality to match a cache entry can be implemented by returning an array of cache names from [CacheStorage.keys], opening each cache with [CacheStorage.open], and matching the one you want with [Cache.match].",
+    "docs": "The **`CacheStorage`** interface represents the storage for [Cache] objects.\n\nThe interface:\n\n- Provides a master directory of all the named caches that can be accessed by a [ServiceWorker] or other type of worker or [window] scope (you're not limited to only using it with service workers).\n- Maintains a mapping of string names to corresponding [Cache] objects.\n\nUse [CacheStorage.open] to obtain a [Cache] instance.\n\nUse [CacheStorage.match] to check if a given [Request] is a key in any of the [Cache] objects that the `CacheStorage` object tracks.\n\nYou can access `CacheStorage` through the [Window.caches] property in windows or through the [WorkerGlobalScope.caches] property in workers.\n\n> **Note:** `CacheStorage` always rejects with a `SecurityError` on untrusted origins (i.e. those that aren't using HTTPS, although this definition will likely become more complex in the future.) When testing on Firefox, you can get around this by checking the **Enable Service Workers over HTTP (when toolbox is open)** option in the Firefox Devtools options/gear menu. Furthermore, because `CacheStorage` requires file-system access, it may be unavailable in private mode in Firefox.\n\n> **Note:** [CacheStorage.match] is a convenience method. Equivalent functionality to match a cache entry can be implemented by returning an array of cache names from [CacheStorage.keys], opening each cache with [CacheStorage.open], and matching the one you want with [Cache.match].",
     "properties": {
-      "delete": "The **`delete()`** method of the [CacheStorage] interface finds the [Cache] object matching the `cacheName`, and if found, deletes the [Cache] object and returns a `Promise` that resolves to `true`.\nIf no [Cache] object is found, it resolves to `false`.\n\nYou can access `CacheStorage` through the global [caches] property.",
-      "has": "The **`has()`** method of the [CacheStorage]\ninterface returns a `Promise` that resolves to `true` if a\n[Cache] object matches the `cacheName`.\n\nYou can access `CacheStorage` through the global [caches] property.",
-      "keys": "The **`keys()`** method of the [CacheStorage] interface returns a `Promise` that will resolve with an array containing strings corresponding to all of the named [Cache] objects tracked by the [CacheStorage] object in the order they were created.\nUse this method to iterate over a list of all [Cache] objects.\n\nYou can access `CacheStorage` through the global [caches] property.",
-      "match": "The **`match()`** method of the [CacheStorage] interface checks if a given [Request] or URL string is a key for a stored [Response].\nThis method returns a `Promise` for a [Response], or a `Promise` which resolves to `undefined` if no match is found.\n\nYou can access `CacheStorage` through the global\n[caches] property.\n\n`Cache` objects are searched in creation order.\n\n> **Note:** [CacheStorage.match] is a convenience method.\n> Equivalent functionality is to call [cache.match] on each cache (in the order returned by [CacheStorage.keys]) until a [Response] is returned.",
-      "open": "The **`open()`** method of the\n[CacheStorage] interface returns a `Promise` that resolves to\nthe [Cache] object matching the `cacheName`.\n\nYou can access `CacheStorage` through the global\n[caches] property.\n\n> **Note:** If the specified [Cache] does not exist, a new\n> cache is created with that `cacheName` and a `Promise` that\n> resolves to this new [Cache] object is returned."
+      "delete": "The **`delete()`** method of the [CacheStorage] interface finds the [Cache] object matching the `cacheName`, and if found, deletes the [Cache] object and returns a `Promise` that resolves to `true`.\nIf no [Cache] object is found, it resolves to `false`.\n\nYou can access `CacheStorage` through the [Window.caches] property in windows or through the [WorkerGlobalScope.caches] property in workers.",
+      "has": "The **`has()`** method of the [CacheStorage]\ninterface returns a `Promise` that resolves to `true` if a\n[Cache] object matches the `cacheName`.\n\nYou can access `CacheStorage` through the [Window.caches] property in windows or through the [WorkerGlobalScope.caches] property in workers.",
+      "keys": "The **`keys()`** method of the [CacheStorage] interface returns a `Promise` that will resolve with an array containing strings corresponding to all of the named [Cache] objects tracked by the [CacheStorage] object in the order they were created.\nUse this method to iterate over a list of all [Cache] objects.\n\nYou can access `CacheStorage` through the [Window.caches] property in windows or through the [WorkerGlobalScope.caches] property in workers.",
+      "match": "The **`match()`** method of the [CacheStorage] interface checks if a given [Request] or URL string is a key for a stored [Response].\nThis method returns a `Promise` for a [Response], or a `Promise` which resolves to `undefined` if no match is found.\n\nYou can access `CacheStorage` through the [Window.caches] property in windows or through the [WorkerGlobalScope.caches] property in workers.\n\n`Cache` objects are searched in creation order.\n\n> **Note:** [CacheStorage.match] is a convenience method.\n> Equivalent functionality is to call [cache.match] on each cache (in the order returned by [CacheStorage.keys]) until a [Response] is returned.",
+      "open": "The **`open()`** method of the\n[CacheStorage] interface returns a `Promise` that resolves to\nthe [Cache] object matching the `cacheName`.\n\nYou can access `CacheStorage` through the [Window.caches] property in windows or through the [WorkerGlobalScope.caches] property in workers.\n\n> **Note:** If the specified [Cache] does not exist, a new\n> cache is created with that `cacheName` and a `Promise` that\n> resolves to this new [Cache] object is returned."
     }
   },
   "CanMakePaymentEvent": {
-    "docs": "The **`CanMakePaymentEvent`** interface of the [Payment Handler API] is the event object for the [ServiceWorkerGlobalScope.canmakepayment_event] event, fired on a payment app's service worker to check whether it is ready to handle a payment. Specifically, it is fired when the merchant website calls [PaymentRequest.PaymentRequest].",
+    "docs": "@AvailableInWorkers(\"service\")\n\nThe **`CanMakePaymentEvent`** interface of the [Payment Handler API] is the event object for the [ServiceWorkerGlobalScope.canmakepayment_event] event, fired on a payment app's service worker to check whether it is ready to handle a payment. Specifically, it is fired when the merchant website calls [PaymentRequest.PaymentRequest].",
     "properties": {
-      "canmakepaymentevent": "The **`CanMakePaymentEvent()`** constructor creates a new [CanMakePaymentEvent] object instance.",
-      "respondwith": "The **`respondWith()`** method of the [CanMakePaymentEvent] interface enables the service worker to respond appropriately to signal whether it is ready to handle payments."
+      "canmakepaymentevent": "@AvailableInWorkers(\"service\")\n\nThe **`CanMakePaymentEvent()`** constructor creates a new [CanMakePaymentEvent] object instance.",
+      "respondwith": "@AvailableInWorkers(\"service\")\n\nThe **`respondWith()`** method of the [CanMakePaymentEvent] interface enables the service worker to respond appropriately to signal whether it is ready to handle payments."
     }
   },
   "CanvasCaptureMediaStreamTrack": {
@@ -1294,7 +1294,7 @@
       "insertdata": "The **`insertData()`** method of the [CharacterData] interface\ninserts the provided data into this `CharacterData` node's current data,\nat the provided offset from the start of the existing data.\nThe provided data is spliced into the existing data.",
       "length": "The read-only **`CharacterData.length`** property\nreturns the number of characters in the contained data, as a positive integer.",
       "nextelementsibling": "The read-only **`nextElementSibling`** property of the [CharacterData] interface\nreturns the first [Element] node following the specified one in its parent's\nchildren list, or `null` if the specified element is the last one in the list.",
-      "previouselementsibling": "The read-only **`previousElementSibling`** of the [CharacterData] interface\nreturns the first [Element] before the current node in its parent's children list,\nor `null` if there is none.",
+      "previouselementsibling": "The read-only **`previousElementSibling`** property of the [CharacterData] interface\nreturns the first [Element] before the current node in its parent's children list,\nor `null` if there is none.",
       "remove": "The **`remove()`** method of the [CharacterData] removes the text contained in the node.",
       "replacedata": "The **`replaceData()`** method of the [CharacterData] interface removes a certain number of characters of the existing text in a given `CharacterData` node and replaces those characters with the text provided.",
       "replacewith": "The **`replaceWith()`** method of the [CharacterData] interface\nreplaces this node in the children list of its parent\nwith a set of [Node] objects or string.\n\nStrings are inserted as [Text] nodes; the string is being passed as argument to the [Text.Text] constructor.",
@@ -1302,22 +1302,22 @@
     }
   },
   "Client": {
-    "docs": "The `Client` interface represents an executable context such as a [Worker], or a [SharedWorker]. [Window] clients are represented by the more-specific [WindowClient]. You can get `Client`/`WindowClient` objects from methods such as [Clients.matchAll] and [Clients.get].",
+    "docs": "@AvailableInWorkers(\"service\")\n\nThe `Client` interface represents an executable context such as a [Worker], or a [SharedWorker]. [Window] clients are represented by the more-specific [WindowClient]. You can get `Client`/`WindowClient` objects from methods such as [Clients.matchAll] and [Clients.get].",
     "properties": {
-      "frametype": "The **`frameType`** read-only property of the [Client] interface indicates the type of browsing context of the current [Client]. This value can be one of `\"auxiliary\"`, `\"top-level\"`, `\"nested\"`, or `\"none\"`.",
-      "id": "The **`id`** read-only property of the [Client] interface returns the universally unique identifier of the [Client] object.",
-      "postmessage": "The **`postMessage()`** method of the\n[Client] interface allows a service worker to send a message to a client\n(a [Window], [Worker], or [SharedWorker]). The\nmessage is received in the \"`message`\" event on\n[ServiceWorkerContainer].",
-      "type": "The **`type`** read-only property of the [Client]\ninterface indicates the type of client the service worker is controlling.",
-      "url": "The **`url`** read-only property of the [Client]\ninterface returns the URL of the current service worker client."
+      "frametype": "@AvailableInWorkers(\"service\")\n\nThe **`frameType`** read-only property of the [Client] interface indicates the type of browsing context of the current [Client]. This value can be one of `\"auxiliary\"`, `\"top-level\"`, `\"nested\"`, or `\"none\"`.",
+      "id": "@AvailableInWorkers(\"service\")\n\nThe **`id`** read-only property of the [Client] interface returns the universally unique identifier of the [Client] object.",
+      "postmessage": "@AvailableInWorkers(\"service\")\n\nThe **`postMessage()`** method of the\n[Client] interface allows a service worker to send a message to a client\n(a [Window], [Worker], or [SharedWorker]). The\nmessage is received in the \"`message`\" event on\n[ServiceWorkerContainer].",
+      "type": "@AvailableInWorkers(\"service\")\n\nThe **`type`** read-only property of the [Client]\ninterface indicates the type of client the service worker is controlling.",
+      "url": "@AvailableInWorkers(\"service\")\n\nThe **`url`** read-only property of the [Client]\ninterface returns the URL of the current service worker client."
     }
   },
   "Clients": {
-    "docs": "The `Clients` interface provides access to [Client] objects. Access it via `[ServiceWorkerGlobalScope].clients` within a [service worker](https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API).",
+    "docs": "@AvailableInWorkers(\"service\")\n\nThe `Clients` interface provides access to [Client] objects. Access it via `[ServiceWorkerGlobalScope].clients` within a [service worker](https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API).",
     "properties": {
-      "claim": "The **`claim()`** method of the [Clients] interface allows an active service worker to set itself as the [ServiceWorkerContainer.controller] for all clients within its [ServiceWorkerRegistration.scope].\nThis triggers a \"`controllerchange`\" event on [ServiceWorkerContainer] in any clients that become controlled by this service worker.\n\nWhen a service worker is initially registered, pages won't use it until they next\nload. The `claim()` method causes those pages to be controlled immediately.\nBe aware that this results in your service worker controlling pages that loaded\nregularly over the network, or possibly via a different service worker.",
-      "get": "The **`get()`** method of the\n[Clients] interface gets a service worker client matching a given\n`id` and returns it in a `Promise`.",
-      "matchall": "The **`matchAll()`** method of the [Clients]\ninterface returns a `Promise` for a list of service worker\n[Client] objects. Include the `options` parameter to return all service worker\nclients whose origin is the same as the associated service worker's origin. If options\nare not included, the method returns only the service worker clients controlled by the\nservice worker.",
-      "openwindow": "The **`openWindow()`** method of the [Clients]\ninterface creates a new top level browsing context and loads a given URL. If the calling\nscript doesn't have permission to show popups, `openWindow()` will throw an\n`InvalidAccessError`.\n\nIn Firefox, the method is allowed to show popups only when called as the result of a\nnotification click event.\n\nIn Chrome for Android, the method may instead open the URL in an existing browsing\ncontext provided by a [standalone web app](https://developer.mozilla.org/en-US/docs/Web/Progressive_web_apps) previously added to the user's home screen. As of recently, this also works on\nChrome for Windows."
+      "claim": "@AvailableInWorkers(\"service\")\n\nThe **`claim()`** method of the [Clients] interface allows an active service worker to set itself as the [ServiceWorkerContainer.controller] for all clients within its [ServiceWorkerRegistration.scope].\nThis triggers a \"`controllerchange`\" event on [ServiceWorkerContainer] in any clients that become controlled by this service worker.\n\nWhen a service worker is initially registered, pages won't use it until they next\nload. The `claim()` method causes those pages to be controlled immediately.\nBe aware that this results in your service worker controlling pages that loaded\nregularly over the network, or possibly via a different service worker.",
+      "get": "@AvailableInWorkers(\"service\")\n\nThe **`get()`** method of the\n[Clients] interface gets a service worker client matching a given\n`id` and returns it in a `Promise`.",
+      "matchall": "@AvailableInWorkers(\"service\")\n\nThe **`matchAll()`** method of the [Clients]\ninterface returns a `Promise` for a list of service worker\n[Client] objects. Include the `options` parameter to return all service worker\nclients whose origin is the same as the associated service worker's origin. If options\nare not included, the method returns only the service worker clients controlled by the\nservice worker.",
+      "openwindow": "@AvailableInWorkers(\"service\")\n\nThe **`openWindow()`** method of the [Clients]\ninterface creates a new top level browsing context and loads a given URL. If the calling\nscript doesn't have permission to show popups, `openWindow()` will throw an\n`InvalidAccessError`.\n\nIn Firefox, the method is allowed to show popups only when called as the result of a\nnotification click event.\n\nIn Chrome for Android, the method may instead open the URL in an existing browsing\ncontext provided by a [standalone web app](https://developer.mozilla.org/en-US/docs/Web/Progressive_web_apps) previously added to the user's home screen. As of recently, this also works on\nChrome for Windows."
     }
   },
   "Clipboard": {
@@ -1416,10 +1416,10 @@
     }
   },
   "ContentIndexEvent": {
-    "docs": "The **`ContentIndexEvent`** interface of the [content index](https://developer.mozilla.org/en-US/docs/Web/API/Content_Index_API) defines the object used to represent the [ServiceWorkerGlobalScope.contentdelete_event] event.\n\nThis event is sent to the [global scope](https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerGlobalScope) of a [ServiceWorker]. It contains the id of the indexed content to be removed.\n\nThe [ServiceWorkerGlobalScope.contentdelete_event] event is only fired when the deletion happens due to interaction with the browser's built-in user interface. It is not fired when the [ContentIndex.delete] method is called.",
+    "docs": "@AvailableInWorkers(\"service\")\n\nThe **`ContentIndexEvent`** interface of the [content index](https://developer.mozilla.org/en-US/docs/Web/API/Content_Index_API) defines the object used to represent the [ServiceWorkerGlobalScope.contentdelete_event] event.\n\nThis event is sent to the [global scope](https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerGlobalScope) of a [ServiceWorker]. It contains the id of the indexed content to be removed.\n\nThe [ServiceWorkerGlobalScope.contentdelete_event] event is only fired when the deletion happens due to interaction with the browser's built-in user interface. It is not fired when the [ContentIndex.delete] method is called.",
     "properties": {
-      "contentindexevent": "The **`ContentIndexEvent()`** constructor creates a new [ContentIndexEvent] object\nwhose type and other options are configured as specified.",
-      "id": "The read-only **`id`** property of the\n[ContentIndexEvent] interface is a `String` which identifies\nthe deleted content index via its `id`."
+      "contentindexevent": "@AvailableInWorkers(\"service\")\n\nThe **`ContentIndexEvent()`** constructor creates a new [ContentIndexEvent] object\nwhose type and other options are configured as specified.",
+      "id": "@AvailableInWorkers(\"service\")\n\nThe **`id`** read-only property of the\n[ContentIndexEvent] interface is a `String` which identifies\nthe deleted content index via its `id`."
     }
   },
   "ContentVisibilityAutoStateChangeEvent": {
@@ -1446,21 +1446,21 @@
     }
   },
   "CookieStore": {
-    "docs": "The **`CookieStore`** interface of the [Cookie Store API] provides methods for getting and setting cookies asynchronously from either a page or a service worker.\n\nThe `CookieStore` is accessed via attributes in the global scope in a [Window] or [ServiceWorkerGlobalScope] context. Therefore there is no constructor.",
+    "docs": "@AvailableInWorkers(\"window_and_service\")\n\nThe **`CookieStore`** interface of the [Cookie Store API] provides methods for getting and setting cookies asynchronously from either a page or a service worker.\n\nThe `CookieStore` is accessed via attributes in the global scope in a [Window] or [ServiceWorkerGlobalScope] context. Therefore there is no constructor.",
     "properties": {
       "change_event": "A `change` event is fired at a [CookieStore] object when a change is made to any cookie.",
-      "delete": "The **`delete()`** method of the [CookieStore] interface deletes a cookie with the given name or options object. The `delete()` method expires the cookie by changing the date to one in the past.",
-      "get": "The **`get()`** method of the [CookieStore] interface returns a single cookie with the given name or options object. The method will return the first matching cookie for the passed parameters.",
-      "getall": "The **`getAll()`** method of the [CookieStore] interface returns a list of cookies that match the name or options passed to it. Passing no parameters will return all cookies for the current context.",
-      "set": "The **`set()`** method of the [CookieStore] interface sets a cookie with the given name and value or options object."
+      "delete": "@AvailableInWorkers(\"window_and_service\")\n\nThe **`delete()`** method of the [CookieStore] interface deletes a cookie with the given `name` or `options` object. The `delete()` method expires the cookie by changing the date to one in the past.",
+      "get": "@AvailableInWorkers(\"window_and_service\")\n\nThe **`get()`** method of the [CookieStore] interface returns a single cookie with the given `name` or `options` object. The method will return the first matching cookie for the passed parameters.",
+      "getall": "@AvailableInWorkers(\"window_and_service\")\n\nThe **`getAll()`** method of the [CookieStore] interface returns a list of cookies that match the `name` or `options` passed to it. Passing no parameters will return all cookies for the current context.",
+      "set": "@AvailableInWorkers(\"window_and_service\")\n\nThe **`set()`** method of the [CookieStore] interface sets a cookie with the given `name` and `value` or `options` object."
     }
   },
   "CookieStoreManager": {
-    "docs": "The **`CookieStoreManager`** interface of the [Cookie Store API] allows service workers to subscribe to cookie change events. Call [CookieStoreManager.subscribe] on a particular service worker registration to receive change events.\n\nA `CookieStoreManager` has an associated [ServiceWorkerRegistration]. Each service worker registration has a cookie change subscription list, which is a list of cookie change subscriptions each containing a name and URL. The methods in this interface allow the service worker to add and remove subscriptions from this list, and to get a list of all subscriptions.\n\nTo get a `CookieStoreManager`, call [ServiceWorkerRegistration.cookies].",
+    "docs": "@AvailableInWorkers(\"window_and_service\")\n\nThe **`CookieStoreManager`** interface of the [Cookie Store API] allows service workers to subscribe to cookie change events. Call [CookieStoreManager.subscribe] on a particular service worker registration to receive change events.\n\nA `CookieStoreManager` has an associated [ServiceWorkerRegistration]. Each service worker registration has a cookie change subscription list, which is a list of cookie change subscriptions each containing a name and URL. The methods in this interface allow the service worker to add and remove subscriptions from this list, and to get a list of all subscriptions.\n\nTo get a `CookieStoreManager`, call [ServiceWorkerRegistration.cookies].",
     "properties": {
-      "getsubscriptions": "The **`getSubscriptions()`** method of the [CookieStoreManager] interface returns a list of all the cookie change subscriptions for this [ServiceWorkerRegistration].",
-      "subscribe": "The **`subscribe()`** method of the [CookieStoreManager] interface subscribes a [ServiceWorkerRegistration] to cookie change events.",
-      "unsubscribe": "The **`unsubscribe()`** method of the [CookieStoreManager] interface stops the [ServiceWorkerRegistration] from receiving previously subscribed events."
+      "getsubscriptions": "@AvailableInWorkers(\"window_and_service\")\n\nThe **`getSubscriptions()`** method of the [CookieStoreManager] interface returns a list of all the cookie change subscriptions for this [ServiceWorkerRegistration].",
+      "subscribe": "@AvailableInWorkers(\"window_and_service\")\n\nThe **`subscribe()`** method of the [CookieStoreManager] interface subscribes a [ServiceWorkerRegistration] to cookie change events.",
+      "unsubscribe": "@AvailableInWorkers(\"window_and_service\")\n\nThe **`unsubscribe()`** method of the [CookieStoreManager] interface stops the [ServiceWorkerRegistration] from receiving previously subscribed events."
     }
   },
   "CountQueuingStrategy": {
@@ -1481,14 +1481,14 @@
   "CredentialsContainer": {
     "docs": "The **`CredentialsContainer`** interface of the [Credential Management API](https://developer.mozilla.org/en-US/docs/Web/API/Credential_Management_API) exposes methods to request credentials and notify the user agent when events such as successful sign in or sign out happen. This interface is accessible from [Navigator.credentials].",
     "properties": {
-      "create": "The **`create()`** method of the [CredentialsContainer] interface returns a `Promise` that resolves with a new credential instance based on the provided options, the information from which can then be stored and later used to authenticate users via [CredentialsContainer.get].\n\nThis is used by multiple different credential-related APIs with significantly different purposes:\n\n- The [Credential Management API](https://developer.mozilla.org/en-US/docs/Web/API/Credential_Management_API) uses `create()` to create basic federated credentials or username/password credentials.\n- The [Web Authentication API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Authentication_API) uses `create()` to create public key credentials (based on asymmetric cryptography).\n\nThe below reference page starts with a syntax section that explains the general method call structure and parameters that apply to all the different APIs. After that, it is split into separate sections providing parameters, return values, and examples specific to each API.\n\n> **Note:** This method is restricted to top-level  (i.e., a document running directly inside a browser tab, and not embedded inside another document). Calls to it from within an `<iframe>` element will resolve without effect.",
+      "create": "The **`create()`** method of the [CredentialsContainer] interface creates a new , which can then be stored and later used to authenticate users via [CredentialsContainer.get].\n\nThis method supports three different types of credential:\n\n- A password credential, which enables a user to sign in using a password.\n- A federated credential, which enables a user to sign in using a federated identity provider.\n- A public key credential, which enables a user to sign in with an authenticator such as a biometric reader built into the platform or a removable hardware token.\n\nNote that the [Federated Credential Management API (FedCM)](https://developer.mozilla.org/en-US/docs/Web/API/FedCM_API) supersedes the federated credential type.",
       "get": "The **`get()`** method of the [CredentialsContainer] interface returns a `Promise` that fulfills with a single credential instance that matches the provided parameters, which the browser can then use to authenticate with a relying party. This is used by several different credential-related APIs with significantly different purposes:\n\n- The [Credential Management API](https://developer.mozilla.org/en-US/docs/Web/API/Credential_Management_API) uses `get()` to authenticate using basic federated credentials or username/password credentials.\n- The [Web Authentication API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Authentication_API) uses `get()` to authenticate or provide additional factors during MFA with public key credentials (based on asymmetric cryptography).\n- The [Federated Credential Management (FedCM) API](https://developer.mozilla.org/en-US/docs/Web/API/FedCM_API) uses `get()` to authenticate with federated identity providers (IdPs).\n- The [WebOTP API](https://developer.mozilla.org/en-US/docs/Web/API/WebOTP_API) uses `get()` to request retrieval of a one-time password (OTP) from a specially-formatted SMS message sent by an app server.\n\nThe below reference page starts with a syntax section that explains the general method call structure and parameters that apply to all the different APIs. After that, it is split into separate sections providing parameters, return values, and examples specific to each API.",
       "preventsilentaccess": "The **`preventSilentAccess()`** method of the [CredentialsContainer] interface sets a flag that specifies whether automatic log in is allowed for future visits to the current origin, then returns a `Promise` that resolves to `undefined`.\nFor example, you might call this, after a user signs out of a website to ensure that they aren't automatically signed in on the next site visit.\nMediation varies by origin, and is an added check point of browser stored credentials, informing a user of an account login status. This method is typically called after a user signs out of a website, ensuring this user's login information is not automatically passed on the next site visit.\n\nEarlier versions of the spec called this method `requireUserMediation()`.\nThe [Browser compatibility](/en-US/docs/Web/API/CredentialsContainer#browser_compatibility) section has support details.",
       "store": "The **`store()`** method of the\n[CredentialsContainer] stores a set of credentials for the user inside a\n[Credential] instance, returning this in a `Promise`.\n\n> **Note:** This method is restricted to top-level contexts. Calls to it within an\n> `<iframe>` element will resolve without effect."
     }
   },
   "Crypto": {
-    "docs": "The **`Crypto`** interface represents basic cryptography features available in the current context.\nIt allows access to a cryptographically strong random number generator and to cryptographic primitives.\n\nThe [Web Crypto API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Crypto_API) is accessed through the global [crypto_property] property, which is a `Crypto` object.",
+    "docs": "The **`Crypto`** interface represents basic cryptography features available in the current context.\nIt allows access to a cryptographically strong random number generator and to cryptographic primitives.\n\nThe `Crypto` is available in windows using the [Window.crypto] property and in workers using the the [WorkerGlobalScope.crypto] property.",
     "properties": {
       "getrandomvalues": "The **`Crypto.getRandomValues()`** method lets you get cryptographically strong random values.\nThe array given as the parameter is filled with random numbers (random in its cryptographic meaning).\n\nTo guarantee enough performance, implementations are not using a truly random number generator, but they are using a pseudo-random number generator _seeded_ with a value with enough entropy.\nThe pseudo-random number generator algorithm (PRNG) may vary across , but is suitable for cryptographic purposes.\n\n`getRandomValues()` is the only member of the `Crypto` interface which can be used from an insecure context.",
       "randomuuid": "The **`randomUUID()`** method of the [Crypto] interface is used to generate a v4  using a cryptographically secure random number generator.",
@@ -1521,7 +1521,7 @@
     "docs": "The **`CustomEvent`** interface represents events initialized by an application for any purpose.\n\n> **Note:** If used to attempt to communicate between a web extension content script and a web page script, a non-string `detail` property throws with \"Permission denied to access property\" in Firefox. To avoid this issue clone the object. See [Share objects with page scripts](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/Sharing_objects_with_page_scripts) for more information.",
     "properties": {
       "customevent": "The **`CustomEvent()`** constructor creates a new [CustomEvent] object.",
-      "detail": "The read-only **`detail`** property of the [CustomEvent] interface\nreturns any data passed when initializing the event.",
+      "detail": "The read-only **`detail`** property of the [CustomEvent] interface returns any data passed when initializing the event.",
       "initcustomevent": "The **`CustomEvent.initCustomEvent()`** method initializes a [CustomEvent] object.\nIf the event has already been dispatched, this method does nothing.\n\nEvents initialized in this way must have been created with the [Document.createEvent] method.\nThis method must be called to set the event before it is dispatched using [EventTarget.dispatchEvent].\nOnce dispatched, it doesn't do anything anymore.\n\n> **Note:** **Do not use this method anymore, as it is deprecated.**\n>\n> Rather than using the feature, instead use specific event constructors, like [CustomEvent.CustomEvent].\n> The page on [Creating and triggering events](https://developer.mozilla.org/en-US/docs/Web/Events/Creating_and_triggering_events) gives more information about the way to use those."
     }
   },
@@ -1707,16 +1707,16 @@
     }
   },
   "DedicatedWorkerGlobalScope": {
-    "docs": "The **`DedicatedWorkerGlobalScope`** object (the [Worker] global scope) is accessible through the [WorkerGlobalScope.self] keyword. Some additional global functions, namespaces objects, and constructors, not typically associated with the worker global scope, but available on it, are listed in the [JavaScript Reference](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference). See also: [Functions available to workers](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Functions_and_classes_available_to_workers).",
+    "docs": "@AvailableInWorkers(\"dedicated\")\n\nThe **`DedicatedWorkerGlobalScope`** object (the [Worker] global scope) is accessible through the [WorkerGlobalScope.self] keyword. Some additional global functions, namespaces objects, and constructors, not typically associated with the worker global scope, but available on it, are listed in the [JavaScript Reference](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference). See also: [Functions available to workers](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Functions_and_classes_available_to_workers).",
     "properties": {
-      "cancelanimationframe": "The **`cancelAnimationFrame()`** method of the [DedicatedWorkerGlobalScope] interface cancels an animation frame request previously scheduled through a call to [DedicatedWorkerGlobalScope.requestAnimationFrame].\n\nCalling the `cancelAnimationFrame()` method requires the current worker to have an associated owner [Window]. That means that the current worker must be created by [Window] or by a dedicated worker that also has an associated owner [Window].",
-      "close": "The **`close()`** method of the [DedicatedWorkerGlobalScope] interface discards any tasks queued in the `DedicatedWorkerGlobalScope`'s event loop, effectively closing this particular scope.",
-      "message_event": "The `message` event is fired on a [DedicatedWorkerGlobalScope] object when the worker receives a message from its parent (i.e. when the parent sends a message using [`Worker.postMessage()`](https://developer.mozilla.org/en-US/docs/Web/API/Worker/postMessage)).\n\nThis event is not cancellable and does not bubble.",
-      "messageerror_event": "The `messageerror` event is fired on a [DedicatedWorkerGlobalScope] object when it receives a message that can't be deserialized.\n\nThis event is not cancellable and does not bubble.",
-      "name": "The **`name`** read-only property of the\n[DedicatedWorkerGlobalScope] interface returns the name that the\n[Worker] was (optionally) given when it was created. This is the name that\nthe [Worker.Worker] constructor can pass to get a reference to\nthe [DedicatedWorkerGlobalScope].",
-      "postmessage": "The **`postMessage()`** method of the [DedicatedWorkerGlobalScope] interface sends a message to the main thread that spawned it.\n\nThis accepts a data parameter, which contains data to copy from the worker to the main thread.\nThe data may be any value or JavaScript object handled by the [structured clone](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm) algorithm, which includes cyclical references.\n\nThe method also accepts an optional array of [transferable objects](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Transferable_objects) to _transfer_ to the main thread;\nUnlike the data parameter transferred objects are no longer usable in the worker thread.\n(Where possible, objects are transferred using a high performance zero-copy operation).\n\nThe main scope that spawned the worker can send back information to the thread that spawned it using the [Worker.postMessage] method.",
-      "requestanimationframe": "The **`requestAnimationFrame()`** method of the [DedicatedWorkerGlobalScope] interface tells the browser you wish to perform an animation frame request and call a user-supplied callback function before the next repaint.\n\nThe frequency of calls to the callback function will generally match the display refresh rate. The most common refresh rate is 60 Hz, (60 cycles/frames per second), though 75 Hz, 120 Hz, and 144 Hz are also widely used. `requestAnimationFrame()` calls are paused in most browsers when running in background tabs or hidden `iframe`s, to improve performance and battery life.\n\nA call to the `requestAnimationFrame()` method schedules only one single call to the callback function. If you want to animate another frame, your callback function must call `requestAnimationFrame()` again.\n\n> **Warning:** Be sure always to use the first argument (or some other method for getting the current time) to calculate how much the animation will progress in a frame — **otherwise, the animation will run faster on high refresh-rate screens**. For ways to do that, see the examples below.\n\nCalling the `requestAnimationFrame()` method requires the current worker to have an associated owner [Window]. That means that the current worker must be created by [Window] or by a dedicated worker that also has an associated owner [Window].",
-      "rtctransform_event": "The **`rtctransform`** event is fired at a worker's [DedicatedWorkerGlobalScope] object when an encoded video or audio frame has been queued for processing by a [WebRTC API.Using Encoded Transforms].\n\nThe event's [RTCTransformEvent.transformer] property returns a [RTCRtpScriptTransformer] that exposes the [ReadableStream] on which the frame is queued, and a [WritableStream] where the frame can be written to inject it back into the WebRTC pipeline.\n\nThis event is not cancellable and does not bubble."
+      "cancelanimationframe": "@AvailableInWorkers(\"dedicated\")\n\nThe **`cancelAnimationFrame()`** method of the [DedicatedWorkerGlobalScope] interface cancels an animation frame request previously scheduled through a call to [DedicatedWorkerGlobalScope.requestAnimationFrame].\n\nCalling the `cancelAnimationFrame()` method requires the current worker to have an associated owner [Window]. That means that the current worker must be created by [Window] or by a dedicated worker that also has an associated owner [Window].",
+      "close": "@AvailableInWorkers(\"dedicated\")\n\nThe **`close()`** method of the [DedicatedWorkerGlobalScope] interface discards any tasks queued in the `DedicatedWorkerGlobalScope`'s event loop, effectively closing this particular scope.",
+      "message_event": "@AvailableInWorkers(\"dedicated\")\n\nThe `message` event is fired on a [DedicatedWorkerGlobalScope] object when the worker receives a message from its parent (i.e. when the parent sends a message using [`Worker.postMessage()`](https://developer.mozilla.org/en-US/docs/Web/API/Worker/postMessage)).\n\nThis event is not cancellable and does not bubble.",
+      "messageerror_event": "@AvailableInWorkers(\"dedicated\")\n\nThe `messageerror` event is fired on a [DedicatedWorkerGlobalScope] object when it receives a message that can't be deserialized.\n\nThis event is not cancellable and does not bubble.",
+      "name": "@AvailableInWorkers(\"dedicated\")\n\nThe **`name`** read-only property of the\n[DedicatedWorkerGlobalScope] interface returns the name that the\n[Worker] was (optionally) given when it was created. This is the name that\nthe [Worker.Worker] constructor can pass to get a reference to\nthe [DedicatedWorkerGlobalScope].",
+      "postmessage": "@AvailableInWorkers(\"dedicated\")\n\nThe **`postMessage()`** method of the [DedicatedWorkerGlobalScope] interface sends a message to the main thread that spawned it.\n\nThis accepts a data parameter, which contains data to copy from the worker to the main thread.\nThe data may be any value or JavaScript object handled by the [structured clone](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm) algorithm, which includes cyclical references.\n\nThe method also accepts an optional array of [transferable objects](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Transferable_objects) to _transfer_ to the main thread;\nUnlike the data parameter transferred objects are no longer usable in the worker thread.\n(Where possible, objects are transferred using a high performance zero-copy operation).\n\nThe main scope that spawned the worker can send back information to the thread that spawned it using the [Worker.postMessage] method.",
+      "requestanimationframe": "@AvailableInWorkers(\"dedicated\")\n\nThe **`requestAnimationFrame()`** method of the [DedicatedWorkerGlobalScope] interface tells the browser you wish to perform an animation frame request and call a user-supplied callback function before the next repaint.\n\nThe frequency of calls to the callback function will generally match the display refresh rate. The most common refresh rate is 60 Hz, (60 cycles/frames per second), though 75 Hz, 120 Hz, and 144 Hz are also widely used. `requestAnimationFrame()` calls are paused in most browsers when running in background tabs or hidden `iframe`s, to improve performance and battery life.\n\nA call to the `requestAnimationFrame()` method schedules only one single call to the callback function. If you want to animate another frame, your callback function must call `requestAnimationFrame()` again.\n\n> **Warning:** Be sure always to use the first argument (or some other method for getting the current time) to calculate how much the animation will progress in a frame — **otherwise, the animation will run faster on high refresh-rate screens**. For ways to do that, see the examples below.\n\nCalling the `requestAnimationFrame()` method requires the current worker to have an associated owner [Window]. That means that the current worker must be created by [Window] or by a dedicated worker that also has an associated owner [Window].",
+      "rtctransform_event": "@AvailableInWorkers(\"dedicated\")\n\nThe **`rtctransform`** event is fired at a worker's [DedicatedWorkerGlobalScope] object when an encoded video or audio frame has been queued for processing by a [WebRTC API.Using Encoded Transforms].\n\nThe event's [RTCTransformEvent.transformer] property returns a [RTCRtpScriptTransformer] that exposes the [ReadableStream] on which the frame is queued, and a [WritableStream] where the frame can be written to inject it back into the WebRTC pipeline.\n\nThis event is not cancellable and does not bubble."
     }
   },
   "DelayNode": {
@@ -1798,7 +1798,7 @@
       "browsingtopics": "> **Warning:** This feature is currently opposed by two browser vendors. See the [Standards positions](/en-US/docs/Web/API/Topics_API#standards_positions) section below for details of opposition.\n\n> **Note:** An [Enrollment process](https://developer.mozilla.org/en-US/docs/Web/Privacy/Privacy_sandbox/Enrollment) is required to use this feature in your applications.\n\nThe `browsingTopics()` method of the [Document] interface returns a promise that fulfills with an array of objects representing the top topics for the user, one from each of the last three epochs. These topics could then be returned to the ad tech platform in a subsequent fetch request. By default, the method also causes the browser to record the current page visit as observed by the caller, so the page's hostname can later be used in topics calculation.\n\nSee [Using the Topics API](https://developer.mozilla.org/en-US/docs/Web/API/Topics_API/Using) for more details.\n\n> **Note:** `browsingTopics()` does not rely on HTTP headers to send topics and mark topics as observed like the other [Topics API enabling features](/en-US/docs/Web/API/Topics_API/Using#what_api_features_enable_the_topics_api), but it is somewhat less performant. You are advised to use one of the HTTP header-using features, falling back to `browsingTopics()` only in situations where the headers cannot be modified.",
       "caretpositionfrompoint": "The **`caretPositionFromPoint()`**\nmethod of the [Document] interface returns a\n[CaretPosition] object, containing the DOM node, along with the caret and\ncaret's character offset within that node.",
       "caretrangefrompoint": "The **`caretRangeFromPoint()`** method of the\n[Document] interface returns a [Range] object for the document\nfragment under the specified coordinates.\n\nThis method is the WebKit-proprietary implementation of the [Document.caretPositionFromPoint] method.",
-      "characterset": "The **`Document.characterSet`**\nread-only property returns the [character encoding](https://developer.mozilla.org/en-US/docs/Glossary/Character_encoding) of the\ndocument that it's currently rendered with.\n\n> **Note:** A \"character set\" and a \"character encoding\" are related, but different. Despite the\n> name of this property, it returns the _encoding_.\n\nUsers can override the developer-specified encoding inside the [Content-Type](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Type) header or inline\nlike `<meta charset=\"utf-8\">`, such as with Firefox's <kbd>View → Text\nEncoding</kbd> menu. This override is provided to fix incorrect developer-specified\nencodings that result in [garbled text](https://en.wikipedia.org/wiki/Mojibake).\n\n> **Note:** The properties `document.charset` and `document.inputEncoding`\n> are legacy aliases for `document.characterSet`. Do not use them any more.",
+      "characterset": "The **`Document.characterSet`**\nread-only property returns the [character encoding](https://developer.mozilla.org/en-US/docs/Glossary/Character_encoding) of the\ndocument that it's currently rendered with.\n\n> **Note:** A \"character set\" and a \"character encoding\" are related, but different. Despite the\n> name of this property, it returns the _encoding_.",
       "childelementcount": "The **`Document.childElementCount`** read-only property\nreturns the number of child elements of the document.\n\nTo get the number of children of a specific element, see [Element.childElementCount].",
       "children": "The read-only **`children`** property returns a live [HTMLCollection]\nwhich contains all of the child [Element] of the document upon which it was called.\n\nFor HTML documents, this is usually only the root `<html>` element.\n\nSee [Element.children] for child elements of specific HTML elements within the document.",
       "clear": "The **`Document.clear()`** method does nothing, but doesn't raise any error.",
@@ -1829,7 +1829,7 @@
       "defaultview": "In browsers, **`document.defaultView`** returns the\n[Window] object associated with , or `null` if none is available.\n\nThis property is read-only.",
       "designmode": "**`document.designMode`** controls whether the entire document\nis editable. Valid values are `\"on\"` and `\"off\"`. According to the\nspecification, this property is meant to default to `\"off\"`. Firefox follows\nthis standard. The earlier versions of Chrome and IE default to `\"inherit\"`.\nStarting in Chrome 43, the default is `\"off\"` and `\"inherit\"` is\nno longer supported. In IE6-10, the value is capitalized.",
       "dir": "The **`Document.dir`** property is a string\nrepresenting the directionality of the text of the document, whether left to right\n(default) or right to left. Possible values are `'rtl'`, right to left, and\n`'ltr'`, left to right.",
-      "doctype": "Returns the Document Type Declaration (DTD) associated with current document. The\nreturned object implements the [DocumentType] interface. Use\n[DOMImplementation.createDocumentType] to create a\n`DocumentType`.\n\n- `doctype` is a read-only property.",
+      "doctype": "The **`doctype`** read-only property of the [Document] interface is a [DocumentType] object representing the the  associated with the current document.",
       "document": "The **`Document`** constructor creates a new\n[Document] object that is a web page loaded in the browser and serving as\nan entry point into the page's content.",
       "documentelement": "**`Document.documentElement`** returns the\n[Element] that is the root element of the [document] (for\nexample, the `html` element for HTML documents).",
       "documenturi": "The **`documentURI`** read-only property of the\n[Document] interface returns the document location as a string.",
@@ -1863,10 +1863,11 @@
       "getelementsbytagnamens": "Returns a list of elements with the given tag name belonging to the given namespace.\nThe complete document is searched, including the root node.",
       "getselection": "The **`getSelection()`** method of\nthe [Document] interface returns a [Selection]\nobject representing the range of text selected by the user, or the current position of\nthe caret.",
       "hasfocus": "The **`hasFocus()`** method of the [Document] interface returns a boolean value indicating whether the document or any element inside the document has focus.\nThis method can be used to determine whether the active element in a document has focus.\n\n> **Note:** When viewing a document, an element with focus is always the [active element](https://developer.mozilla.org/en-US/docs/Web/API/Document/activeElement) in the document, but an active element does not necessarily have focus.\n> For example, an active element within a popup window that is not the foreground doesn't have focus.",
-      "hasstorageaccess": "The **`hasStorageAccess()`** method of the [Document] interface returns a `Promise` that resolves with a boolean value indicating whether the document has access to [third-party](/en-US/docs/Web/HTTP/Cookies#third-party_cookies), [unpartitioned](/en-US/docs/Web/API/Storage_Access_API#unpartitioned_versus_partitioned_cookies) cookies.\n\nThis method is part of the [Storage Access API](https://developer.mozilla.org/en-US/docs/Web/API/Storage_Access_API).",
+      "hasstorageaccess": "The **`hasStorageAccess()`** method of the [Document] interface returns a `Promise` that resolves with a boolean value indicating whether the document has access to [third-party](https://developer.mozilla.org/en-US/docs/Web/Privacy/Third-party_cookies), [unpartitioned](/en-US/docs/Web/API/Storage_Access_API#unpartitioned_versus_partitioned_cookies) cookies.\n\nThis method is part of the [Storage Access API](https://developer.mozilla.org/en-US/docs/Web/API/Storage_Access_API).\n\n> **Note:** This method is another name for [Document.hasUnpartitionedCookieAccess]. There are no current plans to remove this method in favor of [Document.hasUnpartitionedCookieAccess].",
+      "hasunpartitionedcookieaccess": "The **`hasUnpartitionedCookieAccess()`** method of the [Document] interface returns a `Promise` that resolves with a boolean value indicating whether the document has access to [third-party](/en-US/docs/Web/HTTP/Cookies#third-party_cookies), [unpartitioned](/en-US/docs/Web/API/Storage_Access_API#unpartitioned_versus_partitioned_cookies) cookies.\n\nThis method is part of the [Storage Access API](https://developer.mozilla.org/en-US/docs/Web/API/Storage_Access_API).\n\nThis method is a new name for [Document.hasStorageAccess].",
       "head": "The **`head`** read-only property of\nthe [Document] interface returns the `head` element of\nthe current document.",
       "hidden": "The **`Document.hidden`** read-only property returns a Boolean\nvalue indicating if the page is considered hidden or not.\n\nThe [Document.visibilityState] property provides an alternative way to determine whether the page is hidden.",
-      "images": "The **`images`** read-only property of\nthe [Document] interface returns a [collection](https://developer.mozilla.org/en-US/docs/Web/API/HTMLCollection) of the [images](https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement/Image) in the current HTML document.",
+      "images": "The **`images`** read-only property of the [Document] interface returns a [collection](https://developer.mozilla.org/en-US/docs/Web/API/HTMLCollection) of the [images](https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement) in the current HTML document.",
       "implementation": "The **`Document.implementation`** property returns a\n[DOMImplementation] object associated with the current document.",
       "importnode": "The [Document] object's **`importNode()`** method creates a copy of a\n[Node] or [DocumentFragment] from another document, to be\ninserted into the current document later.\n\nThe imported node is not yet included in the document tree. To include it, you need to\ncall an insertion method such as [Node.appendChild] or\n[Node.insertBefore] with a node that _is_\ncurrently in the document tree.\n\nUnlike [document.adoptNode], the original node is not removed from its\noriginal document. The imported node is a clone of the original.",
       "lastelementchild": "The **`Document.lastElementChild`** read-only property\nreturns the document's last child [Element], or `null` if there\nare no child elements.\n\nFor HTML documents, this is usually the only child, the root `<html>` element.\n\nSee [Element.lastElementChild] for the last child element of specific elements within a document.",
@@ -1898,7 +1899,7 @@
       "referrer": "The **`Document.referrer`** property returns the [URI](https://www.w3.org/Addressing/#background) of the page that linked to\nthis page.",
       "releasecapture": "The **`releaseCapture()`** method releases mouse capture if\nit's currently enabled on an element within this document.\nOnce mouse capture is released, mouse events will no longer all be directed to the element on which capture is enabled.\n\nEnabling mouse capture on an element is done by calling [element.setCapture].",
       "replacechildren": "The **`Document.replaceChildren()`** method replaces the\nexisting children of a `Document` with a specified new set of children.",
-      "requeststorageaccess": "The **`requestStorageAccess()`** method of the [Document] interface allows content loaded in a third-party context (i.e., embedded in an `iframe`) to request access to third-party cookies. This is relevant to user agents that, by default, block access to [third-party](/en-US/docs/Web/HTTP/Cookies#third-party_cookies), [unpartitioned](/en-US/docs/Web/API/Storage_Access_API#unpartitioned_versus_partitioned_cookies) cookies to improve privacy (e.g., to prevent tracking), and is part of the [Storage Access API](https://developer.mozilla.org/en-US/docs/Web/API/Storage_Access_API).\n\nTo check whether permission to access third-party cookies has already been granted, you can call [Permissions.query], specifying the feature name `\"storage-access\"`.\n\n> **Note:** Usage of this feature may be blocked by a  [Permissions Policy](https://developer.mozilla.org/en-US/docs/Web/HTTP/Permissions_Policy) set on your server. In addition, the document must pass additional browser-specific checks such as allowlists, blocklists, on-device classification, user settings, anti-[clickjacking](https://developer.mozilla.org/en-US/docs/Glossary/Clickjacking) heuristics, or prompting the user for explicit permission.",
+      "requeststorageaccess": "The **`requestStorageAccess()`** method of the [Document] interface allows content loaded in a third-party context (i.e., embedded in an `iframe`) to request access to [third-party cookies](https://developer.mozilla.org/en-US/docs/Web/Privacy/Third-party_cookies) and [unpartitioned state](/en-US/docs/Web/Privacy/State_Partitioning#state_partitioning). This is relevant to user agents that, by default, block access to third-party, [unpartitioned](/en-US/docs/Web/API/Storage_Access_API#unpartitioned_versus_partitioned_cookies) cookies to improve privacy (e.g., to prevent tracking), and is part of the [Storage Access API](https://developer.mozilla.org/en-US/docs/Web/API/Storage_Access_API).\n\nTo check whether permission to access third-party cookies has already been granted, you can call [Permissions.query], specifying the feature name `\"storage-access\"`.\n\n> **Note:** Usage of this feature may be blocked by a  [Permissions Policy](https://developer.mozilla.org/en-US/docs/Web/HTTP/Permissions_Policy) set on your server. In addition, the document must pass additional browser-specific checks such as allowlists, blocklists, on-device classification, user settings, anti-[clickjacking](https://developer.mozilla.org/en-US/docs/Glossary/Clickjacking) heuristics, or prompting the user for explicit permission.",
       "requeststorageaccessfor": "The **`requestStorageAccessFor()`** method of the [Document] interface allows top-level sites to request third-party cookie access on behalf of embedded content originating from another site in the same [related website set](https://developer.mozilla.org/en-US/docs/Web/API/Storage_Access_API/Related_website_sets). It returns a `Promise` that resolves if the access was granted, and rejects if access was denied.",
       "rootelement": "**`Document.rootElement`** returns the [Element]\nthat is the root element of the [document] if it is an\n element, otherwise `null`. It is deprecated in favor of\n[Document.documentElement], which returns the root element for all\ndocuments.",
       "scripts": "The **`scripts`** property of the [Document]\ninterface returns a list of the `script`\nelements in the document. The returned object is an\n[HTMLCollection].",
@@ -1908,7 +1909,7 @@
       "securitypolicyviolation_event": "The **`securitypolicyviolation`** event is fired when a [Content Security Policy](https://developer.mozilla.org/en-US/docs/Web/HTTP/CSP) is violated.\n\nThe event is fired on the global scope when violates the policy and will bubble to the [Window] object. The event may also bubble from [Node] contained in the document tree.\n\nThe handler can be assigned using the `onsecuritypolicyviolation` event handler property or using [EventTarget.addEventListener].\n\n> **Note:** It is recommended to add the handler for this event to a top level object (i.e. [Window] or [Document]). While the property exists in HTML elements, you can't assign a handler to the property until the elements have been loaded, by which time this event will already have fired.",
       "selectedstylesheetset": "The **`selectedStyleSheetSet`** property indicates the name of the style sheet set that's currently in use.",
       "selectionchange_event": "The **`selectionchange`** event of the [Selection API](https://developer.mozilla.org/en-US/docs/Web/API/Selection) is fired when the current [Selection] of a [Document] is changed.\n\nThis event is not cancelable and does not bubble.\n\nThe event can be handled by adding an event listener for `selectionchange` or using the `onselectionchange` event handler.\n\n> **Note:** This event is not quite the same as the `selectionchange` events fired when the text selection in an `input` or `textarea` element is changed. See [HTMLInputElement.selectionchange_event] for more details.",
-      "startviewtransition": "The **`startViewTransition()`** method of the\n[View Transitions API] starts a new view transition and returns a [ViewTransition] object to represent it.\n\nWhen `startViewTransition()` is invoked, a sequence of steps is followed as explained in [The view transition process](/en-US/docs/Web/API/View_Transitions_API#the_view_transition_process).",
+      "startviewtransition": "The **`startViewTransition()`** method of the [Document] interface starts a new view transition and returns a [ViewTransition] object to represent it.\n\nWhen `startViewTransition()` is invoked, a sequence of steps is followed as explained in [The view transition process](/en-US/docs/Web/API/View_Transitions_API#the_view_transition_process).",
       "stylesheets": "The **`styleSheets`** read-only property of the [Document] interface returns a [StyleSheetList] of [CSSStyleSheet] objects, for stylesheets explicitly linked into or embedded in a document.",
       "stylesheetsets": "The **`styleSheetSets`** read-only property returns a live list of all of the currently-available style sheet sets.",
       "timeline": "The `timeline` readonly property of the [Document] interface represents the default timeline of the current document. This timeline is a special instance of [DocumentTimeline].\n\nThis timeline is unique to each `document` and persists for the lifetime of the `document` including calls to [Document.open].\n\nThis timeline expresses the time in milliseconds since [Performance.timeOrigin].\nPrior to the time origin, the timeline is inactive, and its [AnimationTimeline.currentTime] is `null`.\n\n> **Note:** A document timeline that is associated with a non-active document (a [Document] not associated with a [Window], `iframe`, or `frame`) is also considered to be inactive.",
@@ -2038,6 +2039,8 @@
       "append": "The **`Element.append()`** method\ninserts a set of [Node] objects or string objects after\nthe last child of the `Element`. String objects\nare inserted as equivalent [Text] nodes.\n\nDifferences from [Node.appendChild]:\n\n- `Element.append()` allows you to also append string\n  objects, whereas `Node.appendChild()` only accepts [Node]\n  objects.\n- `Element.append()` has no return value, whereas\n  `Node.appendChild()` returns the appended [Node] object.\n- `Element.append()` can append several nodes and strings, whereas\n  `Node.appendChild()` can only append one node.",
       "ariaatomic": "The **`ariaAtomic`** property of the [Element] interface reflects the value of the [`aria-atomic`](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-atomic) attribute, which indicates whether assistive technologies will present all, or only parts of, the changed region based on the change notifications defined by the [`aria-relevant`](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-relevant) attribute.",
       "ariaautocomplete": "The **`ariaAutoComplete`** property of the [Element] interface reflects the value of the [`aria-autocomplete`](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-autocomplete) attribute, which indicates whether inputting text could trigger display of one or more predictions of the user's intended value for a combobox, searchbox, or textbox and specifies how predictions would be presented if they were made.",
+      "ariabraillelabel": "The **`ariaBrailleLabel`** property of the [Element] interface reflects the value of the [`aria-braillelabel`](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-braillelabel) attribute, which defines the ARIA braille label of the element.\n\nThis element label may be used by assistive technologies that can present content in braille, but should only be set if a braille-specific label would improve the user experience.\nThe [`aria-braillelabel`](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-braillelabel) contains additional information about when the property should be set.",
+      "ariabrailleroledescription": "The **`ariaBrailleRoleDescription`** property of the [Element] interface reflects the value of the [`aria-brailleroledescription`](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-brailleroledescription) attribute, which defines the ARIA braille role description of the element.\n\nThis property may be used to provide an abbreviated version of the [`aria-roledescription`](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-roledescription) value.\nIt should only be used if `aria-roledescription` is present and in the rare case where it is is too verbose for braille.\nThe [`aria-brailleroledescription`](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-brailleroledescription) contains additional information about when the property should be set.",
       "ariabusy": "The **`ariaBusy`** property of the [Element] interface reflects the value of the [`aria-busy`](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-busy) attribute, which indicates whether an element is being modified, as assistive technologies may want to wait until the modifications are complete before exposing them to the user.",
       "ariachecked": "The **`ariaChecked`** property of the [Element] interface reflects the value of the [`aria-checked`](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-checked) attribute, which indicates the current \"checked\" state of checkboxes, radio buttons, and other widgets that have a checked state.\n\n> **Note:** Where possible use an HTML `input` element with `type=\"checkbox\"` as this element has built in semantics and does not require ARIA attributes.",
       "ariacolcount": "The **`ariaColCount`** property of the [Element] interface reflects the value of the [`aria-colcount`](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-colcount) attribute, which defines the number of columns in a table, grid, or treegrid.",
@@ -2104,6 +2107,7 @@
       "contentvisibilityautostatechange_event": "The **`contentvisibilityautostatechange`** event fires on any element with  set on it when it starts or stops being [relevant to the user](/en-US/docs/Web/CSS/CSS_containment#relevant_to_the_user) and [skipping its contents](/en-US/docs/Web/CSS/CSS_containment#skips_its_contents).\n\nWhile the element is not relevant (between the start and end events), the user agent skips an element's rendering, including layout and painting, which can significantly improve page rendering speed.\nThe [element.contentvisibilityautostatechange_event] event provides a way for an app's code to also start or stop rendering processes (e.g. drawing on a `canvas`) when they are not needed, thereby conserving processing power.\n\nNote that even when hidden from view, element contents will remain semantically relevant (e.g. to assistive technology users), so this signal should not be used to skip significant semantic DOM updates.",
       "contextmenu_event": "The **`contextmenu`** event fires when the user attempts to open a context menu. This event is typically triggered by clicking the right mouse button, or by pressing the context menu key.\n\nIn the latter case, the context menu is displayed at the bottom left of the focused element, unless the element is a tree, in which case the context menu is displayed at the bottom left of the current row.\n\nAny right-click event that is not disabled (by calling the click event's [Event.preventDefault] method) will result in a `contextmenu` event being fired at the targeted element.\n\n> **Note:** An exception to this in Firefox: if the user holds down the <kbd>Shift</kbd> key while right-clicking, then the context menu will be shown without a `contextmenu` event being fired.",
       "copy_event": "The **`copy`** event of the [Clipboard API](https://developer.mozilla.org/en-US/docs/Web/API/Clipboard_API) fires when the user initiates a copy action through the browser's user interface.\n\nThe event's default action is to copy the selection (if any) to the clipboard.\n\nA handler for this event can _modify_ the clipboard contents by calling [DataTransfer.setData] on the event's [ClipboardEvent.clipboardData] property, and cancelling the event's default action using [Event.preventDefault].\n\nHowever, the handler cannot _read_ the clipboard data.\n\nIt's possible to construct and dispatch a [synthetic](https://developer.mozilla.org/en-US/docs/Web/Events/Creating_and_triggering_events) `copy` event, but this will not affect the system clipboard.\n\nThis event [bubbles](/en-US/docs/Learn/JavaScript/Building_blocks/Events#event_bubbling_and_capture), is [cancelable](https://developer.mozilla.org/en-US/docs/Web/API/Event/cancelable) and is [composed](https://developer.mozilla.org/en-US/docs/Web/API/Event/composed).",
+      "currentcsszoom": "The **`currentCSSZoom`** read-only property of the [Element] interface provides the \"effective\" [CSS `zoom`](https://developer.mozilla.org/en-US/docs/Web/CSS/zoom) of an element, taking into account the zoom applied to the element and all its parent elements.\n\nThe value calculated by multiplying the CSS `zoom` values of the element and all of its parents.\nFor example, if three elements with zoom values of 2, 1.5, and 3, are nested within each other, the most deeply nested element will have a `currentCSSZoom` value of 9.\nIf the element doesn't have a CSS box, for example because `display: none` is set on the element or one of its parents, then the `currentCSSZoom` is set to 1.\n\nNote that some methods, such as [Element.getBoundingClientRect], return dimensions and position that are relative to the viewport, and hence include the effects of CSS `zoom`.\nOther properties and methods return values that are relative to the element itself, and do not include the effects of zooming.\nThese include, for example, `client*` properties such as [Element.clientHeight], `scroll*()` methods like [Element.scroll], and `offset*` properties such as [HTMLElement.offsetHeight].\nThe `currentCSSZoom` property can be used to scale these values to adjust for the effects of zooming.",
       "cut_event": "The **`cut`** event of the [Clipboard API](https://developer.mozilla.org/en-US/docs/Web/API/Clipboard_API) is fired when the user has initiated a \"cut\" action through the browser's user interface.\n\nIf the user attempts a cut action on uneditable content, the `cut` event still fires but the event object contains no data.\n\nThe event's default action is to copy the current selection (if any) to the system clipboard and remove it from the document.\n\nA handler for this event can _modify_ the clipboard contents by calling [DataTransfer.setData] on the event's [ClipboardEvent.clipboardData] property, and cancelling the default action using [Event.preventDefault].\n\nNote though that cancelling the default action will also prevent the document from being updated. So an event handler which wants to emulate the default action for \"cut\" while modifying the clipboard must also manually remove the selection from the document.\n\nThe handler cannot _read_ the clipboard data.\n\nIt's possible to construct and dispatch a [synthetic](https://developer.mozilla.org/en-US/docs/Web/Events/Creating_and_triggering_events) `cut` event, but this will not affect the system clipboard or the document's contents.\n\nThis event [bubbles](/en-US/docs/Learn/JavaScript/Building_blocks/Events#event_bubbling_and_capture), is [cancelable](https://developer.mozilla.org/en-US/docs/Web/API/Event/cancelable) and is [composed](https://developer.mozilla.org/en-US/docs/Web/API/Event/composed).",
       "dblclick_event": "The **`dblclick`** event fires when a pointing device button (such as a mouse's primary button) is double-clicked; that is, when it's rapidly clicked twice on a single element within a very short span of time.\n\n`dblclick` fires after two [Element.click_event] events (and by extension, after two pairs of [Element.mousedown_event] and [Element.mouseup_event] events).",
       "domactivate_event": "The **`DOMActivate`** event is fired at an element when it becomes active, such as when it is clicked on using the mouse or a keypress is used to navigate to it.",
@@ -2119,7 +2123,7 @@
       "gestureend_event": "The **`gestureend`** event is fired when there are no longer multiple fingers contacting the touch surface, thus ending the gesture.\n\nIt is a proprietary event specific to WebKit.",
       "gesturestart_event": "The **`gesturestart`** event is fired when multiple fingers contact the touch surface, thus starting a new gesture. During the gesture, [Element.gesturechange_event] events will be fired. When the gesture has ended, a [Element.gestureend_event] event will be fired.\n\nIt is a proprietary event specific to WebKit.",
       "getanimations": "The `getAnimations()` method of the [Element] interface\n(specified on the `Animatable` mixin) returns an array of all\n[Animation] objects affecting this element or which are scheduled to do so\nin future. It can optionally return [Animation] objects for descendant\nelements too.\n\n> **Note:** This array includes [CSS Animations](https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_animations), [CSS Transitions](https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_transitions), and [Web Animations](https://developer.mozilla.org/en-US/docs/Web/API/Web_Animations_API).",
-      "getattribute": "The **`getAttribute()`** method of the\n[Element] interface returns the value of a specified attribute on the\nelement.\n\nIf the given attribute does not exist, the value returned will\neither be `null` or `\"\"` (the empty string); see [Non-existing attributes](#non-existing_attributes) for details.\n\nIf you need to inspect the [Attr] node's properties, you can use the [Element.getAttributeNode] method instead.",
+      "getattribute": "The **`getAttribute()`** method of the\n[Element] interface returns the value of a specified attribute on the\nelement.\n\nIf the given attribute does not exist, the value returned will be `null`.\n\nIf you need to inspect the [Attr] node's properties, you can use the [Element.getAttributeNode] method instead.",
       "getattributenames": "The **`getAttributeNames()`** method of the\n[Element] interface returns the attribute names of the element as an\n`Array` of strings. If the element has no attributes it returns an empty\narray.\n\nUsing `getAttributeNames()` along with\n[Element.getAttribute], is a memory-efficient and\nperformant alternative to accessing [Element.attributes].\n\nThe names returned by **`getAttributeNames()`** are _qualified_ attribute names, meaning that attributes with a namespace prefix have their names returned with that namespace prefix (_not_ the actual namespace), followed by a colon, followed by the attribute name (for example, **`xlink:href`**), while any attributes which have no namespace prefix have their names returned as-is (for example, **`href`**).",
       "getattributenode": "Returns the specified attribute of the specified element, as an [Attr] node.\n\nThis method is useful if you need the attribute's [instance properties](/en-US/docs/Web/API/Attr#instance_properties).\nIf you only need the attribute's value, you can use the [Element.getAttribute] method instead.",
       "getattributenodens": "The **`getAttributeNodeNS()`** method of the [Element] interface returns the namespaced [Attr] node of an element.\n\nThis method is useful if you need the namespaced attribute's [instance properties](/en-US/docs/Web/API/Attr#instance_properties).\nIf you only need the namespaced attribute's value, you can use the [Element.getAttributeNS] method instead.\n\nIf you need the [Attr] node of an element in HTML documents and the attribute is not namespaced, use the [Element.getAttributeNode] method instead.",
@@ -2129,13 +2133,14 @@
       "getelementsbyclassname": "The [Element] method\n**`getElementsByClassName()`** returns a live\n[HTMLCollection] which contains every descendant element which has the\nspecified class name or names.\n\nThe method [Document.getElementsByClassName]\non the [Document] interface works essentially the same way, except it acts\non the entire document, starting at the document root.",
       "getelementsbytagname": "The\n**`Element.getElementsByTagName()`** method returns a live\n[HTMLCollection] of elements with the given [tag name](https://developer.mozilla.org/en-US/docs/Web/API/Element/tagName).\n\nAll descendants of the\nspecified element are searched, but not the element itself. The returned list is\n_live_, which means it updates itself with the DOM tree automatically.\nTherefore, there is no need to call `Element.getElementsByTagName()` with\nthe same element and arguments repeatedly if the DOM changes in between calls.\n\nWhen called on an HTML element in an HTML document, `getElementsByTagName`\nlower-cases the argument before searching for it. This is undesirable when trying to\nmatch  SVG elements (such as\n[`<linearGradient>`](https://developer.mozilla.org/en-US/docs/Web/SVG/Element/linearGradient))\nin an HTML document. Instead, use [Element.getElementsByTagNameNS],\nwhich preserves the capitalization of the tag name.\n\n`Element.getElementsByTagName` is similar to\n[Document.getElementsByTagName], except that it only searches for\nelements that are descendants of the specified element.",
       "getelementsbytagnamens": "The **`Element.getElementsByTagNameNS()`** method returns a\nlive [HTMLCollection] of elements with the given tag name belonging to the\ngiven namespace. It is similar to [Document.getElementsByTagNameNS], except\nthat its search is restricted to descendants of the specified element.",
+      "gethtml": "The **`getHTML()`** method of the [Element] interface is used to serialize an element's DOM to an HTML string.\n\nThe method provides an options argument that enables the serialization of child nodes that are shadow roots.\nThe options can be used to include nested shadow roots that have been set as [ShadowRoot.serializable], and/or a specified array of [ShadowRoot] objects, which may be either open or closed.\n\nWithout arguments, child nodes that are shadow roots are not serialized, and this method behaves in the same way as reading the value of [Element.innerHTML].",
       "gotpointercapture_event": "The **`gotpointercapture`** event is fired when an element captures a pointer using [`setPointerCapture()`](https://developer.mozilla.org/en-US/docs/Web/API/Element/setPointerCapture).",
       "hasattribute": "The **`Element.hasAttribute()`** method returns a\n**Boolean** value indicating whether the specified element has the\nspecified attribute or not.",
       "hasattributens": "The **`hasAttributeNS()`** method of the [Element] interface returns a boolean value indicating whether the current element has the specified attribute with the specified namespace.\n\nIf you are working with HTML documents and you don't need to specify the requested attribute as being part of a specific namespace, use the [Element.hasAttribute] method instead.",
       "hasattributes": "The **`hasAttributes()`** method of the [Element]\ninterface returns a boolean value indicating whether the current element has any\nattributes or not.",
       "haspointercapture": "The **`hasPointerCapture()`** method of the\n[Element] interface checks whether the element on which it is invoked has\npointer capture for the pointer identified by the given pointer ID.",
       "id": "The **`id`** property of the [Element] interface\nrepresents the element's identifier, reflecting the\n[**`id`**](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/id)\nglobal attribute.\n\nIf the `id` value is not the empty string, it must be unique in a document.\n\nThe `id` is often used with [Document.getElementById] to retrieve a particular element.\nAnother common case is to use an element's [ID as a selector](https://developer.mozilla.org/en-US/docs/Web/CSS/ID_selectors) when styling the document with [CSS](https://developer.mozilla.org/en-US/docs/Web/CSS).\n\n> **Note:** Identifiers are case-sensitive, but you should avoid creating\n> IDs that differ only in the capitalization.",
-      "innerhtml": "The [Element] property\n**`innerHTML`** gets or sets the HTML or XML markup contained\nwithin the element.\n\nTo insert the HTML into the document rather than replace the contents of an element,\nuse the method [Element.insertAdjacentHTML].",
+      "innerhtml": "The [Element] property **`innerHTML`** gets or sets the HTML or XML markup contained within the element.\n\nMore precisely, `innerHTML` gets a serialization of the nested child DOM elements within the element, or sets HTML or XML that should be parsed to replace the DOM tree within the element.\n\nTo insert the HTML into the document rather than replace the contents of an element, use the method [Element.insertAdjacentHTML].\n\nThe serialization of the DOM tree read from the property does not include  — if you want to get a HTML string that includes shadow roots, you must instead use the [Element.getHTML] or [ShadowRoot.getHTML] methods.\nSimilarly, when setting element content using `innerHTML`, the HTML string is parsed into DOM elements that do not contain shadow roots.\n\nSo for example [`<template>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/template) is parsed into as [HTMLTemplateElement], whether or not the [`shadowrootmode`](/en-US/docs/Web/HTML/Element/template#shadowrootmode) attribute is specfied\nIn order to set an element's contents from an HTML string that includes declarative shadow roots, you must use either [Element.setHTMLUnsafe] or [ShadowRoot.setHTMLUnsafe].",
       "input_event": "The **`input`** event fires when the `value` of an `input`, `select`, or `textarea` element has been changed as a direct result of a user action (such as typing in a textbox or checking a checkbox).\n\nThe event also applies to elements with [HTMLElement.contentEditable] enabled, and to any element when [Document.designMode] is turned on. In the case of `contenteditable` and `designMode`, the event target is the _editing host_. If these properties apply to multiple elements, the editing host is the nearest ancestor element whose parent isn't editable.\n\nFor `<input>` elements with `type=checkbox` or `type=radio`, the `input` event should fire whenever a user toggles the control, per the [HTML Living Standard specification](https://html.spec.whatwg.org/multipage/input.html#the-input-element:event-input-2). However, historically this has not always been the case. Check compatibility, or use the [HTMLElement.change_event] event instead for elements of these types.\n\nFor `textarea` and `input` elements that accept text input (`type=text`, `type=tel`, etc.), the interface is [InputEvent]; for others, the interface is [Event].\n\nThe `input` event is fired every time the `value` of the element changes. This is unlike the [HTMLElement.change_event] event, which only fires when the value is committed, such as by pressing the enter key or selecting a value from a list of options. Note that the `input` event is not fired when JavaScript changes an element's `value` programmatically.",
       "insertadjacentelement": "The **`insertAdjacentElement()`** method of the\n[Element] interface inserts a given element node at a given position\nrelative to the element it is invoked upon.",
       "insertadjacenthtml": "The **`insertAdjacentHTML()`** method of the\n[Element] interface parses the specified text as HTML or XML and inserts\nthe resulting nodes into the DOM tree at a specified position.",
@@ -2198,7 +2203,7 @@
       "scrolltopmax": "The **`Element.scrollTopMax`** read-only property returns a\nnumber representing the maximum top scroll offset possible for the\nelement.",
       "scrollwidth": "The **`Element.scrollWidth`** read-only property is a\nmeasurement of the width of an element's content, including content not visible on the\nscreen due to overflow.\n\nThe `scrollWidth` value is equal to the minimum width the element would\nrequire in order to fit all the content in the viewport without using a horizontal\nscrollbar. The width is measured in the same way as [Element.clientWidth]:\nit includes the element's padding, but not its border, margin or\nvertical scrollbar (if present). It can also include the width of pseudo-elements such\nas  or . If the element's content can fit\nwithout a need for horizontal scrollbar, its `scrollWidth` is equal to\n[Element.clientWidth]\n\n> **Note:** This property will round the value to an integer. If you need a fractional value,\n> use [element.getBoundingClientRect].",
       "securitypolicyviolation_event": "The **`securitypolicyviolation`** event is fired when a [Content Security Policy](https://developer.mozilla.org/en-US/docs/Web/HTTP/CSP) is violated.\n\nThe event is fired on the element that violates the policy and bubbles.\nIt is normally handled by an event handler on the [Window] or [Document] object.\n\nThe handler can be assigned using the `onsecuritypolicyviolation` property or using [EventTarget.addEventListener].\n\n> **Note:** You must add the handler for this event to a top level object (i.e. [Window] or [Document]).\n> While the property exists in HTML elements, you can't assign a handler to the property until the elements have been loaded, by which time this event will already have fired.",
-      "setattribute": "Sets the value of an attribute on the specified element. If\nthe attribute already exists, the value is updated; otherwise a new attribute is added\nwith the specified name and value.\n\nTo get the current value of an attribute, use [Element.getAttribute]; to remove an attribute, call [Element.removeAttribute].\n\nIf you need to work with the [Attr] node (such as cloning from another element) before adding it, you can use the [Element.setAttributeNode] method instead.",
+      "setattribute": "The **`setAttribute()`** method of the [Element] interface sets the value of an attribute on the specified element. If the attribute already exists, the value is updated; otherwise a new attribute is added with the specified name and value.\n\nTo get the current value of an attribute, use [Element.getAttribute]; to remove an attribute, call [Element.removeAttribute].\n\nIf you need to work with the [Attr] node (such as cloning from another element) before adding it, you can use the [Element.setAttributeNode] method instead.",
       "setattributenode": "The **`setAttributeNode()`** method of the [Element] interface adds a new [Attr] node to the specified element.\n\nIf you don't need to work with the attribute node (such as cloning from another element) before adding it, you can use the [Element.setAttribute] method instead.",
       "setattributenodens": "The **`setAttributeNodeNS()`** method of the [Element] interface adds a new namespaced [Attr] node to an element.\n\nIf you don't need to work with the attribute node (such as cloning from another element) before adding it, you can use the [Element.setAttributeNS] method instead.\n\nIf you are working with HTML documents and you don't need to specify the requested attribute as being part of a specific namespace, use the [Element.setAttribute] method instead.",
       "setattributens": "`setAttributeNS` adds a new attribute or changes the value of an attribute\nwith the given namespace and name.\n\nIf you are working with HTML documents and you don't need to specify the requested attribute as being part of a specific namespace, use the [Element.setAttribute] method instead.",
@@ -2254,8 +2259,8 @@
       "ariapressed": "The **`ariaPressed`** property of the [ElementInternals] interface reflects the value of the [`aria-pressed`](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-pressed) attribute, which indicates the current \"pressed\" state of toggle buttons.\n\n> **Note:** Setting aria attributes on `ElementInternals` allows default semantics to be defined on a custom element. These may be overwritten by author-defined attributes, but ensure that default semantics are retained should the author delete those attributes, or fail to add them at all. For more information see the [Accessibility Object Model explainer](https://wicg.github.io/aom/explainer.html#default-semantics-for-custom-elements-via-the-elementinternals-object).",
       "ariareadonly": "The **`ariaReadOnly`** property of the [ElementInternals] interface reflects the value of the [`aria-readonly`](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-readonly) attribute, which indicates that the element is not editable, but is otherwise operable.\n\n> **Note:** Setting aria attributes on `ElementInternals` allows default semantics to be defined on a custom element. These may be overwritten by author-defined attributes, but ensure that default semantics are retained should the author delete those attributes, or fail to add them at all. For more information see the [Accessibility Object Model explainer](https://wicg.github.io/aom/explainer.html#default-semantics-for-custom-elements-via-the-elementinternals-object).",
       "ariarelevant": "The **`ariaRelevant`** property of the [ElementInternals] interface reflects the value of the [`aria-relevant`](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-relevant) attribute, which indicates what notifications the user agent will trigger when the accessibility tree within a live region is modified. This is used to describe what changes in an `aria-live` region are relevant and should be announced.\n\n> **Note:** Setting aria attributes on `ElementInternals` allows default semantics to be defined on a custom element. These may be overwritten by author-defined attributes, but ensure that default semantics are retained should the author delete those attributes, or fail to add them at all. For more information see the [Accessibility Object Model explainer](https://wicg.github.io/aom/explainer.html#default-semantics-for-custom-elements-via-the-elementinternals-object).",
-      "ariarequired": "The **`ariaRequired`** property of the [Element] interface reflects the value of the [`aria-required`](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-required) attribute, which indicates that user input is required on the element before a form may be submitted.\n\n> **Note:** Setting aria attributes on `ElementInternals` allows default semantics to be defined on a custom element. These may be overwritten by author-defined attributes, but ensure that default semantics are retained should the author delete those attributes, or fail to add them at all. For more information see the [Accessibility Object Model explainer](https://wicg.github.io/aom/explainer.html#default-semantics-for-custom-elements-via-the-elementinternals-object).",
-      "ariaroledescription": "The **`ariaRoleDescription`** property of the [Element] interface reflects the value of the [`aria-roledescription`](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-roledescription) attribute, which defines a human-readable, author-localized description for the role of an element.\n\n> **Note:** Setting aria attributes on `ElementInternals` allows default semantics to be defined on a custom element. These may be overwritten by author-defined attributes, but ensure that default semantics are retained should the author delete those attributes, or fail to add them at all. For more information see the [Accessibility Object Model explainer](https://wicg.github.io/aom/explainer.html#default-semantics-for-custom-elements-via-the-elementinternals-object).",
+      "ariarequired": "The **`ariaRequired`** property of the [ElementInternals] interface reflects the value of the [`aria-required`](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-required) attribute, which indicates that user input is required on the element before a form may be submitted.\n\n> **Note:** Setting aria attributes on `ElementInternals` allows default semantics to be defined on a custom element. These may be overwritten by author-defined attributes, but ensure that default semantics are retained should the author delete those attributes, or fail to add them at all. For more information see the [Accessibility Object Model explainer](https://wicg.github.io/aom/explainer.html#default-semantics-for-custom-elements-via-the-elementinternals-object).",
+      "ariaroledescription": "The **`ariaRoleDescription`** property of the [ElementInternals] interface reflects the value of the [`aria-roledescription`](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-roledescription) attribute, which defines a human-readable, author-localized description for the role of an element.\n\n> **Note:** Setting aria attributes on `ElementInternals` allows default semantics to be defined on a custom element. These may be overwritten by author-defined attributes, but ensure that default semantics are retained should the author delete those attributes, or fail to add them at all. For more information see the [Accessibility Object Model explainer](https://wicg.github.io/aom/explainer.html#default-semantics-for-custom-elements-via-the-elementinternals-object).",
       "ariarowcount": "The **`ariaRowCount`** property of the [ElementInternals] interface reflects the value of the [`aria-rowcount`](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-rowcount) attribute, which defines the total number of rows in a table, grid, or treegrid.\n\n> **Note:** Setting aria attributes on `ElementInternals` allows default semantics to be defined on a custom element. These may be overwritten by author-defined attributes, but ensure that default semantics are retained should the author delete those attributes, or fail to add them at all. For more information see the [Accessibility Object Model explainer](https://wicg.github.io/aom/explainer.html#default-semantics-for-custom-elements-via-the-elementinternals-object).",
       "ariarowindex": "The **`ariaRowIndex`** property of the [ElementInternals] interface reflects the value of the [`aria-rowindex`](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-rowindex) attribute, which defines an element's row index or position with respect to the total number of rows within a table, grid, or treegrid.\n\n> **Note:** Setting aria attributes on `ElementInternals` allows default semantics to be defined on a custom element. These may be overwritten by author-defined attributes, but ensure that default semantics are retained should the author delete those attributes, or fail to add them at all. For more information see the [Accessibility Object Model explainer](https://wicg.github.io/aom/explainer.html#default-semantics-for-custom-elements-via-the-elementinternals-object).",
       "ariarowindextext": "The **`ariaRowIndexText`** property of the [ElementInternals] interface reflects the value of the [`aria-rowindextext`](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-rowindextext) attribute, which defines a human readable text alternative of aria-rowindex.\n\n> **Note:** Setting aria attributes on `ElementInternals` allows default semantics to be defined on a custom element. These may be overwritten by author-defined attributes, but ensure that default semantics are retained should the author delete those attributes, or fail to add them at all. For more information see the [Accessibility Object Model explainer](https://wicg.github.io/aom/explainer.html#default-semantics-for-custom-elements-via-the-elementinternals-object).",
@@ -2282,25 +2287,25 @@
     }
   },
   "EncodedAudioChunk": {
-    "docs": "The **`EncodedAudioChunk`** interface of the [WebCodecs API] represents a chunk of encoded audio data.",
+    "docs": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`EncodedAudioChunk`** interface of the [WebCodecs API] represents a chunk of encoded audio data.",
     "properties": {
-      "bytelength": "The **`byteLength`** read-only property of the [EncodedAudioChunk] interface returns the length in bytes of the encoded audio data.",
-      "copyto": "The **`copyTo()`** method of the [EncodedAudioChunk] interface copies the encoded chunk of audio data.",
-      "duration": "The **`duration`** read-only property of the [EncodedAudioChunk] interface returns an integer indicating the duration of the audio in microseconds.",
-      "encodedaudiochunk": "The **`EncodedAudioChunk()`** constructor creates a new [EncodedAudioChunk] object representing a chunk of encoded audio.",
-      "timestamp": "The **`timestamp`** read-only property of the [EncodedAudioChunk] interface returns an integer indicating the timestamp of the audio in microseconds.",
-      "type": "The **`type`** read-only property of the [EncodedAudioChunk] interface returns a value indicating whether the audio chunk is a key chunk, which does not relying on other frames for decoding."
+      "bytelength": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`byteLength`** read-only property of the [EncodedAudioChunk] interface returns the length in bytes of the encoded audio data.",
+      "copyto": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`copyTo()`** method of the [EncodedAudioChunk] interface copies the encoded chunk of audio data.",
+      "duration": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`duration`** read-only property of the [EncodedAudioChunk] interface returns an integer indicating the duration of the audio in microseconds.",
+      "encodedaudiochunk": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`EncodedAudioChunk()`** constructor creates a new [EncodedAudioChunk] object representing a chunk of encoded audio.",
+      "timestamp": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`timestamp`** read-only property of the [EncodedAudioChunk] interface returns an integer indicating the timestamp of the audio in microseconds.",
+      "type": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`type`** read-only property of the [EncodedAudioChunk] interface returns a value indicating whether the audio chunk is a key chunk, which does not relying on other frames for decoding."
     }
   },
   "EncodedVideoChunk": {
-    "docs": "The **`EncodedVideoChunk`** interface of the [WebCodecs API] represents a chunk of encoded video data.",
+    "docs": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`EncodedVideoChunk`** interface of the [WebCodecs API] represents a chunk of encoded video data.",
     "properties": {
-      "bytelength": "The **`byteLength`** read-only property of the [EncodedVideoChunk] interface returns the length in bytes of the encoded video data.",
-      "copyto": "The **`copyTo()`** method of the [EncodedVideoChunk] interface copies the encoded chunk of video data.",
-      "duration": "The **`duration`** read-only property of the [EncodedVideoChunk] interface returns an integer indicating the duration of the video in microseconds.",
-      "encodedvideochunk": "The **`EncodedVideoChunk()`** constructor creates a new [EncodedVideoChunk] object representing a chunk of encoded video.",
-      "timestamp": "The **`timestamp`** read-only property of the [EncodedVideoChunk] interface returns an integer indicating the timestamp of the video in microseconds.",
-      "type": "The **`type`** read-only property of the [EncodedVideoChunk] interface returns a value indicating whether the video chunk is a key chunk, which does not rely on other frames for decoding."
+      "bytelength": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`byteLength`** read-only property of the [EncodedVideoChunk] interface returns the length in bytes of the encoded video data.",
+      "copyto": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`copyTo()`** method of the [EncodedVideoChunk] interface copies the encoded chunk of video data.",
+      "duration": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`duration`** read-only property of the [EncodedVideoChunk] interface returns an integer indicating the duration of the video in microseconds.",
+      "encodedvideochunk": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`EncodedVideoChunk()`** constructor creates a new [EncodedVideoChunk] object representing a chunk of encoded video.",
+      "timestamp": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`timestamp`** read-only property of the [EncodedVideoChunk] interface returns an integer indicating the timestamp of the video in microseconds.",
+      "type": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`type`** read-only property of the [EncodedVideoChunk] interface returns a value indicating whether the video chunk is a key chunk, which does not rely on other frames for decoding."
     }
   },
   "ErrorEvent": {
@@ -2312,7 +2317,7 @@
       "bubbles": "The **`bubbles`** read-only property of the [Event] interface indicates whether the event bubbles up through the DOM tree or not.\n\n> **Note:** See [Event bubbling and capture](/en-US/docs/Learn/JavaScript/Building_blocks/Events#event_bubbling) for more information on bubbling.",
       "cancelable": "The **`cancelable`** read-only property of the [Event] interface indicates whether the event\ncan be canceled, and therefore prevented as if the event never happened.\n\nIf the event is _not_ cancelable, then its `cancelable` property will be\n`false` and the event listener cannot stop the event from occurring.\n\nMost browser-native events that can be canceled are the ones that result from the user\ninteracting with the page. Canceling the [Element.click_event],\n[Element.wheel_event], or\n[Window.beforeunload_event] events would prevent the user\nfrom clicking on something, scrolling the page with the mouse wheel, or\nnavigating away from the page, respectively.\n\n[Synthetic events](https://developer.mozilla.org/en-US/docs/Web/API/Event/Event) created by other JavaScript\ncode define if they can be canceled when they are created.\n\nTo cancel an event, call the [event.preventDefault]\nmethod on the event. This keeps the implementation from executing the default action\nthat is associated with the event.\n\nEvent listeners that handle multiple kinds of events may want to check\n`cancelable` before invoking their [event.preventDefault] methods.",
       "cancelbubble": "The **`cancelBubble`** property of the [Event]\ninterface is deprecated. Use [Event.stopPropagation] instead.\nSetting its value to `true` before returning from an event handler prevents propagation\nof the event. In later implementations, setting this to `false` does nothing.\nSee [Browser compatibility](#browser_compatibility) for details.",
-      "comparison_of_event_targets": "It's easy to get confused about which event target to examine when writing an event handler. This article should clarify the use of the target properties.\n\nThere are five targets to consider:\n\n<table class=\"no-markdown\">\n  <thead>\n    <tr>\n      <th>Property</th>\n      <th>Defined in</th>\n      <th>Purpose</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <td>\n        <code><a href=\"/en-US/docs/Web/API/Event/target\">event.target</a></code>\n      </td>\n      <td>\n        <a href=\"https://www.w3.org/TR/DOM-Level-2/events.html#Events-interface\"\n          >DOM Event Interface</a\n        >\n      </td>\n      <td>\n        The DOM element on the left-hand side of the call that triggered this\n        event.\n      </td>\n    </tr>\n    <tr>\n      <td>\n        <code\n          ><a href=\"/en-US/docs/Web/API/Event/currentTarget\"\n            >event.currentTarget</a\n          ></code\n        >\n      </td>\n      <td>\n        <a href=\"https://www.w3.org/TR/DOM-Level-2/events.html#Events-interface\"\n          >DOM Event Interface</a\n        >\n      </td>\n      <td>\n        The\n        <a\n          href=\"https://www.w3.org/TR/DOM-Level-2/events.html#Events-EventTarget\"\n          ><code>EventTarget</code></a\n        >\n        whose\n        <a\n          href=\"https://www.w3.org/TR/DOM-Level-2/events.html#Events-EventListener\"\n          ><code>EventListeners</code></a\n        >\n        are currently being processed. As the event capturing and bubbling\n        occurs, this value changes.\n      </td>\n    </tr>\n    <tr>\n      <td>\n        <code\n          ><a href=\"/en-US/docs/Web/API/MouseEvent/relatedTarget\"\n            >event.relatedTarget</a\n          ></code\n        >\n      </td>\n      <td>\n        <a\n          href=\"https://www.w3.org/TR/DOM-Level-2/events.html#Events-MouseEvent\"\n          >DOM MouseEvent Interface</a\n        >\n      </td>\n      <td>Identifies a secondary target for the event.</td>\n    </tr>\n    <tr>\n      <td>\n        <code\n          ><a href=\"/en-US/docs/Web/API/Event/explicitOriginalTarget\"\n            >event.explicitOriginalTarget</a\n          ></code\n        >\n      </td>\n      <td><a href=\"https://dxr.mozilla.org/mozilla-central/source/dom/webidl/Event.webidl\">Event.webidl</a>\n      </td>\n      <td>\n         If the event was retargeted for\n        some reason other than an anonymous boundary crossing, this will be set\n        to the target before the retargeting occurs. For example, mouse events\n        are retargeted to their parent node when they happen over text nodes\n        ([Firefox bug 185889](https://bugzil.la/185889)), and in that case <code>.target</code> will\n        show the parent and <code>.explicitOriginalTarget</code> will show the\n        text node.<br />Unlike <code>.originalTarget</code>,\n        <code>.explicitOriginalTarget</code> will never contain anonymous\n        content.\n      </td>\n    </tr>\n    <tr>\n      <td>\n        <code\n          ><a href=\"/en-US/docs/Web/API/Event/originalTarget\"\n            >event.originalTarget</a\n          ></code\n        >\n      </td>\n      <td>\n        <a href=\"https://dxr.mozilla.org/mozilla-central/source/dom/webidl/Event.webidl\">Event.webidl</a>\n      </td>\n      <td>\n         The original target of the event,\n        before any retargetings. See\n        <a\n          href=\"/en-US/docs/XBL/XBL_1.0_Reference/Anonymous_Content#Event_Flow_and_Targeting\"\n          >Anonymous Content#Event_Flow_and_Targeting</a\n        >\n        for details.\n      </td>\n    </tr>\n    <tr>\n      <td>event.composedTarget</td>\n      <td>\n        <a href=\"https://dxr.mozilla.org/mozilla-central/source/dom/webidl/Event.webidl\">Event.webidl</a>\n      </td>\n      <td>\n         The original non-native target of\n        the event before composition from Shadow DOM.\n      </td>\n    </tr>\n  </tbody>\n</table>\n\n### Use of `explicitOriginalTarget` and `originalTarget`\n\n> **Note:** These properties are only available in Mozilla-based browsers.\n\n### Examples\n\n```html\n<!doctype html>\n<html lang=\"en-US\">\n  <head>\n    <meta charset=\"utf-8\" />\n    <meta http-equiv=\"X-UA-Compatible\" content=\"IE=edge\" />\n    <title>Comparison of Event Targets</title>\n    <style>\n      table {\n        border-collapse: collapse;\n        height: 150px;\n        width: 100%;\n      }\n      td {\n        border: 1px solid #ccc;\n        font-weight: bold;\n        padding: 5px;\n        min-height: 30px;\n      }\n      .standard {\n        background-color: #99ff99;\n      }\n      .non-standard {\n        background-color: #902d37;\n      }\n    </style>\n  </head>\n  <body>\n    <table>\n      <thead>\n        <tr>\n          <td class=\"standard\">\n            Original target dispatching the event <small>event.target</small>\n          </td>\n          <td class=\"standard\">\n            Target who's event listener is being processed\n            <small>event.currentTarget</small>\n          </td>\n          <td class=\"standard\">\n            Identify other element (if any) involved in the event\n            <small>event.relatedTarget</small>\n          </td>\n          <td class=\"non-standard\">\n            If there was a retargeting of the event for some reason\n            <small> event.explicitOriginalTarget</small> contains the target\n            before retargeting (never contains anonymous targets)\n          </td>\n          <td class=\"non-standard\">\n            If there was a retargeting of the event for some reason\n            <small> event.originalTarget</small> contains the target before\n            retargeting (may contain anonymous targets)\n          </td>\n        </tr>\n      </thead>\n      <tr>\n        <td id=\"target\"></td>\n        <td id=\"currentTarget\"></td>\n        <td id=\"relatedTarget\"></td>\n        <td id=\"explicitOriginalTarget\"></td>\n        <td id=\"originalTarget\"></td>\n      </tr>\n    </table>\n    <p>\n      Clicking on the text will show the difference between\n      explicitOriginalTarget, originalTarget, and target\n    </p>\n    <script>\n      function handleClicks(e) {\n        document.getElementById(\"target\").innerHTML = e.target;\n        document.getElementById(\"currentTarget\").innerHTML = e.currentTarget;\n        document.getElementById(\"relatedTarget\").innerHTML = e.relatedTarget;\n        document.getElementById(\"explicitOriginalTarget\").innerHTML =\n          e.explicitOriginalTarget;\n        document.getElementById(\"originalTarget\").innerHTML = e.originalTarget;\n      }\n\n      function handleMouseover(e) {\n        document.getElementById(\"target\").innerHTML = e.target;\n        document.getElementById(\"relatedTarget\").innerHTML = e.relatedTarget;\n      }\n\n      document.addEventListener(\"click\", handleClicks, false);\n      document.addEventListener(\"mouseover\", handleMouseover, false);\n    </script>\n  </body>\n</html>\n```\n\n### Use of `target` and `relatedTarget`\n\nThe `relatedTarget` property for the `mouseover` event holds the node that the mouse was previously over. For the `mouseout` event, it holds the node that the mouse moved to.\n\n| Event type  | [event.target](https://developer.mozilla.org/en-US/docs/Web/API/Event/target)  | [event.relatedTarget](https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/relatedTarget) |\n| ----------- | ------------------------------------------------- | ------------------------------------------------------------------- |\n| `mouseover` | the EventTarget which the pointing device entered | the EventTarget which the pointing device exited                    |\n| `mouseout`  | the EventTarget which the pointing device exited  | the EventTarget which the pointing device entered                   |\n\n#### Example\n\n```xml\n<hbox id=\"outer\">\n  <hbox id=\"inner\"\n        onmouseover=\"dump('mouseover ' + event.relatedTarget.id + ' > ' + event.target.id + '\\n');\"\n        onmouseout=\"dump('mouseout  ' + event.target.id + ' > ' + event.relatedTarget.id + '\\n');\"\n        style=\"margin: 100px; border: 10px solid black; width: 100px; height: 100px;\" />\n</hbox>\n```",
+      "comparison_of_event_targets": "It's easy to get confused about which event target to examine when writing an event handler. This article should clarify the use of the target properties.\n\nThere are five targets to consider:\n\n<table class=\"no-markdown\">\n  <thead>\n    <tr>\n      <th>Property</th>\n      <th>Defined in</th>\n      <th>Purpose</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <td>\n        <code><a href=\"/en-US/docs/Web/API/Event/target\">event.target</a></code>\n      </td>\n      <td>\n        <a href=\"https://www.w3.org/TR/DOM-Level-2/events.html#Events-interface\">DOM Event Interface</a>\n      </td>\n      <td>\n        The DOM element on the left-hand side of the call that triggered this event.\n      </td>\n    </tr>\n    <tr>\n      <td>\n        <code><a href=\"/en-US/docs/Web/API/Event/currentTarget\">event.currentTarget</a></code>\n      </td>\n      <td>\n        <a href=\"https://www.w3.org/TR/DOM-Level-2/events.html#Events-interface\">DOM Event Interface</a>\n      </td>\n      <td>\n        The <a href=\"https://www.w3.org/TR/DOM-Level-2/events.html#Events-EventTarget\"><code>EventTarget</code></a> whose <a href=\"https://www.w3.org/TR/DOM-Level-2/events.html#Events-EventListener\"><code>EventListeners</code></a> are currently being processed. As the event capturing and bubbling occurs, this value changes.\n      </td>\n    </tr>\n    <tr>\n      <td>\n        <code><a href=\"/en-US/docs/Web/API/MouseEvent/relatedTarget\">event.relatedTarget</a></code>\n      </td>\n      <td>\n        <a href=\"https://www.w3.org/TR/DOM-Level-2/events.html#Events-MouseEvent\">DOM MouseEvent Interface</a>\n      </td>\n      <td>Identifies a secondary target for the event.</td>\n    </tr>\n    <tr>\n      <td>\n        <code><a href=\"/en-US/docs/Web/API/Event/explicitOriginalTarget\">event.explicitOriginalTarget</a></code>\n      </td>\n      <td>\n        <a href=\"https://searchfox.org/mozilla-central/source/dom/webidl/Event.webidl\">Event.webidl</a>\n      </td>\n      <td>\n         If the event was retargeted for some reason other than an anonymous boundary crossing, this will be set to the target before the retargeting occurs. For example, mouse events are retargeted to their parent node when they happen over text nodes ([Firefox bug 185889](https://bugzil.la/185889)), and in that case <code>.target</code> will show the parent and <code>.explicitOriginalTarget</code> will show the text node.<br />\n        Unlike <code>.originalTarget</code>, <code>.explicitOriginalTarget</code> will never contain anonymous content.\n      </td>\n    </tr>\n    <tr>\n      <td>\n        <code><a href=\"/en-US/docs/Web/API/Event/originalTarget\">event.originalTarget</a></code>\n      </td>\n      <td>\n        <a href=\"https://searchfox.org/mozilla-central/source/dom/webidl/Event.webidl\">Event.webidl</a>\n      </td>\n      <td>\n         The original target of the event, before any retargetings. See <a href=\"/en-US/docs/XBL/XBL_1.0_Reference/Anonymous_Content#Event_Flow_and_Targeting\">Anonymous Content#Event_Flow_and_Targeting</a> for details.\n      </td>\n    </tr>\n    <tr>\n      <td>event.composedTarget</td>\n      <td>\n        <a href=\"https://searchfox.org/mozilla-central/source/dom/webidl/Event.webidl\">Event.webidl</a>\n      </td>\n      <td>\n         The original non-native target of the event before composition from Shadow DOM.\n      </td>\n    </tr>\n  </tbody>\n</table>\n\n### Use of `explicitOriginalTarget` and `originalTarget`\n\n> **Note:** These properties are only available in Mozilla-based browsers.\n\n### Examples\n\n```html\n<!doctype html>\n<html lang=\"en-US\">\n  <head>\n    <meta charset=\"utf-8\" />\n    <meta http-equiv=\"X-UA-Compatible\" content=\"IE=edge\" />\n    <title>Comparison of Event Targets</title>\n    <style>\n      table {\n        border-collapse: collapse;\n        height: 150px;\n        width: 100%;\n      }\n      td {\n        border: 1px solid #ccc;\n        font-weight: bold;\n        padding: 5px;\n        min-height: 30px;\n      }\n      .standard {\n        background-color: #99ff99;\n      }\n      .non-standard {\n        background-color: #902d37;\n      }\n    </style>\n  </head>\n  <body>\n    <table>\n      <thead>\n        <tr>\n          <td class=\"standard\">\n            Original target dispatching the event <small>event.target</small>\n          </td>\n          <td class=\"standard\">\n            Target who's event listener is being processed\n            <small>event.currentTarget</small>\n          </td>\n          <td class=\"standard\">\n            Identify other element (if any) involved in the event\n            <small>event.relatedTarget</small>\n          </td>\n          <td class=\"non-standard\">\n            If there was a retargeting of the event for some reason\n            <small>event.explicitOriginalTarget</small> contains the target\n            before retargeting (never contains anonymous targets)\n          </td>\n          <td class=\"non-standard\">\n            If there was a retargeting of the event for some reason\n            <small>event.originalTarget</small> contains the target before\n            retargeting (may contain anonymous targets)\n          </td>\n        </tr>\n      </thead>\n      <tr>\n        <td id=\"target\"></td>\n        <td id=\"currentTarget\"></td>\n        <td id=\"relatedTarget\"></td>\n        <td id=\"explicitOriginalTarget\"></td>\n        <td id=\"originalTarget\"></td>\n      </tr>\n    </table>\n    <p>\n      Clicking on the text will show the difference between\n      explicitOriginalTarget, originalTarget, and target\n    </p>\n    <script>\n      function handleClicks(e) {\n        document.getElementById(\"target\").innerHTML = e.target;\n        document.getElementById(\"currentTarget\").innerHTML = e.currentTarget;\n        document.getElementById(\"relatedTarget\").innerHTML = e.relatedTarget;\n        document.getElementById(\"explicitOriginalTarget\").innerHTML =\n          e.explicitOriginalTarget;\n        document.getElementById(\"originalTarget\").innerHTML = e.originalTarget;\n      }\n\n      function handleMouseover(e) {\n        document.getElementById(\"target\").innerHTML = e.target;\n        document.getElementById(\"relatedTarget\").innerHTML = e.relatedTarget;\n      }\n\n      document.addEventListener(\"click\", handleClicks, false);\n      document.addEventListener(\"mouseover\", handleMouseover, false);\n    </script>\n  </body>\n</html>\n```\n\n### Use of `target` and `relatedTarget`\n\nThe `relatedTarget` property for the `mouseover` event holds the node that the mouse was previously over. For the `mouseout` event, it holds the node that the mouse moved to.\n\n| Event type  | [event.target](https://developer.mozilla.org/en-US/docs/Web/API/Event/target)  | [event.relatedTarget](https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/relatedTarget) |\n| ----------- | ------------------------------------------------- | ------------------------------------------------------------------- |\n| `mouseover` | the EventTarget which the pointing device entered | the EventTarget which the pointing device exited                    |\n| `mouseout`  | the EventTarget which the pointing device exited  | the EventTarget which the pointing device entered                   |\n\n#### Example\n\n```xml\n<hbox id=\"outer\">\n  <hbox id=\"inner\"\n        onmouseover=\"console.log('mouseover ' + event.relatedTarget.id + ' > ' + event.target.id + '\\n');\"\n        onmouseout=\"console.log('mouseout  ' + event.target.id + ' > ' + event.relatedTarget.id + '\\n');\"\n        style=\"margin: 100px; border: 10px solid black; width: 100px; height: 100px;\" />\n</hbox>\n```",
       "composed": "The read-only **`composed`** property of the\n[Event] interface returns a boolean value which indicates whether\nor not the event will propagate across the shadow DOM boundary into the standard DOM.\n\nAll UA-dispatched UI events are composed (click/touch/mouseover/copy/paste, etc.). Most\nother types of events are not composed, and so will return `false`. For\nexample, this includes synthetic events that are created without their\n`composed` option set to `true`.\n\nPropagation only occurs if the [Event.bubbles] property is also\n`true`. However, capturing only composed events are also handled at host as\nif they were in `AT_TARGET` phase. You can determine the path the event will\nfollow through the shadow root to the DOM root by calling\n[Event.composedPath].",
       "composedpath": "The **`composedPath()`** method of the [Event]\ninterface returns the event's path which is an array of the objects on which listeners\nwill be invoked. This does not include nodes in shadow trees if the shadow root was\ncreated with its [ShadowRoot.mode] closed.",
       "currenttarget": "The **`currentTarget`** read-only property of the [Event] interface identifies the element to which the event handler has been attached.\n\nThis will not always be the same as the element on which the event was fired, because the event may have fired on a descendant of the element with the handler, and then [bubbled](/en-US/docs/Learn/JavaScript/Building_blocks/Events#event_bubbling) up to the element with the handler. The element on which the event was fired is given by [Event.target].",
@@ -2359,29 +2364,29 @@
     }
   },
   "ExtendableCookieChangeEvent": {
-    "docs": "The **`ExtendableCookieChangeEvent`** interface of the [Cookie Store API] is the event type passed to [ServiceWorkerGlobalScope.cookiechange_event] event fired at the [ServiceWorkerGlobalScope] when any cookie changes occur which match the service worker's cookie change subscription list. A cookie change event consists of a cookie and a type. (either \"changed\" or \"deleted\")\n\nCookie changes that cause the `ExtendableCookieChangeEvent` to be dispatched are:\n\n- A cookie is newly created and not immediately removed. In this case `type` is \"changed\".\n- A cookie is newly created and immediately removed. In this case `type` is \"deleted\"\n- A cookie is removed. In this case `type` is \"deleted\".\n\n> **Note:** A cookie that is replaced due to the insertion of another cookie with the same name, domain, and path, is ignored and does not trigger a change event.",
+    "docs": "@AvailableInWorkers(\"service\")\n\nThe **`ExtendableCookieChangeEvent`** interface of the [Cookie Store API] is the event type passed to [ServiceWorkerGlobalScope.cookiechange_event] event fired at the [ServiceWorkerGlobalScope] when any cookie changes occur which match the service worker's cookie change subscription list. A cookie change event consists of a cookie and a type. (either \"changed\" or \"deleted\")\n\nCookie changes that cause the `ExtendableCookieChangeEvent` to be dispatched are:\n\n- A cookie is newly created and not immediately removed. In this case `type` is \"changed\".\n- A cookie is newly created and immediately removed. In this case `type` is \"deleted\"\n- A cookie is removed. In this case `type` is \"deleted\".\n\n> **Note:** A cookie that is replaced due to the insertion of another cookie with the same name, domain, and path, is ignored and does not trigger a change event.",
     "properties": {
-      "changed": "The **`changed`** read-only property of the [ExtendableCookieChangeEvent] interface returns any cookies that have been changed by the given `ExtendableCookieChangeEvent` instance.",
-      "deleted": "The **`deleted`** read-only property of the [ExtendableCookieChangeEvent] interface returns any cookies that have been deleted by the given `ExtendableCookieChangeEvent` instance.",
-      "extendablecookiechangeevent": "The **`ExtendableCookieChangeEvent()`** constructor creates a new [ExtendableCookieChangeEvent] object\nwhich is the event type passed to [ServiceWorkerGlobalScope.cookiechange_event] event fired at the [ServiceWorkerGlobalScope] when any cookie changes occur which match the service worker's cookie change subscription list.\nThis constructor is called by the browser when a change event occurs.\n\n> **Note:** This event constructor is generally not needed for production websites. It's primary use is for tests that require an instance of this event."
+      "changed": "@AvailableInWorkers(\"service\")\n\nThe **`changed`** read-only property of the [ExtendableCookieChangeEvent] interface returns any cookies that have been changed by the given `ExtendableCookieChangeEvent` instance.",
+      "deleted": "@AvailableInWorkers(\"service\")\n\nThe **`deleted`** read-only property of the [ExtendableCookieChangeEvent] interface returns any cookies that have been deleted by the given `ExtendableCookieChangeEvent` instance.",
+      "extendablecookiechangeevent": "@AvailableInWorkers(\"service\")\n\nThe **`ExtendableCookieChangeEvent()`** constructor creates a new [ExtendableCookieChangeEvent] object\nwhich is the event type passed to [ServiceWorkerGlobalScope.cookiechange_event] event fired at the [ServiceWorkerGlobalScope] when any cookie changes occur which match the service worker's cookie change subscription list.\nThis constructor is called by the browser when a change event occurs.\n\n> **Note:** This event constructor is generally not needed for production websites. It's primary use is for tests that require an instance of this event."
     }
   },
   "ExtendableEvent": {
-    "docs": "The **`ExtendableEvent`** interface extends the lifetime of the [`install`](https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerGlobalScope/install_event) and [`activate`](https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerGlobalScope/activate_event) events dispatched on the global scope as part of the service worker lifecycle. This ensures that any functional events (like [FetchEvent]) are not dispatched until it upgrades database schemas and deletes the outdated cache entries.\n\nIf [ExtendableEvent.waitUntil] is called outside of the `ExtendableEvent` handler, the browser should throw an `InvalidStateError`; note also that multiple calls will stack up, and the resulting promises will be added to the list of [extend lifetime promises](https://w3c.github.io/ServiceWorker/#extendableevent-extend-lifetime-promises).\n\nThis interface inherits from the [Event] interface.\n\n> **Note:** This interface is only available when the global scope is a [ServiceWorkerGlobalScope]. It is not available when it is a [Window], or the scope of another kind of worker.",
+    "docs": "@AvailableInWorkers(\"service\")\n\nThe **`ExtendableEvent`** interface extends the lifetime of the [`install`](https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerGlobalScope/install_event) and [`activate`](https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerGlobalScope/activate_event) events dispatched on the global scope as part of the service worker lifecycle. This ensures that any functional events (like [FetchEvent]) are not dispatched until it upgrades database schemas and deletes the outdated cache entries.\n\nIf [ExtendableEvent.waitUntil] is called outside of the `ExtendableEvent` handler, the browser should throw an `InvalidStateError`; note also that multiple calls will stack up, and the resulting promises will be added to the list of [extend lifetime promises](https://w3c.github.io/ServiceWorker/#extendableevent-extend-lifetime-promises).\n\nThis interface inherits from the [Event] interface.\n\n> **Note:** This interface is only available when the global scope is a [ServiceWorkerGlobalScope]. It is not available when it is a [Window], or the scope of another kind of worker.",
     "properties": {
-      "extendableevent": "The **`ExtendableEvent()`** constructor creates a new [ExtendableEvent] object.",
-      "waituntil": "The **`ExtendableEvent.waitUntil()`**\nmethod tells the event dispatcher that work is ongoing. It can also be used to detect\nwhether that work was successful. In service workers, `waitUntil()` tells\nthe browser that work is ongoing until the promise settles, and it shouldn't terminate\nthe service worker if it wants that work to complete.\n\nThe [ServiceWorkerGlobalScope.install_event] events in [service workers](https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerGlobalScope) use\n`waitUntil()` to hold the service worker in\nthe [ServiceWorkerRegistration.installing] phase until tasks\ncomplete. If the promise passed to `waitUntil()` rejects, the install is\nconsidered a failure, and the installing service worker is discarded. This is primarily\nused to ensure that a service worker is not considered installed until all of the core\ncaches it depends on are successfully populated.\n\nThe [ServiceWorkerGlobalScope.activate_event] events in [service workers](https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerGlobalScope) use\n`waitUntil()` to buffer functional events such as `fetch` and\n`push` until the promise passed to `waitUntil()` settles. This\ngives the service worker time to update database schemas and delete outdated\n[Cache], so other events can rely on a completely upgraded state.\n\nThe `waitUntil()` method must be initially called within the event callback,\nbut after that it can be called multiple times, until all the promises passed to it\nsettle."
+      "extendableevent": "@AvailableInWorkers(\"service\")\n\nThe **`ExtendableEvent()`** constructor creates a new [ExtendableEvent] object.",
+      "waituntil": "@AvailableInWorkers(\"service\")\n\nThe **`ExtendableEvent.waitUntil()`**\nmethod tells the event dispatcher that work is ongoing. It can also be used to detect\nwhether that work was successful. In service workers, `waitUntil()` tells\nthe browser that work is ongoing until the promise settles, and it shouldn't terminate\nthe service worker if it wants that work to complete.\n\nThe [ServiceWorkerGlobalScope.install_event] events in [service workers](https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerGlobalScope) use\n`waitUntil()` to hold the service worker in\nthe [ServiceWorkerRegistration.installing] phase until tasks\ncomplete. If the promise passed to `waitUntil()` rejects, the install is\nconsidered a failure, and the installing service worker is discarded. This is primarily\nused to ensure that a service worker is not considered installed until all of the core\ncaches it depends on are successfully populated.\n\nThe [ServiceWorkerGlobalScope.activate_event] events in [service workers](https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerGlobalScope) use\n`waitUntil()` to buffer functional events such as `fetch` and\n`push` until the promise passed to `waitUntil()` settles. This\ngives the service worker time to update database schemas and delete outdated\n[Cache], so other events can rely on a completely upgraded state.\n\nThe `waitUntil()` method must be initially called within the event callback,\nbut after that it can be called multiple times, until all the promises passed to it\nsettle."
     }
   },
   "ExtendableMessageEvent": {
-    "docs": "The **`ExtendableMessageEvent`** interface of the [Service Worker API](https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API) represents the event object of a [ServiceWorkerGlobalScope.message_event] event fired on a service worker (when a message is received on the [ServiceWorkerGlobalScope] from another context) — extends the lifetime of such events.\n\nThis interface inherits from the [ExtendableEvent] interface.",
+    "docs": "@AvailableInWorkers(\"service\")\n\nThe **`ExtendableMessageEvent`** interface of the [Service Worker API](https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API) represents the event object of a [ServiceWorkerGlobalScope.message_event] event fired on a service worker (when a message is received on the [ServiceWorkerGlobalScope] from another context) — extends the lifetime of such events.\n\nThis interface inherits from the [ExtendableEvent] interface.",
     "properties": {
-      "data": "The **`data`** read-only property of the\n[ExtendableMessageEvent] interface returns the event's data. It can be any\ndata type.",
-      "extendablemessageevent": "The **`ExtendableMessageEvent()`** constructor creates a new [ExtendableMessageEvent] object.",
-      "lasteventid": "The **`lastEventID`** read-only property of the\n[ExtendableMessageEvent] interface represents, in [server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events), the last event ID of the event source. This is an empty string.",
-      "origin": "The **`origin`** read-only property of the\n[ExtendableMessageEvent] interface returns the origin of the\n[Client] that sent the message.",
-      "ports": "The **`ports`** read-only property of the\n[ExtendableMessageEvent] interface returns the array containing the\n[MessagePort] objects representing the ports of the associated message\nchannel (the channel the message is being sent through.)",
-      "source": "The **`source`** read-only property of the\n[ExtendableMessageEvent] interface returns a reference to the\n[Client] object from which the message was sent."
+      "data": "@AvailableInWorkers(\"service\")\n\nThe **`data`** read-only property of the\n[ExtendableMessageEvent] interface returns the event's data. It can be any\ndata type.",
+      "extendablemessageevent": "@AvailableInWorkers(\"service\")\n\nThe **`ExtendableMessageEvent()`** constructor creates a new [ExtendableMessageEvent] object.",
+      "lasteventid": "@AvailableInWorkers(\"service\")\n\nThe **`lastEventID`** read-only property of the\n[ExtendableMessageEvent] interface represents, in [server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events), the last event ID of the event source. This is an empty string.",
+      "origin": "@AvailableInWorkers(\"service\")\n\nThe **`origin`** read-only property of the\n[ExtendableMessageEvent] interface returns the origin of the\n[Client] that sent the message.",
+      "ports": "@AvailableInWorkers(\"service\")\n\nThe **`ports`** read-only property of the\n[ExtendableMessageEvent] interface returns the array containing the\n[MessagePort] objects representing the ports of the associated message\nchannel (the channel the message is being sent through.)",
+      "source": "@AvailableInWorkers(\"service\")\n\nThe **`source`** read-only property of the\n[ExtendableMessageEvent] interface returns a reference to the\n[Client] object from which the message was sent."
     }
   },
   "EyeDropper": {
@@ -2408,6 +2413,9 @@
       "provider": "The **`provider`** property of the\n[FederatedCredential] interface returns a string\ncontaining a credential's federated identity provider."
     }
   },
+  "FederatedCredentialInit": {
+    "docs": "The **`FederatedCredentialInit`** dictionary represents the object passed to [CredentialsContainer.create] as the value of the `federated` option: that is, when creating a [FederatedCredential] object representing a credential associated with a federated identify provider.\n\n> **Note:** The [Federated Credential Management API (FedCM)](https://developer.mozilla.org/en-US/docs/Web/API/FedCM_API) supersedes the [FederatedCredential] interface in favor of the [IdentityCredential] interface.\n>\n> The `FederatedCredentialInit` dictionary is not used when working with the `IdentityCredential`interface."
+  },
   "Fence": {
     "docs": "The **`Fence`** interface of the [Fenced Frame API] contains several functions relevant to `fencedframe` functionality.\n\n`Fence` objects are accessed through the [Window.fence] property, but they are only available to documents embedded inside `fencedframe`s (loaded via [FencedFrameConfig]s) or `iframe`s (loaded via opaque URNs).\n\n> **Note:** See [How do `<fencedframe>`s work?](/en-US/docs/Web/API/Fenced_frame_API#how_do_fencedframes_work) for some description around `FencedFrameConfig`s and opaque URNs.",
     "properties": {
@@ -2423,17 +2431,17 @@
     }
   },
   "FetchEvent": {
-    "docs": "This is the event type for `fetch` events dispatched on the [ServiceWorkerGlobalScope]. It contains information about the fetch, including the request and how the receiver will treat the response. It provides the [FetchEvent.respondWith] method, which allows us to provide a response to this fetch.",
+    "docs": "@AvailableInWorkers(\"service\")\n\nThis is the event type for `fetch` events dispatched on the [ServiceWorkerGlobalScope]. It contains information about the fetch, including the request and how the receiver will treat the response. It provides the [FetchEvent.respondWith] method, which allows us to provide a response to this fetch.",
     "properties": {
-      "clientid": "The **`clientId`** read-only property of the\n[FetchEvent] interface returns the id of the [Client] that the\ncurrent service worker is controlling.\n\nThe [Clients.get] method could then be passed this ID to retrieve the\nassociated client.",
-      "fetchevent": "The **`FetchEvent()`** constructor creates a new [FetchEvent] object.",
-      "handled": "The **`handled`** property of the [FetchEvent] interface returns a promise indicating if the event has been handled by the fetch algorithm or not. This property allows executing code after the browser has consumed a response, and is usually used together with the [ExtendableEvent.waitUntil] method.",
-      "isreload": "The **`isReload`** read-only property of the\n[FetchEvent] interface returns `true` if the event was\ndispatched by the user attempting to reload the page, and `false` otherwise.\nPressing the refresh button is a reload while clicking a link and pressing the back\nbutton is not.",
-      "preloadresponse": "The **`preloadResponse`** read-only property of the [FetchEvent] interface returns a `Promise` that resolves to the navigation preload [Response] if [navigation preload](https://developer.mozilla.org/en-US/docs/Web/API/NavigationPreloadManager) was triggered, or `undefined` otherwise.\n\nNavigation preload is triggered if [navigation preload is enabled](https://developer.mozilla.org/en-US/docs/Web/API/NavigationPreloadManager/enable), the request is a `GET` request, and the request is a navigation request (generated by the browser when loading pages and iframes).\n\nA service worker can wait on this promise in its fetch event handler in order to track completion of a fetch request made during service-worker boot.",
-      "replacesclientid": "The **`replacesClientId`** read-only property of the\n[FetchEvent] interface is the [Client.id] of the\n[Client] that is being replaced during a page navigation.\n\nFor example, when navigating from page A to page B `replacesClientId` is the\nID of the client associated with page A. It can be an empty string when navigating from\n`about:blank` to another page, as `about:blank`'s client will be\nreused, rather than be replaced.\n\nAdditionally, if the fetch isn't a navigation, `replacesClientId` will be an\nempty string. This could be used to access/communicate with a client that will\nimminently be replaced, right before a navigation.",
-      "request": "The **`request`** read-only property of the\n[FetchEvent] interface returns the [Request] that triggered\nthe event handler.\n\nThis property is non-nullable (since version 46, in the case of Firefox.) If a request\nis not provided by some other means, the constructor `options` object must\ncontain a request (see [FetchEvent.FetchEvent].)",
-      "respondwith": "The **`respondWith()`** method of\n[FetchEvent] prevents the browser's default fetch handling, and\nallows you to provide a promise for a [Response] yourself.\n\nIn most cases you can provide any response that the receiver understands. For example,\nif an `img` initiates the request, the response body needs to be\nimage data. For security reasons, there are a few global rules:\n\n- You can only return [Response] objects of [Response.type]\n  \"`opaque`\" if the [fetchEvent.request] object's\n  [request.mode] is \"`no-cors`\". This prevents the\n  leaking of private data.\n- You can only return [Response] objects of [Response.type]\n  \"`opaqueredirect`\" if the [fetchEvent.request]\n  object's [request.mode] is \"`manual`\".\n- You cannot return [Response] objects of [Response.type]\n  \"`cors`\" if the [fetchEvent.request] object's\n  [request.mode] is \"`same-origin`\".\n\n### Specifying the final URL of a resource\n\nFrom Firefox 59 onwards, when a service worker provides a [Response] to\n[FetchEvent.respondWith], the [Response.url] value will be\npropagated to the intercepted network request as the final resolved URL. If the\n[Response.url] value is the empty string, then the\n[Request.url] is used as the final URL.\n\nIn the past the [Request.url] was used as the\nfinal URL in all cases. The provided [Response.url] was effectively\nignored.\n\nThis means, for example, if a service worker intercepts a stylesheet or worker script,\nthen the provided [Response.url] will be used to resolve any relative\n or\n[WorkerGlobalScope.importScripts] subresource loads\n([Firefox bug 1222008](https://bugzil.la/1222008)).\n\nFor most types of network request this change has no impact because you can't observe\nthe final URL. There are a few, though, where it does matter:\n\n- If a [fetch] is intercepted,\n  then you can observe the final URL on the result's [Response.url].\n- If a [worker](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API) script is\n  intercepted, then the final URL is used to set\n  [`self.location`](https://developer.mozilla.org/en-US/docs/Web/API/WorkerGlobalScope/location)\n  and used as the base URL for relative URLs in the worker script.\n- If a stylesheet is intercepted, then the final URL is used as the base URL for\n  resolving relative  loads.\n\nNote that navigation requests for [Window] and\n[HTMLIFrameElement] do NOT use the final URL. The way the HTML\nspecification handles redirects for navigations ends up using the request URL for the\nresulting [Window.location]. This means sites can still provide an\n\"alternate\" view of a web page when offline without changing the user-visible URL.",
-      "resultingclientid": "The **`resultingClientId`** read-only property of the\n[FetchEvent] interface is the [Client.id] of the\n[Client] that replaces the previous client during a page\nnavigation.\n\nFor example, when navigating from page A to page B `resultingClientId` is\nthe ID of the client associated with page B.\n\nIf the fetch request is a subresource request or the request's\n[`destination`](https://developer.mozilla.org/en-US/docs/Web/API/Request/destination) is\n`report`, `resultingClientId` will be an empty string."
+      "clientid": "@AvailableInWorkers(\"service\")\n\nThe **`clientId`** read-only property of the\n[FetchEvent] interface returns the id of the [Client] that the\ncurrent service worker is controlling.\n\nThe [Clients.get] method could then be passed this ID to retrieve the\nassociated client.",
+      "fetchevent": "@AvailableInWorkers(\"service\")\n\nThe **`FetchEvent()`** constructor creates a new [FetchEvent] object.",
+      "handled": "@AvailableInWorkers(\"service\")\n\nThe **`handled`** property of the [FetchEvent] interface returns a promise indicating if the event has been handled by the fetch algorithm or not. This property allows executing code after the browser has consumed a response, and is usually used together with the [ExtendableEvent.waitUntil] method.",
+      "isreload": "@AvailableInWorkers(\"service\")\n\nThe **`isReload`** read-only property of the\n[FetchEvent] interface returns `true` if the event was\ndispatched by the user attempting to reload the page, and `false` otherwise.\nPressing the refresh button is a reload while clicking a link and pressing the back\nbutton is not.",
+      "preloadresponse": "@AvailableInWorkers(\"service\")\n\nThe **`preloadResponse`** read-only property of the [FetchEvent] interface returns a `Promise` that resolves to the navigation preload [Response] if [navigation preload](https://developer.mozilla.org/en-US/docs/Web/API/NavigationPreloadManager) was triggered, or `undefined` otherwise.\n\nNavigation preload is triggered if [navigation preload is enabled](https://developer.mozilla.org/en-US/docs/Web/API/NavigationPreloadManager/enable), the request is a `GET` request, and the request is a navigation request (generated by the browser when loading pages and iframes).\n\nA service worker can wait on this promise in its fetch event handler in order to track completion of a fetch request made during service-worker boot.",
+      "replacesclientid": "@AvailableInWorkers(\"service\")\n\nThe **`replacesClientId`** read-only property of the\n[FetchEvent] interface is the [Client.id] of the\n[Client] that is being replaced during a page navigation.\n\nFor example, when navigating from page A to page B `replacesClientId` is the\nID of the client associated with page A. It can be an empty string when navigating from\n`about:blank` to another page, as `about:blank`'s client will be\nreused, rather than be replaced.\n\nAdditionally, if the fetch isn't a navigation, `replacesClientId` will be an\nempty string. This could be used to access/communicate with a client that will\nimminently be replaced, right before a navigation.",
+      "request": "@AvailableInWorkers(\"service\")\n\nThe **`request`** read-only property of the\n[FetchEvent] interface returns the [Request] that triggered\nthe event handler.\n\nThis property is non-nullable (since version 46, in the case of Firefox.) If a request\nis not provided by some other means, the constructor `options` object must\ncontain a request (see [FetchEvent.FetchEvent].)",
+      "respondwith": "@AvailableInWorkers(\"service\")\n\nThe **`respondWith()`** method of\n[FetchEvent] prevents the browser's default fetch handling, and\nallows you to provide a promise for a [Response] yourself.\n\nIn most cases you can provide any response that the receiver understands. For example,\nif an `img` initiates the request, the response body needs to be\nimage data. For security reasons, there are a few global rules:\n\n- You can only return [Response] objects of [Response.type]\n  \"`opaque`\" if the [fetchEvent.request] object's\n  [request.mode] is \"`no-cors`\". This prevents the\n  leaking of private data.\n- You can only return [Response] objects of [Response.type]\n  \"`opaqueredirect`\" if the [fetchEvent.request]\n  object's [request.mode] is \"`manual`\".\n- You cannot return [Response] objects of [Response.type]\n  \"`cors`\" if the [fetchEvent.request] object's\n  [request.mode] is \"`same-origin`\".\n\n### Specifying the final URL of a resource\n\nFrom Firefox 59 onwards, when a service worker provides a [Response] to\n[FetchEvent.respondWith], the [Response.url] value will be\npropagated to the intercepted network request as the final resolved URL. If the\n[Response.url] value is the empty string, then the\n[Request.url] is used as the final URL.\n\nIn the past the [Request.url] was used as the\nfinal URL in all cases. The provided [Response.url] was effectively\nignored.\n\nThis means, for example, if a service worker intercepts a stylesheet or worker script,\nthen the provided [Response.url] will be used to resolve any relative\n or\n[WorkerGlobalScope.importScripts] subresource loads\n([Firefox bug 1222008](https://bugzil.la/1222008)).\n\nFor most types of network request this change has no impact because you can't observe\nthe final URL. There are a few, though, where it does matter:\n\n- If a [fetch] is intercepted,\n  then you can observe the final URL on the result's [Response.url].\n- If a [worker](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API) script is\n  intercepted, then the final URL is used to set\n  [`self.location`](https://developer.mozilla.org/en-US/docs/Web/API/WorkerGlobalScope/location)\n  and used as the base URL for relative URLs in the worker script.\n- If a stylesheet is intercepted, then the final URL is used as the base URL for\n  resolving relative  loads.\n\nNote that navigation requests for [Window] and\n[HTMLIFrameElement] do NOT use the final URL. The way the HTML\nspecification handles redirects for navigations ends up using the request URL for the\nresulting [Window.location]. This means sites can still provide an\n\"alternate\" view of a web page when offline without changing the user-visible URL.",
+      "resultingclientid": "@AvailableInWorkers(\"service\")\n\nThe **`resultingClientId`** read-only property of the\n[FetchEvent] interface is the [Client.id] of the\n[Client] that replaces the previous client during a page\nnavigation.\n\nFor example, when navigating from page A to page B `resultingClientId` is\nthe ID of the client associated with page B.\n\nIf the fetch request is a subresource request or the request's\n[`destination`](https://developer.mozilla.org/en-US/docs/Web/API/Request/destination) is\n`report`, `resultingClientId` will be an empty string."
     }
   },
   "File": {
@@ -2457,33 +2465,33 @@
     }
   },
   "FileReader": {
-    "docs": "The **`FileReader`** object lets web applications asynchronously read the contents of files (or raw data buffers) stored on the user's computer, using [File] or [Blob] objects to specify the file or data to read.\n\nFile objects may be obtained from a [FileList] object returned as a result of a user selecting files using the `input` element, or from a drag and drop operation's [DataTransfer] object.\n\n`FileReader` can only access the contents of files that the user has explicitly selected, either using an HTML `<input type=\"file\">` element or by drag and drop. It cannot be used to read a file by pathname from the user's file system. To read files on the client's file system by pathname, use the [File System Access API](https://developer.mozilla.org/en-US/docs/Web/API/File_System_API). To read server-side files, use [fetch], with [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) permission if reading cross-domain.",
+    "docs": "The **`FileReader`** interface lets web applications asynchronously read the contents of files (or raw data buffers) stored on the user's computer, using [File] or [Blob] objects to specify the file or data to read.\n\nFile objects may be obtained from a [FileList] object returned as a result of a user selecting files using the `input` element, or from a drag and drop operation's [DataTransfer] object.\n\n`FileReader` can only access the contents of files that the user has explicitly selected, either using an HTML `<input type=\"file\">` element or by drag and drop. It cannot be used to read a file by pathname from the user's file system. To read files on the client's file system by pathname, use the [File System Access API](https://developer.mozilla.org/en-US/docs/Web/API/File_System_API). To read server-side files, use [fetch], with [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) permission if reading cross-origin.",
     "properties": {
-      "abort": "The **`abort`** method of the [FileReader] interface aborts the read operation. Upon return,\nthe [FileReader.readyState] will be `DONE`.",
-      "abort_event": "The **`abort`** event is fired when a read has been aborted: for instance because the program called [FileReader.abort].\n\nThis event is not cancelable and does not bubble.",
+      "abort": "The **`abort()`** method of the [FileReader] interface aborts the read operation. Upon return,\nthe [FileReader.readyState] will be `DONE`.",
+      "abort_event": "The **`abort`** event of the [FileReader] interface is fired when a read has been aborted: for instance because the program called [FileReader.abort].\n\nThis event is not cancelable and does not bubble.",
       "error": "The **`error`** read-only property of the [FileReader] interface returns the\nerror that occurred while reading the file.",
-      "error_event": "The **`error`** event is fired when the read failed due to an error (for example, because the file was not found or not readable).\n\nThis event is not cancelable and does not bubble.",
-      "filereader": "The **`FileReader()`** constructor creates a new FileReader.\n\nFor details about how to use `FileReader`, see [Using files from web applications](https://developer.mozilla.org/en-US/docs/Web/API/File_API/Using_files_from_web_applications).",
-      "load_event": "The **`load`** event is fired when a file has been read successfully.\n\nThis event is not cancelable and does not bubble.",
-      "loadend_event": "The **`loadend`** event is fired when a file read has completed, successfully or not.\n\nThis event is not cancelable and does not bubble.",
-      "loadstart_event": "The **`loadstart`** event is fired when a file read operation has begun.\n\nThis event is not cancelable and does not bubble.",
-      "progress_event": "The **`progress`** event is fired periodically as the `FileReader` reads data.\n\nThis event is not cancelable and does not bubble.",
-      "readasarraybuffer": "The **`readAsArrayBuffer()`** method of the [FileReader] interface is used to start reading the\ncontents of a specified [Blob] or [File]. When the read\noperation is finished, the [FileReader.readyState] becomes\n`DONE`, and the [FileReader.loadend_event] is\ntriggered. At that time, the [FileReader.result] attribute\ncontains an `ArrayBuffer` representing the file's data.\n\n> **Note:** The [Blob.arrayBuffer] method is a newer promise-based API to read a\n> file as an array buffer.",
-      "readasbinarystring": "> **Note:** This method is deprecated in favor of [FileReader.readAsArrayBuffer].\n\nThe **`readAsBinaryString`** method of the [FileReader] interface is used to start reading the contents of the\nspecified [Blob] or [File]. When the read operation is\nfinished, the [FileReader.readyState] becomes\n`DONE`, and the [FileReader.loadend_event] is triggered. At that time, the\n[FileReader.result] attribute contains the raw binary data from\nthe file.\n\nNote that this method was once removed from the File API specification, but\nre-introduced for backward compatibility.\nUsing [FileReader.readAsArrayBuffer] is recommended.",
-      "readasdataurl": "The **`readAsDataURL`** method of the [FileReader] interface is used to read the contents of the specified\n[Blob] or [File]. When the read operation is finished, the\n[FileReader.readyState] becomes `DONE`, and the\n[FileReader.loadend_event] is triggered. At that time, the\n[FileReader.result] attribute contains the data as a [data: URL](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URLs) representing the\nfile's data as a base64 encoded string.\n\n> **Note:** The blob's [FileReader.result] cannot be\n> directly decoded as Base64 without first removing the Data-URL declaration preceding\n> the Base64-encoded data. To retrieve only the Base64 encoded string, first\n> remove `data:*/*;base64,` from the result.",
-      "readastext": "The **`readAsText()`** method of the [FileReader] interface is used to read the contents of the specified [Blob] or [File].\nWhen the read operation is complete, the [FileReader.readyState] is changed to `DONE`,\nthe [FileReader.loadend_event] event is triggered, and the [FileReader.result] property contains the contents of the file as a text string.\n\n> **Note:** The [Blob.text] method is a newer promise-based API to read a file as text.\n\n> **Note:** This method loads the entire file's content into memory and is not suitable for large files. Prefer [`readAsArrayBuffer()`](https://developer.mozilla.org/en-US/docs/Web/API/FileReader/readAsArrayBuffer) for large files.",
-      "readystate": "The **`readyState`** read-only property of the [FileReader] interface provides the current state of the reading operation a `FileReader` is in. A `FileReader` exists in one of the following states:\n\n| Value | State     | Description                                                   |\n| ----- | --------- | ------------------------------------------------------------- |\n| `0`   | `EMPTY`   | Reader has been created. None of the read methods called yet. |\n| `1`   | `LOADING` | A read method has been called.                                |\n| `2`   | `DONE`    | The operation is complete.                                    |\n\n- `EMPTY`\n  - : The `FileReader` has been created, but no readAs method was called yet.\n- `LOADING`\n  - : A readAs method was invoked. A [File] or [Blob] is being read, and no error has occurred yet.\n- `DONE`\n  - : The read operation is complete. This could mean that: the entire [File] or [Blob] has been read into memory, a file read error occurred, or [FileReader.abort] was called and the read was cancelled.",
+      "error_event": "The **`error`** event of the [FileReader] interface is fired when the read failed due to an error (for example, because the file was not found or not readable).\n\nThis event is not cancelable and does not bubble.",
+      "filereader": "The **`FileReader()`** constructor creates a new `FileReader`.\n\nFor details about how to use `FileReader`, see [Using files from web applications](https://developer.mozilla.org/en-US/docs/Web/API/File_API/Using_files_from_web_applications).",
+      "load_event": "The **`load`** event of the [FileReader] interface is fired when a file has been read successfully.\n\nThis event is not cancelable and does not bubble.",
+      "loadend_event": "The **`loadend`** event of the [FileReader] interface is fired when a file read has completed, successfully or not.\n\nThis event is not cancelable and does not bubble.",
+      "loadstart_event": "The **`loadstart`** event of the [FileReader] interface is fired when a file read operation has begun.\n\nThis event is not cancelable and does not bubble.",
+      "progress_event": "The **`progress`** event of the [FileReader] interface is fired periodically as the `FileReader` reads data.\n\nThis event is not cancelable and does not bubble.",
+      "readasarraybuffer": "The **`readAsArrayBuffer()`** method of the [FileReader] interface is used to start reading the\ncontents of a specified [Blob] or [File]. When the read\noperation is finished, the [FileReader.readyState] property becomes\n`DONE`, and the [FileReader.loadend_event] event is\ntriggered. At that time, the [FileReader.result] property\ncontains an `ArrayBuffer` representing the file's data.\n\n> **Note:** The [Blob.arrayBuffer] method is a newer promise-based API to read a\n> file as an array buffer.",
+      "readasbinarystring": "> **Note:** This method is deprecated in favor of [FileReader.readAsArrayBuffer].\n\nThe **`readAsBinaryString()`** method of the [FileReader] interface is used to start reading the contents of the\nspecified [Blob] or [File]. When the read operation is\nfinished, the [FileReader.readyState] property becomes\n`DONE`, and the [FileReader.loadend_event] event is triggered. At that time, the\n[FileReader.result] property contains the raw binary data from\nthe file.\n\nNote that this method was once removed from the File API specification, but\nre-introduced for backward compatibility.\nUsing [FileReader.readAsArrayBuffer] is recommended.",
+      "readasdataurl": "The **`readAsDataURL()`** method of the [FileReader] interface is used to read the contents of the specified\n[Blob] or [File]. When the read operation is finished, the\n[FileReader.readyState] property becomes `DONE`, and the\n[FileReader.loadend_event] event is triggered. At that time, the\n[FileReader.result] attribute contains the data as a [data: URL](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URLs) representing the\nfile's data as a base64 encoded string.\n\n> **Note:** The blob's [FileReader.result] cannot be\n> directly decoded as Base64 without first removing the Data-URL declaration preceding\n> the Base64-encoded data. To retrieve only the Base64 encoded string, first\n> remove `data:*/*;base64,` from the result.",
+      "readastext": "The **`readAsText()`** method of the [FileReader] interface is used to read the contents of the specified [Blob] or [File].\nWhen the read operation is complete, the [FileReader.readyState] property is changed to `DONE`,\nthe [FileReader.loadend_event] event is triggered, and the [FileReader.result] property contains the contents of the file as a text string.\n\n> **Note:** The [Blob.text] method is a newer promise-based API to read a file as text.\n\n> **Note:** This method loads the entire file's content into memory and is not suitable for large files. Prefer [FileReader.readAsArrayBuffer] for large files.",
+      "readystate": "The **`readyState`** read-only property of the [FileReader] interface provides the current state of the reading operation.\nThis will be one of the states: `EMPTY`, `LOADING`, or `DONE`.",
       "result": "The **`result`** read-only property of the [FileReader] interface returns the\nfile's contents. This property is only valid after the read operation is complete, and\nthe format of the data depends on which of the methods was used to initiate the read\noperation."
     }
   },
   "FileReaderSync": {
-    "docs": "The **`FileReaderSync`** interface allows to read [File] or [Blob] objects synchronously. This interface is [only available](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Functions_and_classes_available_to_workers) in [workers](https://developer.mozilla.org/en-US/docs/Web/API/Worker) as it enables synchronous I/O that could potentially block.",
+    "docs": "@AvailableInWorkers(\"worker_except_service\")\n\nThe **`FileReaderSync`** interface allows to read [File] or [Blob] objects synchronously. This interface is [only available](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Functions_and_classes_available_to_workers) in [workers](https://developer.mozilla.org/en-US/docs/Web/API/Worker) as it enables synchronous I/O that could potentially block.",
     "properties": {
-      "filereadersync": "The **`FileReaderSync()`** constructor creates a new [FileReaderSync].",
-      "readasarraybuffer": "The **`readAsArrayBuffer()`** method of the [FileReaderSync] interface allows to read [File] or [Blob] objects in a synchronous way into an `ArrayBuffer`. This interface is [only available](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Functions_and_classes_available_to_workers) in [workers](https://developer.mozilla.org/en-US/docs/Web/API/Worker) as it enables synchronous I/O that could potentially block.",
-      "readasbinarystring": "> **Note:** This method is deprecated in favor of [FileReaderSync.readAsArrayBuffer].\n\nThe **`readAsBinaryString()`** method of the [FileReaderSync] interface allows to read [File] or [Blob] objects in a synchronous way into a string. This interface is [only available](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Functions_and_classes_available_to_workers) in [workers](https://developer.mozilla.org/en-US/docs/Web/API/Worker) as it enables synchronous I/O that could potentially block.",
-      "readasdataurl": "The **`readAsDataURL()`** method of the [FileReaderSync] interface allows to read [File] or [Blob] objects in a synchronous way into a string representing a data URL. This interface is [only available](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Functions_and_classes_available_to_workers) in [workers](https://developer.mozilla.org/en-US/docs/Web/API/Worker) as it enables synchronous I/O that could potentially block.",
-      "readastext": "The **`readAsText()`** method of the [FileReaderSync] interface allows to read [File] or [Blob] objects in a synchronous way into a string. This interface is [only available](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Functions_and_classes_available_to_workers) in [workers](https://developer.mozilla.org/en-US/docs/Web/API/Worker) as it enables synchronous I/O that could potentially block."
+      "filereadersync": "@AvailableInWorkers(\"worker_except_service\")\n\nThe **`FileReaderSync()`** constructor creates a new [FileReaderSync].",
+      "readasarraybuffer": "@AvailableInWorkers(\"worker_except_service\")\n\nThe **`readAsArrayBuffer()`** method of the [FileReaderSync] interface allows to read [File] or [Blob] objects in a synchronous way into an `ArrayBuffer`. This interface is [only available](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Functions_and_classes_available_to_workers) in [workers](https://developer.mozilla.org/en-US/docs/Web/API/Worker) as it enables synchronous I/O that could potentially block.",
+      "readasbinarystring": "@AvailableInWorkers(\"worker_except_service\")\n\n> **Note:** This method is deprecated in favor of [FileReaderSync.readAsArrayBuffer].\n\nThe **`readAsBinaryString()`** method of the [FileReaderSync] interface allows to read [File] or [Blob] objects in a synchronous way into a string. This interface is [only available](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Functions_and_classes_available_to_workers) in [workers](https://developer.mozilla.org/en-US/docs/Web/API/Worker) as it enables synchronous I/O that could potentially block.",
+      "readasdataurl": "@AvailableInWorkers(\"worker_except_service\")\n\nThe **`readAsDataURL()`** method of the [FileReaderSync] interface allows to read [File] or [Blob] objects in a synchronous way into a string representing a data URL. This interface is [only available](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Functions_and_classes_available_to_workers) in [workers](https://developer.mozilla.org/en-US/docs/Web/API/Worker) as it enables synchronous I/O that could potentially block.",
+      "readastext": "@AvailableInWorkers(\"worker_except_service\")\n\nThe **`readAsText()`** method of the [FileReaderSync] interface allows to read [File] or [Blob] objects in a synchronous way into a string. This interface is [only available](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Functions_and_classes_available_to_workers) in [workers](https://developer.mozilla.org/en-US/docs/Web/API/Worker) as it enables synchronous I/O that could potentially block."
     }
   },
   "FileSystem": {
@@ -2546,7 +2554,7 @@
   "FileSystemFileHandle": {
     "docs": "The **`FileSystemFileHandle`** interface of the [File System API] represents a handle to a file system entry. The interface is accessed through the [window.showOpenFilePicker] method.\n\nNote that read and write operations depend on file-access permissions that do not persist after a page refresh if no other tabs for that origin remain open. The [FileSystemHandle.queryPermission] method of the [FileSystemHandle] interface can be used to verify permission state before accessing a file.",
     "properties": {
-      "createsyncaccesshandle": "The **`createSyncAccessHandle()`** method of the\n[FileSystemFileHandle] interface returns a `Promise` which resolves to a [FileSystemSyncAccessHandle] object\nthat can be used to synchronously read from and write to a file. The synchronous nature of this method brings performance advantages,\nbut it is only usable inside dedicated [Web Workers](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API) for files within the [origin private file system](https://developer.mozilla.org/en-US/docs/Web/API/File_System_API/Origin_private_file_system).\n\nCreating a [FileSystemSyncAccessHandle] takes an exclusive lock on the file associated with the file handle. This prevents the creation of further [FileSystemSyncAccessHandle]s or [FileSystemWritableFileStream]s for the file until the existing access handle is closed.",
+      "createsyncaccesshandle": "@AvailableInWorkers(\"dedicated\")\n\nThe **`createSyncAccessHandle()`** method of the\n[FileSystemFileHandle] interface returns a `Promise` which resolves to a [FileSystemSyncAccessHandle] object\nthat can be used to synchronously read from and write to a file. The synchronous nature of this method brings performance advantages,\nbut it is only usable inside dedicated [Web Workers](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API) for files within the [origin private file system](https://developer.mozilla.org/en-US/docs/Web/API/File_System_API/Origin_private_file_system).\n\nCreating a [FileSystemSyncAccessHandle] takes an exclusive lock on the file associated with the file handle. This prevents the creation of further [FileSystemSyncAccessHandle]s or [FileSystemWritableFileStream]s for the file until the existing access handle is closed.",
       "createwritable": "The **`createWritable()`** method of the [FileSystemFileHandle] interface creates a [FileSystemWritableFileStream] that can be used to write to a file.\nThe method returns a `Promise` which resolves to this created stream.\n\nAny changes made through the stream won't be reflected in the file represented by the file handle until the stream has been closed.\nThis is typically implemented by writing data to a temporary file, and only replacing the file represented by file handle with the temporary file when the writable filestream is closed.",
       "getfile": "The **`getFile()`** method of the\n[FileSystemFileHandle] interface returns a `Promise` which resolves to a\n[File] object representing the state on disk of the entry represented by the handle.\n\nIf the file on disk changes or is removed after this method is called, the returned\n[File] object will likely be no longer readable."
     }
@@ -2566,14 +2574,14 @@
     "docs": "In the [File and Directory Entries API](https://developer.mozilla.org/en-US/docs/Web/API/File_and_Directory_Entries_API/Introduction), a `FileSystemSync` object represents a file system. It has two properties.\n\n> **Warning:** This interface is deprecated and is no more on the standard track.\n> _Do not use it anymore._ Use the [File and Directory Entries API](https://developer.mozilla.org/en-US/docs/Web/API/File_and_Directory_Entries_API) instead."
   },
   "FileSystemSyncAccessHandle": {
-    "docs": "The **`FileSystemSyncAccessHandle`** interface of the [File System API] represents a synchronous handle to a file system entry.\n\nThis class is only accessible inside dedicated [Web Workers](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API) (so that its methods do not block execution on the main thread) for files within the [origin private file system](https://developer.mozilla.org/en-US/docs/Web/API/File_System_API/Origin_private_file_system), which is not visible to end-users.\n\nAs a result, its methods are not subject to the same security checks as methods running on files within the user-visible file system, and so are much more performant. This makes them suitable for significant, large-scale file updates such as [SQLite](https://www.sqlite.org/wasm) database modifications.\n\nThe interface is accessed through the [FileSystemFileHandle.createSyncAccessHandle] method.\n\n> **Note:** In earlier versions of the spec, [FileSystemSyncAccessHandle.close], [FileSystemSyncAccessHandle.flush], [FileSystemSyncAccessHandle.getSize], and [FileSystemSyncAccessHandle.truncate] were wrongly specified as asynchronous methods, and older versions of some browsers implement them in this way. However, all current browsers that support these methods implement them as synchronous methods.",
+    "docs": "@AvailableInWorkers(\"dedicated\")\n\nThe **`FileSystemSyncAccessHandle`** interface of the [File System API] represents a synchronous handle to a file system entry.\n\nThis class is only accessible inside dedicated [Web Workers](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API) (so that its methods do not block execution on the main thread) for files within the [origin private file system](https://developer.mozilla.org/en-US/docs/Web/API/File_System_API/Origin_private_file_system), which is not visible to end-users.\n\nAs a result, its methods are not subject to the same security checks as methods running on files within the user-visible file system, and so are much more performant. This makes them suitable for significant, large-scale file updates such as [SQLite](https://www.sqlite.org/wasm) database modifications.\n\nThe interface is accessed through the [FileSystemFileHandle.createSyncAccessHandle] method.\n\n> **Note:** In earlier versions of the spec, [FileSystemSyncAccessHandle.close], [FileSystemSyncAccessHandle.flush], [FileSystemSyncAccessHandle.getSize], and [FileSystemSyncAccessHandle.truncate] were wrongly specified as asynchronous methods, and older versions of some browsers implement them in this way. However, all current browsers that support these methods implement them as synchronous methods.",
     "properties": {
-      "close": "The **`close()`** method of the\n[FileSystemSyncAccessHandle] interface closes an open synchronous file handle, disabling any further operations on it and releasing the exclusive lock previously put on the file associated with the file handle.\n\n> **Note:** In earlier versions of the spec, `close()`, [FileSystemSyncAccessHandle.flush], [FileSystemSyncAccessHandle.getSize], and [FileSystemSyncAccessHandle.truncate] were wrongly specified as asynchronous methods, and older versions of some browsers implement them in this way. However, all current browsers that support these methods implement them as synchronous methods.",
-      "flush": "The **`flush()`** method of the\n[FileSystemSyncAccessHandle] interface persists any changes made to the file associated with the handle via the [FileSystemSyncAccessHandle.write] method to disk.\n\nBear in mind that you only need to call this method if you need the changes committed to disk at a specific time, otherwise you can leave the underlying operating system to handle this when it sees fit, which should be OK in most cases.\n\n> **Note:** In earlier versions of the spec, [FileSystemSyncAccessHandle.close], `flush()`, [FileSystemSyncAccessHandle.getSize], and [FileSystemSyncAccessHandle.truncate] were wrongly specified as asynchronous methods, and older versions of some browsers implement them in this way. However, all current browsers that support these methods implement them as synchronous methods.",
-      "getsize": "The **`getSize()`** method of the\n[FileSystemSyncAccessHandle] interface returns the size of the file associated with the handle in bytes.\n\n> **Note:** In earlier versions of the spec, [FileSystemSyncAccessHandle.close], [FileSystemSyncAccessHandle.flush], `getSize()`, and [FileSystemSyncAccessHandle.truncate] were wrongly specified as asynchronous methods, and older versions of some browsers implement them in this way. However, all current browsers that support these methods implement them as synchronous methods.",
-      "read": "The **`read()`** method of the\n[FileSystemSyncAccessHandle] interface reads the content of the file associated with the handle into a specified buffer, optionally at a given offset.",
-      "truncate": "The **`truncate()`** method of the\n[FileSystemSyncAccessHandle] interface resizes the file associated with the handle to a specified number of bytes.\n\n> **Note:** In earlier versions of the spec, [FileSystemSyncAccessHandle.close], [FileSystemSyncAccessHandle.flush], [FileSystemSyncAccessHandle.getSize], and `truncate()` were wrongly specified as asynchronous methods, and older versions of some browsers implement them in this way. However, all current browsers that support these methods implement them as synchronous methods.",
-      "write": "The **`write()`** method of the\n[FileSystemSyncAccessHandle] interface writes the content of a specified buffer to the file associated with the handle, optionally at a given offset.\n\nFiles within the [origin private file system](https://developer.mozilla.org/en-US/docs/Web/API/File_System_API/Origin_private_file_system) are not visible to end-users, therefore are not subject to the same security checks as methods running on files within the user-visible file system. As a result, writes performed using `FileSystemSyncAccessHandle.write()` are much more performant. This makes them suitable for significant, large-scale file updates such as [SQLite](https://www.sqlite.org/wasm) database modifications."
+      "close": "@AvailableInWorkers(\"dedicated\")\n\nThe **`close()`** method of the\n[FileSystemSyncAccessHandle] interface closes an open synchronous file handle, disabling any further operations on it and releasing the exclusive lock previously put on the file associated with the file handle.\n\n> **Note:** In earlier versions of the spec, `close()`, [FileSystemSyncAccessHandle.flush], [FileSystemSyncAccessHandle.getSize], and [FileSystemSyncAccessHandle.truncate] were wrongly specified as asynchronous methods, and older versions of some browsers implement them in this way. However, all current browsers that support these methods implement them as synchronous methods.",
+      "flush": "@AvailableInWorkers(\"dedicated\")\n\nThe **`flush()`** method of the\n[FileSystemSyncAccessHandle] interface persists any changes made to the file associated with the handle via the [FileSystemSyncAccessHandle.write] method to disk.\n\nBear in mind that you only need to call this method if you need the changes committed to disk at a specific time, otherwise you can leave the underlying operating system to handle this when it sees fit, which should be OK in most cases.\n\n> **Note:** In earlier versions of the spec, [FileSystemSyncAccessHandle.close], `flush()`, [FileSystemSyncAccessHandle.getSize], and [FileSystemSyncAccessHandle.truncate] were wrongly specified as asynchronous methods, and older versions of some browsers implement them in this way. However, all current browsers that support these methods implement them as synchronous methods.",
+      "getsize": "@AvailableInWorkers(\"dedicated\")\n\nThe **`getSize()`** method of the\n[FileSystemSyncAccessHandle] interface returns the size of the file associated with the handle in bytes.\n\n> **Note:** In earlier versions of the spec, [FileSystemSyncAccessHandle.close], [FileSystemSyncAccessHandle.flush], `getSize()`, and [FileSystemSyncAccessHandle.truncate] were wrongly specified as asynchronous methods, and older versions of some browsers implement them in this way. However, all current browsers that support these methods implement them as synchronous methods.",
+      "read": "@AvailableInWorkers(\"dedicated\")\n\nThe **`read()`** method of the\n[FileSystemSyncAccessHandle] interface reads the content of the file associated with the handle into a specified buffer, optionally at a given offset.",
+      "truncate": "@AvailableInWorkers(\"dedicated\")\n\nThe **`truncate()`** method of the\n[FileSystemSyncAccessHandle] interface resizes the file associated with the handle to a specified number of bytes.\n\n> **Note:** In earlier versions of the spec, [FileSystemSyncAccessHandle.close], [FileSystemSyncAccessHandle.flush], [FileSystemSyncAccessHandle.getSize], and `truncate()` were wrongly specified as asynchronous methods, and older versions of some browsers implement them in this way. However, all current browsers that support these methods implement them as synchronous methods.",
+      "write": "@AvailableInWorkers(\"dedicated\")\n\nThe **`write()`** method of the\n[FileSystemSyncAccessHandle] interface writes the content of a specified buffer to the file associated with the handle, optionally at a given offset.\n\nFiles within the [origin private file system](https://developer.mozilla.org/en-US/docs/Web/API/File_System_API/Origin_private_file_system) are not visible to end-users, therefore are not subject to the same security checks as methods running on files within the user-visible file system. As a result, writes performed using `FileSystemSyncAccessHandle.write()` are much more performant. This makes them suitable for significant, large-scale file updates such as [SQLite](https://www.sqlite.org/wasm) database modifications."
     }
   },
   "FileSystemWritableFileStream": {
@@ -2588,7 +2596,7 @@
     "docs": "The **`FocusEvent`** interface represents focus-related events, including [Element.focus_event], [Element.blur_event], [Element.focusin_event], and [Element.focusout_event].",
     "properties": {
       "focusevent": "The **`FocusEvent()`** constructor returns a newly created\n[FocusEvent] object with an optional [EventTarget]. When the\nevent has both a source and a destination, the `relatedTarget` value must be\nset to the other target.",
-      "relatedtarget": "The **`FocusEvent.relatedTarget`** read-only property is the\nsecondary target, depending on the type of event:\n\n<table class=\"no-markdown\">\n  <thead>\n    <tr>\n      <th scope=\"col\">Event name</th>\n      <th scope=\"col\"><code>target</code></th>\n      <th scope=\"col\"><code>relatedTarget</code></th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <td>[Element.blur_event]</td>\n      <td>The [EventTarget] losing focus</td>\n      <td>\n        The [EventTarget] receiving focus (if any).\n      </td>\n    </tr>\n    <tr>\n      <td>[Element.focus_event]</td>\n      <td>The [EventTarget] receiving focus</td>\n      <td>The [EventTarget] losing focus (if any)</td>\n    </tr>\n    <tr>\n      <td>[Element.focusin_event]</td>\n      <td>The [EventTarget] receiving focus</td>\n      <td>The [EventTarget] losing focus (if any)</td>\n    </tr>\n    <tr>\n      <td>[Element.focusout_event]</td>\n      <td>The [EventTarget] losing focus</td>\n      <td>The [EventTarget] receiving focus (if any)</td>\n    </tr>\n  </tbody>\n</table>\n\nNote that [many elements can't have focus](https://stackoverflow.com/questions/42764494/blur-event-relatedtarget-returns-null/42764495), which is a common reason for `relatedTarget` to be\n`null`. `relatedTarget` may also be set to `null` for\nsecurity reasons, like when tabbing in or out of a page.\n\n[MouseEvent.relatedTarget] is a similar property for mouse events."
+      "relatedtarget": "The **`relatedTarget`** read-only property of the [FocusEvent] interface is the secondary target, depending on the type of event:\n\n<table class=\"no-markdown\">\n  <thead>\n    <tr>\n      <th scope=\"col\">Event name</th>\n      <th scope=\"col\"><code>target</code></th>\n      <th scope=\"col\"><code>relatedTarget</code></th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <td>[Element.blur_event]</td>\n      <td>The [EventTarget] losing focus</td>\n      <td>The [EventTarget] receiving focus (if any).</td>\n    </tr>\n    <tr>\n      <td>[Element.focus_event]</td>\n      <td>The [EventTarget] receiving focus</td>\n      <td>The [EventTarget] losing focus (if any)</td>\n    </tr>\n    <tr>\n      <td>[Element.focusin_event]</td>\n      <td>The [EventTarget] receiving focus</td>\n      <td>The [EventTarget] losing focus (if any)</td>\n    </tr>\n    <tr>\n      <td>[Element.focusout_event]</td>\n      <td>The [EventTarget] losing focus</td>\n      <td>The [EventTarget] receiving focus (if any)</td>\n    </tr>\n  </tbody>\n</table>\n\nNote that [many elements can't have focus](https://stackoverflow.com/questions/42764494/blur-event-relatedtarget-returns-null/42764495), which is a common reason for `relatedTarget` to be `null`. `relatedTarget` may also be set to `null` for security reasons, like when tabbing in or out of a page.\n\n[MouseEvent.relatedTarget] is a similar property for mouse events."
     }
   },
   "FontData": {
@@ -3314,6 +3322,8 @@
       "accesskey": "The **`HTMLElement.accessKey`** property sets the keystroke which a user can press to jump to a given element.\n\n> **Note:** The `HTMLElement.accessKey` property is seldom used because of its multiple conflicts with already present key bindings in browsers. To work around this, browsers implement accesskey behavior if the keys are pressed with other \"qualifying\" keys (such as <kbd>Alt</kbd> + accesskey).",
       "accesskeylabel": "The **`HTMLElement.accessKeyLabel`**\nread-only property returns a string containing the element's\nbrowser-assigned access key (if any); otherwise it returns an empty string.",
       "attachinternals": "The **`HTMLElement.attachInternals()`** method returns an [ElementInternals] object.\nThis method allows a [custom element](https://developer.mozilla.org/en-US/docs/Web/API/Web_components/Using_custom_elements) to participate in HTML forms. The `ElementInternals` interface provides utilities for working with these elements in the same way you would work with any standard HTML form element, and also exposes the [Accessibility Object Model](https://wicg.github.io/aom/explainer.html) to the element.",
+      "attributestylemap": "The **`attributeStyleMap`** read-only property of the [HTMLElement] interface returns a live [StylePropertyMap] object that contains a list of style properties of the element that are defined in the element's inline [`style`](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/style) attribute, or assigned using the [HTMLElement.style] property of the [HTMLElement] interface via script.\n\nShorthand properties are expanded. If you set `border-top: 1px solid black`, the longhand properties (, , and ) are set instead.\n\nThe main difference between [HTMLElement.style] property and `attributeStyleMap` property is that, the `style` property will return a [CSSStyleDeclaration] object, while the `attributeStyleMap` property will return a [StylePropertyMap] object.\n\nThough the property itself is not writable, you could read and write inline styles through the [StylePropertyMap] object that it returns, just like through the [CSSStyleDeclaration] object that returns via the `style` property.",
+      "autocapitalize": "The **`autocapitalize`** property of the [HTMLElement] interface represents the element's capitalization behavior for user input. It is available on all HTML elements, though it doesn't affect all of them, including:\n\n- `input` and `textarea` elements.\n- Any element with [`contenteditable`](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/contenteditable) set on it.\n\n`autocapitalize` doesn't affect behavior when typing on a physical keyboard. It affects the behavior of other input mechanisms such as virtual keyboards on mobile devices and voice input. This can assist users by making data entry quicker and easier, for example by automatically capitalizing the first letter of each sentence.\n\nIt reflects the value of the [`autocapitalize`](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/autocapitalize) HTML global attribute.",
       "autofocus": "The **`autofocus`** property of the [HTMLElement] interface represents a boolean value reflecting the [`autofocus`](/en-US/docs/Web/HTML/Element/select#autofocus) HTML global attribute, which indicates whether the control should be focused when the page loads, or when dialog or popover become shown if specified in an element inside `dialog` elements or elements whose popover attribute is set.\n\nOnly one form-associated element inside a document, or a `dialog` element, or an element whose `popover` attribute is set, can have this attribute specified. If there are several, the first element with the attribute set inserted, usually the first such element on the page, get the initial focus.\n\n> **Note:** Setting this property doesn't set the focus to the associated element: it merely tells the browser to focus to it when _the element is inserted_ in the document. Setting it after the insertion, that is most of the time after the document load, has no visible effect.",
       "beforetoggle_event": "The **`beforetoggle`** event of the [HTMLElement] interface fires on a [Popover_API] element (i.e. one that has a valid [`popover`](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/popover) attribute) just before it is shown or hidden.\n\n- If the popover is transitioning from hidden to showing, the `event.oldState` property will be set to `closed` and the `event.newState` property will be set to `open`.\n- If the popover is transitioning from showing to hidden, then `event.oldState` will be `open` and `event.newState` will be `closed`.",
       "blur": "The **`HTMLElement.blur()`** method removes keyboard focus from the current element.",
@@ -3344,10 +3354,7 @@
       "inputmode": "The [HTMLElement] property **`inputMode`** reflects the value of the element's [`inputmode`](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/inputmode) attribute.\n\nIt provides a hint about the type of data that might be entered by the user while editing the element or its contents. This allows the browser to display an appropriate virtual keyboard.\n\nIt is used primarily on `input` elements, but is usable on any element in [`contenteditable`](/en-US/docs/Web/HTML/Global_attributes#contenteditable) mode.",
       "iscontenteditable": "The **`HTMLElement.isContentEditable`** read-only property\nreturns a boolean value that is `true` if the contents of the element\nare editable; otherwise it returns `false`.",
       "lang": "The **`HTMLElement.lang`** property gets or sets the base\nlanguage of an element's attribute values and text content.\n\nThe language code returned by this property is defined in `5646, \"Tags for Identifying Languages (also known as BCP 47)\"`.\nCommon examples include \"en\" for English, \"ja\" for\nJapanese, \"es\" for Spanish and so on. The default value of this attribute is\n`unknown`. Note that this attribute, though valid at the individual element\nlevel described here, is most often specified for the root element of the document.\n\nThis also only works with the `lang` attribute and not with\n`xml:lang`.",
-      "load_event": "The **`load`** event fires for elements containing a resource when the resource has successfully loaded. Currently, the list of supported HTML elements are: `body`, `embed`, `iframe`, `img`, `link`, `object`, `script`, `style`, and`track`.\n\n> **Note:** The `load` event on  is actually an alias for the [Window.load_event] event. Therefore, the `load` event will only fire on the `<body>` element once all of the document's resources have loaded or errored. However, for the sake of clarity, it is recommended that the event handler is attached to the `window` object directly rather than on `HTMLBodyElement`.\n\nThis event is not cancelable and does not bubble.",
-      "mscandidatewindowhide_event": "The **`mscandidatewindowhide`** event is thrown after the Input Method Editor (IME) candidate window closes and is fully hidden.\n\nThis proprietary method is specific to Internet Explorer.\n\nThe handler of this event will see that the `isCandidateWindowVisible` method returns `false`, and no `ClientRect` object is returned from `getCandidateWindowClientRect()`.\n\nWeb applications need only register for this event once per element (the handler will remain valid for the lifetime of the element).",
-      "mscandidatewindowshow_event": "The **`mscandidatewindowshow`** event is thrown immediately after the  (IME) candidate window is set to appear, but before it renders.\n\nThis proprietary method is specific to Internet Explorer.\n\nThis event fires after the positioning information of the IME candidate window has been determined. You can obtain the positioning information using the [getCandidateWindowClientRect](https://developer.mozilla.org/en-US/docs/Web/API/getCandidateWindowClientRect) method, and adjust your layout as needed to avoid any occlusions with the IME candidate window.\n\nWeb applications need only register for this event once per element (the handler will remain valid for the lifetime of the element).",
-      "mscandidatewindowupdate_event": "The **`mscandidatewindowupdate`** event is thrown after the  (IME) candidate window has been identified as needing to change size, but before any visual updates have rendered.\n\nThis proprietary method is specific to Internet Explorer.\n\nAn IME candidate window may be identified as needing to change size for any of the following reasons:\n\n- As a result of displaying new / changed alternatives or predictions\n\nWeb applications need only register for this event once per element (the handler will remain valid for the lifetime of the element).",
+      "load_event": "The **`load`** event fires for elements containing a resource when the resource has successfully loaded. Currently, the list of supported HTML elements are: `body`, `embed`, `iframe`, `img`, `link`, `object`, `script`, `style`, and `track`.\n\n> **Note:** The `load` event on  is actually an alias for the [Window.load_event] event. Therefore, the `load` event will only fire on the `<body>` element once all of the document's resources have loaded or errored. However, for the sake of clarity, it is recommended that the event handler is attached to the `window` object directly rather than on `HTMLBodyElement`.\n\nThis event is not cancelable and does not bubble.",
       "nonce": "The **`nonce`** property of the [HTMLElement] interface returns the cryptographic number used once that is used by [Content Security Policy](https://developer.mozilla.org/en-US/docs/Web/HTTP/CSP) to determine whether a given fetch will be allowed to proceed.\n\nIn later implementations, elements only expose their `nonce` attribute to scripts (and not to side-channels like CSS attribute selectors).",
       "offsetheight": "The **`HTMLElement.offsetHeight`** read-only property returns\nthe height of an element, including vertical padding and borders, as an integer.\n\nTypically, `offsetHeight` is a measurement in pixels of the element's CSS\nheight, including any borders, padding, and horizontal scrollbars (if rendered). It does\nnot include the height of pseudo-elements such as `::before` or\n`::after`. For the document body object, the measurement includes total\nlinear content height instead of the element's CSS height. Floated elements extending\nbelow other linear content are ignored.\n\nIf the element is hidden (for example, by setting `style.display` on the\nelement or one of its ancestors to `\"none\"`), then `0` is\nreturned.\n\n> **Note:** This property will round the value to an integer. If you need a fractional value, use\n> [element.getBoundingClientRect].",
       "offsetleft": "The **`HTMLElement.offsetLeft`** read-only property returns the number of pixels that the _upper left corner_ of the current element is offset to the left within the [HTMLElement.offsetParent] node.\n\nFor block-level elements, `offsetTop`, `offsetLeft`, `offsetWidth`, and `offsetHeight` describe the border box of an element relative to the `offsetParent`.\n\nHowever, for inline-level elements (such as **span**) that can wrap from one line to the next, `offsetTop` and `offsetLeft` describe the positions of the _first_ border box (use [Element.getClientRects] to get its width and height), while `offsetWidth` and `offsetHeight` describe the dimensions of the _bounding_ border box (use [Element.getBoundingClientRect] to get its position). Therefore, a box with the left, top, width and height of `offsetLeft`, `offsetTop`, `offsetWidth` and `offsetHeight` will not be a bounding box for a span with wrapped text.",
@@ -3372,6 +3379,7 @@
     "docs": "The **`HTMLEmbedElement`** interface provides special properties (beyond the regular [HTMLElement] interface it also has available to it by inheritance) for manipulating `embed` elements.\n\n> **Note:** This topic describes the `HTMLEmbedElement` interface as defined in the standard. It does not address earlier, non-standardized version of the interface.",
     "properties": {
       "height": "The **`height`** property of the [HTMLEmbedElement] interface returns a string that reflects the `height` attribute of the `embed` element, indicating the displayed height of the resource in CSS pixels.",
+      "src": "The **`src`** property of the [HTMLEmbedElement] interface returns a string that indicates the URL of the resource being embedded.\n\nIt reflects the `src` attribute of the `embed` element.",
       "width": "The **`width`** property of the [HTMLEmbedElement] interface returns a string that reflects the `width` attribute of the `embed` element, indicating the displayed width of the resource in CSS pixels."
     }
   },
@@ -3408,7 +3416,7 @@
       "action": "The **`HTMLFormElement.action`** property represents the action\nof the `form` element.\n\nThe action of a form is the program that is executed on the server when the form is\nsubmitted. This property can be retrieved or set.",
       "elements": "The [HTMLFormElement] property\n**`elements`** returns an\n[HTMLFormControlsCollection] listing all the form controls contained in\nthe `form` element.\n\nIndependently, you can obtain just the\nnumber of form controls using the [HTMLFormElement.length]\nproperty.\n\nYou can access a particular form control in the returned collection by using either an\nindex or the element's `name` or `id` attributes.\n\nPrior to HTML 5, the returned object was an [HTMLCollection], on which\n`HTMLFormControlsCollection` is based.\n\n> **Note:** Similarly, you can get a list of all of the forms contained within a given document using the document's [Document.forms] property.",
       "encoding": "The **`HTMLFormElement.encoding`** property is an alternative name for the [HTMLFormElement.enctype] element on the DOM [HTMLFormElement] object.",
-      "enctype": "The **`HTMLFormElement.enctype`** property is the [MIME type](https://en.wikipedia.org/wiki/Mime_type) of content that is used\nto submit the form to the server. Possible values are:\n\n- `application/x-www-form-urlencoded`: The initial default type.\n- `multipart/form-data`: The type that allows file `input`\n  element(s) to upload file data.\n- `text/plain`: Ambiguous format, human-readable content not reliably interpretable by computer.\n\nThis value can be overridden by a [`formenctype`](/en-US/docs/Web/HTML/Element/button#formenctype) attribute\non a `button` or `input` element.",
+      "enctype": "The **`HTMLFormElement.enctype`** property is the  of content that is used\nto submit the form to the server. Possible values are:\n\n- `application/x-www-form-urlencoded`: The initial default type.\n- `multipart/form-data`: The type that allows file `input`\n  element(s) to upload file data.\n- `text/plain`: Ambiguous format, human-readable content not reliably interpretable by computer.\n\nThis value can be overridden by a [`formenctype`](/en-US/docs/Web/HTML/Element/button#formenctype) attribute\non a `button` or `input` element.",
       "formdata_event": "The **`formdata`** event fires after the entry list representing the form's data is constructed. This happens when the form is submitted, but can also be triggered by the invocation of a [FormData.FormData] constructor.\n\nThis event is not cancelable and does not bubble.",
       "length": "The **`HTMLFormElement.length`**\nread-only property returns the number of controls in the `form`\nelement.\n\nYou can access the list of the form's controls using the\n[HTMLFormElement.elements] property.\n\nThis includes both elements that are descendants of the `<form>`\nelement as well as elements that are made members of the form using their\n`form` property.\n\nElements that are considered for this property are: `button`,\n`fieldset`, `input` (with the exception\nthat any whose type is \"image\" are omitted for historical reasons),\n`object`, `output`, `select`,\nand `textarea`.",
       "method": "The **`HTMLFormElement.method`** property represents the\n method used to submit the `form`.\n\nUnless explicitly specified, the default method is 'get'.",
@@ -3443,9 +3451,10 @@
   "HTMLIFrameElement": {
     "docs": "The **`HTMLIFrameElement`** interface provides special properties and methods (beyond those of the [HTMLElement] interface it also has available to it by inheritance) for manipulating the layout and presentation of inline frame elements.",
     "properties": {
+      "allow": "The **`allow`** property of the [HTMLIFrameElement] interface indicates the [Permissions Policy](https://developer.mozilla.org/en-US/docs/Web/HTTP/Permissions_Policy) specified for this `<iframe>` element. The policy defines what features are available to the `<iframe>` element (for example, access to the `microphone`, `camera`, `battery`, `web-share`, etc.) based on the origin of the request.\n\nThe Permissions Policy specified by the `allow` attribute implements a further restriction on top of the policy specified in the  header. It doesn't replace it.\n\nSee [`<iframe>`'s Permissions Policy syntax](/en-US/docs/Web/HTTP/Permissions_Policy#iframe_syntax) for more details.\n\nIt reflects the `allow` attribute of the `iframe` element.",
       "allowfullscreen": "The **`allowFullscreen`** property of the [HTMLIFrameElement] interface is a boolean value that reflects the `allowfullscreen` attribute of the `iframe` element, indicating whether to allow the iframe's contents to use [Element.requestFullscreen].\n\n> **Note:** This property is considered a legacy property. Use `allow=\"fullscreen\"` and [HTMLIFrameElement.allow] instead.",
       "allowpaymentrequest": "The **`allowPaymentRequest`** property of the\n[HTMLIFrameElement] interface returns a boolean value indicating\nwhether the [Payment Request API](https://developer.mozilla.org/en-US/docs/Web/API/Payment_Request_API) may be invoked on a cross-origin iframe.",
-      "browsingtopics": "> **Warning:** This feature is currently opposed by two browser vendors. See the [Standards positions](#standards_positions) section below for details of opposition.\n\nThe **`browsingTopics`** property of the [HTMLIFrameElement] interface is a boolean specifying that that the selected topics for the current user should be sent with the request for the associated `iframe`'s source in a  header. This reflects the `browsingtopics` HTML attribute.\n\nSee [Using the Topics API](https://developer.mozilla.org/en-US/docs/Web/API/Topics_API/Using) for more details.",
+      "browsingtopics": "> **Warning:** This feature is currently opposed by two browser vendors. See the [Standards positions](/en-US/docs/Web/API/Topics_API#standards_positions) section for details of opposition.\n\nThe **`browsingTopics`** property of the [HTMLIFrameElement] interface is a boolean specifying that the selected topics for the current user should be sent with the request for the associated `iframe`'s source in a  header. This reflects the `browsingtopics` HTML attribute.\n\nSee [Using the Topics API](https://developer.mozilla.org/en-US/docs/Web/API/Topics_API/Using) for more details.",
       "contentdocument": "If the iframe and the iframe's parent document are [Same Origin](https://developer.mozilla.org/en-US/docs/Web/Security/Same-origin_policy), returns a [`Document`](https://developer.mozilla.org/en-US/docs/Web/API/Document) (that is, the active document in the inline frame's nested browsing context), else returns `null`.",
       "contentwindow": "The **`contentWindow`** property returns the [Window](https://developer.mozilla.org/en-US/docs/Web/API/Window) object of an [HTMLIFrameElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLIFrameElement).\n\nThis attribute is read-only.",
       "credentialless": "The **`credentialless`** property of the [HTMLIFrameElement] interface indicates whether the `iframe` is credentialless, meaning that documents inside will be loaded using new, ephemeral contexts.\n\nThose contexts do not have access to their network, cookies and storage data associated with their origin. Instead, they use new ones, local to the top-level document lifetime. It means any data stored won't be accessible anymore after the user navigates away from the page or reloads it.\n\nIn return, the  (COEP) embedding rules can be lifted, so documents with COEP set can embed third-party documents that do not. See [IFrame credentialless](https://developer.mozilla.org/en-US/docs/Web/Security/IFrame_credentialless) for a deeper explanation.",
@@ -3455,6 +3464,7 @@
       "loading": "The **`loading`** property of the [HTMLIFrameElement] interface is a string that provides a hint to the  indicating whether the [iframe](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe) should be loaded immediately on page load, or only when it is needed.\n\nThis can be used to optimize the loading of the document's contents.\nIframes that are visible when the page loads can be downloaded immediately (eagerly), while iframes that are likely to be offscreen on initial page load can be downloaded lazily — just before they will appear in the window's .",
       "name": "The **`name`** property of the [HTMLIFrameElement] interface is a string value that reflects the `name` attribute of the `iframe` element, indicating the specific name of the `<iframe>` element.",
       "referrerpolicy": "The\n**`HTMLIFrameElement.referrerPolicy`**\nproperty reflects the HTML [`referrerpolicy`](/en-US/docs/Web/HTML/Element/iframe#referrerpolicy) attribute of the\n`iframe` element defining which referrer is sent when fetching the\nresource.",
+      "sandbox": "The **`sandbox`** read-only property of the [HTMLIFrameElement] interface returns a [DOMTokenList] indicating extra restrictions on the behavior of the nested content.\n\nIt reflects the `sandbox` attribute of the `iframe` element.",
       "src": "The **`HTMLIFrameElement.src`**\nA string that reflects the [`src`](/en-US/docs/Web/HTML/Element/iframe#src) HTML attribute, containing the address of the content to be embedded.\n\nNote that programmatically removing an `<iframe>`'s src attribute (e.g. via [Element.removeAttribute]) causes `about:blank` to be loaded in the frame.",
       "srcdoc": "The **`srcdoc`** property of the [HTMLIFrameElement] specifies the content of the page.",
       "width": "The **`width`** property of the [HTMLIFrameElement] interface returns a string that reflects the `width` attribute of the `iframe` element, indicating the width of the frame in CSS pixels."
@@ -3517,7 +3527,7 @@
       "showpicker": "The **`HTMLInputElement.showPicker()`** method displays the browser picker for an `input` element.\n\nThis is the same picker that would normally be displayed when the element is selected, but can be triggered from a button press or other user interaction.\n\nCommonly browsers implement it for inputs of these types: `\"date\"`, `\"month\"`, `\"week\"`, `\"time\"`, `\"datetime-local\"`, `\"color\"`, or `\"file\"`.\nIt can also be prepopulated with items from a `datalist` element or [`autocomplete`](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/autocomplete) attribute.\n\nMore generally, this method should ideally display the picker for any input element on the platform that has a picker.",
       "stepdown": "The\n**`HTMLInputElement.stepDown([n])`** method decrements the\nvalue of a numeric type of `input` element by the value of the\n[`step`](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/step) attribute or up\nto `n` multiples of the step attribute if a number is passed as the\nparameter.\n\nThe method, when invoked, decrements the\n[`value`](/en-US/docs/Web/HTML/Element/input#value) by ([`step`](/en-US/docs/Web/HTML/Element/input#step) \\* n), where n\ndefaults to 1 if not specified, and\n[`step`](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/step) defaults to the\ndefault value for `step` if not specified.\n\nValid on all numeric, date, and time input types that support the step attribute,\nincluding `date`, `month`,\n`week`, `time`,\n,\n`number`, and `range`.\n\nGiven `<input id=\"myTime\" type=\"time\" max=\"17:00\" step=\"900\" value=\"17:00\">`,\ninvoking `myTime.stepDown(3)` will change the value to 16:15, decrementing the\ntime by `3 * 900`, or 45 minutes. `myTime.stepDown()`, with no\nparameter, would have resulted in `16:45`, as `n` defaults to\n`1`.\n\n```html\n<!-- decrements by intervals of 900 seconds (15 minute) -->\n<input type=\"time\" max=\"17:00\" step=\"900\" />\n\n<!-- decrements by intervals of 7 days (one week) -->\n<input type=\"date\" max=\"2019-12-25\" step=\"7\" />\n\n<!-- decrements by intervals of 12 months (one year) -->\n<input type=\"month\" max=\"2019-12\" step=\"12\" />\n```\n\nHowever, calling `stepDown` on `<input type=\"time\" max=\"17:00\" step=\"900\">` would not set the value to `17:00`, as one would expect — and as it does for `stepUp` when the input is `<input type=\"time\" min=\"17:00\" step=\"900\">`. Instead, the first call to `stepDown` will set the initial value to `23:45` even though the `max` attribute is set. The second call will set the value to `17:00`. And the third call to will set the value to `16:45`.\n\n```js\nlet input1 = document.createElement(\"input\");\ninput1.setAttribute(\"type\", \"time\");\ninput1.setAttribute(\"min\", \"17:00\");\ninput1.setAttribute(\"step\", 900);\nconsole.log(input1.value); // \"\"\ninput1.stepUp();\nconsole.log(input1.value); // \"17:00\"\n// However\nlet input2 = document.createElement(\"input\");\ninput2.setAttribute(\"type\", \"time\");\ninput2.setAttribute(\"max\", \"17:00\");\ninput2.setAttribute(\"step\", 900);\nconsole.log(input2.value); // \"\"\ninput2.stepDown();\nconsole.log(input2.value); // \"23:45\"\ninput2.stepDown();\nconsole.log(input2.value); // \"17:00\"\ninput2.stepDown();\nconsole.log(input2.value); // \"16:45\"\n```\n\nThe method, when invoked, changes the form control's value by the value given in the\n`step` attribute, multiplied by the parameter, within the constraints set\nwithin the form control. The default value for the parameter, if not is passed, is 1.\nThe method will not cause the value to go below the\n[`min`](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/min) value set or defy the\nconstraints set by the\n[`step`](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/step) attribute. A\nnegative value for `n` will increment the value, but will not increment\nbeyond the [`max`](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/max) value.\n\nIf the value before invoking the `stepDown()` method is invalid, for\nexample, if it doesn't match the constraints set by the `step` attribute,\ninvoking the `stepDown()` method will return a value that does match the form\ncontrols constraints.\n\nIf the form control is non time, date, or numeric in nature, and therefore does not\nsupport the `step` attribute (see the list of supported input types above), or if the `step` value is set to `any`, an\n`InvalidStateError` exception is thrown.\n\n- [HTMLInputElement.stepDown]\n\n  - : Decrements the [`value`](/en-US/docs/Web/HTML/Element/input#value) by\n    ([`step`](/en-US/docs/Web/HTML/Element/input#step) \\* n), where n defaults to 1 if not specified. Throws\n    an `InvalidStateError` exception:\n\n    - if the method is not applicable to for the current\n      [`type`](/en-US/docs/Web/HTML/Element/input#type) value,\n    - if the element has no [`step`](/en-US/docs/Web/HTML/Element/input#step) value,\n    - if the [`value`](/en-US/docs/Web/HTML/Element/input#value) cannot be converted to a number,\n    - if the resulting value is above the [`max`](/en-US/docs/Web/HTML/Element/input#max) or below the\n      [`min`](/en-US/docs/Web/HTML/Element/input#min).",
       "stepup": "The **`HTMLInputElement.stepUp()`** method increments the value\nof a numeric type of `input` element by the value of the\n[`step`](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/step) attribute, or the\ndefault `step` value if the step attribute is not explicitly set. The method,\nwhen invoked, increments the [`value`](/en-US/docs/Web/HTML/Element/input#value) by\n([`step`](/en-US/docs/Web/HTML/Element/input#step) \\* n), where `n` defaults to\n`1` if not specified, and\n[`step`](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/step) defaults to the\ndefault value for `step` if not specified.\n\n<table class=\"no-markdown\">\n  <thead>\n    <tr>\n      <th>Input type</th>\n      <th>Default step value</th>\n      <th>Example step declaration</th>\n    </tr>\n    <tr>\n      <td>`date`</td>\n      <td><code>1</code> (day)</td>\n      <td>\n        7 day (one week) increments:<br />\n        <code>&#x3C;input type=\"date\" min=\"2019-12-25\" step=\"7\"></code>\n      </td>\n    </tr>\n    <tr>\n      <td>`month`</td>\n      <td><code>1</code> (month)</td>\n      <td>\n        12 month (one year) increments:<br />\n        <code>&#x3C;input type=\"month\" min=\"2019-12\" step=\"12\"></code>\n      </td>\n    </tr>\n    <tr>\n      <td>`week`</td>\n      <td><code>1</code> (week)</td>\n      <td>\n        Two week increments:<br />\n        <code>&#x3C;input type=\"week\" min=\"2019-W23\" step=\"2\"></code>\n      </td>\n    </tr>\n    <tr>\n      <td>`time`</td>\n      <td><code>60</code> (seconds)</td>\n      <td>\n        900 second (15 minute) increments:<br />\n        <code>&#x3C;input type=\"time\" min=\"09:00\" step=\"900\"></code>\n      </td>\n    </tr>\n    <tr>\n      <td>\n        \n      </td>\n      <td><code>1</code> (day)</td>\n      <td>\n        Same day of the week:<br />\n        <code>&#x3C;input type=\"datetime-local\" min=\"019-12-25T19:30\"\n          step=\"7\"></code>\n      </td>\n    </tr>\n    <tr>\n      <td>`number`</td>\n      <td><code>1</code></td>\n      <td>\n        0.1 increments<br />\n        <code>&#x3C;input type=\"number\" min=\"0\" step=\"0.1\" max=\"10\"></code>\n      </td>\n    </tr>\n    <tr>\n      <td>`range`</td>\n      <td><code>1</code></td>\n      <td>\n        Increments by 2:<br />\n        <code>&#x3C;input type=\"range\" min=\"0\" step=\"2\" max=\"10\"></code>\n      </td>\n    </tr>\n  </thead>\n</table>\n\nThe method, when invoked, changes the form control's value by the value given in the\n`step` attribute, multiplied by the parameter, within the constraints set on\nthe form control. The default value for the parameter, if no value is passed, is\n`1`. The method will not cause the value to exceed the\nset [`max`](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/max) value, or defy\nthe constraints set by the\n[`step`](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/step) attribute.\n\nIf the value before invoking the `stepUp()` method is invalid—for example,\nif it doesn't match the constraints set by the step attribute—invoking the\n`stepUp()` method will return a value that does match the form controls\nconstraints.\n\nIf the form control is non time, date, or numeric in nature, and therefore does not\nsupport the `step` attribute (see the list of supported input types in the\ntable above), or if the step value is set to `any`, an\n`InvalidStateError` exception is thrown.",
-      "type": "The **`type`** property of the [HTMLInputElement] interface indicates the kind of data allowed in the `input` element, or example a number, a date, or an email. Browsers will select the appropriate widget and behavior to help users to enter a valid value.\n\nIt reflects the [`type`](/en-US/docs/Web/HTML/Element/input#type) attribute of the `input` element.",
+      "type": "The **`type`** property of the [HTMLInputElement] interface indicates the kind of data allowed in the `input` element, for example a number, a date, or an email. Browsers will select the appropriate widget and behavior to help users to enter a valid value.\n\nIt reflects the [`type`](/en-US/docs/Web/HTML/Element/input#type) attribute of the `input` element.",
       "webkitdirectory": "The **`HTMLInputElement.webkitdirectory`** is a property\nthat reflects the [`webkitdirectory`](/en-US/docs/Web/HTML/Element/input/file#webkitdirectory) HTML attribute\nand indicates that the `input` element should let the user select directories instead of files.\nWhen a directory is selected, the directory and its entire hierarchy of contents are included in the set of selected items.\nThe selected file system entries can be obtained using the [HTMLInputElement.webkitEntries] property.\n\n> **Note:** This property is called `webkitEntries` in the specification due to its\n> origins as a Google Chrome-specific API. It's likely to be renamed someday.",
       "webkitentries": "The read-only **`webkitEntries`**\nproperty of the [HTMLInputElement] interface contains an array of file\nsystem entries (as objects based on [FileSystemEntry]) representing files\nand/or directories selected by the user using an `input` element of\ntype `file`, but only if that selection was made using drag-and-drop:\nselecting a file in the dialog will leave the property empty.\n\nThe array can only contain directories if the\n[HTMLInputElement.webkitdirectory] property is\n`true`. This means the `<input>` element was configured to\nlet the user choose directories.\n\n> **Note:** This property is called `webkitEntries` in the specification due to its\n> origins as a Google Chrome-specific API. It's likely to be renamed someday."
     }
@@ -3540,13 +3550,17 @@
     "docs": "The **`HTMLLinkElement`** interface represents reference information for external resources and the relationship of those resources to a document and vice versa (corresponds to [`<link>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link) element; not to be confused with [`<a>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a), which is represented by [`HTMLAnchorElement`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLAnchorElement)). This object inherits all of the properties and methods of the [HTMLElement] interface.",
     "properties": {
       "as": "The **`as`** property of the [HTMLLinkElement] interface returns a string representing the type of content to be preloaded by a link element.\n\nThe `as` property must have a value for link elements when [`rel=\"preload\"`](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/rel/preload), or the resource will not be fetched.\nIt may also be applied to link elements where [`rel=\"modulepreload\"`](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/rel/preload), but if omitted, will default to `script`.\nThe property should not be set for other types of link elements, such as `rel=\"prefetch\"`.\n\nThis property reflects the value of the [`as` attribute](/en-US/docs/Web/HTML/Element/link#as) of the [`<link>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link) HTML element.",
+      "blocking": "The **`blocking`** property of the [HTMLLinkElement] interface is a string indicating that certain operations should be blocked on the fetching of an external resource.\n\nIt reflects the `blocking` attribute of the `link` element.",
       "crossorigin": "The **`crossOrigin`** property of the [HTMLLinkElement] interface specifies the Cross-Origin Resource Sharing () setting to use when retrieving the resource.",
-      "fetchpriority": "The **`fetchPriority`** property of the\n[HTMLLinkElement] interface represents a hint given to the browser\non how it should prioritize the preload of the given resource relative to other\nresources of the same type.",
-      "hreflang": "The **`hreflang`** property of the [HTMLLinkElement] is used to indicate the language and the geographical targeting of a page. This hint can be used by browsers to select the more appropriate page or to improve .\n\nIt reflects the `hreflang` attribute of the `link` element and is the empty string (`\"\"`) if there is no `hreflang` attribute.",
-      "referrerpolicy": "The\n**`HTMLLinkElement.referrerPolicy`**\nproperty reflects the HTML [`referrerpolicy`](/en-US/docs/Web/HTML/Element/link#referrerpolicy) attribute of the\n`link` element defining which referrer is sent when fetching the\nresource.\n\nSee the HTTP  header for details.",
-      "rel": "The **`HTMLLinkElement.rel`** property reflects the [`rel`](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/rel) attribute. It is a string containing a space-separated list of link types indicating the relationship between the resource represented by the `link` element and the current document.\n\nThe most common use of this attribute is to specify a link to an external style sheet:\nthe property is set to `stylesheet`, and the [`href`](/en-US/docs/Web/HTML/Element/link#href)\nattribute is set to the URL of an external style sheet to format the page.",
-      "rellist": "The **`HTMLLinkElement.relList`** read-only property reflects the [`rel`](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/rel) attribute. It is a live [DOMTokenList] containing the set of link types indicating the relationship between the resource represented by the `link` element and the current document.\n\nThe property itself is read-only, meaning you can not substitute the\n[DOMTokenList] by another one, but the content of the returned list can be\nchanged.",
-      "sheet": "The read-only **`sheet`** property of the [HTMLLinkElement] interface\ncontains the stylesheet associated with that element.\n\nA stylesheet is associated to an `HTMLLinkElement` if `rel=\"stylesheet\"` is used with `<link>`."
+      "disabled": "The **`disabled`** property of the [HTMLLinkElement] interface is a boolean value that represents whether the link is disabled. It only has an effect with style sheet links (`rel` property set to `stylesheet`).\n\nIf `disabled` attribute is specified in the HTML when it is loaded, the stylesheet will not be loaded during page load. Instead, the stylesheet will be loaded only when the `disabled` property is set to `false` or removed. Setting the `disabled` property using JavaScript causes the stylesheet to be removed from the document's [Document.styleSheets] list.\n\nIt reflects the `disabled` attribute of the `link` element.",
+      "fetchpriority": "The **`fetchPriority`** property of the\n[HTMLLinkElement] interface represents a hint given to the browser\non how it should prioritize the preload of the given resource relative to other\nresources of the same\n[type](/en-US/docs/Web/HTML/Attributes/rel/preload#what_types_of_content_can_be_preloaded).",
+      "hreflang": "The **`hreflang`** property of the [HTMLLinkElement] interface is used to indicate the language and the geographical targeting of a page. This hint can be used by browsers to select the more appropriate page or to improve .\n\nIt reflects the `hreflang` attribute of the `link` element and is the empty string (`\"\"`) if there is no `hreflang` attribute.",
+      "integrity": "The **`integrity`** property of the [HTMLLinkElement] interface is a string containing inline metadata that a browser can use to verify that a fetched resource has been delivered without unexpected manipulation.\n\nIt reflects the `integrity` attribute of the `link` element.",
+      "referrerpolicy": "The **`referrerPolicy`** property of the [HTMLLinkElement] interface\nreflects the HTML [`referrerpolicy`](/en-US/docs/Web/HTML/Element/link#referrerpolicy) attribute of the\n`link` element defining which referrer is sent when fetching the\nresource.\n\nSee the HTTP  header for details.",
+      "rel": "The **`rel`** property of the [HTMLLinkElement] interface reflects the [`rel`](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/rel) attribute. It is a string containing a space-separated list of link types indicating the relationship between the resource represented by the `link` element and the current document.\n\nThe most common use of this attribute is to specify a link to an external style sheet:\nthe property is set to `stylesheet`, and the [`href`](/en-US/docs/Web/HTML/Element/link#href)\nattribute is set to the URL of an external style sheet to format the page.",
+      "rellist": "The **`relList`** read-only property of the [HTMLLinkElement] interface reflects the [`rel`](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/rel) attribute. It is a live [DOMTokenList] containing the set of link types indicating the relationship between the resource represented by the `link` element and the current document.\n\nThe property itself is read-only, meaning you can not substitute the\n[DOMTokenList] by another one, but the content of the returned list can be\nchanged.",
+      "sheet": "The **`sheet`** read-only property of the [HTMLLinkElement] interface\ncontains the stylesheet associated with that element.\n\nA stylesheet is associated to an `HTMLLinkElement` if `rel=\"stylesheet\"` is used with `<link>`.",
+      "type": "The **`type`** property of the [HTMLLinkElement] interface is a string that reflects the  of the linked resource.\n\nIt reflects the `type` attribute of the `link` element."
     }
   },
   "HTMLMapElement": {
@@ -3601,8 +3615,9 @@
       "paused": "The read-only **`HTMLMediaElement.paused`** property\ntells whether the media element is paused.",
       "play": "The [HTMLMediaElement]\n**`play()`** method attempts to begin playback of the media.\nIt returns a `Promise` which is resolved when playback has been\nsuccessfully started.\n\nFailure to begin playback for any reason, such as\npermission issues, result in the promise being rejected.",
       "play_event": "The `play` event is fired when the `paused` property is changed from `true` to `false`, as a result of the `play` method, or the `autoplay` attribute.\n\nThis event is not cancelable and does not bubble.",
-      "playbackrate": "The **`HTMLMediaElement.playbackRate`** property sets the rate at which the media is being played back. This is used to implement user controls for fast forward, slow motion, and so forth. The normal playback rate is multiplied by this value to obtain the current rate, so a value of 1.0 indicates normal speed.\n\nIf `playbackRate` is negative, the media is played backwards.\n\nThe audio is muted when the fast forward or slow motion is outside a useful range (for example, Gecko mutes the sound outside the range `0.25` to `4.0`).\n\nThe pitch of the audio is corrected by default. You can disable pitch correction using the [HTMLMediaElement.preservesPitch] property.",
+      "playbackrate": "The **`HTMLMediaElement.playbackRate`** property sets the rate at which the media is being played back. This is used to implement user controls for fast forward, slow motion, and so forth. The normal playback rate is multiplied by this value to obtain the current rate, so a value of 1.0 indicates normal speed.\n\nA negative `playbackRate` value indicates that the media should be played backwards, but support for this is not yet widespread.[1](#see-also)\n\nThe audio is muted when the fast forward or slow motion is outside a useful range (for example, Gecko mutes the sound outside the range `0.25` to `4.0`).\n\nThe pitch of the audio is corrected by default. You can disable pitch correction using the [HTMLMediaElement.preservesPitch] property.",
       "playing_event": "The `playing` event is fired after playback is first started, and whenever it is restarted. For example it is fired when playback resumes after having been paused or delayed due to lack of data.\n\nThis event is not cancelable and does not bubble.",
+      "preload": "The **`preload`** property of the [HTMLMediaElement] interface is a string that provides a hint to the browser about what the author thinks will lead to the best user experience.\n\nIt reflects the `preload` attribute of the `audio` element and the `video` element.",
       "preservespitch": "The **`HTMLMediaElement.preservesPitch`** property determines whether or not the browser should adjust the pitch of the audio to compensate for changes to the playback rate made by setting [HTMLMediaElement.playbackRate].",
       "progress_event": "The **`progress`** event is fired periodically as the browser loads a resource.\n\nThis event is not cancelable and does not bubble.",
       "ratechange_event": "The `ratechange` event is fired when the playback rate has changed.\n\nThis event is not cancelable and does not bubble.",
@@ -3724,9 +3739,18 @@
   "HTMLScriptElement": {
     "docs": "HTML `script` elements expose the **`HTMLScriptElement`** interface, which provides special properties and methods for manipulating the behavior and execution of `<script>` elements (beyond the inherited [HTMLElement] interface).\n\nJavaScript files should be served with the `text/javascript` [MIME type](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types), but browsers are lenient and block them only if the script is served with an image type (`image/*`), video type (`video/*`), audio type (`audio/*`), or `text/csv`. If the script is blocked, its element receives an [HTMLElement.error_event] event; otherwise, it receives a [Window.load_event] event.",
     "properties": {
+      "async": "The **`async`** property of the [HTMLScriptElement] interface is a boolean value that controls how the script should be executed. For classic scripts, if the `async` property is set to `true`, the external script will be fetched in parallel to parsing and evaluated as soon as it is available. For [module scripts](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Modules), if the `async` property is set to `true`, the script and all their dependencies will be fetched in parallel to parsing and evaluated as soon as they are available.\n\nIt reflects the `async` attribute of the `script` element.",
+      "blocking": "The **`blocking`** property of the [HTMLScriptElement] interface is a string indicating that certain operations should be blocked on the fetching of the script.\n\nIt reflects the `blocking` attribute of the `script` element.",
       "crossorigin": "The **`crossOrigin`** property of the [HTMLScriptElement] interface reflects the  settings for the script element. For classic scripts from other [origins](https://developer.mozilla.org/en-US/docs/Glossary/Origin), this controls if full error information will be exposed. For module scripts, it controls the script itself and any script it imports. See [CORS settings attributes](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/crossorigin) for details.",
+      "defer": "The **`defer`** property of the [HTMLScriptElement] interface is a boolean value that controls how the script should be executed. For classic scripts, if the `defer` property is set to `true`, the external script will be executed after the document has been parsed, but before firing [Document.DOMContentLoaded_event] event. For [module scripts](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Modules), the `defer` property has no effect.\n\nIt reflects the `defer` attribute of the `script` element.",
+      "fetchpriority": "The **`fetchPriority`** property of the [HTMLScriptElement] interface represents a hint given to the browser on how it should prioritize fetching of an external script relative to other external scripts.\n\nIt reflects the `fetchpriority` attribute of the `script` element.",
+      "integrity": "The **`integrity`** property of the [HTMLScriptElement] interface is a string that contains inline metadata that a browser can use to verify that a fetched resource has been delivered without unexpected manipulation.\n\nIt reflects the `integrity` attribute of the `script` element.",
+      "nomodule": "The **`noModule`** property of the [HTMLScriptElement] interface is a boolean value that indicates whether the script should be executed in browsers that support [ES modules](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Modules). Practically, this can be used to serve fallback scripts to older browsers that do not support JavaScript modules.\n\nIt reflects the `nomodule` attribute of the `script` element.",
       "referrerpolicy": "The **`referrerPolicy`** property of the\n[HTMLScriptElement] interface reflects the HTML\n[`referrerpolicy`](/en-US/docs/Web/HTML/Element/script#referrerpolicy) of the `script` element, which defines how the referrer is set when fetching the script and any scripts it imports.",
-      "supports_static": "The **`supports()`** static method of the [HTMLScriptElement] interface provides a simple and consistent method to feature-detect what types of scripts are supported by the user agent.\n\nThe method is expected to return `true` for classic and module scripts, which are supported by most modern browsers."
+      "src": "The **`src`** property of the [HTMLScriptElement] interface is a string representing the URL of an external script; this can be used as an alternative to embedding a script directly within a document.\n\nIt reflects the `src` attribute of the `script` element.",
+      "supports_static": "The **`supports()`** static method of the [HTMLScriptElement] interface provides a simple and consistent method to feature-detect what types of scripts are supported by the user agent.\n\nThe method is expected to return `true` for classic and module scripts, which are supported by most modern browsers.",
+      "text": "The **`text`** property of the [HTMLScriptElement] interface is a string that reflects the text content inside the `script` element. It acts the same way as the [Node.textContent] property.\n\nIt reflects the `text` attribute of the `script` element.",
+      "type": "The **`type`** property of the [HTMLScriptElement] interface is a string that reflects the type of the script.\n\nIt reflects the `type` attribute of the `script` element."
     }
   },
   "HTMLSelectElement": {
@@ -3771,6 +3795,7 @@
   "HTMLStyleElement": {
     "docs": "The **`HTMLStyleElement`** interface represents a `style` element. It inherits properties and methods from its parent, [HTMLElement].\n\nThis interface doesn't allow to manipulate the CSS it contains (in most case). To manipulate CSS, see [Using dynamic styling information](https://developer.mozilla.org/en-US/docs/Web/API/CSS_Object_Model/Using_dynamic_styling_information) for an overview of the objects used to manipulate specified CSS properties using the DOM.",
     "properties": {
+      "blocking": "The **`blocking`** property of the [HTMLStyleElement] interface is a string indicating that certain operations should be blocked on the fetching of critical subresources.\n\nIt reflects the `blocking` attribute of the `style` element.",
       "disabled": "The **`HTMLStyleElement.disabled`** property can be used to get and set whether the stylesheet is disabled (`true`) or not (`false`).\n\nNote that there is no corresponding `disabled` attribute on the [HTML `<style>` element](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/style).",
       "media": "The **`HTMLStyleElement.media`** property specifies the\nintended destination medium for style information.",
       "sheet": "The read-only **`sheet`** property of the [HTMLStyleElement] interface\ncontains the stylesheet associated with that element.\n\nAn [StyleSheet] is always associated with a [HTMLStyleElement], unless its `type` attribute is not `text/css`.",
@@ -3781,10 +3806,29 @@
     "docs": "The **`HTMLTableCaptionElement`** interface provides special properties (beyond the regular [HTMLElement] interface it also has available to it by inheritance) for manipulating table `caption` elements."
   },
   "HTMLTableCellElement": {
-    "docs": "The **`HTMLTableCellElement`** interface provides special properties and methods (beyond the regular [HTMLElement] interface it also has available to it by inheritance) for manipulating the layout and presentation of table cells, either header cells (`th`)) or data cells (`td`), in an HTML document."
+    "docs": "The **`HTMLTableCellElement`** interface provides special properties and methods (beyond the regular [HTMLElement] interface it also has available to it by inheritance) for manipulating the layout and presentation of table cells, either header cells (`th`) or data cells (`td`), in an HTML document.",
+    "properties": {
+      "abbr": "The **`abbr`** property of the [HTMLTableCellElement] interface\nindicates an abbreviation associated with the cell. If the cell does not represent a header cell `th`, it is ignored.\n\nIt reflects the `abbr` attribute of the `tr` element.\n\n> **Note:** this property doesn't have a visual effect in browsers. It adds information to help assistive technology like screenreaders that can use this abbreviation",
+      "align": "The **`align`** property of the [HTMLTableCellElement] interface is a string indicating how to horizontally align text in the `th` or `td` table cell.\n\n> **Note:** This property is deprecated, and CSS should be used to align text horizontally in a cell. Use the CSS  property, which takes precedence, to horizontally align text in a cell instead.",
+      "bgcolor": "The **`HTMLTableCellElement.bgColor`** property is used to set the background color of a cell or get the value of the obsolete [`bgColor`](/en-US/docs/Web/HTML/Element/td#bgcolor) attribute, if present.\n\n**Note:** This property is deprecated and CSS should be used to set the background color. Use the  property instead.",
+      "cellindex": "The **`cellIndex`** read-only property of the [HTMLTableCellElement] interface\nrepresents the position of a cell within its row (`tr`). The first cell has an index of `0`.",
+      "ch": "The **`ch`** property of the [HTMLTableCellElement] interface does nothing. It reflects the `char` attribute of the cell element.\n\n> **Note:** This property was designed to participate to the ability to align table cell content on a specific character (typically the decimal point), but was never implemented by browsers.\n>\n> To achieve such alignment, watch for the support of a string value with the  CSS property.",
+      "choff": "The **`chOff`** property of the [HTMLTableCellElement] interface does nothing. It reflects the `charoff` attribute of the cell element.\n\n> **Note:** This property was designed to participate in an ability to align table cell content on a specific character (typically the decimal point), but was never implemented by browsers.\n>\n> To achieve such alignment, watch for the support of a string value with the  CSS property.",
+      "colspan": "The **`colSpan`** read-only property of the [HTMLTableCellElement] interface represents the number of columns this cell must span; this lets the cell occupy space across multiple columns of the table. It reflects the [`colspan`](/en-US/docs/Web/HTML/Element/td#colspan) attribute.",
+      "headers": "The **`headers`** property of the [HTMLTableCellElement] interface\ncontains a list of IDs of `th` elements that are _headers_ for this specific cell.",
+      "nowrap": "The **`noWrap`** property of the [HTMLTableCellElement] interface returns a Boolean value indicating if the text of the cell may be wrapped on several lines or not.\n\n> **Note:** This property is deprecated and you should use the CSS  property with the value `nowrap` instead.",
+      "rowspan": "The **`rowSpan`** read-only property of the [HTMLTableCellElement] interface represents the number of rows this cell must span; this lets the cell occupy space across multiple rows of the table. It reflects the [`rowspan`](/en-US/docs/Web/HTML/Element/td#colspan) attribute.",
+      "scope": "The **`scope`** property of the [HTMLTableCellElement] interface\nindicates the scope of a `th` cell.\n\nHeader cells can be configured, using the `scope` attribute, to apply to a specified row or column, or to the not-yet-scoped cells within the current row group (that is, the same ancestor `thead`, `tbody`, or `tfoot` element). If no value is specified for `scope`, the header is not associated directly with cells in this way. Permitted values for `scope` are:\n\n> **Note:** this property doesn't have a visual effect in browsers. It adds semantic information to help assistive technology like screenreaders to present the table in a more coherent way.",
+      "valign": "The **`vAlign`** property of the [HTMLTableCellElement] interface is a string indicating how to vertically align text in a `th` or `td` table cell.\n\n> **Note:** This property is deprecated. Use the CSS  property to horizontally align text in a cell instead."
+    }
   },
   "HTMLTableColElement": {
-    "docs": "The **`HTMLTableColElement`** interface provides properties for manipulating single or grouped table column elements."
+    "docs": "The **`HTMLTableColElement`** interface provides properties for manipulating single or grouped table column elements.",
+    "properties": {
+      "ch": "The **`ch`** property of the [HTMLTableColElement] interface does nothing. It reflects the `char` attribute of the `col` element.\n\n> **Note:** This property was designed to participate to the ability to align table cell content on a specific character (typically the decimal point), but was never implemented by browsers.\n>\n> To achieve such alignment, watch for the support of a string value with the  CSS property.",
+      "choff": "The **`chOff`** property of the [HTMLTableColElement] interface does nothing. It reflects the `charoff` attribute of the `col` element.\n\n> **Note:** This property was designed to participate in an ability to align table cell content on a specific character (typically the decimal point), but was never implemented by browsers.\n>\n> To achieve such alignment, watch for the support of a string value with the  CSS property.",
+      "span": "The **`span`** read-only property of the [HTMLTableColElement] interface represents the number of columns this `col` or `colgroup` must span; this lets the column occupy space across multiple columns of the table. It reflects the [`span`](/en-US/docs/Web/HTML/Element/col#colspan) attribute."
+    }
   },
   "HTMLTableElement": {
     "docs": "The **`HTMLTableElement`** interface provides special properties and methods (beyond the regular [HTMLElement] object interface it also has available to it by inheritance) for manipulating the layout and presentation of tables in an HTML document.",
@@ -3804,7 +3848,7 @@
       "deletetfoot": "The **`HTMLTableElement.deleteTFoot()`** method removes the\n`tfoot` element from a given `table`.",
       "deletethead": "The **`HTMLTableElement.deleteTHead()`** removes the\n`thead` element from a given `table`.",
       "frame": "The [HTMLTableElement] interface's **`frame`**\nproperty is a string that indicates which of the table's exterior borders should be\ndrawn.",
-      "insertrow": "The **`HTMLTableElement.insertRow()`** method inserts a new row\n(`tr`) in a given `table`, and returns a reference to\nthe new row.\n\nIf a table has multiple `tbody` elements, by default, the new row is\ninserted into the last `<tbody>`. To insert the row into a specific\n`<tbody>`:\n\n```js\nlet specific_tbody = document.getElementById(tbody_id);\nlet row = specific_tbody.insertRow(index);\n```\n\n> **Note:** `insertRow()` inserts the row directly into the\n> table. The row does not need to be appended separately as would be the case if\n> [Document.createElement] had been used to create the new\n> `<tr>` element.",
+      "insertrow": "The **`insertRow()`** method of the [HTMLTableElement] interface inserts a new row\n(`tr`) in a given `table`, and returns a reference to\nthe new row.\n\nIf a table has multiple `tbody` elements, by default, the new row is\ninserted into the last `<tbody>`.\nTo insert the row into a specific section, use [HTMLTableSectionElement.insertRow]\n\n> **Note:** `insertRow()` inserts the row directly into the\n> table. The row does not need to be appended separately as would be the case if\n> [Document.createElement] had been used to create the new\n> `<tr>` element.",
       "rows": "The read-only [HTMLTableElement]\nproperty **`rows`** returns a live\n[HTMLCollection] of all the rows in the table, including the rows\ncontained within any `thead`, `tfoot`, and\n`tbody` elements.\n\nAlthough the property itself is read-only, the returned object is live and allows the\nmodification of its content.",
       "rules": "The **`HTMLTableElement.rules`** property indicates which cell\nborders to render in the table.",
       "summary": "The **`HTMLTableElement.summary`** property represents the\ntable description.",
@@ -3817,17 +3861,34 @@
   "HTMLTableRowElement": {
     "docs": "The **`HTMLTableRowElement`** interface provides special properties and methods (beyond the [HTMLElement] interface it also has available to it by inheritance) for manipulating the layout and presentation of rows in an HTML table.",
     "properties": {
-      "insertcell": "The **`HTMLTableRowElement.insertCell()`** method inserts a new\ncell (`td`) into a table row (`tr`) and returns a\nreference to the cell.\n\n> **Note:** `insertCell()` inserts the cell directly into the\n> row. The cell does not need to be appended separately\n> with [Node.appendChild] as would be the case if\n> [Document.createElement] had been used to create the new\n> `<td>` element.\n>\n> You can not use `insertCell()` to create a new `<th>`\n> element though.",
-      "rowindex": "The **`HTMLTableRowElement.rowIndex`** read-only property\nrepresents the position of a row in relation to the whole `table`.\n\nEven when the `thead`, `tbody`, and\n`tfoot` elements are out of order in the HTML, browsers render the\ntable in the right order. Therefore the rows count from `<thead>` to\n`<tbody>`, from `<tbody>` to\n`<tfoot>`."
+      "bgcolor": "The **`HTMLTableRowElement.bgColor`** property is used to set the background color of a row or retrieve the value of the obsolete [`bgColor`](/en-US/docs/Web/HTML/Element/tr#bgcolor) attribute, if present.\n\n**Note:** This property is deprecated and CSS should be used to set the background color. Use the  property instead.",
+      "cells": "The **`cells`** read-only property of the [HTMLTableRowElement] interface\nreturns a live [HTMLCollection] containing the cells in the row. The `HTMLCollection` is live and is automatically updated when cells are added or removed.",
+      "ch": "The **`ch`** property of the [HTMLTableRowElement] interface does nothing. It reflects the `char` attribute of the `tr` element.\n\n> **Note:** This property was designed to participate to the ability to align table cell content on a specific character (typically the decimal point), but was never implemented by browsers.\n>\n> To achieve such alignment, watch for the support of a string value with the  CSS property.",
+      "choff": "The **`chOff`** property of the [HTMLTableRowElement] interface does nothing. It reflects the `charoff` attribute of the `tr` element.\n\n> **Note:** This property was designed to participate in an ability to align table cell content on a specific character (typically the decimal point), but was never implemented by browsers.\n>\n> To achieve such alignment, watch for the support of a string value with the  CSS property.",
+      "deletecell": "The **`deleteCell()`** method of the [HTMLTableRowElement] interface removes a\nspecific row cell from a given `tr`.",
+      "insertcell": "The **`insertCell()`** method of the [HTMLTableRowElement] interface inserts a new\ncell (`td`) into a table row (`tr`) and returns a\nreference to the cell.\n\n> **Note:** `insertCell()` inserts the cell directly into the\n> row. The cell does not need to be appended separately\n> with [Node.appendChild] as would be the case if\n> [Document.createElement] had been used to create the new\n> `<td>` element.\n>\n> You can not use `insertCell()` to create a new `<th>`\n> element though.",
+      "rowindex": "The **`rowIndex`** read-only property of the [HTMLTableRowElement] interface\nrepresents the position of a row within the whole `table`.\n\nEven when the `thead`, `tbody`, and\n`tfoot` elements are out of order in the HTML, browsers render the\ntable in the right order. Therefore the rows count from `<thead>` to\n`<tbody>`, from `<tbody>` to\n`<tfoot>`.",
+      "sectionrowindex": "The **`sectionRowIndex`** read-only property of the [HTMLTableRowElement] interface\nrepresents the position of a row within the current section (`thead`, `tbody`, or `tfoot`)."
     }
   },
   "HTMLTableSectionElement": {
-    "docs": "The **`HTMLTableSectionElement`** interface provides special properties and methods (beyond the [HTMLElement] interface it also has available to it by inheritance) for manipulating the layout and presentation of sections, that is headers, footers and bodies (`thead`, `tfoot`, and `tbody`, respectively) in an HTML table."
+    "docs": "The **`HTMLTableSectionElement`** interface provides special properties and methods (beyond the [HTMLElement] interface it also has available to it by inheritance) for manipulating the layout and presentation of sections, that is headers, footers and bodies (`thead`, `tfoot`, and `tbody`, respectively) in an HTML table.",
+    "properties": {
+      "ch": "The **`ch`** property of the [HTMLTableSectionElement] interface does nothing. It reflects the `char` attribute of the section element.\n\n> **Note:** This property was designed to participate to the ability to align table cell content on a specific character (typically the decimal point), but was never implemented by browsers.\n>\n> To achieve such alignment, watch for the support of a string value with the  CSS property.",
+      "choff": "The **`chOff`** property of the [HTMLTableSectionElement] interface does nothing. It reflects the `charoff` attribute of the section element.\n\n> **Note:** This property was designed to participate in an ability to align table cell content on a specific character (typically the decimal point), but was never implemented by browsers.\n>\n> To achieve such alignment, watch for the support of a string value with the  CSS property.",
+      "deleterow": "The **`deleteRow()`** method of the [HTMLTableSectionElement] interface removes a\nspecific row (`tr`) from a given `section`.",
+      "insertrow": "The **`insertRow()`** method of the [HTMLTableSectionElement] interface inserts a new row\n(`tr`) in the given `section`, and returns a reference to\nthis new row.\n\n> **Note:** `insertRow()` inserts the row directly into the\n> section. The row does not need to be appended separately as would be the case if\n> [Document.createElement] had been used to create the new\n> `<tr>` element.",
+      "rows": "The **`rows`** read-only property of the [HTMLTableSectionElement] interface returns a live [HTMLCollection] containing the rows in the section. The `HTMLCollection` is live and is automatically updated when rows are added or removed."
+    }
   },
   "HTMLTemplateElement": {
-    "docs": "The **`HTMLTemplateElement`** interface enables access to the contents of an HTML `template` element.",
+    "docs": "The **`HTMLTemplateElement`** interface enables access to the contents of an HTML `template` element.\n\n> **Note:** An HTML parser can create either an `HTMLTemplateElement` or a [ShadowRoot] when it parses a `template` element, depending on the `<template>` attributes.\n> If an `HTMLTemplateElement` is created the \"shadow\" attributes are reflected from the template.\n> However these are not useful, because an `HTMLTemplateElement` is not a shadow root and cannot subsequently be changed to a shadow root.",
     "properties": {
-      "content": "The **`HTMLTemplateElement.content`** property returns a\n`<template>` element's template contents (a\n[DocumentFragment])."
+      "content": "The **`HTMLTemplateElement.content`** property returns a\n`<template>` element's template contents (a\n[DocumentFragment]).",
+      "shadowrootclonable": "The **`shadowRootClonable`** property reflects the value of the [`shadowrootclonable`](/en-US/docs/Web/HTML/Element/template#shadowrootclonable) attribute of the associated [`<template>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/template) element.\n\nNote that this property is not useful for developers.\nIf a `<template>` element is used to declaratively create a [`ShadowRoot`](https://developer.mozilla.org/en-US/docs/Web/API/ShadowRoot), then this object and property do not exist.\nOtherwise, if an `HTMLTemplateElement` is created, the value of this property is irrelevant because the object is not a shadow root and cannot subsequently be changed to a shadow root.",
+      "shadowrootdelegatesfocus": "The **`shadowRootDelegatesFocus`** property of the [HTMLTemplateElement] interface reflects the value of the [`shadowrootdelegatesfocus`](/en-US/docs/Web/HTML/Element/template#shadowrootdelegatesfocus) attribute of the associated [`<template>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/template) element.\n\nNote that this property is not useful for developers.\nIf a `<template>` element is used to declaratively create a [`ShadowRoot`](https://developer.mozilla.org/en-US/docs/Web/API/ShadowRoot), then this object and property do not exist.\nOtherwise, if an `HTMLTemplateElement` is created, the value of this property is irrelevant because the object is not a shadow root and cannot subsequently be changed to a shadow root.",
+      "shadowrootmode": "The **`shadowRootMode`** property of the [HTMLTemplateElement] interface reflects the value of the [`shadowrootmode`](/en-US/docs/Web/HTML/Element/template#shadowrootmode) attribute of the associated [`<template>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/template) element.\n\nNote that this property is not useful for developers.\nIf a `<template>` element is used to declaratively create a [`ShadowRoot`](https://developer.mozilla.org/en-US/docs/Web/API/ShadowRoot), then this object and property do not exist.\nOtherwise, if an `HTMLTemplateElement` is created, the value of this property is irrelevant because the object is not a shadow root and cannot subsequently be changed to a shadow root.",
+      "shadowrootserializable": "The **`shadowRootSerializable`** property reflects the value of the [`shadowrootserializable`](/en-US/docs/Web/HTML/Element/template#shadowrootserializable) attribute of the associated [`<template>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/template) element.\n\nNote that this property is not useful for developers.\nIf a `<template>` element is used to declaratively create a [`ShadowRoot`](https://developer.mozilla.org/en-US/docs/Web/API/ShadowRoot), then this object and property do not exist.\nOtherwise, if an `HTMLTemplateElement` is created, the value of this property is irrelevant because the object is not a shadow root and cannot subsequently be changed to a shadow root."
     }
   },
   "HTMLTextAreaElement": {
@@ -3876,6 +3937,7 @@
       "poster": "The **`poster`** property of the [HTMLVideoElement] interface is a string that reflects the URL for an image to be shown while no video data is available. If the property does not represent a valid URL, no poster frame will be shown.\n\nIt reflects the `poster` attribute of the `video` element.",
       "requestpictureinpicture": "The **[HTMLVideoElement]** method\n**`requestPictureInPicture()`** issues an asynchronous request\nto display the video in picture-in-picture mode.\n\nIt's not guaranteed that the video will be put into picture-in-picture. If permission\nto enter that mode is granted, the returned `Promise` will resolve and the\nvideo will receive a [HTMLVideoElement.enterpictureinpicture_event] event to let it know that it's now in picture-in-picture.",
       "requestvideoframecallback": "The **`requestVideoFrameCallback()`** method of the [HTMLVideoElement] interface registers a callback function that runs when a new video frame is sent to the compositor. This enables developers to perform efficient operations on each video frame.",
+      "resize_event": "The **`resize`** event of the [HTMLVideoElement] interface fires when one or both of the [HTMLVideoElement.videoWidth] and [HTMLVideoElement.videoHeight] properties have just been updated.\n\nThis event is not cancelable but may bubble.",
       "videoheight": "The [HTMLVideoElement] interface's read-only **`videoHeight`** property indicates the [intrinsic height](#about_intrinsic_width_and_height) of the video, expressed in CSS pixels.\nIn simple terms, this is the height of the media in its natural size.",
       "videowidth": "The [HTMLVideoElement] interface's read-only **`videoWidth`** property indicates the [intrinsic width](/en-US/docs/Web/API/HTMLVideoElement/videoHeight#about_intrinsic_width_and_height) of the video, expressed in CSS pixels.\nIn simple terms, this is the width of the media in its natural size.\n\nSee [`HTMLVideoElement.videoHeight` > About intrinsic width and height](/en-US/docs/Web/API/HTMLVideoElement/videoHeight#about_intrinsic_width_and_height) for more details.",
       "width": "The **`width`** property of the [HTMLVideoElement] interface returns an integer that reflects the `width` attribute of the `video` element, specifying the displayed width of the resource in CSS pixels."
@@ -3989,7 +4051,7 @@
       "deleteobjectstore": "The **`deleteObjectStore()`** method of the\n[IDBDatabase] interface destroys the object store with the given name in\nthe connected database, along with any indexes that reference it.\n\nAs with [IDBDatabase.createObjectStore], this method can be called\n_only_ within a [`versionchange`](/en-US/docs/Web/API/IDBTransaction#version_change)\ntransaction.",
       "name": "The **`name`** read-only property of the\n`IDBDatabase` interface is a string that contains the\nname of the connected database.",
       "objectstorenames": "The **`objectStoreNames`** read-only property of the\n[IDBDatabase] interface is a [DOMStringList] containing a\nlist of the names of the [object stores](/en-US/docs/Web/API/IndexedDB_API/Basic_Terminology#object_store) currently in the connected database.",
-      "transaction": "The **`transaction`** method of the [IDBDatabase] interface immediately\nreturns a transaction object ([IDBTransaction]) containing the\n[IDBTransaction.objectStore] method, which you can use to access your\nobject store.",
+      "transaction": "The **`transaction`** method of the [IDBDatabase] interface immediately returns a transaction object ([IDBTransaction]) containing the [IDBTransaction.objectStore] method, which you can use to access your object store.",
       "version": "The **`version`** property of the [IDBDatabase]\ninterface is a [64-bit integer](/en-US/docs/NSPR_API_Reference/Long_Long_%2864-bit%29_Integers)\nthat contains the version of the connected database.\nWhen a database is first created, this attribute is an empty string.",
       "versionchange_event": "The `versionchange` event is fired when a database structure change ([`upgradeneeded`](https://developer.mozilla.org/en-US/docs/Web/API/IDBOpenDBRequest/upgradeneeded_event) event send on an [`IDBOpenDBRequest`](https://developer.mozilla.org/en-US/docs/Web/API/IDBOpenDBRequest) or [`IDBFactory.deleteDatabase`](https://developer.mozilla.org/en-US/docs/Web/API/IDBFactory/deleteDatabase)) was requested elsewhere (most probably in\nanother window/tab on the same computer)."
     }
@@ -3998,7 +4060,7 @@
     "docs": "The **`IDBFactory`** interface of the [IndexedDB API](https://developer.mozilla.org/en-US/docs/Web/API/IndexedDB_API) lets applications asynchronously access the indexed databases. The object that implements the interface is `window.indexedDB`. You open — that is, create and access — and delete a database with this object, and not directly with `IDBFactory`.",
     "properties": {
       "cmp": "The **`cmp()`** method of the [IDBFactory]\ninterface compares two values as keys to determine equality and ordering for IndexedDB\noperations, such as storing and iterating.\n\n> **Note:** Do not use this method for comparing arbitrary JavaScript\n> values, because many JavaScript values are either not valid IndexedDB keys (booleans\n> and objects, for example) or are treated as equivalent IndexedDB keys (for example,\n> since IndexedDB ignores arrays with non-numeric properties and treats them as empty\n> arrays, so any non-numeric arrays are treated as equivalent). This throws an exception\n> if either of the values is not a valid key.",
-      "databases": "The **`databases`** method of the [IDBFactory] interface returns a list representing all the available databases, including their names and versions.\n\n> **Note:** This method is introduced in a draft of a specifications and browser compatibility is limited.",
+      "databases": "The **`databases`** method of the [IDBFactory] interface returns a `Promise` that fulfills with an array of objects containing the name and version of all the available databases.\n\nThis is is a snapshot of the databases, intended primarily to allow web applications to check what databases have been created — in order to, for example, clean up databases created by earlier versions of application code.",
       "deletedatabase": "The **`deleteDatabase()`** method of the\n[IDBFactory] interface requests the deletion of a database. The method\nreturns an [IDBOpenDBRequest] object immediately, and performs the deletion\noperation asynchronously.\n\nIf the database is successfully deleted, then a `success` event is fired on\nthe request object returned from this method, with its `result` set to\n`undefined`. If an error occurs while the database is being deleted, then an\n`error` event is fired on the request object that is returned from this\nmethod.\n\nWhen `deleteDatabase()` is called, any other open connections to this\nparticular database will get a [versionchange](https://developer.mozilla.org/en-US/docs/Web/API/IDBDatabase/versionchange_event) event.",
       "open": "The **`open()`** method of the [IDBFactory] interface requests opening a [connection to a database](/en-US/docs/Web/API/IndexedDB_API/Basic_Terminology#database_connection).\n\nThe method returns an [IDBOpenDBRequest] object immediately, and performs the open operation asynchronously.\nIf the operation is successful, a `success` event is fired on the request object that is returned from this method, with its `result` attribute set to the new [IDBDatabase] object for the connection.\n\nMay trigger `upgradeneeded`, `blocked` or `versionchange` events."
     }
@@ -4087,7 +4149,7 @@
       "commit": "The **`commit()`** method of the [IDBTransaction] interface commits the transaction if it is called on an active transaction.\n\nNote that `commit()` doesn't normally _have_ to be called — a transaction will automatically commit when all outstanding requests have been satisfied and no new requests have been made. `commit()` can be used to start the commit process without waiting for events from outstanding requests to be dispatched.\n\nIf it is called on a transaction that is not active, it throws an `InvalidStateError` [DOMException].",
       "complete_event": "The **`complete`** event of the [IndexedDB API](https://developer.mozilla.org/en-US/docs/Web/API/IndexedDB_API) is fired when the transaction successfully completed.",
       "db": "The **`db`** read-only property of the [IDBTransaction] interface returns the database connection\nwith which this transaction is associated.",
-      "durability": "The **`durability`** read-only property of the\n[IDBTransaction] interface returns the durability hint the transaction was\ncreated with. This is a hint to the user agent of whether to prioritize performance or\ndurability when committing the transaction.\n\nThe value of this property is defined in the `options` parameter when creating a transaction using [IDBDatabase.transaction].",
+      "durability": "The **`durability`** read-only property of the [IDBTransaction] interface returns the durability hint the transaction was created with.\nThis is a hint to the user agent of whether to prioritize performance or durability when committing the transaction.\n\nThe value of this property is defined in the [`options.durability`](/en-US/docs/Web/API/IDBDatabase/transaction#options) parameter when creating a transaction using [IDBDatabase.transaction].",
       "error": "The **`IDBTransaction.error`** property of the [IDBTransaction] interface\nreturns the type of error when there is an unsuccessful transaction.",
       "error_event": "The `error` event is fired on `IDBTransaction` when a request returns an error and the event bubbles up to the transaction object.\n\n> **Note:** To handle all the ways a transaction can fail, consider listening for the [IDBTransaction.abort_event] event instead.",
       "mode": "The **`mode`** read-only property of the\n[IDBTransaction] interface returns the current mode for accessing the\ndata in the object stores in the scope of the transaction (i.e. is the mode to be\nread-only, or do you want to write to the object stores?) The default value is\n`readonly`.",
@@ -4121,7 +4183,7 @@
     "docs": "The **`IdentityProvider`** interface of the [Federated Credential Management (FedCM) API](https://developer.mozilla.org/en-US/docs/Web/API/FedCM_API) represents an identity provider (IdP) and provides access to related information and functionality.",
     "properties": {
       "close_static": "The **`close()`** static method of the [IdentityProvider] interface provides a manual signal to the browser that an IdP sign-in flow is finished.",
-      "getuserinfo_static": "The **`getUserInfo()`** static method of the [IdentityProvider] interface returns information about a user that has signed in, which can be used to provide a personalized welcome message and sign-in button. This method has to be called from within an identity provider (IdP)-origin `iframe` so that RP scripts cannot access the data. This must occur after a user has been signed in to a relying party (RP) site.\n\nThis pattern is already common on sites that use identity federation for sign-in, but `getUserInfo()` provides a way to achieve it without relying on third-party cookies."
+      "getuserinfo_static": "The **`getUserInfo()`** static method of the [IdentityProvider] interface returns information about a user that has signed in, which can be used to provide a personalized welcome message and sign-in button. This method has to be called from within an identity provider (IdP)-origin `iframe` so that RP scripts cannot access the data. This must occur after a user has been signed in to a relying party (RP) site.\n\nThis pattern is already common on sites that use identity federation for sign-in, but `getUserInfo()` provides a way to achieve it without relying on [third-party cookies](https://developer.mozilla.org/en-US/docs/Web/Privacy/Third-party_cookies)."
     }
   },
   "IdleDeadline": {
@@ -4178,35 +4240,35 @@
     }
   },
   "ImageDecoder": {
-    "docs": "The **`ImageDecoder`** interface of the [WebCodecs API] provides a way to unpack and decode encoded image data.",
+    "docs": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`ImageDecoder`** interface of the [WebCodecs API] provides a way to unpack and decode encoded image data.",
     "properties": {
-      "close": "The **`close()`** method of the [ImageDecoder] interface ends all pending work and releases system resources.",
-      "complete": "The **`complete`** read-only property of the [ImageDecoder] interface returns true if encoded data has completed buffering.",
-      "completed": "The **`completed`** read-only property of the [ImageDecoder] interface returns a promise that resolves once encoded data has finished buffering.",
-      "decode": "The **`decode()`** method of the [ImageDecoder] interface enqueues a control message to decode the frame of an image.",
-      "imagedecoder": "The **`ImageDecoder()`** constructor creates a new [ImageDecoder] object which unpacks and decodes image data.",
-      "istypesupported_static": "The **`ImageDecoder.isTypeSupported()`** static method checks if a given [MIME type](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types) can be decoded by the user agent.",
-      "reset": "The **`reset()`** method of the [ImageDecoder] interface aborts all pending `decode()` operations; rejecting all pending promises. All other state will be unchanged. Class methods can continue to be invoked after `reset()`. E.g., calling `decode()` after `reset()` is permitted.",
-      "tracks": "The **`tracks`** read-only property of the [ImageDecoder] interface returns a list of the tracks in the encoded image data.",
-      "type": "The **`type`** read-only property of the [ImageDecoder] interface reflects the [MIME type](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types) configured during construction."
+      "close": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`close()`** method of the [ImageDecoder] interface ends all pending work and releases system resources.",
+      "complete": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`complete`** read-only property of the [ImageDecoder] interface returns true if encoded data has completed buffering.",
+      "completed": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`completed`** read-only property of the [ImageDecoder] interface returns a promise that resolves once encoded data has finished buffering.",
+      "decode": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`decode()`** method of the [ImageDecoder] interface enqueues a control message to decode the frame of an image.",
+      "imagedecoder": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`ImageDecoder()`** constructor creates a new [ImageDecoder] object which unpacks and decodes image data.",
+      "istypesupported_static": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`ImageDecoder.isTypeSupported()`** static method checks if a given [MIME type](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types) can be decoded by the user agent.",
+      "reset": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`reset()`** method of the [ImageDecoder] interface aborts all pending `decode()` operations; rejecting all pending promises. All other state will be unchanged. Class methods can continue to be invoked after `reset()`. E.g., calling `decode()` after `reset()` is permitted.",
+      "tracks": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`tracks`** read-only property of the [ImageDecoder] interface returns a list of the tracks in the encoded image data.",
+      "type": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`type`** read-only property of the [ImageDecoder] interface reflects the [MIME type](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types) configured during construction."
     }
   },
   "ImageTrack": {
-    "docs": "The **`ImageTrack`** interface of the [WebCodecs API] represents an individual image track.",
+    "docs": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`ImageTrack`** interface of the [WebCodecs API] represents an individual image track.",
     "properties": {
-      "animated": "The **`animated`** property of the [ImageTrack] interface returns `true` if the track is animated and therefore has multiple frames.",
-      "framecount": "The **`frameCount`** property of the [ImageTrack] interface returns the number of frames in the track.",
-      "repetitioncount": "The **`repetitionCount`** property of the [ImageTrack] interface returns the number of repetitions of this track.",
-      "selected": "The **`selected`** property of the [ImageTrack] interface returns `true` if the track is selected for decoding."
+      "animated": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`animated`** property of the [ImageTrack] interface returns `true` if the track is animated and therefore has multiple frames.",
+      "framecount": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`frameCount`** property of the [ImageTrack] interface returns the number of frames in the track.",
+      "repetitioncount": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`repetitionCount`** property of the [ImageTrack] interface returns the number of repetitions of this track.",
+      "selected": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`selected`** property of the [ImageTrack] interface returns `true` if the track is selected for decoding."
     }
   },
   "ImageTrackList": {
-    "docs": "The **`ImageTrackList`** interface of the [WebCodecs API] represents a list of image tracks.",
+    "docs": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`ImageTrackList`** interface of the [WebCodecs API] represents a list of image tracks.",
     "properties": {
-      "length": "The **`length`** property of the [ImageTrackList] interface returns the length of the `ImageTrackList`.",
-      "ready": "The **`ready`** property of the [ImageTrackList] interface returns a `Promise` that resolves when the `ImageTrackList` is populated with [ImageTrack].",
-      "selectedindex": "The **`selectedIndex`** property of the [ImageTrackList] interface returns the `index` of the selected track.",
-      "selectedtrack": "The **`selectedTrack`** property of the [ImageTrackList] interface returns an [ImageTrack] object representing the currently selected track."
+      "length": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`length`** property of the [ImageTrackList] interface returns the length of the `ImageTrackList`.",
+      "ready": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`ready`** property of the [ImageTrackList] interface returns a `Promise` that resolves when the `ImageTrackList` is populated with [ImageTrack].",
+      "selectedindex": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`selectedIndex`** property of the [ImageTrackList] interface returns the `index` of the selected track.",
+      "selectedtrack": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`selectedTrack`** property of the [ImageTrackList] interface returns an [ImageTrack] object representing the currently selected track."
     }
   },
   "Ink": {
@@ -4241,7 +4303,7 @@
     "properties": {
       "data": "The **`data`** read-only property of the\n[InputEvent] interface returns a string with inserted\ncharacters. This may be an empty string if the change doesn't insert text, such as when\ncharacters are deleted.",
       "datatransfer": "The **`dataTransfer`** read-only property of the\n[InputEvent] interface returns a [DataTransfer] object\ncontaining information about richtext or plaintext data being added to or removed from\neditable content.",
-      "gettargetranges": "The **`getTargetRanges()`** method of the [InputEvent] interface returns an array of static ranges that will be affected by a change to the DOM if the input event is not canceled.\n\nThis allows web apps to override text edit behavior before the browser modifies the DOM tree, and provides more control over input events to improve performance.\n\nDepending on the value of `inputType` and the current editing host, the expected return value of this method varies:\n\n<table>\n  <thead>\n    <tr>\n      <th>inputType</th>\n      <th>Editing host</th>\n      <th>Response of <code>getTargetRanges()</code></th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <td><code>\"historyUndo\"</code> or <code>\"historyRedo\"</code></td>\n      <td>Any</td>\n      <td>empty Array</td>\n    </tr>\n    <tr>\n      <td>All remaining</td>\n      <td><code>contenteditable</code></td>\n      <td>\n        an Array of\n        [StaticRange]\n        objects associated with event\n      </td>\n    </tr>\n    <tr>\n      <td>All remaining</td>\n      <td>\n        <a href=\"/en-US/docs/Web/HTML/Element/input\"><code>input</code></a>\n        or <a href=\"/en-US/docs/Web/HTML/Element/textarea\"><code>textarea</code></a>\n      </td>\n      <td>\n        an empty Array\n      </td>\n    </tr>\n  </tbody>\n</table>",
+      "gettargetranges": "The **`getTargetRanges()`** method of the [InputEvent] interface returns an array of [StaticRange] objects that will be affected by a change to the DOM if the input event is not canceled.\n\nThis allows web apps to override text edit behavior before the browser modifies the DOM tree, and provides more control over input events to improve performance.\n\nDepending on the value of `inputType` and the current editing host, the expected return value of this method varies:\n\n<table>\n  <thead>\n    <tr>\n      <th>inputType</th>\n      <th>Editing host</th>\n      <th>Response of <code>getTargetRanges()</code></th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <td><code>\"historyUndo\"</code> or <code>\"historyRedo\"</code></td>\n      <td>Any</td>\n      <td>empty Array</td>\n    </tr>\n    <tr>\n      <td>All remaining</td>\n      <td><code>contenteditable</code></td>\n      <td>\n        an Array of\n        [StaticRange]\n        objects associated with event\n      </td>\n    </tr>\n    <tr>\n      <td>All remaining</td>\n      <td>\n        <a href=\"/en-US/docs/Web/HTML/Element/input\"><code>input</code></a>\n        or <a href=\"/en-US/docs/Web/HTML/Element/textarea\"><code>textarea</code></a>\n      </td>\n      <td>\n        an empty Array\n      </td>\n    </tr>\n  </tbody>\n</table>",
       "inputevent": "The **`InputEvent()`** constructor creates a new [InputEvent] object.",
       "inputtype": "The **`inputType`** read-only property of the\n[InputEvent] interface returns the type of change made to editable content.\nPossible changes include for example inserting, deleting, and formatting text.",
       "iscomposing": "The **`InputEvent.isComposing`** read-only property returns a\nboolean value indicating if the event is fired after\n[Element.compositionstart_event] and before [Element.compositionend_event]."
@@ -4371,7 +4433,7 @@
     "docs": "The `LayoutShift` interface of the [Performance API](https://developer.mozilla.org/en-US/docs/Web/API/Performance_API) provides insights into the layout stability of web pages based on movements of the elements on the page.",
     "properties": {
       "hadrecentinput": "The **`hadRecentInput`** read-only property of the [LayoutShift] interface returns `true` if [LayoutShift.lastInputTime] is less than 500 milliseconds in the past.\n\nLayout shifts are only a problem if the user is not expecting them, so layout shifts that are the result of user interactions (such as a user expanding a UI element) are often not considered in layout shift metrics. The `hadRecentInput` property allows you to exclude these shifts.",
-      "lastinputtime": "The **`lastInputTime`** read-only property of the [LayoutShift] interface returns the time of the most recent excluding input or `0` if no excluding input has occurred.\n\nLayout shifts are only bad if the user wasn't expecting them. Many layout shift metrics (like [Cumulative Layout Shift (CLS)](https://web.dev/articles/cls)) exclude shifts that occurred soon after certain user interactions. These interactions are called _excluding inputs_. Excluding inputs are:\n\n- Any events which signal a user's active interaction with the document: ([`mousedown`](https://developer.mozilla.org/en-US/docs/Web/API/Element/mousedown_event), [`keydown`](https://developer.mozilla.org/en-US/docs/Web/API/Element/keydown_event), and [`pointerdown`](https://developer.mozilla.org/en-US/docs/Web/API/Element/pointerdown_event))\n- Any events which directly changes the size of the viewport.\n- [`change`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/change_event) events.\n\nThe [`mousemove`](https://developer.mozilla.org/en-US/docs/Web/API/Element/mousemove_event) and [`pointermove`](https://developer.mozilla.org/en-US/docs/Web/API/Element/pointermove_event) events are **not** excluding inputs.",
+      "lastinputtime": "The **`lastInputTime`** read-only property of the [LayoutShift] interface returns the time of the most recent excluding input or `0` if no excluding input has occurred.\n\nLayout shifts are only bad if the user wasn't expecting them. Layout shift metrics like  exclude shifts that occurred soon after certain user interactions. These interactions are called _excluding inputs_. Excluding inputs are:\n\n- Any events which signal a user's active interaction with the document: ([`mousedown`](https://developer.mozilla.org/en-US/docs/Web/API/Element/mousedown_event), [`keydown`](https://developer.mozilla.org/en-US/docs/Web/API/Element/keydown_event), and [`pointerdown`](https://developer.mozilla.org/en-US/docs/Web/API/Element/pointerdown_event))\n- Any events which directly changes the size of the viewport.\n- [`change`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/change_event) events.\n\nThe [`mousemove`](https://developer.mozilla.org/en-US/docs/Web/API/Element/mousemove_event) and [`pointermove`](https://developer.mozilla.org/en-US/docs/Web/API/Element/pointermove_event) events are **not** excluding inputs.",
       "sources": "The **`sources`** read-only property of the [LayoutShift] interface returns an array of [LayoutShiftAttribution] objects that indicate the DOM elements that moved during the layout shift.",
       "tojson": "The **`toJSON()`** method of the [LayoutShift] interface is a ; it returns a JSON representation of the [LayoutShift] object.",
       "value": "The **`value`** read-only property of the [LayoutShift] interface returns the layout shift score calculated as the impact fraction (fraction of the viewport that was shifted) multiplied by the distance fraction (distance moved as a fraction of viewport)."
@@ -4399,7 +4461,7 @@
       "assign": "The **`assign()`** method of the [Location]\ninterface causes the window to load\nand display the document at the URL specified. After the navigation occurs, the user can\nnavigate back to the page that called `Location.assign()` by pressing the \"back\" button.",
       "hash": "The **`hash`** property of the\n[Location] interface returns a string containing a\n`'#'` followed by the fragment identifier of the URL — the ID on the page\nthat the URL is trying to target.\n\nThe fragment is not [URL decoded](https://en.wikipedia.org/wiki/URL_encoding). If the URL does not\nhave a fragment identifier, this property contains an empty string, `\"\"`.",
       "host": "The **`host`** property of the [Location]\ninterface is a string containing the host, that is the\n_hostname_, and then, if the _port_ of the URL is nonempty, a\n`':'`, and the _port_ of the URL.",
-      "hostname": "The **`hostname`** property of the [Location]\ninterface is a string containing the domain of the URL.",
+      "hostname": "The **`hostname`** property of the [Location]\ninterface is a string containing the  of the URL.",
       "href": "The **`href`** property of the [Location]\ninterface is a  that returns a string containing the whole\nURL, and allows the href to be updated.\n\nSetting the value of `href` _navigates_ to the provided URL. If you\nwant _redirection_, use [Location.replace]. The difference from setting the `href` property value is that when using the `location.replace()` method, after navigating to the given URL, the current page will not be saved in session [history](https://developer.mozilla.org/en-US/docs/Web/API/History_API) — meaning the user won't be able to use the back button to navigate to it.",
       "origin": "The **`origin`** read-only property of\nthe [Location] interface is a string containing the\nUnicode serialization of the origin of the represented URL.\n\nThat is:\n\n- for URL using the `http` or `https`, the scheme followed by\n  `'://'`, followed by the domain, followed by `':'`, followed by\n  the port (the default port, `80` and `443` respectively, if\n  explicitly specified);\n- for URL using `file:` scheme, the value is browser dependent;\n- for URL using the `blob:` scheme, the origin of the URL following\n  `blob:`. E.g `\"blob:https://mozilla.org\"` will have\n  `\"https://mozilla.org\".`",
       "pathname": "The **`pathname`** property of the [Location]\ninterface is a string containing the path of the URL for the location. If there is no path, `pathname` will be empty: otherwise, `pathname` contains an initial '/' followed by the path of the URL, not including the query string or fragment.",
@@ -4544,8 +4606,7 @@
     "docs": "The **`MediaError`** interface represents an error which occurred while handling media in an HTML media element based on [HTMLMediaElement], such as `audio` or `video`.\n\nA `MediaError` object describes the error in general terms using a numeric `code` categorizing the kind of error, and a `message`, which provides specific diagnostics about what went wrong.",
     "properties": {
       "code": "The read-only property **`MediaError.code`** returns a numeric\nvalue which represents the kind of error that occurred on a media element. To get a text\nstring with specific diagnostic information, see [MediaError.message].",
-      "message": "The read-only property **`MediaError.message`** returns a\nhuman-readable string offering specific\ndiagnostic details related to the error described by the `MediaError` object,\nor an empty string (`\"\"`) if no diagnostic information can be determined or\nprovided.",
-      "msextendedcode": "In the event of an error, the media element's error event will be fired. The element's error property will then contain an **`msExtendedCode`** read-only property with platform-specific error code information.\n\n**`msExtendedCode`** is a read-only proprietary property specific to Internet Explorer and Microsoft Edge."
+      "message": "The read-only property **`MediaError.message`** returns a\nhuman-readable string offering specific\ndiagnostic details related to the error described by the `MediaError` object,\nor an empty string (`\"\"`) if no diagnostic information can be determined or\nprovided."
     }
   },
   "MediaKeyMessageEvent": {
@@ -4812,7 +4873,7 @@
   "MediaTrackSettings": {
     "docs": "The **`MediaTrackSettings`** dictionary is used to return the current values configured for each of a [MediaStreamTrack]'s settings. These values will adhere as closely as possible to any constraints previously described using a [MediaTrackConstraints] object and set using [MediaStreamTrack.applyConstraints], and will adhere to the default constraints for any properties whose constraints haven't been changed, or whose customized constraints couldn't be matched.\n\nTo learn more about how constraints and settings work, see [Capabilities, constraints, and settings](https://developer.mozilla.org/en-US/docs/Web/API/Media_Capture_and_Streams_API/Constraints).",
     "properties": {
-      "aspectratio": "The [MediaTrackSettings] dictionary's **`aspectRatio`** property is a double-precision floating-point number indicating the aspect ratio of the [MediaStreamTrack] as currently configured.\nThis lets you determine what value was selected to comply with your specified constraints for this property's value as described in the [MediaTrackConstraints.aspectRatio] property you provided when calling either [MediaDevices.getUserMedia] or [MediaStreamTrack.applyConstraints].\n\nIf needed, you can determine whether or not this constraint is supported by checking\nthe value of [MediaTrackSupportedConstraints.aspectRatio] as returned by a\ncall to [MediaDevices.getSupportedConstraints]. However, typically this\nis unnecessary since browsers will ignore any constraints they're unfamiliar with.",
+      "aspectratio": "The [MediaTrackSettings] dictionary's **`aspectRatio`** property is a double-precision floating-point number indicating the  of the [MediaStreamTrack] as currently configured.\nThis lets you determine what value was selected to comply with your specified constraints for this property's value as described in the [MediaTrackConstraints.aspectRatio] property you provided when calling either [MediaDevices.getUserMedia] or [MediaStreamTrack.applyConstraints].\n\nIf needed, you can determine whether or not this constraint is supported by checking\nthe value of [MediaTrackSupportedConstraints.aspectRatio] as returned by a\ncall to [MediaDevices.getSupportedConstraints]. However, typically this\nis unnecessary since browsers will ignore any constraints they're unfamiliar with.",
       "autogaincontrol": "The [MediaTrackSettings] dictionary's\n**`autoGainControl`** property is a Boolean value whose value\nindicates whether or not automatic gain control (AGC) is enabled on an audio track. This\nlets you determine what value was selected to comply with your specified constraints for\nthis property's value as described in the\n[MediaTrackConstraints.autoGainControl] property you provided when calling\neither [MediaDevices.getUserMedia] or\n[MediaStreamTrack.applyConstraints].\n\nAutomatic gain control is a feature in which a sound source automatically manages\nchanges in the volume of its source media to maintain a steady overall volume level.\nThis feature is typically used on microphones, although it can be provided by other\ninput sources as well.\n\nIf needed, you can determine whether or not this constraint is supported by checking\nthe value of [MediaTrackSupportedConstraints.autoGainControl] as returned\nby a call to [MediaDevices.getSupportedConstraints]. However, typically\nthis is unnecessary since browsers will ignore any constraints they're unfamiliar with.",
       "channelcount": "The [MediaTrackSettings] dictionary's\n**`channelCount`** property is an integer indicating how many\naudio channels the [MediaStreamTrack] is currently configured to have. This\nlets you determine what value was selected to comply with your specified constraints for\nthis property's value as described in the\n[MediaTrackConstraints.channelCount] property you provided when calling\neither [MediaDevices.getUserMedia] or\n[MediaStreamTrack.applyConstraints].\n\nIf needed, you can determine whether or not this constraint is supported by checking\nthe value of [MediaTrackSupportedConstraints.channelCount] as returned by a\ncall to [MediaDevices.getSupportedConstraints]. However, typically this\nis unnecessary since browsers will ignore any constraints they're unfamiliar with.",
       "cursor": "The [MediaTrackSettings] dictionary's **`cursor`** property indicates whether or not the cursor should be captured as part of the video track included in the [MediaStream] returned by [MediaDevices.getDisplayMedia].",
@@ -5122,10 +5183,10 @@
       "appversion": "Returns either \"`4.0`\" or a string representing version information about\nthe browser.\n\n> **Note:** Do not rely on this property to return the correct browser version.",
       "bluetooth": "The **`bluetooth`** read-only property of the [Navigator] interface returns a [Bluetooth] object for the current document, providing access to [Web Bluetooth API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Bluetooth_API) functionality.",
       "buildid": "Returns the build identifier of the browser. In modern browsers this property now returns a fixed timestamp as a privacy measure, e.g. `20181001000000` in Firefox 64 onwards.",
-      "canshare": "The **`Navigator.canShare()`** method of the [Web Share API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Share_API) returns `true` if the equivalent call to [navigator.share] would succeed.\n\nThe method returns `false` if the data cannot be _validated_. Reasons the data might be invalid include:\n\n- The `data` parameter has been omitted or only contains properties with unknown values. Note that any properties that are not recognized by the user agent are ignored.\n- A URL is badly formatted.\n- Files are specified but the implementation does not support file sharing.\n- Sharing the specified data would be considered a \"hostile share\" by the user-agent.\n\nThe Web Share API is gated by the [web-share](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Permissions-Policy/web-share) permission policy.\nThe **`canShare()`** method will return `false` if the permission is supported but has not been granted.",
+      "canshare": "The **`canShare()`** method of the [Navigator] interface returns `true` if the equivalent call to [navigator.share] would succeed.\n\nThe method returns `false` if the data cannot be _validated_. Reasons the data might be invalid include:\n\n- The `data` parameter has been omitted or only contains properties with unknown values. Note that any properties that are not recognized by the user agent are ignored.\n- A URL is badly formatted.\n- Files are specified but the implementation does not support file sharing.\n- Sharing the specified data would be considered a \"hostile share\" by the user-agent.\n\nThe [Web Share API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Share_API) is gated by the [web-share](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Permissions-Policy/web-share) permission policy.\nThe `canShare()` method will return `false` if the permission is supported but has not been granted.",
       "clearappbadge": "The **`clearAppBadge()`** method of the [Navigator] interface clears a badge on the current app's icon by setting it to `nothing`. The value `nothing` indicates that no badge is currently set, and the status of the badge is _cleared_.",
       "clipboard": "The **`clipboard`** read-only property of the [Navigator] interface returns a [Clipboard] object used to read and write the clipboard's contents.\n\nThis is the entry point to the [Clipboard API](https://developer.mozilla.org/en-US/docs/Web/API/Clipboard_API), which can be used to implement cut, copy, and paste features within a web application.",
-      "connection": "The **`Navigator.connection`** read-only property returns a [NetworkInformation] object containing information about the system's connection, such as the current bandwidth of the user's device or whether the connection is metered.\n\nThis could be used to select high definition content or low definition content based on the user's connection.",
+      "connection": "The **`connection`** read-only property of the [Navigator] interface returns a [NetworkInformation] object containing information about the system's connection, such as the current bandwidth of the user's device or whether the connection is metered.\n\nThis could be used to select high definition content or low definition content based on the user's connection.",
       "contacts": "The **`contacts`** read-only property of the\n[Navigator] interface returns a [ContactsManager] interface\nwhich allows users to select entries from their contact list and share limited details\nof the selected entries with a website or application.",
       "cookieenabled": "`navigator.cookieEnabled` returns a Boolean value that indicates whether cookies are enabled or not.\n\nThe property is read-only.",
       "credentials": "The **`credentials`** read-only property of the [Navigator] interface returns the [CredentialsContainer] object associated with the current document, which exposes methods to request credentials. The [CredentialsContainer] interface also notifies the user agent when an interesting event occurs, such as a successful sign-in or sign-out. This interface can be used for feature detection.",
@@ -5158,12 +5219,12 @@
       "online": "Returns the online status of the browser. The property returns a boolean value, with\n`true` meaning online and `false` meaning offline. The property\nsends updates whenever the browser's ability to connect to the network changes. The\nupdate occurs when the user follows links or when a script requests a remote page. For\nexample, the property should return `false` when users click links soon after\nthey lose internet connection.\n\nBrowsers implement this property differently.\n\nIn Chrome and Safari, if the browser is not able to connect to a local area network\n(LAN) or a router, it is offline; all other conditions return `true`. So\nwhile you can assume that the browser is offline when it returns a `false`\nvalue, you cannot assume that a true value necessarily means that the browser can access\nthe internet. You could be getting false positives, such as in cases where the computer\nis running a virtualization software that has virtual ethernet adapters that are always\n\"connected.\" Therefore, if you really want to determine the online status of the\nbrowser, you should develop additional means for checking.\n\nIn Firefox, switching the browser to offline mode sends a `false` value. Until Firefox\n41, all other conditions returned a `true` value; testing actual behavior on Nightly 68 on\nWindows shows that it only looks for LAN connection like Chrome and Safari giving false\npositives.\n\nYou can see changes in the network state by listening to the [`online`](https://developer.mozilla.org/en-US/docs/Web/API/Window/online_event) and [`offline`](https://developer.mozilla.org/en-US/docs/Web/API/Window/offline_event) events.",
       "oscpu": "The **`Navigator.oscpu`** property returns a string that identifies the current operating system.",
       "pdfviewerenabled": "The **`pdfViewerEnabled`** read-only property of the [Navigator] interface indicates whether the browser supports inline display of PDF files when navigating to them.\n\nIf inline viewing is not supported the PDF is downloaded and may then be handled by some external application.\n\n> **Note:** This method replaces a number of legacy methods of inferring support for inline viewing of PDF files.",
-      "permissions": "The **`Navigator.permissions`** read-only property returns a\n[Permissions] object that can be used to query and update permission\nstatus of APIs covered by the [Permissions API](https://developer.mozilla.org/en-US/docs/Web/API/Permissions_API).",
+      "permissions": "The **`permissions`** read-only property of the [Navigator] interface returns a\n[Permissions] object that can be used to query and update permission\nstatus of APIs covered by the [Permissions API](https://developer.mozilla.org/en-US/docs/Web/API/Permissions_API).",
       "platform": "The **`platform`** property read-only property of the [Navigator] interface returns a string identifying the platform on which the user's browser is running.\n\n> **Note:** In general, you should whenever possible avoid writing code that uses methods or properties like this one to try to find out information about the user's environment, and instead write code that does [feature detection](https://developer.mozilla.org/en-US/docs/Learn/Tools_and_testing/Cross_browser_testing/Feature_detection).",
       "plugins": "Returns a [PluginArray] object, listing the [Plugin] objects describing the plugins installed in the application.\nNamed properties of the returned object are not enumerable (except in very old browser versions).\n\nRecent versions of the specification hard-code the returned list.\nIf inline viewing of PDF files is supported the property lists five standard plugins.\nIf inline PDF viewing is not supported then an empty list is returned.\n\n> **Note:** Use [Navigator.pdfViewerEnabled] to determine if inline viewing of PDF files is supported. Do not infer it from this property.\n>\n> The \"five standard plugins\" are those that developers have most commonly used to feature detect inline PDF viewing.\n> Returning these ensures that legacy code can more reliably determine whether inline viewing is supported.\n> However this approach is not recommended for new code because this property may eventually be removed.\n\nLegacy browser versions also list plugins for Adobe Flash and PDF viewer extensions.",
       "presentation": "The `presentation` read-only property of [Navigator] serves as the entry\npoint for the [Presentation API](https://developer.mozilla.org/en-US/docs/Web/API/Presentation_API) and\nreturns a reference to [Presentation] object.",
       "product": "The value of the **`Navigator.product`** property is always\n\"`Gecko`\", in any browser. This property is kept only for compatibility\npurposes.\n\n> **Note:** Do not rely on this property to return a real product name. All browsers return \"`Gecko`\" as the value of this property.",
-      "productsub": "The **`Navigator.productSub`** read-only property returns the\nbuild number of the current browser.",
+      "productsub": "The **`Navigator.productSub`** read-only property that returns either the string \"20030107\", or the string \"20100101\".",
       "registerprotocolhandler": "The **[Navigator]** method **`registerProtocolHandler()`** lets websites register their ability to open or handle particular URL schemes (aka protocols).\n\nFor example, this API lets webmail sites open `mailto:` URLs, or VoIP sites open `tel:` URLs.",
       "requestmediakeysystemaccess": "The **`Navigator.requestMediaKeySystemAccess()`** method\nreturns a `Promise` which delivers a [MediaKeySystemAccess]\nobject that can be used to access a particular media key system, which can in turn be\nused to create keys for decrypting a media stream. This method is part of the [Encrypted Media Extensions API](https://developer.mozilla.org/en-US/docs/Web/API/Encrypted_Media_Extensions_API), which brings support for encrypted media and DRM-protected video to the web.\n\nThis method may have user-visible effects such as asking for permission to access one\nor more system resources. Consider that when deciding when to call\n`requestMediaKeySystemAccess()`; you don't want those requests\nto happen at inconvenient times. As a general rule, this function should be called only\nwhen it's about time to create and use a [MediaKeys] object by calling the\nreturned [MediaKeySystemAccess] object's\n[MediaKeySystemAccess.createMediaKeys] method.",
       "requestmidiaccess": "The **`requestMIDIAccess()`** method of the [Navigator] interface returns a `Promise` representing a request for access to MIDI devices on a user's system.\nThis method is part of the [Web MIDI API](https://developer.mozilla.org/en-US/docs/Web/API/Web_MIDI_API), which provides a means for accessing, enumerating, and manipulating MIDI devices.\n\nThis method may prompt the user for access to MIDI devices available to their system, or it may use a previously established preference to grant or deny access.\nIf permission is granted then the `Promise` resolves and a [`MIDIAccess`](https://developer.mozilla.org/en-US/docs/Web/API/MIDIAccess) object is returned.",
@@ -5172,7 +5233,7 @@
       "serial": "The **`serial`** read-only property of the [Navigator] interface returns a [Serial] object which represents the entry point into the [Web Serial API].\n\nWhen getting, the same instance of the [Serial] object will always be returned.",
       "serviceworker": "The **`serviceWorker`** read-only property of the [Navigator] interface returns the [ServiceWorkerContainer] object for the [associated document](https://html.spec.whatwg.org/multipage/browsers.html#concept-document-window), which provides access to registration, removal, upgrade, and communication with the [ServiceWorker].\n\nThe feature may not be available in private mode.",
       "setappbadge": "The **`setAppBadge()`** method of the [Navigator] interface sets a badge on the icon associated with this app. If a value is passed to the method, this will be set as the value of the badge. Otherwise the badge will display as a dot, or other indicator as defined by the platform.",
-      "share": "The **`navigator.share()`** method of the [Web Share API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Share_API) invokes the native sharing mechanism of the device to share data such as text, URLs, or files. The available _share targets_ depend on the device, but might include the clipboard, contacts and email applications, websites, Bluetooth, etc.\n\nThe method resolves a `Promise` with `undefined`.\nOn Windows this happens when the share popup is launched, while on Android the promise resolves once the data has successfully been passed to the _share target_.",
+      "share": "The **`share()`** method of the [Navigator] interface invokes the native sharing mechanism of the device to share data such as text, URLs, or files. The available _share targets_ depend on the device, but might include the clipboard, contacts and email applications, websites, Bluetooth, etc.\n\nThe method resolves a `Promise` with `undefined`.\nOn Windows this happens when the share popup is launched, while on Android the promise resolves once the data has successfully been passed to the _share target_.\n\nThe [Web Share API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Share_API) is gated by the [web-share](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Permissions-Policy/web-share) permission policy.\nThe `share()` method will throw exceptions if the permission is supported but has not been granted.",
       "storage": "The **`Navigator.storage`**\nread-only property returns the singleton [StorageManager] object used to\naccess the overall storage capabilities of the browser for the current site or app.\nThe returned object lets you examine and configure persistence of data stores and\nlearn approximately how much more space your browser has available for local storage\nuse.",
       "taintenabled": "The **`Navigator.taintEnabled()`** method always returns\n`false`.\n\nTainting was a security method used by JavaScript 1.2. It has long been removed; this\nmethod only stays for maintaining compatibility with very old scripts.",
       "unregisterprotocolhandler": "The **[Navigator]** method **`unregisterProtocolHandler()`** removes a protocol handler for a given URL [scheme](#permitted_schemes).\n\nThis method is the inverse of **`registerProtocolHandler()`**.",
@@ -5182,7 +5243,7 @@
       "useragentdata": "The **`userAgentData`** read-only property of the [Navigator] interface returns a [NavigatorUAData] object\nwhich can be used to access the .",
       "vendor": "The value of the [Navigator] **`vendor`** property is always either \"`Google Inc.`\", \"`Apple Computer, Inc.`\", or (in Firefox) the empty string.",
       "vendorsub": "The value of the **`Navigator.vendorSub`** property is always\nthe empty string, in any browser.",
-      "vibrate": "The **`Navigator.vibrate()`** method pulses the vibration\nhardware on the device, if such hardware exists. If the device doesn't support\nvibration, this method has no effect. If a vibration pattern is already in progress when\nthis method is called, the previous pattern is halted and the new one begins instead.\n\nIf the method was unable to vibrate because of invalid parameters, it will return\n`false`, else it returns `true`. If the pattern leads to a too\nlong vibration, it is truncated: the max length depends on the implementation.",
+      "vibrate": "The **`vibrate()`** method of the [Navigator] interface pulses the vibration\nhardware on the device, if such hardware exists. If the device doesn't support\nvibration, this method has no effect. If a vibration pattern is already in progress when\nthis method is called, the previous pattern is halted and the new one begins instead.\n\nIf the method was unable to vibrate because of invalid parameters, it will return\n`false`, else it returns `true`. If the pattern leads to a too\nlong vibration, it is truncated: the max length depends on the implementation.",
       "virtualkeyboard": "The **`virtualKeyboard`** read-only property\nof the [navigator] interface returns a reference to the [VirtualKeyboard] instance object.\n\nThe [VirtualKeyboard_API] gives developers control over the layout of their applications when the on-screen virtual keyboard appears and disappears on devices such as tablets, mobile phones, or other devices where a hardware keyboard may not be available.",
       "wakelock": "The **`wakeLock`** read-only property of the [Navigator] interface returns a [WakeLock] interface that allows a document to acquire a screen wake lock.\nWhile a screen wake lock is active, the user agent will try to prevent the device from dimming the screen, turning it off completely, or showing a screensaver.",
       "webdriver": "The **`webdriver`** read-only property\nof the [navigator] interface indicates whether the user agent is\ncontrolled by automation.\n\nIt defines a standard way for co-operating user agents to inform the document that it\nis controlled by [WebDriver](https://developer.mozilla.org/en-US/docs/Web/WebDriver), for example, so that\nalternate code paths can be triggered during automation.\n\nThe `navigator.webdriver` property is true when in:\n\n- Chrome\n  - : The `--enable-automation` or the `--headless` flag or the\n    `--remote-debugging-port` is used.\n- Firefox\n  - : The `marionette.enabled` preference or `--marionette` flag is\n    passed.",
@@ -5197,25 +5258,25 @@
     }
   },
   "NavigatorUAData": {
-    "docs": "The **`NavigatorUAData`** interface of the  returns information about the browser and operating system of a user.\n\nAn instance of this object is returned by calling [Navigator.userAgentData]. Therefore, this interface has no constructor.\n\n> **Note:** The terms _high entropy_ and _low entropy_ refer to the amount of information these values reveal about the browser. The values returned as properties are deemed low entropy, and unlikely to identify a user. The values returned by [NavigatorUAData.getHighEntropyValues] could potentially reveal more information. These values are therefore retrieved via a `Promise`, allowing time for the browser to request user permission, or make other checks.",
+    "docs": "The **`NavigatorUAData`** interface of the  returns information about the browser and operating system of a user.\n\nAn instance of this object is returned by calling [Navigator.userAgentData] or [WorkerNavigator.userAgentData]. Therefore, this interface has no constructor.\n\n> **Note:** The terms _high entropy_ and _low entropy_ refer to the amount of information these values reveal about the browser. The values returned as properties are deemed low entropy, and unlikely to identify a user. The values returned by [NavigatorUAData.getHighEntropyValues] could potentially reveal more information. These values are therefore retrieved via a `Promise`, allowing time for the browser to request user permission, or make other checks.",
     "properties": {
       "brands": "The **`brands`** read-only property of the [NavigatorUAData] interface returns an array of brand information.",
-      "gethighentropyvalues": "The **`getHighEntropyValues()`** method of the [NavigatorUAData] interface is a `Promise` that resolves with a dictionary object containing the _high entropy_ values the user-agent returns.\n\n> **Note:** The terms _high entropy_ and _low entropy_ refer to the amount of information these values reveal about the browser.\n> The values returned as properties are deemed low entropy, and unlikely to identify a user.\n> The values returned by [NavigatorUAData.getHighEntropyValues] could potentially reveal more information.\n> These values are therefore retrieved via a `Promise`, allowing time for the browser to request user permission, or make other checks.",
+      "gethighentropyvalues": "The **`getHighEntropyValues()`** method of the [NavigatorUAData] interface is a `Promise` that resolves with a dictionary object containing the _high entropy_ values the user-agent returns.\n\n> **Note:** The terms _high entropy_ and _low entropy_ refer to the amount of information these values reveal about the browser.\n> The values returned as properties are deemed low entropy, and unlikely to identify a user.\n> The values returned by `getHighEntropyValues()` could potentially reveal more information.\n> These values are therefore retrieved via a `Promise`, allowing time for the browser to request user permission, or make other checks.",
       "mobile": "The **`mobile`** read-only property of the [NavigatorUAData] interface returns a value indicating whether the device is a mobile device.",
       "platform": "The **`platform`** read-only property of the [NavigatorUAData] interface returns the platform brand information.",
       "tojson": "The **`toJSON()`** method of the [NavigatorUAData] interface is a _serializer_ that returns a JSON representation of the _low entropy_ properties of the `NavigatorUAData` object.\n\n> **Note:** The terms _high entropy_ and _low entropy_ refer to the amount of information these values reveal about the browser. The low entropy values returned by this method are those which do not reveal information able to identify a user. High entropy values can only be returned by the [NavigatorUAData.getHighEntropyValues] method."
     }
   },
   "NetworkInformation": {
-    "docs": "The **`NetworkInformation`** interface of the [Network Information API](https://developer.mozilla.org/en-US/docs/Web/API/Network_Information_API) provides information about the connection a device is using to communicate with the network and provides a means for scripts to be notified if the connection type changes.\nThe `NetworkInformation` interface cannot be instantiated. It is instead accessed through the `connection` property of the [Navigator] interface.",
+    "docs": "The **`NetworkInformation`** interface of the [Network Information API](https://developer.mozilla.org/en-US/docs/Web/API/Network_Information_API) provides information about the connection a device is using to communicate with the network and provides a means for scripts to be notified if the connection type changes.\nThe `NetworkInformation` interface cannot be instantiated. It is instead accessed through the `connection` property of the [Navigator] interface or the [WorkerNavigator] interface.",
     "properties": {
-      "change_event": "The **`change`** event fires when connection information changes, and the event\nis received by the [NetworkInformation] object.",
+      "change_event": "The **`change`** event of the [NetworkInformation] interface fires when connection information changes, and the event is received by the [NetworkInformation] object.",
       "downlink": "The **`downlink`** read-only property of the\n[NetworkInformation] interface returns the effective bandwidth estimate in\nmegabits per second, rounded to the nearest multiple of 25 kilobits per seconds. This\nvalue is based on recently observed application layer throughput across recently active\nconnections, excluding connections made to a private address space. In the absence of\nrecent bandwidth measurement data, the attribute value is determined by the properties\nof the underlying connection technology.",
-      "downlinkmax": "The **`NetworkInformation.downlinkMax`** read-only property\nreturns the maximum downlink speed, in megabits per second (Mbps), for the underlying\nconnection technology.",
+      "downlinkmax": "The **`downlinkMax`** read-only property of the [NetworkInformation] interface returns the maximum downlink speed, in megabits per second (Mbps), for the underlying connection technology.",
       "effectivetype": "The **`effectiveType`** read-only property of the\n[NetworkInformation] interface returns the effective type of the connection\nmeaning one of `slow-2g`, `2g`, `3g`, or `4g`. This value is determined using a\ncombination of recently observed, round-trip time and downlink values.",
-      "rtt": "The **`NetworkInformation.rtt`** read-only property returns the\nestimated effective round-trip time of the current connection, rounded to the nearest\nmultiple of 25 milliseconds. This value is based on recently observed application-layer\nRTT measurements across recently active connections. It excludes connections made to a\nprivate address space. If no recent measurement data is available, the value is based on\nthe properties of the underlying connection technology.",
-      "savedata": "The **`NetworkInformation.saveData`** read-only\nproperty of the [NetworkInformation] interface returns `true` if\nthe user has set a reduced data usage option on the user agent.",
-      "type": "The **`NetworkInformation.type`** read-only property returns\nthe type of connection a device is using to communicate with the network."
+      "rtt": "The **`rtt`** read-only property of the [NetworkInformation] interface returns the estimated effective round-trip time of the current connection, rounded to the nearest multiple of 25 milliseconds.\nThis value is based on recently observed application-layer RTT measurements across recently active connections.\nIt excludes connections made to a private address space.\nIf no recent measurement data is available, the value is based on the properties of the underlying connection technology.",
+      "savedata": "The **`saveData`** read-only\nproperty of the [NetworkInformation] interface returns `true` if the user has set a reduced data usage option on the user agent.",
+      "type": "The **`type`** read-only property of the [NetworkInformation] interface returns the type of connection a device is using to communicate with the network."
     }
   },
   "Node": {
@@ -5277,6 +5338,25 @@
       "values": "The **`NodeList.values()`** method returns an\n`iterator` allowing to go through all values contained\nin this object. The values are [Node] objects."
     }
   },
+  "NotRestoredReasonDetails": {
+    "docs": "The **`NotRestoredReasonDetails`** interface of the [Performance API] represents a single reason why a navigated page was blocked from using the back/forward cache ().\n\nAn array of `NotRestoredReasonDetails` objects can be accessed via the [NotRestoredReasons.reasons] property.",
+    "properties": {
+      "reason": "The **`reason`** read-only property of the\n[NotRestoredReasonDetails] interface returns a string describing a reason that the page was blocked from using the back/forward cache ().",
+      "tojson": "The **`toJSON()`** method of the [NotRestoredReasonDetails] interface is a ; it returns a JSON representation of the [NotRestoredReasonDetails] object."
+    }
+  },
+  "NotRestoredReasons": {
+    "docs": "The **`NotRestoredReasons`** interface of the [Performance API] provides report data containing reasons why the current document was blocked from using the back/forward cache () on navigation.\n\nThese objects are accessed via the [PerformanceNavigationTiming.notRestoredReasons] property.",
+    "properties": {
+      "children": "The **`children`** read-only property of the\n[NotRestoredReasons] interface returns an array of [NotRestoredReasons] objects, one for each child `iframe` embedded in the current document, which may contain reasons why the top-level frame was blocked relating to the child frames.\n\nEach object has the same structure as the parent object — this way, any number of levels of embedded `<iframe>`s can be represented inside the object recursively.",
+      "id": "The **`id`** read-only property of the\n[NotRestoredReasons] interface returns a string representing the `id` attribute value of the `iframe` the document is contained in (for example `<iframe id=\"foo\" src=\"...\">`).",
+      "name": "The **`name`** read-only property of the\n[NotRestoredReasons] interface returns a string representing the `name` attribute value of the `iframe` the document is contained in (for example `<iframe name=\"bar\" src=\"...\">`).",
+      "reasons": "The **`reasons`** read-only property of the\n[NotRestoredReasons] interface returns an array of [NotRestoredReasonDetails] objects, each representing a reason why the navigated page was blocked from using the back/forward cache ().",
+      "src": "The **`src`** read-only property of the\n[NotRestoredReasons] interface returns a string representing the path to the source of the `iframe` the document is contained in (for example `<iframe src=\"b.html\">`).",
+      "tojson": "The **`toJSON()`** method of the [NotRestoredReasons] interface is a ; it returns a JSON representation of the [NotRestoredReasons] object.",
+      "url": "The **`url`** read-only property of the\n[NotRestoredReasons] interface returns a string representing the URL of the navigated page or `iframe`."
+    }
+  },
   "Notification": {
     "docs": "The **`Notification`** interface of the [Notifications API] is used to configure and display desktop notifications to the user.\n\nThese notifications' appearance and specific functionality vary across platforms but generally they provide a way to asynchronously provide information to the user.",
     "properties": {
@@ -5307,11 +5387,11 @@
     }
   },
   "NotificationEvent": {
-    "docs": "The **`NotificationEvent`** interface of the [Notifications API] represents a notification event dispatched on the [ServiceWorkerGlobalScope] of a [ServiceWorker].\n\nThis interface inherits from the [ExtendableEvent] interface.\n\n> **Note:** Only persistent notification events, fired at the [ServiceWorkerGlobalScope] object, implement the `NotificationEvent` interface. Non-persistent notification events, fired at the [Notification] object, implement the `Event` interface.",
+    "docs": "@AvailableInWorkers(\"service\")\n\nThe **`NotificationEvent`** interface of the [Notifications API] represents a notification event dispatched on the [ServiceWorkerGlobalScope] of a [ServiceWorker].\n\nThis interface inherits from the [ExtendableEvent] interface.\n\n> **Note:** Only persistent notification events, fired at the [ServiceWorkerGlobalScope] object, implement the `NotificationEvent` interface. Non-persistent notification events, fired at the [Notification] object, implement the `Event` interface.",
     "properties": {
-      "action": "The **`action`** read-only property of the [NotificationEvent] interface returns the string ID of the notification button the user clicked. This value returns an empty string if the user clicked the notification somewhere other than an action button, or the notification does not have a button. The notification id is set during the creation of the Notification via the actions array attribute and can't be modified unless the notification is replaced.",
-      "notification": "The **`notification`** read-only property of the [NotificationEvent] interface returns the instance of the [Notification] that was clicked to fire the event. The [Notification] provides read-only access to many properties that were set at the instantiation time of the Notification such as `tag` and `data` attributes that allow you to store information for deferred use in the `notificationclick` event.",
-      "notificationevent": "The **`NotificationEvent()`** constructor creates a new [NotificationEvent] object."
+      "action": "@AvailableInWorkers(\"service\")\n\nThe **`action`** read-only property of the [NotificationEvent] interface returns the string ID of the notification button the user clicked. This value returns an empty string if the user clicked the notification somewhere other than an action button, or the notification does not have a button. The notification id is set during the creation of the Notification via the actions array attribute and can't be modified unless the notification is replaced.",
+      "notification": "@AvailableInWorkers(\"service\")\n\nThe **`notification`** read-only property of the [NotificationEvent] interface returns the instance of the [Notification] that was clicked to fire the event. The [Notification] provides read-only access to many properties that were set at the instantiation time of the Notification such as `tag` and `data` attributes that allow you to store information for deferred use in the `notificationclick` event.",
+      "notificationevent": "@AvailableInWorkers(\"service\")\n\nThe **`NotificationEvent()`** constructor creates a new [NotificationEvent] object."
     }
   },
   "OES_draw_buffers_indexed": {
@@ -5329,7 +5409,7 @@
   "OTPCredential": {
     "docs": "The **`OTPCredential`** interface of the [WebOTP API] is returned when a WebOTP [CredentialsContainer.get] call (i.e. invoked with an `otp` option) fulfills. It includes a `code` property that contains the retrieved one-time password (OTP).",
     "properties": {
-      "code": "The **`code`** property of the [OTPCredential] interface contains the one-time password (OTP)."
+      "code": "The **`code`** read-only property of the [OTPCredential] interface contains the one-time password (OTP)."
     }
   },
   "OfflineAudioCompletionEvent": {
@@ -5353,6 +5433,8 @@
   "OffscreenCanvas": {
     "docs": "When using the `canvas` element or the [Canvas API](https://developer.mozilla.org/en-US/docs/Web/API/Canvas_API), rendering, animation, and user interaction usually happen on the main execution thread of a web application.\nThe computation relating to canvas animations and rendering can have a significant impact on application performance.\n\nThe **`OffscreenCanvas`** interface provides a canvas that can be rendered off screen, decoupling the DOM and the Canvas API so that the `canvas` element is no longer entirely dependent on the DOM.\nRendering operations can also be run inside a [worker](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API) context, allowing you to run some tasks in a separate thread and avoid heavy work on the main thread.\n\n`OffscreenCanvas` is a [transferable object](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Transferable_objects).",
     "properties": {
+      "contextlost_event": "The **`contextlost`** event of the [OffscreenCanvas] interface is fired if the browser detects that the [`OffscreenCanvasRenderingContext2D`](https://developer.mozilla.org/en-US/docs/Web/API/OffscreenCanvasRenderingContext2D) context is lost.\nContexts can be lost for several reasons, such as an associated GPU driver crashes, or the application runs out of memory, and so on.\n\nBy default the user agent will attempt to restore the context and then fire the [`contextrestored` event](https://developer.mozilla.org/en-US/docs/Web/API/OffscreenCanvas/contextrestored_event).\nUser code can prevent the context from being restored by calling [`Event.preventDefault()`](https://developer.mozilla.org/en-US/docs/Web/API/Event/preventDefault) during event handling.",
+      "contextrestored_event": "The **`contextrestored`** event of the [OffscreenCanvas] interface is fired if the browser restores a [`OffscreenCanvasRenderingContext2D`](https://developer.mozilla.org/en-US/docs/Web/API/OffscreenCanvasRenderingContext2D) context that was [previously lost](https://developer.mozilla.org/en-US/docs/Web/API/OffscreenCanvas/contextlost_event).\n\nYou can redraw, re-retrieve resources, and reinitialize the state of your context after receiving this event.",
       "converttoblob": "The **`OffscreenCanvas.convertToBlob()`** method creates a [Blob] object representing the image contained in the canvas.\n\nThe desired file format and image quality may be specified.\nIf the file format is not specified, or if the given format is not supported, then the data will be exported as `image/png`.\nBrowsers are required to support `image/png`; many will support additional formats including `image/jpeg` and `image/webp`.\n\nThe created image will have a resolution of 96dpi for file formats that support encoding resolution metadata.",
       "getcontext": "The **`OffscreenCanvas.getContext()`** method returns a drawing context for an offscreen canvas, or [`null`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/null) if the context identifier is not supported.",
       "height": "The **`height`** property returns and sets the height of an [OffscreenCanvas] object.",
@@ -5362,9 +5444,9 @@
     }
   },
   "OffscreenCanvasRenderingContext2D": {
-    "docs": "The **`OffscreenCanvasRenderingContext2D`** interface is a [CanvasRenderingContext2D] rendering context for drawing to the bitmap of an `OffscreenCanvas` object.\nIt is similar to the `CanvasRenderingContext2D` object, with the following differences:\n\n- there is no support for user-interface features (`drawFocusIfNeeded`, and `scrollPathIntoView`)\n- its `canvas` attribute refers to an `OffscreenCanvas` object rather than a `canvas` element\n- it has a `commit()` method for pushing rendered images to the context's `OffscreenCanvas` object's placeholder `canvas` element",
+    "docs": "The **`OffscreenCanvasRenderingContext2D`** interface is a [CanvasRenderingContext2D] rendering context for drawing to the bitmap of an `OffscreenCanvas` object.\nIt is similar to the `CanvasRenderingContext2D` object, with the following differences:\n\n- there is no support for user-interface features (`drawFocusIfNeeded`, and `scrollPathIntoView`)\n- its `canvas` attribute refers to an `OffscreenCanvas` object rather than a `canvas` element\n- the bitmap for the placeholder `canvas` element belonging to the `OffscreenCanvas` object is updated during the rendering update of the `Window` or `Worker` that owns the `OffscreenCanvas`",
     "properties": {
-      "commit": "The\n**`OffscreenCanvasRenderingContext2D.commit()`**\nmethod of the [Canvas 2D API](https://developer.mozilla.org/en-US/docs/Web/API/OffscreenCanvasRenderingContext2D) copies the rendering context's bitmap to the bitmap of the placeholder `canvas` element of the associated `OffscreenCanvas` object.\nThe copy operation is synchronous. Calling this method is not needed for the transfer, since it happens automatically during the event-loop execution."
+      "commit": "The\n**`OffscreenCanvasRenderingContext2D.commit()`**\nmethod of the [Canvas 2D API](https://developer.mozilla.org/en-US/docs/Web/API/OffscreenCanvasRenderingContext2D) was intended to copy the rendering context's bitmap to the bitmap of the placeholder `canvas` element of the associated `OffscreenCanvas` object.\nThe copy operation is synchronous. Calling this method is not needed for the transfer, since it happens automatically during the event-loop execution."
     }
   },
   "OrientationSensor": {
@@ -5436,6 +5518,9 @@
       "passwordcredential": "The **`PasswordCredential()`**\nconstructor creates a new [PasswordCredential] object. In\nsupporting browsers, an instance of this class may be passed the `credential`\nfrom the `init` object for global [fetch]."
     }
   },
+  "PasswordCredentialInit": {
+    "docs": "The **`PasswordCredentialInit`** dictionary represents the object passed to [CredentialsContainer.create] as the value of the `password` option, when creating a password credential."
+  },
   "Path2D": {
     "docs": "The **`Path2D`** interface of the Canvas 2D API is used to declare a path that can then be used on a [CanvasRenderingContext2D] object. The [path methods](/en-US/docs/Web/API/CanvasRenderingContext2D#paths) of the `CanvasRenderingContext2D` interface are also present on this interface, which gives you the convenience of being able to retain and replay your path whenever desired.",
     "properties": {
@@ -5492,19 +5577,19 @@
     }
   },
   "PaymentRequestEvent": {
-    "docs": "The **`PaymentRequestEvent`** interface of the [Payment Handler API] is the object passed to a payment handler when a [PaymentRequest] is made.",
+    "docs": "@AvailableInWorkers(\"service\")\n\nThe **`PaymentRequestEvent`** interface of the [Payment Handler API] is the object passed to a payment handler when a [PaymentRequest] is made.",
     "properties": {
-      "changepaymentmethod": "The **`changePaymentMethod()`** method of the [PaymentRequestEvent] interface is used by the payment handler to get an updated total, given such payment method details as the billing address.\n\nWhen this method is invoked, a [PaymentMethodChangeEvent] is fired.",
-      "instrumentkey": "The **`instrumentKey`** read-only property of the\n[PaymentRequestEvent] interface returns a\n`PaymentInstrument` object reflecting the payment instrument selected by\nthe user or an empty string if the user has not registered or chosen a payment\ninstrument.",
-      "methoddata": "The **`methodData`** read-only property of the\n[PaymentRequestEvent] interface returns an array of\n`PaymentMethodData` objects containing payment method identifiers for the\npayment methods that the website accepts and any associated payment method-specific\ndata.",
-      "modifiers": "The **`modifiers`** read-only property of the\n[PaymentRequestEvent] interface returns an `Array` of `PaymentDetailsModifier` objects containing modifiers for payment details.",
-      "openwindow": "The **`openWindow()`** method of the [PaymentRequestEvent] interface opens the specified URL in a new window, only if the given URL is on the same origin as the calling page. It returns a `Promise` that resolves with a reference to a [WindowClient].",
-      "paymentrequestevent": "The **`PaymentRequestEvent`** constructor creates a new [PaymentRequestEvent] object instance.",
-      "paymentrequestid": "The **`paymentRequestId`** read-only property of the\n[PaymentRequestEvent] interface returns the ID of the\n[PaymentRequest] object.",
-      "paymentrequestorigin": "The **`paymentRequestOrigin`** read-only property of the\n[PaymentRequestEvent] interface returns the origin where the\n[PaymentRequest] object was initialized.",
-      "respondwith": "The **`respondWith()`** method of the [PaymentRequestEvent] interface prevents the default event handling and allows you to provide a `Promise` for a [PaymentResponse] object yourself.",
-      "toporigin": "The **`topOrigin`** read-only property of the\n[PaymentRequestEvent] interface returns the top-level payee origin where\nthe [PaymentRequest] object was initialized.",
-      "total": "The **`total`** read-only property of the [PaymentRequestEvent] interface returns a\n`PaymentCurrencyAmount` object containing the total amount being requested for payment."
+      "changepaymentmethod": "@AvailableInWorkers(\"service\")\n\nThe **`changePaymentMethod()`** method of the [PaymentRequestEvent] interface is used by the payment handler to get an updated total, given such payment method details as the billing address.\n\nWhen this method is invoked, a [PaymentMethodChangeEvent] is fired.",
+      "instrumentkey": "@AvailableInWorkers(\"service\")\n\nThe **`instrumentKey`** read-only property of the\n[PaymentRequestEvent] interface returns a\n`PaymentInstrument` object reflecting the payment instrument selected by\nthe user or an empty string if the user has not registered or chosen a payment\ninstrument.",
+      "methoddata": "@AvailableInWorkers(\"service\")\n\nThe **`methodData`** read-only property of the\n[PaymentRequestEvent] interface returns an array of\n`PaymentMethodData` objects containing payment method identifiers for the\npayment methods that the website accepts and any associated payment method-specific\ndata.",
+      "modifiers": "@AvailableInWorkers(\"service\")\n\nThe **`modifiers`** read-only property of the\n[PaymentRequestEvent] interface returns an `Array` of `PaymentDetailsModifier` objects containing modifiers for payment details.",
+      "openwindow": "@AvailableInWorkers(\"service\")\n\nThe **`openWindow()`** method of the [PaymentRequestEvent] interface opens the specified URL in a new window, only if the given URL is on the same origin as the calling page. It returns a `Promise` that resolves with a reference to a [WindowClient].",
+      "paymentrequestevent": "@AvailableInWorkers(\"service\")\n\nThe **`PaymentRequestEvent`** constructor creates a new [PaymentRequestEvent] object instance.",
+      "paymentrequestid": "@AvailableInWorkers(\"service\")\n\nThe **`paymentRequestId`** read-only property of the\n[PaymentRequestEvent] interface returns the ID of the\n[PaymentRequest] object.",
+      "paymentrequestorigin": "@AvailableInWorkers(\"service\")\n\nThe **`paymentRequestOrigin`** read-only property of the\n[PaymentRequestEvent] interface returns the origin where the\n[PaymentRequest] object was initialized.",
+      "respondwith": "@AvailableInWorkers(\"service\")\n\nThe **`respondWith()`** method of the [PaymentRequestEvent] interface prevents the default event handling and allows you to provide a `Promise` for a [PaymentResponse] object yourself.",
+      "toporigin": "@AvailableInWorkers(\"service\")\n\nThe **`topOrigin`** read-only property of the\n[PaymentRequestEvent] interface returns the top-level payee origin where\nthe [PaymentRequest] object was initialized.",
+      "total": "@AvailableInWorkers(\"service\")\n\nThe **`total`** read-only property of the [PaymentRequestEvent] interface returns a\n`PaymentCurrencyAmount` object containing the total amount being requested for payment."
     }
   },
   "PaymentRequestUpdateEvent": {
@@ -5535,7 +5620,7 @@
     "docs": "The **`Pbkdf2Params`** dictionary of the [Web Crypto API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Crypto_API) represents the object that should be passed as the `algorithm` parameter into [SubtleCrypto.deriveKey], when using the [PBKDF2](/en-US/docs/Web/API/SubtleCrypto/deriveKey#pbkdf2) algorithm."
   },
   "Performance": {
-    "docs": "The **`Performance`** interface provides access to performance-related information for the current page.\n\nAn object of this type can be obtained by calling `window.performance` or `self.performance` in workers. Note that Performance entries are per context. If you create a mark on the main thread (or other worker), you cannot see it in a worker thread, and vice versa. See [`self.performance`](https://developer.mozilla.org/en-US/docs/Web/API/performance_property) for which APIs are available in window and worker contexts.",
+    "docs": "The **`Performance`** interface provides access to performance-related information for the current page.\n\nPerformance entries are specific to each execution context. You can access performance information for code running in a window via [Window.performance], and for code running in a worker via [WorkerGlobalScope.performance].",
     "properties": {
       "clearmarks": "The **`clearMarks()`** method removes all or specific [PerformanceMark] objects from the browser's performance timeline.",
       "clearmeasures": "The **`clearMeasures()`** method removes all or specific [PerformanceMeasure] objects from the browser's performance timeline.",
@@ -5573,7 +5658,7 @@
     }
   },
   "PerformanceEntry": {
-    "docs": "The **`PerformanceEntry`** object encapsulates a single performance metric that is part of the browser's performance timeline.\n\nThe Performance API offers built-in metrics which are specialized subclasses of `PerformanceEntry`. This includes entries for resource loading, event timing,  (FID), and more.\n\nA performance entry can also be created by calling the [Performance.mark] or [Performance.measure] methods at an explicit point in an application. This allows you to add your own metrics to the performance timeline.\n\nThe `PerformanceEntry` instances will always be one of the following subclasses:\n\n- [LargestContentfulPaint]\n- [LayoutShift]\n- [PerformanceEventTiming]\n- [PerformanceLongTaskTiming]\n- [PerformanceMark]\n- [PerformanceMeasure]\n- [PerformanceNavigationTiming]\n- [PerformancePaintTiming]\n- [PerformanceResourceTiming]\n- [PerformanceServerTiming]\n- [TaskAttributionTiming]\n- [VisibilityStateEntry]",
+    "docs": "The **`PerformanceEntry`** object encapsulates a single performance metric that is part of the browser's performance timeline.\n\nThe Performance API offers built-in metrics which are specialized subclasses of `PerformanceEntry`. This includes entries for resource loading, event timing,  (FID), and more.\n\nA performance entry can also be created by calling the [Performance.mark] or [Performance.measure] methods at an explicit point in an application. This allows you to add your own metrics to the performance timeline.\n\nThe `PerformanceEntry` instances will always be one of the following subclasses:\n\n- [LargestContentfulPaint]\n- [LayoutShift]\n- [PerformanceEventTiming]\n- [PerformanceLongAnimationFrameTiming]\n- [PerformanceLongTaskTiming]\n- [PerformanceMark]\n- [PerformanceMeasure]\n- [PerformanceNavigationTiming]\n- [PerformancePaintTiming]\n- [PerformanceResourceTiming]\n- [PerformanceScriptTiming]\n- [PerformanceServerTiming]\n- [TaskAttributionTiming]\n- [VisibilityStateEntry]",
     "properties": {
       "duration": "The read-only **`duration`** property returns a  that is the duration of the . The meaning of this property depends on the value of this entry's [PerformanceEntry.entryType].",
       "entrytype": "The read-only **`entryType`** property returns a string representing the type of performance metric that this entry represents.\n\nAll supported `entryTypes` are available using the static property [PerformanceObserver.supportedEntryTypes_static].",
@@ -5593,6 +5678,17 @@
       "tojson": "The **`toJSON()`** method of the [PerformanceEventTiming] interface is a ; it returns a JSON representation of the [PerformanceEventTiming] object."
     }
   },
+  "PerformanceLongAnimationFrameTiming": {
+    "docs": "The **`PerformanceLongAnimationFrameTiming`** interface is specified in the Long Animation Frames API and provides metrics on long animation frames (LoAFs) that occupy rendering and block other tasks from being executed.",
+    "properties": {
+      "blockingduration": "The **`blockingDuration`** read-only property of the [PerformanceLongAnimationFrameTiming] interface returns a [DOMHighResTimeStamp] indicating the total time in milliseconds for which the main thread was blocked from responding to high priority tasks, such as user input.",
+      "firstuieventtimestamp": "The **`firstUIEventTimestamp`** read-only property of the [PerformanceLongAnimationFrameTiming] interface returns a [DOMHighResTimeStamp] indicating the time of the first UI event — such as a mouse or keyboard event — to be queued during the current animation frame.",
+      "renderstart": "The **`renderStart`** read-only property of the [PerformanceLongAnimationFrameTiming] interface returns a [DOMHighResTimeStamp] indicating the start time of the rendering cycle, which includes [Window.requestAnimationFrame] callbacks, style and layout calculation, [ResizeObserver] callbacks, and [IntersectionObserver] callbacks.",
+      "scripts": "The **`scripts`** read-only property of the [PerformanceLongAnimationFrameTiming] interface returns an array of [PerformanceScriptTiming] objects.\n\nScript attribution is provided only for scripts running in the main thread of a page, including same-origin `<iframe>`s. However, cross-origin `<iframe>`s, [web workers](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API), [service workers](https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API), and [extension](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions) code will not have script attribution in long animation frames, even if they impact the duration of one.",
+      "styleandlayoutstart": "The **`styleAndLayoutStart`** read-only property of the [PerformanceLongAnimationFrameTiming] interface returns a [DOMHighResTimeStamp] indicating the beginning of the time period spent in style and layout calculations for the current animation frame.",
+      "tojson": "The **`toJSON()`** method of the [PerformanceLongAnimationFrameTiming] interface is a ; it returns a JSON representation of the `PerformanceLongAnimationFrameTiming` object."
+    }
+  },
   "PerformanceLongTaskTiming": {
     "docs": "The **`PerformanceLongTaskTiming`** interface provides information about tasks that occupy the UI thread for 50 milliseconds or more.",
     "properties": {
@@ -5632,6 +5728,7 @@
       "dominteractive": "The **`domInteractive`** read-only property returns a [DOMHighResTimeStamp] representing the time immediately before the user agent sets the document's [`readyState`](https://developer.mozilla.org/en-US/docs/Web/API/Document/readyState) to `\"interactive\"`.\n\n> **Note:** This property is **not**  (TTI). This property refers to the time when DOM construction is finished and interaction to it from JavaScript is possible. See also the `interactive` state of [Document.readyState] which corresponds to this property.\n\nMeasuring DOM processing time may not be consequential unless your site has a very large HTML source to a construct a Document Object Model from.\n\nIf there is no parser-blocking JavaScript then the [`DOMContentLoaded`](https://developer.mozilla.org/en-US/docs/Web/API/Document/DOMContentLoaded_event) event (see [`domContentLoadedEventStart`](https://developer.mozilla.org/en-US/docs/Web/API/PerformanceNavigationTiming/domContentLoadedEventStart) for the timestamp) will fire immediately after `domInteractive`.",
       "loadeventend": "The **`loadEventEnd`** read-only property returns a [DOMHighResTimeStamp] representing the time immediately after the current document's [`load`](https://developer.mozilla.org/en-US/docs/Web/API/Window/load_event) event handler completes.",
       "loadeventstart": "The **`loadEventStart`** read-only property returns a [DOMHighResTimeStamp] representing the time immediately before the current document's [`load`](https://developer.mozilla.org/en-US/docs/Web/API/Window/load_event) event handler starts.",
+      "notrestoredreasons": "The **`notRestoredReasons`** read-only property of the [PerformanceNavigationTiming] interface returns a [NotRestoredReasons] object providing report data on reasons why the current document was blocked from using the back/forward cache () on navigation.",
       "redirectcount": "The **`redirectCount`** read-only property returns a number representing the number of redirects since the last non-redirect navigation in the current browsing context.\n\nThe higher the number of redirects on a page, the longer the page load time. To improve the performance of your web page, avoid multiple redirects.\n\nThe [PerformanceResourceTiming.redirectStart] and [PerformanceResourceTiming.redirectEnd] properties can be used to measure redirection time. Note that they will return `0` for cross-origin redirects.\n\nNote that client side redirects, such as `<meta http-equiv=\"refresh\" content=\"0; url=https://example.com/\">` are not considered here.",
       "tojson": "The **`toJSON()`** method of the [PerformanceNavigationTiming] interface is a ; it returns a JSON representation of the [PerformanceNavigationTiming] object.",
       "type": "The **`type`** read-only property returns the type of navigation.\n\nYou can use this property to categorize your navigation timing data as each of these types will have different performance characteristics. Users going back and forth might experience a faster site than users performing navigation for the first time or submitting forms, etc.\n\nFor example, if your site provides new content frequently, you might want to refresh that content using [Fetch](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API) or similar and avoid users having to hit reload for the entire page all the time. The `\"reload\"` type can help you find pages that are reloaded frequently.",
@@ -5688,6 +5785,22 @@
       "workerstart": "The **`workerStart`** read-only property of the [PerformanceResourceTiming] interface returns a\n[DOMHighResTimeStamp] immediately before dispatching the [FetchEvent] if a Service Worker thread is already running, or immediately before starting the Service Worker thread if it is not already running. If the resource is not intercepted by a Service Worker the property will always return 0."
     }
   },
+  "PerformanceScriptTiming": {
+    "docs": "The **`PerformanceScriptTiming`** interface is specified in the Long Animation Frames API and provides metrics on individual scripts that contribute to long animation frames (LoAFs).",
+    "properties": {
+      "executionstart": "The **`executionStart`** read-only property of the [PerformanceScriptTiming] interface returns a [DOMHighResTimeStamp] indicating the time when the script compilation finished and execution started.",
+      "forcedstyleandlayoutduration": "The **`forcedStyleAndLayoutDuration`** read-only property of the [PerformanceScriptTiming] interface returns a [DOMHighResTimeStamp] indicating the total time spent, in milliseconds, by the script processing forced layout/style. See [Avoid layout thrashing](https://web.dev/articles/avoid-large-complex-layouts-and-layout-thrashing#avoid_layout_thrashing) to understand what causes this.",
+      "invoker": "The **`invoker`** read-only property of the [PerformanceScriptTiming] interface returns a string value indicating the identity of the feature that, when invoked, ran the script.",
+      "invokertype": "The **`invokerType`** read-only property of the [PerformanceScriptTiming] interface returns a string value indicating the type of feature that, when invoked, ran the script.",
+      "pauseduration": "The **`pauseDuration`** read-only property of the [PerformanceScriptTiming] interface returns a [DOMHighResTimeStamp] indicating the total time, in milliseconds, spent by the script on \"pausing\" synchronous operations (for example, [Window.alert] calls or synchronous [XMLHttpRequest]s).",
+      "sourcecharposition": "The **`sourceCharPosition`** read-only property of the [PerformanceScriptTiming] interface returns a number representing the script character position of the script feature that contributed to the long animation frame (LoAF).\n\nIt is important to note that the reported function location will be the \"entry point\" of the script, that is, the top level of the stack, not any specific slow sub-function. See [PerformanceScriptTiming.sourceFunctionName] for more discussion around this.",
+      "sourcefunctionname": "The **`sourceFunctionName`** read-only property of the [PerformanceScriptTiming] interface returns a string representing the name of the function that contributed to the long animation frame (LoAF).\n\nIt is important to note that the reported function name will be the \"entry point\" of the script, that is, the top level of the stack, not any specific slow sub-function.\n\nFor example, if an event handler calls a top-level function, which then calls a slow sub-function, the `source*` fields will report the name and location of the top-level function, not the slow sub-function — the function that was passed to the platform API is always the one reported. This is because of performance reasons; a full stack trace is costly.\n\nIn the following snippet:\n\n```js\nsetTimeout(function lib_func() {\n  slow_function();\n});\n```\n\n`sourceFunctionName` would report `lib_func`, not `slow_function`.",
+      "sourceurl": "The **`sourceURL`** read-only property of the [PerformanceScriptTiming] interface returns a string representing the URL of the script.\n\nIt is important to note that the reported function location will be the \"entry point\" of the script, that is, the top level of the stack, not any specific slow sub-function. See [PerformanceScriptTiming.sourceFunctionName] for more discussion around this.",
+      "tojson": "The **`toJSON()`** method of the [PerformanceScriptTiming] interface is a ; it returns a JSON representation of the `PerformanceScriptTiming` object.",
+      "window": "The **`window`** read-only property of the [PerformanceScriptTiming] interface returns a reference to a [Window] object representing the `window` of the container (i.e., either the top-level document or an `iframe`) in which the long animation frame (LoAF)-causing script was executed.",
+      "windowattribution": "The **`windowAttribution`** read-only property of the [PerformanceScriptTiming] interface returns an enumerated value describing the relationship of the container (i.e., either the top-level document or an `iframe`) in which the long animation frame (LoAF)-causing script was executed, relative to the window running the current document."
+    }
+  },
   "PerformanceServerTiming": {
     "docs": "The **`PerformanceServerTiming`** interface surfaces server metrics that are sent with the response in the  HTTP header.\n\nThis interface is restricted to the same origin, but you can use the  header to specify the domains that are allowed to access the server metrics. Note that this interface is only available in secure contexts (HTTPS) in some browsers.",
     "properties": {
@@ -5712,7 +5825,6 @@
       "fetchstart": "> **Warning:** This interface of this property is deprecated in the [Navigation Timing Level 2 specification](https://w3c.github.io/navigation-timing/#obsolete). Please use the [PerformanceNavigationTiming]\n> interface instead.\n\nThe legacy\n**`PerformanceTiming.fetchStart`**\nread-only property returns an `unsigned long long` representing the moment,\nin milliseconds since the UNIX epoch, the browser is ready to fetch the document using\nan HTTP request. This moment is _before_ the check to any application cache.",
       "loadeventend": "> **Warning:** This interface of this property is deprecated in the [Navigation Timing Level 2 specification](https://w3c.github.io/navigation-timing/#obsolete). Please use the [PerformanceNavigationTiming]\n> interface's [PerformanceNavigationTiming.loadEventEnd] read-only property instead.\n\nThe legacy\n**`PerformanceTiming.loadEventEnd`**\nread-only property returns an `unsigned long long` representing the moment,\nin milliseconds since the UNIX epoch, when the [Window.load_event] event handler\nterminated, that is when the load event is completed. If this event has not yet been\nsent, or is not yet completed, it returns `0.`",
       "loadeventstart": "> **Warning:** This interface of this property is deprecated in the [Navigation Timing Level 2 specification](https://w3c.github.io/navigation-timing/#obsolete). Please use the [PerformanceNavigationTiming]\n> interface's [PerformanceNavigationTiming.loadEventStart] read-only property instead.\n\nThe legacy\n**`PerformanceTiming.loadEventStart`**\nread-only property returns an `unsigned long long` representing the moment,\nin milliseconds since the UNIX epoch, when the [Window.load_event] event was sent for the\ncurrent document. If this event has not yet been sent, it returns `0.`",
-      "msfirstpaint": "**`msFirstPaint`** is a read-only property which gets the time\nwhen the document loaded by the window object began to be displayed to the user.\n\nPut another way, `msFirstPaint` utilizes the browser to measure when the\nfirst content completes being painted in the window. It is available from JavaScript and\ncan be reported from the field.\n\nThis proprietary property is specific to Internet Explorer and Microsoft Edge.",
       "navigationstart": "> **Warning:** This interface of this property is deprecated in the [Navigation Timing Level 2 specification](https://w3c.github.io/navigation-timing/#obsolete).\n> Please use the [PerformanceNavigationTiming] interface instead.\n\nThe legacy\n**`PerformanceTiming.navigationStart`**\nread-only property returns an `unsigned long long` representing the moment,\nin milliseconds since the UNIX epoch, right after the prompt for unload terminates on\nthe previous document in the same browsing context. If there is no previous document,\nthis value will be the same as [PerformanceTiming.fetchStart].",
       "redirectend": "> **Warning:** This interface of this property is deprecated in the [Navigation Timing Level 2 specification](https://w3c.github.io/navigation-timing/#obsolete). Please use the [PerformanceNavigationTiming]\n> interface instead.\n\nThe legacy\n**`PerformanceTiming.redirectEnd`**\nread-only property returns an `unsigned long long` representing the moment,\nin milliseconds since the UNIX epoch, the last HTTP redirect is completed, that is when\nthe last byte of the HTTP response has been received. If there is no redirect, or if one\nof the redirect is not of the same origin, the value returned is `0`.",
       "redirectstart": "> **Warning:** This interface of this property is deprecated in the [Navigation Timing Level 2 specification](https://w3c.github.io/navigation-timing/#obsolete). Please use the [PerformanceNavigationTiming]\n> interface instead.\n\nThe legacy\n**`PerformanceTiming.redirectStart`**\nread-only property returns an `unsigned long long` representing the moment,\nin milliseconds since the UNIX epoch, the first HTTP redirect starts. If there is no\nredirect, or if one of the redirect is not of the same origin, the value returned is\n`0`.",
@@ -5726,10 +5838,10 @@
     }
   },
   "PeriodicSyncEvent": {
-    "docs": "The **`PeriodicSyncEvent`** interface of the [Web Periodic Background Synchronization API] provides a way to run tasks in the service worker with network connectivity.\n\nAn instance of this event is passed to the [ServiceWorkerGlobalScope.periodicsync_event] handler. This happens periodically, at an interval greater than or equal to that set in the [PeriodicSyncManager.register] method. Other implementation-specific factors such as the user's engagement with the site decide the actual interval.",
+    "docs": "@AvailableInWorkers(\"service\")\n\nThe **`PeriodicSyncEvent`** interface of the [Web Periodic Background Synchronization API] provides a way to run tasks in the service worker with network connectivity.\n\nAn instance of this event is passed to the [ServiceWorkerGlobalScope.periodicsync_event] handler. This happens periodically, at an interval greater than or equal to that set in the [PeriodicSyncManager.register] method. Other implementation-specific factors such as the user's engagement with the site decide the actual interval.",
     "properties": {
-      "periodicsyncevent": "The **`PeriodicSyncEvent()`** constructor\ncreates a new [PeriodicSyncEvent] object. This constructor is not typically\nused. The browser creates these objects itself and provides them to\n[ServiceWorkerGlobalScope.periodicsync_event] callback.",
-      "tag": "The **`tag`** read-only property of the\n[PeriodicSyncEvent] interface returns the developer-defined identifier for\nthe [PeriodicSyncEvent]. This is specified when calling the\n[PeriodicSyncManager.register] method of the\n[PeriodicSyncManager] interface. Multiple tags can be used by the web app\nto run different periodic tasks at different frequencies."
+      "periodicsyncevent": "@AvailableInWorkers(\"service\")\n\nThe **`PeriodicSyncEvent()`** constructor\ncreates a new [PeriodicSyncEvent] object. This constructor is not typically\nused. The browser creates these objects itself and provides them to\n[ServiceWorkerGlobalScope.periodicsync_event] callback.",
+      "tag": "@AvailableInWorkers(\"service\")\n\nThe **`tag`** read-only property of the\n[PeriodicSyncEvent] interface returns the developer-defined identifier for\nthe [PeriodicSyncEvent]. This is specified when calling the\n[PeriodicSyncManager.register] method of the\n[PeriodicSyncManager] interface. Multiple tags can be used by the web app\nto run different periodic tasks at different frequencies."
     }
   },
   "PeriodicSyncManager": {
@@ -5755,10 +5867,10 @@
     }
   },
   "Permissions": {
-    "docs": "The Permissions interface of the [Permissions API](https://developer.mozilla.org/en-US/docs/Web/API/Permissions_API) provides the core Permission API functionality, such as methods for querying and revoking permissions",
+    "docs": "The **`Permissions`** interface of the [Permissions API](https://developer.mozilla.org/en-US/docs/Web/API/Permissions_API) provides the core Permission API functionality, such as methods for querying and revoking permissions",
     "properties": {
-      "query": "The **`Permissions.query()`** method of the [Permissions] interface returns the state of a user permission on the global scope.",
-      "revoke": "The **`Permissions.revoke()`** method of the\n[Permissions] interface reverts a currently set permission back to its\ndefault state, which is usually `prompt`.\nThis method is called on the global [Permissions] object\n[navigator.permissions]."
+      "query": "The **`query()`** method of the [Permissions] interface returns the state of a user permission on the global scope.",
+      "revoke": "The **`revoke()`** method of the\n[Permissions] interface reverts a currently set permission back to its\ndefault state, which is usually `prompt`.\nThis method is called on the global [Permissions] object\n[navigator.permissions]."
     }
   },
   "PictureInPictureEvent": {
@@ -5870,6 +5982,26 @@
       "start": "The **`start()`** property of the [PresentationRequest] interface returns a `Promise` that resolves with a [PresentationConnection] after the user agent prompts the user to select a display and grant permission to use that display."
     }
   },
+  "PressureObserver": {
+    "docs": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\nThe **`PressureObserver`** interface is part of the [Compute Pressure API](https://developer.mozilla.org/en-US/docs/Web/API/Compute_Pressure_API) and is used to observe the pressure changes of system resources such as the CPU.",
+    "properties": {
+      "disconnect": "The **`disconnect()`** method of the [PressureObserver] interface stops the pressure observer callback from receiving pressure records from all sources.",
+      "knownsources_static": "The static **`knownSources`** read-only property of the [PressureObserver] interface returns an array of the [PressureRecord.source] values supported by the user agent in alphabetical order.\n\n> **Note:** The list of supported sources varies per browser, operating system, and hardware, and is evolving. This property is merely a hint about source types the user agents supports. Call [PressureObserver.observe] and check for a `NotSupportedError` to see if pressure observation is possible.",
+      "observe": "The **`observe()`** method of the [PressureObserver] interface tells the pressure observer to start observing pressure changes. After this method is called, the observer will call its callback function when a pressure record for the specified `source` is observed.\n\nWhen a matching [PressureRecord] is obtained, the pressure observer's callback function is invoked.",
+      "pressureobserver": "The **`PressureObserver()`** constructor creates a new [PressureObserver] object to watch for changes to pressure changes of system resources such as the CPU.",
+      "takerecords": "The **`takeRecords()`** method of the [PressureObserver] interface returns the current list of pressure records stored in the pressure observer, emptying it out.\n\nIt is useful when you want to a stop observing a source but would like to be sure to get any records that have not yet been passed into the observer callback.",
+      "unobserve": "The **`unobserve()`** method of the [PressureObserver] interface stops the pressure observer callback from receiving pressure records from the specified source."
+    }
+  },
+  "PressureRecord": {
+    "docs": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\nThe **`PressureRecord`** interface is part of the [Compute Pressure API](https://developer.mozilla.org/en-US/docs/Web/API/Compute_Pressure_API) and describes the pressure trend of a source at a specific moment of transition.",
+    "properties": {
+      "source": "The read-only **`source`** property is a string indicating the origin source from which the record is coming.",
+      "state": "The read-only **`state`** property is a string indicating the pressure state recorded.",
+      "time": "The read-only **`time`** property returns the  recorded for a [PressureRecord]. It corresponds to the time the data was obtained from the system relative to the [time origin of the global object](https://developer.mozilla.org/en-US/docs/Web/API/Performance/timeOrigin) in which the [PressureObserver] generated the notification.",
+      "tojson": "The **`toJSON()`** method is a ; it returns a JSON representation of the [PressureRecord] object."
+    }
+  },
   "ProcessingInstruction": {
     "docs": "The **`ProcessingInstruction`** interface represents a [processing instruction](https://www.w3.org/TR/xml/#sec-pi); that is, a [Node] which embeds an instruction targeting a specific application but that can be ignored by any other applications which don't recognize the instruction.\n\n> **Warning:** `ProcessingInstruction` nodes are only supported in XML documents, not in HTML documents. In these, a process instruction will be considered as a comment and be represented as a [Comment] object in the tree.\n\nA processing instruction may be different than the [XML declaration](/en-US/docs/Web/XML/XML_introduction#xml_declaration).\n\n> **Note:** User-defined processing instructions cannot begin with \"`xml`\", as `xml`-prefixed processing-instruction target names are reserved by the XML specification for particular, standard uses (see, for example, `<?xml-stylesheet ?>`.\n\nFor example:\n\n```html\n<?xml version=\"1.0\"?>\n```\n\nis a processing instruction whose `target` is `xml`.",
     "properties": {
@@ -5881,9 +6013,9 @@
     "docs": "The **`ProgressEvent`** interface represents events measuring progress of an underlying process, like an HTTP request (for an `XMLHttpRequest`, or the loading of the underlying resource of an `img`, `audio`, `video`, `style` or `link`).",
     "properties": {
       "lengthcomputable": "The\n**`ProgressEvent.lengthComputable`** read-only property is a\nboolean flag indicating if the resource concerned by the\n[ProgressEvent] has a length that can be calculated. If not, the\n[ProgressEvent.total] property has no significant value.",
-      "loaded": "The **`ProgressEvent.loaded`** read-only property is an integer\nrepresenting the amount of work already performed by the underlying process. The ratio\nof work done can be calculated with the property and `ProgressEvent.total`.\nWhen downloading a resource using HTTP, this value is specified in bytes (not bits), and only represents the part of the content\nitself, not headers and other overhead.",
+      "loaded": "The **`ProgressEvent.loaded`** read-only property is a 64-bit unsigned integer\nindicating the size, in bytes, of the data already transmitted or processed. The ratio can be calculated by dividing `ProgressEvent.total` by the value of this property.\nWhen downloading a resource using HTTP, this only counts the body of the HTTP message, and doesn't include headers and other overhead.\n\nNote that for compressed requests of unknown total size, `loaded` might contain the size of the compressed, or decompressed, data, depending on the browser. As of 2024, it contains the size of the compressed data in Firefox, and the size of the uncompressed data in Chrome.",
       "progressevent": "The **`ProgressEvent()`** constructor returns a new [ProgressEvent] object, representing the current completion of a long process.",
-      "total": "The **`ProgressEvent.total`** read-only property is an unsigned\n64-bit integer value indicating the total size of the data being processed or\ntransmitted. In the case of an HTTP transmission, this is the size of the body of the\nmessage (the `Content-Length`), and does not include headers and other\noverhead.\n\nIf the event's [ProgressEvent.lengthComputable]\nproperty is `false`, this value is meaningless and should be ignored."
+      "total": "The **`ProgressEvent.total`** read-only property is a 64-bit unsigned integer\nindicating the total size, in bytes, of the data being transmitted or processed.\n\nWhen downloading a resource using HTTP, this value is taken from the `Content-Length` response header. It only counts the body of the HTTP message, and doesn't include headers and other overhead.\n\nIf the event's [ProgressEvent.lengthComputable]\nproperty is `false`, this value is meaningless and should be ignored."
     }
   },
   "PromiseRejectionEvent": {
@@ -5902,18 +6034,21 @@
       "id": "The **`id`** read-only property of the\n[PublicKeyCredential] interface is a string, inherited\nfrom [Credential], which represents the identifier of the current\n`PublicKeyCredential` instance.\n\nThis property is a [base64url encoded](https://developer.mozilla.org/en-US/docs/Glossary/Base64) version of [PublicKeyCredential.rawId].\n\n> **Note:** This property may only be used in top-level contexts and will\n> not be available in an `iframe` for example.",
       "isconditionalmediationavailable": "The **`isConditionalMediationAvailable()`** static method of the [PublicKeyCredential] interface returns a `Promise` which resolves to `true` if conditional mediation is available.\n\nConditional mediation, if available, results in any discovered credentials being presented to the user in a non-modal dialog box along with an indication of the origin requesting credentials. This is requested by including `mediation: 'conditional'` in your `get()` call. In practice, this means autofilling available credentials; you need to include `autocomplete=\"webauthn\"` on your form fields so that they will show the WebAuthn sign-in options.\n\nA conditional `get()` call does not show the browser UI and remains pending until the user picks an account to sign-in with from available autofill suggestions:\n\n- If the user makes a gesture outside of the dialog, it closes without resolving or rejecting the Promise and without causing a user-visible error condition.\n- If the user selects a credential, that credential is returned to the caller.\n\nThe prevent silent access flag (see [CredentialsContainer.preventSilentAccess]) is treated as being `true` regardless of its actual value: the conditional behavior always involves user mediation of some sort if applicable credentials are discovered.\n\n> **Note:** If no credentials are discovered, the non-modal dialog will not be visible, and the user agent can prompt the user to take action in a way that depends on the type of credential (for example, to insert a device containing credentials).",
       "isuserverifyingplatformauthenticatoravailable_static": "The **`isUserVerifyingPlatformAuthenticatorAvailable()`** static method of the [PublicKeyCredential] interface returns a `Promise` which resolves to `true` if a user-verifying platform authenticator is present.\n\nA user-verifying platform authenticator is a kind of multi-factor authenticator that is part of the client device (it is generally not removable) and that involves an action from the user in order to identify them. Common user-verifying platform authenticators include:\n\n- Touch ID or Face ID (macOS and iOS)\n- Windows Hello (Windows)\n- Device unlock (fingerprint, face, PIN, etc.) on Android\n\n> **Note:** This method may only be used in top-level contexts and will not be available in an `iframe` for example.",
-      "parsecreationoptionsfromjson_static": "The **`parseCreationOptionsFromJSON()`** static method of the [PublicKeyCredential] interface converts a  into its corresponding [`publicKey` create credentials options object structure](/en-US/docs/Web/API/CredentialsContainer/create#publickey_object_structure).\n\nThe method is a convenience function for converting credential options information provided by a relying party server to the form that a web app can use to [create a credential](/en-US/docs/Web/API/Web_Authentication_API#creating_a_key_pair_and_registering_a_user).",
+      "parsecreationoptionsfromjson_static": "The **`parseCreationOptionsFromJSON()`** static method of the [PublicKeyCredential] interface creates a [PublicKeyCredentialCreationOptions] object from a JSON representation of its properties.\n\nThe method is a convenience function for converting credential options information provided by a relying party server to the form that a web app can use to [create a credential](/en-US/docs/Web/API/Web_Authentication_API#creating_a_key_pair_and_registering_a_user).",
       "parserequestoptionsfromjson_static": "The **`parseRequestOptionsFromJSON()`** static method of the [PublicKeyCredential] interface converts a  into its corresponding [`publicKey` request credentials options object structure](/en-US/docs/Web/API/CredentialsContainer/get#publickey_object_structure).\n\nThe method is a convenience function for converting information provided by a relying server to a web app in order to request an existing credential.",
       "rawid": "The **`rawId`** read-only property of the\n[PublicKeyCredential] interface is an `ArrayBuffer` object\ncontaining the identifier of the credentials.\n\nThe [PublicKeyCredential.id] property is a [base64url encoded](https://developer.mozilla.org/en-US/docs/Glossary/Base64) version of this identifier.\n\n> **Note:** This property may only be used in top-level contexts and will\n> not be available in an `iframe` for example.",
       "response": "The **`response`** read-only property of the\n[PublicKeyCredential] interface is an [AuthenticatorResponse]\nobject which is sent from the authenticator to the user agent for the creation/fetching\nof credentials. The information contained in this response will be used by the relying\nparty's server to verify the demand is legitimate.\n\nAn `AuthenticatorResponse` is either:\n\n- an [AuthenticatorAttestationResponse] (when the\n  `PublicKeyCredential` is created via\n  [CredentialsContainer.create])\n- an [AuthenticatorAssertionResponse] (when the\n  `PublicKeyCredential` is obtained via\n  [CredentialsContainer.get]).\n\nIn order to validate the _creation_ of credentials, a relying party's server\nneeds both:\n\n- this response\n- the extensions of the client (given by\n  [PublicKeyCredential.getClientExtensionResults]) to validate the\n  demand.\n\n> **Note:** When validating the fetching of existing credentials, the\n> whole `PublicKeyCredential` object and the client extensions are necessary\n> for the relying party's server.\n\n> **Note:** This property may only be used in top-level contexts and will\n> not be available in an `iframe` for example.",
       "tojson": "The **`toJSON()`** method of the [PublicKeyCredential] interface returns a  of a [PublicKeyCredential].\n\nThe properties of the returned object depend on whether the credential is returned by [`navigator.credentials.create()`](https://developer.mozilla.org/en-US/docs/Web/API/CredentialsContainer/create) when [creating a key pair and registering a user](/en-US/docs/Web/API/Web_Authentication_API#creating_a_key_pair_and_registering_a_user), or [`navigator.credentials.get()`](https://developer.mozilla.org/en-US/docs/Web/API/CredentialsContainer/get) when [authenticating a user](/en-US/docs/Web/API/Web_Authentication_API#authenticating_a_user).\n\nThis method is automatically invoked when web app code calls [`JSON.stringify()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify) to serialize a [PublicKeyCredential] so that it can be sent to relying party server when registering or authenticating a user.\nIt not intended to be called directly in web app code."
     }
   },
+  "PublicKeyCredentialCreationOptions": {
+    "docs": "The **`PublicKeyCredentialCreationOptions`** dictionary represents the object passed to [CredentialsContainer.create] as the value of the `publicKey` option: that is, when using `create()` to create a public key credential using the [Web Authentication API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Authentication_API)."
+  },
   "PushEvent": {
-    "docs": "The **`PushEvent`** interface of the [Push API](https://developer.mozilla.org/en-US/docs/Web/API/Push_API) represents a push message that has been received. This event is sent to the [global scope](https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerGlobalScope) of a [ServiceWorker]. It contains the information sent from an application server to a [PushSubscription].",
+    "docs": "@AvailableInWorkers(\"service\")\n\nThe **`PushEvent`** interface of the [Push API](https://developer.mozilla.org/en-US/docs/Web/API/Push_API) represents a push message that has been received. This event is sent to the [global scope](https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerGlobalScope) of a [ServiceWorker]. It contains the information sent from an application server to a [PushSubscription].",
     "properties": {
-      "data": "The `data` read-only property of the **`PushEvent`** interface returns a reference to a [PushMessageData] object containing data sent to the [PushSubscription].",
-      "pushevent": "The **`PushEvent()`** constructor creates a new\n[PushEvent] object. Note that this constructor is exposed only to a\nservice worker context."
+      "data": "@AvailableInWorkers(\"service\")\n\nThe `data` read-only property of the **`PushEvent`** interface returns a reference to a [PushMessageData] object containing data sent to the [PushSubscription].",
+      "pushevent": "@AvailableInWorkers(\"service\")\n\nThe **`PushEvent()`** constructor creates a new\n[PushEvent] object. Note that this constructor is exposed only to a\nservice worker context."
     }
   },
   "PushManager": {
@@ -5930,12 +6065,12 @@
     }
   },
   "PushMessageData": {
-    "docs": "The **`PushMessageData`** interface of the [Push API](https://developer.mozilla.org/en-US/docs/Web/API/Push_API) provides methods which let you retrieve the push data sent by a server in various formats.\n\nUnlike the similar methods in the [Fetch API](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API), which only allow the method to be invoked once, these methods can be called multiple times.\n\nMessages received through the Push API are sent encrypted by push services and then automatically decrypted by browsers before they are made accessible through the methods of the `PushMessageData` interface.",
+    "docs": "@AvailableInWorkers(\"service\")\n\nThe **`PushMessageData`** interface of the [Push API](https://developer.mozilla.org/en-US/docs/Web/API/Push_API) provides methods which let you retrieve the push data sent by a server in various formats.\n\nUnlike the similar methods in the [Fetch API](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API), which only allow the method to be invoked once, these methods can be called multiple times.\n\nMessages received through the Push API are sent encrypted by push services and then automatically decrypted by browsers before they are made accessible through the methods of the `PushMessageData` interface.",
     "properties": {
-      "arraybuffer": "The **`arrayBuffer()`** method of the [PushMessageData] interface extracts push message data as an `ArrayBuffer` object.",
-      "blob": "The **`blob()`** method of the [PushMessageData] interface extracts push message data as a [Blob] object.",
-      "json": "The **`json()`** method of the [PushMessageData] interface extracts push message data by parsing it as a [JSON](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON) string and returning the result.",
-      "text": "The **`text()`** method of the [PushMessageData] interface extracts push message data as a plain text string."
+      "arraybuffer": "@AvailableInWorkers(\"service\")\n\nThe **`arrayBuffer()`** method of the [PushMessageData] interface extracts push message data as an `ArrayBuffer` object.",
+      "blob": "@AvailableInWorkers(\"service\")\n\nThe **`blob()`** method of the [PushMessageData] interface extracts push message data as a [Blob] object.",
+      "json": "@AvailableInWorkers(\"service\")\n\nThe **`json()`** method of the [PushMessageData] interface extracts push message data by parsing it as a [JSON](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON) string and returning the result.",
+      "text": "@AvailableInWorkers(\"service\")\n\nThe **`text()`** method of the [PushMessageData] interface extracts push message data as a plain text string."
     }
   },
   "PushSubscription": {
@@ -5958,16 +6093,16 @@
     }
   },
   "RTCAudioSourceStats": {
-    "docs": "The [WebRTC API](https://developer.mozilla.org/en-US/docs/Web/API/WebRTC_API)'s **`RTCAudioSourceStats`** dictionary provides information about an audio track that is attached to one or more senders.\n\nThese statistics can be obtained by iterating the [RTCStatsReport] returned by [RTCRtpSender.getStats] or [RTCPeerConnection.getStats] until you find a report with the [`type`](#type) of `media-source` and a [`kind`](#kind) of `audio`.\n\n> **Note:** For audio information about remotely sourced tracks (that are being received), see [RTCInboundRtpStreamStats].",
+    "docs": "The **`RTCAudioSourceStats`** dictionary of the [WebRTC API](https://developer.mozilla.org/en-US/docs/Web/API/WebRTC_API) provides statistics information about an audio track ([MediaStreamTrack]) that is attached to one or more senders ([RTCRtpSender]).\n\nThese statistics can be obtained by iterating the [RTCStatsReport] returned by [RTCRtpSender.getStats] or [RTCPeerConnection.getStats] until you find a report with the [`type`](#type) of `media-source` and a [`kind`](#kind) of `audio`.\n\n> **Note:** For audio information about remotely sourced tracks (that are being received), see [RTCInboundRtpStreamStats].",
     "properties": {
-      "audiolevel": "The [RTCAudioSourceStats] dictionary's **`audioLevel`** property represents the audio level of the media source.\n\nThe level is averaged over some small implementation-dependent interval.\nUsers can alternatively calculate the average audio level over some arbitrary duration using the algorithm described in the [`RTCAudioSourceStats` description](/en-US/docs/Web/API/RTCAudioSourceStats#description).\n\n> **Note:** For audio levels of remotely sourced tracks, see [RTCInboundRtpStreamStats.audioLevel].",
+      "audiolevel": "The **`audioLevel`** property of the [RTCAudioSourceStats] dictionary represents the audio level of the media source.\n\nThe level is averaged over some small implementation-dependent interval.\nUsers can alternatively calculate the average audio level over some arbitrary duration using the algorithm described in the [`RTCAudioSourceStats` description](/en-US/docs/Web/API/RTCAudioSourceStats#description).\n\n> **Note:** For audio levels of remotely sourced tracks, see [RTCInboundRtpStreamStats.audioLevel].",
       "id": "The **`id`** property of the [RTCAudioSourceStats] dictionary is a string which uniquely identifies the object for which this object provides statistics.\n\nUsing the `id`, you can correlate this statistics object with others, in order to monitor statistics over time for a given WebRTC object, such as an [RTCPeerConnection], or an [RTCDataChannel].",
-      "kind": "The [RTCAudioSourceStats] dictionary's **`kind`** property is a string value that is used to differentiate `audio` and `video` media sources.\n\nAlong with the [RTCAudioSourceStats.type], this identifies the object as an [RTCAudioSourceStats] object when iterating the [RTCStatsReport] returned by [RTCRtpSender.getStats] or [RTCPeerConnection.getStats].",
+      "kind": "The **`kind`** property of the [RTCAudioSourceStats] dictionary is a string with the value `audio`.\n\nThe `kind` is used to differentiate between audio and video media sources when iterating an [RTCStatsReport], which both have a [RTCAudioSourceStats.type] of `media-source` (a `kind` of `video` indicates an [RTCVideoSourceStats] object).",
       "timestamp": "The **`timestamp`** property of the [RTCAudioSourceStats] dictionary is a [DOMHighResTimeStamp] object specifying the time at which the data in the object was sampled.\n\nThe time is given in milliseconds elapsed since the first moment of January 1, 1970, UTC (also known as [Unix time](https://developer.mozilla.org/en-US/docs/Glossary/Unix_time)).",
-      "totalaudioenergy": "The [RTCAudioSourceStats] dictionary's **`totalAudioEnergy`** property represents the total audio energy of the media source over the lifetime of this stats object.\n\nThe total energy across a particular duration can be determined by subtracting the value of this property returned by two different `getStats()` calls.\n\n> **Note:** For audio energy of remotely sourced tracks, see [RTCInboundRtpStreamStats.totalAudioEnergy].",
-      "totalsamplesduration": "The [RTCAudioSourceStats] dictionary's **`totalSamplesDuration`** property represents the combined duration of all samples produced by the media source over the lifetime of this stats object, in seconds.\nIt does not include samples dropped before reaching this media source. <!-- Dropped samples in `droppedSamplesDuration`; not implemented -->\n\nThis can be used with [RTCAudioSourceStats.totalAudioEnergy] to compute an [average audio level over different intervals](/en-US/docs/Web/API/RTCAudioSourceStats#description).\n\n> **Note:** For audio duration of remotely sourced tracks, see [RTCInboundRtpStreamStats.totalSamplesDuration].",
-      "trackidentifier": "The [RTCAudioSourceStats] dictionary's property **`trackIdentifier`** contains the `id` attribute of the associated [`MediaStreamTrack`](https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrack).",
-      "type": "The [RTCAudioSourceStats] dictionary's property **`type`** is a string with value `media-source`.\n\nThe type of `media-source` identifies the type of statistics as either [RTCAudioSourceStats] or [RTCVideoSourceStats] when iterating the [RTCStatsReport] returned by [RTCRtpSender.getStats] or [RTCPeerConnection.getStats].\nThe type of stats can further be differentiated using the [RTCAudioSourceStats.kind], which will be `audio` for `RTCAudioSourceStats`."
+      "totalaudioenergy": "The **`totalAudioEnergy`** property of the [RTCAudioSourceStats] dictionary represents the total audio energy of the media source over the lifetime of this stats object.\n\nThe total energy across a particular duration can be determined by subtracting the value of this property returned by two different `getStats()` calls.\n\n> **Note:** For audio energy of remotely sourced tracks, see [RTCInboundRtpStreamStats.totalAudioEnergy].",
+      "totalsamplesduration": "The **`totalSamplesDuration`** property of the [RTCAudioSourceStats] dictionary represents the combined duration of all samples produced by the media source over the lifetime of this stats object, in seconds.\nIt does not include samples dropped before reaching this media source. <!-- Dropped samples in `droppedSamplesDuration`; not implemented -->\n\nThis can be used with [RTCAudioSourceStats.totalAudioEnergy] to compute an [average audio level over different intervals](/en-US/docs/Web/API/RTCAudioSourceStats#description).\n\n> **Note:** For audio duration of remotely sourced tracks, see [RTCInboundRtpStreamStats.totalSamplesDuration].",
+      "trackidentifier": "The **`trackIdentifier`** property of the [RTCAudioSourceStats] dictionary contains the `id` attribute of the associated [`MediaStreamTrack`](https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrack).",
+      "type": "The **`type`** property of the [RTCAudioSourceStats] dictionary is a string with value `media-source`.\n\nThe type of `media-source` identifies the type of statistics as either [RTCAudioSourceStats] or [RTCVideoSourceStats] when iterating the [RTCStatsReport] returned by [RTCRtpSender.getStats] or [RTCPeerConnection.getStats].\nThe type of stats can further be differentiated using the [RTCAudioSourceStats.kind], which will be `audio` for `RTCAudioSourceStats`."
     }
   },
   "RTCCertificate": {
@@ -6053,25 +6188,25 @@
     "docs": "The **`RTCDtlsTransport`** interface provides access to information about the Datagram Transport Layer Security (****) transport over which a [RTCPeerConnection]'s  and  packets are sent and received by its [RTCRtpSender] and [RTCRtpReceiver] objects.\n\nA `RTCDtlsTransport` object is also used to provide information about  packets transmitted and received by a connection's [data channels](https://developer.mozilla.org/en-US/docs/Web/API/RTCDataChannel).\n\nFeatures of the DTLS transport include the addition of security to the underlying transport; the `RTCDtlsTransport` interface can be used to obtain information about the underlying transport and the security added to it by the DTLS layer.",
     "properties": {
       "error_event": "An [RTCDtlsTransport] receives an `error` event when a transport-level error occurs on the [RTCPeerConnection].\n\nThis event is not cancelable and does not bubble.",
-      "icetransport": "The read-only **[RTCDtlsTransport]**\nproperty **`iceTransport`** contains a reference\nto the underlying [RTCIceTransport].",
+      "icetransport": "The **`iceTransport`** read-only property of the **[RTCDtlsTransport]** interface contains a reference to the underlying [RTCIceTransport].",
       "state": "The **`state`** read-only property of the\n[RTCDtlsTransport] interface provides information which describes a\nDatagram Transport Layer Security (****) transport state."
     }
   },
   "RTCEncodedAudioFrame": {
-    "docs": "The **`RTCEncodedAudioFrame`** of the [WebRTC API](https://developer.mozilla.org/en-US/docs/Web/API/WebRTC_API) represents an encoded audio frame in the WebRTC receiver or sender pipeline, which may be modified using a [WebRTC Encoded Transform](https://developer.mozilla.org/en-US/docs/Web/API/WebRTC_API/Using_Encoded_Transforms).\n\nThe interface provides methods and properties to get metadata about the frame, allowing its format and order in the sequence of frames to be determined.\nThe `data` property gives access to the encoded frame data as a buffer, which might be encrypted, or otherwise modified by a transform.\n\n> **Note:** This feature is available in [_Dedicated_ Web Workers](/en-US/docs/Web/API/Web_Workers_API#worker_types).",
+    "docs": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`RTCEncodedAudioFrame`** of the [WebRTC API](https://developer.mozilla.org/en-US/docs/Web/API/WebRTC_API) represents an encoded audio frame in the WebRTC receiver or sender pipeline, which may be modified using a [WebRTC Encoded Transform](https://developer.mozilla.org/en-US/docs/Web/API/WebRTC_API/Using_Encoded_Transforms).\n\nThe interface provides methods and properties to get metadata about the frame, allowing its format and order in the sequence of frames to be determined.\nThe `data` property gives access to the encoded frame data as a buffer, which might be encrypted, or otherwise modified by a transform.\n\n> **Note:** This feature is available in [_Dedicated_ Web Workers](/en-US/docs/Web/API/Web_Workers_API#worker_types).",
     "properties": {
-      "data": "The **`data`** property of the [RTCEncodedAudioFrame] interface returns a buffer containing the data for an encoded frame.",
-      "getmetadata": "The **`getMetadata()`** method of the [RTCEncodedAudioFrame] interface returns an object containing the metadata associated with the frame.\n\nThis includes information about the frame, including the audio encoding used, the synchronization source and contributing sources, and the sequence number (for incoming frames).",
-      "timestamp": "The readonly **`timestamp`** property of the [RTCEncodedAudioFrame] interface indicates the time at which frame sampling started."
+      "data": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`data`** property of the [RTCEncodedAudioFrame] interface returns a buffer containing the data for an encoded frame.",
+      "getmetadata": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`getMetadata()`** method of the [RTCEncodedAudioFrame] interface returns an object containing the metadata associated with the frame.\n\nThis includes information about the frame, including the audio encoding used, the synchronization source and contributing sources, and the sequence number (for incoming frames).",
+      "timestamp": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe readonly **`timestamp`** property of the [RTCEncodedAudioFrame] interface indicates the time at which frame sampling started."
     }
   },
   "RTCEncodedVideoFrame": {
-    "docs": "The **`RTCEncodedVideoFrame`** of the [WebRTC API](https://developer.mozilla.org/en-US/docs/Web/API/WebRTC_API) represents an encoded video frame in the WebRTC receiver or sender pipeline, which may be modified using a [WebRTC Encoded Transform](https://developer.mozilla.org/en-US/docs/Web/API/WebRTC_API/Using_Encoded_Transforms).\n\n> **Note:** This feature is available in [_Dedicated_ Web Workers](/en-US/docs/Web/API/Web_Workers_API#worker_types).",
+    "docs": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`RTCEncodedVideoFrame`** of the [WebRTC API](https://developer.mozilla.org/en-US/docs/Web/API/WebRTC_API) represents an encoded video frame in the WebRTC receiver or sender pipeline, which may be modified using a [WebRTC Encoded Transform](https://developer.mozilla.org/en-US/docs/Web/API/WebRTC_API/Using_Encoded_Transforms).\n\n> **Note:** This feature is available in [_Dedicated_ Web Workers](/en-US/docs/Web/API/Web_Workers_API#worker_types).",
     "properties": {
-      "data": "The **`data`** property of the [RTCEncodedVideoFrame] interface returns a buffer containing the frame data.",
-      "getmetadata": "The **`getMetadata()`** method of the [RTCEncodedVideoFrame] interface returns an object containing the metadata associated with the frame.\n\nThis includes information about the frame, including its size, video encoding, other frames needed to construct a full image, timestamp, and other information.",
-      "timestamp": "The readonly **`timestamp`** property of the [RTCEncodedVideoFrame] interface indicates the time at which frame sampling started.",
-      "type": "The readonly **`type`** property of the [RTCEncodedVideoFrame] interface indicates whether this frame is a key frame, delta frame, or empty frame."
+      "data": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`data`** property of the [RTCEncodedVideoFrame] interface returns a buffer containing the frame data.",
+      "getmetadata": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`getMetadata()`** method of the [RTCEncodedVideoFrame] interface returns an object containing the metadata associated with the frame.\n\nThis includes information about the frame, including its size, video encoding, other frames needed to construct a full image, timestamp, and other information.",
+      "timestamp": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe readonly **`timestamp`** property of the [RTCEncodedVideoFrame] interface indicates the time at which frame sampling started.",
+      "type": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe readonly **`type`** property of the [RTCEncodedVideoFrame] interface indicates whether this frame is a key frame, delta frame, or empty frame."
     }
   },
   "RTCError": {
@@ -6100,7 +6235,7 @@
       "port": "The **[RTCIceCandidate]** interface's read-only **`port`** property contains the port\nnumber on the device at the address given by [RTCIceCandidate.address] at which the candidate's peer can be reached.\n\nThe `port` field's value is set from the `candidateInfo` options object passed to the [RTCIceCandidate.RTCIceCandidate] constructor.\nYou can't specify the value of `port` directly in the options object, but its value is automatically extracted from the object's `candidate` a-line, if it's formatted properly.",
       "priority": "The **[RTCIceCandidate]** interface's read-only **`priority`** property specifies the candidate's priority according to the remote peer; the higher this value is, the better the remote peer considers the candidate to be.\n\nThe `priority` field's value is set from the `candidateInfo` options object passed to the [RTCIceCandidate.RTCIceCandidate] constructor.\nYou can't specify the value of `priority` directly in the options object, but its value is automatically extracted from the object's `candidate` a-line, if it's formatted properly.",
       "protocol": "The **[RTCIceCandidate]** interface's read-only **`protocol`** property is a string\nwhich indicates whether the candidate uses  or  as its transport protocol.\n\nThe `protocol` field's value is set from the `candidateInfo` options object passed to the [RTCIceCandidate.RTCIceCandidate] constructor.\nYou can't specify the value of `protocol` directly in the options object, but its value is automatically extracted from the object's `candidate` a-line, if it's formatted properly.\n\n`protocol` is `null` by default if not specified properly in the SDP, but this is an error condition and will result in a thrown exception when you call [RTCPeerConnection.addIceCandidate].",
-      "relatedaddress": "The **[RTCIceCandidate]** interface's read-only **`relatedAddress`** property is a\nstring indicating the **related address** of a relay or reflexive candidate.\n\nIf the candidate is a host candidate (that is, its [RTCIceCandidate.address] is in fact the real IP address of the remote peer), `relatedAddress` is `null`.\n\nThe `relatedAddress` field's value is set from the `candidateInfo` options object passed to the [RTCIceCandidate.RTCIceCandidate] constructor.\nYou can't specify the value of `relatedAddress` directly in the options object, but its value is automatically extracted from the object's `candidate` a-line if it's formatted properly(the `rel-address` field).\n\nThe related address and port ([RTCIceCandidate.relatedPort]) are not used at all by  itself; they are provided\nfor analysis and diagnostic purposes only, and their inclusion may be blocked by security systems, so do not rely on them having non-`null` values.",
+      "relatedaddress": "The **[RTCIceCandidate]** interface's read-only **`relatedAddress`** property is a string indicating the **related address** of a relay or reflexive candidate.\n\nIf the candidate is a host candidate (that is, its [RTCIceCandidate.address] is in fact the real IP address of the remote peer), `relatedAddress` is `null`.\n\nThe `relatedAddress` field's value is set from the `candidateInfo` options object passed to the [RTCIceCandidate.RTCIceCandidate] constructor.\nYou can't specify the value of `relatedAddress` directly in the options object, but its value is automatically extracted from the object's `candidate` a-line if it's formatted properly(the `rel-address` field).\n\nThe related address and port ([RTCIceCandidate.relatedPort]) are not used at all by  itself; they are provided for analysis and diagnostic purposes only, and their inclusion may be blocked by security systems, so do not rely on them having non-`null` values.",
       "relatedport": "The **[RTCIceCandidate]** interface's read-only **`relatedPort`** property indicates the port number of reflexive or relay candidates.\n\nIf the candidate is a host candidate (that is, its [RTCIceCandidate.address] is in fact the real IP address of the remote peer), `relatedPort` is `null`.\n\nThe `relatedPort` field's value is set from the `candidateInfo` options object passed to the [RTCIceCandidate.RTCIceCandidate] constructor.\nYou can't specify the value of `relatedPort` directly in the options object, but its value is automatically extracted from the object's `candidate` a-line, if it's formatted properly (the `rel-port` field).\n\nThe related address ([RTCIceCandidate.relatedAddress]) and port are not used at all by  itself; they are provided for\nanalysis and diagnostic purposes only, and their inclusion may be blocked by security systems, so do not rely on them having non-`null` values.",
       "rtcicecandidate": "The\n**`RTCIceCandidate()`**\nconstructor creates and returns a new [RTCIceCandidate] object, which can\nbe configured to represent a single  candidate.",
       "sdpmid": "The read-only property **`sdpMid`** on the [RTCIceCandidate] interface returns a string\nspecifying the media stream identification tag of the media component with which the candidate is associated.\nThis ID uniquely identifies a given stream for the component with which the candidate is associated.\n\nThis property can be configured by specifying the value of the `sdpMid` property in the `candidateInfo` options object that is passed to the [RTCIceCandidate.RTCIceCandidate] constructor.\nIf you call the constructor with an m-line string instead of the options object, the value of `sdpMid` is extracted from the specified candidate m-line string.",
@@ -6114,7 +6249,7 @@
   "RTCIceCandidatePair": {
     "docs": "The **`RTCIceCandidatePair`** dictionary describes a pair of ICE candidates which together comprise a description of a viable connection between two WebRTC endpoints. It is used as the return value from [RTCIceTransport.getSelectedCandidatePair] to identify the currently-selected candidate pair identified by the ICE agent.",
     "properties": {
-      "local": "The **`local`** property of the\n**[RTCIceCandidatePair]** dictionary specifies the\n[RTCIceCandidate] which describes the configuration of the local end of a\nviable WebRTC connection.",
+      "local": "The **`local`** property of the **[RTCIceCandidatePair]** dictionary specifies the [RTCIceCandidate] which describes the configuration of the local end of a viable WebRTC connection.",
       "remote": "The **`remote`** property of the\n**[RTCIceCandidatePair]** dictionary specifies the\n[RTCIceCandidate] describing the configuration of the remote end of a\nviable WebRTC connection."
     }
   },
@@ -6174,17 +6309,17 @@
   "RTCIceTransport": {
     "docs": "The **`RTCIceTransport`** interface provides access to information about the  transport layer over which the data is being sent and received.\nThis is particularly useful if you need to access state information about the connection.",
     "properties": {
-      "component": "The read-only **[RTCIceTransport]**\nproperty **`component`** specifies whether the object is\nserving to transport  or .",
-      "gatheringstate": "The read-only property **`gatheringState`** property of the [RTCIceTransport] interface returns a string that indicates the current gathering state of the ICE agent: `\"new\"`, `\"gathering\"`, or `\"complete\"`.",
-      "gatheringstatechange_event": "A **`gatheringstatechange`** event is sent to an [RTCIceTransport] when its  candidate gathering state changes.\n\nThe gathering state, whose actual status can be found in the transport object's [RTCIceTransport.gatheringState] property, indicates whether or not the ICE agent has begun gathering candidates, and if so, if it has finished doing so.\n\nThe key difference between `gatheringstatechange` and [RTCPeerConnection.icegatheringstatechange_event] is that the latter represents the overall state of the connection including every [RTCIceTransport] used by every [RTCRtpSender] and every [RTCRtpReceiver] on the entire connection. In contrast, `gatheringstatechange` represents changes to the candidate gathering state for a single transport.\n\nThis event is not cancelable and does not bubble.",
-      "getlocalcandidates": "The **[RTCIceTransport]** method\n**`getLocalCandidates()`** returns an array of\n[RTCIceCandidate] objects, one for each of the candidates that have been\ngathered by the local device during the current  agent\nsession.\n\nThe local candidates are placed in this list by the ICE agent prior to being delivered\nto the local client's code in an [RTCPeerConnection.icecandidate_event] event so that the client can\nforward the candidates to the remote peer.",
-      "getlocalparameters": "The **[RTCIceTransport]** method\n**`getLocalParameters()`** returns an\n[RTCIceParameters] object which provides information uniquely identifying\nthe local peer for the duration of the ICE session.\n\nThe local peer's parameters are obtained during ICE signaling and delivered to the\ntransport when the client calls [RTCPeerConnection.setLocalDescription].",
-      "getremotecandidates": "The **[RTCIceTransport]** method\n**`getRemoteCandidates()`** returns an array which contains\none [RTCIceCandidate] for each of the candidates that have been received\nfrom the remote peer so far during the current  gathering\nsession.\n\nEach time your signaling code calls [RTCPeerConnection.addIceCandidate]\nto add a received candidate to the ICE session, the ICE agent places it in the list\nreturned by this function.",
-      "getremoteparameters": "The **[RTCIceTransport]** method\n**`getRemoteParameters()`** returns an\n[RTCIceParameters] object which provides information uniquely\nidentifying the remote peer for the duration of the ICE session.\n\nThe remote peer's parameters are received during ICE signaling and delivered to the\ntransport when the client calls\n[RTCPeerConnection.setRemoteDescription].",
-      "getselectedcandidatepair": "The [RTCIceTransport] method\n**`getSelectedCandidatePair()`** returns an\n[RTCIceCandidatePair] object containing the current best-choice pair\nof  candidates describing the configuration of the endpoints of the transport.",
-      "role": "The read-only **[RTCIceTransport]**\nproperty **`role`** indicates which  role\nthe transport is fulfilling: that of the controlling agent, or the agent that is being\ncontrolled.\n\nYou can learn more about ICE roles in\n[Choosing a candidate pair](/en-US/docs/Web/API/WebRTC_API/Connectivity#choosing_a_candidate_pair).",
+      "component": "The **`component`** read-only property of the [RTCIceTransport] interface specifies whether the object is serving to transport  or .",
+      "gatheringstate": "The **`gatheringState`** read-only property of the [RTCIceTransport] interface returns a string that indicates the current gathering state of the ICE agent for this transport: `\"new\"`, `\"gathering\"`, or `\"complete\"`.\n\nYou can detect when the value of this property changes by watching for an event of type [RTCIceTransport.gatheringstatechange_event].\n\nNote that **`gatheringState`** represents the gathering state of just this transport, while [RTCPeerConnection.iceGatheringState] represents the overall gathering state of the whole connection, including every [RTCIceTransport] used by every [RTCRtpSender] and every [RTCRtpReceiver] on the entire connection.",
+      "gatheringstatechange_event": "A **`gatheringstatechange`** event is sent to an [RTCIceTransport] when its  candidate gathering state changes.\n\nThe gathering state, whose actual status can be found in the transport object's [RTCIceTransport.gatheringState] property, indicates whether or not the ICE agent has begun gathering candidates on this transport, and if so, if it has finished doing so.\n\nThis event is not cancelable and does not bubble.",
+      "getlocalcandidates": "The **`getLocalCandidates()`** method of the [RTCIceTransport] interface returns an array of [RTCIceCandidate] objects, one for each of the candidates that have been gathered by the local device during the current  agent session.\n\nThe local candidates are placed in this list by the ICE agent prior to being delivered to the local client's code in an [RTCPeerConnection.icecandidate_event] event so that the client can forward the candidates to the remote peer.",
+      "getlocalparameters": "The **`getLocalParameters()`** method of the [RTCIceTransport] interface returns an [RTCIceParameters] object that provides information uniquely identifying the local peer for the duration of the ICE session.\n\nThe local peer's parameters are obtained during ICE signaling and delivered to the transport when the client calls [RTCPeerConnection.setLocalDescription].",
+      "getremotecandidates": "The **`getRemoteCandidates()`** method of the [RTCIceTransport] interface returns an array that contains one [RTCIceCandidate] for each of the candidates that have been received from the remote peer so far during the current  gathering session.\n\nEach time your signaling code calls [RTCPeerConnection.addIceCandidate] to add a received candidate to the ICE session, the ICE agent places it in the list returned by this function.",
+      "getremoteparameters": "The **`getRemoteParameters()`** method of the [RTCIceTransport] interface returns an [RTCIceParameters] object that provides information uniquely identifying the remote peer for the duration of the ICE session.\n\nThe remote peer's parameters are received during ICE signaling and delivered to the transport when the client calls [RTCPeerConnection.setRemoteDescription].",
+      "getselectedcandidatepair": "The **`getSelectedCandidatePair()`** method of the [RTCIceTransport] interface returns an [RTCIceCandidatePair] object containing the current best-choice pair of  candidates describing the configuration of the endpoints of the transport.",
+      "role": "The **`role`** read-only property of the [RTCIceTransport] interface indicates which  role the transport is fulfilling: that of the controlling agent, or the agent that is being controlled.\n\nYou can learn more about ICE roles in [Choosing a candidate pair](/en-US/docs/Web/API/WebRTC_API/Connectivity#choosing_a_candidate_pair).",
       "selectedcandidatepairchange_event": "A **`selectedcandidatepairchange`** event is sent to an [RTCIceTransport] when the  agent selects a new pair of candidates that describe the endpoints of a viable connection.\n\nThe pair of candidates is in turn described by an [RTCIceCandidatePair] object which contains one [RTCIceCandidate] representing the local end of the connection, and another representing the remote end of the connection.\n\nTogether, the candidates can be used to establish a connection to be used by the [RTCIceTransport], and, by extension, by an [RTCPeerConnection].\n\nThis event is not cancelable and does not bubble.",
-      "state": "The read-only **[RTCIceTransport]**\nproperty **`state`** returns the current state of the ICE\ntransport, so you can determine the state of ICE gathering in which the ICE agent\ncurrently is operating.\n\nThis differs from the [RTCIceTransport.gatheringState],\nwhich only indicates whether or not ICE gathering is currently underway.",
+      "state": "The **`state`** read-only property of the [RTCIceTransport] interface returns the current state of the ICE transport, so you can determine the state of ICE gathering in which the ICE agent currently is operating.\n\nThis differs from the [RTCIceTransport.gatheringState], which only indicates whether or not ICE gathering is currently underway.\nIt also differs from [RTCPeerConnection.connectionState], which aggregates the states across every [RTCIceTransport] used by every [RTCRtpSender] and every [RTCRtpReceiver] on the entire connection.",
       "statechange_event": "A **`statechange`** event occurs when the [RTCIceTransport] changes state. The [RTCIceTransport.state] can be used to determine how far through the process of examining, verifying, and selecting a valid candidate pair is prior to successfully connecting the two peers for WebRTC communications.\n\nThis event is not cancelable and does not bubble."
     }
   },
@@ -6238,51 +6373,51 @@
   "RTCPeerConnection": {
     "docs": "The **`RTCPeerConnection`** interface represents a WebRTC connection between the local computer and a remote peer.\nIt provides methods to connect to a remote peer, maintain and monitor the connection, and close the connection once it's no longer needed.",
     "properties": {
-      "addicecandidate": "When a website or app using [RTCPeerConnection] receives a new ICE candidate from the remote peer over its signaling channel, it delivers the newly-received candidate to the browser's  agent by calling **`RTCPeerConnection.addIceCandidate()`**.\nThis adds this new remote candidate to the `RTCPeerConnection`'s remote description, which describes the state of the remote end of the connection.\n\nIf the `candidate` parameter is missing or a value of `null` is given when calling `addIceCandidate()`, the added ICE candidate is an \"end-of-candidates\" indicator.\nThe same is the case if the value of the specified object's [RTCIceCandidate.candidate] is either missing or an empty string (`\"\"`), it signals that all remote candidates have been delivered.\n\nThe end-of-candidates notification is transmitted to the remote peer using a candidate with an a-line value of `end-of-candidates`.\n\nDuring negotiation, your app will likely receive many candidates which you'll deliver to the ICE agent in this way, allowing it to build up a list of potential connection methods.\nThis is covered in more detail in the articles [WebRTC connectivity](https://developer.mozilla.org/en-US/docs/Web/API/WebRTC_API/Connectivity) and\n[Signaling and video calling](https://developer.mozilla.org/en-US/docs/Web/API/WebRTC_API/Signaling_and_video_calling).",
-      "addstream": "The _obsolete_ [RTCPeerConnection] method\n**`addStream()`** adds a [MediaStream] as a local\nsource of audio or video. Instead of using this obsolete method, you should instead use\n[RTCPeerConnection.addTrack] once for each track you wish to\nsend to the remote peer.\n\nIf the [RTCPeerConnection.signalingState] is set to\n`closed`, an `InvalidStateError` is raised. If the\n[RTCPeerConnection.signalingState] is set to\n`stable`, the event [RTCPeerConnection.negotiationneeded_event] is sent on the\n[RTCPeerConnection] to indicate that  negotiation must\nbe repeated to consider the new stream.",
+      "addicecandidate": "The **`addIceCandidate()`** method of the [RTCPeerConnection] interface adds a new remote candidate to the connection's remote description, which describes the state of the remote end of the connection.\n\nWhen a website or app using [RTCPeerConnection] receives a new ICE candidate from the remote peer over its signaling channel, it delivers the newly-received candidate to the browser's  agent by calling **`RTCPeerConnection.addIceCandidate()`**.\nThis adds this new remote candidate to the `RTCPeerConnection`'s remote description, which describes the state of the remote end of the connection.\n\nIf the `candidate` parameter is missing or a value of `null` is given when calling `addIceCandidate()`, the added ICE candidate is an \"end-of-candidates\" indicator.\nThe same is the case if the value of the specified object's [RTCIceCandidate.candidate] is either missing or an empty string (`\"\"`), it signals that all remote candidates have been delivered.\n\nThe end-of-candidates notification is transmitted to the remote peer using a candidate with an a-line value of `end-of-candidates`.\n\nDuring negotiation, your app will likely receive many candidates which you'll deliver to the ICE agent in this way, allowing it to build up a list of potential connection methods.\nThis is covered in more detail in the articles [WebRTC connectivity](https://developer.mozilla.org/en-US/docs/Web/API/WebRTC_API/Connectivity) and\n[Signaling and video calling](https://developer.mozilla.org/en-US/docs/Web/API/WebRTC_API/Signaling_and_video_calling).",
+      "addstream": "The **`addStream()`** method of the [RTCPeerConnection] interface adds a [MediaStream] as a local source of audio or video.\nInstead of using this obsolete method, you should instead use [RTCPeerConnection.addTrack] once for each track you wish to send to the remote peer.\n\nIf the [RTCPeerConnection.signalingState] is set to `closed`, an `InvalidStateError` is raised.\nIf the [RTCPeerConnection.signalingState] is set to `stable`, the event [RTCPeerConnection.negotiationneeded_event] is sent on the [RTCPeerConnection] to indicate that  negotiation must be repeated to consider the new stream.",
       "addstream_event": "The obsolete **`addstream`** event is sent to an [RTCPeerConnection] when new media, in the form of a [MediaStream] object, has been added to it.\n\n> **Warning:** This event has been removed from the WebRTC specification. You should instead watch for the [RTCPeerConnection.track_event] event, which is sent for each media track added to the `RTCPeerConnection`.\n\nYou can, similarly, watch for streams to be removed from the connection by monitoring the [RTCPeerConnection.removestream_event] event.\n\nThis event is not cancelable and does not bubble.",
-      "addtrack": "The [RTCPeerConnection] method **`addTrack()`** adds a new media track to the set of tracks which will be transmitted to the other peer.\n\n> **Note:** Adding a track to a connection triggers renegotiation by firing a [RTCPeerConnection.negotiationneeded_event] event.\n> See [Starting negotiation](/en-US/docs/Web/API/WebRTC_API/Signaling_and_video_calling#starting_negotiation) for details.",
-      "addtransceiver": "The [RTCPeerConnection] method **`addTransceiver()`** creates a new [RTCRtpTransceiver] and adds it to the set of transceivers associated with the `RTCPeerConnection`.\nEach transceiver represents a bidirectional stream, with both an [RTCRtpSender] and an [RTCRtpReceiver] associated with it.",
-      "cantrickleicecandidates": "The read-only **[RTCPeerConnection]** property **`canTrickleIceCandidates`**\nreturns a boolean value which indicates whether or not the remote peer can accept\n[trickled ICE candidates](https://datatracker.ietf.org/doc/html/draft-ietf-mmusic-trickle-ice).\n\n**ICE trickling** is the process of continuing to send candidates after\nthe initial offer or answer has already been sent to the other peer.\n\nThis property is only set after having called\n[RTCPeerConnection.setRemoteDescription]. Ideally, your signaling\nprotocol provides a way to detect trickling support, so that you don't need to rely on\nthis property. A WebRTC browser will always support trickle ICE. If trickling isn't\nsupported, or you aren't able to tell, you can check for a falsy value for this\nproperty and then wait until the value of\n[RTCPeerConnection.iceGatheringState] changes to\n`\"completed\"` before creating and sending the initial offer. That way, the\noffer contains all of the candidates.",
-      "close": "The **`RTCPeerConnection.close()`** method closes the current\npeer connection.",
-      "connectionstate": "The read-only **`connectionState`** property of the [RTCPeerConnection] interface indicates the current state of the peer connection by returning one of the following string values: `new`, `connecting`, `connected`, `disconnected`, `failed`, or `closed`.\n\nThis state essentially represents the aggregate state of all ICE transports (which are of type [RTCIceTransport] or [RTCDtlsTransport]) being used by the connection.\n\nWhen this property's value changes, a [RTCPeerConnection.connectionstatechange_event] event is sent to the [RTCPeerConnection] instance.",
+      "addtrack": "The **`addTrack()`** method of the [RTCPeerConnection] interface adds a new media track to the set of tracks which will be transmitted to the other peer.\n\n> **Note:** Adding a track to a connection triggers renegotiation by firing a [RTCPeerConnection.negotiationneeded_event] event.\n> See [Starting negotiation](/en-US/docs/Web/API/WebRTC_API/Signaling_and_video_calling#starting_negotiation) for details.",
+      "addtransceiver": "The **`addTransceiver()`** method of the [RTCPeerConnection] interface creates a new [RTCRtpTransceiver] and adds it to the set of transceivers associated with the `RTCPeerConnection`.\nEach transceiver represents a bidirectional stream, with both an [RTCRtpSender] and an [RTCRtpReceiver] associated with it.",
+      "cantrickleicecandidates": "The **`canTrickleIceCandidates`** read-only property of the [RTCPeerConnection] interface returns a boolean value which indicates whether or not the remote peer can accept [trickled ICE candidates](https://datatracker.ietf.org/doc/html/draft-ietf-mmusic-trickle-ice).\n\n**ICE trickling** is the process of continuing to send candidates after the initial offer or answer has already been sent to the other peer.\n\nThis property is only set after having called [RTCPeerConnection.setRemoteDescription]. Ideally, your signaling protocol provides a way to detect trickling support, so that you don't need to rely on this property.\nA WebRTC browser will always support trickle ICE. If trickling isn't supported, or you aren't able to tell, you can check for a falsy value for this property and then wait until the value of [RTCPeerConnection.iceGatheringState] changes to `\"completed\"` before creating and sending the initial offer.\nThat way, the offer contains all of the candidates.",
+      "close": "The **`close()`** method of the [RTCPeerConnection] interface closes the current peer connection.",
+      "connectionstate": "The **`connectionState`** read-only property of the [RTCPeerConnection] interface indicates the current state of the peer connection by returning one of the following string values: `new`, `connecting`, `connected`, `disconnected`, `failed`, or `closed`.\n\nThis state essentially represents the aggregate state of all ICE transports (which are of type [RTCIceTransport] or [RTCDtlsTransport]) being used by the connection.\n\nWhen this property's value changes, a [RTCPeerConnection.connectionstatechange_event] event is sent to the [RTCPeerConnection] instance.",
       "connectionstatechange_event": "The **`connectionstatechange`** event is sent to the `onconnectionstatechange` event handler on an [RTCPeerConnection] object after a new track has been added to an [RTCRtpReceiver] which is part of the connection.\nThe new connection state can be found in [RTCPeerConnection.connectionState], and is one of the string values: `new`, `connecting`, `connected`, `disconnected`, `failed`, or `closed`.\n\nThis event is not cancelable and does not bubble.",
-      "createanswer": "The **`createAnswer()`** method on the\n[RTCPeerConnection] interface creates an  answer to an\noffer received from a remote peer during the offer/answer negotiation of a WebRTC\nconnection. The answer contains information about any media already attached to the\nsession, codecs and options supported by the browser, and any \ncandidates already gathered. The answer is delivered to the returned\n`Promise`, and should then be sent to the source of the offer to continue\nthe negotiation process.",
-      "createdatachannel": "The **`createDataChannel()`** method\non the [RTCPeerConnection] interface\ncreates a new channel linked with the remote peer,\nover which any kind of data may be transmitted.\nThis can be useful for back-channel content,\nsuch as images, file transfer, text chat, game update\npackets, and so forth.\n\nIf the new data channel is the first one added to the connection, renegotiation is\nstarted by delivering a [RTCPeerConnection.negotiationneeded_event] event.",
-      "createoffer": "The **`createOffer()`** method\nof the [RTCPeerConnection] interface\ninitiates the creation of an  offer\nfor the purpose of starting a new WebRTC connection to a remote peer.\nThe SDP offer includes information\nabout any [MediaStreamTrack] objects\nalready attached to the WebRTC session, codec, and options supported by the browser,\nand any candidates already gathered by the  agent,\nfor the purpose of being sent over the signaling channel\nto a potential peer\nto request a connection\nor to update the configuration of an existing connection.\n\nThe return value is a `Promise` which, when the offer has been created, is\nresolved with a [RTCSessionDescription] object containing the newly-created\noffer.",
-      "currentlocaldescription": "The read-only property\n**`RTCPeerConnection.currentLocalDescription`** returns an\n[RTCSessionDescription] object describing the local end of the connection\nas it was most recently successfully negotiated since the last time the\n[RTCPeerConnection] finished negotiating and connecting to a remote peer.\nAlso included is a list of any ICE candidates that may already have been generated by\nthe ICE agent since the offer or answer represented by the description was first\ninstantiated.\n\nTo change the `currentLocalDescription`, call\n[RTCPeerConnection.setLocalDescription], which triggers a series of\nevents which leads to this value being set. For details on what exactly happens and why\nthe change isn't necessarily instantaneous, see\n[Pending and current descriptions](/en-US/docs/Web/API/WebRTC_API/Connectivity#pending_and_current_descriptions) in the WebRTC Connectivity page.\n\n> **Note:** Unlike [RTCPeerConnection.localDescription], this value represents the\n> actual current state of the local end of the connection; `localDescription`\n> may specify a description which the connection is currently in the process of\n> switching over to.",
-      "currentremotedescription": "The read-only property\n**`RTCPeerConnection.currentRemoteDescription`** returns an\n[RTCSessionDescription] object describing the remote end of the connection\nas it was most recently successfully negotiated since the last time the\n[RTCPeerConnection] finished negotiating and connecting to a remote peer.\nAlso included is a list of any ICE candidates that may already have been generated by\nthe ICE agent since the offer or answer represented by the description was first\ninstantiated.\n\nTo change the `currentRemoteDescription`, call\n[RTCPeerConnection.setRemoteDescription], which triggers a series of\nevents which leads to this value being set. For details on what exactly happens and why\nthe change isn't necessarily instantaneous, see\n[Pending and current descriptions](/en-US/docs/Web/API/WebRTC_API/Connectivity#pending_and_current_descriptions) in the WebRTC Connectivity page.\n\n> **Note:** Unlike [RTCPeerConnection.remoteDescription], this value represents the\n> actual current state of the local end of the connection;\n> `remoteDescription` may specify a description which the connection is\n> currently in the process of switching over to.",
+      "createanswer": "The **`createAnswer()`** method of the [RTCPeerConnection] interface creates an  answer to an offer received from a remote peer during the offer/answer negotiation of a WebRTC connection.\n\nThe answer contains information about any media already attached to the session, codecs and options supported by the browser, and any  candidates already gathered.\nThe answer is delivered to the returned `Promise`, and should then be sent to the source of the offer to continue the negotiation process.",
+      "createdatachannel": "The **`createDataChannel()`** method of the [RTCPeerConnection] interface creates a new channel linked with the remote peer, over which any kind of data may be transmitted.\nThis can be useful for back-channel content, such as images, file transfer, text chat, game update packets, and so forth.\n\nIf the new data channel is the first one added to the connection, renegotiation is started by delivering a [RTCPeerConnection.negotiationneeded_event] event.",
+      "createoffer": "The **`createOffer()`** method of the [RTCPeerConnection] interface initiates the creation of an  offer for the purpose of starting a new WebRTC connection to a remote peer.\n\nThe SDP offer includes information about any [MediaStreamTrack] objects already attached to the WebRTC session, codec, and options supported by the browser, and any candidates already gathered by the  agent, for the purpose of being sent over the signaling channel to a potential peer to request a connection or to update the configuration of an existing connection.\n\nThe return value is a `Promise` which, when the offer has been created, is resolved with a [RTCSessionDescription] object containing the newly-created offer.",
+      "currentlocaldescription": "The **`currentLocalDescription`** read-only property of the [RTCPeerConnection] interface returns an [RTCSessionDescription] object describing the local end of the connection as it was most recently successfully negotiated since the last time the [RTCPeerConnection] finished negotiating and connecting to a remote peer.\nAlso included is a list of any ICE candidates that may already have been generated by the ICE agent since the offer or answer represented by the description was first instantiated.\n\nTo change the `currentLocalDescription`, call [RTCPeerConnection.setLocalDescription], which triggers a series of events which leads to this value being set.\nFor details on what exactly happens and why the change isn't necessarily instantaneous, see [Pending and current descriptions](/en-US/docs/Web/API/WebRTC_API/Connectivity#pending_and_current_descriptions) in the WebRTC Connectivity page.\n\n> **Note:** Unlike [RTCPeerConnection.localDescription], this value represents the actual current state of the local end of the connection;\n> `localDescription` may specify a description which the connection is currently in the process of switching over to.",
+      "currentremotedescription": "The **`currentRemoteDescription`** read-only property of the [RTCPeerConnection] interface returns an\n[RTCSessionDescription] object describing the remote end of the connection as it was most recently successfully negotiated since the last time the [RTCPeerConnection] finished negotiating and connecting to a remote peer.\nAlso included is a list of any ICE candidates that may already have been generated by the ICE agent since the offer or answer represented by the description was first instantiated.\n\nTo change the `currentRemoteDescription`, call [RTCPeerConnection.setRemoteDescription], which triggers a series of events which leads to this value being set.\nFor details on what exactly happens and why the change isn't necessarily instantaneous, see [Pending and current descriptions](/en-US/docs/Web/API/WebRTC_API/Connectivity#pending_and_current_descriptions) in the WebRTC Connectivity page.\n\n> **Note:** Unlike [RTCPeerConnection.remoteDescription], this value represents the actual current state of the local end of the connection;\n> `remoteDescription` may specify a description which the connection is currently in the process of switching over to.",
       "datachannel_event": "A **`datachannel`** event is sent to an [RTCPeerConnection] instance when an [RTCDataChannel] has been added to the connection, as a result of the remote peer calling [RTCPeerConnection.createDataChannel].\n\n> **Note:** This event is _not_ dispatched when the local end of the connection creates the channel.\n\nThis event is not cancelable and does not bubble.",
-      "generatecertificate_static": "The static **`RTCPeerConnection.generateCertificate()`**\nfunction creates an X.509 certificate and corresponding private key, returning a promise\nthat resolves with the new [RTCCertificate] once it's generated.",
-      "getconfiguration": "The **`RTCPeerConnection.getConfiguration()`** method returns\nan object which indicates the current configuration of\nthe [RTCPeerConnection] on which the method is called.\n\nThe returned configuration is the last configuration applied via\n[RTCPeerConnection.setConfiguration], or if\n`setConfiguration()` hasn't been called, the configuration the\n`RTCPeerConnection` was constructed with. The configuration includes a list\nof the ICE servers used by the connection, information about transport policies, and\nidentity information.",
-      "getidentityassertion": "The **`RTCPeerConnection.getIdentityAssertion()`** method\ninitiates the gathering of an identity assertion. This has an effect only if the\n[RTCPeerConnection.signalingState] is not\n`\"closed\"`.\n\nThe method returns a JavaScript `Promise` which resolves to an\nidentity assertion encoded as a string.\n\nIt is not expected for the application dealing with the `RTCPeerConnection`:\nthis is automatically done; an explicit call only allows to anticipate the need.",
-      "getreceivers": "The **`RTCPeerConnection.getReceivers()`** method returns an array of [RTCRtpReceiver] objects, each of which represents one RTP receiver.\nEach RTP receiver manages the reception and decoding of data for a [MediaStreamTrack] on an [RTCPeerConnection].",
-      "getsenders": "The [RTCPeerConnection] method **`getSenders()`** returns an array of [RTCRtpSender] objects, each of which represents the RTP sender responsible for transmitting one track's data.\nA sender object provides methods and properties for examining and controlling the encoding and transmission of the track's data.",
-      "getstats": "The [RTCPeerConnection] method\n**`getStats()`** returns a promise which resolves with data\nproviding statistics about either the overall connection or about the specified\n[MediaStreamTrack].",
-      "gettransceivers": "The [RTCPeerConnection] interface's **`getTransceivers()`** method returns a list of the [RTCRtpTransceiver] objects being used to send and receive data on the connection.",
+      "generatecertificate_static": "The **`generateCertificate()`** static function of the [RTCPeerConnection] interface creates an X.509 certificate and corresponding private key, returning a promise that resolves with the new [RTCCertificate] once it's generated.",
+      "getconfiguration": "The **`getConfiguration()`** method of the [RTCPeerConnection] interface returns an object which indicates the current configuration of the [RTCPeerConnection] on which the method is called.\n\nThe returned configuration is the last configuration applied via [RTCPeerConnection.setConfiguration], or if\n`setConfiguration()` hasn't been called, the configuration the `RTCPeerConnection` was constructed with.\nThe configuration includes a list of the ICE servers used by the connection, information about transport policies, and identity information.",
+      "getidentityassertion": "The **`getIdentityAssertion()`** method of the [RTCPeerConnection] interface initiates the gathering of an identity assertion.\nThis has an effect only if the [RTCPeerConnection.signalingState] is not `\"closed\"`.\n\nThe method returns a JavaScript `Promise` which resolves to an identity assertion encoded as a string.\n\nIt is not expected for the application dealing with the `RTCPeerConnection`: this is automatically done; an explicit call only allows to anticipate the need.",
+      "getreceivers": "The **`getReceivers()`** method of the [RTCPeerConnection] interface returns an array of [RTCRtpReceiver] objects, each of which represents one RTP receiver.\nEach RTP receiver manages the reception and decoding of data for a [MediaStreamTrack] on an [RTCPeerConnection].",
+      "getsenders": "The **`getSenders()`** method of the [RTCPeerConnection] interface returns an array of [RTCRtpSender] objects, each of which represents the RTP sender responsible for transmitting one track's data.\nA sender object provides methods and properties for examining and controlling the encoding and transmission of the track's data.",
+      "getstats": "The **`getStats()`** method of the [RTCPeerConnection] interface returns a promise which resolves with data providing statistics about either the overall connection or about the specified [MediaStreamTrack].",
+      "gettransceivers": "The **`getTransceivers()`** method of the [RTCPeerConnection] interface returns a list of the [RTCRtpTransceiver] objects being used to send and receive data on the connection.",
       "icecandidate_event": "An **`icecandidate`** event is sent to an [RTCPeerConnection] when:\n\n- An [RTCIceCandidate] has been identified and added to the local peer by a call to [RTCPeerConnection.setLocalDescription],\n- Every [RTCIceCandidate] correlated with a particular username fragment and password combination (a **generation**) has been so identified and added, and\n- All ICE gathering on all transports is complete.\n\nIn the first two cases, the event handler should transmit the candidate to the remote peer over the signaling channel so the remote peer can add it to its set of remote candidates.\n\nThis event is not cancelable and does not bubble.",
       "icecandidateerror_event": "The [WebRTC API](https://developer.mozilla.org/en-US/docs/Web/API/WebRTC_API) event **`icecandidateerror`** is sent to an [RTCPeerConnection] if an error occurs while performing ICE negotiations through a  or  server. The event object is of type [RTCPeerConnectionIceErrorEvent], and contains information describing the error in some amount of detail.\n\nThis event is not cancelable and does not bubble.",
-      "iceconnectionstate": "The read-only property **`RTCPeerConnection.iceConnectionState`** returns\na string which state of the  agent associated with the [RTCPeerConnection]:\n`new`, `checking`, `connected`, `completed`,\n`failed`, `disconnected`, and `closed`.\n\nIt describes the current state of the ICE agent\nand its connection to the ICE server;\nthat is, the  or  server.\n\nYou can detect when this value has changed by watching for the\n[RTCPeerConnection.iceconnectionstatechange_event] event.",
+      "iceconnectionstate": "The **`iceConnectionState`** read-only property of the [RTCPeerConnection] interface returns a string which state of the  agent associated with the [RTCPeerConnection]: `new`, `checking`, `connected`, `completed`, `failed`, `disconnected`, and `closed`.\n\nIt describes the current state of the ICE agent and its connection to the ICE server;\nthat is, the  or  server.\n\nYou can detect when this value has changed by watching for the [RTCPeerConnection.iceconnectionstatechange_event] event.",
       "iceconnectionstatechange_event": "An **`iceconnectionstatechange`** event is sent to an [RTCPeerConnection] object each time the  connection state changes during the negotiation process.\nThe new ICE connection state is available in the object's [RTCPeerConnection.iceConnectionState] property.\n\nOne common task performed by the `iceconnectionstatechange` event listener is to trigger [ICE restart](/en-US/docs/Web/API/WebRTC_API/Session_lifetime#ice_restart) when the state changes to `failed`.\n\nThis event is not cancelable and does not bubble.",
-      "icegatheringstate": "The read-only property **`RTCPeerConnection.iceGatheringState`** returns a string\nthat describes the connection's ICE gathering state.\nThis lets you detect, for example, when collection of ICE candidates has finished.\n\nYou can detect when the value of this property changes by watching for an event of type\n[RTCPeerConnection.icegatheringstatechange_event].",
+      "icegatheringstate": "The **`iceGatheringState`** read-only property of the [RTCPeerConnection] interface returns a string that describes the overall ICE gathering state for this connection.\nThis lets you detect, for example, when collection of ICE candidates has finished.\n\nYou can detect when the value of this property changes by watching for an event of type [RTCPeerConnection.icegatheringstatechange_event].\n\nNote that **`iceGatheringState`** represents the overall gathering state of the connection, including every [RTCIceTransport] used by every [RTCRtpSender] and every [RTCRtpReceiver] on the entire connection.\nThis contrasts with [RTCIceTransport.gatheringState], which represents the gathering state for a single transport.",
       "icegatheringstatechange_event": "The **`icegatheringstatechange`** event is sent to the `onicegatheringstatechange` event handler on an [RTCPeerConnection] when the state of the  candidate gathering process changes.\nThis signifies that the value of the connection's [RTCPeerConnection.iceGatheringState] property has changed.\n\nWhen ICE first starts to gather connection candidates, the value changes from `new` to `gathering` to indicate that the process of collecting candidate configurations for the connection has begun. When the value changes to `complete`, all of the transports that make up the `RTCPeerConnection` have finished gathering ICE candidates.\n\n> **Note:** While you can determine that ICE candidate gathering is complete by watching for `icegatheringstatechange` events and checking for the value of [RTCPeerConnection.iceGatheringState] to become `complete`, you can also have your handler for the [RTCPeerConnection.icecandidate_event] event look to see if its [RTCPeerConnectionIceEvent.candidate] property is `null`. This also indicates that collection of candidates is finished.\n\nThis event is not cancelable and does not bubble.",
-      "localdescription": "The read-only property **`RTCPeerConnection.localDescription`** returns an [RTCSessionDescription] describing the session for the local end of the connection.\nIf it has not yet been set, this is `null`.",
+      "localdescription": "The **`localDescription`** read-only property of the [RTCPeerConnection] interface returns an [RTCSessionDescription] describing the session for the local end of the connection.\nIf it has not yet been set, this is `null`.",
       "negotiationneeded_event": "A **`negotiationneeded`** event is sent to the [RTCPeerConnection] when negotiation of the connection through the signaling channel is required.\nThis occurs both during the initial setup of the connection as well as any time a change to the communication environment requires reconfiguring the connection.\n\nThe `negotiationneeded` event is first dispatched to the [RTCPeerConnection] when media is first added to the connection. This starts the process of  negotiation by instructing your code to begin exchanging ICE candidates through the signaling server. See [Signaling transaction flow](/en-US/docs/Web/API/WebRTC_API/Signaling_and_video_calling#signaling_transaction_flow) for a description of the signaling process that begins with a `negotiationneeded` event.\n\nThis event is not cancelable and does not bubble.",
-      "peeridentity": "The read-only [RTCPeerConnection] property\n**`peerIdentity`** returns a JavaScript `Promise`\nthat resolves to an [RTCIdentityAssertion] which contains a\nstring identifying the remote peer. Once this promise\nresolves successfully, the resulting identity is the **target peer\nidentity** and cannot change for the duration of the connection.",
-      "pendinglocaldescription": "The read-only property\n**`RTCPeerConnection.pendingLocalDescription`** returns an\n[RTCSessionDescription] object describing a pending configuration change\nfor the local end of the connection. This does not describe the connection as it\ncurrently stands, but as it may exist in the near future. Use\n[RTCPeerConnection.currentLocalDescription] or\n[RTCPeerConnection.localDescription] to get the current state of the\nendpoint. For details on the difference, see\n[Pending and current descriptions](/en-US/docs/Web/API/WebRTC_API/Connectivity#pending_and_current_descriptions) in the WebRTC Connectivity page.",
-      "pendingremotedescription": "The read-only property\n**`RTCPeerConnection.pendingRemoteDescription`** returns an\n[RTCSessionDescription] object describing a pending configuration change\nfor the remote end of the connection. This does not describe the connection as it\ncurrently stands, but as it may exist in the near future. Use\n[RTCPeerConnection.currentRemoteDescription] or\n[RTCPeerConnection.remoteDescription] to get the current session\ndescription for the remote endpoint. For details on the difference, see\n[Pending and current descriptions](/en-US/docs/Web/API/WebRTC_API/Connectivity#pending_and_current_descriptions) in the WebRTC Connectivity page.",
-      "remotedescription": "The read-only property\n**`RTCPeerConnection.remoteDescription`** returns a\n[RTCSessionDescription] describing the session (which includes\nconfiguration and media information) for the remote end of the connection. If this\nhasn't been set yet, this is `null`.\n\nThe returned value typically reflects a remote description which has been received over\nthe signaling server (as either an offer or an answer) and then put into effect by your\ncode calling [RTCPeerConnection.setRemoteDescription] in response.",
-      "removestream": "The\n**`RTCPeerConnection.removeStream()`** method removes a\n[MediaStream] as a local source of audio or video. If the negotiation\nalready happened, a new one will be needed for the remote peer to be able to use it.\nBecause this method has been deprecated, you should instead use\n[RTCPeerConnection.removeTrack] if your target browser\nversions have implemented it.\n\nIf the [RTCPeerConnection.signalingState] is set to\n`\"closed\"`, an `InvalidStateError` is raised. If the\n[RTCPeerConnection.signalingState] is set to\n`\"stable\"`, the event [RTCPeerConnection.negotiationneeded_event] is sent on the\n[RTCPeerConnection].",
+      "peeridentity": "The **`peerIdentity`** read-only property of the [RTCPeerConnection] interface returns a JavaScript `Promise` that resolves to an [RTCIdentityAssertion] which contains a string identifying the remote peer.\nOnce this promise resolves successfully, the resulting identity is the **target peer identity** and cannot change for the duration of the connection.",
+      "pendinglocaldescription": "The **`pendingLocalDescription`** read-only property of the [RTCPeerConnection] interface returns an [RTCSessionDescription] object describing a pending configuration change for the local end of the connection.\n\nThis does not describe the connection as it currently stands, but as it may exist in the near future.\nUse [RTCPeerConnection.currentLocalDescription] or [RTCPeerConnection.localDescription] to get the current state of the endpoint.\nFor details on the difference, see [Pending and current descriptions](/en-US/docs/Web/API/WebRTC_API/Connectivity#pending_and_current_descriptions) in the WebRTC Connectivity page.",
+      "pendingremotedescription": "The **`pendingRemoteDescription`** read-only property of the [RTCPeerConnection] interface returns an [RTCSessionDescription] object describing a pending configuration change for the remote end of the connection.\n\nThis does not describe the connection as it currently stands, but as it may exist in the near future.\nUse [RTCPeerConnection.currentRemoteDescription] or [RTCPeerConnection.remoteDescription] to get the current session\ndescription for the remote endpoint.\nFor details on the difference, see [Pending and current descriptions](/en-US/docs/Web/API/WebRTC_API/Connectivity#pending_and_current_descriptions) in the WebRTC Connectivity page.",
+      "remotedescription": "The **`remoteDescription`** read-only property of the [RTCPeerConnection] interface returns a [RTCSessionDescription] describing the session (which includes configuration and media information) for the remote end of the connection.\nIf this hasn't been set yet, this is `null`.\n\nThe returned value typically reflects a remote description which has been received over the signaling server (as either an offer or an answer) and then put into effect by your code calling [RTCPeerConnection.setRemoteDescription] in response.",
+      "removestream": "The **`removeStream()`** method of the [RTCPeerConnection] interface removes a [MediaStream] as a local source of audio or video.\nIf the negotiation already happened, a new one will be needed for the remote peer to be able to use it.\nBecause this method has been deprecated, you should instead use [RTCPeerConnection.removeTrack] if your target browser versions have implemented it.\n\nIf the [RTCPeerConnection.signalingState] is set to `\"closed\"`, an `InvalidStateError` is raised.\nIf the [RTCPeerConnection.signalingState] is set to `\"stable\"`, the event [RTCPeerConnection.negotiationneeded_event] is sent on the [RTCPeerConnection].",
       "removestream_event": "The obsolete **`removestream`** event was sent to an [RTCPeerConnection] to inform it that a [MediaStream] had been removed from the connection.\nYou can use the `RTCPeerConnection` interface's `onremovestream` property to set a handler for this event.\n\nThis is the counterpart to the [RTCPeerConnection.addstream_event] event, which is also obsolete.\n\n> **Warning:** This event has been removed from the WebRTC specification in favor of the existing [MediaStream.removetrack_event] event on the remote [MediaStream] and the corresponding event handler property of the remote [MediaStream]. The [RTCPeerConnection] API is now track-based, so having zero tracks in the remote stream is equivalent to the remote stream being removed, which caused a `removestream` event.\n\nThis event is not cancelable and does not bubble.",
-      "removetrack": "The\n**`RTCPeerConnection.removeTrack()`** method tells the local\nend of the connection to stop sending media from the specified track, without actually\nremoving the corresponding [RTCRtpSender] from the list of senders as\nreported by [RTCPeerConnection.getSenders]. If the track is\nalready stopped, or is not in the connection's senders list, this method has no effect.\n\nIf the connection has already been negotiated\n([RTCPeerConnection.signalingState] is set to\n`\"stable\"`), it is marked as needing to be negotiated again; the remote peer\nwon't experience the change until this negotiation occurs. A\n[RTCPeerConnection.negotiationneeded_event] event is sent to the [RTCPeerConnection] to\nlet the local end know this negotiation must occur.",
-      "restartice": "The [WebRTC](https://developer.mozilla.org/en-US/docs/Web/API/WebRTC_API) API's\n[RTCPeerConnection] interface offers the\n**`restartIce()`** method to allow a web application to easily\nrequest that  candidate gathering be redone on both ends of the\nconnection.\nThis simplifies the process by allowing the same method to be used\nby either the caller or the receiver to trigger an ICE restart.\n\nAfter `restartIce()` returns, the offer returned by the next call to\n[RTCPeerConnection.createOffer] is automatically\nconfigured to trigger ICE restart on both the local peer (once the local peer has been\nset) and on the remote peer, once the offer is sent across your signaling mechanism and\nthe remote peer has set its description as well.\n\n`restartIce()` causes the\n[RTCPeerConnection.negotiationneeded_event] event to\nbe fired on the `RTCPeerConnection` to inform the application that it should\nperform negotiation using its signaling channel.\n\nIf negotiation fails to complete—either due to rollback or because incoming offers are\nin the process of being negotiated—the [RTCPeerConnection] will remember\nthat you requested ICE restart. The next time the connection's\n[RTCPeerConnection.signalingState] changes to\n`stable`, the connection will fire the\n[RTCPeerConnection.negotiationneeded_event] event.\nThis process continues until an ICE restart has been successfully completed.",
+      "removetrack": "The **`removeTrack()`** method of the [RTCPeerConnection] interface tells the local end of the connection to stop sending media from the specified track, without actually removing the corresponding [RTCRtpSender] from the list of senders as reported by [RTCPeerConnection.getSenders].\nIf the track is already stopped, or is not in the connection's senders list, this method has no effect.\n\nIf the connection has already been negotiated ([RTCPeerConnection.signalingState] is set to `\"stable\"`), it is marked as needing to be negotiated again; the remote peer won't experience the change until this negotiation occurs.\nA [RTCPeerConnection.negotiationneeded_event] event is sent to the [RTCPeerConnection] to let the local end know this negotiation must occur.",
+      "restartice": "The **`restartIce()`** method of the [RTCPeerConnection] interface allows a web application to request that  candidate gathering be redone on both ends of the connection.\nThis simplifies the process by allowing the same method to be used by either the caller or the receiver to trigger an ICE restart.\n\nAfter `restartIce()` returns, the offer returned by the next call to [RTCPeerConnection.createOffer] is automatically configured to trigger ICE restart on both the local peer (once the local peer has been set) and on the remote peer, once the offer is sent across your signaling mechanism and the remote peer has set its description as well.\n\n`restartIce()` causes the\n[RTCPeerConnection.negotiationneeded_event] event to be fired on the `RTCPeerConnection` to inform the application that it should perform negotiation using its signaling channel.\n\nIf negotiation fails to complete—either due to rollback or because incoming offers are in the process of being negotiated—the [RTCPeerConnection] will remember that you requested ICE restart.\nThe next time the connection's [RTCPeerConnection.signalingState] changes to `stable`, the connection will fire the [RTCPeerConnection.negotiationneeded_event] event.\nThis process continues until an ICE restart has been successfully completed.",
       "rtcpeerconnection": "The **`RTCPeerConnection()`** constructor returns a newly-created [RTCPeerConnection], which represents a connection between the local device and a remote peer.",
-      "sctp": "The read-only **`sctp`** property on the [RTCPeerConnection] interface returns an [RTCSctpTransport] describing the  transport over which SCTP data is being sent and\nreceived.\nIf SCTP hasn't been negotiated, this value is `null`.\n\nThe SCTP transport is used for transmitting and receiving data for any and all [RTCDataChannel]s on the peer connection.",
-      "setconfiguration": "The **`RTCPeerConnection.setConfiguration()`** method sets the\ncurrent configuration of the [RTCPeerConnection] based on the values\nincluded in the specified object. This lets you change\nthe ICE servers used by the connection and which transport policies to use.\n\nThe most common use case for this method (and even then, probably not a very common use\ncase) is to replace the set of ICE servers to be used. Two potential scenarios in which\nthis might be done:\n\n- The [RTCPeerConnection] was instantiated without specifying any ICE\n  servers. If, for example, the [RTCPeerConnection.RTCPeerConnection] constructor was called with no parameters, you would have to\n  then call `setConfiguration()` to add ICE servers before ICE negotiation could begin.\n- Renegotiation of the connection is needed, and a different set of ICE servers needs\n  to be used for some reason. Perhaps the user has moved into a new region, so using new\n  regional ICE servers is necessary, for example.\n  In this situation, one might call `setConfiguration()` to switch to new regional ICE servers, then initiate an [ICE restart](/en-US/docs/Web/API/WebRTC_API/Session_lifetime#ice_restart).\n\n> **Note:** You cannot change the identity information for a connection once it's already been set.",
-      "setidentityprovider": "The **`RTCPeerConnection.setIdentityProvider()`** method sets\nthe Identity Provider (IdP) to the triplet given in parameter: its name, the protocol\nused to communicate with it (optional) and an optional username. The IdP will be used\nonly when an assertion is needed.\n\nIf the [RTCPeerConnection.signalingState] is set to\n`\"closed\"`, an `InvalidStateError` is raised.",
-      "setlocaldescription": "The [RTCPeerConnection] method\n[RTCPeerConnection.setLocalDescription] changes\nthe local description associated with the connection. This description specifies the\nproperties of the local end of the connection, including the media format.\nThe method takes a single parameter—the session description—and it returns a\n`Promise` which is fulfilled once the description has been changed,\nasynchronously.\n\nIf `setLocalDescription()` is called while a connection is already in place,\nit means renegotiation is underway (possibly to adapt to changing network conditions).\nBecause descriptions will be exchanged until the two peers agree on a configuration, the\ndescription submitted by calling `setLocalDescription()` does not immediately\ntake effect. Instead, the current connection configuration remains in place until\nnegotiation is complete. Only then does the agreed-upon configuration take effect.",
-      "setremotedescription": "The [RTCPeerConnection]\nmethod **`setRemoteDescription()`** sets the specified\nsession description as the remote peer's current offer or answer. The description\nspecifies the properties of the remote end of the connection, including the media\nformat. The method takes a single parameter—the session description—and it\nreturns a `Promise` which is fulfilled once the description has been\nchanged, asynchronously.\n\nThis is typically called after receiving an offer or answer from another peer over the\nsignaling server. Keep in mind that if `setRemoteDescription()` is called\nwhile a connection is already in place, it means renegotiation is underway (possibly\nto adapt to changing network conditions).\n\nBecause descriptions will be exchanged until the two peers agree on a configuration,\nthe description submitted by calling `setRemoteDescription()` does not\nimmediately take effect. Instead, the current connection configuration remains in\nplace until negotiation is complete. Only then does the agreed-upon configuration take\neffect.",
-      "signalingstate": "The read-only **`signalingState`** property on the\n[RTCPeerConnection] interface returns a string value\ndescribing the state of the signaling process\non the local end of the connection\nwhile connecting or reconnecting to another peer.\nSee [Signaling](/en-US/docs/Web/API/WebRTC_API/Session_lifetime#signaling) in our WebRTC session lifetime page.\n\nBecause the signaling process is a state machine, being able to verify that your code\nis in the expected state when messages arrive can help avoid unexpected and avoidable\nfailures. For example, if you receive an answer while the `signalingState`\nisn't `\"have-local-offer\"`, you know that something is wrong, since you\nshould only receive answers after creating an offer but before an answer has been\nreceived and passed into [RTCPeerConnection.setLocalDescription]. Your\ncode will be more reliable if you watch for mismatched states like this and handle them\ngracefully.\n\nThis value may also be useful during debugging, for example.\n\nIn addition, when the value of this property changes, a\n[RTCPeerConnection.signalingstatechange_event] event is sent to the [RTCPeerConnection]\ninstance.",
+      "sctp": "The **`sctp`** read-only property of the [RTCPeerConnection] interface returns an [RTCSctpTransport] describing the  transport over which SCTP data is being sent and received.\nIf SCTP hasn't been negotiated, this value is `null`.\n\nThe SCTP transport is used for transmitting and receiving data for any and all [RTCDataChannel]s on the peer connection.",
+      "setconfiguration": "The **`setConfiguration()`** method of the [RTCPeerConnection] interface sets the current configuration of the connection based on the values included in the specified object.\nThis lets you change the ICE servers used by the connection and which transport policies to use.\n\nThe most common use case for this method (and even then, probably not a very common use case) is to replace the set of ICE servers to be used. Two potential scenarios in which this might be done:\n\n- The [RTCPeerConnection] was instantiated without specifying any ICE servers.\n  If, for example, the [RTCPeerConnection.RTCPeerConnection] constructor was called with no parameters, you would have to then call `setConfiguration()` to add ICE servers before ICE negotiation could begin.\n- Renegotiation of the connection is needed, and a different set of ICE servers needs to be used for some reason.\n  Perhaps the user has moved into a new region, so using new regional ICE servers is necessary, for example.\n  In this situation, one might call `setConfiguration()` to switch to new regional ICE servers, then initiate an [ICE restart](/en-US/docs/Web/API/WebRTC_API/Session_lifetime#ice_restart).\n\n> **Note:** You cannot change the identity information for a connection once it's already been set.",
+      "setidentityprovider": "The **`setIdentityProvider()`** method of the [RTCPeerConnection] interface sets the Identity Provider (IdP) to the triplet given in parameter: its name, the protocol used to communicate with it (optional) and an optional username.\nThe IdP will be used only when an assertion is needed.\n\nIf the [RTCPeerConnection.signalingState] is set to `\"closed\"`, an `InvalidStateError` is raised.",
+      "setlocaldescription": "The **`setLocalDescription()`** method of the [RTCPeerConnection] interface changes the local description associated with the connection.\nThis description specifies the properties of the local end of the connection, including the media format.\nThe method takes a single parameter—the session description—and it returns a `Promise` which is fulfilled once the description has been changed, asynchronously.\n\nIf `setLocalDescription()` is called while a connection is already in place, it means renegotiation is underway (possibly to adapt to changing network conditions).\nBecause descriptions will be exchanged until the two peers agree on a configuration, the description submitted by calling `setLocalDescription()` does not immediately take effect.\nInstead, the current connection configuration remains in place until negotiation is complete. Only then does the agreed-upon configuration take effect.",
+      "setremotedescription": "The **`setRemoteDescription()`** method of the [RTCPeerConnection] interface sets the specified session description as the remote peer's current offer or answer.\nThe description specifies the properties of the remote end of the connection, including the media format.\nThe method takes a single parameter—the session description—and it returns a `Promise` which is fulfilled once the description has been changed, asynchronously.\n\nThis is typically called after receiving an offer or answer from another peer over the signaling server.\nKeep in mind that if `setRemoteDescription()` is called while a connection is already in place, it means renegotiation is underway (possibly to adapt to changing network conditions).\n\nBecause descriptions will be exchanged until the two peers agree on a configuration, the description submitted by calling `setRemoteDescription()` does not immediately take effect.\nInstead, the current connection configuration remains in place until negotiation is complete.\nOnly then does the agreed-upon configuration take effect.",
+      "signalingstate": "The **`signalingState`** read-only property of the [RTCPeerConnection] interface returns a string value describing the state of the signaling process on the local end of the connection while connecting or reconnecting to another peer.\nSee [Signaling](/en-US/docs/Web/API/WebRTC_API/Session_lifetime#signaling) in our WebRTC session lifetime page.\n\nBecause the signaling process is a state machine, being able to verify that your code is in the expected state when messages arrive can help avoid unexpected and avoidable failures.\nFor example, if you receive an answer while the `signalingState` isn't `\"have-local-offer\"`, you know that something is wrong, since you should only receive answers after creating an offer but before an answer has been received and passed into [RTCPeerConnection.setLocalDescription]. Your code will be more reliable if you watch for mismatched states like this and handle them gracefully.\n\nThis value may also be useful during debugging, for example.\n\nIn addition, when the value of this property changes, a [RTCPeerConnection.signalingstatechange_event] event is sent to the [RTCPeerConnection] instance.",
       "signalingstatechange_event": "A **`signalingstatechange`** event is sent to an [RTCPeerConnection] to notify it that its signaling state, as indicated by the [RTCPeerConnection.signalingState] property, has changed.\n\nThis event is not cancelable and does not bubble.",
       "track_event": "The **`track`** event is sent to the `ontrack` event handler on [RTCPeerConnection]s after a new track has been added to an [RTCRtpReceiver] which is part of the connection.\n\nBy the time this event is delivered, the new track has been fully added to the peer connection. See [Track event types](/en-US/docs/Web/API/RTCTrackEvent#track_event_types) for details.\n\nThis event is not cancellable and does not bubble."
     }
@@ -6335,6 +6470,7 @@
       "getparameters": "The **`getParameters()`** method of the [RTCRtpReceiver] interface returns an object describing the current configuration for the encoding and transmission of media on the receiver's [RTCRtpReceiver.track].",
       "getstats": "The [RTCRtpReceiver] method **`getStats()`** asynchronously requests an [RTCStatsReport] object which provides statistics about incoming traffic on the owning [RTCPeerConnection], returning a `Promise` whose fulfillment handler will be called once the results are available.",
       "getsynchronizationsources": "The **`getSynchronizationSources()`** method of the [RTCRtpReceiver] interface returns an array of objects, each corresponding to one SSRC (synchronization source) identifier received by the current `RTCRtpReceiver` in the last ten seconds.",
+      "jitterbuffertarget": "The **`jitterBufferTarget`** property of the [RTCRtpReceiver] interface is a [DOMHighResTimeStamp] that indicates the application's preferred duration, in milliseconds, for which the jitter buffer should hold media before playing it out.\n\nThe application can use it to influence the tradeoff between playout delay and the risk of running out of audio or video frames due to network jitter.",
       "track": "The **`track`** read-only property of the\n[RTCRtpReceiver] interface returns the [MediaStreamTrack]\nassociated with the current [RTCRtpReceiver] instance.",
       "transform": "The **`transform`** property of the [RTCRtpReceiver] object is used to insert a transform stream ([TransformStream]) running in a worker thread into the receiver pipeline.\nThis allows stream transforms to be applied to encoded video and audio frames as they arrive from the packetizer (before they are played/rendered).\n\nThe transform that is to be added is defined using an [RTCRtpScriptTransform] and its associated [Worker].\nIf the transform is set in the peer connection [`track` event](https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/track_event) handler, the transform stream will receive the first full incoming frame for the track.\n\n### Value\n\nA [RTCRtpScriptTransform]<!-- or [SFrameTransform] -->, or `null` if the receiver has no associated transform stream.",
       "transport": "The read-only **`transport`** property of an\n[RTCRtpReceiver] object provides the [RTCDtlsTransport] object\nused to interact with the underlying transport over which the receiver is exchanging\nReal-time Transport Control Protocol () packets.\n\nThis transport is responsible for receiving the data for the media on the receiver's\n[RTCRtpReceiver.track]."
@@ -6454,6 +6590,20 @@
       "type": "The **`type`** property of the [RTCTransportStats] dictionary is a string with the value `\"transport\"`.\n\nDifferent statistics are obtained by iterating the [RTCStatsReport] object returned by a call to [RTCPeerConnection.getStats].\nThe type indicates the set of statistics available through the object in a particular iteration step.\nA value of `\"transport\"` indicates that the statistics available in the current step are those defined in [RTCTransportStats]."
     }
   },
+  "RTCVideoSourceStats": {
+    "docs": "The **`RTCVideoSourceStats`** dictionary of the [WebRTC API](https://developer.mozilla.org/en-US/docs/Web/API/WebRTC_API) provides statistics information about a video track ([MediaStreamTrack]) that is attached to one or more senders ([RTCRtpSender]).\n\nThese statistics can be obtained by iterating the [RTCStatsReport] returned by [RTCRtpSender.getStats] or [RTCPeerConnection.getStats] until you find a report with the [`type`](#type) of `media-source` and a [`kind`](#kind) of `video`.\n\n> **Note:** For video information about remotely sourced tracks (that are being received), see [RTCInboundRtpStreamStats].",
+    "properties": {
+      "frames": "The **`frames`** property of the [RTCVideoSourceStats] dictionary indicates the total number of frames originating from this video source over its lifetime.",
+      "framespersecond": "The **`framesPerSecond`** property of the [RTCVideoSourceStats] dictionary indicates the number of frames originating from this video source in the last second.\n\nThe property is not defined on the stats object for the first second of its lifetime.",
+      "height": "The **`height`** property of the [RTCVideoSourceStats] dictionary indicates the height, in pixels, of the last frame originating from this source.\n\nThis property is not defined on the stats object until after the first frame has been produced.",
+      "id": "The **`id`** property of the [RTCVideoSourceStats] dictionary is a string which uniquely identifies the object for which this object provides statistics.\n\nUsing the `id`, you can correlate this statistics object with others, in order to monitor statistics over time for a given WebRTC object, such as an [RTCPeerConnection], or an [RTCDataChannel].",
+      "kind": "The **`kind`** property of the [RTCVideoSourceStats] dictionary is a string with the value `video`.\n\nThe `kind` is used to differentiate between audio and video media sources when iterating an [RTCStatsReport], which both have a [RTCVideoSourceStats.type] of `media-source` (a `kind` of `audio` indicates an [RTCAudioSourceStats] object).",
+      "timestamp": "The **`timestamp`** property of the [RTCVideoSourceStats] dictionary is a [DOMHighResTimeStamp] object specifying the time at which the data in the object was sampled.\n\nThe time is given in milliseconds elapsed since the first moment of January 1, 1970, UTC (also known as [Unix time](https://developer.mozilla.org/en-US/docs/Glossary/Unix_time)).",
+      "trackidentifier": "The **`trackIdentifier`** property of the [RTCVideoSourceStats] dictionary contains the `id` attribute of the associated [`MediaStreamTrack`](https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrack).",
+      "type": "The **`type`** property of the [RTCVideoSourceStats] dictionary is a string with value `media-source`.\n\nThe type of `media-source` identifies the type of statistics as either [RTCAudioSourceStats] or [RTCVideoSourceStats] when iterating the [RTCStatsReport] returned by [RTCRtpSender.getStats] or [RTCPeerConnection.getStats].\nThe type of stats can further be differentiated using the [RTCVideoSourceStats.kind], which will be `video` for `RTCVideoSourceStats`.",
+      "width": "The **`width`** property of the [RTCVideoSourceStats] dictionary indicates the width, in pixels, of the last frame originating from this source.\n\nThis property is not defined on the stats object until after the first frame has been produced."
+    }
+  },
   "RadioNodeList": {
     "docs": "The **`RadioNodeList`** interface represents a collection of elements in a `form` or a `fieldset` element, returned by a call to [HTMLFormControlsCollection.namedItem].",
     "properties": {
@@ -6521,7 +6671,7 @@
     }
   },
   "ReadableStreamBYOBReader": {
-    "docs": "The `ReadableStreamBYOBReader` interface of the [Streams API](https://developer.mozilla.org/en-US/docs/Web/API/Streams_API) defines a reader for a [ReadableStream] that supports zero-copy reading from an underlying byte source.\nIt is used for efficient copying from underlying sources where the data is delivered as an \"anonymous\" sequence of bytes, such as files.\n\nAn instance of this reader type should usually be obtained by calling [ReadableStream.getReader] on the stream, specifying `mode: \"byob\"` in the options parameter.\nThe readable stream must have an _underlying byte source_. In other words, it must have been [constructed](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/ReadableStream) specifying an underlying source with [`type: \"bytes\"`](/en-US/docs/Web/API/ReadableStream/ReadableStream#type)).\n\nUsing this kind of reader, a [`read()`](#readablestreambyobreader.read) request when the readable stream's internal queues are empty will result in a zero copy transfer from the underlying source (bypassing the stream's internal queues).\nIf the internal queues are not empty, a `read()` will satisfy the request from the buffered data.\n\nNote that the methods and properties are similar to those for the default reader ([ReadableStreamDefaultReader]).\nThe `read()` method differs in that it provide a view into which data should be written.",
+    "docs": "The `ReadableStreamBYOBReader` interface of the [Streams API](https://developer.mozilla.org/en-US/docs/Web/API/Streams_API) defines a reader for a [ReadableStream] that supports zero-copy reading from an underlying byte source.\nIt is used for efficient copying from underlying sources where the data is delivered as an \"anonymous\" sequence of bytes, such as files.\n\nAn instance of this reader type should usually be obtained by calling [ReadableStream.getReader] on the stream, specifying `mode: \"byob\"` in the options parameter.\nThe readable stream must have an _underlying byte source_. In other words, it must have been [constructed](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/ReadableStream) specifying an underlying source with [`type: \"bytes\"`](/en-US/docs/Web/API/ReadableStream/ReadableStream#type)).\n\nUsing this kind of reader, a [`read()`](#readablestreambyobreader.read) request when the readable stream's internal queues are empty will result in a zero copy transfer from the underlying source (bypassing the stream's internal queues).\nIf the internal queues are not empty, a `read()` will satisfy the request from the buffered data.\n\nNote that the methods and properties are similar to those for the default reader ([ReadableStreamDefaultReader]).\nThe `read()` method differs in that it provides a view into which data should be written.",
     "properties": {
       "cancel": "The **`cancel()`** method of the [ReadableStreamBYOBReader] interface returns a `Promise` that resolves when the stream is canceled.\nCalling this method signals a loss of interest in the stream by a consumer.\n\n> **Note:** If the reader is active, the `cancel()` method behaves the same as that for the associated stream ([ReadableStream.cancel]).",
       "closed": "The **`closed`** read-only property of the [ReadableStreamBYOBReader] interface returns a `Promise` that fulfills when the stream closes, or rejects if the stream throws an error or the reader's lock is released.\n\nThis property enables you to write code that responds to an end to the streaming process.",
@@ -6608,7 +6758,7 @@
       "cache": "The **`cache`** read-only property of the [Request] interface contains the cache mode of the request. It controls how the request will interact with the browser's [HTTP cache](https://developer.mozilla.org/en-US/docs/Web/HTTP/Caching).",
       "clone": "The **`clone()`** method of the [Request] interface creates a copy of the current `Request` object.\n\nLike the underlying [ReadableStream.tee] api,\nthe [Request.body] of a cloned `Response`\nwill signal backpressure at the rate of the _faster_ consumer of the two bodies,\nand unread data is enqueued internally on the slower consumed `body`\nwithout any limit or backpressure.\nBeware when you construct a `Request` from a stream and then `clone` it.\n\n`clone()` throws a `TypeError` if the request body has already been used. In fact, the main reason `clone()` exists is to allow multiple uses of body objects (when they are one-use only.)\n\nIf you intend to modify the request, you may prefer the [Request] constructor.",
       "credentials": "The **`credentials`** read-only property of the [Request] interface indicates whether the user agent should send or receive cookies from the other domain in the case of cross-origin requests.",
-      "destination": "The **`destination`** read-only\nproperty of the **[Request]** interface returns a string\ndescribing the type of content being requested.\n\nThe string must be one of the `audio`, `audioworklet`,\n`document`, `embed`, `fencedframe`, `font`, `frame`,\n`iframe`, `image`, `manifest`, `object`,\n`paintworklet`, `report`, `script`, `sharedworker`,\n`style`, `track`, `video`, `worker`\nor `xslt` strings, or the empty string, which is the default value.\n\nThe `destination` is used by the  to, for example,\nhelp determine which set of rules to follow for CORS purposes, or how to navigate any\ncomplicated code paths that affect how specific types of request get handled.\n\nThese destinations vary substantially in how they operate. Some are data receptacles,\nwhere the received data is stored for processing later. Others are script-based, in\nwhich case the received data is delivered to a script by calling it and passing the data\nalong. Script-based destinations include `script` elements, as well as\nany of the [Worklet]-based destinations\n(including subclasses like [AudioWorklet]), and the\n[Worker]-based destinations, including [ServiceWorker]\nand [SharedWorker].",
+      "destination": "The **`destination`** read-only\nproperty of the **[Request]** interface returns a string\ndescribing the type of content being requested.\n\nThe string must be one of the `audio`, `audioworklet`,\n`document`, `embed`, `fencedframe`, `font`, `frame`,\n`iframe`, `image`, `json`, `manifest`, `object`,\n`paintworklet`, `report`, `script`, `sharedworker`,\n`style`, `track`, `video`, `worker`\nor `xslt` strings, or the empty string, which is the default value.\n\nThe `destination` is used by the  to, for example,\nhelp determine which set of rules to follow for CORS purposes, or how to navigate any\ncomplicated code paths that affect how specific types of request get handled.\n\nThese destinations vary substantially in how they operate. Some are data receptacles,\nwhere the received data is stored for processing later. Others are script-based, in\nwhich case the received data is delivered to a script by calling it and passing the data\nalong. Script-based destinations include `script` elements, as well as\nany of the [Worklet]-based destinations\n(including subclasses like [AudioWorklet]), and the\n[Worker]-based destinations, including [ServiceWorker]\nand [SharedWorker].",
       "formdata": "The **`formData()`** method of the [Request] interface\nreads the request body and returns it as a promise that resolves with a [FormData] object.",
       "headers": "The **`headers`** read-only property of the\n[Request] interface contains the [Headers] object associated\nwith the request.",
       "integrity": "The **`integrity`** read-only property of the [Request] interface contains the [subresource integrity](https://developer.mozilla.org/en-US/docs/Web/Security/Subresource_Integrity) value of the request.",
@@ -7238,18 +7388,20 @@
       "collapsetostart": "The **`Selection.collapseToStart()`** method collapses the\nselection to the start of the first range in the selection. If the content of the\nselection is focused and editable, the caret will blink there.",
       "containsnode": "The **`Selection.containsNode()`** method indicates whether a\nspecified node is part of the selection.",
       "deletefromdocument": "The **`deleteFromDocument()`** method of the\n[Selection] interface deletes the selected text from the document's DOM.",
+      "direction": "The **`direction`** read-only property of the [Selection] interface is a string that provides the direction of the current selection.\n\nThe value is determined by the order in which the user chooses the boundary points of the selection.\nFor example, a user might make a selection by clicking a starting boundary point, dragging the cursor, and releasing at an end boundary point.\nIf the end boundary point is later in the document than the start point, then the direction is \"forwards\", while the direction is \"backwards\" if the end point is before the start point within the document.\nThe value is \"directionless\" if no direction is implied by the user. For example, if the user made the selection by double-clicking on a word or element, or the selection was made programmatically.\n\nThe direction does not change if a selection's range is mutated, for example, using methods like [Range.selectNode].",
       "empty": "The **`Selection.empty()`** method removes all ranges from the selection, leaving the [Selection.anchorNode] and [Selection.focusNode] properties equal to `null` and nothing selected. When this method is called, a [Document.selectionchange_event] event is fired at the document.\n\n> **Note:** This method is an alias for the [Selection.removeAllRanges] method.",
       "extend": "The **`Selection.extend()`** method moves the focus of the\nselection to a specified point. The anchor of the selection does not move. The selection\nwill be from the anchor to the new focus, regardless of direction.",
       "focusnode": "The **`Selection.focusNode`** read-only property returns the\n[Node] in which the selection ends.\n\nA user may make a selection from left to right (in document order) or right to left\n(reverse of document order). The focus is where the user ended the selection. This can\nbe visualized by holding the <kbd>Shift</kbd> key and pressing the arrow keys on your\nkeyboard to modify the current selection. The selection's focus moves, but the\nselection's anchor, the other end of the selection, does not move.",
       "focusoffset": "The **`Selection.focusOffset`** read-only property returns the\nnumber of characters that the selection's focus is offset within the\n[Selection.focusNode].\n\nThis number is zero-based. If the selection ends with the first character in the\n[Selection.focusNode], `0` is returned.",
-      "getrangeat": "The **`Selection.getRangeAt()`** method returns a range object\nrepresenting one of the ranges currently selected.",
+      "getcomposedranges": "The **`Selection.getComposedRanges()`** method returns an array of [StaticRange] objects representing the current selection ranges, and can return ranges that potentially cross shadow boundaries.\n\nAs the selection range endpoints may be within a shadow tree, or even different shadow trees, and because these may be closed, the method cannot by default return nodes from within a shadow tree.\nIf the method needs to return a selection that includes nodes inside shadow trees, then the [ShadowRoot] objects for these trees must be passed as arguments to the method.\nIf a corresponding roots are not provided and the start or endpoint of the selection are within a shadow tree, the returned range is re-scoped to include the host of the shadow root rather than some node with in the root.\n\nThe returned ranges represent the range at the time that `getComposedRanges()` was called.\nIf the DOM or a shadow DOM is mutated, the selected range is likely to be incorrect.\nApplication code might use a [MutationObserver] to monitor for DOM mutations and then call [Selection.setBaseAndExtent] to update the selection.\n\n> **Note:** This method should be used instead of [Selection.getRangeAt] when selecting ranges that can potentially cross shadow root boundaries.\n> [Selection.getRangeAt] is not aware of shadow roots.\n> The returned range is not specified, and varies between browsers.",
+      "getrangeat": "The **`getRangeAt()`** method of the [Selection] interface returns a range object representing a currently selected range.\n\nIf the endpoints of the selected range are within a  then JavaScript does not have visibility of the shadow nodes, and the method should re-scope the range to include the host element that contains the end point.\nIn practice most browsers do not yet implement this behavior, and the returned range is unpredictable.\n\n> **Note:** When selecting within nodes that might contain a shadow root, you can use [Selection.getComposedRanges] (if supported) to get a selection range inside a shadow tree, or to reliably re-scope the selection to the host node.",
       "iscollapsed": "The **`Selection.isCollapsed`** read-only property returns a\nboolean value which indicates whether or not there is currently any text\nselected. No text is selected when the selection's start and end points are at the same\nposition in the content.\n\nKeep in mind that a collapsed selection may still have one (or more, in Gecko)\n[Range]s, so [Selection.rangeCount] may not be zero. In that\nscenario, calling a [Selection] object's [Selection.getRangeAt]\nmethod may return a `Range` object which is collapsed.",
       "modify": "The **`Selection.modify()`** method applies a change to the\ncurrent selection or cursor position, using simple textual commands.",
       "rangecount": "The **`Selection.rangeCount`** read-only property returns the\nnumber of ranges in the selection.\n\nBefore the user has clicked a freshly loaded page, the `rangeCount` is\n`0`. After the user clicks on the page, `rangeCount` is\n`1`, even if no selection is visible.\n\nA user can normally only select one range at a time, so the `rangeCount`\nwill usually be `1`. Scripting can be used to make the selection contain more\nthan one range.\n\nGecko browsers allow multiple selections across table cells. Firefox allows to select\nmultiple ranges in the document by using Ctrl+click (unless the click occurs within an\nelement that has the `display: table-cell` CSS property assigned).",
       "removeallranges": "The **`Selection.removeAllRanges()`** method removes all ranges from the selection, leaving the [Selection.anchorNode] and [Selection.focusNode] properties equal to `null` and nothing selected. When this method is called, a [Document.selectionchange_event] event is fired at the document.\n\n> **Note:** This method is an alias for the [Selection.empty] method.",
       "removerange": "The **`Selection.removeRange()`** method removes a range from a\nselection.",
       "selectallchildren": "The **`Selection.selectAllChildren()`** method adds all the\nchildren of the specified node to the selection. Previous selection is lost.",
-      "setbaseandextent": "The **`setBaseAndExtent()`** method of the\n[Selection] interface sets the selection to be a range including all or\nparts of two specified DOM nodes, and any content located between them.",
+      "setbaseandextent": "The **`setBaseAndExtent()`** method of the [Selection] interface sets the selection to be a range including all or parts of two specified DOM nodes, and any content located between them.\n\nThe anchor and focus nodes can be located in a , if supported by the browser.",
       "setposition": "The **`Selection.setPosition()`** method collapses the current selection to a single point. The document is not modified. If the content is focused and editable, the caret will blink there.\n\n> **Note:** This method is an alias for the [Selection.collapse] method.",
       "tostring": "The **`Selection.toString()`** method returns a string\ncurrently being represented by the selection object, i.e. the currently selected text.",
       "type": "The **`type`** read-only property of the\n[Selection] interface returns a string describing the\ntype of the current selection."
@@ -7276,25 +7428,25 @@
     }
   },
   "Serial": {
-    "docs": "The `Serial` interface of the [Web_Serial_API] provides attributes and methods for finding and connecting to serial ports from a web page.",
+    "docs": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe `Serial` interface of the [Web_Serial_API] provides attributes and methods for finding and connecting to serial ports from a web page.",
     "properties": {
-      "getports": "The **`getPorts()`** method of the [Serial] interface returns a `Promise` that resolves with an array of [SerialPort] objects representing serial ports connected to the host which the origin has permission to access.",
-      "requestport": "The **`Serial.requestPort()`** method of the [Serial] interface returns a `Promise` that resolves with an instance of [SerialPort] representing the device chosen by the user or rejects if no device was selected."
+      "getports": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`getPorts()`** method of the [Serial] interface returns a `Promise` that resolves with an array of [SerialPort] objects representing serial ports connected to the host which the origin has permission to access.",
+      "requestport": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`Serial.requestPort()`** method of the [Serial] interface returns a `Promise` that resolves with an instance of [SerialPort] representing the device chosen by the user or rejects if no device was selected."
     }
   },
   "SerialPort": {
-    "docs": "The `SerialPort` interface of the [Web_Serial_API] provides access to a serial port on the host device.",
+    "docs": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe `SerialPort` interface of the [Web_Serial_API] provides access to a serial port on the host device.",
     "properties": {
-      "close": "The **`SerialPort.close()`** method of the [SerialPort] interface returns a `Promise` that resolves when the port closes.",
-      "connect_event": "The **`connect`** event of the [SerialPort] interface is fired when a port has connected to the device. This event is only fired for ports associated with removable devices such as those connected via USB.\n\nThis event bubbles to the instance of [Serial] that returned this interface.",
-      "disconnect_event": "The **`disconnect`** event of the [SerialPort] interface is fired when the port has disconnected from the device. This event is only fired for ports associated with removable devices such as those connected via USB.\n\nThis event bubbles to the instance of [Serial] that returned this interface.",
-      "forget": "The **`SerialPort.forget()`** method of the [SerialPort] interface returns a `Promise` that resolves when the serial port is closed and is forgotten.",
-      "getinfo": "The **`getInfo()`** method of the [SerialPort] interface returns an object whose properties are the vendor ID and product ID of the device.",
-      "getsignals": "The **`SerialPort.getSignals()`** method of the [SerialPort] interface returns a `Promise` that resolves with an object containing the current state of the port's control signals.",
-      "open": "The **`open()`** method of the [SerialPort] interface returns a `Promise` that resolves when the port is opened. By default the port is opened with 8 data bits, 1 stop bit and no parity checking. The `baudRate` parameter is required.",
-      "readable": "The **`readable`** read-only property of the [SerialPort] interface returns a [ReadableStream] for receiving data from the device connected to the port. Chunks read from this stream are instances of `Uint8Array`. This property is non-null as long as the port is open and has not encountered a fatal error.",
-      "setsignals": "The **`setSignals()`** method of the [SerialPort] interface sets control signals on the port and returns a `Promise` that resolves when they are set.",
-      "writable": "The **`writable`** read-only property of the [SerialPort] interface returns a [WritableStream] for sending data to the device connected to the port. Chunks written to this stream must be instances of `ArrayBuffer`, `TypedArray`, or `DataView`. This property is non-null as long as the port is open and has not encountered a fatal error."
+      "close": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`SerialPort.close()`** method of the [SerialPort] interface returns a `Promise` that resolves when the port closes.",
+      "connect_event": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`connect`** event of the [SerialPort] interface is fired when a port has connected to the device. This event is only fired for ports associated with removable devices such as those connected via USB.\n\nThis event bubbles to the instance of [Serial] that returned this interface.",
+      "disconnect_event": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`disconnect`** event of the [SerialPort] interface is fired when the port has disconnected from the device. This event is only fired for ports associated with removable devices such as those connected via USB.\n\nThis event bubbles to the instance of [Serial] that returned this interface.",
+      "forget": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`SerialPort.forget()`** method of the [SerialPort] interface returns a `Promise` that resolves when the serial port is closed and is forgotten.",
+      "getinfo": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`getInfo()`** method of the [SerialPort] interface returns an object whose properties are the vendor ID and product ID of the device.",
+      "getsignals": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`SerialPort.getSignals()`** method of the [SerialPort] interface returns a `Promise` that resolves with an object containing the current state of the port's control signals.",
+      "open": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`open()`** method of the [SerialPort] interface returns a `Promise` that resolves when the port is opened. By default the port is opened with 8 data bits, 1 stop bit and no parity checking. The `baudRate` parameter is required.",
+      "readable": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`readable`** read-only property of the [SerialPort] interface returns a [ReadableStream] for receiving data from the device connected to the port. Chunks read from this stream are instances of `Uint8Array`. This property is non-null as long as the port is open and has not encountered a fatal error.",
+      "setsignals": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`setSignals()`** method of the [SerialPort] interface sets control signals on the port and returns a `Promise` that resolves when they are set.",
+      "writable": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`writable`** read-only property of the [SerialPort] interface returns a [WritableStream] for sending data to the device connected to the port. Chunks written to this stream must be instances of `ArrayBuffer`, `TypedArray`, or `DataView`. This property is non-null as long as the port is open and has not encountered a fatal error."
     }
   },
   "ServiceWorker": {
@@ -7323,32 +7475,32 @@
     }
   },
   "ServiceWorkerGlobalScope": {
-    "docs": "The **`ServiceWorkerGlobalScope`** interface of the [Service Worker API](https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API) represents the global execution context of a service worker.\n\nDevelopers should keep in mind that the ServiceWorker state is not persisted across the termination/restart cycle, so each event handler should assume it's being invoked with a bare, default global state.\n\nOnce successfully registered, a service worker can and will be terminated when idle to conserve memory and processor power. An active service worker is automatically restarted to respond to events, such as [ServiceWorkerGlobalScope.fetch_event] or [ServiceWorkerGlobalScope.message_event].\n\nAdditionally, synchronous requests are not allowed from within a service worker — only asynchronous requests, like those initiated via the [fetch] method, can be used.\n\nThis interface inherits from the [WorkerGlobalScope] interface, and its parent [EventTarget].",
-    "properties": {
-      "activate_event": "The **`activate`** event of the [ServiceWorkerGlobalScope] interface is fired when a [ServiceWorkerRegistration] acquires a new [ServiceWorkerRegistration.active] worker.\n\nThis event is not cancelable and does not bubble.",
-      "backgroundfetchabort_event": "The **`backgroundfetchabort`** event of the [ServiceWorkerGlobalScope] interface is fired when the user or the app itself cancels a [background fetch](https://developer.mozilla.org/en-US/docs/Web/API/Background_Fetch_API) operation.\n\nThis event is not cancelable and does not bubble.",
-      "backgroundfetchclick_event": "The **`backgroundfetchclick`** event of the [ServiceWorkerGlobalScope] interface is fired when the user clicks on the UI that the browser provides to show the user the progress of the [background fetch](https://developer.mozilla.org/en-US/docs/Web/API/Background_Fetch_API) operation.\n\nThis event is not cancelable and does not bubble.",
-      "backgroundfetchfail_event": "The **`backgroundfetchfail`** event of the [ServiceWorkerGlobalScope] interface is fired when a [background fetch](https://developer.mozilla.org/en-US/docs/Web/API/Background_Fetch_API) operation has failed: that is, when at least one network request in the fetch has failed to complete successfully.\n\nThis event is not cancelable and does not bubble.",
-      "backgroundfetchsuccess_event": "The **`backgroundfetchsuccess`** event of the [ServiceWorkerGlobalScope] interface is fired when a [background fetch](https://developer.mozilla.org/en-US/docs/Web/API/Background_Fetch_API) operation has completed successfully: that is, when all network requests in the fetch have completed successfully.\n\nThis event is not cancelable and does not bubble.",
-      "canmakepayment_event": "The **`canmakepayment`** event of the [ServiceWorkerGlobalScope] interface is fired on a payment app's service worker to check whether it is ready to handle a payment. Specifically, it is fired when the merchant website calls [PaymentRequest.PaymentRequest].",
-      "clients": "The **`clients`** read-only property of the\n[ServiceWorkerGlobalScope] interface returns the [`Clients`](https://developer.mozilla.org/en-US/docs/Web/API/Clients)\nobject associated with the service worker.",
-      "contentdelete_event": "The **`contentdelete`** event of the [ServiceWorkerGlobalScope] interface is fired when an item is removed from the indexed content via the user agent.\n\nThis event is not cancelable and does not bubble.",
-      "cookiechange_event": "The **`cookiechange`** event of the [ServiceWorkerGlobalScope] interface is fired when a cookie change occurs that matches the service worker's cookie change subscription list.\n\nThis event is not cancelable and does not bubble.",
-      "cookiestore": "The **`cookieStore`** read-only property of the [ServiceWorkerGlobalScope] interface returns a reference to the [CookieStore] object associated with this service worker.",
-      "fetch_event": "The **`fetch`** event is fired in the service worker's global scope when the main app thread makes a network request. It enables the service worker to intercept network requests and send customized responses (for example, from a local cache).\n\nThis event is not cancelable and does not bubble.",
-      "install_event": "The **`install`** event of the [ServiceWorkerGlobalScope] interface is fired when a [ServiceWorkerRegistration] acquires a new [ServiceWorkerRegistration.installing] worker.\n\nThis event is not cancelable and does not bubble.",
-      "message_event": "The **`message`** event of the [ServiceWorkerGlobalScope] interface occurs when incoming messages are received. Controlled pages can use the [ServiceWorker.postMessage] method to send messages to service workers.\nThe service worker can optionally send a response back via the [Client.postMessage], corresponding to the controlled page.\n\nThis event is not cancelable and does not bubble.",
-      "messageerror_event": "The **`messageerror`** event of the [ServiceWorkerGlobalScope] interface occurs when incoming messages can't be deserialized.\n\nThis event is not cancelable and does not bubble.",
-      "notificationclick_event": "The **`notificationclick`** event of the [ServiceWorkerGlobalScope] interface is fired to indicate that a system notification spawned by [ServiceWorkerRegistration.showNotification] has been clicked.\n\nNotifications created on the main thread or in workers which aren't service workers\nusing the [Notification.Notification] constructor will\ninstead receive a [Notification.click_event] event on the [Notification] object\nitself.\n\nThis event is not cancelable and does not bubble.",
-      "notificationclose_event": "The **`notificationclose`** event of the [ServiceWorkerGlobalScope] interface fires when a user closes a displayed notification spawned by [ServiceWorkerRegistration.showNotification].\n\nNotifications created on the main thread or in workers which aren't service workers\nusing the [Notification.Notification] constructor will\ninstead receive a [Notification.close_event] event on the [Notification] object\nitself.\n\nThis event is not cancelable and does not bubble.",
-      "paymentrequest_event": "The **`paymentrequest`** event of the [ServiceWorkerGlobalScope] interface is fired on a payment app when a payment flow has been initiated on the merchant website via the [PaymentRequest.show] method.",
-      "periodicsync_event": "The **`periodicsync`** event of the [ServiceWorkerGlobalScope] interface is fired at timed intervals, specified when registering a [PeriodicSyncManager].\n\nThis event is not cancelable and does not bubble.",
-      "push_event": "The **`push`** event is sent to a service worker's global scope (represented by the [ServiceWorkerGlobalScope] interface) when the service worker has received a push message.\n\nThis event is not cancelable and does not bubble.",
-      "pushsubscriptionchange_event": "The **`pushsubscriptionchange`** event is sent to the [global scope](https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerGlobalScope) of a [ServiceWorker] to indicate a change in push subscription that was triggered outside the application's control.\n\nThis may occur if the subscription was refreshed by the browser, but it may also happen if the subscription has been revoked or lost.\n\nThis event is not cancelable and does not bubble.",
-      "registration": "The **`registration`** read-only property of the [ServiceWorkerGlobalScope] interface returns a reference to the [ServiceWorkerRegistration] object, which represents the service worker's registration.",
-      "serviceworker": "The **`serviceWorker`** read-only property of the [ServiceWorkerGlobalScope] interface returns a reference to the [ServiceWorker] object, which represents the service worker.",
-      "skipwaiting": "The **`ServiceWorkerGlobalScope.skipWaiting()`** method of the [ServiceWorkerGlobalScope] forces the waiting service worker to become the active service worker.\n\nUse this method with [Clients.claim] to ensure that updates to the underlying service worker take effect immediately for both the current client and all other active clients.",
-      "sync_event": "The **`sync`** event of the [ServiceWorkerGlobalScope] interface is fired when the page (or worker) that registered the event with the [SyncManager] is running and as soon as network connectivity is available.\n\nThis event is not cancelable and does not bubble."
+    "docs": "@AvailableInWorkers(\"service\")\n\nThe **`ServiceWorkerGlobalScope`** interface of the [Service Worker API](https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API) represents the global execution context of a service worker.\n\nDevelopers should keep in mind that the ServiceWorker state is not persisted across the termination/restart cycle, so each event handler should assume it's being invoked with a bare, default global state.\n\nOnce successfully registered, a service worker can and will be terminated when idle to conserve memory and processor power. An active service worker is automatically restarted to respond to events, such as [ServiceWorkerGlobalScope.fetch_event] or [ServiceWorkerGlobalScope.message_event].\n\nAdditionally, synchronous requests are not allowed from within a service worker — only asynchronous requests, like those initiated via the [fetch] method, can be used.\n\nThis interface inherits from the [WorkerGlobalScope] interface, and its parent [EventTarget].",
+    "properties": {
+      "activate_event": "@AvailableInWorkers(\"service\")\n\nThe **`activate`** event of the [ServiceWorkerGlobalScope] interface is fired when a [ServiceWorkerRegistration] acquires a new [ServiceWorkerRegistration.active] worker.\n\nThis event is not cancelable and does not bubble.",
+      "backgroundfetchabort_event": "@AvailableInWorkers(\"service\")\n\nThe **`backgroundfetchabort`** event of the [ServiceWorkerGlobalScope] interface is fired when the user or the app itself cancels a [background fetch](https://developer.mozilla.org/en-US/docs/Web/API/Background_Fetch_API) operation.\n\nThis event is not cancelable and does not bubble.",
+      "backgroundfetchclick_event": "@AvailableInWorkers(\"service\")\n\nThe **`backgroundfetchclick`** event of the [ServiceWorkerGlobalScope] interface is fired when the user clicks on the UI that the browser provides to show the user the progress of the [background fetch](https://developer.mozilla.org/en-US/docs/Web/API/Background_Fetch_API) operation.\n\nThis event is not cancelable and does not bubble.",
+      "backgroundfetchfail_event": "@AvailableInWorkers(\"service\")\n\nThe **`backgroundfetchfail`** event of the [ServiceWorkerGlobalScope] interface is fired when a [background fetch](https://developer.mozilla.org/en-US/docs/Web/API/Background_Fetch_API) operation has failed: that is, when at least one network request in the fetch has failed to complete successfully.\n\nThis event is not cancelable and does not bubble.",
+      "backgroundfetchsuccess_event": "@AvailableInWorkers(\"service\")\n\nThe **`backgroundfetchsuccess`** event of the [ServiceWorkerGlobalScope] interface is fired when a [background fetch](https://developer.mozilla.org/en-US/docs/Web/API/Background_Fetch_API) operation has completed successfully: that is, when all network requests in the fetch have completed successfully.\n\nThis event is not cancelable and does not bubble.",
+      "canmakepayment_event": "@AvailableInWorkers(\"service\")\n\nThe **`canmakepayment`** event of the [ServiceWorkerGlobalScope] interface is fired on a payment app's service worker to check whether it is ready to handle a payment. Specifically, it is fired when the merchant website calls [PaymentRequest.PaymentRequest].",
+      "clients": "@AvailableInWorkers(\"service\")\n\nThe **`clients`** read-only property of the\n[ServiceWorkerGlobalScope] interface returns the [`Clients`](https://developer.mozilla.org/en-US/docs/Web/API/Clients)\nobject associated with the service worker.",
+      "contentdelete_event": "@AvailableInWorkers(\"service\")\n\nThe **`contentdelete`** event of the [ServiceWorkerGlobalScope] interface is fired when an item is removed from the indexed content via the user agent.\n\nThis event is not cancelable and does not bubble.",
+      "cookiechange_event": "@AvailableInWorkers(\"service\")\n\nThe **`cookiechange`** event of the [ServiceWorkerGlobalScope] interface is fired when a cookie change occurs that matches the service worker's cookie change subscription list.\n\nThis event is not cancelable and does not bubble.",
+      "cookiestore": "@AvailableInWorkers(\"service\")\n\nThe **`cookieStore`** read-only property of the [ServiceWorkerGlobalScope] interface returns a reference to the [CookieStore] object associated with this service worker.",
+      "fetch_event": "@AvailableInWorkers(\"service\")\n\nThe **`fetch`** event of the [ServiceWorkerGlobalScope] interface is fired in the service worker's global scope when the main app thread makes a network request. It enables the service worker to intercept network requests and send customized responses (for example, from a local cache).\n\nThis event is not cancelable and does not bubble.",
+      "install_event": "@AvailableInWorkers(\"service\")\n\nThe **`install`** event of the [ServiceWorkerGlobalScope] interface is fired when a [ServiceWorkerRegistration] acquires a new [ServiceWorkerRegistration.installing] worker.\n\nThis event is not cancelable and does not bubble.",
+      "message_event": "@AvailableInWorkers(\"service\")\n\nThe **`message`** event of the [ServiceWorkerGlobalScope] interface occurs when incoming messages are received. Controlled pages can use the [ServiceWorker.postMessage] method to send messages to service workers.\nThe service worker can optionally send a response back via the [Client.postMessage], corresponding to the controlled page.\n\nThis event is not cancelable and does not bubble.",
+      "messageerror_event": "@AvailableInWorkers(\"service\")\n\nThe **`messageerror`** event of the [ServiceWorkerGlobalScope] interface occurs when incoming messages can't be deserialized.\n\nThis event is not cancelable and does not bubble.",
+      "notificationclick_event": "@AvailableInWorkers(\"service\")\n\nThe **`notificationclick`** event of the [ServiceWorkerGlobalScope] interface is fired to indicate that a system notification spawned by [ServiceWorkerRegistration.showNotification] has been clicked.\n\nNotifications created on the main thread or in workers which aren't service workers\nusing the [Notification.Notification] constructor will\ninstead receive a [Notification.click_event] event on the [Notification] object\nitself.\n\nThis event is not cancelable and does not bubble.",
+      "notificationclose_event": "@AvailableInWorkers(\"service\")\n\nThe **`notificationclose`** event of the [ServiceWorkerGlobalScope] interface fires when a user closes a displayed notification spawned by [ServiceWorkerRegistration.showNotification].\n\nNotifications created on the main thread or in workers which aren't service workers\nusing the [Notification.Notification] constructor will\ninstead receive a [Notification.close_event] event on the [Notification] object\nitself.\n\nThis event is not cancelable and does not bubble.",
+      "paymentrequest_event": "@AvailableInWorkers(\"service\")\n\nThe **`paymentrequest`** event of the [ServiceWorkerGlobalScope] interface is fired on a payment app when a payment flow has been initiated on the merchant website via the [PaymentRequest.show] method.",
+      "periodicsync_event": "@AvailableInWorkers(\"service\")\n\nThe **`periodicsync`** event of the [ServiceWorkerGlobalScope] interface is fired at timed intervals, specified when registering a [PeriodicSyncManager].\n\nThis event is not cancelable and does not bubble.",
+      "push_event": "@AvailableInWorkers(\"service\")\n\nThe **`push`** event is sent to a service worker's global scope (represented by the [ServiceWorkerGlobalScope] interface) when the service worker has received a push message.\n\nThis event is not cancelable and does not bubble.",
+      "pushsubscriptionchange_event": "@AvailableInWorkers(\"service\")\n\nThe **`pushsubscriptionchange`** event is sent to the [global scope](https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerGlobalScope) of a [ServiceWorker] to indicate a change in push subscription that was triggered outside the application's control.\n\nThis may occur if the subscription was refreshed by the browser, but it may also happen if the subscription has been revoked or lost.\n\nThis event is not cancelable and does not bubble.",
+      "registration": "@AvailableInWorkers(\"service\")\n\nThe **`registration`** read-only property of the [ServiceWorkerGlobalScope] interface returns a reference to the [ServiceWorkerRegistration] object, which represents the service worker's registration.",
+      "serviceworker": "@AvailableInWorkers(\"service\")\n\nThe **`serviceWorker`** read-only property of the [ServiceWorkerGlobalScope] interface returns a reference to the [ServiceWorker] object, which represents the service worker.",
+      "skipwaiting": "@AvailableInWorkers(\"service\")\n\nThe **`skipWaiting()`** method of the [ServiceWorkerGlobalScope] interface forces the waiting service worker to become the active service worker.\n\nUse this method with [Clients.claim] to ensure that updates to the underlying service worker take effect immediately for both the current client and all other active clients.",
+      "sync_event": "@AvailableInWorkers(\"service\")\n\nThe **`sync`** event of the [ServiceWorkerGlobalScope] interface is fired when the page (or worker) that registered the event with the [SyncManager] is running and as soon as network connectivity is available.\n\nThis event is not cancelable and does not bubble."
     }
   },
   "ServiceWorkerRegistration": {
@@ -7356,7 +7508,7 @@
     "properties": {
       "active": "The **`active`** read-only property of the\n[ServiceWorkerRegistration] interface returns a service worker whose\n[ServiceWorker.state] is `activating` or `activated`.\nThis property is initially set to `null`.\n\nAn active worker controls a [Client] if the client's URL\nfalls within the scope of the registration (the `scope` option set when\n[ServiceWorkerContainer.register] is first called.)\n\n> **Note:** Once an active worker is `activating`, neither a\n> runtime script error nor a force termination of the active worker prevents the active\n> worker from getting `activated`.",
       "backgroundfetch": "The **`backgroundFetch`** read-only property of the\n[ServiceWorkerRegistration] interface returns a reference to a\n[BackgroundFetchManager] object, which can be used to initiate background fetch operations.",
-      "cookies": "The **`cookies`** read-only property of the [ServiceWorkerRegistration] interface returns a reference to the [CookieStoreManager] interface, which enables a web app to subscribe to and unsubscribe from cookie change events in a [service worker](https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API). This is an entry point for the [Cookie Store API](https://developer.mozilla.org/en-US/docs/Web/API/Cookie_Store_API).",
+      "cookies": "@AvailableInWorkers(\"window_and_service\")\n\nThe **`cookies`** read-only property of the [ServiceWorkerRegistration] interface returns a reference to the [CookieStoreManager] interface, which enables a web app to subscribe to and unsubscribe from cookie change events in a [service worker](https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API). This is an entry point for the [Cookie Store API](https://developer.mozilla.org/en-US/docs/Web/API/Cookie_Store_API).",
       "getnotifications": "The **`getNotifications()`** method of\nthe [ServiceWorkerRegistration] interface returns a list of the\nnotifications in the order that they were created from the current origin via the\ncurrent service worker registration. Origins can have many active but\ndifferently-scoped service worker registrations. Notifications created by one service\nworker on the same origin will not be available to other active service workers on\nthat same origin.",
       "index": "The **`index`** read-only property of the\n[ServiceWorkerRegistration] interface returns a reference to the\n[ContentIndex] interface, which allows for indexing of offline content.",
       "installing": "The **`installing`** read-only property of the\n[ServiceWorkerRegistration] interface returns a service worker whose\n[ServiceWorker.state] is `installing`. This property is\ninitially set to `null`.",
@@ -7364,13 +7516,13 @@
       "paymentmanager": "The **`paymentManager`** read-only property of the\n[ServiceWorkerRegistration] interface returns a payment app's [PaymentManager] instance, which is used to manage various payment app functionality.",
       "periodicsync": "The **`periodicSync`** read-only property of\nthe [ServiceWorkerRegistration] interface returns a reference to the\n[PeriodicSyncManager] interface, which allows for registering of tasks to\nrun at specific intervals.",
       "pushmanager": "The **`pushManager`** read-only property of the\n[ServiceWorkerRegistration] interface returns a reference to the\n[PushManager] interface for managing push subscriptions; this includes\nsupport for subscribing, getting an active subscription, and accessing push permission\nstatus.",
-      "scope": "The **`scope`** read-only property of the\n[ServiceWorkerRegistration] interface returns a unique identifier for a\nservice worker registration. The service worker must be on the same origin as the\ndocument that registers the [ServiceWorker].",
+      "scope": "The **`scope`** read-only property of the [ServiceWorkerRegistration] interface returns a string representing a URL that defines a service worker's registration scope; that is, the range of URLs a service worker can control. This is set using the `scope` parameter specified in the call to [ServiceWorkerContainer.register] which registered the service worker.",
       "shownotification": "The **`showNotification()`** method of the\n[ServiceWorkerRegistration] interface creates a notification on an active\nservice worker.",
       "sync": "The **`sync`** read-only property of the\n[ServiceWorkerRegistration] interface returns a reference to the\n[SyncManager] interface, which manages background synchronization\nprocesses.",
       "unregister": "The **`unregister()`** method of the\n[ServiceWorkerRegistration] interface unregisters the service worker\nregistration and returns a `Promise`. The promise will resolve to\n`false` if no registration was found, otherwise it resolves to\n`true` irrespective of whether unregistration happened or not (it may not\nunregister if someone else just called [ServiceWorkerContainer.register]\nwith the same scope.) The service worker will finish any ongoing operations before it is\nunregistered.",
       "update": "The **`update()`** method of the\n[ServiceWorkerRegistration] interface attempts to update the service\nworker. It fetches the worker's script URL, and if the new worker is not byte-by-byte\nidentical to the current worker, it installs the new worker. The fetch of the worker\nbypasses any browser caches if the previous fetch occurred over 24 hours ago.",
       "updatefound_event": "The **`updatefound`** event of the\n[ServiceWorkerRegistration] interface is fired any time the [ServiceWorkerRegistration.installing] property acquires a new service worker.",
-      "updateviacache": "The **`updateViaCache`** read-only property of the\n[ServiceWorkerRegistration] interface updates the cache using\nthe mode specified in the call to [ServiceWorkerContainer.register].\nRequests for `importScripts` still go via the HTTP cache. `updateViaCache` offers\ncontrol over this behavior.",
+      "updateviacache": "The **`updateViaCache`** read-only property of the [ServiceWorkerRegistration] interface returns the value of the setting used to determine the circumstances in which the browser will consult the HTTP cache when it tries to update the service worker or any scripts that are imported via [WorkerGlobalScope.importScripts].",
       "waiting": "The **`waiting`** read-only property of the\n[ServiceWorkerRegistration] interface returns a service worker whose\n[ServiceWorker.state] is `installed`. This property is initially\nset to `null`."
     }
   },
@@ -7379,15 +7531,17 @@
     "properties": {
       "activeelement": "The **`activeElement`** read-only property of the\n[ShadowRoot] interface returns the element within the shadow tree that has focus.",
       "adoptedstylesheets": "The **`adoptedStyleSheets`** property of the [ShadowRoot] interface sets an array of constructed stylesheets to be used by the shadow DOM subtree.\n\n> **Note:** A constructed stylesheet is a stylesheet created programmatically using the [`CSSStyleSheet()` constructor](https://developer.mozilla.org/en-US/docs/Web/API/CSSStyleSheet/CSSStyleSheet) (as compared to one created by a user-agent when importing a stylesheet from a script, imported using `style` and , or linked to via `link`).\n\nThe same constructed stylesheet can be adopted by multiple [ShadowRoot] instances, and by the parent document (using the [Document.adoptedStyleSheets] property).\nChanging an adopted stylesheet will affect all the adopting objects.\n\nStylesheets in the `adoptedStyleSheets` property are considered along with the shadow DOM's other stylesheets.\nFor the purpose of determining the final computed CSS of any element, they are considered to have been added _after_ the other stylesheets in the shadow DOM ([`ShadowRoot.styleSheets`](https://developer.mozilla.org/en-US/docs/Web/API/ShadowRoot/styleSheets)).\n\nOnly stylesheets created using the [`CSSStyleSheet()` constructor](https://developer.mozilla.org/en-US/docs/Web/API/CSSStyleSheet/CSSStyleSheet), and from within the same parent [Document] as the shadow root, may be adopted.",
-      "clonable": "The **`clonable`** read-only property of the [ShadowRoot] interface returns `true` if the shadow root is clonable, and `false` otherwise. It always returns `true` for shadow roots created via declarative shadow DOM. It can be set to `true` using the `clonable` option of the [Element.attachShadow] method.",
-      "delegatesfocus": "The **`delegatesFocus`** read-only property of the [ShadowRoot] interface returns `true` if the shadow root delegates focus, and `false` otherwise.\n\nIf `true`, when a non-focusable part of the shadow DOM is clicked, or `.focus()` is called on the host element, the first focusable part is given focus, and the shadow host is given any available `:focus` styling.\n\nFocus is of particular importance for keyboard users (including those using screen readers). `delegatesFocus` default behavior is to focus the first focusable element — which may be undesirable if that element is not meant to be part of the tabbing order (for example, an element with `tabindex=\"-1\"`), or if a more 'important' focusable element should receive initial focus (for instance, the first text field rather than the 'close' button which precedes it). In such cases, the `autofocus` attribute can be specified on the element which should receive initial focus. Use the `autofocus` attribute with caution as it can introduce accessibility issues, such as bypassing important content which may go unnoticed due to focus being set to an element later in the DOM order.\n\nThe property value is set using the `delegatesFocus` property of the object passed to [Element.attachShadow]).",
+      "clonable": "The **`clonable`** read-only property of the [ShadowRoot] interface returns `true` if the shadow root is clonable, and `false` otherwise.\n\nWhen the value is `true`, a shadow host cloned with [Node.cloneNode] or [Document.importNode] will include a copy of the shadow root.\n\nBy default the value is `false`.\nIt can be set to `true` using the `clonable` option of the [Element.attachShadow] method or by setting the [`shadowrootclonable`](/en-US/docs/Web/HTML/Element/template#shadowrootclonable) attribute of the `<template>` element that is being used to declaratively attach a shadow root.",
+      "delegatesfocus": "The **`delegatesFocus`** read-only property of the [ShadowRoot] interface returns `true` if the shadow root delegates focus, and `false` otherwise.\n\nIf `true`, when a non-focusable part of the shadow DOM is clicked, or `.focus()` is called on the host element, the first focusable part is given focus, and the shadow host is given any available `:focus` styling.\n\nFocus is of particular importance for keyboard users (including those using screen readers). `delegatesFocus` default behavior is to focus the first focusable element — which may be undesirable if that element is not meant to be part of the tabbing order (for example, an element with `tabindex=\"-1\"`), or if a more 'important' focusable element should receive initial focus (for instance, the first text field rather than the 'close' button which precedes it). In such cases, the `autofocus` attribute can be specified on the element which should receive initial focus. Use the `autofocus` attribute with caution as it can introduce accessibility issues, such as bypassing important content which may go unnoticed due to focus being set to an element later in the DOM order.\n\nThe property value is originally set using the `delegatesFocus` property of the object passed to [Element.attachShadow], or using the [`shadowrootdelegatesfocus`](/en-US/docs/Web/HTML/Element/template#shadowrootclonable) attribute of the [`<template>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/template) element when a shadow root is created declaratively.",
       "fullscreenelement": "The **`fullscreenElement`** read-only property of the\n[ShadowRoot] interface returns the element within the shadow tree that is currently displayed in full screen.",
       "getanimations": "The **`getAnimations()`** method of the [ShadowRoot] interface\nreturns an array of all [Animation] objects currently in effect whose\ntarget elements are descendants of the shadow tree. This array includes [CSS Animations](https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_animations), [CSS Transitions](https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_transitions), and [Web Animations](https://developer.mozilla.org/en-US/docs/Web/API/Web_Animations_API).",
+      "gethtml": "The **`getHTML()`** method of the [ShadowRoot] interface is used to serialize a shadow root's DOM to an HTML string.\n\nThe method provides an options argument that enables the serialization of child nodes that are shadow roots.\nThe options can be used to include nested shadow roots that have been set as [ShadowRoot.serializable], and/or a specified array of [ShadowRoot] objects, which may be either open or closed.\n\nWithout arguments, child nodes that are shadow roots are not serialized, and this method behaves in the same way as reading the value of [Element.innerHTML].",
       "host": "The **`host`** read-only property of\nthe [ShadowRoot] returns a reference to the DOM element the\n`ShadowRoot` is attached to.",
       "innerhtml": "The **`innerHTML`** property of the [ShadowRoot]\ninterface sets or returns a reference to the DOM tree inside the\n`ShadowRoot`.",
-      "mode": "The **`mode`** read-only property of the [ShadowRoot]\nspecifies its mode — either `open` or `closed`. This defines\nwhether or not the shadow root's internal features are accessible from JavaScript.\n\nWhen the `mode` of a shadow root is \"`closed`\", the shadow root's\nimplementation internals are inaccessible and unchangeable from JavaScript—in the same\nway the implementation internals of, for example, the `video` element\nare inaccessible and unchangeable from JavaScript.",
+      "mode": "The **`mode`** read-only property of the [ShadowRoot] specifies its mode — either `open` or `closed`.\nThis defines whether or not the shadow root's internal features are accessible from JavaScript.\n\nWhen the `mode` of a shadow root is \"`closed`\", the shadow root's implementation internals are inaccessible and unchangeable from JavaScript—in the same way the implementation internals of, for example, the `video` element are inaccessible and unchangeable from JavaScript.\n\nThe property value is set using the `options.mode` property of the object passed to [Element.attachShadow], or using the [`shadowrootmode`](/en-US/docs/Web/HTML/Element/template#shadowrootmode) attribute of the [`<template>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/template) element when a shadow root is created declaratively.",
       "pictureinpictureelement": "The **`pictureInPictureElement`** read-only property of the\n[ShadowRoot] interface returns the [Element] that is currently being\npresented in picture-in-picture mode in this shadow tree, or `null` if\npicture-in-picture mode is not currently in use.",
       "pointerlockelement": "The **`pointerLockElement`** read-only property of the [ShadowRoot] interface provides the element set as the target for mouse events while the pointer is locked.\nIt is `null` if lock is pending, pointer is unlocked, or the target is in another tree.",
+      "serializable": "The **`serializable`** read-only property of the [ShadowRoot] interface returns `true` if the shadow root is serializable.\n\nIf set, the shadow root may be serialized by calling the [Element.getHTML] or [ShadowRoot.getHTML] methods with the `options.serializableShadowRoots` parameter set `true`.\n\nThe serializable property of a shadow root is specified when the shadow root is created, either declaratively by adding the [`shadowrootserializable`](/en-US/docs/Web/HTML/Element/template#shadowrootserializable) attribute on a `<template>` element (along with an allowed [`shadowrootmode`](/en-US/docs/Web/HTML/Element/template#shadowrootmode) value), or by setting the [`options.serializable`](/en-US/docs/Web/API/Element/attachShadow#serializable) parameter to `true` when using [`Element.attachShadow()`](https://developer.mozilla.org/en-US/docs/Web/API/Element/attachShadow).",
       "slotassignment": "The read-only **`slotAssignment`** property of the [ShadowRoot] interface returns the _slot assignment mode_ for the shadow DOM tree. Nodes are either automatically assigned (`named`) or manually assigned (`manual`). The value of this property defined using the `slotAssignment` option when calling [Element.attachShadow].",
       "stylesheets": "The **`styleSheets`** read-only property of the [ShadowRoot] interface\nreturns a [StyleSheetList] of [CSSStyleSheet] objects, for stylesheets explicitly linked into or embedded in a shadow tree."
     }
@@ -7496,7 +7650,7 @@
       "end_event": "The **`end`** event of the [Web Speech API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Speech_API) [SpeechRecognition] object is fired when the speech recognition service has disconnected.",
       "error_event": "The **`error`** event of the [Web Speech API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Speech_API) [SpeechRecognition] object is fired when a speech recognition error occurs.",
       "grammars": "The **`grammars`** property of the\n[SpeechRecognition] interface returns and sets a collection of\n[SpeechGrammar] objects that represent the grammars that will be understood\nby the current `SpeechRecognition`.",
-      "interimresults": "The **`interimResults`** property of the\n[SpeechRecognition] interface controls whether interim results should be\nreturned (`true`) or not (`false`.) Interim results are results\nthat are not yet final (e.g. the [SpeechRecognitionResult.isFinal] property\nis `false`.)\n\nThe default value for **`interimResults`** is `false`.",
+      "interimresults": "The **`interimResults`** property of the\n[SpeechRecognition] interface controls whether interim results should be\nreturned (`true`) or not (`false`). Interim results are results\nthat are not yet final (e.g. the [SpeechRecognitionResult.isFinal] property\nis `false`).\n\nThe default value for **`interimResults`** is `false`.",
       "lang": "The **`lang`** property of the [SpeechRecognition]\ninterface returns and sets the language of the current `SpeechRecognition`.\nIf not specified, this defaults to the HTML [`lang`](/en-US/docs/Web/HTML/Element/html#lang) attribute\nvalue, or the user agent's language setting if that isn't set either.",
       "maxalternatives": "The **`maxAlternatives`** property of the\n[SpeechRecognition] interface sets the maximum number of\n[SpeechRecognitionAlternative]s provided per\n[SpeechRecognitionResult].\n\nThe default value is 1.",
       "nomatch_event": "The **`nomatch`** event of the [Web Speech API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Speech_API) is fired when the speech recognition service returns a final result with no significant recognition.\n\nThis may involve some degree of recognition, which doesn't meet or exceed the [SpeechRecognitionAlternative.confidence] threshold.",
@@ -7639,6 +7793,22 @@
       "setitem": "The **`setItem()`** method of the [Storage]\ninterface, when passed a key name and value, will add that key to the given\n`Storage` object, or update that key's value if it already exists."
     }
   },
+  "StorageAccessHandle": {
+    "docs": "The **`StorageAccessHandle`** interface represents access to [unpartitioned state](/en-US/docs/Web/Privacy/State_Partitioning#state_partitioning) granted by a call to [Document.requestStorageAccess].",
+    "properties": {
+      "broadcastchannel": "> **Note:** See [BroadcastChannel.BroadcastChannel] to understand usage.",
+      "caches": "The **`caches`** property of the [StorageAccessHandle] interface returns an unpartitioned [CacheStorage] object if access was granted, and throws a `SecurityError` [DOMException] otherwise.",
+      "createobjecturl": "> **Note:** See [URL.createObjectURL_static] to understand usage.",
+      "estimate": "> **Note:** See [StorageManager.estimate] to understand usage.",
+      "getdirectory": "> **Note:** See [StorageManager.getDirectory] to understand usage.",
+      "indexeddb": "The **`indexedDB`** property of the [StorageAccessHandle] interface returns an unpartitioned [IDBFactory] object if access was granted, and throws a `SecurityError` [DOMException] otherwise.",
+      "localstorage": "The **`localStorage`** property of the [StorageAccessHandle] interface returns an unpartitioned local [Storage] object if access was granted, and throws a `SecurityError` [DOMException] otherwise.",
+      "locks": "The **`locks`** property of the [StorageAccessHandle] interface returns an unpartitioned session [LockManager] object if access was granted, and throws a `SecurityError` [DOMException] otherwise.",
+      "revokeobjecturl": "> **Note:** See [URL.revokeObjectURL_static] to understand usage.",
+      "sessionstorage": "The **`sessionStorage`** property of the [StorageAccessHandle] interface returns an unpartitioned session [Storage] object if access was granted, and throws a `SecurityError` [DOMException] otherwise.",
+      "sharedworker": "> **Note:** See [SharedWorker.SharedWorker] to understand usage."
+    }
+  },
   "StorageEvent": {
     "docs": "The **`StorageEvent`** interface is implemented by the [Window.storage_event] event, which is\nsent to a window\nwhen a storage area the window has access to is changed within the context of another document.",
     "properties": {
@@ -7709,7 +7879,7 @@
     }
   },
   "SubtleCrypto": {
-    "docs": "The **`SubtleCrypto`** interface of the [Web Crypto API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Crypto_API) provides a number of low-level cryptographic functions. Access to the features of `SubtleCrypto` is obtained through the [Crypto.subtle] property of the [Crypto] object you get from the [crypto_property] property.\n\n> **Warning:** This API provides a number of low-level cryptographic primitives. It's very easy to misuse them, and the pitfalls involved can be very subtle.\n>\n> Even assuming you use the basic cryptographic functions correctly, secure key management and overall security system design are extremely hard to get right, and are generally the domain of specialist security experts.\n>\n> Errors in security system design and implementation can make the security of the system completely ineffective.\n>\n> Please learn and experiment, but don't guarantee or imply the security of your work before an individual knowledgeable in this subject matter thoroughly reviews it. The [Crypto 101 Course](https://www.crypto101.io/) can be a great place to start learning about the design and implementation of secure systems.",
+    "docs": "The **`SubtleCrypto`** interface of the [Web Crypto API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Crypto_API) provides a number of low-level cryptographic functions.\n\nAn instance of `SubtleCrypto` is available as the[Crypto.subtle] property of the [Crypto] interface, which in turn is available in windows through the [Window.crypto] property and in workers through the [WorkerGlobalScope.crypto] property.\n\n> **Warning:** This API provides a number of low-level cryptographic primitives. It's very easy to misuse them, and the pitfalls involved can be very subtle.\n>\n> Even assuming you use the basic cryptographic functions correctly, secure key management and overall security system design are extremely hard to get right, and are generally the domain of specialist security experts.\n>\n> Errors in security system design and implementation can make the security of the system completely ineffective.\n>\n> Please learn and experiment, but don't guarantee or imply the security of your work before an individual knowledgeable in this subject matter thoroughly reviews it. The [Crypto 101 Course](https://www.crypto101.io/) can be a great place to start learning about the design and implementation of secure systems.",
     "properties": {
       "decrypt": "The **`decrypt()`** method of the [SubtleCrypto] interface decrypts some encrypted data.\nIt takes as arguments a  to decrypt with, some optional extra parameters, and the data to decrypt (also known as \"ciphertext\").\nIt returns a `Promise` which will be fulfilled with the decrypted data (also known as \"plaintext\").",
       "derivebits": "The **`deriveBits()`** method of the\n[SubtleCrypto] interface can be used to derive an array of bits from a base\nkey.\n\nIt takes as its arguments the base key, the derivation algorithm to use, and the length\nof the bits to derive. It returns a [`Promise`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)\nwhich will be fulfilled with an\n[`ArrayBuffer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer)\ncontaining the derived bits.\n\nThis method is very similar to\n[`SubtleCrypto.deriveKey()`](https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/deriveKey),\nexcept that `deriveKey()` returns a\n[`CryptoKey`](https://developer.mozilla.org/en-US/docs/Web/API/CryptoKey) object rather than an\n`ArrayBuffer`. Essentially `deriveKey()` is composed of\n`deriveBits()` followed by\n[`importKey()`](https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/importKey).\n\nThis function supports the same derivation algorithms as `deriveKey()`:\nECDH, HKDF, and PBKDF2. See [Supported algorithms](/en-US/docs/Web/API/SubtleCrypto/deriveKey#supported_algorithms)\nfor some more detail on these algorithms.",
@@ -7726,11 +7896,11 @@
     }
   },
   "SyncEvent": {
-    "docs": "The **`SyncEvent`** interface of the [Background Synchronization API] represents a sync action that is dispatched on the [ServiceWorkerGlobalScope] of a ServiceWorker.\n\nThis interface inherits from the [ExtendableEvent] interface.",
+    "docs": "@AvailableInWorkers(\"service\")\n\nThe **`SyncEvent`** interface of the [Background Synchronization API] represents a sync action that is dispatched on the [ServiceWorkerGlobalScope] of a ServiceWorker.\n\nThis interface inherits from the [ExtendableEvent] interface.",
     "properties": {
-      "lastchance": "The **`lastChance`** read-only property of the\n[SyncEvent] interface returns `true` if the user agent will not\nmake further synchronization attempts after the current attempt. This is the value\npassed in the `lastChance` parameter of the\n[SyncEvent.SyncEvent] constructor.",
-      "syncevent": "The **`SyncEvent()`** constructor creates a new [SyncEvent] object.",
-      "tag": "The **`tag`** read-only property of the\n[SyncEvent] interface returns the developer-defined identifier for\nthis `SyncEvent`. This is the value passed in the `tag` parameter\nof the [SyncEvent.SyncEvent] constructor."
+      "lastchance": "@AvailableInWorkers(\"service\")\n\nThe **`lastChance`** read-only property of the\n[SyncEvent] interface returns `true` if the user agent will not\nmake further synchronization attempts after the current attempt. This is the value\npassed in the `lastChance` parameter of the\n[SyncEvent.SyncEvent] constructor.",
+      "syncevent": "@AvailableInWorkers(\"service\")\n\nThe **`SyncEvent()`** constructor creates a new [SyncEvent] object.",
+      "tag": "@AvailableInWorkers(\"service\")\n\nThe **`tag`** read-only property of the\n[SyncEvent] interface returns the developer-defined identifier for\nthis `SyncEvent`. This is the value passed in the `tag` parameter\nof the [SyncEvent.SyncEvent] constructor."
     }
   },
   "SyncManager": {
@@ -8017,7 +8187,7 @@
     }
   },
   "TrustedHTML": {
-    "docs": "The **`TrustedHTML`** interface of the [Trusted Types API] represents a string that a developer can insert into an [injection sink](/en-US/docs/Web/API/Trusted_Types_API#injection_sinks) that will render it as HTML. These objects are created via [TrustedTypePolicy.createHTML] and therefore have no constructor.\n\nThe value of a **TrustedHTML** object is set when the object is created and cannot be changed by JavaScript as there is no setter exposed.",
+    "docs": "The **`TrustedHTML`** interface of the [Trusted Types API] represents a string that a developer can insert into an [injection sink](/en-US/docs/Web/API/Trusted_Types_API#injection_sinks) that will render it as HTML. These objects are created via [TrustedTypePolicy.createHTML] and therefore have no constructor.\n\nThe value of a `TrustedHTML` object is set when the object is created and cannot be changed by JavaScript as there is no setter exposed.",
     "properties": {
       "tojson": "The **`toJSON()`** method of the [TrustedHTML] interface returns a JSON representation of the stored data.",
       "tostring": "The **`toString()`** method of the [TrustedHTML] interface returns a string which may safely inserted into an injection sink."
@@ -8031,14 +8201,14 @@
     }
   },
   "TrustedScriptURL": {
-    "docs": "The **`TrustedScriptURL`** interface of the [Trusted Types API] represents a string that a developer can insert into an [injection sink](/en-US/docs/Web/API/Trusted_Types_API#injection_sinks) that will parse it as a URL of an external script. These objects are created via [TrustedTypePolicy.createScriptURL] and therefore have no constructor.\n\nThe value of a **TrustedScriptURL** object is set when the object is created and cannot be changed by JavaScript as there is no setter exposed.",
+    "docs": "The **`TrustedScriptURL`** interface of the [Trusted Types API] represents a string that a developer can insert into an [injection sink](/en-US/docs/Web/API/Trusted_Types_API#injection_sinks) that will parse it as a URL of an external script. These objects are created via [TrustedTypePolicy.createScriptURL] and therefore have no constructor.\n\nThe value of a `TrustedScriptURL` object is set when the object is created and cannot be changed by JavaScript as there is no setter exposed.",
     "properties": {
       "tojson": "The **`toJSON()`** method of the [TrustedScriptURL] interface returns a JSON representation of the stored data.",
       "tostring": "The **`toString()`** method of the [TrustedScriptURL] interface returns a string which may safely inserted into an [injection sink](/en-US/docs/Web/API/Trusted_Types_API#injection_sinks)."
     }
   },
   "TrustedTypePolicy": {
-    "docs": "The **`TrustedTypePolicy`** interface of the [Trusted Types API] defines a group of functions which create [TrustedType] objects.\n\nA `TrustedTypePolicy` object is created by [TrustedTypePolicyFactory.createPolicy] to define a policy for enforcing security rules on input. Therefore, `TrustedTypePolicy` has no constructor.",
+    "docs": "The **`TrustedTypePolicy`** interface of the [Trusted Types API] defines a group of functions which create `TrustedType` objects.\n\nA `TrustedTypePolicy` object is created by [TrustedTypePolicyFactory.createPolicy] to define a policy for enforcing security rules on input. Therefore, `TrustedTypePolicy` has no constructor.",
     "properties": {
       "createhtml": "The **`createHTML()`** method of the [TrustedTypePolicy] interface creates a [TrustedHTML] object using a policy created by [TrustedTypePolicyFactory.createPolicy].",
       "createscript": "The **`createScript()`** method of the [TrustedTypePolicy] interface creates a [TrustedScript] object using a policy created by [TrustedTypePolicyFactory.createPolicy].",
@@ -8075,22 +8245,23 @@
     "docs": "The **`URL`** interface is used to parse, construct, normalize, and encode . It works by providing properties which allow you to easily read and modify the components of a URL.\n\nYou normally create a new `URL` object by specifying the URL as a string when calling its constructor, or by providing a relative URL and a base URL. You can then easily read the parsed components of the URL or make changes to the URL.\n\nIf a browser doesn't yet support the [URL.URL] constructor, you can access a URL object using the [Window] interface's [URL] property. Be sure to check to see if any of your target browsers require this to be prefixed.",
     "properties": {
       "canparse_static": "The **`URL.canParse()`** static method of the [URL] interface returns a boolean indicating whether or not an absolute URL, or a relative URL combined with a base URL, are parsable and valid.\n\nThis is a fast and easy alternative to constructing a `URL` within a [try...catch](/en-US/docs/Web/JavaScript/Reference/Statements/try...catch) block.\nIt returns `true` for the same values for which the [`URL()` constructor](https://developer.mozilla.org/en-US/docs/Web/API/URL/URL) would succeed, and `false` for the values that would cause the constructor to throw.",
-      "createobjecturl_static": "@AvailableInWorkers(\"notservice\")\n\nThe **`URL.createObjectURL()`** static\nmethod creates a string containing a URL representing the object\ngiven in the parameter.\n\nThe URL lifetime is tied to the [document]\nin the window on which it was created. The new object URL represents the specified\n[File] object or [Blob] object.\n\nTo release an object URL, call [URL.revokeObjectURL_static].\n\n> **Note:** This feature is _not_ available in [Service Workers](https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API) due to its\n> potential to create memory leaks.",
+      "createobjecturl_static": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\nThe **`createObjectURL()`** static method of the [URL] interface\ncreates a string containing a URL representing the object given in the parameter.\n\nThe URL lifetime is tied to the [document]\nin the window on which it was created. The new object URL represents the specified\n[File] object or [Blob] object.\n\nTo release an object URL, call [URL.revokeObjectURL_static].\n\n> **Note:** This feature is _not_ available in [Service Workers](https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API) due to its\n> potential to create memory leaks.",
       "hash": "The **`hash`** property of the\n[URL] interface is a string containing a\n`'#'` followed by the fragment identifier of the URL.\n\nThe fragment is not [URL decoded](https://en.wikipedia.org/wiki/URL_encoding). If the URL does not\nhave a fragment identifier, this property contains an empty string — `\"\"`.",
       "host": "The **`host`** property of the [URL] interface is\na string containing the host, that is the [URL.hostname], and then, if the  of the URL is nonempty, a\n`':'`, followed by the [URL.port] of the URL.",
       "hostname": "The **`hostname`** property of the [URL] interface\nis a string containing the  of the URL.",
       "href": "The **`href`** property of the [URL] interface is\na string containing the whole URL.",
       "origin": "The **`origin`** read-only property of\nthe [URL] interface returns a string containing the\nUnicode serialization of the origin of the represented URL.\n\nThe exact structure\nvaries depending on the type of URL:\n\n- For `http` or `https` URLs, the scheme followed by\n  `'://'`, followed by the domain, followed by `':'`, followed by\n  the port (if explicitly specified, unless it is the default port - `80` and `443` respectively).\n- For `file:` URLs, the value is browser dependent.\n- for `blob:` URLs, the origin of the URL following `blob:` will\n  be used. For example, `\"blob:https://mozilla.org\"` will be returned as\n  `\"https://mozilla.org\".`",
+      "parse_static": "The **`URL.parse()`** static method of the [URL] interface returns a newly created [URL] object representing the URL defined by the parameters.\n\nIf the given base URL or the resulting URL are not parsable and valid URLs, `null` is returned.\nThis is an alternative to using the [URL.URL] constructor to construct a `URL` within a [try...catch](/en-US/docs/Web/JavaScript/Reference/Statements/try...catch) block, or using [URL.canParse_static] to check the parameters and returning `null` if the method returns `false`.",
       "password": "The **`password`** property of the [URL] interface\nis a string containing the password specified before the domain name.\n\nIf it is set without first setting the [URL.username]\nproperty, it silently fails.",
       "pathname": "The **`pathname`** property of the [URL] interface represents a location in a hierarchical structure. It is a string constructed from a list of path segments, each of which is prefixed by a `/` character. If the URL has no path segments, the value of its `pathname` property will be the empty string.\n\nURLs such as `https` and `http` URLs that have [hierarchical schemes](https://www.rfc-editor.org/rfc/rfc3986#section-1.2.3) (which the URL standard calls \"[special schemes](https://url.spec.whatwg.org/#special-scheme)\") always have at least one (invisible) path segment: the empty string. Thus the `pathname` value for such \"special scheme\" URLs can never be the empty string, but will instead always have a least one `/` character.\n\nFor example, the URL `https://developer.mozilla.org` has just one path segment: the empty string, so its `pathname` value is constructed by prefixing a `/` character to the empty string.\n\nSome systems define the term _slug_ to mean the final segment of a non-empty path if it identifies a page in human-readable keywords. For example, the URL `https://example.org/articles/this-that-other-outre-collection` has `this-that-other-outre-collection` as its slug.\n\nSome systems use the `;` and `=` characters to delimit parameters and parameter values applicable to a path segment. For example, with the URL `https://example.org/users;id=42/tasks;state=open?sort=modified`, a system might extract and use the path segment parameters `id=42` and `state=open` from the path segments `users;id=42` and `tasks;state=open`.",
       "port": "The **`port`** property of the [URL] interface is\na string containing the port number of the URL.\n\n> **Note:** If an input string passed to the [`URL()`](https://developer.mozilla.org/en-US/docs/Web/API/URL/URL) constructor doesn't contain an explicit port number (e.g., `https://localhost`) or contains a port number that's the default port number corresponding to the protocol part of the input string (e.g., `https://localhost:443`), then in the [`URL`](https://developer.mozilla.org/en-US/docs/Web/API/URL) object the constructor returns, the value of the port property will be the empty string: `''`.",
       "protocol": "The **`protocol`** property of the [URL] interface\nis a string representing the protocol scheme of the URL, including the\nfinal `':'`.",
-      "revokeobjecturl_static": "@AvailableInWorkers(\"notservice\")\n\nThe **`URL.revokeObjectURL()`** static\nmethod releases an existing object URL which was previously created by calling\n[URL.createObjectURL_static].\n\nCall this method when you've finished\nusing an object URL to let the browser know not to keep the reference to the file any\nlonger.\n\n> **Note:** This method is _not_ available in [Service Workers](https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API), due to\n> issues with the [Blob] interface's life cycle and the potential for leaks.",
+      "revokeobjecturl_static": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\nThe **`revokeObjectURL()`** static method of the [URL] interface\nreleases an existing object URL which was previously created by calling\n[URL.createObjectURL_static].\n\nCall this method when you've finished\nusing an object URL to let the browser know not to keep the reference to the file any\nlonger.\n\n> **Note:** This method is _not_ available in [Service Workers](https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API), due to\n> issues with the [Blob] interface's life cycle and the potential for leaks.",
       "search": "The **`search`** property of the [URL] interface\nis a search string, also called a _query string_, that is a\nstring containing a `'?'` followed by the parameters of the\nURL.\n\nModern browsers provide the [URL.searchParams] property to make it easy to\nparse out the parameters from the query string.",
       "searchparams": "The **`searchParams`** read-only property of the\n[URL] interface returns a [URLSearchParams] object allowing\naccess to the `GET` decoded query arguments contained in the URL.",
       "tojson": "The **`toJSON()`** method of the [URL] interface\nreturns a string containing a serialized version of the URL,\nalthough in practice it seems to have the same effect as\n[URL.toString].",
       "tostring": "The **`toString()`** method of the [URL] interface returns a\nstring containing the whole URL. It is effectively a read-only version\nof [URL.href].",
-      "url": "The **`URL()`** constructor returns a newly created\n[URL] object representing the URL defined by the parameters.\n\nIf the given base URL or the resulting URL are not valid URLs, the JavaScript\n`TypeError` exception is thrown.",
+      "url": "The **`URL()`** constructor returns a newly created [URL] object representing the URL defined by the parameters.\n\nIf the given base URL or the resulting URL are not valid URLs, the JavaScript `TypeError` exception is thrown.",
       "username": "The **`username`** property of the [URL] interface\nis a string containing the username specified before the domain name."
     }
   },
@@ -8361,64 +8532,64 @@
     }
   },
   "VideoColorSpace": {
-    "docs": "The **`VideoColorSpace`** interface of the [WebCodecs API] represents the color space of a video.",
+    "docs": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`VideoColorSpace`** interface of the [WebCodecs API] represents the color space of a video.",
     "properties": {
-      "fullrange": "The **`fullRange`** read-only property of the [VideoColorSpace] interface returns `true` if full-range color values are used.",
-      "matrix": "The **`matrix`** read-only property of the [VideoColorSpace] interface returns the matrix coefficient of the video. Matrix coefficients describe the relationship between sample component values and color coordinates.",
-      "primaries": "The **`primaries`** read-only property of the [VideoColorSpace] interface returns the color  of the video.",
-      "tojson": "The **`toJSON()`** method of the [VideoColorSpace] interface is a _serializer_ that returns a JSON representation of the `VideoColorSpace` object.",
-      "transfer": "The **`transfer`** read-only property of the [VideoColorSpace] interface returns the opto-electronic transfer characteristics of the video.",
-      "videocolorspace": "The **`VideoColorSpace()`** constructor creates a new [VideoColorSpace] object which represents a video color space."
+      "fullrange": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`fullRange`** read-only property of the [VideoColorSpace] interface returns `true` if full-range color values are used.",
+      "matrix": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`matrix`** read-only property of the [VideoColorSpace] interface returns the matrix coefficient of the video. Matrix coefficients describe the relationship between sample component values and color coordinates.",
+      "primaries": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`primaries`** read-only property of the [VideoColorSpace] interface returns the color  of the video.",
+      "tojson": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`toJSON()`** method of the [VideoColorSpace] interface is a _serializer_ that returns a JSON representation of the `VideoColorSpace` object.",
+      "transfer": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`transfer`** read-only property of the [VideoColorSpace] interface returns the opto-electronic transfer characteristics of the video.",
+      "videocolorspace": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`VideoColorSpace()`** constructor creates a new [VideoColorSpace] object which represents a video color space."
     }
   },
   "VideoDecoder": {
-    "docs": "The **`VideoDecoder`** interface of the [WebCodecs API] decodes chunks of video.",
+    "docs": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`VideoDecoder`** interface of the [WebCodecs API] decodes chunks of video.",
     "properties": {
-      "close": "The **`close()`** method of the [VideoDecoder] interface ends all pending work and releases system resources.",
-      "configure": "The **`configure()`** method of the [VideoDecoder] interface enqueues a control message to configure the video decoder for decoding chunks.",
-      "decode": "The **`decode()`** method of the [VideoDecoder] interface enqueues a control message to decode a given chunk of video.",
-      "decodequeuesize": "The **`decodeQueueSize`** read-only property of the [VideoDecoder] interface returns the number of pending decode requests in the queue.",
-      "dequeue_event": "The **`dequeue`** event of the [VideoDecoder] interface fires to signal a decrease in [VideoDecoder.decodeQueueSize].\n\nThis eliminates the need for developers to use a [setTimeout] poll to determine when the queue has decreased, and more work should be queued up.",
-      "flush": "The **`flush()`** method of the [VideoDecoder] interface returns a Promise that resolves once all pending messages in the queue have been completed.",
-      "isconfigsupported_static": "The **`isConfigSupported()`** static method of the [VideoDecoder] interface checks if the given config is supported (that is, if [VideoDecoder] objects can be successfully configured with the given config).",
-      "reset": "The **`reset()`** method of the [VideoDecoder] interface resets all states including configuration, control messages in the control message queue, and all pending callbacks.",
-      "state": "The **`state`** property of the [VideoDecoder] interface returns the current state of the underlying codec.",
-      "videodecoder": "The **`VideoDecoder()`** constructor creates a new [VideoDecoder] object with the provided `init.output` callback assigned as the output callback, the provided `init.error` callback as the error callback, and the [VideoDecoder.state] set to `\"unconfigured\"`."
+      "close": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`close()`** method of the [VideoDecoder] interface ends all pending work and releases system resources.",
+      "configure": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`configure()`** method of the [VideoDecoder] interface enqueues a control message to configure the video decoder for decoding chunks.",
+      "decode": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`decode()`** method of the [VideoDecoder] interface enqueues a control message to decode a given chunk of video.",
+      "decodequeuesize": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`decodeQueueSize`** read-only property of the [VideoDecoder] interface returns the number of pending decode requests in the queue.",
+      "dequeue_event": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`dequeue`** event of the [VideoDecoder] interface fires to signal a decrease in [VideoDecoder.decodeQueueSize].\n\nThis eliminates the need for developers to use a [setTimeout] poll to determine when the queue has decreased, and more work should be queued up.",
+      "flush": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`flush()`** method of the [VideoDecoder] interface returns a Promise that resolves once all pending messages in the queue have been completed.",
+      "isconfigsupported_static": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`isConfigSupported()`** static method of the [VideoDecoder] interface checks if the given config is supported (that is, if [VideoDecoder] objects can be successfully configured with the given config).",
+      "reset": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`reset()`** method of the [VideoDecoder] interface resets all states including configuration, control messages in the control message queue, and all pending callbacks.",
+      "state": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`state`** property of the [VideoDecoder] interface returns the current state of the underlying codec.",
+      "videodecoder": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`VideoDecoder()`** constructor creates a new [VideoDecoder] object with the provided `init.output` callback assigned as the output callback, the provided `init.error` callback as the error callback, and the [VideoDecoder.state] set to `\"unconfigured\"`."
     }
   },
   "VideoEncoder": {
-    "docs": "The **`VideoEncoder`** interface of the [WebCodecs API] encodes [VideoFrame] objects into [EncodedVideoChunk]s.",
+    "docs": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`VideoEncoder`** interface of the [WebCodecs API] encodes [VideoFrame] objects into [EncodedVideoChunk]s.",
     "properties": {
-      "close": "The **`close()`** method of the [VideoEncoder] interface ends all pending work and releases system resources.",
-      "configure": "The **`configure()`** method of the [VideoEncoder] interface changes the [VideoEncoder.state] of the encoder to \"configured\" and asynchronously prepares the encoder to accept [VideoEncoder]s for encoding with the specified parameters. If the encoder doesn't support the specified parameters or can't be initialized for other reasons an error will be reported via the error callback provided to the [VideoEncoder] constructor.\n\nIf the [VideoEncoder] has been previously configured, the new configuration will not be applied until all previous tasks have completed.",
-      "dequeue_event": "The **`dequeue`** event of the [VideoEncoder] interface fires to signal a decrease in [VideoEncoder.encodeQueueSize].\n\nThis eliminates the need for developers to use a [setTimeout] poll to determine when the queue has decreased, and more work should be queued up.",
-      "encode": "The **`encode()`** method of the [VideoEncoder] interface asynchronously encodes a [VideoFrame].\nEncoded data ([EncodedVideoChunk]) or an error will eventually be returned via the callbacks provided to the [VideoEncoder] constructor.",
-      "encodequeuesize": "The **`encodeQueueSize`** read-only property of the [VideoEncoder] interface returns the number of pending encode requests in the queue.",
-      "flush": "The **`flush()`** method of the [VideoEncoder] interface forces all pending encodes to complete.",
-      "isconfigsupported_static": "The **`isConfigSupported()`** static method of the [VideoEncoder] interface checks if [VideoEncoder] can be successfully configured with the given config.",
-      "reset": "The **`reset()`** method of the [VideoEncoder] interface synchronously cancels all pending encodes and callbacks, frees all underlying resources and sets the [VideoEncoder.state] to \"unconfigured\".\nAfter calling [VideoEncoder.reset], [VideoEncoder.configure] must be called before resuming [VideoEncoder.encode] calls.\n\n> **Note:** To avoid discarding frames queued via [VideoEncoder.encode], [VideoEncoder.flush] should be called and completed before calling [VideoEncoder.reset].",
-      "state": "The **`state`** read-only property of the [VideoEncoder] interface returns the current state of the underlying codec.",
-      "videoencoder": "The **`VideoEncoder()`** constructor creates a new [VideoEncoder] object with the provided `options.output` callback assigned as the output callback, the provided `options.error` callback as the error callback, and sets the [VideoEncoder.state] to `\"unconfigured\"`."
+      "close": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`close()`** method of the [VideoEncoder] interface ends all pending work and releases system resources.",
+      "configure": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`configure()`** method of the [VideoEncoder] interface changes the [VideoEncoder.state] of the encoder to \"configured\" and asynchronously prepares the encoder to accept [VideoEncoder]s for encoding with the specified parameters. If the encoder doesn't support the specified parameters or can't be initialized for other reasons an error will be reported via the error callback provided to the [VideoEncoder] constructor.\n\nIf the [VideoEncoder] has been previously configured, the new configuration will not be applied until all previous tasks have completed.",
+      "dequeue_event": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`dequeue`** event of the [VideoEncoder] interface fires to signal a decrease in [VideoEncoder.encodeQueueSize].\n\nThis eliminates the need for developers to use a [setTimeout] poll to determine when the queue has decreased, and more work should be queued up.",
+      "encode": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`encode()`** method of the [VideoEncoder] interface asynchronously encodes a [VideoFrame].\nEncoded data ([EncodedVideoChunk]) or an error will eventually be returned via the callbacks provided to the [VideoEncoder] constructor.",
+      "encodequeuesize": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`encodeQueueSize`** read-only property of the [VideoEncoder] interface returns the number of pending encode requests in the queue.",
+      "flush": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`flush()`** method of the [VideoEncoder] interface forces all pending encodes to complete.",
+      "isconfigsupported_static": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`isConfigSupported()`** static method of the [VideoEncoder] interface checks if [VideoEncoder] can be successfully configured with the given config.",
+      "reset": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`reset()`** method of the [VideoEncoder] interface synchronously cancels all pending encodes and callbacks, frees all underlying resources and sets the [VideoEncoder.state] to \"unconfigured\".\nAfter calling [VideoEncoder.reset], [VideoEncoder.configure] must be called before resuming [VideoEncoder.encode] calls.\n\n> **Note:** To avoid discarding frames queued via [VideoEncoder.encode], [VideoEncoder.flush] should be called and completed before calling [VideoEncoder.reset].",
+      "state": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`state`** read-only property of the [VideoEncoder] interface returns the current state of the underlying codec.",
+      "videoencoder": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`VideoEncoder()`** constructor creates a new [VideoEncoder] object with the provided `options.output` callback assigned as the output callback, the provided `options.error` callback as the error callback, and sets the [VideoEncoder.state] to `\"unconfigured\"`."
     }
   },
   "VideoFrame": {
-    "docs": "The **`VideoFrame`** interface of the [Web Codecs API](https://developer.mozilla.org/en-US/docs/Web/API/WebCodecs_API) represents a frame of a video.\n\n`VideoFrame` is a [transferable object](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Transferable_objects).",
-    "properties": {
-      "allocationsize": "The **`allocationSize()`** method of the [VideoFrame] interface returns the number of bytes required to hold the video as filtered by options passed into the method.",
-      "clone": "The **`clone()`** method of the [VideoFrame] interface creates a new `VideoFrame` object referencing the same media resource as the original.",
-      "close": "The **`close()`** method of the [VideoFrame] interface clears all states and releases the reference to the media resource.",
-      "codedheight": "The **`codedHeight`** property of the [VideoFrame] interface returns the height of the VideoFrame in pixels, potentially including non-visible padding, and prior to considering potential ratio adjustments.",
-      "codedrect": "The **`codedRect`** property of the [VideoFrame] interface returns a [DOMRectReadOnly] with the width and height matching [VideoFrame.codedWidth] and [VideoFrame.codedHeight].",
-      "codedwidth": "The **`codedWidth`** property of the [VideoFrame] interface returns the width of the `VideoFrame` in pixels, potentially including non-visible padding, and prior to considering potential ratio adjustments.",
-      "colorspace": "The **`colorSpace`** property of the [VideoFrame] interface returns a [VideoColorSpace] object representing the color space of the video.",
-      "copyto": "The **`copyTo()`** method of the [VideoFrame] interface copies the contents of the `VideoFrame` to an `ArrayBuffer`.",
-      "displayheight": "The **`displayHeight`** property of the [VideoFrame] interface returns the height of the `VideoFrame` after applying aspect ratio adjustments.",
-      "displaywidth": "The **`displayWidth`** property of the [VideoFrame] interface returns the width of the `VideoFrame` after applying aspect ratio adjustments.",
-      "duration": "The **`duration`** property of the [VideoFrame] interface returns an integer indicating the duration of the video in microseconds.",
-      "format": "The **`format`** property of the [VideoFrame] interface returns the pixel format of the `VideoFrame`.",
-      "timestamp": "The **`timestamp`** property of the [VideoFrame] interface returns an integer indicating the timestamp of the video in microseconds.",
-      "videoframe": "The **`VideoFrame()`** constructor creates a new [VideoFrame] object representing a frame of a video.",
-      "visiblerect": "The **`visibleRect`** property of the [VideoFrame] interface returns a [DOMRectReadOnly] describing the visible rectangle of pixels for this `VideoFrame`."
+    "docs": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`VideoFrame`** interface of the [Web Codecs API](https://developer.mozilla.org/en-US/docs/Web/API/WebCodecs_API) represents a frame of a video.\n\n`VideoFrame` is a [transferable object](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Transferable_objects).",
+    "properties": {
+      "allocationsize": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`allocationSize()`** method of the [VideoFrame] interface returns the number of bytes required to hold the video as filtered by options passed into the method.",
+      "clone": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`clone()`** method of the [VideoFrame] interface creates a new `VideoFrame` object referencing the same media resource as the original.",
+      "close": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`close()`** method of the [VideoFrame] interface clears all states and releases the reference to the media resource.",
+      "codedheight": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`codedHeight`** property of the [VideoFrame] interface returns the height of the VideoFrame in pixels, potentially including non-visible padding, and prior to considering potential ratio adjustments.",
+      "codedrect": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`codedRect`** property of the [VideoFrame] interface returns a [DOMRectReadOnly] with the width and height matching [VideoFrame.codedWidth] and [VideoFrame.codedHeight].",
+      "codedwidth": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`codedWidth`** property of the [VideoFrame] interface returns the width of the `VideoFrame` in pixels, potentially including non-visible padding, and prior to considering potential ratio adjustments.",
+      "colorspace": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`colorSpace`** property of the [VideoFrame] interface returns a [VideoColorSpace] object representing the color space of the video.",
+      "copyto": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`copyTo()`** method of the [VideoFrame] interface copies the contents of the `VideoFrame` to an `ArrayBuffer`.",
+      "displayheight": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`displayHeight`** property of the [VideoFrame] interface returns the height of the `VideoFrame` after applying aspect ratio adjustments.",
+      "displaywidth": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`displayWidth`** property of the [VideoFrame] interface returns the width of the `VideoFrame` after applying aspect ratio adjustments.",
+      "duration": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`duration`** property of the [VideoFrame] interface returns an integer indicating the duration of the video in microseconds.",
+      "format": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`format`** property of the [VideoFrame] interface returns the pixel format of the `VideoFrame`.",
+      "timestamp": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`timestamp`** property of the [VideoFrame] interface returns an integer indicating the timestamp of the video in microseconds.",
+      "videoframe": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`VideoFrame()`** constructor creates a new [VideoFrame] object representing a frame of a video.",
+      "visiblerect": "@AvailableInWorkers(\"window_and_dedicated\")\n\nThe **`visibleRect`** property of the [VideoFrame] interface returns a [DOMRectReadOnly] describing the visible rectangle of pixels for this `VideoFrame`."
     }
   },
   "VideoPlaybackQuality": {
@@ -8880,6 +9051,7 @@
       "beforeunload_event": "The **`beforeunload`** event is fired when the current window, contained document, and associated resources are about to be unloaded. The document is still visible and the event is still cancelable at this point.\n\nThe main use case for this event is to trigger a browser-generated confirmation dialog that asks users to confirm if they _really_ want to leave the page when they try to close or reload it, or navigate somewhere else. This is intended to help prevent loss of unsaved data.\n\nThe dialog can be triggered in the following ways:\n\n- Calling the event object's [Event.preventDefault] method.\n- Setting the event object's [BeforeUnloadEvent.returnValue] property to a non-empty string value or any other [truthy](https://developer.mozilla.org/en-US/docs/Glossary/Truthy) value.\n- Returning any truthy value from the event handler function, e.g. `return \"string\"`. Note that this only works when the function is attached via the `onbeforeunload` property, not the [EventTarget.addEventListener] method. This behavior is consistent across modern versions of Firefox, Safari, and Chrome.\n\nThe last two mechanisms are legacy features; best practice is to trigger the dialog by invoking `preventDefault()` on the event object, while also setting `returnValue` to support legacy cases.",
       "blur": "The **`Window.blur()`** method does nothing.\n\n> **Note:** Historically, this method was the programmatic equivalent of the user shifting focus away\n> from the current window. This behavior was removed due to hostile sites abusing this functionality.\n> In Firefox, you can enable the old behavior with the `dom.disable_window_flip` preference.",
       "blur_event": "The **`blur`** event fires when an element has lost focus.\n\nThe opposite of `blur` is [Window.focus_event].\n\nThis event is not cancelable and does not bubble.",
+      "caches": "The **`caches`** read-only property of the [Window] interface returns the [CacheStorage] object associated with the current context.\nThis object enables functionality such as storing assets for offline use, and generating custom responses to requests.",
       "cancelanimationframe": "The **`window.cancelAnimationFrame()`** method cancels an\nanimation frame request previously scheduled through a call to\n[window.requestAnimationFrame].",
       "cancelidlecallback": "The **`window.cancelIdleCallback()`** method cancels a callback\npreviously scheduled with [window.requestIdleCallback].",
       "captureevents": "The **`Window.captureEvents()`** method does nothing.\n\n> **Note:** This is an method long removed from the specification. It is kept in browsers to prevent code breakage but does nothing.",
@@ -8891,6 +9063,8 @@
       "cookiestore": "The **`cookieStore`** read-only property of the [Window] interface returns a reference to the [CookieStore] object for the current document context. This is an entry point for the [Cookie Store API](https://developer.mozilla.org/en-US/docs/Web/API/Cookie_Store_API).",
       "copy_event": "The **`copy`** event fires when the user initiates a copy action through the browser's user interface.\n\nThe original target for this event is the [Element] that was the intended target of the copy action. You can listen for this event on the [Window] interface to handle it in the capture or bubbling phases. For full details on this event please see the page on the [Element: copy event](https://developer.mozilla.org/en-US/docs/Web/API/Element/copy_event).",
       "credentialless": "The **`window.credentialless`** read-only property returns a boolean that indicates whether the current document was loaded inside a credentialless `iframe`, meaning that it is loaded in a new, ephemeral context.\n\nThis context doesn't have access to the network, cookies, and storage data associated with its origin. It uses a new context local to the top-level document lifetime. In return, the  (COEP) embedding rules can be lifted, so documents with COEP set can embed third-party documents that do not.\n\nSee [IFrame credentialless](https://developer.mozilla.org/en-US/docs/Web/Security/IFrame_credentialless) for a deeper explanation.",
+      "crossoriginisolated": "The **`crossOriginIsolated`** read-only property of the [Window] interface returns a boolean value that\nindicates whether the website is in a cross-origin isolation state. That state mitigates the risk of side-channel attacks and unlocks a few capabilities:\n\n- `SharedArrayBuffer` can be created and sent via a [Window.postMessage] or a [MessagePort.postMessage] call.\n- [Performance.now] offers better precision.\n- [Performance.measureUserAgentSpecificMemory] can be accessed.\n\nA website is in a cross-origin isolated state, when the response header  has the value `same-origin` and the  header has the value `require-corp` or `credentialless`.",
+      "crypto": "The **`crypto`** read-only property of the [Window] interface returns the [Crypto] object for this window's scope. This object gives web pages access to certain cryptographic related services.\n\nAlthough the property itself is read-only, all of its methods (and the methods of its\nchild object, [SubtleCrypto]) are not read-only, and therefore vulnerable\nto attack by .\n\nAlthough `crypto` is available on all windows, the returned `Crypto` object only has one usable feature in insecure contexts: the [Crypto.getRandomValues] method. In general, you should use this API only in secure contexts.",
       "customelements": "The **`customElements`** read-only property of the [Window] interface returns a reference to the [CustomElementRegistry] object, which can be used to register new [custom elements](https://developer.mozilla.org/en-US/docs/Web/API/Web_components/Using_custom_elements) and get information about previously registered custom elements.",
       "cut_event": "The **`cut`** event is fired when the user has initiated a \"cut\" action through the browser's user interface.\n\nThe original target for this event is the [Element] that was the intended target of the cut action. You can listen for this event on the [Window] interface to handle it in the capture or bubbling phases. For full details on this event please see the page on the [Element: cut event](https://developer.mozilla.org/en-US/docs/Web/API/Element/cut_event).",
       "devicemotion_event": "The **`devicemotion`** event is fired at a regular interval and indicates the acceleration rate of the device with/without the contribution of the gravity force at that time. It also provides information about the rate of rotation, if available.\n\nThis event is not cancelable and does not bubble.",
@@ -8919,8 +9093,10 @@
       "getselection": "The **`Window.getSelection()`** method returns a\n[Selection] object representing the range of text selected by the user or\nthe current position of the caret.",
       "hashchange_event": "The **`hashchange`** event is fired when the fragment identifier of the URL has changed (the part of the URL beginning with and following the `#` symbol).",
       "history": "The `Window.history` read-only property returns a reference to the [History] object, which provides an interface for manipulating the browser _session history_ (pages visited in the tab or frame that the current page is loaded in).\n\nSee [Manipulating the browser history](https://developer.mozilla.org/en-US/docs/Web/API/History_API) for examples and details. In particular, that article explains security features of the [History.pushState] and [History.replaceState] methods that you should be aware of before using them.",
+      "indexeddb": "The **`indexedDB`** read-only property of the [Window] interface provides a mechanism for applications to\nasynchronously access the capabilities of indexed databases.",
       "innerheight": "The read-only **`innerHeight`** property of the\n[Window] interface returns the interior height of the window in pixels,\nincluding the height of the horizontal scroll bar, if present.\n\nThe value of `innerHeight` is taken from the height of the window's\n. The width can be obtained using the\n[Window.innerWidth] property.",
       "innerwidth": "The read-only [Window] property **`innerWidth`** returns the interior width of the window in pixels (that is, the width of the window's ). That includes the width of the vertical scroll bar, if one is present.\n\nSimilarly, the interior height of the window (that is, the height of the layout viewport) can be obtained using the [Window.innerHeight] property. That measurement also accounts for the height of the horizontal scroll bar, if it is visible.",
+      "issecurecontext": "The **`isSecureContext`** read-only property of the [Window] interface returns a boolean indicating whether the current [context is secure](https://developer.mozilla.org/en-US/docs/Web/Security/Secure_Contexts) (`true`) or not (`false`).",
       "languagechange_event": "The **`languagechange`** event is fired at the global scope object when the user's preferred language changes.",
       "launchqueue": "The `launchQueue` read-only property of the [Window] interface provides access to the [LaunchQueue] class, which allows custom launch navigation handling to be implemented in a [progressive web app](https://developer.mozilla.org/en-US/docs/Web/Progressive_web_apps) (PWA), with the handling context signified by the [`launch_handler`](https://developer.mozilla.org/en-US/docs/Web/Manifest/launch_handler) manifest field `client_mode` value.\n\nThe custom launch navigation handling functionality is controlled by the properties of the [LaunchParams] object passed into the [LaunchQueue.setConsumer] callback function.",
       "length": "Returns the number of frames (either `frame` or\n`iframe` elements) in the window.",
@@ -8945,6 +9121,7 @@
       "opener": "The [Window] interface's\n**`opener`** property returns a reference to the window that\nopened the window, either with [Window.open], or by navigating\na link with a [`target`](/en-US/docs/Web/HTML/Element/a#target) attribute.\n\nIn other words, if window `A` opens window `B`,\n`B.opener` returns `A`.",
       "orientation": "Returns the orientation in degrees (in 90-degree increments) of the viewport relative to the device's natural orientation.\n\nIts only possible values are `-90`, `0`, `90`, and `180`. Positive values are counterclockwise; negative values are clockwise.\n\nThis property is deprecated. Use the [Screen.orientation] property instead, available on the [window.screen] property.",
       "orientationchange_event": "The `orientationchange` event is fired when the orientation of the device has changed.\n\nThis event is not cancelable and does not bubble.\n\nThis event is deprecated. Listen for the [ScreenOrientation.change_event] event of the [ScreenOrientation] interface instead.",
+      "origin": "The **`origin`** read-only property of the [Window] interface returns the origin of the global scope, serialized as a string.",
       "originagentcluster": "The **`originAgentCluster`** read-only property of the [Window] interface returns `true` if this window belongs to an _origin-keyed [agent cluster](https://tc39.es/ecma262/#sec-agent-clusters)_: this means that the operating system has provided dedicated resources (for example an operating system process) to this window's origin that are not shared with windows from other origins.\n\nOtherwise this property returns `false`.\n\nWindows that are part of an origin-keyed agent cluster are subjects to some additional restrictions, compared with windows that are not. In particular, they cannot:\n\n- Set [Document.domain], which is a legacy feature that normally allows same-site cross-origin pages to synchronously access each other's DOM.\n- Send [`WebAssembly.Module`](https://developer.mozilla.org/en-US/docs/WebAssembly/JavaScript_interface/Module) objects to other same-site cross-origin pages via [Window.postMessage].\n- Send `SharedArrayBuffer` or [`WebAssembly.Memory`](https://developer.mozilla.org/en-US/docs/WebAssembly/JavaScript_interface/Memory) objects to other same-site cross-origin pages.\n\nTo request that the browser assign this window to an origin-keyed agent cluster, the server must send the  response header.\n\nNote that the origin-keyed agent cluster feature is only supported in . If a site is not a secure context, the `window.originAgentCluster` will always return `false`.",
       "outerheight": "The **`Window.outerHeight`** read-only property returns the height in pixels of the whole browser window, including any sidebar, window chrome, and window-resizing borders/handles.",
       "outerwidth": "**`Window.outerWidth`** read-only property returns the width of the outside of the browser window. It represents the width of the whole browser window including sidebar (if expanded), window chrome and window resizing borders/handles.",
@@ -8952,6 +9129,7 @@
       "pageshow_event": "The **`pageshow`** event is sent to a [Window] when the browser displays the window's document due to navigation.\n\nThis includes:\n\n- Initially loading the page\n- Navigating to the page from another page in the same window or tab\n- Restoring a frozen page on mobile OSes\n- Returning to the page using the browser's forward or back buttons\n\n> **Note:** During the initial page load, the `pageshow` event fires _after_ the [Window.load_event] event.",
       "parent": "The **`Window.parent`** property is a reference to the parent\nof the current window or subframe.\n\nIf a window does not have a parent, its `parent` property is a reference to\nitself.\n\nWhen a window is loaded in an `iframe`, `object`, or\n`frame`, its parent is the window with the element embedding the\nwindow.",
       "paste_event": "The **`paste`** event is fired when the user has initiated a \"paste\" action through the browser's user interface.\n\nThe original target for this event is the [Element] that was the intended target of the paste action. You can listen for this event on the [Window] interface to handle it in the capture or bubbling phases. For full details on this event please see the page on the [Element: paste event](https://developer.mozilla.org/en-US/docs/Web/API/Element/paste_event).",
+      "performance": "The **`performance`** property of the [Window] interface returns a [Performance] object, which can be used to gather performance information about code running in the window's scope.\n\nPerformance entries are per context. If you create a mark on the main thread (or other worker), you cannot see it in a worker thread, and vice versa.",
       "personalbar": "Returns the `personalbar` object.\n\nThis is one of a group of `Window` properties that contain a boolean `visible` property, that used to represent whether or not a particular part of a web browser's user interface was visible.\n\nFor privacy and interoperability reasons, the value of the `visible` property is now `false` if this `Window` is a popup, and `true` otherwise.",
       "popstate_event": "The **`popstate`** event of the [Window] interface is fired when the active history entry changes while the user navigates the session history. It changes the current history entry to that of the last page the user visited or, if [history.pushState] has been used to add a history entry to the history stack, that history entry is used instead.",
       "postmessage": "The **`window.postMessage()`** method safely enables cross-origin communication between [Window] objects; _e.g.,_ between a page and a pop-up that it spawned, or between a page and an iframe embedded within it.\n\nNormally, scripts on different pages are allowed to access each other if and only if the pages they originate from share the same protocol, port number, and host (also known as the \"[same-origin policy](https://developer.mozilla.org/en-US/docs/Web/Security/Same-origin_policy)\").\n`window.postMessage()` provides a controlled mechanism to securely circumvent this restriction (if used properly).\n\nBroadly, one window may obtain a reference to another (_e.g.,_ via `targetWindow = window.opener`), and then dispatch a [MessageEvent] on it with `targetWindow.postMessage()`.\nThe receiving window is then free to [handle this event](https://developer.mozilla.org/en-US/docs/Web/Events/Event_handlers) as needed.\nThe arguments passed to `window.postMessage()` (_i.e.,_ the \"message\") are [exposed to the receiving window through the event object](#the_dispatched_event).",
@@ -8966,6 +9144,7 @@
       "resize_event": "The **`resize`** event fires when the document view (window) has been resized.\n\nThis event is not cancelable and does not bubble.\n\nIn some earlier browsers it was possible to register `resize` event handlers on any HTML element. It is still possible to set `onresize` attributes or use [EventTarget.addEventListener] to set a handler on any element. However, `resize` events are only fired on the [Window] object (i.e. returned by [document.defaultView]). Only handlers registered on the `window` object will receive `resize` events.\n\nWhile the `resize` event fires only for the window nowadays, you can get resize notifications for other elements using the [ResizeObserver](https://developer.mozilla.org/en-US/docs/Web/API/ResizeObserver) API.\n\nIf the resize event is triggered too many times for your application, see [Optimizing window.onresize](https://web.archive.org/web/20220714020647/https://bencentra.com/code/2015/02/27/optimizing-window-resize.html) to control the time after which the event fires.",
       "resizeby": "The **`Window.resizeBy()`** method resizes the current window\nby a specified amount.",
       "resizeto": "The **`Window.resizeTo()`** method dynamically resizes the\nwindow.",
+      "scheduler": "The **`scheduler`** read-only property of the [Window] interface is the entry point for using the [Prioritized Task Scheduling API](https://developer.mozilla.org/en-US/docs/Web/API/Prioritized_Task_Scheduling_API).\n\nThe object has a single instance method [Scheduler.postTask] that is used to post prioritized tasks for scheduling.",
       "screen": "The [Window] property **`screen`** returns a\nreference to the screen object associated with the window. The `screen`\nobject, implementing the [Screen] interface, is a special object for\ninspecting properties of the screen on which the current window is being rendered.",
       "screenleft": "The **`Window.screenLeft`** read-only property returns the\nhorizontal distance, in CSS pixels, from the left border of the user's browser viewport\nto the left side of the screen.\n\n> **Note:** `screenLeft` is an alias of the older\n> [Window.screenX] property. `screenLeft` was originally\n> supported only in IE but was introduced everywhere due to popularity.",
       "screentop": "The **`Window.screenTop`** read-only property returns the\nvertical distance, in CSS pixels, from the top border of the user's browser viewport to\nthe top side of the screen.\n\n> **Note:** `screenTop` is an alias of the older\n> [Window.screenY] property. `screenTop` was originally\n> supported only in IE but was introduced everywhere due to popularity.",
@@ -8985,7 +9164,7 @@
       "sessionstorage": "The read-only **`sessionStorage`**\nproperty accesses a session [Storage] object for the current\n. `sessionStorage` is similar to\n[Window.localStorage]; the difference is that while data\nin `localStorage` doesn't expire, data in `sessionStorage` is\ncleared when the _page session_ ends.\n\n- Whenever a document is loaded in a particular tab in the browser, a unique page\n  session gets created and assigned to that particular tab. That page session is valid\n  only for that particular tab.\n- A page session lasts as long as the tab or the browser is open, and survives over\n  page reloads and restores.\n- **Opening a page in a new tab or window creates a new session with the value\n  of the top-level browsing context, which differs from how session cookies\n  work.**\n- Opening multiple tabs/windows with the same URL creates `sessionStorage`\n  for each tab/window.\n- Duplicating a tab copies the tab's `sessionStorage` into the new\n  tab.\n- Closing a tab/window ends the session and clears objects in\n  `sessionStorage`.\n\nData stored in `sessionStorage` **is specific to the protocol of the\npage**. In particular, data stored by a script on a site accessed with HTTP\n(e.g., [http://example.com](https://example.com)) is\nput in a different `sessionStorage` object from the same site accessed with\nHTTPS (e.g., <https://example.com>).\n\nThe keys and the values are _always_ in the UTF-16 string\nformat, which uses two bytes per character. As with objects, integer keys are\nautomatically converted to strings.",
       "setimmediate": "This method is used to break up long running operations and run a callback function immediately after the browser has completed other operations such as events and display updates.",
       "setresizable": "This method does nothing; it is a no-op. It is solely kept for compatibility with Netscape 4.x.",
-      "sharedstorage": "The global read-only **`sharedStorage`** property returns the [WindowSharedStorage] object for the current origin. This is the main entry point for writing data to shared storage using the [Shared Storage API](https://developer.mozilla.org/en-US/docs/Web/API/Shared_Storage_API).\n\n> **Note:** `sharedStorage` is not available inside workers. It is implemented by [`Window`](/en-US/docs/Web/API/Window#scheduler) and is also available in shared storage worklets (see [SharedStorageWorkletGlobalScope.sharedStorage], which returns [WorkletSharedStorage]).",
+      "sharedstorage": "The global read-only **`sharedStorage`** property returns the [WindowSharedStorage] object for the current origin. This is the main entry point for writing data to shared storage using the [Shared Storage API](https://developer.mozilla.org/en-US/docs/Web/API/Shared_Storage_API).\n\n> **Note:** `sharedStorage` is not available inside workers. It is implemented by [Window] and is also available in shared storage worklets (see [SharedStorageWorkletGlobalScope.sharedStorage], which returns [WorkletSharedStorage]).",
       "showdirectorypicker": "The **`showDirectoryPicker()`** method of the\n[Window] interface displays a directory picker which allows the user to\nselect a directory.",
       "showmodaldialog": "> **Warning:** This feature has been removed. Please fix your websites and applications.\n>\n> This method was removed in Chrome 43 and Firefox 56.\n\nThe **`Window.showModalDialog()`**\ncreated and displayed a modal dialog box containing a specified HTML document.",
       "showopenfilepicker": "The **`showOpenFilePicker()`** method of the\n[Window] interface shows a file picker that allows a user to select a file\nor multiple files and returns a handle for the file(s).",
@@ -8999,6 +9178,7 @@
       "storage_event": "The **`storage`** event of the [Window] interface fires when a storage area (`localStorage` or `sessionStorage`) has been modified in the context of another document.\n\nThis event is not cancelable and does not bubble.\n\n> **Note:** This won't work on the same  that is making the changes — it is really a way for other browsing contexts on the domain using the storage to sync any changes that are made. Browsing contexts on other domains can't access the same storage objects.",
       "toolbar": "Returns the `toolbar` object.\n\nThis is one of a group of `Window` properties that contain a boolean `visible` property, that used to represent whether or not a particular part of a web browser's user interface was visible.\n\nFor privacy and interoperability reasons, the value of the `visible` property is now `false` if this `Window` is a popup, and `true` otherwise.",
       "top": "Returns a reference to the topmost window in the window hierarchy.",
+      "trustedtypes": "The **`trustedTypes`** read-only property of the [Window] interface returns the [TrustedTypePolicyFactory] object associated with the global object, providing the entry point for using the [Trusted Types API].",
       "unhandledrejection_event": "The **`unhandledrejection`** event is sent to the global scope of a script when a JavaScript `Promise` that has no rejection handler is rejected; typically, this is the [window], but may also be a [Worker].\n\nThis is useful for debugging and for providing fallback error handling for unexpected situations.",
       "unload_event": "> **Warning:** Developers should avoid using this event. See \"Usage notes\" below.\n\nThe **`unload`** event is fired when the document or a child resource is being unloaded.\n\nIt is fired after:\n\n- [Window.beforeunload_event] (cancelable event)\n- [Window.pagehide_event]\n\nThe document is in the following state:\n\n- All the resources still exist (img, iframe etc.)\n- Nothing is visible anymore to the end user\n- UI interactions are ineffective ([window.open], [window.alert], [window.confirm], etc.)\n- An error won't stop the unloading workflow\n\nPlease note that the unload event also follows the document tree: parent frame unload will happen **before** child frame `unload` (see example below).",
       "updatecommands": "Updates the state of commands of the current chrome window (UI).",
@@ -9014,13 +9194,13 @@
     }
   },
   "WindowClient": {
-    "docs": "The `WindowClient` interface of the [ServiceWorker API](https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API) represents the scope of a service worker client that is a document in a browsing context, controlled by an active worker. The service worker client independently selects and uses a service worker for its own loading and sub-resources.",
+    "docs": "@AvailableInWorkers(\"service\")\n\nThe `WindowClient` interface of the [ServiceWorker API](https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API) represents the scope of a service worker client that is a document in a browsing context, controlled by an active worker. The service worker client independently selects and uses a service worker for its own loading and sub-resources.",
     "properties": {
-      "ancestororigins": "The **`ancestorOrigins`** read-only property of the [WindowClient] interface is an array of strings listing the origins of all ancestors of the browsing context represented by this `WindowClient` in reverse order.\n\nThe first element in the array is the origin of this window's parent, and the last element is the origin of the top-level browsing context. If this window is itself a top-level browsing context, then `ancestorOrigins` is an empty array.",
-      "focus": "The **`focus()`** method of the [WindowClient]\ninterface gives user input focus to the current client and returns a\n`Promise` that resolves to the existing\n[WindowClient].",
-      "focused": "The **`focused`** read-only property of the\n[WindowClient] interface is a boolean value that indicates whether\nthe current client has focus.",
-      "navigate": "The **`navigate()`** method of the [WindowClient]\ninterface loads a specified URL into a controlled client page then returns a\n`Promise` that resolves to the existing [WindowClient].",
-      "visibilitystate": "The **`visibilityState`** read-only property of the\n[WindowClient] interface indicates the visibility of the current client.\nThis value can be one of `\"hidden\"`, `\"visible\"`, or\n`\"prerender\"`."
+      "ancestororigins": "@AvailableInWorkers(\"service\")\n\nThe **`ancestorOrigins`** read-only property of the [WindowClient] interface is an array of strings listing the origins of all ancestors of the browsing context represented by this `WindowClient` in reverse order.\n\nThe first element in the array is the origin of this window's parent, and the last element is the origin of the top-level browsing context. If this window is itself a top-level browsing context, then `ancestorOrigins` is an empty array.",
+      "focus": "@AvailableInWorkers(\"service\")\n\nThe **`focus()`** method of the [WindowClient]\ninterface gives user input focus to the current client and returns a\n`Promise` that resolves to the existing\n[WindowClient].",
+      "focused": "@AvailableInWorkers(\"service\")\n\nThe **`focused`** read-only property of the\n[WindowClient] interface is a boolean value that indicates whether\nthe current client has focus.",
+      "navigate": "@AvailableInWorkers(\"service\")\n\nThe **`navigate()`** method of the [WindowClient]\ninterface loads a specified URL into a controlled client page then returns a\n`Promise` that resolves to the existing [WindowClient].",
+      "visibilitystate": "@AvailableInWorkers(\"service\")\n\nThe **`visibilityState`** read-only property of the\n[WindowClient] interface indicates the visibility of the current client.\nThis value can be one of `\"hidden\"`, `\"visible\"`, or\n`\"prerender\"`."
     }
   },
   "WindowControlsOverlay": {
@@ -9048,31 +9228,40 @@
     }
   },
   "Worker": {
-    "docs": "The **`Worker`** interface of the [Web Workers API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API) represents a background task that can be created via script, which can send messages back to its creator.\n\nCreating a worker is done by calling the `Worker(\"path/to/worker/script\")` constructor.\n\nWorkers may themselves spawn new workers, as long as those workers are hosted at the same [origin](https://developer.mozilla.org/en-US/docs/Web/Security/Same-origin_policy) as the parent page.\n\nNote that not all interfaces and functions are available to web workers. See [Functions and classes available to Web Workers](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Functions_and_classes_available_to_workers) for details.",
+    "docs": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\nThe **`Worker`** interface of the [Web Workers API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API) represents a background task that can be created via script, which can send messages back to its creator.\n\nCreating a worker is done by calling the `Worker(\"path/to/worker/script\")` constructor.\n\nWorkers may themselves spawn new workers, as long as those workers are hosted at the same [origin](https://developer.mozilla.org/en-US/docs/Web/Security/Same-origin_policy) as the parent page.\n\nNote that not all interfaces and functions are available to web workers. See [Functions and classes available to Web Workers](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Functions_and_classes_available_to_workers) for details.",
     "properties": {
-      "error_event": "The **`error`** event of the [Worker] interface fires when an error occurs in the worker.",
-      "message_event": "The `message` event is fired on a [Worker] object when the worker's parent receives a message from its worker (i.e. when the worker sends a message using [`DedicatedWorkerGlobalScope.postMessage()`](https://developer.mozilla.org/en-US/docs/Web/API/DedicatedWorkerGlobalScope/postMessage)).\n\nThis event is not cancellable and does not bubble.",
-      "messageerror_event": "The `messageerror` event is fired on a [Worker] object when it receives a message that can't be deserialized.\n\nThis event is not cancellable and does not bubble.",
-      "postmessage": "The **`postMessage()`** method of the [Worker] interface sends a message to the worker. The first parameter is the data to send to the worker. The data may be any JavaScript object that can be handled by the [structured clone algorithm](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm).\n\nThe [Worker] `postMessage()` method delegates to the [MessagePort] [MessagePort.postMessage] method, which adds a task on the event loop corresponding to the receiving [MessagePort].\n\nThe `Worker` can send back information to the thread that spawned it using the [DedicatedWorkerGlobalScope.postMessage] method.",
-      "terminate": "The **`terminate()`** method of the [Worker] interface immediately terminates the [Worker]. This does not offer the worker an opportunity to finish its operations; it is stopped at once.",
-      "worker": "The **`Worker()`** constructor creates a [Worker] object that executes the script at the specified URL. This script must obey the [same-origin policy](https://developer.mozilla.org/en-US/docs/Web/Security/Same-origin_policy).\n\n> **Note:** that there is a disagreement among browser manufacturers about whether a data URL is of the same origin or not. Though Firefox 10 and later accept data URLs, that's not the case in all other browsers."
+      "error_event": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\nThe **`error`** event of the [Worker] interface fires when an error occurs in the worker.",
+      "message_event": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\nThe `message` event is fired on a [Worker] object when the worker's parent receives a message from its worker (i.e. when the worker sends a message using [`DedicatedWorkerGlobalScope.postMessage()`](https://developer.mozilla.org/en-US/docs/Web/API/DedicatedWorkerGlobalScope/postMessage)).\n\nThis event is not cancellable and does not bubble.",
+      "messageerror_event": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\nThe `messageerror` event is fired on a [Worker] object when it receives a message that can't be deserialized.\n\nThis event is not cancellable and does not bubble.",
+      "postmessage": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\nThe **`postMessage()`** method of the [Worker] interface sends a message to the worker. The first parameter is the data to send to the worker. The data may be any JavaScript object that can be handled by the [structured clone algorithm](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm).\n\nThe [Worker] `postMessage()` method delegates to the [MessagePort] [MessagePort.postMessage] method, which adds a task on the event loop corresponding to the receiving [MessagePort].\n\nThe `Worker` can send back information to the thread that spawned it using the [DedicatedWorkerGlobalScope.postMessage] method.",
+      "terminate": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\nThe **`terminate()`** method of the [Worker] interface immediately terminates the [Worker]. This does not offer the worker an opportunity to finish its operations; it is stopped at once.",
+      "worker": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\nThe **`Worker()`** constructor creates a [Worker] object that executes the script at the specified URL. This script must obey the [same-origin policy](https://developer.mozilla.org/en-US/docs/Web/Security/Same-origin_policy).\n\n> **Note:** that there is a disagreement among browser manufacturers about whether a data URL is of the same origin or not. Though Firefox 10 and later accept data URLs, that's not the case in all other browsers."
     }
   },
   "WorkerGlobalScope": {
     "docs": "The **`WorkerGlobalScope`** interface of the [Web Workers API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API) is an interface representing the scope of any worker. Workers have no browsing context; this scope contains the information usually conveyed by [Window] objects — in this case event handlers, the console or the associated [WorkerNavigator] object. Each `WorkerGlobalScope` has its own event loop.\n\nThis interface is usually specialized by each worker type: [DedicatedWorkerGlobalScope] for dedicated workers, [SharedWorkerGlobalScope] for shared workers, and [ServiceWorkerGlobalScope] for [ServiceWorker](https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API). The `self` property returns the specialized scope for each context.",
     "properties": {
+      "caches": "The **`caches`** read-only property of the [WorkerGlobalScope] interface returns the [CacheStorage] object associated with the current context.\nThis object enables functionality such as storing assets for offline use, and generating custom responses to requests.",
+      "crossoriginisolated": "The **`crossOriginIsolated`** read-only property of the [WorkerGlobalScope] interface returns a boolean value that\nindicates whether the website is in a cross-origin isolation state. That state mitigates the risk of side-channel attacks and unlocks a few capabilities:\n\n- `SharedArrayBuffer` can be created and sent via a [DedicatedWorkerGlobalScope.postMessage] or a [MessagePort.postMessage] call.\n- [Performance.now] offers better precision.\n- [Performance.measureUserAgentSpecificMemory] can be accessed.\n\nA website is in a cross-origin isolated state, when the response header  has the value `same-origin` and the  header has the value `require-corp` or `credentialless`.",
+      "crypto": "The **`crypto`** read-only property of the [WorkerGlobalScope] interface returns the [Crypto] object for this worker. This object gives workers access to certain cryptographic related services.\n\nAlthough the property itself is read-only, all of its methods (and the methods of its\nchild object, [SubtleCrypto]) are not read-only, and therefore vulnerable\nto attack by .\n\nAlthough `crypto` is available on all workers, the returned `Crypto` object only has one usable feature in insecure contexts: the [Crypto.getRandomValues] method. In general, you should use this API only in secure contexts.",
       "dump": "The **`WorkerGlobalScope.dump()`** method logs messages to the browser's standard output (`stdout`). If the browser was started from a terminal, output sent to `dump()` will appear in the terminal. This is the same as [Window.dump], but for workers.\n\nOutput from `dump()` is _not_ sent to the browser's developer tools console. To log to the developer tools console, use [`console.log()`](https://developer.mozilla.org/en-US/docs/Web/API/console/log_static).",
       "error_event": "The **`error`** event of the [WorkerGlobalScope] interface fires when an error occurs in the worker.",
       "fonts": "The **`fonts`** property of the [WorkerGlobalScope] interface returns the [FontFaceSet] interface of the worker.\n\nThis property is part of the [CSS Font Loading API](https://developer.mozilla.org/en-US/docs/Web/API/CSS_Font_Loading_API).",
       "importscripts": "The **`importScripts()`** method of the [WorkerGlobalScope] interface synchronously imports one or more scripts into the worker's scope.",
+      "indexeddb": "The **`indexedDB`** read-only property of the [WorkerGlobalScope] interface provides a mechanism for workers to\nasynchronously access the capabilities of indexed databases.",
+      "issecurecontext": "The **`isSecureContext`** read-only property of the [WorkerGlobalScope] interface returns a boolean indicating whether the current [context is secure](https://developer.mozilla.org/en-US/docs/Web/Security/Secure_Contexts) (`true`) or not (`false`).",
       "languagechange_event": "The **`languagechange`** event is fired at the global scope object when the user's preferred language changes.\n\nThis event is not cancelable and does not bubble.",
       "location": "The **`location`** read-only property of the [WorkerGlobalScope] interface returns the [WorkerLocation] associated with the worker. It is a specific location object, mostly a subset of the [Location] for browsing scopes, but adapted to workers.",
       "navigator": "The **`navigator`** read-only property of the [WorkerGlobalScope] interface returns the [WorkerNavigator] associated with the worker. It is a specific navigator object, mostly a subset of the [Navigator] for browsing scopes, but adapted to workers.",
       "offline_event": "The **`offline`** event of the [WorkerGlobalScope] fires when the device loses connection to the internet.",
       "online_event": "The **`online`** event of the [WorkerGlobalScope] fires when the device reconnects to the internet.",
+      "origin": "The **`origin`** read-only property of the [WorkerGlobalScope] interface returns the origin of the global scope, serialized as a string.",
+      "performance": "The **`performance`** property of the [WorkerGlobalScope] interface returns a [Performance] object, which can be used to gather performance information about code running in the worker's scope.\n\nPerformance entries are per context. If you create a mark on a worker thread, you will not see it in the main thread or any other workers.\n\nNote that only the following performance interfaces are available in worker contexts:\n\n- [Performance]\n- [PerformanceEntry]\n- [PerformanceMark]\n- [PerformanceMeasure]\n- [PerformanceObserver]\n- [PerformanceObserverEntryList]\n- [PerformanceResourceTiming]\n- [PerformanceServerTiming]",
       "rejectionhandled_event": "The **`rejectionhandled`** event is sent to the script's global scope (typically [WorkerGlobalScope]) whenever a rejected `Promise` is handled late, i.e., when a handler is attached to the promise after its rejection had caused an [WorkerGlobalScope.unhandledrejection_event] event.\n\nThis can be used in debugging and for general application resiliency, in tandem with the `unhandledrejection` event, which is sent when a promise is rejected but there is no handler for the rejection at the time.",
+      "scheduler": "The **`scheduler`** read-only property of the [WorkerGlobalScope] interface is the entry point for using the [Prioritized Task Scheduling API](https://developer.mozilla.org/en-US/docs/Web/API/Prioritized_Task_Scheduling_API).\n\nThe object has a single instance method [Scheduler.postTask] that is used to post prioritized tasks for scheduling.",
       "securitypolicyviolation_event": "The **`securitypolicyviolation`** event is fired when a [Content Security Policy](https://developer.mozilla.org/en-US/docs/Web/HTTP/CSP) is violated in a worker.\n\nThe handler can be assigned using the `onsecuritypolicyviolation` event handler property or using [EventTarget.addEventListener].",
       "self": "The **`self`** read-only property of the [WorkerGlobalScope] interface returns a reference to the `WorkerGlobalScope` itself. Most of the time it is a specific scope like [DedicatedWorkerGlobalScope], [SharedWorkerGlobalScope], or [ServiceWorkerGlobalScope].",
+      "trustedtypes": "The **`trustedTypes`** read-only property of the [WorkerGlobalScope] interface returns the [TrustedTypePolicyFactory] object associated with the global object, providing the entry point for using the [Trusted Types API].",
       "unhandledrejection_event": "The **`unhandledrejection`** event is sent to the global scope (typically [WorkerGlobalScope]) of a script when a `Promise` that has no rejection handler is rejected.\n\nThis is useful for debugging and for providing fallback error handling for unexpected situations."
     }
   },
@@ -9098,9 +9287,9 @@
       "appname": "The value of the **`WorkerNavigator.appName`** property is always\n\"`Netscape`\", in any browser. This property is kept only for compatibility\npurposes.\n\n> **Note:** Do not rely on this property to return a real browser name. All browsers return \"`Netscape`\" as the value of this property.",
       "appversion": "Returns either \"`4.0`\" or a string representing version information about\nthe browser.\n\n> **Note:** Do not rely on this property to return the correct browser version.",
       "clearappbadge": "The **`clearAppBadge()`** method of the [WorkerNavigator] interface clears a badge on the current app's icon by setting it to `nothing`. The value `nothing` indicates that no badge is currently set, and the status of the badge is _cleared_.",
-      "connection": "The **`WorkerNavigator.connection`** read-only property returns\na [NetworkInformation] object containing information about the system's\nconnection, such as the current bandwidth of the user's device or whether the connection\nis metered. This could be used to select high definition content or low definition\ncontent based on the user's connection.",
+      "connection": "The **`connection`** read-only property of the [WorkerNavigator] interface returns a [NetworkInformation] object containing information about the system's connection, such as the current bandwidth of the user's device or whether the connection is metered.\nThis could be used to select high definition content or low definition content based on the user's connection.",
       "devicememory": "The **`deviceMemory`** read-only\nproperty of the [WorkerNavigator] interface returns the approximate amount of\ndevice memory in gigabytes.\n\nThe reported value is imprecise to curtail . It's approximated by\nrounding down to the nearest power of 2, then dividing that number by 1024. It is then\nclamped within lower and upper bounds to protect the privacy of owners of very low-memory or\nhigh-memory devices.",
-      "globalprivacycontrol": "The **`WorkerNavigator.globalPrivacyControl`** read-only property returns the user's Global Privacy Control setting for the current website.\nThis setting indicates whether the user consents to the website or service selling or sharing their personal information with third parties.\n\nThe value of the property reflects that of the  HTTP header.",
+      "globalprivacycontrol": "The **`WorkerNavigator.globalPrivacyControl`** read-only property returns the user's [Global Privacy Control](https://globalprivacycontrol.org/) setting for the current website.\nThis setting indicates whether the user consents to the website or service selling or sharing their personal information with third parties.\n\nThe value of the property reflects that of the  HTTP header.",
       "gpu": "The **`gpu`** read-only property of the [WorkerNavigator] interface returns the [GPU] object for the current worker context, which is the entry point for the [WebGPU_API].",
       "hardwareconcurrency": "The **`navigator.hardwareConcurrency`** read-only property\nreturns the number of logical processors available to run threads on the user's\ncomputer.",
       "language": "The **`WorkerNavigator.language`** read-only property returns\na string representing the preferred language of the user, usually the language of the\nbrowser UI.",
@@ -9108,16 +9297,16 @@
       "locks": "The **`locks`** read-only property of\nthe [WorkerNavigator] interface returns a [LockManager]\nobject which provides methods for requesting a new [Lock] object and\nquerying for an existing `Lock` object.",
       "mediacapabilities": "The read-only **`WorkerNavigator.mediaCapabilities`** property\nreturns a [MediaCapabilities] object that can expose information about the\ndecoding and encoding capabilities for a given format and output capabilities as defined\nby the [Media Capabilities API](https://developer.mozilla.org/en-US/docs/Web/API/Media_Capabilities_API).",
       "online": "Returns the online status of the browser. The property returns a boolean value, with `true` meaning online and `false` meaning offline. The property sends updates whenever the browser's ability to connect to the network changes. The update occurs when the user follows links or when a script requests a remote page.\n\nFor example, the property should return `false` when users click links soon after they lose internet connection.\n\nBrowsers implement this property differently.\n\nIn Chrome and Safari, if the browser is not able to connect to a local area network (LAN) or a router, it is offline; all other conditions return `true`. So while you can assume that the browser is offline when it returns a `false` value, you cannot assume that a true value necessarily means that the browser can access the internet. You could be getting false positives, such as in cases where the computer is running a virtualization software that has virtual ethernet adapters that are always\n\"connected.\" Therefore, if you really want to determine the online status of the browser, you should develop additional means for checking. To learn more, see the 2011 article, [Working Off the Grid](https://developer.chrome.com/docs/workbox/service-worker-overview/).\n\nIn Firefox, switching the browser to offline mode sends a `false` value.",
-      "permissions": "The **`WorkerNavigator.permissions`** read-only property\nreturns a [Permissions] object that can be used to query and update\npermission status of APIs covered by the [Permissions API](https://developer.mozilla.org/en-US/docs/Web/API/Permissions_API).",
+      "permissions": "The **`permissions`** read-only property of the [WorkerNavigator] interface\nreturns a [Permissions] object that can be used to query and update\npermission status of APIs covered by the [Permissions API](https://developer.mozilla.org/en-US/docs/Web/API/Permissions_API).",
       "platform": "Returns a string representing the platform of the browser. The specification allows\nbrowsers to always return the empty string, so don't rely on this property to get a\nreliable answer.",
       "product": "The value of the **`WorkerNavigator.product`** property is always\n\"`Gecko`\", in any browser. This property is kept only for compatibility\npurposes.\n\n> **Note:** Do not rely on this property to return a real product name. All browsers return \"`Gecko`\" as the value of this property.",
-      "serial": "The **`serial`** read-only property of the [WorkerNavigator] interface returns a [Serial] object which represents the entry point into the [Web Serial API].\n\nWhen getting, the same instance of the [Serial] object will always be returned.",
+      "serial": "@AvailableInWorkers(\"dedicated\")\n\nThe **`serial`** read-only property of the [WorkerNavigator] interface returns a [Serial] object which represents the entry point into the [Web Serial API].\n\nWhen getting, the same instance of the [Serial] object will always be returned.",
       "serviceworker": "The **`serviceWorker`** read-only property of the [WorkerNavigator] interface returns the [ServiceWorkerContainer] object for the [associated document](https://html.spec.whatwg.org/multipage/browsers.html#concept-document-window), which provides access to registration, removal, upgrade, and communication with the [ServiceWorker].\n\nThe feature may not be available in private mode.",
       "setappbadge": "The **`setAppBadge()`** method of the [WorkerNavigator] interface sets a badge on the icon associated with this app. If a value is passed to the method, this will be set as the value of the badge. Otherwise the badge will display as a dot, or other indicator as defined by the platform.",
       "storage": "The **`storage`** read-only property of the [WorkerNavigator] interface\nreturns the singleton [StorageManager] object used to\naccess the overall storage capabilities of the browser for the current site or app.\nThe returned object lets you examine and configure persistence of data stores and\nlearn approximately how much more space your browser has available for local storage\nuse.",
       "usb": "The **`usb`** read-only property of the [WorkerNavigator] interface returns a [USB] object for the current document, providing access to [WebUSB API](https://developer.mozilla.org/en-US/docs/Web/API/WebUSB_API) functionality.",
       "useragent": "The **`WorkerNavigator.userAgent`** read-only property returns the\nuser agent string for the current browser.\n\n> **Note:** The specification asks browsers to provide as little information via this field as\n> possible. Never assume that the value of this property will stay the same in future\n> versions of the same browser. Try not to use it at all, or only for current and past\n> versions of a browser. New browsers may start using the same UA, or part of it, as an\n> older browser: you really have no guarantee that the browser agent is indeed the one\n> advertised by this property.\n>\n> Also keep in mind that users of a browser can change the value of this field if they\n> want (UA spoofing).\n\nBrowser identification based on detecting the user agent string is\n**unreliable** and **is not recommended**, as the user agent\nstring is user configurable. For example:\n\n- In Firefox, you can change the preference `general.useragent.override` in\n  `about:config`. Some Firefox extensions do that; however, this only changes\n  the HTTP header that gets sent, and doesn't affect browser detection performed by\n  JavaScript code.\n- Opera 6+ allows users to set the browser identification string via a menu.",
-      "useragentdata": "The **`userAgentData`** read-only property of the [WorkerNavigator] interface returns an [NavigatorUAData] object\nwhich can be used to access the ."
+      "useragentdata": "The **`userAgentData`** read-only property of the [WorkerNavigator] interface returns an [NavigatorUAData] object which can be used to access the ."
     }
   },
   "Worklet": {
@@ -9174,54 +9363,54 @@
     "docs": "The **XMLDocument** interface represents an XML document. It inherits from the generic [Document] and does not add any specific methods or properties to it: nevertheless, several algorithms behave differently with the two types of documents."
   },
   "XMLHttpRequest": {
-    "docs": "@AvailableInWorkers(\"notservice\")\n\n`XMLHttpRequest` (XHR) objects are used to interact with servers. You can retrieve data from a URL without having to do a full page refresh. This enables a Web page to update just part of a page without disrupting what the user is doing.\n\nDespite its name, `XMLHttpRequest` can be used to retrieve any type of data, not just XML.\n\nIf your communication needs to involve receiving event data or message data from a server, consider using [server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events) through the [EventSource] interface. For full-duplex communication, [WebSockets](https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API) may be a better choice.",
-    "properties": {
-      "abort": "The **`XMLHttpRequest.abort()`** method aborts the request if\nit has already been sent. When a request is aborted, its\n[XMLHttpRequest.readyState] is changed to\n`XMLHttpRequest.UNSENT` (0) and the request's\n[XMLHttpRequest.status] code is set to 0.",
-      "abort_event": "The `abort` event is fired when a request has been aborted, for example because the program called [XMLHttpRequest.abort].",
-      "channel": "XMLHttpRequest.channel is an `nsIChannel` that used by the object when performing the request. This is `null` if the channel hasn't been created yet. In the case of a multi-part request, this is the initial channel, not the different parts in the multi-part request. **Requires elevated privileges to access.**",
-      "error_event": "The `error` event is fired when the request encountered an error.",
-      "getallresponseheaders": "The [XMLHttpRequest] method\n**`getAllResponseHeaders()`** returns all the response\nheaders, separated by , as a string, or returns `null`\nif no response has been received.\n\nIf a network error happened, an empty string\nis returned.\n\n> **Note:** For multipart requests, this returns the headers from the\n> _current_ part of the request, not from the original channel.",
-      "getresponseheader": "The [XMLHttpRequest] method\n**`getResponseHeader()`** returns the string containing the\ntext of a particular header's value.\n\nIf there are multiple response headers\nwith the same name, then their values are returned as a single concatenated string,\nwhere each value is separated from the previous one by a pair of comma and space. The\n`getResponseHeader()` method returns the value as a UTF byte sequence.\n\n> **Note:** The search for the header name is case-insensitive.\n\nIf you need to get the raw string of all of the headers, use the\n[XMLHttpRequest.getAllResponseHeaders] method,\nwhich returns the entire raw header string.",
-      "load_event": "The `load` event is fired when an [XMLHttpRequest] transaction completes successfully.",
-      "loadend_event": "The **`loadend`** event is fired when a request has completed, whether successfully (after [XMLHttpRequest.load_event]) or unsuccessfully (after [XMLHttpRequest.abort_event] or [XMLHttpRequest.error_event]).",
-      "loadstart_event": "The **`loadstart`** event is fired when a request has started to load data.",
-      "mozanon": "**`XMLHttpRequest.mozAnon`** is a boolean. If true, the request will be sent without cookies or authentication headers.",
-      "mozbackgroundrequest": "> **Note:** This method is not available from Web content. It requires elevated privileges to access.\n\n**`XMLHttpRequest.mozBackgroundRequest`** is a Boolean, indicating if the object represents a background service request. If `true`, no load group is associated with the request, with security dialogs prevented from being shown to the user.\n\nIn cases in where a security dialog (such as authentication or a bad certificate notification) would normally be shown, this request fails instead.\n\n> **Note:** This property must be set before calling `open()`.",
-      "mozsystem": "**`mozSystem`** is a boolean. If true, the same origin policy is not enforced on the request.",
-      "open": "The [XMLHttpRequest] method **`open()`**\ninitializes a newly-created request, or re-initializes an existing one.\n\n> **Note:** Calling this method for an already active request\n> (one for which `open()` has already been called) is the equivalent of calling\n> [XMLHttpRequest.abort].",
-      "overridemimetype": "The [XMLHttpRequest] method\n**`overrideMimeType()`** specifies a MIME type other than the\none provided by the server to be used instead when interpreting the data being\ntransferred in a request.\n\nThis may be used, for example, to force a stream to\nbe treated and parsed as `\"text/xml\"`, even if the server does not report it\nas such. This method must be called before calling [XMLHttpRequest.send].",
-      "progress_event": "The **`progress`** event is fired periodically when a request receives more data.",
-      "readystate": "The **XMLHttpRequest.readyState** property returns the state an XMLHttpRequest client is in. An XHR client exists in one of the following states:\n\n| Value | State              | Description                                                     |\n| ----- | ------------------ | --------------------------------------------------------------- |\n| `0`   | `UNSENT`           | Client has been created. `open()` not called yet.               |\n| `1`   | `OPENED`           | `open()` has been called.                                       |\n| `2`   | `HEADERS_RECEIVED` | `send()` has been called, and headers and status are available. |\n| `3`   | `LOADING`          | Downloading; `responseText` holds partial data.                 |\n| `4`   | `DONE`             | The operation is complete.                                      |\n\n- UNSENT\n  - : The XMLHttpRequest client has been created, but the open() method hasn't been called yet.\n- OPENED\n  - : open() method has been invoked. During this state, the request headers can be set using the [setRequestHeader()](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/setRequestHeader) method and the [send()](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/send) method can be called which will initiate the fetch.\n- HEADERS_RECEIVED\n  - : send() has been called, all redirects (if any) have been followed and the response headers have been received.\n- LOADING\n  - : Response's body is being received. If [`responseType`](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/responseType) is \"text\" or empty string, [`responseText`](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/responseText) will have the partial text response as it loads.\n- DONE\n  - : The fetch operation is complete. This could mean that either the data transfer has been completed successfully or failed.",
-      "readystatechange_event": "The `readystatechange` event is fired whenever the [XMLHttpRequest.readyState] property of the [XMLHttpRequest] changes.\n\n> **Warning:** This should not be used with synchronous requests and must\n> not be used from native code.",
-      "response": "The [XMLHttpRequest]\n**`response`** property returns the response's body content as\nan `ArrayBuffer`, a [Blob], a [Document],\na JavaScript `Object`, or a string, depending on the value\nof the request's [XMLHttpRequest.responseType]\nproperty.",
-      "responsetext": "The read-only [XMLHttpRequest] property\n**`responseText`** returns the text received from a server\nfollowing a request being sent.",
-      "responsetype": "The [XMLHttpRequest] property\n**`responseType`** is an enumerated string value specifying\nthe type of data contained in the response.\n\nIt also lets the author change the\nresponse type. If an empty string is set as the value of `responseType`, the\ndefault value of `text` is used.",
-      "responseurl": "The read-only **`XMLHttpRequest.responseURL`** property returns the serialized URL of the response or the empty string if the URL is `null`. If the URL is returned, any URL fragment present in the URL will be stripped away. The value of `responseURL` will be the final URL obtained after any redirects.",
-      "responsexml": "The **`XMLHttpRequest.responseXML`** read-only property returns\na [Document] containing the HTML or XML retrieved by the request; or\n`null` if the request was unsuccessful, has not yet been sent, or if the data\ncan't be parsed as XML or HTML.\n\n> **Note:** The name `responseXML` is an artifact of this\n> property's history; it works for both HTML and XML.\n\nUsually, the response is parsed as \"`text/xml`\". If the\n[XMLHttpRequest.responseType] is set to\n\"`document`\" and the request was made asynchronously, instead the response is\nparsed as \"`text/html`\". `responseXML` is `null` for\nany other types of data, as well as for [`data:` URLs](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URLs).\n\nIf the server doesn't specify the  as\n\"`text/xml`\" or \"`application/xml`\", you can use\n[XMLHttpRequest.overrideMimeType] to parse it as XML anyway.\n\nThis property isn't available to workers.",
-      "send": "The [XMLHttpRequest] method\n**`send()`** sends the request to the server.\n\nIf the\nrequest is asynchronous (which is the default), this method returns as soon as the\nrequest is sent and the result is delivered using events. If the request is synchronous,\nthis method doesn't return until the response has arrived.\n\n`send()` accepts an optional parameter which lets you specify the request's\nbody; this is primarily used for requests such as `PUT`. If the request\nmethod is `GET` or `HEAD`, the `body`\nparameter is ignored and the request body is set to `null`.\n\nIf no `Accept` header has been set using the\n[XMLHttpRequest.setRequestHeader], an\n`Accept` header with the type `\"*/*\"` (any type) is sent.",
-      "setrequestheader": "The [XMLHttpRequest] method **`setRequestHeader()`** sets the value of an HTTP request header.\nWhen using `setRequestHeader()`, you must call it after calling [XMLHttpRequest.open], but before calling [XMLHttpRequest.send].\nIf this method is called several times with the same header, the values are merged into one single request header.\n\nEach time you call `setRequestHeader()` after the first time you call it, the specified text is appended to the end of the existing header's content.\n\nIf no `Accept` header has been set using this, an `Accept` header with the type `\"*/*\"` is sent with the request when [XMLHttpRequest.send] is called.\n\nFor security reasons, there are several  whose values are controlled by the user agent. Any attempt to set a value for one of those headers from frontend JavaScript code will be ignored without warning or error.\n\nIn addition, the [`Authorization`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Authorization) HTTP header may be added to a request, but will be removed if the request is redirected cross-origin.\n\n> **Note:** For your custom fields, you may encounter a \"**not allowed by Access-Control-Allow-Headers in preflight response**\" exception when you send requests across domains.\n> In this situation, you need to set up the  in your response header at server side.",
-      "status": "The read-only **`XMLHttpRequest.status`** property returns the numerical HTTP [status code](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status) of the `XMLHttpRequest`'s response.\n\nBefore the request completes, the value of `status` is 0. Browsers also report a status of 0 in case of `XMLHttpRequest` errors.",
-      "statustext": "The read-only **`XMLHttpRequest.statusText`** property returns a string containing the response's status message as returned by the HTTP server. Unlike [`XMLHTTPRequest.status`](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/status) which indicates a numerical status code, this property contains the _text_ of the response status, such as \"OK\" or \"Not Found\". If the request's [`readyState`](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/readyState) is in `UNSENT` or `OPENED` state, the value of `statusText` will be an empty string.\n\nIf the server response doesn't explicitly specify a status text, `statusText` will assume the default value \"OK\".\n\n> **Note:** Responses over an HTTP/2 connection will always have an empty string as status message as HTTP/2 does not support them.",
-      "timeout": "The **`XMLHttpRequest.timeout`** property is an `unsigned long` representing the number of milliseconds a request can take before automatically being terminated. The default value is 0, which means there is no timeout. Timeout shouldn't be used for synchronous XMLHttpRequests requests used in a  or it will throw an `InvalidAccessError` exception. When a timeout happens, a [timeout](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/timeout_event) event is fired.\n\n> **Note:** You may not use a timeout for synchronous requests with an owning window.\n\n[Using a timeout with an asynchronous request](/en-US/docs/Web/API/XMLHttpRequest_API/Synchronous_and_Asynchronous_Requests#example_using_a_timeout).",
-      "timeout_event": "The **`timeout`** event is fired when progression is terminated due to preset time expiring.",
-      "upload": "The [XMLHttpRequest] `upload` property returns an [XMLHttpRequestUpload] object that can be observed to monitor an upload's progress.\n\nIt is an opaque object, but because it's also an [XMLHttpRequestEventTarget], event listeners can be attached to track its process.\n\n> **Note:** Attaching event listeners to this object prevents the request from being a \"simple request\" and will cause a preflight request to be issued if cross-origin; see [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS). Because of this, event listeners need to be registered before calling [XMLHttpRequest.send] or upload events won't be dispatched.\n\n> **Note:** The spec also seems to indicate that event listeners should be attached after [XMLHttpRequest.open]. However, browsers are buggy on this matter, and often need the listeners to be registered _before_ [XMLHttpRequest.open] to work.\n\nThe following events can be triggered on an upload object and used to monitor the upload:\n\n<table class=\"no-markdown\">\n  <thead>\n    <tr>\n      <th>Event</th>\n      <th>Description</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <td>[XMLHttpRequestUpload.loadstart_event]</td>\n      <td>The upload has begun.</td>\n    </tr>\n    <tr>\n      <td>[XMLHttpRequestUpload.progress_event]</td>\n      <td>\n        Periodically delivered to indicate the amount of progress made so far.\n      </td>\n    </tr>\n    <tr>\n      <td>[XMLHttpRequestUpload.abort_event]</td>\n      <td>The upload operation was aborted.</td>\n    </tr>\n    <tr>\n      <td>[XMLHttpRequestUpload.error_event]</td>\n      <td>The upload failed due to an error.</td>\n    </tr>\n    <tr>\n      <td>[XMLHttpRequestUpload.load_event]</td>\n      <td>The upload completed successfully.</td>\n    </tr>\n    <tr>\n      <td>[XMLHttpRequestUpload.timeout_event]</td>\n      <td>\n        The upload timed out because a reply did not arrive within the time\n        interval specified by the\n        [XMLHttpRequest.timeout].\n      </td>\n    </tr>\n    <tr>\n      <td>[XMLHttpRequestUpload.loadend_event]</td>\n      <td>\n        The upload finished. This event does not differentiate between success\n        or failure, and is sent at the end of the upload regardless of the\n        outcome. Prior to this event, one of <code>load</code>,\n        <code>error</code>, <code>abort</code>, or <code>timeout</code> will\n        already have been delivered to indicate why the upload ended.\n      </td>\n    </tr>\n  </tbody>\n</table>",
-      "withcredentials": "The **`XMLHttpRequest.withCredentials`** property is a boolean value that indicates whether or not cross-site `Access-Control` requests should be made using credentials such as cookies, authorization headers or TLS client certificates. Setting `withCredentials` has no effect on same-origin requests.\n\nIn addition, this flag is also used to indicate when cookies are to be ignored in the response. The default is `false`. `XMLHttpRequest` responses from a different domain cannot set cookie values for their own domain unless `withCredentials` is set to `true` before making the request. The third-party cookies obtained by setting `withCredentials` to true will still honor same-origin policy and hence can not be accessed by the requesting script through [document.cookie](https://developer.mozilla.org/en-US/docs/Web/API/Document/cookie) or from response headers.\n\n> **Note:** This never affects same-origin requests.\n\n> **Note:** `XMLHttpRequest` responses from a different domain _cannot_ set cookie values for their own domain unless `withCredentials` is set to `true` before making the request, regardless of `Access-Control-` header values.",
-      "xmlhttprequest": "The **`XMLHttpRequest()`** constructor\ncreates a new [XMLHttpRequest]."
+    "docs": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\n`XMLHttpRequest` (XHR) objects are used to interact with servers. You can retrieve data from a URL without having to do a full page refresh. This enables a Web page to update just part of a page without disrupting what the user is doing.\n\nDespite its name, `XMLHttpRequest` can be used to retrieve any type of data, not just XML.\n\nIf your communication needs to involve receiving event data or message data from a server, consider using [server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events) through the [EventSource] interface. For full-duplex communication, [WebSockets](https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API) may be a better choice.",
+    "properties": {
+      "abort": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\nThe **`XMLHttpRequest.abort()`** method aborts the request if\nit has already been sent. When a request is aborted, its\n[XMLHttpRequest.readyState] is changed to\n`XMLHttpRequest.UNSENT` (0) and the request's\n[XMLHttpRequest.status] code is set to 0.",
+      "abort_event": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\nThe `abort` event is fired when a request has been aborted, for example because the program called [XMLHttpRequest.abort].",
+      "channel": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\nXMLHttpRequest.channel is an `nsIChannel` that used by the object when performing the request. This is `null` if the channel hasn't been created yet. In the case of a multi-part request, this is the initial channel, not the different parts in the multi-part request. **Requires elevated privileges to access.**",
+      "error_event": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\nThe `error` event is fired when the request encountered an error.",
+      "getallresponseheaders": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\nThe [XMLHttpRequest] method\n**`getAllResponseHeaders()`** returns all the response\nheaders, separated by , as a string, or returns `null`\nif no response has been received.\n\nIf a network error happened, an empty string\nis returned.\n\n> **Note:** For multipart requests, this returns the headers from the\n> _current_ part of the request, not from the original channel.",
+      "getresponseheader": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\nThe [XMLHttpRequest] method\n**`getResponseHeader()`** returns the string containing the\ntext of a particular header's value.\n\nIf there are multiple response headers\nwith the same name, then their values are returned as a single concatenated string,\nwhere each value is separated from the previous one by a pair of comma and space. The\n`getResponseHeader()` method returns the value as a UTF byte sequence.\n\n> **Note:** The search for the header name is case-insensitive.\n\nIf you need to get the raw string of all of the headers, use the\n[XMLHttpRequest.getAllResponseHeaders] method,\nwhich returns the entire raw header string.",
+      "load_event": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\nThe `load` event is fired when an [XMLHttpRequest] transaction completes successfully.",
+      "loadend_event": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\nThe **`loadend`** event is fired when a request has completed, whether successfully (after [XMLHttpRequest.load_event]) or unsuccessfully (after [XMLHttpRequest.abort_event] or [XMLHttpRequest.error_event]).",
+      "loadstart_event": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\nThe **`loadstart`** event is fired when a request has started to load data.",
+      "mozanon": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\n**`XMLHttpRequest.mozAnon`** is a boolean. If true, the request will be sent without cookies or authentication headers.",
+      "mozbackgroundrequest": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\n> **Note:** This method is not available from Web content. It requires elevated privileges to access.\n\n**`XMLHttpRequest.mozBackgroundRequest`** is a Boolean, indicating if the object represents a background service request. If `true`, no load group is associated with the request, with security dialogs prevented from being shown to the user.\n\nIn cases in where a security dialog (such as authentication or a bad certificate notification) would normally be shown, this request fails instead.\n\n> **Note:** This property must be set before calling `open()`.",
+      "mozsystem": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\n**`mozSystem`** is a boolean. If true, the same origin policy is not enforced on the request.",
+      "open": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\nThe [XMLHttpRequest] method **`open()`**\ninitializes a newly-created request, or re-initializes an existing one.\n\n> **Note:** Calling this method for an already active request\n> (one for which `open()` has already been called) is the equivalent of calling\n> [XMLHttpRequest.abort].",
+      "overridemimetype": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\nThe [XMLHttpRequest] method\n**`overrideMimeType()`** specifies a MIME type other than the\none provided by the server to be used instead when interpreting the data being\ntransferred in a request.\n\nThis may be used, for example, to force a stream to\nbe treated and parsed as `\"text/xml\"`, even if the server does not report it\nas such. This method must be called before calling [XMLHttpRequest.send].",
+      "progress_event": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\nThe **`progress`** event is fired periodically when a request receives more data.",
+      "readystate": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\nThe **XMLHttpRequest.readyState** property returns the state an XMLHttpRequest client is in. An XHR client exists in one of the following states:\n\n| Value | State              | Description                                                     |\n| ----- | ------------------ | --------------------------------------------------------------- |\n| `0`   | `UNSENT`           | Client has been created. `open()` not called yet.               |\n| `1`   | `OPENED`           | `open()` has been called.                                       |\n| `2`   | `HEADERS_RECEIVED` | `send()` has been called, and headers and status are available. |\n| `3`   | `LOADING`          | Downloading; `responseText` holds partial data.                 |\n| `4`   | `DONE`             | The operation is complete.                                      |\n\n- UNSENT\n  - : The XMLHttpRequest client has been created, but the open() method hasn't been called yet.\n- OPENED\n  - : open() method has been invoked. During this state, the request headers can be set using the [setRequestHeader()](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/setRequestHeader) method and the [send()](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/send) method can be called which will initiate the fetch.\n- HEADERS_RECEIVED\n  - : send() has been called, all redirects (if any) have been followed and the response headers have been received.\n- LOADING\n  - : Response's body is being received. If [`responseType`](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/responseType) is \"text\" or empty string, [`responseText`](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/responseText) will have the partial text response as it loads.\n- DONE\n  - : The fetch operation is complete. This could mean that either the data transfer has been completed successfully or failed.",
+      "readystatechange_event": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\nThe `readystatechange` event is fired whenever the [XMLHttpRequest.readyState] property of the [XMLHttpRequest] changes.\n\n> **Warning:** This should not be used with synchronous requests and must\n> not be used from native code.",
+      "response": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\nThe [XMLHttpRequest]\n**`response`** property returns the response's body content as\nan `ArrayBuffer`, a [Blob], a [Document],\na JavaScript `Object`, or a string, depending on the value\nof the request's [XMLHttpRequest.responseType]\nproperty.",
+      "responsetext": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\nThe read-only [XMLHttpRequest] property\n**`responseText`** returns the text received from a server\nfollowing a request being sent.",
+      "responsetype": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\nThe [XMLHttpRequest] property\n**`responseType`** is an enumerated string value specifying\nthe type of data contained in the response.\n\nIt also lets the author change the\nresponse type. If an empty string is set as the value of `responseType`, the\ndefault value of `text` is used.",
+      "responseurl": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\nThe read-only **`XMLHttpRequest.responseURL`** property returns the serialized URL of the response or the empty string if the URL is `null`. If the URL is returned, any URL fragment present in the URL will be stripped away. The value of `responseURL` will be the final URL obtained after any redirects.",
+      "responsexml": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\nThe **`XMLHttpRequest.responseXML`** read-only property returns\na [Document] containing the HTML or XML retrieved by the request; or\n`null` if the request was unsuccessful, has not yet been sent, or if the data\ncan't be parsed as XML or HTML.\n\n> **Note:** The name `responseXML` is an artifact of this\n> property's history; it works for both HTML and XML.\n\nUsually, the response is parsed as \"`text/xml`\". If the\n[XMLHttpRequest.responseType] is set to\n\"`document`\" and the request was made asynchronously, instead the response is\nparsed as \"`text/html`\". `responseXML` is `null` for\nany other types of data, as well as for [`data:` URLs](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URLs).\n\nIf the server doesn't specify the  as\n\"`text/xml`\" or \"`application/xml`\", you can use\n[XMLHttpRequest.overrideMimeType] to parse it as XML anyway.\n\nThis property isn't available to workers.",
+      "send": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\nThe [XMLHttpRequest] method\n**`send()`** sends the request to the server.\n\nIf the\nrequest is asynchronous (which is the default), this method returns as soon as the\nrequest is sent and the result is delivered using events. If the request is synchronous,\nthis method doesn't return until the response has arrived.\n\n`send()` accepts an optional parameter which lets you specify the request's\nbody; this is primarily used for requests such as `PUT`. If the request\nmethod is `GET` or `HEAD`, the `body`\nparameter is ignored and the request body is set to `null`.\n\nIf no `Accept` header has been set using the\n[XMLHttpRequest.setRequestHeader], an\n`Accept` header with the type `\"*/*\"` (any type) is sent.",
+      "setrequestheader": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\nThe [XMLHttpRequest] method **`setRequestHeader()`** sets the value of an HTTP request header.\nWhen using `setRequestHeader()`, you must call it after calling [XMLHttpRequest.open], but before calling [XMLHttpRequest.send].\nIf this method is called several times with the same header, the values are merged into one single request header.\n\nEach time you call `setRequestHeader()` after the first time you call it, the specified text is appended to the end of the existing header's content.\n\nIf no `Accept` header has been set using this, an `Accept` header with the type `\"*/*\"` is sent with the request when [XMLHttpRequest.send] is called.\n\nFor security reasons, there are several  whose values are controlled by the user agent. Any attempt to set a value for one of those headers from frontend JavaScript code will be ignored without warning or error.\n\nIn addition, the [`Authorization`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Authorization) HTTP header may be added to a request, but will be removed if the request is redirected cross-origin.\n\n> **Note:** For your custom fields, you may encounter a \"**not allowed by Access-Control-Allow-Headers in preflight response**\" exception when you send requests across domains.\n> In this situation, you need to set up the  in your response header at server side.",
+      "status": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\nThe read-only **`XMLHttpRequest.status`** property returns the numerical HTTP [status code](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status) of the `XMLHttpRequest`'s response.\n\nBefore the request completes, the value of `status` is 0. Browsers also report a status of 0 in case of `XMLHttpRequest` errors.",
+      "statustext": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\nThe read-only **`XMLHttpRequest.statusText`** property returns a string containing the response's status message as returned by the HTTP server. Unlike [`XMLHTTPRequest.status`](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/status) which indicates a numerical status code, this property contains the _text_ of the response status, such as \"OK\" or \"Not Found\". If the request's [`readyState`](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/readyState) is in `UNSENT` or `OPENED` state, the value of `statusText` will be an empty string.\n\nIf the server response doesn't explicitly specify a status text, `statusText` will assume the default value \"OK\".\n\n> **Note:** Responses over an HTTP/2 connection will always have an empty string as status message as HTTP/2 does not support them.",
+      "timeout": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\nThe **`XMLHttpRequest.timeout`** property is an `unsigned long` representing the number of milliseconds a request can take before automatically being terminated. The default value is 0, which means there is no timeout. Timeout shouldn't be used for synchronous XMLHttpRequests requests used in a  or it will throw an `InvalidAccessError` exception. When a timeout happens, a [timeout](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/timeout_event) event is fired.\n\n> **Note:** You may not use a timeout for synchronous requests with an owning window.\n\n[Using a timeout with an asynchronous request](/en-US/docs/Web/API/XMLHttpRequest_API/Synchronous_and_Asynchronous_Requests#example_using_a_timeout).",
+      "timeout_event": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\nThe **`timeout`** event is fired when progression is terminated due to preset time expiring.",
+      "upload": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\nThe [XMLHttpRequest] `upload` property returns an [XMLHttpRequestUpload] object that can be observed to monitor an upload's progress.\n\nIt is an opaque object, but because it's also an [XMLHttpRequestEventTarget], event listeners can be attached to track its process.\n\n> **Note:** Attaching event listeners to this object prevents the request from being a \"simple request\" and will cause a preflight request to be issued if cross-origin; see [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS). Because of this, event listeners need to be registered before calling [XMLHttpRequest.send] or upload events won't be dispatched.\n\n> **Note:** The spec also seems to indicate that event listeners should be attached after [XMLHttpRequest.open]. However, browsers are buggy on this matter, and often need the listeners to be registered _before_ [XMLHttpRequest.open] to work.\n\nThe following events can be triggered on an upload object and used to monitor the upload:\n\n<table class=\"no-markdown\">\n  <thead>\n    <tr>\n      <th>Event</th>\n      <th>Description</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <td>[XMLHttpRequestUpload.loadstart_event]</td>\n      <td>The upload has begun.</td>\n    </tr>\n    <tr>\n      <td>[XMLHttpRequestUpload.progress_event]</td>\n      <td>\n        Periodically delivered to indicate the amount of progress made so far.\n      </td>\n    </tr>\n    <tr>\n      <td>[XMLHttpRequestUpload.abort_event]</td>\n      <td>The upload operation was aborted.</td>\n    </tr>\n    <tr>\n      <td>[XMLHttpRequestUpload.error_event]</td>\n      <td>The upload failed due to an error.</td>\n    </tr>\n    <tr>\n      <td>[XMLHttpRequestUpload.load_event]</td>\n      <td>The upload completed successfully.</td>\n    </tr>\n    <tr>\n      <td>[XMLHttpRequestUpload.timeout_event]</td>\n      <td>\n        The upload timed out because a reply did not arrive within the time\n        interval specified by the\n        [XMLHttpRequest.timeout].\n      </td>\n    </tr>\n    <tr>\n      <td>[XMLHttpRequestUpload.loadend_event]</td>\n      <td>\n        The upload finished. This event does not differentiate between success\n        or failure, and is sent at the end of the upload regardless of the\n        outcome. Prior to this event, one of <code>load</code>,\n        <code>error</code>, <code>abort</code>, or <code>timeout</code> will\n        already have been delivered to indicate why the upload ended.\n      </td>\n    </tr>\n  </tbody>\n</table>",
+      "withcredentials": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\nThe **`XMLHttpRequest.withCredentials`** property is a boolean value that indicates whether or not cross-site `Access-Control` requests should be made using credentials such as cookies, authentication headers or TLS client certificates. Setting `withCredentials` has no effect on same-origin requests.\n\nIn addition, this flag is also used to indicate when cookies are to be ignored in the response. The default is `false`. `XMLHttpRequest` responses from a different domain cannot set cookie values for their own domain unless `withCredentials` is set to `true` before making the request. The [third-party cookies](https://developer.mozilla.org/en-US/docs/Web/Privacy/Third-party_cookies) obtained by setting `withCredentials` to `true` will still honor same-origin policy and hence can not be accessed by the requesting script through [document.cookie](https://developer.mozilla.org/en-US/docs/Web/API/Document/cookie) or from response headers.\n\n> **Note:** This never affects same-origin requests.\n\n> **Note:** `XMLHttpRequest` responses from a different domain _cannot_ set cookie values for their own domain unless `withCredentials` is set to `true` before making the request, regardless of `Access-Control-` header values.",
+      "xmlhttprequest": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\nThe **`XMLHttpRequest()`** constructor\ncreates a new [XMLHttpRequest]."
     }
   },
   "XMLHttpRequestEventTarget": {
-    "docs": "`XMLHttpRequestEventTarget` is the interface that describes the event handlers shared on [XMLHttpRequest] and [XMLHttpRequestUpload].\n\nYou don't use `XMLHttpRequestEventTarget` directly; instead you interact with the sub classes."
+    "docs": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\n`XMLHttpRequestEventTarget` is the interface that describes the event handlers shared on [XMLHttpRequest] and [XMLHttpRequestUpload].\n\nYou don't use `XMLHttpRequestEventTarget` directly; instead you interact with the sub classes."
   },
   "XMLHttpRequestUpload": {
-    "docs": "@AvailableInWorkers(\"notservice\")\n\nThe **`XMLHttpRequestUpload`** interface represents the upload process for a specific [XMLHttpRequest]. It is an _opaque_ object that represents the underlying, browser-dependent, upload process. It is an [XMLHttpRequestEventTarget] and can be obtained by calling [XMLHttpRequest.upload].",
+    "docs": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\nThe **`XMLHttpRequestUpload`** interface represents the upload process for a specific [XMLHttpRequest]. It is an _opaque_ object that represents the underlying, browser-dependent, upload process. It is an [XMLHttpRequestEventTarget] and can be obtained by calling [XMLHttpRequest.upload].",
     "properties": {
-      "abort_event": "The `abort` event is fired at [XMLHttpRequestUpload] when a request has been aborted, for example because the program called [XMLHttpRequest.abort].",
-      "error_event": "The `error` event is fired when the request encountered an error.",
-      "load_event": "The `load` event is fired when an [XMLHttpRequestUpload] transaction completes successfully.",
-      "loadend_event": "The **`loadend`** event is fired when a request has completed, whether successfully (after [XMLHttpRequestUpload.load_event]) or unsuccessfully (after [XMLHttpRequestUpload.abort_event] or [XMLHttpRequestUpload.error_event]).\n\nThe `loadend` event is also sent when the request has been interrupted (by a [XMLHttpRequestUpload.timeout_event], an [XMLHttpRequestUpload.abort_event], or an [XMLHttpRequestUpload.error_event]). In such cases, both the `loaded` and `total` value of the event will be 0.",
-      "loadstart_event": "The **`loadstart`** event is fired when a request has started to load data.",
-      "progress_event": "The **`progress`** event is fired periodically when a request receives more data.",
-      "timeout_event": "The **`timeout`** event is fired when progression is terminated due to preset time expiring."
+      "abort_event": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\nThe `abort` event is fired at [XMLHttpRequestUpload] when a request has been aborted, for example because the program called [XMLHttpRequest.abort].",
+      "error_event": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\nThe `error` event is fired when the request encountered an error.",
+      "load_event": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\nThe `load` event is fired when an [XMLHttpRequestUpload] transaction completes successfully.",
+      "loadend_event": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\nThe **`loadend`** event is fired when a request has completed, whether successfully (after [XMLHttpRequestUpload.load_event]) or unsuccessfully (after [XMLHttpRequestUpload.abort_event] or [XMLHttpRequestUpload.error_event]).\n\nThe `loadend` event is also sent when the request has been interrupted (by a [XMLHttpRequestUpload.timeout_event], an [XMLHttpRequestUpload.abort_event], or an [XMLHttpRequestUpload.error_event]). In such cases, both the `loaded` and `total` value of the event will be 0.",
+      "loadstart_event": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\nThe **`loadstart`** event is fired when a request has started to load data.",
+      "progress_event": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\nThe **`progress`** event is fired periodically when a request receives more data.",
+      "timeout_event": "@AvailableInWorkers(\"window_and_worker_except_service\")\n\nThe **`timeout`** event is fired when progression is terminated due to preset time expiring."
     }
   },
   "XMLSerializer": {
@@ -9694,14 +9883,14 @@
     }
   },
   "console": {
-    "docs": "The **`console`** object provides access to the debugging console (e.g., the [Web console](https://firefox-source-docs.mozilla.org/devtools-user/web_console/index.html) in Firefox). The specifics of how it works vary from browser to browser or server runtimes (Node.js, for example), but there is a _de facto_ set of features that are typically provided.\n\nThe `console` object can be accessed from any global object. [Window] on browsing scopes and [WorkerGlobalScope] as specific variants in workers via the property console. It's exposed as [Window.console], and can be referenced as `console`. For example:\n\n```js\nconsole.log(\"Failed to open the specified link\");\n```\n\nThis page documents the [Methods](#methods) available on the `console` object and gives a few [Usage](#usage) examples.\n\n> **Note:** Certain online IDEs and editors may implement the console API differently than the browsers. As a result, certain functionality of the console API, such as the timer methods, may not be outputted in the console of online IDEs or editors. Always open your browser's DevTools console to see the logs as shown in this documentation.",
+    "docs": "The **`console`** object provides access to the debugging console (e.g., the [Web console](https://firefox-source-docs.mozilla.org/devtools-user/web_console/index.html) in Firefox).\n\nImplementations of the console API may differ between runtimes. In particular, some console methods may work differently or not work at all in some online editors and IDEs. To see the behavior described in this documentation, try the methods in your browser's developer tools, although even here, there are some differences between browsers.\n\nThe `console` object can be accessed from any global object. [Window] on browsing scopes and [WorkerGlobalScope] as specific variants in workers via the property console. It's exposed as [Window.console], and can be referenced as `console`. For example:\n\n```js\nconsole.log(\"Failed to open the specified link\");\n```\n\nThis page documents the [Methods](#methods) available on the `console` object and gives a few [Usage](#usage) examples.",
     "properties": {
       "assert_static": "The **`console.assert()`** static method writes an error message to the console if the assertion is false. If the assertion is true, nothing happens.",
       "clear_static": "The **`console.clear()`** static method clears the console if the console allows it. A graphical console, like those running on browsers, will allow it; a console displaying on the terminal, like the one running on Node, will not support it, and will have no effect (and no error).",
       "count_static": "The **`console.count()`** static method logs the number of times that this particular call to `count()` has been called.",
       "countreset_static": "The **`console.countReset()`** static method resets counter used with [console.count_static].",
       "debug_static": "The **`console.debug()`** static method outputs a message to the console at the \"debug\" log level. The message is only displayed to the user if the console is configured to display debug output. In most cases, the log level is configured within the console UI. This log level might correspond to the `Debug` or `Verbose` log level.",
-      "dir_static": "The **`console.dir()`** static method displays an interactive list of the properties of the specified JavaScript object. The output is presented as a hierarchical listing with disclosure triangles that let you see the contents of child objects.\n\nIn other words, `console.dir()` is the way to see all the properties of a specified JavaScript object in console by which the developer can easily get the properties of the object.\n\n![A screenshot of the Firefox console where console.dir(document.location) is run. We can see the URL of the page, followed by a block of properties. If the property is a function or an object, a disclosure triangle is prepended.](console-dir.png)",
+      "dir_static": "The **`console.dir()`** static method displays a list of the properties of the specified JavaScript object. In browser consoles, the output is presented as a hierarchical listing with disclosure triangles that let you see the contents of child objects.\n\nIn other words, `console.dir()` is the way to see all the properties of a specified JavaScript object in the console.\n\n![A screenshot of the Firefox console where console.dir(document.location) is run. We can see the URL of the page, followed by a block of properties. If the property is a function or an object, a disclosure triangle is prepended.](console-dir.png)\n\nIn runtimes like  and , where console output goes to the terminal and is therefore not interactive, the `options` parameter provides a way to customize the way the object is presented.",
       "dirxml_static": "The **`console.dirxml()`** static method displays an interactive tree of the descendant elements of the specified XML/HTML element. If it is not possible to display as an element the JavaScript Object view is shown instead. The output is presented as a hierarchical listing of expandable nodes that let you see the contents of child nodes.",
       "error_static": "The **`console.error()`** static method outputs an error message to the console.",
       "group_static": "The **`console.group()`** static method creates a new inline group in the [Web console](https://firefox-source-docs.mozilla.org/devtools-user/web_console/index.html) log, causing any subsequent console messages to be indented by an additional level, until [console.groupend_static] is called.",