@webref/idl 3.47.1 → 3.47.2

package/compute-pressure.idl

@@ -21,7 +21,7 @@ interface PressureObserver {
   undefined disconnect();
   sequence<PressureRecord> takeRecords();
 
-  [SameObject] static readonly attribute FrozenArray<PressureSource> supportedSources;
+  [SameObject] static readonly attribute FrozenArray<PressureSource> knownSources;
 };
 
 [Exposed=(DedicatedWorker,SharedWorker,Window), SecureContext]

package/digital-identities.idl

@@ -23,5 +23,5 @@ dictionary IdentityRequestProvider {
 [Exposed=Window, SecureContext]
 interface DigitalCredential : Credential {
   readonly attribute DOMString protocol;
-  [SameObject] readonly attribute Uint8Array data;
+  readonly attribute any data;
 };

package/encrypted-media.idl

@@ -5,44 +5,46 @@
 
 [Exposed=Window]
 partial interface Navigator {
-    [SecureContext] Promise<MediaKeySystemAccess> requestMediaKeySystemAccess (DOMString keySystem, sequence<MediaKeySystemConfiguration> supportedConfigurations);
+  [SecureContext] Promise<MediaKeySystemAccess> requestMediaKeySystemAccess (
+      DOMString keySystem,
+      sequence<MediaKeySystemConfiguration> supportedConfigurations);
 };
 
 enum MediaKeysRequirement {
-    "required",
-    "optional",
-    "not-allowed"
+  "required",
+  "optional",
+  "not-allowed"
 };
 
 dictionary MediaKeySystemConfiguration {
-             DOMString                               label = "";
-             sequence<DOMString>                     initDataTypes = [];
-             sequence<MediaKeySystemMediaCapability> audioCapabilities = [];
-             sequence<MediaKeySystemMediaCapability> videoCapabilities = [];
-             MediaKeysRequirement                    distinctiveIdentifier = "optional";
-             MediaKeysRequirement                    persistentState = "optional";
-             sequence<DOMString>                     sessionTypes;
+  DOMString                               label = "";
+  sequence<DOMString>                     initDataTypes = [];
+  sequence<MediaKeySystemMediaCapability> audioCapabilities = [];
+  sequence<MediaKeySystemMediaCapability> videoCapabilities = [];
+  MediaKeysRequirement                    distinctiveIdentifier = "optional";
+  MediaKeysRequirement                    persistentState = "optional";
+  sequence<DOMString>                     sessionTypes;
 };
 
 dictionary MediaKeySystemMediaCapability {
-   DOMString contentType = "";
-   DOMString? encryptionScheme = null;
-   DOMString robustness = "";
+  DOMString contentType = "";
+  DOMString? encryptionScheme = null;
+  DOMString robustness = "";
 };
 
 [Exposed=Window, SecureContext] interface MediaKeySystemAccess {
-    readonly        attribute DOMString keySystem;
-    MediaKeySystemConfiguration getConfiguration ();
-    Promise<MediaKeys>          createMediaKeys ();
+  readonly attribute DOMString keySystem;
+  MediaKeySystemConfiguration  getConfiguration ();
+  Promise<MediaKeys>           createMediaKeys ();
 };
 
 enum MediaKeySessionType {
-    "temporary",
-    "persistent-license"
+  "temporary",
+  "persistent-license"
 };
 
 [Exposed=Window, SecureContext] interface MediaKeys {
-    MediaKeySession  createSession (optional MediaKeySessionType sessionType = "temporary");
+    MediaKeySession createSession (optional MediaKeySessionType sessionType = "temporary");
     Promise<MediaKeyStatus> getStatusForPolicy (optional MediaKeysPolicy policy = {});
     Promise<boolean> setServerCertificate (BufferSource serverCertificate);
 };
@@ -64,69 +66,69 @@ enum HDCPVersion {
 };
 
 enum MediaKeySessionClosedReason {
-    "internal-error",
-    "closed-by-application",
-    "release-acknowledged",
-    "hardware-context-reset",
-    "resource-evicted"
+  "internal-error",
+  "closed-by-application",
+  "release-acknowledged",
+  "hardware-context-reset",
+  "resource-evicted"
 };
 
 [Exposed=Window, SecureContext] interface MediaKeySession : EventTarget {
-    readonly        attribute DOMString                            sessionId;
-    readonly        attribute unrestricted double                  expiration;
-    readonly        attribute Promise<MediaKeySessionClosedReason> closed;
-    readonly        attribute MediaKeyStatusMap                    keyStatuses;
-                    attribute EventHandler                         onkeystatuseschange;
-                    attribute EventHandler                         onmessage;
-    Promise<undefined>    generateRequest (DOMString initDataType, BufferSource initData);
-    Promise<boolean> load (DOMString sessionId);
-    Promise<undefined>    update (BufferSource response);
-    Promise<undefined>    close ();
-    Promise<undefined>    remove ();
+  readonly        attribute DOMString                            sessionId;
+  readonly        attribute unrestricted double                  expiration;
+  readonly        attribute Promise<MediaKeySessionClosedReason> closed;
+  readonly        attribute MediaKeyStatusMap                    keyStatuses;
+                  attribute EventHandler                         onkeystatuseschange;
+                  attribute EventHandler                         onmessage;
+  Promise<undefined>    generateRequest (DOMString initDataType, BufferSource initData);
+  Promise<boolean> load (DOMString sessionId);
+  Promise<undefined>    update (BufferSource response);
+  Promise<undefined>    close ();
+  Promise<undefined>    remove ();
 };
 
 [Exposed=Window, SecureContext] interface MediaKeyStatusMap {
-    iterable<BufferSource,MediaKeyStatus>;
-    readonly        attribute unsigned long size;
-    boolean has (BufferSource keyId);
-    (MediaKeyStatus or undefined)     get (BufferSource keyId);
+  iterable<BufferSource,MediaKeyStatus>;
+  readonly attribute unsigned long size;
+  boolean has (BufferSource keyId);
+  (MediaKeyStatus or undefined) get (BufferSource keyId);
 };
 
 enum MediaKeyStatus {
-    "usable",
-    "expired",
-    "released",
-    "output-restricted",
-    "output-downscaled",
-    "usable-in-future",
-    "status-pending",
-    "internal-error"
+  "usable",
+  "expired",
+  "released",
+  "output-restricted",
+  "output-downscaled",
+  "usable-in-future",
+  "status-pending",
+  "internal-error"
 };
 
 enum MediaKeyMessageType {
-    "license-request",
-    "license-renewal",
-    "license-release",
-    "individualization-request"
+  "license-request",
+  "license-renewal",
+  "license-release",
+  "individualization-request"
 };
 
 [Exposed=Window, SecureContext]
 interface MediaKeyMessageEvent : Event {
-    constructor(DOMString type, MediaKeyMessageEventInit eventInitDict);
-    readonly        attribute MediaKeyMessageType messageType;
-    readonly        attribute ArrayBuffer         message;
+  constructor(DOMString type, MediaKeyMessageEventInit eventInitDict);
+  readonly attribute MediaKeyMessageType messageType;
+  readonly attribute ArrayBuffer         message;
 };
 
 dictionary MediaKeyMessageEventInit : EventInit {
-             required MediaKeyMessageType messageType;
-             required ArrayBuffer         message;
+  required MediaKeyMessageType messageType;
+  required ArrayBuffer         message;
 };
 
 [Exposed=Window] partial interface HTMLMediaElement {
-    [SecureContext] readonly        attribute MediaKeys?   mediaKeys;
-                                    attribute EventHandler onencrypted;
-                                    attribute EventHandler onwaitingforkey;
-    [SecureContext] Promise<undefined> setMediaKeys (MediaKeys? mediaKeys);
+  [SecureContext] readonly        attribute MediaKeys?   mediaKeys;
+                                  attribute EventHandler onencrypted;
+                                  attribute EventHandler onwaitingforkey;
+  [SecureContext] Promise<undefined> setMediaKeys (MediaKeys? mediaKeys);
 };
 
 [Exposed=Window]
@@ -137,6 +139,6 @@ interface MediaEncryptedEvent : Event {
 };
 
 dictionary MediaEncryptedEventInit : EventInit {
-             DOMString    initDataType = "";
-             ArrayBuffer? initData = null;
+  DOMString    initDataType = "";
+  ArrayBuffer? initData = null;
 };

package/fenced-frame.idl

@@ -53,10 +53,17 @@ dictionary FenceEvent {
   DOMString eventData;
   sequence<FenceReportingDestination> destination;
 
+  // Determines if this data can be sent in a reportEvent() beacon or automatic
+  // beacon that originates from a document that is cross-origin to the mapped
+  // URL of the fenced frame config that loaded this frame tree.
+  // Note that automatic beacon data can only be set from documents that are
+  // same-origin to the fenced frame config’s mapped URL, so this effectively
+  // opts in the data to being used in a cross-origin subframe.
+  boolean crossOriginExposed = false;
+
   // When setting event data to be used later in an automatic beacon, the
   // following properties are used:
   boolean once = false;
-  boolean crossOriginExposed = false;
 
   // When reporting to a custom destination URL (with substitution of macros defined by
   // the Protected Audience buyer), the following property is used:

package/mediacapture-streams.idl

@@ -179,6 +179,16 @@ interface InputDeviceInfo : MediaDeviceInfo {
   MediaTrackCapabilities getCapabilities();
 };
 
+[Exposed=Window]
+interface DeviceChangeEvent : Event {
+  constructor(DOMString type, optional DeviceChangeEventInit eventInitDict = {});
+  [SameObject] readonly attribute FrozenArray<MediaDeviceInfo> devices;
+};
+
+dictionary DeviceChangeEventInit : EventInit {
+  sequence<MediaDeviceInfo> devices = [];
+};
+
 partial interface MediaDevices {
   MediaTrackSupportedConstraints getSupportedConstraints();
   Promise<MediaStream> getUserMedia(optional MediaStreamConstraints constraints = {});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@webref/idl",
   "description": "Web IDL definitions of the web platform",
-  "version": "3.47.1",
+  "version": "3.47.2",
   "repository": {
     "type": "git",
     "url": "https://github.com/w3c/webref.git"

package/service-workers.idl

@@ -60,7 +60,7 @@ interface ServiceWorkerContainer : EventTarget {
   readonly attribute ServiceWorker? controller;
   readonly attribute Promise<ServiceWorkerRegistration> ready;
 
-  [NewObject] Promise<ServiceWorkerRegistration> register(USVString scriptURL, optional RegistrationOptions options = {});
+  [NewObject] Promise<ServiceWorkerRegistration> register((TrustedScriptURL or USVString) scriptURL, optional RegistrationOptions options = {});
 
   [NewObject] Promise<(ServiceWorkerRegistration or undefined)> getRegistration(optional USVString clientURL = "");
   [NewObject] Promise<FrozenArray<ServiceWorkerRegistration>> getRegistrations();