fetch-nodeshim 0.3.0 → 0.4.0-canary-2b29583b1a984d5ee8a9b457f7c00942dca24790

package/dist/minifetch.mjs

@@ -1,159 +1,177 @@
-import { Readable as e, PassThrough as t, Transform as r, pipeline as n, Stream as o } from "node:stream";
+import { Readable as e, PassThrough as t, Transform as o, pipeline as n, Stream as s } from "node:stream";
 
-import * as a from "node:https";
+import * as r from "node:https";
 
-import * as s from "node:http";
+import * as i from "node:http";
 
-import * as i from "node:url";
+import * as a from "node:url";
 
-import { isAnyArrayBuffer as f } from "node:util/types";
+import { isAnyArrayBuffer as c } from "node:util/types";
 
 import { randomBytes as l } from "node:crypto";
 
-import * as c from "node:buffer";
+import * as f from "node:buffer";
 
 import * as u from "node:zlib";
 
-var d = globalThis.File || c.File;
+import * as d from "node:net";
+
+const p = globalThis.File || f.File;
 
 if (void 0 === globalThis.File) {
-  globalThis.File = d;
+  globalThis.File = p;
 }
 
-var y = Blob;
+const y = Blob;
+
+const h = URLSearchParams;
+
+const m = URL;
+
+let g;
 
-var p = URLSearchParams;
+let b;
 
-var h = URL;
+let w;
 
-var v = Request;
+let T;
 
-var m = Response;
+if ("undefined" != typeof Request) {
+  g = Request;
+}
 
-var b = Headers;
+if ("undefined" != typeof Response) {
+  b = Response;
+}
 
-var g = FormData;
+if ("undefined" != typeof Headers) {
+  w = Headers;
+}
 
-var w = "\r\n";
+if ("undefined" != typeof FormData) {
+  T = FormData;
+}
 
-var L = "-".repeat(2);
+const L = "\r\n";
 
-var isReadable = t => e.isReadable(t);
+const _ = "-".repeat(2);
 
-var isReadableStream = e => "object" == typeof e && "function" == typeof e.getReader && "function" == typeof e.cancel && "function" == typeof e.tee;
+const isReadable = t => e.isReadable(t);
 
-var isBlob = e => {
+const isReadableStream = e => "object" == typeof e && "function" == typeof e.getReader && "function" == typeof e.cancel && "function" == typeof e.tee;
+
+const isBlob = e => {
   if ("object" == typeof e && "function" == typeof e.arrayBuffer && "string" == typeof e.type && "function" == typeof e.stream && "function" == typeof e.constructor) {
-    var t = e[Symbol.toStringTag];
+    const t = e[Symbol.toStringTag];
     return t.startsWith("Blob") || t.startsWith("File");
   } else {
     return !1;
   }
 };
 
-var getFormHeader = (e, t, r) => {
-  var n = `${L}${e}${w}`;
+const getFormHeader = (e, t, o) => {
+  let n = `${_}${e}${L}`;
   n += `Content-Disposition: form-data; name="${t}"`;
-  if (isBlob(r)) {
-    n += `; filename="${r.name ?? "blob"}"${w}`;
-    n += `Content-Type: ${r.type || "application/octet-stream"}`;
+  if (isBlob(o)) {
+    n += `; filename="${o.name ?? "blob"}"${L}`;
+    n += `Content-Type: ${o.type || "application/octet-stream"}`;
   }
-  return `${n}${w}${w}`;
+  return `${n}${L}${L}`;
 };
 
-var getFormFooter = e => `${L}${e}${L}${w}${w}`;
+const getFormFooter = e => `${_}${e}${_}${L}${L}`;
 
-var T = new TextEncoder;
+const v = new TextEncoder;
 
-var extractBody = t => {
-  var r = null;
-  var n;
-  var o = null;
+const extractBody = t => {
+  let o = null;
+  let n;
+  let s = null;
   if (null == t) {
     n = null;
-    o = 0;
+    s = 0;
   } else if ("string" == typeof t) {
-    var a = T.encode(`${t}`);
-    r = "text/plain;charset=UTF-8";
-    o = a.byteLength;
-    n = a;
+    const e = v.encode(`${t}`);
+    o = "text/plain;charset=UTF-8";
+    s = e.byteLength;
+    n = e;
   } else if ((e => "object" == typeof e && "function" == typeof e.append && "function" == typeof e.delete && "function" == typeof e.get && "function" == typeof e.getAll && "function" == typeof e.has && "function" == typeof e.set && "function" == typeof e.sort && "URLSearchParams" === e[Symbol.toStringTag])(t)) {
-    var s = T.encode(t.toString());
-    n = s;
-    o = s.byteLength;
-    r = "application/x-www-form-urlencoded;charset=UTF-8";
+    const e = v.encode(t.toString());
+    n = e;
+    s = e.byteLength;
+    o = "application/x-www-form-urlencoded;charset=UTF-8";
   } else if (isBlob(t)) {
-    o = t.size;
-    r = t.type || null;
+    s = t.size;
+    o = t.type || null;
     n = t.stream();
   } else if (t instanceof Uint8Array) {
     n = t;
-    o = t.byteLength;
-  } else if (f(t)) {
-    var i = new Uint8Array(t);
-    n = i;
-    o = i.byteLength;
+    s = t.byteLength;
+  } else if (c(t)) {
+    const e = new Uint8Array(t);
+    n = e;
+    s = e.byteLength;
   } else if (ArrayBuffer.isView(t)) {
-    var c = new Uint8Array(t.buffer, t.byteOffset, t.byteLength);
-    n = c;
-    o = c.byteLength;
+    const e = new Uint8Array(t.buffer, t.byteOffset, t.byteLength);
+    n = e;
+    s = e.byteLength;
   } else if (isReadableStream(t)) {
     n = t;
   } else if ((e => "object" == typeof e && "function" == typeof e.append && "function" == typeof e.set && "function" == typeof e.get && "function" == typeof e.getAll && "function" == typeof e.delete && "function" == typeof e.keys && "function" == typeof e.values && "function" == typeof e.entries && "function" == typeof e.constructor && "FormData" === e[Symbol.toStringTag])(t)) {
-    var u = `formdata-${l(8).toString("hex")}`;
-    r = `multipart/form-data; boundary=${u}`;
-    o = ((e, t) => {
-      var r = Buffer.byteLength(getFormFooter(t));
-      for (var [n, o] of e) {
-        r += Buffer.byteLength(getFormHeader(t, n, o)) + (isBlob(o) ? o.size : Buffer.byteLength(`${o}`)) + 2;
+    const r = `formdata-${l(8).toString("hex")}`;
+    o = `multipart/form-data; boundary=${r}`;
+    s = ((e, t) => {
+      let o = Buffer.byteLength(getFormFooter(t));
+      for (const [n, s] of e) {
+        o += Buffer.byteLength(getFormHeader(t, n, s)) + (isBlob(s) ? s.size : Buffer.byteLength(`${s}`)) + 2;
       }
-      return r;
-    })(t, u);
+      return o;
+    })(t, r);
     n = e.from(async function* generatorOfFormData(e, t) {
-      var r = new TextEncoder;
-      for (var [n, o] of e) {
-        if (isBlob(o)) {
-          yield r.encode(getFormHeader(t, n, o));
-          yield* o.stream();
-          yield r.encode(w);
+      const o = new TextEncoder;
+      for (const [n, s] of e) {
+        if (isBlob(s)) {
+          yield o.encode(getFormHeader(t, n, s));
+          yield* s.stream();
+          yield o.encode(L);
         } else {
-          yield r.encode(getFormHeader(t, n, o) + o + w);
+          yield o.encode(getFormHeader(t, n, s) + s + L);
         }
       }
-      yield r.encode(getFormFooter(t));
-    }(t, u));
+      yield o.encode(getFormFooter(t));
+    }(t, r));
   } else if ((t => "function" == typeof t.getBoundary && "function" == typeof t.hasKnownLength && "function" == typeof t.getLengthSync && e.isReadable(t))(t)) {
-    r = `multipart/form-data; boundary=${t.getBoundary()}`;
-    o = t.hasKnownLength() ? t.getLengthSync() : null;
+    o = `multipart/form-data; boundary=${t.getBoundary()}`;
+    s = t.hasKnownLength() ? t.getLengthSync() : null;
     n = t;
   } else if (isReadable(t)) {
     n = t;
   } else if ((e => "function" == typeof e[Symbol.asyncIterator] || "function" == typeof e[Symbol.iterator])(t)) {
     n = e.from(t);
   } else {
-    var d = T.encode(`${t}`);
-    r = "text/plain;charset=UTF-8";
-    n = d;
-    o = d.byteLength;
+    const e = v.encode(`${t}`);
+    o = "text/plain;charset=UTF-8";
+    n = e;
+    s = e.byteLength;
   }
   return {
-    contentLength: o,
-    contentType: r,
+    contentLength: s,
+    contentType: o,
     body: n
   };
 };
 
-var S = Symbol("kBodyInternals");
+const $ = Symbol("kBodyInternals");
 
 class Body {
   constructor(e) {
-    this[S] = extractBody(e);
+    this[$] = extractBody(e);
   }
   get body() {
-    return this[S].body;
+    return this[$].body;
   }
   get bodyUsed() {
-    var {body: t} = this[S];
+    const {body: t} = this[$];
     if (isReadable(t)) {
       return e.isDisturbed(t);
     } else if (isReadableStream(t)) {
@@ -163,30 +181,30 @@ class Body {
     }
   }
   async arrayBuffer() {
-    var {body: e} = this[S];
-    return f(e) ? e : new m(this.body).arrayBuffer();
+    const {body: e} = this[$];
+    return c(e) ? e : new b(this.body).arrayBuffer();
   }
   async formData() {
-    var {body: e, contentLength: t, contentType: r} = this[S];
-    var n = {};
+    const {body: e, contentLength: t, contentType: o} = this[$];
+    const n = {};
     if (t) {
       n["Content-Length"] = t;
     }
-    if (r) {
-      n["Content-Type"] = r;
+    if (o) {
+      n["Content-Type"] = o;
     }
-    return new m(e, {
+    return new b(e, {
       headers: n
     }).formData();
   }
   async blob() {
-    var {contentType: e} = this[S];
+    const {contentType: e} = this[$];
     return new y([ await this.arrayBuffer() ], {
       type: e ?? void 0
     });
   }
   async json() {
-    var e = await this.text();
+    const e = await this.text();
     return JSON.parse(e);
   }
   async text() {
@@ -194,15 +212,15 @@ class Body {
   }
 }
 
-class InflateStream extends r {
+class InflateStream extends o {
   constructor(e) {
     super();
     this._opts = e;
   }
-  _transform(e, t, r) {
+  _transform(e, t, o) {
     if (!this._inflate) {
       if (0 === e.length) {
-        r();
+        o();
         return;
       }
       this._inflate = 8 == (15 & e[0]) ? u.createInflate(this._opts) : u.createInflateRaw(this._opts);
@@ -210,7 +228,7 @@ class InflateStream extends r {
       this._inflate.on("end", (() => this.push(null)));
       this._inflate.on("error", (e => this.destroy(e)));
     }
-    this._inflate.write(e, t, r);
+    this._inflate.write(e, t, o);
   }
   _final(e) {
     if (this._inflate) {
@@ -221,15 +239,149 @@ class InflateStream extends r {
   }
 }
 
-var headersOfRawHeaders = e => {
-  var t = new Headers;
-  for (var r = 0; r < e.length; r += 2) {
-    t.set(e[r], e[r + 1]);
+const getHttpProxyUrl = () => process.env.HTTP_PROXY ?? process.env.http_proxy;
+
+const createProxyPattern = e => {
+  if (!(e = e.trim().replace(/\./g, "\\.").replace(/\*/g, "[w.]+")).startsWith(".")) {
+    e = `^${e}`;
+  }
+  if (!e.endsWith(".") || e.includes(":")) {
+    e += "$";
+  }
+  return new RegExp(e, "i");
+};
+
+const matchesNoProxy = e => {
+  const t = process.env.NO_PROXY ?? process.env.no_proxy;
+  if ("*" === t || "1" === t || "true" === t) {
+    return !0;
+  } else if (t) {
+    for (const o of t.split(",")) {
+      const t = createProxyPattern(o);
+      const n = e.hostname || e.host;
+      const s = n && `${n}:${e.port || e.defaultPort || 80}`;
+      if (n && t.test(n) || s && t.test(s)) {
+        return !0;
+      }
+    }
+    return !1;
+  } else {
+    return !1;
+  }
+};
+
+const R = {
+  keepAlive: !0,
+  keepAliveMsecs: 1e3
+};
+
+let x;
+
+let S;
+
+let P;
+
+let A;
+
+const createRequestOptions = (e, t, o) => {
+  const n = {
+    host: `${o.host}:${o.port}`,
+    connection: t ? "keep-alive" : "close"
+  };
+  if (e.username || e.password) {
+    const t = decodeURIComponent(e.username || "");
+    const o = decodeURIComponent(e.password || "");
+    const s = Buffer.from(`${t}:${o}`).toString("base64");
+    n["proxy-authorization"] = `Basic ${s}`;
+  }
+  return {
+    method: "CONNECT",
+    host: e.hostname,
+    port: e.port,
+    path: `${o.host}:${o.port}`,
+    setHost: !1,
+    agent: !1,
+    proxyEnv: {},
+    timeout: 8e3,
+    headers: n,
+    servername: "https:" === e.protocol ? e.hostname : void 0
+  };
+};
+
+class HttpProxyAgent extends i.Agent {
+  constructor(e, t) {
+    super(t);
+    this._proxy = e;
+    this._keepAlive = !!t.keepAlive;
+  }
+  createConnection(e, t) {
+    const o = ("http:" === this._proxy.protocol ? i : r).request(createRequestOptions(this._proxy, this._keepAlive, e));
+    o.once("connect", ((e, n, s) => {
+      o.removeAllListeners();
+      n.removeAllListeners();
+      if (200 === e.statusCode) {
+        t(null, n);
+      } else {
+        n.destroy();
+        t(new Error(`HTTP Proxy Network Error: ${e.statusMessage || e.statusCode}`), null);
+      }
+    }));
+    o.once("timeout", (() => {
+      o.destroy(new Error("HTTP Proxy timed out"));
+    }));
+    o.once("error", (e => {
+      o.removeAllListeners();
+      t(e, null);
+    }));
+    o.end();
+  }
+}
+
+class HttpsProxyAgent extends r.Agent {
+  constructor(e, t) {
+    super(t);
+    this._proxy = e;
+    this._keepAlive = !!t.keepAlive;
+  }
+  createConnection(e, t) {
+    const o = ("http:" === this._proxy.protocol ? i : r).request(createRequestOptions(this._proxy, this._keepAlive, e));
+    o.once("connect", ((n, s, r) => {
+      o.removeAllListeners();
+      s.removeAllListeners();
+      if (200 === n.statusCode) {
+        const o = {
+          ...e,
+          socket: s
+        };
+        d._normalizeArgs(o);
+        const n = super.createConnection(o);
+        t?.(null, n);
+      } else {
+        s.destroy();
+        t?.(new Error(`HTTP Proxy Network Error: ${n.statusMessage || n.statusCode}`), null);
+      }
+    }));
+    o.once("timeout", (() => {
+      o.destroy(new Error("HTTP Proxy timed out"));
+    }));
+    o.once("error", (e => {
+      o.removeAllListeners();
+      t?.(e, null);
+    }));
+    o.end();
+    return o.socket;
+  }
+}
+
+const headersOfRawHeaders = e => {
+  const t = new Headers;
+  for (let o = 0; o < e.length; o += 2) {
+    t.set(e[o], e[o + 1]);
   }
   return t;
 };
 
-var methodToHttpOption = e => {
+const methodToHttpOption = e => {
   switch (e) {
    case "CONNECT":
    case "TRACE":
@@ -241,24 +393,24 @@ var methodToHttpOption = e => {
   }
 };
 
-var urlToHttpOptions = e => {
-  var t = new h(e);
+const urlToHttpOptions = e => {
+  const t = new m(e);
   switch (t.protocol) {
    case "http:":
    case "https:":
-    return i.urlToHttpOptions(t);
+    return a.urlToHttpOptions(t);
 
    default:
     throw new TypeError(`URL scheme "${t.protocol}" is not supported.`);
   }
 };
 
-async function _fetch(r, i) {
-  var f = (e => null != e && "object" == typeof e && "body" in e)(r);
-  var l = f ? r.url : r;
-  var c = f ? r.body : i?.body || null;
-  var d = f ? r.signal : i?.signal || void 0;
-  var y = (e => {
+async function _fetch(o, a) {
+  const c = (e => null != e && "object" == typeof e && "body" in e)(o);
+  const l = c ? o.url : o;
+  const f = c ? o.body : a?.body || null;
+  const d = c ? o.signal : a?.signal || void 0;
+  const p = (e => {
     switch (e) {
      case "follow":
      case "manual":
@@ -271,72 +423,115 @@ async function _fetch(r, i) {
      default:
       throw new TypeError(`Request constructor: ${e} is not an accepted type. Expected one of follow, manual, error.`);
     }
-  })(f ? r.redirect : i?.redirect);
-  var p = new h(l);
-  var v = extractBody(c);
-  var b = 0;
-  var g = new Headers(i?.headers || (f ? r.headers : void 0));
-  var w = {
-    ...urlToHttpOptions(p),
-    method: methodToHttpOption(f ? r.method : i?.method),
+  })(c ? o.redirect : a?.redirect);
+  let y = new m(l);
+  let h = extractBody(f);
+  let g = 0;
+  const w = new Headers(a?.headers || (c ? o.headers : void 0));
+  const T = {
+    ...urlToHttpOptions(y),
+    method: methodToHttpOption(c ? o.method : a?.method),
     signal: d
   };
-  return await new Promise((function _call(r, i) {
-    var f = w.method;
-    var l = ("https:" === w.protocol ? a : s).request(w);
+  T.agent = "https:" === T.protocol ? (e => {
+    const t = process.env.HTTPS_PROXY ?? process.env.https_proxy ?? getHttpProxyUrl();
+    if (!t) {
+      A = void 0;
+      return;
+    } else if (matchesNoProxy(e)) {
+      return;
+    } else if (!P || P !== t) {
+      A = void 0;
+      try {
+        P = t;
+        A = new HttpsProxyAgent(new URL(t), R);
+      } catch (e) {
+        const o = new Error(`Invalid HTTPS_PROXY URL: "${t}".\n` + e?.message || e);
+        o.cause = e;
+        throw o;
+      }
+      return A;
+    } else {
+      return A;
+    }
+  })(T) : (e => {
+    const t = getHttpProxyUrl();
+    if (!t) {
+      S = void 0;
+      return;
+    } else if (matchesNoProxy(e)) {
+      return;
+    } else if (!x || x !== t) {
+      S = void 0;
+      try {
+        x = t;
+        S = new HttpProxyAgent(new URL(t), R);
+      } catch (e) {
+        const o = new Error(`Invalid HTTP_PROXY URL: "${t}".\n` + e?.message || e);
+        o.cause = e;
+        throw o;
+      }
+      return S;
+    } else {
+      return S;
+    }
+  })(T);
+  return await new Promise((function _call(o, a) {
+    const c = T.method;
+    const l = ("https:" === T.protocol ? r : i).request(T);
     l.on("response", (e => {
       e.setTimeout(0);
-      var o = {
+      const s = {
         status: e.statusCode,
         statusText: e.statusMessage,
         headers: headersOfRawHeaders(e.rawHeaders)
       };
-      if (301 === (l = o.status) || 302 === l || 303 === l || 307 === l || 308 === l) {
-        var a = o.headers.get("Location");
-        var s = null != a ? new h(a, p) : null;
-        if ("error" === y) {
-          i(new Error("URI requested responds with a redirect, redirect mode is set to error"));
+      if (301 === (r = s.status) || 302 === r || 303 === r || 307 === r || 308 === r) {
+        const e = s.headers.get("Location");
+        const t = null != e ? new m(e, y) : null;
+        if ("error" === p) {
+          a(new Error("URI requested responds with a redirect, redirect mode is set to error"));
           return;
-        } else if ("manual" === y && null !== s) {
-          o.headers.set("Location", s.toString());
-        } else if ("follow" === y && null !== s) {
-          if (++b > 20) {
-            i(new Error(`maximum redirect reached at: ${p}`));
+        } else if ("manual" === p && null !== t) {
+          s.headers.set("Location", t.toString());
+        } else if ("follow" === p && null !== t) {
+          if (++g > 20) {
+            a(new Error(`maximum redirect reached at: ${y}`));
             return;
-          } else if ("http:" !== s.protocol && "https:" !== s.protocol) {
-            i(new Error("URL scheme must be a HTTP(S) scheme"));
+          } else if ("http:" !== t.protocol && "https:" !== t.protocol) {
+            a(new Error("URL scheme must be a HTTP(S) scheme"));
             return;
           }
-          if (303 === o.status || (301 === o.status || 302 === o.status) && "POST" === f) {
-            v = extractBody(null);
-            w.method = "GET";
-            g.delete("Content-Length");
-          } else if (null != v.body && null == v.contentLength) {
-            i(new Error("Cannot follow redirect with a streamed body"));
+          if (303 === s.status || (301 === s.status || 302 === s.status) && "POST" === c) {
+            h = extractBody(null);
+            T.method = "GET";
+            w.delete("Content-Length");
+          } else if (null != h.body && null == h.contentLength) {
+            a(new Error("Cannot follow redirect with a streamed body"));
             return;
           } else {
-            v = extractBody(c);
+            h = extractBody(f);
           }
-          Object.assign(w, urlToHttpOptions(p = s));
-          return _call(r, i);
+          Object.assign(T, urlToHttpOptions(y = t));
+          return _call(o, a);
         }
       }
-      var l;
-      var destroy = t => {
+      var r;
+      const destroy = t => {
         d?.removeEventListener("abort", destroy);
         if (t) {
           e.destroy(d?.aborted ? d.reason : t);
-          i(d?.aborted ? d.reason : t);
+          a(d?.aborted ? d.reason : t);
         }
       };
       d?.addEventListener("abort", destroy);
-      var L = e;
-      var T = o.headers.get("Content-Encoding")?.toLowerCase();
-      if ("HEAD" === f || 204 === o.status || 304 === o.status) {
-        L = null;
-      } else if (null != T) {
-        o.headers.set("Content-Encoding", T);
-        L = n(L, (e => {
+      let i = e;
+      const l = s.headers.get("Content-Encoding")?.toLowerCase();
+      if ("HEAD" === c || 204 === s.status || 304 === s.status) {
+        i = null;
+      } else if (null != l) {
+        s.headers.set("Content-Encoding", l);
+        i = n(i, (e => {
           switch (e) {
            case "br":
             return u.createBrotliDecompress({
@@ -361,66 +556,66 @@ async function _fetch(r, i) {
            default:
             return new t;
           }
-        })(T), destroy);
+        })(l), destroy);
       }
-      r(function createResponse(e, t, r) {
-        var n = new m(e, t);
+      o(function createResponse(e, t, o) {
+        const n = new b(e, t);
         Object.defineProperty(n, "url", {
-          value: r.url
+          value: o.url
         });
-        if ("default" !== r.type) {
+        if ("default" !== o.type) {
           Object.defineProperty(n, "type", {
-            value: r.type
+            value: o.type
           });
         }
-        if (r.redirected) {
+        if (o.redirected) {
           Object.defineProperty(n, "redirected", {
-            value: r.redirected
+            value: o.redirected
           });
         }
         return n;
-      }(L, o, {
+      }(i, s, {
         type: "default",
-        url: p.toString(),
-        redirected: b > 0
+        url: y.toString(),
+        redirected: g > 0
       }));
     }));
-    l.on("error", i);
-    if (!g.has("Accept")) {
-      g.set("Accept", "*/*");
+    l.on("error", a);
+    if (!w.has("Accept")) {
+      w.set("Accept", "*/*");
     }
-    if (v.contentType) {
-      g.set("Content-Type", v.contentType);
+    if (h.contentType) {
+      w.set("Content-Type", h.contentType);
     }
-    if (null == v.body && ("POST" === f || "PUT" === f)) {
-      g.set("Content-Length", "0");
-    } else if (null != v.body && null != v.contentLength) {
-      g.set("Content-Length", `${v.contentLength}`);
+    if (null == h.body && ("POST" === c || "PUT" === c)) {
+      w.set("Content-Length", "0");
+    } else if (null != h.body && null != h.contentLength) {
+      w.set("Content-Length", `${h.contentLength}`);
     }
     ((e, t) => {
       if ("function" == typeof e.setHeaders) {
         e.setHeaders(t);
       } else {
-        for (var [r, n] of t) {
-          e.setHeader(r, n);
+        for (const [o, n] of t) {
+          e.setHeader(o, n);
         }
       }
-    })(l, g);
-    if (null == v.body) {
+    })(l, w);
+    if (null == h.body) {
       l.end();
-    } else if (v.body instanceof Uint8Array) {
-      l.write(v.body);
+    } else if (h.body instanceof Uint8Array) {
+      l.write(h.body);
       l.end();
     } else {
-      var L = v.body instanceof o ? v.body : e.fromWeb(v.body);
-      n(L, l, (e => {
+      const t = h.body instanceof s ? h.body : e.fromWeb(h.body);
+      n(t, l, (e => {
         if (e) {
-          i(e);
+          a(e);
         }
       }));
     }
   }));
 }
 
-export { y as Blob, Body, d as File, g as FormData, b as Headers, v as Request, m as Response, h as URL, p as URLSearchParams, _fetch as default, _fetch as fetch };
+export { y as Blob, Body, p as File, T as FormData, w as Headers, g as Request, b as Response, m as URL, h as URLSearchParams, _fetch as default, _fetch as fetch };
 //# sourceMappingURL=minifetch.mjs.map