script: Move code generation and webidl files to new script_bindings crate. (#35157)

Signed-off-by: Josh Matthews <josh@joshmatthews.net>

components/script_bindings/webidls/ANGLEInstancedArrays.webidl

@@ -0,0 +1,15 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/*
+ * WebGL IDL definitions from the Khronos specification:
+ * https://www.khronos.org/registry/webgl/extensions/ANGLE_instanced_arrays/
+ */
+
+[LegacyNoInterfaceObject, Exposed=Window]
+interface ANGLEInstancedArrays {
+    const GLenum VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE = 0x88FE;
+    undefined drawArraysInstancedANGLE(GLenum mode, GLint first, GLsizei count, GLsizei primcount);
+    undefined drawElementsInstancedANGLE(GLenum mode, GLsizei count, GLenum type, GLintptr offset, GLsizei primcount);
+    undefined vertexAttribDivisorANGLE(GLuint index, GLuint divisor);
+};

components/script_bindings/webidls/ARIAMixin.webidl

@@ -0,0 +1,57 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/*
+ * The origin of this IDL file is
+ * https://w3c.github.io/aria/#dom-ariamixin
+ *
+ * Copyright © 2012 W3C® (MIT, ERCIM, Keio), All Rights Reserved. W3C
+ * liability, trademark and document use rules apply.
+ */
+
+interface mixin ARIAMixin {
+  [CEReactions] attribute DOMString? role;
+  [CEReactions] attribute DOMString? ariaAtomic;
+  [CEReactions] attribute DOMString? ariaAutoComplete;
+  [CEReactions] attribute DOMString? ariaBrailleLabel;
+  [CEReactions] attribute DOMString? ariaBrailleRoleDescription;
+  [CEReactions] attribute DOMString? ariaBusy;
+  [CEReactions] attribute DOMString? ariaChecked;
+  [CEReactions] attribute DOMString? ariaColCount;
+  [CEReactions] attribute DOMString? ariaColIndex;
+  [CEReactions] attribute DOMString? ariaColIndexText;
+  [CEReactions] attribute DOMString? ariaColSpan;
+  [CEReactions] attribute DOMString? ariaCurrent;
+  [CEReactions] attribute DOMString? ariaDescription;
+  [CEReactions] attribute DOMString? ariaDisabled;
+  [CEReactions] attribute DOMString? ariaExpanded;
+  [CEReactions] attribute DOMString? ariaHasPopup;
+  [CEReactions] attribute DOMString? ariaHidden;
+  [CEReactions] attribute DOMString? ariaInvalid;
+  [CEReactions] attribute DOMString? ariaKeyShortcuts;
+  [CEReactions] attribute DOMString? ariaLabel;
+  [CEReactions] attribute DOMString? ariaLevel;
+  [CEReactions] attribute DOMString? ariaLive;
+  [CEReactions] attribute DOMString? ariaModal;
+  [CEReactions] attribute DOMString? ariaMultiLine;
+  [CEReactions] attribute DOMString? ariaMultiSelectable;
+  [CEReactions] attribute DOMString? ariaOrientation;
+  [CEReactions] attribute DOMString? ariaPlaceholder;
+  [CEReactions] attribute DOMString? ariaPosInSet;
+  [CEReactions] attribute DOMString? ariaPressed;
+  [CEReactions] attribute DOMString? ariaReadOnly;
+  [CEReactions] attribute DOMString? ariaRelevant;
+  [CEReactions] attribute DOMString? ariaRequired;
+  [CEReactions] attribute DOMString? ariaRoleDescription;
+  [CEReactions] attribute DOMString? ariaRowCount;
+  [CEReactions] attribute DOMString? ariaRowIndex;
+  [CEReactions] attribute DOMString? ariaRowIndexText;
+  [CEReactions] attribute DOMString? ariaRowSpan;
+  [CEReactions] attribute DOMString? ariaSelected;
+  [CEReactions] attribute DOMString? ariaSetSize;
+  [CEReactions] attribute DOMString? ariaSort;
+  [CEReactions] attribute DOMString? ariaValueMax;
+  [CEReactions] attribute DOMString? ariaValueMin;
+  [CEReactions] attribute DOMString? ariaValueNow;
+  [CEReactions] attribute DOMString? ariaValueText;
+};

components/script_bindings/webidls/AbortController.webidl

@@ -0,0 +1,13 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+// https://dom.spec.whatwg.org/#interface-abortcontroller
+[Exposed=*, Pref="dom_abort_controller_enabled"]
+interface AbortController {
+  constructor();
+
+  //[SameObject] readonly attribute AbortSignal signal;
+
+  undefined abort(optional any reason);
+};

components/script_bindings/webidls/AbstractRange.webidl

@@ -0,0 +1,21 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/*
+ * The origin of this IDL file is
+ * https://dom.spec.whatwg.org/#interface-abstractrange
+ */
+
+[Exposed=Window]
+interface AbstractRange {
+  [Pure]
+  readonly attribute Node startContainer;
+  [Pure]
+  readonly attribute unsigned long startOffset;
+  [Pure]
+  readonly attribute Node endContainer;
+  [Pure]
+  readonly attribute unsigned long endOffset;
+  [Pure]
+  readonly attribute boolean collapsed;
+};

components/script_bindings/webidls/ActivatableElement.webidl

@@ -0,0 +1,15 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+// Interface for testing element activation
+// This interface is entirely internal to Servo, and should not be accessible to
+// web pages.
+[Exposed=(Window,Worker)]
+interface mixin ActivatableElement {
+  [Throws, Pref="dom_testing_element_activation_enabled"]
+  undefined enterFormalActivationState();
+
+  [Throws, Pref="dom_testing_element_activation_enabled"]
+  undefined exitFormalActivationState();
+};

components/script_bindings/webidls/AnalyserNode.webidl

@@ -0,0 +1,28 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/*
+ * The origin of this IDL file is
+ * https://webaudio.github.io/web-audio-api/#analysernode
+ */
+
+dictionary AnalyserOptions : AudioNodeOptions {
+  unsigned long fftSize = 2048;
+  double maxDecibels = -30;
+  double minDecibels = -100;
+  double smoothingTimeConstant = 0.8;
+};
+
+[Exposed=Window]
+interface AnalyserNode : AudioNode {
+  [Throws] constructor(BaseAudioContext context, optional AnalyserOptions options = {});
+  undefined getFloatFrequencyData (Float32Array array);
+  undefined getByteFrequencyData (Uint8Array array);
+  undefined getFloatTimeDomainData (Float32Array array);
+  undefined getByteTimeDomainData (Uint8Array array);
+  [SetterThrows] attribute unsigned long fftSize;
+  readonly attribute unsigned long frequencyBinCount;
+  [SetterThrows] attribute double minDecibels;
+  [SetterThrows] attribute double maxDecibels;
+  [SetterThrows] attribute double smoothingTimeConstant;
+};

components/script_bindings/webidls/AnimationEvent.webidl

@@ -0,0 +1,26 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * The origin of this IDL file is
+ * http://www.w3.org/TR/css3-animations/#animation-events-
+ * http://dev.w3.org/csswg/css3-animations/#animation-events-
+ *
+ * Copyright © 2012 W3C® (MIT, ERCIM, Keio), All Rights Reserved. W3C
+ * liability, trademark and document use rules apply.
+ */
+
+[Exposed=Window]
+interface AnimationEvent : Event {
+  constructor(DOMString type, optional AnimationEventInit eventInitDict = {});
+
+  readonly attribute DOMString animationName;
+  readonly attribute float     elapsedTime;
+  readonly attribute DOMString pseudoElement;
+};
+
+dictionary AnimationEventInit : EventInit {
+  DOMString animationName = "";
+  float elapsedTime = 0;
+  DOMString pseudoElement = "";
+};

components/script_bindings/webidls/Attr.webidl

@@ -0,0 +1,28 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/*
+ * The origin of this IDL file is
+ * https://dom.spec.whatwg.org/#interface-attr
+ *
+ */
+
+[Exposed=Window]
+interface Attr : Node {
+  [Constant]
+  readonly attribute DOMString? namespaceURI;
+  [Constant]
+  readonly attribute DOMString? prefix;
+  [Constant]
+  readonly attribute DOMString localName;
+  [Constant]
+  readonly attribute DOMString name;
+  [CEReactions, Pure]
+           attribute DOMString value;
+
+  [Pure]
+  readonly attribute Element? ownerElement;
+
+  [Constant]
+  readonly attribute boolean specified; // useless; always returns true
+};

components/script_bindings/webidls/AudioBuffer.webidl

@@ -0,0 +1,29 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/*
+ * The origin of this IDL file is
+ * https://webaudio.github.io/web-audio-api/#audiobuffer
+ */
+
+dictionary AudioBufferOptions {
+  unsigned long numberOfChannels = 1;
+  required unsigned long length;
+  required float sampleRate;
+};
+
+[Exposed=Window]
+interface AudioBuffer {
+  [Throws] constructor(AudioBufferOptions options);
+  readonly attribute float sampleRate;
+  readonly attribute unsigned long length;
+  readonly attribute double duration;
+  readonly attribute unsigned long numberOfChannels;
+  [Throws] Float32Array getChannelData(unsigned long channel);
+  [Throws] undefined copyFromChannel(Float32Array destination,
+                                unsigned long channelNumber,
+                                optional unsigned long startInChannel = 0);
+  [Throws] undefined copyToChannel(Float32Array source,
+                              unsigned long channelNumber,
+                              optional unsigned long startInChannel = 0);
+};

components/script_bindings/webidls/AudioBufferSourceNode.webidl

@@ -0,0 +1,30 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/*
+ * The origin of this IDL file is
+ * https://webaudio.github.io/web-audio-api/#AudioBufferSourceNode
+ */
+
+dictionary AudioBufferSourceOptions {
+  AudioBuffer? buffer;
+  float detune = 0;
+  boolean loop = false;
+  double loopEnd = 0;
+  double loopStart = 0;
+  float playbackRate = 1;
+};
+
+[Exposed=Window]
+interface AudioBufferSourceNode : AudioScheduledSourceNode {
+  [Throws] constructor(BaseAudioContext context, optional AudioBufferSourceOptions options = {});
+  [Throws] attribute AudioBuffer? buffer;
+  readonly attribute AudioParam playbackRate;
+  readonly attribute AudioParam detune;
+  attribute boolean loop;
+  attribute double loopStart;
+  attribute double loopEnd;
+  [Throws] undefined start(optional double when = 0,
+                      optional double offset,
+                      optional double duration);
+};

components/script_bindings/webidls/AudioContext.webidl

@@ -0,0 +1,40 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/*
+ * The origin of this IDL file is
+ * https://webaudio.github.io/web-audio-api/#dom-audiocontext
+ */
+
+enum AudioContextLatencyCategory {
+  "balanced",
+  "interactive",
+  "playback"
+};
+
+dictionary AudioContextOptions {
+  (AudioContextLatencyCategory or double) latencyHint = "interactive";
+  float sampleRate;
+};
+
+dictionary AudioTimestamp {
+  double contextTime;
+  DOMHighResTimeStamp performanceTime;
+};
+
+[Exposed=Window]
+interface AudioContext : BaseAudioContext {
+  [Throws] constructor(optional AudioContextOptions contextOptions = {});
+  readonly attribute double baseLatency;
+  readonly attribute double outputLatency;
+
+  AudioTimestamp getOutputTimestamp();
+
+  Promise<undefined> suspend();
+  Promise<undefined> close();
+
+  [Throws] MediaElementAudioSourceNode createMediaElementSource(HTMLMediaElement mediaElement);
+  [Throws] MediaStreamAudioSourceNode createMediaStreamSource(MediaStream mediaStream);
+  [Throws] MediaStreamTrackAudioSourceNode createMediaStreamTrackSource(MediaStreamTrack mediaStreamTrack);
+  [Throws] MediaStreamAudioDestinationNode createMediaStreamDestination();
+};

components/script_bindings/webidls/AudioDestinationNode.webidl

@@ -0,0 +1,12 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/*
+ * The origin of this IDL file is
+ * https://webaudio.github.io/web-audio-api/#dom-audiodestinationnode
+ */
+
+[Exposed=Window]
+interface AudioDestinationNode : AudioNode {
+  readonly attribute unsigned long maxChannelCount;
+};

components/script_bindings/webidls/AudioListener.webidl

@@ -0,0 +1,22 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/*
+ * The origin of this IDL file is
+ * https://webaudio.github.io/web-audio-api/#audiolistener
+ */
+
+[Exposed=Window]
+interface AudioListener {
+  readonly attribute AudioParam positionX;
+  readonly attribute AudioParam positionY;
+  readonly attribute AudioParam positionZ;
+  readonly attribute AudioParam forwardX;
+  readonly attribute AudioParam forwardY;
+  readonly attribute AudioParam forwardZ;
+  readonly attribute AudioParam upX;
+  readonly attribute AudioParam upY;
+  readonly attribute AudioParam upZ;
+  [Throws] AudioListener setPosition (float x, float y, float z);
+  [Throws] AudioListener setOrientation (float x, float y, float z, float xUp, float yUp, float zUp);
+};

components/script_bindings/webidls/AudioNode.webidl

@@ -0,0 +1,62 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/*
+ * The origin of this IDL file is
+ * https://webaudio.github.io/web-audio-api/#dom-audionode
+ */
+
+enum ChannelCountMode {
+  "max",
+  "clamped-max",
+  "explicit"
+};
+
+enum ChannelInterpretation {
+  "speakers",
+  "discrete"
+};
+
+dictionary AudioNodeOptions {
+   unsigned long         channelCount;
+   ChannelCountMode      channelCountMode;
+   ChannelInterpretation channelInterpretation;
+};
+
+[Exposed=Window]
+interface AudioNode : EventTarget {
+  [Throws]
+  AudioNode connect(AudioNode destinationNode,
+                    optional unsigned long output = 0,
+                    optional unsigned long input = 0);
+  [Throws]
+  undefined connect(AudioParam destinationParam,
+               optional unsigned long output = 0);
+  [Throws]
+  undefined disconnect();
+  [Throws]
+  undefined disconnect(unsigned long output);
+  [Throws]
+  undefined disconnect(AudioNode destination);
+  [Throws]
+  undefined disconnect(AudioNode destination, unsigned long output);
+  [Throws]
+  undefined disconnect(AudioNode destination,
+                  unsigned long output,
+                  unsigned long input);
+  [Throws]
+  undefined disconnect(AudioParam destination);
+  [Throws]
+  undefined disconnect(AudioParam destination, unsigned long output);
+
+  readonly attribute BaseAudioContext context;
+  readonly attribute unsigned long numberOfInputs;
+  readonly attribute unsigned long numberOfOutputs;
+
+  [SetterThrows]
+  attribute unsigned long channelCount;
+  [SetterThrows]
+  attribute ChannelCountMode channelCountMode;
+  [SetterThrows]
+  attribute ChannelInterpretation channelInterpretation;
+};

components/script_bindings/webidls/AudioParam.webidl

@@ -0,0 +1,32 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/*
+ * The origin of this IDL file is
+ * https://webaudio.github.io/web-audio-api/#dom-audioparam
+ */
+
+enum AutomationRate {
+  "a-rate",
+  "k-rate"
+};
+
+[Exposed=Window]
+interface AudioParam {
+             attribute float value;
+             [SetterThrows] attribute AutomationRate automationRate;
+    readonly attribute float defaultValue;
+    readonly attribute float minValue;
+    readonly attribute float maxValue;
+    [Throws] AudioParam setValueAtTime(float value, double startTime);
+    [Throws] AudioParam linearRampToValueAtTime(float value, double endTime);
+    [Throws] AudioParam exponentialRampToValueAtTime(float value, double endTime);
+    [Throws] AudioParam setTargetAtTime(float target,
+                               double startTime,
+                               float timeConstant);
+    [Throws] AudioParam setValueCurveAtTime(sequence<float> values,
+                                   double startTime,
+                                   double duration);
+    [Throws] AudioParam cancelScheduledValues(double cancelTime);
+    [Throws] AudioParam cancelAndHoldAtTime(double cancelTime);
+};

components/script_bindings/webidls/AudioScheduledSourceNode.webidl

@@ -0,0 +1,14 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/*
+ * The origin of this IDL file is
+ * https://webaudio.github.io/web-audio-api/#AudioScheduledSourceNode
+ */
+
+[Exposed=Window]
+interface AudioScheduledSourceNode : AudioNode {
+  attribute EventHandler onended;
+  [Throws] undefined start(optional double when = 0);
+  [Throws] undefined stop(optional double when = 0);
+};

components/script_bindings/webidls/AudioTrack.webidl

@@ -0,0 +1,14 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+// https://html.spec.whatwg.org/multipage/#audiotrack
+
+[Exposed=Window]
+interface AudioTrack {
+  readonly attribute DOMString id;
+  readonly attribute DOMString kind;
+  readonly attribute DOMString label;
+  readonly attribute DOMString language;
+  attribute boolean enabled;
+};

components/script_bindings/webidls/AudioTrackList.webidl

@@ -0,0 +1,16 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+// https://html.spec.whatwg.org/multipage/#audiotracklist
+
+[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;
+};

components/script_bindings/webidls/BaseAudioContext.webidl

@@ -0,0 +1,55 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/*
+ * The origin of this IDL file is
+ * https://webaudio.github.io/web-audio-api/#BaseAudioContext
+ */
+
+enum AudioContextState {
+  "suspended",
+  "running",
+  "closed"
+};
+
+callback DecodeErrorCallback = undefined (DOMException error);
+callback DecodeSuccessCallback = undefined (AudioBuffer decodedData);
+
+[Exposed=Window]
+interface BaseAudioContext : EventTarget {
+  readonly attribute AudioDestinationNode destination;
+  readonly attribute float sampleRate;
+  readonly attribute double currentTime;
+  readonly attribute AudioListener listener;
+  readonly attribute AudioContextState  state;
+  Promise<undefined> resume();
+  attribute EventHandler onstatechange;
+  [Throws] AudioBuffer createBuffer(unsigned long numberOfChannels,
+                                    unsigned long length,
+                                    float sampleRate);
+  Promise<AudioBuffer> decodeAudioData(ArrayBuffer audioData,
+                                       optional DecodeSuccessCallback successCallback,
+                                       optional DecodeErrorCallback errorCallback);
+  [Throws] AudioBufferSourceNode createBufferSource();
+  [Throws] ConstantSourceNode createConstantSource();
+  // ScriptProcessorNode createScriptProcessor(optional unsigned long bufferSize = 0,
+  //                                           optional unsigned long numberOfInputChannels = 2,
+  //                                           optional unsigned long numberOfOutputChannels = 2);
+  [Throws] AnalyserNode createAnalyser();
+  [Throws]  GainNode createGain();
+  // DelayNode createDelay(optional double maxDelayTime = 1);
+  [Throws] BiquadFilterNode createBiquadFilter();
+  [Throws] IIRFilterNode createIIRFilter(sequence<double> feedforward,
+                                sequence<double> feedback);
+  // WaveShaperNode createWaveShaper();
+  [Throws] PannerNode createPanner();
+  [Throws] StereoPannerNode createStereoPanner();
+  // ConvolverNode createConvolver();
+  [Throws] ChannelSplitterNode createChannelSplitter(optional unsigned long numberOfOutputs = 6);
+  [Throws] ChannelMergerNode createChannelMerger(optional unsigned long numberOfInputs = 6);
+  // DynamicsCompressorNode createDynamicsCompressor();
+  [Throws]  OscillatorNode createOscillator();
+  // PeriodicWave createPeriodicWave(sequence<float> real,
+  //                                 sequence<float> imag,
+  //                                 optional PeriodicWaveConstraints constraints);
+};

components/script_bindings/webidls/BeforeUnloadEvent.webidl

@@ -0,0 +1,12 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/*
+ * For more information on this interface please see
+ * https://html.spec.whatwg.org/multipage/#beforeunloadevent
+ */
+
+[Exposed=Window]
+interface BeforeUnloadEvent : Event {
+  attribute DOMString returnValue;
+};

components/script_bindings/webidls/BiquadFilterNode.webidl

@@ -0,0 +1,39 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/*
+ * The origin of this IDL file is
+ * https://webaudio.github.io/web-audio-api/#biquadfilternode
+ */
+
+enum BiquadFilterType {
+  "lowpass",
+  "highpass",
+  "bandpass",
+  "lowshelf",
+  "highshelf",
+  "peaking",
+  "notch",
+  "allpass"
+};
+
+dictionary BiquadFilterOptions : AudioNodeOptions {
+  BiquadFilterType type = "lowpass";
+  float Q = 1;
+  float detune = 0;
+  float frequency = 350;
+  float gain = 0;
+};
+
+[Exposed=Window]
+interface BiquadFilterNode : AudioNode {
+  [Throws] constructor(BaseAudioContext context, optional BiquadFilterOptions options = {});
+  attribute BiquadFilterType type;
+  readonly attribute AudioParam frequency;
+  readonly attribute AudioParam detune;
+  readonly attribute AudioParam Q;
+  readonly attribute AudioParam gain;
+  // the AudioParam model of https://github.com/servo/servo/issues/21659 needs to
+  // be implemented before we implement this
+  // void getFrequencyResponse (Float32Array frequencyHz, Float32Array magResponse, Float32Array phaseResponse);
+};

components/script_bindings/webidls/Blob.webidl

@@ -0,0 +1,29 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+// https://w3c.github.io/FileAPI/#blob
+
+[Exposed=(Window,Worker)]
+interface Blob {
+  [Throws] constructor(optional sequence<BlobPart> blobParts,
+    optional BlobPropertyBag options = {});
+
+  readonly attribute unsigned long long size;
+  readonly attribute DOMString type;
+
+  // slice Blob into byte-ranged chunks
+  Blob slice(optional [Clamp] long long start,
+             optional [Clamp] long long end,
+             optional DOMString contentType);
+
+  [NewObject, Throws] ReadableStream stream();
+  [NewObject] Promise<DOMString> text();
+  [NewObject] Promise<ArrayBuffer> arrayBuffer();
+};
+
+dictionary BlobPropertyBag {
+  DOMString type = "";
+};
+
+typedef (ArrayBuffer or ArrayBufferView or Blob or DOMString) BlobPart;

components/script_bindings/webidls/Bluetooth.webidl

@@ -0,0 +1,42 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+// https://webbluetoothcg.github.io/web-bluetooth/#bluetooth
+
+dictionary BluetoothDataFilterInit {
+  BufferSource dataPrefix;
+  BufferSource mask;
+};
+
+dictionary BluetoothLEScanFilterInit {
+  sequence<BluetoothServiceUUID> services;
+  DOMString name;
+  DOMString namePrefix;
+  // Maps unsigned shorts to BluetoothDataFilters.
+  record<DOMString, BluetoothDataFilterInit> manufacturerData;
+  // Maps BluetoothServiceUUIDs to BluetoothDataFilters.
+  record<DOMString, BluetoothDataFilterInit> serviceData;
+};
+
+dictionary RequestDeviceOptions {
+  sequence<BluetoothLEScanFilterInit> filters;
+  sequence<BluetoothServiceUUID> optionalServices = [];
+  boolean acceptAllDevices = false;
+};
+
+[Exposed=Window, Pref="dom_bluetooth_enabled"]
+interface Bluetooth : EventTarget {
+  [SecureContext]
+  Promise<boolean> getAvailability();
+  [SecureContext]
+  attribute EventHandler onavailabilitychanged;
+  // [SecureContext, SameObject]
+  // readonly attribute BluetoothDevice? referringDevice;
+  [SecureContext]
+  Promise<BluetoothDevice> requestDevice(optional RequestDeviceOptions options = {});
+};
+
+// Bluetooth includes BluetoothDeviceEventHandlers;
+// Bluetooth includes CharacteristicEventHandlers;
+// Bluetooth includes ServiceEventHandlers;

components/script_bindings/webidls/BluetoothAdvertisingEvent.webidl

@@ -0,0 +1,37 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+// https://webbluetoothcg.github.io/web-bluetooth/#advertising-events
+
+/*interface BluetoothManufacturerDataMap {
+  readonly maplike<unsigned short, DataView>;
+};
+interface BluetoothServiceDataMap {
+  readonly maplike<UUID, DataView>;
+};*/
+[Exposed=Window, Pref="dom_bluetooth_enabled"]
+interface BluetoothAdvertisingEvent : Event {
+  [Throws] constructor(DOMString type, BluetoothAdvertisingEventInit init);
+  [SameObject]
+  readonly attribute BluetoothDevice device;
+  // readonly attribute FrozenArray<UUID> uuids;
+  readonly attribute DOMString? name;
+  readonly attribute unsigned short? appearance;
+  readonly attribute byte? txPower;
+  readonly attribute byte? rssi;
+  // [SameObject]
+  // readonly attribute BluetoothManufacturerDataMap manufacturerData;
+  // [SameObject]
+  // readonly attribute BluetoothServiceDataMap serviceData;
+};
+dictionary BluetoothAdvertisingEventInit : EventInit {
+  required BluetoothDevice device;
+  // sequence<(DOMString or unsigned long)> uuids;
+  DOMString name;
+  unsigned short appearance;
+  byte txPower;
+  byte rssi;
+  // Map manufacturerData;
+  // Map serviceData;
+};

components/script_bindings/webidls/BluetoothCharacteristicProperties.webidl

@@ -0,0 +1,18 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+// https://webbluetoothcg.github.io/web-bluetooth/#characteristicproperties
+
+[Exposed=Window, Pref="dom_bluetooth_enabled"]
+interface BluetoothCharacteristicProperties {
+  readonly attribute boolean broadcast;
+  readonly attribute boolean read;
+  readonly attribute boolean writeWithoutResponse;
+  readonly attribute boolean write;
+  readonly attribute boolean notify;
+  readonly attribute boolean indicate;
+  readonly attribute boolean authenticatedSignedWrites;
+  readonly attribute boolean reliableWrite;
+  readonly attribute boolean writableAuxiliaries;
+};

components/script_bindings/webidls/BluetoothDevice.webidl

@@ -0,0 +1,25 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+// https://webbluetoothcg.github.io/web-bluetooth/#bluetoothdevice
+
+[Exposed=Window, Pref="dom_bluetooth_enabled"]
+interface BluetoothDevice : EventTarget {
+  readonly attribute DOMString id;
+  readonly attribute DOMString? name;
+  readonly attribute BluetoothRemoteGATTServer? gatt;
+
+  Promise<undefined> watchAdvertisements();
+  undefined unwatchAdvertisements();
+  readonly attribute boolean watchingAdvertisements;
+};
+
+interface mixin BluetoothDeviceEventHandlers {
+  attribute EventHandler ongattserverdisconnected;
+};
+
+// BluetoothDevice includes EventTarget;
+BluetoothDevice includes BluetoothDeviceEventHandlers;
+// BluetoothDevice includes CharacteristicEventHandlers;
+// BluetoothDevice includes ServiceEventHandlers;

components/script_bindings/webidls/BluetoothPermissionResult.webidl

@@ -0,0 +1,20 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+// https://webbluetoothcg.github.io/web-bluetooth/#bluetoothpermissionresult
+
+dictionary BluetoothPermissionDescriptor : PermissionDescriptor {
+  DOMString deviceId;
+  // These match RequestDeviceOptions.
+  sequence<BluetoothLEScanFilterInit> filters;
+  sequence<BluetoothServiceUUID> optionalServices = [];
+  boolean acceptAllDevices = false;
+};
+
+[Exposed=Window, Pref="dom_bluetooth_enabled"]
+interface BluetoothPermissionResult : PermissionStatus {
+  // attribute FrozenArray<BluetoothDevice> devices;
+  // Workaround until FrozenArray get implemented.
+  sequence<BluetoothDevice> devices();
+};

components/script_bindings/webidls/BluetoothRemoteGATTCharacteristic.webidl

@@ -0,0 +1,29 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+// https://webbluetoothcg.github.io/web-bluetooth/#bluetoothremotegattcharacteristic
+
+[Exposed=Window, Pref="dom_bluetooth_enabled"]
+interface BluetoothRemoteGATTCharacteristic : EventTarget {
+  [SameObject]
+  readonly attribute BluetoothRemoteGATTService service;
+  readonly attribute DOMString uuid;
+  readonly attribute BluetoothCharacteristicProperties properties;
+  readonly attribute ByteString? value;
+  Promise<BluetoothRemoteGATTDescriptor> getDescriptor(BluetoothDescriptorUUID descriptor);
+  Promise<sequence<BluetoothRemoteGATTDescriptor>>
+  getDescriptors(optional BluetoothDescriptorUUID descriptor);
+  Promise<ByteString> readValue();
+  //Promise<DataView> readValue();
+  Promise<undefined> writeValue(BufferSource value);
+  Promise<BluetoothRemoteGATTCharacteristic> startNotifications();
+  Promise<BluetoothRemoteGATTCharacteristic> stopNotifications();
+};
+
+interface mixin CharacteristicEventHandlers {
+  attribute EventHandler oncharacteristicvaluechanged;
+};
+
+// BluetoothRemoteGATTCharacteristic includes EventTarget;
+BluetoothRemoteGATTCharacteristic includes CharacteristicEventHandlers;

components/script_bindings/webidls/BluetoothRemoteGATTDescriptor.webidl

@@ -0,0 +1,16 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+// http://webbluetoothcg.github.io/web-bluetooth/#bluetoothremotegattdescriptor
+
+[Exposed=Window, Pref="dom_bluetooth_enabled"]
+interface BluetoothRemoteGATTDescriptor {
+  [SameObject]
+  readonly attribute BluetoothRemoteGATTCharacteristic characteristic;
+  readonly attribute DOMString uuid;
+  readonly attribute ByteString? value;
+  Promise<ByteString> readValue();
+  //Promise<DataView> readValue();
+  Promise<undefined> writeValue(BufferSource value);
+};

components/script_bindings/webidls/BluetoothRemoteGATTServer.webidl

@@ -0,0 +1,17 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+//https://webbluetoothcg.github.io/web-bluetooth/#bluetoothremotegattserver
+
+[Exposed=Window, Pref="dom_bluetooth_enabled"]
+interface BluetoothRemoteGATTServer {
+  [SameObject]
+  readonly attribute BluetoothDevice device;
+  readonly attribute boolean connected;
+  Promise<BluetoothRemoteGATTServer> connect();
+  [Throws]
+  undefined disconnect();
+  Promise<BluetoothRemoteGATTService> getPrimaryService(BluetoothServiceUUID service);
+  Promise<sequence<BluetoothRemoteGATTService>> getPrimaryServices(optional BluetoothServiceUUID service);
+};

components/script_bindings/webidls/BluetoothRemoteGATTService.webidl

@@ -0,0 +1,28 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+// https://webbluetoothcg.github.io/web-bluetooth/#bluetoothremotegattservice
+
+[Exposed=Window, Pref="dom_bluetooth_enabled"]
+interface BluetoothRemoteGATTService : EventTarget {
+  [SameObject]
+  readonly attribute BluetoothDevice device;
+  readonly attribute DOMString uuid;
+  readonly attribute boolean isPrimary;
+  Promise<BluetoothRemoteGATTCharacteristic> getCharacteristic(BluetoothCharacteristicUUID characteristic);
+  Promise<sequence<BluetoothRemoteGATTCharacteristic>>
+  getCharacteristics(optional BluetoothCharacteristicUUID characteristic);
+  Promise<BluetoothRemoteGATTService> getIncludedService(BluetoothServiceUUID service);
+  Promise<sequence<BluetoothRemoteGATTService>> getIncludedServices(optional BluetoothServiceUUID service);
+};
+
+interface mixin ServiceEventHandlers {
+  attribute EventHandler onserviceadded;
+  attribute EventHandler onservicechanged;
+  attribute EventHandler onserviceremoved;
+};
+
+// BluetoothRemoteGATTService includes EventTarget;
+// BluetoothRemoteGATTService includes CharacteristicEventHandlers;
+BluetoothRemoteGATTService includes ServiceEventHandlers;

components/script_bindings/webidls/BluetoothUUID.webidl

@@ -0,0 +1,21 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+// https://webbluetoothcg.github.io/web-bluetooth/#bluetoothuuid
+
+[Exposed=Window, Pref="dom_bluetooth_enabled"]
+interface BluetoothUUID {
+  [Throws]
+  static UUID getService(BluetoothServiceUUID name);
+  [Throws]
+  static UUID getCharacteristic(BluetoothCharacteristicUUID name);
+  [Throws]
+  static UUID getDescriptor(BluetoothDescriptorUUID name);
+  static UUID canonicalUUID([EnforceRange] unsigned long alias);
+};
+
+typedef DOMString UUID;
+typedef (DOMString or unsigned long) BluetoothServiceUUID;
+typedef (DOMString or unsigned long) BluetoothCharacteristicUUID;
+typedef (DOMString or unsigned long) BluetoothDescriptorUUID;

components/script_bindings/webidls/Body.webidl

@@ -0,0 +1,17 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+// https://fetch.spec.whatwg.org/#body
+
+[Exposed=(Window,Worker)]
+interface mixin Body {
+  readonly attribute boolean bodyUsed;
+  readonly attribute ReadableStream? body;
+
+  [NewObject] Promise<ArrayBuffer> arrayBuffer();
+  [NewObject] Promise<Blob> blob();
+  [NewObject] Promise<FormData> formData();
+  [NewObject] Promise<any> json();
+  [NewObject] Promise<USVString> text();
+};

components/script_bindings/webidls/BroadcastChannel.webidl

@@ -0,0 +1,18 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+/*
+ * The origin of this IDL file is:
+ * https://html.spec.whatwg.org/multipage/#broadcastchannel
+ */
+
+[Exposed=(Window,Worker)]
+interface BroadcastChannel : EventTarget {
+  constructor(DOMString name);
+
+  readonly attribute DOMString name;
+  [Throws] undefined postMessage(any message);
+  undefined close();
+  attribute EventHandler onmessage;
+  attribute EventHandler onmessageerror;
+};

components/script_bindings/webidls/CDATASection.webidl

@@ -0,0 +1,11 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/*
+ * The origin of this IDL file is
+ * https://dom.spec.whatwg.org/#interface-cdatasection
+ */
+
+[Exposed=Window]
+interface CDATASection : Text {
+};

components/script_bindings/webidls/CSS.webidl

@@ -0,0 +1,24 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/*
+ * The origin of this IDL file is
+ * http://dev.w3.org/csswg/cssom/#the-css-interface
+ */
+
+[Abstract, Exposed=Window]
+interface CSS {
+  [Throws]
+  static DOMString escape(DOMString ident);
+};
+
+// https://drafts.csswg.org/css-conditional-3/#the-css-interface
+partial interface CSS {
+  static boolean supports(DOMString property, DOMString value);
+  static boolean supports(DOMString conditionText);
+};
+
+// https://drafts.css-houdini.org/css-paint-api-1/#paint-worklet
+partial interface CSS {
+    [SameObject, Pref="dom_worklet_enabled"] static readonly attribute Worklet paintWorklet;
+};

components/script_bindings/webidls/CSSConditionRule.webidl

@@ -0,0 +1,9 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+// https://drafts.csswg.org/css-conditional/#cssconditionrule
+[Abstract, Exposed=Window]
+interface CSSConditionRule : CSSGroupingRule {
+    readonly attribute DOMString conditionText;
+};

components/script_bindings/webidls/CSSFontFaceRule.webidl

@@ -0,0 +1,14 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+// https://drafts.csswg.org/css-fonts/#cssfontfacerule is unfortunately not web-compatible:
+// https://github.com/w3c/csswg-drafts/issues/825
+
+// https://www.w3.org/TR/2000/REC-DOM-Level-2-Style-20001113/css.html#CSS-CSSFontFaceRule ,
+// plus extended attributes matching CSSStyleRule
+[Exposed=Window]
+interface CSSFontFaceRule : CSSRule {
+  // [SameObject, PutForwards=cssText] readonly attribute CSSStyleDeclaration style;
+};
+

components/script_bindings/webidls/CSSGroupingRule.webidl

@@ -0,0 +1,12 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+// https://drafts.csswg.org/cssom/#the-cssgroupingrule-interface
+[Abstract, Exposed=Window]
+interface CSSGroupingRule : CSSRule {
+  [SameObject] readonly attribute CSSRuleList cssRules;
+  [Throws] unsigned long insertRule(DOMString rule, unsigned long index);
+  [Throws] undefined deleteRule(unsigned long index);
+};
+

components/script_bindings/webidls/CSSImportRule.webidl

@@ -0,0 +1,12 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+// https://drafts.csswg.org/cssom/#cssimportrule
+[Exposed=Window]
+interface CSSImportRule : CSSRule {
+  // readonly attribute DOMString href;
+  // [SameObject, PutForwards=mediaText] readonly attribute MediaList media;
+  // [SameObject] readonly attribute CSSStyleSheet styleSheet;
+  readonly attribute DOMString? layerName;
+};

components/script_bindings/webidls/CSSKeyframeRule.webidl

@@ -0,0 +1,10 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+// https://drafts.csswg.org/css-animations/#interface-csskeyframerule
+[Exposed=Window]
+interface CSSKeyframeRule : CSSRule {
+  //          attribute DOMString           keyText;
+  readonly attribute CSSStyleDeclaration style;
+};

components/script_bindings/webidls/CSSKeyframesRule.webidl

@@ -0,0 +1,15 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+// https://drafts.csswg.org/css-animations/#interface-csskeyframesrule
+[Exposed=Window]
+interface CSSKeyframesRule : CSSRule {
+  [SetterThrows]
+           attribute DOMString   name;
+  readonly attribute CSSRuleList cssRules;
+
+  undefined            appendRule(DOMString rule);
+  undefined            deleteRule(DOMString select);
+  CSSKeyframeRule? findRule(DOMString select);
+};

components/script_bindings/webidls/CSSLayerBlockRule.webidl

@@ -0,0 +1,9 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+// https://drafts.csswg.org/css-cascade-5/#the-csslayerblockrule-interface
+[Exposed=Window]
+interface CSSLayerBlockRule : CSSGroupingRule {
+  readonly attribute DOMString name;
+};

components/script_bindings/webidls/CSSLayerStatementRule.webidl

@@ -0,0 +1,9 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+// https://drafts.csswg.org/css-cascade-5/#the-csslayerstatementrule-interface
+[Exposed=Window]
+interface CSSLayerStatementRule : CSSRule {
+  readonly attribute /*FrozenArray<ResizeObserverSize>*/any nameList;
+};

components/script_bindings/webidls/CSSMediaRule.webidl

@@ -0,0 +1,10 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+// https://drafts.csswg.org/cssom/#the-cssmediarule-interface
+// https://drafts.csswg.org/css-conditional/#cssmediarule
+[Exposed=Window]
+interface CSSMediaRule : CSSConditionRule {
+  [SameObject, PutForwards=mediaText] readonly attribute MediaList media;
+};

components/script_bindings/webidls/CSSNamespaceRule.webidl

@@ -0,0 +1,10 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+// https://drafts.csswg.org/cssom/#the-cssnamespacerule-interface
+[Exposed=Window]
+interface CSSNamespaceRule : CSSRule {
+  readonly attribute DOMString namespaceURI;
+  readonly attribute DOMString prefix;
+};

components/script_bindings/webidls/CSSRule.webidl

@@ -0,0 +1,32 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+// https://drafts.csswg.org/cssom/#the-cssrule-interface
+[Abstract, Exposed=Window]
+interface CSSRule {
+  const unsigned short STYLE_RULE = 1;
+  const unsigned short CHARSET_RULE = 2; // historical
+  const unsigned short IMPORT_RULE = 3;
+  const unsigned short MEDIA_RULE = 4;
+  const unsigned short FONT_FACE_RULE = 5;
+  const unsigned short PAGE_RULE = 6;
+  const unsigned short MARGIN_RULE = 9;
+  const unsigned short NAMESPACE_RULE = 10;
+
+  readonly attribute unsigned short type;
+  attribute DOMString cssText;
+  // readonly attribute CSSRule? parentRule;
+  readonly attribute CSSStyleSheet? parentStyleSheet;
+};
+
+// https://drafts.csswg.org/css-animations/#interface-cssrule-idl
+partial interface CSSRule {
+    const unsigned short KEYFRAMES_RULE = 7;
+    const unsigned short KEYFRAME_RULE = 8;
+};
+
+// https://drafts.csswg.org/css-conditional-3/#extentions-to-cssrule-interface
+partial interface CSSRule {
+    const unsigned short SUPPORTS_RULE = 12;
+};

components/script_bindings/webidls/CSSRuleList.webidl

@@ -0,0 +1,11 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+// https://drafts.csswg.org/cssom/#cssrulelist
+// [LegacyArrayClass]
+[Exposed=Window]
+interface CSSRuleList {
+  getter CSSRule? item(unsigned long index);
+  readonly attribute unsigned long length;
+};

components/script_bindings/webidls/CSSStyleDeclaration.webidl

@@ -0,0 +1,29 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/*
+ * The origin of this IDL file is
+ * http://dev.w3.org/csswg/cssom/#the-cssstyledeclaration-interface
+ *
+ * Copyright © 2013 W3C® (MIT, ERCIM, Keio, Beihang), All Rights Reserved.
+ */
+
+[Exposed=Window]
+interface CSSStyleDeclaration {
+  [CEReactions, SetterThrows]
+           attribute DOMString cssText;
+  readonly attribute unsigned long length;
+  getter DOMString item(unsigned long index);
+  DOMString getPropertyValue(DOMString property);
+  DOMString getPropertyPriority(DOMString property);
+  [CEReactions, Throws]
+  undefined setProperty(DOMString property, [LegacyNullToEmptyString] DOMString value,
+                                       optional [LegacyNullToEmptyString] DOMString priority = "");
+  [CEReactions, Throws]
+  DOMString removeProperty(DOMString property);
+  // readonly attribute CSSRule? parentRule;
+  [CEReactions, SetterThrows]
+           attribute DOMString cssFloat;
+};
+
+// Auto-generated in GlobalGen.py: accessors for each CSS property

components/script_bindings/webidls/CSSStyleRule.webidl

@@ -0,0 +1,10 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+// https://drafts.csswg.org/cssom/#the-cssstylerule-interface
+[Exposed=Window]
+interface CSSStyleRule : CSSRule {
+  attribute DOMString selectorText;
+  [SameObject, PutForwards=cssText] readonly attribute CSSStyleDeclaration style;
+};

components/script_bindings/webidls/CSSStyleSheet.webidl

@@ -0,0 +1,12 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+// https://drafts.csswg.org/cssom/#the-cssstylesheet-interface
+[Exposed=Window]
+interface CSSStyleSheet : StyleSheet {
+  // readonly attribute CSSRule? ownerRule;
+  [Throws, SameObject] readonly attribute CSSRuleList cssRules;
+  [Throws] unsigned long insertRule(DOMString rule, optional unsigned long index = 0);
+  [Throws] undefined deleteRule(unsigned long index);
+};

components/script_bindings/webidls/CSSStyleValue.webidl

@@ -0,0 +1,10 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+// https://drafts.css-houdini.org/css-typed-om-1/#cssstylevalue
+// NOTE: should this be exposed to Window?
+[Pref="dom_worklet_enabled", Exposed=(Worklet)]
+interface CSSStyleValue {
+    stringifier;
+};

components/script_bindings/webidls/CSSSupportsRule.webidl

@@ -0,0 +1,8 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+// https://drafts.csswg.org/css-conditional/#csssupportsrule
+[Exposed=Window]
+interface CSSSupportsRule : CSSConditionRule {
+};

components/script_bindings/webidls/CanvasRenderingContext2D.webidl

@@ -0,0 +1,264 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+// https://html.spec.whatwg.org/multipage/#2dcontext
+
+// typedef (HTMLImageElement or
+//          SVGImageElement) HTMLOrSVGImageElement;
+typedef HTMLImageElement HTMLOrSVGImageElement;
+
+typedef (HTMLOrSVGImageElement or
+         /*HTMLVideoElement or*/
+         HTMLCanvasElement or
+         /*ImageBitmap or*/
+         OffscreenCanvas or
+         /*VideoFrame or*/
+         /*CSSImageValue*/ CSSStyleValue) CanvasImageSource;
+
+enum CanvasFillRule { "nonzero", "evenodd" };
+
+[Exposed=Window]
+interface CanvasRenderingContext2D {
+  // back-reference to the canvas
+  readonly attribute HTMLCanvasElement canvas;
+};
+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 CanvasState {
+  // state
+  undefined save(); // push state on state stack
+  undefined restore(); // pop state stack and restore state
+  undefined reset();
+};
+
+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);
+  // void setTransform(optional DOMMatrixInit matrix);
+  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 {
+  // colours and styles (see also the CanvasDrawingStyles interface)
+  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);
+  [Throws]
+  CanvasGradient createRadialGradient(double x0, double y0, double r0, double x1, double y1, double r1);
+  [Throws]
+  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");
+  //void fill(Path2D path, optional CanvasFillRule fillRule = "nonzero");
+  undefined stroke();
+  //void stroke(Path2D path);
+  undefined clip(optional CanvasFillRule fillRule = "nonzero");
+  //void 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 {
+  //void drawFocusIfNeeded(Element element);
+  //void drawFocusIfNeeded(Path2D path, Element element);
+  //void scrollPathIntoView();
+  //void scrollPathIntoView(Path2D path);
+};
+
+interface mixin CanvasText {
+  // text (see also the CanvasPathDrawingStyles and CanvasTextDrawingStyles interfaces)
+  [Pref="dom_canvas_text_enabled"]
+  undefined fillText(DOMString text, unrestricted double x, unrestricted double y,
+                optional unrestricted double maxWidth);
+  //void strokeText(DOMString text, unrestricted double x, unrestricted double y,
+  //                optional unrestricted double maxWidth);
+  [Pref="dom_canvas_text_enabled"]
+  TextMetrics measureText(DOMString text);
+};
+
+interface mixin CanvasDrawImage {
+  // drawing images
+  [Throws]
+  undefined drawImage(CanvasImageSource image, unrestricted double dx, unrestricted double dy);
+  [Throws]
+  undefined drawImage(CanvasImageSource image, unrestricted double dx, unrestricted double dy,
+                                          unrestricted double dw, unrestricted double dh);
+  [Throws]
+  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
+  [Throws]
+  ImageData createImageData(long sw, long sh);
+  [Throws]
+  ImageData createImageData(ImageData imagedata);
+  [Throws]
+  ImageData getImageData(long sx, long sy, long sw, long sh);
+  undefined putImageData(ImageData imagedata, long dx, long dy);
+  undefined putImageData(ImageData imagedata,
+                    long dx, long dy,
+                    long dirtyX, long dirtyY,
+                    long dirtyWidth, 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" };
+
+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
+  //void setLineDash(sequence<unrestricted double> segments); // default empty
+  //sequence<unrestricted double> getLineDash();
+  //attribute unrestricted double lineDashOffset;
+};
+
+interface mixin CanvasTextDrawingStyles {
+  // text
+  attribute DOMString font; // (default 10px sans-serif)
+  attribute CanvasTextAlign textAlign; // "start", "end", "left", "right", "center" (default: "start")
+  attribute CanvasTextBaseline textBaseline; // "top", "hanging", "middle", "alphabetic",
+                                      // "ideographic", "bottom" (default: "alphabetic")
+  attribute CanvasDirection direction; // "ltr", "rtl", "inherit" (default: "inherit")
+};
+
+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);
+
+  [Throws]
+  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);
+
+  [Throws]
+  undefined arc(unrestricted double x, unrestricted double y, unrestricted double radius,
+           unrestricted double startAngle, unrestricted double endAngle, optional boolean anticlockwise = false);
+
+  [Throws]
+  undefined ellipse(unrestricted double x, unrestricted double y, unrestricted double radius_x,
+               unrestricted double radius_y, unrestricted double rotation, unrestricted double startAngle,
+               unrestricted double endAngle, optional boolean anticlockwise = false);
+};
+
+[Exposed=(Window, PaintWorklet, Worker)]
+interface CanvasGradient {
+  // opaque object
+  [Throws]
+  undefined addColorStop(double offset, DOMString color);
+};
+
+[Exposed=(Window, PaintWorklet, Worker)]
+interface CanvasPattern {
+  // opaque object
+  //undefined setTransform(optional DOMMatrix2DInit transform = {});
+};
+
+[Exposed=(Window,Worker),
+ Serializable]
+interface ImageData {
+  [Throws] constructor(unsigned long sw, unsigned long sh/*, optional ImageDataSettings settings = {}*/);
+  [Throws] constructor(/* Uint8ClampedArray */ object data, unsigned long sw, optional unsigned long sh
+              /*, optional ImageDataSettings settings = {}*/);
+
+  readonly attribute unsigned long width;
+  readonly attribute unsigned long height;
+  [Throws] readonly attribute Uint8ClampedArray data;
+  //readonly attribute PredefinedColorSpace colorSpace;
+};

components/script_bindings/webidls/ChannelMergerNode.webidl

@@ -0,0 +1,16 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/*
+ * The origin of this IDL file is
+ * https://webaudio.github.io/web-audio-api/#channelmergernode
+ */
+
+dictionary ChannelMergerOptions : AudioNodeOptions {
+  unsigned long numberOfInputs = 6;
+};
+
+[Exposed=Window]
+interface ChannelMergerNode : AudioNode {
+  [Throws] constructor(BaseAudioContext context, optional ChannelMergerOptions options = {});
+};

components/script_bindings/webidls/ChannelSplitterNode.webidl

@@ -0,0 +1,16 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/*
+ * The origin of this IDL file is
+ * https://webaudio.github.io/web-audio-api/#channelsplitternode
+ */
+
+dictionary ChannelSplitterOptions : AudioNodeOptions {
+  unsigned long numberOfOutputs = 6;
+};
+
+[Exposed=Window]
+interface ChannelSplitterNode : AudioNode {
+  [Throws] constructor(BaseAudioContext context, optional ChannelSplitterOptions options = {});
+};

components/script_bindings/webidls/CharacterData.webidl

@@ -0,0 +1,28 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/*
+ * The origin of this IDL file is
+ * https://dom.spec.whatwg.org/#characterdata
+ *
+ * Copyright © 2012 W3C® (MIT, ERCIM, Keio), All Rights Reserved. W3C
+ * liability, trademark and document use rules apply.
+ */
+
+[Exposed=Window, Abstract]
+interface CharacterData : Node {
+  [Pure] attribute [LegacyNullToEmptyString] DOMString data;
+  [Pure] readonly attribute unsigned long length;
+  [Pure, Throws]
+  DOMString substringData(unsigned long offset, unsigned long count);
+  undefined appendData(DOMString data);
+  [Throws]
+  undefined insertData(unsigned long offset, DOMString data);
+  [Throws]
+  undefined deleteData(unsigned long offset, unsigned long count);
+  [Throws]
+  undefined replaceData(unsigned long offset, unsigned long count, DOMString data);
+};
+
+CharacterData includes ChildNode;
+CharacterData includes NonDocumentTypeChildNode;

components/script_bindings/webidls/ChildNode.webidl

@@ -0,0 +1,25 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/*
+ * The origin of this IDL file is:
+ * https://dom.spec.whatwg.org/#interface-childnode
+ */
+
+interface mixin ChildNode {
+  [Throws, CEReactions, Unscopable]
+  undefined before((Node or DOMString)... nodes);
+  [Throws, CEReactions, Unscopable]
+  undefined after((Node or DOMString)... nodes);
+  [Throws, CEReactions, Unscopable]
+  undefined replaceWith((Node or DOMString)... nodes);
+  [CEReactions, Unscopable]
+  undefined remove();
+};
+
+interface mixin NonDocumentTypeChildNode {
+  [Pure]
+  readonly attribute Element? previousElementSibling;
+  [Pure]
+  readonly attribute Element? nextElementSibling;
+};

components/script_bindings/webidls/Client.webidl

@@ -0,0 +1,20 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+// https://w3c.github.io/ServiceWorker/#client
+
+[Pref="dom_serviceworker_enabled", Exposed=ServiceWorker]
+interface Client {
+  readonly attribute USVString url;
+  readonly attribute FrameType frameType;
+  readonly attribute DOMString id;
+  //void postMessage(any message, optional sequence<Transferable> transfer);
+};
+
+enum FrameType {
+  "auxiliary",
+  "top-level",
+  "nested",
+  "none"
+};

components/script_bindings/webidls/ClipboardEvent.webidl

@@ -0,0 +1,15 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// https://w3c.github.io/clipboard-apis/
+
+[Exposed=Window, Pref="dom_clipboardevent_enabled"]
+interface ClipboardEvent : Event {
+  constructor (DOMString type, optional ClipboardEventInit eventInitDict = {});
+  readonly attribute DataTransfer? clipboardData;
+};
+
+dictionary ClipboardEventInit : EventInit {
+  DataTransfer? clipboardData = null;
+};

components/script_bindings/webidls/CloseEvent.webidl

@@ -0,0 +1,18 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+//https://html.spec.whatwg.org/multipage/#the-closeevent-interfaces
+[Exposed=(Window,Worker)]
+interface CloseEvent : Event {
+  [Throws] constructor(DOMString type, optional CloseEventInit eventInitDict = {});
+  readonly attribute boolean wasClean;
+  readonly attribute unsigned short code;
+  readonly attribute DOMString reason;
+};
+
+dictionary CloseEventInit : EventInit {
+  boolean wasClean = false;
+  unsigned short code = 0;
+  DOMString reason = "";
+};

components/script_bindings/webidls/Comment.webidl

@@ -0,0 +1,15 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/*
+ * The origin of this IDL file is
+ * https://dom.spec.whatwg.org/#comment
+ *
+ * Copyright © 2012 W3C® (MIT, ERCIM, Keio), All Rights Reserved. W3C
+ * liability, trademark and document use rules apply.
+ */
+
+[Exposed=Window]
+interface Comment : CharacterData {
+  [Throws] constructor(optional DOMString data = "");
+};

components/script_bindings/webidls/CompositionEvent.webidl

@@ -0,0 +1,21 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/*
+ * The origin of this IDL file is
+ * https://w3c.github.io/uievents/#idl-compositionevent
+ *
+ */
+
+// https://w3c.github.io/uievents/#idl-compositionevent
+[Exposed=Window, Pref="dom_composition_event_enabled"]
+interface CompositionEvent : UIEvent {
+  [Throws] constructor(DOMString type, optional CompositionEventInit eventInitDict = {});
+  readonly attribute DOMString data;
+};
+
+// https://w3c.github.io/uievents/#idl-compositioneventinit
+dictionary CompositionEventInit : UIEventInit {
+  DOMString data = "";
+};
+

components/script_bindings/webidls/Console.webidl

@@ -0,0 +1,36 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+// https://console.spec.whatwg.org/
+
+[ClassString="Console",
+ Exposed=*]
+namespace console {
+  // Logging
+  undefined assert(optional boolean condition = false, any... data);
+  undefined clear();
+  undefined debug(any... messages);
+  undefined error(any... messages);
+  undefined info(any... messages);
+  undefined log(any... messages);
+  // undefined table(optional any tabularData, optional sequence<DOMString> properties);
+  undefined trace(any... data);
+  undefined warn(any... messages);
+  // undefined dir(optional any item, optional object? options);
+  // undefined dirxml(any... data);
+
+  // Counting
+  undefined count(optional DOMString label = "default");
+  undefined countReset(optional DOMString label = "default");
+
+  // Grouping
+  undefined group(any... data);
+  undefined groupCollapsed(any... data);
+  undefined groupEnd();
+
+  // Timing
+  undefined time(optional DOMString label = "default");
+  undefined timeLog(optional DOMString label = "default", any... data);
+  undefined timeEnd(optional DOMString label = "default");
+};

components/script_bindings/webidls/ConstantSourceNode.webidl

@@ -0,0 +1,17 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/*
+ * The origin of this IDL file is
+ * https://webaudio.github.io/web-audio-api/#ConstantSourceNode
+ */
+
+dictionary ConstantSourceOptions: AudioNodeOptions {
+  float offset = 1;
+};
+
+[Exposed=Window]
+interface ConstantSourceNode : AudioScheduledSourceNode {
+  [Throws] constructor(BaseAudioContext context, optional ConstantSourceOptions options = {});
+  readonly attribute AudioParam offset;
+};

components/script_bindings/webidls/Crypto.webidl

@@ -0,0 +1,19 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/*
+ * The origin of this IDL file is
+ * https://w3c.github.io/webcrypto/#crypto-interface
+ *
+ */
+
+partial interface mixin WindowOrWorkerGlobalScope {
+  [SameObject] readonly attribute Crypto crypto;
+};
+
+[Exposed=(Window,Worker)]
+interface Crypto {
+  [SecureContext, Pref="dom_crypto_subtle_enabled"] readonly attribute SubtleCrypto subtle;
+  [Throws] ArrayBufferView getRandomValues(ArrayBufferView array);
+  [SecureContext] DOMString randomUUID();
+};

components/script_bindings/webidls/CryptoKey.webidl

@@ -0,0 +1,17 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+// https://w3c.github.io/webcrypto/#cryptokey-interface
+
+enum KeyType { "public", "private", "secret" };
+
+enum KeyUsage { "encrypt", "decrypt", "sign", "verify", "deriveKey", "deriveBits", "wrapKey", "unwrapKey" };
+
+[SecureContext, Exposed=(Window,Worker), Serializable, Pref="dom_crypto_subtle_enabled"]
+interface CryptoKey {
+  readonly attribute KeyType type;
+  readonly attribute boolean extractable;
+  readonly attribute object algorithm;
+  readonly attribute object usages;
+};

components/script_bindings/webidls/CustomElementRegistry.webidl

@@ -0,0 +1,28 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+// https://html.spec.whatwg.org/multipage/#customelementregistry
+[Exposed=Window, Pref="dom_customelements_enabled"]
+interface CustomElementRegistry {
+  [Throws, CEReactions]
+  undefined define(
+    DOMString name,
+    CustomElementConstructor constructor_,
+    optional ElementDefinitionOptions options = {}
+  );
+
+  any get(DOMString name);
+
+  DOMString? getName(CustomElementConstructor constructor);
+
+  Promise<CustomElementConstructor> whenDefined(DOMString name);
+
+  [CEReactions] undefined upgrade(Node root);
+};
+
+callback CustomElementConstructor = HTMLElement();
+
+dictionary ElementDefinitionOptions {
+  DOMString extends;
+};

components/script_bindings/webidls/CustomEvent.webidl

@@ -0,0 +1,33 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/*
+ * For more information on this interface please see
+ * https://dom.spec.whatwg.org/#interface-customevent
+ *
+ * To the extent possible under law, the editors have waived
+ * all copyright and related or neighboring rights to this work.
+ * In addition, as of 1 May 2014, the editors have made this specification
+ * available under the Open Web Foundation Agreement Version 1.0,
+ * which is available at
+ * http://www.openwebfoundation.org/legal/the-owf-1-0-agreements/owfa-1-0.
+ */
+
+// https://dom.spec.whatwg.org/#dom-customevent-initcustomevent
+[Exposed=*]
+interface CustomEvent : Event {
+  constructor(DOMString type, optional CustomEventInit eventInitDict = {});
+
+  readonly attribute any detail;
+
+  undefined initCustomEvent(
+    DOMString type,
+    optional boolean bubbles = false,
+    optional boolean cancelable = false,
+    optional any detail = null
+  ); // legacy
+};
+
+dictionary CustomEventInit : EventInit {
+  any detail = null;
+};

components/script_bindings/webidls/DOMException.webidl

@@ -0,0 +1,50 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/*
+
+/* https://heycam.github.io/webidl/#es-DOMException
+ * https://heycam.github.io/webidl/#es-DOMException-constructor-object
+ */
+
+[
+  ExceptionClass,
+  Exposed=(Window,Worker,Worklet,DissimilarOriginWindow)
+]
+interface DOMException {
+  [Throws] constructor(optional DOMString message="", optional DOMString name="Error");
+  const unsigned short INDEX_SIZE_ERR = 1;
+  const unsigned short DOMSTRING_SIZE_ERR = 2; // historical
+  const unsigned short HIERARCHY_REQUEST_ERR = 3;
+  const unsigned short WRONG_DOCUMENT_ERR = 4;
+  const unsigned short INVALID_CHARACTER_ERR = 5;
+  const unsigned short NO_DATA_ALLOWED_ERR = 6; // historical
+  const unsigned short NO_MODIFICATION_ALLOWED_ERR = 7;
+  const unsigned short NOT_FOUND_ERR = 8;
+  const unsigned short NOT_SUPPORTED_ERR = 9;
+  const unsigned short INUSE_ATTRIBUTE_ERR = 10; // historical
+  const unsigned short INVALID_STATE_ERR = 11;
+  const unsigned short SYNTAX_ERR = 12;
+  const unsigned short INVALID_MODIFICATION_ERR = 13;
+  const unsigned short NAMESPACE_ERR = 14;
+  const unsigned short INVALID_ACCESS_ERR = 15;
+  const unsigned short VALIDATION_ERR = 16; // historical
+  const unsigned short TYPE_MISMATCH_ERR = 17; // historical; use JavaScript's TypeError instead
+  const unsigned short SECURITY_ERR = 18;
+  const unsigned short NETWORK_ERR = 19;
+  const unsigned short ABORT_ERR = 20;
+  const unsigned short URL_MISMATCH_ERR = 21;
+  const unsigned short QUOTA_EXCEEDED_ERR = 22;
+  const unsigned short TIMEOUT_ERR = 23;
+  const unsigned short INVALID_NODE_TYPE_ERR = 24;
+  const unsigned short DATA_CLONE_ERR = 25;
+
+  // Error code as u16
+  readonly attribute unsigned short code;
+
+  // The name of the error code (ie, a string repr of |code|)
+  readonly attribute DOMString name;
+
+  // A custom message set by the thrower.
+  readonly attribute DOMString message;
+};

components/script_bindings/webidls/DOMImplementation.webidl

@@ -0,0 +1,27 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/*
+ * The origin of this IDL file is
+ * https://dom.spec.whatwg.org/#interface-domimplementation
+ *
+ * Copyright:
+ * To the extent possible under law, the editors have waived all copyright and
+ * related or neighboring rights to this work.
+ */
+
+[Exposed=Window]
+interface DOMImplementation {
+  [NewObject, Throws]
+  DocumentType createDocumentType(DOMString qualifiedName, DOMString publicId,
+                                  DOMString systemId);
+  [NewObject, Throws]
+  XMLDocument createDocument(DOMString? namespace,
+                             [LegacyNullToEmptyString] DOMString qualifiedName,
+                             optional DocumentType? doctype = null);
+  [NewObject]
+  Document createHTMLDocument(optional DOMString title);
+
+  [Pure]
+  boolean hasFeature(); // useless, always return true
+};

components/script_bindings/webidls/DOMMatrix.webidl

@@ -0,0 +1,100 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+// https://drafts.fxtf.org/geometry/#dommatrix
+
+[Exposed=(Window,Worker,PaintWorklet),
+ LegacyWindowAlias=WebKitCSSMatrix]
+interface DOMMatrix : DOMMatrixReadOnly {
+    [Throws] constructor(optional (DOMString or sequence<unrestricted double>) init);
+
+    [NewObject, Throws] static DOMMatrix fromMatrix(optional DOMMatrixInit other = {});
+    [NewObject, Throws] static DOMMatrix fromFloat32Array(Float32Array array32);
+    [NewObject, Throws] static DOMMatrix fromFloat64Array(Float64Array array64);
+
+    // These attributes are simple aliases for certain elements of the 4x4 matrix
+    inherit attribute unrestricted double a;
+    inherit attribute unrestricted double b;
+    inherit attribute unrestricted double c;
+    inherit attribute unrestricted double d;
+    inherit attribute unrestricted double e;
+    inherit attribute unrestricted double f;
+
+    inherit attribute unrestricted double m11;
+    inherit attribute unrestricted double m12;
+    inherit attribute unrestricted double m13;
+    inherit attribute unrestricted double m14;
+    inherit attribute unrestricted double m21;
+    inherit attribute unrestricted double m22;
+    inherit attribute unrestricted double m23;
+    inherit attribute unrestricted double m24;
+    inherit attribute unrestricted double m31;
+    inherit attribute unrestricted double m32;
+    inherit attribute unrestricted double m33;
+    inherit attribute unrestricted double m34;
+    inherit attribute unrestricted double m41;
+    inherit attribute unrestricted double m42;
+    inherit attribute unrestricted double m43;
+    inherit attribute unrestricted double m44;
+
+    // Mutable transform methods
+    [Throws] DOMMatrix multiplySelf(optional DOMMatrixInit other = {});
+    [Throws] DOMMatrix preMultiplySelf(optional DOMMatrixInit other = {});
+    DOMMatrix translateSelf(optional unrestricted double tx = 0,
+                            optional unrestricted double ty = 0,
+                            optional unrestricted double tz = 0);
+    DOMMatrix scaleSelf(optional unrestricted double scaleX = 1,
+                        optional unrestricted double scaleY,
+                        optional unrestricted double scaleZ = 1,
+                        optional unrestricted double originX = 0,
+                        optional unrestricted double originY = 0,
+                        optional unrestricted double originZ = 0);
+    DOMMatrix scale3dSelf(optional unrestricted double scale = 1,
+                          optional unrestricted double originX = 0,
+                          optional unrestricted double originY = 0,
+                          optional unrestricted double originZ = 0);
+    DOMMatrix rotateSelf(optional unrestricted double rotX = 0,
+                         optional unrestricted double rotY,
+                         optional unrestricted double rotZ);
+    DOMMatrix rotateFromVectorSelf(optional unrestricted double x = 0,
+                                   optional unrestricted double y = 0);
+    DOMMatrix rotateAxisAngleSelf(optional unrestricted double x = 0,
+                                  optional unrestricted double y = 0,
+                                  optional unrestricted double z = 0,
+                                  optional unrestricted double angle = 0);
+    DOMMatrix skewXSelf(optional unrestricted double sx = 0);
+    DOMMatrix skewYSelf(optional unrestricted double sy = 0);
+    DOMMatrix invertSelf();
+
+//  DOMMatrix setMatrixValue(DOMString transformList);
+};
+
+dictionary DOMMatrix2DInit {
+    unrestricted double a;
+    unrestricted double b;
+    unrestricted double c;
+    unrestricted double d;
+    unrestricted double e;
+    unrestricted double f;
+    unrestricted double m11;
+    unrestricted double m12;
+    unrestricted double m21;
+    unrestricted double m22;
+    unrestricted double m41;
+    unrestricted double m42;
+};
+
+dictionary DOMMatrixInit : DOMMatrix2DInit {
+    unrestricted double m13 = 0;
+    unrestricted double m14 = 0;
+    unrestricted double m23 = 0;
+    unrestricted double m24 = 0;
+    unrestricted double m31 = 0;
+    unrestricted double m32 = 0;
+    unrestricted double m33 = 1;
+    unrestricted double m34 = 0;
+    unrestricted double m43 = 0;
+    unrestricted double m44 = 1;
+    boolean is2D;
+};

components/script_bindings/webidls/DOMMatrixReadOnly.webidl

@@ -0,0 +1,86 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/*
+ * The origin of this IDL file is
+ * https://drafts.fxtf.org/geometry-1/#DOMMatrix
+ *
+ * Copyright:
+ * To the extent possible under law, the editors have waived all copyright and
+ * related or neighboring rights to this work.
+ */
+
+[Exposed=(Window,Worker,PaintWorklet)]
+interface DOMMatrixReadOnly {
+    [Throws] constructor(optional (DOMString or sequence<unrestricted double>) init);
+
+    [NewObject, Throws] static DOMMatrixReadOnly fromMatrix(optional DOMMatrixInit other = {});
+    [NewObject, Throws] static DOMMatrixReadOnly fromFloat32Array(Float32Array array32);
+    [NewObject, Throws] static DOMMatrixReadOnly fromFloat64Array(Float64Array array64);
+
+    // These attributes are simple aliases for certain elements of the 4x4 matrix
+    readonly attribute unrestricted double a;
+    readonly attribute unrestricted double b;
+    readonly attribute unrestricted double c;
+    readonly attribute unrestricted double d;
+    readonly attribute unrestricted double e;
+    readonly attribute unrestricted double f;
+
+    readonly attribute unrestricted double m11;
+    readonly attribute unrestricted double m12;
+    readonly attribute unrestricted double m13;
+    readonly attribute unrestricted double m14;
+    readonly attribute unrestricted double m21;
+    readonly attribute unrestricted double m22;
+    readonly attribute unrestricted double m23;
+    readonly attribute unrestricted double m24;
+    readonly attribute unrestricted double m31;
+    readonly attribute unrestricted double m32;
+    readonly attribute unrestricted double m33;
+    readonly attribute unrestricted double m34;
+    readonly attribute unrestricted double m41;
+    readonly attribute unrestricted double m42;
+    readonly attribute unrestricted double m43;
+    readonly attribute unrestricted double m44;
+
+    readonly attribute boolean is2D;
+    readonly attribute boolean isIdentity;
+
+    // Immutable transform methods
+    DOMMatrix translate(optional unrestricted double tx = 0,
+                        optional unrestricted double ty = 0,
+                        optional unrestricted double tz = 0);
+    DOMMatrix scale(optional unrestricted double scaleX = 1,
+                    optional unrestricted double scaleY,
+                    optional unrestricted double scaleZ = 1,
+                    optional unrestricted double originX = 0,
+                    optional unrestricted double originY = 0,
+                    optional unrestricted double originZ = 0);
+    [NewObject] DOMMatrix scaleNonUniform(optional unrestricted double scaleX = 1,
+                                          optional unrestricted double scaleY = 1);
+    DOMMatrix scale3d(optional unrestricted double scale = 1,
+                      optional unrestricted double originX = 0,
+                      optional unrestricted double originY = 0,
+                      optional unrestricted double originZ = 0);
+    DOMMatrix rotate(optional unrestricted double rotX = 0,
+                     optional unrestricted double rotY,
+                     optional unrestricted double rotZ);
+    DOMMatrix rotateFromVector(optional unrestricted double x = 0,
+                               optional unrestricted double y = 0);
+    DOMMatrix rotateAxisAngle(optional unrestricted double x = 0,
+                              optional unrestricted double y = 0,
+                              optional unrestricted double z = 0,
+                              optional unrestricted double angle = 0);
+    DOMMatrix skewX(optional unrestricted double sx = 0);
+    DOMMatrix skewY(optional unrestricted double sy = 0);
+    [Throws] DOMMatrix multiply(optional DOMMatrixInit other = {});
+    DOMMatrix flipX();
+    DOMMatrix flipY();
+    DOMMatrix inverse();
+
+    DOMPoint            transformPoint(optional DOMPointInit point = {});
+    Float32Array        toFloat32Array();
+    Float64Array        toFloat64Array();
+    [Exposed=Window, Throws] stringifier;
+    [Default] object toJSON();
+};

components/script_bindings/webidls/DOMParser.webidl

@@ -0,0 +1,22 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/*
+ * The origin of this IDL file is
+ * https://w3c.github.io/DOM-Parsing/#the-domparser-interface
+ */
+
+enum SupportedType {
+  "text/html",
+  "text/xml",
+  "application/xml",
+  "application/xhtml+xml",
+  "image/svg+xml"
+};
+
+[Exposed=Window]
+interface DOMParser {
+  [Throws] constructor();
+  [Throws]
+  Document parseFromString(DOMString str, SupportedType type);
+};

components/script_bindings/webidls/DOMPoint.webidl

@@ -0,0 +1,30 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/*
+ * The origin of this IDL file is
+ * http://dev.w3.org/fxtf/geometry/
+ *
+ * Copyright © 2012 W3C® (MIT, ERCIM, Keio), All Rights Reserved. W3C
+ * liability, trademark and document use rules apply.
+ */
+
+// http://dev.w3.org/fxtf/geometry/Overview.html#dompoint
+[Exposed=(Window,Worker,PaintWorklet)]
+interface DOMPoint : DOMPointReadOnly {
+    [Throws] constructor(optional unrestricted double x = 0, optional unrestricted double y = 0,
+                optional unrestricted double z = 0, optional unrestricted double w = 1);
+    [NewObject] static DOMPoint fromPoint(optional DOMPointInit other = {});
+
+    inherit attribute unrestricted double x;
+    inherit attribute unrestricted double y;
+    inherit attribute unrestricted double z;
+    inherit attribute unrestricted double w;
+};
+
+dictionary DOMPointInit {
+    unrestricted double x = 0;
+    unrestricted double y = 0;
+    unrestricted double z = 0;
+    unrestricted double w = 1;
+};

components/script_bindings/webidls/DOMPointReadOnly.webidl

@@ -0,0 +1,25 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/*
+ * The origin of this IDL file is
+ * http://dev.w3.org/fxtf/geometry/
+ *
+ * Copyright © 2012 W3C® (MIT, ERCIM, Keio), All Rights Reserved. W3C
+ * liability, trademark and document use rules apply.
+ */
+
+// http://dev.w3.org/fxtf/geometry/Overview.html#dompointreadonly
+[Exposed=(Window,Worker,PaintWorklet)]
+interface DOMPointReadOnly {
+    [Throws] constructor(optional unrestricted double x = 0, optional unrestricted double y = 0,
+                optional unrestricted double z = 0, optional unrestricted double w = 1);
+    [NewObject] static DOMPointReadOnly fromPoint(optional DOMPointInit other = {});
+
+    readonly attribute unrestricted double x;
+    readonly attribute unrestricted double y;
+    readonly attribute unrestricted double z;
+    readonly attribute unrestricted double w;
+
+    [Default] object toJSON();
+};

components/script_bindings/webidls/DOMQuad.webidl

@@ -0,0 +1,34 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/*
+ * The origin of this IDL file is
+ * https://drafts.fxtf.org/geometry/#DOMQuad
+ *
+ * Copyright:
+ * To the extent possible under law, the editors have waived all copyright and
+ * related or neighboring rights to this work.
+ */
+
+[Exposed=(Window,Worker)]
+interface DOMQuad {
+    [Throws] constructor(optional DOMPointInit p1 = {}, optional DOMPointInit p2 = {},
+                optional DOMPointInit p3 = {}, optional DOMPointInit p4 = {});
+    [NewObject] static DOMQuad fromRect(optional DOMRectInit other = {});
+    [NewObject] static DOMQuad fromQuad(optional DOMQuadInit other = {});
+
+    [SameObject] readonly attribute DOMPoint p1;
+    [SameObject] readonly attribute DOMPoint p2;
+    [SameObject] readonly attribute DOMPoint p3;
+    [SameObject] readonly attribute DOMPoint p4;
+    [NewObject] DOMRect getBounds();
+
+    [Default] object toJSON();
+};
+
+dictionary DOMQuadInit {
+    DOMPointInit p1 = {};
+    DOMPointInit p2 = {};
+    DOMPointInit p3 = {};
+    DOMPointInit p4 = {};
+};

components/script_bindings/webidls/DOMRect.webidl

@@ -0,0 +1,20 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+// https://drafts.fxtf.org/geometry/#domrect
+
+[Exposed=(Window,Worker),
+ Serializable,
+ LegacyWindowAlias=SVGRect]
+interface DOMRect : DOMRectReadOnly {
+    [Throws] constructor(optional unrestricted double x = 0, optional unrestricted double y = 0,
+                optional unrestricted double width = 0, optional unrestricted double height = 0);
+
+    [NewObject] static DOMRect fromRect(optional DOMRectInit other = {});
+
+    inherit attribute unrestricted double x;
+    inherit attribute unrestricted double y;
+    inherit attribute unrestricted double width;
+    inherit attribute unrestricted double height;
+};

components/script_bindings/webidls/DOMRectList.webidl

@@ -0,0 +1,11 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+// https://drafts.fxtf.org/geometry-1/#domrectlist
+
+[Exposed=Window]
+interface DOMRectList {
+    readonly attribute unsigned long length;
+    getter DOMRect? item(unsigned long index);
+};

components/script_bindings/webidls/DOMRectReadOnly.webidl

@@ -0,0 +1,33 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+// https://drafts.fxtf.org/geometry/#domrect
+
+[Exposed=(Window,Worker),
+ Serializable]
+interface DOMRectReadOnly {
+  [Throws] constructor(optional unrestricted double x = 0, optional unrestricted double y = 0,
+              optional unrestricted double width = 0, optional unrestricted double height = 0);
+
+  [NewObject] static DOMRectReadOnly fromRect(optional DOMRectInit other = {});
+
+  readonly attribute unrestricted double x;
+  readonly attribute unrestricted double y;
+  readonly attribute unrestricted double width;
+  readonly attribute unrestricted double height;
+  readonly attribute unrestricted double top;
+  readonly attribute unrestricted double right;
+  readonly attribute unrestricted double bottom;
+  readonly attribute unrestricted double left;
+
+  [Default] object toJSON();
+};
+
+// https://drafts.fxtf.org/geometry/#dictdef-domrectinit
+dictionary DOMRectInit {
+  unrestricted double x = 0;
+  unrestricted double y = 0;
+  unrestricted double width = 0;
+  unrestricted double height = 0;
+};

components/script_bindings/webidls/DOMStringList.webidl

@@ -0,0 +1,18 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/*
+ * The origin of this IDL file is
+ * https://html.spec.whatwg.org/multipage/#domstringlist
+ *
+ * Copyright:
+ * To the extent possible under law, the editors have waived all copyright and
+ * related or neighboring rights to this work.
+ */
+
+[Exposed=(Window,Worker)]
+interface DOMStringList {
+  readonly attribute unsigned long length;
+  getter DOMString? item(unsigned long index);
+  boolean contains(DOMString string);
+};

components/script_bindings/webidls/DOMStringMap.webidl

@@ -0,0 +1,13 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+// https://html.spec.whatwg.org/multipage/#the-domstringmap-interface
+[Exposed=Window, LegacyOverrideBuiltIns]
+interface DOMStringMap {
+  getter DOMString (DOMString name);
+  [CEReactions, Throws]
+  setter undefined (DOMString name, DOMString value);
+  [CEReactions]
+  deleter undefined (DOMString name);
+};

components/script_bindings/webidls/DOMTokenList.webidl

@@ -0,0 +1,30 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+// https://dom.spec.whatwg.org/#domtokenlist
+[Exposed=Window]
+interface DOMTokenList {
+  [Pure]
+  readonly attribute unsigned long length;
+  [Pure]
+  getter DOMString? item(unsigned long index);
+
+  [Pure]
+  boolean contains(DOMString token);
+  [CEReactions, Throws]
+  undefined add(DOMString... tokens);
+  [CEReactions, Throws]
+  undefined remove(DOMString... tokens);
+  [CEReactions, Throws]
+  boolean toggle(DOMString token, optional boolean force);
+  [CEReactions, Throws]
+  boolean replace(DOMString token, DOMString newToken);
+  [Pure, Throws]
+  boolean supports(DOMString token);
+
+  [CEReactions, Pure]
+  stringifier attribute DOMString value;
+
+  iterable<DOMString?>;
+};

components/script_bindings/webidls/DataTransfer.webidl

@@ -0,0 +1,24 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// https://html.spec.whatwg.org/multipage/#datatransfer
+
+[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> */ any types;
+  DOMString getData(DOMString format);
+  undefined setData(DOMString format, DOMString data);
+  undefined clearData(optional DOMString format);
+  [SameObject] readonly attribute FileList files;
+};

components/script_bindings/webidls/DataTransferItem.webidl

@@ -0,0 +1,15 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// https://html.spec.whatwg.org/multipage/#datatransferitem
+
+[Exposed=Window]
+interface DataTransferItem {
+  readonly attribute DOMString kind;
+  readonly attribute DOMString type;
+  undefined getAsString(FunctionStringCallback? _callback);
+  File? getAsFile();
+};
+
+callback FunctionStringCallback = undefined (DOMString data);

components/script_bindings/webidls/DataTransferItemList.webidl

@@ -0,0 +1,15 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// https://html.spec.whatwg.org/multipage/#datatransferitemlist
+
+[Exposed=Window]
+interface DataTransferItemList {
+  readonly attribute unsigned long length;
+  getter DataTransferItem (unsigned long index);
+  [Throws] DataTransferItem? add(DOMString data, DOMString type);
+  [Throws] DataTransferItem? add(File data);
+  [Throws] undefined remove(unsigned long index);
+  undefined clear();
+};

components/script_bindings/webidls/DedicatedWorkerGlobalScope.webidl

@@ -0,0 +1,13 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+// https://html.spec.whatwg.org/multipage/#dedicatedworkerglobalscope
+[Global=(Worker,DedicatedWorker), Exposed=DedicatedWorker]
+/*sealed*/ interface DedicatedWorkerGlobalScope : WorkerGlobalScope {
+  [Throws] undefined postMessage(any message, sequence<object> transfer);
+  [Throws] undefined postMessage(any message, optional StructuredSerializeOptions options = {});
+  attribute EventHandler onmessage;
+
+  undefined close();
+};

components/script_bindings/webidls/DissimilarOriginLocation.webidl

@@ -0,0 +1,26 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+
+// This is a Servo-specific interface, used to represent locations
+// that are not similar-origin, so live in another script thread.
+// It is based on the interface for Window, but only contains the
+// accessors that do not throw security exceptions when called
+// cross-origin.
+//
+// Note that similar-origin locations are kept in the same script
+// thread, so this mechanism cannot be relied upon as the only
+// way to enforce security policy.
+
+// https://html.spec.whatwg.org/multipage/#location
+[Exposed=(Window,DissimilarOriginWindow), LegacyUnforgeable, LegacyNoInterfaceObject]
+interface DissimilarOriginLocation {
+  [Throws] attribute USVString href;
+  [Throws] undefined assign(USVString url);
+  [Throws] undefined replace(USVString url);
+  [Throws] undefined reload();
+  [Throws] stringifier;
+
+  // TODO: finish this interface
+};

components/script_bindings/webidls/DissimilarOriginWindow.webidl

@@ -0,0 +1,33 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+// This is a Servo-specific interface, used to represent windows
+// that are not similar-origin, so live in another script thread.
+// It is based on the interface for Window, but only contains the
+// accessors that do not throw security exceptions when called
+// cross-origin.
+//
+// Note that similar-origin windows are kept in the same script
+// thread, so this mechanism cannot be relied upon as the only
+// way to enforce security policy.
+
+// https://html.spec.whatwg.org/multipage/#window
+[Global=DissimilarOriginWindow, Exposed=(Window,DissimilarOriginWindow), LegacyNoInterfaceObject]
+interface DissimilarOriginWindow : GlobalScope {
+  [LegacyUnforgeable] readonly attribute WindowProxy window;
+  [BinaryName="Self_", Replaceable] readonly attribute WindowProxy self;
+  [LegacyUnforgeable] readonly attribute WindowProxy? parent;
+  [LegacyUnforgeable] readonly attribute WindowProxy? top;
+  [Replaceable] readonly attribute WindowProxy frames;
+  [Replaceable] readonly attribute unsigned long length;
+  [LegacyUnforgeable] readonly attribute DissimilarOriginLocation location;
+
+  undefined close();
+  readonly attribute boolean closed;
+  [Throws] undefined postMessage(any message, USVString targetOrigin, optional sequence<object> transfer = []);
+  [Throws] undefined postMessage(any message, optional WindowPostMessageOptions options = {});
+  attribute any opener;
+  undefined blur();
+  undefined focus();
+};

components/script_bindings/webidls/Document.webidl

@@ -0,0 +1,220 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/*
+ * The origin of this IDL file is:
+ * https://dom.spec.whatwg.org/#interface-document
+ * https://html.spec.whatwg.org/multipage/#the-document-object
+ */
+
+// https://dom.spec.whatwg.org/#interface-document
+[Exposed=Window]
+interface Document : Node {
+  [Throws] constructor();
+  [SameObject]
+  readonly attribute DOMImplementation implementation;
+  [Constant]
+  readonly attribute USVString URL;
+  [Constant]
+  readonly attribute USVString documentURI;
+  // readonly attribute USVString origin;
+  readonly attribute DOMString compatMode;
+  readonly attribute DOMString characterSet;
+  readonly attribute DOMString charset; // legacy alias of .characterSet
+  readonly attribute DOMString inputEncoding; // legacy alias of .characterSet
+  [Constant]
+  readonly attribute DOMString contentType;
+
+  [Pure]
+  readonly attribute DocumentType? doctype;
+  [Pure]
+  readonly attribute Element? documentElement;
+  HTMLCollection getElementsByTagName(DOMString qualifiedName);
+  HTMLCollection getElementsByTagNameNS(DOMString? namespace, DOMString qualifiedName);
+  HTMLCollection getElementsByClassName(DOMString classNames);
+
+  [CEReactions, NewObject, Throws]
+  Element createElement(DOMString localName, optional (DOMString or ElementCreationOptions) options = {});
+  [CEReactions, NewObject, Throws]
+  Element createElementNS(DOMString? namespace, DOMString qualifiedName,
+                          optional (DOMString or ElementCreationOptions) options = {});
+  [NewObject]
+  DocumentFragment createDocumentFragment();
+  [NewObject]
+  Text createTextNode(DOMString data);
+  [NewObject, Throws]
+  CDATASection createCDATASection(DOMString data);
+  [NewObject]
+  Comment createComment(DOMString data);
+  [NewObject, Throws]
+  ProcessingInstruction createProcessingInstruction(DOMString target, DOMString data);
+
+  [CEReactions, NewObject, Throws]
+  Node importNode(Node node, optional boolean deep = false);
+  [CEReactions, Throws]
+  Node adoptNode(Node node);
+
+  [NewObject, Throws]
+  Attr createAttribute(DOMString localName);
+  [NewObject, Throws]
+  Attr createAttributeNS(DOMString? namespace, DOMString qualifiedName);
+
+  [NewObject, Throws]
+  Event createEvent(DOMString interface_);
+
+  [NewObject]
+  Range createRange();
+
+  // NodeFilter.SHOW_ALL = 0xFFFFFFFF
+  [NewObject]
+  NodeIterator createNodeIterator(Node root, optional unsigned long whatToShow = 0xFFFFFFFF,
+                                  optional NodeFilter? filter = null);
+  [NewObject]
+  TreeWalker createTreeWalker(Node root, optional unsigned long whatToShow = 0xFFFFFFFF,
+                              optional NodeFilter? filter = null);
+};
+
+Document includes NonElementParentNode;
+Document includes ParentNode;
+
+enum DocumentReadyState { "loading", "interactive", "complete" };
+enum DocumentVisibilityState { "visible", "hidden" };
+
+dictionary ElementCreationOptions {
+  DOMString is;
+};
+
+// https://html.spec.whatwg.org/multipage/#the-document-object
+// [LegacyOverrideBuiltIns]
+partial /*sealed*/ interface Document {
+  // resource metadata management
+  [PutForwards=href, LegacyUnforgeable]
+  readonly attribute Location? location;
+  [SetterThrows] attribute DOMString domain;
+  readonly attribute DOMString referrer;
+  [Throws]
+  attribute DOMString cookie;
+  readonly attribute DOMString lastModified;
+  readonly attribute DocumentReadyState readyState;
+
+  // DOM tree accessors
+  getter NamedPropertyValue (DOMString name);
+  [CEReactions]
+           attribute DOMString title;
+  // [CEReactions]
+  //       attribute DOMString dir;
+  [CEReactions, SetterThrows]
+           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 HTMLScriptElement? currentScript;
+
+  // dynamic markup insertion
+  [CEReactions, Throws]
+  Document open(optional DOMString unused1, optional DOMString unused2);
+  [CEReactions, Throws]
+  WindowProxy? open(USVString url, DOMString name, DOMString features);
+  [CEReactions, Throws]
+  undefined close();
+  [CEReactions, Throws]
+  undefined write(DOMString... text);
+  [CEReactions, Throws]
+  undefined writeln(DOMString... text);
+
+  // user interaction
+  readonly attribute Window?/*Proxy?*/ 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;
+
+  // also has obsolete members
+};
+Document includes GlobalEventHandlers;
+Document includes DocumentAndElementEventHandlers;
+
+// https://html.spec.whatwg.org/multipage/#Document-partial
+partial interface Document {
+  [CEReactions]
+  attribute [LegacyNullToEmptyString] DOMString fgColor;
+
+  // https://github.com/servo/servo/issues/8715
+  // [CEReactions, LegacyNullToEmptyString]
+  // attribute DOMString linkColor;
+
+  // https://github.com/servo/servo/issues/8716
+  // [CEReactions, LegacyNullToEmptyString]
+  // attribute DOMString vlinkColor;
+
+  // https://github.com/servo/servo/issues/8717
+  // [CEReactions, LegacyNullToEmptyString]
+  // attribute DOMString alinkColor;
+
+  [CEReactions]
+  attribute [LegacyNullToEmptyString] DOMString bgColor;
+
+  [SameObject]
+  readonly attribute HTMLCollection anchors;
+
+  [SameObject]
+  readonly attribute HTMLCollection applets;
+
+  undefined clear();
+  undefined captureEvents();
+  undefined releaseEvents();
+
+  // Tracking issue for document.all: https://github.com/servo/servo/issues/7396
+  // readonly attribute HTMLAllCollection all;
+};
+
+// https://fullscreen.spec.whatwg.org/#api
+partial interface Document {
+  [LegacyLenientSetter] readonly attribute boolean fullscreenEnabled;
+  [LegacyLenientSetter] readonly attribute Element? fullscreenElement;
+  [LegacyLenientSetter] readonly attribute boolean fullscreen; // historical
+
+  Promise<undefined> exitFullscreen();
+
+  attribute EventHandler onfullscreenchange;
+  attribute EventHandler onfullscreenerror;
+};
+
+Document includes DocumentOrShadowRoot;
+
+// https://w3c.github.io/selection-api/#dom-document
+partial interface Document {
+  Selection? getSelection();
+};
+
+
+// Servo internal API.
+partial interface Document {
+  [Throws]
+  ShadowRoot servoGetMediaControls(DOMString id);
+};
+
+// https://html.spec.whatwg.org/multipage/#dom-document-nameditem-filter
+typedef (WindowProxy or Element or HTMLCollection) NamedPropertyValue;

components/script_bindings/webidls/DocumentFragment.webidl

@@ -0,0 +1,12 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+// https://dom.spec.whatwg.org/#interface-documentfragment
+[Exposed=Window]
+interface DocumentFragment : Node {
+  [Throws] constructor();
+};
+
+DocumentFragment includes NonElementParentNode;
+DocumentFragment includes ParentNode;

components/script_bindings/webidls/DocumentOrShadowRoot.webidl

@@ -0,0 +1,17 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/*
+ * The origin of this IDL file is
+ * https://dom.spec.whatwg.org/#documentorshadowroot
+ * https://w3c.github.io/webcomponents/spec/shadow/#extensions-to-the-documentorshadowroot-mixin
+ */
+
+interface mixin DocumentOrShadowRoot {
+  // Selection? getSelection();
+  Element? elementFromPoint (double x, double y);
+  sequence<Element> elementsFromPoint (double x, double y);
+  // CaretPosition? caretPositionFromPoint (double x, double y);
+  readonly attribute Element? activeElement;
+  readonly attribute StyleSheetList styleSheets;
+};

components/script_bindings/webidls/DocumentType.webidl

@@ -0,0 +1,22 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/*
+ * The origin of this IDL file is
+ * https://dom.spec.whatwg.org/#documenttype
+ *
+ * Copyright © 2012 W3C® (MIT, ERCIM, Keio), All Rights Reserved. W3C
+ * liability, trademark and document use rules apply.
+ */
+
+[Exposed=Window]
+interface DocumentType : Node {
+  [Constant]
+  readonly attribute DOMString name;
+  [Constant]
+  readonly attribute DOMString publicId;
+  [Constant]
+  readonly attribute DOMString systemId;
+};
+
+DocumentType includes ChildNode;

components/script_bindings/webidls/DynamicModuleOwner.webidl

@@ -0,0 +1,13 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+/**
+ * This is defined for [`Dynamic Module`](https://html.spec.whatwg.org/multipage/#fetch-an-import()-module-script-graph)
+ * so that we can hold a traceable owner for those dynamic modules which don't hold a owner.
+ */
+
+[LegacyNoInterfaceObject, Exposed=Window]
+interface DynamicModuleOwner {
+  readonly attribute Promise<any> promise;
+};

components/script_bindings/webidls/EXTBlendMinmax.webidl

@@ -0,0 +1,13 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/*
+ * WebGL IDL definitions scraped from the Khronos specification:
+ * https://www.khronos.org/registry/webgl/extensions/EXT_blend_minmax/
+ */
+
+[LegacyNoInterfaceObject, Exposed=Window]
+interface EXTBlendMinmax {
+  const GLenum MIN_EXT = 0x8007;
+  const GLenum MAX_EXT = 0x8008;
+};

components/script_bindings/webidls/EXTColorBufferHalfFloat.webidl

@@ -0,0 +1,15 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/*
+ * WebGL IDL definitions from the Khronos specification:
+ * https://www.khronos.org/registry/webgl/extensions/EXT_color_buffer_half_float/
+ */
+
+[LegacyNoInterfaceObject, Exposed=Window]
+interface EXTColorBufferHalfFloat {
+  const GLenum RGBA16F_EXT = 0x881A;
+  const GLenum RGB16F_EXT = 0x881B;
+  const GLenum FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT = 0x8211;
+  const GLenum UNSIGNED_NORMALIZED_EXT = 0x8C17;
+}; // interface EXT_color_buffer_half_float

components/script_bindings/webidls/EXTFragDepth.webidl

@@ -0,0 +1,11 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/*
+ * WebGL IDL definitions from the Khronos specification:
+ * https://www.khronos.org/registry/webgl/extensions/EXT_frag_depth/
+ */
+
+[LegacyNoInterfaceObject, Exposed=Window]
+interface EXTFragDepth {
+}; // interface EXT_frag_depth

components/script_bindings/webidls/EXTShaderTextureLod.webidl

@@ -0,0 +1,11 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/*
+ * WebGL IDL definitions scraped from the Khronos specification:
+ * https://www.khronos.org/registry/webgl/extensions/EXT_shader_texture_lod/
+ */
+
+[LegacyNoInterfaceObject, Exposed=Window]
+interface EXTShaderTextureLod {
+};

components/script_bindings/webidls/EXTTextureFilterAnisotropic.webidl

@@ -0,0 +1,13 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/*
+ * WebGL IDL definitions from the Khronos specification:
+ * https://www.khronos.org/registry/webgl/extensions/EXT_texture_filter_anisotropic/
+ */
+
+[LegacyNoInterfaceObject, Exposed=Window]
+interface EXTTextureFilterAnisotropic {
+  const GLenum TEXTURE_MAX_ANISOTROPY_EXT       = 0x84FE;
+  const GLenum MAX_TEXTURE_MAX_ANISOTROPY_EXT   = 0x84FF;
+};

components/script_bindings/webidls/Element.webidl

@@ -0,0 +1,137 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/*
+ * The origin of this IDL file is
+ * https://dom.spec.whatwg.org/#element and
+ * https://w3c.github.io/DOM-Parsing/ and
+ * http://dev.w3.org/csswg/cssom-view/ and
+ * http://www.w3.org/TR/selectors-api/
+ *
+ * Copyright © 2012 W3C® (MIT, ERCIM, Keio), All Rights Reserved. W3C
+ * liability, trademark and document use rules apply.
+ */
+
+[Exposed=Window]
+interface Element : Node {
+  [Constant]
+  readonly attribute DOMString? namespaceURI;
+  [Constant]
+  readonly attribute DOMString? prefix;
+  [Constant]
+  readonly attribute DOMString localName;
+  // Not [Constant] because it depends on which document we're in
+  [Pure]
+  readonly attribute DOMString tagName;
+
+  [CEReactions, Pure]
+           attribute DOMString id;
+  [CEReactions, Pure]
+           attribute DOMString className;
+  [SameObject, PutForwards=value]
+  readonly attribute DOMTokenList classList;
+
+  [Pure]
+  boolean hasAttributes();
+  [SameObject]
+  readonly attribute NamedNodeMap attributes;
+  [Pure]
+  sequence<DOMString> getAttributeNames();
+  [Pure]
+  DOMString? getAttribute(DOMString name);
+  [Pure]
+  DOMString? getAttributeNS(DOMString? namespace, DOMString localName);
+  [CEReactions, Throws]
+  boolean toggleAttribute(DOMString name, optional boolean force);
+  [CEReactions, Throws]
+  undefined setAttribute(DOMString name, DOMString value);
+  [CEReactions, Throws]
+  undefined setAttributeNS(DOMString? namespace, DOMString name, DOMString value);
+  [CEReactions]
+  undefined removeAttribute(DOMString name);
+  [CEReactions]
+  undefined removeAttributeNS(DOMString? namespace, DOMString localName);
+  boolean hasAttribute(DOMString name);
+  boolean hasAttributeNS(DOMString? namespace, DOMString localName);
+
+  [Pure]
+  Attr? getAttributeNode(DOMString name);
+  [Pure]
+  Attr? getAttributeNodeNS(DOMString? namespace, DOMString localName);
+  [CEReactions, Throws]
+  Attr? setAttributeNode(Attr attr);
+  [CEReactions, Throws]
+  Attr? setAttributeNodeNS(Attr attr);
+  [CEReactions, Throws]
+  Attr removeAttributeNode(Attr oldAttr);
+
+  [Pure, Throws]
+  Element? closest(DOMString selectors);
+  [Pure, Throws]
+  boolean matches(DOMString selectors);
+  [Pure, Throws]
+  boolean webkitMatchesSelector(DOMString selectors); // historical alias of .matches
+
+  HTMLCollection getElementsByTagName(DOMString localName);
+  HTMLCollection getElementsByTagNameNS(DOMString? namespace, DOMString localName);
+  HTMLCollection getElementsByClassName(DOMString classNames);
+
+  [CEReactions, Throws]
+  Element? insertAdjacentElement(DOMString where_, Element element); // historical
+  [Throws]
+  undefined insertAdjacentText(DOMString where_, DOMString data);
+  [CEReactions, Throws]
+  undefined insertAdjacentHTML(DOMString position, DOMString html);
+
+  [Throws, Pref="dom_shadowdom_enabled"] ShadowRoot attachShadow(ShadowRootInit init);
+  readonly attribute ShadowRoot? shadowRoot;
+};
+
+dictionary ShadowRootInit {
+  required ShadowRootMode mode;
+  // boolean delegatesFocus = false;
+  SlotAssignmentMode slotAssignment = "named";
+  boolean clonable = false;
+  // boolean serializable = false;
+};
+
+// http://dev.w3.org/csswg/cssom-view/#extensions-to-the-element-interface
+partial interface Element {
+  DOMRectList getClientRects();
+  [NewObject]
+  DOMRect getBoundingClientRect();
+
+  undefined scroll(optional ScrollToOptions options = {});
+  undefined scroll(unrestricted double x, unrestricted double y);
+
+  undefined scrollTo(optional ScrollToOptions options = {});
+  undefined scrollTo(unrestricted double x, unrestricted double y);
+  undefined scrollBy(optional ScrollToOptions options = {});
+  undefined scrollBy(unrestricted double x, unrestricted double y);
+  attribute unrestricted double scrollTop;
+  attribute unrestricted double scrollLeft;
+  readonly attribute long scrollWidth;
+  readonly attribute long scrollHeight;
+
+  readonly attribute long clientTop;
+  readonly attribute long clientLeft;
+  readonly attribute long clientWidth;
+  readonly attribute long clientHeight;
+};
+
+// https://w3c.github.io/DOM-Parsing/#extensions-to-the-element-interface
+partial interface Element {
+  [CEReactions, Throws] attribute [LegacyNullToEmptyString] DOMString innerHTML;
+  [CEReactions, Throws] attribute [LegacyNullToEmptyString] DOMString outerHTML;
+};
+
+// https://fullscreen.spec.whatwg.org/#api
+partial interface Element {
+  Promise<undefined> requestFullscreen();
+};
+
+Element includes ChildNode;
+Element includes NonDocumentTypeChildNode;
+Element includes ParentNode;
+Element includes ActivatableElement;
+Element includes ARIAMixin;