@node-core/utils 7.2.1 → 7.2.3

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

@@ -1,153 +0,0 @@
-'use strict'
-
-const net = require('node:net')
-const assert = require('node:assert')
-const util = require('./util')
-const { InvalidArgumentError } = require('./errors')
-
-let tls // include tls conditionally since it is not always available
-
-// TODO: session re-use does not wait for the first
-// connection to resolve the session and might therefore
-// resolve the same servername multiple times even when
-// re-use is enabled.
-
-const SessionCache = class WeakSessionCache {
-  constructor (maxCachedSessions) {
-    this._maxCachedSessions = maxCachedSessions
-    this._sessionCache = new Map()
-    this._sessionRegistry = new FinalizationRegistry((key) => {
-      if (this._sessionCache.size < this._maxCachedSessions) {
-        return
-      }
-
-      const ref = this._sessionCache.get(key)
-      if (ref !== undefined && ref.deref() === undefined) {
-        this._sessionCache.delete(key)
-      }
-    })
-  }
-
-  get (sessionKey) {
-    const ref = this._sessionCache.get(sessionKey)
-    return ref ? ref.deref() : null
-  }
-
-  set (sessionKey, session) {
-    if (this._maxCachedSessions === 0) {
-      return
-    }
-
-    if (this._sessionCache.has(sessionKey)) {
-      this._sessionCache.delete(sessionKey)
-    } else if (this._sessionCache.size >= this._maxCachedSessions) {
-      for (const [key, ref] of this._sessionCache) {
-        if (ref.deref() === undefined) {
-          this._sessionCache.delete(key)
-          return
-        }
-      }
-
-      const oldest = this._sessionCache.keys().next()
-      if (!oldest.done) {
-        this._sessionCache.delete(oldest.value)
-      }
-    }
-
-    this._sessionCache.set(sessionKey, new WeakRef(session))
-    this._sessionRegistry.register(session, sessionKey)
-  }
-}
-
-function buildConnector ({ allowH2, useH2c, maxCachedSessions, socketPath, timeout, session: customSession, ...opts }) {
-  if (maxCachedSessions != null && (!Number.isInteger(maxCachedSessions) || maxCachedSessions < 0)) {
-    throw new InvalidArgumentError('maxCachedSessions must be a positive integer or zero')
-  }
-
-  const options = { path: socketPath, ...opts }
-  const sessionCache = new SessionCache(maxCachedSessions == null ? 100 : maxCachedSessions)
-  timeout = timeout == null ? 10e3 : timeout
-  allowH2 = allowH2 != null ? allowH2 : false
-  return function connect ({ hostname, host, protocol, port, servername, localAddress, httpSocket }, callback) {
-    let socket
-    if (protocol === 'https:') {
-      if (!tls) {
-        tls = require('node:tls')
-      }
-      servername = servername || options.servername || util.getServerName(host) || null
-
-      const sessionKey = servername || hostname
-      assert(sessionKey)
-
-      const session = customSession || sessionCache.get(sessionKey) || null
-
-      port = port || 443
-
-      socket = tls.connect({
-        highWaterMark: 16384, // TLS in node can't have bigger HWM anyway...
-        ...options,
-        servername,
-        session,
-        localAddress,
-        ALPNProtocols: allowH2 ? ['http/1.1', 'h2'] : ['http/1.1'],
-        socket: httpSocket, // upgrade socket connection
-        port,
-        host: hostname
-      })
-
-      socket
-        .on('session', function (session) {
-          // TODO (fix): Can a session become invalid once established? Don't think so?
-          sessionCache.set(sessionKey, session)
-        })
-    } else {
-      assert(!httpSocket, 'httpSocket can only be sent on TLS update')
-
-      port = port || 80
-
-      socket = net.connect({
-        highWaterMark: 64 * 1024, // Same as nodejs fs streams.
-        ...options,
-        localAddress,
-        port,
-        host: hostname
-      })
-      if (useH2c === true) {
-        socket.alpnProtocol = 'h2'
-      }
-    }
-
-    // Set TCP keep alive options on the socket here instead of in connect() for the case of assigning the socket
-    if (options.keepAlive == null || options.keepAlive) {
-      const keepAliveInitialDelay = options.keepAliveInitialDelay === undefined ? 60e3 : options.keepAliveInitialDelay
-      socket.setKeepAlive(true, keepAliveInitialDelay)
-    }
-
-    const clearConnectTimeout = util.setupConnectTimeout(new WeakRef(socket), { timeout, hostname, port })
-
-    socket
-      .setNoDelay(true)
-      .once(protocol === 'https:' ? 'secureConnect' : 'connect', function () {
-        queueMicrotask(clearConnectTimeout)
-
-        if (callback) {
-          const cb = callback
-          callback = null
-          cb(null, this)
-        }
-      })
-      .on('error', function (err) {
-        queueMicrotask(clearConnectTimeout)
-
-        if (callback) {
-          const cb = callback
-          callback = null
-          cb(err)
-        }
-      })
-
-    return socket
-  }
-}
-
-module.exports = buildConnector

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

@@ -1,143 +0,0 @@
-'use strict'
-
-/**
- * @see https://developer.mozilla.org/docs/Web/HTTP/Headers
- */
-const wellknownHeaderNames = /** @type {const} */ ([
-  'Accept',
-  'Accept-Encoding',
-  'Accept-Language',
-  'Accept-Ranges',
-  'Access-Control-Allow-Credentials',
-  'Access-Control-Allow-Headers',
-  'Access-Control-Allow-Methods',
-  'Access-Control-Allow-Origin',
-  'Access-Control-Expose-Headers',
-  'Access-Control-Max-Age',
-  'Access-Control-Request-Headers',
-  'Access-Control-Request-Method',
-  'Age',
-  'Allow',
-  'Alt-Svc',
-  'Alt-Used',
-  'Authorization',
-  'Cache-Control',
-  'Clear-Site-Data',
-  'Connection',
-  'Content-Disposition',
-  'Content-Encoding',
-  'Content-Language',
-  'Content-Length',
-  'Content-Location',
-  'Content-Range',
-  'Content-Security-Policy',
-  'Content-Security-Policy-Report-Only',
-  'Content-Type',
-  'Cookie',
-  'Cross-Origin-Embedder-Policy',
-  'Cross-Origin-Opener-Policy',
-  'Cross-Origin-Resource-Policy',
-  'Date',
-  'Device-Memory',
-  'Downlink',
-  'ECT',
-  'ETag',
-  'Expect',
-  'Expect-CT',
-  'Expires',
-  'Forwarded',
-  'From',
-  'Host',
-  'If-Match',
-  'If-Modified-Since',
-  'If-None-Match',
-  'If-Range',
-  'If-Unmodified-Since',
-  'Keep-Alive',
-  'Last-Modified',
-  'Link',
-  'Location',
-  'Max-Forwards',
-  'Origin',
-  'Permissions-Policy',
-  'Pragma',
-  'Proxy-Authenticate',
-  'Proxy-Authorization',
-  'RTT',
-  'Range',
-  'Referer',
-  'Referrer-Policy',
-  'Refresh',
-  'Retry-After',
-  'Sec-WebSocket-Accept',
-  'Sec-WebSocket-Extensions',
-  'Sec-WebSocket-Key',
-  'Sec-WebSocket-Protocol',
-  'Sec-WebSocket-Version',
-  'Server',
-  'Server-Timing',
-  'Service-Worker-Allowed',
-  'Service-Worker-Navigation-Preload',
-  'Set-Cookie',
-  'SourceMap',
-  'Strict-Transport-Security',
-  'Supports-Loading-Mode',
-  'TE',
-  'Timing-Allow-Origin',
-  'Trailer',
-  'Transfer-Encoding',
-  'Upgrade',
-  'Upgrade-Insecure-Requests',
-  'User-Agent',
-  'Vary',
-  'Via',
-  'WWW-Authenticate',
-  'X-Content-Type-Options',
-  'X-DNS-Prefetch-Control',
-  'X-Frame-Options',
-  'X-Permitted-Cross-Domain-Policies',
-  'X-Powered-By',
-  'X-Requested-With',
-  'X-XSS-Protection'
-])
-
-/** @type {Record<typeof wellknownHeaderNames[number]|Lowercase<typeof wellknownHeaderNames[number]>, string>} */
-const headerNameLowerCasedRecord = {}
-
-// Note: object prototypes should not be able to be referenced. e.g. `Object#hasOwnProperty`.
-Object.setPrototypeOf(headerNameLowerCasedRecord, null)
-
-/**
- * @type {Record<Lowercase<typeof wellknownHeaderNames[number]>, Buffer>}
- */
-const wellknownHeaderNameBuffers = {}
-
-// Note: object prototypes should not be able to be referenced. e.g. `Object#hasOwnProperty`.
-Object.setPrototypeOf(wellknownHeaderNameBuffers, null)
-
-/**
- * @param {string} header Lowercased header
- * @returns {Buffer}
- */
-function getHeaderNameAsBuffer (header) {
-  let buffer = wellknownHeaderNameBuffers[header]
-
-  if (buffer === undefined) {
-    buffer = Buffer.from(header)
-  }
-
-  return buffer
-}
-
-for (let i = 0; i < wellknownHeaderNames.length; ++i) {
-  const key = wellknownHeaderNames[i]
-  const lowerCasedKey = key.toLowerCase()
-  headerNameLowerCasedRecord[key] = headerNameLowerCasedRecord[lowerCasedKey] =
-    lowerCasedKey
-}
-
-module.exports = {
-  wellknownHeaderNames,
-  headerNameLowerCasedRecord,
-  getHeaderNameAsBuffer
-}

package/node_modules/cheerio/node_modules/undici/lib/core/diagnostics.js

@@ -1,227 +0,0 @@
-'use strict'
-
-const diagnosticsChannel = require('node:diagnostics_channel')
-const util = require('node:util')
-
-const undiciDebugLog = util.debuglog('undici')
-const fetchDebuglog = util.debuglog('fetch')
-const websocketDebuglog = util.debuglog('websocket')
-
-const channels = {
-  // Client
-  beforeConnect: diagnosticsChannel.channel('undici:client:beforeConnect'),
-  connected: diagnosticsChannel.channel('undici:client:connected'),
-  connectError: diagnosticsChannel.channel('undici:client:connectError'),
-  sendHeaders: diagnosticsChannel.channel('undici:client:sendHeaders'),
-  // Request
-  create: diagnosticsChannel.channel('undici:request:create'),
-  bodySent: diagnosticsChannel.channel('undici:request:bodySent'),
-  bodyChunkSent: diagnosticsChannel.channel('undici:request:bodyChunkSent'),
-  bodyChunkReceived: diagnosticsChannel.channel('undici:request:bodyChunkReceived'),
-  headers: diagnosticsChannel.channel('undici:request:headers'),
-  trailers: diagnosticsChannel.channel('undici:request:trailers'),
-  error: diagnosticsChannel.channel('undici:request:error'),
-  // WebSocket
-  open: diagnosticsChannel.channel('undici:websocket:open'),
-  close: diagnosticsChannel.channel('undici:websocket:close'),
-  socketError: diagnosticsChannel.channel('undici:websocket:socket_error'),
-  ping: diagnosticsChannel.channel('undici:websocket:ping'),
-  pong: diagnosticsChannel.channel('undici:websocket:pong'),
-  // ProxyAgent
-  proxyConnected: diagnosticsChannel.channel('undici:proxy:connected')
-}
-
-let isTrackingClientEvents = false
-
-function trackClientEvents (debugLog = undiciDebugLog) {
-  if (isTrackingClientEvents) {
-    return
-  }
-
-  // Check if any of the channels already have subscribers to prevent duplicate subscriptions
-  // This can happen when both Node.js built-in undici and undici as a dependency are present
-  if (channels.beforeConnect.hasSubscribers || channels.connected.hasSubscribers ||
-      channels.connectError.hasSubscribers || channels.sendHeaders.hasSubscribers) {
-    isTrackingClientEvents = true
-    return
-  }
-
-  isTrackingClientEvents = true
-
-  diagnosticsChannel.subscribe('undici:client:beforeConnect',
-    evt => {
-      const {
-        connectParams: { version, protocol, port, host }
-      } = evt
-      debugLog(
-        'connecting to %s%s using %s%s',
-        host,
-        port ? `:${port}` : '',
-        protocol,
-        version
-      )
-    })
-
-  diagnosticsChannel.subscribe('undici:client:connected',
-    evt => {
-      const {
-        connectParams: { version, protocol, port, host }
-      } = evt
-      debugLog(
-        'connected to %s%s using %s%s',
-        host,
-        port ? `:${port}` : '',
-        protocol,
-        version
-      )
-    })
-
-  diagnosticsChannel.subscribe('undici:client:connectError',
-    evt => {
-      const {
-        connectParams: { version, protocol, port, host },
-        error
-      } = evt
-      debugLog(
-        'connection to %s%s using %s%s errored - %s',
-        host,
-        port ? `:${port}` : '',
-        protocol,
-        version,
-        error.message
-      )
-    })
-
-  diagnosticsChannel.subscribe('undici:client:sendHeaders',
-    evt => {
-      const {
-        request: { method, path, origin }
-      } = evt
-      debugLog('sending request to %s %s%s', method, origin, path)
-    })
-}
-
-let isTrackingRequestEvents = false
-
-function trackRequestEvents (debugLog = undiciDebugLog) {
-  if (isTrackingRequestEvents) {
-    return
-  }
-
-  // Check if any of the channels already have subscribers to prevent duplicate subscriptions
-  // This can happen when both Node.js built-in undici and undici as a dependency are present
-  if (channels.headers.hasSubscribers || channels.trailers.hasSubscribers ||
-      channels.error.hasSubscribers) {
-    isTrackingRequestEvents = true
-    return
-  }
-
-  isTrackingRequestEvents = true
-
-  diagnosticsChannel.subscribe('undici:request:headers',
-    evt => {
-      const {
-        request: { method, path, origin },
-        response: { statusCode }
-      } = evt
-      debugLog(
-        'received response to %s %s%s - HTTP %d',
-        method,
-        origin,
-        path,
-        statusCode
-      )
-    })
-
-  diagnosticsChannel.subscribe('undici:request:trailers',
-    evt => {
-      const {
-        request: { method, path, origin }
-      } = evt
-      debugLog('trailers received from %s %s%s', method, origin, path)
-    })
-
-  diagnosticsChannel.subscribe('undici:request:error',
-    evt => {
-      const {
-        request: { method, path, origin },
-        error
-      } = evt
-      debugLog(
-        'request to %s %s%s errored - %s',
-        method,
-        origin,
-        path,
-        error.message
-      )
-    })
-}
-
-let isTrackingWebSocketEvents = false
-
-function trackWebSocketEvents (debugLog = websocketDebuglog) {
-  if (isTrackingWebSocketEvents) {
-    return
-  }
-
-  // Check if any of the channels already have subscribers to prevent duplicate subscriptions
-  // This can happen when both Node.js built-in undici and undici as a dependency are present
-  if (channels.open.hasSubscribers || channels.close.hasSubscribers ||
-      channels.socketError.hasSubscribers || channels.ping.hasSubscribers ||
-      channels.pong.hasSubscribers) {
-    isTrackingWebSocketEvents = true
-    return
-  }
-
-  isTrackingWebSocketEvents = true
-
-  diagnosticsChannel.subscribe('undici:websocket:open',
-    evt => {
-      if (evt.address != null) {
-        const { address, port } = evt.address
-        debugLog('connection opened %s%s', address, port ? `:${port}` : '')
-      } else {
-        debugLog('connection opened')
-      }
-    })
-
-  diagnosticsChannel.subscribe('undici:websocket:close',
-    evt => {
-      const { websocket, code, reason } = evt
-      debugLog(
-        'closed connection to %s - %s %s',
-        websocket.url,
-        code,
-        reason
-      )
-    })
-
-  diagnosticsChannel.subscribe('undici:websocket:socket_error',
-    err => {
-      debugLog('connection errored - %s', err.message)
-    })
-
-  diagnosticsChannel.subscribe('undici:websocket:ping',
-    evt => {
-      debugLog('ping received')
-    })
-
-  diagnosticsChannel.subscribe('undici:websocket:pong',
-    evt => {
-      debugLog('pong received')
-    })
-}
-
-if (undiciDebugLog.enabled || fetchDebuglog.enabled) {
-  trackClientEvents(fetchDebuglog.enabled ? fetchDebuglog : undiciDebugLog)
-  trackRequestEvents(fetchDebuglog.enabled ? fetchDebuglog : undiciDebugLog)
-}
-
-if (websocketDebuglog.enabled) {
-  trackClientEvents(undiciDebugLog.enabled ? undiciDebugLog : websocketDebuglog)
-  trackWebSocketEvents(websocketDebuglog)
-}
-
-module.exports = {
-  channels
-}