deepv-code 1.0.182 → 1.0.183

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

@@ -1,161 +0,0 @@
-'use strict'
-
-const Dispatcher = require('./dispatcher')
-const UnwrapHandler = require('../handler/unwrap-handler')
-const {
-  ClientDestroyedError,
-  ClientClosedError,
-  InvalidArgumentError
-} = require('../core/errors')
-const { kDestroy, kClose, kClosed, kDestroyed, kDispatch } = require('../core/symbols')
-
-const kOnDestroyed = Symbol('onDestroyed')
-const kOnClosed = Symbol('onClosed')
-
-class DispatcherBase extends Dispatcher {
-  constructor () {
-    super()
-
-    this[kDestroyed] = false
-    this[kOnDestroyed] = null
-    this[kClosed] = false
-    this[kOnClosed] = []
-  }
-
-  get destroyed () {
-    return this[kDestroyed]
-  }
-
-  get closed () {
-    return this[kClosed]
-  }
-
-  close (callback) {
-    if (callback === undefined) {
-      return new Promise((resolve, reject) => {
-        this.close((err, data) => {
-          return err ? reject(err) : resolve(data)
-        })
-      })
-    }
-
-    if (typeof callback !== 'function') {
-      throw new InvalidArgumentError('invalid callback')
-    }
-
-    if (this[kDestroyed]) {
-      queueMicrotask(() => callback(new ClientDestroyedError(), null))
-      return
-    }
-
-    if (this[kClosed]) {
-      if (this[kOnClosed]) {
-        this[kOnClosed].push(callback)
-      } else {
-        queueMicrotask(() => callback(null, null))
-      }
-      return
-    }
-
-    this[kClosed] = true
-    this[kOnClosed].push(callback)
-
-    const onClosed = () => {
-      const callbacks = this[kOnClosed]
-      this[kOnClosed] = null
-      for (let i = 0; i < callbacks.length; i++) {
-        callbacks[i](null, null)
-      }
-    }
-
-    // Should not error.
-    this[kClose]()
-      .then(() => this.destroy())
-      .then(() => {
-        queueMicrotask(onClosed)
-      })
-  }
-
-  destroy (err, callback) {
-    if (typeof err === 'function') {
-      callback = err
-      err = null
-    }
-
-    if (callback === undefined) {
-      return new Promise((resolve, reject) => {
-        this.destroy(err, (err, data) => {
-          return err ? /* istanbul ignore next: should never error */ reject(err) : resolve(data)
-        })
-      })
-    }
-
-    if (typeof callback !== 'function') {
-      throw new InvalidArgumentError('invalid callback')
-    }
-
-    if (this[kDestroyed]) {
-      if (this[kOnDestroyed]) {
-        this[kOnDestroyed].push(callback)
-      } else {
-        queueMicrotask(() => callback(null, null))
-      }
-      return
-    }
-
-    if (!err) {
-      err = new ClientDestroyedError()
-    }
-
-    this[kDestroyed] = true
-    this[kOnDestroyed] = this[kOnDestroyed] || []
-    this[kOnDestroyed].push(callback)
-
-    const onDestroyed = () => {
-      const callbacks = this[kOnDestroyed]
-      this[kOnDestroyed] = null
-      for (let i = 0; i < callbacks.length; i++) {
-        callbacks[i](null, null)
-      }
-    }
-
-    // Should not error.
-    this[kDestroy](err).then(() => {
-      queueMicrotask(onDestroyed)
-    })
-  }
-
-  dispatch (opts, handler) {
-    if (!handler || typeof handler !== 'object') {
-      throw new InvalidArgumentError('handler must be an object')
-    }
-
-    handler = UnwrapHandler.unwrap(handler)
-
-    try {
-      if (!opts || typeof opts !== 'object') {
-        throw new InvalidArgumentError('opts must be an object.')
-      }
-
-      if (this[kDestroyed] || this[kOnDestroyed]) {
-        throw new ClientDestroyedError()
-      }
-
-      if (this[kClosed]) {
-        throw new ClientClosedError()
-      }
-
-      return this[kDispatch](opts, handler)
-    } catch (err) {
-      if (typeof handler.onError !== 'function') {
-        throw err
-      }
-
-      handler.onError(err)
-
-      return false
-    }
-  }
-}
-
-module.exports = DispatcherBase

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

@@ -1,48 +0,0 @@
-'use strict'
-const EventEmitter = require('node:events')
-const WrapHandler = require('../handler/wrap-handler')
-
-const wrapInterceptor = (dispatch) => (opts, handler) => dispatch(opts, WrapHandler.wrap(handler))
-
-class Dispatcher extends EventEmitter {
-  dispatch () {
-    throw new Error('not implemented')
-  }
-
-  close () {
-    throw new Error('not implemented')
-  }
-
-  destroy () {
-    throw new Error('not implemented')
-  }
-
-  compose (...args) {
-    // So we handle [interceptor1, interceptor2] or interceptor1, interceptor2, ...
-    const interceptors = Array.isArray(args[0]) ? args[0] : args
-    let dispatch = this.dispatch.bind(this)
-
-    for (const interceptor of interceptors) {
-      if (interceptor == null) {
-        continue
-      }
-
-      if (typeof interceptor !== 'function') {
-        throw new TypeError(`invalid interceptor, expected function received ${typeof interceptor}`)
-      }
-
-      dispatch = interceptor(dispatch)
-      dispatch = wrapInterceptor(dispatch)
-
-      if (dispatch == null || typeof dispatch !== 'function' || dispatch.length !== 2) {
-        throw new TypeError('invalid interceptor')
-      }
-    }
-
-    return new Proxy(this, {
-      get: (target, key) => key === 'dispatch' ? dispatch : target[key]
-    })
-  }
-}
-
-module.exports = Dispatcher

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

@@ -1,151 +0,0 @@
-'use strict'
-
-const DispatcherBase = require('./dispatcher-base')
-const { kClose, kDestroy, kClosed, kDestroyed, kDispatch, kNoProxyAgent, kHttpProxyAgent, kHttpsProxyAgent } = require('../core/symbols')
-const ProxyAgent = require('./proxy-agent')
-const Agent = require('./agent')
-
-const DEFAULT_PORTS = {
-  'http:': 80,
-  'https:': 443
-}
-
-class EnvHttpProxyAgent extends DispatcherBase {
-  #noProxyValue = null
-  #noProxyEntries = null
-  #opts = null
-
-  constructor (opts = {}) {
-    super()
-    this.#opts = opts
-
-    const { httpProxy, httpsProxy, noProxy, ...agentOpts } = opts
-
-    this[kNoProxyAgent] = new Agent(agentOpts)
-
-    const HTTP_PROXY = httpProxy ?? process.env.http_proxy ?? process.env.HTTP_PROXY
-    if (HTTP_PROXY) {
-      this[kHttpProxyAgent] = new ProxyAgent({ ...agentOpts, uri: HTTP_PROXY })
-    } else {
-      this[kHttpProxyAgent] = this[kNoProxyAgent]
-    }
-
-    const HTTPS_PROXY = httpsProxy ?? process.env.https_proxy ?? process.env.HTTPS_PROXY
-    if (HTTPS_PROXY) {
-      this[kHttpsProxyAgent] = new ProxyAgent({ ...agentOpts, uri: HTTPS_PROXY })
-    } else {
-      this[kHttpsProxyAgent] = this[kHttpProxyAgent]
-    }
-
-    this.#parseNoProxy()
-  }
-
-  [kDispatch] (opts, handler) {
-    const url = new URL(opts.origin)
-    const agent = this.#getProxyAgentForUrl(url)
-    return agent.dispatch(opts, handler)
-  }
-
-  async [kClose] () {
-    await this[kNoProxyAgent].close()
-    if (!this[kHttpProxyAgent][kClosed]) {
-      await this[kHttpProxyAgent].close()
-    }
-    if (!this[kHttpsProxyAgent][kClosed]) {
-      await this[kHttpsProxyAgent].close()
-    }
-  }
-
-  async [kDestroy] (err) {
-    await this[kNoProxyAgent].destroy(err)
-    if (!this[kHttpProxyAgent][kDestroyed]) {
-      await this[kHttpProxyAgent].destroy(err)
-    }
-    if (!this[kHttpsProxyAgent][kDestroyed]) {
-      await this[kHttpsProxyAgent].destroy(err)
-    }
-  }
-
-  #getProxyAgentForUrl (url) {
-    let { protocol, host: hostname, port } = url
-
-    // Stripping ports in this way instead of using parsedUrl.hostname to make
-    // sure that the brackets around IPv6 addresses are kept.
-    hostname = hostname.replace(/:\d*$/, '').toLowerCase()
-    port = Number.parseInt(port, 10) || DEFAULT_PORTS[protocol] || 0
-    if (!this.#shouldProxy(hostname, port)) {
-      return this[kNoProxyAgent]
-    }
-    if (protocol === 'https:') {
-      return this[kHttpsProxyAgent]
-    }
-    return this[kHttpProxyAgent]
-  }
-
-  #shouldProxy (hostname, port) {
-    if (this.#noProxyChanged) {
-      this.#parseNoProxy()
-    }
-
-    if (this.#noProxyEntries.length === 0) {
-      return true // Always proxy if NO_PROXY is not set or empty.
-    }
-    if (this.#noProxyValue === '*') {
-      return false // Never proxy if wildcard is set.
-    }
-
-    for (let i = 0; i < this.#noProxyEntries.length; i++) {
-      const entry = this.#noProxyEntries[i]
-      if (entry.port && entry.port !== port) {
-        continue // Skip if ports don't match.
-      }
-      if (!/^[.*]/.test(entry.hostname)) {
-        // No wildcards, so don't proxy only if there is not an exact match.
-        if (hostname === entry.hostname) {
-          return false
-        }
-      } else {
-        // Don't proxy if the hostname ends with the no_proxy host.
-        if (hostname.endsWith(entry.hostname.replace(/^\*/, ''))) {
-          return false
-        }
-      }
-    }
-
-    return true
-  }
-
-  #parseNoProxy () {
-    const noProxyValue = this.#opts.noProxy ?? this.#noProxyEnv
-    const noProxySplit = noProxyValue.split(/[,\s]/)
-    const noProxyEntries = []
-
-    for (let i = 0; i < noProxySplit.length; i++) {
-      const entry = noProxySplit[i]
-      if (!entry) {
-        continue
-      }
-      const parsed = entry.match(/^(.+):(\d+)$/)
-      noProxyEntries.push({
-        hostname: (parsed ? parsed[1] : entry).toLowerCase(),
-        port: parsed ? Number.parseInt(parsed[2], 10) : 0
-      })
-    }
-
-    this.#noProxyValue = noProxyValue
-    this.#noProxyEntries = noProxyEntries
-  }
-
-  get #noProxyChanged () {
-    if (this.#opts.noProxy !== undefined) {
-      return false
-    }
-    return this.#noProxyValue !== this.#noProxyEnv
-  }
-
-  get #noProxyEnv () {
-    return process.env.no_proxy ?? process.env.NO_PROXY ?? ''
-  }
-}
-
-module.exports = EnvHttpProxyAgent

package/bundle/node_modules/undici/lib/dispatcher/fixed-queue.js

@@ -1,159 +0,0 @@
-'use strict'
-
-// Extracted from node/lib/internal/fixed_queue.js
-
-// Currently optimal queue size, tested on V8 6.0 - 6.6. Must be power of two.
-const kSize = 2048
-const kMask = kSize - 1
-
-// The FixedQueue is implemented as a singly-linked list of fixed-size
-// circular buffers. It looks something like this:
-//
-//  head                                                       tail
-//    |                                                          |
-//    v                                                          v
-// +-----------+ <-----\       +-----------+ <------\         +-----------+
-// |  [null]   |        \----- |   next    |         \------- |   next    |
-// +-----------+               +-----------+                  +-----------+
-// |   item    | <-- bottom    |   item    | <-- bottom       | undefined |
-// |   item    |               |   item    |                  | undefined |
-// |   item    |               |   item    |                  | undefined |
-// |   item    |               |   item    |                  | undefined |
-// |   item    |               |   item    |       bottom --> |   item    |
-// |   item    |               |   item    |                  |   item    |
-// |    ...    |               |    ...    |                  |    ...    |
-// |   item    |               |   item    |                  |   item    |
-// |   item    |               |   item    |                  |   item    |
-// | undefined | <-- top       |   item    |                  |   item    |
-// | undefined |               |   item    |                  |   item    |
-// | undefined |               | undefined | <-- top  top --> | undefined |
-// +-----------+               +-----------+                  +-----------+
-//
-// Or, if there is only one circular buffer, it looks something
-// like either of these:
-//
-//  head   tail                                 head   tail
-//    |     |                                     |     |
-//    v     v                                     v     v
-// +-----------+                               +-----------+
-// |  [null]   |                               |  [null]   |
-// +-----------+                               +-----------+
-// | undefined |                               |   item    |
-// | undefined |                               |   item    |
-// |   item    | <-- bottom            top --> | undefined |
-// |   item    |                               | undefined |
-// | undefined | <-- top            bottom --> |   item    |
-// | undefined |                               |   item    |
-// +-----------+                               +-----------+
-//
-// Adding a value means moving `top` forward by one, removing means
-// moving `bottom` forward by one. After reaching the end, the queue
-// wraps around.
-//
-// When `top === bottom` the current queue is empty and when
-// `top + 1 === bottom` it's full. This wastes a single space of storage
-// but allows much quicker checks.
-
-/**
- * @type {FixedCircularBuffer}
- * @template T
- */
-class FixedCircularBuffer {
-  constructor () {
-    /**
-     * @type {number}
-     */
-    this.bottom = 0
-    /**
-     * @type {number}
-     */
-    this.top = 0
-    /**
-     * @type {Array<T|undefined>}
-     */
-    this.list = new Array(kSize).fill(undefined)
-    /**
-     * @type {T|null}
-     */
-    this.next = null
-  }
-
-  /**
-   * @returns {boolean}
-   */
-  isEmpty () {
-    return this.top === this.bottom
-  }
-
-  /**
-   * @returns {boolean}
-   */
-  isFull () {
-    return ((this.top + 1) & kMask) === this.bottom
-  }
-
-  /**
-   * @param {T} data
-   * @returns {void}
-   */
-  push (data) {
-    this.list[this.top] = data
-    this.top = (this.top + 1) & kMask
-  }
-
-  /**
-   * @returns {T|null}
-   */
-  shift () {
-    const nextItem = this.list[this.bottom]
-    if (nextItem === undefined) { return null }
-    this.list[this.bottom] = undefined
-    this.bottom = (this.bottom + 1) & kMask
-    return nextItem
-  }
-}
-
-/**
- * @template T
- */
-module.exports = class FixedQueue {
-  constructor () {
-    /**
-     * @type {FixedCircularBuffer<T>}
-     */
-    this.head = this.tail = new FixedCircularBuffer()
-  }
-
-  /**
-   * @returns {boolean}
-   */
-  isEmpty () {
-    return this.head.isEmpty()
-  }
-
-  /**
-   * @param {T} data
-   */
-  push (data) {
-    if (this.head.isFull()) {
-      // Head is full: Creates a new queue, sets the old queue's `.next` to it,
-      // and sets it as the new main queue.
-      this.head = this.head.next = new FixedCircularBuffer()
-    }
-    this.head.push(data)
-  }
-
-  /**
-   * @returns {T|null}
-   */
-  shift () {
-    const tail = this.tail
-    const next = tail.shift()
-    if (tail.isEmpty() && tail.next !== null) {
-      // If there is another queue, it forms the new tail.
-      this.tail = tail.next
-      tail.next = null
-    }
-    return next
-  }
-}

package/bundle/node_modules/undici/lib/dispatcher/h2c-client.js

@@ -1,122 +0,0 @@
-'use strict'
-const { connect } = require('node:net')
-
-const { kClose, kDestroy } = require('../core/symbols')
-const { InvalidArgumentError } = require('../core/errors')
-const util = require('../core/util')
-
-const Client = require('./client')
-const DispatcherBase = require('./dispatcher-base')
-
-class H2CClient extends DispatcherBase {
-  #client = null
-
-  constructor (origin, clientOpts) {
-    super()
-
-    if (typeof origin === 'string') {
-      origin = new URL(origin)
-    }
-
-    if (origin.protocol !== 'http:') {
-      throw new InvalidArgumentError(
-        'h2c-client: Only h2c protocol is supported'
-      )
-    }
-
-    const { connect, maxConcurrentStreams, pipelining, ...opts } =
-      clientOpts ?? {}
-    let defaultMaxConcurrentStreams = 100
-    let defaultPipelining = 100
-
-    if (
-      maxConcurrentStreams != null &&
-      Number.isInteger(maxConcurrentStreams) &&
-      maxConcurrentStreams > 0
-    ) {
-      defaultMaxConcurrentStreams = maxConcurrentStreams
-    }
-
-    if (pipelining != null && Number.isInteger(pipelining) && pipelining > 0) {
-      defaultPipelining = pipelining
-    }
-
-    if (defaultPipelining > defaultMaxConcurrentStreams) {
-      throw new InvalidArgumentError(
-        'h2c-client: pipelining cannot be greater than maxConcurrentStreams'
-      )
-    }
-
-    this.#client = new Client(origin, {
-      ...opts,
-      connect: this.#buildConnector(connect),
-      maxConcurrentStreams: defaultMaxConcurrentStreams,
-      pipelining: defaultPipelining,
-      allowH2: true
-    })
-  }
-
-  #buildConnector (connectOpts) {
-    return (opts, callback) => {
-      const timeout = connectOpts?.connectOpts ?? 10e3
-      const { hostname, port, pathname } = opts
-      const socket = connect({
-        ...opts,
-        host: hostname,
-        port,
-        pathname
-      })
-
-      // Set TCP keep alive options on the socket here instead of in connect() for the case of assigning the socket
-      if (opts.keepAlive == null || opts.keepAlive) {
-        const keepAliveInitialDelay =
-          opts.keepAliveInitialDelay == null ? 60e3 : opts.keepAliveInitialDelay
-        socket.setKeepAlive(true, keepAliveInitialDelay)
-      }
-
-      socket.alpnProtocol = 'h2'
-
-      const clearConnectTimeout = util.setupConnectTimeout(
-        new WeakRef(socket),
-        { timeout, hostname, port }
-      )
-
-      socket
-        .setNoDelay(true)
-        .once('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
-    }
-  }
-
-  dispatch (opts, handler) {
-    return this.#client.dispatch(opts, handler)
-  }
-
-  async [kClose] () {
-    await this.#client.close()
-  }
-
-  async [kDestroy] () {
-    await this.#client.destroy()
-  }
-}
-
-module.exports = H2CClient