@webref/idl 3.29.0 → 3.31.0

package/push-api.idl

@@ -0,0 +1,93 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Push API (https://w3c.github.io/push-api/)
+
+dictionary PushPermissionDescriptor : PermissionDescriptor {
+  boolean userVisibleOnly = false;
+};
+
+[SecureContext]
+partial interface ServiceWorkerRegistration {
+  readonly attribute PushManager pushManager;
+};
+
+[Exposed=(Window,Worker), SecureContext]
+interface PushManager {
+  [SameObject] static readonly attribute FrozenArray<DOMString> supportedContentEncodings;
+
+  Promise<PushSubscription> subscribe(optional PushSubscriptionOptionsInit options = {});
+  Promise<PushSubscription?> getSubscription();
+  Promise<PermissionState> permissionState(optional PushSubscriptionOptionsInit options = {});
+};
+
+[Exposed=(Window,Worker), SecureContext]
+interface PushSubscriptionOptions {
+  readonly attribute boolean userVisibleOnly;
+  [SameObject] readonly attribute ArrayBuffer? applicationServerKey;
+};
+
+dictionary PushSubscriptionOptionsInit {
+  boolean userVisibleOnly = false;
+  (BufferSource or DOMString)? applicationServerKey = null;
+};
+
+[Exposed=(Window,Worker), SecureContext]
+interface PushSubscription {
+  readonly attribute USVString endpoint;
+  readonly attribute EpochTimeStamp? expirationTime;
+  [SameObject] readonly attribute PushSubscriptionOptions options;
+  ArrayBuffer? getKey(PushEncryptionKeyName name);
+  Promise<boolean> unsubscribe();
+
+  PushSubscriptionJSON toJSON();
+};
+
+dictionary PushSubscriptionJSON {
+  USVString endpoint;
+  EpochTimeStamp? expirationTime = null;
+  record<DOMString, USVString> keys;
+};
+
+enum PushEncryptionKeyName {
+  "p256dh",
+  "auth"
+};
+
+[Exposed=ServiceWorker, SecureContext]
+interface PushMessageData {
+  ArrayBuffer arrayBuffer();
+  Blob blob();
+  any json();
+  USVString text();
+};
+
+[Exposed=ServiceWorker, SecureContext]
+partial interface ServiceWorkerGlobalScope {
+  attribute EventHandler onpush;
+  attribute EventHandler onpushsubscriptionchange;
+};
+
+[Exposed=ServiceWorker, SecureContext]
+interface PushEvent : ExtendableEvent {
+  constructor(DOMString type, optional PushEventInit eventInitDict = {});
+  readonly attribute PushMessageData? data;
+};
+
+typedef (BufferSource or USVString) PushMessageDataInit;
+
+dictionary PushEventInit : ExtendableEventInit {
+  PushMessageDataInit data;
+};
+
+[Exposed=ServiceWorker, SecureContext]
+interface PushSubscriptionChangeEvent : ExtendableEvent {
+  constructor(DOMString type, optional PushSubscriptionChangeEventInit eventInitDict = {});
+  readonly attribute PushSubscription? newSubscription;
+  readonly attribute PushSubscription? oldSubscription;
+};
+
+dictionary PushSubscriptionChangeEventInit : ExtendableEventInit {
+  PushSubscription newSubscription = null;
+  PushSubscription oldSubscription = null;
+};

package/raw-camera-access.idl

@@ -0,0 +1,18 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: WebXR Raw Camera Access Module (https://immersive-web.github.io/raw-camera-access/)
+
+partial interface XRView {
+  [SameObject] readonly attribute XRCamera? camera;
+};
+
+[SecureContext, Exposed=Window]
+interface XRCamera {
+  readonly attribute unsigned long width;
+  readonly attribute unsigned long height;
+};
+
+partial interface XRWebGLBinding {
+  WebGLTexture? getCameraImage(XRCamera camera);
+};

package/referrer-policy.idl

@@ -0,0 +1,16 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Referrer Policy (https://w3c.github.io/webappsec-referrer-policy/)
+
+enum ReferrerPolicy {
+  "",
+  "no-referrer",
+  "no-referrer-when-downgrade",
+  "same-origin",
+  "origin",
+  "strict-origin",
+  "origin-when-cross-origin",
+  "strict-origin-when-cross-origin",
+  "unsafe-url"
+};

package/remote-playback.idl

@@ -0,0 +1,32 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Remote Playback API (https://w3c.github.io/remote-playback/)
+
+[Exposed=Window]
+interface RemotePlayback : EventTarget {
+  Promise<long> watchAvailability(RemotePlaybackAvailabilityCallback callback);
+  Promise<undefined> cancelWatchAvailability(optional long id);
+
+  readonly attribute RemotePlaybackState state;
+
+  attribute EventHandler onconnecting;
+  attribute EventHandler onconnect;
+  attribute EventHandler ondisconnect;
+
+  Promise<undefined> prompt();
+};
+
+enum RemotePlaybackState {
+  "connecting",
+  "connected",
+  "disconnected"
+};
+
+callback RemotePlaybackAvailabilityCallback = undefined(boolean available);
+
+partial interface HTMLMediaElement {
+  [SameObject] readonly attribute RemotePlayback remote;
+
+  [CEReactions] attribute boolean disableRemotePlayback;
+};

package/reporting.idl

@@ -0,0 +1,39 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Reporting API (https://w3c.github.io/reporting/)
+
+[Exposed=(Window,Worker)]
+interface ReportBody {
+  [Default] object toJSON();
+};
+
+[Exposed=(Window,Worker)]
+interface Report {
+  [Default] object toJSON();
+  readonly attribute DOMString type;
+  readonly attribute DOMString url;
+  readonly attribute ReportBody? body;
+};
+
+[Exposed=(Window,Worker)]
+interface ReportingObserver {
+  constructor(ReportingObserverCallback callback, optional ReportingObserverOptions options = {});
+  undefined observe();
+  undefined disconnect();
+  ReportList takeRecords();
+};
+
+callback ReportingObserverCallback = undefined (sequence<Report> reports, ReportingObserver observer);
+
+dictionary ReportingObserverOptions {
+  sequence<DOMString> types;
+  boolean buffered = false;
+};
+
+typedef sequence<Report> ReportList;
+
+dictionary GenerateTestReportParameters {
+  required DOMString message;
+  DOMString group = "default";
+};

package/requestStorageAccessFor.idl

@@ -0,0 +1,12 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: requestStorageAccessFor API (https://privacycg.github.io/requestStorageAccessFor/)
+
+partial interface Document {
+  Promise<undefined> requestStorageAccessFor(USVString requestedOrigin);
+};
+
+dictionary TopLevelStorageAccessPermissionDescriptor : PermissionDescriptor {
+    USVString requestedOrigin = "";
+};

package/requestidlecallback.idl

@@ -0,0 +1,20 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: requestIdleCallback() (https://w3c.github.io/requestidlecallback/)
+
+partial interface Window {
+  unsigned long requestIdleCallback(IdleRequestCallback callback, optional IdleRequestOptions options = {});
+  undefined cancelIdleCallback(unsigned long handle);
+};
+
+dictionary IdleRequestOptions {
+  unsigned long timeout;
+};
+
+[Exposed=Window] interface IdleDeadline {
+  DOMHighResTimeStamp timeRemaining();
+  readonly attribute boolean didTimeout;
+};
+
+callback IdleRequestCallback = undefined (IdleDeadline deadline);

package/resize-observer.idl

@@ -0,0 +1,37 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Resize Observer (https://drafts.csswg.org/resize-observer-1/)
+
+enum ResizeObserverBoxOptions {
+    "border-box", "content-box", "device-pixel-content-box"
+};
+
+dictionary ResizeObserverOptions {
+    ResizeObserverBoxOptions box = "content-box";
+};
+
+[Exposed=(Window)]
+interface ResizeObserver {
+    constructor(ResizeObserverCallback callback);
+    undefined observe(Element target, optional ResizeObserverOptions options = {});
+    undefined unobserve(Element target);
+    undefined disconnect();
+};
+
+callback ResizeObserverCallback = undefined (sequence<ResizeObserverEntry> entries, ResizeObserver observer);
+
+[Exposed=Window]
+interface ResizeObserverEntry {
+    readonly attribute Element target;
+    readonly attribute DOMRectReadOnly contentRect;
+    readonly attribute FrozenArray<ResizeObserverSize> borderBoxSize;
+    readonly attribute FrozenArray<ResizeObserverSize> contentBoxSize;
+    readonly attribute FrozenArray<ResizeObserverSize> devicePixelContentBoxSize;
+};
+
+[Exposed=Window]
+interface ResizeObserverSize {
+    readonly attribute unrestricted double inlineSize;
+    readonly attribute unrestricted double blockSize;
+};

package/resource-timing.idl

@@ -0,0 +1,40 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Resource Timing (https://w3c.github.io/resource-timing/)
+
+[Exposed=(Window,Worker)]
+interface PerformanceResourceTiming : PerformanceEntry {
+    readonly attribute DOMString initiatorType;
+    readonly attribute DOMString deliveryType;
+    readonly attribute ByteString nextHopProtocol;
+    readonly attribute DOMHighResTimeStamp workerStart;
+    readonly attribute DOMHighResTimeStamp redirectStart;
+    readonly attribute DOMHighResTimeStamp redirectEnd;
+    readonly attribute DOMHighResTimeStamp fetchStart;
+    readonly attribute DOMHighResTimeStamp domainLookupStart;
+    readonly attribute DOMHighResTimeStamp domainLookupEnd;
+    readonly attribute DOMHighResTimeStamp connectStart;
+    readonly attribute DOMHighResTimeStamp connectEnd;
+    readonly attribute DOMHighResTimeStamp secureConnectionStart;
+    readonly attribute DOMHighResTimeStamp requestStart;
+    readonly attribute DOMHighResTimeStamp responseStart;
+    readonly attribute DOMHighResTimeStamp responseEnd;
+    readonly attribute unsigned long long  transferSize;
+    readonly attribute unsigned long long  encodedBodySize;
+    readonly attribute unsigned long long  decodedBodySize;
+    readonly attribute unsigned short responseStatus;
+    readonly attribute RenderBlockingStatusType renderBlockingStatus;
+    [Default] object toJSON();
+};
+
+enum RenderBlockingStatusType {
+    "blocking",
+    "non-blocking"
+};
+
+partial interface Performance {
+  undefined clearResourceTimings ();
+  undefined setResourceTimingBufferSize (unsigned long maxSize);
+  attribute EventHandler onresourcetimingbufferfull;
+};

package/sanitizer-api.idl

@@ -0,0 +1,38 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: HTML Sanitizer API (https://wicg.github.io/sanitizer-api/)
+
+[
+  Exposed=(Window),
+  SecureContext
+] interface Sanitizer {
+  constructor(optional SanitizerConfig config = {});
+
+  DocumentFragment sanitize((Document or DocumentFragment) input);
+  Element? sanitizeFor(DOMString element, DOMString input);
+
+  SanitizerConfig getConfiguration();
+  static SanitizerConfig getDefaultConfiguration();
+};
+
+dictionary SetHTMLOptions {
+  Sanitizer sanitizer;
+};
+[SecureContext]
+partial interface Element {
+  undefined setHTML(DOMString input, optional SetHTMLOptions options = {});
+};
+
+dictionary SanitizerConfig {
+  sequence<DOMString> allowElements;
+  sequence<DOMString> blockElements;
+  sequence<DOMString> dropElements;
+  AttributeMatchList allowAttributes;
+  AttributeMatchList dropAttributes;
+  boolean allowCustomElements;
+  boolean allowUnknownMarkup;
+  boolean allowComments;
+};
+
+typedef record<DOMString, sequence<DOMString>> AttributeMatchList;

package/savedata.idl

@@ -0,0 +1,10 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Save Data API (https://wicg.github.io/savedata/)
+
+interface mixin NetworkInformationSaveData {
+  [SameObject] readonly attribute boolean saveData;
+};
+
+NetworkInformation includes NetworkInformationSaveData;

package/scheduling-apis.idl

@@ -0,0 +1,11 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Prioritized Task Scheduling (https://wicg.github.io/scheduling-apis/)
+
+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 = {});  undefined setPriority(TaskPriority priority);};
+[Exposed=(Window, Worker)]interface TaskSignal : AbortSignal {  readonly attribute TaskPriority priority;  attribute EventHandler onprioritychange;};
+partial interface mixin WindowOrWorkerGlobalScope {  [Replaceable] readonly attribute Scheduler scheduler;};

package/screen-capture.idl

@@ -0,0 +1,85 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Screen Capture (https://w3c.github.io/mediacapture-screen-share/)
+
+partial interface MediaDevices {
+  Promise<MediaStream> getDisplayMedia(optional DisplayMediaStreamOptions options = {});
+};
+
+enum CaptureStartFocusBehavior {
+  "focus-captured-surface",
+  "no-focus-change"
+};
+
+[Exposed=Window, SecureContext]
+interface CaptureController {
+  constructor();
+  undefined setFocusBehavior(CaptureStartFocusBehavior focusBehavior);
+};
+
+enum SelfCapturePreferenceEnum {
+  "include",
+  "exclude"
+};
+
+enum SystemAudioPreferenceEnum {
+  "include",
+  "exclude"
+};
+
+enum SurfaceSwitchingPreferenceEnum {
+  "include",
+  "exclude"
+};
+
+dictionary DisplayMediaStreamOptions {
+  (boolean or MediaTrackConstraints) video = true;
+  (boolean or MediaTrackConstraints) audio = false;
+  CaptureController controller;
+  SelfCapturePreferenceEnum selfBrowserSurface;
+  SystemAudioPreferenceEnum systemAudio;
+  SurfaceSwitchingPreferenceEnum surfaceSwitching;
+};
+
+partial dictionary MediaTrackSupportedConstraints {
+  boolean displaySurface = true;
+  boolean logicalSurface = true;
+  boolean cursor = true;
+  boolean restrictOwnAudio = true;
+  boolean suppressLocalAudioPlayback = true;
+};
+
+partial dictionary MediaTrackConstraintSet {
+  ConstrainDOMString displaySurface;
+  ConstrainBoolean logicalSurface;
+  ConstrainDOMString cursor;
+  ConstrainBoolean restrictOwnAudio;
+  ConstrainBoolean suppressLocalAudioPlayback;
+};
+
+partial dictionary MediaTrackSettings {
+  DOMString displaySurface;
+  boolean logicalSurface;
+  DOMString cursor;
+  boolean restrictOwnAudio;
+  boolean suppressLocalAudioPlayback;
+};
+
+partial dictionary MediaTrackCapabilities {
+  DOMString displaySurface;
+  boolean logicalSurface;
+  sequence<DOMString> cursor;
+};
+
+enum DisplayCaptureSurfaceType {
+  "monitor",
+  "window",
+  "browser"
+};
+
+enum CursorCaptureConstraint {
+  "never",
+  "always",
+  "motion"
+};

package/screen-orientation.idl

@@ -0,0 +1,35 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Screen Orientation (https://w3c.github.io/screen-orientation/)
+
+partial interface Screen {
+  [SameObject] readonly attribute ScreenOrientation orientation;
+};
+
+[Exposed=Window]
+interface ScreenOrientation : EventTarget {
+  Promise<undefined> lock(OrientationLockType orientation);
+  undefined unlock();
+  readonly attribute OrientationType type;
+  readonly attribute unsigned short angle;
+  attribute EventHandler onchange;
+};
+
+enum OrientationLockType {
+  "any",
+  "natural",
+  "landscape",
+  "portrait",
+  "portrait-primary",
+  "portrait-secondary",
+  "landscape-primary",
+  "landscape-secondary"
+};
+
+enum OrientationType {
+  "portrait-primary",
+  "portrait-secondary",
+  "landscape-primary",
+  "landscape-secondary"
+};

package/screen-wake-lock.idl

@@ -0,0 +1,24 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Screen Wake Lock API (https://w3c.github.io/screen-wake-lock/)
+
+[SecureContext]
+partial interface Navigator {
+  [SameObject] readonly attribute WakeLock wakeLock;
+};
+
+[SecureContext, Exposed=(Window)]
+interface WakeLock {
+  Promise<WakeLockSentinel> request(optional WakeLockType type = "screen");
+};
+
+[SecureContext, Exposed=(Window)]
+interface WakeLockSentinel : EventTarget {
+  readonly attribute boolean released;
+  readonly attribute WakeLockType type;
+  Promise<undefined> release();
+  attribute EventHandler onrelease;
+};
+
+enum WakeLockType { "screen" };

package/scroll-animations.idl

@@ -0,0 +1,41 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Scroll-driven Animations (https://drafts.csswg.org/scroll-animations-1/)
+
+enum ScrollAxis {
+  "block",
+  "inline",
+  "horizontal",
+  "vertical"
+};
+
+dictionary ScrollTimelineOptions {
+  Element? source;
+  ScrollAxis axis = "block";
+};
+
+[Exposed=Window]
+interface ScrollTimeline : AnimationTimeline {
+  constructor(optional ScrollTimelineOptions options = {});
+  readonly attribute Element? source;
+  readonly attribute ScrollAxis axis;
+};
+
+dictionary ViewTimelineOptions {
+  Element subject;
+  ScrollAxis axis = "block";
+};
+
+[Exposed=Window]
+interface ViewTimeline : ScrollTimeline {
+  constructor(optional ViewTimelineOptions options = {});
+  readonly attribute Element subject;
+  readonly attribute CSSNumericValue startOffset;
+  readonly attribute CSSNumericValue endOffset;
+};
+
+[Exposed=Window]
+partial interface AnimationTimeline {
+  CSSNumericValue? getCurrentTime(optional CSSOMString rangeName);
+};

package/scroll-to-text-fragment.idl

@@ -0,0 +1,12 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: URL Fragment Text Directives (https://wicg.github.io/scroll-to-text-fragment/)
+
+[Exposed=Window]
+interface FragmentDirective {
+};
+
+partial interface Document {
+    [SameObject] readonly attribute FragmentDirective fragmentDirective;
+};

package/secure-payment-confirmation.idl

@@ -0,0 +1,48 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Secure Payment Confirmation (https://w3c.github.io/secure-payment-confirmation/)
+
+dictionary SecurePaymentConfirmationRequest {
+    required BufferSource challenge;
+    required USVString rpId;
+    required sequence<BufferSource> credentialIds;
+    required PaymentCredentialInstrument instrument;
+    unsigned long timeout;
+    USVString payeeName;
+    USVString payeeOrigin;
+    AuthenticationExtensionsClientInputs extensions;
+    sequence<USVString> locale;
+    boolean showOptOut;
+};
+partial dictionary AuthenticationExtensionsClientInputs {
+  AuthenticationExtensionsPaymentInputs payment;
+};
+
+dictionary AuthenticationExtensionsPaymentInputs {
+  boolean isPayment;
+
+  // Only used for authentication.
+  USVString rpId;
+  USVString topOrigin;
+  USVString payeeName;
+  USVString payeeOrigin;
+  PaymentCurrencyAmount total;
+  PaymentCredentialInstrument instrument;
+};
+dictionary CollectedClientPaymentData : CollectedClientData {
+    required CollectedClientAdditionalPaymentData payment;
+};
+dictionary CollectedClientAdditionalPaymentData {
+    required USVString rpId;
+    required USVString topOrigin;
+    USVString payeeName;
+    USVString payeeOrigin;
+    required PaymentCurrencyAmount total;
+    required PaymentCredentialInstrument instrument;
+};
+dictionary PaymentCredentialInstrument {
+    required USVString displayName;
+    required USVString icon;
+    boolean iconMustBeShown = true;
+};

package/selection-api.idl

@@ -0,0 +1,46 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Selection API (https://w3c.github.io/selection-api/)
+
+[Exposed=Window]
+interface Selection {
+  readonly attribute Node? anchorNode;
+  readonly attribute unsigned long anchorOffset;
+  readonly attribute Node? focusNode;
+  readonly attribute unsigned long focusOffset;
+  readonly attribute boolean isCollapsed;
+  readonly attribute unsigned long rangeCount;
+  readonly attribute DOMString type;
+  readonly attribute DOMString direction;
+  Range getRangeAt(unsigned long index);
+  undefined addRange(Range range);
+  undefined removeRange(Range range);
+  undefined removeAllRanges();
+  undefined empty();
+  sequence<StaticRange> getComposedRanges(ShadowRoot... shadowRoots);
+  undefined collapse(Node? node, optional unsigned long offset = 0);
+  undefined setPosition(Node? node, optional unsigned long offset = 0);
+  undefined collapseToStart();
+  undefined collapseToEnd();
+  undefined extend(Node node, optional unsigned long offset = 0);
+  undefined setBaseAndExtent(Node anchorNode, unsigned long anchorOffset, Node focusNode, unsigned long focusOffset);
+  undefined selectAllChildren(Node node);
+  undefined modify(optional DOMString alter, optional DOMString direction, optional DOMString granularity);
+  [CEReactions] undefined deleteFromDocument();
+  boolean containsNode(Node node, optional boolean allowPartialContainment = false);
+  stringifier;
+};
+
+partial interface Document {
+  Selection? getSelection();
+};
+
+partial interface Window {
+  Selection? getSelection();
+};
+
+partial interface mixin GlobalEventHandlers {
+  attribute EventHandler onselectstart;
+  attribute EventHandler onselectionchange;
+};