@yanglaofish/fishtools 0.5.1 → 0.5.3

package/node_modules/undici/lib/web/fetch/body.js

@@ -2,49 +2,57 @@
 
 const util = require('../../core/util')
 const {
+  ReadableStreamFrom,
+  isBlobLike,
+  isReadableStreamLike,
   readableStreamClose,
+  createDeferredPromise,
   fullyReadBody,
-  extractMimeType
+  extractMimeType,
+  utf8DecodeBytes
 } = require('./util')
-const { FormData, setFormDataState, getFormDataBoundary } = require('./formdata')
-const { webidl } = require('../webidl')
+const { FormData } = require('./formdata')
+const { kState } = require('./symbols')
+const { webidl } = require('./webidl')
+const { Blob } = require('node:buffer')
 const assert = require('node:assert')
 const { isErrored, isDisturbed } = require('node:stream')
-const { isUint8Array } = require('node:util/types')
+const { isArrayBuffer } = require('node:util/types')
 const { serializeAMimeType } = require('./data-url')
 const { multipartFormDataParser } = require('./formdata-parser')
-const { parseJSONFromBytes } = require('../infra')
-const { utf8DecodeBytes } = require('../../encoding')
-const { ReadableStreamTee } = require('node:stream/web')
+let random
+
+try {
+  const crypto = require('node:crypto')
+  random = (max) => crypto.randomInt(0, max)
+} catch {
+  random = (max) => Math.floor(Math.random(max))
+}
 
 const textEncoder = new TextEncoder()
 function noop () {}
 
-const streamRegistry = new FinalizationRegistry((weakRef) => {
-  const stream = weakRef.deref()
-  if (stream && !stream.locked && !isDisturbed(stream) && !isErrored(stream)) {
-    stream.cancel('Response object has been garbage collected').catch(noop)
-  }
-})
+const hasFinalizationRegistry = globalThis.FinalizationRegistry && process.version.indexOf('v18') !== 0
+let streamRegistry
 
-/**
- * Extract a body with type from a byte sequence or BodyInit object
- *
- * @param {import('../../../types').BodyInit} object - The BodyInit object to extract from
- * @param {boolean} [keepalive=false] - If true, indicates that the body
- * @returns {[{stream: ReadableStream, source: any, length: number | null}, string | null]} - Returns a tuple containing the body and its type
- *
- * @see https://fetch.spec.whatwg.org/#concept-bodyinit-extract
- */
+if (hasFinalizationRegistry) {
+  streamRegistry = new FinalizationRegistry((weakRef) => {
+    const stream = weakRef.deref()
+    if (stream && !stream.locked && !isDisturbed(stream) && !isErrored(stream)) {
+      stream.cancel('Response object has been garbage collected').catch(noop)
+    }
+  })
+}
+
+// https://fetch.spec.whatwg.org/#concept-bodyinit-extract
 function extractBody (object, keepalive = false) {
   // 1. Let stream be null.
   let stream = null
-  let controller = null
 
   // 2. If object is a ReadableStream object, then set stream to object.
-  if (webidl.is.ReadableStream(object)) {
+  if (object instanceof ReadableStream) {
     stream = object
-  } else if (webidl.is.Blob(object)) {
+  } else if (isBlobLike(object)) {
     // 3. Otherwise, if object is a Blob object, set stream to the
     //    result of running object’s get stream.
     stream = object.stream()
@@ -52,17 +60,22 @@ function extractBody (object, keepalive = false) {
     // 4. Otherwise, set stream to a new ReadableStream object, and set
     //    up stream with byte reading support.
     stream = new ReadableStream({
-      pull () {},
-      start (c) {
-        controller = c
+      async pull (controller) {
+        const buffer = typeof source === 'string' ? textEncoder.encode(source) : source
+
+        if (buffer.byteLength) {
+          controller.enqueue(buffer)
+        }
+
+        queueMicrotask(() => readableStreamClose(controller))
       },
-      cancel () {},
+      start () {},
       type: 'bytes'
     })
   }
 
   // 5. Assert: stream is a ReadableStream object.
-  assert(webidl.is.ReadableStream(stream))
+  assert(isReadableStreamLike(stream))
 
   // 6. Let action be null.
   let action = null
@@ -84,7 +97,7 @@ function extractBody (object, keepalive = false) {
 
     // Set type to `text/plain;charset=UTF-8`.
     type = 'text/plain;charset=UTF-8'
-  } else if (webidl.is.URLSearchParams(object)) {
+  } else if (object instanceof URLSearchParams) {
     // URLSearchParams
 
     // spec says to run application/x-www-form-urlencoded on body.list
@@ -97,15 +110,22 @@ function extractBody (object, keepalive = false) {
 
     // Set type to `application/x-www-form-urlencoded;charset=UTF-8`.
     type = 'application/x-www-form-urlencoded;charset=UTF-8'
-  } else if (webidl.is.BufferSource(object)) {
+  } else if (isArrayBuffer(object)) {
+    // BufferSource/ArrayBuffer
+
     // Set source to a copy of the bytes held by object.
-    source = webidl.util.getCopyOfBytesHeldByBufferSource(object)
-  } else if (webidl.is.FormData(object)) {
-    const boundary = getFormDataBoundary(object)
+    source = new Uint8Array(object.slice())
+  } else if (ArrayBuffer.isView(object)) {
+    // BufferSource/ArrayBufferView
+
+    // Set source to a copy of the bytes held by object.
+    source = new Uint8Array(object.buffer.slice(object.byteOffset, object.byteOffset + object.byteLength))
+  } else if (util.isFormDataLike(object)) {
+    const boundary = `----formdata-undici-0${`${random(1e11)}`.padStart(11, '0')}`
     const prefix = `--${boundary}\r\nContent-Disposition: form-data`
 
     /*! formdata-polyfill. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> */
-    const formdataEscape = (str) =>
+    const escape = (str) =>
       str.replace(/\n/g, '%0A').replace(/\r/g, '%0D').replace(/"/g, '%22')
     const normalizeLinefeeds = (value) => value.replace(/\r?\n|\r/g, '\r\n')
 
@@ -123,13 +143,13 @@ function extractBody (object, keepalive = false) {
     for (const [name, value] of object) {
       if (typeof value === 'string') {
         const chunk = textEncoder.encode(prefix +
-          `; name="${formdataEscape(normalizeLinefeeds(name))}"` +
+          `; name="${escape(normalizeLinefeeds(name))}"` +
           `\r\n\r\n${normalizeLinefeeds(value)}\r\n`)
         blobParts.push(chunk)
         length += chunk.byteLength
       } else {
-        const chunk = textEncoder.encode(`${prefix}; name="${formdataEscape(normalizeLinefeeds(name))}"` +
-          (value.name ? `; filename="${formdataEscape(value.name)}"` : '') + '\r\n' +
+        const chunk = textEncoder.encode(`${prefix}; name="${escape(normalizeLinefeeds(name))}"` +
+          (value.name ? `; filename="${escape(value.name)}"` : '') + '\r\n' +
           `Content-Type: ${
             value.type || 'application/octet-stream'
           }\r\n\r\n`)
@@ -169,7 +189,7 @@ function extractBody (object, keepalive = false) {
     // followed by the multipart/form-data boundary string generated
     // by the multipart/form-data encoding algorithm.
     type = `multipart/form-data; boundary=${boundary}`
-  } else if (webidl.is.Blob(object)) {
+  } else if (isBlobLike(object)) {
     // Blob
 
     // Set source to object.
@@ -196,50 +216,50 @@ function extractBody (object, keepalive = false) {
       )
     }
 
-    stream = webidl.is.ReadableStream(object)
-      ? object
-      : ReadableStream.from(object).pipeThrough(new TransformStream({
-        transform (chunk, controller) {
-          const bytes = isUint8Array(chunk) ? chunk : Buffer.from(chunk)
-          if (bytes.byteLength) {
-            controller.enqueue(bytes)
-          }
-        }
-      }))
+    stream =
+      object instanceof ReadableStream ? object : ReadableStreamFrom(object)
   }
 
   // 11. If source is a byte sequence, then set action to a
   // step that returns source and length to source’s length.
-  if (typeof source === 'string' || isUint8Array(source)) {
-    action = () => {
-      length = typeof source === 'string' ? Buffer.byteLength(source) : source.length
-      return source
-    }
+  if (typeof source === 'string' || util.isBuffer(source)) {
+    length = Buffer.byteLength(source)
   }
 
-  // 12. If action is non-null, then run these steps in parallel:
+  // 12. If action is non-null, then run these steps in in parallel:
   if (action != null) {
-    ;(async () => {
-      // 1. Run action.
-      const result = action()
-
-      // 2. Whenever one or more bytes are available and stream is not errored,
-      //    enqueue the result of creating a Uint8Array from the available bytes into stream.
-      const iterator = result?.[Symbol.asyncIterator]?.()
-      if (iterator) {
-        for await (const bytes of iterator) {
-          if (isErrored(stream)) break
-          if (bytes.length) {
-            controller.enqueue(new Uint8Array(bytes))
+    // Run action.
+    let iterator
+    stream = new ReadableStream({
+      async start () {
+        iterator = action(object)[Symbol.asyncIterator]()
+      },
+      async pull (controller) {
+        const { value, done } = await iterator.next()
+        if (done) {
+          // When running action is done, close stream.
+          queueMicrotask(() => {
+            controller.close()
+            controller.byobRequest?.respond(0)
+          })
+        } else {
+          // Whenever one or more bytes are available and stream is not errored,
+          // enqueue a Uint8Array wrapping an ArrayBuffer containing the available
+          // bytes into stream.
+          if (!isErrored(stream)) {
+            const buffer = new Uint8Array(value)
+            if (buffer.byteLength) {
+              controller.enqueue(buffer)
+            }
           }
         }
-      } else if (result?.length && !isErrored(stream)) {
-        controller.enqueue(typeof result === 'string' ? textEncoder.encode(result) : new Uint8Array(result))
-      }
-
-      // 3. When running action is done, close stream.
-      queueMicrotask(() => readableStreamClose(controller))
-    })()
+        return controller.desiredSize > 0
+      },
+      async cancel (reason) {
+        await iterator.return()
+      },
+      type: 'bytes'
+    })
   }
 
   // 13. Let body be a body whose stream is stream, source is source,
@@ -250,30 +270,17 @@ function extractBody (object, keepalive = false) {
   return [body, type]
 }
 
-/**
- * @typedef {object} ExtractBodyResult
- * @property {ReadableStream<Uint8Array<ArrayBuffer>>} stream - The ReadableStream containing the body data
- * @property {any} source - The original source of the body data
- * @property {number | null} length - The length of the body data, or null
- */
-
-/**
- * Safely extract a body with type from a byte sequence or BodyInit object.
- *
- * @param {import('../../../types').BodyInit} object - The BodyInit object to extract from
- * @param {boolean} [keepalive=false] - If true, indicates that the body
- * @returns {[ExtractBodyResult, string | null]} - Returns a tuple containing the body and its type
- *
- * @see https://fetch.spec.whatwg.org/#bodyinit-safely-extract
- */
+// https://fetch.spec.whatwg.org/#bodyinit-safely-extract
 function safelyExtractBody (object, keepalive = false) {
   // To safely extract a body and a `Content-Type` value from
   // a byte sequence or BodyInit object object, run these steps:
 
   // 1. If object is a ReadableStream object, then:
-  if (webidl.is.ReadableStream(object)) {
+  if (object instanceof ReadableStream) {
     // Assert: object is neither disturbed nor locked.
+    // istanbul ignore next
     assert(!util.isDisturbed(object), 'The body has already been consumed.')
+    // istanbul ignore next
     assert(!object.locked, 'The stream is locked.')
   }
 
@@ -281,13 +288,13 @@ function safelyExtractBody (object, keepalive = false) {
   return extractBody(object, keepalive)
 }
 
-function cloneBody (body) {
+function cloneBody (instance, body) {
   // To clone a body body, run these steps:
 
   // https://fetch.spec.whatwg.org/#concept-body-clone
 
   // 1. Let « out1, out2 » be the result of teeing body’s stream.
-  const { 0: out1, 1: out2 } = ReadableStreamTee?.(body.stream, true) ?? body.stream.tee()
+  const [out1, out2] = body.stream.tee()
 
   // 2. Set body’s stream to out1.
   body.stream = out1
@@ -300,7 +307,13 @@ function cloneBody (body) {
   }
 }
 
-function bodyMixinMethods (brandCheck, getInternalState) {
+function throwIfAborted (state) {
+  if (state.aborted) {
+    throw new DOMException('The operation was aborted.', 'AbortError')
+  }
+}
+
+function bodyMixinMethods (instance) {
   const methods = {
     blob () {
       // The blob() method steps are to return the result of
@@ -309,7 +322,7 @@ function bodyMixinMethods (brandCheck, getInternalState) {
       // contents are bytes and whose type attribute is this’s
       // MIME type.
       return consumeBody(this, (bytes) => {
-        let mimeType = bodyMimeType(getInternalState(this))
+        let mimeType = bodyMimeType(this)
 
         if (mimeType === null) {
           mimeType = ''
@@ -320,7 +333,7 @@ function bodyMixinMethods (brandCheck, getInternalState) {
         // Return a Blob whose contents are bytes and type attribute
         // is mimeType.
         return new Blob([bytes], { type: mimeType })
-      }, brandCheck, getInternalState)
+      }, instance)
     },
 
     arrayBuffer () {
@@ -330,19 +343,19 @@ function bodyMixinMethods (brandCheck, getInternalState) {
       // whose contents are bytes.
       return consumeBody(this, (bytes) => {
         return new Uint8Array(bytes).buffer
-      }, brandCheck, getInternalState)
+      }, instance)
     },
 
     text () {
       // The text() method steps are to return the result of running
       // consume body with this and UTF-8 decode.
-      return consumeBody(this, utf8DecodeBytes, brandCheck, getInternalState)
+      return consumeBody(this, utf8DecodeBytes, instance)
     },
 
     json () {
       // The json() method steps are to return the result of running
       // consume body with this and parse JSON from bytes.
-      return consumeBody(this, parseJSONFromBytes, brandCheck, getInternalState)
+      return consumeBody(this, parseJSONFromBytes, instance)
     },
 
     formData () {
@@ -350,7 +363,7 @@ function bodyMixinMethods (brandCheck, getInternalState) {
       // consume body with this and the following step given a byte sequence bytes:
       return consumeBody(this, (value) => {
         // 1. Let mimeType be the result of get the MIME type with this.
-        const mimeType = bodyMimeType(getInternalState(this))
+        const mimeType = bodyMimeType(this)
 
         // 2. If mimeType is non-null, then switch on mimeType’s essence and run
         //    the corresponding steps:
@@ -358,13 +371,17 @@ function bodyMixinMethods (brandCheck, getInternalState) {
           switch (mimeType.essence) {
             case 'multipart/form-data': {
               // 1. ... [long step]
-              // 2. If that fails for some reason, then throw a TypeError.
               const parsed = multipartFormDataParser(value, mimeType)
 
+              // 2. If that fails for some reason, then throw a TypeError.
+              if (parsed === 'failure') {
+                throw new TypeError('Failed to parse body as FormData.')
+              }
+
               // 3. Return a new FormData object, appending each entry,
               //    resulting from the parsing operation, to its entry list.
               const fd = new FormData()
-              setFormDataState(fd, parsed)
+              fd[kState] = parsed
 
               return fd
             }
@@ -390,7 +407,7 @@ function bodyMixinMethods (brandCheck, getInternalState) {
         throw new TypeError(
           'Content-Type was not one of "multipart/form-data" or "application/x-www-form-urlencoded".'
         )
-      }, brandCheck, getInternalState)
+      }, instance)
     },
 
     bytes () {
@@ -399,87 +416,39 @@ function bodyMixinMethods (brandCheck, getInternalState) {
       // result of creating a Uint8Array from bytes in this’s relevant realm.
       return consumeBody(this, (bytes) => {
         return new Uint8Array(bytes)
-      }, brandCheck, getInternalState)
-    },
-
-    textStream () {
-      const this_ = getInternalState(this)
-
-      // 1. If this is unusable, then throw a TypeError.
-      if (bodyUnusable(this_)) {
-        throw new TypeError('Body is unusable: Body has already been read')
-      }
-
-      // 2. If this’s body is null:
-      if (this_.body == null) {
-        // 2.1. Let emptyStream be a new ReadableStream in this’s relevant realm.
-        // 2.2. Set up emptyStream.
-        /** @type {ReadableStreamDefaultController<any>} */
-        let controller
-        const emptyStream = new ReadableStream({
-          start: (c) => {
-            controller = c
-          },
-          pull: () => Promise.resolve(),
-          cancel: () => Promise.resolve()
-        }, {
-          size: () => 1
-        })
-
-        // 2.3. Close emptyStream.
-        controller.close()
-
-        // 2.4. Return emptyStream.
-        return emptyStream
-      }
-
-      // 3. Let stream be this’s body’s stream.
-      /** @type {ReadableStream} */
-      const stream = this_.body.stream
-
-      // 4. Let decoder be a new TextDecoderStream object in this’s relevant realm.
-      // 5. Set up decoder with UTF-8.
-      const decoder = new TextDecoderStream('UTF-8')
-
-      // 6. Return the result of stream, piped through decoder.
-      return stream.pipeThrough(decoder)
+      }, instance)
     }
   }
 
   return methods
 }
 
-function mixinBody (prototype, getInternalState, brandCheck) {
-  Object.assign(prototype.prototype, bodyMixinMethods(brandCheck, getInternalState))
+function mixinBody (prototype) {
+  Object.assign(prototype.prototype, bodyMixinMethods(prototype))
 }
 
 /**
  * @see https://fetch.spec.whatwg.org/#concept-body-consume-body
- * @param {any} object internal state
+ * @param {Response|Request} object
  * @param {(value: unknown) => unknown} convertBytesToJSValue
- * @param {import('../../../types/webidl').WebidlIsFunction} brandCheck
- * @param {(target: any) => any} getInternalState
+ * @param {Response|Request} instance
  */
-function consumeBody (object, convertBytesToJSValue, brandCheck, getInternalState) {
-  try {
-    webidl.brandCheck(object, brandCheck)
-  } catch (e) {
-    return Promise.reject(e)
-  }
-
-  object = getInternalState(object)
+async function consumeBody (object, convertBytesToJSValue, instance) {
+  webidl.brandCheck(object, instance)
 
   // 1. If object is unusable, then return a promise rejected
   //    with a TypeError.
   if (bodyUnusable(object)) {
-    return Promise.reject(new TypeError('Body is unusable: Body has already been read'))
+    throw new TypeError('Body is unusable: Body has already been read')
   }
 
+  throwIfAborted(object[kState])
+
   // 2. Let promise be a new promise.
-  const promise = Promise.withResolvers()
+  const promise = createDeferredPromise()
 
   // 3. Let errorSteps given error be to reject promise with error.
-  const errorSteps = promise.reject
+  const errorSteps = (error) => promise.reject(error)
 
   // 4. Let successSteps given a byte sequence data be to resolve
   //    promise with the result of running convertBytesToJSValue
@@ -495,25 +464,22 @@ function consumeBody (object, convertBytesToJSValue, brandCheck, getInternalStat
 
   // 5. If object’s body is null, then run successSteps with an
   //    empty byte sequence.
-  if (object.body == null) {
+  if (object[kState].body == null) {
     successSteps(Buffer.allocUnsafe(0))
     return promise.promise
   }
 
   // 6. Otherwise, fully read object’s body given successSteps,
   //    errorSteps, and object’s relevant global object.
-  fullyReadBody(object.body, successSteps, errorSteps)
+  await fullyReadBody(object[kState].body, successSteps, errorSteps)
 
   // 7. Return promise.
   return promise.promise
 }
 
-/**
- * @see https://fetch.spec.whatwg.org/#body-unusable
- * @param {any} object internal state
- */
+// https://fetch.spec.whatwg.org/#body-unusable
 function bodyUnusable (object) {
-  const body = object.body
+  const body = object[kState].body
 
   // An object including the Body interface mixin is
   // said to be unusable if its body is non-null and
@@ -521,16 +487,24 @@ function bodyUnusable (object) {
   return body != null && (body.stream.locked || util.isDisturbed(body.stream))
 }
 
+/**
+ * @see https://infra.spec.whatwg.org/#parse-json-bytes-to-a-javascript-value
+ * @param {Uint8Array} bytes
+ */
+function parseJSONFromBytes (bytes) {
+  return JSON.parse(utf8DecodeBytes(bytes))
+}
+
 /**
  * @see https://fetch.spec.whatwg.org/#concept-body-mime-type
- * @param {any} requestOrResponse internal state
+ * @param {import('./response').Response|import('./request').Request} requestOrResponse
  */
 function bodyMimeType (requestOrResponse) {
   // 1. Let headers be null.
   // 2. If requestOrResponse is a Request object, then set headers to requestOrResponse’s request’s header list.
   // 3. Otherwise, set headers to requestOrResponse’s response’s header list.
   /** @type {import('./headers').HeadersList} */
-  const headers = requestOrResponse.headersList
+  const headers = requestOrResponse[kState].headersList
 
   // 4. Let mimeType be the result of extracting a MIME type from headers.
   const mimeType = extractMimeType(headers)
@@ -550,5 +524,6 @@ module.exports = {
   cloneBody,
   mixinBody,
   streamRegistry,
+  hasFinalizationRegistry,
   bodyUnusable
 }

package/node_modules/undici/lib/web/fetch/constants.js

@@ -22,9 +22,10 @@ const badPorts = /** @type {const} */ ([
 const badPortsSet = new Set(badPorts)
 
 /**
- * @see https://w3c.github.io/webappsec-referrer-policy/#referrer-policy-header
+ * @see https://w3c.github.io/webappsec-referrer-policy/#referrer-policies
  */
-const referrerPolicyTokens = /** @type {const} */ ([
+const referrerPolicy = /** @type {const} */ ([
+  '',
   'no-referrer',
   'no-referrer-when-downgrade',
   'same-origin',
@@ -34,19 +35,11 @@ const referrerPolicyTokens = /** @type {const} */ ([
   'strict-origin-when-cross-origin',
   'unsafe-url'
 ])
-
-/**
- * @see https://w3c.github.io/webappsec-referrer-policy/#referrer-policies
- */
-const referrerPolicy = /** @type {const} */ ([
-  '',
-  ...referrerPolicyTokens
-])
-const referrerPolicyTokensSet = new Set(referrerPolicyTokens)
+const referrerPolicySet = new Set(referrerPolicy)
 
 const requestRedirect = /** @type {const} */ (['follow', 'manual', 'error'])
 
-const safeMethods = /** @type {const} */ (['GET', 'HEAD', 'OPTIONS', 'TRACE', 'QUERY'])
+const safeMethods = /** @type {const} */ (['GET', 'HEAD', 'OPTIONS', 'TRACE'])
 const safeMethodsSet = new Set(safeMethods)
 
 const requestMode = /** @type {const} */ (['navigate', 'same-origin', 'no-cors', 'cors'])
@@ -127,5 +120,5 @@ module.exports = {
   corsSafeListedMethodsSet,
   safeMethodsSet,
   forbiddenMethodsSet,
-  referrerPolicyTokens: referrerPolicyTokensSet
+  referrerPolicySet
 }