undici-types 7.15.0 → 7.17.0

package/agent.d.ts

@@ -1,4 +1,4 @@
-import { URL } from 'url'
+import { URL } from 'node:url'
 import Pool from './pool'
 import Dispatcher from './dispatcher'
 import TClientStats from './client-stats'
@@ -24,6 +24,7 @@ declare namespace Agent {
     factory?(origin: string | URL, opts: Object): Dispatcher;
 
     interceptors?: { Agent?: readonly Dispatcher.DispatchInterceptor[] } & Pool.Options['interceptors']
+    maxOrigins?: number
   }
 
   export interface DispatchOptions extends Dispatcher.DispatchOptions {

package/api.d.ts

@@ -1,5 +1,5 @@
-import { URL, UrlObject } from 'url'
-import { Duplex } from 'stream'
+import { URL, UrlObject } from 'node:url'
+import { Duplex } from 'node:stream'
 import Dispatcher from './dispatcher'
 
 /** Performs an HTTP request. */

package/balanced-pool.d.ts

@@ -1,6 +1,6 @@
 import Pool from './pool'
 import Dispatcher from './dispatcher'
-import { URL } from 'url'
+import { URL } from 'node:url'
 
 export default BalancedPool
 
@@ -11,6 +11,7 @@ declare class BalancedPool extends Dispatcher {
 
   addUpstream (upstream: string | URL): BalancedPool
   removeUpstream (upstream: string | URL): BalancedPool
+  getUpstream (upstream: string | URL): Pool | undefined
   upstreams: Array<string>
 
   /** `true` after `pool.close()` has been called. */

package/cache-interceptor.d.ts

@@ -38,6 +38,7 @@ declare namespace CacheHandler {
      * @default 'shared'
      */
     type?: 'shared' | 'private'
+
   }
 
   export interface CacheControlDirectives {

package/client.d.ts

@@ -1,4 +1,4 @@
-import { URL } from 'url'
+import { URL } from 'node:url'
 import Dispatcher from './dispatcher'
 import buildConnector from './connector'
 import TClientStats from './client-stats'

package/connector.d.ts

@@ -1,5 +1,5 @@
-import { TLSSocket, ConnectionOptions } from 'tls'
-import { IpcNetConnectOpts, Socket, TcpNetConnectOpts } from 'net'
+import { TLSSocket, ConnectionOptions } from 'node:tls'
+import { IpcNetConnectOpts, Socket, TcpNetConnectOpts } from 'node:net'
 
 export default buildConnector
 declare function buildConnector (options?: buildConnector.BuildOptions): buildConnector.connector

package/diagnostics-channel.d.ts

@@ -1,5 +1,5 @@
-import { Socket } from 'net'
-import { URL } from 'url'
+import { Socket } from 'node:net'
+import { URL } from 'node:url'
 import buildConnector from './connector'
 import Dispatcher from './dispatcher'
 

package/dispatcher.d.ts

@@ -1,7 +1,7 @@
-import { URL } from 'url'
-import { Duplex, Readable, Writable } from 'stream'
-import { EventEmitter } from 'events'
-import { Blob } from 'buffer'
+import { URL } from 'node:url'
+import { Duplex, Readable, Writable } from 'node:stream'
+import { EventEmitter } from 'node:events'
+import { Blob } from 'node:buffer'
 import { IncomingHttpHeaders } from './header'
 import BodyReadable from './readable'
 import { FormData } from './formdata'
@@ -19,30 +19,30 @@ declare class Dispatcher extends EventEmitter {
   /** Dispatches a request. This API is expected to evolve through semver-major versions and is less stable than the preceding higher level APIs. It is primarily intended for library developers who implement higher level APIs on top of this. */
   dispatch (options: Dispatcher.DispatchOptions, handler: Dispatcher.DispatchHandler): boolean
   /** Starts two-way communications with the requested resource. */
-  connect<TOpaque = null>(options: Dispatcher.ConnectOptions<TOpaque>): Promise<Dispatcher.ConnectData<TOpaque>>
   connect<TOpaque = null>(options: Dispatcher.ConnectOptions<TOpaque>, callback: (err: Error | null, data: Dispatcher.ConnectData<TOpaque>) => void): void
+  connect<TOpaque = null>(options: Dispatcher.ConnectOptions<TOpaque>): Promise<Dispatcher.ConnectData<TOpaque>>
   /** Compose a chain of dispatchers */
   compose (dispatchers: Dispatcher.DispatcherComposeInterceptor[]): Dispatcher.ComposedDispatcher
   compose (...dispatchers: Dispatcher.DispatcherComposeInterceptor[]): Dispatcher.ComposedDispatcher
   /** Performs an HTTP request. */
-  request<TOpaque = null>(options: Dispatcher.RequestOptions<TOpaque>): Promise<Dispatcher.ResponseData<TOpaque>>
   request<TOpaque = null>(options: Dispatcher.RequestOptions<TOpaque>, callback: (err: Error | null, data: Dispatcher.ResponseData<TOpaque>) => void): void
+  request<TOpaque = null>(options: Dispatcher.RequestOptions<TOpaque>): Promise<Dispatcher.ResponseData<TOpaque>>
   /** For easy use with `stream.pipeline`. */
   pipeline<TOpaque = null>(options: Dispatcher.PipelineOptions<TOpaque>, handler: Dispatcher.PipelineHandler<TOpaque>): Duplex
   /** A faster version of `Dispatcher.request`. */
-  stream<TOpaque = null>(options: Dispatcher.RequestOptions<TOpaque>, factory: Dispatcher.StreamFactory<TOpaque>): Promise<Dispatcher.StreamData<TOpaque>>
   stream<TOpaque = null>(options: Dispatcher.RequestOptions<TOpaque>, factory: Dispatcher.StreamFactory<TOpaque>, callback: (err: Error | null, data: Dispatcher.StreamData<TOpaque>) => void): void
+  stream<TOpaque = null>(options: Dispatcher.RequestOptions<TOpaque>, factory: Dispatcher.StreamFactory<TOpaque>): Promise<Dispatcher.StreamData<TOpaque>>
   /** Upgrade to a different protocol. */
-  upgrade (options: Dispatcher.UpgradeOptions): Promise<Dispatcher.UpgradeData>
   upgrade (options: Dispatcher.UpgradeOptions, callback: (err: Error | null, data: Dispatcher.UpgradeData) => void): void
+  upgrade (options: Dispatcher.UpgradeOptions): Promise<Dispatcher.UpgradeData>
   /** Closes the client and gracefully waits for enqueued requests to complete before invoking the callback (or returning a promise if no callback is provided). */
-  close (): Promise<void>
   close (callback: () => void): void
+  close (): Promise<void>
   /** Destroy the client abruptly with the given err. All the pending and running requests will be asynchronously aborted and error. Waits until socket is closed before invoking the callback (or returning a promise if no callback is provided). Since this operation is asynchronously dispatched there might still be some progress on dispatched requests. */
-  destroy (): Promise<void>
-  destroy (err: Error | null): Promise<void>
-  destroy (callback: () => void): void
   destroy (err: Error | null, callback: () => void): void
+  destroy (callback: () => void): void
+  destroy (err: Error | null): Promise<void>
+  destroy (): Promise<void>
 
   on (eventName: 'connect', callback: (origin: URL, targets: readonly Dispatcher[]) => void): this
   on (eventName: 'disconnect', callback: (origin: URL, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this

package/errors.d.ts

@@ -49,21 +49,6 @@ declare namespace Errors {
     headers: IncomingHttpHeaders | string[] | null
   }
 
-  export class ResponseStatusCodeError extends UndiciError {
-    constructor (
-      message?: string,
-      statusCode?: number,
-      headers?: IncomingHttpHeaders | string[] | null,
-      body?: null | Record<string, any> | string
-    )
-    name: 'ResponseStatusCodeError'
-    code: 'UND_ERR_RESPONSE_STATUS_CODE'
-    body: null | Record<string, any> | string
-    status: number
-    statusCode: number
-    headers: IncomingHttpHeaders | string[] | null
-  }
-
   /** Passed an invalid argument. */
   export class InvalidArgumentError extends UndiciError {
     name: 'InvalidArgumentError'
@@ -168,4 +153,9 @@ declare namespace Errors {
     name: 'SecureProxyConnectionError'
     code: 'UND_ERR_PRX_TLS'
   }
+
+  class MaxOriginsReachedError extends UndiciError {
+    name: 'MaxOriginsReachedError'
+    code: 'UND_ERR_MAX_ORIGINS_REACHED'
+  }
 }

package/fetch.d.ts

@@ -2,9 +2,9 @@
 // and https://github.com/node-fetch/node-fetch/blob/914ce6be5ec67a8bab63d68510aabf07cb818b6d/index.d.ts (MIT license)
 /// <reference types="node" />
 
-import { Blob } from 'buffer'
-import { URL, URLSearchParams } from 'url'
-import { ReadableStream } from 'stream/web'
+import { Blob } from 'node:buffer'
+import { URL, URLSearchParams } from 'node:url'
+import { ReadableStream } from 'node:stream/web'
 import { FormData } from './formdata'
 import { HeaderRecord } from './header'
 import Dispatcher from './dispatcher'
@@ -207,5 +207,5 @@ export declare class Response extends BodyMixin {
 
   static error (): Response
   static json (data: any, init?: ResponseInit): Response
-  static redirect (url: string | URL, status: ResponseRedirectStatus): Response
+  static redirect (url: string | URL, status?: ResponseRedirectStatus): Response
 }

package/formdata.d.ts

@@ -1,7 +1,7 @@
 // Based on https://github.com/octet-stream/form-data/blob/2d0f0dc371517444ce1f22cdde13f51995d0953a/lib/FormData.ts (MIT)
 /// <reference types="node" />
 
-import { File } from 'buffer'
+import { File } from 'node:buffer'
 import { SpecIterableIterator } from './fetch'
 
 /**

package/h2c-client.d.ts

@@ -1,4 +1,4 @@
-import { URL } from 'url'
+import { URL } from 'node:url'
 import Dispatcher from './dispatcher'
 import buildConnector from './connector'
 

package/index.d.ts

@@ -5,6 +5,7 @@ import Pool from './pool'
 import { RedirectHandler, DecoratorHandler } from './handlers'
 
 import BalancedPool from './balanced-pool'
+import RoundRobinPool from './round-robin-pool'
 import Client from './client'
 import H2CClient from './h2c-client'
 import buildConnector from './connector'
@@ -23,6 +24,12 @@ import RetryAgent from './retry-agent'
 import { request, pipeline, stream, connect, upgrade } from './api'
 import interceptors from './interceptors'
 
+import CacheInterceptor from './cache-interceptor'
+declare const cacheStores: {
+  MemoryCacheStore: typeof CacheInterceptor.MemoryCacheStore;
+  SqliteCacheStore: typeof CacheInterceptor.SqliteCacheStore;
+}
+
 export * from './util'
 export * from './cookies'
 export * from './eventsource'
@@ -36,7 +43,7 @@ export { Interceptable } from './mock-interceptor'
 
 declare function globalThisInstall (): void
 
-export { Dispatcher, BalancedPool, Pool, Client, buildConnector, errors, Agent, request, stream, pipeline, connect, upgrade, setGlobalDispatcher, getGlobalDispatcher, setGlobalOrigin, getGlobalOrigin, interceptors, MockClient, MockPool, MockAgent, SnapshotAgent, MockCallHistory, MockCallHistoryLog, mockErrors, ProxyAgent, EnvHttpProxyAgent, RedirectHandler, DecoratorHandler, RetryHandler, RetryAgent, H2CClient, globalThisInstall as install }
+export { Dispatcher, BalancedPool, RoundRobinPool, Pool, Client, buildConnector, errors, Agent, request, stream, pipeline, connect, upgrade, setGlobalDispatcher, getGlobalDispatcher, setGlobalOrigin, getGlobalOrigin, interceptors, cacheStores, MockClient, MockPool, MockAgent, SnapshotAgent, MockCallHistory, MockCallHistoryLog, mockErrors, ProxyAgent, EnvHttpProxyAgent, RedirectHandler, DecoratorHandler, RetryHandler, RetryAgent, H2CClient, globalThisInstall as install }
 export default Undici
 
 declare namespace Undici {
@@ -46,6 +53,7 @@ declare namespace Undici {
   const DecoratorHandler: typeof import ('./handlers').DecoratorHandler
   const RetryHandler: typeof import ('./retry-handler').default
   const BalancedPool: typeof import('./balanced-pool').default
+  const RoundRobinPool: typeof import('./round-robin-pool').default
   const Client: typeof import('./client').default
   const H2CClient: typeof import('./h2c-client').default
   const buildConnector: typeof import('./connector').default

package/interceptors.d.ts

@@ -19,14 +19,47 @@ declare namespace Interceptors {
 
   // DNS interceptor
   export type DNSInterceptorRecord = { address: string, ttl: number, family: 4 | 6 }
-  export type DNSInterceptorOriginRecords = { 4: { ips: DNSInterceptorRecord[] } | null, 6: { ips: DNSInterceptorRecord[] } | null }
+  export type DNSInterceptorOriginRecords = { records: { 4: { ips: DNSInterceptorRecord[] } | null, 6: { ips: DNSInterceptorRecord[] } | null } }
+  export type DNSStorage = {
+    size: number
+    get(origin: string): DNSInterceptorOriginRecords | null
+    set(origin: string, records: DNSInterceptorOriginRecords | null, options: { ttl: number }): void
+    delete(origin: string): void
+    full(): boolean
+  }
   export type DNSInterceptorOpts = {
     maxTTL?: number
     maxItems?: number
-    lookup?: (hostname: string, options: LookupOptions, callback: (err: NodeJS.ErrnoException | null, addresses: DNSInterceptorRecord[]) => void) => void
+    lookup?: (origin: URL, options: LookupOptions, callback: (err: NodeJS.ErrnoException | null, addresses: DNSInterceptorRecord[]) => void) => void
     pick?: (origin: URL, records: DNSInterceptorOriginRecords, affinity: 4 | 6) => DNSInterceptorRecord
     dualStack?: boolean
     affinity?: 4 | 6
+    storage?: DNSStorage
+  }
+
+  // Deduplicate interceptor
+  export type DeduplicateMethods = 'GET' | 'HEAD' | 'OPTIONS' | 'TRACE'
+  export type DeduplicateInterceptorOpts = {
+    /**
+     * The HTTP methods to deduplicate.
+     * Note: Only safe HTTP methods can be deduplicated.
+     * @default ['GET']
+     */
+    methods?: DeduplicateMethods[]
+    /**
+     * Header names that, if present in a request, will cause the request to skip deduplication.
+     * Header name matching is case-insensitive.
+     * @default []
+     */
+    skipHeaderNames?: string[]
+    /**
+     * Header names to exclude from the deduplication key.
+     * Requests with different values for these headers will still be deduplicated together.
+     * Useful for headers like `x-request-id` that vary per request but shouldn't affect deduplication.
+     * Header name matching is case-insensitive.
+     * @default []
+     */
+    excludeHeaderNames?: string[]
   }
 
   export function dump (opts?: DumpInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
@@ -36,4 +69,5 @@ declare namespace Interceptors {
   export function responseError (opts?: ResponseErrorInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
   export function dns (opts?: DNSInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
   export function cache (opts?: CacheInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
+  export function deduplicate (opts?: DeduplicateInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "undici-types",
-  "version": "7.15.0",
+  "version": "7.17.0",
   "description": "A stand-alone types package for Undici",
   "homepage": "https://undici.nodejs.org",
   "bugs": {

package/pool.d.ts

@@ -1,6 +1,6 @@
 import Client from './client'
 import TPoolStats from './pool-stats'
-import { URL } from 'url'
+import { URL } from 'node:url'
 import Dispatcher from './dispatcher'
 
 export default Pool

package/readable.d.ts

@@ -1,5 +1,5 @@
-import { Readable } from 'stream'
-import { Blob } from 'buffer'
+import { Readable } from 'node:stream'
+import { Blob } from 'node:buffer'
 
 export default BodyReadable
 

package/round-robin-pool.d.ts

@@ -0,0 +1,41 @@
+import Client from './client'
+import TPoolStats from './pool-stats'
+import { URL } from 'node:url'
+import Dispatcher from './dispatcher'
+
+export default RoundRobinPool
+
+type RoundRobinPoolConnectOptions = Omit<Dispatcher.ConnectOptions, 'origin'>
+
+declare class RoundRobinPool extends Dispatcher {
+  constructor (url: string | URL, options?: RoundRobinPool.Options)
+  /** `true` after `pool.close()` has been called. */
+  closed: boolean
+  /** `true` after `pool.destroyed()` has been called or `pool.close()` has been called and the pool shutdown has completed. */
+  destroyed: boolean
+  /** Aggregate stats for a RoundRobinPool. */
+  readonly stats: TPoolStats
+
+  // Override dispatcher APIs.
+  override connect (
+    options: RoundRobinPoolConnectOptions
+  ): Promise<Dispatcher.ConnectData>
+  override connect (
+    options: RoundRobinPoolConnectOptions,
+    callback: (err: Error | null, data: Dispatcher.ConnectData) => void
+  ): void
+}
+
+declare namespace RoundRobinPool {
+  export type RoundRobinPoolStats = TPoolStats
+  export interface Options extends Client.Options {
+    /** Default: `(origin, opts) => new Client(origin, opts)`. */
+    factory?(origin: URL, opts: object): Dispatcher;
+    /** The max number of clients to create. `null` if no limit. Default `null`. */
+    connections?: number | null;
+    /** The amount of time before a client is removed from the pool and closed. `null` if no time limit. Default `null` */
+    clientTtl?: number | null;
+
+    interceptors?: { RoundRobinPool?: readonly Dispatcher.DispatchInterceptor[] } & Client.Options['interceptors']
+  }
+}

package/webidl.d.ts

@@ -10,11 +10,6 @@ type SequenceConverter<T> = (object: unknown, iterable?: IterableIterator<T>) =>
 
 type RecordConverter<K extends string, V> = (object: unknown) => Record<K, V>
 
-interface ConvertToIntOpts {
-  clamp?: boolean
-  enforceRange?: boolean
-}
-
 interface WebidlErrors {
   /**
    * @description Instantiate an error
@@ -74,7 +69,7 @@ interface WebidlUtil {
     V: unknown,
     bitLength: number,
     signedness: 'signed' | 'unsigned',
-    opts?: ConvertToIntOpts
+    flags?: number
   ): number
 
   /**
@@ -94,15 +89,17 @@ interface WebidlUtil {
    * This is only effective in some newer Node.js versions.
    */
   markAsUncloneable (V: any): void
+
+  IsResizableArrayBuffer (V: ArrayBufferLike): boolean
+
+  HasFlag (flag: number, attributes: number): boolean
 }
 
 interface WebidlConverters {
   /**
    * @see https://webidl.spec.whatwg.org/#es-DOMString
    */
-  DOMString (V: unknown, prefix: string, argument: string, opts?: {
-    legacyNullToEmptyString: boolean
-  }): string
+  DOMString (V: unknown, prefix: string, argument: string, flags?: number): string
 
   /**
    * @see https://webidl.spec.whatwg.org/#es-ByteString
@@ -142,39 +139,78 @@ interface WebidlConverters {
   /**
    * @see https://webidl.spec.whatwg.org/#es-unsigned-short
    */
-  ['unsigned short'] (V: unknown, opts?: ConvertToIntOpts): number
+  ['unsigned short'] (V: unknown, flags?: number): number
 
   /**
    * @see https://webidl.spec.whatwg.org/#idl-ArrayBuffer
    */
-  ArrayBuffer (V: unknown): ArrayBufferLike
-  ArrayBuffer (V: unknown, opts: { allowShared: false }): ArrayBuffer
+  ArrayBuffer (
+    V: unknown,
+    prefix: string,
+    argument: string,
+    options?: { allowResizable: boolean }
+  ): ArrayBuffer
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#idl-SharedArrayBuffer
+   */
+  SharedArrayBuffer (
+    V: unknown,
+    prefix: string,
+    argument: string,
+    options?: { allowResizable: boolean }
+  ): SharedArrayBuffer
 
   /**
    * @see https://webidl.spec.whatwg.org/#es-buffer-source-types
    */
   TypedArray (
     V: unknown,
-    TypedArray: NodeJS.TypedArray | ArrayBufferLike
-  ): NodeJS.TypedArray | ArrayBufferLike
-  TypedArray (
+    T: new () => NodeJS.TypedArray,
+    prefix: string,
+    argument: string,
+    flags?: number
+  ): NodeJS.TypedArray
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-buffer-source-types
+   */
+  DataView (
     V: unknown,
-    TypedArray: NodeJS.TypedArray | ArrayBufferLike,
-    opts?: { allowShared: false }
-  ): NodeJS.TypedArray | ArrayBuffer
+    prefix: string,
+    argument: string,
+    flags?: number
+  ): DataView
 
   /**
    * @see https://webidl.spec.whatwg.org/#es-buffer-source-types
    */
-  DataView (V: unknown, opts?: { allowShared: boolean }): DataView
+  ArrayBufferView (
+    V: unknown,
+    prefix: string,
+    argument: string,
+    flags?: number
+  ): NodeJS.ArrayBufferView
 
   /**
    * @see https://webidl.spec.whatwg.org/#BufferSource
    */
   BufferSource (
     V: unknown,
-    opts?: { allowShared: boolean }
-  ): NodeJS.TypedArray | ArrayBufferLike | DataView
+    prefix: string,
+    argument: string,
+    flags?: number
+  ): ArrayBuffer | NodeJS.ArrayBufferView
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#AllowSharedBufferSource
+   */
+  AllowSharedBufferSource (
+    V: unknown,
+    prefix: string,
+    argument: string,
+    flags?: number
+  ): ArrayBuffer | SharedArrayBuffer | NodeJS.ArrayBufferView
 
   ['sequence<ByteString>']: SequenceConverter<string>
 
@@ -192,6 +228,13 @@ interface WebidlConverters {
    */
   RequestInit (V: unknown): undici.RequestInit
 
+  /**
+   * @see https://html.spec.whatwg.org/multipage/webappapis.html#eventhandlernonnull
+   */
+  EventHandlerNonNull (V: unknown): Function | null
+
+  WebSocketStreamWrite (V: unknown): ArrayBuffer | NodeJS.TypedArray | string
+
   [Key: string]: (...args: any[]) => unknown
 }
 
@@ -210,6 +253,10 @@ interface WebidlIs {
   AbortSignal: WebidlIsFunction<AbortSignal>
   MessagePort: WebidlIsFunction<MessagePort>
   USVString: WebidlIsFunction<string>
+  /**
+   * @see https://webidl.spec.whatwg.org/#BufferSource
+   */
+  BufferSource: WebidlIsFunction<ArrayBuffer | NodeJS.TypedArray>
 }
 
 export interface Webidl {
@@ -217,6 +264,7 @@ export interface Webidl {
   util: WebidlUtil
   converters: WebidlConverters
   is: WebidlIs
+  attributes: WebIDLExtendedAttributes
 
   /**
    * @description Performs a brand-check on {@param V} to ensure it is a
@@ -278,3 +326,16 @@ export interface Webidl {
 
   argumentLengthCheck (args: { length: number }, min: number, context: string): void
 }
+
+interface WebIDLExtendedAttributes {
+  /** https://webidl.spec.whatwg.org/#Clamp */
+  Clamp: number
+  /** https://webidl.spec.whatwg.org/#EnforceRange */
+  EnforceRange: number
+  /** https://webidl.spec.whatwg.org/#AllowShared */
+  AllowShared: number
+  /** https://webidl.spec.whatwg.org/#AllowResizable */
+  AllowResizable: number
+  /** https://webidl.spec.whatwg.org/#LegacyNullToEmptyString */
+  LegacyNullToEmptyString: number
+}

package/websocket.d.ts

@@ -1,8 +1,8 @@
 /// <reference types="node" />
 
-import type { Blob } from 'buffer'
-import type { ReadableStream, WritableStream } from 'stream/web'
-import type { MessagePort } from 'worker_threads'
+import type { Blob } from 'node:buffer'
+import type { ReadableStream, WritableStream } from 'node:stream/web'
+import type { MessagePort } from 'node:worker_threads'
 import {
   EventInit,
   EventListenerOptions,
@@ -96,16 +96,16 @@ interface MessageEventInit<T = any> extends EventInit {
   data?: T
   lastEventId?: string
   origin?: string
-  ports?: (typeof MessagePort)[]
-  source?: typeof MessagePort | null
+  ports?: MessagePort[]
+  source?: MessagePort | null
 }
 
 interface MessageEvent<T = any> extends Event {
   readonly data: T
   readonly lastEventId: string
   readonly origin: string
-  readonly ports: ReadonlyArray<typeof MessagePort>
-  readonly source: typeof MessagePort | null
+  readonly ports: readonly MessagePort[]
+  readonly source: MessagePort | null
   initMessageEvent(
     type: string,
     bubbles?: boolean,
@@ -113,8 +113,8 @@ interface MessageEvent<T = any> extends Event {
     data?: any,
     origin?: string,
     lastEventId?: string,
-    source?: typeof MessagePort | null,
-    ports?: (typeof MessagePort)[]
+    source?: MessagePort | null,
+    ports?: MessagePort[]
   ): void;
 }