deno.land / x / deno@v1.28.2 / ext / web / lib.deno_web.d.ts
نووسراو ببینە
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047// Copyright 2018-2022 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 DOM Events */declare class DOMException extends Error { constructor(message?: string, name?: string); readonly name: string; readonly message: string; readonly code: number;}
/** @category DOM Events */interface EventInit { bubbles?: boolean; cancelable?: boolean; composed?: boolean;}
/** An event which takes place in the DOM. * * @category DOM Events */declare class Event { constructor(type: string, eventInitDict?: EventInit); /** 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; static readonly AT_TARGET: number; static readonly BUBBLING_PHASE: number; static readonly CAPTURING_PHASE: number; static 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 { /** 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;}
/** @category DOM Events */interface EventListener { (evt: Event): void | Promise<void>;}
/** @category DOM Events */interface EventListenerObject { handleEvent(evt: Event): void | Promise<void>;}
/** @category DOM Events */declare type EventListenerOrEventListenerObject = | EventListener | EventListenerObject;
/** @category DOM Events */interface AddEventListenerOptions extends EventListenerOptions { once?: boolean; passive?: boolean; signal?: AbortSignal;}
/** @category DOM Events */interface EventListenerOptions { capture?: boolean;}
/** @category DOM Events */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 class ProgressEvent<T extends EventTarget = EventTarget> extends Event { constructor(type: string, eventInitDict?: ProgressEventInit); readonly lengthComputable: boolean; readonly loaded: number; readonly target: T | null; readonly total: number;}
/** 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 */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: { prototype: TextDecoder; new (label?: string, options?: TextDecoderOptions): TextDecoder;};
/** @category Encoding API */declare interface TextEncoderEncodeIntoResult { read: number; written: number;}
/** @category Encoding API */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: { prototype: TextEncoder; new (): TextEncoder;};
/** @category Encoding API */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: { prototype: TextDecoderStream; new (label?: string, options?: TextDecoderOptions): TextDecoderStream;};
/** @category Encoding API */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: { 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 class 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;}
/** @category Web APIs */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 */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: { prototype: AbortSignal; new (): AbortSignal; abort(reason?: any): AbortSignal; timeout(milliseconds: number): AbortSignal;};
/** @category Web File API */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 */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: { prototype: FileReader; new (): FileReader; readonly DONE: number; readonly EMPTY: number; readonly LOADING: number;};
/** @category Web File API */type BlobPart = BufferSource | Blob | string;
/** @category Web File API */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 class Blob { constructor(blobParts?: BlobPart[], options?: BlobPropertyBag);
readonly size: number; readonly type: string; arrayBuffer(): Promise<ArrayBuffer>; slice(start?: number, end?: number, contentType?: string): Blob; stream(): ReadableStream<Uint8Array>; text(): Promise<string>;}
/** @category Web File API */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 class File extends Blob { constructor( fileBits: BlobPart[], fileName: string, options?: FilePropertyBag, );
readonly lastModified: number; readonly name: string;}
/** @category Streams API */interface ReadableStreamReadDoneResult<T> { done: true; value?: T;}
/** @category Streams API */interface ReadableStreamReadValueResult<T> { done: false; value: T;}
/** @category Streams API */type ReadableStreamReadResult<T> = | ReadableStreamReadValueResult<T> | ReadableStreamReadDoneResult<T>;
/** @category Streams API */interface ReadableStreamDefaultReader<R = any> { readonly closed: Promise<void>; cancel(reason?: any): Promise<void>; read(): Promise<ReadableStreamReadResult<R>>; releaseLock(): void;}
/** @category Streams API */interface ReadableStreamBYOBReadDoneResult<V extends ArrayBufferView> { done: true; value?: V;}
/** @category Streams API */interface ReadableStreamBYOBReadValueResult<V extends ArrayBufferView> { done: false; value: V;}
/** @category Streams API */type ReadableStreamBYOBReadResult<V extends ArrayBufferView> = | ReadableStreamBYOBReadDoneResult<V> | ReadableStreamBYOBReadValueResult<V>;
/** @category Streams API */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 */interface ReadableStreamBYOBRequest { readonly view: ArrayBufferView | null; respond(bytesWritten: number): void; respondWithNewView(view: ArrayBufferView): void;}
/** @category Streams API */declare var ReadableStreamDefaultReader: { prototype: ReadableStreamDefaultReader; new <R>(stream: ReadableStream<R>): ReadableStreamDefaultReader<R>;};
/** @category Streams API */interface ReadableStreamReader<R = any> { cancel(): Promise<void>; read(): Promise<ReadableStreamReadResult<R>>; releaseLock(): void;}
/** @category Streams API */declare var ReadableStreamReader: { prototype: ReadableStreamReader; new (): ReadableStreamReader;};
/** @category Streams API */interface ReadableByteStreamControllerCallback { (controller: ReadableByteStreamController): void | PromiseLike<void>;}
/** @category Streams API */interface UnderlyingByteSource { autoAllocateChunkSize?: number; cancel?: ReadableStreamErrorCallback; pull?: ReadableByteStreamControllerCallback; start?: ReadableByteStreamControllerCallback; type: "bytes";}
/** @category Streams API */interface UnderlyingSink<W = any> { abort?: WritableStreamErrorCallback; close?: WritableStreamDefaultControllerCloseCallback; start?: WritableStreamDefaultControllerStartCallback; type?: undefined; write?: WritableStreamDefaultControllerWriteCallback<W>;}
/** @category Streams API */interface UnderlyingSource<R = any> { cancel?: ReadableStreamErrorCallback; pull?: ReadableStreamDefaultControllerCallback<R>; start?: ReadableStreamDefaultControllerCallback<R>; type?: undefined;}
/** @category Streams API */interface ReadableStreamErrorCallback { (reason: any): void | PromiseLike<void>;}
/** @category Streams API */interface ReadableStreamDefaultControllerCallback<R> { (controller: ReadableStreamDefaultController<R>): void | PromiseLike<void>;}
/** @category Streams API */interface ReadableStreamDefaultController<R = any> { readonly desiredSize: number | null; close(): void; enqueue(chunk: R): void; error(error?: any): void;}
/** @category Streams API */declare var ReadableStreamDefaultController: { prototype: ReadableStreamDefaultController; new (): ReadableStreamDefaultController;};
/** @category Streams API */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: { prototype: ReadableByteStreamController; new (): ReadableByteStreamController;};
/** @category Streams API */interface PipeOptions { preventAbort?: boolean; preventCancel?: boolean; preventClose?: boolean; signal?: AbortSignal;}
/** @category Streams API */interface QueuingStrategySizeCallback<T = any> { (chunk: T): number;}
/** @category Streams API */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 */interface CountQueuingStrategy extends QueuingStrategy { highWaterMark: number; size(chunk: any): 1;}
/** @category Streams API */declare var CountQueuingStrategy: { prototype: CountQueuingStrategy; new (options: { highWaterMark: number }): CountQueuingStrategy;};
/** @category Streams API */interface ByteLengthQueuingStrategy extends QueuingStrategy<ArrayBufferView> { highWaterMark: number; size(chunk: ArrayBufferView): number;}
/** @category Streams API */declare var ByteLengthQueuingStrategy: { 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 */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>]; [Symbol.asyncIterator](options?: { preventCancel?: boolean; }): AsyncIterableIterator<R>;}
/** @category Streams API */declare var ReadableStream: { prototype: ReadableStream; new ( underlyingSource: UnderlyingByteSource, strategy?: { highWaterMark?: number; size?: undefined }, ): ReadableStream<Uint8Array>; new <R = any>( underlyingSource?: UnderlyingSource<R>, strategy?: QueuingStrategy<R>, ): ReadableStream<R>;};
/** @category Streams API */interface WritableStreamDefaultControllerCloseCallback { (): void | PromiseLike<void>;}
/** @category Streams API */interface WritableStreamDefaultControllerStartCallback { (controller: WritableStreamDefaultController): void | PromiseLike<void>;}
/** @category Streams API */interface WritableStreamDefaultControllerWriteCallback<W> { (chunk: W, controller: WritableStreamDefaultController): | void | PromiseLike< void >;}
/** @category Streams API */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 */interface WritableStream<W = any> { readonly locked: boolean; abort(reason?: any): Promise<void>; close(): Promise<void>; getWriter(): WritableStreamDefaultWriter<W>;}
/** @category Streams API */declare var WritableStream: { 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 */interface WritableStreamDefaultController { signal: AbortSignal; error(error?: any): void;}
/** @category Streams API */declare var WritableStreamDefaultController: WritableStreamDefaultController;
/** 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 */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: { prototype: WritableStreamDefaultWriter; new (): WritableStreamDefaultWriter;};
/** @category Streams API */interface TransformStream<I = any, O = any> { readonly readable: ReadableStream<O>; readonly writable: WritableStream<I>;}
/** @category Streams API */declare var TransformStream: { prototype: TransformStream; new <I = any, O = any>( transformer?: Transformer<I, O>, writableStrategy?: QueuingStrategy<I>, readableStrategy?: QueuingStrategy<O>, ): TransformStream<I, O>;};
/** @category Streams API */interface TransformStreamDefaultController<O = any> { readonly desiredSize: number | null; enqueue(chunk: O): void; error(reason?: any): void; terminate(): void;}
/** @category Streams API */declare var TransformStreamDefaultController: TransformStreamDefaultController;
/** @category Streams API */interface Transformer<I = any, O = any> { flush?: TransformStreamDefaultControllerCallback<O>; readableType?: undefined; start?: TransformStreamDefaultControllerCallback<O>; transform?: TransformStreamDefaultControllerTransformCallback<I, O>; writableType?: undefined;}
/** @category Streams API */interface TransformStreamDefaultControllerCallback<O> { (controller: TransformStreamDefaultController<O>): void | PromiseLike<void>;}
/** @category Streams API */interface TransformStreamDefaultControllerTransformCallback<I, O> { ( chunk: I, controller: TransformStreamDefaultController<O>, ): void | PromiseLike<void>;}
/** @category Streams API */interface MessageEventInit<T = any> extends EventInit { data?: T; origin?: string; lastEventId?: string;}
/** @category Streams API */declare class MessageEvent<T = any> extends Event { /** * Returns the data of the message. */ readonly data: T; /** * Returns the last event ID string, for server-sent events. */ readonly lastEventId: string; /** * Returns transferred ports. */ readonly ports: ReadonlyArray<MessagePort>; constructor(type: string, eventInitDict?: MessageEventInit);}
/** @category DOM APIs */type Transferable = ArrayBuffer | MessagePort;
/** * This type has been renamed to StructuredSerializeOptions. Use that type for * new code. * * @deprecated use `StructuredSerializeOptions` instead. * @category DOM APIs */type PostMessageOptions = StructuredSerializeOptions;
/** @category DOM APIs */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 class MessageChannel { constructor(); readonly port1: MessagePort; readonly port2: MessagePort;}
/** @category DOM APIs */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 class 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;}
/** * 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 class 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. */ constructor(format: string);
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 class 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. */ constructor(format: string);
readonly readable: ReadableStream<Uint8Array>; readonly writable: WritableStream<Uint8Array>;}
/** 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;
deno
Version Info
a year ago
