Merging upstream version 1.72.1+dfsg1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

29 files changed, 434 insertions, 55 deletions

diff --git a/vendor/web-sys/webidls/enabled/AnimationFrame.webidl b/vendor/web-sys/webidls/enabled/AnimationFrame.webidl
new file mode 100644
index 000000000..6f81d3e1f
--- /dev/null
+++ b/vendor/web-sys/webidls/enabled/AnimationFrame.webidl
@@ -0,0 +1,10 @@
+// https://html.spec.whatwg.org/multipage/imagebitmap-and-animations.html#animation-frames
+
+callback FrameRequestCallback = undefined (DOMHighResTimeStamp time);
+
+interface mixin AnimationFrameProvider {
+  [Throws] long requestAnimationFrame(FrameRequestCallback callback);
+  [Throws] undefined cancelAnimationFrame(long handle);
+};
+Window includes AnimationFrameProvider;
+DedicatedWorkerGlobalScope includes AnimationFrameProvider;
diff --git a/vendor/web-sys/webidls/enabled/CanvasCaptureMediaStream.webidl b/vendor/web-sys/webidls/enabled/CanvasCaptureMediaStream.webidl
index 9bd504417..f206f36f5 100644
--- a/vendor/web-sys/webidls/enabled/CanvasCaptureMediaStream.webidl
+++ b/vendor/web-sys/webidls/enabled/CanvasCaptureMediaStream.webidl
@@ -10,7 +10,7 @@
  * W3C liability, trademark and document use rules apply.
  */
 
-[Pref="canvas.capturestream.enabled"]
+[Deprecated]
 interface CanvasCaptureMediaStream : MediaStream {
     readonly attribute HTMLCanvasElement canvas;
     undefined requestFrame();
diff --git a/vendor/web-sys/webidls/enabled/CanvasCaptureMediaStreamTrack.webidl b/vendor/web-sys/webidls/enabled/CanvasCaptureMediaStreamTrack.webidl
new file mode 100644
index 000000000..e5a7a6981
--- /dev/null
+++ b/vendor/web-sys/webidls/enabled/CanvasCaptureMediaStreamTrack.webidl
@@ -0,0 +1,17 @@
+/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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://w3c.github.io/mediacapture-fromelement/index.html
+ *
+ * Copyright © 2015 W3C® (MIT, ERCIM, Keio, Beihang), All Rights Reserved.
+ * W3C liability, trademark and document use rules apply.
+ */
+
+[Exposed=Window]
+interface CanvasCaptureMediaStreamTrack : MediaStreamTrack {
+    readonly attribute HTMLCanvasElement canvas;
+    undefined requestFrame();
+};
diff --git a/vendor/web-sys/webidls/enabled/CanvasRenderingContext2D.webidl b/vendor/web-sys/webidls/enabled/CanvasRenderingContext2D.webidl
index 476a96882..a21b0e5ae 100644
--- a/vendor/web-sys/webidls/enabled/CanvasRenderingContext2D.webidl
+++ b/vendor/web-sys/webidls/enabled/CanvasRenderingContext2D.webidl
@@ -124,7 +124,7 @@ CanvasRenderingContext2D includes CanvasDrawImage;
 CanvasRenderingContext2D includes CanvasImageData;
 CanvasRenderingContext2D includes CanvasPathDrawingStyles;
 CanvasRenderingContext2D includes CanvasTextDrawingStyles;
-CanvasRenderingContext2D includes CanvasPathMethods;
+CanvasRenderingContext2D includes CanvasPath;
 CanvasRenderingContext2D includes CanvasHitRegions;
 
 interface mixin CanvasState {
@@ -201,7 +201,7 @@ interface mixin CanvasRect {
 };
 
 interface mixin CanvasDrawPath {
-  // path API (see also CanvasPathMethods)
+  // path API (see also CanvasPath)
   undefined beginPath();
   undefined fill(optional CanvasWindingRule winding = "nonzero");
   undefined fill(Path2D path, optional CanvasWindingRule winding = "nonzero");
@@ -286,31 +286,22 @@ interface mixin CanvasTextDrawingStyles {
   attribute DOMString textBaseline; // "top", "hanging", "middle", "alphabetic", "ideographic", "bottom" (default: "alphabetic")
 };
 
-interface mixin CanvasPathMethods {
+interface mixin CanvasPath {
   // shared path API methods
   undefined closePath();
-  [LenientFloat]
-  undefined moveTo(double x, double y);
-  [LenientFloat]
-  undefined lineTo(double x, double y);
-  [LenientFloat]
-  undefined quadraticCurveTo(double cpx, double cpy, double x, double y);
-
-  [LenientFloat]
-  undefined bezierCurveTo(double cp1x, double cp1y, double cp2x, double cp2y, double x, double y);
-
-  [Throws, LenientFloat]
-  undefined arcTo(double x1, double y1, double x2, double y2, double radius);
-// NOT IMPLEMENTED  [LenientFloat] undefined arcTo(double x1, double y1, double x2, double y2, double radiusX, double radiusY, double rotation);
-
-  [LenientFloat]
-  undefined rect(double x, double y, double w, double h);
-
-  [Throws, LenientFloat]
-  undefined arc(double x, double y, double radius, double startAngle, double endAngle, optional boolean anticlockwise = false);
-
-  [Throws, LenientFloat]
-  undefined ellipse(double x, double y, double radiusX, double radiusY, double rotation, double startAngle, double endAngle, optional boolean anticlockwise = false);
+  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 roundRect(unrestricted double x, unrestricted double y, unrestricted double w, unrestricted double h, optional (unrestricted double or DOMPointInit or sequence<(unrestricted double or DOMPointInit)>) radii = 0);
+  [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 radiusX, unrestricted double radiusY, unrestricted double rotation, unrestricted double startAngle, unrestricted double endAngle, optional boolean anticlockwise = false);
 };
 
 interface mixin CanvasHitRegions {
@@ -371,4 +362,4 @@ interface Path2D
 {
   undefined addPath(Path2D path, optional SVGMatrix transformation);
 };
-Path2D includes CanvasPathMethods;
+Path2D includes CanvasPath;
diff --git a/vendor/web-sys/webidls/enabled/DOMException.webidl b/vendor/web-sys/webidls/enabled/DOMException.webidl
index 7e9791870..7ce10e3a5 100644
--- a/vendor/web-sys/webidls/enabled/DOMException.webidl
+++ b/vendor/web-sys/webidls/enabled/DOMException.webidl
@@ -42,7 +42,7 @@ interface mixin ExceptionMembers
   [ChromeOnly, Exposed=Window]
   readonly attribute StackFrame?             location;
 
-  // Arbitary data for the implementation.
+  // Arbitrary data for the implementation.
   [Exposed=Window]
   readonly attribute nsISupports?            data;
 
diff --git a/vendor/web-sys/webidls/enabled/Document.webidl b/vendor/web-sys/webidls/enabled/Document.webidl
index df41dfbf1..a0dba3e5d 100644
--- a/vendor/web-sys/webidls/enabled/Document.webidl
+++ b/vendor/web-sys/webidls/enabled/Document.webidl
@@ -355,7 +355,7 @@ partial interface Document {
   [ChromeOnly] readonly attribute boolean userHasInteracted;
 };
 
-// Extension to give chrome JS the ability to simulate activate the docuement
+// Extension to give chrome JS the ability to simulate activate the document
 // by user gesture.
 partial interface Document {
   [ChromeOnly]
diff --git a/vendor/web-sys/webidls/enabled/Element.webidl b/vendor/web-sys/webidls/enabled/Element.webidl
index 02704b318..2aa383a2a 100644
--- a/vendor/web-sys/webidls/enabled/Element.webidl
+++ b/vendor/web-sys/webidls/enabled/Element.webidl
@@ -110,7 +110,7 @@ interface Element : Node {
   /**
    * Set this during a mousedown event to grab and retarget all mouse events
    * to this element until the mouse button is released or releaseCapture is
-   * called. If retargetToElement is true, then all events are targetted at
+   * called. If retargetToElement is true, then all events are targeted at
    * this element. If false, events can also fire at descendants of this
    * element.
    *
diff --git a/vendor/web-sys/webidls/enabled/HTMLCanvasElement.webidl b/vendor/web-sys/webidls/enabled/HTMLCanvasElement.webidl
index 6d9f58280..708122a9e 100644
--- a/vendor/web-sys/webidls/enabled/HTMLCanvasElement.webidl
+++ b/vendor/web-sys/webidls/enabled/HTMLCanvasElement.webidl
@@ -36,8 +36,15 @@ interface HTMLCanvasElement : HTMLElement {
 // For OffscreenCanvas
 // Reference: https://wiki.whatwg.org/wiki/OffscreenCanvas
 partial interface HTMLCanvasElement {
-  [Pref="gfx.offscreencanvas.enabled", Throws]
+  [Throws]
   OffscreenCanvas transferControlToOffscreen();
 };
 
+// For MediaStream
+// Reference: https://w3c.github.io/mediacapture-main/getusermedia.html#idl-def-mediastream
+partial interface HTMLCanvasElement {
+  [Throws]
+  MediaStream captureStream (optional double frameRequestRate);
+};
+
 callback BlobCallback = undefined(Blob? blob);
diff --git a/vendor/web-sys/webidls/enabled/HTMLInputElement.webidl b/vendor/web-sys/webidls/enabled/HTMLInputElement.webidl
index 572f7468e..32a0e22e8 100644
--- a/vendor/web-sys/webidls/enabled/HTMLInputElement.webidl
+++ b/vendor/web-sys/webidls/enabled/HTMLInputElement.webidl
@@ -12,7 +12,6 @@
  * and create derivative works of this document.
  */
 
-/*TODO
 enum SelectionMode {
   "select",
   "start",
@@ -20,6 +19,7 @@ enum SelectionMode {
   "preserve",
 };
 
+/*TODO
 interface XULControllers;
 */
 
diff --git a/vendor/web-sys/webidls/enabled/HTMLMenuElement.webidl b/vendor/web-sys/webidls/enabled/HTMLMenuElement.webidl
index 5f1f13081..32b9a1f6a 100644
--- a/vendor/web-sys/webidls/enabled/HTMLMenuElement.webidl
+++ b/vendor/web-sys/webidls/enabled/HTMLMenuElement.webidl
@@ -12,13 +12,21 @@
  * and create derivative works of this document.
  */
 
-/* TODO
-interface MenuBuilder;
-*/
-
-// http://www.whatwg.org/specs/web-apps/current-work/#the-menu-element
+// https://developer.mozilla.org/en-US/docs/Web/HTML/Element/menu
+// > The <menu> and <ul> elements both represent an unordered list of items.
+// > The key difference is that <ul> primarily contains items for display,
+// > while <menu> was intended for interactive items.
 [HTMLConstructor]
 interface HTMLMenuElement : HTMLElement {
+};
+
+// > In early versions of the HTML specification, the <menu> element had
+// > an additional use case as a context menu. This functionality is considered
+// > obsolete and is not in the specification.
+// Define this as deprecated partial interface to prevent breaking changes
+// in wasm-bindgen.
+[RustDeprecated="Absent in all major browsers"]
+partial interface HTMLMenuElement {
            [CEReactions, SetterThrows]
            attribute DOMString type;
            [CEReactions, SetterThrows]
diff --git a/vendor/web-sys/webidls/enabled/HTMLMenuItemElement.webidl b/vendor/web-sys/webidls/enabled/HTMLMenuItemElement.webidl
index 648188e2c..5b807644c 100644
--- a/vendor/web-sys/webidls/enabled/HTMLMenuItemElement.webidl
+++ b/vendor/web-sys/webidls/enabled/HTMLMenuItemElement.webidl
@@ -11,8 +11,10 @@
  * and create derivative works of this document.
  */
 
-// http://www.whatwg.org/specs/web-apps/current-work/#the-menuitem-element
-[HTMLConstructor]
+// https://developer.mozilla.org/en-US/docs/Web/HTML/Element/menu
+// > The related <menuitem> element has been deprecated.
+// Keep this in wasm-bindgen to prevent breaking changes.
+[HTMLConstructor, RustDeprecated="Absent in all major browsers"]
 interface HTMLMenuItemElement : HTMLElement {
            [CEReactions, SetterThrows]
            attribute DOMString type;
diff --git a/vendor/web-sys/webidls/enabled/HTMLTextAreaElement.webidl b/vendor/web-sys/webidls/enabled/HTMLTextAreaElement.webidl
index e20773c26..c3487ff69 100644
--- a/vendor/web-sys/webidls/enabled/HTMLTextAreaElement.webidl
+++ b/vendor/web-sys/webidls/enabled/HTMLTextAreaElement.webidl
@@ -74,7 +74,7 @@ interface HTMLTextAreaElement : HTMLElement {
   undefined setRangeText(DOMString replacement);
   [Throws]
   undefined setRangeText(DOMString replacement, unsigned long start,
-    unsigned long end, optional SelectionMode selectionMode = "preserve");
+    unsigned long end, optional DOMString mode);
   [Throws]
   undefined setSelectionRange(unsigned long start, unsigned long end, optional DOMString direction);
 };
diff --git a/vendor/web-sys/webidls/enabled/ImageBitmapRenderingContext.webidl b/vendor/web-sys/webidls/enabled/ImageBitmapRenderingContext.webidl
index 7a4e0fde5..e8c1b38ff 100644
--- a/vendor/web-sys/webidls/enabled/ImageBitmapRenderingContext.webidl
+++ b/vendor/web-sys/webidls/enabled/ImageBitmapRenderingContext.webidl
@@ -28,7 +28,7 @@ interface ImageBitmapRenderingContext {
   // it does not change the canvas's intrinsic width or height.
   //
   // The ImageBitmap, when displayed, is clipped to the rectangle
-  // defined by the canvas's instrinsic width and height. Pixels that
+  // defined by the canvas's intrinsic width and height. Pixels that
   // would be covered by the canvas's bitmap which are not covered by
   // the supplied ImageBitmap are rendered transparent black. Any CSS
   // styles affecting the display of the canvas are applied as usual.
diff --git a/vendor/web-sys/webidls/enabled/OffscreenCanvas.webidl b/vendor/web-sys/webidls/enabled/OffscreenCanvas.webidl
index c1bc84bea..2273e4a9b 100644
--- a/vendor/web-sys/webidls/enabled/OffscreenCanvas.webidl
+++ b/vendor/web-sys/webidls/enabled/OffscreenCanvas.webidl
@@ -7,6 +7,11 @@
  * https://wiki.whatwg.org/wiki/OffscreenCanvas
  */
 
+dictionary ImageEncodeOptions {
+  DOMString type = "image/png";
+  unrestricted double quality;
+};
+
 [Constructor(unsigned long width, unsigned long height),
  Exposed=(Window,Worker),
  Func="mozilla::dom::DOMPrefs::OffscreenCanvasEnabled"]
@@ -23,8 +28,7 @@ interface OffscreenCanvas : EventTarget {
   [Throws]
   ImageBitmap transferToImageBitmap();
   [Throws]
-  Promise<Blob> toBlob(optional DOMString type = "",
-                       optional any encoderOptions);
+  Promise<Blob> convertToBlob(optional ImageEncodeOptions options = {});
 };
 
 // OffscreenCanvas includes Transferable;
diff --git a/vendor/web-sys/webidls/enabled/OffscreenCanvasRenderingContext2D.webidl b/vendor/web-sys/webidls/enabled/OffscreenCanvasRenderingContext2D.webidl
new file mode 100644
index 000000000..621f80bdf
--- /dev/null
+++ b/vendor/web-sys/webidls/enabled/OffscreenCanvasRenderingContext2D.webidl
@@ -0,0 +1,22 @@
+[Exposed = (Window, Worker)]
+interface OffscreenCanvasRenderingContext2D {
+  // `commit()` doesn't exist, spec has to be updated: <https://github.com/whatwg/html/pull/3872>
+  // undefined commit();
+  readonly attribute OffscreenCanvas canvas;
+};
+
+OffscreenCanvasRenderingContext2D includes CanvasState;
+OffscreenCanvasRenderingContext2D includes CanvasTransform;
+OffscreenCanvasRenderingContext2D includes CanvasCompositing;
+OffscreenCanvasRenderingContext2D includes CanvasImageSmoothing;
+OffscreenCanvasRenderingContext2D includes CanvasFillStrokeStyles;
+OffscreenCanvasRenderingContext2D includes CanvasShadowStyles;
+OffscreenCanvasRenderingContext2D includes CanvasFilters;
+OffscreenCanvasRenderingContext2D includes CanvasRect;
+OffscreenCanvasRenderingContext2D includes CanvasDrawPath;
+OffscreenCanvasRenderingContext2D includes CanvasText;
+OffscreenCanvasRenderingContext2D includes CanvasDrawImage;
+OffscreenCanvasRenderingContext2D includes CanvasImageData;
+OffscreenCanvasRenderingContext2D includes CanvasPathDrawingStyles;
+OffscreenCanvasRenderingContext2D includes CanvasTextDrawingStyles;
+OffscreenCanvasRenderingContext2D includes CanvasPath;
diff --git a/vendor/web-sys/webidls/enabled/ParentNode.webidl b/vendor/web-sys/webidls/enabled/ParentNode.webidl
index 5256d189b..b94c876f3 100644
--- a/vendor/web-sys/webidls/enabled/ParentNode.webidl
+++ b/vendor/web-sys/webidls/enabled/ParentNode.webidl
@@ -21,4 +21,6 @@ interface mixin ParentNode {
   undefined prepend((Node or DOMString)... nodes);
   [CEReactions, Throws, Unscopable]
   undefined append((Node or DOMString)... nodes);
+  [CEReactions, Unscopable]
+  undefined replaceChildren((Node or DOMString)... nodes);
 };
diff --git a/vendor/web-sys/webidls/enabled/PresentationConnection.webidl b/vendor/web-sys/webidls/enabled/PresentationConnection.webidl
index 753dfee16..e3bc8c5a6 100644
--- a/vendor/web-sys/webidls/enabled/PresentationConnection.webidl
+++ b/vendor/web-sys/webidls/enabled/PresentationConnection.webidl
@@ -9,7 +9,7 @@
 
 enum PresentationConnectionState
 {
-  // The initial state when a PresentationConnection is ceated.
+  // The initial state when a PresentationConnection is created.
   "connecting",
 
   // Existing presentation, and the communication channel is active.
diff --git a/vendor/web-sys/webidls/enabled/RTCPeerConnection.webidl b/vendor/web-sys/webidls/enabled/RTCPeerConnection.webidl
index 9c74b611e..b91563e99 100644
--- a/vendor/web-sys/webidls/enabled/RTCPeerConnection.webidl
+++ b/vendor/web-sys/webidls/enabled/RTCPeerConnection.webidl
@@ -36,6 +36,15 @@ enum RTCIceConnectionState {
     "closed"
 };
 
+enum RTCPeerConnectionState {
+  "closed",
+  "failed",
+  "disconnected",
+  "new",
+  "connecting",
+  "connected"
+};
+
 dictionary RTCDataChannelInit {
   boolean        ordered = true;
   unsigned short maxPacketLifeTime;
@@ -89,6 +98,7 @@ interface RTCPeerConnection : EventTarget  {
   readonly attribute boolean? canTrickleIceCandidates;
   readonly attribute RTCIceGatheringState iceGatheringState;
   readonly attribute RTCIceConnectionState iceConnectionState;
+  readonly attribute RTCPeerConnectionState connectionState;
   [Pref="media.peerconnection.identity.enabled"]
   readonly attribute Promise<RTCIdentityAssertion> peerIdentity;
   [Pref="media.peerconnection.identity.enabled"]
@@ -130,6 +140,7 @@ interface RTCPeerConnection : EventTarget  {
   attribute EventHandler onremovestream;
   attribute EventHandler oniceconnectionstatechange;
   attribute EventHandler onicegatheringstatechange;
+  attribute EventHandler onconnectionstatechange;
 
   Promise<RTCStatsReport> getStats (optional MediaStreamTrack? selector);
 
diff --git a/vendor/web-sys/webidls/enabled/RTCRtpSender.webidl b/vendor/web-sys/webidls/enabled/RTCRtpSender.webidl
index e7b375b90..3b1c49c7b 100644
--- a/vendor/web-sys/webidls/enabled/RTCRtpSender.webidl
+++ b/vendor/web-sys/webidls/enabled/RTCRtpSender.webidl
@@ -76,7 +76,7 @@ interface RTCRtpSender {
   Promise<RTCStatsReport> getStats();
   [Pref="media.peerconnection.dtmf.enabled"]
   readonly attribute RTCDTMFSender? dtmf;
-  // Ugh, can't use a ChromeOnly attibute sequence<MediaStream>...
+  // Ugh, can't use a ChromeOnly attribute sequence<MediaStream>...
   [ChromeOnly]
   sequence<MediaStream> getStreams();
   [ChromeOnly]
diff --git a/vendor/web-sys/webidls/unstable/ResizeObserver.webidl b/vendor/web-sys/webidls/enabled/ResizeObserver.webidl
index 48876887d..48876887d 100644
--- a/vendor/web-sys/webidls/unstable/ResizeObserver.webidl
+++ b/vendor/web-sys/webidls/enabled/ResizeObserver.webidl
diff --git a/vendor/web-sys/webidls/enabled/ScrollBoxObject.webidl b/vendor/web-sys/webidls/enabled/ScrollBoxObject.webidl
index 4f9e31f49..b9cff7fd8 100644
--- a/vendor/web-sys/webidls/enabled/ScrollBoxObject.webidl
+++ b/vendor/web-sys/webidls/enabled/ScrollBoxObject.webidl
@@ -18,7 +18,7 @@ interface ScrollBoxObject : BoxObject {
 
   /**
    * Scroll the given amount of device pixels to the right and down.
-   * Values will be clamped to make the resuling position legal.
+   * Values will be clamped to make the resulting position legal.
    */
   [Throws]
   undefined scrollBy(long dx, long dy);
diff --git a/vendor/web-sys/webidls/enabled/ServiceWorkerContainer.webidl b/vendor/web-sys/webidls/enabled/ServiceWorkerContainer.webidl
index 3d0bc34f2..384b53cd4 100644
--- a/vendor/web-sys/webidls/enabled/ServiceWorkerContainer.webidl
+++ b/vendor/web-sys/webidls/enabled/ServiceWorkerContainer.webidl
@@ -42,5 +42,6 @@ partial interface ServiceWorkerContainer {
 
 dictionary RegistrationOptions {
   USVString scope;
+  USVString type;
   ServiceWorkerUpdateViaCache updateViaCache = "imports";
 };
diff --git a/vendor/web-sys/webidls/enabled/TreeView.webidl b/vendor/web-sys/webidls/enabled/TreeView.webidl
index 9aee1ce40..2ec994275 100644
--- a/vendor/web-sys/webidls/enabled/TreeView.webidl
+++ b/vendor/web-sys/webidls/enabled/TreeView.webidl
@@ -110,7 +110,7 @@ interface TreeView
   /**
    * The level is an integer value that represents
    * the level of indentation.  It is multiplied by the width specified in the 
-   * :moz-tree-indentation pseudoelement to compute the exact indendation.
+   * :moz-tree-indentation pseudoelement to compute the exact indentation.
    */
   [Throws]
   long getLevel(long row);
diff --git a/vendor/web-sys/webidls/enabled/Window.webidl b/vendor/web-sys/webidls/enabled/Window.webidl
index d2985fca9..fb8735f8b 100644
--- a/vendor/web-sys/webidls/enabled/Window.webidl
+++ b/vendor/web-sys/webidls/enabled/Window.webidl
@@ -9,7 +9,6 @@
  * https://dvcs.w3.org/hg/IndexedDB/raw-file/tip/Overview.html
  * http://dev.w3.org/csswg/cssom/
  * http://dev.w3.org/csswg/cssom-view/
- * https://dvcs.w3.org/hg/webperf/raw-file/tip/specs/RequestAnimationFrame/Overview.html
  * https://dvcs.w3.org/hg/webperf/raw-file/tip/specs/NavigationTiming/Overview.html
  * https://dvcs.w3.org/hg/webcrypto-api/raw-file/tip/spec/Overview.html
  * http://dvcs.w3.org/hg/speech-api/raw-file/tip/speechapi.html
@@ -196,13 +195,6 @@ partial interface Window {
   [Replaceable] readonly attribute double devicePixelRatio;
 };
 
-// https://dvcs.w3.org/hg/webperf/raw-file/tip/specs/RequestAnimationFrame/Overview.html
-partial interface Window {
-  [Throws] long requestAnimationFrame(FrameRequestCallback callback);
-  [Throws] undefined cancelAnimationFrame(long handle);
-};
-callback FrameRequestCallback = undefined (DOMHighResTimeStamp time);
-
 // https://dvcs.w3.org/hg/webperf/raw-file/tip/specs/NavigationTiming/Overview.html
 partial interface Window {
   [Replaceable, Pure, StoreInSlot] readonly attribute Performance? performance;
diff --git a/vendor/web-sys/webidls/unstable/Animatable.webidl b/vendor/web-sys/webidls/unstable/Animatable.webidl
new file mode 100644
index 000000000..26a6c9f87
--- /dev/null
+++ b/vendor/web-sys/webidls/unstable/Animatable.webidl
@@ -0,0 +1,14 @@
+interface mixin Animatable {
+    Animation           animate(object? keyframes,
+                                optional (unrestricted double or KeyframeAnimationOptions) options = {});
+    sequence<Animation> getAnimations(optional GetAnimationsOptions options = {});
+};
+
+dictionary KeyframeAnimationOptions : KeyframeEffectOptions {
+    DOMString id = "";
+    AnimationTimeline? timeline;
+};
+
+dictionary GetAnimationsOptions {
+    boolean subtree = false;
+};
diff --git a/vendor/web-sys/webidls/unstable/FileSystemAccess.webidl b/vendor/web-sys/webidls/unstable/FileSystemAccess.webidl
new file mode 100644
index 000000000..cc5623bdb
--- /dev/null
+++ b/vendor/web-sys/webidls/unstable/FileSystemAccess.webidl
@@ -0,0 +1,101 @@
+enum FileSystemHandleKind {
+  "file",
+  "directory",
+};
+
+[Exposed=(Window,Worker), SecureContext, Serializable]
+interface FileSystemHandle {
+  readonly attribute FileSystemHandleKind kind;
+  readonly attribute USVString name;
+
+  Promise<boolean> isSameEntry(FileSystemHandle other);
+};
+
+dictionary FileSystemCreateWritableOptions {
+  boolean keepExistingData = false;
+};
+
+[Exposed=(Window,Worker), SecureContext, Serializable]
+interface FileSystemFileHandle : FileSystemHandle {
+  Promise<File> getFile();
+  Promise<FileSystemWritableFileStream> createWritable(optional FileSystemCreateWritableOptions options = {});
+  [Exposed=DedicatedWorker]
+  Promise<FileSystemSyncAccessHandle> createSyncAccessHandle();
+};
+
+dictionary FileSystemGetFileOptions {
+  boolean create = false;
+};
+
+dictionary FileSystemGetDirectoryOptions {
+  boolean create = false;
+};
+
+dictionary FileSystemRemoveOptions {
+  boolean recursive = false;
+};
+
+[Exposed=(Window,Worker), SecureContext, Serializable]
+interface FileSystemDirectoryHandle : FileSystemHandle {
+  async iterable<USVString, FileSystemHandle>;
+
+  Promise<FileSystemFileHandle> getFileHandle(USVString name, optional FileSystemGetFileOptions options = {});
+  Promise<FileSystemDirectoryHandle> getDirectoryHandle(USVString name, optional FileSystemGetDirectoryOptions options = {});
+
+  Promise<undefined> removeEntry(USVString name, optional FileSystemRemoveOptions options = {});
+
+  Promise<sequence<USVString>?> resolve(FileSystemHandle possibleDescendant);
+};
+
+enum WriteCommandType {
+  "write",
+  "seek",
+  "truncate",
+};
+
+dictionary WriteParams {
+  required WriteCommandType type;
+  unsigned long long? size;
+  unsigned long long? position;
+  (BufferSource or Blob or USVString)? data;
+};
+
+typedef (BufferSource or Blob or USVString or WriteParams) FileSystemWriteChunkType;
+
+[Exposed=(Window,Worker), SecureContext]
+interface FileSystemWritableFileStream : WritableStream {
+  [Throws]
+  Promise<undefined> write(FileSystemWriteChunkType data);
+  [Throws]
+  Promise<undefined> seek(unsigned long long position);
+  [Throws]
+  Promise<undefined> truncate(unsigned long long size);
+};
+
+dictionary FileSystemReadWriteOptions {
+  [EnforceRange] unsigned long long at;
+};
+
+[Exposed=DedicatedWorker, SecureContext]
+interface FileSystemSyncAccessHandle {
+  [Throws]
+  unsigned long long read([AllowShared] BufferSource buffer,
+                          optional FileSystemReadWriteOptions options = {});
+  [Throws]
+  unsigned long long write([AllowShared] BufferSource buffer,
+                           optional FileSystemReadWriteOptions options = {});
+
+  [Throws]
+  undefined truncate([EnforceRange] unsigned long long newSize);
+  [Throws]
+  unsigned long long getSize();
+  [Throws]
+  undefined flush();
+  undefined close();
+};
+
+
+[SecureContext]
+partial interface StorageManager {
+  Promise<FileSystemDirectoryHandle> getDirectory();
+};
diff --git a/vendor/web-sys/webidls/unstable/LocalFontAccess.webidl b/vendor/web-sys/webidls/unstable/LocalFontAccess.webidl
new file mode 100644
index 000000000..d6d6d3b22
--- /dev/null
+++ b/vendor/web-sys/webidls/unstable/LocalFontAccess.webidl
@@ -0,0 +1,20 @@
+[SecureContext]
+partial interface Window {
+  [Throws]
+  Promise<sequence<FontData>> queryLocalFonts(optional QueryOptions options = {});
+};
+
+dictionary QueryOptions {
+  sequence<DOMString> postscriptNames;
+};
+
+[Exposed=Window]
+interface FontData {
+  Promise<Blob> blob();
+
+  // Names
+  readonly attribute USVString postscriptName;
+  readonly attribute USVString fullName;
+  readonly attribute USVString family;
+  readonly attribute USVString style;
+};
diff --git a/vendor/web-sys/webidls/unstable/MeasureMemory.webidl b/vendor/web-sys/webidls/unstable/MeasureMemory.webidl
new file mode 100644
index 000000000..47e442f88
--- /dev/null
+++ b/vendor/web-sys/webidls/unstable/MeasureMemory.webidl
@@ -0,0 +1,27 @@
+/* Source: https://wicg.github.io/performance-measure-memory/#idl-index */
+
+dictionary MemoryMeasurement {
+  unsigned long long bytes;
+  sequence<MemoryBreakdownEntry> breakdown;
+};
+
+dictionary MemoryBreakdownEntry {
+  unsigned long long bytes;
+  sequence<MemoryAttribution> attribution;
+  sequence<DOMString> types;
+};
+
+dictionary MemoryAttribution {
+  USVString url;
+  MemoryAttributionContainer container;
+  DOMString scope;
+};
+
+dictionary MemoryAttributionContainer {
+  DOMString id;
+  USVString src;
+};
+
+partial interface Performance {
+  [Exposed=(Window,ServiceWorker,SharedWorker), CrossOriginIsolated] Promise<MemoryMeasurement> measureUserAgentSpecificMemory();
+};
diff --git a/vendor/web-sys/webidls/unstable/WebTransport.webidl b/vendor/web-sys/webidls/unstable/WebTransport.webidl
new file mode 100644
index 000000000..f0a85b948
--- /dev/null
+++ b/vendor/web-sys/webidls/unstable/WebTransport.webidl
@@ -0,0 +1,150 @@
+/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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://www.w3.org/TR/webtransport/
+ *
+ * © Copyright 2004-2011 Apple Computer, Inc., Mozilla Foundation, and Opera Software ASA.
+ * You are granted a license to use, reproduce and create derivative works of this document.
+ */
+
+[Exposed=(Window,Worker), SecureContext]
+interface WebTransportDatagramDuplexStream {
+  readonly attribute ReadableStream readable;
+  readonly attribute WritableStream writable;
+
+  readonly attribute unsigned long maxDatagramSize;
+  attribute unrestricted double incomingMaxAge;
+  attribute unrestricted double outgoingMaxAge;
+  attribute unrestricted double incomingHighWaterMark;
+  attribute unrestricted double outgoingHighWaterMark;
+};
+
+[Exposed=(Window,Worker), SecureContext]
+interface WebTransport {
+  constructor(USVString url, optional WebTransportOptions options = {});
+
+  Promise<WebTransportStats> getStats();
+  readonly attribute Promise<undefined> ready;
+  readonly attribute WebTransportReliabilityMode reliability;
+  readonly attribute WebTransportCongestionControl congestionControl;
+  readonly attribute Promise<WebTransportCloseInfo> closed;
+  readonly attribute Promise<undefined> draining;
+  undefined close(optional WebTransportCloseInfo closeInfo = {});
+
+  readonly attribute WebTransportDatagramDuplexStream datagrams;
+
+  Promise<WebTransportBidirectionalStream> createBidirectionalStream(
+      optional WebTransportSendStreamOptions options = {});
+  /* a ReadableStream of WebTransportBidirectionalStream objects */
+  readonly attribute ReadableStream incomingBidirectionalStreams;
+
+  Promise<WebTransportSendStream> createUnidirectionalStream(
+      optional WebTransportSendStreamOptions options = {});
+  /* a ReadableStream of WebTransportReceiveStream objects */
+  readonly attribute ReadableStream incomingUnidirectionalStreams;
+};
+
+enum WebTransportReliabilityMode {
+  "pending",
+  "reliable-only",
+  "supports-unreliable",
+};
+
+dictionary WebTransportHash {
+  DOMString algorithm;
+  BufferSource value;
+};
+
+dictionary WebTransportOptions {
+  boolean allowPooling = false;
+  boolean requireUnreliable = false;
+  sequence<WebTransportHash> serverCertificateHashes;
+  WebTransportCongestionControl congestionControl = "default";
+};
+
+enum WebTransportCongestionControl {
+  "default",
+  "throughput",
+  "low-latency",
+};
+
+dictionary WebTransportCloseInfo {
+  unsigned long closeCode = 0;
+  USVString reason = "";
+};
+
+dictionary WebTransportSendStreamOptions {
+  long long? sendOrder = null;
+};
+
+dictionary WebTransportStats {
+  DOMHighResTimeStamp timestamp;
+  unsigned long long bytesSent;
+  unsigned long long packetsSent;
+  unsigned long long packetsLost;
+  unsigned long numOutgoingStreamsCreated;
+  unsigned long numIncomingStreamsCreated;
+  unsigned long long bytesReceived;
+  unsigned long long packetsReceived;
+  DOMHighResTimeStamp smoothedRtt;
+  DOMHighResTimeStamp rttVariation;
+  DOMHighResTimeStamp minRtt;
+  WebTransportDatagramStats datagrams;
+};
+
+dictionary WebTransportDatagramStats {
+  DOMHighResTimeStamp timestamp;
+  unsigned long long expiredOutgoing;
+  unsigned long long droppedIncoming;
+  unsigned long long lostOutgoing;
+};
+
+[Exposed=(Window,Worker), SecureContext, Transferable]
+interface WebTransportSendStream : WritableStream {
+  Promise<WebTransportSendStreamStats> getStats();
+};
+
+dictionary WebTransportSendStreamStats {
+  DOMHighResTimeStamp timestamp;
+  unsigned long long bytesWritten;
+  unsigned long long bytesSent;
+  unsigned long long bytesAcknowledged;
+};
+
+[Exposed=(Window,Worker), SecureContext, Transferable]
+interface WebTransportReceiveStream : ReadableStream {
+  Promise<WebTransportReceiveStreamStats> getStats();
+};
+
+dictionary WebTransportReceiveStreamStats {
+  DOMHighResTimeStamp timestamp;
+  unsigned long long bytesReceived;
+  unsigned long long bytesRead;
+};
+
+[Exposed=(Window,Worker), SecureContext]
+interface WebTransportBidirectionalStream {
+  readonly attribute WebTransportReceiveStream readable;
+  readonly attribute WebTransportSendStream writable;
+};
+
+[Exposed=(Window,Worker), Serializable, SecureContext]
+interface WebTransportError : DOMException {
+  constructor(optional DOMString message = "", optional WebTransportErrorOptions options = {});
+
+  readonly attribute WebTransportErrorSource source;
+  readonly attribute octet? streamErrorCode;
+};
+
+dictionary WebTransportErrorOptions {
+  WebTransportErrorSource source = "stream";
+  [Clamp] octet? streamErrorCode = null;
+};
+
+enum WebTransportErrorSource {
+  "stream",
+  "session",
+};