tor-browser

html.idl (103907B)

---

// GENERATED CONTENT - DO NOT EDIT
// Content was automatically extracted by Reffy into webref
// (https://github.com/w3c/webref)
// Source: HTML Standard (https://html.spec.whatwg.org/multipage/)

[Exposed=Window,
LegacyUnenumerableNamedProperties]
interface HTMLAllCollection {
 readonly attribute unsigned long length;
 getter Element (unsigned long index);
 getter (HTMLCollection or Element)? namedItem(DOMString name);
 (HTMLCollection or Element)? item(optional DOMString nameOrIndex);

 // Note: HTMLAllCollection objects have a custom [[Call]] internal method and an [[IsHTMLDDA]] internal slot.
};

[Exposed=Window]
interface HTMLFormControlsCollection : HTMLCollection {
 // inherits length and item()
 getter (RadioNodeList or Element)? namedItem(DOMString name); // shadows inherited namedItem()
};

[Exposed=Window]
interface RadioNodeList : NodeList {
 attribute DOMString value;
};

[Exposed=Window]
interface HTMLOptionsCollection : HTMLCollection {
 // inherits item(), namedItem()
 [CEReactions] attribute unsigned long length; // shadows inherited length
 [CEReactions] setter undefined (unsigned long index, HTMLOptionElement? option);
 [CEReactions] undefined add((HTMLOptionElement or HTMLOptGroupElement) element, optional (HTMLElement or long)? before = null);
 [CEReactions] undefined remove(long index);
 attribute long selectedIndex;
};

[Exposed=(Window,Worker)]
interface DOMStringList {
 readonly attribute unsigned long length;
 getter DOMString? item(unsigned long index);
 boolean contains(DOMString string);
};

enum DocumentReadyState { "loading", "interactive", "complete" };
enum DocumentVisibilityState { "visible", "hidden" };
typedef (HTMLScriptElement or SVGScriptElement) HTMLOrSVGScriptElement;

[LegacyOverrideBuiltIns]
partial interface Document {
 static Document parseHTMLUnsafe((TrustedHTML or DOMString) html);

 // resource metadata management
 [PutForwards=href, LegacyUnforgeable] readonly attribute Location? location;
 attribute USVString domain;
 readonly attribute USVString referrer;
 attribute USVString cookie;
 readonly attribute DOMString lastModified;
 readonly attribute DocumentReadyState readyState;

 // DOM tree accessors
 getter object (DOMString name);
 [CEReactions] attribute DOMString title;
 [CEReactions] attribute DOMString dir;
 [CEReactions] attribute HTMLElement? body;
 readonly attribute HTMLHeadElement? head;
 [SameObject] readonly attribute HTMLCollection images;
 [SameObject] readonly attribute HTMLCollection embeds;
 [SameObject] readonly attribute HTMLCollection plugins;
 [SameObject] readonly attribute HTMLCollection links;
 [SameObject] readonly attribute HTMLCollection forms;
 [SameObject] readonly attribute HTMLCollection scripts;
 NodeList getElementsByName(DOMString elementName);
 readonly attribute HTMLOrSVGScriptElement? currentScript; // classic scripts in a document tree only

 // dynamic markup insertion
 [CEReactions] Document open(optional DOMString unused1, optional DOMString unused2); // both arguments are ignored
 WindowProxy? open(USVString url, DOMString name, DOMString features);
 [CEReactions] undefined close();
 [CEReactions] undefined write((TrustedHTML or DOMString)... text);
 [CEReactions] undefined writeln((TrustedHTML or DOMString)... text);

 // user interaction
 readonly attribute WindowProxy? defaultView;
 boolean hasFocus();
 [CEReactions] attribute DOMString designMode;
 [CEReactions] boolean execCommand(DOMString commandId, optional boolean showUI = false, optional DOMString value = "");
 boolean queryCommandEnabled(DOMString commandId);
 boolean queryCommandIndeterm(DOMString commandId);
 boolean queryCommandState(DOMString commandId);
 boolean queryCommandSupported(DOMString commandId);
 DOMString queryCommandValue(DOMString commandId);
 readonly attribute boolean hidden;
 readonly attribute DocumentVisibilityState visibilityState;

 // special event handler IDL attributes that only apply to Document objects
 [LegacyLenientThis] attribute EventHandler onreadystatechange;
 attribute EventHandler onvisibilitychange;

 // also has obsolete members
};
Document includes GlobalEventHandlers;

partial interface mixin DocumentOrShadowRoot {
 readonly attribute Element? activeElement;
};

[Exposed=Window]
interface HTMLElement : Element {
 [HTMLConstructor] constructor();

 // metadata attributes
 [CEReactions, Reflect] attribute DOMString title;
 [CEReactions, Reflect] attribute DOMString lang;
 [CEReactions] attribute boolean translate;
 [CEReactions] attribute DOMString dir;

 // user interaction
 [CEReactions] attribute (boolean or unrestricted double or DOMString)? hidden;
 [CEReactions, Reflect] attribute boolean inert;
 undefined click();
 [CEReactions, Reflect] attribute DOMString accessKey;
 readonly attribute DOMString accessKeyLabel;
 [CEReactions] attribute boolean draggable;
 [CEReactions] attribute boolean spellcheck;
 [CEReactions, ReflectSetter] attribute DOMString writingSuggestions;
 [CEReactions, ReflectSetter] attribute DOMString autocapitalize;
 [CEReactions] attribute boolean autocorrect;

 [CEReactions] attribute [LegacyNullToEmptyString] DOMString innerText;
 [CEReactions] attribute [LegacyNullToEmptyString] DOMString outerText;

 ElementInternals attachInternals();

 // The popover API
 undefined showPopover(optional ShowPopoverOptions options = {});
 undefined hidePopover();
 boolean togglePopover(optional (TogglePopoverOptions or boolean) options = {});
 [CEReactions] attribute DOMString? popover;

 [CEReactions, Reflect, ReflectRange=(0, 8)] attribute unsigned long headingOffset;
 [CEReactions, Reflect] attribute boolean headingReset;
};

dictionary ShowPopoverOptions {
 HTMLElement source;
};

dictionary TogglePopoverOptions : ShowPopoverOptions {
 boolean force;
};

HTMLElement includes GlobalEventHandlers;
HTMLElement includes ElementContentEditable;
HTMLElement includes HTMLOrSVGElement;

[Exposed=Window]
interface HTMLUnknownElement : HTMLElement {
 // Note: intentionally no [HTMLConstructor]
};

interface mixin HTMLOrSVGElement {
 [SameObject] readonly attribute DOMStringMap dataset;
 attribute DOMString nonce; // intentionally no [CEReactions]

 [CEReactions, Reflect] attribute boolean autofocus;
 [CEReactions, ReflectSetter] attribute long tabIndex;
 undefined focus(optional FocusOptions options = {});
 undefined blur();
};

[Exposed=Window,
LegacyOverrideBuiltIns]
interface DOMStringMap {
 getter DOMString (DOMString name);
 [CEReactions] setter undefined (DOMString name, DOMString value);
 [CEReactions] deleter undefined (DOMString name);
};

[Exposed=Window]
interface HTMLHtmlElement : HTMLElement {
 [HTMLConstructor] constructor();

 // also has obsolete members
};

[Exposed=Window]
interface HTMLHeadElement : HTMLElement {
 [HTMLConstructor] constructor();
};

[Exposed=Window]
interface HTMLTitleElement : HTMLElement {
 [HTMLConstructor] constructor();

 [CEReactions] attribute DOMString text;
};

[Exposed=Window]
interface HTMLBaseElement : HTMLElement {
 [HTMLConstructor] constructor();

 [CEReactions, ReflectSetter] attribute USVString href;
 [CEReactions, Reflect] attribute DOMString target;
};

[Exposed=Window]
interface HTMLLinkElement : HTMLElement {
 [HTMLConstructor] constructor();

 [CEReactions, ReflectURL] attribute USVString href;
 [CEReactions] attribute DOMString? crossOrigin;
 [CEReactions, Reflect] attribute DOMString rel;
 [CEReactions] attribute DOMString as;
 [SameObject, PutForwards=value, Reflect="rel"] readonly attribute DOMTokenList relList;
 [CEReactions, Reflect] attribute DOMString media;
 [CEReactions, Reflect] attribute DOMString integrity;
 [CEReactions, Reflect] attribute DOMString hreflang;
 [CEReactions, Reflect] attribute DOMString type;
 [SameObject, PutForwards=value, Reflect] readonly attribute DOMTokenList sizes;
 [CEReactions, Reflect] attribute USVString imageSrcset;
 [CEReactions, Reflect] attribute DOMString imageSizes;
 [CEReactions] attribute DOMString referrerPolicy;
 [SameObject, PutForwards=value, Reflect] readonly attribute DOMTokenList blocking;
 [CEReactions, Reflect] attribute boolean disabled;
 [CEReactions] attribute DOMString fetchPriority;

 // also has obsolete members
};
HTMLLinkElement includes LinkStyle;

[Exposed=Window]
interface HTMLMetaElement : HTMLElement {
 [HTMLConstructor] constructor();

 [CEReactions, Reflect] attribute DOMString name;
 [CEReactions, Reflect="http-equiv"] attribute DOMString httpEquiv;
 [CEReactions, Reflect] attribute DOMString content;
 [CEReactions, Reflect] attribute DOMString media;

 // also has obsolete members
};

[Exposed=Window]
interface HTMLStyleElement : HTMLElement {
 [HTMLConstructor] constructor();

 attribute boolean disabled;
 [CEReactions, Reflect] attribute DOMString media;
 [SameObject, PutForwards=value, Reflect] readonly attribute DOMTokenList blocking;

 // also has obsolete members
};
HTMLStyleElement includes LinkStyle;

[Exposed=Window]
interface HTMLBodyElement : HTMLElement {
 [HTMLConstructor] constructor();

 // also has obsolete members
};

HTMLBodyElement includes WindowEventHandlers;

[Exposed=Window]
interface HTMLHeadingElement : HTMLElement {
 [HTMLConstructor] constructor();

 // also has obsolete members
};

[Exposed=Window]
interface HTMLParagraphElement : HTMLElement {
 [HTMLConstructor] constructor();

 // also has obsolete members
};

[Exposed=Window]
interface HTMLHRElement : HTMLElement {
 [HTMLConstructor] constructor();

 // also has obsolete members
};

[Exposed=Window]
interface HTMLPreElement : HTMLElement {
 [HTMLConstructor] constructor();

 // also has obsolete members
};

[Exposed=Window]
interface HTMLQuoteElement : HTMLElement {
 [HTMLConstructor] constructor();

 [CEReactions, ReflectURL] attribute USVString cite;
};

[Exposed=Window]
interface HTMLOListElement : HTMLElement {
 [HTMLConstructor] constructor();

 [CEReactions, Reflect] attribute boolean reversed;
 [CEReactions, Reflect, ReflectDefault=1] attribute long start;
 [CEReactions, Reflect] attribute DOMString type;

 // also has obsolete members
};

[Exposed=Window]
interface HTMLUListElement : HTMLElement {
 [HTMLConstructor] constructor();

 // also has obsolete members
};

[Exposed=Window]
interface HTMLMenuElement : HTMLElement {
 [HTMLConstructor] constructor();

 // also has obsolete members
};

[Exposed=Window]
interface HTMLLIElement : HTMLElement {
 [HTMLConstructor] constructor();

 [CEReactions, Reflect] attribute long value;

 // also has obsolete members
};

[Exposed=Window]
interface HTMLDListElement : HTMLElement {
 [HTMLConstructor] constructor();

 // also has obsolete members
};

[Exposed=Window]
interface HTMLDivElement : HTMLElement {
 [HTMLConstructor] constructor();

 // also has obsolete members
};

[Exposed=Window]
interface HTMLAnchorElement : HTMLElement {
 [HTMLConstructor] constructor();

 [CEReactions, Reflect] attribute DOMString target;
 [CEReactions, Reflect] attribute DOMString download;
 [CEReactions, Reflect] attribute USVString ping;
 [CEReactions, Reflect] attribute DOMString rel;
 [SameObject, PutForwards=value, Reflect="rel"] readonly attribute DOMTokenList relList;
 [CEReactions, Reflect] attribute DOMString hreflang;
 [CEReactions, Reflect] attribute DOMString type;

 [CEReactions] attribute DOMString text;

 [CEReactions] attribute DOMString referrerPolicy;

 // also has obsolete members
};
HTMLAnchorElement includes HTMLHyperlinkElementUtils;

[Exposed=Window]
interface HTMLDataElement : HTMLElement {
 [HTMLConstructor] constructor();

 [CEReactions, Reflect] attribute DOMString value;
};

[Exposed=Window]
interface HTMLTimeElement : HTMLElement {
 [HTMLConstructor] constructor();

 [CEReactions, Reflect] attribute DOMString dateTime;
};

[Exposed=Window]
interface HTMLSpanElement : HTMLElement {
 [HTMLConstructor] constructor();
};

[Exposed=Window]
interface HTMLBRElement : HTMLElement {
 [HTMLConstructor] constructor();

 // also has obsolete members
};

interface mixin HTMLHyperlinkElementUtils {
 [CEReactions, ReflectSetter] stringifier attribute USVString href;
 readonly attribute USVString origin;
 [CEReactions] attribute USVString protocol;
 [CEReactions] attribute USVString username;
 [CEReactions] attribute USVString password;
 [CEReactions] attribute USVString host;
 [CEReactions] attribute USVString hostname;
 [CEReactions] attribute USVString port;
 [CEReactions] attribute USVString pathname;
 [CEReactions] attribute USVString search;
 [CEReactions] attribute USVString hash;
};

[Exposed=Window]
interface HTMLModElement : HTMLElement {
 [HTMLConstructor] constructor();

 [CEReactions, ReflectURL] attribute USVString cite;
 [CEReactions, Reflect] attribute DOMString dateTime;
};

[Exposed=Window]
interface HTMLPictureElement : HTMLElement {
 [HTMLConstructor] constructor();
};

[Exposed=Window]
interface HTMLSourceElement : HTMLElement {
 [HTMLConstructor] constructor();

 [CEReactions, ReflectURL] attribute USVString src;
 [CEReactions, Reflect] attribute DOMString type;
 [CEReactions, Reflect] attribute USVString srcset;
 [CEReactions, Reflect] attribute DOMString sizes;
 [CEReactions, Reflect] attribute DOMString media;
 [CEReactions, Reflect] attribute unsigned long width;
 [CEReactions, Reflect] attribute unsigned long height;
};

[Exposed=Window,
LegacyFactoryFunction=Image(optional unsigned long width, optional unsigned long height)]
interface HTMLImageElement : HTMLElement {
 [HTMLConstructor] constructor();

 [CEReactions, Reflect] attribute DOMString alt;
 [CEReactions, ReflectURL] attribute USVString src;
 [CEReactions, Reflect] attribute USVString srcset;
 [CEReactions, Reflect] attribute DOMString sizes;
 [CEReactions] attribute DOMString? crossOrigin;
 [CEReactions, Reflect] attribute DOMString useMap;
 [CEReactions, Reflect] attribute boolean isMap;
 [CEReactions, ReflectSetter] attribute unsigned long width;
 [CEReactions, ReflectSetter] attribute unsigned long height;
 readonly attribute unsigned long naturalWidth;
 readonly attribute unsigned long naturalHeight;
 readonly attribute boolean complete;
 readonly attribute USVString currentSrc;
 [CEReactions] attribute DOMString referrerPolicy;
 [CEReactions] attribute DOMString decoding;
 [CEReactions] attribute DOMString loading;
 [CEReactions] attribute DOMString fetchPriority;

 Promise<undefined> decode();

 // also has obsolete members
};

[Exposed=Window]
interface HTMLIFrameElement : HTMLElement {
 [HTMLConstructor] constructor();

 [CEReactions, ReflectURL] attribute USVString src;
 [CEReactions] attribute (TrustedHTML or DOMString) srcdoc;
 [CEReactions, Reflect] attribute DOMString name;
 [SameObject, PutForwards=value, Reflect] readonly attribute DOMTokenList sandbox;
 [CEReactions, Reflect] attribute DOMString allow;
 [CEReactions, Reflect] attribute boolean allowFullscreen;
 [CEReactions, Reflect] attribute DOMString width;
 [CEReactions, Reflect] attribute DOMString height;
 [CEReactions] attribute DOMString referrerPolicy;
 [CEReactions] attribute DOMString loading;
 readonly attribute Document? contentDocument;
 readonly attribute WindowProxy? contentWindow;
 Document? getSVGDocument();

 // also has obsolete members
};

[Exposed=Window]
interface HTMLEmbedElement : HTMLElement {
 [HTMLConstructor] constructor();

 [CEReactions, ReflectURL] attribute USVString src;
 [CEReactions, Reflect] attribute DOMString type;
 [CEReactions, Reflect] attribute DOMString width;
 [CEReactions, Reflect] attribute DOMString height;
 Document? getSVGDocument();

 // also has obsolete members
};

[Exposed=Window]
interface HTMLObjectElement : HTMLElement {
 [HTMLConstructor] constructor();

 [CEReactions, ReflectURL] attribute USVString data;
 [CEReactions, Reflect] attribute DOMString type;
 [CEReactions, Reflect] attribute DOMString name;
 readonly attribute HTMLFormElement? form;
 [CEReactions, Reflect] attribute DOMString width;
 [CEReactions, Reflect] attribute DOMString height;
 readonly attribute Document? contentDocument;
 readonly attribute WindowProxy? contentWindow;
 Document? getSVGDocument();

 readonly attribute boolean willValidate;
 readonly attribute ValidityState validity;
 readonly attribute DOMString validationMessage;
 boolean checkValidity();
 boolean reportValidity();
 undefined setCustomValidity(DOMString error);

 // also has obsolete members
};

[Exposed=Window]
interface HTMLVideoElement : HTMLMediaElement {
 [HTMLConstructor] constructor();

 [CEReactions, Reflect] attribute unsigned long width;
 [CEReactions, Reflect] attribute unsigned long height;
 readonly attribute unsigned long videoWidth;
 readonly attribute unsigned long videoHeight;
 [CEReactions, ReflectURL] attribute USVString poster;
 [CEReactions, Reflect] attribute boolean playsInline;
};

[Exposed=Window,
LegacyFactoryFunction=Audio(optional DOMString src)]
interface HTMLAudioElement : HTMLMediaElement {
 [HTMLConstructor] constructor();
};

[Exposed=Window]
interface HTMLTrackElement : HTMLElement {
 [HTMLConstructor] constructor();

 [CEReactions] attribute DOMString kind;
 [CEReactions, ReflectURL] attribute USVString src;
 [CEReactions, Reflect] attribute DOMString srclang;
 [CEReactions, Reflect] attribute DOMString label;
 [CEReactions, Reflect] attribute boolean default;

 const unsigned short NONE = 0;
 const unsigned short LOADING = 1;
 const unsigned short LOADED = 2;
 const unsigned short ERROR = 3;
 readonly attribute unsigned short readyState;

 readonly attribute TextTrack track;
};

enum CanPlayTypeResult { "" /* empty string */, "maybe", "probably" };
typedef (MediaStream or MediaSource or Blob) MediaProvider;

[Exposed=Window]
interface HTMLMediaElement : HTMLElement {

 // error state
 readonly attribute MediaError? error;

 // network state
 [CEReactions, ReflectURL] attribute USVString src;
 attribute MediaProvider? srcObject;
 readonly attribute USVString currentSrc;
 [CEReactions] attribute DOMString? crossOrigin;
 const unsigned short NETWORK_EMPTY = 0;
 const unsigned short NETWORK_IDLE = 1;
 const unsigned short NETWORK_LOADING = 2;
 const unsigned short NETWORK_NO_SOURCE = 3;
 readonly attribute unsigned short networkState;
 [CEReactions] attribute DOMString preload;
 readonly attribute TimeRanges buffered;
 undefined load();
 CanPlayTypeResult canPlayType(DOMString type);

 // ready state
 const unsigned short HAVE_NOTHING = 0;
 const unsigned short HAVE_METADATA = 1;
 const unsigned short HAVE_CURRENT_DATA = 2;
 const unsigned short HAVE_FUTURE_DATA = 3;
 const unsigned short HAVE_ENOUGH_DATA = 4;
 readonly attribute unsigned short readyState;
 readonly attribute boolean seeking;

 // playback state
 attribute double currentTime;
 undefined fastSeek(double time);
 readonly attribute unrestricted double duration;
 object getStartDate();
 readonly attribute boolean paused;
 attribute double defaultPlaybackRate;
 attribute double playbackRate;
 attribute boolean preservesPitch;
 readonly attribute TimeRanges played;
 readonly attribute TimeRanges seekable;
 readonly attribute boolean ended;
 [CEReactions, Reflect] attribute boolean autoplay;
 [CEReactions, Reflect] attribute boolean loop;
 Promise<undefined> play();
 undefined pause();

 // controls
 [CEReactions, Reflect] attribute boolean controls;
 attribute double volume;
 attribute boolean muted;
 [CEReactions, Reflect="muted"] attribute boolean defaultMuted;

 // tracks
 [SameObject] readonly attribute AudioTrackList audioTracks;
 [SameObject] readonly attribute VideoTrackList videoTracks;
 [SameObject] readonly attribute TextTrackList textTracks;
 TextTrack addTextTrack(TextTrackKind kind, optional DOMString label = "", optional DOMString language = "");
};

[Exposed=Window]
interface MediaError {
 const unsigned short MEDIA_ERR_ABORTED = 1;
 const unsigned short MEDIA_ERR_NETWORK = 2;
 const unsigned short MEDIA_ERR_DECODE = 3;
 const unsigned short MEDIA_ERR_SRC_NOT_SUPPORTED = 4;

 readonly attribute unsigned short code;
 readonly attribute DOMString message;
};

[Exposed=Window]
interface AudioTrackList : EventTarget {
 readonly attribute unsigned long length;
 getter AudioTrack (unsigned long index);
 AudioTrack? getTrackById(DOMString id);

 attribute EventHandler onchange;
 attribute EventHandler onaddtrack;
 attribute EventHandler onremovetrack;
};

[Exposed=Window]
interface AudioTrack {
 readonly attribute DOMString id;
 readonly attribute DOMString kind;
 readonly attribute DOMString label;
 readonly attribute DOMString language;
 attribute boolean enabled;
};

[Exposed=Window]
interface VideoTrackList : EventTarget {
 readonly attribute unsigned long length;
 getter VideoTrack (unsigned long index);
 VideoTrack? getTrackById(DOMString id);
 readonly attribute long selectedIndex;

 attribute EventHandler onchange;
 attribute EventHandler onaddtrack;
 attribute EventHandler onremovetrack;
};

[Exposed=Window]
interface VideoTrack {
 readonly attribute DOMString id;
 readonly attribute DOMString kind;
 readonly attribute DOMString label;
 readonly attribute DOMString language;
 attribute boolean selected;
};

[Exposed=Window]
interface TextTrackList : EventTarget {
 readonly attribute unsigned long length;
 getter TextTrack (unsigned long index);
 TextTrack? getTrackById(DOMString id);

 attribute EventHandler onchange;
 attribute EventHandler onaddtrack;
 attribute EventHandler onremovetrack;
};

enum TextTrackMode { "disabled",  "hidden",  "showing" };
enum TextTrackKind { "subtitles",  "captions",  "descriptions",  "chapters",  "metadata" };

[Exposed=Window]
interface TextTrack : EventTarget {
 readonly attribute TextTrackKind kind;
 readonly attribute DOMString label;
 readonly attribute DOMString language;

 readonly attribute DOMString id;
 readonly attribute DOMString inBandMetadataTrackDispatchType;

 attribute TextTrackMode mode;

 readonly attribute TextTrackCueList? cues;
 readonly attribute TextTrackCueList? activeCues;

 undefined addCue(TextTrackCue cue);
 undefined removeCue(TextTrackCue cue);

 attribute EventHandler oncuechange;
};

[Exposed=Window]
interface TextTrackCueList {
 readonly attribute unsigned long length;
 getter TextTrackCue (unsigned long index);
 TextTrackCue? getCueById(DOMString id);
};

[Exposed=Window]
interface TextTrackCue : EventTarget {
 readonly attribute TextTrack? track;

 attribute DOMString id;
 attribute double startTime;
 attribute unrestricted double endTime;
 attribute boolean pauseOnExit;

 attribute EventHandler onenter;
 attribute EventHandler onexit;
};

[Exposed=Window]
interface TimeRanges {
 readonly attribute unsigned long length;
 double start(unsigned long index);
 double end(unsigned long index);
};

[Exposed=Window]
interface TrackEvent : Event {
 constructor(DOMString type, optional TrackEventInit eventInitDict = {});

 readonly attribute (VideoTrack or AudioTrack or TextTrack)? track;
};

dictionary TrackEventInit : EventInit {
 (VideoTrack or AudioTrack or TextTrack)? track = null;
};

[Exposed=Window]
interface HTMLMapElement : HTMLElement {
 [HTMLConstructor] constructor();

 [CEReactions, Reflect] attribute DOMString name;
 [SameObject] readonly attribute HTMLCollection areas;
};

[Exposed=Window]
interface HTMLAreaElement : HTMLElement {
 [HTMLConstructor] constructor();

 [CEReactions, Reflect] attribute DOMString alt;
 [CEReactions, Reflect] attribute DOMString coords;
 [CEReactions, Reflect] attribute DOMString shape;
 [CEReactions, Reflect] attribute DOMString target;
 [CEReactions, Reflect] attribute DOMString download;
 [CEReactions, Reflect] attribute USVString ping;
 [CEReactions, Reflect] attribute DOMString rel;
 [SameObject, PutForwards=value, Reflect="rel"] readonly attribute DOMTokenList relList;
 [CEReactions] attribute DOMString referrerPolicy;

 // also has obsolete members
};
HTMLAreaElement includes HTMLHyperlinkElementUtils;

[Exposed=Window]
interface HTMLTableElement : HTMLElement {
 [HTMLConstructor] constructor();

 [CEReactions] attribute HTMLTableCaptionElement? caption;
 HTMLTableCaptionElement createCaption();
 [CEReactions] undefined deleteCaption();

 [CEReactions] attribute HTMLTableSectionElement? tHead;
 HTMLTableSectionElement createTHead();
 [CEReactions] undefined deleteTHead();

 [CEReactions] attribute HTMLTableSectionElement? tFoot;
 HTMLTableSectionElement createTFoot();
 [CEReactions] undefined deleteTFoot();

 [SameObject] readonly attribute HTMLCollection tBodies;
 HTMLTableSectionElement createTBody();

 [SameObject] readonly attribute HTMLCollection rows;
 HTMLTableRowElement insertRow(optional long index = -1);
 [CEReactions] undefined deleteRow(long index);

 // also has obsolete members
};

[Exposed=Window]
interface HTMLTableCaptionElement : HTMLElement {
 [HTMLConstructor] constructor();

 // also has obsolete members
};

[Exposed=Window]
interface HTMLTableColElement : HTMLElement {
 [HTMLConstructor] constructor();

 [CEReactions, Reflect, ReflectDefault=1, ReflectRange=(1, 1000)] attribute unsigned long span;

 // also has obsolete members
};

[Exposed=Window]
interface HTMLTableSectionElement : HTMLElement {
 [HTMLConstructor] constructor();

 [SameObject] readonly attribute HTMLCollection rows;
 HTMLTableRowElement insertRow(optional long index = -1);
 [CEReactions] undefined deleteRow(long index);

 // also has obsolete members
};

[Exposed=Window]
interface HTMLTableRowElement : HTMLElement {
 [HTMLConstructor] constructor();

 readonly attribute long rowIndex;
 readonly attribute long sectionRowIndex;
 [SameObject] readonly attribute HTMLCollection cells;
 HTMLTableCellElement insertCell(optional long index = -1);
 [CEReactions] undefined deleteCell(long index);

 // also has obsolete members
};

[Exposed=Window]
interface HTMLTableCellElement : HTMLElement {
 [HTMLConstructor] constructor();

 [CEReactions, Reflect, ReflectDefault=1, ReflectRange=(1, 1000)] attribute unsigned long colSpan;
 [CEReactions, Reflect, ReflectDefault=1, ReflectRange=(0, 65534)] attribute unsigned long rowSpan;
 [CEReactions, Reflect] attribute DOMString headers;
 readonly attribute long cellIndex;

 [CEReactions] attribute DOMString scope; // only conforming for th elements
 [CEReactions, Reflect] attribute DOMString abbr;  // only conforming for th elements

 // also has obsolete members
};

[Exposed=Window,
LegacyOverrideBuiltIns,
LegacyUnenumerableNamedProperties]
interface HTMLFormElement : HTMLElement {
 [HTMLConstructor] constructor();

 [CEReactions, Reflect="accept-charset"] attribute DOMString acceptCharset;
 [CEReactions, ReflectSetter] attribute USVString action;
 [CEReactions] attribute DOMString autocomplete;
 [CEReactions] attribute DOMString enctype;
 [CEReactions] attribute DOMString encoding;
 [CEReactions] attribute DOMString method;
 [CEReactions, Reflect] attribute DOMString name;
 [CEReactions, Reflect] attribute boolean noValidate;
 [CEReactions, Reflect] attribute DOMString target;
 [CEReactions, Reflect] attribute DOMString rel;
 [SameObject, PutForwards=value, Reflect="rel"] readonly attribute DOMTokenList relList;

 [SameObject] readonly attribute HTMLFormControlsCollection elements;
 readonly attribute unsigned long length;
 getter Element (unsigned long index);
 getter (RadioNodeList or Element) (DOMString name);

 undefined submit();
 undefined requestSubmit(optional HTMLElement? submitter = null);
 [CEReactions] undefined reset();
 boolean checkValidity();
 boolean reportValidity();
};

[Exposed=Window]
interface HTMLLabelElement : HTMLElement {
 [HTMLConstructor] constructor();

 readonly attribute HTMLFormElement? form;
 [CEReactions, Reflect="for"] attribute DOMString htmlFor;
 readonly attribute HTMLElement? control;
};

[Exposed=Window]
interface HTMLInputElement : HTMLElement {
 [HTMLConstructor] constructor();

 [CEReactions, Reflect] attribute DOMString accept;
 [CEReactions, Reflect] attribute boolean alpha;
 [CEReactions, Reflect] attribute DOMString alt;
 [CEReactions, ReflectSetter] attribute DOMString autocomplete;
 [CEReactions, Reflect="checked"] attribute boolean defaultChecked;
 attribute boolean checked;
 [CEReactions] attribute DOMString colorSpace;
 [CEReactions, Reflect] attribute DOMString dirName;
 [CEReactions, Reflect] attribute boolean disabled;
 readonly attribute HTMLFormElement? form;
 attribute FileList? files;
 [CEReactions, ReflectSetter] attribute USVString formAction;
 [CEReactions] attribute DOMString formEnctype;
 [CEReactions] attribute DOMString formMethod;
 [CEReactions, Reflect] attribute boolean formNoValidate;
 [CEReactions, Reflect] attribute DOMString formTarget;
 [CEReactions, ReflectSetter] attribute unsigned long height;
 attribute boolean indeterminate;
 readonly attribute HTMLDataListElement? list;
 [CEReactions, Reflect] attribute DOMString max;
 [CEReactions, ReflectNonNegative] attribute long maxLength;
 [CEReactions, Reflect] attribute DOMString min;
 [CEReactions, ReflectNonNegative] attribute long minLength;
 [CEReactions, Reflect] attribute boolean multiple;
 [CEReactions, Reflect] attribute DOMString name;
 [CEReactions, Reflect] attribute DOMString pattern;
 [CEReactions, Reflect] attribute DOMString placeholder;
 [CEReactions, Reflect] attribute boolean readOnly;
 [CEReactions, Reflect] attribute boolean required;
 [CEReactions, Reflect] attribute unsigned long size;
 [CEReactions, ReflectURL] attribute USVString src;
 [CEReactions, Reflect] attribute DOMString step;
 [CEReactions] attribute DOMString type;
 [CEReactions, Reflect="value"] attribute DOMString defaultValue;
 [CEReactions] attribute [LegacyNullToEmptyString] DOMString value;
 attribute object? valueAsDate;
 attribute unrestricted double valueAsNumber;
 [CEReactions, ReflectSetter] attribute unsigned long width;

 undefined stepUp(optional long n = 1);
 undefined stepDown(optional long n = 1);

 readonly attribute boolean willValidate;
 readonly attribute ValidityState validity;
 readonly attribute DOMString validationMessage;
 boolean checkValidity();
 boolean reportValidity();
 undefined setCustomValidity(DOMString error);

 readonly attribute NodeList? labels;

 undefined select();
 attribute unsigned long? selectionStart;
 attribute unsigned long? selectionEnd;
 attribute DOMString? selectionDirection;
 undefined setRangeText(DOMString replacement);
 undefined setRangeText(DOMString replacement, unsigned long start, unsigned long end, optional SelectionMode selectionMode = "preserve");
 undefined setSelectionRange(unsigned long start, unsigned long end, optional DOMString direction);

 undefined showPicker();

 // also has obsolete members
};
HTMLInputElement includes PopoverTargetAttributes;

[Exposed=Window]
interface HTMLButtonElement : HTMLElement {
 [HTMLConstructor] constructor();

 [CEReactions, ReflectSetter] attribute DOMString command;
 [CEReactions, Reflect] attribute Element? commandForElement;
 [CEReactions, Reflect] attribute boolean disabled;
 readonly attribute HTMLFormElement? form;
 [CEReactions, ReflectSetter] attribute USVString formAction;
 [CEReactions] attribute DOMString formEnctype;
 [CEReactions] attribute DOMString formMethod;
 [CEReactions, Reflect] attribute boolean formNoValidate;
 [CEReactions, Reflect] attribute DOMString formTarget;
 [CEReactions, Reflect] attribute DOMString name;
 [CEReactions, ReflectSetter] attribute DOMString type;
 [CEReactions, Reflect] attribute DOMString value;

 readonly attribute boolean willValidate;
 readonly attribute ValidityState validity;
 readonly attribute DOMString validationMessage;
 boolean checkValidity();
 boolean reportValidity();
 undefined setCustomValidity(DOMString error);

 readonly attribute NodeList labels;
};
HTMLButtonElement includes PopoverTargetAttributes;

[Exposed=Window]
interface HTMLSelectElement : HTMLElement {
 [HTMLConstructor] constructor();

 [CEReactions, ReflectSetter] attribute DOMString autocomplete;
 [CEReactions, Reflect] attribute boolean disabled;
 readonly attribute HTMLFormElement? form;
 [CEReactions, Reflect] attribute boolean multiple;
 [CEReactions, Reflect] attribute DOMString name;
 [CEReactions, Reflect] attribute boolean required;
 [CEReactions, Reflect, ReflectDefault=0] attribute unsigned long size;

 readonly attribute DOMString type;

 [SameObject] readonly attribute HTMLOptionsCollection options;
 [CEReactions] attribute unsigned long length;
 getter HTMLOptionElement? item(unsigned long index);
 HTMLOptionElement? namedItem(DOMString name);
 [CEReactions] undefined add((HTMLOptionElement or HTMLOptGroupElement) element, optional (HTMLElement or long)? before = null);
 [CEReactions] undefined remove(); // ChildNode overload
 [CEReactions] undefined remove(long index);
 [CEReactions] setter undefined (unsigned long index, HTMLOptionElement? option);

 [SameObject] readonly attribute HTMLCollection selectedOptions;
 attribute long selectedIndex;
 attribute DOMString value;

 readonly attribute boolean willValidate;
 readonly attribute ValidityState validity;
 readonly attribute DOMString validationMessage;
 boolean checkValidity();
 boolean reportValidity();
 undefined setCustomValidity(DOMString error);

 undefined showPicker();

 readonly attribute NodeList labels;
};

[Exposed=Window]
interface HTMLDataListElement : HTMLElement {
 [HTMLConstructor] constructor();

 [SameObject] readonly attribute HTMLCollection options;
};

[Exposed=Window]
interface HTMLOptGroupElement : HTMLElement {
 [HTMLConstructor] constructor();

 [CEReactions, Reflect] attribute boolean disabled;
 [CEReactions, Reflect] attribute DOMString label;
};

[Exposed=Window,
LegacyFactoryFunction=Option(optional DOMString text = "", optional DOMString value, optional boolean defaultSelected = false, optional boolean selected = false)]
interface HTMLOptionElement : HTMLElement {
 [HTMLConstructor] constructor();

 [CEReactions, Reflect] attribute boolean disabled;
 readonly attribute HTMLFormElement? form;
 [CEReactions, ReflectSetter] attribute DOMString label;
 [CEReactions, Reflect="selected"] attribute boolean defaultSelected;
 attribute boolean selected;
 [CEReactions, ReflectSetter] attribute DOMString value;

 [CEReactions] attribute DOMString text;
 readonly attribute long index;
};

[Exposed=Window]
interface HTMLTextAreaElement : HTMLElement {
 [HTMLConstructor] constructor();

 [CEReactions, ReflectSetter] attribute DOMString autocomplete;
 [CEReactions, ReflectPositiveWithFallback, ReflectDefault=20] attribute unsigned long cols;
 [CEReactions, Reflect] attribute DOMString dirName;
 [CEReactions, Reflect] attribute boolean disabled;
 readonly attribute HTMLFormElement? form;
 [CEReactions, ReflectNonNegative] attribute long maxLength;
 [CEReactions, ReflectNonNegative] attribute long minLength;
 [CEReactions, Reflect] attribute DOMString name;
 [CEReactions, Reflect] attribute DOMString placeholder;
 [CEReactions, Reflect] attribute boolean readOnly;
 [CEReactions, Reflect] attribute boolean required;
 [CEReactions, ReflectPositiveWithFallback, ReflectDefault=2] attribute unsigned long rows;
 [CEReactions, Reflect] attribute DOMString wrap;

 readonly attribute DOMString type;
 [CEReactions] attribute DOMString defaultValue;
 attribute [LegacyNullToEmptyString] DOMString value;
 readonly attribute unsigned long textLength;

 readonly attribute boolean willValidate;
 readonly attribute ValidityState validity;
 readonly attribute DOMString validationMessage;
 boolean checkValidity();
 boolean reportValidity();
 undefined setCustomValidity(DOMString error);

 readonly attribute NodeList labels;

 undefined select();
 attribute unsigned long selectionStart;
 attribute unsigned long selectionEnd;
 attribute DOMString selectionDirection;
 undefined setRangeText(DOMString replacement);
 undefined setRangeText(DOMString replacement, unsigned long start, unsigned long end, optional SelectionMode selectionMode = "preserve");
 undefined setSelectionRange(unsigned long start, unsigned long end, optional DOMString direction);
};

[Exposed=Window]
interface HTMLOutputElement : HTMLElement {
 [HTMLConstructor] constructor();

 [SameObject, PutForwards=value, Reflect="for"] readonly attribute DOMTokenList htmlFor;
 readonly attribute HTMLFormElement? form;
 [CEReactions, Reflect] attribute DOMString name;

 readonly attribute DOMString type;
 [CEReactions] attribute DOMString defaultValue;
 [CEReactions] attribute DOMString value;

 readonly attribute boolean willValidate;
 readonly attribute ValidityState validity;
 readonly attribute DOMString validationMessage;
 boolean checkValidity();
 boolean reportValidity();
 undefined setCustomValidity(DOMString error);

 readonly attribute NodeList labels;
};

[Exposed=Window]
interface HTMLProgressElement : HTMLElement {
 [HTMLConstructor] constructor();

 [CEReactions, ReflectSetter] attribute double value;
 [CEReactions, ReflectPositive, ReflectDefault=1.0] attribute double max;
 readonly attribute double position;
 readonly attribute NodeList labels;
};

[Exposed=Window]
interface HTMLMeterElement : HTMLElement {
 [HTMLConstructor] constructor();

 [CEReactions, ReflectSetter] attribute double value;
 [CEReactions, ReflectSetter] attribute double min;
 [CEReactions, ReflectSetter] attribute double max;
 [CEReactions, ReflectSetter] attribute double low;
 [CEReactions, ReflectSetter] attribute double high;
 [CEReactions, ReflectSetter] attribute double optimum;
 readonly attribute NodeList labels;
};

[Exposed=Window]
interface HTMLFieldSetElement : HTMLElement {
 [HTMLConstructor] constructor();

 [CEReactions, Reflect] attribute boolean disabled;
 readonly attribute HTMLFormElement? form;
 [CEReactions, Reflect] attribute DOMString name;

 readonly attribute DOMString type;

 [SameObject] readonly attribute HTMLCollection elements;

 readonly attribute boolean willValidate;
 [SameObject] readonly attribute ValidityState validity;
 readonly attribute DOMString validationMessage;
 boolean checkValidity();
 boolean reportValidity();
 undefined setCustomValidity(DOMString error);
};

[Exposed=Window]
interface HTMLLegendElement : HTMLElement {
 [HTMLConstructor] constructor();

 readonly attribute HTMLFormElement? form;

 // also has obsolete members
};

[Exposed=Window]
interface HTMLSelectedContentElement : HTMLElement {
 [HTMLConstructor] constructor();
};

enum SelectionMode {
 "select",
 "start",
 "end",
 "preserve" // default
};

[Exposed=Window]
interface ValidityState {
 readonly attribute boolean valueMissing;
 readonly attribute boolean typeMismatch;
 readonly attribute boolean patternMismatch;
 readonly attribute boolean tooLong;
 readonly attribute boolean tooShort;
 readonly attribute boolean rangeUnderflow;
 readonly attribute boolean rangeOverflow;
 readonly attribute boolean stepMismatch;
 readonly attribute boolean badInput;
 readonly attribute boolean customError;
 readonly attribute boolean valid;
};

[Exposed=Window]
interface SubmitEvent : Event {
 constructor(DOMString type, optional SubmitEventInit eventInitDict = {});

 readonly attribute HTMLElement? submitter;
};

dictionary SubmitEventInit : EventInit {
 HTMLElement? submitter = null;
};

[Exposed=Window]
interface FormDataEvent : Event {
 constructor(DOMString type, FormDataEventInit eventInitDict);

 readonly attribute FormData formData;
};

dictionary FormDataEventInit : EventInit {
 required FormData formData;
};

[Exposed=Window]
interface HTMLDetailsElement : HTMLElement {
 [HTMLConstructor] constructor();

 [CEReactions, Reflect] attribute DOMString name;
 [CEReactions, Reflect] attribute boolean open;
};

[Exposed=Window]
interface HTMLDialogElement : HTMLElement {
 [HTMLConstructor] constructor();

 [CEReactions, Reflect] attribute boolean open;
 attribute DOMString returnValue;
 [CEReactions, ReflectSetter] attribute DOMString closedBy;
 [CEReactions] undefined show();
 [CEReactions] undefined showModal();
 [CEReactions] undefined close(optional DOMString returnValue);
 [CEReactions] undefined requestClose(optional DOMString returnValue);
};

[Exposed=Window]
interface HTMLScriptElement : HTMLElement {
 [HTMLConstructor] constructor();

 [CEReactions, Reflect] attribute DOMString type;
 [CEReactions, ReflectURL] attribute USVString src;
 [CEReactions, Reflect] attribute boolean noModule;
 [CEReactions] attribute boolean async;
 [CEReactions, Reflect] attribute boolean defer;
 [SameObject, PutForwards=value, Reflect] readonly attribute DOMTokenList blocking;
 [CEReactions] attribute DOMString? crossOrigin;
 [CEReactions] attribute DOMString referrerPolicy;
 [CEReactions, Reflect] attribute DOMString integrity;
 [CEReactions] attribute DOMString fetchPriority;

 [CEReactions] attribute DOMString text;

 static boolean supports(DOMString type);

 // also has obsolete members
};

[Exposed=Window]
interface HTMLTemplateElement : HTMLElement {
 [HTMLConstructor] constructor();

 readonly attribute DocumentFragment content;
 [CEReactions] attribute DOMString shadowRootMode;
 [CEReactions, Reflect] attribute boolean shadowRootDelegatesFocus;
 [CEReactions, Reflect] attribute boolean shadowRootClonable;
 [CEReactions, Reflect] attribute boolean shadowRootSerializable;
 [CEReactions, Reflect] attribute DOMString shadowRootCustomElementRegistry;
};

[Exposed=Window]
interface HTMLSlotElement : HTMLElement {
 [HTMLConstructor] constructor();

 [CEReactions, Reflect] attribute DOMString name;
 sequence<Node> assignedNodes(optional AssignedNodesOptions options = {});
 sequence<Element> assignedElements(optional AssignedNodesOptions options = {});
 undefined assign((Element or Text)... nodes);
};

dictionary AssignedNodesOptions {
 boolean flatten = false;
};

typedef (CanvasRenderingContext2D or ImageBitmapRenderingContext or WebGLRenderingContext or WebGL2RenderingContext or GPUCanvasContext) RenderingContext;

[Exposed=Window]
interface HTMLCanvasElement : HTMLElement {
 [HTMLConstructor] constructor();

 [CEReactions] attribute unsigned long width;
 [CEReactions] attribute unsigned long height;

 RenderingContext? getContext(DOMString contextId, optional any options = null);

 USVString toDataURL(optional DOMString type = "image/png", optional any quality);
 undefined toBlob(BlobCallback _callback, optional DOMString type = "image/png", optional any quality);
 OffscreenCanvas transferControlToOffscreen();
};

callback BlobCallback = undefined (Blob? blob);

typedef (HTMLImageElement or
        SVGImageElement) HTMLOrSVGImageElement;

typedef (HTMLOrSVGImageElement or
        HTMLVideoElement or
        HTMLCanvasElement or
        ImageBitmap or
        OffscreenCanvas or
        VideoFrame) CanvasImageSource;

enum CanvasColorType { "unorm8", "float16" };

enum CanvasFillRule { "nonzero", "evenodd" };

dictionary CanvasRenderingContext2DSettings {
 boolean alpha = true;
 boolean desynchronized = false;
 PredefinedColorSpace colorSpace = "srgb";
 CanvasColorType colorType = "unorm8";
 boolean willReadFrequently = false;
};

enum ImageSmoothingQuality { "low", "medium", "high" };

[Exposed=Window]
interface CanvasRenderingContext2D {
 // back-reference to the canvas
 readonly attribute HTMLCanvasElement canvas;
};
CanvasRenderingContext2D includes CanvasSettings;
CanvasRenderingContext2D includes CanvasState;
CanvasRenderingContext2D includes CanvasTransform;
CanvasRenderingContext2D includes CanvasCompositing;
CanvasRenderingContext2D includes CanvasImageSmoothing;
CanvasRenderingContext2D includes CanvasFillStrokeStyles;
CanvasRenderingContext2D includes CanvasShadowStyles;
CanvasRenderingContext2D includes CanvasFilters;
CanvasRenderingContext2D includes CanvasRect;
CanvasRenderingContext2D includes CanvasDrawPath;
CanvasRenderingContext2D includes CanvasUserInterface;
CanvasRenderingContext2D includes CanvasText;
CanvasRenderingContext2D includes CanvasDrawImage;
CanvasRenderingContext2D includes CanvasImageData;
CanvasRenderingContext2D includes CanvasPathDrawingStyles;
CanvasRenderingContext2D includes CanvasTextDrawingStyles;
CanvasRenderingContext2D includes CanvasPath;

interface mixin CanvasSettings {
 // settings
 CanvasRenderingContext2DSettings getContextAttributes();
};

interface mixin CanvasState {
 // state
 undefined save(); // push state on state stack
 undefined restore(); // pop state stack and restore state
 undefined reset(); // reset the rendering context to its default state
 boolean isContextLost(); // return whether context is lost
};

interface mixin CanvasTransform {
 // transformations (default transform is the identity matrix)
 undefined scale(unrestricted double x, unrestricted double y);
 undefined rotate(unrestricted double angle);
 undefined translate(unrestricted double x, unrestricted double y);
 undefined transform(unrestricted double a, unrestricted double b, unrestricted double c, unrestricted double d, unrestricted double e, unrestricted double f);

 [NewObject] DOMMatrix getTransform();
 undefined setTransform(unrestricted double a, unrestricted double b, unrestricted double c, unrestricted double d, unrestricted double e, unrestricted double f);
 undefined setTransform(optional DOMMatrix2DInit transform = {});
 undefined resetTransform();

};

interface mixin CanvasCompositing {
 // compositing
 attribute unrestricted double globalAlpha; // (default 1.0)
 attribute DOMString globalCompositeOperation; // (default "source-over")
};

interface mixin CanvasImageSmoothing {
 // image smoothing
 attribute boolean imageSmoothingEnabled; // (default true)
 attribute ImageSmoothingQuality imageSmoothingQuality; // (default low)

};

interface mixin CanvasFillStrokeStyles {
 // colors and styles (see also the CanvasPathDrawingStyles and CanvasTextDrawingStyles interfaces)
 attribute (DOMString or CanvasGradient or CanvasPattern) strokeStyle; // (default black)
 attribute (DOMString or CanvasGradient or CanvasPattern) fillStyle; // (default black)
 CanvasGradient createLinearGradient(double x0, double y0, double x1, double y1);
 CanvasGradient createRadialGradient(double x0, double y0, double r0, double x1, double y1, double r1);
 CanvasGradient createConicGradient(double startAngle, double x, double y);
 CanvasPattern? createPattern(CanvasImageSource image, [LegacyNullToEmptyString] DOMString repetition);

};

interface mixin CanvasShadowStyles {
 // shadows
 attribute unrestricted double shadowOffsetX; // (default 0)
 attribute unrestricted double shadowOffsetY; // (default 0)
 attribute unrestricted double shadowBlur; // (default 0)
 attribute DOMString shadowColor; // (default transparent black)
};

interface mixin CanvasFilters {
 // filters
 attribute DOMString filter; // (default "none")
};

interface mixin CanvasRect {
 // rects
 undefined clearRect(unrestricted double x, unrestricted double y, unrestricted double w, unrestricted double h);
 undefined fillRect(unrestricted double x, unrestricted double y, unrestricted double w, unrestricted double h);
 undefined strokeRect(unrestricted double x, unrestricted double y, unrestricted double w, unrestricted double h);
};

interface mixin CanvasDrawPath {
 // path API (see also CanvasPath)
 undefined beginPath();
 undefined fill(optional CanvasFillRule fillRule = "nonzero");
 undefined fill(Path2D path, optional CanvasFillRule fillRule = "nonzero");
 undefined stroke();
 undefined stroke(Path2D path);
 undefined clip(optional CanvasFillRule fillRule = "nonzero");
 undefined clip(Path2D path, optional CanvasFillRule fillRule = "nonzero");
 boolean isPointInPath(unrestricted double x, unrestricted double y, optional CanvasFillRule fillRule = "nonzero");
 boolean isPointInPath(Path2D path, unrestricted double x, unrestricted double y, optional CanvasFillRule fillRule = "nonzero");
 boolean isPointInStroke(unrestricted double x, unrestricted double y);
 boolean isPointInStroke(Path2D path, unrestricted double x, unrestricted double y);
};

interface mixin CanvasUserInterface {
 undefined drawFocusIfNeeded(Element element);
 undefined drawFocusIfNeeded(Path2D path, Element element);
};

interface mixin CanvasText {
 // text (see also the CanvasPathDrawingStyles and CanvasTextDrawingStyles interfaces)
 undefined fillText(DOMString text, unrestricted double x, unrestricted double y, optional unrestricted double maxWidth);
 undefined strokeText(DOMString text, unrestricted double x, unrestricted double y, optional unrestricted double maxWidth);
 TextMetrics measureText(DOMString text);
};

interface mixin CanvasDrawImage {
 // drawing images
 undefined drawImage(CanvasImageSource image, unrestricted double dx, unrestricted double dy);
 undefined drawImage(CanvasImageSource image, unrestricted double dx, unrestricted double dy, unrestricted double dw, unrestricted double dh);
 undefined drawImage(CanvasImageSource image, unrestricted double sx, unrestricted double sy, unrestricted double sw, unrestricted double sh, unrestricted double dx, unrestricted double dy, unrestricted double dw, unrestricted double dh);
};

interface mixin CanvasImageData {
 // pixel manipulation
 ImageData createImageData([EnforceRange] long sw, [EnforceRange] long sh, optional ImageDataSettings settings = {});
 ImageData createImageData(ImageData imageData);
 ImageData getImageData([EnforceRange] long sx, [EnforceRange] long sy, [EnforceRange] long sw, [EnforceRange] long sh, optional ImageDataSettings settings = {});
 undefined putImageData(ImageData imageData, [EnforceRange] long dx, [EnforceRange] long dy);
 undefined putImageData(ImageData imageData, [EnforceRange] long dx, [EnforceRange] long dy, [EnforceRange] long dirtyX, [EnforceRange] long dirtyY, [EnforceRange] long dirtyWidth, [EnforceRange] long dirtyHeight);
};

enum CanvasLineCap { "butt", "round", "square" };
enum CanvasLineJoin { "round", "bevel", "miter" };
enum CanvasTextAlign { "start", "end", "left", "right", "center" };
enum CanvasTextBaseline { "top", "hanging", "middle", "alphabetic", "ideographic", "bottom" };
enum CanvasDirection { "ltr", "rtl", "inherit" };
enum CanvasFontKerning { "auto", "normal", "none" };
enum CanvasFontStretch { "ultra-condensed", "extra-condensed", "condensed", "semi-condensed", "normal", "semi-expanded", "expanded", "extra-expanded", "ultra-expanded" };
enum CanvasFontVariantCaps { "normal", "small-caps", "all-small-caps", "petite-caps", "all-petite-caps", "unicase", "titling-caps" };
enum CanvasTextRendering { "auto", "optimizeSpeed", "optimizeLegibility", "geometricPrecision" };

interface mixin CanvasPathDrawingStyles {
 // line caps/joins
 attribute unrestricted double lineWidth; // (default 1)
 attribute CanvasLineCap lineCap; // (default "butt")
 attribute CanvasLineJoin lineJoin; // (default "miter")
 attribute unrestricted double miterLimit; // (default 10)

 // dashed lines
 undefined setLineDash(sequence<unrestricted double> segments); // default empty
 sequence<unrestricted double> getLineDash();
 attribute unrestricted double lineDashOffset;
};

interface mixin CanvasTextDrawingStyles {
 // text
 attribute DOMString lang; // (default: "inherit")
 attribute DOMString font; // (default 10px sans-serif)
 attribute CanvasTextAlign textAlign; // (default: "start")
 attribute CanvasTextBaseline textBaseline; // (default: "alphabetic")
 attribute CanvasDirection direction; // (default: "inherit")
 attribute DOMString letterSpacing; // (default: "0px")
 attribute CanvasFontKerning fontKerning; // (default: "auto")
 attribute CanvasFontStretch fontStretch; // (default: "normal")
 attribute CanvasFontVariantCaps fontVariantCaps; // (default: "normal")
 attribute CanvasTextRendering textRendering; // (default: "auto")
 attribute DOMString wordSpacing; // (default: "0px")
};

interface mixin CanvasPath {
 // shared path API methods
 undefined closePath();
 undefined moveTo(unrestricted double x, unrestricted double y);
 undefined lineTo(unrestricted double x, unrestricted double y);
 undefined quadraticCurveTo(unrestricted double cpx, unrestricted double cpy, unrestricted double x, unrestricted double y);
 undefined bezierCurveTo(unrestricted double cp1x, unrestricted double cp1y, unrestricted double cp2x, unrestricted double cp2y, unrestricted double x, unrestricted double y);
 undefined arcTo(unrestricted double x1, unrestricted double y1, unrestricted double x2, unrestricted double y2, unrestricted double radius);
 undefined rect(unrestricted double x, unrestricted double y, unrestricted double w, unrestricted double h);
 undefined roundRect(unrestricted double x, unrestricted double y, unrestricted double w, unrestricted double h, optional (unrestricted double or DOMPointInit or sequence<(unrestricted double or DOMPointInit)>) radii = 0);
 undefined arc(unrestricted double x, unrestricted double y, unrestricted double radius, unrestricted double startAngle, unrestricted double endAngle, optional boolean counterclockwise = false);
 undefined ellipse(unrestricted double x, unrestricted double y, unrestricted double radiusX, unrestricted double radiusY, unrestricted double rotation, unrestricted double startAngle, unrestricted double endAngle, optional boolean counterclockwise = false);
};

[Exposed=(Window,Worker)]
interface CanvasGradient {
 // opaque object
 undefined addColorStop(double offset, DOMString color);
};

[Exposed=(Window,Worker)]
interface CanvasPattern {
 // opaque object
 undefined 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;

 // y-direction
 readonly attribute double fontBoundingBoxAscent;
 readonly attribute double fontBoundingBoxDescent;
 readonly attribute double actualBoundingBoxAscent;
 readonly attribute double actualBoundingBoxDescent;
 readonly attribute double emHeightAscent;
 readonly attribute double emHeightDescent;
 readonly attribute double hangingBaseline;
 readonly attribute double alphabeticBaseline;
 readonly attribute double ideographicBaseline;
};

[Exposed=(Window,Worker)]
interface Path2D {
 constructor(optional (Path2D or DOMString) path);

 undefined addPath(Path2D path, optional DOMMatrix2DInit transform = {});
};
Path2D includes CanvasPath;

[Exposed=(Window,Worker)]
interface ImageBitmapRenderingContext {
 readonly attribute (HTMLCanvasElement or OffscreenCanvas) canvas;
 undefined transferFromImageBitmap(ImageBitmap? bitmap);
};

dictionary ImageBitmapRenderingContextSettings {
 boolean alpha = true;
};

typedef (OffscreenCanvasRenderingContext2D or ImageBitmapRenderingContext or WebGLRenderingContext or WebGL2RenderingContext or GPUCanvasContext) OffscreenRenderingContext;

dictionary ImageEncodeOptions {
 DOMString type = "image/png";
 unrestricted double quality;
};

enum OffscreenRenderingContextId { "2d", "bitmaprenderer", "webgl", "webgl2", "webgpu" };

[Exposed=(Window,Worker), Transferable]
interface OffscreenCanvas : EventTarget {
 constructor([EnforceRange] unsigned long long width, [EnforceRange] unsigned long long height);

 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 = {});

 attribute EventHandler oncontextlost;
 attribute EventHandler oncontextrestored;
};

[Exposed=(Window,Worker)]
interface OffscreenCanvasRenderingContext2D {
 readonly attribute OffscreenCanvas canvas;
};

OffscreenCanvasRenderingContext2D includes CanvasSettings;
OffscreenCanvasRenderingContext2D includes CanvasState;
OffscreenCanvasRenderingContext2D includes CanvasTransform;
OffscreenCanvasRenderingContext2D includes CanvasCompositing;
OffscreenCanvasRenderingContext2D includes CanvasImageSmoothing;
OffscreenCanvasRenderingContext2D includes CanvasFillStrokeStyles;
OffscreenCanvasRenderingContext2D includes CanvasShadowStyles;
OffscreenCanvasRenderingContext2D includes CanvasFilters;
OffscreenCanvasRenderingContext2D includes CanvasRect;
OffscreenCanvasRenderingContext2D includes CanvasDrawPath;
OffscreenCanvasRenderingContext2D includes CanvasText;
OffscreenCanvasRenderingContext2D includes CanvasDrawImage;
OffscreenCanvasRenderingContext2D includes CanvasImageData;
OffscreenCanvasRenderingContext2D includes CanvasPathDrawingStyles;
OffscreenCanvasRenderingContext2D includes CanvasTextDrawingStyles;
OffscreenCanvasRenderingContext2D includes CanvasPath;

enum PredefinedColorSpace { "srgb", "srgb-linear", "display-p3", "display-p3-linear" };

[Exposed=Window]
interface CustomElementRegistry {
 constructor();

 [CEReactions] undefined define(DOMString name, CustomElementConstructor constructor, optional ElementDefinitionOptions options = {});
 (CustomElementConstructor or undefined) get(DOMString name);
 DOMString? getName(CustomElementConstructor constructor);
 Promise<CustomElementConstructor> whenDefined(DOMString name);
 [CEReactions] undefined upgrade(Node root);
 [CEReactions] undefined initialize(Node root);
};

callback CustomElementConstructor = HTMLElement ();

dictionary ElementDefinitionOptions {
 DOMString extends;
};

[Exposed=Window]
interface ElementInternals {
 // Shadow root access
 readonly attribute ShadowRoot? shadowRoot;

 // Form-associated custom elements
 undefined setFormValue((File or USVString or FormData)? value,
                        optional (File or USVString or FormData)? state);

 readonly attribute HTMLFormElement? form;

 undefined setValidity(optional ValidityStateFlags flags = {},
                       optional DOMString message,
                       optional HTMLElement anchor);
 readonly attribute boolean willValidate;
 readonly attribute ValidityState validity;
 readonly attribute DOMString validationMessage;
 boolean checkValidity();
 boolean reportValidity();

 readonly attribute NodeList labels;

 // Custom state pseudo-class
 [SameObject] readonly attribute CustomStateSet states;
};

// Accessibility semantics
ElementInternals includes ARIAMixin;

dictionary ValidityStateFlags {
 boolean valueMissing = false;
 boolean typeMismatch = false;
 boolean patternMismatch = false;
 boolean tooLong = false;
 boolean tooShort = false;
 boolean rangeUnderflow = false;
 boolean rangeOverflow = false;
 boolean stepMismatch = false;
 boolean badInput = false;
 boolean customError = false;
};

[Exposed=Window]
interface CustomStateSet {
 setlike<DOMString>;
};

[Exposed=(Window)]
interface VisibilityStateEntry : PerformanceEntry {
 readonly attribute DOMString name;                 // shadows inherited name
 readonly attribute DOMString entryType;            // shadows inherited entryType
 readonly attribute DOMHighResTimeStamp startTime;  // shadows inherited startTime
 readonly attribute unsigned long duration;         // shadows inherited duration
};

[Exposed=Window]
interface UserActivation {
 readonly attribute boolean hasBeenActive;
 readonly attribute boolean isActive;
};

partial interface Navigator {
 [SameObject] readonly attribute UserActivation userActivation;
};

[Exposed=Window]
interface ToggleEvent : Event {
 constructor(DOMString type, optional ToggleEventInit eventInitDict = {});
 readonly attribute DOMString oldState;
 readonly attribute DOMString newState;
 readonly attribute Element? source;
};

dictionary ToggleEventInit : EventInit {
 DOMString oldState = "";
 DOMString newState = "";
 Element? source = null;
};

[Exposed=Window]
interface CommandEvent : Event {
 constructor(DOMString type, optional CommandEventInit eventInitDict = {});
 readonly attribute Element? source;
 readonly attribute DOMString command;
};

dictionary CommandEventInit : EventInit {
 Element? source = null;
 DOMString command = "";
};

dictionary FocusOptions {
 boolean preventScroll = false;
 boolean focusVisible;
};

interface mixin ElementContentEditable {
 [CEReactions] attribute DOMString contentEditable;
 [CEReactions] attribute DOMString enterKeyHint;
 readonly attribute boolean isContentEditable;
 [CEReactions] attribute DOMString inputMode;
};

[Exposed=Window]
interface CloseWatcher : EventTarget {
 constructor(optional CloseWatcherOptions options = {});

 undefined requestClose();
 undefined close();
 undefined destroy();

 attribute EventHandler oncancel;
 attribute EventHandler onclose;
};

dictionary CloseWatcherOptions {
 AbortSignal signal;
};

[Exposed=Window]
interface DataTransfer {
 constructor();

 attribute DOMString dropEffect;
 attribute DOMString effectAllowed;

 [SameObject] readonly attribute DataTransferItemList items;

 undefined setDragImage(Element image, long x, long y);

 /* old interface */
 readonly attribute FrozenArray<DOMString> types;
 DOMString getData(DOMString format);
 undefined setData(DOMString format, DOMString data);
 undefined clearData(optional DOMString format);
 [SameObject] readonly attribute FileList files;
};

[Exposed=Window]
interface DataTransferItemList {
 readonly attribute unsigned long length;
 getter DataTransferItem (unsigned long index);
 DataTransferItem? add(DOMString data, DOMString type);
 DataTransferItem? add(File data);
 undefined remove(unsigned long index);
 undefined clear();
};

[Exposed=Window]
interface DataTransferItem {
 readonly attribute DOMString kind;
 readonly attribute DOMString type;
 undefined getAsString(FunctionStringCallback? _callback);
 File? getAsFile();
};

callback FunctionStringCallback = undefined (DOMString data);

[Exposed=Window]
interface DragEvent : MouseEvent {
 constructor(DOMString type, optional DragEventInit eventInitDict = {});

 readonly attribute DataTransfer? dataTransfer;
};

dictionary DragEventInit : MouseEventInit {
 DataTransfer? dataTransfer = null;
};

interface mixin PopoverTargetAttributes {
 [CEReactions, Reflect] attribute Element? popoverTargetElement;
 [CEReactions] attribute DOMString popoverTargetAction;
};

[Exposed=*]
interface Origin {
 constructor();

 static Origin from(any value);

 readonly attribute boolean opaque;

 boolean isSameOrigin(Origin other);
 boolean isSameSite(Origin other);
};

[Global=Window,
Exposed=Window,
LegacyUnenumerableNamedProperties]
interface Window : EventTarget {
 // the current browsing context
 [LegacyUnforgeable] readonly attribute WindowProxy window;
 [Replaceable] readonly attribute WindowProxy self;
 [LegacyUnforgeable] readonly attribute Document document;
 attribute DOMString name;
 [PutForwards=href, LegacyUnforgeable] readonly attribute Location location;
 readonly attribute History history;
 [Replaceable] readonly attribute Navigation navigation;
 readonly attribute CustomElementRegistry customElements;
 [Replaceable] readonly attribute BarProp locationbar;
 [Replaceable] readonly attribute BarProp menubar;
 [Replaceable] readonly attribute BarProp personalbar;
 [Replaceable] readonly attribute BarProp scrollbars;
 [Replaceable] readonly attribute BarProp statusbar;
 [Replaceable] readonly attribute BarProp toolbar;
 attribute DOMString status;
 undefined close();
 readonly attribute boolean closed;
 undefined stop();
 undefined focus();
 undefined blur();

 // other browsing contexts
 [Replaceable] readonly attribute WindowProxy frames;
 [Replaceable] readonly attribute unsigned long length;
 [LegacyUnforgeable] readonly attribute WindowProxy? top;
 attribute any opener;
 [Replaceable] readonly attribute WindowProxy? parent;
 readonly attribute Element? frameElement;
 WindowProxy? open(optional USVString url = "", optional DOMString target = "_blank", optional [LegacyNullToEmptyString] DOMString features = "");

 // Since this is the global object, the IDL named getter adds a NamedPropertiesObject exotic
 // object on the prototype chain. Indeed, this does not make the global object an exotic object.
 // Indexed access is taken care of by the WindowProxy exotic object.
 getter object (DOMString name);

 // the user agent
 readonly attribute Navigator navigator;
 [Replaceable] readonly attribute Navigator clientInformation; // legacy alias of .navigator
 readonly attribute boolean originAgentCluster;

 // user prompts
 undefined alert();
 undefined alert(DOMString message);
 boolean confirm(optional DOMString message = "");
 DOMString? prompt(optional DOMString message = "", optional DOMString default = "");
 undefined print();

 undefined postMessage(any message, USVString targetOrigin, optional sequence<object> transfer = []);
 undefined postMessage(any message, optional WindowPostMessageOptions options = {});

 // also has obsolete members
};
Window includes GlobalEventHandlers;
Window includes WindowEventHandlers;

dictionary WindowPostMessageOptions : StructuredSerializeOptions {
 USVString targetOrigin = "/";
};

[Exposed=Window]
interface BarProp {
 readonly attribute boolean visible;
};

[Exposed=Window]
interface Location { // but see also additional creation steps and overridden internal methods
 [LegacyUnforgeable] stringifier attribute USVString href;
 [LegacyUnforgeable] readonly attribute USVString origin;
 [LegacyUnforgeable] attribute USVString protocol;
 [LegacyUnforgeable] attribute USVString host;
 [LegacyUnforgeable] attribute USVString hostname;
 [LegacyUnforgeable] attribute USVString port;
 [LegacyUnforgeable] attribute USVString pathname;
 [LegacyUnforgeable] attribute USVString search;
 [LegacyUnforgeable] attribute USVString hash;

 [LegacyUnforgeable] undefined assign(USVString url);
 [LegacyUnforgeable] undefined replace(USVString url);
 [LegacyUnforgeable] undefined reload();

 [LegacyUnforgeable, SameObject] readonly attribute DOMStringList ancestorOrigins;
};

enum ScrollRestoration { "auto", "manual" };

[Exposed=Window]
interface History {
 readonly attribute unsigned long length;
 attribute ScrollRestoration scrollRestoration;
 readonly attribute any state;
 undefined go(optional long delta = 0);
 undefined back();
 undefined forward();
 undefined pushState(any data, DOMString unused, optional USVString? url = null);
 undefined replaceState(any data, DOMString unused, optional USVString? url = null);
};

[Exposed=Window]
interface Navigation : EventTarget {
 sequence<NavigationHistoryEntry> entries();
 readonly attribute NavigationHistoryEntry? currentEntry;
 undefined updateCurrentEntry(NavigationUpdateCurrentEntryOptions options);
 readonly attribute NavigationTransition? transition;
 readonly attribute NavigationActivation? activation;

 readonly attribute boolean canGoBack;
 readonly attribute boolean canGoForward;

 NavigationResult navigate(USVString url, optional NavigationNavigateOptions options = {});
 NavigationResult reload(optional NavigationReloadOptions options = {});

 NavigationResult traverseTo(DOMString key, optional NavigationOptions options = {});
 NavigationResult back(optional NavigationOptions options = {});
 NavigationResult forward(optional NavigationOptions options = {});

 attribute EventHandler onnavigate;
 attribute EventHandler onnavigatesuccess;
 attribute EventHandler onnavigateerror;
 attribute EventHandler oncurrententrychange;
};

dictionary NavigationUpdateCurrentEntryOptions {
 required any state;
};

dictionary NavigationOptions {
 any info;
};

dictionary NavigationNavigateOptions : NavigationOptions {
 any state;
 NavigationHistoryBehavior history = "auto";
};

dictionary NavigationReloadOptions : NavigationOptions {
 any state;
};

dictionary NavigationResult {
 Promise<NavigationHistoryEntry> committed;
 Promise<NavigationHistoryEntry> finished;
};

enum NavigationHistoryBehavior {
 "auto",
 "push",
 "replace"
};

enum NavigationType {
"push",
"replace",
"reload",
"traverse"
};

[Exposed=Window]
interface NavigationHistoryEntry : EventTarget {
 readonly attribute USVString? url;
 readonly attribute DOMString key;
 readonly attribute DOMString id;
 readonly attribute long long index;
 readonly attribute boolean sameDocument;

 any getState();

 attribute EventHandler ondispose;
};

[Exposed=Window]
interface NavigationTransition {
 readonly attribute NavigationType navigationType;
 readonly attribute NavigationHistoryEntry from;
 readonly attribute NavigationDestination to;
 readonly attribute Promise<undefined> committed;
 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);

 readonly attribute NavigationType navigationType;
 readonly attribute NavigationDestination destination;
 readonly attribute boolean canIntercept;
 readonly attribute boolean userInitiated;
 readonly attribute boolean hashChange;
 readonly attribute AbortSignal signal;
 readonly attribute FormData? formData;
 readonly attribute DOMString? downloadRequest;
 readonly attribute any info;
 readonly attribute boolean hasUAVisualTransition;
 readonly attribute Element? sourceElement;

 undefined intercept(optional NavigationInterceptOptions options = {});
 undefined scroll();
};

dictionary NavigateEventInit : EventInit {
 NavigationType navigationType = "push";
 required NavigationDestination destination;
 boolean canIntercept = false;
 boolean userInitiated = false;
 boolean hashChange = false;
 required AbortSignal signal;
 FormData? formData = null;
 DOMString? downloadRequest = null;
 any info;
 boolean hasUAVisualTransition = false;
 Element? sourceElement = null;
};

dictionary NavigationInterceptOptions {
 NavigationPrecommitHandler precommitHandler;
 NavigationInterceptHandler handler;
 NavigationFocusReset focusReset;
 NavigationScrollBehavior scroll;
};

enum NavigationFocusReset {
 "after-transition",
 "manual"
};

enum NavigationScrollBehavior {
 "after-transition",
 "manual"
};

callback NavigationInterceptHandler = Promise<undefined> ();

[Exposed=Window]
interface NavigationPrecommitController {
 undefined redirect(USVString url, optional NavigationNavigateOptions options = {});
 undefined addHandler(NavigationInterceptHandler handler);
};

callback NavigationPrecommitHandler = Promise<undefined> (NavigationPrecommitController controller);

[Exposed=Window]
interface NavigationDestination {
 readonly attribute USVString url;
 readonly attribute DOMString key;
 readonly attribute DOMString id;
 readonly attribute long long index;
 readonly attribute boolean sameDocument;

 any getState();
};

[Exposed=Window]
interface NavigationCurrentEntryChangeEvent : Event {
 constructor(DOMString type, NavigationCurrentEntryChangeEventInit eventInitDict);

 readonly attribute NavigationType? navigationType;
 readonly attribute NavigationHistoryEntry from;
};

dictionary NavigationCurrentEntryChangeEventInit : EventInit {
 NavigationType? navigationType = null;
 required NavigationHistoryEntry from;
};

[Exposed=Window]
interface PopStateEvent : Event {
 constructor(DOMString type, optional PopStateEventInit eventInitDict = {});

 readonly attribute any state;
 readonly attribute boolean hasUAVisualTransition;
};

dictionary PopStateEventInit : EventInit {
 any state = null;
 boolean hasUAVisualTransition = false;
};

[Exposed=Window]
interface HashChangeEvent : Event {
 constructor(DOMString type, optional HashChangeEventInit eventInitDict = {});

 readonly attribute USVString oldURL;
 readonly attribute USVString newURL;
};

dictionary HashChangeEventInit : EventInit {
 USVString oldURL = "";
 USVString newURL = "";
};

[Exposed=Window]
interface PageSwapEvent : Event {
 constructor(DOMString type, optional PageSwapEventInit eventInitDict = {});
 readonly attribute NavigationActivation? activation;
 readonly attribute ViewTransition? viewTransition;
};

dictionary PageSwapEventInit : EventInit {
 NavigationActivation? activation = null;
 ViewTransition? viewTransition = null;
};

[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 = {});

 readonly attribute boolean persisted;
};

dictionary PageTransitionEventInit : EventInit {
 boolean persisted = false;
};

[Exposed=Window]
interface BeforeUnloadEvent : Event {
 attribute DOMString returnValue;
};

[Exposed=Window]
interface NotRestoredReasonDetails {
 readonly attribute DOMString reason;
 [Default] object toJSON();
};

[Exposed=Window]
interface NotRestoredReasons {
 readonly attribute USVString? src;
 readonly attribute DOMString? id;
 readonly attribute DOMString? name;
 readonly attribute USVString? url;
 readonly attribute FrozenArray<NotRestoredReasonDetails>? reasons;
 readonly attribute FrozenArray<NotRestoredReasons>? children;
 [Default] object toJSON();
};

[Exposed=*]
interface ErrorEvent : Event {
 constructor(DOMString type, optional ErrorEventInit eventInitDict = {});

 readonly attribute DOMString message;
 readonly attribute USVString filename;
 readonly attribute unsigned long lineno;
 readonly attribute unsigned long colno;
 readonly attribute any error;
};

dictionary ErrorEventInit : EventInit {
 DOMString message = "";
 USVString filename = "";
 unsigned long lineno = 0;
 unsigned long colno = 0;
 any error;
};

[Exposed=*]
interface PromiseRejectionEvent : Event {
 constructor(DOMString type, PromiseRejectionEventInit eventInitDict);

 readonly attribute object promise;
 readonly attribute any reason;
};

dictionary PromiseRejectionEventInit : EventInit {
 required object promise;
 any reason;
};

[LegacyTreatNonObjectAsNull]
callback EventHandlerNonNull = any (Event event);
typedef EventHandlerNonNull? EventHandler;

[LegacyTreatNonObjectAsNull]
callback OnErrorEventHandlerNonNull = any ((Event or DOMString) event, optional DOMString source, optional unsigned long lineno, optional unsigned long colno, optional any error);
typedef OnErrorEventHandlerNonNull? OnErrorEventHandler;

[LegacyTreatNonObjectAsNull]
callback OnBeforeUnloadEventHandlerNonNull = DOMString? (Event event);
typedef OnBeforeUnloadEventHandlerNonNull? OnBeforeUnloadEventHandler;

interface mixin GlobalEventHandlers {
 attribute EventHandler onabort;
 attribute EventHandler onauxclick;
 attribute EventHandler onbeforeinput;
 attribute EventHandler onbeforematch;
 attribute EventHandler onbeforetoggle;
 attribute EventHandler onblur;
 attribute EventHandler oncancel;
 attribute EventHandler oncanplay;
 attribute EventHandler oncanplaythrough;
 attribute EventHandler onchange;
 attribute EventHandler onclick;
 attribute EventHandler onclose;
 attribute EventHandler oncommand;
 attribute EventHandler oncontextlost;
 attribute EventHandler oncontextmenu;
 attribute EventHandler oncontextrestored;
 attribute EventHandler oncopy;
 attribute EventHandler oncuechange;
 attribute EventHandler oncut;
 attribute EventHandler ondblclick;
 attribute EventHandler ondrag;
 attribute EventHandler ondragend;
 attribute EventHandler ondragenter;
 attribute EventHandler ondragleave;
 attribute EventHandler ondragover;
 attribute EventHandler ondragstart;
 attribute EventHandler ondrop;
 attribute EventHandler ondurationchange;
 attribute EventHandler onemptied;
 attribute EventHandler onended;
 attribute OnErrorEventHandler onerror;
 attribute EventHandler onfocus;
 attribute EventHandler onformdata;
 attribute EventHandler oninput;
 attribute EventHandler oninvalid;
 attribute EventHandler onkeydown;
 attribute EventHandler onkeypress;
 attribute EventHandler onkeyup;
 attribute EventHandler onload;
 attribute EventHandler onloadeddata;
 attribute EventHandler onloadedmetadata;
 attribute EventHandler onloadstart;
 attribute EventHandler onmousedown;
 [LegacyLenientThis] attribute EventHandler onmouseenter;
 [LegacyLenientThis] attribute EventHandler onmouseleave;
 attribute EventHandler onmousemove;
 attribute EventHandler onmouseout;
 attribute EventHandler onmouseover;
 attribute EventHandler onmouseup;
 attribute EventHandler onpaste;
 attribute EventHandler onpause;
 attribute EventHandler onplay;
 attribute EventHandler onplaying;
 attribute EventHandler onprogress;
 attribute EventHandler onratechange;
 attribute EventHandler onreset;
 attribute EventHandler onresize;
 attribute EventHandler onscroll;
 attribute EventHandler onscrollend;
 attribute EventHandler onsecuritypolicyviolation;
 attribute EventHandler onseeked;
 attribute EventHandler onseeking;
 attribute EventHandler onselect;
 attribute EventHandler onslotchange;
 attribute EventHandler onstalled;
 attribute EventHandler onsubmit;
 attribute EventHandler onsuspend;
 attribute EventHandler ontimeupdate;
 attribute EventHandler ontoggle;
 attribute EventHandler onvolumechange;
 attribute EventHandler onwaiting;
 attribute EventHandler onwebkitanimationend;
 attribute EventHandler onwebkitanimationiteration;
 attribute EventHandler onwebkitanimationstart;
 attribute EventHandler onwebkittransitionend;
 attribute EventHandler onwheel;
};

interface mixin WindowEventHandlers {
 attribute EventHandler onafterprint;
 attribute EventHandler onbeforeprint;
 attribute OnBeforeUnloadEventHandler onbeforeunload;
 attribute EventHandler onhashchange;
 attribute EventHandler onlanguagechange;
 attribute EventHandler onmessage;
 attribute EventHandler onmessageerror;
 attribute EventHandler onoffline;
 attribute EventHandler ononline;
 attribute EventHandler onpagehide;
 attribute EventHandler onpagereveal;
 attribute EventHandler onpageshow;
 attribute EventHandler onpageswap;
 attribute EventHandler onpopstate;
 attribute EventHandler onrejectionhandled;
 attribute EventHandler onstorage;
 attribute EventHandler onunhandledrejection;
 attribute EventHandler onunload;
};

typedef (DOMString or Function or TrustedScript) TimerHandler;

interface mixin WindowOrWorkerGlobalScope {
 [Replaceable] readonly attribute USVString origin;
 readonly attribute boolean isSecureContext;
 readonly attribute boolean crossOriginIsolated;

 undefined reportError(any e);

 // base64 utility methods
 DOMString btoa(DOMString data);
 ByteString atob(DOMString data);

 // timers
 long setTimeout(TimerHandler handler, optional long timeout = 0, any... arguments);
 undefined clearTimeout(optional long id = 0);
 long setInterval(TimerHandler handler, optional long timeout = 0, any... arguments);
 undefined clearInterval(optional long id = 0);

 // microtask queuing
 undefined 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 = {});

 // structured cloning
 any structuredClone(any value, optional StructuredSerializeOptions options = {});
};
Window includes WindowOrWorkerGlobalScope;
WorkerGlobalScope includes WindowOrWorkerGlobalScope;

partial interface Element {
 [CEReactions] undefined setHTMLUnsafe((TrustedHTML or DOMString) html);
 DOMString getHTML(optional GetHTMLOptions options = {});

 [CEReactions] attribute (TrustedHTML or [LegacyNullToEmptyString] DOMString) innerHTML;
 [CEReactions] attribute (TrustedHTML or [LegacyNullToEmptyString] DOMString) outerHTML;
 [CEReactions] undefined insertAdjacentHTML(DOMString position, (TrustedHTML or DOMString) string);
};

partial interface ShadowRoot {
 [CEReactions] undefined setHTMLUnsafe((TrustedHTML or DOMString) html);
 DOMString getHTML(optional GetHTMLOptions options = {});

 [CEReactions] attribute (TrustedHTML or [LegacyNullToEmptyString] DOMString) innerHTML;
};

dictionary GetHTMLOptions {
 boolean serializableShadowRoots = false;
 sequence<ShadowRoot> shadowRoots = [];
};

[Exposed=Window]
interface DOMParser {
 constructor();

 [NewObject] Document parseFromString((TrustedHTML or DOMString) string, DOMParserSupportedType type);
};

enum DOMParserSupportedType {
 "text/html",
 "text/xml",
 "application/xml",
 "application/xhtml+xml",
 "image/svg+xml"
};

partial interface Range {
 [CEReactions, NewObject] DocumentFragment createContextualFragment((TrustedHTML or DOMString) string);
};

[Exposed=Window]
interface XMLSerializer {
 constructor();

 DOMString serializeToString(Node root);
};

[Exposed=Window]
interface Navigator {
 // objects implementing this interface also implement the interfaces given below
};
Navigator includes NavigatorID;
Navigator includes NavigatorLanguage;
Navigator includes NavigatorOnLine;
Navigator includes NavigatorContentUtils;
Navigator includes NavigatorCookies;
Navigator includes NavigatorPlugins;
Navigator includes NavigatorConcurrentHardware;

interface mixin NavigatorID {
 readonly attribute DOMString appCodeName; // constant "Mozilla"
 readonly attribute DOMString appName; // constant "Netscape"
 readonly attribute DOMString appVersion;
 readonly attribute DOMString platform;
 readonly attribute DOMString product; // constant "Gecko"
 [Exposed=Window] readonly attribute DOMString productSub;
 readonly attribute DOMString userAgent;
 [Exposed=Window] readonly attribute DOMString vendor;
 [Exposed=Window] readonly attribute DOMString vendorSub; // constant ""
};

partial interface mixin NavigatorID {
 [Exposed=Window] boolean taintEnabled(); // constant false
 [Exposed=Window] readonly attribute DOMString oscpu;
};

interface mixin NavigatorLanguage {
 readonly attribute DOMString language;
 readonly attribute FrozenArray<DOMString> languages;
};

interface mixin NavigatorOnLine {
 readonly attribute boolean onLine;
};

interface mixin NavigatorContentUtils {
 [SecureContext] undefined registerProtocolHandler(DOMString scheme, USVString url);
 [SecureContext] undefined unregisterProtocolHandler(DOMString scheme, USVString url);
};

interface mixin NavigatorCookies {
 readonly attribute boolean cookieEnabled;
};

interface mixin NavigatorPlugins {
 [SameObject] readonly attribute PluginArray plugins;
 [SameObject] readonly attribute MimeTypeArray mimeTypes;
 boolean javaEnabled();
 readonly attribute boolean pdfViewerEnabled;
};

[Exposed=Window,
LegacyUnenumerableNamedProperties]
interface PluginArray {
 undefined refresh();
 readonly attribute unsigned long length;
 getter Plugin? item(unsigned long index);
 getter Plugin? namedItem(DOMString name);
};

[Exposed=Window,
LegacyUnenumerableNamedProperties]
interface MimeTypeArray {
 readonly attribute unsigned long length;
 getter MimeType? item(unsigned long index);
 getter MimeType? namedItem(DOMString name);
};

[Exposed=Window,
LegacyUnenumerableNamedProperties]
interface Plugin {
 readonly attribute DOMString name;
 readonly attribute DOMString description;
 readonly attribute DOMString filename;
 readonly attribute unsigned long length;
 getter MimeType? item(unsigned long index);
 getter MimeType? namedItem(DOMString name);
};

[Exposed=Window]
interface MimeType {
 readonly attribute DOMString type;
 readonly attribute DOMString description;
 readonly attribute DOMString suffixes;
 readonly attribute Plugin enabledPlugin;
};

typedef (Uint8ClampedArray or Float16Array) ImageDataArray;

enum ImageDataPixelFormat { "rgba-unorm8", "rgba-float16" };

dictionary ImageDataSettings {
 PredefinedColorSpace colorSpace;
 ImageDataPixelFormat pixelFormat = "rgba-unorm8";
};

[Exposed=(Window,Worker),
Serializable]
interface ImageData {
 constructor(unsigned long sw, unsigned long sh, optional ImageDataSettings settings = {});
 constructor(ImageDataArray data, unsigned long sw, optional unsigned long sh, optional ImageDataSettings settings = {});

 readonly attribute unsigned long width;
 readonly attribute unsigned long height;
 readonly attribute ImageDataArray data;
 readonly attribute ImageDataPixelFormat pixelFormat;
 readonly attribute PredefinedColorSpace colorSpace;
};

[Exposed=(Window,Worker), Serializable, Transferable]
interface ImageBitmap {
 readonly attribute unsigned long width;
 readonly attribute unsigned long height;
 undefined close();
};

typedef (CanvasImageSource or
        Blob or
        ImageData) ImageBitmapSource;

enum ImageOrientation { "from-image", "flipY" };
enum PremultiplyAlpha { "none", "premultiply", "default" };
enum ColorSpaceConversion { "none", "default" };
enum ResizeQuality { "pixelated", "low", "medium", "high" };

dictionary ImageBitmapOptions {
 ImageOrientation imageOrientation = "from-image";
 PremultiplyAlpha premultiplyAlpha = "default";
 ColorSpaceConversion colorSpaceConversion = "default";
 [EnforceRange] unsigned long resizeWidth;
 [EnforceRange] unsigned long resizeHeight;
 ResizeQuality resizeQuality = "low";
};

callback FrameRequestCallback = undefined (DOMHighResTimeStamp time);

interface mixin AnimationFrameProvider {
 unsigned long requestAnimationFrame(FrameRequestCallback callback);
 undefined cancelAnimationFrame(unsigned long handle);
};
Window includes AnimationFrameProvider;
DedicatedWorkerGlobalScope includes AnimationFrameProvider;

[Exposed=(Window,Worker,AudioWorklet)]
interface MessageEvent : Event {
 constructor(DOMString type, optional MessageEventInit eventInitDict = {});

 readonly attribute any data;
 readonly attribute USVString origin;
 readonly attribute DOMString lastEventId;
 readonly attribute MessageEventSource? source;
 readonly attribute FrozenArray<MessagePort> ports;

 undefined 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 = []);
};

dictionary MessageEventInit : EventInit {
 any data = null;
 USVString origin = "";
 DOMString lastEventId = "";
 MessageEventSource? source = null;
 sequence<MessagePort> ports = [];
};

typedef (WindowProxy or MessagePort or ServiceWorker) MessageEventSource;

[Exposed=(Window,Worker)]
interface EventSource : EventTarget {
 constructor(USVString url, optional EventSourceInit eventSourceInitDict = {});

 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;
 readonly attribute unsigned short readyState;

 // networking
 attribute EventHandler onopen;
 attribute EventHandler onmessage;
 attribute EventHandler onerror;
 undefined close();
};

dictionary EventSourceInit {
 boolean withCredentials = false;
};

[Exposed=(Window,Worker)]
interface MessageChannel {
 constructor();

 readonly attribute MessagePort port1;
 readonly attribute MessagePort port2;
};

interface mixin MessageEventTarget {
 attribute EventHandler onmessage;
 attribute EventHandler onmessageerror;
};

[Exposed=(Window,Worker,AudioWorklet), Transferable]
interface MessagePort : EventTarget {
 undefined postMessage(any message, sequence<object> transfer);
 undefined postMessage(any message, optional StructuredSerializeOptions options = {});
 undefined start();
 undefined close();

 // event handlers
 attribute EventHandler onclose;
};

MessagePort includes MessageEventTarget;

dictionary StructuredSerializeOptions {
 sequence<object> transfer = [];
};

[Exposed=(Window,Worker)]
interface BroadcastChannel : EventTarget {
 constructor(DOMString name);

 readonly attribute DOMString name;
 undefined postMessage(any message);
 undefined close();
 attribute EventHandler onmessage;
 attribute EventHandler onmessageerror;
};

[Exposed=Worker]
interface WorkerGlobalScope : EventTarget {
 readonly attribute WorkerGlobalScope self;
 readonly attribute WorkerLocation location;
 readonly attribute WorkerNavigator navigator;
 undefined importScripts((TrustedScriptURL or USVString)... urls);

 attribute OnErrorEventHandler onerror;
 attribute EventHandler onlanguagechange;
 attribute EventHandler onoffline;
 attribute EventHandler ononline;
 attribute EventHandler onrejectionhandled;
 attribute EventHandler onunhandledrejection;
};

[Global=(Worker,DedicatedWorker),Exposed=DedicatedWorker]
interface DedicatedWorkerGlobalScope : WorkerGlobalScope {
 [Replaceable] readonly attribute DOMString name;

 undefined postMessage(any message, sequence<object> transfer);
 undefined postMessage(any message, optional StructuredSerializeOptions options = {});

 undefined close();
};

DedicatedWorkerGlobalScope includes MessageEventTarget;

[Global=(Worker,SharedWorker),Exposed=SharedWorker]
interface SharedWorkerGlobalScope : WorkerGlobalScope {
 [Replaceable] readonly attribute DOMString name;

 undefined close();

 attribute EventHandler onconnect;
};

interface mixin AbstractWorker {
 attribute EventHandler onerror;
};

[Exposed=(Window,DedicatedWorker,SharedWorker)]
interface Worker : EventTarget {
 constructor((TrustedScriptURL or USVString) scriptURL, optional WorkerOptions options = {});

 undefined terminate();

 undefined postMessage(any message, sequence<object> transfer);
 undefined postMessage(any message, optional StructuredSerializeOptions options = {});
};

dictionary WorkerOptions {
 DOMString name = "";
 WorkerType type = "classic";
 RequestCredentials credentials = "same-origin"; // credentials is only used if type is "module"
};

enum WorkerType { "classic", "module" };

Worker includes AbstractWorker;
Worker includes MessageEventTarget;

[Exposed=Window]
interface SharedWorker : EventTarget {
 constructor((TrustedScriptURL or USVString) scriptURL, optional (DOMString or WorkerOptions) options = {});

 readonly attribute MessagePort port;
};
SharedWorker includes AbstractWorker;

interface mixin NavigatorConcurrentHardware {
 readonly attribute unsigned long long hardwareConcurrency;
};

[Exposed=Worker]
interface WorkerNavigator {};
WorkerNavigator includes NavigatorID;
WorkerNavigator includes NavigatorLanguage;
WorkerNavigator includes NavigatorOnLine;
WorkerNavigator includes NavigatorConcurrentHardware;

[Exposed=Worker]
interface WorkerLocation {
 stringifier readonly attribute USVString href;
 readonly attribute USVString origin;
 readonly attribute USVString protocol;
 readonly attribute USVString host;
 readonly attribute USVString hostname;
 readonly attribute USVString port;
 readonly attribute USVString pathname;
 readonly attribute USVString search;
 readonly attribute USVString hash;
};

[Exposed=Worklet, SecureContext]
interface WorkletGlobalScope {};

[Exposed=Window, SecureContext]
interface Worklet {
 [NewObject] Promise<undefined> addModule(USVString moduleURL, optional WorkletOptions options = {});
};

dictionary WorkletOptions {
 RequestCredentials credentials = "same-origin";
};

[Exposed=Window]
interface Storage {
 readonly attribute unsigned long length;
 DOMString? key(unsigned long index);
 getter DOMString? getItem(DOMString key);
 setter undefined setItem(DOMString key, DOMString value);
 deleter undefined removeItem(DOMString key);
 undefined clear();
};

interface mixin WindowSessionStorage {
 readonly attribute Storage sessionStorage;
};
Window includes WindowSessionStorage;

interface mixin WindowLocalStorage {
 readonly attribute Storage localStorage;
};
Window includes WindowLocalStorage;

[Exposed=Window]
interface StorageEvent : Event {
 constructor(DOMString type, optional StorageEventInit eventInitDict = {});

 readonly attribute DOMString? key;
 readonly attribute DOMString? oldValue;
 readonly attribute DOMString? newValue;
 readonly attribute USVString url;
 readonly attribute Storage? storageArea;

 undefined 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);
};

dictionary StorageEventInit : EventInit {
 DOMString? key = null;
 DOMString? oldValue = null;
 DOMString? newValue = null;
 USVString url = "";
 Storage? storageArea = null;
};

[Exposed=Window]
interface HTMLMarqueeElement : HTMLElement {
 [HTMLConstructor] constructor();

 [CEReactions, Reflect] attribute DOMString behavior;
 [CEReactions, Reflect] attribute DOMString bgColor;
 [CEReactions, Reflect] attribute DOMString direction;
 [CEReactions, Reflect] attribute DOMString height;
 [CEReactions, Reflect] attribute unsigned long hspace;
 [CEReactions] attribute long loop;
 [CEReactions, Reflect, ReflectDefault=6] attribute unsigned long scrollAmount;
 [CEReactions, Reflect, ReflectDefault=85] attribute unsigned long scrollDelay;
 [CEReactions, Reflect] attribute boolean trueSpeed;
 [CEReactions, Reflect] attribute unsigned long vspace;
 [CEReactions, Reflect] attribute DOMString width;

 undefined start();
 undefined stop();
};

[Exposed=Window]
interface HTMLFrameSetElement : HTMLElement {
 [HTMLConstructor] constructor();

 [CEReactions, Reflect] attribute DOMString cols;
 [CEReactions, Reflect] attribute DOMString rows;
};
HTMLFrameSetElement includes WindowEventHandlers;

[Exposed=Window]
interface HTMLFrameElement : HTMLElement {
 [HTMLConstructor] constructor();

 [CEReactions, Reflect] attribute DOMString name;
 [CEReactions, Reflect] attribute DOMString scrolling;
 [CEReactions, ReflectURL] attribute USVString src;
 [CEReactions, Reflect] attribute DOMString frameBorder;
 [CEReactions, ReflectURL] attribute USVString longDesc;
 [CEReactions, Reflect] attribute boolean noResize;
 readonly attribute Document? contentDocument;
 readonly attribute WindowProxy? contentWindow;

 [CEReactions, Reflect] attribute [LegacyNullToEmptyString] DOMString marginHeight;
 [CEReactions, Reflect] attribute [LegacyNullToEmptyString] DOMString marginWidth;
};

partial interface HTMLAnchorElement {
 [CEReactions, Reflect] attribute DOMString coords;
 [CEReactions, Reflect] attribute DOMString charset;
 [CEReactions, Reflect] attribute DOMString name;
 [CEReactions, Reflect] attribute DOMString rev;
 [CEReactions, Reflect] attribute DOMString shape;
};

partial interface HTMLAreaElement {
 [CEReactions, Reflect] attribute boolean noHref;
};

partial interface HTMLBodyElement {
 [CEReactions, Reflect] attribute [LegacyNullToEmptyString] DOMString text;
 [CEReactions, Reflect] attribute [LegacyNullToEmptyString] DOMString link;
 [CEReactions, Reflect] attribute [LegacyNullToEmptyString] DOMString vLink;
 [CEReactions, Reflect] attribute [LegacyNullToEmptyString] DOMString aLink;
 [CEReactions, Reflect] attribute [LegacyNullToEmptyString] DOMString bgColor;
 [CEReactions, Reflect] attribute DOMString background;
};

partial interface HTMLBRElement {
 [CEReactions, Reflect] attribute DOMString clear;
};

partial interface HTMLTableCaptionElement {
 [CEReactions, Reflect] attribute DOMString align;
};

partial interface HTMLTableColElement {
 [CEReactions, Reflect] attribute DOMString align;
 [CEReactions, Reflect="char"] attribute DOMString ch;
 [CEReactions, Reflect="charoff"] attribute DOMString chOff;
 [CEReactions, Reflect] attribute DOMString vAlign;
 [CEReactions, Reflect] attribute DOMString width;
};

[Exposed=Window]
interface HTMLDirectoryElement : HTMLElement {
 [HTMLConstructor] constructor();

 [CEReactions, Reflect] attribute boolean compact;
};

partial interface HTMLDivElement {
 [CEReactions, Reflect] attribute DOMString align;
};

partial interface HTMLDListElement {
 [CEReactions, Reflect] attribute boolean compact;
};

partial interface HTMLEmbedElement {
 [CEReactions, Reflect] attribute DOMString align;
 [CEReactions, Reflect] attribute DOMString name;
};

[Exposed=Window]
interface HTMLFontElement : HTMLElement {
 [HTMLConstructor] constructor();

 [CEReactions, Reflect] attribute [LegacyNullToEmptyString] DOMString color;
 [CEReactions, Reflect] attribute DOMString face;
 [CEReactions, Reflect] attribute DOMString size;
};

partial interface HTMLHeadingElement {
 [CEReactions, Reflect] attribute DOMString align;
};

partial interface HTMLHRElement {
 [CEReactions, Reflect] attribute DOMString align;
 [CEReactions, Reflect] attribute DOMString color;
 [CEReactions, Reflect] attribute boolean noShade;
 [CEReactions, Reflect] attribute DOMString size;
 [CEReactions, Reflect] attribute DOMString width;
};

partial interface HTMLHtmlElement {
 [CEReactions, Reflect] attribute DOMString version;
};

partial interface HTMLIFrameElement {
 [CEReactions, Reflect] attribute DOMString align;
 [CEReactions, Reflect] attribute DOMString scrolling;
 [CEReactions, Reflect] attribute DOMString frameBorder;
 [CEReactions, ReflectURL] attribute USVString longDesc;

 [CEReactions, Reflect] attribute [LegacyNullToEmptyString] DOMString marginHeight;
 [CEReactions, Reflect] attribute [LegacyNullToEmptyString] DOMString marginWidth;
};

partial interface HTMLImageElement {
 [CEReactions, Reflect] attribute DOMString name;
 [CEReactions, ReflectURL] attribute USVString lowsrc;
 [CEReactions, Reflect] attribute DOMString align;
 [CEReactions, Reflect] attribute unsigned long hspace;
 [CEReactions, Reflect] attribute unsigned long vspace;
 [CEReactions, ReflectURL] attribute USVString longDesc;

 [CEReactions, Reflect] attribute [LegacyNullToEmptyString] DOMString border;
};

partial interface HTMLInputElement {
 [CEReactions, Reflect] attribute DOMString align;
 [CEReactions, Reflect] attribute DOMString useMap;
};

partial interface HTMLLegendElement {
 [CEReactions, Reflect] attribute DOMString align;
};

partial interface HTMLLIElement {
 [CEReactions, Reflect] attribute DOMString type;
};

partial interface HTMLLinkElement {
 [CEReactions, Reflect] attribute DOMString charset;
 [CEReactions, Reflect] attribute DOMString rev;
 [CEReactions, Reflect] attribute DOMString target;
};

partial interface HTMLMenuElement {
 [CEReactions, Reflect] attribute boolean compact;
};

partial interface HTMLMetaElement {
 [CEReactions, Reflect] attribute DOMString scheme;
};

partial interface HTMLObjectElement {
 [CEReactions, Reflect] attribute DOMString align;
 [CEReactions, Reflect] attribute DOMString archive;
 [CEReactions, Reflect] attribute DOMString code;
 [CEReactions, Reflect] attribute boolean declare;
 [CEReactions, Reflect] attribute unsigned long hspace;
 [CEReactions, Reflect] attribute DOMString standby;
 [CEReactions, Reflect] attribute unsigned long vspace;
 [CEReactions, ReflectURL] attribute DOMString codeBase;
 [CEReactions, Reflect] attribute DOMString codeType;
 [CEReactions, Reflect] attribute DOMString useMap;

 [CEReactions, Reflect] attribute [LegacyNullToEmptyString] DOMString border;
};

partial interface HTMLOListElement {
 [CEReactions, Reflect] attribute boolean compact;
};

partial interface HTMLParagraphElement {
 [CEReactions, Reflect] attribute DOMString align;
};

[Exposed=Window]
interface HTMLParamElement : HTMLElement {
 [HTMLConstructor] constructor();

 [CEReactions, Reflect] attribute DOMString name;
 [CEReactions, Reflect] attribute DOMString value;
 [CEReactions, Reflect] attribute DOMString type;
 [CEReactions, Reflect] attribute DOMString valueType;
};

partial interface HTMLPreElement {
 [CEReactions, Reflect] attribute long width;
};

partial interface HTMLStyleElement {
 [CEReactions, Reflect] attribute DOMString type;
};

partial interface HTMLScriptElement {
 [CEReactions, Reflect] attribute DOMString charset;
 [CEReactions, Reflect] attribute DOMString event;
 [CEReactions, Reflect="for"] attribute DOMString htmlFor;
};

partial interface HTMLTableElement {
 [CEReactions, Reflect] attribute DOMString align;
 [CEReactions, Reflect] attribute DOMString border;
 [CEReactions, Reflect] attribute DOMString frame;
 [CEReactions, Reflect] attribute DOMString rules;
 [CEReactions, Reflect] attribute DOMString summary;
 [CEReactions, Reflect] attribute DOMString width;

 [CEReactions, Reflect] attribute [LegacyNullToEmptyString] DOMString bgColor;
 [CEReactions, Reflect] attribute [LegacyNullToEmptyString] DOMString cellPadding;
 [CEReactions, Reflect] attribute [LegacyNullToEmptyString] DOMString cellSpacing;
};

partial interface HTMLTableSectionElement {
 [CEReactions, Reflect] attribute DOMString align;
 [CEReactions, Reflect="char"] attribute DOMString ch;
 [CEReactions, Reflect="charoff"] attribute DOMString chOff;
 [CEReactions, Reflect] attribute DOMString vAlign;
};

partial interface HTMLTableCellElement {
 [CEReactions, Reflect] attribute DOMString align;
 [CEReactions, Reflect] attribute DOMString axis;
 [CEReactions, Reflect] attribute DOMString height;
 [CEReactions, Reflect] attribute DOMString width;

 [CEReactions, Reflect="char"] attribute DOMString ch;
 [CEReactions, Reflect="charoff"] attribute DOMString chOff;
 [CEReactions, Reflect] attribute boolean noWrap;
 [CEReactions, Reflect] attribute DOMString vAlign;

 [CEReactions, Reflect] attribute [LegacyNullToEmptyString] DOMString bgColor;
};

partial interface HTMLTableRowElement {
 [CEReactions, Reflect] attribute DOMString align;
 [CEReactions, Reflect="char"] attribute DOMString ch;
 [CEReactions, Reflect="charoff"] attribute DOMString chOff;
 [CEReactions, Reflect] attribute DOMString vAlign;

 [CEReactions, Reflect] attribute [LegacyNullToEmptyString] DOMString bgColor;
};

partial interface HTMLUListElement {
 [CEReactions, Reflect] attribute boolean compact;
 [CEReactions, Reflect] attribute DOMString type;
};

partial interface Document {
 [CEReactions] attribute [LegacyNullToEmptyString] DOMString fgColor;
 [CEReactions] attribute [LegacyNullToEmptyString] DOMString linkColor;
 [CEReactions] attribute [LegacyNullToEmptyString] DOMString vlinkColor;
 [CEReactions] attribute [LegacyNullToEmptyString] DOMString alinkColor;
 [CEReactions] attribute [LegacyNullToEmptyString] DOMString bgColor;

 [SameObject] readonly attribute HTMLCollection anchors;
 [SameObject] readonly attribute HTMLCollection applets;

 undefined clear();
 undefined captureEvents();
 undefined releaseEvents();

 [SameObject] readonly attribute HTMLAllCollection all;
};

partial interface Window {
 undefined captureEvents();
 undefined releaseEvents();

 [Replaceable, SameObject] readonly attribute External external;
};

[Exposed=Window]
interface External {
 undefined AddSearchProvider();
 undefined IsSearchProviderInstalled();
};