@automattic/vip 4.1.5 → 4.1.8

package/node_modules/undici/docs/docs/type-map.json

@@ -1,79 +1,79 @@
 {
-  "AbortError": "/api/Errors.md#class-aborterror",
-  "Agent": "/api/Agent.md#class-agent",
-  "AgentDispatchOptions": "/api/Agent.md#agentdispatchoptions-handler",
-  "AgentOptions": "/api/Agent.md#new-agentoptions",
-  "BalancedPool": "/api/BalancedPool.md#class-balancedpool",
-  "BalancedPoolOptions": "/api/BalancedPool.md#parameter-balancedpooloptions",
-  "BodyMixin": "/api/Fetch.md#new-formdata",
+  "AbortError": "/api/Errors.html#class-aborterror",
+  "Agent": "/api/Agent.html#class-agent",
+  "AgentDispatchOptions": "/api/Agent.html#agentdispatchoptions-handler",
+  "AgentOptions": "/api/Agent.html#new-agentoptions",
+  "BalancedPool": "/api/BalancedPool.html#class-balancedpool",
+  "BalancedPoolOptions": "/api/BalancedPool.html#parameter-balancedpooloptions",
+  "BodyMixin": "/api/Fetch.html#new-formdata",
   "Buffer": "https://nodejs.org/api/buffer.html#class-buffer",
-  "BuildOptions": "/api/Connector.md#buildconnectoroptions",
-  "CacheKey": "/api/CacheStore.md#cachekey",
-  "CacheStore": "/api/CacheStore.md#new-memorycachestoreoptions",
-  "CacheValue": "/api/CacheStore.md#cachevalue",
-  "ClientDestroyedError": "/api/Errors.md#class-clientdestroyederror",
-  "ClientOptions": "/api/Client.md#new-clienturl-options",
-  "ClientStats": "/api/ClientStats.md#class-clientstats",
-  "ConnectOptions": "/api/Dispatcher.md#class-dispatcher",
-  "Cookie": "/api/Cookies.md#cookie",
-  "DispatchController": "/api/Dispatcher.md#class-dispatcher",
-  "DispatchHandler": "/api/Dispatcher.md#class-dispatcher",
-  "DispatchOptions": "/api/Dispatcher.md#class-dispatcher",
-  "Dispatcher": "/api/Dispatcher.md#class-dispatcher",
+  "BuildOptions": "/api/Connector.html#buildconnectoroptions",
+  "CacheKey": "/api/CacheStore.html#cachekey",
+  "CacheStore": "/api/CacheStore.html#new-memorycachestoreoptions",
+  "CacheValue": "/api/CacheStore.html#cachevalue",
+  "ClientDestroyedError": "/api/Errors.html#class-clientdestroyederror",
+  "ClientOptions": "/api/Client.html#new-clienturl-options",
+  "ClientStats": "/api/ClientStats.html#class-clientstats",
+  "ConnectOptions": "/api/Dispatcher.html#class-dispatcher",
+  "Cookie": "/api/Cookies.html#cookie",
+  "DispatchController": "/api/Dispatcher.html#class-dispatcher",
+  "DispatchHandler": "/api/Dispatcher.html#class-dispatcher",
+  "DispatchOptions": "/api/Dispatcher.html#class-dispatcher",
+  "Dispatcher": "/api/Dispatcher.html#class-dispatcher",
   "Duplex": "https://nodejs.org/api/stream.html#class-streamduplex",
-  "EnvHttpProxyAgent": "/api/EnvHttpProxyAgent.md#class-envhttpproxyagent",
-  "EnvHttpProxyAgentOptions": "/api/EnvHttpProxyAgent.md#new-envhttpproxyagentoptions",
+  "EnvHttpProxyAgent": "/api/EnvHttpProxyAgent.html#class-envhttpproxyagent",
+  "EnvHttpProxyAgentOptions": "/api/EnvHttpProxyAgent.html#new-envhttpproxyagentoptions",
   "EventEmitter": "https://nodejs.org/api/events.html#class-eventemitter",
-  "GetResult": "/api/CacheStore.md#getresult",
-  "H2CClientOptions": "/api/H2CClient.md#new-h2cclienturl-options",
+  "GetResult": "/api/CacheStore.html#getresult",
+  "H2CClientOptions": "/api/H2CClient.html#new-h2cclienturl-options",
   "HeadersInit": "https://developer.mozilla.org/docs/Web/API/Headers/Headers",
-  "InvalidArgumentError": "/api/Errors.md#class-invalidargumenterror",
+  "InvalidArgumentError": "/api/Errors.html#class-invalidargumenterror",
   "Iterable": "https://developer.mozilla.org/docs/Web/JavaScript/Reference/Iteration_protocols",
-  "MaxOriginsReachedError": "/api/Errors.md#class-maxoriginsreachederror",
-  "MockAgent": "/api/MockAgent.md#class-mockagent",
-  "MockAgentOptions": "/api/MockAgent.md#parameter-mockagentoptions",
-  "MockCallHistory": "/api/MockCallHistory.md#class-mockcallhistory",
-  "MockCallHistoryLog": "/api/MockCallHistoryLog.md#class-mockcallhistorylog",
-  "MockClient": "/api/MockClient.md#class-mockclient",
-  "MockClientOptions": "/api/MockClient.md#parameter-mockclientoptions",
-  "MockInterceptor": "/api/MockPool.md#return-mockinterceptor",
-  "MockInterceptor.Options": "/api/MockPool.md#parameter-mockpoolinterceptoptions",
-  "MockPool": "/api/MockPool.md#class-mockpool",
-  "MockPoolInterceptOptions": "/api/MockPool.md#parameter-mockpoolinterceptoptions",
-  "MockPoolOptions": "/api/MockPool.md#parameter-mockpooloptions",
-  "MockResponseOptions": "/api/MockPool.md#parameter-mockresponseoptions",
-  "MockScope": "/api/MockPool.md#return-mockscope",
-  "PendingInterceptor": "/api/MockAgent.md#new-mockagentoptions",
-  "PipelineOptions": "/api/Dispatcher.md#class-dispatcher",
-  "Pool": "/api/Pool.md#class-pool",
-  "PoolOptions": "/api/Pool.md#new-poolurl-options",
-  "PoolStats": "/api/PoolStats.md#class-poolstats",
-  "ProxyAgent": "/api/ProxyAgent.md#class-proxyagent",
-  "ProxyAgentOptions": "/api/ProxyAgent.md#new-proxyagentoptions",
+  "MaxOriginsReachedError": "/api/Errors.html#class-maxoriginsreachederror",
+  "MockAgent": "/api/MockAgent.html#class-mockagent",
+  "MockAgentOptions": "/api/MockAgent.html#parameter-mockagentoptions",
+  "MockCallHistory": "/api/MockCallHistory.html#class-mockcallhistory",
+  "MockCallHistoryLog": "/api/MockCallHistoryLog.html#class-mockcallhistorylog",
+  "MockClient": "/api/MockClient.html#class-mockclient",
+  "MockClientOptions": "/api/MockClient.html#parameter-mockclientoptions",
+  "MockInterceptor": "/api/MockPool.html#return-mockinterceptor",
+  "MockInterceptor.Options": "/api/MockPool.html#parameter-mockpoolinterceptoptions",
+  "MockPool": "/api/MockPool.html#class-mockpool",
+  "MockPoolInterceptOptions": "/api/MockPool.html#parameter-mockpoolinterceptoptions",
+  "MockPoolOptions": "/api/MockPool.html#parameter-mockpooloptions",
+  "MockResponseOptions": "/api/MockPool.html#parameter-mockresponseoptions",
+  "MockScope": "/api/MockPool.html#return-mockscope",
+  "PendingInterceptor": "/api/MockAgent.html#new-mockagentoptions",
+  "PipelineOptions": "/api/Dispatcher.html#class-dispatcher",
+  "Pool": "/api/Pool.html#class-pool",
+  "PoolOptions": "/api/Pool.html#new-poolurl-options",
+  "PoolStats": "/api/PoolStats.html#class-poolstats",
+  "ProxyAgent": "/api/ProxyAgent.html#class-proxyagent",
+  "ProxyAgentOptions": "/api/ProxyAgent.html#new-proxyagentoptions",
   "Readable": "https://nodejs.org/api/stream.html#class-streamreadable",
   "Record": "https://www.typescriptlang.org/docs/handbook/utility-types.html#recordkeys-type",
-  "RequestInit": "/api/Fetch.md#new-formdata",
-  "RequestOptions": "/api/Dispatcher.md#class-dispatcher",
-  "ResponseInit": "/api/Fetch.md#new-formdata",
-  "RetryContext": "/api/RetryHandler.md#retrycontext",
-  "RetryHandler": "/api/RetryHandler.md#class-retryhandler",
-  "RetryHandlers": "/api/RetryHandler.md#parameter-retryhandlers",
-  "RetryOptions": "/api/RetryHandler.md#retryoptions",
-  "RetryState": "/api/RetryHandler.md#retrystate",
-  "RoundRobinPoolOptions": "/api/RoundRobinPool.md#parameter-roundrobinpooloptions",
-  "SnapshotRecorder": "/api/SnapshotAgent.md#new-snapshotagentoptions",
+  "RequestInit": "/api/Fetch.html#new-formdata",
+  "RequestOptions": "/api/Dispatcher.html#class-dispatcher",
+  "ResponseInit": "/api/Fetch.html#new-formdata",
+  "RetryContext": "/api/RetryHandler.html#retrycontext",
+  "RetryHandler": "/api/RetryHandler.html#class-retryhandler",
+  "RetryHandlers": "/api/RetryHandler.html#parameter-retryhandlers",
+  "RetryOptions": "/api/RetryHandler.html#retryoptions",
+  "RetryState": "/api/RetryHandler.html#retrystate",
+  "RoundRobinPoolOptions": "/api/RoundRobinPool.html#parameter-roundrobinpooloptions",
+  "SnapshotRecorder": "/api/SnapshotAgent.html#new-snapshotagentoptions",
   "Socket": "https://nodejs.org/api/net.html#class-netsocket",
-  "SocketInfo": "/api/Errors.md#new-requestretryerrormessage-code-options",
-  "StreamOptions": "/api/Dispatcher.md#class-dispatcher",
+  "SocketInfo": "/api/Errors.html#new-requestretryerrormessage-code-options",
+  "StreamOptions": "/api/Dispatcher.html#class-dispatcher",
   "TLSSocket": "https://nodejs.org/api/tls.html#class-tlstlssocket",
-  "UndiciError": "/api/Errors.md#class-undicierror",
-  "UndiciHeaders": "/api/Dispatcher.md#class-dispatcher",
-  "UpgradeOptions": "/api/Dispatcher.md#class-dispatcher",
-  "UrlObject": "/index.md#urlobject",
-  "WebSocketInit": "/api/WebSocket.md#new-websocketurl-protocols",
-  "WebSocketStreamOptions": "/api/WebSocket.md#new-websocketurl-protocols",
+  "UndiciError": "/api/Errors.html#class-undicierror",
+  "UndiciHeaders": "/api/Dispatcher.html#class-dispatcher",
+  "UpgradeOptions": "/api/Dispatcher.html#class-dispatcher",
+  "UrlObject": "/index.html#urlobject",
+  "WebSocketInit": "/api/WebSocket.html#new-websocketurl-protocols",
+  "WebSocketStreamOptions": "/api/WebSocket.html#new-websocketurl-protocols",
   "Writable": "https://nodejs.org/api/stream.html#class-streamwritable",
-  "buildConnector.BuildOptions": "/api/Connector.md#buildconnectoroptions",
+  "buildConnector.BuildOptions": "/api/Connector.html#buildconnectoroptions",
   "net.Socket": "https://nodejs.org/api/net.html#class-netsocket",
   "stream.Readable": "https://nodejs.org/api/stream.html#class-streamreadable"
-}
+}

package/node_modules/undici/lib/cache/memory-cache-store.js

@@ -100,6 +100,11 @@ class MemoryCacheStore extends EventEmitter {
 
     const entry = entries ? findEntry(key, entries, now) : null
 
+    if (entry != null) {
+      this.#entries.delete(topLevelKey)
+      this.#entries.set(topLevelKey, entries)
+    }
+
     return entry == null
       ? undefined
       : {
@@ -148,11 +153,13 @@ class MemoryCacheStore extends EventEmitter {
       },
       final (callback) {
         let entries = store.#entries.get(topLevelKey)
-        if (!entries) {
+        if (entries) {
+          store.#entries.delete(topLevelKey)
+        } else {
           entries = []
-          store.#entries.set(topLevelKey, entries)
         }
-        const previousEntry = findEntry(key, entries, Date.now())
+        store.#entries.set(topLevelKey, entries)
+        const previousEntry = findEntry(key, entries, -Infinity)
         if (previousEntry) {
           const index = entries.indexOf(previousEntry)
           entries.splice(index, 1, entry)
@@ -177,16 +184,7 @@ class MemoryCacheStore extends EventEmitter {
             store.#hasEmittedMaxSizeEvent = true
           }
 
-          // Perform eviction
-          for (const [key, entries] of store.#entries) {
-            for (const entry of entries.splice(0, Math.ceil(entries.length / 2))) {
-              store.#size -= entry.size
-              store.#count -= 1
-            }
-            if (entries.length === 0) {
-              store.#entries.delete(key)
-            }
-          }
+          store.#evict(entry)
 
           // Reset the event flag after eviction
           if (store.#size < store.#maxSize && store.#count < store.#maxCount) {
@@ -199,6 +197,43 @@ class MemoryCacheStore extends EventEmitter {
     })
   }
 
+  #evict (keep) {
+    const targetSize = this.#maxSize / 2
+    const targetCount = this.#maxCount / 2
+
+    for (const [key, entries] of this.#entries) {
+      for (let i = 0; i < entries.length && (this.#size > targetSize || this.#count > targetCount);) {
+        const entry = entries[i]
+        if (entry === keep) {
+          i++
+          continue
+        }
+        entries.splice(i, 1)
+        this.#size -= entry.size
+        this.#count -= 1
+      }
+
+      if (entries.length === 0) {
+        this.#entries.delete(key)
+      }
+
+      if (this.#size <= targetSize && this.#count <= targetCount) {
+        return
+      }
+    }
+
+    if (this.#size > this.#maxSize || this.#count > this.#maxCount) {
+      const topLevelKey = `${keep.origin}:${keep.path}`
+      const entries = this.#entries.get(topLevelKey)
+      entries.splice(entries.indexOf(keep), 1)
+      this.#size -= keep.size
+      this.#count -= 1
+      if (entries.length === 0) {
+        this.#entries.delete(topLevelKey)
+      }
+    }
+  }
+
   /**
    * @param {CacheKey} key
    */

package/node_modules/undici/lib/cache/sqlite-cache-store.js

@@ -2,14 +2,22 @@
 
 const { Writable } = require('node:stream')
 const { assertCacheKey, assertCacheValue } = require('../util/cache.js')
+const { zstdCompressSync, zstdDecompressSync } = require('node:zlib')
 
 let DatabaseSync
 
-const VERSION = 3
+const VERSION = 4
 
 // 2gb
 const MAX_ENTRY_SIZE = 2 * 1000 * 1000 * 1000
 
+// 1MiB
+const COMPRESS_THRESHOLD = 1024 * 1024
+
+// zstd support landed in Node 22.19.0/23.4.0, so it may be missing even when
+// node:sqlite is available.
+const hasZstd = typeof zstdCompressSync === 'function' && typeof zstdDecompressSync === 'function'
+
 /**
  * @typedef {import('../../types/cache-interceptor.d.ts').default.CacheStore} CacheStore
  * @implements {CacheStore}
@@ -17,6 +25,7 @@ const MAX_ENTRY_SIZE = 2 * 1000 * 1000 * 1000
  * @typedef {{
  *  id: Readonly<number>,
  *  body?: Uint8Array
+ *  compressed?: string
  *  statusCode: number
  *  statusMessage: string
  *  headers?: string
@@ -31,6 +40,7 @@ const MAX_ENTRY_SIZE = 2 * 1000 * 1000 * 1000
 module.exports = class SqliteCacheStore {
   #maxEntrySize = MAX_ENTRY_SIZE
   #maxCount = Infinity
+  #compressThreshold = COMPRESS_THRESHOLD
 
   /**
    * @type {import('node:sqlite').DatabaseSync}
@@ -107,6 +117,17 @@ module.exports = class SqliteCacheStore {
         }
         this.#maxCount = opts.maxCount
       }
+
+      if (opts.compressThreshold !== undefined) {
+        if (
+          typeof opts.compressThreshold !== 'number' ||
+          !Number.isInteger(opts.compressThreshold) ||
+          opts.compressThreshold < 0
+        ) {
+          throw new TypeError('SqliteCacheStore options.compressThreshold must be a non-negative integer')
+        }
+        this.#compressThreshold = opts.compressThreshold
+      }
     }
 
     if (!DatabaseSync) {
@@ -128,6 +149,7 @@ module.exports = class SqliteCacheStore {
 
         -- Data returned to the interceptor
         body BUF NULL,
+        compressed TEXT NULL,
         deleteAt INTEGER NOT NULL,
         statusCode INTEGER NOT NULL,
         statusMessage TEXT NOT NULL,
@@ -147,6 +169,7 @@ module.exports = class SqliteCacheStore {
       SELECT
         id,
         body,
+        compressed,
         deleteAt,
         statusCode,
         statusMessage,
@@ -167,6 +190,7 @@ module.exports = class SqliteCacheStore {
     this.#updateValueQuery = this.#db.prepare(`
       UPDATE cacheInterceptorV${VERSION} SET
         body = ?,
+        compressed = ?,
         deleteAt = ?,
         statusCode = ?,
         statusMessage = ?,
@@ -185,6 +209,7 @@ module.exports = class SqliteCacheStore {
         url,
         method,
         body,
+        compressed,
         deleteAt,
         statusCode,
         statusMessage,
@@ -194,7 +219,7 @@ module.exports = class SqliteCacheStore {
         vary,
         cachedAt,
         staleAt
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `)
 
     this.#deleteByUrlQuery = this.#db.prepare(
@@ -237,7 +262,11 @@ module.exports = class SqliteCacheStore {
     const value = this.#findValue(key)
     return value
       ? {
-          body: value.body ? Buffer.from(value.body.buffer, value.body.byteOffset, value.body.byteLength) : undefined,
+          body: value.body
+            ? value.compressed === 'zstd'
+              ? zstdDecompressSync(Buffer.from(value.body.buffer, value.body.byteOffset, value.body.byteLength))
+              : Buffer.from(value.body.buffer, value.body.byteOffset, value.body.byteLength)
+            : undefined,
           statusCode: value.statusCode,
           statusMessage: value.statusMessage,
           headers: value.headers ? JSON.parse(value.headers) : undefined,
@@ -268,11 +297,22 @@ module.exports = class SqliteCacheStore {
       return
     }
 
+    let compressed = null
+    let storedBody = body
+    if (body && hasZstd && (size > this.#compressThreshold || isCompressibleContentType(getContentType(value.headers)))) {
+      const candidate = zstdCompressSync(body)
+      if (candidate.byteLength < body.byteLength) {
+        storedBody = candidate
+        compressed = 'zstd'
+      }
+    }
+
     const existingValue = this.#findValue(key, true)
     if (existingValue) {
       // Updating an existing response, let's overwrite it
       this.#updateValueQuery.run(
-        body,
+        storedBody,
+        compressed,
         value.deleteAt,
         value.statusCode,
         value.statusMessage,
@@ -289,7 +329,8 @@ module.exports = class SqliteCacheStore {
       this.#insertValueQuery.run(
         url,
         key.method,
-        body,
+        storedBody,
+        compressed,
         value.deleteAt,
         value.statusCode,
         value.statusMessage,
@@ -467,3 +508,40 @@ function headerValueEquals (lhs, rhs) {
 
   return lhs === rhs
 }
+
+/**
+ * @param {Record<string, string|string[]>|null|undefined} headers
+ * @returns {string|undefined}
+ */
+function getContentType (headers) {
+  if (headers == null) {
+    return undefined
+  }
+
+  for (const key in headers) {
+    if (key.toLowerCase() === 'content-type') {
+      const value = headers[key]
+      return Array.isArray(value) ? value[0] : value
+    }
+  }
+
+  return undefined
+}
+
+/**
+ * @param {string|undefined} contentType
+ * @returns {boolean}
+ */
+function isCompressibleContentType (contentType) {
+  if (contentType == null) {
+    return false
+  }
+
+  const type = contentType.toLowerCase()
+
+  // text/* and application/json, xml, javascript, ... are easily compressible
+  // even at smaller sizes, so ignore the compressThreshold for them.
+  return /^text\//.test(type) ||
+    /^application\/(json|xml|javascript|x-www-form-urlencoded|graphql)(\s|;|$)/.test(type) ||
+    /\+(json|xml)(\s|;|$)/.test(type)
+}

package/node_modules/undici/lib/core/connect.js

@@ -41,16 +41,22 @@ const SessionCache = class WeakSessionCache {
     if (this._sessionCache.has(sessionKey)) {
       this._sessionCache.delete(sessionKey)
     } else if (this._sessionCache.size >= this._maxCachedSessions) {
+      // Make room for the new session: prefer an entry whose session has
+      // already been collected, otherwise evict the oldest one.
+      let evicted = false
       for (const [key, ref] of this._sessionCache) {
         if (ref.deref() === undefined) {
           this._sessionCache.delete(key)
-          return
+          evicted = true
+          break
         }
       }
 
-      const oldest = this._sessionCache.keys().next()
-      if (!oldest.done) {
-        this._sessionCache.delete(oldest.value)
+      if (!evicted) {
+        const oldest = this._sessionCache.keys().next()
+        if (!oldest.done) {
+          this._sessionCache.delete(oldest.value)
+        }
       }
     }
 

package/node_modules/undici/lib/core/constants.js

@@ -114,7 +114,18 @@ for (let i = 0; i < wellknownHeaderNames.length; ++i) {
     lowerCasedKey
 }
 
+/**
+ * Default WebSocket receive limits (see `webSocket` in Client.md). Used by
+ * DispatcherBase#webSocketOptions and by the WebSocket parser when the
+ * dispatcher doesn't provide a value, so a dispatcher without
+ * `webSocketOptions` (a custom one, or a wrapper) doesn't remove the limits.
+ */
+const defaultWebSocketMaxFragments = 131072
+const defaultWebSocketMaxPayloadSize = 128 * 1024 * 1024 // 128 MB
+
 module.exports = {
   wellknownHeaderNames,
-  headerNameLowerCasedRecord
+  headerNameLowerCasedRecord,
+  defaultWebSocketMaxFragments,
+  defaultWebSocketMaxPayloadSize
 }

package/node_modules/undici/lib/core/errors.js

@@ -306,6 +306,22 @@ class BalancedPoolMissingUpstreamError extends UndiciError {
   }
 }
 
+const kWebAssemblyNotSupportedError = Symbol.for('undici.error.ERR_WEBASSEMBLY_NOT_SUPPORTED')
+class WebAssemblyNotSupportedError extends Error {
+  constructor (message) {
+    super(message || 'WebAssembly is not supported in this environment, but is required for HTTP/1 parsing')
+    this.code = 'ERR_WEBASSEMBLY_NOT_SUPPORTED'
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kWebAssemblyNotSupportedError] === true
+  }
+
+  get [kWebAssemblyNotSupportedError] () {
+    return true
+  }
+}
+
 const kHTTPParserError = Symbol.for('undici.error.UND_ERR_HTTP_PARSER')
 class HTTPParserError extends Error {
   constructor (message, code, data) {
@@ -365,13 +381,14 @@ class RequestRetryError extends UndiciError {
 
 const kResponseError = Symbol.for('undici.error.UND_ERR_RESPONSE')
 class ResponseError extends UndiciError {
-  constructor (message, code, { headers, body }) {
+  constructor (message, code, { headers, body, bodyTruncated = false }) {
     super(message)
     this.name = 'ResponseError'
     this.message = message || 'Response error'
     this.code = 'UND_ERR_RESPONSE'
     this.statusCode = code
     this.body = body
+    this.bodyTruncated = bodyTruncated
     this.headers = headers
   }
 
@@ -422,6 +439,24 @@ class ProxyConnectionError extends UndiciError {
   }
 }
 
+const kMaxRedirectsError = Symbol.for('undici.error.UND_ERR_REDIRECT_MAX')
+class MaxRedirectsError extends UndiciError {
+  constructor (message) {
+    super(message)
+    this.name = 'MaxRedirectsError'
+    this.message = message || 'max redirects'
+    this.code = 'UND_ERR_REDIRECT_MAX'
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kMaxRedirectsError] === true
+  }
+
+  get [kMaxRedirectsError] () {
+    return true
+  }
+}
+
 const kMaxOriginsReachedError = Symbol.for('undici.error.UND_ERR_MAX_ORIGINS_REACHED')
 class MaxOriginsReachedError extends UndiciError {
   constructor (message) {
@@ -469,6 +504,7 @@ class MessageSizeExceededError extends UndiciError {
 
 module.exports = {
   AbortError,
+  WebAssemblyNotSupportedError,
   HTTPParserError,
   UndiciError,
   HeadersTimeoutError,
@@ -492,6 +528,7 @@ module.exports = {
   SecureProxyConnectionError,
   ProxyConnectionError,
   MaxOriginsReachedError,
+  MaxRedirectsError,
   Socks5ProxyError,
   MessageSizeExceededError
 }

package/node_modules/undici/lib/core/request.js

@@ -206,7 +206,12 @@ class Request {
       this.body = body.byteLength ? Buffer.from(body) : null
     } else if (typeof body === 'string') {
       this.body = body.length ? Buffer.from(body) : null
-    } else if (isFormDataLike(body) || isIterable(body) || isBlobLike(body)) {
+    } else if (isFormDataLike(body)) {
+      if (!isUndiciFormData(body)) {
+        throw new InvalidArgumentError('body must be a FormData created by this undici package instance; FormData from other sources, such as the built-in FormData provided by Node.js, is not supported')
+      }
+      this.body = body
+    } else if (isIterable(body) || isBlobLike(body)) {
       this.body = body
     } else {
       throw new InvalidArgumentError('body must be a string, a Buffer, a Readable stream, an iterable, or an async iterable')
@@ -564,4 +569,14 @@ function processHeader (request, key, val) {
   }
 }
 
+let isFormData
+
+function isUndiciFormData (body) {
+  if (isFormData === undefined) {
+    require('../web/fetch/formdata')
+    isFormData = require('../web/webidl').webidl.is.FormData
+  }
+  return isFormData(body)
+}
+
 module.exports = Request

package/node_modules/undici/lib/core/symbols.js

@@ -6,6 +6,7 @@ module.exports = {
   kDispatch: Symbol('dispatch'),
   kUrl: Symbol('url'),
   kRequestOrigin: Symbol('request origin'),
+  kRedirectCacheControl: Symbol('redirect cache control'),
   kOriginless: Symbol('originless'),
   kWriting: Symbol('writing'),
   kResuming: Symbol('resuming'),
@@ -72,6 +73,7 @@ module.exports = {
   kRemoteSettings: Symbol('http2session remote settings'),
   kHTTP2Stream: Symbol('http2session client stream'),
   kPingInterval: Symbol('ping interval'),
+  kUseMilo: Symbol('use milo'),
   kNoProxyAgent: Symbol('no proxy agent'),
   kHttpProxyAgent: Symbol('http proxy agent'),
   kHttpsProxyAgent: Symbol('https proxy agent'),

package/node_modules/undici/lib/core/util.js

@@ -387,7 +387,7 @@ function destroy (stream, err) {
   }
 }
 
-const KEEPALIVE_TIMEOUT_EXPR = /timeout=(\d+)/
+const KEEPALIVE_TIMEOUT_EXPR = /(?:^|,)[\t ]*timeout=(\d+)/i
 /**
  * @param {string} val
  * @returns {number | null}
@@ -417,6 +417,30 @@ function bufferToLowerCasedHeaderName (value) {
   return tree.lookup(value) ?? value.toString('latin1').toLowerCase()
 }
 
+/**
+ * Writes a header onto a plain object without going through the
+ * `Object.prototype` `__proto__` setter. Plain assignment there drops a string
+ * value and, when the value is an array, replaces the object's prototype
+ * instead of storing anything. Every other name is a normal assignment.
+ *
+ * @param {Record<string, string | string[]>} obj Accumulator to write onto
+ * @param {string} key Header name
+ * @param {string | string[]} value Header value
+ * @returns {void}
+ */
+function setHeader (obj, key, value) {
+  if (key === '__proto__') {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    })
+  } else {
+    obj[key] = value
+  }
+}
+
 /**
  * @param {(Buffer | string)[]} headers
  * @param {Record<string, string | string[]>} [obj]
@@ -984,6 +1008,7 @@ module.exports = {
   toRawHeaders,
   encodeRawHeaders,
   parseHeaders,
+  setHeader,
   parseKeepAliveTimeout,
   destroy,
   bodyLength,

package/node_modules/undici/lib/dispatcher/agent.js

@@ -22,7 +22,7 @@ function defaultFactory (origin, opts) {
 }
 
 class Agent extends DispatcherBase {
-  constructor ({ factory = defaultFactory, maxOrigins = Infinity, connect, ...options } = {}) {
+  constructor ({ factory = defaultFactory, maxOrigins = Infinity, connect, tls, ...options } = {}) {
     if (typeof factory !== 'function') {
       throw new InvalidArgumentError('factory must be a function.')
     }
@@ -41,7 +41,11 @@ class Agent extends DispatcherBase {
       connect = { ...connect }
     }
 
-    this[kOptions] = { ...util.deepClone(options), maxOrigins, connect }
+    if (tls && typeof tls !== 'function') {
+      tls = { ...tls }
+    }
+
+    this[kOptions] = { ...util.deepClone(options), maxOrigins, connect, tls }
     this[kFactory] = factory
     this[kClients] = new Map()
     this[kOrigins] = new Set()