pnpm 7.9.1 → 7.9.2

package/dist/node_modules/minipass-fetch/lib/body.js

@@ -3,7 +3,7 @@ const Minipass = require('minipass')
 const MinipassSized = require('minipass-sized')
 
 const Blob = require('./blob.js')
-const {BUFFER} = Blob
+const { BUFFER } = Blob
 const FetchError = require('./fetch-error.js')
 
 // optional dependency on 'encoding'
@@ -24,10 +24,10 @@ class Body {
       : Buffer.isBuffer(bodyArg) ? bodyArg
       : Object.prototype.toString.call(bodyArg) === '[object ArrayBuffer]'
         ? Buffer.from(bodyArg)
-      : ArrayBuffer.isView(bodyArg)
-        ? Buffer.from(bodyArg.buffer, bodyArg.byteOffset, bodyArg.byteLength)
-      : Minipass.isStream(bodyArg) ? bodyArg
-      : Buffer.from(String(bodyArg))
+        : ArrayBuffer.isView(bodyArg)
+          ? Buffer.from(bodyArg.buffer, bodyArg.byteOffset, bodyArg.byteLength)
+          : Minipass.isStream(bodyArg) ? bodyArg
+          : Buffer.from(String(bodyArg))
 
     this[INTERNALS] = {
       body,
@@ -94,28 +94,32 @@ class Body {
   }
 
   [CONSUME_BODY] () {
-    if (this[INTERNALS].disturbed)
+    if (this[INTERNALS].disturbed) {
       return Promise.reject(new TypeError(`body used already for: ${
         this.url}`))
+    }
 
     this[INTERNALS].disturbed = true
 
-    if (this[INTERNALS].error)
+    if (this[INTERNALS].error) {
       return Promise.reject(this[INTERNALS].error)
+    }
 
     // body is null
     if (this.body === null) {
       return Promise.resolve(Buffer.alloc(0))
     }
 
-    if (Buffer.isBuffer(this.body))
+    if (Buffer.isBuffer(this.body)) {
       return Promise.resolve(this.body)
+    }
 
     const upstream = isBlob(this.body) ? this.body.stream() : this.body
 
     /* istanbul ignore if: should never happen */
-    if (!Minipass.isStream(upstream))
+    if (!Minipass.isStream(upstream)) {
       return Promise.resolve(Buffer.alloc(0))
+    }
 
     const stream = this.size && upstream instanceof MinipassSized ? upstream
       : !this.size && upstream instanceof Minipass &&
@@ -123,8 +127,10 @@ class Body {
       : this.size ? new MinipassSized({ size: this.size })
       : new Minipass()
 
-    // allow timeout on slow response body
-    const resTimeout = this.timeout ? setTimeout(() => {
+    // allow timeout on slow response body, but only if the stream is still writable. this
+    // makes the timeout center on the socket stream from lib/index.js rather than the
+    // intermediary minipass stream we create to receive the data
+    const resTimeout = this.timeout && stream.writable ? setTimeout(() => {
       stream.emit('error', new FetchError(
         `Response timeout while trying to fetch ${
           this.url} (over ${this.timeout}ms)`, 'body-timeout'))
@@ -132,7 +138,7 @@ class Body {
 
     // do not keep the process open just for this timeout, even
     // though we expect it'll get cleared eventually.
-    if (resTimeout) {
+    if (resTimeout && resTimeout.unref) {
       resTimeout.unref()
     }
 
@@ -152,21 +158,23 @@ class Body {
     }).catch(er => {
       clearTimeout(resTimeout)
       // request was aborted, reject with this Error
-      if (er.name === 'AbortError' || er.name === 'FetchError')
+      if (er.name === 'AbortError' || er.name === 'FetchError') {
         throw er
-      else if (er.name === 'RangeError')
+      } else if (er.name === 'RangeError') {
         throw new FetchError(`Could not create Buffer from response body for ${
           this.url}: ${er.message}`, 'system', er)
-      else
+      } else {
         // other errors, such as incorrect content-encoding or content-length
         throw new FetchError(`Invalid response body while trying to fetch ${
           this.url}: ${er.message}`, 'system', er)
+      }
     })
   }
 
   static clone (instance) {
-    if (instance.bodyUsed)
+    if (instance.bodyUsed) {
       throw new Error('cannot clone body after it is used')
+    }
 
     const body = instance.body
 
@@ -190,8 +198,9 @@ class Body {
       // set instance body to one fork, return the other
       instance[INTERNALS].body = p1
       return p2
-    } else
+    } else {
       return instance.body
+    }
   }
 
   static extractContentType (body) {
@@ -199,38 +208,38 @@ class Body {
       : typeof body === 'string' ? 'text/plain;charset=UTF-8'
       : isURLSearchParams(body)
         ? 'application/x-www-form-urlencoded;charset=UTF-8'
-      : isBlob(body) ? body.type || null
-      : Buffer.isBuffer(body) ? null
-      : Object.prototype.toString.call(body) === '[object ArrayBuffer]' ? null
-      : ArrayBuffer.isView(body) ? null
-      : typeof body.getBoundary === 'function'
-        ? `multipart/form-data;boundary=${body.getBoundary()}`
-      : Minipass.isStream(body) ? null
-      : 'text/plain;charset=UTF-8'
+        : isBlob(body) ? body.type || null
+        : Buffer.isBuffer(body) ? null
+        : Object.prototype.toString.call(body) === '[object ArrayBuffer]' ? null
+        : ArrayBuffer.isView(body) ? null
+        : typeof body.getBoundary === 'function'
+          ? `multipart/form-data;boundary=${body.getBoundary()}`
+          : Minipass.isStream(body) ? null
+          : 'text/plain;charset=UTF-8'
   }
 
   static getTotalBytes (instance) {
-    const {body} = instance
+    const { body } = instance
     return (body === null || body === undefined) ? 0
-    : isBlob(body) ? body.size
-    : Buffer.isBuffer(body) ? body.length
-    : body && typeof body.getLengthSync === 'function' && (
+      : isBlob(body) ? body.size
+      : Buffer.isBuffer(body) ? body.length
+      : body && typeof body.getLengthSync === 'function' && (
         // detect form data input from form-data module
         body._lengthRetrievers &&
-        /* istanbul ignore next */ body._lengthRetrievers.length == 0 || // 1.x
+        /* istanbul ignore next */ body._lengthRetrievers.length === 0 || // 1.x
         body.hasKnownLength && body.hasKnownLength()) // 2.x
-      ? body.getLengthSync()
-    : null
+        ? body.getLengthSync()
+        : null
   }
 
   static writeToStream (dest, instance) {
-    const {body} = instance
+    const { body } = instance
 
-    if (body === null || body === undefined)
+    if (body === null || body === undefined) {
       dest.end()
-    else if (Buffer.isBuffer(body) || typeof body === 'string')
+    } else if (Buffer.isBuffer(body) || typeof body === 'string') {
       dest.end(body)
-    else {
+    } else {
       // body is stream or blob
       const stream = isBlob(body) ? body.stream() : body
       stream.on('error', er => dest.emit('error', er)).pipe(dest)
@@ -246,10 +255,9 @@ Object.defineProperties(Body.prototype, {
   arrayBuffer: { enumerable: true },
   blob: { enumerable: true },
   json: { enumerable: true },
-  text: { enumerable: true }
+  text: { enumerable: true },
 })
 
-
 const isURLSearchParams = obj =>
   // Duck-typing as a necessary condition.
   (typeof obj !== 'object' ||
@@ -274,26 +282,28 @@ const isBlob = obj =>
   /^(Blob|File)$/.test(obj.constructor.name) &&
   /^(Blob|File)$/.test(obj[Symbol.toStringTag])
 
-
 const convertBody = (buffer, headers) => {
   /* istanbul ignore if */
-  if (typeof convert !== 'function')
+  if (typeof convert !== 'function') {
     throw new Error('The package `encoding` must be installed to use the textConverted() function')
+  }
 
   const ct = headers && headers.get('content-type')
   let charset = 'utf-8'
-  let res, str
+  let res
 
   // header
-  if (ct)
+  if (ct) {
     res = /charset=([^;]*)/i.exec(ct)
+  }
 
   // no charset in content type, peek at response body for at most 1024 bytes
-  str = buffer.slice(0, 1024).toString()
+  const str = buffer.slice(0, 1024).toString()
 
   // html5
-  if (!res && str)
+  if (!res && str) {
     res = /<meta.+?charset=(['"])(.+?)\1/i.exec(str)
+  }
 
   // html4
   if (!res && str) {
@@ -301,17 +311,20 @@ const convertBody = (buffer, headers) => {
 
     if (!res) {
       res = /<meta[\s]+?content=(['"])(.+?)\1[\s]+?http-equiv=(['"])content-type\3/i.exec(str)
-      if (res)
-        res.pop() // drop last quote
+      if (res) {
+        res.pop()
+      } // drop last quote
     }
 
-    if (res)
+    if (res) {
       res = /charset=(.*)/i.exec(res.pop())
+    }
   }
 
   // xml
-  if (!res && str)
+  if (!res && str) {
     res = /<\?xml.+?encoding=(['"])(.+?)\1/i.exec(str)
+  }
 
   // found charset
   if (res) {
@@ -319,8 +332,9 @@ const convertBody = (buffer, headers) => {
 
     // prevent decode issues when sites use incorrect encoding
     // ref: https://hsivonen.fi/encoding-menu/
-    if (charset === 'gb2312' || charset === 'gbk')
+    if (charset === 'gb2312' || charset === 'gbk') {
       charset = 'gb18030'
+    }
   }
 
   // turn raw buffers into a single utf-8 buffer

package/dist/node_modules/minipass-fetch/lib/fetch-error.js

@@ -5,8 +5,9 @@ class FetchError extends Error {
     this.code = 'FETCH_ERROR'
 
     // pick up code, expected, path, ...
-    if (systemError)
+    if (systemError) {
       Object.assign(this, systemError)
+    }
 
     this.errno = this.code
 

package/dist/node_modules/minipass-fetch/lib/headers.js

@@ -1,24 +1,27 @@
 'use strict'
-const invalidTokenRegex = /[^\^_`a-zA-Z\-0-9!#$%&'*+.|~]/
+const invalidTokenRegex = /[^^_`a-zA-Z\-0-9!#$%&'*+.|~]/
 const invalidHeaderCharRegex = /[^\t\x20-\x7e\x80-\xff]/
 
 const validateName = name => {
   name = `${name}`
-  if (invalidTokenRegex.test(name) || name === '')
+  if (invalidTokenRegex.test(name) || name === '') {
     throw new TypeError(`${name} is not a legal HTTP header name`)
+  }
 }
 
 const validateValue = value => {
   value = `${value}`
-  if (invalidHeaderCharRegex.test(value))
+  if (invalidHeaderCharRegex.test(value)) {
     throw new TypeError(`${value} is not a legal HTTP header value`)
+  }
 }
 
 const find = (map, name) => {
   name = name.toLowerCase()
   for (const key in map) {
-    if (key.toLowerCase() === name)
+    if (key.toLowerCase() === name) {
       return key
+    }
   }
   return undefined
 }
@@ -39,25 +42,29 @@ class Headers {
     }
 
     // no-op
-    if (init === undefined || init === null)
+    if (init === undefined || init === null) {
       return
+    }
 
     if (typeof init === 'object') {
       const method = init[Symbol.iterator]
       if (method !== null && method !== undefined) {
-        if (typeof method !== 'function')
+        if (typeof method !== 'function') {
           throw new TypeError('Header pairs must be iterable')
+        }
 
         // sequence<sequence<ByteString>>
         // Note: per spec we have to first exhaust the lists then process them
         const pairs = []
         for (const pair of init) {
           if (typeof pair !== 'object' ||
-              typeof pair[Symbol.iterator] !== 'function')
+              typeof pair[Symbol.iterator] !== 'function') {
             throw new TypeError('Each header pair must be iterable')
+          }
           const arrPair = Array.from(pair)
-          if (arrPair.length !== 2)
+          if (arrPair.length !== 2) {
             throw new TypeError('Each header pair must be a name/value tuple')
+          }
           pairs.push(arrPair)
         }
 
@@ -70,16 +77,18 @@ class Headers {
           this.append(key, init[key])
         }
       }
-    } else
+    } else {
       throw new TypeError('Provided initializer must be an object')
+    }
   }
 
   get (name) {
     name = `${name}`
     validateName(name)
     const key = find(this[MAP], name)
-    if (key === undefined)
+    if (key === undefined) {
       return null
+    }
 
     return this[MAP][key].join(', ')
   }
@@ -109,10 +118,11 @@ class Headers {
     validateName(name)
     validateValue(value)
     const key = find(this[MAP], name)
-    if (key !== undefined)
+    if (key !== undefined) {
       this[MAP][key].push(value)
-    else
+    } else {
       this[MAP][name] = [value]
+    }
   }
 
   has (name) {
@@ -125,8 +135,9 @@ class Headers {
     name = `${name}`
     validateName(name)
     const key = find(this[MAP], name)
-    if (key !== undefined)
+    if (key !== undefined) {
       delete this[MAP][key]
+    }
   }
 
   raw () {
@@ -141,7 +152,7 @@ class Headers {
     return new HeadersIterator(this, 'value')
   }
 
-  [Symbol.iterator]() {
+  [Symbol.iterator] () {
     return new HeadersIterator(this, 'key+value')
   }
 
@@ -159,8 +170,9 @@ class Headers {
     // http.request() only supports string as Host header. This hack makes
     // specifying custom Host header possible.
     const hostHeaderKey = find(headers[MAP], 'Host')
-    if (hostHeaderKey !== undefined)
+    if (hostHeaderKey !== undefined) {
       obj[hostHeaderKey] = obj[hostHeaderKey][0]
+    }
 
     return obj
   }
@@ -168,21 +180,25 @@ class Headers {
   static createHeadersLenient (obj) {
     const headers = new Headers()
     for (const name of Object.keys(obj)) {
-      if (invalidTokenRegex.test(name))
+      if (invalidTokenRegex.test(name)) {
         continue
+      }
 
       if (Array.isArray(obj[name])) {
         for (const val of obj[name]) {
-          if (invalidHeaderCharRegex.test(val))
+          if (invalidHeaderCharRegex.test(val)) {
             continue
+          }
 
-          if (headers[MAP][name] === undefined)
+          if (headers[MAP][name] === undefined) {
             headers[MAP][name] = [val]
-          else
+          } else {
             headers[MAP][name].push(val)
+          }
         }
-      } else if (!invalidHeaderCharRegex.test(obj[name]))
+      } else if (!invalidHeaderCharRegex.test(obj[name])) {
         headers[MAP][name] = [obj[name]]
+      }
     }
     return headers
   }
@@ -224,8 +240,9 @@ class HeadersIterator {
 
   next () {
     /* istanbul ignore if: should be impossible */
-    if (!this || Object.getPrototypeOf(this) !== HeadersIterator.prototype)
+    if (!this || Object.getPrototypeOf(this) !== HeadersIterator.prototype) {
       throw new TypeError('Value of `this` is not a HeadersIterator')
+    }
 
     const { target, kind, index } = this[INTERNAL]
     const values = getHeaders(target, kind)