@webref/idl 3.21.0 → 3.22.0

package/css-view-transitions.idl

@@ -4,19 +4,15 @@
 // Source: CSS View Transitions Module Level 1 (https://drafts.csswg.org/css-view-transitions-1/)
 
 partial interface Document {
-    ViewTransition createTransition(ViewTransitionInit init);
-};
-
-dictionary ViewTransitionInit {
-    required UpdateDOMCallback updateDOM;
+  ViewTransition startViewTransition(optional UpdateDOMCallback? callback = null);
 };
 
 callback UpdateDOMCallback = Promise<any> ();
 
 [Exposed=Window]
 interface ViewTransition {
-    undefined skipTransition();
-    readonly attribute Promise<undefined> finished;
-    readonly attribute Promise<undefined> ready;
-    readonly attribute Promise<undefined> domUpdated;
+  undefined skipTransition();
+  readonly attribute Promise<undefined> finished;
+  readonly attribute Promise<undefined> ready;
+  readonly attribute Promise<undefined> domUpdated;
 };

package/manifest-incubations.idl

@@ -22,18 +22,3 @@ partial interface Window {
   attribute EventHandler onappinstalled;
   attribute EventHandler onbeforeinstallprompt;
 };
-
-[Exposed=Window] interface LaunchParams {
-  readonly attribute DOMString? targetURL;
-  readonly attribute FrozenArray<FileSystemHandle> files;
-};
-
-callback LaunchConsumer = any (LaunchParams params);
-
-partial interface Window {
-  readonly attribute LaunchQueue launchQueue;
-};
-
-[Exposed=Window] interface LaunchQueue {
-  undefined setConsumer(LaunchConsumer consumer);
-};

package/package.json

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

package/web-app-launch.idl

@@ -0,0 +1,19 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Web App Launch Handler API (https://wicg.github.io/web-app-launch/)
+
+[Exposed=Window] interface LaunchParams {
+  readonly attribute DOMString? targetURL;
+  readonly attribute FrozenArray<FileSystemHandle> files;
+};
+
+callback LaunchConsumer = any (LaunchParams params);
+
+partial interface Window {
+  readonly attribute LaunchQueue launchQueue;
+};
+
+[Exposed=Window] interface LaunchQueue {
+  undefined setConsumer(LaunchConsumer consumer);
+};

package/webaudio.idl

@@ -4,9 +4,9 @@
 // Source: Web Audio API (https://webaudio.github.io/web-audio-api/)
 
 enum AudioContextState {
-  "suspended",
-  "running",
-  "closed"
+    "suspended",
+    "running",
+    "closed"
 };
 
 callback DecodeErrorCallback = undefined (DOMException error);
@@ -15,604 +15,604 @@ callback DecodeSuccessCallback = undefined (AudioBuffer decodedData);
 
 [Exposed=Window]
 interface BaseAudioContext : EventTarget {
-  readonly attribute AudioDestinationNode destination;
-  readonly attribute float sampleRate;
-  readonly attribute double currentTime;
-  readonly attribute AudioListener listener;
-  readonly attribute AudioContextState state;
-  [SameObject, SecureContext]
-  readonly attribute AudioWorklet audioWorklet;
-  attribute EventHandler onstatechange;
-
-  AnalyserNode createAnalyser ();
-  BiquadFilterNode createBiquadFilter ();
-  AudioBuffer createBuffer (unsigned long numberOfChannels,
-                            unsigned long length,
-                            float sampleRate);
-  AudioBufferSourceNode createBufferSource ();
-  ChannelMergerNode createChannelMerger (optional unsigned long numberOfInputs = 6);
-  ChannelSplitterNode createChannelSplitter (
-    optional unsigned long numberOfOutputs = 6);
-  ConstantSourceNode createConstantSource ();
-  ConvolverNode createConvolver ();
-  DelayNode createDelay (optional double maxDelayTime = 1.0);
-  DynamicsCompressorNode createDynamicsCompressor ();
-  GainNode createGain ();
-  IIRFilterNode createIIRFilter (sequence<double> feedforward,
-                                 sequence<double> feedback);
-  OscillatorNode createOscillator ();
-  PannerNode createPanner ();
-  PeriodicWave createPeriodicWave (sequence<float> real,
-                                   sequence<float> imag,
-                                   optional PeriodicWaveConstraints constraints = {});
-  ScriptProcessorNode createScriptProcessor(
-    optional unsigned long bufferSize = 0,
-    optional unsigned long numberOfInputChannels = 2,
-    optional unsigned long numberOfOutputChannels = 2);
-  StereoPannerNode createStereoPanner ();
-  WaveShaperNode createWaveShaper ();
-
-  Promise<AudioBuffer> decodeAudioData (
-    ArrayBuffer audioData,
-    optional DecodeSuccessCallback? successCallback,
-    optional DecodeErrorCallback? errorCallback);
+    readonly attribute AudioDestinationNode destination;
+    readonly attribute float sampleRate;
+    readonly attribute double currentTime;
+    readonly attribute AudioListener listener;
+    readonly attribute AudioContextState state;
+    [SameObject, SecureContext]
+    readonly attribute AudioWorklet audioWorklet;
+    attribute EventHandler onstatechange;
+
+    AnalyserNode createAnalyser ();
+    BiquadFilterNode createBiquadFilter ();
+    AudioBuffer createBuffer (unsigned long numberOfChannels,
+                              unsigned long length,
+                              float sampleRate);
+    AudioBufferSourceNode createBufferSource ();
+    ChannelMergerNode createChannelMerger (optional unsigned long numberOfInputs = 6);
+    ChannelSplitterNode createChannelSplitter (
+        optional unsigned long numberOfOutputs = 6);
+    ConstantSourceNode createConstantSource ();
+    ConvolverNode createConvolver ();
+    DelayNode createDelay (optional double maxDelayTime = 1.0);
+    DynamicsCompressorNode createDynamicsCompressor ();
+    GainNode createGain ();
+    IIRFilterNode createIIRFilter (sequence<double> feedforward,
+                                   sequence<double> feedback);
+    OscillatorNode createOscillator ();
+    PannerNode createPanner ();
+    PeriodicWave createPeriodicWave (sequence<float> real,
+                                     sequence<float> imag,
+                                     optional PeriodicWaveConstraints constraints = {});
+    ScriptProcessorNode createScriptProcessor(
+        optional unsigned long bufferSize = 0,
+        optional unsigned long numberOfInputChannels = 2,
+        optional unsigned long numberOfOutputChannels = 2);
+    StereoPannerNode createStereoPanner ();
+    WaveShaperNode createWaveShaper ();
+
+    Promise<AudioBuffer> decodeAudioData (
+        ArrayBuffer audioData,
+        optional DecodeSuccessCallback? successCallback,
+        optional DecodeErrorCallback? errorCallback);
 };
 
 enum AudioContextLatencyCategory {
-    "balanced",
-    "interactive",
-    "playback"
+        "balanced",
+        "interactive",
+        "playback"
 };
 
 enum AudioSinkType {
-  "none"
+    "none"
 };
 
 [Exposed=Window]
 interface AudioContext : BaseAudioContext {
-  constructor (optional AudioContextOptions contextOptions = {});
-  readonly attribute double baseLatency;
-  readonly attribute double outputLatency;
-  [SecureContext] readonly attribute (DOMString or AudioSinkInfo) sinkId;
-  [SecureContext] readonly attribute AudioRenderCapacity renderCapacity;
-  attribute EventHandler onsinkchange;
-  AudioTimestamp getOutputTimestamp ();
-  Promise<undefined> resume ();
-  Promise<undefined> suspend ();
-  Promise<undefined> close ();
-  [SecureContext] Promise<undefined> setSinkId ((DOMString or AudioSinkOptions) sinkId);
-  MediaElementAudioSourceNode createMediaElementSource (HTMLMediaElement mediaElement);
-  MediaStreamAudioSourceNode createMediaStreamSource (MediaStream mediaStream);
-  MediaStreamTrackAudioSourceNode createMediaStreamTrackSource (
-    MediaStreamTrack mediaStreamTrack);
-  MediaStreamAudioDestinationNode createMediaStreamDestination ();
+    constructor (optional AudioContextOptions contextOptions = {});
+    readonly attribute double baseLatency;
+    readonly attribute double outputLatency;
+    [SecureContext] readonly attribute (DOMString or AudioSinkInfo) sinkId;
+    [SecureContext] readonly attribute AudioRenderCapacity renderCapacity;
+    attribute EventHandler onsinkchange;
+    AudioTimestamp getOutputTimestamp ();
+    Promise<undefined> resume ();
+    Promise<undefined> suspend ();
+    Promise<undefined> close ();
+    [SecureContext] Promise<undefined> setSinkId ((DOMString or AudioSinkOptions) sinkId);
+    MediaElementAudioSourceNode createMediaElementSource (HTMLMediaElement mediaElement);
+    MediaStreamAudioSourceNode createMediaStreamSource (MediaStream mediaStream);
+    MediaStreamTrackAudioSourceNode createMediaStreamTrackSource (
+        MediaStreamTrack mediaStreamTrack);
+    MediaStreamAudioDestinationNode createMediaStreamDestination ();
 };
 
 dictionary AudioContextOptions {
-  (AudioContextLatencyCategory or double) latencyHint = "interactive";
-  float sampleRate;
-  (DOMString or AudioSinkOptions) sinkId;
+    (AudioContextLatencyCategory or double) latencyHint = "interactive";
+    float sampleRate;
+    (DOMString or AudioSinkOptions) sinkId;
 };
 
 dictionary AudioSinkOptions {
-  required AudioSinkType type;
+    required AudioSinkType type;
 };
 
 [Exposed=Window]
 interface AudioSinkInfo {
-  readonly attribute AudioSinkType type;
+    readonly attribute AudioSinkType type;
 };
 
 dictionary AudioTimestamp {
-  double contextTime;
-  DOMHighResTimeStamp performanceTime;
+    double contextTime;
+    DOMHighResTimeStamp performanceTime;
 };
 
 [Exposed=Window]
 interface AudioRenderCapacity : EventTarget {
-  undefined start(optional AudioRenderCapacityOptions options = {});
-    undefined stop();
-    attribute EventHandler onupdate;
+    undefined start(optional AudioRenderCapacityOptions options = {});
+        undefined stop();
+        attribute EventHandler onupdate;
 };
 
 dictionary AudioRenderCapacityOptions {
-    double updateInterval = 1;
+        double updateInterval = 1;
 };
 
 [Exposed=Window]
 interface AudioRenderCapacityEvent : Event {
-  constructor (DOMString type, optional AudioRenderCapacityEventInit eventInitDict = {});
-    readonly attribute double timestamp;
-    readonly attribute double averageLoad;
-    readonly attribute double peakLoad;
-    readonly attribute double underrunRatio;
+    constructor (DOMString type, optional AudioRenderCapacityEventInit eventInitDict = {});
+        readonly attribute double timestamp;
+        readonly attribute double averageLoad;
+        readonly attribute double peakLoad;
+        readonly attribute double underrunRatio;
 };
 
 dictionary AudioRenderCapacityEventInit : EventInit {
-  double timestamp = 0;
-  double averageLoad = 0;
-  double peakLoad = 0;
-  double underrunRatio = 0;
+    double timestamp = 0;
+    double averageLoad = 0;
+    double peakLoad = 0;
+    double underrunRatio = 0;
 };
 
 [Exposed=Window]
 interface OfflineAudioContext : BaseAudioContext {
-  constructor(OfflineAudioContextOptions contextOptions);
-  constructor(unsigned long numberOfChannels, unsigned long length, float sampleRate);
-  Promise<AudioBuffer> startRendering();
-  Promise<undefined> resume();
-  Promise<undefined> suspend(double suspendTime);
-  readonly attribute unsigned long length;
-  attribute EventHandler oncomplete;
+    constructor(OfflineAudioContextOptions contextOptions);
+    constructor(unsigned long numberOfChannels, unsigned long length, float sampleRate);
+    Promise<AudioBuffer> startRendering();
+    Promise<undefined> resume();
+    Promise<undefined> suspend(double suspendTime);
+    readonly attribute unsigned long length;
+    attribute EventHandler oncomplete;
 };
 
 dictionary OfflineAudioContextOptions {
-  unsigned long numberOfChannels = 1;
-  required unsigned long length;
-  required float sampleRate;
+    unsigned long numberOfChannels = 1;
+    required unsigned long length;
+    required float sampleRate;
 };
 
 [Exposed=Window]
 interface OfflineAudioCompletionEvent : Event {
-  constructor (DOMString type, OfflineAudioCompletionEventInit eventInitDict);
-  readonly attribute AudioBuffer renderedBuffer;
+    constructor (DOMString type, OfflineAudioCompletionEventInit eventInitDict);
+    readonly attribute AudioBuffer renderedBuffer;
 };
 
 dictionary OfflineAudioCompletionEventInit : EventInit {
-  required AudioBuffer renderedBuffer;
+    required AudioBuffer renderedBuffer;
 };
 
 [Exposed=Window]
 interface AudioBuffer {
-  constructor (AudioBufferOptions options);
-  readonly attribute float sampleRate;
-  readonly attribute unsigned long length;
-  readonly attribute double duration;
-  readonly attribute unsigned long numberOfChannels;
-  Float32Array getChannelData (unsigned long channel);
-  undefined copyFromChannel (Float32Array destination,
+    constructor (AudioBufferOptions options);
+    readonly attribute float sampleRate;
+    readonly attribute unsigned long length;
+    readonly attribute double duration;
+    readonly attribute unsigned long numberOfChannels;
+    Float32Array getChannelData (unsigned long channel);
+    undefined copyFromChannel (Float32Array destination,
+                               unsigned long channelNumber,
+                               optional unsigned long bufferOffset = 0);
+    undefined copyToChannel (Float32Array source,
                              unsigned long channelNumber,
                              optional unsigned long bufferOffset = 0);
-  undefined copyToChannel (Float32Array source,
-                           unsigned long channelNumber,
-                           optional unsigned long bufferOffset = 0);
 };
 
 dictionary AudioBufferOptions {
-  unsigned long numberOfChannels = 1;
-  required unsigned long length;
-  required float sampleRate;
+    unsigned long numberOfChannels = 1;
+    required unsigned long length;
+    required float sampleRate;
 };
 
 [Exposed=Window]
 interface AudioNode : EventTarget {
-  AudioNode connect (AudioNode destinationNode,
-                     optional unsigned long output = 0,
-                     optional unsigned long input = 0);
-  undefined connect (AudioParam destinationParam, optional unsigned long output = 0);
-  undefined disconnect ();
-  undefined disconnect (unsigned long output);
-  undefined disconnect (AudioNode destinationNode);
-  undefined disconnect (AudioNode destinationNode, unsigned long output);
-  undefined disconnect (AudioNode destinationNode,
-                        unsigned long output,
-                        unsigned long input);
-  undefined disconnect (AudioParam destinationParam);
-  undefined disconnect (AudioParam destinationParam, unsigned long output);
-  readonly attribute BaseAudioContext context;
-  readonly attribute unsigned long numberOfInputs;
-  readonly attribute unsigned long numberOfOutputs;
-  attribute unsigned long channelCount;
-  attribute ChannelCountMode channelCountMode;
-  attribute ChannelInterpretation channelInterpretation;
+    AudioNode connect (AudioNode destinationNode,
+                       optional unsigned long output = 0,
+                       optional unsigned long input = 0);
+    undefined connect (AudioParam destinationParam, optional unsigned long output = 0);
+    undefined disconnect ();
+    undefined disconnect (unsigned long output);
+    undefined disconnect (AudioNode destinationNode);
+    undefined disconnect (AudioNode destinationNode, unsigned long output);
+    undefined disconnect (AudioNode destinationNode,
+                          unsigned long output,
+                          unsigned long input);
+    undefined disconnect (AudioParam destinationParam);
+    undefined disconnect (AudioParam destinationParam, unsigned long output);
+    readonly attribute BaseAudioContext context;
+    readonly attribute unsigned long numberOfInputs;
+    readonly attribute unsigned long numberOfOutputs;
+    attribute unsigned long channelCount;
+    attribute ChannelCountMode channelCountMode;
+    attribute ChannelInterpretation channelInterpretation;
 };
 
 enum ChannelCountMode {
-  "max",
-  "clamped-max",
-  "explicit"
+    "max",
+    "clamped-max",
+    "explicit"
 };
 
 enum ChannelInterpretation {
-  "speakers",
-  "discrete"
+    "speakers",
+    "discrete"
 };
 
 dictionary AudioNodeOptions {
-  unsigned long channelCount;
-  ChannelCountMode channelCountMode;
-  ChannelInterpretation channelInterpretation;
+    unsigned long channelCount;
+    ChannelCountMode channelCountMode;
+    ChannelInterpretation channelInterpretation;
 };
 
 enum AutomationRate {
-  "a-rate",
-  "k-rate"
+    "a-rate",
+    "k-rate"
 };
 
 [Exposed=Window]
 interface AudioParam {
-  attribute float value;
-  attribute AutomationRate automationRate;
-  readonly attribute float defaultValue;
-  readonly attribute float minValue;
-  readonly attribute float maxValue;
-  AudioParam setValueAtTime (float value, double startTime);
-  AudioParam linearRampToValueAtTime (float value, double endTime);
-  AudioParam exponentialRampToValueAtTime (float value, double endTime);
-  AudioParam setTargetAtTime (float target, double startTime, float timeConstant);
-  AudioParam setValueCurveAtTime (sequence<float> values,
-                                  double startTime,
-                                  double duration);
-  AudioParam cancelScheduledValues (double cancelTime);
-  AudioParam cancelAndHoldAtTime (double cancelTime);
+    attribute float value;
+    attribute AutomationRate automationRate;
+    readonly attribute float defaultValue;
+    readonly attribute float minValue;
+    readonly attribute float maxValue;
+    AudioParam setValueAtTime (float value, double startTime);
+    AudioParam linearRampToValueAtTime (float value, double endTime);
+    AudioParam exponentialRampToValueAtTime (float value, double endTime);
+    AudioParam setTargetAtTime (float target, double startTime, float timeConstant);
+    AudioParam setValueCurveAtTime (sequence<float> values,
+                                    double startTime,
+                                    double duration);
+    AudioParam cancelScheduledValues (double cancelTime);
+    AudioParam cancelAndHoldAtTime (double cancelTime);
 };
 
 [Exposed=Window]
 interface AudioScheduledSourceNode : AudioNode {
-  attribute EventHandler onended;
-  undefined start(optional double when = 0);
-  undefined stop(optional double when = 0);
+    attribute EventHandler onended;
+    undefined start(optional double when = 0);
+    undefined stop(optional double when = 0);
 };
 
 [Exposed=Window]
 interface AnalyserNode : AudioNode {
-  constructor (BaseAudioContext context, optional AnalyserOptions options = {});
-  undefined getFloatFrequencyData (Float32Array array);
-  undefined getByteFrequencyData (Uint8Array array);
-  undefined getFloatTimeDomainData (Float32Array array);
-  undefined getByteTimeDomainData (Uint8Array array);
-  attribute unsigned long fftSize;
-  readonly attribute unsigned long frequencyBinCount;
-  attribute double minDecibels;
-  attribute double maxDecibels;
-  attribute double smoothingTimeConstant;
+    constructor (BaseAudioContext context, optional AnalyserOptions options = {});
+    undefined getFloatFrequencyData (Float32Array array);
+    undefined getByteFrequencyData (Uint8Array array);
+    undefined getFloatTimeDomainData (Float32Array array);
+    undefined getByteTimeDomainData (Uint8Array array);
+    attribute unsigned long fftSize;
+    readonly attribute unsigned long frequencyBinCount;
+    attribute double minDecibels;
+    attribute double maxDecibels;
+    attribute double smoothingTimeConstant;
 };
 
 dictionary AnalyserOptions : AudioNodeOptions {
-  unsigned long fftSize = 2048;
-  double maxDecibels = -30;
-  double minDecibels = -100;
-  double smoothingTimeConstant = 0.8;
+    unsigned long fftSize = 2048;
+    double maxDecibels = -30;
+    double minDecibels = -100;
+    double smoothingTimeConstant = 0.8;
 };
 
 [Exposed=Window]
 interface AudioBufferSourceNode : AudioScheduledSourceNode {
-  constructor (BaseAudioContext context,
-               optional AudioBufferSourceOptions options = {});
-  attribute AudioBuffer? buffer;
-  readonly attribute AudioParam playbackRate;
-  readonly attribute AudioParam detune;
-  attribute boolean loop;
-  attribute double loopStart;
-  attribute double loopEnd;
-  undefined start (optional double when = 0,
-                   optional double offset,
-                   optional double duration);
+    constructor (BaseAudioContext context,
+                 optional AudioBufferSourceOptions options = {});
+    attribute AudioBuffer? buffer;
+    readonly attribute AudioParam playbackRate;
+    readonly attribute AudioParam detune;
+    attribute boolean loop;
+    attribute double loopStart;
+    attribute double loopEnd;
+    undefined start (optional double when = 0,
+                     optional double offset,
+                     optional double duration);
 };
 
 dictionary AudioBufferSourceOptions {
-  AudioBuffer? buffer;
-  float detune = 0;
-  boolean loop = false;
-  double loopEnd = 0;
-  double loopStart = 0;
-  float playbackRate = 1;
+    AudioBuffer? buffer;
+    float detune = 0;
+    boolean loop = false;
+    double loopEnd = 0;
+    double loopStart = 0;
+    float playbackRate = 1;
 };
 
 [Exposed=Window]
 interface AudioDestinationNode : AudioNode {
-  readonly attribute unsigned long maxChannelCount;
+    readonly attribute unsigned long maxChannelCount;
 };
 
 [Exposed=Window]
 interface AudioListener {
-  readonly attribute AudioParam positionX;
-  readonly attribute AudioParam positionY;
-  readonly attribute AudioParam positionZ;
-  readonly attribute AudioParam forwardX;
-  readonly attribute AudioParam forwardY;
-  readonly attribute AudioParam forwardZ;
-  readonly attribute AudioParam upX;
-  readonly attribute AudioParam upY;
-  readonly attribute AudioParam upZ;
-  undefined setPosition (float x, float y, float z);
-  undefined setOrientation (float x, float y, float z, float xUp, float yUp, float zUp);
+    readonly attribute AudioParam positionX;
+    readonly attribute AudioParam positionY;
+    readonly attribute AudioParam positionZ;
+    readonly attribute AudioParam forwardX;
+    readonly attribute AudioParam forwardY;
+    readonly attribute AudioParam forwardZ;
+    readonly attribute AudioParam upX;
+    readonly attribute AudioParam upY;
+    readonly attribute AudioParam upZ;
+    undefined setPosition (float x, float y, float z);
+    undefined setOrientation (float x, float y, float z, float xUp, float yUp, float zUp);
 };
 
 [Exposed=Window]
 interface AudioProcessingEvent : Event {
-  constructor (DOMString type, AudioProcessingEventInit eventInitDict);
-  readonly attribute double playbackTime;
-  readonly attribute AudioBuffer inputBuffer;
-  readonly attribute AudioBuffer outputBuffer;
+    constructor (DOMString type, AudioProcessingEventInit eventInitDict);
+    readonly attribute double playbackTime;
+    readonly attribute AudioBuffer inputBuffer;
+    readonly attribute AudioBuffer outputBuffer;
 };
 
 dictionary AudioProcessingEventInit : EventInit {
-  required double playbackTime;
-  required AudioBuffer inputBuffer;
-  required AudioBuffer outputBuffer;
+    required double playbackTime;
+    required AudioBuffer inputBuffer;
+    required AudioBuffer outputBuffer;
 };
 
 enum BiquadFilterType {
-  "lowpass",
-  "highpass",
-  "bandpass",
-  "lowshelf",
-  "highshelf",
-  "peaking",
-  "notch",
-  "allpass"
+    "lowpass",
+    "highpass",
+    "bandpass",
+    "lowshelf",
+    "highshelf",
+    "peaking",
+    "notch",
+    "allpass"
 };
 
 [Exposed=Window]
 interface BiquadFilterNode : AudioNode {
-  constructor (BaseAudioContext context, optional BiquadFilterOptions options = {});
-  attribute BiquadFilterType type;
-  readonly attribute AudioParam frequency;
-  readonly attribute AudioParam detune;
-  readonly attribute AudioParam Q;
-  readonly attribute AudioParam gain;
-  undefined getFrequencyResponse (Float32Array frequencyHz,
-                                  Float32Array magResponse,
-                                  Float32Array phaseResponse);
+    constructor (BaseAudioContext context, optional BiquadFilterOptions options = {});
+    attribute BiquadFilterType type;
+    readonly attribute AudioParam frequency;
+    readonly attribute AudioParam detune;
+    readonly attribute AudioParam Q;
+    readonly attribute AudioParam gain;
+    undefined getFrequencyResponse (Float32Array frequencyHz,
+                                    Float32Array magResponse,
+                                    Float32Array phaseResponse);
 };
 
 dictionary BiquadFilterOptions : AudioNodeOptions {
-  BiquadFilterType type = "lowpass";
-  float Q = 1;
-  float detune = 0;
-  float frequency = 350;
-  float gain = 0;
+    BiquadFilterType type = "lowpass";
+    float Q = 1;
+    float detune = 0;
+    float frequency = 350;
+    float gain = 0;
 };
 
 [Exposed=Window]
 interface ChannelMergerNode : AudioNode {
-  constructor (BaseAudioContext context, optional ChannelMergerOptions options = {});
+    constructor (BaseAudioContext context, optional ChannelMergerOptions options = {});
 };
 
 dictionary ChannelMergerOptions : AudioNodeOptions {
-  unsigned long numberOfInputs = 6;
+    unsigned long numberOfInputs = 6;
 };
 
 [Exposed=Window]
 interface ChannelSplitterNode : AudioNode {
-  constructor (BaseAudioContext context, optional ChannelSplitterOptions options = {});
+    constructor (BaseAudioContext context, optional ChannelSplitterOptions options = {});
 };
 
 dictionary ChannelSplitterOptions : AudioNodeOptions {
-  unsigned long numberOfOutputs = 6;
+    unsigned long numberOfOutputs = 6;
 };
 
 [Exposed=Window]
 interface ConstantSourceNode : AudioScheduledSourceNode {
-  constructor (BaseAudioContext context, optional ConstantSourceOptions options = {});
-  readonly attribute AudioParam offset;
+    constructor (BaseAudioContext context, optional ConstantSourceOptions options = {});
+    readonly attribute AudioParam offset;
 };
 
 dictionary ConstantSourceOptions {
-  float offset = 1;
+    float offset = 1;
 };
 
 [Exposed=Window]
 interface ConvolverNode : AudioNode {
-  constructor (BaseAudioContext context, optional ConvolverOptions options = {});
-  attribute AudioBuffer? buffer;
-  attribute boolean normalize;
+    constructor (BaseAudioContext context, optional ConvolverOptions options = {});
+    attribute AudioBuffer? buffer;
+    attribute boolean normalize;
 };
 
 dictionary ConvolverOptions : AudioNodeOptions {
-  AudioBuffer? buffer;
-  boolean disableNormalization = false;
+    AudioBuffer? buffer;
+    boolean disableNormalization = false;
 };
 
 [Exposed=Window]
 interface DelayNode : AudioNode {
-  constructor (BaseAudioContext context, optional DelayOptions options = {});
-  readonly attribute AudioParam delayTime;
+    constructor (BaseAudioContext context, optional DelayOptions options = {});
+    readonly attribute AudioParam delayTime;
 };
 
 dictionary DelayOptions : AudioNodeOptions {
-  double maxDelayTime = 1;
-  double delayTime = 0;
+    double maxDelayTime = 1;
+    double delayTime = 0;
 };
 
 [Exposed=Window]
 interface DynamicsCompressorNode : AudioNode {
-  constructor (BaseAudioContext context,
-               optional DynamicsCompressorOptions options = {});
-  readonly attribute AudioParam threshold;
-  readonly attribute AudioParam knee;
-  readonly attribute AudioParam ratio;
-  readonly attribute float reduction;
-  readonly attribute AudioParam attack;
-  readonly attribute AudioParam release;
+    constructor (BaseAudioContext context,
+                 optional DynamicsCompressorOptions options = {});
+    readonly attribute AudioParam threshold;
+    readonly attribute AudioParam knee;
+    readonly attribute AudioParam ratio;
+    readonly attribute float reduction;
+    readonly attribute AudioParam attack;
+    readonly attribute AudioParam release;
 };
 
 dictionary DynamicsCompressorOptions : AudioNodeOptions {
-  float attack = 0.003;
-  float knee = 30;
-  float ratio = 12;
-  float release = 0.25;
-  float threshold = -24;
+    float attack = 0.003;
+    float knee = 30;
+    float ratio = 12;
+    float release = 0.25;
+    float threshold = -24;
 };
 
 [Exposed=Window]
 interface GainNode : AudioNode {
-  constructor (BaseAudioContext context, optional GainOptions options = {});
-  readonly attribute AudioParam gain;
+    constructor (BaseAudioContext context, optional GainOptions options = {});
+    readonly attribute AudioParam gain;
 };
 
 dictionary GainOptions : AudioNodeOptions {
-  float gain = 1.0;
+    float gain = 1.0;
 };
 
 [Exposed=Window]
 interface IIRFilterNode : AudioNode {
-  constructor (BaseAudioContext context, IIRFilterOptions options);
-  undefined getFrequencyResponse (Float32Array frequencyHz,
-                                  Float32Array magResponse,
-                                  Float32Array phaseResponse);
+    constructor (BaseAudioContext context, IIRFilterOptions options);
+    undefined getFrequencyResponse (Float32Array frequencyHz,
+                                    Float32Array magResponse,
+                                    Float32Array phaseResponse);
 };
 
 dictionary IIRFilterOptions : AudioNodeOptions {
-  required sequence<double> feedforward;
-  required sequence<double> feedback;
+    required sequence<double> feedforward;
+    required sequence<double> feedback;
 };
 
 [Exposed=Window]
 interface MediaElementAudioSourceNode : AudioNode {
-  constructor (AudioContext context, MediaElementAudioSourceOptions options);
-  [SameObject] readonly attribute HTMLMediaElement mediaElement;
+    constructor (AudioContext context, MediaElementAudioSourceOptions options);
+    [SameObject] readonly attribute HTMLMediaElement mediaElement;
 };
 
 dictionary MediaElementAudioSourceOptions {
-  required HTMLMediaElement mediaElement;
+    required HTMLMediaElement mediaElement;
 };
 
 [Exposed=Window]
 interface MediaStreamAudioDestinationNode : AudioNode {
-  constructor (AudioContext context, optional AudioNodeOptions options = {});
-  readonly attribute MediaStream stream;
+    constructor (AudioContext context, optional AudioNodeOptions options = {});
+    readonly attribute MediaStream stream;
 };
 
 [Exposed=Window]
 interface MediaStreamAudioSourceNode : AudioNode {
-  constructor (AudioContext context, MediaStreamAudioSourceOptions options);
-  [SameObject] readonly attribute MediaStream mediaStream;
+    constructor (AudioContext context, MediaStreamAudioSourceOptions options);
+    [SameObject] readonly attribute MediaStream mediaStream;
 };
 
 dictionary MediaStreamAudioSourceOptions {
-  required MediaStream mediaStream;
+    required MediaStream mediaStream;
 };
 
 [Exposed=Window]
 interface MediaStreamTrackAudioSourceNode : AudioNode {
-  constructor (AudioContext context, MediaStreamTrackAudioSourceOptions options);
+    constructor (AudioContext context, MediaStreamTrackAudioSourceOptions options);
 };
 
 dictionary MediaStreamTrackAudioSourceOptions {
-  required MediaStreamTrack mediaStreamTrack;
+    required MediaStreamTrack mediaStreamTrack;
 };
 
 enum OscillatorType {
-  "sine",
-  "square",
-  "sawtooth",
-  "triangle",
-  "custom"
+    "sine",
+    "square",
+    "sawtooth",
+    "triangle",
+    "custom"
 };
 
 [Exposed=Window]
 interface OscillatorNode : AudioScheduledSourceNode {
-  constructor (BaseAudioContext context, optional OscillatorOptions options = {});
-  attribute OscillatorType type;
-  readonly attribute AudioParam frequency;
-  readonly attribute AudioParam detune;
-  undefined setPeriodicWave (PeriodicWave periodicWave);
+    constructor (BaseAudioContext context, optional OscillatorOptions options = {});
+    attribute OscillatorType type;
+    readonly attribute AudioParam frequency;
+    readonly attribute AudioParam detune;
+    undefined setPeriodicWave (PeriodicWave periodicWave);
 };
 
 dictionary OscillatorOptions : AudioNodeOptions {
-  OscillatorType type = "sine";
-  float frequency = 440;
-  float detune = 0;
-  PeriodicWave periodicWave;
+    OscillatorType type = "sine";
+    float frequency = 440;
+    float detune = 0;
+    PeriodicWave periodicWave;
 };
 
 enum PanningModelType {
-    "equalpower",
-    "HRTF"
+        "equalpower",
+        "HRTF"
 };
 
 enum DistanceModelType {
-  "linear",
-  "inverse",
-  "exponential"
+    "linear",
+    "inverse",
+    "exponential"
 };
 
 [Exposed=Window]
 interface PannerNode : AudioNode {
-  constructor (BaseAudioContext context, optional PannerOptions options = {});
-  attribute PanningModelType panningModel;
-  readonly attribute AudioParam positionX;
-  readonly attribute AudioParam positionY;
-  readonly attribute AudioParam positionZ;
-  readonly attribute AudioParam orientationX;
-  readonly attribute AudioParam orientationY;
-  readonly attribute AudioParam orientationZ;
-  attribute DistanceModelType distanceModel;
-  attribute double refDistance;
-  attribute double maxDistance;
-  attribute double rolloffFactor;
-  attribute double coneInnerAngle;
-  attribute double coneOuterAngle;
-  attribute double coneOuterGain;
-  undefined setPosition (float x, float y, float z);
-  undefined setOrientation (float x, float y, float z);
+    constructor (BaseAudioContext context, optional PannerOptions options = {});
+    attribute PanningModelType panningModel;
+    readonly attribute AudioParam positionX;
+    readonly attribute AudioParam positionY;
+    readonly attribute AudioParam positionZ;
+    readonly attribute AudioParam orientationX;
+    readonly attribute AudioParam orientationY;
+    readonly attribute AudioParam orientationZ;
+    attribute DistanceModelType distanceModel;
+    attribute double refDistance;
+    attribute double maxDistance;
+    attribute double rolloffFactor;
+    attribute double coneInnerAngle;
+    attribute double coneOuterAngle;
+    attribute double coneOuterGain;
+    undefined setPosition (float x, float y, float z);
+    undefined setOrientation (float x, float y, float z);
 };
 
 dictionary PannerOptions : AudioNodeOptions {
-  PanningModelType panningModel = "equalpower";
-  DistanceModelType distanceModel = "inverse";
-  float positionX = 0;
-  float positionY = 0;
-  float positionZ = 0;
-  float orientationX = 1;
-  float orientationY = 0;
-  float orientationZ = 0;
-  double refDistance = 1;
-  double maxDistance = 10000;
-  double rolloffFactor = 1;
-  double coneInnerAngle = 360;
-  double coneOuterAngle = 360;
-  double coneOuterGain = 0;
+    PanningModelType panningModel = "equalpower";
+    DistanceModelType distanceModel = "inverse";
+    float positionX = 0;
+    float positionY = 0;
+    float positionZ = 0;
+    float orientationX = 1;
+    float orientationY = 0;
+    float orientationZ = 0;
+    double refDistance = 1;
+    double maxDistance = 10000;
+    double rolloffFactor = 1;
+    double coneInnerAngle = 360;
+    double coneOuterAngle = 360;
+    double coneOuterGain = 0;
 };
 
 [Exposed=Window]
 interface PeriodicWave {
-  constructor (BaseAudioContext context, optional PeriodicWaveOptions options = {});
+    constructor (BaseAudioContext context, optional PeriodicWaveOptions options = {});
 };
 
 dictionary PeriodicWaveConstraints {
-  boolean disableNormalization = false;
+    boolean disableNormalization = false;
 };
 
 dictionary PeriodicWaveOptions : PeriodicWaveConstraints {
-  sequence<float> real;
-  sequence<float> imag;
+    sequence<float> real;
+    sequence<float> imag;
 };
 
 [Exposed=Window]
 interface ScriptProcessorNode : AudioNode {
-  attribute EventHandler onaudioprocess;
-  readonly attribute long bufferSize;
+    attribute EventHandler onaudioprocess;
+    readonly attribute long bufferSize;
 };
 
 [Exposed=Window]
 interface StereoPannerNode : AudioNode {
-  constructor (BaseAudioContext context, optional StereoPannerOptions options = {});
-  readonly attribute AudioParam pan;
+    constructor (BaseAudioContext context, optional StereoPannerOptions options = {});
+    readonly attribute AudioParam pan;
 };
 
 dictionary StereoPannerOptions : AudioNodeOptions {
-  float pan = 0;
+    float pan = 0;
 };
 
 enum OverSampleType {
-  "none",
-  "2x",
-  "4x"
+    "none",
+    "2x",
+    "4x"
 };
 
 [Exposed=Window]
 interface WaveShaperNode : AudioNode {
-  constructor (BaseAudioContext context, optional WaveShaperOptions options = {});
-  attribute Float32Array? curve;
-  attribute OverSampleType oversample;
+    constructor (BaseAudioContext context, optional WaveShaperOptions options = {});
+    attribute Float32Array? curve;
+    attribute OverSampleType oversample;
 };
 
 dictionary WaveShaperOptions : AudioNodeOptions {
-  sequence<float> curve;
-  OverSampleType oversample = "none";
+    sequence<float> curve;
+    OverSampleType oversample = "none";
 };
 
 [Exposed=Window, SecureContext]
@@ -624,40 +624,40 @@ callback AudioWorkletProcessorConstructor = AudioWorkletProcessor (object option
 
 [Global=(Worklet, AudioWorklet), Exposed=AudioWorklet]
 interface AudioWorkletGlobalScope : WorkletGlobalScope {
-  undefined registerProcessor (DOMString name,
-                               AudioWorkletProcessorConstructor processorCtor);
-  readonly attribute unsigned long long currentFrame;
-  readonly attribute double currentTime;
-  readonly attribute float sampleRate;
-  readonly attribute MessagePort port;
+    undefined registerProcessor (DOMString name,
+                                               AudioWorkletProcessorConstructor processorCtor);
+    readonly attribute unsigned long long currentFrame;
+    readonly attribute double currentTime;
+    readonly attribute float sampleRate;
+    readonly attribute MessagePort port;
 };
 
 [Exposed=Window]
 interface AudioParamMap {
-  readonly maplike<DOMString, AudioParam>;
+    readonly maplike<DOMString, AudioParam>;
 };
 
 [Exposed=Window, SecureContext]
 interface AudioWorkletNode : AudioNode {
-  constructor (BaseAudioContext context, DOMString name,
+    constructor (BaseAudioContext context, DOMString name,
                optional AudioWorkletNodeOptions options = {});
-  readonly attribute AudioParamMap parameters;
-  readonly attribute MessagePort port;
-  attribute EventHandler onprocessorerror;
+    readonly attribute AudioParamMap parameters;
+    readonly attribute MessagePort port;
+    attribute EventHandler onprocessorerror;
 };
 
 dictionary AudioWorkletNodeOptions : AudioNodeOptions {
-  unsigned long numberOfInputs = 1;
-  unsigned long numberOfOutputs = 1;
-  sequence<unsigned long> outputChannelCount;
-  record<DOMString, double> parameterData;
-  object processorOptions;
+    unsigned long numberOfInputs = 1;
+    unsigned long numberOfOutputs = 1;
+    sequence<unsigned long> outputChannelCount;
+    record<DOMString, double> parameterData;
+    object processorOptions;
 };
 
 [Exposed=AudioWorklet]
 interface AudioWorkletProcessor {
-  constructor ();
-  readonly attribute MessagePort port;
+    constructor ();
+    readonly attribute MessagePort port;
 };
 
 callback AudioWorkletProcessCallback =
@@ -666,9 +666,9 @@ callback AudioWorkletProcessCallback =
            object parameters);
 
 dictionary AudioParamDescriptor {
-  required DOMString name;
-  float defaultValue = 0;
-  float minValue = -3.4028235e38;
-  float maxValue = 3.4028235e38;
-  AutomationRate automationRate = "a-rate";
+    required DOMString name;
+    float defaultValue = 0;
+    float minValue = -3.4028235e38;
+    float maxValue = 3.4028235e38;
+    AutomationRate automationRate = "a-rate";
 };

package/webnn.idl

@@ -27,8 +27,13 @@ dictionary MLContextOptions {
 
 [SecureContext, Exposed=(Window, DedicatedWorker)]
 interface ML {
-  MLContext createContext(optional MLContextOptions options = {});
-  MLContext createContext(GPUDevice gpuDevice);
+  Promise<MLContext> createContext(optional MLContextOptions options = {});
+  Promise<MLContext> createContext(GPUDevice gpuDevice);
+
+  [Exposed=(DedicatedWorker)]
+  MLContext createContextSync(optional MLContextOptions options = {});
+  [Exposed=(DedicatedWorker)]
+  MLContext createContextSync(GPUDevice gpuDevice);
 };
 
 typedef record<DOMString, ArrayBufferView> MLNamedArrayBufferViews;
@@ -38,12 +43,12 @@ interface MLContext {};
 
 partial interface MLContext {
   [Exposed=(DedicatedWorker)]
-  undefined compute(
+  undefined computeSync(
       MLGraph graph, MLNamedArrayBufferViews inputs, MLNamedArrayBufferViews outputs);
 };
 
 partial interface MLContext {
-  Promise<undefined> computeAsync(
+  Promise<undefined> compute(
       MLGraph graph, MLNamedArrayBufferViews inputs, MLNamedArrayBufferViews outputs);
 };
 
@@ -103,12 +108,12 @@ interface MLGraphBuilder {
   // Create a single-value operand from the specified number of the specified type.
   MLOperand constant(double value, optional MLOperandType type = "float32");
 
+  // Compile the graph up to the specified output operands asynchronously.
+  Promise<MLGraph> build(MLNamedOperands outputs);
+
   // Compile the graph up to the specified output operands synchronously.
   [Exposed=(DedicatedWorker)]
-  MLGraph build(MLNamedOperands outputs);
-
-  // Compile the graph up to the specified output operands asynchronously.
-  Promise<MLGraph> buildAsync(MLNamedOperands outputs);
+  MLGraph buildSync(MLNamedOperands outputs);
 };
 
 dictionary MLBatchNormalizationOptions {