@jsenv/fetch 1.1.32 → 1.1.34

package/README.md

@@ -3,19 +3,19 @@
 `fetchUrl` is an async function requesting an url and returning a response object. It is a small wrapper on top of [node-fetch](https://github.com/node-fetch/node-fetch). It was created to provide a unified approach to request file and data urls.
 
 ```js
-import { fetchUrl } from "@jsenv/fetch"
+import { fetchUrl } from "@jsenv/fetch";
 
 const responseForFile = await fetchUrl("file:///Users/you/index.html", {
   method: "GET",
   headers: {
     "if-modified-since": "Wed, 21 Oct 2015 07:28:00 GMT",
   },
-})
+});
 
 const responseForHttp = await fetchUrl("http://example.com/file.js", {
   method: "GET",
   headers: {
     "if-modified-since": "Wed, 21 Oct 2015 07:28:00 GMT",
   },
-})
+});
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/fetch",
-  "version": "1.1.32",
+  "version": "1.1.34",
   "description": "Unified url fetcher (http, http, file, data)",
   "license": "MIT",
   "author": {
@@ -10,8 +10,8 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/jsenv/jsenv-core",
-    "directory": "packages/fetch"
+    "url": "https://github.com/jsenv/core",
+    "directory": "packages/independent/fetch"
   },
   "engines": {
     "node": ">=16.13.0"
@@ -37,7 +37,7 @@
   },
   "dependencies": {
     "@jsenv/urls": "2.0.0",
-    "@jsenv/server": "15.0.2",
+    "@jsenv/server": "15.0.4",
     "node-fetch": "2.6.7"
   }
 }

package/src/browser/fetch_and_eval.js

@@ -1,14 +1,14 @@
-import { fetchUrl } from "./fetch_url_browser.js"
+import { fetchUrl } from "./fetch_url_browser.js";
 
 export const fetchAndEval = async (url) => {
-  const response = await fetchUrl(url)
+  const response = await fetchUrl(url);
 
   if (response.status >= 200 && response.status <= 299) {
-    const text = await response.text()
+    const text = await response.text();
     // eslint-disable-next-line no-eval
-    window.eval(appendSourceURL(text, url))
+    window.eval(appendSourceURL(text, url));
   } else {
-    const text = await response.text()
+    const text = await response.text();
     throw new Error(
       `Unexpected response for script.
 --- script url ---
@@ -17,11 +17,11 @@ ${url}
 ${text}
 --- response status ---
 ${response.status}`,
-    )
+    );
   }
-}
+};
 
 const appendSourceURL = (code, sourceURL) => {
   return `${code}
-${"//#"} sourceURL=${sourceURL}`
-}
+${"//#"} sourceURL=${sourceURL}`;
+};

package/src/browser/fetch_and_eval_using_script.js

@@ -1,47 +1,47 @@
 export const fetchAndEvalUsingScript = async (src) => {
   return new Promise((resolve, reject) => {
-    const script = document.createElement("script")
+    const script = document.createElement("script");
 
     const onwindowerror = (errorEvent) => {
       if (errorEvent.filename === src) {
-        cleanup()
-        reject(errorEvent.error)
+        cleanup();
+        reject(errorEvent.error);
       }
-    }
+    };
 
     const onscripterror = () => {
-      cleanup()
-      reject(new Error(`Error loading ${src}`))
-    }
+      cleanup();
+      reject(new Error(`Error loading ${src}`));
+    };
 
     const onscriptload = () => {
-      cleanup()
-      resolve()
-    }
+      cleanup();
+      resolve();
+    };
 
     const cleanup = () => {
-      removeOnWindowError()
-      removeOnScriptError()
-      removeOnScriptLoad()
-      document.head.removeChild(script)
-    }
+      removeOnWindowError();
+      removeOnScriptError();
+      removeOnScriptLoad();
+      document.head.removeChild(script);
+    };
 
     const removeOnWindowError = () =>
-      window.removeEventListener("error", onwindowerror)
+      window.removeEventListener("error", onwindowerror);
 
     const removeOnScriptError = () =>
-      script.removeEventListener("error", onscripterror)
+      script.removeEventListener("error", onscripterror);
 
     const removeOnScriptLoad = () =>
-      script.removeEventListener("load", onscriptload)
-
-    window.addEventListener("error", onwindowerror)
-    script.addEventListener("error", onscripterror)
-    script.addEventListener("load", onscriptload)
-    script.charset = "utf-8"
-    script.crossOrigin = "anonymous"
-    script.src = src
-
-    document.head.appendChild(script)
-  })
-}
+      script.removeEventListener("load", onscriptload);
+
+    window.addEventListener("error", onwindowerror);
+    script.addEventListener("error", onscripterror);
+    script.addEventListener("load", onscriptload);
+    script.charset = "utf-8";
+    script.crossOrigin = "anonymous";
+    script.src = src;
+
+    document.head.appendChild(script);
+  });
+};

package/src/browser/fetch_json.js

@@ -1,7 +1,7 @@
-import { fetchUrl } from "./fetch_url_browser.js"
+import { fetchUrl } from "./fetch_url_browser.js";
 
 export const fetchJson = async (url, options = {}) => {
-  const response = await fetchUrl(url, options)
-  const object = await response.json()
-  return object
-}
+  const response = await fetchUrl(url, options);
+  const object = await response.json();
+  return object;
+};

package/src/browser/fetch_url_browser.js

@@ -1,8 +1,8 @@
-import { fetchUsingXHR } from "./fetch_using_xhr.js"
-import { fetchUsingFetch } from "./fetch_using_fetch.js"
+import { fetchUsingXHR } from "./fetch_using_xhr.js";
+import { fetchUsingFetch } from "./fetch_using_fetch.js";
 
 export const fetchUrl =
   typeof window.fetch === "function" &&
   typeof window.AbortController === "function"
     ? fetchUsingFetch
-    : fetchUsingXHR
+    : fetchUsingXHR;

package/src/browser/fetch_using_fetch.js

@@ -5,7 +5,7 @@ export const fetchUsingFetch = async (
   const response = await window.fetch(url, {
     mode,
     ...options,
-  })
+  });
   return {
     url: response.url,
     status: response.status,
@@ -16,13 +16,13 @@ export const fetchUsingFetch = async (
     blob: () => response.blob(),
     arrayBuffer: () => response.arrayBuffer(),
     formData: () => response.formData(),
-  }
-}
+  };
+};
 
 const responseToHeaders = (response) => {
-  const headers = {}
+  const headers = {};
   response.headers.forEach((value, name) => {
-    headers[name] = value
-  })
-  return headers
-}
+    headers[name] = value;
+  });
+  return headers;
+};

package/src/browser/fetch_using_xhr.js

@@ -8,164 +8,164 @@ export const fetchUsingXHR = async (
     body = null,
   } = {},
 ) => {
-  const headersPromise = createPromiseAndHooks()
-  const bodyPromise = createPromiseAndHooks()
+  const headersPromise = createPromiseAndHooks();
+  const bodyPromise = createPromiseAndHooks();
 
-  const xhr = new XMLHttpRequest()
+  const xhr = new XMLHttpRequest();
 
   const failure = (error) => {
     // if it was already resolved, we must reject the body promise
     if (headersPromise.settled) {
-      bodyPromise.reject(error)
+      bodyPromise.reject(error);
     } else {
-      headersPromise.reject(error)
+      headersPromise.reject(error);
     }
-  }
+  };
 
   const cleanup = () => {
-    xhr.ontimeout = null
-    xhr.onerror = null
-    xhr.onload = null
-    xhr.onreadystatechange = null
-  }
+    xhr.ontimeout = null;
+    xhr.onerror = null;
+    xhr.onload = null;
+    xhr.onreadystatechange = null;
+  };
 
   xhr.ontimeout = () => {
-    cleanup()
-    failure(new Error(`xhr request timeout on ${url}.`))
-  }
+    cleanup();
+    failure(new Error(`xhr request timeout on ${url}.`));
+  };
 
   xhr.onerror = (error) => {
-    cleanup()
+    cleanup();
     // unfortunately with have no clue why it fails
     // might be cors for instance
-    failure(createRequestError(error, { url }))
-  }
+    failure(createRequestError(error, { url }));
+  };
 
   xhr.onload = () => {
-    cleanup()
-    bodyPromise.resolve()
-  }
+    cleanup();
+    bodyPromise.resolve();
+  };
 
   signal.addEventListener("abort", () => {
-    xhr.abort()
-    const abortError = new Error("aborted")
-    abortError.name = "AbortError"
-    failure(abortError)
-  })
+    xhr.abort();
+    const abortError = new Error("aborted");
+    abortError.name = "AbortError";
+    failure(abortError);
+  });
 
   xhr.onreadystatechange = () => {
     // https://developer.mozilla.org/fr/docs/Web/API/XMLHttpRequest/readyState
-    const { readyState } = xhr
+    const { readyState } = xhr;
 
     if (readyState === 2) {
-      headersPromise.resolve()
+      headersPromise.resolve();
     } else if (readyState === 4) {
-      cleanup()
-      bodyPromise.resolve()
+      cleanup();
+      bodyPromise.resolve();
     }
-  }
+  };
 
-  xhr.open(method, url, true)
+  xhr.open(method, url, true);
   Object.keys(headers).forEach((key) => {
-    xhr.setRequestHeader(key, headers[key])
-  })
-  xhr.withCredentials = computeWithCredentials({ credentials, url })
+    xhr.setRequestHeader(key, headers[key]);
+  });
+  xhr.withCredentials = computeWithCredentials({ credentials, url });
   if ("responseType" in xhr && hasBlob) {
-    xhr.responseType = "blob"
+    xhr.responseType = "blob";
   }
-  xhr.send(body)
+  xhr.send(body);
 
-  await headersPromise
+  await headersPromise;
 
   // https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/responseURL
   const responseUrl =
-    "responseURL" in xhr ? xhr.responseURL : headers["x-request-url"]
-  let responseStatus = xhr.status
-  const responseStatusText = xhr.statusText
-  const responseHeaders = getHeadersFromXHR(xhr)
+    "responseURL" in xhr ? xhr.responseURL : headers["x-request-url"];
+  let responseStatus = xhr.status;
+  const responseStatusText = xhr.statusText;
+  const responseHeaders = getHeadersFromXHR(xhr);
 
   const readBody = async () => {
-    await bodyPromise
+    await bodyPromise;
 
-    const { status } = xhr
+    const { status } = xhr;
     // in Chrome on file:/// URLs, status is 0
     if (status === 0) {
-      responseStatus = 200
+      responseStatus = 200;
     }
 
-    const body = "response" in xhr ? xhr.response : xhr.responseText
+    const body = "response" in xhr ? xhr.response : xhr.responseText;
 
     return {
       responseBody: body,
       responseBodyType: detectBodyType(body),
-    }
-  }
+    };
+  };
 
   const text = async () => {
-    const { responseBody, responseBodyType } = await readBody()
+    const { responseBody, responseBodyType } = await readBody();
 
     if (responseBodyType === "blob") {
-      return blobToText(responseBody)
+      return blobToText(responseBody);
     }
     if (responseBodyType === "formData") {
-      throw new Error("could not read FormData body as text")
+      throw new Error("could not read FormData body as text");
     }
     if (responseBodyType === "dataView") {
-      return arrayBufferToText(responseBody.buffer)
+      return arrayBufferToText(responseBody.buffer);
     }
     if (responseBodyType === "arrayBuffer") {
-      return arrayBufferToText(responseBody)
+      return arrayBufferToText(responseBody);
     }
     // if (responseBodyType === "text" || responseBodyType === 'searchParams') {
     //   return body
     // }
-    return String(responseBody)
-  }
+    return String(responseBody);
+  };
 
   const json = async () => {
-    const responseText = await text()
-    return JSON.parse(responseText)
-  }
+    const responseText = await text();
+    return JSON.parse(responseText);
+  };
 
   const blob = async () => {
     if (!hasBlob) {
-      throw new Error(`blob not supported`)
+      throw new Error(`blob not supported`);
     }
 
-    const { responseBody, responseBodyType } = await readBody()
+    const { responseBody, responseBodyType } = await readBody();
 
     if (responseBodyType === "blob") {
-      return responseBody
+      return responseBody;
     }
     if (responseBodyType === "dataView") {
-      return new Blob([cloneBuffer(responseBody.buffer)])
+      return new Blob([cloneBuffer(responseBody.buffer)]);
     }
     if (responseBodyType === "arrayBuffer") {
-      return new Blob([cloneBuffer(responseBody)])
+      return new Blob([cloneBuffer(responseBody)]);
     }
     if (responseBodyType === "formData") {
-      throw new Error("could not read FormData body as blob")
+      throw new Error("could not read FormData body as blob");
     }
-    return new Blob([String(responseBody)])
-  }
+    return new Blob([String(responseBody)]);
+  };
 
   const arrayBuffer = async () => {
-    const { responseBody, responseBodyType } = await readBody()
+    const { responseBody, responseBodyType } = await readBody();
 
     if (responseBodyType === "arrayBuffer") {
-      return cloneBuffer(responseBody)
+      return cloneBuffer(responseBody);
     }
-    const responseBlob = await blob()
-    return blobToArrayBuffer(responseBlob)
-  }
+    const responseBlob = await blob();
+    return blobToArrayBuffer(responseBlob);
+  };
 
   const formData = async () => {
     if (!hasFormData) {
-      throw new Error(`formData not supported`)
+      throw new Error(`formData not supported`);
     }
-    const responseText = await text()
-    return textToFormData(responseText)
-  }
+    const responseText = await text();
+    return textToFormData(responseText);
+  };
 
   return {
     url: responseUrl,
@@ -177,146 +177,146 @@ export const fetchUsingXHR = async (
     blob,
     arrayBuffer,
     formData,
-  }
-}
+  };
+};
 
 const canUseBlob = () => {
-  if (typeof window.FileReader !== "function") return false
+  if (typeof window.FileReader !== "function") return false;
 
-  if (typeof window.Blob !== "function") return false
+  if (typeof window.Blob !== "function") return false;
 
   try {
     // eslint-disable-next-line no-new
-    new Blob()
-    return true
+    new Blob();
+    return true;
   } catch (e) {
-    return false
+    return false;
   }
-}
+};
 
-const hasBlob = canUseBlob()
+const hasBlob = canUseBlob();
 
-const hasFormData = typeof window.FormData === "function"
+const hasFormData = typeof window.FormData === "function";
 
-const hasArrayBuffer = typeof window.ArrayBuffer === "function"
+const hasArrayBuffer = typeof window.ArrayBuffer === "function";
 
-const hasSearchParams = typeof window.URLSearchParams === "function"
+const hasSearchParams = typeof window.URLSearchParams === "function";
 
 const createRequestError = (error, { url }) => {
   return new Error(
     `error during xhr request on ${url}.
 --- error stack ---
 ${error.stack}`,
-  )
-}
+  );
+};
 
 const createPromiseAndHooks = () => {
-  let resolve
-  let reject
+  let resolve;
+  let reject;
   const promise = new Promise((res, rej) => {
     resolve = (value) => {
-      promise.settled = true
-      res(value)
-    }
+      promise.settled = true;
+      res(value);
+    };
     reject = (value) => {
-      promise.settled = true
-      rej(value)
-    }
-  })
-  promise.resolve = resolve
-  promise.reject = reject
-  return promise
-}
+      promise.settled = true;
+      rej(value);
+    };
+  });
+  promise.resolve = resolve;
+  promise.reject = reject;
+  return promise;
+};
 
 // https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch
 const computeWithCredentials = ({ credentials, url }) => {
   if (credentials === "same-origin") {
-    return originSameAsGlobalOrigin(url)
+    return originSameAsGlobalOrigin(url);
   }
-  return credentials === "include"
-}
+  return credentials === "include";
+};
 
 const originSameAsGlobalOrigin = (url) => {
   // if we cannot read globalOrigin from window.location.origin, let's consider it's ok
-  if (typeof window !== "object") return true
-  if (typeof window.location !== "object") return true
-  const globalOrigin = window.location.origin
-  if (globalOrigin === "null") return true
-  return hrefToOrigin(url) === globalOrigin
-}
+  if (typeof window !== "object") return true;
+  if (typeof window.location !== "object") return true;
+  const globalOrigin = window.location.origin;
+  if (globalOrigin === "null") return true;
+  return hrefToOrigin(url) === globalOrigin;
+};
 
 const detectBodyType = (body) => {
   if (!body) {
-    return ""
+    return "";
   }
   if (typeof body === "string") {
-    return "text"
+    return "text";
   }
   if (hasBlob && Blob.prototype.isPrototypeOf(body)) {
-    return "blob"
+    return "blob";
   }
   if (hasFormData && FormData.prototype.isPrototypeOf(body)) {
-    return "formData"
+    return "formData";
   }
   if (hasArrayBuffer) {
     if (hasBlob && isDataView(body)) {
-      return `dataView`
+      return `dataView`;
     }
     if (ArrayBuffer.prototype.isPrototypeOf(body) || isArrayBufferView(body)) {
-      return `arrayBuffer`
+      return `arrayBuffer`;
     }
   }
   if (hasSearchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
-    return "searchParams"
+    return "searchParams";
   }
-  return ""
-}
+  return "";
+};
 
 // https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/getAllResponseHeaders#Example
 const getHeadersFromXHR = (xhr) => {
-  const headerMap = {}
+  const headerMap = {};
 
-  const headersString = xhr.getAllResponseHeaders()
-  if (headersString === "") return headerMap
+  const headersString = xhr.getAllResponseHeaders();
+  if (headersString === "") return headerMap;
 
-  const lines = headersString.trim().split(/[\r\n]+/)
+  const lines = headersString.trim().split(/[\r\n]+/);
   lines.forEach((line) => {
-    const parts = line.split(": ")
-    const name = parts.shift()
-    const value = parts.join(": ")
-    headerMap[name.toLowerCase()] = value
-  })
+    const parts = line.split(": ");
+    const name = parts.shift();
+    const value = parts.join(": ");
+    headerMap[name.toLowerCase()] = value;
+  });
 
-  return headerMap
-}
+  return headerMap;
+};
 
 const hrefToOrigin = (href) => {
-  const scheme = hrefToScheme(href)
+  const scheme = hrefToScheme(href);
 
   if (scheme === "file") {
-    return "file://"
+    return "file://";
   }
 
   if (scheme === "http" || scheme === "https") {
-    const secondProtocolSlashIndex = scheme.length + "://".length
-    const pathnameSlashIndex = href.indexOf("/", secondProtocolSlashIndex)
+    const secondProtocolSlashIndex = scheme.length + "://".length;
+    const pathnameSlashIndex = href.indexOf("/", secondProtocolSlashIndex);
 
-    if (pathnameSlashIndex === -1) return href
-    return href.slice(0, pathnameSlashIndex)
+    if (pathnameSlashIndex === -1) return href;
+    return href.slice(0, pathnameSlashIndex);
   }
 
-  return href.slice(0, scheme.length + 1)
-}
+  return href.slice(0, scheme.length + 1);
+};
 
 const hrefToScheme = (href) => {
-  const colonIndex = href.indexOf(":")
-  if (colonIndex === -1) return ""
-  return href.slice(0, colonIndex)
-}
+  const colonIndex = href.indexOf(":");
+  if (colonIndex === -1) return "";
+  return href.slice(0, colonIndex);
+};
 
 const isDataView = (obj) => {
-  return obj && DataView.prototype.isPrototypeOf(obj)
-}
+  return obj && DataView.prototype.isPrototypeOf(obj);
+};
 
 const isArrayBufferView =
   ArrayBuffer.isView ||
@@ -331,73 +331,73 @@ const isArrayBufferView =
       "[object Uint32Array]",
       "[object Float32Array]",
       "[object Float64Array]",
-    ]
+    ];
 
     return (value) => {
       return (
         value && viewClasses.includes(Object.prototype.toString.call(value))
-      )
-    }
-  })()
+      );
+    };
+  })();
 
 const textToFormData = (text) => {
-  const form = new FormData()
+  const form = new FormData();
   text
     .trim()
     .split("&")
     .forEach(function (bytes) {
       if (bytes) {
-        const split = bytes.split("=")
-        const name = split.shift().replace(/\+/g, " ")
-        const value = split.join("=").replace(/\+/g, " ")
-        form.append(decodeURIComponent(name), decodeURIComponent(value))
+        const split = bytes.split("=");
+        const name = split.shift().replace(/\+/g, " ");
+        const value = split.join("=").replace(/\+/g, " ");
+        form.append(decodeURIComponent(name), decodeURIComponent(value));
       }
-    })
-  return form
-}
+    });
+  return form;
+};
 
 const blobToArrayBuffer = async (blob) => {
-  const reader = new FileReader()
-  const promise = fileReaderReady(reader)
-  reader.readAsArrayBuffer(blob)
-  return promise
-}
+  const reader = new FileReader();
+  const promise = fileReaderReady(reader);
+  reader.readAsArrayBuffer(blob);
+  return promise;
+};
 
 const blobToText = (blob) => {
-  const reader = new FileReader()
-  const promise = fileReaderReady(reader)
-  reader.readAsText(blob)
-  return promise
-}
+  const reader = new FileReader();
+  const promise = fileReaderReady(reader);
+  reader.readAsText(blob);
+  return promise;
+};
 
 const arrayBufferToText = (arrayBuffer) => {
-  const view = new Uint8Array(arrayBuffer)
-  const chars = new Array(view.length)
-  let i = 0
+  const view = new Uint8Array(arrayBuffer);
+  const chars = new Array(view.length);
+  let i = 0;
   while (i < view.length) {
-    chars[i] = String.fromCharCode(view[i])
+    chars[i] = String.fromCharCode(view[i]);
 
-    i++
+    i++;
   }
-  return chars.join("")
-}
+  return chars.join("");
+};
 
 const fileReaderReady = (reader) => {
   return new Promise(function (resolve, reject) {
     reader.onload = function () {
-      resolve(reader.result)
-    }
+      resolve(reader.result);
+    };
     reader.onerror = function () {
-      reject(reader.error)
-    }
-  })
-}
+      reject(reader.error);
+    };
+  });
+};
 
 const cloneBuffer = (buffer) => {
   if (buffer.slice) {
-    return buffer.slice(0)
+    return buffer.slice(0);
   }
-  const view = new Uint8Array(buffer.byteLength)
-  view.set(new Uint8Array(buffer))
-  return view.buffer
-}
+  const view = new Uint8Array(buffer.byteLength);
+  view.set(new Uint8Array(buffer));
+  return view.buffer;
+};

package/src/node/fetch_url_node.js

@@ -1,14 +1,14 @@
 // https://github.com/node-fetch/node-fetch/blob/8c197f8982a238b3c345c64b17bfa92e16b4f7c4/src/response.js#L1
 
-import { Agent } from "node:https"
-import nodeFetch, { Response } from "node-fetch"
+import { Agent } from "node:https";
+import nodeFetch, { Response } from "node-fetch";
 
-import { DATA_URL } from "@jsenv/urls"
-import { fetchFileSystem } from "@jsenv/server"
+import { DATA_URL } from "@jsenv/urls";
+import { fetchFileSystem } from "@jsenv/server";
 import {
   isFileHandle,
   fileHandleToReadableStream,
-} from "@jsenv/server/src/interfacing_with_node/body.js"
+} from "@jsenv/server/src/interfacing_with_node/body.js";
 
 export const fetchUrl = async (
   url,
@@ -24,11 +24,11 @@ export const fetchUrl = async (
   } = {},
 ) => {
   try {
-    url = String(new URL(url))
+    url = String(new URL(url));
   } catch (e) {
     throw new Error(
       `fetchUrl first argument must be an absolute url, received ${url}`,
-    )
+    );
   }
 
   if (url.startsWith("file://")) {
@@ -41,8 +41,8 @@ export const fetchUrl = async (
       canReadDirectory,
       contentTypeMap,
       ...rest,
-    })
-    const responseBody = responseProperties.body
+    });
+    const responseBody = responseProperties.body;
 
     const response = new Response(
       typeof responseBody === "string"
@@ -56,21 +56,21 @@ export const fetchUrl = async (
         statusText: responseProperties.statusText,
         headers: responseProperties.headers,
       },
-    )
-    return response
+    );
+    return response;
   }
 
   if (url.startsWith("data:")) {
-    const { contentType, base64Flag, data } = DATA_URL.parse(url)
-    const body = base64Flag ? Buffer.from(data, "base64") : Buffer.from(data)
+    const { contentType, base64Flag, data } = DATA_URL.parse(url);
+    const body = base64Flag ? Buffer.from(data, "base64") : Buffer.from(data);
     const response = new Response(body, {
       url,
       status: 200,
       headers: {
         "content-type": contentType,
       },
-    })
-    return response
+    });
+    return response;
   }
 
   const response = await nodeFetch(url, {
@@ -82,12 +82,12 @@ export const fetchUrl = async (
           agent: () => {
             return new Agent({
               rejectUnauthorized: false,
-            })
+            });
           },
         }
       : {}),
     ...rest,
-  })
+  });
 
-  return response
-}
+  return response;
+};