undici 6.0.0 → 6.1.0

package/lib/core/tree.js

@@ -0,0 +1,134 @@
+'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 {Uint8Array} key
+   * @param {any} value
+   * @param {number} index
+   */
+  constructor (key, value, index) {
+    if (index === undefined || index >= key.length) {
+      throw new TypeError('Unreachable')
+    }
+    this.code = key[index]
+    if (key.length !== ++index) {
+      this.middle = new TstNode(key, value, index)
+    } else {
+      this.value = value
+    }
+  }
+
+  /**
+   * @param {Uint8Array} key
+   * @param {any} value
+   * @param {number} index
+   */
+  add (key, value, index) {
+    if (index === undefined || index >= key.length) {
+      throw new TypeError('Unreachable')
+    }
+    const code = key[index]
+    if (this.code === code) {
+      if (key.length === ++index) {
+        this.value = value
+      } else if (this.middle !== null) {
+        this.middle.add(key, value, index)
+      } else {
+        this.middle = new TstNode(key, value, index)
+      }
+    } else if (this.code < code) {
+      if (this.left !== null) {
+        this.left.add(key, value, index)
+      } else {
+        this.left = new TstNode(key, value, index)
+      }
+    } else {
+      if (this.right !== null) {
+        this.right.add(key, value, index)
+      } else {
+        this.right = new TstNode(key, value, index)
+      }
+    }
+  }
+
+  /**
+   * @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
+      if (code >= 0x41 && code <= 0x5a) {
+        // 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 {Uint8Array} key
+   * @param {any} value
+   * */
+  insert (key, value) {
+    if (this.node === null) {
+      this.node = new TstNode(key, value, 0)
+    } else {
+      this.node.add(key, value, 0)
+    }
+  }
+
+  /**
+   * @param {Uint8Array} key
+   */
+  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(Buffer.from(key), key)
+}
+
+module.exports = {
+  TernarySearchTree,
+  tree
+}

package/lib/core/util.js

@@ -10,6 +10,7 @@ const { Blob } = require('buffer')
 const nodeUtil = require('util')
 const { stringify } = require('querystring')
 const { headerNameLowerCasedRecord } = require('./constants')
+const { tree } = require('./tree')
 
 const [nodeMajor, nodeMinor] = process.versions.node.split('.').map(v => Number(v))
 
@@ -219,26 +220,51 @@ function parseKeepAliveTimeout (val) {
   return m ? parseInt(m[1], 10) * 1000 : null
 }
 
-function parseHeaders (headers, obj = {}) {
+/**
+ * Retrieves a header name and returns its lowercase value.
+ * @param {string | Buffer} value Header name
+ * @returns {string}
+ */
+function headerNameToString (value) {
+  return typeof value === 'string'
+    ? headerNameLowerCasedRecord[value] ?? value.toLowerCase()
+    : tree.lookup(value) ?? value.toString('latin1').toLowerCase()
+}
+
+/**
+ * Receive the buffer as a string and return its lowercase value.
+ * @param {Buffer} value Header name
+ * @returns {string}
+ */
+function bufferToLowerCasedHeaderName (value) {
+  return tree.lookup(value) ?? value.toString('latin1').toLowerCase()
+}
+
+/**
+ * @param {Record<string, string | string[]> | (Buffer | string | (Buffer | string)[])[]} headers
+ * @param {Record<string, string | string[]>} [obj]
+ * @returns {Record<string, string | string[]>}
+ */
+function parseHeaders (headers, obj) {
   // For H2 support
   if (!Array.isArray(headers)) return headers
 
+  if (obj === undefined) obj = {}
   for (let i = 0; i < headers.length; i += 2) {
-    const key = headers[i].toString()
-    const lowerCasedKey = headerNameLowerCasedRecord[key] ?? key.toLowerCase()
-    let val = obj[lowerCasedKey]
+    const key = headerNameToString(headers[i])
+    let val = obj[key]
 
     if (!val) {
       const headersValue = headers[i + 1]
       if (typeof headersValue === 'string') {
-        obj[lowerCasedKey] = headersValue
+        obj[key] = headersValue
       } else {
-        obj[lowerCasedKey] = Array.isArray(headersValue) ? headersValue.map(x => x.toString('utf8')) : headersValue.toString('utf8')
+        obj[key] = Array.isArray(headersValue) ? headersValue.map(x => x.toString('utf8')) : headersValue.toString('utf8')
       }
     } else {
-      if (!Array.isArray(val)) {
+      if (typeof val === 'string') {
         val = [val]
-        obj[lowerCasedKey] = val
+        obj[key] = val
       }
       val.push(headers[i + 1].toString('utf8'))
     }
@@ -334,19 +360,11 @@ function isDisturbed (body) {
 }
 
 function isErrored (body) {
-  return !!(body && (
-    stream.isErrored
-      ? stream.isErrored(body)
-      : /state: 'errored'/.test(nodeUtil.inspect(body)
-      )))
+  return !!(body && stream.isErrored(body))
 }
 
 function isReadable (body) {
-  return !!(body && (
-    stream.isReadable
-      ? stream.isReadable(body)
-      : /state: 'readable'/.test(nodeUtil.inspect(body)
-      )))
+  return !!(body && stream.isReadable(body))
 }
 
 function getSocketInfo (socket) {
@@ -411,20 +429,6 @@ function isFormDataLike (object) {
   )
 }
 
-function throwIfAborted (signal) {
-  if (!signal) { return }
-  if (typeof signal.throwIfAborted === 'function') {
-    signal.throwIfAborted()
-  } else {
-    if (signal.aborted) {
-      // DOMException not available < v17.0.0
-      const err = new Error('The operation was aborted')
-      err.name = 'AbortError'
-      throw err
-    }
-  }
-}
-
 function addAbortListener (signal, listener) {
   if ('addEventListener' in signal) {
     signal.addEventListener('abort', listener, { once: true })
@@ -449,6 +453,52 @@ function toUSVString (val) {
   return `${val}`
 }
 
+/**
+ * @see https://tools.ietf.org/html/rfc7230#section-3.2.6
+ * @param {number} c
+ */
+function isTokenCharCode (c) {
+  switch (c) {
+    case 0x22:
+    case 0x28:
+    case 0x29:
+    case 0x2c:
+    case 0x2f:
+    case 0x3a:
+    case 0x3b:
+    case 0x3c:
+    case 0x3d:
+    case 0x3e:
+    case 0x3f:
+    case 0x40:
+    case 0x5b:
+    case 0x5c:
+    case 0x5d:
+    case 0x7b:
+    case 0x7d:
+      // DQUOTE and "(),/:;<=>?@[\]{}"
+      return false
+    default:
+      // VCHAR %x21-7E
+      return c >= 0x21 && c <= 0x7e
+  }
+}
+
+/**
+ * @param {string} characters
+ */
+function isValidHTTPToken (characters) {
+  if (characters.length === 0) {
+    return false
+  }
+  for (let i = 0; i < characters.length; ++i) {
+    if (!isTokenCharCode(characters.charCodeAt(i))) {
+      return false
+    }
+  }
+  return true
+}
+
 // Parsed accordingly to RFC 9110
 // https://www.rfc-editor.org/rfc/rfc9110#field.content-range
 function parseRangeHeader (range) {
@@ -483,6 +533,8 @@ module.exports = {
   isIterable,
   isAsyncIterable,
   isDestroyed,
+  headerNameToString,
+  bufferToLowerCasedHeaderName,
   parseRawHeaders,
   parseHeaders,
   parseKeepAliveTimeout,
@@ -495,8 +547,9 @@ module.exports = {
   getSocketInfo,
   isFormDataLike,
   buildURL,
-  throwIfAborted,
   addAbortListener,
+  isValidHTTPToken,
+  isTokenCharCode,
   parseRangeHeader,
   nodeMajor,
   nodeMinor,

package/lib/fetch/body.js

@@ -374,7 +374,7 @@ function bodyMixinMethods (instance) {
       // If mimeType’s essence is "multipart/form-data", then:
       if (/multipart\/form-data/.test(contentType)) {
         const headers = {}
-        for (const [key, value] of this.headers) headers[key.toLowerCase()] = value
+        for (const [key, value] of this.headers) headers[key] = value
 
         const responseFormData = new FormData()
 

package/lib/fetch/dataURL.js

@@ -1,5 +1,4 @@
 const assert = require('assert')
-const { atob } = require('buffer')
 const { isomorphicDecode } = require('./util')
 
 const encoder = new TextEncoder()
@@ -8,7 +7,8 @@ const encoder = new TextEncoder()
  * @see https://mimesniff.spec.whatwg.org/#http-token-code-point
  */
 const HTTP_TOKEN_CODEPOINTS = /^[!#$%&'*+-.^_|~A-Za-z0-9]+$/
-const HTTP_WHITESPACE_REGEX = /(\u000A|\u000D|\u0009|\u0020)/ // eslint-disable-line
+const HTTP_WHITESPACE_REGEX = /[\u000A|\u000D|\u0009|\u0020]/ // eslint-disable-line
+const ASCII_WHITESPACE_REPLACE_REGEX = /[\u0009\u000A\u000C\u000D\u0020]/g // eslint-disable-line
 /**
  * @see https://mimesniff.spec.whatwg.org/#http-quoted-string-token-code-point
  */
@@ -188,20 +188,26 @@ function stringPercentDecode (input) {
   return percentDecode(bytes)
 }
 
+function isHexCharByte (byte) {
+  // 0-9 A-F a-f
+  return (byte >= 0x30 && byte <= 0x39) || (byte >= 0x41 && byte <= 0x46) || (byte >= 0x61 && byte <= 0x66)
+}
+
 // https://url.spec.whatwg.org/#percent-decode
 /** @param {Uint8Array} input */
 function percentDecode (input) {
+  const length = input.length
   // 1. Let output be an empty byte sequence.
-  /** @type {number[]} */
-  const output = []
-
+  /** @type {Uint8Array} */
+  const output = new Uint8Array(length)
+  let j = 0
   // 2. For each byte byte in input:
-  for (let i = 0; i < input.length; i++) {
+  for (let i = 0; i < length; ++i) {
     const byte = input[i]
 
     // 1. If byte is not 0x25 (%), then append byte to output.
     if (byte !== 0x25) {
-      output.push(byte)
+      output[j++] = byte
 
     // 2. Otherwise, if byte is 0x25 (%) and the next two bytes
     // after byte in input are not in the ranges
@@ -210,9 +216,9 @@ function percentDecode (input) {
     // to output.
     } else if (
       byte === 0x25 &&
-      !/^[0-9A-Fa-f]{2}$/i.test(String.fromCharCode(input[i + 1], input[i + 2]))
+      !(isHexCharByte(input[i + 1]) && isHexCharByte(input[i + 2]))
     ) {
-      output.push(0x25)
+      output[j++] = 0x25
 
     // 3. Otherwise:
     } else {
@@ -222,7 +228,7 @@ function percentDecode (input) {
       const bytePoint = Number.parseInt(nextTwoBytes, 16)
 
       // 2. Append a byte whose value is bytePoint to output.
-      output.push(bytePoint)
+      output[j++] = bytePoint
 
       // 3. Skip the next two bytes in input.
       i += 2
@@ -230,7 +236,7 @@ function percentDecode (input) {
   }
 
   // 3. Return output.
-  return Uint8Array.from(output)
+  return length === j ? output : output.subarray(0, j)
 }
 
 // https://mimesniff.spec.whatwg.org/#parse-a-mime-type
@@ -410,19 +416,25 @@ function parseMIMEType (input) {
 /** @param {string} data */
 function forgivingBase64 (data) {
   // 1. Remove all ASCII whitespace from data.
-  data = data.replace(/[\u0009\u000A\u000C\u000D\u0020]/g, '')  // eslint-disable-line
+  data = data.replace(ASCII_WHITESPACE_REPLACE_REGEX, '')  // eslint-disable-line
 
+  let dataLength = data.length
   // 2. If data’s code point length divides by 4 leaving
   // no remainder, then:
-  if (data.length % 4 === 0) {
+  if (dataLength % 4 === 0) {
     // 1. If data ends with one or two U+003D (=) code points,
     // then remove them from data.
-    data = data.replace(/=?=$/, '')
+    if (data.charCodeAt(dataLength - 1) === 0x003D) {
+      --dataLength
+      if (data.charCodeAt(dataLength - 1) === 0x003D) {
+        --dataLength
+      }
+    }
   }
 
   // 3. If data’s code point length divides by 4 leaving
   // a remainder of 1, then return failure.
-  if (data.length % 4 === 1) {
+  if (dataLength % 4 === 1) {
     return 'failure'
   }
 
@@ -431,18 +443,12 @@ function forgivingBase64 (data) {
   //  U+002F (/)
   //  ASCII alphanumeric
   // then return failure.
-  if (/[^+/0-9A-Za-z]/.test(data)) {
+  if (/[^+/0-9A-Za-z]/.test(data.length === dataLength ? data : data.substring(0, dataLength))) {
     return 'failure'
   }
 
-  const binary = atob(data)
-  const bytes = new Uint8Array(binary.length)
-
-  for (let byte = 0; byte < binary.length; byte++) {
-    bytes[byte] = binary.charCodeAt(byte)
-  }
-
-  return bytes
+  const buffer = Buffer.from(data, 'base64')
+  return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength)
 }
 
 // https://fetch.spec.whatwg.org/#collect-an-http-quoted-string
@@ -570,55 +576,54 @@ function serializeAMimeType (mimeType) {
 
 /**
  * @see https://fetch.spec.whatwg.org/#http-whitespace
- * @param {string} char
+ * @param {number} char
  */
 function isHTTPWhiteSpace (char) {
-  return char === '\r' || char === '\n' || char === '\t' || char === ' '
+  // "\r\n\t "
+  return char === 0x00d || char === 0x00a || char === 0x009 || char === 0x020
 }
 
 /**
  * @see https://fetch.spec.whatwg.org/#http-whitespace
  * @param {string} str
+ * @param {boolean} [leading=true]
+ * @param {boolean} [trailing=true]
  */
 function removeHTTPWhitespace (str, leading = true, trailing = true) {
-  let lead = 0
-  let trail = str.length - 1
-
+  let i = 0; let j = str.length
   if (leading) {
-    for (; lead < str.length && isHTTPWhiteSpace(str[lead]); lead++);
+    while (j > i && isHTTPWhiteSpace(str.charCodeAt(i))) --i
   }
-
   if (trailing) {
-    for (; trail > 0 && isHTTPWhiteSpace(str[trail]); trail--);
+    while (j > i && isHTTPWhiteSpace(str.charCodeAt(j - 1))) --j
   }
-
-  return str.slice(lead, trail + 1)
+  return i === 0 && j === str.length ? str : str.substring(i, j)
 }
 
 /**
  * @see https://infra.spec.whatwg.org/#ascii-whitespace
- * @param {string} char
+ * @param {number} char
  */
 function isASCIIWhitespace (char) {
-  return char === '\r' || char === '\n' || char === '\t' || char === '\f' || char === ' '
+  // "\r\n\t\f "
+  return char === 0x00d || char === 0x00a || char === 0x009 || char === 0x00c || char === 0x020
 }
 
 /**
  * @see https://infra.spec.whatwg.org/#strip-leading-and-trailing-ascii-whitespace
+ * @param {string} str
+ * @param {boolean} [leading=true]
+ * @param {boolean} [trailing=true]
  */
 function removeASCIIWhitespace (str, leading = true, trailing = true) {
-  let lead = 0
-  let trail = str.length - 1
-
+  let i = 0; let j = str.length
   if (leading) {
-    for (; lead < str.length && isASCIIWhitespace(str[lead]); lead++);
+    while (j > i && isASCIIWhitespace(str.charCodeAt(i))) --i
   }
-
   if (trailing) {
-    for (; trail > 0 && isASCIIWhitespace(str[trail]); trail--);
+    while (j > i && isASCIIWhitespace(str.charCodeAt(j - 1))) --j
   }
-
-  return str.slice(lead, trail + 1)
+  return i === 0 && j === str.length ? str : str.substring(i, j)
 }
 
 module.exports = {

package/lib/fetch/headers.js

@@ -114,7 +114,7 @@ function appendHeader (headers, name, value) {
   //    forbidden response-header name, return.
 
   // 7. Append (name, value) to headers’s header list.
-  return headers[kHeadersList].append(name, value)
+  return headers[kHeadersList].append(name, value, false)
 
   // 8. If headers’s guard is "request-no-cors", then remove
   //    privileged no-CORS request headers from headers
@@ -135,14 +135,17 @@ class HeadersList {
     }
   }
 
-  // https://fetch.spec.whatwg.org/#header-list-contains
-  contains (name) {
+  /**
+   * @see https://fetch.spec.whatwg.org/#header-list-contains
+   * @param {string} name
+   * @param {boolean} isLowerCase
+   */
+  contains (name, isLowerCase) {
     // A header list list contains a header name name if list
     // contains a header whose name is a byte-case-insensitive
     // match for name.
-    name = name.toLowerCase()
 
-    return this[kHeadersMap].has(name)
+    return this[kHeadersMap].has(isLowerCase ? name : name.toLowerCase())
   }
 
   clear () {
@@ -151,13 +154,18 @@ class HeadersList {
     this.cookies = null
   }
 
-  // https://fetch.spec.whatwg.org/#concept-header-list-append
-  append (name, value) {
+  /**
+   * @see https://fetch.spec.whatwg.org/#concept-header-list-append
+   * @param {string} name
+   * @param {string} value
+   * @param {boolean} isLowerCase
+   */
+  append (name, value, isLowerCase) {
     this[kHeadersSortedMap] = null
 
     // 1. If list contains name, then set name to the first such
     //    header’s name.
-    const lowercaseName = name.toLowerCase()
+    const lowercaseName = isLowerCase ? name : name.toLowerCase()
     const exists = this[kHeadersMap].get(lowercaseName)
 
     // 2. Append (name, value) to list.
@@ -172,15 +180,19 @@ class HeadersList {
     }
 
     if (lowercaseName === 'set-cookie') {
-      this.cookies ??= []
-      this.cookies.push(value)
+      (this.cookies ??= []).push(value)
     }
   }
 
-  // https://fetch.spec.whatwg.org/#concept-header-list-set
-  set (name, value) {
+  /**
+   * @see https://fetch.spec.whatwg.org/#concept-header-list-set
+   * @param {string} name
+   * @param {string} value
+   * @param {boolean} isLowerCase
+   */
+  set (name, value, isLowerCase) {
     this[kHeadersSortedMap] = null
-    const lowercaseName = name.toLowerCase()
+    const lowercaseName = isLowerCase ? name : name.toLowerCase()
 
     if (lowercaseName === 'set-cookie') {
       this.cookies = [value]
@@ -193,11 +205,14 @@ class HeadersList {
     this[kHeadersMap].set(lowercaseName, { name, value })
   }
 
-  // https://fetch.spec.whatwg.org/#concept-header-list-delete
-  delete (name) {
+  /**
+   * @see https://fetch.spec.whatwg.org/#concept-header-list-delete
+   * @param {string} name
+   * @param {boolean} isLowerCase
+   */
+  delete (name, isLowerCase) {
     this[kHeadersSortedMap] = null
-
-    name = name.toLowerCase()
+    if (!isLowerCase) name = name.toLowerCase()
 
     if (name === 'set-cookie') {
       this.cookies = null
@@ -206,15 +221,18 @@ class HeadersList {
     this[kHeadersMap].delete(name)
   }
 
-  // https://fetch.spec.whatwg.org/#concept-header-list-get
-  get (name) {
-    const value = this[kHeadersMap].get(name.toLowerCase())
-
+  /**
+   * @see https://fetch.spec.whatwg.org/#concept-header-list-get
+   * @param {string} name
+   * @param {boolean} isLowerCase
+   * @returns {string | null}
+   */
+  get (name, isLowerCase) {
     // 1. If list does not contain name, then return null.
     // 2. Return the values of all headers in list whose name
     //    is a byte-case-insensitive match for name,
     //    separated from each other by 0x2C 0x20, in order.
-    return value === undefined ? null : value.value
+    return this[kHeadersMap].get(isLowerCase ? name : name.toLowerCase())?.value ?? null
   }
 
   * [Symbol.iterator] () {
@@ -304,14 +322,14 @@ class Headers {
 
     // 6. If this’s header list does not contain name, then
     //    return.
-    if (!this[kHeadersList].contains(name)) {
+    if (!this[kHeadersList].contains(name, false)) {
       return
     }
 
     // 7. Delete name from this’s header list.
     // 8. If this’s guard is "request-no-cors", then remove
     //    privileged no-CORS request headers from this.
-    this[kHeadersList].delete(name)
+    this[kHeadersList].delete(name, false)
   }
 
   // https://fetch.spec.whatwg.org/#dom-headers-get
@@ -333,7 +351,7 @@ class Headers {
 
     // 2. Return the result of getting name from this’s header
     //    list.
-    return this[kHeadersList].get(name)
+    return this[kHeadersList].get(name, false)
   }
 
   // https://fetch.spec.whatwg.org/#dom-headers-has
@@ -355,7 +373,7 @@ class Headers {
 
     // 2. Return true if this’s header list contains name;
     //    otherwise false.
-    return this[kHeadersList].contains(name)
+    return this[kHeadersList].contains(name, false)
   }
 
   // https://fetch.spec.whatwg.org/#dom-headers-set
@@ -404,7 +422,7 @@ class Headers {
     // 7. Set (name, value) in this’s header list.
     // 8. If this’s guard is "request-no-cors", then remove
     //    privileged no-CORS request headers from this
-    this[kHeadersList].set(name, value)
+    this[kHeadersList].set(name, value, false)
   }
 
   // https://fetch.spec.whatwg.org/#dom-headers-getsetcookie