@runware/sdk-js 1.0.27

package/dist/index.mjs

@@ -0,0 +1,1293 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// Runware/reconnect.ts
+var require_reconnect = __commonJS({
+  "Runware/reconnect.ts"(exports, module) {
+    "use strict";
+    var isWebSocket = (constructor) => constructor && constructor.CLOSING === 2;
+    var isGlobalWebSocket = () => typeof WebSocket !== "undefined" && isWebSocket(WebSocket);
+    var getDefaultOptions = () => ({
+      constructor: isGlobalWebSocket() ? WebSocket : null,
+      maxReconnectionDelay: 1e4,
+      minReconnectionDelay: 1500,
+      reconnectionDelayGrowFactor: 1.3,
+      connectionTimeout: 4e3,
+      maxRetries: Infinity,
+      debug: false
+    });
+    var bypassProperty = (src, dst, name) => {
+      Object.defineProperty(dst, name, {
+        get: () => src[name],
+        set: (value) => {
+          src[name] = value;
+        },
+        enumerable: true,
+        configurable: true
+      });
+    };
+    var initReconnectionDelay = (config) => config.minReconnectionDelay + Math.random() * config.minReconnectionDelay;
+    var updateReconnectionDelay = (config, previousDelay) => {
+      const newDelay = previousDelay * config.reconnectionDelayGrowFactor;
+      return newDelay > config.maxReconnectionDelay ? config.maxReconnectionDelay : newDelay;
+    };
+    var LEVEL_0_EVENTS = ["onopen", "onclose", "onmessage", "onerror"];
+    var reassignEventListeners = (ws, oldWs, listeners) => {
+      Object.keys(listeners).forEach((type) => {
+        listeners[type].forEach(([listener, options]) => {
+          ws.addEventListener(type, listener, options);
+        });
+      });
+      if (oldWs) {
+        LEVEL_0_EVENTS.forEach((name) => {
+          ws[name] = oldWs[name];
+        });
+      }
+    };
+    var ReconnectingWebsocket2 = function(url, protocols, options = {}) {
+      let ws;
+      let connectingTimeout;
+      let reconnectDelay = 0;
+      let retriesCount = 0;
+      let shouldRetry = true;
+      const listeners = {};
+      if (!(this instanceof ReconnectingWebsocket2)) {
+        throw new TypeError(
+          "Failed to construct 'ReconnectingWebSocket': Please use the 'new' operator"
+        );
+      }
+      const config = getDefaultOptions();
+      Object.keys(config).filter((key) => options.hasOwnProperty(key)).forEach((key) => config[key] = options[key]);
+      if (!isWebSocket(config.constructor)) {
+        throw new TypeError(
+          "Invalid WebSocket constructor. Set `options.constructor`"
+        );
+      }
+      const log = config.debug ? (...params) => console.log("RWS:", ...params) : () => {
+      };
+      const emitError = (code, msg) => setTimeout(() => {
+        const err = new Error(msg);
+        err.code = code;
+        if (Array.isArray(listeners.error)) {
+          listeners.error.forEach(([fn]) => fn(err));
+        }
+        if (ws.onerror) {
+          ws.onerror(err);
+        }
+      }, 0);
+      const handleClose = () => {
+        log("close");
+        retriesCount++;
+        log("retries count:", retriesCount);
+        if (retriesCount > config.maxRetries) {
+          emitError("EHOSTDOWN", "Too many failed connection attempts");
+          return;
+        }
+        if (!reconnectDelay) {
+          reconnectDelay = initReconnectionDelay(config);
+        } else {
+          reconnectDelay = updateReconnectionDelay(config, reconnectDelay);
+        }
+        log("reconnectDelay:", reconnectDelay);
+        if (shouldRetry) {
+          setTimeout(connect, reconnectDelay);
+        }
+      };
+      const connect = () => {
+        log("connect");
+        const oldWs = ws;
+        ws = new config.constructor(url, protocols);
+        connectingTimeout = setTimeout(() => {
+          log("timeout");
+          ws.close();
+          emitError("ETIMEDOUT", "Connection timeout");
+        }, config.connectionTimeout);
+        log("bypass properties");
+        for (let key in ws) {
+          if (["addEventListener", "removeEventListener", "close", "send"].indexOf(
+            key
+          ) < 0) {
+            bypassProperty(ws, this, key);
+          }
+        }
+        ws.addEventListener("open", () => {
+          clearTimeout(connectingTimeout);
+          log("open");
+          reconnectDelay = initReconnectionDelay(config);
+          log("reconnectDelay:", reconnectDelay);
+          retriesCount = 0;
+        });
+        ws.addEventListener("close", handleClose);
+        reassignEventListeners(ws, oldWs, listeners);
+      };
+      log("init");
+      connect();
+      this.close = (code = 1e3, reason = "", { keepClosed = false, fastClose = true, delay: delay2 = 0 } = {}) => {
+        if (delay2) {
+          reconnectDelay = delay2;
+        }
+        shouldRetry = !keepClosed;
+        ws.close(code, reason);
+        if (fastClose) {
+          const fakeCloseEvent = {
+            code,
+            reason,
+            wasClean: true
+          };
+          handleClose();
+          if (Array.isArray(listeners.close)) {
+            listeners.close.forEach(([listener, options2]) => {
+              listener(fakeCloseEvent);
+              ws.removeEventListener("close", listener, options2);
+            });
+          }
+          if (ws.onclose) {
+            ws.onclose(fakeCloseEvent);
+            ws.onclose = null;
+          }
+        }
+      };
+      this.send = (data) => {
+        ws.send(data);
+      };
+      this.addEventListener = (type, listener, options2) => {
+        if (Array.isArray(listeners[type])) {
+          if (!listeners[type].some(([l]) => l === listener)) {
+            listeners[type].push([listener, options2]);
+          }
+        } else {
+          listeners[type] = [[listener, options2]];
+        }
+        ws.addEventListener(type, listener, options2);
+      };
+      this.removeEventListener = (type, listener, options2) => {
+        if (Array.isArray(listeners[type])) {
+          listeners[type] = listeners[type].filter(([l]) => l !== listener);
+        }
+        ws.removeEventListener(type, listener, options2);
+      };
+    };
+    module.exports = ReconnectingWebsocket2;
+  }
+});
+
+// Runware/types.ts
+var Environment = /* @__PURE__ */ ((Environment2) => {
+  Environment2["PRODUCTION"] = "PRODUCTION";
+  Environment2["DEVELOPMENT"] = "DEVELOPMENT";
+  Environment2["TEST"] = "TEST";
+  return Environment2;
+})(Environment || {});
+var SdkType = /* @__PURE__ */ ((SdkType2) => {
+  SdkType2["CLIENT"] = "CLIENT";
+  SdkType2["SERVER"] = "SERVER";
+  return SdkType2;
+})(SdkType || {});
+var EControlMode = /* @__PURE__ */ ((EControlMode2) => {
+  EControlMode2["BALANCED"] = "balanced";
+  EControlMode2["PROMPT"] = "prompt";
+  EControlMode2["CONTROL_NET"] = "controlnet";
+  return EControlMode2;
+})(EControlMode || {});
+var EPreProcessorGroup = /* @__PURE__ */ ((EPreProcessorGroup3) => {
+  EPreProcessorGroup3["canny"] = "canny";
+  EPreProcessorGroup3["depth"] = "depth";
+  EPreProcessorGroup3["mlsd"] = "mlsd";
+  EPreProcessorGroup3["normalbae"] = "normalbae";
+  EPreProcessorGroup3["openpose"] = "openpose";
+  EPreProcessorGroup3["tile"] = "tile";
+  EPreProcessorGroup3["seg"] = "seg";
+  EPreProcessorGroup3["lineart"] = "lineart";
+  EPreProcessorGroup3["lineart_anime"] = "lineart_anime";
+  EPreProcessorGroup3["shuffle"] = "shuffle";
+  EPreProcessorGroup3["scribble"] = "scribble";
+  EPreProcessorGroup3["softedge"] = "softedge";
+  return EPreProcessorGroup3;
+})(EPreProcessorGroup || {});
+var EPreProcessor = /* @__PURE__ */ ((EPreProcessor3) => {
+  EPreProcessor3["canny"] = "canny";
+  EPreProcessor3["depth_leres"] = "depth_leres";
+  EPreProcessor3["depth_midas"] = "depth_midas";
+  EPreProcessor3["depth_zoe"] = "depth_zoe";
+  EPreProcessor3["inpaint_global_harmonious"] = "inpaint_global_harmonious";
+  EPreProcessor3["lineart_anime"] = "lineart_anime";
+  EPreProcessor3["lineart_coarse"] = "lineart_coarse";
+  EPreProcessor3["lineart_realistic"] = "lineart_realistic";
+  EPreProcessor3["lineart_standard"] = "lineart_standard";
+  EPreProcessor3["mlsd"] = "mlsd";
+  EPreProcessor3["normal_bae"] = "normal_bae";
+  EPreProcessor3["scribble_hed"] = "scribble_hed";
+  EPreProcessor3["scribble_pidinet"] = "scribble_pidinet";
+  EPreProcessor3["seg_ofade20k"] = "seg_ofade20k";
+  EPreProcessor3["seg_ofcoco"] = "seg_ofcoco";
+  EPreProcessor3["seg_ufade20k"] = "seg_ufade20k";
+  EPreProcessor3["shuffle"] = "shuffle";
+  EPreProcessor3["softedge_hed"] = "softedge_hed";
+  EPreProcessor3["softedge_hedsafe"] = "softedge_hedsafe";
+  EPreProcessor3["softedge_pidinet"] = "softedge_pidinet";
+  EPreProcessor3["softedge_pidisafe"] = "softedge_pidisafe";
+  EPreProcessor3["tile_gaussian"] = "tile_gaussian";
+  EPreProcessor3["openpose"] = "openpose";
+  EPreProcessor3["openpose_face"] = "openpose_face";
+  EPreProcessor3["openpose_faceonly"] = "openpose_faceonly";
+  EPreProcessor3["openpose_full"] = "openpose_full";
+  EPreProcessor3["openpose_hand"] = "openpose_hand";
+  return EPreProcessor3;
+})(EPreProcessor || {});
+var EOpenPosePreProcessor = /* @__PURE__ */ ((EOpenPosePreProcessor2) => {
+  EOpenPosePreProcessor2["openpose"] = "openpose";
+  EOpenPosePreProcessor2["openpose_face"] = "openpose_face";
+  EOpenPosePreProcessor2["openpose_faceonly"] = "openpose_faceonly";
+  EOpenPosePreProcessor2["openpose_full"] = "openpose_full";
+  EOpenPosePreProcessor2["openpose_hand"] = "openpose_hand";
+  return EOpenPosePreProcessor2;
+})(EOpenPosePreProcessor || {});
+
+// Runware/utils.ts
+import { v4 as uuidv4, validate as validateUUID } from "uuid";
+var TIMEOUT_DURATION = 6e4;
+var POLLING_INTERVAL = 100;
+var BASE_RUNWARE_URLS = {
+  ["PRODUCTION" /* PRODUCTION */]: "wss://ws-api.runware.ai/v1",
+  ["TEST" /* TEST */]: "ws://localhost:8080"
+};
+var removeFromAray = (col, targetElem) => {
+  if (col == null) {
+    return;
+  }
+  let i = col.indexOf(targetElem);
+  if (i === -1) {
+    return;
+  }
+  col.splice(i, 1);
+};
+var getIntervalWithPromise = (callback, {
+  debugKey = "debugKey",
+  timeOutDuration = TIMEOUT_DURATION,
+  shouldThrowError = true
+}) => {
+  return new Promise((resolve, reject) => {
+    let intervalId = setInterval(async () => {
+      const shouldClear = callback({ resolve, reject, intervalId });
+      if (shouldClear) {
+        clearInterval(intervalId);
+        intervalId = 0;
+      }
+    }, POLLING_INTERVAL);
+    const timeoutId = setTimeout(() => {
+      if (intervalId) {
+        clearInterval(intervalId);
+        if (shouldThrowError) {
+          reject(`Message could not be received for ${debugKey}`);
+          console.error("Message could not be received for ", debugKey);
+        }
+      }
+      clearTimeout(timeoutId);
+    }, timeOutDuration);
+  });
+};
+var fileToBase64 = (file) => new Promise((resolve) => {
+  const reader = new FileReader();
+  reader.readAsDataURL(file);
+  reader.onload = function() {
+    resolve(reader.result);
+  };
+});
+var getUUID = () => uuidv4();
+var isValidUUID = (uuid) => validateUUID(uuid);
+var getTaskType = ({
+  prompt,
+  controlNet,
+  imageMaskInitiator,
+  imageInitiator
+}) => {
+  if (evaluateToBoolean(prompt, !controlNet, !imageMaskInitiator, !imageInitiator)) {
+    return 1;
+  }
+  if (evaluateToBoolean(prompt, !controlNet, !imageMaskInitiator, imageInitiator)) {
+    return 2;
+  }
+  if (evaluateToBoolean(prompt, !controlNet, imageMaskInitiator, imageInitiator)) {
+    return 3;
+  }
+  if (evaluateToBoolean(prompt, controlNet, !imageMaskInitiator, !imageInitiator)) {
+    return 9;
+  }
+  if (evaluateToBoolean(prompt, controlNet, !imageMaskInitiator, imageInitiator)) {
+    return 10;
+  }
+  if (evaluateToBoolean(prompt, controlNet, imageMaskInitiator, imageInitiator)) {
+    return 10;
+  }
+};
+var evaluateToBoolean = (...args) => [...args].every((e) => !!e);
+var compact = (value, data) => !!value ? data : {};
+var getPreprocessorType = (processor) => {
+  const processorGroup = Object.keys(
+    EPreProcessorGroup
+  );
+  switch (processor) {
+    case "canny" /* canny */:
+      return "canny" /* canny */;
+    case "depth_leres" /* depth_leres */:
+    case "depth_midas" /* depth_midas */:
+    case "depth_zoe" /* depth_zoe */:
+      return "depth" /* depth */;
+    case "inpaint_global_harmonious" /* inpaint_global_harmonious */:
+      return "depth" /* depth */;
+    case "lineart_anime" /* lineart_anime */:
+      return "lineart_anime" /* lineart_anime */;
+    case "lineart_coarse" /* lineart_coarse */:
+    case "lineart_realistic" /* lineart_realistic */:
+    case "lineart_standard" /* lineart_standard */:
+      return "lineart" /* lineart */;
+    case "mlsd" /* mlsd */:
+      return "mlsd" /* mlsd */;
+    case "normal_bae" /* normal_bae */:
+      return "normalbae" /* normalbae */;
+    case "openpose_face" /* openpose_face */:
+    case "openpose_faceonly" /* openpose_faceonly */:
+    case "openpose_full" /* openpose_full */:
+    case "openpose_hand" /* openpose_hand */:
+    case "openpose" /* openpose */:
+      return "openpose" /* openpose */;
+    case "scribble_hed" /* scribble_hed */:
+    case "scribble_pidinet" /* scribble_pidinet */:
+      return "scribble" /* scribble */;
+    case "seg_ofade20k" /* seg_ofade20k */:
+    case "seg_ofcoco" /* seg_ofcoco */:
+    case "seg_ufade20k" /* seg_ufade20k */:
+      return "seg" /* seg */;
+    case "shuffle" /* shuffle */:
+      return "shuffle" /* shuffle */;
+    case "softedge_hed" /* softedge_hed */:
+    case "softedge_hedsafe" /* softedge_hedsafe */:
+    case "softedge_pidinet" /* softedge_pidinet */:
+    case "softedge_pidisafe" /* softedge_pidisafe */:
+      return "softedge" /* softedge */;
+    case "tile_gaussian" /* tile_gaussian */:
+      return "tile" /* tile */;
+    default:
+      return "canny" /* canny */;
+  }
+};
+var accessDeepObject = ({
+  key,
+  data,
+  useZero = true,
+  shouldReturnString = false
+}) => {
+  const splittedKeys = key.split(/\.|\[/).map((key2) => key2.replace(/\]$/, ""));
+  const value = splittedKeys.reduce((acc, curr) => {
+    var _a, _b;
+    const returnZero = useZero ? 0 : void 0;
+    const currentValue = acc == null ? void 0 : acc[curr];
+    if (!currentValue) {
+      return returnZero;
+    }
+    if (Array.isArray(currentValue) && /^\d+$/.test(curr)) {
+      const index = parseInt(curr, 10);
+      if (index >= 0 && index < currentValue.length) {
+        return acc[curr] = currentValue[index];
+      } else {
+        return (_a = acc[curr]) != null ? _a : returnZero;
+      }
+    } else {
+      return (_b = acc[curr]) != null ? _b : returnZero;
+    }
+  }, data || {});
+  return value != null ? value : {};
+};
+var delay = (time, milliseconds = 1e3) => {
+  return new Promise((resolve) => setTimeout(resolve, time * milliseconds));
+};
+var removeListener = (listeners, listener) => {
+  return listeners.filter((lis) => lis.key !== listener.key);
+};
+var evaluateNonTrue = ({
+  key,
+  value
+}) => {
+  if (!!value || value === 0 || value === false) {
+    return { [key]: value };
+  } else {
+    return {};
+  }
+};
+
+// Runware/async-retry.ts
+var asyncRetry = async (apiCall, options = {}) => {
+  var _a;
+  const { delayInSeconds = 1, callback } = options;
+  let maxRetries = (_a = options.maxRetries) != null ? _a : 1;
+  while (maxRetries) {
+    try {
+      const result = await apiCall();
+      return result;
+    } catch (error) {
+      callback == null ? void 0 : callback();
+      maxRetries--;
+      if (maxRetries > 0) {
+        await delay(delayInSeconds);
+        await asyncRetry(apiCall, __spreadProps(__spreadValues({}, options), { maxRetries }));
+      } else {
+        throw error;
+      }
+    }
+  }
+};
+
+// Runware/Runware-base.ts
+var RunwareBase = class {
+  constructor({ apiKey, url = BASE_RUNWARE_URLS.PRODUCTION }) {
+    this._listeners = [];
+    // _globalMessages: any[] = [];
+    this._globalMessages = {};
+    this._globalImages = [];
+    this.isWebsocketReadyState = () => {
+      var _a;
+      return ((_a = this._ws) == null ? void 0 : _a.readyState) === 1;
+    };
+    this.send = (msg) => this._ws.send(JSON.stringify(msg));
+    this.uploadImage = async (file) => {
+      try {
+        return await asyncRetry(async () => {
+          const taskUUID = getUUID();
+          if (typeof file === "string" && isValidUUID(file)) {
+            return {
+              newImageUUID: file,
+              newImageSrc: file,
+              taskUUID
+            };
+          }
+          const imageBase64 = typeof file === "string" ? file : await fileToBase64(file);
+          this.send({
+            newImageUpload: {
+              imageBase64,
+              taskUUID,
+              taskType: 7
+            }
+          });
+          const lis = this.globalListener({
+            responseKey: "newUploadedImageUUID",
+            taskKey: "newUploadedImageUUID",
+            taskUUID
+          });
+          const image = await getIntervalWithPromise(
+            ({ resolve, reject }) => {
+              const uploadedImage = this._globalMessages[taskUUID];
+              if (uploadedImage == null ? void 0 : uploadedImage.error) {
+                reject(uploadedImage);
+                return true;
+              }
+              if (uploadedImage) {
+                delete this._globalMessages[taskUUID];
+                resolve(uploadedImage);
+                return true;
+              }
+            },
+            { debugKey: "upload-image" }
+          );
+          lis.destroy();
+          return image;
+        });
+      } catch (e) {
+        throw e;
+      }
+    };
+    this.uploadUnprocessedImage = async ({
+      file,
+      preProcessorType,
+      width,
+      height,
+      lowThresholdCanny,
+      highThresholdCanny,
+      includeHandsAndFaceOpenPose = true
+    }) => {
+      try {
+        const image = await this.uploadImage(file);
+        if (!image)
+          return null;
+        const taskUUID = getUUID();
+        this.send({
+          newPreProcessControlNet: __spreadValues(__spreadValues({
+            taskUUID,
+            preProcessorType,
+            guideImageUUID: image.newImageUUID,
+            includeHandsAndFaceOpenPose
+          }, compact(lowThresholdCanny, { lowThresholdCanny })), compact(highThresholdCanny, { highThresholdCanny }))
+        });
+        const lis = this.globalListener({
+          responseKey: "newPreProcessControlNet",
+          taskKey: "newPreProcessControlNet",
+          taskUUID
+        });
+        const guideImage = await getIntervalWithPromise(
+          ({ resolve, reject }) => {
+            const uploadedImage = this._globalMessages[taskUUID];
+            if (uploadedImage == null ? void 0 : uploadedImage.error) {
+              reject(uploadedImage);
+              return true;
+            }
+            if (uploadedImage) {
+              delete this._globalMessages[taskUUID];
+              resolve(uploadedImage == null ? void 0 : uploadedImage.newPreProcessControlNet);
+              return true;
+            }
+          },
+          { debugKey: "unprocessed-image" }
+        );
+        lis.destroy();
+        return guideImage;
+      } catch (e) {
+        throw e;
+      }
+    };
+    this.requestImageToText = async ({
+      imageInitiator
+    }) => {
+      try {
+        await this.ensureConnection();
+        return await asyncRetry(async () => {
+          const imageUploaded = await this.uploadImage(
+            imageInitiator
+          );
+          if (!(imageUploaded == null ? void 0 : imageUploaded.newImageUUID))
+            return null;
+          const taskUUID = getUUID();
+          this.send({
+            newReverseImageClip: {
+              imageUUID: imageUploaded.newImageUUID,
+              taskUUID
+            }
+          });
+          const lis = this.globalListener({
+            responseKey: "newReverseClip",
+            taskKey: "newReverseClip.texts",
+            taskUUID
+          });
+          const response = await getIntervalWithPromise(
+            ({ resolve, reject }) => {
+              const newReverseClip = this._globalMessages[taskUUID];
+              if (newReverseClip == null ? void 0 : newReverseClip.error) {
+                reject(newReverseClip);
+                return true;
+              }
+              if (newReverseClip) {
+                delete this._globalMessages[taskUUID];
+                resolve(newReverseClip[0]);
+                return true;
+              }
+            },
+            { debugKey: "remove-image-background" }
+          );
+          lis.destroy();
+          return response;
+        });
+      } catch (e) {
+        throw e;
+      }
+    };
+    this.removeImageBackground = async ({
+      imageInitiator
+    }) => {
+      try {
+        await this.ensureConnection();
+        return await asyncRetry(async () => {
+          const imageUploaded = await this.uploadImage(
+            imageInitiator
+          );
+          if (!(imageUploaded == null ? void 0 : imageUploaded.newImageUUID))
+            return null;
+          const taskUUID = getUUID();
+          this.send({
+            newRemoveBackground: {
+              imageUUID: imageUploaded.newImageUUID,
+              taskUUID,
+              taskType: 8
+            }
+          });
+          const lis = this.globalListener({
+            responseKey: "newRemoveBackground",
+            taskKey: "newRemoveBackground.images",
+            taskUUID
+          });
+          const response = await getIntervalWithPromise(
+            ({ resolve, reject }) => {
+              const newRemoveBackground = this._globalMessages[taskUUID];
+              if (newRemoveBackground == null ? void 0 : newRemoveBackground.error) {
+                reject(newRemoveBackground);
+                return true;
+              }
+              if (newRemoveBackground) {
+                delete this._globalMessages[taskUUID];
+                resolve(newRemoveBackground);
+                return true;
+              }
+            },
+            { debugKey: "remove-image-background" }
+          );
+          lis.destroy();
+          return response;
+        });
+      } catch (e) {
+        throw e;
+      }
+    };
+    this.upscaleGan = async ({
+      imageInitiator,
+      upscaleFactor
+    }) => {
+      try {
+        await this.ensureConnection();
+        return await asyncRetry(async () => {
+          let imageUploaded;
+          imageUploaded = await this.uploadImage(imageInitiator);
+          if (!(imageUploaded == null ? void 0 : imageUploaded.newImageUUID))
+            return null;
+          const taskUUID = getUUID();
+          this.send({
+            newUpscaleGan: {
+              imageUUID: imageUploaded == null ? void 0 : imageUploaded.newImageUUID,
+              taskUUID,
+              upscaleFactor
+            }
+          });
+          const lis = this.globalListener({
+            responseKey: "newUpscaleGan",
+            taskKey: "newUpscaleGan.images",
+            taskUUID
+          });
+          const response = await getIntervalWithPromise(
+            ({ resolve, reject }) => {
+              const newUpscaleGan = this._globalMessages[taskUUID];
+              if (newUpscaleGan == null ? void 0 : newUpscaleGan.error) {
+                reject(newUpscaleGan);
+                return true;
+              }
+              if (newUpscaleGan) {
+                delete this._globalMessages[taskUUID];
+                resolve(newUpscaleGan);
+                return true;
+              }
+            },
+            { debugKey: "upscale-gan" }
+          );
+          lis.destroy();
+          return response;
+        });
+      } catch (e) {
+        throw e;
+      }
+    };
+    this.enhancePrompt = async ({
+      prompt,
+      promptMaxLength = 380,
+      promptLanguageId = 1,
+      promptVersions = 1
+    }) => {
+      try {
+        await this.ensureConnection();
+        return await asyncRetry(async () => {
+          const taskUUID = getUUID();
+          this.send({
+            newPromptEnhance: {
+              prompt,
+              taskUUID,
+              promptMaxLength,
+              promptVersions,
+              promptLanguageId
+            }
+          });
+          const lis = this.globalListener({
+            responseKey: "newPromptEnhancer",
+            taskKey: "newPromptEnhancer.texts",
+            taskUUID
+          });
+          const response = await getIntervalWithPromise(
+            ({ resolve, reject }) => {
+              const reducedPrompt = this._globalMessages[taskUUID];
+              if (reducedPrompt == null ? void 0 : reducedPrompt.error) {
+                reject(reducedPrompt);
+                return true;
+              }
+              if ((reducedPrompt == null ? void 0 : reducedPrompt.length) >= promptVersions) {
+                delete this._globalMessages[taskUUID];
+                resolve(reducedPrompt);
+                return true;
+              }
+            },
+            { debugKey: "enhance-prompt" }
+          );
+          lis.destroy();
+          return response;
+        });
+      } catch (e) {
+        throw e;
+      }
+    };
+    this.connected = () => this.isWebsocketReadyState() && !!this._connectionSessionUUID;
+    this._apiKey = apiKey;
+    this._url = url;
+    this._sdkType = "CLIENT" /* CLIENT */;
+  }
+  // protected addListener({
+  //   lis,
+  //   check,
+  // }: {
+  //   lis: (v: any) => any;
+  //   check: (v: any) => any;
+  //   groupKey?: string;
+  // }): { destroy: Function } {
+  //   this._ws.onmessage = (e: any) => {
+  //     const m = JSON.parse(e.data);
+  //     if (m?.error) {
+  //       lis(m);
+  //     } else if (check(m)) {
+  //       lis(m);
+  //     }
+  //   };
+  //   return {
+  //     destroy: () => {},
+  //   };
+  // }
+  addListener({
+    lis,
+    check,
+    groupKey
+  }) {
+    const listener = (msg) => {
+      if (msg == null ? void 0 : msg.error) {
+        lis(msg);
+      } else if (check(msg)) {
+        lis(msg);
+      }
+    };
+    const groupListener = { key: getUUID(), listener, groupKey };
+    this._listeners.push(groupListener);
+    const destroy = () => {
+      this._listeners = removeListener(this._listeners, groupListener);
+    };
+    return {
+      destroy
+    };
+  }
+  connect() {
+    this._ws.onopen = (e) => {
+      if (this._connectionSessionUUID) {
+        this.send({
+          newConnection: {
+            apiKey: this._apiKey,
+            connectionSessionUUID: this._connectionSessionUUID
+          }
+        });
+      } else {
+        this.send({ newConnection: { apiKey: this._apiKey } });
+      }
+      this.addListener({
+        check: (m) => {
+          var _a;
+          return (_a = m == null ? void 0 : m.newConnectionSessionUUID) == null ? void 0 : _a.connectionSessionUUID;
+        },
+        lis: (m) => {
+          var _a;
+          if (m == null ? void 0 : m.error) {
+            if (m.errorId === 19) {
+              this._invalidAPIkey = "Invalid API key";
+            }
+            return;
+          }
+          this._connectionSessionUUID = (_a = m == null ? void 0 : m.newConnectionSessionUUID) == null ? void 0 : _a.connectionSessionUUID;
+          this._invalidAPIkey = void 0;
+        }
+      });
+    };
+    this._ws.onmessage = (e) => {
+      var _a;
+      const data = JSON.parse(e.data);
+      for (const lis of this._listeners) {
+        const result = (_a = lis == null ? void 0 : lis.listener) == null ? void 0 : _a.call(lis, data);
+        if (result)
+          return;
+      }
+    };
+    this._ws.onclose = (e) => {
+      if (this._invalidAPIkey) {
+        console.error(this._invalidAPIkey);
+        return;
+      }
+    };
+  }
+  destroy(lis) {
+    removeFromAray(this._listeners, lis);
+  }
+  listenToImages({
+    onPartialImages,
+    taskUUID,
+    groupKey
+  }) {
+    return this.addListener({
+      check: (m) => {
+        var _a;
+        return (_a = m.newImages) == null ? void 0 : _a.images;
+      },
+      lis: (m) => {
+        var _a, _b, _c;
+        const images = (_b = (_a = m.newImages) == null ? void 0 : _a.images) == null ? void 0 : _b.filter(
+          (img) => img.taskUUID === taskUUID
+        );
+        onPartialImages == null ? void 0 : onPartialImages(images, (m == null ? void 0 : m.error) && m);
+        if (m.error) {
+          this._globalError = m;
+        } else {
+          if (this._sdkType === "CLIENT" /* CLIENT */) {
+            this._globalImages = [
+              ...this._globalImages,
+              ...(_c = m.newImages) == null ? void 0 : _c.images
+            ];
+          } else {
+            this._globalImages = [...this._globalImages, ...images];
+          }
+        }
+      },
+      groupKey
+    });
+  }
+  globalListener({
+    responseKey,
+    taskKey,
+    taskUUID
+  }) {
+    return this.addListener({
+      check: (m) => {
+        const value = accessDeepObject({
+          key: responseKey,
+          data: m,
+          useZero: false
+        });
+        return !!value;
+      },
+      lis: (m) => {
+        if (m.error) {
+          this._globalMessages[taskUUID] = m;
+          return;
+        }
+        const value = accessDeepObject({
+          key: taskKey,
+          data: m,
+          useZero: false
+        });
+        if (Array.isArray(value)) {
+          value.forEach((v) => {
+            var _a;
+            this._globalMessages[v.taskUUID] = [
+              ...(_a = this._globalMessages[v.taskUUID]) != null ? _a : [],
+              v
+            ];
+          });
+        } else {
+          this._globalMessages[value.taskUUID] = value;
+        }
+      }
+    });
+  }
+  async requestImages({
+    modelId,
+    positivePrompt,
+    imageSize,
+    negativePrompt,
+    numberOfImages = 1,
+    useCache = false,
+    imageInitiator,
+    controlNet,
+    imageMaskInitiator,
+    steps,
+    onPartialImages,
+    lora,
+    seed,
+    gScale,
+    checkNsfw
+  }) {
+    let lis = void 0;
+    let requestObject = void 0;
+    let taskUUIDs = [];
+    let retryCount = 0;
+    try {
+      await this.ensureConnection();
+      let imageInitiatorUUID = null;
+      let imageMaskInitiatorUUID = null;
+      let controlNetData = [];
+      if (imageInitiator) {
+        const uploadedImage = await this.uploadImage(imageInitiator);
+        if (!uploadedImage)
+          return [];
+        imageInitiatorUUID = uploadedImage.newImageUUID;
+      }
+      if (imageMaskInitiator) {
+        const uploadedMaskInitiator = await this.uploadImage(
+          imageMaskInitiator
+        );
+        if (!uploadedMaskInitiator)
+          return [];
+        imageMaskInitiatorUUID = uploadedMaskInitiator.newImageUUID;
+      }
+      if (controlNet == null ? void 0 : controlNet.length) {
+        for (let i = 0; i < controlNet.length; i++) {
+          const controlData = controlNet[i];
+          const anyControlData = controlData;
+          const {
+            endStep,
+            preprocessor,
+            startStep,
+            weight,
+            guideImage,
+            guideImageUnprocessed,
+            controlMode
+          } = controlData;
+          const getCannyObject = () => {
+            if (controlData.preprocessor === "canny") {
+              return {
+                lowThresholdCanny: anyControlData.lowThresholdCanny,
+                highThresholdCanny: anyControlData.highThresholdCanny
+              };
+            } else
+              return {};
+          };
+          const imageUploaded = await (guideImageUnprocessed ? this.uploadUnprocessedImage(__spreadValues({
+            file: guideImageUnprocessed,
+            preProcessorType: getPreprocessorType(
+              preprocessor
+            ),
+            includeHandsAndFaceOpenPose: anyControlData.includeHandsAndFaceOpenPose
+          }, getCannyObject())) : this.uploadImage(guideImage));
+          if (!imageUploaded)
+            return [];
+          controlNetData.push(__spreadValues({
+            guideImageUUID: imageUploaded.newImageUUID,
+            endStep,
+            preprocessor,
+            startStep,
+            weight,
+            controlMode: controlMode || "controlnet" /* CONTROL_NET */
+          }, getCannyObject()));
+        }
+      }
+      const prompt = `${positivePrompt} ${negativePrompt ? `-no ${negativePrompt}` : ""}`.trim();
+      gScale = gScale != null ? gScale : 7;
+      requestObject = __spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues({
+        offset: 0,
+        modelId,
+        promptText: prompt,
+        numberResults: numberOfImages,
+        sizeId: imageSize,
+        taskType: getTaskType({
+          prompt,
+          controlNet,
+          imageInitiator,
+          imageMaskInitiator
+        }),
+        useCache,
+        schedulerId: 22
+      }, evaluateNonTrue({ key: "checkNsfw", value: checkNsfw })), evaluateNonTrue({ key: "gScale", value: gScale })), evaluateNonTrue({ key: "steps", value: steps })), imageInitiatorUUID ? { imageInitiatorUUID } : {}), imageMaskInitiatorUUID ? { imageMaskInitiatorUUID } : {}), controlNetData.length ? { controlNet: controlNetData } : {}), (lora == null ? void 0 : lora.length) ? { lora } : {}), seed ? { seed } : {});
+      return await asyncRetry(
+        async () => {
+          retryCount++;
+          lis == null ? void 0 : lis.destroy();
+          const imagesWithSimilarTask = this._globalImages.filter(
+            (img) => taskUUIDs.includes(img.taskUUID)
+          );
+          const taskUUID = getUUID();
+          taskUUIDs.push(taskUUID);
+          const imageRemaining = numberOfImages - imagesWithSimilarTask.length;
+          const newRequestObject = {
+            newTask: __spreadProps(__spreadValues({}, requestObject), {
+              taskUUID,
+              numberResults: imageRemaining
+            })
+          };
+          this.send(newRequestObject);
+          lis = this.listenToImages({
+            onPartialImages,
+            taskUUID,
+            groupKey: "REQUEST_IMAGES" /* REQUEST_IMAGES */
+          });
+          const promise = await this.getSimililarImage({
+            taskUUID: taskUUIDs,
+            numberOfImages,
+            lis
+          });
+          return promise;
+        },
+        {
+          maxRetries: 2,
+          callback: () => {
+            lis == null ? void 0 : lis.destroy();
+          }
+        }
+      );
+    } catch (e) {
+      if (retryCount >= 2) {
+        return this.handleIncompleteImages({ taskUUIDs, error: e });
+      }
+    }
+  }
+  handleIncompleteImages({
+    taskUUIDs,
+    error
+  }) {
+    const imagesWithSimilarTask = this._globalImages.filter(
+      (img) => taskUUIDs.includes(img.taskUUID)
+    );
+    if (imagesWithSimilarTask.length > 1) {
+      this._globalImages = this._globalImages.filter(
+        (img) => !taskUUIDs.includes(img.taskUUID)
+      );
+      return imagesWithSimilarTask;
+    } else {
+      throw error;
+    }
+  }
+  async ensureConnection() {
+    var _a;
+    let isConnected = this.connected() && this._ws.readyState === 1;
+    try {
+      if (this._invalidAPIkey)
+        throw this._invalidAPIkey;
+      if (!isConnected) {
+        this.connect();
+        await delay(2);
+      }
+    } catch (e) {
+      throw (_a = this._invalidAPIkey) != null ? _a : "Could not connect to server. Ensure your API key is correct";
+    }
+  }
+  async getSimililarImage({
+    taskUUID,
+    numberOfImages,
+    shouldThrowError,
+    lis
+  }) {
+    return await getIntervalWithPromise(
+      ({ resolve, reject, intervalId }) => {
+        const taskUUIDs = Array.isArray(taskUUID) ? taskUUID : [taskUUID];
+        const imagesWithSimilarTask = this._globalImages.filter(
+          (img) => taskUUIDs.includes(img.taskUUID)
+        );
+        if (this._globalError) {
+          const newData = this._globalError;
+          this._globalError = void 0;
+          clearInterval(intervalId);
+          reject == null ? void 0 : reject(newData);
+          return true;
+        } else if (imagesWithSimilarTask.length >= numberOfImages) {
+          clearInterval(intervalId);
+          this._globalImages = this._globalImages.filter(
+            (img) => !taskUUIDs.includes(img.taskUUID)
+          );
+          resolve(
+            [...imagesWithSimilarTask].slice(0, numberOfImages)
+          );
+          return true;
+        }
+      },
+      { debugKey: "getting images", shouldThrowError }
+    );
+  }
+  //end of data
+};
+
+// Runware/Runware.ts
+var import_reconnect = __toESM(require_reconnect());
+var Runware = class extends RunwareBase {
+  constructor({ apiKey, url }) {
+    super({ apiKey, url });
+    if (apiKey) {
+      this._ws = new import_reconnect.default(
+        this._url
+      );
+      this.connect();
+    }
+  }
+};
+
+// Runware/Runware-server.ts
+import WebSocket2 from "ws";
+var RunwareServer = class extends RunwareBase {
+  constructor({ apiKey, url }) {
+    super({ apiKey, url });
+    this._instantiated = false;
+    this._listeners = [];
+    this._reconnectingIntervalId = null;
+    this.send = (msg) => {
+      this._ws.send(JSON.stringify(msg));
+    };
+    this._sdkType = "SERVER" /* SERVER */;
+    if (apiKey) {
+      this.connect();
+    }
+  }
+  // protected addListener({
+  //   lis,
+  //   check,
+  //   groupKey,
+  // }: {
+  //   lis: (v: any) => any;
+  //   check: (v: any) => any;
+  //   groupKey?: string;
+  // }) {
+  //   const listener = (msg: any) => {
+  //     if (msg?.error) {
+  //       lis(msg);
+  //     } else if (check(msg)) {
+  //       lis(msg);
+  //     }
+  //   };
+  //   const groupListener = { key: getUUID(), listener, groupKey };
+  //   this._listeners.push(groupListener);
+  //   const destroy = () => {
+  //     this._listeners = removeListener(this._listeners, groupListener);
+  //   };
+  //   return {
+  //     destroy,
+  //   };
+  // }
+  async connect() {
+    if (!this._url)
+      return;
+    this._ws = new WebSocket2(this._url, {
+      perMessageDeflate: false
+    });
+    delay(1);
+    this._ws.on("error", () => {
+    });
+    this._ws.on("close", () => this.handleClose());
+    this._ws.on("open", () => {
+      var _a;
+      if (this._reconnectingIntervalId) {
+        clearInterval(this._reconnectingIntervalId);
+      }
+      if (this._connectionSessionUUID && this.isWebsocketReadyState()) {
+        this.send({
+          newConnection: {
+            apiKey: this._apiKey,
+            connectionSessionUUID: this._connectionSessionUUID
+          }
+        });
+      } else {
+        if (this.isWebsocketReadyState()) {
+          this.send({ newConnection: { apiKey: this._apiKey } });
+        }
+      }
+      this.addListener({
+        check: (m) => {
+          var _a2;
+          return (_a2 = m == null ? void 0 : m.newConnectionSessionUUID) == null ? void 0 : _a2.connectionSessionUUID;
+        },
+        lis: (m) => {
+          var _a2;
+          if (m == null ? void 0 : m.error) {
+            if (m.errorId === 19) {
+              this._invalidAPIkey = "Invalid API key";
+            } else {
+              this._invalidAPIkey = "Error connection ";
+            }
+            return;
+          }
+          this._connectionSessionUUID = (_a2 = m == null ? void 0 : m.newConnectionSessionUUID) == null ? void 0 : _a2.connectionSessionUUID;
+          this._invalidAPIkey = void 0;
+          this.heartBeat();
+        }
+      });
+      (_a = this._pongListener) == null ? void 0 : _a.destroy();
+      this._pongListener = this.addListener({
+        check: (m) => m == null ? void 0 : m.pong,
+        lis: (m) => {
+          if (m.pong) {
+            this.heartBeat();
+          }
+        }
+      });
+    });
+    this._ws.on("message", (e, isBinary) => {
+      const data = isBinary ? e : e == null ? void 0 : e.toString();
+      if (!data)
+        return;
+      const m = JSON.parse(data);
+      this._listeners.forEach((lis) => {
+        const result = lis.listener(m);
+        if (result) {
+          return;
+        }
+      });
+    });
+  }
+  handleClose() {
+    if (this._invalidAPIkey) {
+      console.error(this._invalidAPIkey);
+      return;
+    }
+    if (this._reconnectingIntervalId) {
+      clearInterval(this._reconnectingIntervalId);
+    }
+    this._reconnectingIntervalId = setInterval(() => this.connect(), 1e3);
+  }
+  heartBeat() {
+    clearTimeout(this._pingTimeout);
+    this._pingTimeout = setTimeout(() => {
+      if (this.isWebsocketReadyState()) {
+        this.send({ ping: true });
+      }
+    }, 5e3);
+  }
+  //end of data
+};
+export {
+  EControlMode,
+  EOpenPosePreProcessor,
+  EPreProcessor,
+  EPreProcessorGroup,
+  Environment,
+  Runware,
+  RunwareServer,
+  SdkType
+};