pnpm 11.23.0 → 11.24.0

package/artifacts/exe/dist/node_modules/undici/lib/core/request.js

@@ -1,416 +0,0 @@
-'use strict'
-
-const {
-  InvalidArgumentError,
-  NotSupportedError
-} = require('./errors')
-const assert = require('node:assert')
-const {
-  isValidHTTPToken,
-  isValidHeaderValue,
-  isStream,
-  destroy,
-  isBuffer,
-  isFormDataLike,
-  isIterable,
-  isBlobLike,
-  buildURL,
-  validateHandler,
-  getServerName,
-  normalizedMethodRecords
-} = require('./util')
-const { channels } = require('./diagnostics.js')
-const { headerNameLowerCasedRecord } = require('./constants')
-
-// Verifies that a given path is valid does not contain control chars \x00 to \x20
-const invalidPathRegex = /[^\u0021-\u00ff]/
-
-const kHandler = Symbol('handler')
-
-class Request {
-  constructor (origin, {
-    path,
-    method,
-    body,
-    headers,
-    query,
-    idempotent,
-    blocking,
-    upgrade,
-    headersTimeout,
-    bodyTimeout,
-    reset,
-    throwOnError,
-    expectContinue,
-    servername
-  }, handler) {
-    if (typeof path !== 'string') {
-      throw new InvalidArgumentError('path must be a string')
-    } else if (
-      path[0] !== '/' &&
-      !(path.startsWith('http://') || path.startsWith('https://')) &&
-      method !== 'CONNECT'
-    ) {
-      throw new InvalidArgumentError('path must be an absolute URL or start with a slash')
-    } else if (invalidPathRegex.test(path)) {
-      throw new InvalidArgumentError('invalid request path')
-    }
-
-    if (typeof method !== 'string') {
-      throw new InvalidArgumentError('method must be a string')
-    } else if (normalizedMethodRecords[method] === undefined && !isValidHTTPToken(method)) {
-      throw new InvalidArgumentError('invalid request method')
-    }
-
-    if (upgrade && typeof upgrade !== 'string') {
-      throw new InvalidArgumentError('upgrade must be a string')
-    }
-
-    if (upgrade && !isValidHeaderValue(upgrade)) {
-      throw new InvalidArgumentError('invalid upgrade header')
-    }
-
-    if (headersTimeout != null && (!Number.isFinite(headersTimeout) || headersTimeout < 0)) {
-      throw new InvalidArgumentError('invalid headersTimeout')
-    }
-
-    if (bodyTimeout != null && (!Number.isFinite(bodyTimeout) || bodyTimeout < 0)) {
-      throw new InvalidArgumentError('invalid bodyTimeout')
-    }
-
-    if (reset != null && typeof reset !== 'boolean') {
-      throw new InvalidArgumentError('invalid reset')
-    }
-
-    if (expectContinue != null && typeof expectContinue !== 'boolean') {
-      throw new InvalidArgumentError('invalid expectContinue')
-    }
-
-    this.headersTimeout = headersTimeout
-
-    this.bodyTimeout = bodyTimeout
-
-    this.throwOnError = throwOnError === true
-
-    this.method = method
-
-    this.abort = null
-
-    if (body == null) {
-      this.body = null
-    } else if (isStream(body)) {
-      this.body = body
-
-      const rState = this.body._readableState
-      if (!rState || !rState.autoDestroy) {
-        this.endHandler = function autoDestroy () {
-          destroy(this)
-        }
-        this.body.on('end', this.endHandler)
-      }
-
-      this.errorHandler = err => {
-        if (this.abort) {
-          this.abort(err)
-        } else {
-          this.error = err
-        }
-      }
-      this.body.on('error', this.errorHandler)
-    } else if (isBuffer(body)) {
-      this.body = body.byteLength ? body : null
-    } else if (ArrayBuffer.isView(body)) {
-      this.body = body.buffer.byteLength ? Buffer.from(body.buffer, body.byteOffset, body.byteLength) : null
-    } else if (body instanceof ArrayBuffer) {
-      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)) {
-      this.body = body
-    } else {
-      throw new InvalidArgumentError('body must be a string, a Buffer, a Readable stream, an iterable, or an async iterable')
-    }
-
-    this.completed = false
-
-    this.aborted = false
-
-    this.upgrade = upgrade || null
-
-    this.path = query ? buildURL(path, query) : path
-
-    this.origin = origin
-
-    this.idempotent = idempotent == null
-      ? method === 'HEAD' || method === 'GET'
-      : idempotent
-
-    this.blocking = blocking == null ? false : blocking
-
-    this.reset = reset == null ? null : reset
-
-    this.host = null
-
-    this.contentLength = null
-
-    this.contentType = null
-
-    this.headers = []
-
-    // Only for H2
-    this.expectContinue = expectContinue != null ? expectContinue : false
-
-    if (Array.isArray(headers)) {
-      if (headers.length % 2 !== 0) {
-        throw new InvalidArgumentError('headers array must be even')
-      }
-      for (let i = 0; i < headers.length; i += 2) {
-        processHeader(this, headers[i], headers[i + 1])
-      }
-    } else if (headers && typeof headers === 'object') {
-      if (headers[Symbol.iterator]) {
-        for (const header of headers) {
-          if (!Array.isArray(header) || header.length !== 2) {
-            throw new InvalidArgumentError('headers must be in key-value pair format')
-          }
-          processHeader(this, header[0], header[1])
-        }
-      } else {
-        const keys = Object.keys(headers)
-        for (let i = 0; i < keys.length; ++i) {
-          processHeader(this, keys[i], headers[keys[i]])
-        }
-      }
-    } else if (headers != null) {
-      throw new InvalidArgumentError('headers must be an object or an array')
-    }
-
-    validateHandler(handler, method, upgrade)
-
-    this.servername = servername || getServerName(this.host)
-
-    this[kHandler] = handler
-
-    if (channels.create.hasSubscribers) {
-      channels.create.publish({ request: this })
-    }
-  }
-
-  onBodySent (chunk) {
-    if (this[kHandler].onBodySent) {
-      try {
-        return this[kHandler].onBodySent(chunk)
-      } catch (err) {
-        this.abort(err)
-      }
-    }
-  }
-
-  onRequestSent () {
-    if (channels.bodySent.hasSubscribers) {
-      channels.bodySent.publish({ request: this })
-    }
-
-    if (this[kHandler].onRequestSent) {
-      try {
-        return this[kHandler].onRequestSent()
-      } catch (err) {
-        this.abort(err)
-      }
-    }
-  }
-
-  onConnect (abort) {
-    assert(!this.aborted)
-    assert(!this.completed)
-
-    if (this.error) {
-      abort(this.error)
-    } else {
-      this.abort = abort
-      return this[kHandler].onConnect(abort)
-    }
-  }
-
-  onResponseStarted () {
-    return this[kHandler].onResponseStarted?.()
-  }
-
-  onHeaders (statusCode, headers, resume, statusText) {
-    assert(!this.aborted)
-    assert(!this.completed)
-
-    if (channels.headers.hasSubscribers) {
-      channels.headers.publish({ request: this, response: { statusCode, headers, statusText } })
-    }
-
-    try {
-      return this[kHandler].onHeaders(statusCode, headers, resume, statusText)
-    } catch (err) {
-      this.abort(err)
-    }
-  }
-
-  onData (chunk) {
-    assert(!this.aborted)
-    assert(!this.completed)
-
-    try {
-      return this[kHandler].onData(chunk)
-    } catch (err) {
-      this.abort(err)
-      return false
-    }
-  }
-
-  onUpgrade (statusCode, headers, socket) {
-    assert(!this.aborted)
-    assert(!this.completed)
-
-    return this[kHandler].onUpgrade(statusCode, headers, socket)
-  }
-
-  onComplete (trailers) {
-    this.onFinally()
-
-    assert(!this.aborted)
-
-    this.completed = true
-    if (channels.trailers.hasSubscribers) {
-      channels.trailers.publish({ request: this, trailers })
-    }
-
-    try {
-      return this[kHandler].onComplete(trailers)
-    } catch (err) {
-      // TODO (fix): This might be a bad idea?
-      this.onError(err)
-    }
-  }
-
-  onError (error) {
-    this.onFinally()
-
-    if (channels.error.hasSubscribers) {
-      channels.error.publish({ request: this, error })
-    }
-
-    if (this.aborted) {
-      return
-    }
-    this.aborted = true
-
-    return this[kHandler].onError(error)
-  }
-
-  onFinally () {
-    if (this.errorHandler) {
-      this.body.off('error', this.errorHandler)
-      this.errorHandler = null
-    }
-
-    if (this.endHandler) {
-      this.body.off('end', this.endHandler)
-      this.endHandler = null
-    }
-  }
-
-  addHeader (key, value) {
-    processHeader(this, key, value)
-    return this
-  }
-}
-
-function processHeader (request, key, val) {
-  if (val && (typeof val === 'object' && !Array.isArray(val))) {
-    throw new InvalidArgumentError(`invalid ${key} header`)
-  } else if (val === undefined) {
-    return
-  }
-
-  let headerName = headerNameLowerCasedRecord[key]
-
-  if (headerName === undefined) {
-    headerName = key.toLowerCase()
-    if (headerNameLowerCasedRecord[headerName] === undefined && !isValidHTTPToken(headerName)) {
-      throw new InvalidArgumentError('invalid header key')
-    }
-  }
-
-  if (Array.isArray(val)) {
-    const arr = []
-    for (let i = 0; i < val.length; i++) {
-      if (typeof val[i] === 'string') {
-        if (!isValidHeaderValue(val[i])) {
-          throw new InvalidArgumentError(`invalid ${key} header`)
-        }
-        arr.push(val[i])
-      } else if (val[i] === null) {
-        arr.push('')
-      } else if (typeof val[i] === 'object') {
-        throw new InvalidArgumentError(`invalid ${key} header`)
-      } else {
-        // Coerce primitives (and reject unsafe coercions such as functions
-        // with a crafted toString/Symbol.toPrimitive).
-        const str = `${val[i]}`
-        if (!isValidHeaderValue(str)) {
-          throw new InvalidArgumentError(`invalid ${key} header`)
-        }
-        arr.push(str)
-      }
-    }
-    val = arr
-  } else if (typeof val === 'string') {
-    if (!isValidHeaderValue(val)) {
-      throw new InvalidArgumentError(`invalid ${key} header`)
-    }
-  } else if (val === null) {
-    val = ''
-  } else {
-    // Coerce primitives (and reject unsafe coercions such as functions
-    // with a crafted toString/Symbol.toPrimitive).
-    val = `${val}`
-    if (!isValidHeaderValue(val)) {
-      throw new InvalidArgumentError(`invalid ${key} header`)
-    }
-  }
-
-  if (headerName === 'host') {
-    if (request.host !== null) {
-      throw new InvalidArgumentError('duplicate host header')
-    }
-    if (typeof val !== 'string') {
-      throw new InvalidArgumentError('invalid host header')
-    }
-    // Consumed by Client
-    request.host = val
-  } else if (headerName === 'content-length') {
-    if (request.contentLength !== null) {
-      throw new InvalidArgumentError('duplicate content-length header')
-    }
-    request.contentLength = parseInt(val, 10)
-    if (!Number.isFinite(request.contentLength)) {
-      throw new InvalidArgumentError('invalid content-length header')
-    }
-  } else if (request.contentType === null && headerName === 'content-type') {
-    request.contentType = val
-    request.headers.push(key, val)
-  } else if (headerName === 'transfer-encoding' || headerName === 'keep-alive' || headerName === 'upgrade') {
-    throw new InvalidArgumentError(`invalid ${headerName} header`)
-  } else if (headerName === 'connection') {
-    const value = typeof val === 'string' ? val.toLowerCase() : null
-    if (value !== 'close' && value !== 'keep-alive') {
-      throw new InvalidArgumentError('invalid connection header')
-    }
-
-    if (value === 'close') {
-      request.reset = true
-    }
-  } else if (headerName === 'expect') {
-    throw new NotSupportedError('expect header not supported')
-  } else {
-    request.headers.push(key, val)
-  }
-}
-
-module.exports = Request

package/artifacts/exe/dist/node_modules/undici/lib/core/symbols.js

@@ -1,67 +0,0 @@
-module.exports = {
-  kClose: Symbol('close'),
-  kDestroy: Symbol('destroy'),
-  kDispatch: Symbol('dispatch'),
-  kUrl: Symbol('url'),
-  kWriting: Symbol('writing'),
-  kResuming: Symbol('resuming'),
-  kQueue: Symbol('queue'),
-  kConnect: Symbol('connect'),
-  kConnecting: Symbol('connecting'),
-  kKeepAliveDefaultTimeout: Symbol('default keep alive timeout'),
-  kKeepAliveMaxTimeout: Symbol('max keep alive timeout'),
-  kKeepAliveTimeoutThreshold: Symbol('keep alive timeout threshold'),
-  kKeepAliveTimeoutValue: Symbol('keep alive timeout'),
-  kKeepAlive: Symbol('keep alive'),
-  kHeadersTimeout: Symbol('headers timeout'),
-  kBodyTimeout: Symbol('body timeout'),
-  kServerName: Symbol('server name'),
-  kLocalAddress: Symbol('local address'),
-  kHost: Symbol('host'),
-  kNoRef: Symbol('no ref'),
-  kBodyUsed: Symbol('used'),
-  kBody: Symbol('abstracted request body'),
-  kRunning: Symbol('running'),
-  kBlocking: Symbol('blocking'),
-  kPending: Symbol('pending'),
-  kSize: Symbol('size'),
-  kBusy: Symbol('busy'),
-  kQueued: Symbol('queued'),
-  kFree: Symbol('free'),
-  kConnected: Symbol('connected'),
-  kClosed: Symbol('closed'),
-  kNeedDrain: Symbol('need drain'),
-  kReset: Symbol('reset'),
-  kDestroyed: Symbol.for('nodejs.stream.destroyed'),
-  kResume: Symbol('resume'),
-  kOnError: Symbol('on error'),
-  kMaxHeadersSize: Symbol('max headers size'),
-  kRunningIdx: Symbol('running index'),
-  kPendingIdx: Symbol('pending index'),
-  kError: Symbol('error'),
-  kClients: Symbol('clients'),
-  kClient: Symbol('client'),
-  kParser: Symbol('parser'),
-  kOnDestroyed: Symbol('destroy callbacks'),
-  kPipelining: Symbol('pipelining'),
-  kSocket: Symbol('socket'),
-  kHostHeader: Symbol('host header'),
-  kConnector: Symbol('connector'),
-  kStrictContentLength: Symbol('strict content length'),
-  kMaxRedirections: Symbol('maxRedirections'),
-  kMaxRequests: Symbol('maxRequestsPerClient'),
-  kProxy: Symbol('proxy agent options'),
-  kCounter: Symbol('socket request counter'),
-  kInterceptors: Symbol('dispatch interceptors'),
-  kMaxResponseSize: Symbol('max response size'),
-  kHTTP2Session: Symbol('http2Session'),
-  kHTTP2SessionState: Symbol('http2Session state'),
-  kRetryHandlerDefaultRetry: Symbol('retry agent default retry'),
-  kConstruct: Symbol('constructable'),
-  kListeners: Symbol('listeners'),
-  kHTTPContext: Symbol('http context'),
-  kMaxConcurrentStreams: Symbol('max concurrent streams'),
-  kNoProxyAgent: Symbol('no proxy agent'),
-  kHttpProxyAgent: Symbol('http proxy agent'),
-  kHttpsProxyAgent: Symbol('https proxy agent')
-}

package/artifacts/exe/dist/node_modules/undici/lib/core/tree.js

@@ -1,152 +0,0 @@
-'use strict'
-
-const {
-  wellknownHeaderNames,
-  headerNameLowerCasedRecord
-} = require('./constants')
-
-class TstNode {
-  /** @type {any} */
-  value = null
-  /** @type {null | TstNode} */
-  left = null
-  /** @type {null | TstNode} */
-  middle = null
-  /** @type {null | TstNode} */
-  right = null
-  /** @type {number} */
-  code
-  /**
-   * @param {string} key
-   * @param {any} value
-   * @param {number} index
-   */
-  constructor (key, value, index) {
-    if (index === undefined || index >= key.length) {
-      throw new TypeError('Unreachable')
-    }
-    const code = this.code = key.charCodeAt(index)
-    // check code is ascii string
-    if (code > 0x7F) {
-      throw new TypeError('key must be ascii string')
-    }
-    if (key.length !== ++index) {
-      this.middle = new TstNode(key, value, index)
-    } else {
-      this.value = value
-    }
-  }
-
-  /**
-   * @param {string} key
-   * @param {any} value
-   */
-  add (key, value) {
-    const length = key.length
-    if (length === 0) {
-      throw new TypeError('Unreachable')
-    }
-    let index = 0
-    let node = this
-    while (true) {
-      const code = key.charCodeAt(index)
-      // check code is ascii string
-      if (code > 0x7F) {
-        throw new TypeError('key must be ascii string')
-      }
-      if (node.code === code) {
-        if (length === ++index) {
-          node.value = value
-          break
-        } else if (node.middle !== null) {
-          node = node.middle
-        } else {
-          node.middle = new TstNode(key, value, index)
-          break
-        }
-      } else if (node.code < code) {
-        if (node.left !== null) {
-          node = node.left
-        } else {
-          node.left = new TstNode(key, value, index)
-          break
-        }
-      } else if (node.right !== null) {
-        node = node.right
-      } else {
-        node.right = new TstNode(key, value, index)
-        break
-      }
-    }
-  }
-
-  /**
-   * @param {Uint8Array} key
-   * @return {TstNode | null}
-   */
-  search (key) {
-    const keylength = key.length
-    let index = 0
-    let node = this
-    while (node !== null && index < keylength) {
-      let code = key[index]
-      // A-Z
-      // First check if it is bigger than 0x5a.
-      // Lowercase letters have higher char codes than uppercase ones.
-      // Also we assume that headers will mostly contain lowercase characters.
-      if (code <= 0x5a && code >= 0x41) {
-        // Lowercase for uppercase.
-        code |= 32
-      }
-      while (node !== null) {
-        if (code === node.code) {
-          if (keylength === ++index) {
-            // Returns Node since it is the last key.
-            return node
-          }
-          node = node.middle
-          break
-        }
-        node = node.code < code ? node.left : node.right
-      }
-    }
-    return null
-  }
-}
-
-class TernarySearchTree {
-  /** @type {TstNode | null} */
-  node = null
-
-  /**
-   * @param {string} key
-   * @param {any} value
-   * */
-  insert (key, value) {
-    if (this.node === null) {
-      this.node = new TstNode(key, value, 0)
-    } else {
-      this.node.add(key, value)
-    }
-  }
-
-  /**
-   * @param {Uint8Array} key
-   * @return {any}
-   */
-  lookup (key) {
-    return this.node?.search(key)?.value ?? null
-  }
-}
-
-const tree = new TernarySearchTree()
-
-for (let i = 0; i < wellknownHeaderNames.length; ++i) {
-  const key = headerNameLowerCasedRecord[wellknownHeaderNames[i]]
-  tree.insert(key, key)
-}
-
-module.exports = {
-  TernarySearchTree,
-  tree
-}