// https://github.com/Ethan-Arrowood/undici-fetch

'use strict'

const {

Response,

makeNetworkError,

makeAppropriateNetworkError,

filterResponse,

makeResponse

} = require('./response')

const { Headers } = require('./headers')

const { Request, makeRequest } = require('./request')

const zlib = require('zlib')

const {

bytesMatch,

makePolicyContainer,

clonePolicyContainer,

requestBadPort,

TAOCheck,

appendRequestOriginHeader,

responseLocationURL,

requestCurrentURL,

setRequestReferrerPolicyOnRedirect,

tryUpgradeRequestToAPotentiallyTrustworthyURL,

createOpaqueTimingInfo,

appendFetchMetadata,

corsCheck,

crossOriginResourcePolicyCheck,

determineRequestsReferrer,

coarsenedSharedCurrentTime,

createDeferredPromise,

isBlobLike,

sameOrigin,

isCancelled,

isAborted,

isErrorLike,

fullyReadBody

} = require('./util')

const { kState, kHeaders, kGuard, kRealm } = require('./symbols')

const assert = require('assert')

const { safelyExtractBody, extractBody } = require('./body')

const {

redirectStatus,

nullBodyStatus,

safeMethods,

requestBodyHeader,

subresource,

DOMException

} = require('./constants')

const { kHeadersList } = require('../core/symbols')

const EE = require('events')

const { Readable, pipeline } = require('stream')

const { isErrored, isReadable } = require('../core/util')

const { dataURLProcessor, serializeAMimeType } = require('./dataURL')

const { TransformStream } = require('stream/web')

const { getGlobalDispatcher } = require('../../index')

/** @type {import('buffer').resolveObjectURL} */

let resolveObjectURL

/** @type {globalThis['ReadableStream']} */

let ReadableStream

const nodeVersion = process.versions.node.split('.')

const nodeMajor = Number(nodeVersion[0])

const nodeMinor = Number(nodeVersion[1])

class Fetch extends EE {

constructor (dispatcher) {

super()

this.dispatcher = dispatcher

this.connection = null

this.dump = false

this.state = 'ongoing'

}

terminate (reason) {

if (this.state !== 'ongoing') {

return

}

this.state = 'terminated'

this.connection?.destroy(reason)

this.emit('terminated', reason)

}

// https://fetch.spec.whatwg.org/#fetch-controller-abort

abort (error) {

if (this.state !== 'ongoing') {

return

}

// 1. Set controller’s state to "aborted".

this.state = 'aborted'

// 2. Let fallbackError be an "AbortError" DOMException.

// 3. Set error to fallbackError if it is not given.

if (!error) {

error = new DOMException('The operation was aborted.', 'AbortError')

}

// 4. Let serializedError be StructuredSerialize(error).

// If that threw an exception, catch it, and let

// serializedError be StructuredSerialize(fallbackError).

// 5. Set controller’s serialized abort reason to serializedError.

this.serializedAbortReason = error

this.connection?.destroy(error)

this.emit('terminated', error)

}

}

// https://fetch.spec.whatwg.org/#fetch-method

async function fetch (input, init = {}) {

if (arguments.length < 1) {

throw new TypeError(

`Failed to execute 'fetch' on 'Window': 1 argument required, but only ${arguments.length} present.`

)

}

// 1. Let p be a new promise.

const p = createDeferredPromise()

// 2. Let requestObject be the result of invoking the initial value of

// Request as constructor with input and init as arguments. If this throws

// an exception, reject p with it and return p.

let requestObject

try {

requestObject = new Request(input, init)

} catch (e) {

p.reject(e)

return p.promise

}

// 3. Let request be requestObject’s request.

const request = requestObject[kState]

// 4. If requestObject’s signal’s aborted flag is set, then:

if (requestObject.signal.aborted) {

// 1. Abort the fetch() call with p, request, null, and

// requestObject’s signal’s abort reason.

abortFetch(p, request, null, requestObject.signal.reason)

// 2. Return p.

return p.promise

}

// 5. Let globalObject be request’s client’s global object.

const globalObject = request.client.globalObject

// 6. If globalObject is a ServiceWorkerGlobalScope object, then set

// request’s service-workers mode to "none".

if (globalObject?.constructor?.name === 'ServiceWorkerGlobalScope') {

request.serviceWorkers = 'none'

}

// 7. Let responseObject be null.

let responseObject = null

// 8. Let relevantRealm be this’s relevant Realm.

const relevantRealm = null

// 9. Let locallyAborted be false.

let locallyAborted = false

// 10. Let controller be null.

let controller = null

// 11. Add the following abort steps to requestObject’s signal:

requestObject.signal.addEventListener(

'abort',

() => {

// 1. Set locallyAborted to true.

locallyAborted = true

// 2. Abort the fetch() call with p, request, responseObject,

// and requestObject’s signal’s abort reason.

abortFetch(p, request, responseObject, requestObject.signal.reason)

// 3. If controller is not null, then abort controller.

if (controller != null) {

controller.abort()

}

},

{ once: true }

)

// 12. Let handleFetchDone given response response be to finalize and

// report timing with response, globalObject, and "fetch".

const handleFetchDone = (response) =>

finalizeAndReportTiming(response, 'fetch')

// 13. Set controller to the result of calling fetch given request,

// with processResponseEndOfBody set to handleFetchDone, and processResponse

// given response being these substeps:

const processResponse = (response) => {

// 1. If locallyAborted is true, terminate these substeps.

if (locallyAborted) {

return

}

// 2. If response’s aborted flag is set, then:

if (response.aborted) {

// 1. Let deserializedError be the result of deserialize a serialized

// abort reason given controller’s serialized abort reason and

// relevantRealm.

// 2. Abort the fetch() call with p, request, responseObject, and

// deserializedError.

abortFetch(p, request, responseObject, controller.serializedAbortReason)

return

}

// 3. If response is a network error, then reject p with a TypeError

// and terminate these substeps.

if (response.type === 'error') {

p.reject(

Object.assign(new TypeError('fetch failed'), { cause: response.error })

)

return

}

// 4. Set responseObject to the result of creating a Response object,

// given response, "immutable", and relevantRealm.

responseObject = new Response()

responseObject[kState] = response

responseObject[kRealm] = relevantRealm

responseObject[kHeaders][kHeadersList] = response.headersList

responseObject[kHeaders][kGuard] = 'immutable'

responseObject[kHeaders][kRealm] = relevantRealm

// 5. Resolve p with responseObject.

p.resolve(responseObject)

}

controller = fetching({

request,

processResponseEndOfBody: handleFetchDone,

processResponse,

dispatcher: init.dispatcher ?? getGlobalDispatcher() // undici

})

// 14. Return p.

return p.promise

}

// https://fetch.spec.whatwg.org/#finalize-and-report-timing

function finalizeAndReportTiming (response, initiatorType = 'other') {

// 1. If response is an aborted network error, then return.

if (response.type === 'error' && response.aborted) {

return

}

// 2. If response’s URL list is null or empty, then return.

if (!response.urlList?.length) {

return

}

// 3. Let originalURL be response’s URL list[0].

const originalURL = response.urlList[0]

// 4. Let timingInfo be response’s timing info.

let timingInfo = response.timingInfo

// 5. Let cacheState be response’s cache state.

let cacheState = response.cacheState

// 6. If originalURL’s scheme is not an HTTP(S) scheme, then return.

if (!/^https?:/.test(originalURL.protocol)) {

return

}

// 7. If timingInfo is null, then return.

if (timingInfo === null) {

return

}

// 8. If response’s timing allow passed flag is not set, then:

if (!timingInfo.timingAllowPassed) {

// 1. Set timingInfo to a the result of creating an opaque timing info for timingInfo.

timingInfo = createOpaqueTimingInfo({

startTime: timingInfo.startTime

})

// 2. Set cacheState to the empty string.

cacheState = ''

}

// 9. Set timingInfo’s end time to the coarsened shared current time

// given global’s relevant settings object’s cross-origin isolated

// capability.

// TODO: given global’s relevant settings object’s cross-origin isolated

// capability?

response.timingInfo.endTime = coarsenedSharedCurrentTime()

// 10. Set response’s timing info to timingInfo.

response.timingInfo = timingInfo

// 11. Mark resource timing for timingInfo, originalURL, initiatorType,

// global, and cacheState.

markResourceTiming(

timingInfo,

originalURL,

initiatorType,

globalThis,

cacheState

)

}

// https://w3c.github.io/resource-timing/#dfn-mark-resource-timing

function markResourceTiming (timingInfo, originalURL, initiatorType, globalThis, cacheState) {

if (nodeMajor >= 18 && nodeMinor >= 2) {

performance.markResourceTiming(timingInfo, originalURL, initiatorType, globalThis, cacheState)

}

}

// https://fetch.spec.whatwg.org/#abort-fetch

function abortFetch (p, request, responseObject, error) {

// Note: AbortSignal.reason was added in node v17.2.0

// which would give us an undefined error to reject with.

// Remove this once node v16 is no longer supported.

if (!error) {

error = new DOMException('The operation was aborted.', 'AbortError')

}

// 1. Reject promise with error.

p.reject(error)

// 2. If request’s body is not null and is readable, then cancel request’s

// body with error.

if (request.body != null && isReadable(request.body?.stream)) {

request.body.stream.cancel(error).catch((err) => {

if (err.code === 'ERR_INVALID_STATE') {

// Node bug?

return

}

throw err

})

}

// 3. If responseObject is null, then return.

if (responseObject == null) {

return

}

// 4. Let response be responseObject’s response.

const response = responseObject[kState]

// 5. If response’s body is not null and is readable, then error response’s

// body with error.

if (response.body != null && isReadable(response.body?.stream)) {

response.body.stream.cancel(error).catch((err) => {

if (err.code === 'ERR_INVALID_STATE') {

// Node bug?

return

}

throw err

})

}

}

// https://fetch.spec.whatwg.org/#fetching

function fetching ({

request,

processRequestBodyChunkLength,

processRequestEndOfBody,

processResponse,

processResponseEndOfBody,

processResponseConsumeBody,

useParallelQueue = false,

dispatcher // undici

}) {

// 1. Let taskDestination be null.

let taskDestination = null

// 2. Let crossOriginIsolatedCapability be false.

let crossOriginIsolatedCapability = false

// 3. If request’s client is non-null, then:

if (request.client != null) {

// 1. Set taskDestination to request’s client’s global object.

taskDestination = request.client.globalObject

// 2. Set crossOriginIsolatedCapability to request’s client’s cross-origin

// isolated capability.

crossOriginIsolatedCapability =

request.client.crossOriginIsolatedCapability

}

// 4. If useParallelQueue is true, then set taskDestination to the result of

// starting a new parallel queue.

// TODO

// 5. Let timingInfo be a new fetch timing info whose start time and

// post-redirect start time are the coarsened shared current time given

// crossOriginIsolatedCapability.

const currenTime = coarsenedSharedCurrentTime(crossOriginIsolatedCapability)

const timingInfo = createOpaqueTimingInfo({

startTime: currenTime

})

// 6. Let fetchParams be a new fetch params whose

// request is request,

// timing info is timingInfo,

// process request body chunk length is processRequestBodyChunkLength,

// process request end-of-body is processRequestEndOfBody,

// process response is processResponse,

// process response consume body is processResponseConsumeBody,

// process response end-of-body is processResponseEndOfBody,

// task destination is taskDestination,

// and cross-origin isolated capability is crossOriginIsolatedCapability.

const fetchParams = {

controller: new Fetch(dispatcher),

request,

timingInfo,

processRequestBodyChunkLength,

processRequestEndOfBody,

processResponse,

processResponseConsumeBody,

processResponseEndOfBody,

taskDestination,

crossOriginIsolatedCapability

}

// 7. If request’s body is a byte sequence, then set request’s body to the

// first return value of safely extracting request’s body.

// NOTE: Since fetching is only called from fetch, body should already be

// extracted.

assert(!request.body || request.body.stream)

// 8. If request’s window is "client", then set request’s window to request’s

// client, if request’s client’s global object is a Window object; otherwise

// "no-window".

if (request.window === 'client') {

// TODO: What if request.client is null?

request.window =

request.client?.globalObject?.constructor?.name === 'Window'

? request.client

: 'no-window'

}

// 9. If request’s origin is "client", then set request’s origin to request’s

// client’s origin.

if (request.origin === 'client') {

// TODO: What if request.client is null?

request.origin = request.client?.origin

}

// 10. If all of the following conditions are true:

// TODO

// 11. If request’s policy container is "client", then:

if (request.policyContainer === 'client') {

// 1. If request’s client is non-null, then set request’s policy

// container to a clone of request’s client’s policy container. [HTML]

if (request.client != null) {

request.policyContainer = clonePolicyContainer(

request.client.policyContainer

)

} else {

// 2. Otherwise, set request’s policy container to a new policy

// container.

request.policyContainer = makePolicyContainer()

}

}

// 12. If request’s header list does not contain `Accept`, then:

if (!request.headersList.has('accept')) {

// 1. Let value be `*/*`.

const value = '*/*'

// 2. A user agent should set value to the first matching statement, if

// any, switching on request’s destination:

// "document"

// "frame"

// "iframe"

// `text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8`

// "image"

// `image/png,image/svg+xml,image/*;q=0.8,*/*;q=0.5`

// "style"

// `text/css,*/*;q=0.1`

// TODO

// 3. Append `Accept`/value to request’s header list.

request.headersList.append('accept', value)

}

// 13. If request’s header list does not contain `Accept-Language`, then

// user agents should append `Accept-Language`/an appropriate value to

// request’s header list.

if (!request.headersList.has('accept-language')) {

request.headersList.append('accept-language', '*')

}

// 14. If request’s priority is null, then use request’s initiator and

// destination appropriately in setting request’s priority to a

// user-agent-defined object.

if (request.priority === null) {

// TODO

}

// 15. If request is a subresource request, then:

if (subresource.includes(request.destination)) {

// TODO

}

// 16. Run main fetch given fetchParams.

mainFetch(fetchParams)

.catch(err => {

fetchParams.controller.terminate(err)

})

// 17. Return fetchParam's controller

return fetchParams.controller

}

// https://fetch.spec.whatwg.org/#concept-main-fetch

async function mainFetch (fetchParams, recursive = false) {

// 1. Let request be fetchParams’s request.

const request = fetchParams.request

// 2. Let response be null.

let response = null

// 3. If request’s local-URLs-only flag is set and request’s current URL is

// not local, then set response to a network error.

if (

request.localURLsOnly &&

!/^(about|blob|data):/.test(requestCurrentURL(request).protocol)

) {

response = makeNetworkError('local URLs only')

}

// 4. Run report Content Security Policy violations for request.

// TODO

// 5. Upgrade request to a potentially trustworthy URL, if appropriate.

tryUpgradeRequestToAPotentiallyTrustworthyURL(request)

// 6. If should request be blocked due to a bad port, should fetching request

// be blocked as mixed content, or should request be blocked by Content

// Security Policy returns blocked, then set response to a network error.

if (requestBadPort(request) === 'blocked') {

response = makeNetworkError('bad port')

}

// TODO: should fetching request be blocked as mixed content?

// TODO: should request be blocked by Content Security Policy?

// 7. If request’s referrer policy is the empty string, then set request’s

// referrer policy to request’s policy container’s referrer policy.

if (request.referrerPolicy === '') {

request.referrerPolicy = request.policyContainer.referrerPolicy

}

// 8. If request’s referrer is not "no-referrer", then set request’s

// referrer to the result of invoking determine request’s referrer.

if (request.referrer !== 'no-referrer') {

request.referrer = determineRequestsReferrer(request)

}

// 9. Set request’s current URL’s scheme to "https" if all of the following

// conditions are true:

// - request’s current URL’s scheme is "http"

// - request’s current URL’s host is a domain

// - Matching request’s current URL’s host per Known HSTS Host Domain Name

// Matching results in either a superdomain match with an asserted

// includeSubDomains directive or a congruent match (with or without an

// asserted includeSubDomains directive). [HSTS]

// TODO

// 10. If recursive is false, then run the remaining steps in parallel.

// TODO

// 11. If response is null, then set response to the result of running

// the steps corresponding to the first matching statement:

if (response === null) {

response = await (async () => {

const currentURL = requestCurrentURL(request)

if (

// - request’s current URL’s origin is same origin with request’s origin,

// and request’s response tainting is "basic"

(sameOrigin(currentURL, request.url) && request.responseTainting === 'basic') ||

// request’s current URL’s scheme is "data"

(currentURL.protocol === 'data:') ||

// - request’s mode is "navigate" or "websocket"

(request.mode === 'navigate' || request.mode === 'websocket')

) {

// 1. Set request’s response tainting to "basic".

request.responseTainting = 'basic'

// 2. Return the result of running scheme fetch given fetchParams.

return await schemeFetch(fetchParams)

}

// request’s mode is "same-origin"

if (request.mode === 'same-origin') {

// 1. Return a network error.

return makeNetworkError('request mode cannot be "same-origin"')

}

// request’s mode is "no-cors"

if (request.mode === 'no-cors') {

// 1. If request’s redirect mode is not "follow", then return a network

// error.

if (request.redirect !== 'follow') {

return makeNetworkError(

'redirect mode cannot be "follow" for "no-cors" request'

)

}

// 2. Set request’s response tainting to "opaque".

request.responseTainting = 'opaque'

// 3. Return the result of running scheme fetch given fetchParams.

return await schemeFetch(fetchParams)

}

// request’s current URL’s scheme is not an HTTP(S) scheme

if (!/^https?:/.test(requestCurrentURL(request).protocol)) {

// Return a network error.

return makeNetworkError('URL scheme must be a HTTP(S) scheme')

}

// - request’s use-CORS-preflight flag is set

// - request’s unsafe-request flag is set and either request’s method is

// not a CORS-safelisted method or CORS-unsafe request-header names with

// request’s header list is not empty

// 1. Set request’s response tainting to "cors".

// 2. Let corsWithPreflightResponse be the result of running HTTP fetch

// given fetchParams and true.

// 3. If corsWithPreflightResponse is a network error, then clear cache

// entries using request.

// 4. Return corsWithPreflightResponse.

// TODO

// Otherwise

// 1. Set request’s response tainting to "cors".

request.responseTainting = 'cors'

// 2. Return the result of running HTTP fetch given fetchParams.

return await httpFetch(fetchParams)

})()

}

// 12. If recursive is true, then return response.

if (recursive) {

return response

}

// 13. If response is not a network error and response is not a filtered

// response, then:

if (response.status !== 0 && !response.internalResponse) {

// If request’s response tainting is "cors", then:

if (request.responseTainting === 'cors') {

// 1. Let headerNames be the result of extracting header list values

// given `Access-Control-Expose-Headers` and response’s header list.

// TODO

// 2. If request’s credentials mode is not "include" and headerNames

// contains `*`, then set response’s CORS-exposed header-name list to

// all unique header names in response’s header list.

// TODO

// 3. Otherwise, if headerNames is not null or failure, then set

// response’s CORS-exposed header-name list to headerNames.

// TODO

}

// Set response to the following filtered response with response as its

// internal response, depending on request’s response tainting:

if (request.responseTainting === 'basic') {

response = filterResponse(response, 'basic')

} else if (request.responseTainting === 'cors') {

response = filterResponse(response, 'cors')

} else if (request.responseTainting === 'opaque') {

response = filterResponse(response, 'opaque')

} else {

assert(false)

}

}

// 14. Let internalResponse be response, if response is a network error,

// and response’s internal response otherwise.

let internalResponse =

response.status === 0 ? response : response.internalResponse

// 15. If internalResponse’s URL list is empty, then set it to a clone of

// request’s URL list.

if (internalResponse.urlList.length === 0) {

internalResponse.urlList.push(...request.urlList)

}

// 16. If request’s timing allow failed flag is unset, then set

// internalResponse’s timing allow passed flag.

if (!request.timingAllowFailed) {

response.timingAllowPassed = true

}

// 17. If response is not a network error and any of the following returns

// blocked

// - should internalResponse to request be blocked as mixed content

// - should internalResponse to request be blocked by Content Security Policy

// - should internalResponse to request be blocked due to its MIME type

// - should internalResponse to request be blocked due to nosniff

// TODO

// 18. If response’s type is "opaque", internalResponse’s status is 206,

// internalResponse’s range-requested flag is set, and request’s header

// list does not contain `Range`, then set response and internalResponse

// to a network error.

if (

response.type === 'opaque' &&

internalResponse.status === 206 &&

internalResponse.rangeRequested &&

!request.headers.has('range')

) {

response = internalResponse = makeNetworkError()

}

// 19. If response is not a network error and either request’s method is

// `HEAD` or `CONNECT`, or internalResponse’s status is a null body status,

// set internalResponse’s body to null and disregard any enqueuing toward

// it (if any).

if (

response.status !== 0 &&

(request.method === 'HEAD' ||

request.method === 'CONNECT' ||

nullBodyStatus.includes(internalResponse.status))

) {

internalResponse.body = null

fetchParams.controller.dump = true

}

// 20. If request’s integrity metadata is not the empty string, then:

if (request.integrity) {

// 1. Let processBodyError be this step: run fetch finale given fetchParams

// and a network error.

const processBodyError = (reason) =>

fetchFinale(fetchParams, makeNetworkError(reason))

// 2. If request’s response tainting is "opaque", or response’s body is null,

// then run processBodyError and abort these steps.

if (request.responseTainting === 'opaque' || response.body == null) {

processBodyError(response.error)

return

}

// 3. Let processBody given bytes be these steps:

const processBody = (bytes) => {

// 1. If bytes do not match request’s integrity metadata,

// then run processBodyError and abort these steps. [SRI]

if (!bytesMatch(bytes, request.integrity)) {

processBodyError('integrity mismatch')

return

}

// 2. Set response’s body to the first return value of safely

// extracting bytes.

response.body = safelyExtractBody(bytes)[0]

// 3. Run fetch finale given fetchParams and response.

fetchFinale(fetchParams, response)

}

// 4. Fully read response’s body given processBody and processBodyError.

await fullyReadBody(response.body, processBody, processBodyError)

} else {

// 21. Otherwise, run fetch finale given fetchParams and response.

fetchFinale(fetchParams, response)

}

}

// https://fetch.spec.whatwg.org/#concept-scheme-fetch

// given a fetch params fetchParams

async function schemeFetch (fetchParams) {

// let request be fetchParams’s request

const { request } = fetchParams

const { protocol: scheme } = requestCurrentURL(request)

// switch on request’s current URL’s scheme, and run the associated steps:

switch (scheme) {

case 'about:': {

// If request’s current URL’s path is the string "blank", then return a new response

// whose status message is `OK`, header list is « (`Content-Type`, `text/html;charset=utf-8`) »,

// and body is the empty byte sequence.

// Otherwise, return a network error.

return makeNetworkError('about scheme is not supported')

}

case 'blob:': {

resolveObjectURL = resolveObjectURL || require('buffer').resolveObjectURL

// 1. Run these steps, but abort when the ongoing fetch is terminated:

// 1. Let blob be request’s current URL’s blob URL entry’s object.

// https://w3c.github.io/FileAPI/#blob-url-entry

// P.S. Thank God this method is available in node.

const currentURL = requestCurrentURL(request)

// https://github.com/web-platform-tests/wpt/blob/7b0ebaccc62b566a1965396e5be7bb2bc06f841f/FileAPI/url/resources/fetch-tests.js#L52-L56

// Buffer.resolveObjectURL does not ignore URL queries.

if (currentURL.search.length !== 0) {

return makeNetworkError('NetworkError when attempting to fetch resource.')

}

const blob = resolveObjectURL(currentURL.toString())

// 2. If request’s method is not `GET` or blob is not a Blob object, then return a network error. [FILEAPI]

if (request.method !== 'GET' || !isBlobLike(blob)) {

return makeNetworkError('invalid method')

}

// 3. Let response be a new response whose status message is `OK`.

const response = makeResponse({ statusText: 'OK', urlList: [currentURL] })

// 4. Append (`Content-Length`, blob’s size attribute value) to response’s header list.

response.headersList.set('content-length', `${blob.size}`)

// 5. Append (`Content-Type`, blob’s type attribute value) to response’s header list.

response.headersList.set('content-type', blob.type)

// 6. Set response’s body to the result of performing the read operation on blob.

// TODO (fix): This needs to read?

response.body = extractBody(blob)[0]

// 7. Return response.

return response

// 2. If aborted, then return the appropriate network error for fetchParams.

// TODO

}

case 'data:': {

// 1. Let dataURLStruct be the result of running the

// data: URL processor on request’s current URL.

const currentURL = requestCurrentURL(request)

const dataURLStruct = dataURLProcessor(currentURL)

// 2. If dataURLStruct is failure, then return a

// network error.

if (dataURLStruct === 'failure') {

return makeNetworkError('failed to fetch the data URL')

}

// 3. Let mimeType be dataURLStruct’s MIME type, serialized.

const mimeType = serializeAMimeType(dataURLStruct.mimeType)

// 4. Return a response whose status message is `OK`,

// header list is « (`Content-Type`, mimeType) »,

// and body is dataURLStruct’s body.

return makeResponse({

statusText: 'OK',

headersList: [

['content-type', mimeType]

],

body: extractBody(dataURLStruct.body)[0]

})

}

case 'file:': {

// For now, unfortunate as it is, file URLs are left as an exercise for the reader.

// When in doubt, return a network error.

return makeNetworkError('not implemented... yet...')

}

case 'http:':

case 'https:': {

// Return the result of running HTTP fetch given fetchParams.

return await httpFetch(fetchParams)

.catch((err) => makeNetworkError(err))

}

default: {

return makeNetworkError('unknown scheme')

}

}

}

// https://fetch.spec.whatwg.org/#finalize-response

function finalizeResponse (fetchParams, response) {

// 1. Set fetchParams’s request’s done flag.

fetchParams.request.done = true

// 2, If fetchParams’s process response done is not null, then queue a fetch

// task to run fetchParams’s process response done given response, with

// fetchParams’s task destination.

if (fetchParams.processResponseDone != null) {

queueMicrotask(() => fetchParams.processResponseDone(response))

}

}

// https://fetch.spec.whatwg.org/#fetch-finale

async function fetchFinale (fetchParams, response) {

// 1. If response is a network error, then:

if (response.type === 'error') {

// 1. Set response’s URL list to « fetchParams’s request’s URL list[0] ».

response.urlList = [fetchParams.request.urlList[0]]

// 2. Set response’s timing info to the result of creating an opaque timing

// info for fetchParams’s timing info.

response.timingInfo = createOpaqueTimingInfo({

startTime: fetchParams.timingInfo.startTime

})

}

// 2. Let processResponseEndOfBody be the following steps:

const processResponseEndOfBody = () => {

// 1. Set fetchParams’s request’s done flag.

fetchParams.request.done = true

// If fetchParams’s process response end-of-body is not null,

// then queue a fetch task to run fetchParams’s process response

// end-of-body given response with fetchParams’s task destination.

if (fetchParams.processResponseEndOfBody != null) {

queueMicrotask(() => fetchParams.processResponseEndOfBody(response))

}

}

// 3. If fetchParams’s process response is non-null, then queue a fetch task

// to run fetchParams’s process response given response, with fetchParams’s

// task destination.

if (fetchParams.processResponse != null) {

queueMicrotask(() => fetchParams.processResponse(response))

}

// 4. If response’s body is null, then run processResponseEndOfBody.

if (response.body == null) {

processResponseEndOfBody()

} else {

// 5. Otherwise:

// 1. Let transformStream be a new a TransformStream.

// 2. Let identityTransformAlgorithm be an algorithm which, given chunk,

// enqueues chunk in transformStream.

const identityTransformAlgorithm = (chunk, controller) => {

controller.enqueue(chunk)

}

// 3. Set up transformStream with transformAlgorithm set to identityTransformAlgorithm

// and flushAlgorithm set to processResponseEndOfBody.

const transformStream = new TransformStream({

start () {},

transform: identityTransformAlgorithm,

flush: processResponseEndOfBody

}, {

size () {

return 1

}

}, {

size () {

return 1

}

})

// 4. Set response’s body to the result of piping response’s body through transformStream.

response.body = { stream: response.body.stream.pipeThrough(transformStream) }

}

// 6. If fetchParams’s process response consume body is non-null, then:

if (fetchParams.processResponseConsumeBody != null) {

// 1. Let processBody given nullOrBytes be this step: run fetchParams’s

// process response consume body given response and nullOrBytes.

const processBody = (nullOrBytes) => fetchParams.processResponseConsumeBody(response, nullOrBytes)

// 2. Let processBodyError be this step: run fetchParams’s process

// response consume body given response and failure.

const processBodyError = (failure) => fetchParams.processResponseConsumeBody(response, failure)

// 3. If response’s body is null, then queue a fetch task to run processBody

// given null, with fetchParams’s task destination.

if (response.body == null) {

queueMicrotask(() => processBody(null))

} else {

// 4. Otherwise, fully read response’s body given processBody, processBodyError,

// and fetchParams’s task destination.

await fullyReadBody(response.body, processBody, processBodyError)

}

}

}

// https://fetch.spec.whatwg.org/#http-fetch

async function httpFetch (fetchParams) {

// 1. Let request be fetchParams’s request.

const request = fetchParams.request

// 2. Let response be null.

let response = null

// 3. Let actualResponse be null.

let actualResponse = null

// 4. Let timingInfo be fetchParams’s timing info.

const timingInfo = fetchParams.timingInfo

// 5. If request’s service-workers mode is "all", then:

if (request.serviceWorkers === 'all') {

// TODO

}