Vendor things

third-party/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;
+};

third-party/vendor/web-sys/webidls/unstable/AudioContext.webidl

@@ -0,0 +1,18 @@
+enum AudioSinkType {
+    "none"
+};
+
+dictionary AudioSinkOptions {
+    required AudioSinkType type;
+};
+
+partial dictionary AudioContextOptions {
+    (DOMString or AudioSinkOptions) sinkId;
+};
+
+partial interface AudioContext {
+  [SecureContext] readonly attribute (DOMString or AudioSinkInfo) sinkId;
+
+  [SecureContext] Promise<undefined> setSinkId ((DOMString or AudioSinkOptions) sinkId);
+  attribute EventHandler onsinkchange;
+};

third-party/vendor/web-sys/webidls/unstable/AudioSinkInfo.webidl

@@ -0,0 +1,4 @@
+[Exposed=Window]
+interface AudioSinkInfo {
+    readonly attribute AudioSinkType type;
+};

third-party/vendor/web-sys/webidls/unstable/Bluetooth.webidl

@@ -0,0 +1,236 @@
+dictionary BluetoothDataFilterInit {
+  BufferSource dataPrefix;
+  BufferSource mask;
+};
+
+dictionary BluetoothLEScanFilterInit {
+  sequence<BluetoothServiceUUID> services;
+  DOMString name;
+  DOMString namePrefix;
+  // Maps unsigned shorts to BluetoothDataFilters.
+  object manufacturerData;
+  // Maps BluetoothServiceUUIDs to BluetoothDataFilters.
+  object serviceData;
+};
+
+dictionary RequestDeviceOptions {
+  sequence<BluetoothLEScanFilterInit> filters;
+  sequence<BluetoothServiceUUID> optionalServices = [];
+  boolean acceptAllDevices = false;
+};
+
+[Exposed=Window, SecureContext]
+interface Bluetooth : EventTarget {
+  Promise<boolean> getAvailability();
+  attribute EventHandler onavailabilitychanged;
+  [SameObject]
+  readonly attribute BluetoothDevice? referringDevice;
+  Promise<sequence<BluetoothDevice>> getDevices();
+  Promise<BluetoothDevice> requestDevice(RequestDeviceOptions options);
+};
+
+Bluetooth includes BluetoothDeviceEventHandlers;
+Bluetooth includes CharacteristicEventHandlers;
+Bluetooth includes ServiceEventHandlers;
+
+dictionary BluetoothPermissionDescriptor : PermissionDescriptor {
+  DOMString deviceId;
+  // These match RequestDeviceOptions.
+  sequence<BluetoothLEScanFilterInit> filters;
+  sequence<BluetoothServiceUUID> optionalServices = [];
+  boolean acceptAllDevices = false;
+};
+
+dictionary AllowedBluetoothDevice {
+  required DOMString deviceId;
+  required boolean mayUseGATT;
+  // An allowedServices of "all" means all services are allowed.
+  required (DOMString or sequence<UUID>) allowedServices;
+};
+dictionary BluetoothPermissionStorage {
+  required sequence<AllowedBluetoothDevice> allowedDevices;
+};
+
+[Exposed=Window]
+interface BluetoothPermissionResult : PermissionStatus {
+  attribute FrozenArray<BluetoothDevice> devices;
+};
+
+[
+  Exposed=Window,
+  SecureContext
+]
+interface ValueEvent : Event {
+  constructor(DOMString type, optional ValueEventInit initDict = {});
+  readonly attribute any value;
+};
+
+dictionary ValueEventInit : EventInit {
+  any value = null;
+};
+
+[Exposed=Window, SecureContext]
+interface BluetoothDevice : EventTarget {
+  readonly attribute DOMString id;
+  readonly attribute DOMString? name;
+  readonly attribute BluetoothRemoteGATTServer? gatt;
+
+  Promise<undefined> watchAdvertisements(
+      optional WatchAdvertisementsOptions options = {});
+  readonly attribute boolean watchingAdvertisements;
+};
+BluetoothDevice includes BluetoothDeviceEventHandlers;
+BluetoothDevice includes CharacteristicEventHandlers;
+BluetoothDevice includes ServiceEventHandlers;
+
+dictionary WatchAdvertisementsOptions {
+  AbortSignal signal;
+};
+
+[Exposed=Window, SecureContext]
+interface BluetoothManufacturerDataMap {
+  readonly maplike<unsigned short, DataView>;
+};
+[Exposed=Window, SecureContext]
+interface BluetoothServiceDataMap {
+  readonly maplike<UUID, DataView>;
+};
+[
+  Exposed=Window,
+  SecureContext
+]
+interface BluetoothAdvertisingEvent : Event {
+  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;
+  BluetoothManufacturerDataMap manufacturerData;
+  BluetoothServiceDataMap serviceData;
+};
+
+[Exposed=Window, SecureContext]
+interface BluetoothRemoteGATTServer {
+  [SameObject]
+  readonly attribute BluetoothDevice device;
+  readonly attribute boolean connected;
+  Promise<BluetoothRemoteGATTServer> connect();
+  undefined disconnect();
+  Promise<BluetoothRemoteGATTService> getPrimaryService(BluetoothServiceUUID service);
+  Promise<sequence<BluetoothRemoteGATTService>>
+    getPrimaryServices(optional BluetoothServiceUUID service);
+};
+
+[Exposed=Window, SecureContext]
+interface BluetoothRemoteGATTService : EventTarget {
+  [SameObject]
+  readonly attribute BluetoothDevice device;
+  readonly attribute UUID 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);
+};
+BluetoothRemoteGATTService includes CharacteristicEventHandlers;
+BluetoothRemoteGATTService includes ServiceEventHandlers;
+
+[Exposed=Window, SecureContext]
+interface BluetoothRemoteGATTCharacteristic : EventTarget {
+  [SameObject]
+  readonly attribute BluetoothRemoteGATTService service;
+  readonly attribute UUID uuid;
+  readonly attribute BluetoothCharacteristicProperties properties;
+  readonly attribute DataView? value;
+  Promise<BluetoothRemoteGATTDescriptor> getDescriptor(BluetoothDescriptorUUID descriptor);
+  Promise<sequence<BluetoothRemoteGATTDescriptor>>
+    getDescriptors(optional BluetoothDescriptorUUID descriptor);
+  Promise<DataView> readValue();
+  Promise<undefined> writeValue(BufferSource value);
+  Promise<undefined> writeValueWithResponse(BufferSource value);
+  Promise<undefined> writeValueWithoutResponse(BufferSource value);
+  Promise<BluetoothRemoteGATTCharacteristic> startNotifications();
+  Promise<BluetoothRemoteGATTCharacteristic> stopNotifications();
+};
+BluetoothRemoteGATTCharacteristic includes CharacteristicEventHandlers;
+
+[Exposed=Window, SecureContext]
+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;
+};
+
+[Exposed=Window, SecureContext]
+interface BluetoothRemoteGATTDescriptor {
+  [SameObject]
+  readonly attribute BluetoothRemoteGATTCharacteristic characteristic;
+  readonly attribute UUID uuid;
+  readonly attribute DataView? value;
+  Promise<DataView> readValue();
+  Promise<undefined> writeValue(BufferSource value);
+};
+
+[SecureContext]
+interface mixin CharacteristicEventHandlers {
+  attribute EventHandler oncharacteristicvaluechanged;
+};
+
+[SecureContext]
+interface mixin BluetoothDeviceEventHandlers {
+  attribute EventHandler onadvertisementreceived;
+  attribute EventHandler ongattserverdisconnected;
+};
+
+[SecureContext]
+interface mixin ServiceEventHandlers {
+  attribute EventHandler onserviceadded;
+  attribute EventHandler onservicechanged;
+  attribute EventHandler onserviceremoved;
+};
+
+typedef DOMString UUID;
+
+[Exposed=Window]
+interface BluetoothUUID {
+  static UUID getService((DOMString or unsigned long) name);
+  static UUID getCharacteristic((DOMString or unsigned long) name);
+  static UUID getDescriptor((DOMString or unsigned long) name);
+
+  static UUID canonicalUUID([EnforceRange] unsigned long alias);
+};
+
+typedef (DOMString or unsigned long) BluetoothServiceUUID;
+typedef (DOMString or unsigned long) BluetoothCharacteristicUUID;
+typedef (DOMString or unsigned long) BluetoothDescriptorUUID;
+
+[SecureContext]
+partial interface Navigator {
+  [SameObject]
+  readonly attribute Bluetooth? bluetooth;
+};

third-party/vendor/web-sys/webidls/unstable/Clipboard.webidl

@@ -0,0 +1,51 @@
+/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/*
+ * Clipboard API and events
+ * W3C Working Draft, 4 June 2021
+ * The origin of this IDL file is:
+ * https://www.w3.org/TR/2021/WD-clipboard-apis-20210604/
+ */
+
+partial interface Navigator {
+  [SecureContext, SameObject] readonly attribute Clipboard? clipboard;
+};
+
+typedef sequence<ClipboardItem> ClipboardItems;
+
+[SecureContext, Exposed=Window] interface Clipboard : EventTarget {
+  Promise<ClipboardItems> read();
+  Promise<DOMString> readText();
+  Promise<undefined> write(ClipboardItems data);
+  Promise<undefined> writeText(DOMString data);
+};
+
+typedef (DOMString or Blob) ClipboardItemDataType;
+typedef Promise<ClipboardItemDataType> ClipboardItemData;
+
+callback ClipboardItemDelayedCallback = ClipboardItemData ();
+
+[Exposed=Window] interface ClipboardItem {
+  constructor(record<DOMString, ClipboardItemData> items,
+    optional ClipboardItemOptions options = {});
+  static ClipboardItem createDelayed(
+      record<DOMString, ClipboardItemDelayedCallback> items,
+      optional ClipboardItemOptions options = {});
+
+  readonly attribute PresentationStyle presentationStyle;
+  readonly attribute long long lastModified;
+  readonly attribute boolean delayed;
+
+  readonly attribute FrozenArray<DOMString> types;
+
+  Promise<Blob> getType(DOMString type);
+};
+
+enum PresentationStyle { "unspecified", "inline", "attachment" };
+
+dictionary ClipboardItemOptions {
+  PresentationStyle presentationStyle = "unspecified";
+};
+
+dictionary ClipboardPermissionDescriptor : PermissionDescriptor {
+  boolean allowWithoutGesture = false;
+};

third-party/vendor/web-sys/webidls/unstable/Compression.webidl

@@ -0,0 +1,17 @@
+enum CompressionFormat {
+  "deflate",
+  "deflate-raw",
+  "gzip",
+};
+
+[Exposed=*]
+interface CompressionStream {
+  constructor(CompressionFormat format);
+};
+CompressionStream includes GenericTransformStream;
+
+[Exposed=*]
+interface DecompressionStream {
+  constructor(CompressionFormat format);
+};
+DecompressionStream includes GenericTransformStream;

third-party/vendor/web-sys/webidls/unstable/FileSystemAccess.webidl

@@ -0,0 +1,70 @@
+enum FileSystemPermissionMode {
+  "read",
+  "readwrite"
+};
+
+dictionary FileSystemPermissionDescriptor : PermissionDescriptor {
+  required FileSystemHandle handle;
+  FileSystemPermissionMode mode = "read";
+};
+
+dictionary FileSystemHandlePermissionDescriptor {
+  FileSystemPermissionMode mode = "read";
+};
+
+[Exposed=(Window,Worker), SecureContext, Serializable]
+partial interface FileSystemHandle {
+  Promise<PermissionState> queryPermission(optional FileSystemHandlePermissionDescriptor descriptor = {});
+  Promise<PermissionState> requestPermission(optional FileSystemHandlePermissionDescriptor descriptor = {});
+};
+
+enum WellKnownDirectory {
+  "desktop",
+  "documents",
+  "downloads",
+  "music",
+  "pictures",
+  "videos",
+};
+
+typedef (WellKnownDirectory or FileSystemHandle) StartInDirectory;
+
+dictionary FilePickerAcceptType {
+    USVString description = "";
+    record<USVString, (USVString or sequence<USVString>)> accept;
+};
+
+dictionary FilePickerOptions {
+    sequence<FilePickerAcceptType> types;
+    boolean excludeAcceptAllOption = false;
+    DOMString id;
+    StartInDirectory startIn;
+};
+
+dictionary OpenFilePickerOptions : FilePickerOptions {
+    boolean multiple = false;
+};
+
+dictionary SaveFilePickerOptions : FilePickerOptions {
+    USVString? suggestedName;
+};
+
+dictionary DirectoryPickerOptions {
+    DOMString id;
+    StartInDirectory startIn;
+    FileSystemPermissionMode mode = "read";
+};
+
+[SecureContext]
+partial interface Window {
+    [Throws]
+    Promise<sequence<FileSystemFileHandle>> showOpenFilePicker(optional OpenFilePickerOptions options = {});
+    [Throws]
+    Promise<FileSystemFileHandle> showSaveFilePicker(optional SaveFilePickerOptions options = {});
+    [Throws]
+    Promise<FileSystemDirectoryHandle> showDirectoryPicker(optional DirectoryPickerOptions options = {});
+};
+
+partial interface DataTransferItem {
+    Promise<FileSystemHandle?> getAsFileSystemHandle();
+};

third-party/vendor/web-sys/webidls/unstable/ImageCapture.webidl

@@ -0,0 +1,22 @@
+/* -*- 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://dvcs.w3.org/hg/dap/raw-file/default/media-stream-capture/ImageCapture.html
+ *
+ * Copyright © 2012-2014 W3C® (MIT, ERCIM, Keio, Beihang), All Rights Reserved.
+ * W3C liability, trademark and document use rules apply.
+ */
+
+[Pref="dom.imagecapture.enabled", Constructor(MediaStreamTrack videoTrack)]
+interface ImageCapture {
+   Promise<Blob>              takePhoto(optional PhotoSettings photoSettings);
+   Promise<PhotoCapabilities> getPhotoCapabilities();
+   Promise<PhotoSettings>     getPhotoSettings();
+
+   Promise<ImageBitmap>       grabFrame();
+
+   readonly attribute MediaStreamTrack track;
+};

third-party/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;
+};

third-party/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();
+};

third-party/vendor/web-sys/webidls/unstable/MediaCaptureTransform.webidl

@@ -0,0 +1,20 @@
+[Exposed=Window,DedicatedWorker]
+interface MediaStreamTrackGenerator : MediaStreamTrack {
+    constructor(MediaStreamTrackGeneratorInit init);
+    attribute WritableStream writable;  // VideoFrame or AudioData
+};
+
+dictionary MediaStreamTrackGeneratorInit {
+  required DOMString kind;
+};
+
+[Exposed=DedicatedWorker]
+interface MediaStreamTrackProcessor {
+    constructor(MediaStreamTrackProcessorInit init);
+    attribute ReadableStream readable;
+};
+
+dictionary MediaStreamTrackProcessorInit {
+  required MediaStreamTrack track;
+  [EnforceRange] unsigned short maxBufferSize;
+};

third-party/vendor/web-sys/webidls/unstable/MediaSession.webidl

@@ -0,0 +1,77 @@
+[Exposed=Window]
+partial interface Navigator {
+  [SameObject] readonly attribute MediaSession mediaSession;
+};
+
+enum MediaSessionPlaybackState {
+  "none",
+  "paused",
+  "playing"
+};
+
+enum MediaSessionAction {
+  "play",
+  "pause",
+  "seekbackward",
+  "seekforward",
+  "previoustrack",
+  "nexttrack",
+  "skipad",
+  "stop",
+  "seekto",
+  "togglemicrophone",
+  "togglecamera",
+  "hangup"
+};
+
+callback MediaSessionActionHandler = undefined(MediaSessionActionDetails details);
+
+[Exposed=Window]
+interface MediaSession {
+  attribute MediaMetadata? metadata;
+
+  attribute MediaSessionPlaybackState playbackState;
+
+  undefined setActionHandler(MediaSessionAction action, MediaSessionActionHandler? handler);
+
+  undefined setPositionState(optional MediaPositionState state = {});
+
+  undefined setMicrophoneActive(boolean active);
+
+  undefined setCameraActive(boolean active);
+};
+
+[Exposed=Window]
+interface MediaMetadata {
+  constructor(optional MediaMetadataInit init = {});
+  attribute DOMString title;
+  attribute DOMString artist;
+  attribute DOMString album;
+  attribute FrozenArray<MediaImage> artwork;
+};
+
+dictionary MediaMetadataInit {
+  DOMString title = "";
+  DOMString artist = "";
+  DOMString album = "";
+  sequence<MediaImage> artwork = [];
+};
+
+dictionary MediaImage {
+  required USVString src;
+  DOMString sizes = "";
+  DOMString type = "";
+};
+
+dictionary MediaPositionState {
+  double duration;
+  double playbackRate;
+  double position;
+};
+
+dictionary MediaSessionActionDetails {
+  required MediaSessionAction action;
+  double? seekOffset;
+  double? seekTime;
+  boolean? fastSeek;
+};

third-party/vendor/web-sys/webidls/unstable/RTCRtpSender.webidl

@@ -0,0 +1,3 @@
+partial dictionary RTCRtpEncodingParameters {
+    DOMString scalabilityMode;
+};

third-party/vendor/web-sys/webidls/unstable/ScreenWakeLock.webidl

@@ -0,0 +1,23 @@
+/* The origin of this IDL file is
+ * https://www.w3.org/TR/screen-wake-lock/#idl-index
+ */
+
+[SecureContext]
+partial interface Navigator {
+  [SameObject] readonly attribute WakeLock wakeLock;
+};
+
+[SecureContext, Exposed=(Window)]
+interface WakeLock {
+  Promise<WakeLockSentinel> request(WakeLockType type);
+};
+
+[SecureContext, Exposed=(Window)]
+interface WakeLockSentinel : EventTarget {
+  readonly attribute boolean released;
+  readonly attribute WakeLockType type;
+  Promise<undefined> release();
+  attribute EventHandler onrelease;
+};
+
+enum WakeLockType { "screen" };

third-party/vendor/web-sys/webidls/unstable/Share.webidl

@@ -0,0 +1,20 @@
+/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/*
+ * API for sharing text, links and other content to an arbitrary destination of the user's choice.
+ * W3C Working Draft, 22 November 2021
+ * The origin of this IDL file is:
+ * https://www.w3.org/TR/web-share
+ */
+
+partial interface Navigator {
+  [SecureContext] Promise<undefined> share(optional ShareData data = {});
+
+  [SecureContext] boolean canShare(optional ShareData data = {});
+};
+
+dictionary ShareData {
+  sequence<File> files;
+  USVString title;
+  USVString text;
+  USVString url;
+};

third-party/vendor/web-sys/webidls/unstable/ViewTransition.webidl

@@ -0,0 +1,15 @@
+partial interface Document {
+  [Throws]
+  ViewTransition startViewTransition(optional UpdateCallback? updateCallback = null);
+};
+
+callback UpdateCallback = Promise<any> ();
+
+[Exposed=Window]
+interface ViewTransition {
+  readonly attribute Promise<undefined> updateCallbackDone;
+  readonly attribute Promise<undefined> ready;
+  readonly attribute Promise<undefined> finished;
+  [Throws]
+  undefined skipTransition();
+};

third-party/vendor/web-sys/webidls/unstable/WebCodecs.webidl

@@ -0,0 +1,478 @@
+[Exposed=(Window,DedicatedWorker), SecureContext]
+interface AudioDecoder {
+  constructor(AudioDecoderInit init);
+
+  readonly attribute CodecState state;
+  readonly attribute unsigned long decodeQueueSize;
+
+  undefined configure(AudioDecoderConfig config);
+  undefined decode(EncodedAudioChunk chunk);
+  Promise<undefined> flush();
+  undefined reset();
+  undefined close();
+
+  static Promise<AudioDecoderSupport> isConfigSupported(AudioDecoderConfig config);
+};
+
+dictionary AudioDecoderInit {
+  required AudioDataOutputCallback output;
+  required WebCodecsErrorCallback error;
+};
+
+callback AudioDataOutputCallback = undefined(AudioData output);
+
+[Exposed=(Window,DedicatedWorker), SecureContext]
+interface VideoDecoder {
+  constructor(VideoDecoderInit init);
+
+  readonly attribute CodecState state;
+  readonly attribute unsigned long decodeQueueSize;
+
+  undefined configure(VideoDecoderConfig config);
+  undefined decode(EncodedVideoChunk chunk);
+  Promise<undefined> flush();
+  undefined reset();
+  undefined close();
+
+  static Promise<VideoDecoderSupport> isConfigSupported(VideoDecoderConfig config);
+};
+
+dictionary VideoDecoderInit {
+  required VideoFrameOutputCallback output;
+  required WebCodecsErrorCallback error;
+};
+
+callback VideoFrameOutputCallback = undefined(VideoFrame output);
+
+[Exposed=(Window,DedicatedWorker), SecureContext]
+interface AudioEncoder {
+  constructor(AudioEncoderInit init);
+
+  readonly attribute CodecState state;
+  readonly attribute unsigned long encodeQueueSize;
+
+  undefined configure(AudioEncoderConfig config);
+  undefined encode(AudioData data);
+  Promise<undefined> flush();
+  undefined reset();
+  undefined close();
+
+  static Promise<AudioEncoderSupport> isConfigSupported(AudioEncoderConfig config);
+};
+
+dictionary AudioEncoderInit {
+  required EncodedAudioChunkOutputCallback output;
+  required WebCodecsErrorCallback error;
+};
+
+callback EncodedAudioChunkOutputCallback =
+    undefined (EncodedAudioChunk output,
+               optional EncodedAudioChunkMetadata metadata = {});
+
+dictionary EncodedAudioChunkMetadata {
+  AudioDecoderConfig decoderConfig;
+};
+
+[Exposed=(Window,DedicatedWorker), SecureContext]
+interface VideoEncoder {
+  constructor(VideoEncoderInit init);
+
+  readonly attribute CodecState state;
+  readonly attribute unsigned long encodeQueueSize;
+
+  undefined configure(VideoEncoderConfig config);
+  undefined encode(VideoFrame frame, optional VideoEncoderEncodeOptions options = {});
+  Promise<undefined> flush();
+  undefined reset();
+  undefined close();
+
+  static Promise<VideoEncoderSupport> isConfigSupported(VideoEncoderConfig config);
+};
+
+dictionary VideoEncoderInit {
+  required EncodedVideoChunkOutputCallback output;
+  required WebCodecsErrorCallback error;
+};
+
+callback EncodedVideoChunkOutputCallback =
+    undefined (EncodedVideoChunk chunk,
+               optional EncodedVideoChunkMetadata metadata = {});
+
+dictionary EncodedVideoChunkMetadata {
+  VideoDecoderConfig decoderConfig;
+  SvcOutputMetadata svc;
+  BufferSource alphaSideData;
+};
+
+dictionary SvcOutputMetadata {
+  unsigned long temporalLayerId;
+};
+
+dictionary AudioDecoderSupport {
+  boolean supported;
+  AudioDecoderConfig config;
+};
+
+dictionary VideoDecoderSupport {
+  boolean supported;
+  VideoDecoderConfig config;
+};
+
+dictionary AudioEncoderSupport {
+  boolean supported;
+  AudioEncoderConfig config;
+};
+
+dictionary VideoEncoderSupport {
+  boolean supported;
+  VideoEncoderConfig config;
+};
+
+dictionary AudioDecoderConfig {
+  required DOMString codec;
+  [EnforceRange] required unsigned long sampleRate;
+  [EnforceRange] required unsigned long numberOfChannels;
+  BufferSource description;
+};
+
+dictionary VideoDecoderConfig {
+  required DOMString codec;
+  BufferSource description;
+  [EnforceRange] unsigned long codedWidth;
+  [EnforceRange] unsigned long codedHeight;
+  [EnforceRange] unsigned long displayAspectWidth;
+  [EnforceRange] unsigned long displayAspectHeight;
+  VideoColorSpaceInit colorSpace;
+  HardwareAcceleration hardwareAcceleration = "no-preference";
+  boolean optimizeForLatency;
+};
+
+dictionary AudioEncoderConfig {
+  required DOMString codec;
+  [EnforceRange] unsigned long sampleRate;
+  [EnforceRange] unsigned long numberOfChannels;
+  [EnforceRange] unsigned long long bitrate;
+};
+
+dictionary VideoEncoderConfig {
+  required DOMString codec;
+  [EnforceRange] required unsigned long width;
+  [EnforceRange] required unsigned long height;
+  [EnforceRange] unsigned long displayWidth;
+  [EnforceRange] unsigned long displayHeight;
+  [EnforceRange] unsigned long long bitrate;
+  [EnforceRange] double framerate;
+  HardwareAcceleration hardwareAcceleration = "no-preference";
+  AlphaOption alpha = "discard";
+  DOMString scalabilityMode;
+  BitrateMode bitrateMode = "variable";
+  LatencyMode latencyMode = "quality";
+};
+
+enum HardwareAcceleration {
+  "no-preference",
+  "prefer-hardware",
+  "prefer-software",
+};
+
+enum AlphaOption {
+  "keep",
+  "discard",
+};
+
+enum LatencyMode {
+  "quality",
+  "realtime"
+};
+
+dictionary VideoEncoderEncodeOptions {
+  boolean keyFrame = false;
+};
+
+enum CodecState {
+  "unconfigured",
+  "configured",
+  "closed"
+};
+
+callback WebCodecsErrorCallback = undefined(DOMException error);
+
+[Exposed=(Window,DedicatedWorker)]
+interface EncodedAudioChunk {
+  constructor(EncodedAudioChunkInit init);
+  readonly attribute EncodedAudioChunkType type;
+  readonly attribute long long timestamp;          // microseconds
+  readonly attribute unsigned long long? duration; // microseconds
+  readonly attribute unsigned long byteLength;
+
+  undefined copyTo([AllowShared] BufferSource destination);
+};
+
+dictionary EncodedAudioChunkInit {
+  required EncodedAudioChunkType type;
+  [EnforceRange] required long long timestamp;    // microseconds
+  [EnforceRange] unsigned long long duration;     // microseconds
+  required BufferSource data;
+};
+
+enum EncodedAudioChunkType {
+    "key",
+    "delta",
+};
+
+[Exposed=(Window,DedicatedWorker)]
+interface EncodedVideoChunk {
+  constructor(EncodedVideoChunkInit init);
+  readonly attribute EncodedVideoChunkType type;
+  readonly attribute long long timestamp;             // microseconds
+  readonly attribute unsigned long long? duration;    // microseconds
+  readonly attribute unsigned long byteLength;
+
+  undefined copyTo([AllowShared] BufferSource destination);
+};
+
+dictionary EncodedVideoChunkInit {
+  required EncodedVideoChunkType type;
+  [EnforceRange] required long long timestamp;        // microseconds
+  [EnforceRange] unsigned long long duration;         // microseconds
+  required BufferSource data;
+};
+
+enum EncodedVideoChunkType {
+    "key",
+    "delta",
+};
+
+[Exposed=(Window,DedicatedWorker), Serializable, Transferable]
+interface AudioData {
+  constructor(AudioDataInit init);
+
+  readonly attribute AudioSampleFormat? format;
+  readonly attribute float sampleRate;
+  readonly attribute unsigned long numberOfFrames;
+  readonly attribute unsigned long numberOfChannels;
+  readonly attribute unsigned long long duration;  // microseconds
+  readonly attribute long long timestamp;          // microseconds
+
+  unsigned long allocationSize(AudioDataCopyToOptions options);
+  undefined copyTo([AllowShared] BufferSource destination, AudioDataCopyToOptions options);
+  AudioData clone();
+  undefined close();
+};
+
+dictionary AudioDataInit {
+  required AudioSampleFormat format;
+  required float sampleRate;
+  [EnforceRange] required unsigned long numberOfFrames;
+  [EnforceRange] required unsigned long numberOfChannels;
+  [EnforceRange] required long long timestamp;  // microseconds
+  required BufferSource data;
+};
+
+dictionary AudioDataCopyToOptions {
+  [EnforceRange] required unsigned long planeIndex;
+  [EnforceRange] unsigned long frameOffset = 0;
+  [EnforceRange] unsigned long frameCount;
+  AudioSampleFormat format;
+};
+
+enum AudioSampleFormat {
+  "u8",
+  "s16",
+  "s32",
+  "f32",
+  "u8-planar",
+  "s16-planar",
+  "s32-planar",
+  "f32-planar",
+};
+
+[Exposed=(Window,DedicatedWorker), Serializable, Transferable]
+interface VideoFrame {
+  constructor(CanvasImageSource image, optional VideoFrameInit init = {});
+  constructor([AllowShared] BufferSource data, VideoFrameBufferInit init);
+
+  readonly attribute VideoPixelFormat? format;
+  readonly attribute unsigned long codedWidth;
+  readonly attribute unsigned long codedHeight;
+  readonly attribute DOMRectReadOnly? codedRect;
+  readonly attribute DOMRectReadOnly? visibleRect;
+  readonly attribute unsigned long displayWidth;
+  readonly attribute unsigned long displayHeight;
+  readonly attribute unsigned long long? duration;  // microseconds
+  readonly attribute long long? timestamp;          // microseconds
+  readonly attribute VideoColorSpace colorSpace;
+
+  unsigned long allocationSize(
+      optional VideoFrameCopyToOptions options = {});
+  Promise<sequence<PlaneLayout>> copyTo(
+      [AllowShared] BufferSource destination,
+      optional VideoFrameCopyToOptions options = {});
+  VideoFrame clone();
+  undefined close();
+};
+
+dictionary VideoFrameInit {
+  unsigned long long duration;  // microseconds
+  long long timestamp;          // microseconds
+  AlphaOption alpha = "keep";
+
+  // Default matches image. May be used to efficiently crop. Will trigger
+  // new computation of displayWidth and displayHeight using image’s pixel
+  // aspect ratio unless an explicit displayWidth and displayHeight are given.
+  DOMRectInit visibleRect;
+
+  // Default matches image unless visibleRect is provided.
+  [EnforceRange] unsigned long displayWidth;
+  [EnforceRange] unsigned long displayHeight;
+};
+
+dictionary VideoFrameBufferInit {
+  required VideoPixelFormat format;
+  [EnforceRange] required unsigned long codedWidth;
+  [EnforceRange] required unsigned long codedHeight;
+  [EnforceRange] required long long timestamp;  // microseconds
+  [EnforceRange] unsigned long long duration;  // microseconds
+
+  // Default layout is tightly-packed.
+  sequence<PlaneLayout> layout;
+
+  // Default visible rect is coded size positioned at (0,0)
+  DOMRectInit visibleRect;
+
+  // Default display dimensions match visibleRect.
+  [EnforceRange] unsigned long displayWidth;
+  [EnforceRange] unsigned long displayHeight;
+
+  VideoColorSpaceInit colorSpace;
+};
+
+dictionary VideoFrameCopyToOptions {
+  DOMRectInit rect;
+  sequence<PlaneLayout> layout;
+};
+
+dictionary PlaneLayout {
+  [EnforceRange] required unsigned long offset;
+  [EnforceRange] required unsigned long stride;
+};
+
+enum VideoPixelFormat {
+  // 4:2:0 Y, U, V
+  "I420",
+  // 4:2:0 Y, U, V, A
+  "I420A",
+  // 4:2:2 Y, U, V
+  "I422",
+  // 4:4:4 Y, U, V
+  "I444",
+  // 4:2:0 Y, UV
+  "NV12",
+  // 32bpp RGBA
+  "RGBA",
+  // 32bpp RGBX (opaque)
+  "RGBX",
+  // 32bpp BGRA
+  "BGRA",
+  // 32bpp BGRX (opaque)
+  "BGRX",
+};
+
+[Exposed=(Window,DedicatedWorker)]
+interface VideoColorSpace {
+  constructor(optional VideoColorSpaceInit init = {});
+
+  readonly attribute VideoColorPrimaries? primaries;
+  readonly attribute VideoTransferCharacteristics? transfer;
+  readonly attribute VideoMatrixCoefficients? matrix;
+  readonly attribute boolean? fullRange;
+
+  [Default] VideoColorSpaceInit toJSON();
+};
+
+dictionary VideoColorSpaceInit {
+  VideoColorPrimaries primaries;
+  VideoTransferCharacteristics transfer;
+  VideoMatrixCoefficients matrix;
+  boolean fullRange;
+};
+
+enum VideoColorPrimaries {
+  "bt709",      // BT.709, sRGB
+  "bt470bg",    // BT.601 PAL
+  "smpte170m",  // BT.601 NTSC
+};
+
+enum VideoTransferCharacteristics {
+  "bt709",         // BT.709
+  "smpte170m",     // BT.601 (functionally the same as bt709)
+  "iec61966-2-1",  // sRGB
+};
+
+enum VideoMatrixCoefficients {
+  "rgb",        // sRGB
+  "bt709",      // BT.709
+  "bt470bg",    // BT.601 PAL
+  "smpte170m",  // BT.601 NTSC (functionally the same as bt470bg)
+};
+
+[Exposed=(Window,DedicatedWorker), SecureContext]
+interface ImageDecoder {
+  constructor(ImageDecoderInit init);
+
+  readonly attribute DOMString type;
+  readonly attribute boolean complete;
+  readonly attribute Promise<undefined> completed;
+  readonly attribute ImageTrackList tracks;
+
+  Promise<ImageDecodeResult> decode(optional ImageDecodeOptions options = {});
+  undefined reset();
+  undefined close();
+
+  static Promise<boolean> isTypeSupported(DOMString type);
+};
+
+
+typedef (BufferSource or ReadableStream) ImageBufferSource;
+dictionary ImageDecoderInit {
+  required DOMString type;
+  required ImageBufferSource data;
+  PremultiplyAlpha premultiplyAlpha = "default";
+  ColorSpaceConversion colorSpaceConversion = "default";
+  [EnforceRange] unsigned long desiredWidth;
+  [EnforceRange] unsigned long desiredHeight;
+  boolean preferAnimation;
+};
+
+
+dictionary ImageDecodeOptions {
+  [EnforceRange] unsigned long frameIndex = 0;
+  boolean completeFramesOnly = true;
+};
+
+
+dictionary ImageDecodeResult {
+  required VideoFrame image;
+  required boolean complete;
+};
+
+
+[Exposed=(Window,DedicatedWorker)]
+interface ImageTrackList {
+  getter ImageTrack (unsigned long index);
+
+  readonly attribute Promise<undefined> ready;
+  readonly attribute unsigned long length;
+  readonly attribute long selectedIndex;
+  readonly attribute ImageTrack? selectedTrack;
+};
+
+
+[Exposed=(Window,DedicatedWorker)]
+interface ImageTrack : EventTarget {
+  readonly attribute boolean animated;
+  readonly attribute unsigned long frameCount;
+  readonly attribute unrestricted float repetitionCount;
+  attribute EventHandler onchange;
+  attribute boolean selected;
+};

third-party/vendor/web-sys/webidls/unstable/WebHID.webidl

@@ -0,0 +1,127 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: WebHID API (https://wicg.github.io/webhid/)
+
+dictionary HIDDeviceFilter {
+    unsigned long vendorId;
+    unsigned short productId;
+    unsigned short usagePage;
+    unsigned short usage;
+};
+
+dictionary HIDDeviceRequestOptions {
+    required sequence<HIDDeviceFilter> filters;
+};
+
+[
+    Exposed=Window,
+    SecureContext
+]
+interface HID : EventTarget {
+    attribute EventHandler onconnect;
+    attribute EventHandler ondisconnect;
+    Promise<sequence<HIDDevice>> getDevices();
+    Promise<sequence<HIDDevice>> requestDevice(
+        HIDDeviceRequestOptions options);
+};
+
+[SecureContext] partial interface Navigator {
+    [SameObject] readonly attribute HID hid;
+};
+
+dictionary HIDConnectionEventInit : EventInit {
+    required HIDDevice device;
+};
+
+[
+    Exposed=Window,
+    SecureContext
+] interface HIDConnectionEvent : Event {
+    constructor(DOMString type, HIDConnectionEventInit eventInitDict);
+    [SameObject] readonly attribute HIDDevice device;
+};
+
+dictionary HIDInputReportEventInit : EventInit {
+    required HIDDevice device;
+    required octet reportId;
+    required DataView data;
+};
+
+[
+    Exposed=Window,
+    SecureContext
+] interface HIDInputReportEvent : Event {
+    constructor(DOMString type, HIDInputReportEventInit eventInitDict);
+    [SameObject] readonly attribute HIDDevice device;
+    readonly attribute octet reportId;
+    readonly attribute DataView data;
+};
+
+enum HIDUnitSystem {
+    "none", "si-linear", "si-rotation", "english-linear",
+    "english-rotation", "vendor-defined", "reserved"
+};
+
+dictionary HIDReportItem {
+    boolean isAbsolute;
+    boolean isArray;
+    boolean isBufferedBytes;
+    boolean isConstant;
+    boolean isLinear;
+    boolean isRange;
+    boolean isVolatile;
+    boolean hasNull;
+    boolean hasPreferredState;
+    boolean wrap;
+    sequence<unsigned long> usages;
+    unsigned long usageMinimum;
+    unsigned long usageMaximum;
+    unsigned short reportSize;
+    unsigned short reportCount;
+    byte unitExponent;
+    HIDUnitSystem unitSystem;
+    byte unitFactorLengthExponent;
+    byte unitFactorMassExponent;
+    byte unitFactorTimeExponent;
+    byte unitFactorTemperatureExponent;
+    byte unitFactorCurrentExponent;
+    byte unitFactorLuminousIntensityExponent;
+    long logicalMinimum;
+    long logicalMaximum;
+    long physicalMinimum;
+    long physicalMaximum;
+    sequence<DOMString> strings;
+};
+
+dictionary HIDReportInfo {
+    octet reportId;
+    sequence<HIDReportItem> items;
+};
+
+dictionary HIDCollectionInfo {
+    unsigned short usagePage;
+    unsigned short usage;
+    octet type;
+    sequence<HIDCollectionInfo> children;
+    sequence<HIDReportInfo> inputReports;
+    sequence<HIDReportInfo> outputReports;
+    sequence<HIDReportInfo> featureReports;
+};
+
+[
+    Exposed=Window,
+    SecureContext
+] interface HIDDevice : EventTarget {
+    attribute EventHandler oninputreport;
+    readonly attribute boolean opened;
+    readonly attribute unsigned short vendorId;
+    readonly attribute unsigned short productId;
+    readonly attribute DOMString productName;
+    readonly attribute FrozenArray<HIDCollectionInfo> collections;
+    Promise<undefined> open();
+    Promise<undefined> close();
+    Promise<undefined> sendReport([EnforceRange] octet reportId, BufferSource data);
+    Promise<undefined> sendFeatureReport([EnforceRange] octet reportId, BufferSource data);
+    Promise<DataView> receiveFeatureReport([EnforceRange] octet reportId);
+};

third-party/vendor/web-sys/webidls/unstable/WebSerial.webidl

@@ -0,0 +1,80 @@
+[Exposed=Window, SecureContext]
+partial interface Navigator {
+  [SameObject] readonly attribute Serial serial;
+};
+
+[Exposed=DedicatedWorker, SecureContext]
+partial interface WorkerNavigator {
+  [SameObject] readonly attribute Serial serial;
+};
+
+[Exposed=(DedicatedWorker, Window), SecureContext]
+interface Serial : EventTarget {
+  attribute EventHandler onconnect;
+  attribute EventHandler ondisconnect;
+  Promise<sequence<SerialPort>> getPorts();
+  [Exposed=Window] Promise<SerialPort> requestPort(optional SerialPortRequestOptions options = {});
+};
+
+dictionary SerialPortRequestOptions {
+  sequence<SerialPortFilter> filters;
+};
+
+dictionary SerialPortFilter {
+  unsigned short usbVendorId;
+  unsigned short usbProductId;
+};
+
+[Exposed=(DedicatedWorker,Window), SecureContext]
+interface SerialPort : EventTarget {
+  attribute EventHandler onconnect;
+  attribute EventHandler ondisconnect;
+  readonly attribute ReadableStream readable;
+  readonly attribute WritableStream writable;
+
+  SerialPortInfo getInfo();
+
+  Promise<undefined> open(SerialOptions options);
+  Promise<undefined> setSignals(optional SerialOutputSignals signals = {});
+  Promise<SerialInputSignals> getSignals();
+  Promise<undefined> close();
+  Promise<undefined> forget();
+};
+
+dictionary SerialPortInfo {
+  unsigned short usbVendorId;
+  unsigned short usbProductId;
+};
+
+dictionary SerialOptions {
+  [EnforceRange] required unsigned long baudRate;
+  [EnforceRange] octet dataBits = 8;
+  [EnforceRange] octet stopBits = 1;
+  ParityType parity = "none";
+  [EnforceRange] unsigned long bufferSize = 255;
+  FlowControlType flowControl = "none";
+};
+
+enum ParityType {
+  "none",
+  "even",
+  "odd"
+};
+
+enum FlowControlType {
+  "none",
+  "hardware"
+};
+
+dictionary SerialOutputSignals {
+  boolean dataTerminalReady;
+  boolean requestToSend;
+  boolean break;
+};
+
+dictionary SerialInputSignals {
+  required boolean dataCarrierDetect;
+  required boolean clearToSend;
+  required boolean ringIndicator;
+  required boolean dataSetReady;
+};

third-party/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",
+};

third-party/vendor/web-sys/webidls/unstable/WebUSB.webidl

@@ -0,0 +1,244 @@
+dictionary USBDeviceFilter {
+  unsigned short vendorId;
+  unsigned short productId;
+  octet classCode;
+  octet subclassCode;
+  octet protocolCode;
+  DOMString serialNumber;
+};
+
+dictionary USBDeviceRequestOptions {
+  required sequence<USBDeviceFilter> filters;
+};
+
+[Exposed=(DedicatedWorker,SharedWorker,Window), SecureContext]
+interface USB : EventTarget {
+  attribute EventHandler onconnect;
+  attribute EventHandler ondisconnect;
+  Promise<sequence<USBDevice>> getDevices();
+  [Exposed=Window] Promise<USBDevice> requestDevice(USBDeviceRequestOptions options);
+};
+
+[Exposed=Window, SecureContext]
+partial interface Navigator {
+  [SameObject] readonly attribute USB usb;
+};
+
+[Exposed=(DedicatedWorker,SharedWorker), SecureContext]
+partial interface WorkerNavigator {
+  [SameObject] readonly attribute USB usb;
+};
+
+dictionary USBConnectionEventInit : EventInit {
+    required USBDevice device;
+};
+
+[
+  Exposed=(DedicatedWorker,SharedWorker,Window),
+  SecureContext
+]
+interface USBConnectionEvent : Event {
+  constructor(DOMString type, USBConnectionEventInit eventInitDict);
+  [SameObject] readonly attribute USBDevice device;
+};
+
+[Exposed=(DedicatedWorker,SharedWorker,Window), SecureContext]
+interface USBDevice {
+  readonly attribute octet usbVersionMajor;
+  readonly attribute octet usbVersionMinor;
+  readonly attribute octet usbVersionSubminor;
+  readonly attribute octet deviceClass;
+  readonly attribute octet deviceSubclass;
+  readonly attribute octet deviceProtocol;
+  readonly attribute unsigned short vendorId;
+  readonly attribute unsigned short productId;
+  readonly attribute octet deviceVersionMajor;
+  readonly attribute octet deviceVersionMinor;
+  readonly attribute octet deviceVersionSubminor;
+  readonly attribute DOMString? manufacturerName;
+  readonly attribute DOMString? productName;
+  readonly attribute DOMString? serialNumber;
+  readonly attribute USBConfiguration? configuration;
+  readonly attribute FrozenArray<USBConfiguration> configurations;
+  readonly attribute boolean opened;
+  Promise<undefined> open();
+  Promise<undefined> forget();
+  Promise<undefined> close();
+  Promise<undefined> selectConfiguration(octet configurationValue);
+  Promise<undefined> claimInterface(octet interfaceNumber);
+  Promise<undefined> releaseInterface(octet interfaceNumber);
+  Promise<undefined> selectAlternateInterface(octet interfaceNumber, octet alternateSetting);
+  Promise<USBInTransferResult> controlTransferIn(USBControlTransferParameters setup, unsigned short length);
+  Promise<USBOutTransferResult> controlTransferOut(USBControlTransferParameters setup, optional BufferSource data);
+  Promise<undefined> clearHalt(USBDirection direction, octet endpointNumber);
+  Promise<USBInTransferResult> transferIn(octet endpointNumber, unsigned long length);
+  Promise<USBOutTransferResult> transferOut(octet endpointNumber, BufferSource data);
+  Promise<USBIsochronousInTransferResult> isochronousTransferIn(octet endpointNumber, sequence<unsigned long> packetLengths);
+  Promise<USBIsochronousOutTransferResult> isochronousTransferOut(octet endpointNumber, BufferSource data, sequence<unsigned long> packetLengths);
+  Promise<undefined> reset();
+};
+
+enum USBRequestType {
+  "standard",
+  "class",
+  "vendor"
+};
+
+enum USBRecipient {
+  "device",
+  "interface",
+  "endpoint",
+  "other"
+};
+
+enum USBTransferStatus {
+  "ok",
+  "stall",
+  "babble"
+};
+
+dictionary USBControlTransferParameters {
+  required USBRequestType requestType;
+  required USBRecipient recipient;
+  required octet request;
+  required unsigned short value;
+  required unsigned short index;
+};
+
+[
+  Exposed=(DedicatedWorker,SharedWorker,Window),
+  SecureContext
+]
+interface USBInTransferResult {
+  constructor(USBTransferStatus status, optional DataView? data);
+  readonly attribute DataView? data;
+  readonly attribute USBTransferStatus status;
+};
+
+[
+  Exposed=(DedicatedWorker,SharedWorker,Window),
+  SecureContext
+]
+interface USBOutTransferResult {
+  constructor(USBTransferStatus status, optional unsigned long bytesWritten = 0);
+  readonly attribute unsigned long bytesWritten;
+  readonly attribute USBTransferStatus status;
+};
+
+[
+  Exposed=(DedicatedWorker,SharedWorker,Window),
+  SecureContext
+]
+interface USBIsochronousInTransferPacket {
+  constructor(USBTransferStatus status, optional DataView? data);
+  readonly attribute DataView? data;
+  readonly attribute USBTransferStatus status;
+};
+
+[
+  Exposed=(DedicatedWorker,SharedWorker,Window),
+  SecureContext
+]
+interface USBIsochronousInTransferResult {
+  constructor(sequence<USBIsochronousInTransferPacket> packets, optional DataView? data);
+  readonly attribute DataView? data;
+  readonly attribute FrozenArray<USBIsochronousInTransferPacket> packets;
+};
+
+[
+  Exposed=(DedicatedWorker,SharedWorker,Window),
+  SecureContext
+]
+interface USBIsochronousOutTransferPacket {
+  constructor(USBTransferStatus status, optional unsigned long bytesWritten = 0);
+  readonly attribute unsigned long bytesWritten;
+  readonly attribute USBTransferStatus status;
+};
+
+[
+  Exposed=(DedicatedWorker,SharedWorker,Window),
+  SecureContext
+]
+interface USBIsochronousOutTransferResult {
+  constructor(sequence<USBIsochronousOutTransferPacket> packets);
+  readonly attribute FrozenArray<USBIsochronousOutTransferPacket> packets;
+};
+
+[
+  Exposed=(DedicatedWorker,SharedWorker,Window),
+  SecureContext
+]
+interface USBConfiguration {
+  constructor(USBDevice device, octet configurationValue);
+  readonly attribute octet configurationValue;
+  readonly attribute DOMString? configurationName;
+  readonly attribute FrozenArray<USBInterface> interfaces;
+};
+
+[
+  Exposed=(DedicatedWorker,SharedWorker,Window),
+  SecureContext
+]
+interface USBInterface {
+  constructor(USBConfiguration configuration, octet interfaceNumber);
+  readonly attribute octet interfaceNumber;
+  readonly attribute USBAlternateInterface alternate;
+  readonly attribute FrozenArray<USBAlternateInterface> alternates;
+  readonly attribute boolean claimed;
+};
+
+[
+  Exposed=(DedicatedWorker,SharedWorker,Window),
+  SecureContext
+]
+interface USBAlternateInterface {
+  constructor(USBInterface deviceInterface, octet alternateSetting);
+  readonly attribute octet alternateSetting;
+  readonly attribute octet interfaceClass;
+  readonly attribute octet interfaceSubclass;
+  readonly attribute octet interfaceProtocol;
+  readonly attribute DOMString? interfaceName;
+  readonly attribute FrozenArray<USBEndpoint> endpoints;
+};
+
+enum USBDirection {
+  "in",
+  "out"
+};
+
+enum USBEndpointType {
+  "bulk",
+  "interrupt",
+  "isochronous"
+};
+
+[
+  Exposed=(DedicatedWorker,SharedWorker,Window),
+  SecureContext
+]
+interface USBEndpoint {
+  constructor(USBAlternateInterface alternate, octet endpointNumber, USBDirection direction);
+  readonly attribute octet endpointNumber;
+  readonly attribute USBDirection direction;
+  readonly attribute USBEndpointType type;
+  readonly attribute unsigned long packetSize;
+};
+
+dictionary USBPermissionDescriptor : PermissionDescriptor {
+  sequence<USBDeviceFilter> filters;
+};
+
+dictionary AllowedUSBDevice {
+  required octet vendorId;
+  required octet productId;
+  DOMString serialNumber;
+};
+
+dictionary USBPermissionStorage {
+  sequence<AllowedUSBDevice> allowedDevices = [];
+};
+
+[Exposed=(DedicatedWorker,SharedWorker,Window)]
+interface USBPermissionResult : PermissionStatus {
+  attribute FrozenArray<USBDevice> devices;
+};

third-party/vendor/web-sys/webidls/unstable/WebXRDevice.webidl

@@ -0,0 +1,297 @@
+/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/*
+ * WebXR Device API
+ * W3C Working Draft, 31 March 2022
+ * The origin of this IDL file is:
+ * https://www.w3.org/TR/2022/CR-webxr-20220331/
+ */
+
+partial interface Navigator {
+  [SecureContext, SameObject] readonly attribute XRSystem xr;
+};
+
+[SecureContext, Exposed=Window] interface XRSystem : EventTarget {
+  // Methods
+  Promise<boolean> isSessionSupported(XRSessionMode mode);
+  [NewObject] Promise<XRSession> requestSession(XRSessionMode mode, optional XRSessionInit options = {});
+
+  // Events
+  attribute EventHandler ondevicechange;
+};
+
+enum XRSessionMode {
+  "inline",
+  "immersive-vr",
+  "immersive-ar"
+};
+
+dictionary XRSessionInit {
+  sequence<any> requiredFeatures;
+  sequence<any> optionalFeatures;
+};
+
+enum XRVisibilityState {
+  "visible",
+  "visible-blurred",
+  "hidden",
+};
+
+[SecureContext, Exposed=Window] interface XRSession : EventTarget {
+  // Attributes
+  readonly attribute XRVisibilityState visibilityState;
+  readonly attribute float? frameRate;
+  readonly attribute Float32Array? supportedFrameRates;
+  [SameObject] readonly attribute XRRenderState renderState;
+  [SameObject] readonly attribute XRInputSourceArray inputSources;
+
+  // Methods
+  undefined updateRenderState(optional XRRenderStateInit state = {});
+  Promise<undefined> updateTargetFrameRate(float rate);
+  [NewObject] Promise<XRReferenceSpace> requestReferenceSpace(XRReferenceSpaceType type);
+
+  unsigned long requestAnimationFrame(XRFrameRequestCallback callback);
+  undefined cancelAnimationFrame(unsigned long handle);
+
+  Promise<undefined> end();
+
+  // Events
+  attribute EventHandler onend;
+  attribute EventHandler oninputsourceschange;
+  attribute EventHandler onselect;
+  attribute EventHandler onselectstart;
+  attribute EventHandler onselectend;
+  attribute EventHandler onsqueeze;
+  attribute EventHandler onsqueezestart;
+  attribute EventHandler onsqueezeend;
+  attribute EventHandler onvisibilitychange;
+  attribute EventHandler onframeratechange;
+};
+
+dictionary XRRenderStateInit {
+  double depthNear;
+  double depthFar;
+  double inlineVerticalFieldOfView;
+  XRWebGLLayer? baseLayer;
+  sequence<XRLayer>? layers;
+};
+
+[SecureContext, Exposed=Window] interface XRRenderState {
+  readonly attribute double depthNear;
+  readonly attribute double depthFar;
+  readonly attribute double? inlineVerticalFieldOfView;
+  readonly attribute XRWebGLLayer? baseLayer;
+};
+
+callback XRFrameRequestCallback = undefined (DOMHighResTimeStamp time, XRFrame frame);
+
+[SecureContext, Exposed=Window] interface XRFrame {
+  [SameObject] readonly attribute XRSession session;
+  readonly attribute DOMHighResTimeStamp predictedDisplayTime;
+
+  XRViewerPose? getViewerPose(XRReferenceSpace referenceSpace);
+  XRPose? getPose(XRSpace space, XRSpace baseSpace);
+};
+
+[SecureContext, Exposed=Window] interface XRSpace : EventTarget {
+
+};
+
+enum XRReferenceSpaceType {
+  "viewer",
+  "local",
+  "local-floor",
+  "bounded-floor",
+  "unbounded"
+};
+
+[SecureContext, Exposed=Window]
+interface XRReferenceSpace : XRSpace {
+  [NewObject] XRReferenceSpace getOffsetReferenceSpace(XRRigidTransform originOffset);
+
+  attribute EventHandler onreset;
+};
+
+[SecureContext, Exposed=Window]
+interface XRBoundedReferenceSpace : XRReferenceSpace {
+  readonly attribute FrozenArray<DOMPointReadOnly> boundsGeometry;
+};
+
+enum XREye {
+  "none",
+  "left",
+  "right"
+};
+
+[SecureContext, Exposed=Window] interface XRView {
+  readonly attribute XREye eye;
+  readonly attribute Float32Array projectionMatrix;
+  [SameObject] readonly attribute XRRigidTransform transform;
+  readonly attribute double? recommendedViewportScale;
+
+  undefined requestViewportScale(double? scale);
+};
+
+[SecureContext, Exposed=Window] interface XRViewport {
+  readonly attribute long x;
+  readonly attribute long y;
+  readonly attribute long width;
+  readonly attribute long height;
+};
+
+[SecureContext, Exposed=Window]
+interface XRRigidTransform {
+  constructor(optional DOMPointInit position = {}, optional DOMPointInit orientation = {});
+  [SameObject] readonly attribute DOMPointReadOnly position;
+  [SameObject] readonly attribute DOMPointReadOnly orientation;
+  readonly attribute Float32Array matrix;
+  [SameObject] readonly attribute XRRigidTransform inverse;
+};
+
+[SecureContext, Exposed=Window] interface XRPose {
+  [SameObject] readonly attribute XRRigidTransform transform;
+  [SameObject] readonly attribute DOMPointReadOnly? linearVelocity;
+  [SameObject] readonly attribute DOMPointReadOnly? angularVelocity;
+
+  readonly attribute boolean emulatedPosition;
+};
+
+[SecureContext, Exposed=Window] interface XRViewerPose : XRPose {
+  [SameObject] readonly attribute FrozenArray<XRView> views;
+};
+
+enum XRHandedness {
+  "none",
+  "left",
+  "right"
+};
+
+enum XRTargetRayMode {
+  "gaze",
+  "tracked-pointer",
+  "screen"
+};
+
+[SecureContext, Exposed=Window]
+interface XRInputSource {
+  readonly attribute XRHandedness handedness;
+  readonly attribute XRTargetRayMode targetRayMode;
+  [SameObject] readonly attribute XRSpace targetRaySpace;
+  [SameObject] readonly attribute XRSpace? gripSpace;
+  [SameObject] readonly attribute FrozenArray<DOMString> profiles;
+};
+
+[SecureContext, Exposed=Window]
+interface XRInputSourceArray {
+  iterable<XRInputSource>;
+  readonly attribute unsigned long length;
+  getter XRInputSource(unsigned long index);
+};
+
+[SecureContext, Exposed=Window]
+interface XRLayer : EventTarget {};
+
+
+typedef (WebGLRenderingContext or
+         WebGL2RenderingContext) XRWebGLRenderingContext;
+
+dictionary XRWebGLLayerInit {
+  boolean antialias = true;
+  boolean depth = true;
+  boolean stencil = false;
+  boolean alpha = true;
+  boolean ignoreDepthValues = false;
+  double framebufferScaleFactor = 1.0;
+};
+
+[SecureContext, Exposed=Window]
+interface XRWebGLLayer: XRLayer {
+  constructor(XRSession session,
+             XRWebGLRenderingContext context,
+             optional XRWebGLLayerInit layerInit = {});
+  // Attributes
+  readonly attribute boolean antialias;
+  readonly attribute boolean ignoreDepthValues;
+  attribute float? fixedFoveation;
+
+  [SameObject] readonly attribute WebGLFramebuffer? framebuffer;
+  readonly attribute unsigned long framebufferWidth;
+  readonly attribute unsigned long framebufferHeight;
+
+  // Methods
+  XRViewport? getViewport(XRView view);
+
+  // Static Methods
+  static double getNativeFramebufferScaleFactor(XRSession session);
+};
+
+partial dictionary WebGLContextAttributes {
+    boolean xrCompatible = false;
+};
+
+partial interface mixin WebGLRenderingContextBase {
+    [NewObject] Promise<undefined> makeXRCompatible();
+};
+
+[SecureContext, Exposed=Window]
+interface XRSessionEvent : Event {
+  constructor(DOMString type, XRSessionEventInit eventInitDict);
+  [SameObject] readonly attribute XRSession session;
+};
+
+dictionary XRSessionEventInit : EventInit {
+  required XRSession session;
+};
+
+[SecureContext, Exposed=Window]
+interface XRInputSourceEvent : Event {
+  constructor(DOMString type, XRInputSourceEventInit eventInitDict);
+  [SameObject] readonly attribute XRFrame frame;
+  [SameObject] readonly attribute XRInputSource inputSource;
+};
+
+dictionary XRInputSourceEventInit : EventInit {
+  required XRFrame frame;
+  required XRInputSource inputSource;
+};
+
+[SecureContext, Exposed=Window]
+interface XRInputSourcesChangeEvent : Event {
+  constructor(DOMString type, XRInputSourcesChangeEventInit eventInitDict);
+  [SameObject] readonly attribute XRSession session;
+  [SameObject] readonly attribute FrozenArray<XRInputSource> added;
+  [SameObject] readonly attribute FrozenArray<XRInputSource> removed;
+};
+
+dictionary XRInputSourcesChangeEventInit : EventInit {
+  required XRSession session;
+  required FrozenArray<XRInputSource> added;
+  required FrozenArray<XRInputSource> removed;
+
+};
+
+[SecureContext, Exposed=Window]
+interface XRReferenceSpaceEvent : Event {
+  constructor(DOMString type, XRReferenceSpaceEventInit eventInitDict);
+  [SameObject] readonly attribute XRReferenceSpace referenceSpace;
+  [SameObject] readonly attribute XRRigidTransform? transform;
+};
+
+dictionary XRReferenceSpaceEventInit : EventInit {
+  required XRReferenceSpace referenceSpace;
+  XRRigidTransform? transform = null;
+};
+
+dictionary XRSessionSupportedPermissionDescriptor: PermissionDescriptor {
+  XRSessionMode mode;
+};
+
+dictionary XRPermissionDescriptor: PermissionDescriptor {
+  XRSessionMode mode;
+  sequence<any> requiredFeatures;
+  sequence<any> optionalFeatures;
+};
+
+[Exposed=Window]
+interface XRPermissionStatus: PermissionStatus {
+  attribute FrozenArray<any> granted;
+};

third-party/vendor/web-sys/webidls/unstable/WebXRGamepadsModule.webidl

@@ -0,0 +1,11 @@
+/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/*
+ * WebXR Device API
+ * W3C Working Draft, 31 March 2022
+ * The origin of this IDL file is:
+ * https://www.w3.org/TR/2022/WD-webxr-gamepads-module-1-20220426/
+ */
+
+partial interface XRInputSource {
+  [SameObject] readonly attribute Gamepad? gamepad;
+};

third-party/vendor/web-sys/webidls/unstable/WebXRHandInputModule.webidl

@@ -0,0 +1,69 @@
+/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/*
+ * WebXR Device API
+ * W3C Working Draft, 19 April 2022
+ * The origin of this IDL file is:
+ * https://www.w3.org/TR/2022/WD-webxr-hand-input-1-20220419/
+ */
+
+partial interface XRInputSource {
+   [SameObject] readonly attribute XRHand? hand;
+};
+
+enum XRHandJoint {
+  "wrist",
+
+  "thumb-metacarpal",
+  "thumb-phalanx-proximal",
+  "thumb-phalanx-distal",
+  "thumb-tip",
+
+  "index-finger-metacarpal",
+  "index-finger-phalanx-proximal",
+  "index-finger-phalanx-intermediate",
+  "index-finger-phalanx-distal",
+  "index-finger-tip",
+
+  "middle-finger-metacarpal",
+  "middle-finger-phalanx-proximal",
+  "middle-finger-phalanx-intermediate",
+  "middle-finger-phalanx-distal",
+  "middle-finger-tip",
+
+  "ring-finger-metacarpal",
+  "ring-finger-phalanx-proximal",
+  "ring-finger-phalanx-intermediate",
+  "ring-finger-phalanx-distal",
+  "ring-finger-tip",
+
+  "pinky-finger-metacarpal",
+  "pinky-finger-phalanx-proximal",
+  "pinky-finger-phalanx-intermediate",
+  "pinky-finger-phalanx-distal",
+  "pinky-finger-tip"
+};
+
+[Exposed=Window]
+interface XRHand {
+    iterable<XRHandJoint, XRJointSpace>;
+
+    readonly attribute unsigned long size;
+    XRJointSpace get(XRHandJoint key);
+};
+
+[Exposed=Window]
+interface XRJointSpace: XRSpace {
+  readonly attribute XRHandJoint jointName;
+};
+
+partial interface XRFrame {
+    XRJointPose? getJointPose(XRJointSpace joint, XRSpace baseSpace);
+    boolean fillJointRadii(sequence<XRJointSpace> jointSpaces, Float32Array radii);
+
+    boolean fillPoses(sequence<XRSpace> spaces, XRSpace baseSpace, Float32Array transforms);
+};
+
+[Exposed=Window]
+interface XRJointPose: XRPose {
+    readonly attribute float radius;
+};

third-party/vendor/web-sys/webidls/unstable/is-input-pending.webidl

@@ -0,0 +1,11 @@
+dictionary IsInputPendingOptions {
+  boolean includeContinuous = false;
+};
+
+[Exposed=Window] interface Scheduling {
+   boolean isInputPending(optional IsInputPendingOptions isInputPendingOptions = {});
+};
+
+partial interface Navigator {
+  readonly attribute Scheduling scheduling;
+};

third-party/vendor/web-sys/webidls/unstable/scheduling-apis.webidl

@@ -0,0 +1,59 @@
+enum TaskPriority {
+  "user-blocking",
+  "user-visible",
+  "background"
+};
+
+dictionary SchedulerPostTaskOptions {
+  AbortSignal signal;
+  TaskPriority priority;
+  [EnforceRange] unsigned long long delay = 0;
+};
+
+callback SchedulerPostTaskCallback = any ();
+
+[Exposed=(Window, Worker)]
+interface Scheduler {
+  Promise<any> postTask(SchedulerPostTaskCallback callback,
+                        optional SchedulerPostTaskOptions options = {});
+};
+
+[Exposed=(Window, Worker)]
+interface TaskPriorityChangeEvent : Event {
+  constructor(DOMString type, TaskPriorityChangeEventInit priorityChangeEventInitDict);
+
+  readonly attribute TaskPriority previousPriority;
+};
+
+dictionary TaskPriorityChangeEventInit : EventInit {
+  required TaskPriority previousPriority;
+};
+
+dictionary TaskControllerInit {
+  TaskPriority priority = "user-visible";
+};
+
+[Exposed=(Window,Worker)]
+interface TaskController : AbortController {
+  constructor(optional TaskControllerInit init = {});
+
+  [Throws]
+  undefined setPriority(TaskPriority priority);
+};
+
+dictionary TaskSignalAnyInit {
+  (TaskPriority or TaskSignal) priority = "user-visible";
+};
+
+[Exposed=(Window, Worker)]
+interface TaskSignal : AbortSignal {
+  [NewObject] static TaskSignal _any(sequence<AbortSignal> signals, optional TaskSignalAnyInit init = {});
+
+  readonly attribute TaskPriority priority;
+
+  attribute EventHandler onprioritychange;
+};
+
+partial interface mixin WindowOrWorkerGlobalScope {
+  [Replaceable] readonly attribute Scheduler scheduler;
+};

third-party/vendor/web-sys/webidls/unstable/weblock-apis.webidl

@@ -0,0 +1,45 @@
+[SecureContext]
+interface mixin NavigatorLocks {
+  readonly attribute LockManager locks;
+};
+Navigator includes NavigatorLocks;
+WorkerNavigator includes NavigatorLocks;
+
+[SecureContext, Exposed=(Window,Worker)]
+interface LockManager {
+  Promise<any> request(DOMString name,
+                       LockGrantedCallback callback);
+  Promise<any> request(DOMString name,
+                       LockOptions options,
+                       LockGrantedCallback callback);
+
+  Promise<LockManagerSnapshot> query();
+};
+
+callback LockGrantedCallback = Promise<any> (Lock? lock);
+
+enum LockMode { "shared", "exclusive" };
+
+dictionary LockOptions {
+  LockMode mode = "exclusive";
+  boolean ifAvailable = false;
+  boolean steal = false;
+  AbortSignal signal;
+};
+
+dictionary LockManagerSnapshot {
+  sequence<LockInfo> held;
+  sequence<LockInfo> pending;
+};
+
+dictionary LockInfo {
+  DOMString name;
+  LockMode mode;
+  DOMString clientId;
+};
+
+[SecureContext, Exposed=(Window,Worker)]
+interface Lock {
+  readonly attribute DOMString name;
+  readonly attribute LockMode mode;
+};