path: root/op_crates/fetch/26_fetch.js

// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.

// @ts-check
/// <reference path="../../core/lib.deno_core.d.ts" />
/// <reference path="../web/internal.d.ts" />
/// <reference path="../url/internal.d.ts" />
/// <reference path="../web/lib.deno_web.d.ts" />
/// <reference path="./11_streams_types.d.ts" />
/// <reference path="./internal.d.ts" />
/// <reference path="./lib.deno_fetch.d.ts" />
/// <reference lib="esnext" />
"use strict";

((window) => {
  const core = window.Deno.core;

  // provided by "deno_web"
  const { URLSearchParams } = window.__bootstrap.url;
  const { getLocationHref } = window.__bootstrap.location;
  const { FormData, parseFormData, encodeFormData } =
    window.__bootstrap.formData;
  const { parseMimeType } = window.__bootstrap.mimesniff;

  const { ReadableStream, isReadableStreamDisturbed } =
    window.__bootstrap.streams;
  const { Headers } = window.__bootstrap.headers;
  const { Blob, _byteSequence, File } = window.__bootstrap.file;

  const MAX_SIZE = 2 ** 32 - 2;

  /**
   * @param {Uint8Array} src 
   * @param {Uint8Array} dst 
   * @param {number} off the offset into `dst` where it will at which to begin writing values from `src`
   * 
   * @returns {number} number of bytes copied
   */
  function copyBytes(src, dst, off = 0) {
    const r = dst.byteLength - off;
    if (src.byteLength > r) {
      src = src.subarray(0, r);
    }
    dst.set(src, off);
    return src.byteLength;
  }

  class Buffer {
    /** @type {Uint8Array} */
    #buf; // contents are the bytes buf[off : len(buf)]
    #off = 0; // read at buf[off], write at buf[buf.byteLength]

    /** @param {ArrayBuffer} [ab] */
    constructor(ab) {
      if (ab == null) {
        this.#buf = new Uint8Array(0);
        return;
      }

      this.#buf = new Uint8Array(ab);
    }

    /**
     * @returns {Uint8Array}
     */
    bytes(options = { copy: true }) {
      if (options.copy === false) return this.#buf.subarray(this.#off);
      return this.#buf.slice(this.#off);
    }

    /**
     * @returns {boolean}
     */
    empty() {
      return this.#buf.byteLength <= this.#off;
    }

    /**
     * @returns {number}
     */
    get length() {
      return this.#buf.byteLength - this.#off;
    }

    /**
     * @returns {number}
     */
    get capacity() {
      return this.#buf.buffer.byteLength;
    }

    /**
     * @returns {void}
     */
    reset() {
      this.#reslice(0);
      this.#off = 0;
    }

    /**
     * @param {number} n
     * @returns {number}
     */
    #tryGrowByReslice = (n) => {
      const l = this.#buf.byteLength;
      if (n <= this.capacity - l) {
        this.#reslice(l + n);
        return l;
      }
      return -1;
    };

    /**
     * @param {number} len
     * @returns {void}
     */
    #reslice = (len) => {
      if (!(len <= this.#buf.buffer.byteLength)) {
        throw new Error("assert");
      }
      this.#buf = new Uint8Array(this.#buf.buffer, 0, len);
    };

    /**
     * @param {Uint8Array} p
     * @returns {number}
     */
    writeSync(p) {
      const m = this.#grow(p.byteLength);
      return copyBytes(p, this.#buf, m);
    }

    /**
     * @param {Uint8Array} p
     * @returns {Promise<number>}
     */
    write(p) {
      const n = this.writeSync(p);
      return Promise.resolve(n);
    }

    /** 
     * @param {number} n
     * @returns {number}
     */
    #grow = (n) => {
      const m = this.length;
      // If buffer is empty, reset to recover space.
      if (m === 0 && this.#off !== 0) {
        this.reset();
      }
      // Fast: Try to grow by means of a reslice.
      const i = this.#tryGrowByReslice(n);
      if (i >= 0) {
        return i;
      }
      const c = this.capacity;
      if (n <= Math.floor(c / 2) - m) {
        // We can slide things down instead of allocating a new
        // ArrayBuffer. We only need m+n <= c to slide, but
        // we instead let capacity get twice as large so we
        // don't spend all our time copying.
        copyBytes(this.#buf.subarray(this.#off), this.#buf);
      } else if (c + n > MAX_SIZE) {
        throw new Error("The buffer cannot be grown beyond the maximum size.");
      } else {
        // Not enough space anywhere, we need to allocate.
        const buf = new Uint8Array(Math.min(2 * c + n, MAX_SIZE));
        copyBytes(this.#buf.subarray(this.#off), buf);
        this.#buf = buf;
      }
      // Restore this.#off and len(this.#buf).
      this.#off = 0;
      this.#reslice(Math.min(m + n, MAX_SIZE));
      return m;
    };

    /** 
     * @param {number} n
     * @returns {void}
     */
    grow(n) {
      if (n < 0) {
        throw Error("Buffer.grow: negative count");
      }
      const m = this.#grow(n);
      this.#reslice(m);
    }
  }

  /** 
   * @param {unknown} x
   * @returns {x is ArrayBufferView}
   */
  function isTypedArray(x) {
    return ArrayBuffer.isView(x) && !(x instanceof DataView);
  }

  /** 
   * @param {string} s
   * @param {string} value
   * @returns {boolean}
   */
  function hasHeaderValueOf(s, value) {
    return new RegExp(`^${value}(?:[\\s;]|$)`).test(s);
  }

  /**
   * @param {string} name 
   * @param {BodyInit | null} bodySource 
   */
  function validateBodyType(name, bodySource) {
    if (isTypedArray(bodySource)) {
      return true;
    } else if (bodySource instanceof ArrayBuffer) {
      return true;
    } else if (typeof bodySource === "string") {
      return true;
    } else if (bodySource instanceof ReadableStream) {
      return true;
    } else if (bodySource instanceof FormData) {
      return true;
    } else if (bodySource instanceof URLSearchParams) {
      return true;
    } else if (!bodySource) {
      return true; // null body is fine
    }
    throw new TypeError(
      `Bad ${name} body type: ${bodySource.constructor.name}`,
    );
  }

  /**
   * @param {ReadableStreamReader<Uint8Array>} stream 
   * @param {number} [size] 
   */
  async function bufferFromStream(
    stream,
    size,
  ) {
    const encoder = new TextEncoder();
    const buffer = new Buffer();

    if (size) {
      // grow to avoid unnecessary allocations & copies
      buffer.grow(size);
    }

    while (true) {
      const { done, value } = await stream.read();

      if (done) break;

      if (typeof value === "string") {
        buffer.writeSync(encoder.encode(value));
      } else if (value instanceof ArrayBuffer) {
        buffer.writeSync(new Uint8Array(value));
      } else if (value instanceof Uint8Array) {
        buffer.writeSync(value);
      } else if (!value) {
        // noop for undefined
      } else {
        throw new Error("unhandled type on stream read");
      }
    }

    return buffer.bytes().buffer;
  }

  /**
   * @param {Exclude<BodyInit, ReadableStream> | null} bodySource 
   */
  function bodyToArrayBuffer(bodySource) {
    if (isTypedArray(bodySource)) {
      return bodySource.buffer;
    } else if (bodySource instanceof ArrayBuffer) {
      return bodySource;
    } else if (typeof bodySource === "string") {
      const enc = new TextEncoder();
      return enc.encode(bodySource).buffer;
    } else if (
      bodySource instanceof FormData ||
      bodySource instanceof URLSearchParams
    ) {
      const enc = new TextEncoder();
      return enc.encode(bodySource.toString()).buffer;
    } else if (!bodySource) {
      return new ArrayBuffer(0);
    }
    throw new Error(
      `Body type not implemented: ${bodySource.constructor.name}`,
    );
  }

  const BodyUsedError =
    "Failed to execute 'clone' on 'Body': body is already used";

  const teeBody = Symbol("Body#tee");

  // fastBody and dontValidateUrl allow users to opt out of certain behaviors
  const fastBody = Symbol("Body#fast");
  const dontValidateUrl = Symbol("dontValidateUrl");
  const lazyHeaders = Symbol("lazyHeaders");

  class Body {
    #contentType = "";
    #size;
    /** @type {BodyInit | null} */
    #bodySource;
    /** @type {ReadableStream<Uint8Array> | null} */
    #stream = null;

    /**
     * @param {BodyInit| null} bodySource 
     * @param {{contentType: string, size?: number}} meta 
     */
    constructor(bodySource, meta) {
      validateBodyType(this.constructor.name, bodySource);
      this.#bodySource = bodySource;
      this.#contentType = meta.contentType;
      this.#size = meta.size;
    }

    get body() {
      if (!this.#stream) {
        if (!this.#bodySource) {
          return null;
        } else if (this.#bodySource instanceof ReadableStream) {
          this.#stream = this.#bodySource;
        } else {
          const buf = bodyToArrayBuffer(this.#bodySource);
          if (!(buf instanceof ArrayBuffer)) {
            throw new Error(
              `Expected ArrayBuffer from body`,
            );
          }

          this.#stream = new ReadableStream({
            /**
             * @param {ReadableStreamDefaultController<Uint8Array>} controller 
             */
            start(controller) {
              controller.enqueue(new Uint8Array(buf));
              controller.close();
            },
          });
        }
      }

      return this.#stream;
    }

    // Optimization that allows caller to bypass expensive ReadableStream.
    [fastBody]() {
      if (!this.#bodySource) {
        return null;
      } else if (!(this.#bodySource instanceof ReadableStream)) {
        return bodyToArrayBuffer(this.#bodySource);
      } else {
        return this.body;
      }
    }

    /** @returns {BodyInit | null} */
    [teeBody]() {
      if (this.#stream || this.#bodySource instanceof ReadableStream) {
        const body = this.body;
        if (body) {
          const [stream1, stream2] = body.tee();
          this.#stream = stream1;
          return stream2;
        } else {
          return null;
        }
      }

      return this.#bodySource;
    }

    get bodyUsed() {
      if (this.body && isReadableStreamDisturbed(this.body)) {
        return true;
      }
      return false;
    }

    set bodyUsed(_) {
      // this is a noop per spec
    }

    /** @returns {Promise<Blob>} */
    async blob() {
      return new Blob([await this.arrayBuffer()], {
        type: this.#contentType,
      });
    }

    // ref: https://fetch.spec.whatwg.org/#body-mixin
    /** @returns {Promise<FormData>} */
    async formData() {
      const formData = new FormData();
      const mimeType = parseMimeType(this.#contentType);
      if (mimeType) {
        if (mimeType.type === "multipart" && mimeType.subtype === "form-data") {
          // ref: https://tools.ietf.org/html/rfc2046#section-5.1
          const boundary = mimeType.parameters.get("boundary");
          const body = new Uint8Array(await this.arrayBuffer());
          return parseFormData(body, boundary);
        } else if (
          mimeType.type === "application" &&
          mimeType.subtype === "x-www-form-urlencoded"
        ) {
          // From https://github.com/github/fetch/blob/master/fetch.js
          // Copyright (c) 2014-2016 GitHub, Inc. MIT License
          const body = await this.text();
          try {
            body
              .trim()
              .split("&")
              .forEach((bytes) => {
                if (bytes) {
                  const split = bytes.split("=");
                  if (split.length >= 2) {
                    // @ts-expect-error this is safe because of the above check
                    const name = split.shift().replace(/\+/g, " ");
                    const value = split.join("=").replace(/\+/g, " ");
                    formData.append(
                      decodeURIComponent(name),
                      decodeURIComponent(value),
                    );
                  }
                }
              });
          } catch (e) {
            throw new TypeError("Invalid form urlencoded format");
          }
          return formData;
        }
      }

      throw new TypeError("Invalid form data");
    }

    /** @returns {Promise<string>} */
    async text() {
      if (typeof this.#bodySource === "string") {
        return this.#bodySource;
      }

      const ab = await this.arrayBuffer();
      const decoder = new TextDecoder("utf-8");
      return decoder.decode(ab);
    }

    /** @returns {Promise<any>} */
    async json() {
      const raw = await this.text();
      return JSON.parse(raw);
    }

    /** @returns {Promise<ArrayBuffer>} */
    arrayBuffer() {
      if (this.#bodySource instanceof ReadableStream) {
        const body = this.body;
        if (!body) throw new TypeError("Unreachable state (no body)");
        return bufferFromStream(body.getReader(), this.#size);
      }
      return Promise.resolve(bodyToArrayBuffer(this.#bodySource));
    }
  }

  /**
   * @param {Deno.CreateHttpClientOptions} options
   * @returns {HttpClient}
   */
  function createHttpClient(options) {
    return new HttpClient(core.opSync("op_create_http_client", options));
  }

  class HttpClient {
    /**
     * @param {number} rid 
     */
    constructor(rid) {
      this.rid = rid;
    }
    close() {
      core.close(this.rid);
    }
  }

  /**
   * @param {{ headers: [string,string][], method: string, url: string, baseUrl: string | null, clientRid: number | null, hasBody: boolean }} args 
   * @param {Uint8Array | null} body 
   * @returns {{requestRid: number, requestBodyRid: number | null}}
   */
  function opFetch(args, body) {
    let zeroCopy;
    if (body != null) {
      zeroCopy = new Uint8Array(body.buffer, body.byteOffset, body.byteLength);
    }
    return core.opSync("op_fetch", args, zeroCopy);
  }

  /**
   * @param {number} rid
   * @returns {Promise<{status: number, statusText: string, headers: Record<string,string[]>, url: string, responseRid: number}>}
   */
  function opFetchSend(rid) {
    return core.opAsync("op_fetch_send", rid);
  }

  /**
   * @param {number} rid 
   * @param {Uint8Array} body 
   * @returns {Promise<void>}
   */
  function opFetchRequestWrite(rid, body) {
    const zeroCopy = new Uint8Array(
      body.buffer,
      body.byteOffset,
      body.byteLength,
    );
    return core.opAsync("op_fetch_request_write", rid, zeroCopy);
  }

  const NULL_BODY_STATUS = [101, 204, 205, 304];
  const REDIRECT_STATUS = [301, 302, 303, 307, 308];

  /**
   * @param {string} s
   * @returns {string}
   */
  function byteUpperCase(s) {
    return String(s).replace(/[a-z]/g, function byteUpperCaseReplace(c) {
      return c.toUpperCase();
    });
  }

  /**
   * @param {string} m
   * @returns {boolean}
   */
  function isKnownMethod(m) {
    return (
      m === "DELETE" ||
      m === "GET" ||
      m === "HEAD" ||
      m === "OPTIONS" ||
      m === "POST" ||
      m === "PUT"
    );
  }

  /**
   * @param {string} m
   * @returns {string}
   */
  function normalizeMethod(m) {
    // Fast path for already valid methods
    if (isKnownMethod(m)) {
      return m;
    }
    // Normalize lower case (slowpath and should be avoided ...)
    const u = byteUpperCase(m);
    if (isKnownMethod(u)) {
      return u;
    }
    // Otherwise passthrough
    return m;
  }

  class Request extends Body {
    /** @type {string} */
    #method = "GET";
    /** @type {string} */
    #url = "";
    /** @type {Headers | string[][]} */
    #headers;
    /** @type {"include" | "omit" | "same-origin" | undefined} */
    #credentials = "omit";

    /**
     * @param {RequestInfo} input 
     * @param {RequestInit} init 
     */
    // @ts-expect-error because the use of super in this constructor is valid.
    constructor(input, init) {
      if (arguments.length < 1) {
        throw TypeError("Not enough arguments");
      }

      if (!init) {
        init = {};
      }

      let b;

      // prefer body from init
      if (init.body) {
        b = init.body;
      } else if (input instanceof Request) {
        if (input.bodyUsed) {
          throw TypeError(BodyUsedError);
        }
        b = input[teeBody]();
      } else if (typeof input === "object" && "body" in input && input.body) {
        if (input.bodyUsed) {
          throw TypeError(BodyUsedError);
        }
        b = input.body;
      } else {
        b = "";
      }

      let headers;
      let contentType = "";
      // prefer headers from init
      if (init.headers) {
        if (init[lazyHeaders] && Array.isArray(init.headers)) {
          // Trust the headers are valid, and only put them into the `Headers`
          // strucutre when the user accesses the property. We also assume that
          // all passed headers are lower-case (as is the case when they come
          // from hyper in Rust), and that headers are of type
          // `[string, string][]`.
          headers = init.headers;
          for (const tuple of headers) {
            if (tuple[0] === "content-type") {
              contentType = tuple[1];
            }
          }
        } else {
          headers = new Headers(init.headers);
          contentType = headers.get("content-type") || "";
        }
      } else if (input instanceof Request) {
        headers = input.headers;
        contentType = headers.get("content-type") || "";
      } else {
        headers = new Headers();
      }

      super(b, { contentType });
      this.#headers = headers;

      if (input instanceof Request) {
        if (input.bodyUsed) {
          throw TypeError(BodyUsedError);
        }
        // headers are already set above. no reason to do it again
        this.#method = input.method;
        this.#url = input.url;
        this.#credentials = input.credentials;
      } else {
        // Constructing a URL just for validation is known to be expensive.
        // dontValidateUrl allows one to opt out.
        if (init[dontValidateUrl]) {
          this.#url = input;
        } else {
          const baseUrl = getLocationHref();
          this.#url = baseUrl != null
            ? new URL(String(input), baseUrl).href
            : new URL(String(input)).href;
        }
      }

      if (init && "method" in init && init.method) {
        this.#method = normalizeMethod(init.method);
      }

      if (
        init &&
        "credentials" in init &&
        init.credentials &&
        ["omit", "same-origin", "include"].indexOf(init.credentials) !== -1
      ) {
        this.credentials = init.credentials;
      }
    }

    clone() {
      if (this.bodyUsed) {
        throw TypeError(BodyUsedError);
      }

      const iterators = this.headers.entries();
      const headersList = [];
      for (const header of iterators) {
        headersList.push(header);
      }

      const body = this[teeBody]();

      return new Request(this.url, {
        body,
        method: this.method,
        headers: new Headers(headersList),
        credentials: this.credentials,
      });
    }

    get method() {
      return this.#method;
    }

    set method(_) {
      // can not set method
    }

    get url() {
      return this.#url;
    }

    set url(_) {
      // can not set url
    }

    get headers() {
      if (!(this.#headers instanceof Headers)) {
        this.#headers = new Headers(this.#headers);
      }
      return this.#headers;
    }

    set headers(_) {
      // can not set headers
    }

    get credentials() {
      return this.#credentials;
    }

    set credentials(_) {
      // can not set credentials
    }
  }

  const responseData = new WeakMap();
  class Response extends Body {
    /** 
     * @param {BodyInit | null} body 
     * @param {ResponseInit} [init]
     */
    constructor(body = null, init) {
      init = init ?? {};

      if (typeof init !== "object") {
        throw new TypeError(`'init' is not an object`);
      }

      const extraInit = responseData.get(init) || {};
      let { type = "default", url = "" } = extraInit;

      let status = init.status === undefined ? 200 : Number(init.status || 0);
      let statusText = init.statusText ?? "";
      let headers = init.headers instanceof Headers
        ? init.headers
        : new Headers(init.headers);

      if (init.status !== undefined && (status < 200 || status > 599)) {
        throw new RangeError(
          `The status provided (${init.status}) is outside the range [200, 599]`,
        );
      }

      // null body status
      if (body && NULL_BODY_STATUS.includes(status)) {
        throw new TypeError("Response with null body status cannot have body");
      }

      if (!type) {
        type = "default";
      } else {
        if (type == "error") {
          // spec: https://fetch.spec.whatwg.org/#concept-network-error
          status = 0;
          statusText = "";
          headers = new Headers();
          body = null;
          /* spec for other Response types:
           https://fetch.spec.whatwg.org/#concept-filtered-response-basic
           Please note that type "basic" is not the same thing as "default".*/
        } else if (type == "basic") {
          for (const h of headers) {
            /* Forbidden Response-Header Names:
             https://fetch.spec.whatwg.org/#forbidden-response-header-name */
            if (["set-cookie", "set-cookie2"].includes(h[0].toLowerCase())) {
              headers.delete(h[0]);
            }
          }
        } else if (type == "cors") {
          /* CORS-safelisted Response-Header Names:
             https://fetch.spec.whatwg.org/#cors-safelisted-response-header-name */
          const allowedHeaders = [
            "Cache-Control",
            "Content-Language",
            "Content-Length",
            "Content-Type",
            "Expires",
            "Last-Modified",
            "Pragma",
          ].map((c) => c.toLowerCase());
          for (const h of headers) {
            /* Technically this is still not standards compliant because we are
             supposed to allow headers allowed in the
             'Access-Control-Expose-Headers' header in the 'internal response'
             However, this implementation of response doesn't seem to have an
             easy way to access the internal response, so we ignore that
             header.
             TODO(serverhiccups): change how internal responses are handled
             so we can do this properly. */
            if (!allowedHeaders.includes(h[0].toLowerCase())) {
              headers.delete(h[0]);
            }
          }
          /* TODO(serverhiccups): Once I fix the 'internal response' thing,
           these actually need to treat the internal response differently */
        } else if (type == "opaque" || type == "opaqueredirect") {
          url = "";
          status = 0;
          statusText = "";
          headers = new Headers();
          body = null;
        }
      }

      const contentType = headers.get("content-type") || "";
      const size = Number(headers.get("content-length")) || undefined;

      super(body, { contentType, size });

      this.url = url;
      this.statusText = statusText;
      this.status = extraInit.status || status;
      this.headers = headers;
      this.redirected = extraInit.redirected || false;
      this.type = type;
    }

    get ok() {
      return 200 <= this.status && this.status < 300;
    }

    clone() {
      if (this.bodyUsed) {
        throw TypeError(BodyUsedError);
      }

      const iterators = this.headers.entries();
      const headersList = [];
      for (const header of iterators) {
        headersList.push(header);
      }

      const body = this[teeBody]();

      return new Response(body, {
        status: this.status,
        statusText: this.statusText,
        headers: new Headers(headersList),
      });
    }

    /**
     * @param {string } url 
     * @param {number} status
     */
    static redirect(url, status = 302) {
      if (![301, 302, 303, 307, 308].includes(status)) {
        throw new RangeError(
          "The redirection status must be one of 301, 302, 303, 307 and 308.",
        );
      }
      return new Response(null, {
        status,
        statusText: "",
        headers: [["Location", String(url)]],
      });
    }
  }

  /** @type {string | null} */
  let baseUrl = null;

  /** @param {string} href */
  function setBaseUrl(href) {
    baseUrl = href;
  }

  /**
   * @param {string} url 
   * @param {string} method 
   * @param {Headers} headers 
   * @param {ReadableStream<Uint8Array> | ArrayBufferView | undefined} body 
   * @param {number | null} clientRid
   * @returns {Promise<{status: number, statusText: string, headers: Record<string,string[]>, url: string, responseRid: number}>}
   */
  async function sendFetchReq(url, method, headers, body, clientRid) {
    /** @type {[string, string][]} */
    let headerArray = [];
    if (headers) {
      headerArray = Array.from(headers.entries());
    }

    const { requestRid, requestBodyRid } = opFetch(
      {
        method,
        url,
        baseUrl,
        headers: headerArray,
        clientRid,
        hasBody: !!body,
      },
      body instanceof Uint8Array ? body : null,
    );
    if (requestBodyRid) {
      if (!(body instanceof ReadableStream)) {
        throw new TypeError("Unreachable state (body is not ReadableStream).");
      }
      const writer = new WritableStream({
        /**
         * @param {Uint8Array} chunk 
         * @param {WritableStreamDefaultController} controller 
         */
        async write(chunk, controller) {
          try {
            await opFetchRequestWrite(requestBodyRid, chunk);
          } catch (err) {
            controller.error(err);
          }
        },
        close() {
          core.close(requestBodyRid);
        },
      });
      body.pipeTo(writer);
    }

    return await opFetchSend(requestRid);
  }

  /**
   * @param {Request | URL | string} input 
   * @param {RequestInit & {client: Deno.HttpClient}} [init] 
   * @returns {Promise<Response>}
   */
  async function fetch(input, init) {
    /** @type {string | null} */
    let url;
    let method = null;
    let headers = null;
    let body;
    let clientRid = null;
    let redirected = false;
    let remRedirectCount = 20; // TODO(bartlomieju): use a better way to handle

    if (typeof input === "string" || input instanceof URL) {
      url = typeof input === "string" ? input : input.href;
      if (init != null) {
        method = init.method || null;
        if (init.headers) {
          headers = init.headers instanceof Headers
            ? init.headers
            : new Headers(init.headers);
        } else {
          headers = null;
        }

        // ref: https://fetch.spec.whatwg.org/#body-mixin
        // Body should have been a mixin
        // but we are treating it as a separate class
        if (init.body) {
          if (!headers) {
            headers = new Headers();
          }
          let contentType = "";
          if (typeof init.body === "string") {
            body = new TextEncoder().encode(init.body);
            contentType = "text/plain;charset=UTF-8";
          } else if (isTypedArray(init.body)) {
            body = init.body;
          } else if (init.body instanceof ArrayBuffer) {
            body = new Uint8Array(init.body);
          } else if (init.body instanceof URLSearchParams) {
            body = new TextEncoder().encode(init.body.toString());
            contentType = "application/x-www-form-urlencoded;charset=UTF-8";
          } else if (init.body instanceof Blob) {
            body = init.body[_byteSequence];
            contentType = init.body.type;
          } else if (init.body instanceof FormData) {
            const res = encodeFormData(init.body);
            body = res.body;
            contentType = res.contentType;
          } else if (init.body instanceof ReadableStream) {
            body = init.body;
          }
          if (contentType && !headers.has("content-type")) {
            headers.set("content-type", contentType);
          }
        }

        if (init.client instanceof HttpClient) {
          clientRid = init.client.rid;
        }
      }
    } else {
      url = input.url;
      method = input.method;
      headers = input.headers;

      if (input.body) {
        body = input.body;
      }
    }

    let responseBody;
    let responseInit = {};
    while (remRedirectCount) {
      const fetchResp = await sendFetchReq(
        url,
        method ?? "GET",
        headers ?? new Headers(),
        body,
        clientRid,
      );
      const rid = fetchResp.responseRid;

      if (
        NULL_BODY_STATUS.includes(fetchResp.status) ||
        REDIRECT_STATUS.includes(fetchResp.status)
      ) {
        // We won't use body of received response, so close it now
        // otherwise it will be kept in resource table.
        core.close(rid);
        responseBody = null;
      } else {
        responseBody = new ReadableStream({
          type: "bytes",
          /** @param {ReadableStreamDefaultController<Uint8Array>} controller */
          async pull(controller) {
            try {
              const chunk = new Uint8Array(16 * 1024 + 256);
              const read = await core.opAsync(
                "op_fetch_response_read",
                rid,
                chunk,
              );
              if (read != 0) {
                if (chunk.length == read) {
                  controller.enqueue(chunk);
                } else {
                  controller.enqueue(chunk.subarray(0, read));
                }
              } else {
                controller.close();
                core.close(rid);
              }
            } catch (e) {
              controller.error(e);
              controller.close();
              core.close(rid);
            }
          },
          cancel() {
            // When reader.cancel() is called
            core.close(rid);
          },
        });
      }

      responseInit = {
        status: 200,
        statusText: fetchResp.statusText,
        headers: fetchResp.headers,
      };

      responseData.set(responseInit, {
        redirected,
        rid: fetchResp.responseRid,
        status: fetchResp.status,
        url: fetchResp.url,
      });

      const response = new Response(responseBody, responseInit);

      if (REDIRECT_STATUS.includes(fetchResp.status)) {
        // We're in a redirect status
        switch ((init && init.redirect) || "follow") {
          case "error":
            responseInit = {};
            responseData.set(responseInit, {
              type: "error",
              redirected: false,
              url: "",
            });
            return new Response(null, responseInit);
          case "manual":
            // On the web this would return a `opaqueredirect` response, but
            // those don't make sense server side. See denoland/deno#8351.
            return response;
          case "follow":
          // fallthrough
          default: {
            /** @type {string | null} */
            let redirectUrl = response.headers.get("Location");
            if (redirectUrl == null) {
              return response; // Unspecified
            }
            if (
              !redirectUrl.startsWith("http://") &&
              !redirectUrl.startsWith("https://")
            ) {
              redirectUrl = new URL(redirectUrl, fetchResp.url).href;
            }
            url = redirectUrl;
            redirected = true;
            remRedirectCount--;
          }
        }
      } else {
        return response;
      }
    }

    responseData.set(responseInit, {
      type: "error",
      redirected: false,
      url: "",
    });

    return new Response(null, responseInit);
  }

  window.__bootstrap.fetch = {
    FormData,
    setBaseUrl,
    fetch,
    Request,
    Response,
    HttpClient,
    createHttpClient,
    fastBody,
    dontValidateUrl,
    lazyHeaders,
  };
})(this);