Skip to content

Instantly share code, notes, and snippets.

@penalosa

penalosa/diff.md

Last active October 27, 2022 17:16
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save penalosa/23efb9df31dabbc18ca0aac07c43bcc2 to your computer and use it in GitHub Desktop.
Save penalosa/23efb9df31dabbc18ca0aac07c43bcc2 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
diff.md

Workers/Standards diff

class DOMException

Standards:

DOMException: {
    prototype: DOMException;
    new (message?: string, name?: string): DOMException;
    readonly ABORT_ERR: number;
    readonly DATA_CLONE_ERR: number;
    readonly DOMSTRING_SIZE_ERR: number;
    readonly HIERARCHY_REQUEST_ERR: number;
    readonly INDEX_SIZE_ERR: number;
    readonly INUSE_ATTRIBUTE_ERR: number;
    readonly INVALID_ACCESS_ERR: number;
    readonly INVALID_CHARACTER_ERR: number;
    readonly INVALID_MODIFICATION_ERR: number;
    readonly INVALID_NODE_TYPE_ERR: number;
    readonly INVALID_STATE_ERR: number;
    readonly NAMESPACE_ERR: number;
    readonly NETWORK_ERR: number;
    readonly NOT_FOUND_ERR: number;
    readonly NOT_SUPPORTED_ERR: number;
    readonly NO_DATA_ALLOWED_ERR: number;
    readonly NO_MODIFICATION_ALLOWED_ERR: number;
    readonly QUOTA_EXCEEDED_ERR: number;
    readonly SECURITY_ERR: number;
    readonly SYNTAX_ERR: number;
    readonly TIMEOUT_ERR: number;
    readonly TYPE_MISMATCH_ERR: number;
    readonly URL_MISMATCH_ERR: number;
    readonly VALIDATION_ERR: number;
    readonly WRONG_DOCUMENT_ERR: number;
}

Workers:

/* eslint-disable */
// noinspection JSUnusedGlobalSymbols
export declare class DOMException extends Error {
    constructor(param0?: string, param1?: string);
    readonly message: string;
    readonly name: string;
    readonly code: number;
    readonly stack: any;
    static readonly INDEX_SIZE_ERR: 1;
    static readonly DOMSTRING_SIZE_ERR: 2;
    static readonly HIERARCHY_REQUEST_ERR: 3;
    static readonly WRONG_DOCUMENT_ERR: 4;
    static readonly INVALID_CHARACTER_ERR: 5;
    static readonly NO_DATA_ALLOWED_ERR: 6;
    static readonly NO_MODIFICATION_ALLOWED_ERR: 7;
    static readonly NOT_FOUND_ERR: 8;
    static readonly NOT_SUPPORTED_ERR: 9;
    static readonly INUSE_ATTRIBUTE_ERR: 10;
    static readonly INVALID_STATE_ERR: 11;
    static readonly SYNTAX_ERR: 12;
    static readonly INVALID_MODIFICATION_ERR: 13;
    static readonly NAMESPACE_ERR: 14;
    static readonly INVALID_ACCESS_ERR: 15;
    static readonly VALIDATION_ERR: 16;
    static readonly TYPE_MISMATCH_ERR: 17;
    static readonly SECURITY_ERR: 18;
    static readonly NETWORK_ERR: 19;
    static readonly ABORT_ERR: 20;
    static readonly URL_MISMATCH_ERR: 21;
    static readonly QUOTA_EXCEEDED_ERR: 22;
    static readonly TIMEOUT_ERR: 23;
    static readonly INVALID_NODE_TYPE_ERR: 24;
    static readonly DATA_CLONE_ERR: 25;
}
TypeScript Details 

Type 'typeof DOMException' is not assignable to type '{ new (message?: string, name?: string): DOMException; prototype: DOMException; readonly ABORT_ERR: number; readonly DATA_CLONE_ERR: number; readonly DOMSTRING_SIZE_ERR: number; ... 21 more ...; readonly WRONG_DOCUMENT_ERR: number; }'.
  Types of property 'prototype' are incompatible.
    Type 'DOMException' is missing the following properties from type 'DOMException': ABORT_ERR, DATA_CLONE_ERR, DOMSTRING_SIZE_ERR, HIERARCHY_REQUEST_ERR, and 21 more.

DOMException.prototype.INDEX_SIZE_ERR

Standards:

readonly INDEX_SIZE_ERR: number;

Workers:

static readonly INDEX_SIZE_ERR: 1;
TypeScript Details 

Type 'number' is not assignable to type '1'.

DOMException.prototype.DOMSTRING_SIZE_ERR

Standards:

readonly DOMSTRING_SIZE_ERR: number;

Workers:

static readonly DOMSTRING_SIZE_ERR: 2;
TypeScript Details 

Type 'number' is not assignable to type '2'.

DOMException.prototype.HIERARCHY_REQUEST_ERR

Standards:

readonly HIERARCHY_REQUEST_ERR: number;

Workers:

static readonly HIERARCHY_REQUEST_ERR: 3;
TypeScript Details 

Type 'number' is not assignable to type '3'.

DOMException.prototype.WRONG_DOCUMENT_ERR

Standards:

readonly WRONG_DOCUMENT_ERR: number;

Workers:

static readonly WRONG_DOCUMENT_ERR: 4;
TypeScript Details 

Type 'number' is not assignable to type '4'.

DOMException.prototype.INVALID_CHARACTER_ERR

Standards:

readonly INVALID_CHARACTER_ERR: number;

Workers:

static readonly INVALID_CHARACTER_ERR: 5;
TypeScript Details 

Type 'number' is not assignable to type '5'.

DOMException.prototype.NO_DATA_ALLOWED_ERR

Standards:

readonly NO_DATA_ALLOWED_ERR: number;

Workers:

static readonly NO_DATA_ALLOWED_ERR: 6;
TypeScript Details 

Type 'number' is not assignable to type '6'.

DOMException.prototype.NO_MODIFICATION_ALLOWED_ERR

Standards:

readonly NO_MODIFICATION_ALLOWED_ERR: number;

Workers:

static readonly NO_MODIFICATION_ALLOWED_ERR: 7;
TypeScript Details 

Type 'number' is not assignable to type '7'.

DOMException.prototype.NOT_FOUND_ERR

Standards:

readonly NOT_FOUND_ERR: number;

Workers:

static readonly NOT_FOUND_ERR: 8;
TypeScript Details 

Type 'number' is not assignable to type '8'.

DOMException.prototype.NOT_SUPPORTED_ERR

Standards:

readonly NOT_SUPPORTED_ERR: number;

Workers:

static readonly NOT_SUPPORTED_ERR: 9;
TypeScript Details 

Type 'number' is not assignable to type '9'.

DOMException.prototype.INUSE_ATTRIBUTE_ERR

Standards:

readonly INUSE_ATTRIBUTE_ERR: number;

Workers:

static readonly INUSE_ATTRIBUTE_ERR: 10;
TypeScript Details 

Type 'number' is not assignable to type '10'.

DOMException.prototype.INVALID_STATE_ERR

Standards:

readonly INVALID_STATE_ERR: number;

Workers:

static readonly INVALID_STATE_ERR: 11;
TypeScript Details 

Type 'number' is not assignable to type '11'.

DOMException.prototype.SYNTAX_ERR

Standards:

readonly SYNTAX_ERR: number;

Workers:

static readonly SYNTAX_ERR: 12;
TypeScript Details 

Type 'number' is not assignable to type '12'.

DOMException.prototype.INVALID_MODIFICATION_ERR

Standards:

readonly INVALID_MODIFICATION_ERR: number;

Workers:

static readonly INVALID_MODIFICATION_ERR: 13;
TypeScript Details 

Type 'number' is not assignable to type '13'.

DOMException.prototype.NAMESPACE_ERR

Standards:

readonly NAMESPACE_ERR: number;

Workers:

static readonly NAMESPACE_ERR: 14;
TypeScript Details 

Type 'number' is not assignable to type '14'.

DOMException.prototype.INVALID_ACCESS_ERR

Standards:

readonly INVALID_ACCESS_ERR: number;

Workers:

static readonly INVALID_ACCESS_ERR: 15;
TypeScript Details 

Type 'number' is not assignable to type '15'.

DOMException.prototype.VALIDATION_ERR

Standards:

readonly VALIDATION_ERR: number;

Workers:

static readonly VALIDATION_ERR: 16;
TypeScript Details 

Type 'number' is not assignable to type '16'.

DOMException.prototype.TYPE_MISMATCH_ERR

Standards:

readonly TYPE_MISMATCH_ERR: number;

Workers:

static readonly TYPE_MISMATCH_ERR: 17;
TypeScript Details 

Type 'number' is not assignable to type '17'.

DOMException.prototype.SECURITY_ERR

Standards:

readonly SECURITY_ERR: number;

Workers:

static readonly SECURITY_ERR: 18;
TypeScript Details 

Type 'number' is not assignable to type '18'.

DOMException.prototype.NETWORK_ERR

Standards:

readonly NETWORK_ERR: number;

Workers:

static readonly NETWORK_ERR: 19;
TypeScript Details 

Type 'number' is not assignable to type '19'.

DOMException.prototype.ABORT_ERR

Standards:

readonly ABORT_ERR: number;

Workers:

static readonly ABORT_ERR: 20;
TypeScript Details 

Type 'number' is not assignable to type '20'.

DOMException.prototype.URL_MISMATCH_ERR

Standards:

readonly URL_MISMATCH_ERR: number;

Workers:

static readonly URL_MISMATCH_ERR: 21;
TypeScript Details 

Type 'number' is not assignable to type '21'.

DOMException.prototype.QUOTA_EXCEEDED_ERR

Standards:

readonly QUOTA_EXCEEDED_ERR: number;

Workers:

static readonly QUOTA_EXCEEDED_ERR: 22;
TypeScript Details 

Type 'number' is not assignable to type '22'.

DOMException.prototype.TIMEOUT_ERR

Standards:

readonly TIMEOUT_ERR: number;

Workers:

static readonly TIMEOUT_ERR: 23;
TypeScript Details 

Type 'number' is not assignable to type '23'.

DOMException.prototype.INVALID_NODE_TYPE_ERR

Standards:

readonly INVALID_NODE_TYPE_ERR: number;

Workers:

static readonly INVALID_NODE_TYPE_ERR: 24;
TypeScript Details 

Type 'number' is not assignable to type '24'.

DOMException.prototype.DATA_CLONE_ERR

Standards:

readonly DATA_CLONE_ERR: number;

Workers:

static readonly DATA_CLONE_ERR: 25;
TypeScript Details 

Type 'number' is not assignable to type '25'.

DOMException.prototype.stack

Standards:

never

Workers:

readonly stack: any;
TypeScript Details 

Type 'any' is not assignable to type 'never'.

class PromiseRejectionEvent

Standards:

PromiseRejectionEvent: {
    prototype: PromiseRejectionEvent;
    new (type: string, eventInitDict: PromiseRejectionEventInit): PromiseRejectionEvent;
}

Workers:

export declare abstract class PromiseRejectionEvent extends Event {
    readonly promise: Promise<any>;
    readonly reason: any;
}
TypeScript Details 

Type 'typeof PromiseRejectionEvent' is not assignable to type '{ new (type: string, eventInitDict: PromiseRejectionEventInit): PromiseRejectionEvent; prototype: PromiseRejectionEvent; }'.
  Types of property 'prototype' are incompatible.
    Type 'PromiseRejectionEvent' is missing the following properties from type 'PromiseRejectionEvent': target, initEvent, AT_TARGET, BUBBLING_PHASE, and 2 more.

class Navigator

Standards:

Navigator: {
    prototype: Navigator;
    new (): Navigator;
}

Workers:

export declare abstract class Navigator {
    readonly userAgent: string;
}
TypeScript Details 

Type 'typeof Navigator' is not assignable to type '{ new (): Navigator; prototype: Navigator; }'.
  Types of property 'prototype' are incompatible.
    Type 'Navigator' is missing the following properties from type 'Navigator': clipboard, credentials, doNotTrack, geolocation, and 33 more.

Navigator.prototype.userAgent

Standards:

never

Workers:

readonly userAgent: string;
TypeScript Details 

Type 'string' is not assignable to type 'never'.

Navigator.prototype.requestMediaKeySystemAccess()

Standards:

/** Available only in secure contexts. */
requestMediaKeySystemAccess(keySystem: string, supportedConfigurations: Iterable<MediaKeySystemConfiguration>): Promise<MediaKeySystemAccess>;

Workers:

never
TypeScript Details 

Type '{ (keySystem: string, supportedConfigurations: MediaKeySystemConfiguration[]): Promise<MediaKeySystemAccess>; (keySystem: string, supportedConfigurations: Iterable<...>): Promise<...>; (keySystem: string, supportedConfigurations: Iterable<...>): Promise<...>; }' is not assignable to type 'never'.

Navigator.prototype.vibrate()

Standards:

vibrate(pattern: Iterable<number>): boolean;

Workers:

never
TypeScript Details 

Type '{ (pattern: VibratePattern): boolean; (pattern: Iterable<number>): boolean; (pattern: Iterable<number>): boolean; }' is not assignable to type 'never'.

class Event

Standards:

Event: {
    prototype: Event;
    new (type: string, eventInitDict?: EventInit): Event;
    readonly AT_TARGET: number;
    readonly BUBBLING_PHASE: number;
    readonly CAPTURING_PHASE: number;
    readonly NONE: number;
}

Workers:

export declare class Event {
    constructor(param0: string, param1?: EventInit);
    get type(): string;
    get eventPhase(): number;
    get composed(): boolean;
    get bubbles(): boolean;
    get cancelable(): boolean;
    get defaultPrevented(): boolean;
    get returnValue(): boolean;
    get currentTarget(): EventTarget | undefined;
    get srcElement(): EventTarget | undefined;
    get timeStamp(): number;
    get isTrusted(): boolean;
    get cancelBubble(): boolean;
    set cancelBubble(value: boolean);
    stopImmediatePropagation(): void;
    preventDefault(): void;
    stopPropagation(): void;
    composedPath(): EventTarget[];
    static readonly NONE: 0;
    static readonly CAPTURING_PHASE: 1;
    static readonly AT_TARGET: 2;
    static readonly BUBBLING_PHASE: 3;
}
TypeScript Details 

Type 'typeof Event' is not assignable to type '{ new (type: string, eventInitDict?: EventInit): Event; prototype: Event; readonly AT_TARGET: number; readonly BUBBLING_PHASE: number; readonly CAPTURING_PHASE: number; readonly NONE: number; }'.
  Types of property 'prototype' are incompatible.
    Type 'Event' is missing the following properties from type 'Event': target, initEvent, AT_TARGET, BUBBLING_PHASE, and 2 more.

Event.prototype.NONE

Standards:

readonly NONE: number;

Workers:

static readonly NONE: 0;
TypeScript Details 

Type 'number' is not assignable to type '0'.

Event.prototype.CAPTURING_PHASE

Standards:

readonly CAPTURING_PHASE: number;

Workers:

static readonly CAPTURING_PHASE: 1;
TypeScript Details 

Type 'number' is not assignable to type '1'.

Event.prototype.AT_TARGET

Standards:

readonly AT_TARGET: number;

Workers:

static readonly AT_TARGET: 2;
TypeScript Details 

Type 'number' is not assignable to type '2'.

Event.prototype.BUBBLING_PHASE

Standards:

readonly BUBBLING_PHASE: number;

Workers:

static readonly BUBBLING_PHASE: 3;
TypeScript Details 

Type 'number' is not assignable to type '3'.

Event.prototype.target

Standards:

/** Returns the object to which event is dispatched (its target). */
readonly target: EventTarget | null;

Workers:

never
TypeScript Details 

Type 'EventTarget' is not assignable to type 'never'.

Event.prototype.initEvent()

Standards:

/** @deprecated */
initEvent(type: string, bubbles?: boolean, cancelable?: boolean): void;

Workers:

never
TypeScript Details 

Type '(type: string, bubbles?: boolean, cancelable?: boolean) => void' is not assignable to type 'never'.

class EventTarget

Standards:

EventTarget: {
    prototype: EventTarget;
    new (): EventTarget;
}

Workers:

export declare class EventTarget<EventMap extends Record<string, Event> = Record<string, Event>> {
    constructor();
    addEventListener<Type extends keyof EventMap>(type: Type, handler: EventListenerOrEventListenerObject<EventMap[Type]>, options?: EventTargetAddEventListenerOptions | boolean): void;
    removeEventListener<Type extends keyof EventMap>(type: Type, handler: EventListenerOrEventListenerObject<EventMap[Type]>, options?: EventTargetEventListenerOptions | boolean): void;
    dispatchEvent(event: EventMap[keyof EventMap]): boolean;
}
TypeScript Details 

Types of construct signatures are incompatible.
  Type 'new () => EventTarget' is not assignable to type 'new <EventMap extends Record<string, Event> = Record<string, Event>>() => EventTarget<EventMap>'.
    Construct signature return types 'EventTarget' and 'EventTarget<EventMap>' are incompatible.
      The types of 'addEventListener' are incompatible between these types.
        Type '(type: string, callback: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions) => void' is not assignable to type '<Type extends keyof EventMap>(type: Type, handler: EventListenerOrEventListenerObject<EventMap[Type]>, options?: boolean | EventTargetAddEventListenerOptions) => void'.
          Types of parameters 'type' and 'type' are incompatible.
            Type 'Type' is not assignable to type 'string'.
              Type 'keyof EventMap' is not assignable to type 'string'.
                Type 'string | number | symbol' is not assignable to type 'string'.
                  Type 'number' is not assignable to type 'string'.

EventTarget.prototype.addEventListener(options)

Standards:

options?: AddEventListenerOptions | boolean

Workers:

options?: EventTargetAddEventListenerOptions | boolean
TypeScript Details 

Type 'boolean | EventTargetAddEventListenerOptions' is not assignable to type 'boolean | AddEventListenerOptions'.
  Type 'EventTargetAddEventListenerOptions' is not assignable to type 'boolean | AddEventListenerOptions'.
    Type 'EventTargetAddEventListenerOptions' is not assignable to type 'AddEventListenerOptions'.
      Types of property 'signal' are incompatible.
        Property 'onabort' is missing in type 'CfWorker.AbortSignal' but required in type 'DOM.AbortSignal'.

EventTarget.prototype.dispatchEvent(event)

Standards:

event: Event

Workers:

event: EventMap[keyof EventMap]
TypeScript Details 

Type 'CfWorker.Event' is not assignable to type 'DOM.Event'.

class AbortController

Standards:

AbortController: {
    prototype: AbortController;
    new (): AbortController;
}

Workers:

export declare class AbortController {
    constructor();
    get signal(): AbortSignal;
    abort(param0?: any): void;
}
TypeScript Details 

Type 'typeof AbortController' is not assignable to type '{ new (): AbortController; prototype: AbortController; }'.
  The types of 'prototype.signal' are incompatible between these types.
    Type 'CfWorker.AbortSignal' is not assignable to type 'DOM.AbortSignal'.

AbortController.prototype.signal

Standards:

/** Returns the AbortSignal object associated with this object. */
readonly signal: AbortSignal;

Workers:

get signal(): AbortSignal;
TypeScript Details 

Type 'CfWorker.AbortSignal' is not assignable to type 'DOM.AbortSignal'.

class AbortSignal

Standards:

AbortSignal: {
    prototype: AbortSignal;
    new (): AbortSignal;
}

Workers:

export declare abstract class AbortSignal extends EventTarget {
    static abort(param0?: any): AbortSignal;
    static timeout(param0: number): AbortSignal;
    get aborted(): boolean;
    get reason(): any;
    throwIfAborted(): void;
}
TypeScript Details 

Type 'typeof AbortSignal' is not assignable to type '{ new (): AbortSignal; prototype: AbortSignal; }'.
  Types of property 'prototype' are incompatible.
    Type 'CfWorker.AbortSignal' is not assignable to type 'DOM.AbortSignal'.

AbortSignal.prototype.onabort

Standards:

onabort: ((this: AbortSignal, ev: Event) => any) | null;

Workers:

never
TypeScript Details 

Type '(this: AbortSignal, ev: Event) => any' is not assignable to type 'never'.

AbortSignal.prototype.addEventListener()

Standards:

addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;

Workers:

never
TypeScript Details 

Type '{ <K extends "abort">(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void; (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void; }' is not assignable to type 'never'.

AbortSignal.prototype.removeEventListener()

Standards:

removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;

Workers:

never
TypeScript Details 

Type '{ <K extends "abort">(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | EventListenerOptions): void; (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void; }' is not assignable to type 'never'.

AbortSignal.abort()

Standards:

never

Workers:

static abort(param0?: any): AbortSignal;
TypeScript Details 

Type '(param0?: any) => AbortSignal' is not assignable to type 'never'.

AbortSignal.timeout()

Standards:

never

Workers:

static timeout(param0: number): AbortSignal;
TypeScript Details 

Type '(param0: number) => AbortSignal' is not assignable to type 'never'.

class Blob

Standards:

Blob: {
    prototype: Blob;
    new (blobParts?: BlobPart[], options?: BlobPropertyBag): Blob;
}

Workers:

export declare class Blob {
    constructor(param0?: ((ArrayBuffer | ArrayBufferView) | string | Blob)[], param1?: BlobOptions);
    get size(): number;
    get type(): string;
    slice(param0?: number, param1?: number, param2?: string): Blob;
    arrayBuffer(): Promise<ArrayBuffer>;
    text(): Promise<string>;
    stream(): ReadableStream;
}
TypeScript Details 

Type 'typeof Blob' is not assignable to type '{ new (blobParts?: BlobPart[], options?: BlobPropertyBag): Blob; prototype: Blob; }'.
  The types of 'prototype.stream().getReader().closed' are incompatible between these types.
    Type 'Promise<void>' is not assignable to type 'Promise<undefined>'.
      Type 'void' is not assignable to type 'undefined'.

Blob.prototype.slice()

Standards:

slice(start?: number, end?: number, contentType?: string): Blob;

Workers:

slice(param0?: number, param1?: number, param2?: string): Blob;
TypeScript Details 

Type '(param0?: number, param1?: number, param2?: string) => Blob' is not assignable to type '(start?: number, end?: number, contentType?: string) => Blob'.
  Type 'CfWorker.Blob' is not assignable to type 'DOM.Blob'.

Blob.prototype.stream()

Standards:

stream(): ReadableStream<Uint8Array>;

Workers:

stream(): ReadableStream;
TypeScript Details 

Type '() => ReadableStream<any>' is not assignable to type '() => ReadableStream<Uint8Array>'.

new Blob(blobParts)

Standards:

blobParts?: BlobPart[]

Workers:

param0?: ((ArrayBuffer | ArrayBufferView) | string | Blob)[]
TypeScript Details 

Type '(string | ArrayBuffer | ArrayBufferView | Blob)[]' is not assignable to type 'BlobPart[]'.

class File

Standards:

File: {
    prototype: File;
    new (fileBits: BlobPart[], fileName: string, options?: FilePropertyBag): File;
}

Workers:

export declare class File extends Blob {
    constructor(param0: ((ArrayBuffer | ArrayBufferView) | string | Blob)[] | undefined, param1: string, param2?: FileOptions);
    get name(): string;
    get lastModified(): number;
}
TypeScript Details 

Type 'typeof File' is not assignable to type '{ new (fileBits: BlobPart[], fileName: string, options?: FilePropertyBag): File; prototype: File; }'.
  Types of property 'prototype' are incompatible.
    Property 'webkitRelativePath' is missing in type 'CfWorker.File' but required in type 'DOM.File'.

File.prototype.webkitRelativePath

Standards:

readonly webkitRelativePath: string;

Workers:

never
TypeScript Details 

Type 'string' is not assignable to type 'never'.

new File(fileBits)

Standards:

fileBits: BlobPart[]

Workers:

param0: ((ArrayBuffer | ArrayBufferView) | string | Blob)[] | undefined
TypeScript Details 

Type '(string | ArrayBuffer | ArrayBufferView | Blob)[]' is not assignable to type 'BlobPart[]'.

class CacheStorage

Standards:

CacheStorage: {
    prototype: CacheStorage;
    new (): CacheStorage;
}

Workers:

export declare abstract class CacheStorage {
    open(param0: string): Promise<Cache>;
    readonly default: Cache;
}
TypeScript Details 

Type 'typeof CacheStorage' is not assignable to type '{ new (): CacheStorage; prototype: CacheStorage; }'.
  Types of property 'prototype' are incompatible.
    Type 'CacheStorage' is missing the following properties from type 'CacheStorage': delete, has, keys, match

CacheStorage.prototype.default

Standards:

never

Workers:

readonly default: Cache;
TypeScript Details 

Type 'Cache' is not assignable to type 'never'.

CacheStorage.prototype.open()

Standards:

open(cacheName: string): Promise<Cache>;

Workers:

open(param0: string): Promise<Cache>;
TypeScript Details 

Type '(param0: string) => Promise<Cache>' is not assignable to type '(cacheName: string) => Promise<Cache>'.
  Type 'Promise<CfWorker.Cache>' is not assignable to type 'Promise<DOM.Cache>'.
    Type 'Cache' is missing the following properties from type 'Cache': add, addAll, keys, matchAll

CacheStorage.prototype.delete()

Standards:

delete(cacheName: string): Promise<boolean>;

Workers:

never
TypeScript Details 

Type '(cacheName: string) => Promise<boolean>' is not assignable to type 'never'.

CacheStorage.prototype.has()

Standards:

has(cacheName: string): Promise<boolean>;

Workers:

never
TypeScript Details 

Type '(cacheName: string) => Promise<boolean>' is not assignable to type 'never'.

CacheStorage.prototype.keys()

Standards:

keys(): Promise<string[]>;

Workers:

never
TypeScript Details 

Type '() => Promise<string[]>' is not assignable to type 'never'.

CacheStorage.prototype.match()

Standards:

match(request: RequestInfo | URL, options?: MultiCacheQueryOptions): Promise<Response | undefined>;

Workers:

never
TypeScript Details 

Type '(request: RequestInfo | URL, options?: MultiCacheQueryOptions) => Promise<Response>' is not assignable to type 'never'.

class Cache

Standards:

Cache: {
    prototype: Cache;
    new (): Cache;
}

Workers:

export declare abstract class Cache {
    delete(param0: Request | string, param1?: CacheQueryOptions): Promise<boolean>;
    match(param0: Request | string, param1?: CacheQueryOptions): Promise<Response | undefined>;
    put(param0: Request | string, param1: Response): Promise<void>;
}
TypeScript Details 

Type 'typeof Cache' is not assignable to type '{ new (): Cache; prototype: Cache; }'.
  Types of property 'prototype' are incompatible.
    Type 'CfWorker.Cache' is not assignable to type 'DOM.Cache'.

Cache.prototype.addAll()

Standards:

addAll(requests: Iterable<RequestInfo>): Promise<void>;

Workers:

never
TypeScript Details 

Type '{ (requests: RequestInfo[]): Promise<void>; (requests: Iterable<RequestInfo>): Promise<void>; (requests: Iterable<RequestInfo>): Promise<...>; }' is not assignable to type 'never'.

Cache.prototype.delete()

Standards:

never

Workers:

delete(param0: Request | string, param1?: CacheQueryOptions): Promise<boolean>;
TypeScript Details 

Type '(param0: string | Request, param1?: CacheQueryOptions) => Promise<boolean>' is not assignable to type 'never'.

Cache.prototype.match()

Standards:

never

Workers:

match(param0: Request | string, param1?: CacheQueryOptions): Promise<Response | undefined>;
TypeScript Details 

Type '(param0: string | Request, param1?: CacheQueryOptions) => Promise<Response>' is not assignable to type 'never'.

Cache.prototype.put()

Standards:

never

Workers:

put(param0: Request | string, param1: Response): Promise<void>;
TypeScript Details 

Type '(param0: string | Request, param1: Response) => Promise<void>' is not assignable to type 'never'.

class Crypto

Standards:

Crypto: {
    prototype: Crypto;
    new (): Crypto;
}

Workers:

export declare abstract class Crypto {
    get subtle(): SubtleCrypto;
    getRandomValues<T extends Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array | BigInt64Array | BigUint64Array>(buffer: T): T;
    randomUUID(): string;
    DigestStream: typeof DigestStream;
}
TypeScript Details 

Type 'typeof Crypto' is not assignable to type '{ new (): Crypto; prototype: Crypto; }'.
  The types returned by 'prototype.subtle.deriveKey(...)' are incompatible between these types.
    Type 'Promise<CfWorker.CryptoKey>' is not assignable to type 'Promise<DOM.CryptoKey>'.
      Type 'CfWorker.CryptoKey' is not assignable to type 'DOM.CryptoKey'.
        Types of property 'type' are incompatible.
          Type 'string' is not assignable to type 'KeyType'.

Crypto.prototype.subtle

Standards:

/** Available only in secure contexts. */
readonly subtle: SubtleCrypto;

Workers:

get subtle(): SubtleCrypto;
TypeScript Details 

Type 'CfWorker.SubtleCrypto' is not assignable to type 'DOM.SubtleCrypto'.

Crypto.prototype.DigestStream

Standards:

never

Workers:

DigestStream: typeof DigestStream;
TypeScript Details 

Type 'typeof DigestStream' is not assignable to type 'never'.

Crypto.prototype.getRandomValues()

Standards:

getRandomValues<T extends ArrayBufferView | null>(array: T): T;

Workers:

getRandomValues<T extends Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array | BigInt64Array | BigUint64Array>(buffer: T): T;
TypeScript Details 

Type '<T extends Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array | BigInt64Array | BigUint64Array>(buffer: T) => T' is not assignable to type '<T extends ArrayBufferView>(array: T) => T'.
  Types of parameters 'buffer' and 'array' are incompatible.
    Type 'T' is not assignable to type 'Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array | BigInt64Array | BigUint64Array'.
      Type 'ArrayBufferView' is not assignable to type 'Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array | BigInt64Array | BigUint64Array'.
        Type 'ArrayBufferView' is not assignable to type 'BigUint64Array'.
          Type 'T' is not assignable to type 'BigUint64Array'.
            Type 'ArrayBufferView' is missing the following properties from type 'BigUint64Array': BYTES_PER_ELEMENT, copyWithin, entries, every, and 24 more.

Crypto.prototype.getRandomValues(array)

Standards:

array: T

Workers:

buffer: T
TypeScript Details 

Type 'ArrayBufferView' is not assignable to type 'Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array | BigInt64Array | BigUint64Array'.

class SubtleCrypto

Standards:

SubtleCrypto: {
    prototype: SubtleCrypto;
    new (): SubtleCrypto;
}

Workers:

export declare abstract class SubtleCrypto {
    encrypt(param0: string | SubtleCryptoEncryptAlgorithm, param1: CryptoKey, param2: ArrayBuffer | ArrayBufferView): Promise<ArrayBuffer>;
    decrypt(param0: string | SubtleCryptoEncryptAlgorithm, param1: CryptoKey, param2: ArrayBuffer | ArrayBufferView): Promise<ArrayBuffer>;
    sign(param0: string | SubtleCryptoSignAlgorithm, param1: CryptoKey, param2: ArrayBuffer | ArrayBufferView): Promise<ArrayBuffer>;
    verify(param0: string | SubtleCryptoSignAlgorithm, param1: CryptoKey, param2: ArrayBuffer | ArrayBufferView, param3: ArrayBuffer | ArrayBufferView): Promise<boolean>;
    digest(param0: string | SubtleCryptoHashAlgorithm, param1: ArrayBuffer | ArrayBufferView): Promise<ArrayBuffer>;
    generateKey(param0: string | SubtleCryptoGenerateKeyAlgorithm, param1: boolean, param2: string[]): Promise<CryptoKey | CryptoKeyPair>;
    deriveKey(param0: string | SubtleCryptoDeriveKeyAlgorithm, param1: CryptoKey, param2: string | SubtleCryptoImportKeyAlgorithm, param3: boolean, param4: string[]): Promise<CryptoKey>;
    deriveBits(param0: string | SubtleCryptoDeriveKeyAlgorithm, param1: CryptoKey, param2: number | null): Promise<ArrayBuffer>;
    importKey(param0: string, param1: (ArrayBuffer | ArrayBufferView) | JsonWebKey, param2: string | SubtleCryptoImportKeyAlgorithm, param3: boolean, param4: string[]): Promise<CryptoKey>;
    exportKey(param0: string, param1: CryptoKey): Promise<ArrayBuffer | JsonWebKey>;
    wrapKey(param0: string, param1: CryptoKey, param2: CryptoKey, param3: string | SubtleCryptoEncryptAlgorithm): Promise<ArrayBuffer>;
    unwrapKey(param0: string, param1: ArrayBuffer | ArrayBufferView, param2: CryptoKey, param3: string | SubtleCryptoEncryptAlgorithm, param4: string | SubtleCryptoImportKeyAlgorithm, param5: boolean, param6: string[]): Promise<CryptoKey>;
    timingSafeEqual(param0: ArrayBuffer | ArrayBufferView, param1: ArrayBuffer | ArrayBufferView): boolean;
}
TypeScript Details 

Type 'typeof SubtleCrypto' is not assignable to type '{ new (): SubtleCrypto; prototype: SubtleCrypto; }'.
  Types of property 'prototype' are incompatible.
    Type 'CfWorker.SubtleCrypto' is not assignable to type 'DOM.SubtleCrypto'.

SubtleCrypto.prototype.generateKey()

Standards:

generateKey(algorithm: AlgorithmIdentifier, extractable: boolean, keyUsages: Iterable<KeyUsage>): Promise<CryptoKeyPair | CryptoKey>;

Workers:

generateKey(param0: string | SubtleCryptoGenerateKeyAlgorithm, param1: boolean, param2: string[]): Promise<CryptoKey | CryptoKeyPair>;
TypeScript Details 

Type '(param0: string | SubtleCryptoGenerateKeyAlgorithm, param1: boolean, param2: string[]) => Promise<CryptoKey | CryptoKeyPair>' is not assignable to type '{ (algorithm: EcKeyGenParams | RsaHashedKeyGenParams, extractable: boolean, keyUsages: readonly KeyUsage[]): Promise<CryptoKeyPair>; (algorithm: AesKeyGenParams | ... 1 more ... | Pbkdf2Params, extractable: boolean, keyUsages: readonly KeyUsage[]): Promise<...>; (algorithm: AlgorithmIdentifier, extractable: boolean,...'.
  Types of parameters 'param2' and 'keyUsages' are incompatible.
    The type 'readonly KeyUsage[]' is 'readonly' and cannot be assigned to the mutable type 'string[]'.

SubtleCrypto.prototype.generateKey(keyUsages)

Standards:

keyUsages: Iterable<KeyUsage>

Workers:

param2: string[]
TypeScript Details 

Type 'string[]' is not assignable to type 'Iterable<KeyUsage>'.
  The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types.
    Type 'IteratorResult<string, any>' is not assignable to type 'IteratorResult<KeyUsage, any>'.
      Type 'IteratorYieldResult<string>' is not assignable to type 'IteratorResult<KeyUsage, any>'.
        Type 'IteratorYieldResult<string>' is not assignable to type 'IteratorYieldResult<KeyUsage>'.
          Type 'string' is not assignable to type 'KeyUsage'.

SubtleCrypto.prototype.deriveKey()

Standards:

deriveKey(algorithm: AlgorithmIdentifier | EcdhKeyDeriveParams | HkdfParams | Pbkdf2Params, baseKey: CryptoKey, derivedKeyType: AlgorithmIdentifier | AesDerivedKeyParams | HmacImportParams | HkdfParams | Pbkdf2Params, extractable: boolean, keyUsages: Iterable<KeyUsage>): Promise<CryptoKey>;

Workers:

deriveKey(param0: string | SubtleCryptoDeriveKeyAlgorithm, param1: CryptoKey, param2: string | SubtleCryptoImportKeyAlgorithm, param3: boolean, param4: string[]): Promise<CryptoKey>;
TypeScript Details 

Type '(param0: string | SubtleCryptoDeriveKeyAlgorithm, param1: CryptoKey, param2: string | SubtleCryptoImportKeyAlgorithm, param3: boolean, param4: string[]) => Promise<...>' is not assignable to type '{ (algorithm: EcdhKeyDeriveParams | AlgorithmIdentifier | HkdfParams | Pbkdf2Params, baseKey: CryptoKey, derivedKeyType: AesDerivedKeyParams | ... 3 more ... | Pbkdf2Params, extractable: boolean, keyUsages: KeyUsage[]): Promise<...>; (algorithm: EcdhKeyDeriveParams | ... 2 more ... | Pbkdf2Params, baseKey: CryptoKey...'.

SubtleCrypto.prototype.deriveKey(algorithm)

Standards:

algorithm: AlgorithmIdentifier | EcdhKeyDeriveParams | HkdfParams | Pbkdf2Params

Workers:

param0: string | SubtleCryptoDeriveKeyAlgorithm
TypeScript Details 

Type 'EcdhKeyDeriveParams | AlgorithmIdentifier | HkdfParams | Pbkdf2Params' is not assignable to type 'string | SubtleCryptoDeriveKeyAlgorithm'.
  Type 'HkdfParams' is not assignable to type 'string | SubtleCryptoDeriveKeyAlgorithm'.
    Type 'HkdfParams' is not assignable to type 'SubtleCryptoDeriveKeyAlgorithm'.
      Types of property 'salt' are incompatible.
        Type 'BufferSource' is not assignable to type 'ArrayBuffer'.
          Type 'ArrayBufferView' is missing the following properties from type 'ArrayBuffer': slice, [Symbol.toStringTag]

SubtleCrypto.prototype.deriveKey(baseKey)

Standards:

baseKey: CryptoKey

Workers:

param1: CryptoKey
TypeScript Details 

Type 'CfWorker.CryptoKey' is not assignable to type 'DOM.CryptoKey'.

SubtleCrypto.prototype.deriveKey(keyUsages)

Standards:

keyUsages: Iterable<KeyUsage>

Workers:

param4: string[]
TypeScript Details 

Type 'string[]' is not assignable to type 'Iterable<KeyUsage>'.

SubtleCrypto.prototype.importKey()

Standards:

importKey(format: Exclude<KeyFormat, 'jwk'>, keyData: BufferSource, algorithm: AlgorithmIdentifier | RsaHashedImportParams | EcKeyImportParams | HmacImportParams | AesKeyAlgorithm, extractable: boolean, keyUsages: Iterable<KeyUsage>): Promise<CryptoKey>;

Workers:

importKey(param0: string, param1: (ArrayBuffer | ArrayBufferView) | JsonWebKey, param2: string | SubtleCryptoImportKeyAlgorithm, param3: boolean, param4: string[]): Promise<CryptoKey>;
TypeScript Details 

Type '(param0: string, param1: ArrayBuffer | ArrayBufferView | JsonWebKey, param2: string | SubtleCryptoImportKeyAlgorithm, param3: boolean, param4: string[]) => Promise<...>' is not assignable to type '{ (format: "jwk", keyData: JsonWebKey, algorithm: AesKeyAlgorithm | EcKeyImportParams | AlgorithmIdentifier | HmacImportParams | RsaHashedImportParams, extractable: boolean, keyUsages: readonly KeyUsage[]): Promise<...>; (format: "raw" | ... 1 more ... | "spki", keyData: BufferSource, algorithm: AesKeyAlgorithm | .....'.
  Types of parameters 'param1' and 'keyData' are incompatible.
    Type 'JsonWebKey' is not assignable to type 'ArrayBuffer | ArrayBufferView | JsonWebKey'.
      Type 'DOM.JsonWebKey' is not assignable to type 'CfWorker.JsonWebKey'.
        Property 'kty' is optional in type 'JsonWebKey' but required in type 'JsonWebKey'.

SubtleCrypto.prototype.importKey(format)

Standards:

format: Exclude<KeyFormat, 'jwk'>

Workers:

param0: string
TypeScript Details 

Type 'string' is not assignable to type '"raw" | "pkcs8" | "spki"'.

SubtleCrypto.prototype.importKey(keyData)

Standards:

keyData: BufferSource

Workers:

param1: (ArrayBuffer | ArrayBufferView) | JsonWebKey
TypeScript Details 

Type 'ArrayBuffer | ArrayBufferView | JsonWebKey' is not assignable to type 'BufferSource'.
  Type 'JsonWebKey' is not assignable to type 'BufferSource'.

SubtleCrypto.prototype.importKey(keyUsages)

Standards:

keyUsages: Iterable<KeyUsage>

Workers:

param4: string[]
TypeScript Details 

Type 'string[]' is not assignable to type 'Iterable<KeyUsage>'.

SubtleCrypto.prototype.unwrapKey()

Standards:

unwrapKey(format: KeyFormat, wrappedKey: BufferSource, unwrappingKey: CryptoKey, unwrapAlgorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AesGcmParams, unwrappedKeyAlgorithm: AlgorithmIdentifier | RsaHashedImportParams | EcKeyImportParams | HmacImportParams | AesKeyAlgorithm, extractable: boolean, keyUsages: Iterable<KeyUsage>): Promise<CryptoKey>;

Workers:

unwrapKey(param0: string, param1: ArrayBuffer | ArrayBufferView, param2: CryptoKey, param3: string | SubtleCryptoEncryptAlgorithm, param4: string | SubtleCryptoImportKeyAlgorithm, param5: boolean, param6: string[]): Promise<CryptoKey>;
TypeScript Details 

Type '(param0: string, param1: ArrayBuffer | ArrayBufferView, param2: CryptoKey, param3: string | SubtleCryptoEncryptAlgorithm, param4: string | SubtleCryptoImportKeyAlgorithm, param5: boolean, param6: string[]) => Promise<...>' is not assignable to type '{ (format: KeyFormat, wrappedKey: BufferSource, unwrappingKey: CryptoKey, unwrapAlgorithm: AesCbcParams | AesCtrParams | AesGcmParams | AlgorithmIdentifier | RsaOaepParams, unwrappedKeyAlgorithm: AesKeyAlgorithm | ... 3 more ... | RsaHashedImportParams, extractable: boolean, keyUsages: KeyUsage[]): Promise<...>; (fo...'.
  Type 'Promise<CfWorker.CryptoKey>' is not assignable to type 'Promise<DOM.CryptoKey>'.

SubtleCrypto.prototype.unwrapKey(format)

Standards:

format: KeyFormat

Workers:

param0: string
TypeScript Details 

Type 'string' is not assignable to type 'KeyFormat'.

SubtleCrypto.prototype.unwrapKey(unwrappingKey)

Standards:

unwrappingKey: CryptoKey

Workers:

param2: CryptoKey
TypeScript Details 

Type 'CfWorker.CryptoKey' is not assignable to type 'DOM.CryptoKey'.

SubtleCrypto.prototype.unwrapKey(unwrapAlgorithm)

Standards:

unwrapAlgorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AesGcmParams

Workers:

param3: string | SubtleCryptoEncryptAlgorithm
TypeScript Details 

Type 'AesCbcParams | AesCtrParams | AesGcmParams | AlgorithmIdentifier | RsaOaepParams' is not assignable to type 'string | SubtleCryptoEncryptAlgorithm'.
  Type 'AesCbcParams' is not assignable to type 'string | SubtleCryptoEncryptAlgorithm'.
    Type 'AesCbcParams' is not assignable to type 'SubtleCryptoEncryptAlgorithm'.
      Types of property 'iv' are incompatible.
        Type 'BufferSource' is not assignable to type 'ArrayBuffer'.
          Type 'ArrayBufferView' is not assignable to type 'ArrayBuffer'.

SubtleCrypto.prototype.unwrapKey(keyUsages)

Standards:

keyUsages: Iterable<KeyUsage>

Workers:

param6: string[]
TypeScript Details 

Type 'string[]' is not assignable to type 'Iterable<KeyUsage>'.

SubtleCrypto.prototype.encrypt()

Standards:

never

Workers:

encrypt(param0: string | SubtleCryptoEncryptAlgorithm, param1: CryptoKey, param2: ArrayBuffer | ArrayBufferView): Promise<ArrayBuffer>;
TypeScript Details 

Type '(param0: string | SubtleCryptoEncryptAlgorithm, param1: CryptoKey, param2: ArrayBuffer | ArrayBufferView) => Promise<...>' is not assignable to type 'never'.

SubtleCrypto.prototype.decrypt()

Standards:

never

Workers:

decrypt(param0: string | SubtleCryptoEncryptAlgorithm, param1: CryptoKey, param2: ArrayBuffer | ArrayBufferView): Promise<ArrayBuffer>;
TypeScript Details 

Type '(param0: string | SubtleCryptoEncryptAlgorithm, param1: CryptoKey, param2: ArrayBuffer | ArrayBufferView) => Promise<...>' is not assignable to type 'never'.

SubtleCrypto.prototype.sign()

Standards:

never

Workers:

sign(param0: string | SubtleCryptoSignAlgorithm, param1: CryptoKey, param2: ArrayBuffer | ArrayBufferView): Promise<ArrayBuffer>;
TypeScript Details 

Type '(param0: string | SubtleCryptoSignAlgorithm, param1: CryptoKey, param2: ArrayBuffer | ArrayBufferView) => Promise<...>' is not assignable to type 'never'.

SubtleCrypto.prototype.verify()

Standards:

never

Workers:

verify(param0: string | SubtleCryptoSignAlgorithm, param1: CryptoKey, param2: ArrayBuffer | ArrayBufferView, param3: ArrayBuffer | ArrayBufferView): Promise<boolean>;
TypeScript Details 

Type '(param0: string | SubtleCryptoSignAlgorithm, param1: CryptoKey, param2: ArrayBuffer | ArrayBufferView, param3: ArrayBuffer | ArrayBufferView) => Promise<...>' is not assignable to type 'never'.

SubtleCrypto.prototype.digest()

Standards:

never

Workers:

digest(param0: string | SubtleCryptoHashAlgorithm, param1: ArrayBuffer | ArrayBufferView): Promise<ArrayBuffer>;
TypeScript Details 

Type '(param0: string | SubtleCryptoHashAlgorithm, param1: ArrayBuffer | ArrayBufferView) => Promise<ArrayBuffer>' is not assignable to type 'never'.

SubtleCrypto.prototype.deriveBits()

Standards:

never

Workers:

deriveBits(param0: string | SubtleCryptoDeriveKeyAlgorithm, param1: CryptoKey, param2: number | null): Promise<ArrayBuffer>;
TypeScript Details 

Type '(param0: string | SubtleCryptoDeriveKeyAlgorithm, param1: CryptoKey, param2: number) => Promise<ArrayBuffer>' is not assignable to type 'never'.

SubtleCrypto.prototype.exportKey()

Standards:

never

Workers:

exportKey(param0: string, param1: CryptoKey): Promise<ArrayBuffer | JsonWebKey>;
TypeScript Details 

Type '(param0: string, param1: CryptoKey) => Promise<ArrayBuffer | JsonWebKey>' is not assignable to type 'never'.

SubtleCrypto.prototype.wrapKey()

Standards:

never

Workers:

wrapKey(param0: string, param1: CryptoKey, param2: CryptoKey, param3: string | SubtleCryptoEncryptAlgorithm): Promise<ArrayBuffer>;
TypeScript Details 

Type '(param0: string, param1: CryptoKey, param2: CryptoKey, param3: string | SubtleCryptoEncryptAlgorithm) => Promise<ArrayBuffer>' is not assignable to type 'never'.

SubtleCrypto.prototype.timingSafeEqual()

Standards:

never

Workers:

timingSafeEqual(param0: ArrayBuffer | ArrayBufferView, param1: ArrayBuffer | ArrayBufferView): boolean;
TypeScript Details 

Type '(param0: ArrayBuffer | ArrayBufferView, param1: ArrayBuffer | ArrayBufferView) => boolean' is not assignable to type 'never'.

class CryptoKey

Standards:

CryptoKey: {
    prototype: CryptoKey;
    new (): CryptoKey;
}

Workers:

export declare abstract class CryptoKey {
    readonly type: string;
    readonly extractable: boolean;
    readonly algorithm: CryptoKeyKeyAlgorithm | CryptoKeyAesKeyAlgorithm | CryptoKeyHmacKeyAlgorithm | CryptoKeyRsaKeyAlgorithm | CryptoKeyEllipticKeyAlgorithm | CryptoKeyArbitraryKeyAlgorithm;
    readonly usages: string[];
}
TypeScript Details 

Type 'typeof CryptoKey' is not assignable to type '{ new (): CryptoKey; prototype: CryptoKey; }'.
  Types of property 'prototype' are incompatible.
    Type 'CfWorker.CryptoKey' is not assignable to type 'DOM.CryptoKey'.

CryptoKey.prototype.type

Standards:

readonly type: KeyType;

Workers:

readonly type: string;
TypeScript Details 

Type 'string' is not assignable to type 'KeyType'.

CryptoKey.prototype.usages

Standards:

readonly usages: KeyUsage[];

Workers:

readonly usages: string[];
TypeScript Details 

Type 'string[]' is not assignable to type 'KeyUsage[]'.
  Type 'string' is not assignable to type 'KeyUsage'.

TextDecoder.prototype.encoding

Standards:

never

Workers:

get encoding(): string;
TypeScript Details 

Type 'string' is not assignable to type 'never'.

TextDecoder.prototype.fatal

Standards:

never

Workers:

get fatal(): boolean;
TypeScript Details 

Type 'boolean' is not assignable to type 'never'.

TextDecoder.prototype.ignoreBOM

Standards:

never

Workers:

get ignoreBOM(): boolean;
TypeScript Details 

Type 'boolean' is not assignable to type 'never'.

TextDecoder.prototype.decode(options)

Standards:

options?: TextDecodeOptions

Workers:

param1?: TextDecoderDecodeOptions
TypeScript Details 

Type 'TextDecodeOptions' is not assignable to type 'TextDecoderDecodeOptions'.
  Property 'stream' is optional in type 'TextDecodeOptions' but required in type 'TextDecoderDecodeOptions'.

new TextDecoder(options)

Standards:

options?: TextDecoderOptions

Workers:

param1?: TextDecoderConstructorOptions
TypeScript Details 

Type 'TextDecoderOptions' is not assignable to type 'TextDecoderConstructorOptions'.
  Property 'fatal' is optional in type 'TextDecoderOptions' but required in type 'TextDecoderConstructorOptions'.

class TextEncoder

Standards:

TextEncoder: {
    prototype: TextEncoder;
    new (): TextEncoder;
}

Workers:

export declare class TextEncoder {
    constructor();
    encode(param0?: string): Uint8Array;
    encodeInto(param0: string, param1: Uint8Array): TextEncoderEncodeIntoResult;
    get encoding(): string;
}
TypeScript Details 

Types of construct signatures are incompatible.
  Type 'new () => TextEncoder' is not assignable to type 'new () => TextEncoder'.
    Construct signature return types 'TextEncoder' and 'TextEncoder' are incompatible.
      The types returned by 'encodeInto(...)' are incompatible between these types.
        Type 'DOM.TextEncoderEncodeIntoResult' is not assignable to type 'CfWorker.TextEncoderEncodeIntoResult'.
          Property 'read' is optional in type 'TextEncoderEncodeIntoResult' but required in type 'TextEncoderEncodeIntoResult'.

TextEncoder.prototype.encoding

Standards:

never

Workers:

get encoding(): string;
TypeScript Details 

Type 'string' is not assignable to type 'never'.

TextEncoder.prototype.encodeInto()

Standards:

/** Runs the UTF-8 encoder on source, stores the result of that operation into destination, and returns the progress made as an object wherein read is the number of converted code units of source and written is the number of bytes modified in destination. */
encodeInto(source: string, destination: Uint8Array): TextEncoderEncodeIntoResult;

Workers:

encodeInto(param0: string, param1: Uint8Array): TextEncoderEncodeIntoResult;
TypeScript Details 

Type '(source: string, destination: Uint8Array) => TextEncoderEncodeIntoResult' is not assignable to type '(param0: string, param1: Uint8Array) => TextEncoderEncodeIntoResult'.

class FormData

Standards:

FormData: {
    prototype: FormData;
    new (form?: HTMLFormElement): FormData;
}

Workers:

export declare class FormData {
    constructor();
    append(name: string, value: string): void;
    append(name: string, value: Blob, filename?: string): void;
    delete(param0: string): void;
    get(param0: string): (File | string) | null;
    getAll(param0: string): (File | string)[];
    has(param0: string): boolean;
    set(name: string, value: string): void;
    set(name: string, value: Blob, filename?: string): void;
    entries(): IterableIterator<[
        key: string,
        value: File | string
    ]>;
    keys(): IterableIterator<string>;
    values(): IterableIterator<File | string>;
    forEach<This = unknown>(callback: (this: This, value: File | string, key: string, parent: FormData) => void, thisArg?: This): void;
    [Symbol.iterator](): IterableIterator<[
        key: string,
        value: File | string
    ]>;
}
TypeScript Details 

Type 'typeof FormData' is not assignable to type '{ new (form?: HTMLFormElement): FormData; prototype: FormData; }'.
  The types returned by 'prototype.get(...)' are incompatible between these types.
    Type 'string | File' is not assignable to type 'FormDataEntryValue'.
      Type 'File' is not assignable to type 'FormDataEntryValue'.
        Type 'CfWorker.File' is not assignable to type 'DOM.File'.

FormData.prototype.entries()

Standards:

/** Returns an array of key, value pairs for every entry in the list. */
entries(): IterableIterator<[
    string,
    FormDataEntryValue
]>;

Workers:

entries(): IterableIterator<[
    key: string,
    value: File | string
]>;
TypeScript Details 

Type '() => IterableIterator<[key: string, value: string | File]>' is not assignable to type '{ (): IterableIterator<[string, FormDataEntryValue]>; (): IterableIterator<[string, FormDataEntryValue]>; }'.
  Type 'IterableIterator<[key: string, value: string | File]>' is not assignable to type 'IterableIterator<[string, FormDataEntryValue]>'.
    Type '[key: string, value: string | File]' is not assignable to type '[string, FormDataEntryValue]'.
      Type at position 1 in source is not compatible with type at position 1 in target.
        Type 'string | File' is not assignable to type 'FormDataEntryValue'.

FormData.prototype.values()

Standards:

/** Returns a list of values in the list. */
values(): IterableIterator<FormDataEntryValue>;

Workers:

values(): IterableIterator<File | string>;
TypeScript Details 

Type '() => IterableIterator<string | File>' is not assignable to type '{ (): IterableIterator<FormDataEntryValue>; (): IterableIterator<FormDataEntryValue>; }'.
  Type 'IterableIterator<string | File>' is not assignable to type 'IterableIterator<FormDataEntryValue>'.
    Type 'string | File' is not assignable to type 'FormDataEntryValue'.

FormData.prototype.[Symbol.iterator]()

Standards:

[Symbol.iterator](): IterableIterator<[
    string,
    FormDataEntryValue
]>;

Workers:

[Symbol.iterator](): IterableIterator<[
    key: string,
    value: File | string
]>;
TypeScript Details 

Property '[Symbol.iterator]' does not exist on type 'FormData'.

return FormData.prototype.[Symbol.iterator]()

Standards:

[Symbol.iterator](): IterableIterator<[
    string,
    FormDataEntryValue
]>;

Workers:

[Symbol.iterator](): IterableIterator<[
    key: string,
    value: File | string
]>;
TypeScript Details 

Property '[Symbol.iterator]' does not exist on type 'FormData'.

FormData.prototype.append()

Standards:

never

Workers:

append(name: string, value: Blob, filename?: string): void;
TypeScript Details 

Type '{ (name: string, value: string): void; (name: string, value: Blob, filename?: string): void; }' is not assignable to type 'never'.

FormData.prototype.delete()

Standards:

never

Workers:

delete(param0: string): void;
TypeScript Details 

Type '(param0: string) => void' is not assignable to type 'never'.

FormData.prototype.get()

Standards:

never

Workers:

get(param0: string): (File | string) | null;
TypeScript Details 

Type '(param0: string) => string | File' is not assignable to type 'never'.

FormData.prototype.getAll()

Standards:

never

Workers:

getAll(param0: string): (File | string)[];
TypeScript Details 

Type '(param0: string) => (string | File)[]' is not assignable to type 'never'.

FormData.prototype.has()

Standards:

never

Workers:

has(param0: string): boolean;
TypeScript Details 

Type '(param0: string) => boolean' is not assignable to type 'never'.

FormData.prototype.set()

Standards:

never

Workers:

set(name: string, value: Blob, filename?: string): void;
TypeScript Details 

Type '{ (name: string, value: string): void; (name: string, value: Blob, filename?: string): void; }' is not assignable to type 'never'.

FormData.prototype.forEach()

Standards:

never

Workers:

forEach<This = unknown>(callback: (this: This, value: File | string, key: string, parent: FormData) => void, thisArg?: This): void;
TypeScript Details 

Type '<This = unknown>(callback: (this: This, value: string | File, key: string, parent: FormData) => void, thisArg?: This) => void' is not assignable to type 'never'.

new FormData(form)

Standards:

form?: HTMLFormElement

Workers:

never
TypeScript Details 

Type 'HTMLFormElement' is not assignable to type 'never'.

class Headers

Standards:

Headers: {
    prototype: Headers;
    new (init?: HeadersInit): Headers;
}

Workers:

export declare class Headers {
    constructor(init?: Headers | Record<string, string> | [
        key: string,
        value: string
    ][]);
    get(param0: string): string | null;
    getAll(param0: string): string[];
    has(param0: string): boolean;
    set(param0: string, param1: string): void;
    append(param0: string, param1: string): void;
    delete(param0: string): void;
    forEach<This = unknown>(callback: (this: This, value: string, key: string, parent: Headers) => void, thisArg?: This): void;
    entries(): IterableIterator<[
        key: string,
        value: string
    ]>;
    keys(): IterableIterator<string>;
    values(): IterableIterator<string>;
    [Symbol.iterator](): IterableIterator<[
        key: string,
        value: string
    ]>;
}
TypeScript Details 

Types of construct signatures are incompatible.
  Type 'new (init?: HeadersInit) => Headers' is not assignable to type 'new (init?: Record<string, string> | Headers | [key: string, value: string][]) => Headers'.
    Property 'getAll' is missing in type 'DOM.Headers' but required in type 'CfWorker.Headers'.

Headers.prototype.[Symbol.iterator]()

Standards:

[Symbol.iterator](): IterableIterator<[
    string,
    string
]>;

Workers:

[Symbol.iterator](): IterableIterator<[
    key: string,
    value: string
]>;
TypeScript Details 

Property '[Symbol.iterator]' does not exist on type 'Headers'.

return Headers.prototype.[Symbol.iterator]()

Standards:

[Symbol.iterator](): IterableIterator<[
    string,
    string
]>;

Workers:

[Symbol.iterator](): IterableIterator<[
    key: string,
    value: string
]>;
TypeScript Details 

Property '[Symbol.iterator]' does not exist on type 'Headers'.

Headers.prototype.get()

Standards:

never

Workers:

get(param0: string): string | null;
TypeScript Details 

Type '(param0: string) => string' is not assignable to type 'never'.

Headers.prototype.getAll()

Standards:

never

Workers:

getAll(param0: string): string[];
TypeScript Details 

Type '(param0: string) => string[]' is not assignable to type 'never'.

Headers.prototype.has()

Standards:

never

Workers:

has(param0: string): boolean;
TypeScript Details 

Type '(param0: string) => boolean' is not assignable to type 'never'.

Headers.prototype.set()

Standards:

never

Workers:

set(param0: string, param1: string): void;
TypeScript Details 

Type '(param0: string, param1: string) => void' is not assignable to type 'never'.

Headers.prototype.append()

Standards:

never

Workers:

append(param0: string, param1: string): void;
TypeScript Details 

Type '(param0: string, param1: string) => void' is not assignable to type 'never'.

Headers.prototype.delete()

Standards:

never

Workers:

delete(param0: string): void;
TypeScript Details 

Type '(param0: string) => void' is not assignable to type 'never'.

Headers.prototype.forEach()

Standards:

never

Workers:

forEach<This = unknown>(callback: (this: This, value: string, key: string, parent: Headers) => void, thisArg?: This): void;
TypeScript Details 

Type '<This = unknown>(callback: (this: This, value: string, key: string, parent: Headers) => void, thisArg?: This) => void' is not assignable to type 'never'.

new Headers(init)

Standards:

init?: HeadersInit

Workers:

init?: Headers | Record<string, string> | [
    key: string,
    value: string
][]
TypeScript Details 

Type 'HeadersInit' is not assignable to type 'Record<string, string> | Headers | [key: string, value: string][]'.
  Type 'Headers' is not assignable to type 'Record<string, string> | Headers | [key: string, value: string][]'.
    Type 'DOM.Headers' is not assignable to type 'CfWorker.Headers'.

class Response

Standards:

Response: {
    prototype: Response;
    new (body?: BodyInit | null, init?: ResponseInit): Response;
    error(): Response;
    redirect(url: string | URL, status?: number): Response;
}

Workers:

export declare class Response extends Body {
    constructor(param0?: (ReadableStream | string | (ArrayBuffer | ArrayBufferView) | Blob | URLSearchParams | FormData) | null, param1?: ResponseInitializerDict | Response);
    static redirect(param0: string, param1?: number): Response;
    static json(param0: any, param1?: ResponseInitializerDict | Response): Response;
    clone(): Response;
    get status(): number;
    get statusText(): string;
    get headers(): Headers;
    get ok(): boolean;
    get redirected(): boolean;
    get url(): string;
    get webSocket(): WebSocket | null;
    get cf(): any | undefined;
}
TypeScript Details 

Property 'error' is missing in type 'typeof Response' but required in type '{ new (body?: BodyInit, init?: ResponseInit): Response; prototype: Response; error(): Response; redirect(url: string | URL, status?: number): Response; }'.

Response.prototype.headers

Standards:

readonly headers: Headers;

Workers:

get headers(): Headers;
TypeScript Details 

Type 'DOM.Headers' is not assignable to type 'CfWorker.Headers'.

Response.prototype.type

Standards:

readonly type: ResponseType;

Workers:

never
TypeScript Details 

Type 'string' is not assignable to type 'never'.
  Type 'string' is not assignable to type 'never'.

Response.prototype.webSocket

Standards:

never

Workers:

get webSocket(): WebSocket | null;
TypeScript Details 

Type 'WebSocket' is not assignable to type 'never'.

Response.prototype.cf

Standards:

never

Workers:

get cf(): any | undefined;
TypeScript Details 

Type 'any' is not assignable to type 'never'.

Response.redirect()

Standards:

redirect(url: string | URL, status?: number): Response;

Workers:

static redirect(param0: string, param1?: number): Response;
TypeScript Details 

Type '(param0: string, param1?: number) => Response' is not assignable to type '(url: string | URL, status?: number) => Response'.
  Property 'type' is missing in type 'CfWorker.Response' but required in type 'DOM.Response'.

Response.prototype.redirect(url)

Standards:

url: string | URL

Workers:

param0: string
TypeScript Details 

Property 'redirect' does not exist on type 'Response'.

Response.prototype.redirect(status)

Standards:

status?: number

Workers:

param1?: number
TypeScript Details 

Property 'redirect' does not exist on type 'Response'.

Response.prototype.clone()

Standards:

clone(): Response;

Workers:

clone(): Response;
TypeScript Details 

Type '() => CfWorker.Response' is not assignable to type '() => DOM.Response'.
  Type 'CfWorker.Response' is not assignable to type 'DOM.Response'.

Response.error()

Standards:

error(): Response;

Workers:

never
TypeScript Details 

Type '() => Response' is not assignable to type 'never'.

Response.json()

Standards:

never

Workers:

static json(param0: any, param1?: ResponseInitializerDict | Response): Response;
TypeScript Details 

Type '(param0: any, param1?: Response | ResponseInitializerDict) => Response' is not assignable to type 'never'.

new Response(body)

Standards:

body?: BodyInit | null

Workers:

param0?: (ReadableStream | string | (ArrayBuffer | ArrayBufferView) | Blob | URLSearchParams | FormData) | null
TypeScript Details 

Type 'string | ArrayBuffer | ArrayBufferView | URLSearchParams | Blob | FormData | ReadableStream<any>' is not assignable to type 'BodyInit'.
  Type 'Blob' is not assignable to type 'BodyInit'.
    Type 'CfWorker.Blob' is not assignable to type 'DOM.Blob'.

new Response(init)

Standards:

init?: ResponseInit

Workers:

param1?: ResponseInitializerDict | Response
TypeScript Details 

Type 'Response | ResponseInitializerDict' is not assignable to type 'ResponseInit'.
  Type 'ResponseInitializerDict' is not assignable to type 'ResponseInit'.
    Types of property 'headers' are incompatible.
      Type 'Record<string, string> | string[][] | Headers' is not assignable to type 'HeadersInit'.
        Type 'string[][]' is not assignable to type 'HeadersInit'.
          Type 'string[][]' is not assignable to type '[string, string][]'.
            Type 'string[]' is not assignable to type '[string, string]'.
              Target requires 2 element(s) but source may have fewer.

class Request

Standards:

Request: {
    prototype: Request;
    new (input: RequestInfo | URL, init?: RequestInit): Request;
}

Workers:

export declare class Request extends Body {
    constructor(param0: Request | string, param1?: RequestInitializerDict | Request);
    clone(): Request;
    get method(): string;
    get url(): string;
    get headers(): Headers;
    get redirect(): string;
    get fetcher(): Fetcher | null;
    get signal(): AbortSignal;
    get cf(): any | undefined;
}
TypeScript Details 

Type 'typeof Request' is not assignable to type '{ new (input: RequestInfo | URL, init?: RequestInit): Request; prototype: Request; }'.
  Types of property 'prototype' are incompatible.
    Type 'CfWorker.Request' is not assignable to type 'DOM.Request'.

Request.prototype.headers

Standards:

/** Returns a Headers object consisting of the headers associated with request. Note that headers added in the network layer by the user agent will not be accounted for in this object, e.g., the "Host" header. */
readonly headers: Headers;

Workers:

get headers(): Headers;
TypeScript Details 

Type 'DOM.Headers' is not assignable to type 'CfWorker.Headers'.

Request.prototype.redirect

Standards:

/** Returns the redirect mode associated with request, which is a string indicating how redirects for the request will be handled during fetching. A request will follow redirects by default. */
readonly redirect: RequestRedirect;

Workers:

get redirect(): string;
TypeScript Details 

Type 'string' is not assignable to type 'RequestRedirect'.

Request.prototype.signal

Standards:

/** Returns the signal associated with request, which is an AbortSignal object indicating whether or not request has been aborted, and its abort event handler. */
readonly signal: AbortSignal;

Workers:

get signal(): AbortSignal;
TypeScript Details 

Type 'CfWorker.AbortSignal' is not assignable to type 'DOM.AbortSignal'.

Request.prototype.cache

Standards:

/** Returns the cache mode associated with request, which is a string indicating how the request will interact with the browser's cache when fetching. */
readonly cache: RequestCache;

Workers:

never
TypeScript Details 

Type 'string' is not assignable to type 'never'.
  Type 'string' is not assignable to type 'never'.

Request.prototype.credentials

Standards:

/** Returns the credentials mode associated with request, which is a string indicating whether credentials will be sent with the request always, never, or only when sent to a same-origin URL. */
readonly credentials: RequestCredentials;

Workers:

never
TypeScript Details 

Type 'string' is not assignable to type 'never'.
  Type 'string' is not assignable to type 'never'.

Request.prototype.destination

Standards:

/** Returns the kind of resource requested by request, e.g., "document" or "script". */
readonly destination: RequestDestination;

Workers:

never
TypeScript Details 

Type 'string' is not assignable to type 'never'.
  Type 'string' is not assignable to type 'never'.

Request.prototype.integrity

Standards:

/** Returns request's subresource integrity metadata, which is a cryptographic hash of the resource being fetched. Its value consists of multiple hashes separated by whitespace. [SRI] */
readonly integrity: string;

Workers:

never
TypeScript Details 

Type 'string' is not assignable to type 'never'.

Request.prototype.keepalive

Standards:

/** Returns a boolean indicating whether or not request can outlive the global in which it was created. */
readonly keepalive: boolean;

Workers:

never
TypeScript Details 

Type 'boolean' is not assignable to type 'never'.

Request.prototype.mode

Standards:

/** Returns the mode associated with request, which is a string indicating whether the request will use CORS, or will be restricted to same-origin URLs. */
readonly mode: RequestMode;

Workers:

never
TypeScript Details 

Type 'string' is not assignable to type 'never'.
  Type 'string' is not assignable to type 'never'.

Request.prototype.referrer

Standards:

/** Returns the referrer of request. Its value can be a same-origin URL if explicitly set in init, the empty string to indicate no referrer, and "about:client" when defaulting to the global's default. This is used during fetching to determine the value of the `Referer` header of the request being made. */
readonly referrer: string;

Workers:

never
TypeScript Details 

Type 'string' is not assignable to type 'never'.

Request.prototype.referrerPolicy

Standards:

/** Returns the referrer policy associated with request. This is used during fetching to compute the value of the request's referrer. */
readonly referrerPolicy: ReferrerPolicy;

Workers:

never
TypeScript Details 

Type 'string' is not assignable to type 'never'.
  Type 'string' is not assignable to type 'never'.

Request.prototype.fetcher

Standards:

never

Workers:

get fetcher(): Fetcher | null;
TypeScript Details 

Type 'Fetcher' is not assignable to type 'never'.

Request.prototype.cf

Standards:

never

Workers:

get cf(): any | undefined;
TypeScript Details 

Type 'any' is not assignable to type 'never'.

Request.prototype.clone()

Standards:

clone(): Request;

Workers:

clone(): Request;
TypeScript Details 

Type '() => CfWorker.Request' is not assignable to type '() => DOM.Request'.
  Type 'CfWorker.Request' is not assignable to type 'DOM.Request'.

new Request(input)

Standards:

input: RequestInfo | URL

Workers:

param0: Request | string
TypeScript Details 

Type 'string | Request' is not assignable to type 'RequestInfo | URL'.

new Request(init)

Standards:

init?: RequestInit

Workers:

param1?: RequestInitializerDict | Request
TypeScript Details 

Type 'Request | RequestInitializerDict' is not assignable to type 'RequestInit'.
  Type 'Request' is not assignable to type 'RequestInit'.
    Types of property 'body' are incompatible.
      Type 'ReadableStream<any>' is not assignable to type 'BodyInit'.
        Type 'CfWorker.ReadableStream<any>' is not assignable to type 'DOM.ReadableStream<any>'.
          The types of 'getReader().closed' are incompatible between these types.
            Type 'Promise<void>' is not assignable to type 'Promise<undefined>'.

class ReadableStream

Standards:

ReadableStream: {
    prototype: ReadableStream;
    new <R = any>(underlyingSource?: UnderlyingSource<R>, strategy?: QueuingStrategy<R>): ReadableStream<R>;
}

Workers:

export declare class ReadableStream<R = any> {
    constructor(param0?: UnderlyingSource, param1?: QueuingStrategy);
    get locked(): boolean;
    cancel(param0?: any): Promise<void>;
    getReader(): ReadableStreamDefaultReader<R>;
    getReader(options: ReadableStreamGetReaderOptions): ReadableStreamBYOBReader;
    pipeThrough<T>(transform: ReadableWritablePair<T, R>, options?: StreamPipeOptions): ReadableStream<T>;
    pipeTo(destination: WritableStream<R>, options?: StreamPipeOptions): Promise<void>;
    tee(): [
        ReadableStream<R>,
        ReadableStream<R>
    ];
    values(options?: ReadableStreamValuesOptions): AsyncIterableIterator<R>;
    [Symbol.asyncIterator](options?: ReadableStreamValuesOptions): AsyncIterableIterator<R>;
}
TypeScript Details 

Type 'typeof ReadableStream' is not assignable to type '{ new <R = any>(underlyingSource?: UnderlyingSource<R>, strategy?: QueuingStrategy<R>): ReadableStream<R>; prototype: ReadableStream<any>; }'.
  Types of property 'prototype' are incompatible.
    Type 'CfWorker.ReadableStream<any>' is not assignable to type 'DOM.ReadableStream<any>'.

ReadableStream.prototype.getReader()

Standards:

getReader(): ReadableStreamDefaultReader<R>;

Workers:

getReader(options: ReadableStreamGetReaderOptions): ReadableStreamBYOBReader;
TypeScript Details 

Type '{ (): ReadableStreamDefaultReader<any>; (options: ReadableStreamGetReaderOptions): ReadableStreamBYOBReader; }' is not assignable to type '() => ReadableStreamDefaultReader<any>'.

ReadableStream.prototype.getReader(options)

Standards:

never

Workers:

options: ReadableStreamGetReaderOptions
TypeScript Details 

Type 'ReadableStreamGetReaderOptions' is not assignable to type 'never'.

ReadableStream.prototype.pipeThrough()

Standards:

pipeThrough<T>(transform: ReadableWritablePair<T, R>, options?: StreamPipeOptions): ReadableStream<T>;

Workers:

pipeThrough<T>(transform: ReadableWritablePair<T, R>, options?: StreamPipeOptions): ReadableStream<T>;
TypeScript Details 

Type '<T>(transform: CfWorker.ReadableWritablePair<T, any>, options?: CfWorker.StreamPipeOptions) => CfWorker.ReadableStream<T>' is not assignable to type '<T>(transform: DOM.ReadableWritablePair<T, any>, options?: DOM.StreamPipeOptions) => DOM.ReadableStream<T>'.
  Types of parameters 'transform' and 'transform' are incompatible.
    Type 'DOM.ReadableWritablePair<T, any>' is not assignable to type 'CfWorker.ReadableWritablePair<T, any>'.
      Types of property 'readable' are incompatible.
        Type 'ReadableStream<T>' is missing the following properties from type 'ReadableStream<T>': values, [Symbol.asyncIterator]

ReadableStream.prototype.pipeThrough(transform)

Standards:

transform: ReadableWritablePair<T, R>

Workers:

transform: ReadableWritablePair<T, R>
TypeScript Details 

Type 'CfWorker.ReadableWritablePair<unknown, any>' is not assignable to type 'DOM.ReadableWritablePair<unknown, any>'.
  The types of 'readable.getReader().closed' are incompatible between these types.
    Type 'Promise<void>' is not assignable to type 'Promise<undefined>'.

ReadableStream.prototype.pipeThrough(options)

Standards:

options?: StreamPipeOptions

Workers:

options?: StreamPipeOptions
TypeScript Details 

Type 'CfWorker.StreamPipeOptions' is not assignable to type 'DOM.StreamPipeOptions'.
  Types of property 'signal' are incompatible.
    Type 'CfWorker.AbortSignal' is not assignable to type 'DOM.AbortSignal'.

ReadableStream.prototype.pipeTo(destination)

Standards:

destination: WritableStream<R>

Workers:

destination: WritableStream<R>
TypeScript Details 

Type 'CfWorker.WritableStream<any>' is not assignable to type 'DOM.WritableStream<any>'.
  The types of 'getWriter().closed' are incompatible between these types.
    Type 'Promise<void>' is not assignable to type 'Promise<undefined>'.

ReadableStream.prototype.pipeTo(options)

Standards:

options?: StreamPipeOptions

Workers:

options?: StreamPipeOptions
TypeScript Details 

Type 'CfWorker.StreamPipeOptions' is not assignable to type 'DOM.StreamPipeOptions'.

ReadableStream.prototype.tee()

Standards:

tee(): [
    ReadableStream<R>,
    ReadableStream<R>
];

Workers:

tee(): [
    ReadableStream<R>,
    ReadableStream<R>
];
TypeScript Details 

Type '() => [CfWorker.ReadableStream<any>, CfWorker.ReadableStream<any>]' is not assignable to type '() => [DOM.ReadableStream<any>, DOM.ReadableStream<any>]'.
  Call signature return types '[ReadableStream<any>, ReadableStream<any>]' and '[ReadableStream<any>, ReadableStream<any>]' are incompatible.
    Type 'CfWorker.ReadableStream<any>' is not assignable to type 'DOM.ReadableStream<any>'.

ReadableStream.prototype.values()

Standards:

never

Workers:

values(options?: ReadableStreamValuesOptions): AsyncIterableIterator<R>;
TypeScript Details 

Type '(options?: ReadableStreamValuesOptions) => AsyncIterableIterator<any>' is not assignable to type 'never'.

ReadableStream.prototype.[Symbol.asyncIterator]()

Standards:

never

Workers:

[Symbol.asyncIterator](options?: ReadableStreamValuesOptions): AsyncIterableIterator<R>;
TypeScript Details 

Property '[Symbol.asyncIterator]' does not exist on type 'ReadableStream<any>'.

new ReadableStream(underlyingSource)

Standards:

underlyingSource?: UnderlyingSource<R>

Workers:

param0?: UnderlyingSource
TypeScript Details 

Type 'UnderlyingSource<any>' is not assignable to type 'UnderlyingSource<unknown>'.
  Types of property 'type' are incompatible.
    Type 'string' is not assignable to type 'undefined'.

new ReadableStream(strategy)

Standards:

strategy?: QueuingStrategy<R>

Workers:

param1?: QueuingStrategy
TypeScript Details 

Type 'QueuingStrategy<any>' is not assignable to type 'QueuingStrategy<unknown>'.
  Types of property 'highWaterMark' are incompatible.
    Type 'number | bigint' is not assignable to type 'number'.
      Type 'bigint' is not assignable to type 'number'.

class ReadableStreamDefaultReader

Standards:

ReadableStreamDefaultReader: {
    prototype: ReadableStreamDefaultReader;
    new <R = any>(stream: ReadableStream<R>): ReadableStreamDefaultReader<R>;
}

Workers:

export declare class ReadableStreamDefaultReader<R = any> {
    constructor(param0: ReadableStream);
    get closed(): Promise<void>;
    cancel(param0?: any): Promise<void>;
    read(): Promise<ReadableStreamReadResult<R>>;
    releaseLock(): void;
}
TypeScript Details 

Type 'typeof ReadableStreamDefaultReader' is not assignable to type '{ new <R = any>(stream: ReadableStream<R>): ReadableStreamDefaultReader<R>; prototype: ReadableStreamDefaultReader<any>; }'.
  Types of property 'prototype' are incompatible.
    Type 'CfWorker.ReadableStreamDefaultReader<any>' is not assignable to type 'DOM.ReadableStreamDefaultReader<any>'.

ReadableStreamDefaultReader.prototype.closed

Standards:

never

Workers:

get closed(): Promise<void>;
TypeScript Details 

Type 'Promise<void>' is not assignable to type 'never'.

ReadableStreamDefaultReader.prototype.cancel()

Standards:

never

Workers:

cancel(param0?: any): Promise<void>;
TypeScript Details 

Type '(param0?: any) => Promise<void>' is not assignable to type 'never'.

new ReadableStreamDefaultReader(stream)

Standards:

stream: ReadableStream<R>

Workers:

param0: ReadableStream
TypeScript Details 

Type 'ReadableStream<any>' is not assignable to type 'ReadableStream<unknown>'.
  The types of 'getReader().closed' are incompatible between these types.
    Type 'Promise<void>' is not assignable to type 'Promise<undefined>'.

class ReadableStreamBYOBReader

Standards:

ReadableStreamBYOBReader: {
    prototype: ReadableStreamBYOBReader;
    new (stream: ReadableStream): ReadableStreamBYOBReader;
}

Workers:

export declare class ReadableStreamBYOBReader {
    constructor(param0: ReadableStream);
    get closed(): Promise<void>;
    cancel(param0?: any): Promise<void>;
    read<T extends ArrayBufferView>(view: T): Promise<ReadableStreamReadResult<T>>;
    releaseLock(): void;
    readAtLeast(minBytes: number, view: Uint8Array): Promise<ReadableStreamReadResult<Uint8Array>>;
}
TypeScript Details 

Type 'typeof ReadableStreamBYOBReader' is not assignable to type '{ new (stream: ReadableStream<any>): ReadableStreamBYOBReader; prototype: ReadableStreamBYOBReader; }'.
  The types of 'prototype.closed' are incompatible between these types.
    Type 'Promise<void>' is not assignable to type 'Promise<undefined>'.

ReadableStreamBYOBReader.prototype.closed

Standards:

never

Workers:

get closed(): Promise<void>;
TypeScript Details 

Type 'Promise<void>' is not assignable to type 'never'.

ReadableStreamBYOBReader.prototype.read()

Standards:

read(view: ArrayBufferView): Promise<ReadableStreamReadResult<ArrayBufferView>>;

Workers:

read<T extends ArrayBufferView>(view: T): Promise<ReadableStreamReadResult<T>>;
TypeScript Details 

Type '(view: ArrayBufferView) => Promise<ReadableStreamReadResult<ArrayBufferView>>' is not assignable to type '<T extends ArrayBufferView>(view: T) => Promise<ReadableStreamReadResult<T>>'.
  Type 'Promise<ReadableStreamReadResult<ArrayBufferView>>' is not assignable to type 'Promise<ReadableStreamReadResult<T>>'.
    Type 'ReadableStreamReadResult<ArrayBufferView>' is not assignable to type 'ReadableStreamReadResult<T>'.
      Type 'ReadableStreamReadValueResult<ArrayBufferView>' is not assignable to type 'ReadableStreamReadResult<T>'.
        Type 'ReadableStreamReadValueResult<ArrayBufferView>' is not assignable to type '{ done: false; value: T; }'.
          Types of property 'value' are incompatible.
            Type 'ArrayBufferView' is not assignable to type 'T'.
              'ArrayBufferView' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint 'ArrayBufferView'.

ReadableStreamBYOBReader.prototype.cancel()

Standards:

never

Workers:

cancel(param0?: any): Promise<void>;
TypeScript Details 

Type '(param0?: any) => Promise<void>' is not assignable to type 'never'.

ReadableStreamBYOBReader.prototype.readAtLeast()

Standards:

never

Workers:

readAtLeast(minBytes: number, view: Uint8Array): Promise<ReadableStreamReadResult<Uint8Array>>;
TypeScript Details 

Type '(minBytes: number, view: Uint8Array) => Promise<ReadableStreamReadResult<Uint8Array>>' is not assignable to type 'never'.

new ReadableStreamBYOBReader(stream)

Standards:

stream: ReadableStream

Workers:

param0: ReadableStream
TypeScript Details 

Type 'CfWorker.ReadableStream<any>' is not assignable to type 'DOM.ReadableStream<any>'.

class ReadableStreamBYOBRequest

Standards:

ReadableStreamBYOBRequest: {
    prototype: ReadableStreamBYOBRequest;
    new (): ReadableStreamBYOBRequest;
}

Workers:

export declare abstract class ReadableStreamBYOBRequest {
    readonly view: Uint8Array | null;
    respond(param0: number): void;
    respondWithNewView(param0: ArrayBuffer | ArrayBufferView): void;
    readonly atLeast: number | null;
}
TypeScript Details 

Type 'typeof ReadableStreamBYOBRequest' is not assignable to type '{ new (): ReadableStreamBYOBRequest; prototype: ReadableStreamBYOBRequest; }'.
  Cannot assign an abstract constructor type to a non-abstract constructor type.

ReadableStreamBYOBRequest.prototype.view

Standards:

readonly view: ArrayBufferView | null;

Workers:

readonly view: Uint8Array | null;
TypeScript Details 

Type 'ArrayBufferView' is missing the following properties from type 'Uint8Array': BYTES_PER_ELEMENT, copyWithin, every, fill, and 24 more.

ReadableStreamBYOBRequest.prototype.atLeast

Standards:

never

Workers:

readonly atLeast: number | null;
TypeScript Details 

Type 'number' is not assignable to type 'never'.

ReadableStreamBYOBRequest.prototype.respondWithNewView(view)

Standards:

view: ArrayBufferView

Workers:

param0: ArrayBuffer | ArrayBufferView
TypeScript Details 

Type 'ArrayBuffer | ArrayBufferView' is not assignable to type 'ArrayBufferView'.
  Type 'ArrayBuffer' is missing the following properties from type 'ArrayBufferView': buffer, byteOffset

class ReadableStreamDefaultController

Standards:

ReadableStreamDefaultController: {
    prototype: ReadableStreamDefaultController;
    new (): ReadableStreamDefaultController;
}

Workers:

export declare abstract class ReadableStreamDefaultController<R = any> {
    readonly desiredSize: number | null;
    close(): void;
    enqueue(chunk?: R): void;
    error(param0: any): void;
}
TypeScript Details 

Type 'typeof ReadableStreamDefaultController' is not assignable to type '{ new (): ReadableStreamDefaultController<any>; prototype: ReadableStreamDefaultController<any>; }'.
  Cannot assign an abstract constructor type to a non-abstract constructor type.

class ReadableByteStreamController

Standards:

ReadableByteStreamController: {
    prototype: ReadableByteStreamController;
    new (): ReadableByteStreamController;
}

Workers:

export declare abstract class ReadableByteStreamController {
    readonly byobRequest: ReadableStreamBYOBRequest | null;
    readonly desiredSize: number | null;
    close(): void;
    enqueue(param0: ArrayBuffer | ArrayBufferView): void;
    error(param0: any): void;
}
TypeScript Details 

Type 'typeof ReadableByteStreamController' is not assignable to type '{ new (): ReadableByteStreamController; prototype: ReadableByteStreamController; }'.
  Cannot assign an abstract constructor type to a non-abstract constructor type.

ReadableByteStreamController.prototype.byobRequest

Standards:

readonly byobRequest: ReadableStreamBYOBRequest | null;

Workers:

readonly byobRequest: ReadableStreamBYOBRequest | null;
TypeScript Details 

Type 'DOM.ReadableStreamBYOBRequest' is not assignable to type 'CfWorker.ReadableStreamBYOBRequest'.

ReadableByteStreamController.prototype.enqueue(chunk)

Standards:

chunk: ArrayBufferView

Workers:

param0: ArrayBuffer | ArrayBufferView
TypeScript Details 

Type 'ArrayBuffer | ArrayBufferView' is not assignable to type 'ArrayBufferView'.
  Type 'ArrayBuffer' is not assignable to type 'ArrayBufferView'.

class WritableStreamDefaultController

Standards:

WritableStreamDefaultController: {
    prototype: WritableStreamDefaultController;
    new (): WritableStreamDefaultController;
}

Workers:

export declare abstract class WritableStreamDefaultController {
    readonly signal: AbortSignal;
    error(param0?: any): void;
}
TypeScript Details 

Type 'typeof WritableStreamDefaultController' is not assignable to type '{ new (): WritableStreamDefaultController; prototype: WritableStreamDefaultController; }'.
  The types of 'prototype.signal' are incompatible between these types.
    Type 'CfWorker.AbortSignal' is not assignable to type 'DOM.AbortSignal'.

WritableStreamDefaultController.prototype.signal

Standards:

readonly signal: AbortSignal;

Workers:

readonly signal: AbortSignal;
TypeScript Details 

Type 'CfWorker.AbortSignal' is not assignable to type 'DOM.AbortSignal'.

class WritableStream

Standards:

WritableStream: {
    prototype: WritableStream;
    new <W = any>(underlyingSink?: UnderlyingSink<W>, strategy?: QueuingStrategy<W>): WritableStream<W>;
}

Workers:

export declare class WritableStream<W = any> {
    constructor(param0?: UnderlyingSink, param1?: QueuingStrategy);
    get locked(): boolean;
    abort(param0?: any): Promise<void>;
    close(): Promise<void>;
    getWriter(): WritableStreamDefaultWriter<W>;
}
TypeScript Details 

Type 'typeof WritableStream' is not assignable to type '{ new <W = any>(underlyingSink?: UnderlyingSink<W>, strategy?: QueuingStrategy<W>): WritableStream<W>; prototype: WritableStream<any>; }'.
  Types of property 'prototype' are incompatible.
    Type 'CfWorker.WritableStream<any>' is not assignable to type 'DOM.WritableStream<any>'.

WritableStream.prototype.getWriter()

Standards:

getWriter(): WritableStreamDefaultWriter<W>;

Workers:

getWriter(): WritableStreamDefaultWriter<W>;
TypeScript Details 

Type '() => CfWorker.WritableStreamDefaultWriter<any>' is not assignable to type '() => DOM.WritableStreamDefaultWriter<any>'.

new WritableStream(underlyingSink)

Standards:

underlyingSink?: UnderlyingSink<W>

Workers:

param0?: UnderlyingSink
TypeScript Details 

Type 'UnderlyingSink<any>' is not assignable to type 'UnderlyingSink<unknown>'.
  Types of property 'type' are incompatible.
    Type 'string' is not assignable to type 'undefined'.

new WritableStream(strategy)

Standards:

strategy?: QueuingStrategy<W>

Workers:

param1?: QueuingStrategy
TypeScript Details 

Type 'QueuingStrategy<any>' is not assignable to type 'QueuingStrategy<unknown>'.

class WritableStreamDefaultWriter

Standards:

WritableStreamDefaultWriter: {
    prototype: WritableStreamDefaultWriter;
    new <W = any>(stream: WritableStream<W>): WritableStreamDefaultWriter<W>;
}

Workers:

export declare class WritableStreamDefaultWriter<W = any> {
    constructor(param0: WritableStream);
    get closed(): Promise<void>;
    get ready(): Promise<void>;
    get desiredSize(): number | null;
    abort(param0?: any): Promise<void>;
    close(): Promise<void>;
    write(chunk?: W): Promise<void>;
    releaseLock(): void;
}
TypeScript Details 

Type 'typeof WritableStreamDefaultWriter' is not assignable to type '{ new <W = any>(stream: WritableStream<W>): WritableStreamDefaultWriter<W>; prototype: WritableStreamDefaultWriter<any>; }'.
  Types of property 'prototype' are incompatible.
    Type 'CfWorker.WritableStreamDefaultWriter<any>' is not assignable to type 'DOM.WritableStreamDefaultWriter<any>'.

WritableStreamDefaultWriter.prototype.closed

Standards:

readonly closed: Promise<undefined>;

Workers:

get closed(): Promise<void>;
TypeScript Details 

Type 'Promise<void>' is not assignable to type 'Promise<undefined>'.

WritableStreamDefaultWriter.prototype.ready

Standards:

readonly ready: Promise<undefined>;

Workers:

get ready(): Promise<void>;
TypeScript Details 

Type 'Promise<void>' is not assignable to type 'Promise<undefined>'.

new WritableStreamDefaultWriter(stream)

Standards:

stream: WritableStream<W>

Workers:

param0: WritableStream
TypeScript Details 

Type 'WritableStream<any>' is not assignable to type 'WritableStream<unknown>'.
  The types of 'getWriter().closed' are incompatible between these types.
    Type 'Promise<void>' is not assignable to type 'Promise<undefined>'.

class TransformStream

Standards:

TransformStream: {
    prototype: TransformStream;
    new <I = any, O = any>(transformer?: Transformer<I, O>, writableStrategy?: QueuingStrategy<I>, readableStrategy?: QueuingStrategy<O>): TransformStream<I, O>;
}

Workers:

export declare class TransformStream<I = any, O = any> {
    constructor(transformer?: Transformer<I, O>, writableStrategy?: QueuingStrategy<I>, readableStrategy?: QueuingStrategy<O>);
    get readable(): ReadableStream<O>;
    get writable(): WritableStream<I>;
}
TypeScript Details 

Type 'typeof TransformStream' is not assignable to type '{ new <I = any, O = any>(transformer?: Transformer<I, O>, writableStrategy?: QueuingStrategy<I>, readableStrategy?: QueuingStrategy<O>): TransformStream<...>; prototype: TransformStream<...>; }'.
  The types of 'prototype.readable' are incompatible between these types.
    Type 'CfWorker.ReadableStream<any>' is not assignable to type 'DOM.ReadableStream<any>'.

TransformStream.prototype.readable

Standards:

readonly readable: ReadableStream<O>;

Workers:

get readable(): ReadableStream<O>;
TypeScript Details 

Type 'CfWorker.ReadableStream<any>' is not assignable to type 'DOM.ReadableStream<any>'.

TransformStream.prototype.writable

Standards:

readonly writable: WritableStream<I>;

Workers:

get writable(): WritableStream<I>;
TypeScript Details 

Type 'CfWorker.WritableStream<any>' is not assignable to type 'DOM.WritableStream<any>'.

new TransformStream(transformer)

Standards:

transformer?: Transformer<I, O>

Workers:

transformer?: Transformer<I, O>
TypeScript Details 

Type 'CfWorker.Transformer<unknown, unknown>' is not assignable to type 'DOM.Transformer<unknown, unknown>'.
  Types of property 'readableType' are incompatible.
    Type 'string' is not assignable to type 'undefined'.

new TransformStream(writableStrategy)

Standards:

writableStrategy?: QueuingStrategy<I>

Workers:

writableStrategy?: QueuingStrategy<I>
TypeScript Details 

Type 'CfWorker.QueuingStrategy<unknown>' is not assignable to type 'DOM.QueuingStrategy<unknown>'.
  Types of property 'highWaterMark' are incompatible.
    Type 'number | bigint' is not assignable to type 'number'.
      Type 'bigint' is not assignable to type 'number'.

new TransformStream(readableStrategy)

Standards:

readableStrategy?: QueuingStrategy<O>

Workers:

readableStrategy?: QueuingStrategy<O>
TypeScript Details 

Type 'CfWorker.QueuingStrategy<unknown>' is not assignable to type 'DOM.QueuingStrategy<unknown>'.

class TextEncoderStream

Standards:

TextEncoderStream: {
    prototype: TextEncoderStream;
    new (): TextEncoderStream;
}

Workers:

export declare class TextEncoderStream extends TransformStream<string, Uint8Array> {
    constructor();
}
TypeScript Details 

Type 'typeof TextEncoderStream' is not assignable to type '{ new (): TextEncoderStream; prototype: TextEncoderStream; }'.
  Types of property 'prototype' are incompatible.
    Property 'encoding' is missing in type 'CfWorker.TextEncoderStream' but required in type 'DOM.TextEncoderStream'.

TextEncoderStream.prototype.readable

Standards:

readonly readable: ReadableStream<Uint8Array>;

Workers:

never
TypeScript Details 

Type 'ReadableStream<Uint8Array>' is not assignable to type 'never'.

TextEncoderStream.prototype.writable

Standards:

readonly writable: WritableStream<string>;

Workers:

never
TypeScript Details 

Type 'WritableStream<string>' is not assignable to type 'never'.

class TextDecoderStream

Standards:

TextDecoderStream: {
    prototype: TextDecoderStream;
    new (label?: string, options?: TextDecoderOptions): TextDecoderStream;
}

Workers:

export declare class TextDecoderStream extends TransformStream<ArrayBuffer | ArrayBufferView, string> {
    constructor(param0?: string, param1?: TextDecoderStreamTextDecoderStreamInit);
}
TypeScript Details 

Type 'typeof TextDecoderStream' is not assignable to type '{ new (label?: string, options?: TextDecoderOptions): TextDecoderStream; prototype: TextDecoderStream; }'.
  Types of property 'prototype' are incompatible.
    Type 'TextDecoderStream' is missing the following properties from type 'TextDecoderStream': encoding, fatal, ignoreBOM

TextDecoderStream.prototype.readable

Standards:

readonly readable: ReadableStream<string>;

Workers:

never
TypeScript Details 

Type 'ReadableStream<string>' is not assignable to type 'never'.

TextDecoderStream.prototype.writable

Standards:

readonly writable: WritableStream<BufferSource>;

Workers:

never
TypeScript Details 

Type 'WritableStream<BufferSource>' is not assignable to type 'never'.

class URL

Standards:

URL: {
    prototype: URL;
    new (url: string | URL, base?: string | URL): URL;
    createObjectURL(obj: Blob | MediaSource): string;
    revokeObjectURL(url: string): void;
}

Workers:

export declare class URL {
    constructor(param0: string, param1?: string);
    get origin(): string;
    get href(): string;
    set href(value: string);
    get protocol(): string;
    set protocol(value: string);
    get username(): string;
    set username(value: string);
    get password(): string;
    set password(value: string);
    get host(): string;
    set host(value: string);
    get hostname(): string;
    set hostname(value: string);
    get port(): string;
    set port(value: string);
    get pathname(): string;
    set pathname(value: string);
    get search(): string;
    set search(value: string);
    get hash(): string;
    set hash(value: string);
    get searchParams(): URLSearchParams;
    toJSON(): string;
    toString(): string;
}
TypeScript Details 

Type 'typeof URL' is missing the following properties from type '{ new (url: string | URL, base?: string | URL): URL; prototype: URL; createObjectURL(obj: Blob | MediaSource): string; revokeObjectURL(url: string): void; }': createObjectURL, revokeObjectURL

URL.createObjectURL()

Standards:

createObjectURL(obj: Blob | MediaSource): string;

Workers:

never
TypeScript Details 

Type '(obj: Blob | MediaSource) => string' is not assignable to type 'never'.

URL.revokeObjectURL()

Standards:

revokeObjectURL(url: string): void;

Workers:

never
TypeScript Details 

Type '(url: string) => void' is not assignable to type 'never'.

new URL(url)

Standards:

url: string | URL

Workers:

param0: string
TypeScript Details 

Type 'string | URL' is not assignable to type 'string'.
  Type 'URL' is not assignable to type 'string'.

new URL(base)

Standards:

base?: string | URL

Workers:

param1?: string
TypeScript Details 

Type 'string | URL' is not assignable to type 'string'.
  Type 'URL' is not assignable to type 'string'.

URLSearchParams.prototype.[Symbol.iterator]()

Standards:

[Symbol.iterator](): IterableIterator<[
    string,
    string
]>;

Workers:

[Symbol.iterator](): IterableIterator<[
    key: string,
    value: string
]>;
TypeScript Details 

Property '[Symbol.iterator]' does not exist on type 'URLSearchParams'.

return URLSearchParams.prototype.[Symbol.iterator]()

Standards:

[Symbol.iterator](): IterableIterator<[
    string,
    string
]>;

Workers:

[Symbol.iterator](): IterableIterator<[
    key: string,
    value: string
]>;
TypeScript Details 

Property '[Symbol.iterator]' does not exist on type 'URLSearchParams'.

URLSearchParams.prototype.append()

Standards:

never

Workers:

append(param0: string, param1: string): void;
TypeScript Details 

Type '(param0: string, param1: string) => void' is not assignable to type 'never'.

URLSearchParams.prototype.delete()

Standards:

never

Workers:

delete(param0: string): void;
TypeScript Details 

Type '(param0: string) => void' is not assignable to type 'never'.

URLSearchParams.prototype.get()

Standards:

never

Workers:

get(param0: string): string | null;
TypeScript Details 

Type '(param0: string) => string' is not assignable to type 'never'.

URLSearchParams.prototype.getAll()

Standards:

never

Workers:

getAll(param0: string): string[];
TypeScript Details 

Type '(param0: string) => string[]' is not assignable to type 'never'.

URLSearchParams.prototype.has()

Standards:

never

Workers:

has(param0: string): boolean;
TypeScript Details 

Type '(param0: string) => boolean' is not assignable to type 'never'.

URLSearchParams.prototype.set()

Standards:

never

Workers:

set(param0: string, param1: string): void;
TypeScript Details 

Type '(param0: string, param1: string) => void' is not assignable to type 'never'.

URLSearchParams.prototype.sort()

Standards:

never

Workers:

sort(): void;
TypeScript Details 

Type '() => void' is not assignable to type 'never'.

URLSearchParams.prototype.forEach()

Standards:

never

Workers:

forEach<This = unknown>(callback: (this: This, value: string, key: string, parent: URLSearchParams) => void, thisArg?: This): void;
TypeScript Details 

Type '<This = unknown>(callback: (this: This, value: string, key: string, parent: URLSearchParams) => void, thisArg?: This) => void' is not assignable to type 'never'.

new URLSearchParams(init)

Standards:

init?: string[][] | Record<string, string> | string | URLSearchParams

Workers:

param0?: Iterable<Iterable<string>> | Record<string, string> | string
TypeScript Details 

Type 'string | Record<string, string> | Iterable<Iterable<string>>' is not assignable to type 'string | Record<string, string> | URLSearchParams | string[][]'.
  Type 'Iterable<Iterable<string>>' is not assignable to type 'string | Record<string, string> | URLSearchParams | string[][]'.
    Type 'Iterable<Iterable<string>>' is missing the following properties from type 'string[][]': length, pop, push, concat, and 28 more.

class CloseEvent

Standards:

CloseEvent: {
    prototype: CloseEvent;
    new (type: string, eventInitDict?: CloseEventInit): CloseEvent;
}

Workers:

export declare class CloseEvent extends Event {
    constructor(param0: string, param1: CloseEventInit);
    readonly code: number;
    readonly reason: string;
    readonly wasClean: boolean;
}
TypeScript Details 

Type 'typeof CloseEvent' is not assignable to type '{ new (type: string, eventInitDict?: CloseEventInit): CloseEvent; prototype: CloseEvent; }'.
  Types of property 'prototype' are incompatible.
    Type 'CloseEvent' is missing the following properties from type 'CloseEvent': target, initEvent, AT_TARGET, BUBBLING_PHASE, and 2 more.

class MessageEvent

Standards:

MessageEvent: {
    prototype: MessageEvent;
    new <T>(type: string, eventInitDict?: MessageEventInit<T>): MessageEvent<T>;
}

Workers:

export declare class MessageEvent extends Event {
    constructor(param0: string, param1: MessageEventInit);
    readonly data: ArrayBuffer | string;
}
TypeScript Details 

Type 'typeof MessageEvent' is not assignable to type '{ new <T>(type: string, eventInitDict?: MessageEventInit<T>): MessageEvent<T>; prototype: MessageEvent<any>; }'.
  Types of property 'prototype' are incompatible.
    Type 'MessageEvent' is missing the following properties from type 'MessageEvent<any>': lastEventId, origin, ports, source, and 7 more.

MessageEvent.prototype.data

Standards:

never

Workers:

readonly data: ArrayBuffer | string;
TypeScript Details 

Type 'string | ArrayBuffer' is not assignable to type 'never'.
  Type 'string' is not assignable to type 'never'.

MessageEvent.prototype.initMessageEvent()

Standards:

/** @deprecated */
initMessageEvent(type: string, bubbles?: boolean, cancelable?: boolean, data?: any, origin?: string, lastEventId?: string, source?: MessageEventSource | null, ports?: Iterable<MessagePort>): void;

Workers:

never
TypeScript Details 

Type '{ (type: string, bubbles?: boolean, cancelable?: boolean, data?: any, origin?: string, lastEventId?: string, source?: MessageEventSource, ports?: MessagePort[]): void; (type: string, bubbles?: boolean, cancelable?: boolean, data?: any, origin?: string, lastEventId?: string, source?: MessageEventSource, ports?: Itera...' is not assignable to type 'never'.

new MessageEvent(eventInitDict)

Standards:

eventInitDict?: MessageEventInit<T>

Workers:

param1: MessageEventInit
TypeScript Details 

Type 'MessageEventInit<unknown>' is not assignable to type 'MessageEventInit'.
  Types of property 'data' are incompatible.
    Type 'unknown' is not assignable to type 'string | ArrayBuffer'.

class WebSocket

Standards:

WebSocket: {
    prototype: WebSocket;
    new (url: string | URL | number, protocols?: string | string[]): WebSocket;
    make(url: string | URL, protocols?: string | string[]): WebSocket;
    makeIt: (url: string | URL, protocols?: string | string[]) => WebSocket;
    readonly CLOSED: number;
    readonly CLOSING: number;
    readonly CONNECTING: number;
    readonly OPEN: number;
}

Workers:

export declare class WebSocket extends EventTarget<WebSocketEventMap> {
    constructor(param0: string, param1?: string[] | string);
    accept(): void;
    send(param0: (ArrayBuffer | ArrayBufferView) | string): void;
    close(param0?: number, param1?: string): void;
    static readonly READY_STATE_CONNECTING: 0;
    static readonly READY_STATE_OPEN: 1;
    static readonly READY_STATE_CLOSING: 2;
    static readonly READY_STATE_CLOSED: 3;
    get readyState(): number;
    get url(): string | null;
    get protocol(): string | null;
    get extensions(): string | null;
}
TypeScript Details 

Type 'typeof WebSocket' is missing the following properties from type '{ new (url: string | number | URL, protocols?: string | string[]): WebSocket; prototype: WebSocket; make(url: string | URL, protocols?: string | string[]): WebSocket; ... 4 more ...; readonly OPEN: number; }': make, makeIt, CLOSED, CLOSING, and 2 more.

WebSocket.prototype.CLOSED

Standards:

readonly CLOSED: number;

Workers:

never
TypeScript Details 

Type 'number' is not assignable to type 'never'.

WebSocket.prototype.CLOSING

Standards:

readonly CLOSING: number;

Workers:

never
TypeScript Details 

Type 'number' is not assignable to type 'never'.

WebSocket.prototype.CONNECTING

Standards:

readonly CONNECTING: number;

Workers:

never
TypeScript Details 

Type 'number' is not assignable to type 'never'.

WebSocket.prototype.OPEN

Standards:

readonly OPEN: number;

Workers:

never
TypeScript Details 

Type 'number' is not assignable to type 'never'.

WebSocket.prototype.binaryType

Standards:

/**
 * Returns a string that indicates how binary data from the WebSocket object is exposed to scripts:
 *
 * Can be set, to change how binary data is returned. The default is "blob".
 */
binaryType: BinaryType;

Workers:

never
TypeScript Details 

Type 'string' is not assignable to type 'never'.
  Type 'string' is not assignable to type 'never'.

WebSocket.prototype.bufferedAmount

Standards:

/**
 * Returns the number of bytes of application data (UTF-8 text and binary data) that have been queued using send() but not yet been transmitted to the network.
 *
 * If the WebSocket connection is closed, this attribute's value will only increase with each call to the send() method. (The number does not reset to zero once the connection closes.)
 */
readonly bufferedAmount: number;

Workers:

never
TypeScript Details 

Type 'number' is not assignable to type 'never'.

WebSocket.prototype.onclose

Standards:

onclose: ((this: WebSocket, ev: CloseEvent) => any) | null;

Workers:

never
TypeScript Details 

Type '(this: WebSocket, ev: CloseEvent) => any' is not assignable to type 'never'.

WebSocket.prototype.onerror

Standards:

onerror: ((this: WebSocket, ev: Event) => any) | null;

Workers:

never
TypeScript Details 

Type '(this: WebSocket, ev: Event) => any' is not assignable to type 'never'.

WebSocket.prototype.onmessage

Standards:

onmessage: ((this: WebSocket, ev: MessageEvent) => any) | null;

Workers:

never
TypeScript Details 

Type '(this: WebSocket, ev: MessageEvent<any>) => any' is not assignable to type 'never'.

WebSocket.prototype.onopen

Standards:

onopen: ((this: WebSocket, ev: Event) => any) | null;

Workers:

never
TypeScript Details 

Type '(this: WebSocket, ev: Event) => any' is not assignable to type 'never'.

WebSocket.READY_STATE_CONNECTING

Standards:

never

Workers:

static readonly READY_STATE_CONNECTING: 0;
TypeScript Details 

Type 'number' is not assignable to type 'never'.

WebSocket.READY_STATE_OPEN

Standards:

never

Workers:

static readonly READY_STATE_OPEN: 1;
TypeScript Details 

Type 'number' is not assignable to type 'never'.

WebSocket.READY_STATE_CLOSING

Standards:

never

Workers:

static readonly READY_STATE_CLOSING: 2;
TypeScript Details 

Type 'number' is not assignable to type 'never'.

WebSocket.READY_STATE_CLOSED

Standards:

never

Workers:

static readonly READY_STATE_CLOSED: 3;
TypeScript Details 

Type 'number' is not assignable to type 'never'.

WebSocket.prototype.send(data)

Standards:

data: string | ArrayBufferLike | Blob | ArrayBufferView

Workers:

param0: (ArrayBuffer | ArrayBufferView) | string
TypeScript Details 

Type 'string | ArrayBufferLike | ArrayBufferView | Blob' is not assignable to type 'string | ArrayBuffer | ArrayBufferView'.
  Type 'Blob' is not assignable to type 'string | ArrayBuffer | ArrayBufferView'.
    Type 'Blob' is missing the following properties from type 'ArrayBuffer': byteLength, [Symbol.toStringTag]

WebSocket.make()

Standards:

make(url: string | URL, protocols?: string | string[]): WebSocket;

Workers:

never
TypeScript Details 

Type '(url: string | URL, protocols?: string | string[]) => WebSocket' is not assignable to type 'never'.

WebSocket.makeIt()

Standards:

makeIt: (url: string | URL, protocols?: string | string[]) => WebSocket;

Workers:

never
TypeScript Details 

Type '(url: string | URL, protocols?: string | string[]) => WebSocket' is not assignable to type 'never'.

WebSocket.prototype.addEventListener()

Standards:

addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;

Workers:

never
TypeScript Details 

Type '{ <K extends keyof WebSocketEventMap>(type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void; (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void; }' is not assignable to type 'never'.

WebSocket.prototype.removeEventListener()

Standards:

removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;

Workers:

never
TypeScript Details 

Type '{ <K extends keyof WebSocketEventMap>(type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any, options?: boolean | EventListenerOptions): void; (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void; }' is not assignable to type 'never'.

WebSocket.prototype.accept()

Standards:

never

Workers:

accept(): void;
TypeScript Details 

Type '() => void' is not assignable to type 'never'.

new WebSocket(url)

Standards:

url: string | URL | number

Workers:

param0: string
TypeScript Details 

Type 'string | number | URL' is not assignable to type 'string'.
  Type 'number' is not assignable to type 'string'.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment