// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. // deno-lint-ignore-file no-explicit-any no-var /// <reference no-default-lib="true" /> /// <reference lib="esnext" /> /** @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 */ declare interface EventInit { bubbles?: boolean; cancelable?: boolean; composed?: boolean; } /** An event which takes place in the DOM. * * @category DOM Events */ 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. */ readonly bubbles: boolean; cancelBubble: boolean; /** Returns true or false depending on how event was initialized. Its return * value does not always carry meaning, but true can indicate that part of the * operation during which event was dispatched, can be canceled by invoking * the preventDefault() method. */ readonly cancelable: boolean; /** Returns true or false depending on how event was initialized. True if * event invokes listeners past a ShadowRoot node that is the root of its * target, and false otherwise. */ readonly composed: boolean; /** Returns the object whose event listener's callback is currently being * invoked. */ readonly currentTarget: EventTarget | null; /** Returns true if preventDefault() was invoked successfully to indicate * cancellation, and false otherwise. */ readonly defaultPrevented: boolean; /** Returns the event's phase, which is one of NONE, CAPTURING_PHASE, * AT_TARGET, and BUBBLING_PHASE. */ readonly eventPhase: number; /** Returns true if event was dispatched by the user agent, and false * otherwise. */ readonly isTrusted: boolean; /** Returns the object to which event is dispatched (its target). */ readonly target: EventTarget | null; /** Returns the event's timestamp as the number of milliseconds measured * relative to the time origin. */ readonly timeStamp: number; /** Returns the type of event, e.g. "click", "hashchange", or "submit". */ readonly type: string; /** Returns the invocation target objects of event's path (objects on which * listeners will be invoked), except for any nodes in shadow trees of which * the shadow root's mode is "closed" that are not reachable from event's * currentTarget. */ composedPath(): EventTarget[]; /** If invoked when the cancelable attribute value is true, and while * executing a listener for the event with passive set to false, signals to * the operation that caused event to be dispatched that it needs to be * canceled. */ preventDefault(): void; /** Invoking this method prevents event from reaching any registered event * listeners after the current one finishes running and, when dispatched in a * tree, also prevents event from reaching any other objects. */ stopImmediatePropagation(): void; /** When dispatched in a tree, invoking this method prevents event from * reaching any objects other than the current object. */ stopPropagation(): void; readonly AT_TARGET: number; readonly BUBBLING_PHASE: number; readonly CAPTURING_PHASE: number; 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 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. * * The options argument sets listener-specific options. For compatibility this * can be a boolean, in which case the method behaves exactly as if the value * was specified as options's capture. * * When set to true, options's capture prevents callback from being invoked * when the event's eventPhase attribute value is BUBBLING_PHASE. When false * (or not present), callback will not be invoked when event's eventPhase * attribute value is CAPTURING_PHASE. Either way, callback will be invoked if * event's eventPhase attribute value is AT_TARGET. * * When set to true, options's passive indicates that the callback will not * cancel the event by invoking preventDefault(). This is used to enable * performance optimizations described in ยง 2.8 Observing event listeners. * * When set to true, options's once indicates that the callback will only be * invoked once after which the event listener will be removed. * * The event listener is appended to target's event listener list and is not * appended if it has the same type, callback, and capture. */ addEventListener( type: string, listener: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions, ): void; /** Dispatches a synthetic event event to target and returns true if either * event's cancelable attribute value is false or its preventDefault() method * was not invoked, and false otherwise. */ dispatchEvent(event: Event): boolean; /** Removes the event listener in target's event listener list with the same * type, callback, and options. */ removeEventListener( type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean, ): 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 */ declare interface EventListener { (evt: Event): void | Promise<void>; } /** @category DOM Events */ declare interface EventListenerObject { handleEvent(evt: Event): void | Promise<void>; } /** @category DOM Events */ declare type EventListenerOrEventListenerObject = | EventListener | EventListenerObject; /** @category DOM Events */ declare interface AddEventListenerOptions extends EventListenerOptions { once?: boolean; passive?: boolean; signal?: AbortSignal; } /** @category DOM Events */ declare interface EventListenerOptions { capture?: boolean; } /** @category DOM Events */ declare interface ProgressEventInit extends EventInit { lengthComputable?: boolean; loaded?: number; 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 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. * * ``` * console.log(atob("aGVsbG8gd29ybGQ=")); // outputs 'hello world' * ``` * * @category Encoding API */ declare function atob(s: string): string; /** Creates a base-64 ASCII encoded string from the input string. * * ``` * console.log(btoa("hello world")); // outputs "aGVsbG8gd29ybGQ=" * ``` * * @category Encoding API */ declare function btoa(s: string): string; /** @category Encoding API */ declare interface TextDecoderOptions { fatal?: boolean; ignoreBOM?: boolean; } /** @category Encoding API */ declare interface TextDecodeOptions { stream?: boolean; } /** @category Encoding API */ declare interface TextDecoder { /** Returns encoding's name, lowercased. */ readonly encoding: string; /** Returns `true` if error mode is "fatal", and `false` otherwise. */ readonly fatal: boolean; /** Returns `true` if ignore BOM flag is set, and `false` otherwise. */ readonly ignoreBOM: boolean; /** Returns the result of running encoding's decoder. */ decode(input?: BufferSource, options?: TextDecodeOptions): string; } /** @category Encoding API */ declare var TextDecoder: { readonly prototype: TextDecoder; new (label?: string, options?: TextDecoderOptions): TextDecoder; }; /** @category Encoding API */ declare interface TextEncoderEncodeIntoResult { read: number; written: number; } /** @category Encoding API */ declare interface TextEncoder { /** Returns "utf-8". */ readonly encoding: "utf-8"; /** Returns the result of running UTF-8's encoder. */ encode(input?: string): Uint8Array; encodeInto(input: string, dest: Uint8Array): TextEncoderEncodeIntoResult; } /** @category Encoding API */ declare var TextEncoder: { readonly prototype: TextEncoder; new (): TextEncoder; }; /** @category Encoding API */ declare interface TextDecoderStream { /** Returns encoding's name, lowercased. */ readonly encoding: string; /** Returns `true` if error mode is "fatal", and `false` otherwise. */ readonly fatal: boolean; /** Returns `true` if ignore BOM flag is set, and `false` otherwise. */ readonly ignoreBOM: boolean; readonly readable: ReadableStream<string>; readonly writable: WritableStream<BufferSource>; readonly [Symbol.toStringTag]: string; } /** @category Encoding API */ declare var TextDecoderStream: { readonly prototype: TextDecoderStream; new (label?: string, options?: TextDecoderOptions): TextDecoderStream; }; /** @category Encoding API */ declare interface TextEncoderStream { /** Returns "utf-8". */ readonly encoding: "utf-8"; readonly readable: ReadableStream<Uint8Array>; readonly writable: WritableStream<string>; readonly [Symbol.toStringTag]: string; } /** @category Encoding API */ declare var TextEncoderStream: { readonly prototype: TextEncoderStream; new (): TextEncoderStream; }; /** A controller object that allows you to abort one or more DOM requests as and * when desired. * * @category Web APIs */ 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 * signal to any observers that the associated activity is to be aborted. */ 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 */ declare interface AbortSignalEventMap { abort: Event; } /** A signal object that allows you to communicate with a DOM request (such as a * Fetch) and abort it if required via an AbortController object. * * @category Web APIs */ declare interface AbortSignal extends EventTarget { /** Returns true if this AbortSignal's AbortController has signaled to abort, * and false otherwise. */ readonly aborted: boolean; readonly reason: any; onabort: ((this: AbortSignal, ev: Event) => any) | null; addEventListener<K extends keyof AbortSignalEventMap>( type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | AddEventListenerOptions, ): void; addEventListener( type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions, ): void; removeEventListener<K extends keyof AbortSignalEventMap>( type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | EventListenerOptions, ): void; removeEventListener( type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions, ): void; /** Throws this AbortSignal's abort reason, if its AbortController has * signaled to abort; otherwise, does nothing. */ throwIfAborted(): void; } /** @category Web APIs */ declare var AbortSignal: { readonly prototype: AbortSignal; new (): never; abort(reason?: any): AbortSignal; timeout(milliseconds: number): AbortSignal; }; /** @category Web File API */ declare interface FileReaderEventMap { "abort": ProgressEvent<FileReader>; "error": ProgressEvent<FileReader>; "load": ProgressEvent<FileReader>; "loadend": ProgressEvent<FileReader>; "loadstart": ProgressEvent<FileReader>; "progress": ProgressEvent<FileReader>; } /** Lets web applications asynchronously read the contents of files (or raw data * buffers) stored on the user's computer, using File or Blob objects to specify * the file or data to read. * * @category Web File API */ 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; onload: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null; onloadend: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null; onloadstart: | ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null; onprogress: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null; readonly readyState: number; readonly result: string | ArrayBuffer | null; abort(): void; readAsArrayBuffer(blob: Blob): void; readAsBinaryString(blob: Blob): void; readAsDataURL(blob: Blob): void; readAsText(blob: Blob, encoding?: string): void; readonly DONE: number; readonly EMPTY: number; readonly LOADING: number; addEventListener<K extends keyof FileReaderEventMap>( type: K, listener: (this: FileReader, ev: FileReaderEventMap[K]) => any, options?: boolean | AddEventListenerOptions, ): void; addEventListener( type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions, ): void; removeEventListener<K extends keyof FileReaderEventMap>( type: K, listener: (this: FileReader, ev: FileReaderEventMap[K]) => any, options?: boolean | EventListenerOptions, ): void; removeEventListener( type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions, ): void; } /** @category Web File API */ declare var FileReader: { readonly prototype: FileReader; new (): FileReader; readonly DONE: number; readonly EMPTY: number; readonly LOADING: number; }; /** @category Web File API */ declare type BlobPart = BufferSource | Blob | string; /** @category Web File API */ declare interface BlobPropertyBag { type?: string; endings?: "transparent" | "native"; } /** 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 interface Blob { readonly size: number; readonly type: string; arrayBuffer(): Promise<ArrayBuffer>; slice(start?: number, end?: number, contentType?: string): Blob; stream(): ReadableStream<Uint8Array>; 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 */ declare interface FilePropertyBag extends BlobPropertyBag { lastModified?: number; } /** Provides information about files and allows JavaScript in a web page to * access their content. * * @category Web File API */ 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 */ declare interface ReadableStreamDefaultReadDoneResult { done: true; value?: undefined; } /** @category Streams API */ declare interface ReadableStreamDefaultReadValueResult<T> { done: false; value: T; } /** @category Streams API */ declare type ReadableStreamDefaultReadResult<T> = | ReadableStreamDefaultReadValueResult<T> | ReadableStreamDefaultReadDoneResult; /** @category Streams API */ declare interface ReadableStreamDefaultReader<R = any> { readonly closed: Promise<void>; cancel(reason?: any): Promise<void>; read(): Promise<ReadableStreamDefaultReadResult<R>>; releaseLock(): void; } /** @category Streams API */ declare var ReadableStreamDefaultReader: { readonly prototype: ReadableStreamDefaultReader; new <R>(stream: ReadableStream<R>): ReadableStreamDefaultReader<R>; }; /** @category Streams API */ declare interface ReadableStreamBYOBReadDoneResult<V extends ArrayBufferView> { done: true; value?: V; } /** @category Streams API */ declare interface ReadableStreamBYOBReadValueResult<V extends ArrayBufferView> { done: false; value: V; } /** @category Streams API */ declare type ReadableStreamBYOBReadResult<V extends ArrayBufferView> = | ReadableStreamBYOBReadDoneResult<V> | ReadableStreamBYOBReadValueResult<V>; /** @category Streams API */ declare interface ReadableStreamBYOBReader { readonly closed: Promise<void>; cancel(reason?: any): Promise<void>; read<V extends ArrayBufferView>( view: V, ): Promise<ReadableStreamBYOBReadResult<V>>; releaseLock(): void; } /** @category Streams API */ declare var ReadableStreamBYOBReader: { readonly prototype: ReadableStreamBYOBReader; new (stream: ReadableStream<Uint8Array>): ReadableStreamBYOBReader; }; /** @category Streams API */ declare interface ReadableStreamBYOBRequest { readonly view: ArrayBufferView | null; respond(bytesWritten: number): void; respondWithNewView(view: ArrayBufferView): void; } /** @category Streams API */ declare var ReadableStreamBYOBRequest: { readonly prototype: ReadableStreamBYOBRequest; new (): never; }; /** @category Streams API */ declare interface ReadableByteStreamControllerCallback { (controller: ReadableByteStreamController): void | PromiseLike<void>; } /** @category Streams API */ declare interface UnderlyingByteSource { autoAllocateChunkSize?: number; cancel?: ReadableStreamErrorCallback; pull?: ReadableByteStreamControllerCallback; start?: ReadableByteStreamControllerCallback; type: "bytes"; } /** @category Streams API */ declare interface UnderlyingSink<W = any> { abort?: WritableStreamErrorCallback; close?: WritableStreamDefaultControllerCloseCallback; start?: WritableStreamDefaultControllerStartCallback; type?: undefined; write?: WritableStreamDefaultControllerWriteCallback<W>; } /** @category Streams API */ declare interface UnderlyingSource<R = any> { cancel?: ReadableStreamErrorCallback; pull?: ReadableStreamDefaultControllerCallback<R>; start?: ReadableStreamDefaultControllerCallback<R>; type?: undefined; } /** @category Streams API */ declare interface ReadableStreamErrorCallback { (reason: any): void | PromiseLike<void>; } /** @category Streams API */ declare interface ReadableStreamDefaultControllerCallback<R> { (controller: ReadableStreamDefaultController<R>): void | PromiseLike<void>; } /** @category Streams API */ declare interface ReadableStreamDefaultController<R = any> { readonly desiredSize: number | null; close(): void; enqueue(chunk: R): void; error(error?: any): void; } /** @category Streams API */ declare var ReadableStreamDefaultController: { readonly prototype: ReadableStreamDefaultController; new (): never; }; /** @category Streams API */ declare interface ReadableByteStreamController { readonly byobRequest: ReadableStreamBYOBRequest | null; readonly desiredSize: number | null; close(): void; enqueue(chunk: ArrayBufferView): void; error(error?: any): void; } /** @category Streams API */ declare var ReadableByteStreamController: { readonly prototype: ReadableByteStreamController; new (): never; }; /** @category Streams API */ declare interface PipeOptions { preventAbort?: boolean; preventCancel?: boolean; preventClose?: boolean; signal?: AbortSignal; } /** @category Streams API */ declare interface QueuingStrategySizeCallback<T = any> { (chunk: T): number; } /** @category Streams API */ declare interface QueuingStrategy<T = any> { highWaterMark?: number; size?: QueuingStrategySizeCallback<T>; } /** This Streams API interface provides a built-in byte length queuing strategy * that can be used when constructing streams. * * @category Streams API */ declare interface CountQueuingStrategy extends QueuingStrategy { highWaterMark: number; size(chunk: any): 1; } /** @category Streams API */ declare var CountQueuingStrategy: { readonly prototype: CountQueuingStrategy; new (options: { highWaterMark: number }): CountQueuingStrategy; }; /** @category Streams API */ declare interface ByteLengthQueuingStrategy extends QueuingStrategy<ArrayBufferView> { highWaterMark: number; size(chunk: ArrayBufferView): number; } /** @category Streams API */ declare var ByteLengthQueuingStrategy: { readonly prototype: ByteLengthQueuingStrategy; new (options: { highWaterMark: number }): ByteLengthQueuingStrategy; }; /** This Streams API interface represents a readable stream of byte data. The * Fetch API offers a concrete instance of a ReadableStream through the body * property of a Response object. * * @category Streams API */ declare interface ReadableStream<R = any> { readonly locked: boolean; cancel(reason?: any): Promise<void>; getReader(options: { mode: "byob" }): ReadableStreamBYOBReader; getReader(options?: { mode?: undefined }): ReadableStreamDefaultReader<R>; pipeThrough<T>(transform: { writable: WritableStream<R>; readable: ReadableStream<T>; }, 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>; } /** @category Streams API */ declare var ReadableStream: { readonly prototype: ReadableStream; new ( underlyingSource: UnderlyingByteSource, strategy?: { highWaterMark?: number; size?: undefined }, ): ReadableStream<Uint8Array>; new <R = any>( underlyingSource?: UnderlyingSource<R>, strategy?: QueuingStrategy<R>, ): ReadableStream<R>; from<R>( asyncIterable: AsyncIterable<R> | Iterable<R | PromiseLike<R>>, ): ReadableStream<R>; }; /** @category Streams API */ declare interface WritableStreamDefaultControllerCloseCallback { (): void | PromiseLike<void>; } /** @category Streams API */ declare interface WritableStreamDefaultControllerStartCallback { (controller: WritableStreamDefaultController): void | PromiseLike<void>; } /** @category Streams API */ declare interface WritableStreamDefaultControllerWriteCallback<W> { (chunk: W, controller: WritableStreamDefaultController): | void | PromiseLike< void >; } /** @category Streams API */ declare interface WritableStreamErrorCallback { (reason: any): void | PromiseLike<void>; } /** This Streams API interface provides a standard abstraction for writing * streaming data to a destination, known as a sink. This object comes with * built-in backpressure and queuing. * * @category Streams API */ declare interface WritableStream<W = any> { readonly locked: boolean; abort(reason?: any): Promise<void>; close(): Promise<void>; getWriter(): WritableStreamDefaultWriter<W>; } /** @category Streams API */ declare var WritableStream: { readonly prototype: WritableStream; new <W = any>( underlyingSink?: UnderlyingSink<W>, strategy?: QueuingStrategy<W>, ): WritableStream<W>; }; /** This Streams API interface represents a controller allowing control of a * WritableStream's state. When constructing a WritableStream, the underlying * sink is given a corresponding WritableStreamDefaultController instance to * manipulate. * * @category Streams API */ declare interface WritableStreamDefaultController { signal: AbortSignal; error(error?: any): void; } /** @category Streams API */ 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 * WritableStream ensuring that no other streams can write to the underlying * sink. * * @category Streams API */ declare interface WritableStreamDefaultWriter<W = any> { readonly closed: Promise<void>; readonly desiredSize: number | null; readonly ready: Promise<void>; abort(reason?: any): Promise<void>; close(): Promise<void>; releaseLock(): void; write(chunk: W): Promise<void>; } /** @category Streams API */ declare var WritableStreamDefaultWriter: { readonly prototype: WritableStreamDefaultWriter; new <W>(stream: WritableStream<W>): WritableStreamDefaultWriter<W>; }; /** @category Streams API */ declare interface TransformStream<I = any, O = any> { readonly readable: ReadableStream<O>; readonly writable: WritableStream<I>; } /** @category Streams API */ declare var TransformStream: { readonly prototype: TransformStream; new <I = any, O = any>( transformer?: Transformer<I, O>, writableStrategy?: QueuingStrategy<I>, readableStrategy?: QueuingStrategy<O>, ): TransformStream<I, O>; }; /** @category Streams API */ declare interface TransformStreamDefaultController<O = any> { readonly desiredSize: number | null; enqueue(chunk: O): void; error(reason?: any): void; terminate(): void; } /** @category Streams API */ declare var TransformStreamDefaultController: { readonly prototype: TransformStreamDefaultController; new (): never; }; /** @category Streams API */ declare interface Transformer<I = any, O = any> { flush?: TransformStreamDefaultControllerCallback<O>; readableType?: undefined; start?: TransformStreamDefaultControllerCallback<O>; transform?: TransformStreamDefaultControllerTransformCallback<I, O>; writableType?: undefined; } /** @category Streams API */ declare interface TransformStreamDefaultControllerCallback<O> { (controller: TransformStreamDefaultController<O>): void | PromiseLike<void>; } /** @category Streams API */ declare interface TransformStreamDefaultControllerTransformCallback<I, O> { ( chunk: I, controller: TransformStreamDefaultController<O>, ): void | PromiseLike<void>; } /** @category DOM APIs */ declare interface MessageEventInit<T = any> extends EventInit { data?: T; origin?: string; lastEventId?: string; } /** @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>; } /** @category DOM APIs */ 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 * new code. * * @deprecated use `StructuredSerializeOptions` instead. * @category DOM APIs */ declare type PostMessageOptions = StructuredSerializeOptions; /** @category DOM APIs */ declare interface StructuredSerializeOptions { transfer?: Transferable[]; } /** 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 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 */ declare interface MessagePortEventMap { "message": MessageEvent; "messageerror": MessageEvent; } /** 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 interface MessagePort extends EventTarget { onmessage: ((this: MessagePort, ev: MessageEvent) => any) | null; onmessageerror: ((this: MessagePort, ev: MessageEvent) => any) | null; /** * Disconnects the port, so that it is no longer active. */ close(): void; /** * Posts a message through the channel. Objects listed in transfer are * transferred, not just cloned, meaning that they are no longer usable on the * sending side. * * Throws a "DataCloneError" DOMException if transfer contains duplicate * objects or port, or if message could not be cloned. */ postMessage(message: any, transfer: Transferable[]): void; postMessage(message: any, options?: StructuredSerializeOptions): void; /** * Begins dispatching messages received on the port. This is implicitly called * when assigning a value to `this.onmessage`. */ start(): void; addEventListener<K extends keyof MessagePortEventMap>( type: K, listener: (this: MessagePort, ev: MessagePortEventMap[K]) => any, options?: boolean | AddEventListenerOptions, ): void; addEventListener( type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions, ): void; removeEventListener<K extends keyof MessagePortEventMap>( type: K, listener: (this: MessagePort, ev: MessagePortEventMap[K]) => any, options?: boolean | EventListenerOptions, ): void; removeEventListener( type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions, ): 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. * * Unlike a shallow copy, a deep copy does not hold the same references as the * source object, meaning its properties can be changed without affecting the * source. For more details, see * [MDN](https://developer.mozilla.org/en-US/docs/Glossary/Deep_copy). * * Throws a `DataCloneError` if any part of the input value is not * serializable. * * @example * ```ts * const object = { x: 0, y: 1 }; * * const deepCopy = structuredClone(object); * deepCopy.x = 1; * console.log(deepCopy.x, object.x); // 1 0 * * const shallowCopy = object; * shallowCopy.x = 1; * // shallowCopy.x is pointing to the same location in memory as object.x * console.log(shallowCopy.x, object.x); // 1 1 * ``` * * @category DOM APIs */ declare function structuredClone( value: any, options?: StructuredSerializeOptions, ): any; /** * 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 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. * * Throws a `TypeError` if the format passed to the constructor is not * supported. */ 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>; } /** * 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 var DecompressionStream: { readonly prototype: DecompressionStream; /** * Creates a new `DecompressionStream` object which decompresses a stream of * data. * * Throws a `TypeError` if the format passed to the constructor is not * supported. */ new (format: string): DecompressionStream; }; /** Dispatch an uncaught exception. Similar to a synchronous version of: * ```ts * setTimeout(() => { throw error; }, 0); * ``` * The error can not be caught with a `try/catch` block. An error event will * be dispatched to the global scope. You can prevent the error from being * reported to the console with `Event.prototype.preventDefault()`: * ```ts * addEventListener("error", (event) => { * event.preventDefault(); * }); * reportError(new Error("foo")); // Will not be reported. * ``` * In Deno, this error will terminate the process if not intercepted like above. * * @category Web APIs */ declare function reportError( error: any, ): void;