@webref/idl 3.61.0 → 3.61.2

package/css-mixins.idl

@@ -4,7 +4,17 @@
 // Source: CSS Functions and Mixins Module (https://drafts.csswg.org/css-mixins-1/)
 
 [Exposed=Window]
-interface CSSFunctionRule : CSSGroupingRule { };
+interface CSSFunctionRule : CSSGroupingRule {
+  readonly attribute CSSOMString name;
+  sequence<FunctionParameter> getParameters();
+  readonly attribute CSSOMString returnType;
+};
+
+dictionary FunctionParameter {
+  required CSSOMString name;
+  required CSSOMString type;
+  CSSOMString? defaultValue;
+};
 
 [Exposed=Window]
 interface CSSFunctionDescriptors : CSSStyleDeclaration {

package/dom.idl

@@ -124,6 +124,8 @@ interface mixin ParentNode {
   [CEReactions, Unscopable] undefined append((Node or DOMString)... nodes);
   [CEReactions, Unscopable] undefined replaceChildren((Node or DOMString)... nodes);
 
+  [CEReactions] undefined moveBefore(Node node, Node? child);
+
   Element? querySelector(DOMString selectors);
   [NewObject] NodeList querySelectorAll(DOMString selectors);
 };

package/fedcm.idl

@@ -12,6 +12,7 @@ interface IdentityCredential : Credential {
   static Promise<undefined> disconnect(IdentityCredentialDisconnectOptions options);
   readonly attribute USVString? token;
   readonly attribute boolean isAutoSelected;
+  readonly attribute USVString configURL;
 };
 
 dictionary DisconnectedAccount {
@@ -78,6 +79,7 @@ dictionary IdentityProviderAPIConfig {
   required USVString login_url;
   USVString disconnect_endpoint;
   IdentityProviderBranding branding;
+  USVString account_label;
 };
 
 dictionary IdentityProviderAccount {
@@ -89,6 +91,7 @@ dictionary IdentityProviderAccount {
   sequence<USVString> approved_clients;
   sequence<DOMString> login_hints;
   sequence<DOMString> domain_hints;
+  sequence<DOMString> label_hints;
 };
 dictionary IdentityProviderAccountList {
   sequence<IdentityProviderAccount> accounts;

package/package.json

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

package/webaudio.idl

@@ -6,7 +6,8 @@
 enum AudioContextState {
     "suspended",
     "running",
-    "closed"
+    "closed",
+    "interrupted"
 };
 
 enum AudioContextRenderSizeCategory {

package/webgpu.idl

@@ -64,6 +64,7 @@ interface GPUAdapterInfo {
     readonly attribute DOMString description;
     readonly attribute unsigned long subgroupMinSize;
     readonly attribute unsigned long subgroupMaxSize;
+    readonly attribute boolean isFallbackAdapter;
 };
 
 interface mixin NavigatorGPU {
@@ -96,7 +97,6 @@ interface GPUAdapter {
     [SameObject] readonly attribute GPUSupportedFeatures features;
     [SameObject] readonly attribute GPUSupportedLimits limits;
     [SameObject] readonly attribute GPUAdapterInfo info;
-    readonly attribute boolean isFallbackAdapter;
 
     Promise<GPUDevice> requestDevice(optional GPUDeviceDescriptor descriptor = {});
 };
@@ -936,12 +936,16 @@ interface GPUCommandEncoder {
     GPURenderPassEncoder beginRenderPass(GPURenderPassDescriptor descriptor);
     GPUComputePassEncoder beginComputePass(optional GPUComputePassDescriptor descriptor = {});
 
+    undefined copyBufferToBuffer(
+        GPUBuffer source,
+        GPUBuffer destination,
+        optional GPUSize64 size);
     undefined copyBufferToBuffer(
         GPUBuffer source,
         GPUSize64 sourceOffset,
         GPUBuffer destination,
         GPUSize64 destinationOffset,
-        GPUSize64 size);
+        optional GPUSize64 size);
 
     undefined copyBufferToTexture(
         GPUTexelCopyBufferInfo source,

package/webnn.idl

@@ -286,6 +286,21 @@ partial dictionary MLOpSupportLimits {
   MLConv2dSupportLimits convTranspose2d;
 };
 
+dictionary MLCumulativeSumOptions : MLOperatorOptions {
+  boolean exclusive = false;
+  boolean reversed = false;
+};
+
+partial interface MLGraphBuilder {
+  MLOperand cumulativeSum(MLOperand input,
+                          unsigned long axis,
+                          optional MLCumulativeSumOptions options = {});
+};
+
+partial dictionary MLOpSupportLimits {
+  MLSingleInputSupportLimits cumulativeSum;
+};
+
 partial interface MLGraphBuilder {
   MLOperand add(MLOperand a, MLOperand b, optional MLOperatorOptions options = {});
   MLOperand sub(MLOperand a, MLOperand b, optional MLOperatorOptions options = {});
@@ -310,6 +325,9 @@ partial interface MLGraphBuilder {
   MLOperand equal(MLOperand a,
                   MLOperand b,
                   optional MLOperatorOptions options = {});
+  MLOperand notEqual(MLOperand a,
+                     MLOperand b,
+                     optional MLOperatorOptions options = {});
   MLOperand greater(MLOperand a,
                     MLOperand b,
                     optional MLOperatorOptions options = {});
@@ -323,6 +341,15 @@ partial interface MLGraphBuilder {
                           MLOperand b,
                           optional MLOperatorOptions options = {});
   MLOperand logicalNot(MLOperand a, optional MLOperatorOptions options = {});
+  MLOperand logicalAnd(MLOperand a,
+                       MLOperand b,
+                       optional MLOperatorOptions options = {});
+  MLOperand logicalOr(MLOperand a,
+                      MLOperand b,
+                      optional MLOperatorOptions options = {});
+  MLOperand logicalXor(MLOperand a,
+                       MLOperand b,
+                       optional MLOperatorOptions options = {});
 };
 
 dictionary MLLogicalNotSupportLimits {
@@ -332,11 +359,15 @@ dictionary MLLogicalNotSupportLimits {
 
 partial dictionary MLOpSupportLimits {
   MLBinarySupportLimits equal;
+  MLBinarySupportLimits notEqual;
   MLBinarySupportLimits greater;
   MLBinarySupportLimits greaterOrEqual;
   MLBinarySupportLimits lesser;
   MLBinarySupportLimits lesserOrEqual;
   MLLogicalNotSupportLimits logicalNot;
+  MLBinarySupportLimits logicalAnd;
+  MLBinarySupportLimits logicalOr;
+  MLBinarySupportLimits logicalXor;
 };
 
 partial interface MLGraphBuilder {
@@ -351,6 +382,7 @@ partial interface MLGraphBuilder {
   MLOperand neg(MLOperand input, optional MLOperatorOptions options = {});
   MLOperand reciprocal(MLOperand input, optional MLOperatorOptions options = {});
   MLOperand sin(MLOperand input, optional MLOperatorOptions options = {});
+  MLOperand sign(MLOperand input, optional MLOperatorOptions options = {});
   MLOperand sqrt(MLOperand input, optional MLOperatorOptions options = {});
   MLOperand tan(MLOperand input, optional MLOperatorOptions options = {});
 };
@@ -367,10 +399,40 @@ partial dictionary MLOpSupportLimits {
   MLSingleInputSupportLimits neg;
   MLSingleInputSupportLimits reciprocal;
   MLSingleInputSupportLimits sin;
+  MLSingleInputSupportLimits sign;
   MLSingleInputSupportLimits sqrt;
   MLSingleInputSupportLimits tan;
 };
 
+partial interface MLGraphBuilder {
+  MLOperand dequantizeLinear(MLOperand input,
+                             MLOperand scale,
+                             MLOperand zeroPoint,
+                             optional MLOperatorOptions options = {});
+};
+
+dictionary MLQuantizationSupportLimits {
+  MLSupportLimits input;
+  MLSupportLimits scale;
+  MLSupportLimits zeroPoint;
+  MLSupportLimits output;
+};
+
+partial dictionary MLOpSupportLimits {
+  MLQuantizationSupportLimits dequantizeLinear;
+};
+
+partial interface MLGraphBuilder {
+  MLOperand quantizeLinear(MLOperand input,
+                           MLOperand scale,
+                           MLOperand zeroPoint,
+                           optional MLOperatorOptions options = {});
+};
+
+partial dictionary MLOpSupportLimits {
+  MLQuantizationSupportLimits quantizeLinear;
+};
+
 dictionary MLEluOptions : MLOperatorOptions {
   double alpha = 1;
 };
@@ -413,6 +475,26 @@ partial dictionary MLOpSupportLimits {
   MLGatherSupportLimits gather;
 };
 
+partial interface MLGraphBuilder {
+  MLOperand gatherElements(MLOperand input,
+                           MLOperand indices,
+                           optional MLGatherOptions options = {});
+};
+
+partial dictionary MLOpSupportLimits {
+  MLGatherSupportLimits gatherElements;
+};
+
+partial interface MLGraphBuilder {
+  MLOperand gatherND(MLOperand input,
+                     MLOperand indices,
+                     optional MLOperatorOptions options = {});
+};
+
+partial dictionary MLOpSupportLimits {
+  MLGatherSupportLimits gatherND;
+};
+
 partial interface MLGraphBuilder {
   MLOperand gelu(MLOperand input, optional MLOperatorOptions options = {});
 };
@@ -830,6 +912,51 @@ partial dictionary MLOpSupportLimits {
   MLSingleInputSupportLimits reshape;
 };
 
+dictionary MLReverseOptions : MLOperatorOptions {
+  sequence<[EnforceRange] unsigned long> axes;
+};
+
+partial interface MLGraphBuilder {
+  MLOperand reverse(MLOperand input, optional MLReverseOptions options = {});
+};
+
+partial dictionary MLOpSupportLimits {
+  MLSingleInputSupportLimits reverse;
+};
+
+dictionary MLScatterOptions : MLOperatorOptions {
+  [EnforceRange] unsigned long axis = 0;
+};
+
+partial interface MLGraphBuilder {
+  MLOperand scatterElements(MLOperand input,
+                            MLOperand indices,
+                            MLOperand updates,
+                            optional MLScatterOptions options = {});
+};
+
+dictionary MLScatterSupportLimits {
+  MLSupportLimits input;
+  MLSupportLimits indices;
+  MLSupportLimits updates;
+  MLSupportLimits output;
+};
+
+partial dictionary MLOpSupportLimits {
+  MLScatterSupportLimits scatterElements;
+};
+
+partial interface MLGraphBuilder {
+  MLOperand scatterND(MLOperand input,
+                      MLOperand indices,
+                      MLOperand updates,
+                      optional MLOperatorOptions options = {});
+};
+
+partial dictionary MLOpSupportLimits {
+  MLScatterSupportLimits scatterND;
+};
+
 partial interface MLGraphBuilder {
   MLOperand sigmoid(MLOperand input, optional MLOperatorOptions options = {});
 };
@@ -838,14 +965,18 @@ partial dictionary MLOpSupportLimits {
   MLSingleInputSupportLimits sigmoid;
 };
 
+dictionary MLSliceOptions : MLOperatorOptions {
+  sequence<[EnforceRange] unsigned long> strides;
+};
+
 partial interface MLGraphBuilder {
   MLOperand slice(MLOperand input,
                   sequence<[EnforceRange] unsigned long> starts,
                   sequence<[EnforceRange] unsigned long> sizes,
-                  optional MLOperatorOptions options = {});
+                  optional MLSliceOptions options = {});
 };
 
-partial  dictionary MLOpSupportLimits {
+partial dictionary MLOpSupportLimits {
   MLSingleInputSupportLimits slice;
 };
 
@@ -903,6 +1034,16 @@ partial dictionary MLOpSupportLimits {
   MLSingleInputSupportLimits tanh;
 };
 
+partial interface MLGraphBuilder {
+  MLOperand tile(MLOperand input,
+                 sequence<unsigned long> repetitions,
+                 optional MLOperatorOptions options = {});
+};
+
+partial dictionary MLOpSupportLimits {
+  MLSingleInputSupportLimits tile;
+};
+
 dictionary MLTransposeOptions : MLOperatorOptions {
   sequence<[EnforceRange] unsigned long> permutation;
 };

package/webtransport.idl

@@ -3,10 +3,18 @@
 // (https://github.com/w3c/webref)
 // Source: WebTransport (https://w3c.github.io/webtransport/)
 
+[Exposed=(Window,Worker), SecureContext, Transferable]
+interface WebTransportDatagramsWritable : WritableStream {
+  attribute WebTransportSendGroup? sendGroup;
+  attribute long long sendOrder;
+};
+
 [Exposed=(Window,Worker), SecureContext]
 interface WebTransportDatagramDuplexStream {
+  WebTransportDatagramsWritable createWritable(
+      optional WebTransportSendOptions options = {});
   readonly attribute ReadableStream readable;
-  readonly attribute WritableStream writable;
+  readonly attribute WebTransportDatagramsWritable writable;
 
   readonly attribute unsigned long maxDatagramSize;
   attribute unrestricted double? incomingMaxAge;
@@ -79,9 +87,12 @@ dictionary WebTransportCloseInfo {
   USVString reason = "";
 };
 
-dictionary WebTransportSendStreamOptions {
+dictionary WebTransportSendOptions {
   WebTransportSendGroup? sendGroup = null;
   long long sendOrder = 0;
+};
+
+dictionary WebTransportSendStreamOptions : WebTransportSendOptions {
   boolean waitUntilAvailable = false;
 };
 

package/webxr.idl

@@ -70,6 +70,7 @@ enum XRVisibilityState {
 dictionary XRRenderStateInit {
   double depthNear;
   double depthFar;
+  boolean passthroughFullyObscured;
   double inlineVerticalFieldOfView;
   XRWebGLLayer? baseLayer;
   sequence<XRLayer>? layers;
@@ -78,6 +79,7 @@ dictionary XRRenderStateInit {
 [SecureContext, Exposed=Window] interface XRRenderState {
   readonly attribute double depthNear;
   readonly attribute double depthFar;
+  readonly attribute boolean? passthroughFullyObscured;
   readonly attribute double? inlineVerticalFieldOfView;
   readonly attribute XRWebGLLayer? baseLayer;
 };

package/xhr.idl

@@ -88,12 +88,12 @@ interface ProgressEvent : Event {
   constructor(DOMString type, optional ProgressEventInit eventInitDict = {});
 
   readonly attribute boolean lengthComputable;
-  readonly attribute unsigned long long loaded;
-  readonly attribute unsigned long long total;
+  readonly attribute double loaded;
+  readonly attribute double total;
 };
 
 dictionary ProgressEventInit : EventInit {
   boolean lengthComputable = false;
-  unsigned long long loaded = 0;
-  unsigned long long total = 0;
+  double loaded = 0;
+  double total = 0;
 };