deepv-code 1.0.182 → 1.0.185

package/bundle/node_modules/undici/lib/dispatcher/pool-base.js

@@ -1,191 +0,0 @@
-'use strict'
-
-const { PoolStats } = require('../util/stats.js')
-const DispatcherBase = require('./dispatcher-base')
-const FixedQueue = require('./fixed-queue')
-const { kConnected, kSize, kRunning, kPending, kQueued, kBusy, kFree, kUrl, kClose, kDestroy, kDispatch } = require('../core/symbols')
-
-const kClients = Symbol('clients')
-const kNeedDrain = Symbol('needDrain')
-const kQueue = Symbol('queue')
-const kClosedResolve = Symbol('closed resolve')
-const kOnDrain = Symbol('onDrain')
-const kOnConnect = Symbol('onConnect')
-const kOnDisconnect = Symbol('onDisconnect')
-const kOnConnectionError = Symbol('onConnectionError')
-const kGetDispatcher = Symbol('get dispatcher')
-const kAddClient = Symbol('add client')
-const kRemoveClient = Symbol('remove client')
-
-class PoolBase extends DispatcherBase {
-  constructor () {
-    super()
-
-    this[kQueue] = new FixedQueue()
-    this[kClients] = []
-    this[kQueued] = 0
-
-    const pool = this
-
-    this[kOnDrain] = function onDrain (origin, targets) {
-      const queue = pool[kQueue]
-
-      let needDrain = false
-
-      while (!needDrain) {
-        const item = queue.shift()
-        if (!item) {
-          break
-        }
-        pool[kQueued]--
-        needDrain = !this.dispatch(item.opts, item.handler)
-      }
-
-      this[kNeedDrain] = needDrain
-
-      if (!this[kNeedDrain] && pool[kNeedDrain]) {
-        pool[kNeedDrain] = false
-        pool.emit('drain', origin, [pool, ...targets])
-      }
-
-      if (pool[kClosedResolve] && queue.isEmpty()) {
-        Promise
-          .all(pool[kClients].map(c => c.close()))
-          .then(pool[kClosedResolve])
-      }
-    }
-
-    this[kOnConnect] = (origin, targets) => {
-      pool.emit('connect', origin, [pool, ...targets])
-    }
-
-    this[kOnDisconnect] = (origin, targets, err) => {
-      pool.emit('disconnect', origin, [pool, ...targets], err)
-    }
-
-    this[kOnConnectionError] = (origin, targets, err) => {
-      pool.emit('connectionError', origin, [pool, ...targets], err)
-    }
-  }
-
-  get [kBusy] () {
-    return this[kNeedDrain]
-  }
-
-  get [kConnected] () {
-    return this[kClients].filter(client => client[kConnected]).length
-  }
-
-  get [kFree] () {
-    return this[kClients].filter(client => client[kConnected] && !client[kNeedDrain]).length
-  }
-
-  get [kPending] () {
-    let ret = this[kQueued]
-    for (const { [kPending]: pending } of this[kClients]) {
-      ret += pending
-    }
-    return ret
-  }
-
-  get [kRunning] () {
-    let ret = 0
-    for (const { [kRunning]: running } of this[kClients]) {
-      ret += running
-    }
-    return ret
-  }
-
-  get [kSize] () {
-    let ret = this[kQueued]
-    for (const { [kSize]: size } of this[kClients]) {
-      ret += size
-    }
-    return ret
-  }
-
-  get stats () {
-    return new PoolStats(this)
-  }
-
-  async [kClose] () {
-    if (this[kQueue].isEmpty()) {
-      await Promise.all(this[kClients].map(c => c.close()))
-    } else {
-      await new Promise((resolve) => {
-        this[kClosedResolve] = resolve
-      })
-    }
-  }
-
-  async [kDestroy] (err) {
-    while (true) {
-      const item = this[kQueue].shift()
-      if (!item) {
-        break
-      }
-      item.handler.onError(err)
-    }
-
-    await Promise.all(this[kClients].map(c => c.destroy(err)))
-  }
-
-  [kDispatch] (opts, handler) {
-    const dispatcher = this[kGetDispatcher]()
-
-    if (!dispatcher) {
-      this[kNeedDrain] = true
-      this[kQueue].push({ opts, handler })
-      this[kQueued]++
-    } else if (!dispatcher.dispatch(opts, handler)) {
-      dispatcher[kNeedDrain] = true
-      this[kNeedDrain] = !this[kGetDispatcher]()
-    }
-
-    return !this[kNeedDrain]
-  }
-
-  [kAddClient] (client) {
-    client
-      .on('drain', this[kOnDrain])
-      .on('connect', this[kOnConnect])
-      .on('disconnect', this[kOnDisconnect])
-      .on('connectionError', this[kOnConnectionError])
-
-    this[kClients].push(client)
-
-    if (this[kNeedDrain]) {
-      queueMicrotask(() => {
-        if (this[kNeedDrain]) {
-          this[kOnDrain](client[kUrl], [this, client])
-        }
-      })
-    }
-
-    return this
-  }
-
-  [kRemoveClient] (client) {
-    client.close(() => {
-      const idx = this[kClients].indexOf(client)
-      if (idx !== -1) {
-        this[kClients].splice(idx, 1)
-      }
-    })
-
-    this[kNeedDrain] = this[kClients].some(dispatcher => (
-      !dispatcher[kNeedDrain] &&
-      dispatcher.closed !== true &&
-      dispatcher.destroyed !== true
-    ))
-  }
-}
-
-module.exports = {
-  PoolBase,
-  kClients,
-  kNeedDrain,
-  kAddClient,
-  kRemoveClient,
-  kGetDispatcher
-}

package/bundle/node_modules/undici/lib/dispatcher/pool.js

@@ -1,118 +0,0 @@
-'use strict'
-
-const {
-  PoolBase,
-  kClients,
-  kNeedDrain,
-  kAddClient,
-  kGetDispatcher,
-  kRemoveClient
-} = require('./pool-base')
-const Client = require('./client')
-const {
-  InvalidArgumentError
-} = require('../core/errors')
-const util = require('../core/util')
-const { kUrl } = require('../core/symbols')
-const buildConnector = require('../core/connect')
-
-const kOptions = Symbol('options')
-const kConnections = Symbol('connections')
-const kFactory = Symbol('factory')
-
-function defaultFactory (origin, opts) {
-  return new Client(origin, opts)
-}
-
-class Pool extends PoolBase {
-  constructor (origin, {
-    connections,
-    factory = defaultFactory,
-    connect,
-    connectTimeout,
-    tls,
-    maxCachedSessions,
-    socketPath,
-    autoSelectFamily,
-    autoSelectFamilyAttemptTimeout,
-    allowH2,
-    clientTtl,
-    ...options
-  } = {}) {
-    if (connections != null && (!Number.isFinite(connections) || connections < 0)) {
-      throw new InvalidArgumentError('invalid connections')
-    }
-
-    if (typeof factory !== 'function') {
-      throw new InvalidArgumentError('factory must be a function.')
-    }
-
-    if (connect != null && typeof connect !== 'function' && typeof connect !== 'object') {
-      throw new InvalidArgumentError('connect must be a function or an object')
-    }
-
-    super()
-
-    if (typeof connect !== 'function') {
-      connect = buildConnector({
-        ...tls,
-        maxCachedSessions,
-        allowH2,
-        socketPath,
-        timeout: connectTimeout,
-        ...(typeof autoSelectFamily === 'boolean' ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : undefined),
-        ...connect
-      })
-    }
-
-    this[kConnections] = connections || null
-    this[kUrl] = util.parseOrigin(origin)
-    this[kOptions] = { ...util.deepClone(options), connect, allowH2, clientTtl }
-    this[kOptions].interceptors = options.interceptors
-      ? { ...options.interceptors }
-      : undefined
-    this[kFactory] = factory
-
-    this.on('connect', (origin, targets) => {
-      if (clientTtl != null && clientTtl > 0) {
-        for (const target of targets) {
-          Object.assign(target, { ttl: Date.now() })
-        }
-      }
-    })
-
-    this.on('connectionError', (origin, targets, error) => {
-      // If a connection error occurs, we remove the client from the pool,
-      // and emit a connectionError event. They will not be re-used.
-      // Fixes https://github.com/nodejs/undici/issues/3895
-      for (const target of targets) {
-        // Do not use kRemoveClient here, as it will close the client,
-        // but the client cannot be closed in this state.
-        const idx = this[kClients].indexOf(target)
-        if (idx !== -1) {
-          this[kClients].splice(idx, 1)
-        }
-      }
-    })
-  }
-
-  [kGetDispatcher] () {
-    const clientTtlOption = this[kOptions].clientTtl
-    for (const client of this[kClients]) {
-      // check ttl of client and if it's stale, remove it from the pool
-      if (clientTtlOption != null && clientTtlOption > 0 && client.ttl && ((Date.now() - client.ttl) > clientTtlOption)) {
-        this[kRemoveClient](client)
-      } else if (!client[kNeedDrain]) {
-        return client
-      }
-    }
-
-    if (!this[kConnections] || this[kClients].length < this[kConnections]) {
-      const dispatcher = this[kFactory](this[kUrl], this[kOptions])
-      this[kAddClient](dispatcher)
-      return dispatcher
-    }
-  }
-}
-
-module.exports = Pool

package/bundle/node_modules/undici/lib/dispatcher/proxy-agent.js

@@ -1,275 +0,0 @@
-'use strict'
-
-const { kProxy, kClose, kDestroy, kDispatch, kConnector } = require('../core/symbols')
-const { URL } = require('node:url')
-const Agent = require('./agent')
-const Pool = require('./pool')
-const DispatcherBase = require('./dispatcher-base')
-const { InvalidArgumentError, RequestAbortedError, SecureProxyConnectionError } = require('../core/errors')
-const buildConnector = require('../core/connect')
-const Client = require('./client')
-
-const kAgent = Symbol('proxy agent')
-const kClient = Symbol('proxy client')
-const kProxyHeaders = Symbol('proxy headers')
-const kRequestTls = Symbol('request tls settings')
-const kProxyTls = Symbol('proxy tls settings')
-const kConnectEndpoint = Symbol('connect endpoint function')
-const kTunnelProxy = Symbol('tunnel proxy')
-
-function defaultProtocolPort (protocol) {
-  return protocol === 'https:' ? 443 : 80
-}
-
-function defaultFactory (origin, opts) {
-  return new Pool(origin, opts)
-}
-
-const noop = () => {}
-
-class ProxyClient extends DispatcherBase {
-  #client = null
-  constructor (origin, opts) {
-    if (typeof origin === 'string') {
-      origin = new URL(origin)
-    }
-
-    if (origin.protocol !== 'http:' && origin.protocol !== 'https:') {
-      throw new InvalidArgumentError('ProxyClient only supports http and https protocols')
-    }
-
-    super()
-
-    this.#client = new Client(origin, opts)
-  }
-
-  async [kClose] () {
-    await this.#client.close()
-  }
-
-  async [kDestroy] () {
-    await this.#client.destroy()
-  }
-
-  async [kDispatch] (opts, handler) {
-    const { method, origin } = opts
-    if (method === 'CONNECT') {
-      this.#client[kConnector]({
-        origin,
-        port: opts.port || defaultProtocolPort(opts.protocol),
-        path: opts.host,
-        signal: opts.signal,
-        headers: {
-          ...this[kProxyHeaders],
-          host: opts.host
-        },
-        servername: this[kProxyTls]?.servername || opts.servername
-      },
-      (err, socket) => {
-        if (err) {
-          handler.callback(err)
-        } else {
-          handler.callback(null, { socket, statusCode: 200 })
-        }
-      }
-      )
-      return
-    }
-    if (typeof origin === 'string') {
-      opts.origin = new URL(origin)
-    }
-
-    return this.#client.dispatch(opts, handler)
-  }
-}
-class ProxyAgent extends DispatcherBase {
-  constructor (opts) {
-    if (!opts || (typeof opts === 'object' && !(opts instanceof URL) && !opts.uri)) {
-      throw new InvalidArgumentError('Proxy uri is mandatory')
-    }
-
-    const { clientFactory = defaultFactory } = opts
-    if (typeof clientFactory !== 'function') {
-      throw new InvalidArgumentError('Proxy opts.clientFactory must be a function.')
-    }
-
-    const { proxyTunnel = true } = opts
-
-    super()
-
-    const url = this.#getUrl(opts)
-    const { href, origin, port, protocol, username, password, hostname: proxyHostname } = url
-
-    this[kProxy] = { uri: href, protocol }
-    this[kRequestTls] = opts.requestTls
-    this[kProxyTls] = opts.proxyTls
-    this[kProxyHeaders] = opts.headers || {}
-
-    if (opts.auth && opts.token) {
-      throw new InvalidArgumentError('opts.auth cannot be used in combination with opts.token')
-    } else if (opts.auth) {
-      /* @deprecated in favour of opts.token */
-      this[kProxyHeaders]['proxy-authorization'] = `Basic ${opts.auth}`
-    } else if (opts.token) {
-      this[kProxyHeaders]['proxy-authorization'] = opts.token
-    } else if (username && password) {
-      this[kProxyHeaders]['proxy-authorization'] = `Basic ${Buffer.from(`${decodeURIComponent(username)}:${decodeURIComponent(password)}`).toString('base64')}`
-    }
-
-    const factory = (!proxyTunnel && protocol === 'http:')
-      ? (origin, options) => {
-          if (origin.protocol === 'http:') {
-            return new ProxyClient(origin, options)
-          }
-          return new Client(origin, options)
-        }
-      : undefined
-
-    const connect = buildConnector({ ...opts.proxyTls })
-    this[kConnectEndpoint] = buildConnector({ ...opts.requestTls })
-    this[kClient] = clientFactory(url, { connect, factory })
-    this[kTunnelProxy] = proxyTunnel
-    this[kAgent] = new Agent({
-      ...opts,
-      connect: async (opts, callback) => {
-        let requestedPath = opts.host
-        if (!opts.port) {
-          requestedPath += `:${defaultProtocolPort(opts.protocol)}`
-        }
-        try {
-          const { socket, statusCode } = await this[kClient].connect({
-            origin,
-            port,
-            path: requestedPath,
-            signal: opts.signal,
-            headers: {
-              ...this[kProxyHeaders],
-              host: opts.host
-            },
-            servername: this[kProxyTls]?.servername || proxyHostname
-          })
-          if (statusCode !== 200) {
-            socket.on('error', noop).destroy()
-            callback(new RequestAbortedError(`Proxy response (${statusCode}) !== 200 when HTTP Tunneling`))
-          }
-          if (opts.protocol !== 'https:') {
-            callback(null, socket)
-            return
-          }
-          let servername
-          if (this[kRequestTls]) {
-            servername = this[kRequestTls].servername
-          } else {
-            servername = opts.servername
-          }
-          this[kConnectEndpoint]({ ...opts, servername, httpSocket: socket }, callback)
-        } catch (err) {
-          if (err.code === 'ERR_TLS_CERT_ALTNAME_INVALID') {
-            // Throw a custom error to avoid loop in client.js#connect
-            callback(new SecureProxyConnectionError(err))
-          } else {
-            callback(err)
-          }
-        }
-      }
-    })
-  }
-
-  dispatch (opts, handler) {
-    const headers = buildHeaders(opts.headers)
-    throwIfProxyAuthIsSent(headers)
-
-    if (headers && !('host' in headers) && !('Host' in headers)) {
-      const { host } = new URL(opts.origin)
-      headers.host = host
-    }
-
-    if (!this.#shouldConnect(new URL(opts.origin))) {
-      opts.path = opts.origin + opts.path
-    }
-
-    return this[kAgent].dispatch(
-      {
-        ...opts,
-        headers
-      },
-      handler
-    )
-  }
-
-  /**
-   * @param {import('../types/proxy-agent').ProxyAgent.Options | string | URL} opts
-   * @returns {URL}
-   */
-  #getUrl (opts) {
-    if (typeof opts === 'string') {
-      return new URL(opts)
-    } else if (opts instanceof URL) {
-      return opts
-    } else {
-      return new URL(opts.uri)
-    }
-  }
-
-  async [kClose] () {
-    await this[kAgent].close()
-    await this[kClient].close()
-  }
-
-  async [kDestroy] () {
-    await this[kAgent].destroy()
-    await this[kClient].destroy()
-  }
-
-  #shouldConnect (uri) {
-    if (typeof uri === 'string') {
-      uri = new URL(uri)
-    }
-    if (this[kTunnelProxy]) {
-      return true
-    }
-    if (uri.protocol !== 'http:' || this[kProxy].protocol !== 'http:') {
-      return true
-    }
-    return false
-  }
-}
-
-/**
- * @param {string[] | Record<string, string>} headers
- * @returns {Record<string, string>}
- */
-function buildHeaders (headers) {
-  // When using undici.fetch, the headers list is stored
-  // as an array.
-  if (Array.isArray(headers)) {
-    /** @type {Record<string, string>} */
-    const headersPair = {}
-
-    for (let i = 0; i < headers.length; i += 2) {
-      headersPair[headers[i]] = headers[i + 1]
-    }
-
-    return headersPair
-  }
-
-  return headers
-}
-
-/**
- * @param {Record<string, string>} headers
- *
- * Previous versions of ProxyAgent suggests the Proxy-Authorization in request headers
- * Nevertheless, it was changed and to avoid a security vulnerability by end users
- * this check was created.
- * It should be removed in the next major version for performance reasons
- */
-function throwIfProxyAuthIsSent (headers) {
-  const existProxyAuth = headers && Object.keys(headers)
-    .find((key) => key.toLowerCase() === 'proxy-authorization')
-  if (existProxyAuth) {
-    throw new InvalidArgumentError('Proxy-Authorization should be sent in ProxyAgent constructor')
-  }
-}
-
-module.exports = ProxyAgent

package/bundle/node_modules/undici/lib/dispatcher/retry-agent.js

@@ -1,35 +0,0 @@
-'use strict'
-
-const Dispatcher = require('./dispatcher')
-const RetryHandler = require('../handler/retry-handler')
-
-class RetryAgent extends Dispatcher {
-  #agent = null
-  #options = null
-  constructor (agent, options = {}) {
-    super(options)
-    this.#agent = agent
-    this.#options = options
-  }
-
-  dispatch (opts, handler) {
-    const retry = new RetryHandler({
-      ...opts,
-      retryOptions: this.#options
-    }, {
-      dispatch: this.#agent.dispatch.bind(this.#agent),
-      handler
-    })
-    return this.#agent.dispatch(opts, retry)
-  }
-
-  close () {
-    return this.#agent.close()
-  }
-
-  destroy () {
-    return this.#agent.destroy()
-  }
-}
-
-module.exports = RetryAgent

package/bundle/node_modules/undici/lib/global.js

@@ -1,32 +0,0 @@
-'use strict'
-
-// We include a version number for the Dispatcher API. In case of breaking changes,
-// this version number must be increased to avoid conflicts.
-const globalDispatcher = Symbol.for('undici.globalDispatcher.1')
-const { InvalidArgumentError } = require('./core/errors')
-const Agent = require('./dispatcher/agent')
-
-if (getGlobalDispatcher() === undefined) {
-  setGlobalDispatcher(new Agent())
-}
-
-function setGlobalDispatcher (agent) {
-  if (!agent || typeof agent.dispatch !== 'function') {
-    throw new InvalidArgumentError('Argument agent must implement Agent')
-  }
-  Object.defineProperty(globalThis, globalDispatcher, {
-    value: agent,
-    writable: true,
-    enumerable: false,
-    configurable: false
-  })
-}
-
-function getGlobalDispatcher () {
-  return globalThis[globalDispatcher]
-}
-
-module.exports = {
-  setGlobalDispatcher,
-  getGlobalDispatcher
-}