@yanglaofish/fishtools 0.5.2 → 0.5.3

package/node_modules/undici/package.json

@@ -1,6 +1,6 @@
 {
   "name": "undici",
-  "version": "8.11.2",
+  "version": "6.29.0",
   "description": "An HTTP/1.1 client, written from scratch for Node.js",
   "homepage": "https://undici.nodejs.org",
   "bugs": {
@@ -62,43 +62,39 @@
   "main": "index.js",
   "types": "index.d.ts",
   "scripts": {
-    "build:node": "esbuild index-fetch.js --bundle --platform=node --outfile=undici-fetch.js --define:esbuildDetection=1 --keep-names && node scripts/strip-comments.js",
+    "build:node": "npx esbuild@0.19.10 index-fetch.js --bundle --platform=node --outfile=undici-fetch.js --define:esbuildDetection=1 --keep-names && node scripts/strip-comments.js",
+    "prebuild:wasm": "node build/wasm.js --prebuild",
     "build:wasm": "node build/wasm.js --docker",
-    "generate-pem": "node scripts/generate-pem.js",
-    "lint": "eslint --cache",
-    "lint:fix": "eslint --fix --cache",
-    "test": "npm run test:javascript && cross-env NODE_V8_COVERAGE= npm run test:typescript",
-    "test:javascript": "npm run test:javascript:no-jest && npm run test:jest",
-    "test:javascript:no-jest": "npm run generate-pem && npm run test:unit && npm run test:fetch && npm run test:node-fetch && npm run test:infra && npm run test:cache && npm run test:cache-interceptor && npm run test:interceptors && npm run test:cookies && npm run test:eventsource && npm run test:subresource-integrity && npm run test:wpt && npm run test:websocket && npm run test:node-test && npm run test:cache-tests",
-    "test:javascript:without-intl": "npm run test:javascript:no-jest",
-    "test:busboy": "borp --timeout 180000 -p \"test/busboy/*.js\"",
-    "test:cache": "borp --timeout 180000 -p \"test/cache/*.js\"",
-    "test:cache-interceptor": "borp --timeout 180000 -p \"test/cache-interceptor/*.js\"",
-    "test:cache-interceptor:sqlite": "cross-env NODE_OPTIONS=--experimental-sqlite npm run test:cache-interceptor",
-    "test:cookies": "borp --timeout 180000 -p \"test/cookie/*.js\"",
-    "test:eventsource": "npm run build:node && borp --timeout 180000 --expose-gc -p \"test/eventsource/*.js\"",
+    "lint": "standard | snazzy",
+    "lint:fix": "standard --fix | snazzy",
+    "test": "npm run test:javascript && cross-env NODE_V8_COVERAGE=  npm run test:typescript",
+    "test:javascript": "node scripts/generate-pem && npm run test:unit && npm run test:node-fetch && npm run test:cache && npm run test:interceptors && npm run test:fetch && npm run test:cookies && npm run test:eventsource && npm run test:wpt && npm run test:websocket && npm run test:node-test && npm run test:jest",
+    "test:javascript:withoutintl": "node scripts/generate-pem && npm run test:unit && npm run test:node-fetch && npm run test:fetch:nobuild && npm run test:cache && npm run test:interceptors && npm run test:cookies && npm run test:eventsource:nobuild && npm run test:wpt:withoutintl && npm run test:node-test",
+    "test:busboy": "borp -p \"test/busboy/*.js\"",
+    "test:cache": "borp -p \"test/cache/*.js\"",
+    "test:cookies": "borp -p \"test/cookie/*.js\"",
+    "test:eventsource": "npm run build:node && npm run test:eventsource:nobuild",
+    "test:eventsource:nobuild": "borp --expose-gc -p \"test/eventsource/*.js\"",
     "test:fuzzing": "node test/fuzzing/fuzzing.test.js",
-    "test:fetch": "npm run build:node && borp --timeout 180000 --expose-gc --concurrency 1 -p \"test/fetch/*.js\" && npm run test:webidl && npm run test:busboy",
-    "test:subresource-integrity": "borp --timeout 180000 -p \"test/subresource-integrity/*.js\"",
+    "test:fetch": "npm run build:node && npm run test:fetch:nobuild",
+    "test:fetch:nobuild": "borp --timeout 180000 --expose-gc --concurrency 1 -p \"test/fetch/*.js\" && npm run test:webidl && npm run test:busboy",
     "test:h2": "npm run test:h2:core && npm run test:h2:fetch",
-    "test:h2:core": "borp --timeout 180000 -p \"test/+(http2|h2)*.js\"",
-    "test:h2:fetch": "npm run build:node && borp --timeout 180000 -p \"test/fetch/http2*.js\"",
-    "test:infra": "borp --timeout 180000 -p \"test/infra/*.js\"",
-    "test:interceptors": "borp --timeout 180000 -p \"test/interceptors/*.js\"",
+    "test:h2:core": "borp -p \"test/http2*.js\"",
+    "test:h2:fetch": "npm run build:node && borp -p \"test/fetch/http2*.js\"",
+    "test:interceptors": "borp -p \"test/interceptors/*.js\"",
     "test:jest": "cross-env NODE_V8_COVERAGE= jest",
-    "test:unit": "borp --timeout 180000 --expose-gc -p \"test/*.js\"",
-    "test:node-fetch": "borp --timeout 180000 -p \"test/node-fetch/**/*.js\"",
-    "test:node-test": "borp --timeout 180000 -p \"test/node-test/**/*.js\"",
-    "test:tdd": "borp --timeout 180000 --expose-gc -p \"test/*.js\"",
-    "test:tdd:node-test": "borp --timeout 180000 -p \"test/node-test/**/*.js\" -w",
-    "test:typescript": "tsd && tsc test/imports/undici-import.ts --typeRoots ./types --noEmit && tsc ./types/*.d.ts --noEmit --typeRoots ./types",
-    "test:webidl": "borp --timeout 180000 -p \"test/webidl/*.js\"",
-    "test:websocket": "borp --timeout 180000 -p \"test/websocket/**/*.js\"",
+    "test:unit": "borp --expose-gc -p \"test/*.js\"",
+    "test:node-fetch": "borp -p \"test/node-fetch/**/*.js\"",
+    "test:node-test": "borp -p \"test/node-test/**/*.js\"",
+    "test:tdd": "borp --expose-gc -p \"test/*.js\"",
+    "test:tdd:node-test": "borp -p \"test/node-test/**/*.js\" -w",
+    "test:typescript": "tsd && tsc test/imports/undici-import.ts --typeRoots ./types && tsc ./types/*.d.ts --noEmit --typeRoots ./types",
+    "test:webidl": "borp -p \"test/webidl/*.js\"",
+    "test:websocket": "borp -p \"test/websocket/*.js\"",
     "test:websocket:autobahn": "node test/autobahn/client.js",
     "test:websocket:autobahn:report": "node test/autobahn/report.js",
-    "test:wpt:setup": "node test/web-platform-tests/wpt-runner.mjs setup",
-    "test:wpt": "npm run test:wpt:setup && node test/web-platform-tests/wpt-runner.mjs run /fetch /mimesniff /xhr /websockets /eventsource",
-    "test:cache-tests": "node test/cache-interceptor/cache-tests.mjs --ci",
+    "test:wpt": "node test/wpt/start-fetch.mjs && node test/wpt/start-FileAPI.mjs && node test/wpt/start-mimesniff.mjs && node test/wpt/start-xhr.mjs && node test/wpt/start-websockets.mjs && node test/wpt/start-cacheStorage.mjs && node test/wpt/start-eventsource.mjs",
+    "test:wpt:withoutintl": "node test/wpt/start-fetch.mjs && node test/wpt/start-mimesniff.mjs && node test/wpt/start-xhr.mjs && node test/wpt/start-cacheStorage.mjs && node test/wpt/start-eventsource.mjs",
     "coverage": "npm run coverage:clean && cross-env NODE_V8_COVERAGE=./coverage/tmp npm run test:javascript && npm run coverage:report",
     "coverage:ci": "npm run coverage:clean && cross-env NODE_V8_COVERAGE=./coverage/tmp npm run test:javascript && npm run coverage:report:ci",
     "coverage:clean": "node ./scripts/clean-coverage.js",
@@ -109,31 +105,43 @@
     "prepare": "husky && node ./scripts/platform-shell.js"
   },
   "devDependencies": {
-    "@fastify/busboy": "3.2.2",
-    "@matteo.collina/tspl": "^0.2.0",
+    "@fastify/busboy": "2.1.1",
+    "@matteo.collina/tspl": "^0.1.1",
     "@metcoder95/https-pem": "^1.0.0",
-    "@sinonjs/fake-timers": "^12.0.0",
-    "@types/node": "^22.0.0",
+    "@sinonjs/fake-timers": "^11.1.0",
+    "@types/node": "~18.19.50",
     "abort-controller": "^3.0.0",
-    "borp": "^1.0.0",
-    "c8": "^12.0.0",
-    "cross-env": "^10.0.0",
+    "borp": "^0.15.0",
+    "c8": "^10.0.0",
+    "cross-env": "^7.0.3",
     "dns-packet": "^5.4.0",
-    "esbuild": "^0.28.0",
-    "eslint": "^9.9.0",
-    "fast-check": "^4.1.1",
+    "fast-check": "^3.17.1",
+    "form-data": "^4.0.0",
+    "formdata-node": "^6.0.3",
     "husky": "^9.0.7",
-    "jest": "^30.0.5",
-    "jsondiffpatch": "^0.7.3",
-    "neostandard": "^0.13.0",
+    "jest": "^29.0.2",
+    "jsdom": "^24.0.0",
     "node-forge": "^1.3.1",
-    "proxy": "^4.0.0",
-    "tsd": "^0.33.0",
-    "typescript": "^6.0.2",
+    "pre-commit": "^1.2.2",
+    "proxy": "^2.1.1",
+    "snazzy": "^9.0.0",
+    "standard": "^17.0.0",
+    "tsd": "^0.31.0",
+    "typescript": "^5.0.2",
     "ws": "^8.11.0"
   },
   "engines": {
-    "node": ">=22.19.0"
+    "node": ">=18.17"
+  },
+  "standard": {
+    "env": [
+      "jest"
+    ],
+    "ignore": [
+      "lib/llhttp/constants.js",
+      "lib/llhttp/utils.js",
+      "test/fixtures/wpt"
+    ]
   },
   "tsd": {
     "directory": "test/types",

package/node_modules/undici/scripts/strip-comments.js

@@ -3,8 +3,6 @@
 const { readFileSync, writeFileSync } = require('node:fs')
 const { transcode } = require('node:buffer')
 
-const buffer = transcode
-  ? transcode(readFileSync('./undici-fetch.js'), 'utf8', 'latin1')
-  : readFileSync('./undici-fetch.js')
+const buffer = transcode(readFileSync('./undici-fetch.js'), 'utf8', 'latin1')
 
 writeFileSync('./undici-fetch.js', buffer.toString('latin1'))

package/node_modules/undici/types/agent.d.ts

@@ -1,30 +1,31 @@
-import { URL } from 'node:url'
+import { URL } from 'url'
 import Pool from './pool'
-import Dispatcher from './dispatcher'
-import TClientStats from './client-stats'
-import TPoolStats from './pool-stats'
+import Dispatcher from "./dispatcher";
 
 export default Agent
 
-declare class Agent extends Dispatcher {
-  constructor (opts?: Agent.Options)
+declare class Agent extends Dispatcher{
+  constructor(opts?: Agent.Options)
   /** `true` after `dispatcher.close()` has been called. */
-  closed: boolean
+  closed: boolean;
   /** `true` after `dispatcher.destroyed()` has been called or `dispatcher.close()` has been called and the dispatcher shutdown has completed. */
-  destroyed: boolean
+  destroyed: boolean;
   /** Dispatches a request. */
-  dispatch (options: Agent.DispatchOptions, handler: Dispatcher.DispatchHandler): boolean
-  /** Aggregate stats for a Agent by origin. */
-  readonly stats: Record<string, TClientStats | TPoolStats>
+  dispatch(options: Agent.DispatchOptions, handler: Dispatcher.DispatchHandlers): boolean;
 }
 
 declare namespace Agent {
   export interface Options extends Pool.Options {
     /** Default: `(origin, opts) => new Pool(origin, opts)`. */
     factory?(origin: string | URL, opts: Object): Dispatcher;
-    maxOrigins?: number
+    /** Integer. Default: `0` */
+    maxRedirections?: number;
+
+    interceptors?: { Agent?: readonly Dispatcher.DispatchInterceptor[] } & Pool.Options["interceptors"]
   }
 
   export interface DispatchOptions extends Dispatcher.DispatchOptions {
+    /** Integer. */
+    maxRedirections?: number;
   }
 }

package/node_modules/undici/types/api.d.ts

@@ -1,43 +1,43 @@
-import { URL, UrlObject } from 'node:url'
-import { Duplex } from 'node:stream'
+import { URL, UrlObject } from 'url'
+import { Duplex } from 'stream'
 import Dispatcher from './dispatcher'
 
+export {
+  request,
+  stream,
+  pipeline,
+  connect,
+  upgrade,
+}
+
 /** Performs an HTTP request. */
-declare function request<TOpaque = null> (
+declare function request(
   url: string | URL | UrlObject,
-  options?: { dispatcher?: Dispatcher } & Omit<Dispatcher.RequestOptions<TOpaque>, 'origin' | 'path' | 'method'> & Partial<Pick<Dispatcher.RequestOptions, 'method'>>,
-): Promise<Dispatcher.ResponseData<TOpaque>>
+  options?: { dispatcher?: Dispatcher } & Omit<Dispatcher.RequestOptions, 'origin' | 'path' | 'method'> & Partial<Pick<Dispatcher.RequestOptions, 'method'>>,
+): Promise<Dispatcher.ResponseData>;
 
 /** A faster version of `request`. */
-declare function stream<TOpaque = null> (
+declare function stream(
   url: string | URL | UrlObject,
-  options: { dispatcher?: Dispatcher } & Omit<Dispatcher.RequestOptions<TOpaque>, 'origin' | 'path'>,
-  factory: Dispatcher.StreamFactory<TOpaque>
-): Promise<Dispatcher.StreamData<TOpaque>>
+  options: { dispatcher?: Dispatcher } & Omit<Dispatcher.RequestOptions, 'origin' | 'path'>,
+  factory: Dispatcher.StreamFactory
+): Promise<Dispatcher.StreamData>;
 
 /** For easy use with `stream.pipeline`. */
-declare function pipeline<TOpaque = null> (
+declare function pipeline(
   url: string | URL | UrlObject,
-  options: { dispatcher?: Dispatcher } & Omit<Dispatcher.PipelineOptions<TOpaque>, 'origin' | 'path'>,
-  handler: Dispatcher.PipelineHandler<TOpaque>
-): Duplex
+  options: { dispatcher?: Dispatcher } & Omit<Dispatcher.PipelineOptions, 'origin' | 'path'>,
+  handler: Dispatcher.PipelineHandler
+): Duplex;
 
 /** Starts two-way communications with the requested resource. */
-declare function connect<TOpaque = null> (
+declare function connect(
   url: string | URL | UrlObject,
-  options?: { dispatcher?: Dispatcher } & Omit<Dispatcher.ConnectOptions<TOpaque>, 'origin' | 'path'>
-): Promise<Dispatcher.ConnectData<TOpaque>>
+  options?: { dispatcher?: Dispatcher } & Omit<Dispatcher.ConnectOptions, 'origin' | 'path'>
+): Promise<Dispatcher.ConnectData>;
 
 /** Upgrade to a different protocol. */
-declare function upgrade (
+declare function upgrade(
   url: string | URL | UrlObject,
   options?: { dispatcher?: Dispatcher } & Omit<Dispatcher.UpgradeOptions, 'origin' | 'path'>
-): Promise<Dispatcher.UpgradeData>
-
-export {
-  request,
-  stream,
-  pipeline,
-  connect,
-  upgrade
-}
+): Promise<Dispatcher.UpgradeData>;

package/node_modules/undici/types/balanced-pool.d.ts

@@ -1,30 +1,29 @@
 import Pool from './pool'
 import Dispatcher from './dispatcher'
-import { URL } from 'node:url'
+import { URL } from 'url'
 
 export default BalancedPool
 
-type BalancedPoolConnectOptions = Omit<Dispatcher.ConnectOptions, 'origin'>
+type BalancedPoolConnectOptions = Omit<Dispatcher.ConnectOptions, "origin">;
 
 declare class BalancedPool extends Dispatcher {
-  constructor (url: string | string[] | URL | URL[], options?: Pool.Options)
+  constructor(url: string | string[] | URL | URL[], options?: Pool.Options);
 
-  addUpstream (upstream: string | URL): BalancedPool
-  removeUpstream (upstream: string | URL): BalancedPool
-  getUpstream (upstream: string | URL): Pool | undefined
-  upstreams: Array<string>
+  addUpstream(upstream: string | URL): BalancedPool;
+  removeUpstream(upstream: string | URL): BalancedPool;
+  upstreams: Array<string>;
 
   /** `true` after `pool.close()` has been called. */
-  closed: boolean
+  closed: boolean;
   /** `true` after `pool.destroyed()` has been called or `pool.close()` has been called and the pool shutdown has completed. */
-  destroyed: boolean
+  destroyed: boolean;
 
   // Override dispatcher APIs.
-  override connect (
+  override connect(
     options: BalancedPoolConnectOptions
-  ): Promise<Dispatcher.ConnectData>
-  override connect (
+  ): Promise<Dispatcher.ConnectData>;
+  override connect(
     options: BalancedPoolConnectOptions,
     callback: (err: Error | null, data: Dispatcher.ConnectData) => void
-  ): void
+  ): void;
 }

package/node_modules/undici/types/client.d.ts

@@ -1,52 +1,50 @@
-import { URL } from 'node:url'
-import { SessionOptions } from 'node:http2'
+import { URL } from 'url'
+import { TlsOptions } from 'tls'
 import Dispatcher from './dispatcher'
-import buildConnector from './connector'
-import TClientStats from './client-stats'
+import buildConnector from "./connector";
 
-type ClientConnectOptions<TOpaque = null> = Omit<Dispatcher.ConnectOptions<TOpaque>, 'origin'>
-
-// TODO: Pendings
-// 1. Reflect this on Client instantiation
-// 2. Client H2 should use this namespaced options instead.
+type ClientConnectOptions = Omit<Dispatcher.ConnectOptions, "origin">;
 
 /**
  * A basic HTTP/1.1 client, mapped on top a single TCP/TLS connection. Pipelining is disabled by default.
  */
 export class Client extends Dispatcher {
-  constructor (url: string | URL, options?: Client.Options)
+  constructor(url: string | URL, options?: Client.Options);
   /** Property to get and set the pipelining factor. */
-  pipelining: number
+  pipelining: number;
   /** `true` after `client.close()` has been called. */
-  closed: boolean
+  closed: boolean;
   /** `true` after `client.destroyed()` has been called or `client.close()` has been called and the client shutdown has completed. */
-  destroyed: boolean
-  /** Aggregate stats for a Client. */
-  readonly stats: TClientStats
+  destroyed: boolean;
 
   // Override dispatcher APIs.
-  override connect<TOpaque = null> (
-    options: ClientConnectOptions<TOpaque>
-  ): Promise<Dispatcher.ConnectData<TOpaque>>
-  override connect<TOpaque = null> (
-    options: ClientConnectOptions<TOpaque>,
-    callback: (err: Error | null, data: Dispatcher.ConnectData<TOpaque>) => void
-  ): void
+  override connect(
+    options: ClientConnectOptions
+  ): Promise<Dispatcher.ConnectData>;
+  override connect(
+    options: ClientConnectOptions,
+    callback: (err: Error | null, data: Dispatcher.ConnectData) => void
+  ): void;
 }
 
 export declare namespace Client {
+  export interface OptionsInterceptors {
+    Client: readonly Dispatcher.DispatchInterceptor[];
+  }
   export interface Options {
+    /** TODO */
+    interceptors?: OptionsInterceptors;
     /** The maximum length of request headers in bytes. Default: Node.js' `--max-http-header-size` or `16384` (16KiB). */
     maxHeaderSize?: number;
-    /** The amount of time, in milliseconds, the parser will wait to receive the complete HTTP headers (Node 14 and above only). Default: `300e3` milliseconds (300s). HTTP/1.1 parser timeouts are not guaranteed to fire with exact millisecond precision: delays up to 1000ms use native timers, while larger delays use lower-overhead fast timers with a target resolution around 500ms. */
+    /** The amount of time, in milliseconds, the parser will wait to receive the complete HTTP headers (Node 14 and above only). Default: `300e3` milliseconds (300s). */
     headersTimeout?: number;
     /** @deprecated unsupported socketTimeout, use headersTimeout & bodyTimeout instead */
     socketTimeout?: never;
     /** @deprecated unsupported requestTimeout, use headersTimeout & bodyTimeout instead */
     requestTimeout?: never;
-    /** The timeout for establishing a socket connection, in milliseconds. Use `0` to disable it entirely. Default: `10e3` milliseconds (10s). */
+    /** TODO */
     connectTimeout?: number;
-    /** The timeout after which a request will time out, in milliseconds. Monitors time between receiving body data. Use `0` to disable it entirely. Default: `300e3` milliseconds (300s). HTTP/1.1 parser timeouts are not guaranteed to fire with exact millisecond precision: delays up to 1000ms use native timers, while larger delays use lower-overhead fast timers with a target resolution around 500ms. */
+    /** The timeout after which a request will time out, in milliseconds. Monitors time between receiving body data. Use `0` to disable it entirely. Default: `300e3` milliseconds (300s). */
     bodyTimeout?: number;
     /** @deprecated unsupported idleTimeout, use keepAliveTimeout instead */
     idleTimeout?: never;
@@ -60,65 +58,42 @@ export declare namespace Client {
     keepAliveMaxTimeout?: number;
     /** A number of milliseconds subtracted from server *keep-alive* hints when overriding `idleTimeout` to account for timing inaccuracies caused by e.g. transport latency. Default: `1e3` milliseconds (1s). */
     keepAliveTimeoutThreshold?: number;
-    /** An IPC endpoint, either a Unix domain socket or Windows named pipe. Default: `null`. */
+    /** TODO */
     socketPath?: string;
-    /** The amount of concurrent requests to be sent over the single TCP/TLS connection according to [RFC7230](https://tools.ietf.org/html/rfc7230#section-6.3.2). Only enable values greater than `1` when the remote server is trusted. Default: `1`. */
+    /** The amount of concurrent requests to be sent over the single TCP/TLS connection according to [RFC7230](https://tools.ietf.org/html/rfc7230#section-6.3.2). Default: `1`. */
     pipelining?: number;
     /** @deprecated use the connect option instead */
     tls?: never;
     /** If `true`, an error is thrown when the request content-length header doesn't match the length of the request body. Default: `true`. */
     strictContentLength?: boolean;
-    /** Maximum number of TLS cached sessions used by the built-in connector. Use `0` to disable TLS session caching. Default: `100`. */
+    /** TODO */
     maxCachedSessions?: number;
-    /** Connector options passed to `buildConnector`, or a custom connector function. Default: `null`. */
-    connect?: Partial<buildConnector.BuildOptions> | buildConnector.connector;
-    /** The maximum number of requests to send over a single connection before it is reset. Use `0` to disable this limit. Default: `null`. */
+    /** TODO */
+    maxRedirections?: number;
+    /** TODO */
+    connect?: buildConnector.BuildOptions | buildConnector.connector;
+    /** TODO */
     maxRequestsPerClient?: number;
-    /** Local IP address the socket should connect from. */
+    /** TODO */
     localAddress?: string;
     /** Max response body size in bytes, -1 is disabled */
     maxResponseSize?: number;
     /** WebSocket-specific options */
     webSocket?: Client.WebSocketOptions;
-    /** EventSource-specific options */
-    eventSource?: Client.EventSourceOptions;
     /** Enables a family autodetection algorithm that loosely implements section 5 of RFC 8305. */
     autoSelectFamily?: boolean;
     /** The amount of time in milliseconds to wait for a connection attempt to finish before trying the next address when using the `autoSelectFamily` option. */
     autoSelectFamilyAttemptTimeout?: number;
     /**
      * @description Enables support for H2 if the server has assigned bigger priority to it through ALPN negotiation.
-     * @default true
-     */
+     * @default false
+    */
     allowH2?: boolean;
     /**
      * @description Dictates the maximum number of concurrent streams for a single H2 session. It can be overridden by a SETTINGS remote frame.
      * @default 100
-     * @deprecated Use h2Options.maxConcurrentStreams instead
-     */
-    maxConcurrentStreams?: number;
-    /**
-     * @description Sets the HTTP/2 stream-level flow-control window size (SETTINGS_INITIAL_WINDOW_SIZE).
-     * @default 262144
-     * @deprecated Use h2Options.settings.initialWindowSize instead
-     */
-    initialWindowSize?: number;
-    /**
-     * @description Sets the HTTP/2 connection-level flow-control window size (ClientHttp2Session.setLocalWindowSize).
-     * @default 524288
-     * @deprecated Use h2Options.connectionWindowSize instead
-     */
-    connectionWindowSize?: number;
-    /**
-     * @description Time interval between PING frames dispatch
-     * @default 60000
-     * @deprecated Use h2Options.connectionWindowSize instead
-     */
-    pingInterval?: number;
-    /**
-     * @description HTTP/2 configuration options
-     */
-    h2Options?: Client.H2Options;
+    */
+    maxConcurrentStreams?: number
   }
   export interface SocketInfo {
     localAddress?: string
@@ -132,7 +107,8 @@ export declare namespace Client {
   }
   export interface WebSocketOptions {
     /**
-     * Maximum number of fragments in a message. Set to 0 to disable the limit.
+     * Maximum number of fragments in a message.
+     * Set to 0 to disable the limit.
      * @default 131072
      */
     maxFragments?: number;
@@ -144,41 +120,6 @@ export declare namespace Client {
      */
     maxPayloadSize?: number;
   }
-
-  export interface H2Options extends Omit<SessionOptions, keyof buildConnector.BuildOptions> {
-    /**
-     * @description Sets the HTTP/2 connection-level flow-control window size (ClientHttp2Session.setLocalWindowSize).
-     * @default 524288
-     */
-    connectionWindowSize?: number;
-    /**
-     * @description Time interval between PING frames dispatch
-     * @default 60000
-     */
-    pingInterval?: number;
-    /**
-     * @description Dictates the maximum number of concurrent streams for a single H2 session. It can be overridden by a SETTINGS remote frame.
-     * @default 100
-    */
-    maxConcurrentStreams?: number;
-    /**
-     * @description Enable support for H2C (plain text)
-     * @default false
-     */
-    useH2c?: boolean;
-    /**
-     * @description SETTINGS frame object. Default to 'node:http2' defaults
-     */
-    settings?: Omit<SessionOptions['settings'], 'enablePush' | 'maxConcurrentStreams' | 'enableConnectProtocol'>
-  }
-  export interface EventSourceOptions {
-    /**
-     * Maximum allowed event size in bytes for EventSource messages.
-     * Set to 0 to disable the limit.
-     * @default buffer.kStringMaxLength
-     */
-    maxEventSize?: number;
-  }
 }
 
-export default Client
+export default Client;

package/node_modules/undici/types/connector.d.ts

@@ -1,5 +1,5 @@
-import { TLSSocket, ConnectionOptions } from 'node:tls'
-import { IpcNetConnectOpts, Socket, TcpNetConnectOpts } from 'node:net'
+import { TLSSocket, ConnectionOptions } from 'tls'
+import { IpcNetConnectOpts, Socket, TcpNetConnectOpts } from 'net'
 
 export default buildConnector
 declare function buildConnector (options?: buildConnector.BuildOptions): buildConnector.connector
@@ -7,14 +7,12 @@ declare function buildConnector (options?: buildConnector.BuildOptions): buildCo
 declare namespace buildConnector {
   export type BuildOptions = (ConnectionOptions | TcpNetConnectOpts | IpcNetConnectOpts) & {
     allowH2?: boolean;
-    preferH2?: boolean;
     maxCachedSessions?: number | null;
     socketPath?: string | null;
     timeout?: number | null;
     port?: number;
     keepAlive?: boolean | null;
     keepAliveInitialDelay?: number | null;
-    typeOfService?: number | null;
   }
 
   export interface Options {
@@ -24,7 +22,6 @@ declare namespace buildConnector {
     port: string
     servername?: string
     localAddress?: string | null
-    socketPath?: string | null
     httpSocket?: Socket
   }
 

package/node_modules/undici/types/cookies.d.ts

@@ -18,7 +18,7 @@ export interface Cookie {
 export function deleteCookie (
   headers: Headers,
   name: string,
-  attributes?: { path?: string, domain?: string }
+  attributes?: { name?: string, domain?: string }
 ): void
 
 export function getCookies (headers: Headers): Record<string, string>
@@ -26,5 +26,3 @@ export function getCookies (headers: Headers): Record<string, string>
 export function getSetCookies (headers: Headers): Cookie[]
 
 export function setCookie (headers: Headers, cookie: Cookie): void
-
-export function parseCookie (cookie: string): Cookie | null

package/node_modules/undici/types/diagnostics-channel.d.ts

@@ -1,8 +1,7 @@
-import { Socket } from 'node:net'
-import { URL } from 'node:url'
-import buildConnector from './connector'
-import Dispatcher from './dispatcher'
-import { IncomingHttpHeaders } from './header'
+import { Socket } from "net";
+import { URL } from "url";
+import Connector from "./connector";
+import Dispatcher from "./dispatcher";
 
 declare namespace DiagnosticsChannel {
   interface Request {
@@ -15,31 +14,23 @@ declare namespace DiagnosticsChannel {
   interface Response {
     statusCode: number;
     statusText: string;
-    headers: Array<Buffer> | IncomingHttpHeaders;
+    headers: Array<Buffer>;
   }
+  type Error = unknown;
   interface ConnectParams {
-    host: URL['host'];
-    hostname: URL['hostname'];
-    protocol: URL['protocol'];
-    port: URL['port'];
+    host: URL["host"];
+    hostname: URL["hostname"];
+    protocol: URL["protocol"];
+    port: URL["port"];
     servername: string | null;
   }
-  type Connector = buildConnector.connector
+  type Connector = Connector.connector;
   export interface RequestCreateMessage {
     request: Request;
   }
   export interface RequestBodySentMessage {
     request: Request;
   }
-
-  export interface RequestBodyChunkSentMessage {
-    request: Request;
-    chunk: Uint8Array | string;
-  }
-  export interface RequestBodyChunkReceivedMessage {
-    request: Request;
-    chunk: Buffer;
-  }
   export interface RequestHeadersMessage {
     request: Request;
     response: Response;