--- a/testing/web-platform/tests/interfaces/html.idl
+++ b/testing/web-platform/tests/interfaces/html.idl
@@ -129,17 +129,17 @@ HTMLElement includes HTMLOrSVGElement;
 [Exposed=Window]
 interface HTMLUnknownElement : HTMLElement { };
 
 interface mixin HTMLOrSVGElement {
   [SameObject] readonly attribute DOMStringMap dataset;
   attribute DOMString nonce; // intentionally no [CEReactions]
 
   [CEReactions] attribute long tabIndex;
-  void focus(optional FocusOptions options);
+  void focus(optional FocusOptions options = {});
   void blur();
 };
 
 [Exposed=Window,
  OverrideBuiltins]
 interface DOMStringMap {
   getter DOMString (DOMString name);
   [CEReactions] setter void (DOMString name, DOMString value);
@@ -661,17 +661,17 @@ interface TextTrackCue : EventTarget {
 [Exposed=Window]
 interface TimeRanges {
   readonly attribute unsigned long length;
   double start(unsigned long index);
   double end(unsigned long index);
 };
 
 [Exposed=Window,
- Constructor(DOMString type, optional TrackEventInit eventInitDict)]
+ Constructor(DOMString type, optional TrackEventInit eventInitDict = {})]
 interface TrackEvent : Event {
   readonly attribute (VideoTrack or AudioTrack or TextTrack)? track;
 };
 
 dictionary TrackEventInit : EventInit {
   (VideoTrack or AudioTrack or TextTrack)? track = null;
 };
 
@@ -1093,17 +1093,17 @@ interface ValidityState {
   readonly attribute boolean rangeOverflow;
   readonly attribute boolean stepMismatch;
   readonly attribute boolean badInput;
   readonly attribute boolean customError;
   readonly attribute boolean valid;
 };
 
 [Exposed=Window,
- Constructor(DOMString type, optional FormDataEventInit eventInitDict)]
+ Constructor(DOMString type, optional FormDataEventInit eventInitDict = {})]
 interface FormDataEvent : Event {
   readonly attribute FormData formData;
 };
 
 dictionary FormDataEventInit : EventInit {
   required FormData formData;
 };
 
@@ -1144,18 +1144,18 @@ interface HTMLScriptElement : HTMLElemen
 interface HTMLTemplateElement : HTMLElement {
   readonly attribute DocumentFragment content;
 };
 
 [Exposed=Window,
  HTMLConstructor]
 interface HTMLSlotElement : HTMLElement {
   [CEReactions] attribute DOMString name;
-  sequence<Node> assignedNodes(optional AssignedNodesOptions options);
-  sequence<Element> assignedElements(optional AssignedNodesOptions options);
+  sequence<Node> assignedNodes(optional AssignedNodesOptions options = {});
+  sequence<Element> assignedElements(optional AssignedNodesOptions options = {});
 };
 
 dictionary AssignedNodesOptions {
   boolean flatten = false;
 };
 
 typedef (CanvasRenderingContext2D or ImageBitmapRenderingContext or WebGLRenderingContext or WebGL2RenderingContext) RenderingContext;
 
@@ -1226,17 +1226,17 @@ interface mixin CanvasTransform {
   // transformations (default transform is the identity matrix)
   void scale(unrestricted double x, unrestricted double y);
   void rotate(unrestricted double angle);
   void translate(unrestricted double x, unrestricted double y);
   void transform(unrestricted double a, unrestricted double b, unrestricted double c, unrestricted double d, unrestricted double e, unrestricted double f);
 
   [NewObject] DOMMatrix getTransform();
   void setTransform(unrestricted double a, unrestricted double b, unrestricted double c, unrestricted double d, unrestricted double e, unrestricted double f);
-  void setTransform(optional DOMMatrix2DInit transform);
+  void setTransform(optional DOMMatrix2DInit transform = {});
   void resetTransform();
 
 };
 
 interface mixin CanvasCompositing {
   // compositing
   attribute unrestricted double globalAlpha; // (default 1.0)
   attribute DOMString globalCompositeOperation; // (default source-over)
@@ -1368,17 +1368,17 @@ interface mixin CanvasPath {
 interface CanvasGradient {
   // opaque object
   void addColorStop(double offset, DOMString color);
 };
 
 [Exposed=(Window,Worker)]
 interface CanvasPattern {
   // opaque object
-  void setTransform(optional DOMMatrix2DInit transform);
+  void setTransform(optional DOMMatrix2DInit transform = {});
 };
 
 [Exposed=(Window,Worker)]
 interface TextMetrics {
   // x-direction
   readonly attribute double width; // advance width
   readonly attribute double actualBoundingBoxLeft;
   readonly attribute double actualBoundingBoxRight;
@@ -1403,17 +1403,17 @@ interface ImageData {
   readonly attribute unsigned long width;
   readonly attribute unsigned long height;
   readonly attribute Uint8ClampedArray data;
 };
 
 [Constructor(optional (Path2D or DOMString) path),
  Exposed=(Window,Worker)]
 interface Path2D {
-  void addPath(Path2D path, optional DOMMatrix2DInit transform);
+  void addPath(Path2D path, optional DOMMatrix2DInit transform = {});
 };
 Path2D includes CanvasPath;
 
 [Exposed=(Window,Worker)]
 interface ImageBitmapRenderingContext {
   readonly attribute (HTMLCanvasElement or OffscreenCanvas) canvas;
   void transferFromImageBitmap(ImageBitmap? bitmap);
 };
@@ -1433,17 +1433,17 @@ enum OffscreenRenderingContextId { "2d",
 
 [Constructor([EnforceRange] unsigned long long width, [EnforceRange] unsigned long long height), Exposed=(Window,Worker), Transferable]
 interface OffscreenCanvas : EventTarget {
   attribute [EnforceRange] unsigned long long width;
   attribute [EnforceRange] unsigned long long height;
 
   OffscreenRenderingContext? getContext(OffscreenRenderingContextId contextId, optional any options = null);
   ImageBitmap transferToImageBitmap();
-  Promise<Blob> convertToBlob(optional ImageEncodeOptions options);
+  Promise<Blob> convertToBlob(optional ImageEncodeOptions options = {});
 };
 
 [Exposed=(Window,Worker)]
 interface OffscreenCanvasRenderingContext2D {
   void commit();
   readonly attribute OffscreenCanvas canvas;
 };
 
@@ -1460,17 +1460,17 @@ OffscreenCanvasRenderingContext2D includ
 OffscreenCanvasRenderingContext2D includes CanvasDrawImage;
 OffscreenCanvasRenderingContext2D includes CanvasImageData;
 OffscreenCanvasRenderingContext2D includes CanvasPathDrawingStyles;
 OffscreenCanvasRenderingContext2D includes CanvasTextDrawingStyles;
 OffscreenCanvasRenderingContext2D includes CanvasPath;
 
 [Exposed=Window]
 interface CustomElementRegistry {
-  [CEReactions] void define(DOMString name, CustomElementConstructor constructor, optional ElementDefinitionOptions options);
+  [CEReactions] void define(DOMString name, CustomElementConstructor constructor, optional ElementDefinitionOptions options = {});
   any get(DOMString name);
   Promise<void> whenDefined(DOMString name);
   [CEReactions] void upgrade(Node root);
 };
 
 callback CustomElementConstructor = HTMLElement ();
 
 dictionary ElementDefinitionOptions {
@@ -1556,17 +1556,17 @@ interface DataTransferItem {
   readonly attribute DOMString type;
   void getAsString(FunctionStringCallback? _callback);
   File? getAsFile();
 };
 
 callback FunctionStringCallback = void (DOMString data);
 
 [Exposed=Window,
- Constructor(DOMString type, optional DragEventInit eventInitDict)]
+ Constructor(DOMString type, optional DragEventInit eventInitDict = {})]
 interface DragEvent : MouseEvent {
   readonly attribute DataTransfer? dataTransfer;
 };
 
 dictionary DragEventInit : MouseEventInit {
   DataTransfer? dataTransfer = null;
 };
 
@@ -1615,17 +1615,17 @@ interface Window : EventTarget {
   // user prompts
   void alert();
   void alert(DOMString message);
   boolean confirm(optional DOMString message = "");
   DOMString? prompt(optional DOMString message = "", optional DOMString default = "");
   void print();
 
   void postMessage(any message, USVString targetOrigin, optional sequence<object> transfer = []);
-  void postMessage(any message, optional WindowPostMessageOptions options);
+  void postMessage(any message, optional WindowPostMessageOptions options = {});
 };
 Window includes GlobalEventHandlers;
 Window includes WindowEventHandlers;
 
 dictionary WindowPostMessageOptions : PostMessageOptions {
   USVString targetOrigin = "/";
 };
 
@@ -1663,39 +1663,39 @@ interface Location { // but see also add
   [Unforgeable] void assign(USVString url);
   [Unforgeable] void replace(USVString url);
   [Unforgeable] void reload();
 
   [Unforgeable, SameObject] readonly attribute DOMStringList ancestorOrigins;
 };
 
 [Exposed=Window,
- Constructor(DOMString type, optional PopStateEventInit eventInitDict)]
+ Constructor(DOMString type, optional PopStateEventInit eventInitDict = {})]
 interface PopStateEvent : Event {
   readonly attribute any state;
 };
 
 dictionary PopStateEventInit : EventInit {
   any state = null;
 };
 
 [Exposed=Window,
- Constructor(DOMString type, optional HashChangeEventInit eventInitDict)]
+ Constructor(DOMString type, optional HashChangeEventInit eventInitDict = {})]
 interface HashChangeEvent : Event {
   readonly attribute USVString oldURL;
   readonly attribute USVString newURL;
 };
 
 dictionary HashChangeEventInit : EventInit {
   USVString oldURL = "";
   USVString newURL = "";
 };
 
 [Exposed=Window,
- Constructor(DOMString type, optional PageTransitionEventInit eventInitDict)]
+ Constructor(DOMString type, optional PageTransitionEventInit eventInitDict = {})]
 interface PageTransitionEvent : Event {
   readonly attribute boolean persisted;
 };
 
 dictionary PageTransitionEventInit : EventInit {
   boolean persisted = false;
 };
 
@@ -1732,17 +1732,18 @@ interface ApplicationCache : EventTarget
   attribute EventHandler oncached;
   attribute EventHandler onobsolete;
 };
 
 interface mixin NavigatorOnLine {
   readonly attribute boolean onLine;
 };
 
-[Constructor(DOMString type, optional ErrorEventInit eventInitDict), Exposed=(Window,Worker)]
+[Constructor(DOMString type, optional ErrorEventInit eventInitDict = {}),
+ Exposed=(Window,Worker)]
 interface ErrorEvent : Event {
   readonly attribute DOMString message;
   readonly attribute USVString filename;
   readonly attribute unsigned long lineno;
   readonly attribute unsigned long colno;
   readonly attribute any error;
 };
 
@@ -1882,18 +1883,18 @@ interface mixin WindowOrWorkerGlobalScop
   void clearTimeout(optional long handle = 0);
   long setInterval(TimerHandler handler, optional long timeout = 0, any... arguments);
   void clearInterval(optional long handle = 0);
 
   // microtask queuing
   void queueMicrotask(VoidFunction callback);
 
   // ImageBitmap
-  Promise<ImageBitmap> createImageBitmap(ImageBitmapSource image, optional ImageBitmapOptions options);
-  Promise<ImageBitmap> createImageBitmap(ImageBitmapSource image, long sx, long sy, long sw, long sh, optional ImageBitmapOptions options);
+  Promise<ImageBitmap> createImageBitmap(ImageBitmapSource image, optional ImageBitmapOptions options = {});
+  Promise<ImageBitmap> createImageBitmap(ImageBitmapSource image, long sx, long sy, long sw, long sh, optional ImageBitmapOptions options = {});
 };
 Window includes WindowOrWorkerGlobalScope;
 WorkerGlobalScope includes WindowOrWorkerGlobalScope;
 
 [Exposed=Window]
 interface Navigator {
   // objects implementing this interface also implement the interfaces given below
 };
@@ -2007,17 +2008,18 @@ callback FrameRequestCallback = void (DO
 
 interface mixin AnimationFrameProvider {
   unsigned long requestAnimationFrame(FrameRequestCallback callback);
   void cancelAnimationFrame(unsigned long handle);
 };
 Window includes AnimationFrameProvider;
 DedicatedWorkerGlobalScope includes AnimationFrameProvider;
 
-[Constructor(DOMString type, optional MessageEventInit eventInitDict), Exposed=(Window,Worker,AudioWorklet)]
+[Constructor(DOMString type, optional MessageEventInit eventInitDict = {}),
+ Exposed=(Window,Worker,AudioWorklet)]
 interface MessageEvent : Event {
   readonly attribute any data;
   readonly attribute USVString origin;
   readonly attribute DOMString lastEventId;
   readonly attribute MessageEventSource? source;
   readonly attribute FrozenArray<MessagePort> ports;
 
   void initMessageEvent(DOMString type, optional boolean bubbles = false, optional boolean cancelable = false, optional any data = null, optional USVString origin = "", optional DOMString lastEventId = "", optional MessageEventSource? source = null, optional sequence<MessagePort> ports = []);
@@ -2028,17 +2030,17 @@ dictionary MessageEventInit : EventInit 
   USVString origin = "";
   DOMString lastEventId = "";
   MessageEventSource? source = null;
   sequence<MessagePort> ports = [];
 };
 
 typedef (WindowProxy or MessagePort or ServiceWorker) MessageEventSource;
 
-[Constructor(USVString url, optional EventSourceInit eventSourceInitDict), Exposed=(Window,Worker)]
+[Constructor(USVString url, optional EventSourceInit eventSourceInitDict = {}), Exposed=(Window,Worker)]
 interface EventSource : EventTarget {
   readonly attribute USVString url;
   readonly attribute boolean withCredentials;
 
   // ready state
   const unsigned short CONNECTING = 0;
   const unsigned short OPEN = 1;
   const unsigned short CLOSED = 2;
@@ -2080,17 +2082,18 @@ interface WebSocket : EventTarget {
   attribute EventHandler onmessage;
   attribute BinaryType binaryType;
   void send(USVString data);
   void send(Blob data);
   void send(ArrayBuffer data);
   void send(ArrayBufferView data);
 };
 
-[Constructor(DOMString type, optional CloseEventInit eventInitDict), Exposed=(Window,Worker)]
+[Constructor(DOMString type, optional CloseEventInit eventInitDict = {}),
+ Exposed=(Window,Worker)]
 interface CloseEvent : Event {
   readonly attribute boolean wasClean;
   readonly attribute unsigned short code;
   readonly attribute USVString reason;
 };
 
 dictionary CloseEventInit : EventInit {
   boolean wasClean = false;
@@ -2102,17 +2105,17 @@ dictionary CloseEventInit : EventInit {
 interface MessageChannel {
   readonly attribute MessagePort port1;
   readonly attribute MessagePort port2;
 };
 
 [Exposed=(Window,Worker,AudioWorklet), Transferable]
 interface MessagePort : EventTarget {
   void postMessage(any message, sequence<object> transfer);
-  void postMessage(any message, optional PostMessageOptions options);
+  void postMessage(any message, optional PostMessageOptions options = {});
   void start();
   void close();
 
   // event handlers
   attribute EventHandler onmessage;
   attribute EventHandler onmessageerror;
 };
 
@@ -2144,17 +2147,17 @@ interface WorkerGlobalScope : EventTarge
   attribute EventHandler onunhandledrejection;
 };
 
 [Global=(Worker,DedicatedWorker),Exposed=DedicatedWorker]
 interface DedicatedWorkerGlobalScope : WorkerGlobalScope {
   [Replaceable] readonly attribute DOMString name;
 
   void postMessage(any message, sequence<object> transfer);
-  void postMessage(any message, optional PostMessageOptions options);
+  void postMessage(any message, optional PostMessageOptions options = {});
 
   void close();
 
   attribute EventHandler onmessage;
   attribute EventHandler onmessageerror;
 };
 
 [Global=(Worker,SharedWorker),Exposed=SharedWorker]
@@ -2165,37 +2168,38 @@ interface SharedWorkerGlobalScope : Work
 
   attribute EventHandler onconnect;
 };
 
 interface mixin AbstractWorker {
   attribute EventHandler onerror;
 };
 
-[Constructor(USVString scriptURL, optional WorkerOptions options), Exposed=(Window,Worker)]
+[Constructor(USVString scriptURL, optional WorkerOptions options = {}),
+ Exposed=(Window,Worker)]
 interface Worker : EventTarget {
   void terminate();
 
   void postMessage(any message, sequence<object> transfer);
-  void postMessage(any message, optional PostMessageOptions options);
+  void postMessage(any message, optional PostMessageOptions options = {});
   attribute EventHandler onmessage;
   attribute EventHandler onmessageerror;
 };
 
 dictionary WorkerOptions {
   WorkerType type = "classic";
   RequestCredentials credentials = "same-origin"; // credentials is only used if type is "module"
   DOMString name = "";
 };
 
 enum WorkerType { "classic", "module" };
 
 Worker includes AbstractWorker;
 
-[Constructor(USVString scriptURL, optional (DOMString or WorkerOptions) options),
+[Constructor(USVString scriptURL, optional (DOMString or WorkerOptions) options = {}),
  Exposed=(Window,Worker)]
 interface SharedWorker : EventTarget {
   readonly attribute MessagePort port;
 };
 SharedWorker includes AbstractWorker;
 
 interface mixin NavigatorConcurrentHardware {
   readonly attribute unsigned long long hardwareConcurrency;
@@ -2237,17 +2241,17 @@ interface mixin WindowSessionStorage {
 Window includes WindowSessionStorage;
 
 interface mixin WindowLocalStorage {
   readonly attribute Storage localStorage;
 };
 Window includes WindowLocalStorage;
 
 [Exposed=Window,
- Constructor(DOMString type, optional StorageEventInit eventInitDict)]
+ Constructor(DOMString type, optional StorageEventInit eventInitDict = {})]
 interface StorageEvent : Event {
   readonly attribute DOMString? key;
   readonly attribute DOMString? oldValue;
   readonly attribute DOMString? newValue;
   readonly attribute USVString url;
   readonly attribute Storage? storageArea;
 
   void initStorageEvent(DOMString type, optional boolean bubbles = false, optional boolean cancelable = false, optional DOMString? key = null, optional DOMString? oldValue = null, optional DOMString? newValue = null, optional USVString url = "", optional Storage? storageArea = null);