@gradio/client 0.1.2 → 0.1.4

package/dist/index.js

@@ -161,45 +161,7 @@ const hardware_types = [
 ];
 const QUEUE_FULL_MSG = "This application is too busy. Keep trying!";
 const BROKEN_CONNECTION_MSG = "Connection errored out.";
-async function post_data(url, body, token) {
-  const headers = { "Content-Type": "application/json" };
-  if (token) {
-    headers.Authorization = `Bearer ${token}`;
-  }
-  try {
-    var response = await fetch(url, {
-      method: "POST",
-      body: JSON.stringify(body),
-      headers
-    });
-  } catch (e) {
-    return [{ error: BROKEN_CONNECTION_MSG }, 500];
-  }
-  const output = await response.json();
-  return [output, response.status];
-}
 let NodeBlob;
-async function upload_files(root, files, token) {
-  const headers = {};
-  if (token) {
-    headers.Authorization = `Bearer ${token}`;
-  }
-  const formData = new FormData();
-  files.forEach((file) => {
-    formData.append("files", file);
-  });
-  try {
-    var response = await fetch(`${root}/upload`, {
-      method: "POST",
-      body: formData,
-      headers
-    });
-  } catch (e) {
-    return { error: BROKEN_CONNECTION_MSG };
-  }
-  const output = await response.json();
-  return { files: output };
-}
 async function duplicate(app_reference, options) {
   const { hf_token, private: _private, hardware, timeout } = options;
   if (hardware && !hardware_types.includes(hardware)) {
@@ -254,371 +216,423 @@ async function duplicate(app_reference, options) {
     throw new Error(e);
   }
 }
-async function client(app_reference, options = { normalise_files: true }) {
-  return new Promise(async (res) => {
-    const { status_callback, hf_token, normalise_files } = options;
-    const return_obj = {
-      predict,
-      submit,
-      view_api
-      // duplicate
-    };
-    let transform_files = normalise_files ?? true;
-    if (typeof window === "undefined" || !("WebSocket" in window)) {
-      const ws = await import("./wrapper-b7460963.js");
-      NodeBlob = (await import("node:buffer")).Blob;
-      global.WebSocket = ws.WebSocket;
+function api_factory(fetch_implementation) {
+  return { post_data: post_data2, upload_files: upload_files2, client: client2, handle_blob: handle_blob2 };
+  async function post_data2(url, body, token) {
+    const headers = { "Content-Type": "application/json" };
+    if (token) {
+      headers.Authorization = `Bearer ${token}`;
     }
-    const { ws_protocol, http_protocol, host, space_id } = await process_endpoint(app_reference, hf_token);
-    const session_hash = Math.random().toString(36).substring(2);
-    const last_status = {};
-    let config;
-    let api_map = {};
-    let jwt = false;
-    if (hf_token && space_id) {
-      jwt = await get_jwt(space_id, hf_token);
+    try {
+      var response = await fetch_implementation(url, {
+        method: "POST",
+        body: JSON.stringify(body),
+        headers
+      });
+    } catch (e) {
+      return [{ error: BROKEN_CONNECTION_MSG }, 500];
     }
-    async function config_success(_config) {
-      config = _config;
-      api_map = map_names_to_ids((_config == null ? void 0 : _config.dependencies) || []);
-      try {
-        api = await view_api(config);
-      } catch (e) {
-        console.error(`Could not get api details: ${e.message}`);
-      }
-      return {
-        config,
-        ...return_obj
-      };
+    const output = await response.json();
+    return [output, response.status];
+  }
+  async function upload_files2(root, files, token) {
+    const headers = {};
+    if (token) {
+      headers.Authorization = `Bearer ${token}`;
     }
-    let api;
-    async function handle_space_sucess(status) {
-      if (status_callback)
-        status_callback(status);
-      if (status.status === "running")
+    const formData = new FormData();
+    files.forEach((file) => {
+      formData.append("files", file);
+    });
+    try {
+      var response = await fetch_implementation(`${root}/upload`, {
+        method: "POST",
+        body: formData,
+        headers
+      });
+    } catch (e) {
+      return { error: BROKEN_CONNECTION_MSG };
+    }
+    const output = await response.json();
+    return { files: output };
+  }
+  async function client2(app_reference, options = { normalise_files: true }) {
+    return new Promise(async (res) => {
+      const { status_callback, hf_token, normalise_files } = options;
+      const return_obj = {
+        predict,
+        submit,
+        view_api
+        // duplicate
+      };
+      const transform_files = normalise_files ?? true;
+      if (typeof window === "undefined" || !("WebSocket" in window)) {
+        const ws = await import("./wrapper-6f348d45.js");
+        NodeBlob = (await import("node:buffer")).Blob;
+        global.WebSocket = ws.WebSocket;
+      }
+      const { ws_protocol, http_protocol, host, space_id } = await process_endpoint(app_reference, hf_token);
+      const session_hash = Math.random().toString(36).substring(2);
+      const last_status = {};
+      let config;
+      let api_map = {};
+      let jwt = false;
+      if (hf_token && space_id) {
+        jwt = await get_jwt(space_id, hf_token);
+      }
+      async function config_success(_config) {
+        config = _config;
+        api_map = map_names_to_ids((_config == null ? void 0 : _config.dependencies) || []);
         try {
-          config = await resolve_config(`${http_protocol}//${host}`, hf_token);
-          const _config = await config_success(config);
-          res(_config);
+          api = await view_api(config);
         } catch (e) {
-          if (status_callback) {
+          console.error(`Could not get api details: ${e.message}`);
+        }
+        return {
+          config,
+          ...return_obj
+        };
+      }
+      let api;
+      async function handle_space_sucess(status) {
+        if (status_callback)
+          status_callback(status);
+        if (status.status === "running")
+          try {
+            config = await resolve_config(
+              fetch_implementation,
+              `${http_protocol}//${host}`,
+              hf_token
+            );
+            const _config = await config_success(config);
+            res(_config);
+          } catch (e) {
+            console.error(e);
+            if (status_callback) {
+              status_callback({
+                status: "error",
+                message: "Could not load this space.",
+                load_status: "error",
+                detail: "NOT_FOUND"
+              });
+            }
+          }
+      }
+      try {
+        config = await resolve_config(
+          fetch_implementation,
+          `${http_protocol}//${host}`,
+          hf_token
+        );
+        const _config = await config_success(config);
+        res(_config);
+      } catch (e) {
+        console.error(e);
+        if (space_id) {
+          check_space_status(
+            space_id,
+            RE_SPACE_NAME.test(space_id) ? "space_name" : "subdomain",
+            handle_space_sucess
+          );
+        } else {
+          if (status_callback)
             status_callback({
               status: "error",
               message: "Could not load this space.",
               load_status: "error",
               detail: "NOT_FOUND"
             });
-          }
         }
-    }
-    try {
-      config = await resolve_config(`${http_protocol}//${host}`, hf_token);
-      const _config = await config_success(config);
-      res(_config);
-    } catch (e) {
-      if (space_id) {
-        check_space_status(
-          space_id,
-          RE_SPACE_NAME.test(space_id) ? "space_name" : "subdomain",
-          handle_space_sucess
-        );
-      } else {
-        if (status_callback)
-          status_callback({
-            status: "error",
-            message: "Could not load this space.",
-            load_status: "error",
-            detail: "NOT_FOUND"
-          });
       }
-    }
-    function predict(endpoint, data, event_data) {
-      let data_returned = false;
-      let status_complete = false;
-      return new Promise((res2, rej) => {
-        const app = submit(endpoint, data, event_data);
-        app.on("data", (d) => {
-          data_returned = true;
-          if (status_complete) {
-            app.destroy();
-          }
-          res2(d);
-        }).on("status", (status) => {
-          if (status.stage === "error")
-            rej(status);
-          if (status.stage === "complete" && data_returned) {
-            app.destroy();
-          }
-          if (status.stage === "complete") {
-            status_complete = true;
-          }
+      function predict(endpoint, data, event_data) {
+        let data_returned = false;
+        let status_complete = false;
+        return new Promise((res2, rej) => {
+          const app = submit(endpoint, data, event_data);
+          app.on("data", (d) => {
+            data_returned = true;
+            if (status_complete) {
+              app.destroy();
+            }
+            res2(d);
+          }).on("status", (status) => {
+            if (status.stage === "error")
+              rej(status);
+            if (status.stage === "complete" && data_returned) {
+              app.destroy();
+            }
+            if (status.stage === "complete") {
+              status_complete = true;
+            }
+          });
         });
-      });
-    }
-    function submit(endpoint, data, event_data) {
-      let fn_index;
-      let api_info;
-      if (typeof endpoint === "number") {
-        fn_index = endpoint;
-        api_info = api.unnamed_endpoints[fn_index];
-      } else {
-        const trimmed_endpoint = endpoint.replace(/^\//, "");
-        fn_index = api_map[trimmed_endpoint];
-        api_info = api.named_endpoints[endpoint.trim()];
-      }
-      if (typeof fn_index !== "number") {
-        throw new Error(
-          "There is no endpoint matching that name of fn_index matching that number."
-        );
       }
-      let websocket;
-      const _endpoint = typeof endpoint === "number" ? "/predict" : endpoint;
-      let payload;
-      let complete = false;
-      const listener_map = {};
-      handle_blob(
-        `${http_protocol}//${host + config.path}`,
-        data,
-        api_info,
-        hf_token
-      ).then((_payload) => {
-        payload = { data: _payload || [], event_data, fn_index };
-        if (skip_queue(fn_index, config)) {
-          fire_event({
-            type: "status",
-            endpoint: _endpoint,
-            stage: "pending",
-            queue: false,
-            fn_index,
-            time: /* @__PURE__ */ new Date()
-          });
-          post_data(
-            `${http_protocol}//${host + config.path}/run${_endpoint.startsWith("/") ? _endpoint : `/${_endpoint}`}`,
-            {
-              ...payload,
-              session_hash
-            },
-            hf_token
-          ).then(([output, status_code]) => {
-            const data2 = transform_files ? transform_output(
-              output.data,
-              api_info,
-              config.root,
-              config.root_url
-            ) : output.data;
-            if (status_code == 200) {
-              fire_event({
-                type: "data",
-                endpoint: _endpoint,
-                fn_index,
-                data: data2,
-                time: /* @__PURE__ */ new Date()
-              });
-              fire_event({
-                type: "status",
-                endpoint: _endpoint,
-                fn_index,
-                stage: "complete",
-                eta: output.average_duration,
-                queue: false,
-                time: /* @__PURE__ */ new Date()
-              });
-            } else {
+      function submit(endpoint, data, event_data) {
+        let fn_index;
+        let api_info;
+        if (typeof endpoint === "number") {
+          fn_index = endpoint;
+          api_info = api.unnamed_endpoints[fn_index];
+        } else {
+          const trimmed_endpoint = endpoint.replace(/^\//, "");
+          fn_index = api_map[trimmed_endpoint];
+          api_info = api.named_endpoints[endpoint.trim()];
+        }
+        if (typeof fn_index !== "number") {
+          throw new Error(
+            "There is no endpoint matching that name of fn_index matching that number."
+          );
+        }
+        let websocket;
+        const _endpoint = typeof endpoint === "number" ? "/predict" : endpoint;
+        let payload;
+        let complete = false;
+        const listener_map = {};
+        handle_blob2(
+          `${http_protocol}//${host + config.path}`,
+          data,
+          api_info,
+          hf_token
+        ).then((_payload) => {
+          payload = { data: _payload || [], event_data, fn_index };
+          if (skip_queue(fn_index, config)) {
+            fire_event({
+              type: "status",
+              endpoint: _endpoint,
+              stage: "pending",
+              queue: false,
+              fn_index,
+              time: /* @__PURE__ */ new Date()
+            });
+            post_data2(
+              `${http_protocol}//${host + config.path}/run${_endpoint.startsWith("/") ? _endpoint : `/${_endpoint}`}`,
+              {
+                ...payload,
+                session_hash
+              },
+              hf_token
+            ).then(([output, status_code]) => {
+              const data2 = transform_files ? transform_output(
+                output.data,
+                api_info,
+                config.root,
+                config.root_url
+              ) : output.data;
+              if (status_code == 200) {
+                fire_event({
+                  type: "data",
+                  endpoint: _endpoint,
+                  fn_index,
+                  data: data2,
+                  time: /* @__PURE__ */ new Date()
+                });
+                fire_event({
+                  type: "status",
+                  endpoint: _endpoint,
+                  fn_index,
+                  stage: "complete",
+                  eta: output.average_duration,
+                  queue: false,
+                  time: /* @__PURE__ */ new Date()
+                });
+              } else {
+                fire_event({
+                  type: "status",
+                  stage: "error",
+                  endpoint: _endpoint,
+                  fn_index,
+                  message: output.error,
+                  queue: false,
+                  time: /* @__PURE__ */ new Date()
+                });
+              }
+            }).catch((e) => {
               fire_event({
                 type: "status",
                 stage: "error",
+                message: e.message,
                 endpoint: _endpoint,
                 fn_index,
-                message: output.error,
                 queue: false,
                 time: /* @__PURE__ */ new Date()
               });
-            }
-          }).catch((e) => {
+            });
+          } else {
             fire_event({
               type: "status",
-              stage: "error",
-              message: e.message,
+              stage: "pending",
+              queue: true,
               endpoint: _endpoint,
               fn_index,
-              queue: false,
               time: /* @__PURE__ */ new Date()
             });
-          });
-        } else {
-          fire_event({
-            type: "status",
-            stage: "pending",
-            queue: true,
-            endpoint: _endpoint,
-            fn_index,
-            time: /* @__PURE__ */ new Date()
-          });
-          let url = new URL(`${ws_protocol}://${host}${config.path}
-						/queue/join`);
-          if (jwt) {
-            url.searchParams.set("__sign", jwt);
-          }
-          websocket = new WebSocket(url);
-          websocket.onclose = (evt) => {
-            if (!evt.wasClean) {
-              fire_event({
-                type: "status",
-                stage: "error",
-                message: BROKEN_CONNECTION_MSG,
-                queue: true,
-                endpoint: _endpoint,
-                fn_index,
-                time: /* @__PURE__ */ new Date()
-              });
+            let url = new URL(`${ws_protocol}://${host}${config.path}
+							/queue/join`);
+            if (jwt) {
+              url.searchParams.set("__sign", jwt);
             }
-          };
-          websocket.onmessage = function(event) {
-            const _data = JSON.parse(event.data);
-            const { type, status, data: data2 } = handle_message(
-              _data,
-              last_status[fn_index]
-            );
-            if (type === "update" && status && !complete) {
-              fire_event({
-                type: "status",
-                endpoint: _endpoint,
-                fn_index,
-                time: /* @__PURE__ */ new Date(),
-                ...status
-              });
-              if (status.stage === "error") {
-                websocket.close();
+            websocket = new WebSocket(url);
+            websocket.onclose = (evt) => {
+              if (!evt.wasClean) {
+                fire_event({
+                  type: "status",
+                  stage: "error",
+                  message: BROKEN_CONNECTION_MSG,
+                  queue: true,
+                  endpoint: _endpoint,
+                  fn_index,
+                  time: /* @__PURE__ */ new Date()
+                });
               }
-            } else if (type === "hash") {
-              websocket.send(JSON.stringify({ fn_index, session_hash }));
-              return;
-            } else if (type === "data") {
-              websocket.send(JSON.stringify({ ...payload, session_hash }));
-            } else if (type === "complete") {
-              complete = status;
-            } else if (type === "generating") {
-              fire_event({
-                type: "status",
-                time: /* @__PURE__ */ new Date(),
-                ...status,
-                stage: status == null ? void 0 : status.stage,
-                queue: true,
-                endpoint: _endpoint,
-                fn_index
-              });
-            }
-            if (data2) {
-              fire_event({
-                type: "data",
-                time: /* @__PURE__ */ new Date(),
-                data: transform_files ? transform_output(
-                  data2.data,
-                  api_info,
-                  config.root,
-                  config.root_url
-                ) : data2.data,
-                endpoint: _endpoint,
-                fn_index
-              });
-              if (complete) {
+            };
+            websocket.onmessage = function(event) {
+              const _data = JSON.parse(event.data);
+              const { type, status, data: data2 } = handle_message(
+                _data,
+                last_status[fn_index]
+              );
+              if (type === "update" && status && !complete) {
                 fire_event({
                   type: "status",
+                  endpoint: _endpoint,
+                  fn_index,
                   time: /* @__PURE__ */ new Date(),
-                  ...complete,
+                  ...status
+                });
+                if (status.stage === "error") {
+                  websocket.close();
+                }
+              } else if (type === "hash") {
+                websocket.send(JSON.stringify({ fn_index, session_hash }));
+                return;
+              } else if (type === "data") {
+                websocket.send(JSON.stringify({ ...payload, session_hash }));
+              } else if (type === "complete") {
+                complete = status;
+              } else if (type === "generating") {
+                fire_event({
+                  type: "status",
+                  time: /* @__PURE__ */ new Date(),
+                  ...status,
                   stage: status == null ? void 0 : status.stage,
                   queue: true,
                   endpoint: _endpoint,
                   fn_index
                 });
-                websocket.close();
               }
+              if (data2) {
+                fire_event({
+                  type: "data",
+                  time: /* @__PURE__ */ new Date(),
+                  data: transform_files ? transform_output(
+                    data2.data,
+                    api_info,
+                    config.root,
+                    config.root_url
+                  ) : data2.data,
+                  endpoint: _endpoint,
+                  fn_index
+                });
+                if (complete) {
+                  fire_event({
+                    type: "status",
+                    time: /* @__PURE__ */ new Date(),
+                    ...complete,
+                    stage: status == null ? void 0 : status.stage,
+                    queue: true,
+                    endpoint: _endpoint,
+                    fn_index
+                  });
+                  websocket.close();
+                }
+              }
+            };
+            if (semiver(config.version || "2.0.0", "3.6") < 0) {
+              addEventListener(
+                "open",
+                () => websocket.send(JSON.stringify({ hash: session_hash }))
+              );
             }
-          };
-          if (semiver(config.version || "2.0.0", "3.6") < 0) {
-            addEventListener(
-              "open",
-              () => websocket.send(JSON.stringify({ hash: session_hash }))
-            );
           }
-        }
-      });
-      function fire_event(event) {
-        const narrowed_listener_map = listener_map;
-        let listeners = narrowed_listener_map[event.type] || [];
-        listeners == null ? void 0 : listeners.forEach((l) => l(event));
-      }
-      function on(eventType, listener) {
-        const narrowed_listener_map = listener_map;
-        let listeners = narrowed_listener_map[eventType] || [];
-        narrowed_listener_map[eventType] = listeners;
-        listeners == null ? void 0 : listeners.push(listener);
-        return { on, off, cancel, destroy };
-      }
-      function off(eventType, listener) {
-        const narrowed_listener_map = listener_map;
-        let listeners = narrowed_listener_map[eventType] || [];
-        listeners = listeners == null ? void 0 : listeners.filter((l) => l !== listener);
-        narrowed_listener_map[eventType] = listeners;
-        return { on, off, cancel, destroy };
-      }
-      async function cancel() {
-        const _status = {
-          stage: "complete",
-          queue: false,
-          time: /* @__PURE__ */ new Date()
-        };
-        complete = _status;
-        fire_event({
-          ..._status,
-          type: "status",
-          endpoint: _endpoint,
-          fn_index
         });
-        if (websocket && websocket.readyState === 0) {
-          websocket.addEventListener("open", () => {
-            websocket.close();
-          });
-        } else {
-          websocket.close();
+        function fire_event(event) {
+          const narrowed_listener_map = listener_map;
+          const listeners = narrowed_listener_map[event.type] || [];
+          listeners == null ? void 0 : listeners.forEach((l) => l(event));
         }
-        try {
-          await fetch(`${http_protocol}//${host + config.path}/reset`, {
-            headers: { "Content-Type": "application/json" },
-            method: "POST",
-            body: JSON.stringify({ fn_index, session_hash })
-          });
-        } catch (e) {
-          console.warn(
-            "The `/reset` endpoint could not be called. Subsequent endpoint results may be unreliable."
-          );
+        function on(eventType, listener) {
+          const narrowed_listener_map = listener_map;
+          const listeners = narrowed_listener_map[eventType] || [];
+          narrowed_listener_map[eventType] = listeners;
+          listeners == null ? void 0 : listeners.push(listener);
+          return { on, off, cancel, destroy };
         }
-      }
-      function destroy() {
-        for (const event_type in listener_map) {
-          listener_map[event_type].forEach((fn2) => {
-            off(event_type, fn2);
+        function off(eventType, listener) {
+          const narrowed_listener_map = listener_map;
+          let listeners = narrowed_listener_map[eventType] || [];
+          listeners = listeners == null ? void 0 : listeners.filter((l) => l !== listener);
+          narrowed_listener_map[eventType] = listeners;
+          return { on, off, cancel, destroy };
+        }
+        async function cancel() {
+          const _status = {
+            stage: "complete",
+            queue: false,
+            time: /* @__PURE__ */ new Date()
+          };
+          complete = _status;
+          fire_event({
+            ..._status,
+            type: "status",
+            endpoint: _endpoint,
+            fn_index
           });
+          if (websocket && websocket.readyState === 0) {
+            websocket.addEventListener("open", () => {
+              websocket.close();
+            });
+          } else {
+            websocket.close();
+          }
+          try {
+            await fetch_implementation(
+              `${http_protocol}//${host + config.path}/reset`,
+              {
+                headers: { "Content-Type": "application/json" },
+                method: "POST",
+                body: JSON.stringify({ fn_index, session_hash })
+              }
+            );
+          } catch (e) {
+            console.warn(
+              "The `/reset` endpoint could not be called. Subsequent endpoint results may be unreliable."
+            );
+          }
         }
+        function destroy() {
+          for (const event_type in listener_map) {
+            listener_map[event_type].forEach((fn2) => {
+              off(event_type, fn2);
+            });
+          }
+        }
+        return {
+          on,
+          off,
+          cancel,
+          destroy
+        };
       }
-      return {
-        on,
-        off,
-        cancel,
-        destroy
-      };
-    }
-    async function view_api(config2) {
-      if (api)
-        return api;
-      const headers = { "Content-Type": "application/json" };
-      if (hf_token) {
-        headers.Authorization = `Bearer ${hf_token}`;
-      }
-      try {
+      async function view_api(config2) {
+        if (api)
+          return api;
+        const headers = { "Content-Type": "application/json" };
+        if (hf_token) {
+          headers.Authorization = `Bearer ${hf_token}`;
+        }
         let response;
         if (semiver(config2.version || "2.0.0", "3.30") < 0) {
-          response = await fetch(
+          response = await fetch_implementation(
             "https://gradio-space-api-fetcher-v2.hf.space/api",
             {
               method: "POST",
@@ -630,10 +644,13 @@ async function client(app_reference, options = { normalise_files: true }) {
             }
           );
         } else {
-          response = await fetch(`${config2.root}/info`, {
+          response = await fetch_implementation(`${config2.root}/info`, {
             headers
           });
         }
+        if (!response.ok) {
+          throw new Error(BROKEN_CONNECTION_MSG);
+        }
         let api_info = await response.json();
         if ("api" in api_info) {
           api_info = api_info.api;
@@ -643,14 +660,49 @@ async function client(app_reference, options = { normalise_files: true }) {
         }
         const x = transform_api_info(api_info, config2, api_map);
         return x;
-      } catch (e) {
-        return [{ error: BROKEN_CONNECTION_MSG }, 500];
       }
-    }
-  });
+    });
+  }
+  async function handle_blob2(endpoint, data, api_info, token) {
+    const blob_refs = await walk_and_store_blobs(
+      data,
+      void 0,
+      [],
+      true,
+      api_info
+    );
+    return Promise.all(
+      blob_refs.map(async ({ path, blob, data: data2, type }) => {
+        if (blob) {
+          const file_url = (await upload_files2(endpoint, [blob], token)).files[0];
+          return { path, file_url, type };
+        } else {
+          return { path, base64: data2, type };
+        }
+      })
+    ).then((r) => {
+      r.forEach(({ path, file_url, base64, type }) => {
+        if (base64) {
+          update_object(data, base64, path);
+        } else if (type === "Gallery") {
+          update_object(data, file_url, path);
+        } else if (file_url) {
+          const o = {
+            is_file: true,
+            name: `${file_url}`,
+            data: null
+            // orig_name: "file.csv"
+          };
+          update_object(data, o, path);
+        }
+      });
+      return data;
+    });
+  }
 }
+const { post_data, upload_files, client, handle_blob } = api_factory(fetch);
 function transform_output(data, api_info, root_url, remote_url) {
-  let transformed_data = data.map((d, i) => {
+  return data.map((d, i) => {
     var _a, _b, _c, _d;
     if (((_b = (_a = api_info.returns) == null ? void 0 : _a[i]) == null ? void 0 : _b.component) === "File") {
       return normalise_file(d, root_url, remote_url);
@@ -664,7 +716,6 @@ function transform_output(data, api_info, root_url, remote_url) {
       return d;
     }
   });
-  return transformed_data;
 }
 function normalise_file(file, root, root_url) {
   if (file == null)
@@ -688,7 +739,7 @@ function normalise_file(file, root, root_url) {
     if (!root_url) {
       file.data = root + "/file=" + file.name;
     } else {
-      file.data = "/proxy=" + root_url + "/file=" + file.name;
+      file.data = "/proxy=" + root_url + "file=" + file.name;
     }
   }
   return file;
@@ -777,44 +828,6 @@ async function get_jwt(space, token) {
     return false;
   }
 }
-async function handle_blob(endpoint, data, api_info, token) {
-  const blob_refs = await walk_and_store_blobs(
-    data,
-    void 0,
-    [],
-    true,
-    api_info
-  );
-  return new Promise((res) => {
-    Promise.all(
-      blob_refs.map(async ({ path, blob, data: data2, type }) => {
-        if (blob) {
-          const file_url = (await upload_files(endpoint, [blob], token)).files[0];
-          return { path, file_url, type };
-        } else {
-          return { path, base64: data2, type };
-        }
-      })
-    ).then((r) => {
-      r.forEach(({ path, file_url, base64, type }) => {
-        if (base64) {
-          update_object(data, base64, path);
-        } else if (type === "Gallery") {
-          update_object(data, file_url, path);
-        } else if (file_url) {
-          const o = {
-            is_file: true,
-            name: `${file_url}`,
-            data: null
-            // orig_name: "file.csv"
-          };
-          update_object(data, o, path);
-        }
-      });
-      res(data);
-    }).catch(console.log);
-  });
-}
 function update_object(object, newValue, stack) {
   while (stack.length > 1) {
     object = object[stack.shift()];
@@ -896,7 +909,7 @@ function skip_queue(id, config) {
   var _a, _b, _c, _d;
   return !(((_b = (_a = config == null ? void 0 : config.dependencies) == null ? void 0 : _a[id]) == null ? void 0 : _b.queue) === null ? config.enable_queue : (_d = (_c = config == null ? void 0 : config.dependencies) == null ? void 0 : _c[id]) == null ? void 0 : _d.queue) || false;
 }
-async function resolve_config(endpoint, token) {
+async function resolve_config(fetch_implementation, endpoint, token) {
   const headers = {};
   if (token) {
     headers.Authorization = `Bearer ${token}`;
@@ -907,7 +920,9 @@ async function resolve_config(endpoint, token) {
     config.root = endpoint + config.root;
     return { ...config, path };
   } else if (endpoint) {
-    let response = await fetch(`${endpoint}/config`, { headers });
+    let response = await fetch_implementation(`${endpoint}/config`, {
+      headers
+    });
     if (response.status === 200) {
       const config = await response.json();
       config.path = config.path ?? "";
@@ -958,6 +973,15 @@ async function check_space_status(id, type, status_callback) {
         check_space_status(id, type, status_callback);
       }, 1e3);
       break;
+    case "PAUSED":
+      status_callback({
+        status: "paused",
+        load_status: "error",
+        message: "This space has been paused by the author. If you would like to try this demo, consider duplicating the space.",
+        detail: stage,
+        discussions_enabled: await discussions_enabled(space_name)
+      });
+      break;
     case "RUNNING":
     case "RUNNING_BUILDING":
       status_callback({
@@ -1086,6 +1110,7 @@ function handle_message(data, last_status) {
   return { type: "none", status: { stage: "error", queue } };
 }
 export {
+  api_factory,
   client,
   duplicate,
   post_data,