@webref/idl 3.42.0 → 3.42.2

package/css-transitions.idl

@@ -1,7 +1,7 @@
 // GENERATED CONTENT - DO NOT EDIT
 // Content was automatically extracted by Reffy into webref
 // (https://github.com/w3c/webref)
-// Source: CSS Transitions (https://drafts.csswg.org/css-transitions-1/)
+// Source: CSS Transitions Level 1 (https://drafts.csswg.org/css-transitions-1/)
 
 [Exposed=Window]
 interface TransitionEvent : Event {

package/css-view-transitions-2.idl

@@ -3,11 +3,6 @@
 // (https://github.com/w3c/webref)
 // Source: CSS View Transitions Module Level 2 (https://drafts.csswg.org/css-view-transitions-2/)
 
-[Exposed=Window]
-interface PageRevealEvent : Event {
-  readonly attribute ViewTransition? viewTransition;
-};
-
 dictionary StartViewTransitionOptions {
   UpdateCallback? update = null;
   sequence<DOMString>? type = null;

package/dom.idl

@@ -339,6 +339,7 @@ interface ShadowRoot : DocumentFragment {
   readonly attribute ShadowRootMode mode;
   readonly attribute boolean delegatesFocus;
   readonly attribute SlotAssignmentMode slotAssignment;
+  readonly attribute boolean clonable;
   readonly attribute Element host;
   attribute EventHandler onslotchange;
 };

package/html.idl

@@ -1872,6 +1872,7 @@ interface Navigation : EventTarget {
   readonly attribute NavigationHistoryEntry? currentEntry;
   undefined updateCurrentEntry(NavigationUpdateCurrentEntryOptions options);
   readonly attribute NavigationTransition? transition;
+  readonly attribute NavigationActivation? activation;
 
   readonly attribute boolean canGoBack;
   readonly attribute boolean canGoForward;
@@ -1944,6 +1945,13 @@ interface NavigationTransition {
   readonly attribute Promise<undefined> finished;
 };
 
+[Exposed=Window]
+interface NavigationActivation {
+  readonly attribute NavigationHistoryEntry? from;
+  readonly attribute NavigationHistoryEntry entry;
+  readonly attribute NavigationType navigationType;
+};
+
 [Exposed=Window]
 interface NavigateEvent : Event {
   constructor(DOMString type, NavigateEventInit eventInitDict);
@@ -2044,6 +2052,16 @@ dictionary HashChangeEventInit : EventInit {
   USVString newURL = "";
 };
 
+[Exposed=Window]
+interface PageRevealEvent : Event {
+  constructor(DOMString type, optional PageRevealEventInit eventInitDict = {});
+  readonly attribute ViewTransition? viewTransition;
+};
+
+dictionary PageRevealEventInit : EventInit {
+  ViewTransition? viewTransition = null;
+};
+
 [Exposed=Window]
 interface PageTransitionEvent : Event {
   constructor(DOMString type, optional PageTransitionEventInit eventInitDict = {});
@@ -2083,12 +2101,12 @@ dictionary ErrorEventInit : EventInit {
 interface PromiseRejectionEvent : Event {
   constructor(DOMString type, PromiseRejectionEventInit eventInitDict);
 
-  readonly attribute Promise<any> promise;
+  readonly attribute object promise;
   readonly attribute any reason;
 };
 
 dictionary PromiseRejectionEventInit : EventInit {
-  required Promise<any> promise;
+  required object promise;
   any reason;
 };
 
@@ -2193,6 +2211,7 @@ interface mixin WindowEventHandlers {
   attribute EventHandler onoffline;
   attribute EventHandler ononline;
   attribute EventHandler onpagehide;
+  attribute EventHandler onpagereveal;
   attribute EventHandler onpageshow;
   attribute EventHandler onpopstate;
   attribute EventHandler onrejectionhandled;

package/media-source.idl

@@ -75,6 +75,32 @@ interface SourceBufferList : EventTarget {
     getter SourceBuffer (unsigned long index);
 };
 
+[Exposed=(Window,DedicatedWorker)]
+interface ManagedMediaSource : MediaSource {
+  constructor();
+  readonly attribute boolean streaming;
+  attribute EventHandler onstartstreaming;
+  attribute EventHandler onendstreaming;
+};
+
+[Exposed=(Window,DedicatedWorker)]
+interface BufferedChangeEvent : Event {
+  constructor(DOMString type, optional BufferedChangeEventInit eventInitDict = {});
+
+  [SameObject] readonly attribute TimeRanges addedRanges;
+  [SameObject] readonly attribute TimeRanges removedRanges;
+};
+
+dictionary BufferedChangeEventInit : EventInit {
+  TimeRanges addedRanges;
+  TimeRanges removedRanges;
+};
+
+[Exposed=(Window,DedicatedWorker)]
+interface ManagedSourceBuffer : SourceBuffer {
+  attribute EventHandler onbufferedchange;
+};
+
 [Exposed=(Window,DedicatedWorker)]
 partial interface AudioTrack {
     readonly        attribute SourceBuffer? sourceBuffer;

package/package.json

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

package/storage-buckets.idl

@@ -20,8 +20,8 @@ interface StorageBucketManager {
 
 dictionary StorageBucketOptions {
   boolean persisted = false;
-  unsigned long long? quota;
-  DOMHighResTimeStamp? expires;
+  unsigned long long quota;
+  DOMHighResTimeStamp expires;
 };
 
 [Exposed=(Window,Worker),

package/turtledove.idl

@@ -69,6 +69,7 @@ dictionary AuctionAdConfig {
   USVString trustedScoringSignalsURL;
   sequence<USVString> interestGroupBuyers;
   Promise<any> auctionSignals;
+  record<DOMString, DOMString> requestedSize;
   Promise<any> sellerSignals;
   Promise<DOMString> directFromSellerSignalsHeaderAdSlot;
   unsigned long long sellerTimeout;
@@ -150,6 +151,10 @@ partial dictionary RequestInit {
   boolean adAuctionHeaders;
 };
 
+partial interface HTMLIFrameElement {
+  [CEReactions] attribute boolean adAuctionHeaders;
+};
+
 dictionary PreviousWin {
   required long long timeDelta;
   required DOMString adJSON;

package/webauthn.idl

@@ -32,7 +32,7 @@ dictionary AuthenticatorAttestationResponseJSON {
     required Base64URLString authenticatorData;
     required sequence<DOMString> transports;
     // The publicKey field will be missing if pubKeyCredParams was used to
-    // negotiate a public-key algorithm that the user agent doesn’t
+    // negotiate a public-key algorithm that the user agent doesn't
     // understand. (See section “Easily accessing credential data” for a
     // list of which algorithms user agents must support.) If using such an
     // algorithm then the public key must be parsed directly from

package/webgl1.idl

@@ -467,6 +467,7 @@ interface mixin WebGLRenderingContextBase
 
     const GLenum RGBA4                          = 0x8056;
     const GLenum RGB5_A1                        = 0x8057;
+    const GLenum RGBA8                          = 0x8058;
     const GLenum RGB565                         = 0x8D62;
     const GLenum DEPTH_COMPONENT16              = 0x81A5;
     const GLenum STENCIL_INDEX8                 = 0x8D48;
@@ -516,6 +517,7 @@ interface mixin WebGLRenderingContextBase
     readonly attribute (HTMLCanvasElement or OffscreenCanvas) canvas;
     readonly attribute GLsizei drawingBufferWidth;
     readonly attribute GLsizei drawingBufferHeight;
+    readonly attribute GLenum drawingBufferFormat;
     attribute PredefinedColorSpace drawingBufferColorSpace;
     attribute PredefinedColorSpace unpackColorSpace;
 
@@ -525,6 +527,8 @@ interface mixin WebGLRenderingContextBase
     sequence<DOMString>? getSupportedExtensions();
     object? getExtension(DOMString name);
 
+    undefined drawingBufferStorage(GLenum sizedFormat, unsigned long width, unsigned long height);
+
     undefined activeTexture(GLenum texture);
     undefined attachShader(WebGLProgram program, WebGLShader shader);
     undefined bindAttribLocation(WebGLProgram program, GLuint index, DOMString name);

package/webgl2.idl

@@ -42,7 +42,6 @@ interface mixin WebGL2RenderingContextBase
   const GLenum STENCIL                                       = 0x1802;
   const GLenum RED                                           = 0x1903;
   const GLenum RGB8                                          = 0x8051;
-  const GLenum RGBA8                                         = 0x8058;
   const GLenum RGB10_A2                                      = 0x8059;
   const GLenum TEXTURE_BINDING_3D                            = 0x806A;
   const GLenum UNPACK_SKIP_IMAGES                            = 0x806D;

package/webnn.idl

@@ -37,35 +37,26 @@ interface ML {
 };
 
 [SecureContext, Exposed=(Window, DedicatedWorker)]
-interface MLGraph {};
-
-enum MLInputOperandLayout {
-  "nchw",
-  "nhwc"
+interface MLActivation {
 };
 
-enum MLOperandDataType {
-  "float32",
-  "float16",
-  "int32",
-  "uint32",
-  "int8",
-  "uint8"
-};
+typedef (GPUBuffer or GPUTexture) MLGPUResource;
 
-dictionary MLOperandDescriptor {
-  // The operand data type.
-  required MLOperandDataType dataType;
+typedef record<DOMString, MLGPUResource> MLNamedGPUResources;
 
-  // The dimensions field is only required for tensor operands.
-  sequence<unsigned long> dimensions;
+[SecureContext, Exposed=(Window, DedicatedWorker)]
+interface MLCommandEncoder {};
+
+partial interface MLCommandEncoder {
+  undefined initializeGraph(MLGraph graph);
 };
 
-[SecureContext, Exposed=(Window, DedicatedWorker)]
-interface MLOperand {};
+partial interface MLCommandEncoder {
+  undefined dispatch(MLGraph graph, MLNamedGPUResources inputs, MLNamedGPUResources outputs);
+};
 
-[SecureContext, Exposed=(Window, DedicatedWorker)]
-interface MLActivation {
+partial interface MLCommandEncoder {
+  GPUCommandBuffer finish(optional GPUCommandBufferDescriptor descriptor = {});
 };
 
 typedef record<DOMString, ArrayBufferView> MLNamedArrayBufferViews;
@@ -93,24 +84,8 @@ partial interface MLContext {
   MLCommandEncoder createCommandEncoder();
 };
 
-typedef (GPUBuffer or GPUTexture) MLGPUResource;
-
-typedef record<DOMString, MLGPUResource> MLNamedGPUResources;
-
 [SecureContext, Exposed=(Window, DedicatedWorker)]
-interface MLCommandEncoder {};
-
-partial interface MLCommandEncoder {
-  undefined initializeGraph(MLGraph graph);
-};
-
-partial interface MLCommandEncoder {
-  undefined dispatch(MLGraph graph, MLNamedGPUResources inputs, MLNamedGPUResources outputs);
-};
-
-partial interface MLCommandEncoder {
-  GPUCommandBuffer finish(optional GPUCommandBufferDescriptor descriptor = {});
-};
+interface MLGraph {};
 
 typedef record<DOMString, MLOperand> MLNamedOperands;
 
@@ -134,7 +109,7 @@ interface MLGraphBuilder {
   MLOperand constant(MLOperandDescriptor descriptor, MLBufferView bufferView);
 
   // Create a single-value operand from the specified number of the specified type.
-  MLOperand constant(double value, optional MLOperandDataType dataType = "float32");
+  MLOperand constant(double value, optional MLOperandDataType type = "float32");
 
   // Compile the graph up to the specified output operands asynchronously.
   Promise<MLGraph> build(MLNamedOperands outputs);
@@ -144,6 +119,17 @@ interface MLGraphBuilder {
   MLGraph buildSync(MLNamedOperands outputs);
 };
 
+dictionary MLArgMinMaxOptions {
+  sequence<unsigned long> axes = null;
+  boolean keepDimensions = false;
+  boolean selectLastIndex = false;
+};
+
+partial interface MLGraphBuilder {
+  MLOperand argMin(MLOperand input, optional MLArgMinMaxOptions options = {});
+  MLOperand argMax(MLOperand input, optional MLArgMinMaxOptions options = {});
+};
+
 dictionary MLBatchNormalizationOptions {
   MLOperand scale;
   MLOperand bias;
@@ -157,13 +143,17 @@ partial interface MLGraphBuilder {
                              optional MLBatchNormalizationOptions options = {});
 };
 
+partial interface MLGraphBuilder {
+  MLOperand cast(MLOperand input, MLOperandDataType type);
+};
+
 dictionary MLClampOptions {
   float minValue;
   float maxValue;
 };
 
 partial interface MLGraphBuilder {
-  MLOperand clamp(MLOperand operand, optional MLClampOptions options = {});
+  MLOperand clamp(MLOperand input, optional MLClampOptions options = {});
   MLActivation clamp(optional MLClampOptions options = {});
 };
 
@@ -235,15 +225,28 @@ partial interface MLGraphBuilder {
   MLOperand pow(MLOperand a, MLOperand b);
 };
 
+partial interface MLGraphBuilder {
+  MLOperand equal(MLOperand a, MLOperand b);
+  MLOperand greater(MLOperand a, MLOperand b);
+  MLOperand greaterOrEqual(MLOperand a, MLOperand b);
+  MLOperand lesser(MLOperand a, MLOperand b);
+  MLOperand lesserOrEqual(MLOperand a, MLOperand b);
+  MLOperand not(MLOperand a);
+};
+
 partial interface MLGraphBuilder {
   MLOperand abs(MLOperand input);
   MLOperand ceil(MLOperand input);
   MLOperand cos(MLOperand input);
+  MLOperand erf(MLOperand input);
   MLOperand exp(MLOperand input);
   MLOperand floor(MLOperand input);
+  MLOperand identity(MLOperand input);
   MLOperand log(MLOperand input);
   MLOperand neg(MLOperand input);
+  MLOperand reciprocal(MLOperand input);
   MLOperand sin(MLOperand input);
+  MLOperand sqrt(MLOperand input);
   MLOperand tan(MLOperand input);
 };
 
@@ -256,6 +259,18 @@ partial interface MLGraphBuilder {
   MLActivation elu(optional MLEluOptions options = {});
 };
 
+partial interface MLGraphBuilder {
+  MLOperand expand(MLOperand input, sequence<unsigned long> newShape);
+};
+
+dictionary MLGatherOptions {
+  unsigned long axis = 0;
+};
+
+partial interface MLGraphBuilder {
+  MLOperand gather(MLOperand input, MLOperand indices, optional MLGatherOptions options = {});
+};
+
 dictionary MLGemmOptions {
   MLOperand c;
   float alpha = 1.0;
@@ -337,6 +352,17 @@ partial interface MLGraphBuilder {
                                 optional MLInstanceNormalizationOptions options = {});
 };
 
+dictionary MLLayerNormalizationOptions {
+  MLOperand scale;
+  MLOperand bias;
+  sequence<unsigned long> axes;
+  float epsilon = 1e-5;
+};
+
+partial interface MLGraphBuilder {
+  MLOperand layerNormalization(MLOperand input, optional MLLayerNormalizationOptions options = {});
+};
+
 dictionary MLLeakyReluOptions {
   float alpha = 0.01;
 };
@@ -523,14 +549,6 @@ partial interface MLGraphBuilder {
                           optional MLSplitOptions options = {});
 };
 
-dictionary MLSqueezeOptions {
-  sequence<unsigned long> axes;
-};
-
-partial interface MLGraphBuilder {
-  MLOperand squeeze(MLOperand input, optional MLSqueezeOptions options = {});
-};
-
 partial interface MLGraphBuilder {
   MLOperand tanh(MLOperand input);
   MLActivation tanh();
@@ -543,3 +561,51 @@ dictionary MLTransposeOptions {
 partial interface MLGraphBuilder {
   MLOperand transpose(MLOperand input, optional MLTransposeOptions options = {});
 };
+
+dictionary MLTriangularOptions {
+  boolean upper = true;
+  long diagonal = 0;
+};
+
+partial interface MLGraphBuilder {
+  MLOperand triangular(MLOperand input, optional MLTriangularOptions options = {});
+};
+
+partial interface MLGraphBuilder {
+  MLOperand where(MLOperand condition, MLOperand input, MLOperand other);
+};
+
+[SecureContext, Exposed=(Window, DedicatedWorker)]
+interface MLOperand {};
+
+partial interface MLOperand {
+  MLOperandDataType dataType();
+};
+
+partial interface MLOperand {
+  sequence<unsigned long> shape();
+};
+
+enum MLInputOperandLayout {
+  "nchw",
+  "nhwc"
+};
+
+enum MLOperandDataType {
+  "float32",
+  "float16",
+  "int32",
+  "uint32",
+  "int64",
+  "uint64",
+  "int8",
+  "uint8"
+};
+
+dictionary MLOperandDescriptor {
+  // The operand type.
+  required MLOperandDataType dataType;
+
+  // The dimensions field is only required for tensor operands.
+  sequence<unsigned long> dimensions;
+};

package/webrtc-encoded-transform.idl

@@ -112,12 +112,16 @@ partial interface DedicatedWorkerGlobalScope {
 };
 
 [Exposed=DedicatedWorker]
-interface RTCRtpScriptTransformer {
+interface RTCRtpScriptTransformer : EventTarget {
+    // Attributes and methods related to the transformer source
     readonly attribute ReadableStream readable;
-    readonly attribute WritableStream writable;
-    readonly attribute any options;
     Promise<unsigned long long> generateKeyFrame(optional DOMString rid);
     Promise<undefined> sendKeyFrameRequest();
+    // Attributes and methods related to the transformer sink
+    readonly attribute WritableStream writable;
+    attribute EventHandler onkeyframerequest;
+    // Attributes for configuring the Javascript code
+    readonly attribute any options;
 };
 
 [Exposed=Window]
@@ -125,6 +129,12 @@ interface RTCRtpScriptTransform {
     constructor(Worker worker, optional any options, optional sequence<object> transfer);
 };
 
+[Exposed=DedicatedWorker]
+interface KeyFrameRequestEvent : Event {
+  constructor(DOMString type, optional DOMString rid);
+  readonly attribute DOMString? rid;
+};
+
 partial interface RTCRtpSender {
     Promise<undefined> generateKeyFrame(optional sequence <DOMString> rids);
 };

package/webrtc-stats.idl

@@ -171,10 +171,6 @@ dictionary RTCAudioSourceStats : RTCMediaSourceStats {
               double              totalSamplesDuration;
               double              echoReturnLoss;
               double              echoReturnLossEnhancement;
-              double              droppedSamplesDuration;
-              unsigned long       droppedSamplesEvents;
-              double              totalCaptureDelay;
-              unsigned long long  totalSamplesCaptured;
 };
 
 dictionary RTCVideoSourceStats : RTCMediaSourceStats {