From d632cce129cb7025a34cf0aa7262a38fb12f47c4 Mon Sep 17 00:00:00 2001
From: ud2 <sjx233@qq.com>
Date: Tue, 4 Jul 2023 02:36:55 +0800
Subject: fix(dts): make globals available on globalThis (#19438)

This PR changes Web IDL interfaces to be declared with `var` instead of
`class`, so that accessing them via `globalThis` does not raise type
errors.

Closes #13390.
---
 ext/web/lib.deno_web.d.ts | 426 +++++++++++++++++++++++++++++++++-------------
 1 file changed, 309 insertions(+), 117 deletions(-)

(limited to 'ext/web')

diff --git a/ext/web/lib.deno_web.d.ts b/ext/web/lib.deno_web.d.ts
index e1ffdc329..331c9536b 100644
--- a/ext/web/lib.deno_web.d.ts
+++ b/ext/web/lib.deno_web.d.ts
@@ -5,16 +5,71 @@
 /// <reference no-default-lib="true" />
 /// <reference lib="esnext" />
 
-/** @category DOM Events */
-declare class DOMException extends Error {
-  constructor(message?: string, name?: string);
+/** @category Web APIs */
+declare interface DOMException extends Error {
   readonly name: string;
   readonly message: string;
   readonly code: number;
+  readonly INDEX_SIZE_ERR: 1;
+  readonly DOMSTRING_SIZE_ERR: 2;
+  readonly HIERARCHY_REQUEST_ERR: 3;
+  readonly WRONG_DOCUMENT_ERR: 4;
+  readonly INVALID_CHARACTER_ERR: 5;
+  readonly NO_DATA_ALLOWED_ERR: 6;
+  readonly NO_MODIFICATION_ALLOWED_ERR: 7;
+  readonly NOT_FOUND_ERR: 8;
+  readonly NOT_SUPPORTED_ERR: 9;
+  readonly INUSE_ATTRIBUTE_ERR: 10;
+  readonly INVALID_STATE_ERR: 11;
+  readonly SYNTAX_ERR: 12;
+  readonly INVALID_MODIFICATION_ERR: 13;
+  readonly NAMESPACE_ERR: 14;
+  readonly INVALID_ACCESS_ERR: 15;
+  readonly VALIDATION_ERR: 16;
+  readonly TYPE_MISMATCH_ERR: 17;
+  readonly SECURITY_ERR: 18;
+  readonly NETWORK_ERR: 19;
+  readonly ABORT_ERR: 20;
+  readonly URL_MISMATCH_ERR: 21;
+  readonly QUOTA_EXCEEDED_ERR: 22;
+  readonly TIMEOUT_ERR: 23;
+  readonly INVALID_NODE_TYPE_ERR: 24;
+  readonly DATA_CLONE_ERR: 25;
 }
 
+/** @category Web APIs */
+declare var DOMException: {
+  readonly prototype: DOMException;
+  new (message?: string, name?: string): DOMException;
+  readonly INDEX_SIZE_ERR: 1;
+  readonly DOMSTRING_SIZE_ERR: 2;
+  readonly HIERARCHY_REQUEST_ERR: 3;
+  readonly WRONG_DOCUMENT_ERR: 4;
+  readonly INVALID_CHARACTER_ERR: 5;
+  readonly NO_DATA_ALLOWED_ERR: 6;
+  readonly NO_MODIFICATION_ALLOWED_ERR: 7;
+  readonly NOT_FOUND_ERR: 8;
+  readonly NOT_SUPPORTED_ERR: 9;
+  readonly INUSE_ATTRIBUTE_ERR: 10;
+  readonly INVALID_STATE_ERR: 11;
+  readonly SYNTAX_ERR: 12;
+  readonly INVALID_MODIFICATION_ERR: 13;
+  readonly NAMESPACE_ERR: 14;
+  readonly INVALID_ACCESS_ERR: 15;
+  readonly VALIDATION_ERR: 16;
+  readonly TYPE_MISMATCH_ERR: 17;
+  readonly SECURITY_ERR: 18;
+  readonly NETWORK_ERR: 19;
+  readonly ABORT_ERR: 20;
+  readonly URL_MISMATCH_ERR: 21;
+  readonly QUOTA_EXCEEDED_ERR: 22;
+  readonly TIMEOUT_ERR: 23;
+  readonly INVALID_NODE_TYPE_ERR: 24;
+  readonly DATA_CLONE_ERR: 25;
+};
+
 /** @category DOM Events */
-interface EventInit {
+declare interface EventInit {
   bubbles?: boolean;
   cancelable?: boolean;
   composed?: boolean;
@@ -24,8 +79,7 @@ interface EventInit {
  *
  * @category DOM Events
  */
-declare class Event {
-  constructor(type: string, eventInitDict?: EventInit);
+declare interface Event {
   /** Returns true or false depending on how event was initialized. True if
    * event goes through its target's ancestors in reverse tree order, and
    * false otherwise. */
@@ -80,19 +134,28 @@ declare class Event {
   readonly BUBBLING_PHASE: number;
   readonly CAPTURING_PHASE: number;
   readonly NONE: number;
-  static readonly AT_TARGET: number;
-  static readonly BUBBLING_PHASE: number;
-  static readonly CAPTURING_PHASE: number;
-  static readonly NONE: number;
 }
 
+/** An event which takes place in the DOM.
+ *
+ * @category DOM Events
+ */
+declare var Event: {
+  readonly prototype: Event;
+  new (type: string, eventInitDict?: EventInit): Event;
+  readonly AT_TARGET: number;
+  readonly BUBBLING_PHASE: number;
+  readonly CAPTURING_PHASE: number;
+  readonly NONE: number;
+};
+
 /**
  * EventTarget is a DOM interface implemented by objects that can receive events
  * and may have listeners for them.
  *
  * @category DOM Events
  */
-declare class EventTarget {
+declare interface EventTarget {
   /** Appends an event listener for events whose type attribute value is type.
    * The callback argument sets the callback that will be invoked when the event
    * is dispatched.
@@ -134,13 +197,24 @@ declare class EventTarget {
   ): void;
 }
 
+/**
+ * EventTarget is a DOM interface implemented by objects that can receive events
+ * and may have listeners for them.
+ *
+ * @category DOM Events
+ */
+declare var EventTarget: {
+  readonly prototype: EventTarget;
+  new (): EventTarget;
+};
+
 /** @category DOM Events */
-interface EventListener {
+declare interface EventListener {
   (evt: Event): void | Promise<void>;
 }
 
 /** @category DOM Events */
-interface EventListenerObject {
+declare interface EventListenerObject {
   handleEvent(evt: Event): void | Promise<void>;
 }
 
@@ -150,19 +224,19 @@ declare type EventListenerOrEventListenerObject =
   | EventListenerObject;
 
 /** @category DOM Events */
-interface AddEventListenerOptions extends EventListenerOptions {
+declare interface AddEventListenerOptions extends EventListenerOptions {
   once?: boolean;
   passive?: boolean;
   signal?: AbortSignal;
 }
 
 /** @category DOM Events */
-interface EventListenerOptions {
+declare interface EventListenerOptions {
   capture?: boolean;
 }
 
 /** @category DOM Events */
-interface ProgressEventInit extends EventInit {
+declare interface ProgressEventInit extends EventInit {
   lengthComputable?: boolean;
   loaded?: number;
   total?: number;
@@ -174,14 +248,25 @@ interface ProgressEventInit extends EventInit {
  *
  * @category DOM Events
  */
-declare class ProgressEvent<T extends EventTarget = EventTarget> extends Event {
-  constructor(type: string, eventInitDict?: ProgressEventInit);
+declare interface ProgressEvent<T extends EventTarget = EventTarget>
+  extends Event {
   readonly lengthComputable: boolean;
   readonly loaded: number;
   readonly target: T | null;
   readonly total: number;
 }
 
+/** Events measuring progress of an underlying process, like an HTTP request
+ * (for an XMLHttpRequest, or the loading of the underlying resource of an
+ * <img>, <audio>, <video>, <style> or <link>).
+ *
+ * @category DOM Events
+ */
+declare var ProgressEvent: {
+  readonly prototype: ProgressEvent;
+  new (type: string, eventInitDict?: ProgressEventInit): ProgressEvent;
+};
+
 /** Decodes a string of data which has been encoded using base-64 encoding.
  *
  * ```
@@ -214,7 +299,7 @@ declare interface TextDecodeOptions {
 }
 
 /** @category Encoding API */
-interface TextDecoder {
+declare interface TextDecoder {
   /** Returns encoding's name, lowercased. */
   readonly encoding: string;
   /** Returns `true` if error mode is "fatal", and `false` otherwise. */
@@ -228,7 +313,7 @@ interface TextDecoder {
 
 /** @category Encoding API */
 declare var TextDecoder: {
-  prototype: TextDecoder;
+  readonly prototype: TextDecoder;
   new (label?: string, options?: TextDecoderOptions): TextDecoder;
 };
 
@@ -239,7 +324,7 @@ declare interface TextEncoderEncodeIntoResult {
 }
 
 /** @category Encoding API */
-interface TextEncoder {
+declare interface TextEncoder {
   /** Returns "utf-8". */
   readonly encoding: "utf-8";
   /** Returns the result of running UTF-8's encoder. */
@@ -249,12 +334,12 @@ interface TextEncoder {
 
 /** @category Encoding API */
 declare var TextEncoder: {
-  prototype: TextEncoder;
+  readonly prototype: TextEncoder;
   new (): TextEncoder;
 };
 
 /** @category Encoding API */
-interface TextDecoderStream {
+declare interface TextDecoderStream {
   /** Returns encoding's name, lowercased. */
   readonly encoding: string;
   /** Returns `true` if error mode is "fatal", and `false` otherwise. */
@@ -268,12 +353,12 @@ interface TextDecoderStream {
 
 /** @category Encoding API */
 declare var TextDecoderStream: {
-  prototype: TextDecoderStream;
+  readonly prototype: TextDecoderStream;
   new (label?: string, options?: TextDecoderOptions): TextDecoderStream;
 };
 
 /** @category Encoding API */
-interface TextEncoderStream {
+declare interface TextEncoderStream {
   /** Returns "utf-8". */
   readonly encoding: "utf-8";
   readonly readable: ReadableStream<Uint8Array>;
@@ -283,7 +368,7 @@ interface TextEncoderStream {
 
 /** @category Encoding API */
 declare var TextEncoderStream: {
-  prototype: TextEncoderStream;
+  readonly prototype: TextEncoderStream;
   new (): TextEncoderStream;
 };
 
@@ -292,7 +377,7 @@ declare var TextEncoderStream: {
  *
  * @category Web APIs
  */
-declare class AbortController {
+declare interface AbortController {
   /** Returns the AbortSignal object associated with this object. */
   readonly signal: AbortSignal;
   /** Invoking this method will set this object's AbortSignal's aborted flag and
@@ -300,8 +385,18 @@ declare class AbortController {
   abort(reason?: any): void;
 }
 
+/** A controller object that allows you to abort one or more DOM requests as and
+ * when desired.
+ *
+ * @category Web APIs
+ */
+declare var AbortController: {
+  readonly prototype: AbortController;
+  new (): AbortController;
+};
+
 /** @category Web APIs */
-interface AbortSignalEventMap {
+declare interface AbortSignalEventMap {
   abort: Event;
 }
 
@@ -310,7 +405,7 @@ interface AbortSignalEventMap {
  *
  * @category Web APIs
  */
-interface AbortSignal extends EventTarget {
+declare interface AbortSignal extends EventTarget {
   /** Returns true if this AbortSignal's AbortController has signaled to abort,
    * and false otherwise. */
   readonly aborted: boolean;
@@ -344,14 +439,14 @@ interface AbortSignal extends EventTarget {
 
 /** @category Web APIs */
 declare var AbortSignal: {
-  prototype: AbortSignal;
-  new (): AbortSignal;
+  readonly prototype: AbortSignal;
+  new (): never;
   abort(reason?: any): AbortSignal;
   timeout(milliseconds: number): AbortSignal;
 };
 
 /** @category Web File API */
-interface FileReaderEventMap {
+declare interface FileReaderEventMap {
   "abort": ProgressEvent<FileReader>;
   "error": ProgressEvent<FileReader>;
   "load": ProgressEvent<FileReader>;
@@ -366,7 +461,7 @@ interface FileReaderEventMap {
  *
  * @category Web File API
  */
-interface FileReader extends EventTarget {
+declare interface FileReader extends EventTarget {
   readonly error: DOMException | null;
   onabort: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
   onerror: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
@@ -410,7 +505,7 @@ interface FileReader extends EventTarget {
 
 /** @category Web File API */
 declare var FileReader: {
-  prototype: FileReader;
+  readonly prototype: FileReader;
   new (): FileReader;
   readonly DONE: number;
   readonly EMPTY: number;
@@ -418,10 +513,10 @@ declare var FileReader: {
 };
 
 /** @category Web File API */
-type BlobPart = BufferSource | Blob | string;
+declare type BlobPart = BufferSource | Blob | string;
 
 /** @category Web File API */
-interface BlobPropertyBag {
+declare interface BlobPropertyBag {
   type?: string;
   endings?: "transparent" | "native";
 }
@@ -433,9 +528,7 @@ interface BlobPropertyBag {
  *
  * @category Web File API
  */
-declare class Blob {
-  constructor(blobParts?: BlobPart[], options?: BlobPropertyBag);
-
+declare interface Blob {
   readonly size: number;
   readonly type: string;
   arrayBuffer(): Promise<ArrayBuffer>;
@@ -444,8 +537,20 @@ declare class Blob {
   text(): Promise<string>;
 }
 
+/** A file-like object of immutable, raw data. Blobs represent data that isn't
+ * necessarily in a JavaScript-native format. The File interface is based on
+ * Blob, inheriting blob functionality and expanding it to support files on the
+ * user's system.
+ *
+ * @category Web File API
+ */
+declare var Blob: {
+  readonly prototype: Blob;
+  new (blobParts?: BlobPart[], options?: BlobPropertyBag): Blob;
+};
+
 /** @category Web File API */
-interface FilePropertyBag extends BlobPropertyBag {
+declare interface FilePropertyBag extends BlobPropertyBag {
   lastModified?: number;
 }
 
@@ -454,36 +559,40 @@ interface FilePropertyBag extends BlobPropertyBag {
  *
  * @category Web File API
  */
-declare class File extends Blob {
-  constructor(
-    fileBits: BlobPart[],
-    fileName: string,
-    options?: FilePropertyBag,
-  );
-
+declare interface File extends Blob {
   readonly lastModified: number;
   readonly name: string;
 }
 
+/** Provides information about files and allows JavaScript in a web page to
+ * access their content.
+ *
+ * @category Web File API
+ */
+declare var File: {
+  readonly prototype: File;
+  new (fileBits: BlobPart[], fileName: string, options?: FilePropertyBag): File;
+};
+
 /** @category Streams API */
-interface ReadableStreamDefaultReadDoneResult {
+declare interface ReadableStreamDefaultReadDoneResult {
   done: true;
   value?: undefined;
 }
 
 /** @category Streams API */
-interface ReadableStreamDefaultReadValueResult<T> {
+declare interface ReadableStreamDefaultReadValueResult<T> {
   done: false;
   value: T;
 }
 
 /** @category Streams API */
-type ReadableStreamDefaultReadResult<T> =
+declare type ReadableStreamDefaultReadResult<T> =
   | ReadableStreamDefaultReadValueResult<T>
   | ReadableStreamDefaultReadDoneResult;
 
 /** @category Streams API */
-interface ReadableStreamDefaultReader<R = any> {
+declare interface ReadableStreamDefaultReader<R = any> {
   readonly closed: Promise<void>;
   cancel(reason?: any): Promise<void>;
   read(): Promise<ReadableStreamDefaultReadResult<R>>;
@@ -492,29 +601,29 @@ interface ReadableStreamDefaultReader<R = any> {
 
 /** @category Streams API */
 declare var ReadableStreamDefaultReader: {
-  prototype: ReadableStreamDefaultReader;
+  readonly prototype: ReadableStreamDefaultReader;
   new <R>(stream: ReadableStream<R>): ReadableStreamDefaultReader<R>;
 };
 
 /** @category Streams API */
-interface ReadableStreamBYOBReadDoneResult<V extends ArrayBufferView> {
+declare interface ReadableStreamBYOBReadDoneResult<V extends ArrayBufferView> {
   done: true;
   value?: V;
 }
 
 /** @category Streams API */
-interface ReadableStreamBYOBReadValueResult<V extends ArrayBufferView> {
+declare interface ReadableStreamBYOBReadValueResult<V extends ArrayBufferView> {
   done: false;
   value: V;
 }
 
 /** @category Streams API */
-type ReadableStreamBYOBReadResult<V extends ArrayBufferView> =
+declare type ReadableStreamBYOBReadResult<V extends ArrayBufferView> =
   | ReadableStreamBYOBReadDoneResult<V>
   | ReadableStreamBYOBReadValueResult<V>;
 
 /** @category Streams API */
-interface ReadableStreamBYOBReader {
+declare interface ReadableStreamBYOBReader {
   readonly closed: Promise<void>;
   cancel(reason?: any): Promise<void>;
   read<V extends ArrayBufferView>(
@@ -525,24 +634,30 @@ interface ReadableStreamBYOBReader {
 
 /** @category Streams API */
 declare var ReadableStreamBYOBReader: {
-  prototype: ReadableStreamBYOBReader;
+  readonly prototype: ReadableStreamBYOBReader;
   new (stream: ReadableStream<Uint8Array>): ReadableStreamBYOBReader;
 };
 
 /** @category Streams API */
-interface ReadableStreamBYOBRequest {
+declare interface ReadableStreamBYOBRequest {
   readonly view: ArrayBufferView | null;
   respond(bytesWritten: number): void;
   respondWithNewView(view: ArrayBufferView): void;
 }
 
 /** @category Streams API */
-interface ReadableByteStreamControllerCallback {
+declare var ReadableStreamBYOBRequest: {
+  readonly prototype: ReadableStreamBYOBRequest;
+  new (): never;
+};
+
+/** @category Streams API */
+declare interface ReadableByteStreamControllerCallback {
   (controller: ReadableByteStreamController): void | PromiseLike<void>;
 }
 
 /** @category Streams API */
-interface UnderlyingByteSource {
+declare interface UnderlyingByteSource {
   autoAllocateChunkSize?: number;
   cancel?: ReadableStreamErrorCallback;
   pull?: ReadableByteStreamControllerCallback;
@@ -551,7 +666,7 @@ interface UnderlyingByteSource {
 }
 
 /** @category Streams API */
-interface UnderlyingSink<W = any> {
+declare interface UnderlyingSink<W = any> {
   abort?: WritableStreamErrorCallback;
   close?: WritableStreamDefaultControllerCloseCallback;
   start?: WritableStreamDefaultControllerStartCallback;
@@ -560,7 +675,7 @@ interface UnderlyingSink<W = any> {
 }
 
 /** @category Streams API */
-interface UnderlyingSource<R = any> {
+declare interface UnderlyingSource<R = any> {
   cancel?: ReadableStreamErrorCallback;
   pull?: ReadableStreamDefaultControllerCallback<R>;
   start?: ReadableStreamDefaultControllerCallback<R>;
@@ -568,17 +683,17 @@ interface UnderlyingSource<R = any> {
 }
 
 /** @category Streams API */
-interface ReadableStreamErrorCallback {
+declare interface ReadableStreamErrorCallback {
   (reason: any): void | PromiseLike<void>;
 }
 
 /** @category Streams API */
-interface ReadableStreamDefaultControllerCallback<R> {
+declare interface ReadableStreamDefaultControllerCallback<R> {
   (controller: ReadableStreamDefaultController<R>): void | PromiseLike<void>;
 }
 
 /** @category Streams API */
-interface ReadableStreamDefaultController<R = any> {
+declare interface ReadableStreamDefaultController<R = any> {
   readonly desiredSize: number | null;
   close(): void;
   enqueue(chunk: R): void;
@@ -587,12 +702,12 @@ interface ReadableStreamDefaultController<R = any> {
 
 /** @category Streams API */
 declare var ReadableStreamDefaultController: {
-  prototype: ReadableStreamDefaultController;
-  new (): ReadableStreamDefaultController;
+  readonly prototype: ReadableStreamDefaultController;
+  new (): never;
 };
 
 /** @category Streams API */
-interface ReadableByteStreamController {
+declare interface ReadableByteStreamController {
   readonly byobRequest: ReadableStreamBYOBRequest | null;
   readonly desiredSize: number | null;
   close(): void;
@@ -602,12 +717,12 @@ interface ReadableByteStreamController {
 
 /** @category Streams API */
 declare var ReadableByteStreamController: {
-  prototype: ReadableByteStreamController;
-  new (): ReadableByteStreamController;
+  readonly prototype: ReadableByteStreamController;
+  new (): never;
 };
 
 /** @category Streams API */
-interface PipeOptions {
+declare interface PipeOptions {
   preventAbort?: boolean;
   preventCancel?: boolean;
   preventClose?: boolean;
@@ -615,12 +730,12 @@ interface PipeOptions {
 }
 
 /** @category Streams API */
-interface QueuingStrategySizeCallback<T = any> {
+declare interface QueuingStrategySizeCallback<T = any> {
   (chunk: T): number;
 }
 
 /** @category Streams API */
-interface QueuingStrategy<T = any> {
+declare interface QueuingStrategy<T = any> {
   highWaterMark?: number;
   size?: QueuingStrategySizeCallback<T>;
 }
@@ -630,26 +745,27 @@ interface QueuingStrategy<T = any> {
  *
  * @category Streams API
  */
-interface CountQueuingStrategy extends QueuingStrategy {
+declare interface CountQueuingStrategy extends QueuingStrategy {
   highWaterMark: number;
   size(chunk: any): 1;
 }
 
 /** @category Streams API */
 declare var CountQueuingStrategy: {
-  prototype: CountQueuingStrategy;
+  readonly prototype: CountQueuingStrategy;
   new (options: { highWaterMark: number }): CountQueuingStrategy;
 };
 
 /** @category Streams API */
-interface ByteLengthQueuingStrategy extends QueuingStrategy<ArrayBufferView> {
+declare interface ByteLengthQueuingStrategy
+  extends QueuingStrategy<ArrayBufferView> {
   highWaterMark: number;
   size(chunk: ArrayBufferView): number;
 }
 
 /** @category Streams API */
 declare var ByteLengthQueuingStrategy: {
-  prototype: ByteLengthQueuingStrategy;
+  readonly prototype: ByteLengthQueuingStrategy;
   new (options: { highWaterMark: number }): ByteLengthQueuingStrategy;
 };
 
@@ -659,7 +775,7 @@ declare var ByteLengthQueuingStrategy: {
  *
  * @category Streams API
  */
-interface ReadableStream<R = any> {
+declare interface ReadableStream<R = any> {
   readonly locked: boolean;
   cancel(reason?: any): Promise<void>;
   getReader(options: { mode: "byob" }): ReadableStreamBYOBReader;
@@ -670,6 +786,9 @@ interface ReadableStream<R = any> {
   }, options?: PipeOptions): ReadableStream<T>;
   pipeTo(dest: WritableStream<R>, options?: PipeOptions): Promise<void>;
   tee(): [ReadableStream<R>, ReadableStream<R>];
+  values(options?: {
+    preventCancel?: boolean;
+  }): AsyncIterableIterator<R>;
   [Symbol.asyncIterator](options?: {
     preventCancel?: boolean;
   }): AsyncIterableIterator<R>;
@@ -677,7 +796,7 @@ interface ReadableStream<R = any> {
 
 /** @category Streams API */
 declare var ReadableStream: {
-  prototype: ReadableStream;
+  readonly prototype: ReadableStream;
   new (
     underlyingSource: UnderlyingByteSource,
     strategy?: { highWaterMark?: number; size?: undefined },
@@ -686,20 +805,23 @@ declare var ReadableStream: {
     underlyingSource?: UnderlyingSource<R>,
     strategy?: QueuingStrategy<R>,
   ): ReadableStream<R>;
+  from<R>(
+    asyncIterable: AsyncIterable<R> | Iterable<R | PromiseLike<R>>,
+  ): ReadableStream<R>;
 };
 
 /** @category Streams API */
-interface WritableStreamDefaultControllerCloseCallback {
+declare interface WritableStreamDefaultControllerCloseCallback {
   (): void | PromiseLike<void>;
 }
 
 /** @category Streams API */
-interface WritableStreamDefaultControllerStartCallback {
+declare interface WritableStreamDefaultControllerStartCallback {
   (controller: WritableStreamDefaultController): void | PromiseLike<void>;
 }
 
 /** @category Streams API */
-interface WritableStreamDefaultControllerWriteCallback<W> {
+declare interface WritableStreamDefaultControllerWriteCallback<W> {
   (chunk: W, controller: WritableStreamDefaultController):
     | void
     | PromiseLike<
@@ -708,7 +830,7 @@ interface WritableStreamDefaultControllerWriteCallback<W> {
 }
 
 /** @category Streams API */
-interface WritableStreamErrorCallback {
+declare interface WritableStreamErrorCallback {
   (reason: any): void | PromiseLike<void>;
 }
 
@@ -718,7 +840,7 @@ interface WritableStreamErrorCallback {
  *
  * @category Streams API
  */
-interface WritableStream<W = any> {
+declare interface WritableStream<W = any> {
   readonly locked: boolean;
   abort(reason?: any): Promise<void>;
   close(): Promise<void>;
@@ -727,7 +849,7 @@ interface WritableStream<W = any> {
 
 /** @category Streams API */
 declare var WritableStream: {
-  prototype: WritableStream;
+  readonly prototype: WritableStream;
   new <W = any>(
     underlyingSink?: UnderlyingSink<W>,
     strategy?: QueuingStrategy<W>,
@@ -741,13 +863,16 @@ declare var WritableStream: {
  *
  * @category Streams API
  */
-interface WritableStreamDefaultController {
+declare interface WritableStreamDefaultController {
   signal: AbortSignal;
   error(error?: any): void;
 }
 
 /** @category Streams API */
-declare var WritableStreamDefaultController: WritableStreamDefaultController;
+declare var WritableStreamDefaultController: {
+  readonly prototype: WritableStreamDefaultController;
+  new (): never;
+};
 
 /** This Streams API interface is the object returned by
  * WritableStream.getWriter() and once created locks the < writer to the
@@ -756,7 +881,7 @@ declare var WritableStreamDefaultController: WritableStreamDefaultController;
  *
  * @category Streams API
  */
-interface WritableStreamDefaultWriter<W = any> {
+declare interface WritableStreamDefaultWriter<W = any> {
   readonly closed: Promise<void>;
   readonly desiredSize: number | null;
   readonly ready: Promise<void>;
@@ -768,19 +893,19 @@ interface WritableStreamDefaultWriter<W = any> {
 
 /** @category Streams API */
 declare var WritableStreamDefaultWriter: {
-  prototype: WritableStreamDefaultWriter;
-  new (): WritableStreamDefaultWriter;
+  readonly prototype: WritableStreamDefaultWriter;
+  new <W>(stream: WritableStream<W>): WritableStreamDefaultWriter<W>;
 };
 
 /** @category Streams API */
-interface TransformStream<I = any, O = any> {
+declare interface TransformStream<I = any, O = any> {
   readonly readable: ReadableStream<O>;
   readonly writable: WritableStream<I>;
 }
 
 /** @category Streams API */
 declare var TransformStream: {
-  prototype: TransformStream;
+  readonly prototype: TransformStream;
   new <I = any, O = any>(
     transformer?: Transformer<I, O>,
     writableStrategy?: QueuingStrategy<I>,
@@ -789,7 +914,7 @@ declare var TransformStream: {
 };
 
 /** @category Streams API */
-interface TransformStreamDefaultController<O = any> {
+declare interface TransformStreamDefaultController<O = any> {
   readonly desiredSize: number | null;
   enqueue(chunk: O): void;
   error(reason?: any): void;
@@ -797,10 +922,13 @@ interface TransformStreamDefaultController<O = any> {
 }
 
 /** @category Streams API */
-declare var TransformStreamDefaultController: TransformStreamDefaultController;
+declare var TransformStreamDefaultController: {
+  readonly prototype: TransformStreamDefaultController;
+  new (): never;
+};
 
 /** @category Streams API */
-interface Transformer<I = any, O = any> {
+declare interface Transformer<I = any, O = any> {
   flush?: TransformStreamDefaultControllerCallback<O>;
   readableType?: undefined;
   start?: TransformStreamDefaultControllerCallback<O>;
@@ -809,44 +937,54 @@ interface Transformer<I = any, O = any> {
 }
 
 /** @category Streams API */
-interface TransformStreamDefaultControllerCallback<O> {
+declare interface TransformStreamDefaultControllerCallback<O> {
   (controller: TransformStreamDefaultController<O>): void | PromiseLike<void>;
 }
 
 /** @category Streams API */
-interface TransformStreamDefaultControllerTransformCallback<I, O> {
+declare interface TransformStreamDefaultControllerTransformCallback<I, O> {
   (
     chunk: I,
     controller: TransformStreamDefaultController<O>,
   ): void | PromiseLike<void>;
 }
 
-/** @category Streams API */
-interface MessageEventInit<T = any> extends EventInit {
+/** @category DOM APIs */
+declare interface MessageEventInit<T = any> extends EventInit {
   data?: T;
   origin?: string;
   lastEventId?: string;
 }
 
-/** @category Streams API */
-declare class MessageEvent<T = any> extends Event {
+/** @category DOM APIs */
+declare interface MessageEvent<T = any> extends Event {
   /**
    * Returns the data of the message.
    */
   readonly data: T;
+  /**
+   * Returns the origin of the message, for server-sent events.
+   */
+  readonly origin: string;
   /**
    * Returns the last event ID string, for server-sent events.
    */
   readonly lastEventId: string;
+  readonly source: null;
   /**
    * Returns transferred ports.
    */
   readonly ports: ReadonlyArray<MessagePort>;
-  constructor(type: string, eventInitDict?: MessageEventInit);
 }
 
 /** @category DOM APIs */
-type Transferable = ArrayBuffer | MessagePort;
+declare var MessageEvent: {
+  readonly prototype: MessageEvent;
+  new <T>(type: string, eventInitDict?: MessageEventInit<T>): MessageEvent<T>;
+};
+
+/** @category DOM APIs */
+declare type Transferable = ArrayBuffer | MessagePort;
 
 /**
  * This type has been renamed to StructuredSerializeOptions. Use that type for
@@ -855,10 +993,10 @@ type Transferable = ArrayBuffer | MessagePort;
  * @deprecated use `StructuredSerializeOptions` instead.
  * @category DOM APIs
  */
-type PostMessageOptions = StructuredSerializeOptions;
+declare type PostMessageOptions = StructuredSerializeOptions;
 
 /** @category DOM APIs */
-interface StructuredSerializeOptions {
+declare interface StructuredSerializeOptions {
   transfer?: Transferable[];
 }
 
@@ -868,14 +1006,24 @@ interface StructuredSerializeOptions {
  *
  * @category DOM APIs
  */
-declare class MessageChannel {
-  constructor();
+declare interface MessageChannel {
   readonly port1: MessagePort;
   readonly port2: MessagePort;
 }
 
+/** The MessageChannel interface of the Channel Messaging API allows us to
+ * create a new message channel and send data through it via its two MessagePort
+ * properties.
+ *
+ * @category DOM APIs
+ */
+declare var MessageChannel: {
+  readonly prototype: MessageChannel;
+  new (): MessageChannel;
+};
+
 /** @category DOM APIs */
-interface MessagePortEventMap {
+declare interface MessagePortEventMap {
   "message": MessageEvent;
   "messageerror": MessageEvent;
 }
@@ -886,7 +1034,7 @@ interface MessagePortEventMap {
  *
  * @category DOM APIs
  */
-declare class MessagePort extends EventTarget {
+declare interface MessagePort extends EventTarget {
   onmessage: ((this: MessagePort, ev: MessageEvent) => any) | null;
   onmessageerror: ((this: MessagePort, ev: MessageEvent) => any) | null;
   /**
@@ -930,6 +1078,17 @@ declare class MessagePort extends EventTarget {
   ): void;
 }
 
+/** The MessagePort interface of the Channel Messaging API represents one of the
+ * two ports of a MessageChannel, allowing messages to be sent from one port and
+ * listening out for them arriving at the other.
+ *
+ * @category DOM APIs
+ */
+declare var MessagePort: {
+  readonly prototype: MessagePort;
+  new (): never;
+};
+
 /**
  * Creates a deep copy of a given value using the structured clone algorithm.
  *
@@ -974,7 +1133,25 @@ declare function structuredClone(
  *
  * @category Compression Streams API
  */
-declare class CompressionStream {
+declare interface CompressionStream {
+  readonly readable: ReadableStream<Uint8Array>;
+  readonly writable: WritableStream<Uint8Array>;
+}
+
+/**
+ * An API for compressing a stream of data.
+ *
+ * @example
+ * ```ts
+ * await Deno.stdin.readable
+ *   .pipeThrough(new CompressionStream("gzip"))
+ *   .pipeTo(Deno.stdout.writable);
+ * ```
+ *
+ * @category Compression Streams API
+ */
+declare var CompressionStream: {
+  readonly prototype: CompressionStream;
   /**
    * Creates a new `CompressionStream` object which compresses a stream of
    * data.
@@ -982,8 +1159,25 @@ declare class CompressionStream {
    * Throws a `TypeError` if the format passed to the constructor is not
    * supported.
    */
-  constructor(format: string);
+  new (format: string): CompressionStream;
+};
 
+/**
+ * An API for decompressing a stream of data.
+ *
+ * @example
+ * ```ts
+ * const input = await Deno.open("./file.txt.gz");
+ * const output = await Deno.create("./file.txt");
+ *
+ * await input.readable
+ *   .pipeThrough(new DecompressionStream("gzip"))
+ *   .pipeTo(output.writable);
+ * ```
+ *
+ * @category Compression Streams API
+ */
+declare interface DecompressionStream {
   readonly readable: ReadableStream<Uint8Array>;
   readonly writable: WritableStream<Uint8Array>;
 }
@@ -1003,7 +1197,8 @@ declare class CompressionStream {
  *
  * @category Compression Streams API
  */
-declare class DecompressionStream {
+declare var DecompressionStream: {
+  readonly prototype: DecompressionStream;
   /**
    * Creates a new `DecompressionStream` object which decompresses a stream of
    * data.
@@ -1011,11 +1206,8 @@ declare class DecompressionStream {
    * Throws a `TypeError` if the format passed to the constructor is not
    * supported.
    */
-  constructor(format: string);
-
-  readonly readable: ReadableStream<Uint8Array>;
-  readonly writable: WritableStream<Uint8Array>;
-}
+  new (format: string): DecompressionStream;
+};
 
 /** Dispatch an uncaught exception. Similar to a synchronous version of:
  * ```ts
-- 
cgit v1.2.3