@wandelbots/nova-js 1.17.1-pr.feat-added-v2-client.64.9ac2247

package/dist/lib/v1/index.js

@@ -0,0 +1,3662 @@
+import {
+  AutoReconnectingWebsocket,
+  __async,
+  __spreadProps,
+  __spreadValues,
+  availableStorage,
+  isSameCoordinateSystem,
+  loginWithAuth0,
+  tryParseJson
+} from "../../chunk-V3NJLR6P.js";
+
+// src/lib/v1/index.ts
+export * from "@wandelbots/nova-api/v1";
+
+// src/lib/v1/ConnectedMotionGroup.ts
+import { makeAutoObservable, runInAction } from "mobx";
+import * as THREE from "three";
+
+// src/lib/v1/motionStateUpdate.ts
+function jointValuesEqual(oldJointValues, newJointValues, changeDeltaThreshold) {
+  if (newJointValues.length !== oldJointValues.length) {
+    return true;
+  }
+  for (let jointIndex = 0; jointIndex < newJointValues.length; jointIndex++) {
+    if (Math.abs(newJointValues[jointIndex] - oldJointValues[jointIndex]) > changeDeltaThreshold) {
+      return false;
+    }
+  }
+  return true;
+}
+function tcpPoseEqual(oldTcp, newTcp, changeDeltaThreshold) {
+  if (oldTcp === void 0 && newTcp || oldTcp && newTcp === void 0) {
+    return false;
+  }
+  if (oldTcp === void 0 || newTcp === void 0) {
+    return true;
+  }
+  let changedDelta = 0;
+  changedDelta += Math.abs(oldTcp.orientation.x - newTcp.orientation.x);
+  changedDelta += Math.abs(oldTcp.orientation.y - newTcp.orientation.y);
+  changedDelta += Math.abs(oldTcp.orientation.z - newTcp.orientation.z);
+  changedDelta += Math.abs(oldTcp.position.x - newTcp.position.x);
+  changedDelta += Math.abs(oldTcp.position.y - newTcp.position.y);
+  changedDelta += Math.abs(oldTcp.position.z - newTcp.position.z);
+  if (changedDelta > changeDeltaThreshold) {
+    return false;
+  }
+  return oldTcp.coordinate_system === newTcp.coordinate_system && oldTcp.tcp === newTcp.tcp;
+}
+
+// src/lib/v1/ConnectedMotionGroup.ts
+var MOTION_DELTA_THRESHOLD = 1e-4;
+var ConnectedMotionGroup = class _ConnectedMotionGroup {
+  constructor(nova, controller, motionGroup, initialMotionState, motionStateSocket, isVirtual, tcps, motionGroupSpecification, safetySetup, mounting, initialControllerState, controllerStateSocket) {
+    this.nova = nova;
+    this.controller = controller;
+    this.motionGroup = motionGroup;
+    this.initialMotionState = initialMotionState;
+    this.motionStateSocket = motionStateSocket;
+    this.isVirtual = isVirtual;
+    this.tcps = tcps;
+    this.motionGroupSpecification = motionGroupSpecification;
+    this.safetySetup = safetySetup;
+    this.mounting = mounting;
+    this.initialControllerState = initialControllerState;
+    this.controllerStateSocket = controllerStateSocket;
+    this.connectedJoggingCartesianSocket = null;
+    this.connectedJoggingJointsSocket = null;
+    // tmp
+    this.joggingVelocity = 10;
+    /**
+     * Reflects activation state of the motion group / robot servos. The
+     * movement controls in the UI should only be enabled in the "active" state
+     */
+    this.activationState = "inactive";
+    this.rapidlyChangingMotionState = initialMotionState;
+    this.controllerState = initialControllerState;
+    controllerStateSocket.addEventListener("message", (event) => {
+      var _a;
+      const data = (_a = tryParseJson(event.data)) == null ? void 0 : _a.result;
+      if (!data) {
+        return;
+      }
+      runInAction(() => {
+        this.controllerState = data;
+      });
+    });
+    motionStateSocket.addEventListener("message", (event) => {
+      var _a;
+      const motionStateResponse = (_a = tryParseJson(event.data)) == null ? void 0 : _a.result;
+      if (!motionStateResponse) {
+        throw new Error(
+          `Failed to get motion state for ${this.motionGroupId}: ${event.data}`
+        );
+      }
+      if (!jointValuesEqual(
+        this.rapidlyChangingMotionState.state.joint_position.joints,
+        motionStateResponse.state.joint_position.joints,
+        MOTION_DELTA_THRESHOLD
+      )) {
+        runInAction(() => {
+          this.rapidlyChangingMotionState.state = motionStateResponse.state;
+        });
+      }
+      if (!tcpPoseEqual(
+        this.rapidlyChangingMotionState.tcp_pose,
+        motionStateResponse.tcp_pose,
+        MOTION_DELTA_THRESHOLD
+      )) {
+        runInAction(() => {
+          this.rapidlyChangingMotionState.tcp_pose = motionStateResponse.tcp_pose;
+        });
+      }
+    });
+    makeAutoObservable(this);
+  }
+  static connect(nova, motionGroupId, controllers) {
+    return __async(this, null, function* () {
+      var _a, _b;
+      const [_motionGroupIndex, controllerId] = motionGroupId.split("@");
+      const controller = controllers.find((c) => c.controller === controllerId);
+      const motionGroup = controller == null ? void 0 : controller.physical_motion_groups.find(
+        (mg) => mg.motion_group === motionGroupId
+      );
+      if (!controller || !motionGroup) {
+        throw new Error(
+          `Controller ${controllerId} or motion group ${motionGroupId} not found`
+        );
+      }
+      const motionStateSocket = nova.openReconnectingWebsocket(
+        `/motion-groups/${motionGroupId}/state-stream`
+      );
+      const firstMessage = yield motionStateSocket.firstMessage();
+      const initialMotionState = (_a = tryParseJson(firstMessage.data)) == null ? void 0 : _a.result;
+      if (!initialMotionState) {
+        throw new Error(
+          `Unable to parse initial motion state message ${firstMessage.data}`
+        );
+      }
+      console.log(
+        `Connected motion state websocket to motion group ${motionGroup.motion_group}. Initial state:
+  `,
+        initialMotionState
+      );
+      const config = yield nova.api.controller.getRobotController(
+        controller.controller
+      );
+      const isVirtual = config.configuration.kind === "VirtualController";
+      const mounting = yield (() => __async(this, null, function* () {
+        try {
+          const mounting2 = yield nova.api.motionGroupInfos.getMounting(
+            motionGroup.motion_group
+          );
+          return mounting2;
+        } catch (err) {
+          console.error(
+            `Error fetching mounting for ${motionGroup.motion_group}`,
+            err
+          );
+          return null;
+        }
+      }))();
+      const controllerStateSocket = nova.openReconnectingWebsocket(
+        `/controllers/${controller.controller}/state-stream?response_rate=1000`
+      );
+      const firstControllerMessage = yield controllerStateSocket.firstMessage();
+      const initialControllerState = (_b = tryParseJson(firstControllerMessage.data)) == null ? void 0 : _b.result;
+      if (!initialControllerState) {
+        throw new Error(
+          `Unable to parse initial controller state message ${firstControllerMessage.data}`
+        );
+      }
+      console.log(
+        `Connected controller state websocket to controller ${controller.controller}. Initial state:
+  `,
+        initialControllerState
+      );
+      const { tcps } = yield nova.api.motionGroupInfos.listTcps(motionGroupId);
+      const motionGroupSpecification = yield nova.api.motionGroupInfos.getMotionGroupSpecification(motionGroupId);
+      const safetySetup = yield nova.api.motionGroupInfos.getSafetySetup(motionGroupId);
+      return new _ConnectedMotionGroup(
+        nova,
+        controller,
+        motionGroup,
+        initialMotionState,
+        motionStateSocket,
+        isVirtual,
+        tcps,
+        motionGroupSpecification,
+        safetySetup,
+        mounting,
+        initialControllerState,
+        controllerStateSocket
+      );
+    });
+  }
+  get motionGroupId() {
+    return this.motionGroup.motion_group;
+  }
+  get controllerId() {
+    return this.controller.controller;
+  }
+  get modelFromController() {
+    return this.motionGroup.model_from_controller;
+  }
+  get wandelscriptIdentifier() {
+    const num = this.motionGroupId.split("@")[0];
+    return `${this.controllerId.replaceAll("-", "_")}_${num}`;
+  }
+  /** Jogging velocity in radians for rotation and joint movement */
+  get joggingVelocityRads() {
+    return this.joggingVelocity * Math.PI / 180;
+  }
+  get joints() {
+    return this.initialMotionState.state.joint_position.joints.map((_, i) => {
+      return {
+        index: i
+      };
+    });
+  }
+  get dhParameters() {
+    return this.motionGroupSpecification.dh_parameters;
+  }
+  get safetyZones() {
+    return this.safetySetup.safety_zones;
+  }
+  /** Gets the robot mounting position offset in 3D viz coordinates */
+  get mountingPosition() {
+    if (!this.mounting) {
+      return [0, 0, 0];
+    }
+    return [
+      this.mounting.pose.position.x / 1e3,
+      this.mounting.pose.position.y / 1e3,
+      this.mounting.pose.position.z / 1e3
+    ];
+  }
+  /** Gets the robot mounting position rotation in 3D viz coordinates */
+  get mountingQuaternion() {
+    var _a, _b, _c, _d, _e, _f;
+    const rotationVector = new THREE.Vector3(
+      ((_b = (_a = this.mounting) == null ? void 0 : _a.pose.orientation) == null ? void 0 : _b.x) || 0,
+      ((_d = (_c = this.mounting) == null ? void 0 : _c.pose.orientation) == null ? void 0 : _d.y) || 0,
+      ((_f = (_e = this.mounting) == null ? void 0 : _e.pose.orientation) == null ? void 0 : _f.z) || 0
+    );
+    const magnitude = rotationVector.length();
+    const axis = rotationVector.normalize();
+    return new THREE.Quaternion().setFromAxisAngle(axis, magnitude);
+  }
+  /**
+   * Whether the controller is currently in a safety state
+   * corresponding to an emergency stop
+   */
+  get isEstopActive() {
+    const estopStates = [
+      "SAFETY_STATE_ROBOT_EMERGENCY_STOP",
+      "SAFETY_STATE_DEVICE_EMERGENCY_STOP"
+    ];
+    return estopStates.includes(this.controllerState.safety_state);
+  }
+  /**
+   * Whether the controller is in a safety state
+   * that may be non-functional for robot pad purposes
+   */
+  get isMoveableSafetyState() {
+    const goodSafetyStates = [
+      "SAFETY_STATE_NORMAL",
+      "SAFETY_STATE_REDUCED"
+    ];
+    return goodSafetyStates.includes(this.controllerState.safety_state);
+  }
+  /**
+   * Whether the controller is in an operation mode that allows movement
+   */
+  get isMoveableOperationMode() {
+    const goodOperationModes = [
+      "OPERATION_MODE_AUTO",
+      "OPERATION_MODE_MANUAL",
+      "OPERATION_MODE_MANUAL_T1",
+      "OPERATION_MODE_MANUAL_T2"
+    ];
+    return goodOperationModes.includes(this.controllerState.operation_mode);
+  }
+  /**
+   * Whether the robot is currently active and can be moved, based on the
+   * safety state, operation mode and servo toggle activation state.
+   */
+  get canBeMoved() {
+    return this.isMoveableSafetyState && this.isMoveableOperationMode && this.activationState === "active";
+  }
+  deactivate() {
+    return __async(this, null, function* () {
+      if (this.activationState !== "active") {
+        console.error("Tried to deactivate while already deactivating");
+        return;
+      }
+      runInAction(() => {
+        this.activationState = "deactivating";
+      });
+      try {
+        yield this.nova.api.controller.setDefaultMode(
+          this.controllerId,
+          "MODE_MONITOR"
+        );
+        runInAction(() => {
+          this.activationState = "inactive";
+        });
+      } catch (err) {
+        runInAction(() => {
+          this.activationState = "active";
+        });
+        throw err;
+      }
+    });
+  }
+  activate() {
+    return __async(this, null, function* () {
+      if (this.activationState !== "inactive") {
+        console.error("Tried to activate while already activating");
+        return;
+      }
+      runInAction(() => {
+        this.activationState = "activating";
+      });
+      try {
+        yield this.nova.api.controller.setDefaultMode(
+          this.controllerId,
+          "MODE_CONTROL"
+        );
+        runInAction(() => {
+          this.activationState = "active";
+        });
+      } catch (err) {
+        runInAction(() => {
+          this.activationState = "inactive";
+        });
+        throw err;
+      }
+    });
+  }
+  toggleActivation() {
+    if (this.activationState === "inactive") {
+      this.activate();
+    } else if (this.activationState === "active") {
+      this.deactivate();
+    }
+  }
+  dispose() {
+    this.motionStateSocket.close();
+    if (this.connectedJoggingCartesianSocket)
+      this.connectedJoggingCartesianSocket.close();
+    if (this.connectedJoggingJointsSocket)
+      this.connectedJoggingJointsSocket.close();
+  }
+  setJoggingVelocity(velocity) {
+    this.joggingVelocity = velocity;
+  }
+};
+
+// src/lib/v1/getLatestTrajectories.ts
+var lastMotionIds = /* @__PURE__ */ new Set();
+function getLatestTrajectories(apiClient, sampleTime = 50, responsesCoordinateSystem) {
+  return __async(this, null, function* () {
+    const newTrajectories = [];
+    try {
+      const motions = yield apiClient.motion.listMotions();
+      const currentMotionIds = new Set(motions.motions);
+      const newMotionIds = Array.from(currentMotionIds).filter(
+        (id) => !lastMotionIds.has(id)
+      );
+      for (const motionId of newMotionIds) {
+        const trajectory = yield apiClient.motion.getMotionTrajectory(
+          motionId,
+          sampleTime,
+          responsesCoordinateSystem
+        );
+        newTrajectories.push(trajectory);
+      }
+      lastMotionIds = currentMotionIds;
+    } catch (error) {
+      console.error("Failed to get latest trajectories:", error);
+    }
+    return newTrajectories;
+  });
+}
+
+// node_modules/lodash-es/_listCacheClear.js
+function listCacheClear() {
+  this.__data__ = [];
+  this.size = 0;
+}
+var listCacheClear_default = listCacheClear;
+
+// node_modules/lodash-es/eq.js
+function eq(value, other) {
+  return value === other || value !== value && other !== other;
+}
+var eq_default = eq;
+
+// node_modules/lodash-es/_assocIndexOf.js
+function assocIndexOf(array, key) {
+  var length = array.length;
+  while (length--) {
+    if (eq_default(array[length][0], key)) {
+      return length;
+    }
+  }
+  return -1;
+}
+var assocIndexOf_default = assocIndexOf;
+
+// node_modules/lodash-es/_listCacheDelete.js
+var arrayProto = Array.prototype;
+var splice = arrayProto.splice;
+function listCacheDelete(key) {
+  var data = this.__data__, index = assocIndexOf_default(data, key);
+  if (index < 0) {
+    return false;
+  }
+  var lastIndex = data.length - 1;
+  if (index == lastIndex) {
+    data.pop();
+  } else {
+    splice.call(data, index, 1);
+  }
+  --this.size;
+  return true;
+}
+var listCacheDelete_default = listCacheDelete;
+
+// node_modules/lodash-es/_listCacheGet.js
+function listCacheGet(key) {
+  var data = this.__data__, index = assocIndexOf_default(data, key);
+  return index < 0 ? void 0 : data[index][1];
+}
+var listCacheGet_default = listCacheGet;
+
+// node_modules/lodash-es/_listCacheHas.js
+function listCacheHas(key) {
+  return assocIndexOf_default(this.__data__, key) > -1;
+}
+var listCacheHas_default = listCacheHas;
+
+// node_modules/lodash-es/_listCacheSet.js
+function listCacheSet(key, value) {
+  var data = this.__data__, index = assocIndexOf_default(data, key);
+  if (index < 0) {
+    ++this.size;
+    data.push([key, value]);
+  } else {
+    data[index][1] = value;
+  }
+  return this;
+}
+var listCacheSet_default = listCacheSet;
+
+// node_modules/lodash-es/_ListCache.js
+function ListCache(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+ListCache.prototype.clear = listCacheClear_default;
+ListCache.prototype["delete"] = listCacheDelete_default;
+ListCache.prototype.get = listCacheGet_default;
+ListCache.prototype.has = listCacheHas_default;
+ListCache.prototype.set = listCacheSet_default;
+var ListCache_default = ListCache;
+
+// node_modules/lodash-es/_stackClear.js
+function stackClear() {
+  this.__data__ = new ListCache_default();
+  this.size = 0;
+}
+var stackClear_default = stackClear;
+
+// node_modules/lodash-es/_stackDelete.js
+function stackDelete(key) {
+  var data = this.__data__, result = data["delete"](key);
+  this.size = data.size;
+  return result;
+}
+var stackDelete_default = stackDelete;
+
+// node_modules/lodash-es/_stackGet.js
+function stackGet(key) {
+  return this.__data__.get(key);
+}
+var stackGet_default = stackGet;
+
+// node_modules/lodash-es/_stackHas.js
+function stackHas(key) {
+  return this.__data__.has(key);
+}
+var stackHas_default = stackHas;
+
+// node_modules/lodash-es/_freeGlobal.js
+var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
+var freeGlobal_default = freeGlobal;
+
+// node_modules/lodash-es/_root.js
+var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+var root = freeGlobal_default || freeSelf || Function("return this")();
+var root_default = root;
+
+// node_modules/lodash-es/_Symbol.js
+var Symbol = root_default.Symbol;
+var Symbol_default = Symbol;
+
+// node_modules/lodash-es/_getRawTag.js
+var objectProto = Object.prototype;
+var hasOwnProperty = objectProto.hasOwnProperty;
+var nativeObjectToString = objectProto.toString;
+var symToStringTag = Symbol_default ? Symbol_default.toStringTag : void 0;
+function getRawTag(value) {
+  var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
+  try {
+    value[symToStringTag] = void 0;
+    var unmasked = true;
+  } catch (e) {
+  }
+  var result = nativeObjectToString.call(value);
+  if (unmasked) {
+    if (isOwn) {
+      value[symToStringTag] = tag;
+    } else {
+      delete value[symToStringTag];
+    }
+  }
+  return result;
+}
+var getRawTag_default = getRawTag;
+
+// node_modules/lodash-es/_objectToString.js
+var objectProto2 = Object.prototype;
+var nativeObjectToString2 = objectProto2.toString;
+function objectToString(value) {
+  return nativeObjectToString2.call(value);
+}
+var objectToString_default = objectToString;
+
+// node_modules/lodash-es/_baseGetTag.js
+var nullTag = "[object Null]";
+var undefinedTag = "[object Undefined]";
+var symToStringTag2 = Symbol_default ? Symbol_default.toStringTag : void 0;
+function baseGetTag(value) {
+  if (value == null) {
+    return value === void 0 ? undefinedTag : nullTag;
+  }
+  return symToStringTag2 && symToStringTag2 in Object(value) ? getRawTag_default(value) : objectToString_default(value);
+}
+var baseGetTag_default = baseGetTag;
+
+// node_modules/lodash-es/isObject.js
+function isObject(value) {
+  var type = typeof value;
+  return value != null && (type == "object" || type == "function");
+}
+var isObject_default = isObject;
+
+// node_modules/lodash-es/isFunction.js
+var asyncTag = "[object AsyncFunction]";
+var funcTag = "[object Function]";
+var genTag = "[object GeneratorFunction]";
+var proxyTag = "[object Proxy]";
+function isFunction(value) {
+  if (!isObject_default(value)) {
+    return false;
+  }
+  var tag = baseGetTag_default(value);
+  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
+}
+var isFunction_default = isFunction;
+
+// node_modules/lodash-es/_coreJsData.js
+var coreJsData = root_default["__core-js_shared__"];
+var coreJsData_default = coreJsData;
+
+// node_modules/lodash-es/_isMasked.js
+var maskSrcKey = function() {
+  var uid = /[^.]+$/.exec(coreJsData_default && coreJsData_default.keys && coreJsData_default.keys.IE_PROTO || "");
+  return uid ? "Symbol(src)_1." + uid : "";
+}();
+function isMasked(func) {
+  return !!maskSrcKey && maskSrcKey in func;
+}
+var isMasked_default = isMasked;
+
+// node_modules/lodash-es/_toSource.js
+var funcProto = Function.prototype;
+var funcToString = funcProto.toString;
+function toSource(func) {
+  if (func != null) {
+    try {
+      return funcToString.call(func);
+    } catch (e) {
+    }
+    try {
+      return func + "";
+    } catch (e) {
+    }
+  }
+  return "";
+}
+var toSource_default = toSource;
+
+// node_modules/lodash-es/_baseIsNative.js
+var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+var reIsHostCtor = /^\[object .+?Constructor\]$/;
+var funcProto2 = Function.prototype;
+var objectProto3 = Object.prototype;
+var funcToString2 = funcProto2.toString;
+var hasOwnProperty2 = objectProto3.hasOwnProperty;
+var reIsNative = RegExp(
+  "^" + funcToString2.call(hasOwnProperty2).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
+);
+function baseIsNative(value) {
+  if (!isObject_default(value) || isMasked_default(value)) {
+    return false;
+  }
+  var pattern = isFunction_default(value) ? reIsNative : reIsHostCtor;
+  return pattern.test(toSource_default(value));
+}
+var baseIsNative_default = baseIsNative;
+
+// node_modules/lodash-es/_getValue.js
+function getValue(object, key) {
+  return object == null ? void 0 : object[key];
+}
+var getValue_default = getValue;
+
+// node_modules/lodash-es/_getNative.js
+function getNative(object, key) {
+  var value = getValue_default(object, key);
+  return baseIsNative_default(value) ? value : void 0;
+}
+var getNative_default = getNative;
+
+// node_modules/lodash-es/_Map.js
+var Map = getNative_default(root_default, "Map");
+var Map_default = Map;
+
+// node_modules/lodash-es/_nativeCreate.js
+var nativeCreate = getNative_default(Object, "create");
+var nativeCreate_default = nativeCreate;
+
+// node_modules/lodash-es/_hashClear.js
+function hashClear() {
+  this.__data__ = nativeCreate_default ? nativeCreate_default(null) : {};
+  this.size = 0;
+}
+var hashClear_default = hashClear;
+
+// node_modules/lodash-es/_hashDelete.js
+function hashDelete(key) {
+  var result = this.has(key) && delete this.__data__[key];
+  this.size -= result ? 1 : 0;
+  return result;
+}
+var hashDelete_default = hashDelete;
+
+// node_modules/lodash-es/_hashGet.js
+var HASH_UNDEFINED = "__lodash_hash_undefined__";
+var objectProto4 = Object.prototype;
+var hasOwnProperty3 = objectProto4.hasOwnProperty;
+function hashGet(key) {
+  var data = this.__data__;
+  if (nativeCreate_default) {
+    var result = data[key];
+    return result === HASH_UNDEFINED ? void 0 : result;
+  }
+  return hasOwnProperty3.call(data, key) ? data[key] : void 0;
+}
+var hashGet_default = hashGet;
+
+// node_modules/lodash-es/_hashHas.js
+var objectProto5 = Object.prototype;
+var hasOwnProperty4 = objectProto5.hasOwnProperty;
+function hashHas(key) {
+  var data = this.__data__;
+  return nativeCreate_default ? data[key] !== void 0 : hasOwnProperty4.call(data, key);
+}
+var hashHas_default = hashHas;
+
+// node_modules/lodash-es/_hashSet.js
+var HASH_UNDEFINED2 = "__lodash_hash_undefined__";
+function hashSet(key, value) {
+  var data = this.__data__;
+  this.size += this.has(key) ? 0 : 1;
+  data[key] = nativeCreate_default && value === void 0 ? HASH_UNDEFINED2 : value;
+  return this;
+}
+var hashSet_default = hashSet;
+
+// node_modules/lodash-es/_Hash.js
+function Hash(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+Hash.prototype.clear = hashClear_default;
+Hash.prototype["delete"] = hashDelete_default;
+Hash.prototype.get = hashGet_default;
+Hash.prototype.has = hashHas_default;
+Hash.prototype.set = hashSet_default;
+var Hash_default = Hash;
+
+// node_modules/lodash-es/_mapCacheClear.js
+function mapCacheClear() {
+  this.size = 0;
+  this.__data__ = {
+    "hash": new Hash_default(),
+    "map": new (Map_default || ListCache_default)(),
+    "string": new Hash_default()
+  };
+}
+var mapCacheClear_default = mapCacheClear;
+
+// node_modules/lodash-es/_isKeyable.js
+function isKeyable(value) {
+  var type = typeof value;
+  return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
+}
+var isKeyable_default = isKeyable;
+
+// node_modules/lodash-es/_getMapData.js
+function getMapData(map, key) {
+  var data = map.__data__;
+  return isKeyable_default(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
+}
+var getMapData_default = getMapData;
+
+// node_modules/lodash-es/_mapCacheDelete.js
+function mapCacheDelete(key) {
+  var result = getMapData_default(this, key)["delete"](key);
+  this.size -= result ? 1 : 0;
+  return result;
+}
+var mapCacheDelete_default = mapCacheDelete;
+
+// node_modules/lodash-es/_mapCacheGet.js
+function mapCacheGet(key) {
+  return getMapData_default(this, key).get(key);
+}
+var mapCacheGet_default = mapCacheGet;
+
+// node_modules/lodash-es/_mapCacheHas.js
+function mapCacheHas(key) {
+  return getMapData_default(this, key).has(key);
+}
+var mapCacheHas_default = mapCacheHas;
+
+// node_modules/lodash-es/_mapCacheSet.js
+function mapCacheSet(key, value) {
+  var data = getMapData_default(this, key), size = data.size;
+  data.set(key, value);
+  this.size += data.size == size ? 0 : 1;
+  return this;
+}
+var mapCacheSet_default = mapCacheSet;
+
+// node_modules/lodash-es/_MapCache.js
+function MapCache(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+MapCache.prototype.clear = mapCacheClear_default;
+MapCache.prototype["delete"] = mapCacheDelete_default;
+MapCache.prototype.get = mapCacheGet_default;
+MapCache.prototype.has = mapCacheHas_default;
+MapCache.prototype.set = mapCacheSet_default;
+var MapCache_default = MapCache;
+
+// node_modules/lodash-es/_stackSet.js
+var LARGE_ARRAY_SIZE = 200;
+function stackSet(key, value) {
+  var data = this.__data__;
+  if (data instanceof ListCache_default) {
+    var pairs = data.__data__;
+    if (!Map_default || pairs.length < LARGE_ARRAY_SIZE - 1) {
+      pairs.push([key, value]);
+      this.size = ++data.size;
+      return this;
+    }
+    data = this.__data__ = new MapCache_default(pairs);
+  }
+  data.set(key, value);
+  this.size = data.size;
+  return this;
+}
+var stackSet_default = stackSet;
+
+// node_modules/lodash-es/_Stack.js
+function Stack(entries) {
+  var data = this.__data__ = new ListCache_default(entries);
+  this.size = data.size;
+}
+Stack.prototype.clear = stackClear_default;
+Stack.prototype["delete"] = stackDelete_default;
+Stack.prototype.get = stackGet_default;
+Stack.prototype.has = stackHas_default;
+Stack.prototype.set = stackSet_default;
+var Stack_default = Stack;
+
+// node_modules/lodash-es/_setCacheAdd.js
+var HASH_UNDEFINED3 = "__lodash_hash_undefined__";
+function setCacheAdd(value) {
+  this.__data__.set(value, HASH_UNDEFINED3);
+  return this;
+}
+var setCacheAdd_default = setCacheAdd;
+
+// node_modules/lodash-es/_setCacheHas.js
+function setCacheHas(value) {
+  return this.__data__.has(value);
+}
+var setCacheHas_default = setCacheHas;
+
+// node_modules/lodash-es/_SetCache.js
+function SetCache(values) {
+  var index = -1, length = values == null ? 0 : values.length;
+  this.__data__ = new MapCache_default();
+  while (++index < length) {
+    this.add(values[index]);
+  }
+}
+SetCache.prototype.add = SetCache.prototype.push = setCacheAdd_default;
+SetCache.prototype.has = setCacheHas_default;
+var SetCache_default = SetCache;
+
+// node_modules/lodash-es/_arraySome.js
+function arraySome(array, predicate) {
+  var index = -1, length = array == null ? 0 : array.length;
+  while (++index < length) {
+    if (predicate(array[index], index, array)) {
+      return true;
+    }
+  }
+  return false;
+}
+var arraySome_default = arraySome;
+
+// node_modules/lodash-es/_cacheHas.js
+function cacheHas(cache, key) {
+  return cache.has(key);
+}
+var cacheHas_default = cacheHas;
+
+// node_modules/lodash-es/_equalArrays.js
+var COMPARE_PARTIAL_FLAG = 1;
+var COMPARE_UNORDERED_FLAG = 2;
+function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
+  var isPartial = bitmask & COMPARE_PARTIAL_FLAG, arrLength = array.length, othLength = other.length;
+  if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
+    return false;
+  }
+  var arrStacked = stack.get(array);
+  var othStacked = stack.get(other);
+  if (arrStacked && othStacked) {
+    return arrStacked == other && othStacked == array;
+  }
+  var index = -1, result = true, seen = bitmask & COMPARE_UNORDERED_FLAG ? new SetCache_default() : void 0;
+  stack.set(array, other);
+  stack.set(other, array);
+  while (++index < arrLength) {
+    var arrValue = array[index], othValue = other[index];
+    if (customizer) {
+      var compared = isPartial ? customizer(othValue, arrValue, index, other, array, stack) : customizer(arrValue, othValue, index, array, other, stack);
+    }
+    if (compared !== void 0) {
+      if (compared) {
+        continue;
+      }
+      result = false;
+      break;
+    }
+    if (seen) {
+      if (!arraySome_default(other, function(othValue2, othIndex) {
+        if (!cacheHas_default(seen, othIndex) && (arrValue === othValue2 || equalFunc(arrValue, othValue2, bitmask, customizer, stack))) {
+          return seen.push(othIndex);
+        }
+      })) {
+        result = false;
+        break;
+      }
+    } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
+      result = false;
+      break;
+    }
+  }
+  stack["delete"](array);
+  stack["delete"](other);
+  return result;
+}
+var equalArrays_default = equalArrays;
+
+// node_modules/lodash-es/_Uint8Array.js
+var Uint8Array = root_default.Uint8Array;
+var Uint8Array_default = Uint8Array;
+
+// node_modules/lodash-es/_mapToArray.js
+function mapToArray(map) {
+  var index = -1, result = Array(map.size);
+  map.forEach(function(value, key) {
+    result[++index] = [key, value];
+  });
+  return result;
+}
+var mapToArray_default = mapToArray;
+
+// node_modules/lodash-es/_setToArray.js
+function setToArray(set) {
+  var index = -1, result = Array(set.size);
+  set.forEach(function(value) {
+    result[++index] = value;
+  });
+  return result;
+}
+var setToArray_default = setToArray;
+
+// node_modules/lodash-es/_equalByTag.js
+var COMPARE_PARTIAL_FLAG2 = 1;
+var COMPARE_UNORDERED_FLAG2 = 2;
+var boolTag = "[object Boolean]";
+var dateTag = "[object Date]";
+var errorTag = "[object Error]";
+var mapTag = "[object Map]";
+var numberTag = "[object Number]";
+var regexpTag = "[object RegExp]";
+var setTag = "[object Set]";
+var stringTag = "[object String]";
+var symbolTag = "[object Symbol]";
+var arrayBufferTag = "[object ArrayBuffer]";
+var dataViewTag = "[object DataView]";
+var symbolProto = Symbol_default ? Symbol_default.prototype : void 0;
+var symbolValueOf = symbolProto ? symbolProto.valueOf : void 0;
+function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
+  switch (tag) {
+    case dataViewTag:
+      if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) {
+        return false;
+      }
+      object = object.buffer;
+      other = other.buffer;
+    case arrayBufferTag:
+      if (object.byteLength != other.byteLength || !equalFunc(new Uint8Array_default(object), new Uint8Array_default(other))) {
+        return false;
+      }
+      return true;
+    case boolTag:
+    case dateTag:
+    case numberTag:
+      return eq_default(+object, +other);
+    case errorTag:
+      return object.name == other.name && object.message == other.message;
+    case regexpTag:
+    case stringTag:
+      return object == other + "";
+    case mapTag:
+      var convert = mapToArray_default;
+    case setTag:
+      var isPartial = bitmask & COMPARE_PARTIAL_FLAG2;
+      convert || (convert = setToArray_default);
+      if (object.size != other.size && !isPartial) {
+        return false;
+      }
+      var stacked = stack.get(object);
+      if (stacked) {
+        return stacked == other;
+      }
+      bitmask |= COMPARE_UNORDERED_FLAG2;
+      stack.set(object, other);
+      var result = equalArrays_default(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
+      stack["delete"](object);
+      return result;
+    case symbolTag:
+      if (symbolValueOf) {
+        return symbolValueOf.call(object) == symbolValueOf.call(other);
+      }
+  }
+  return false;
+}
+var equalByTag_default = equalByTag;
+
+// node_modules/lodash-es/_arrayPush.js
+function arrayPush(array, values) {
+  var index = -1, length = values.length, offset = array.length;
+  while (++index < length) {
+    array[offset + index] = values[index];
+  }
+  return array;
+}
+var arrayPush_default = arrayPush;
+
+// node_modules/lodash-es/isArray.js
+var isArray = Array.isArray;
+var isArray_default = isArray;
+
+// node_modules/lodash-es/_baseGetAllKeys.js
+function baseGetAllKeys(object, keysFunc, symbolsFunc) {
+  var result = keysFunc(object);
+  return isArray_default(object) ? result : arrayPush_default(result, symbolsFunc(object));
+}
+var baseGetAllKeys_default = baseGetAllKeys;
+
+// node_modules/lodash-es/_arrayFilter.js
+function arrayFilter(array, predicate) {
+  var index = -1, length = array == null ? 0 : array.length, resIndex = 0, result = [];
+  while (++index < length) {
+    var value = array[index];
+    if (predicate(value, index, array)) {
+      result[resIndex++] = value;
+    }
+  }
+  return result;
+}
+var arrayFilter_default = arrayFilter;
+
+// node_modules/lodash-es/stubArray.js
+function stubArray() {
+  return [];
+}
+var stubArray_default = stubArray;
+
+// node_modules/lodash-es/_getSymbols.js
+var objectProto6 = Object.prototype;
+var propertyIsEnumerable = objectProto6.propertyIsEnumerable;
+var nativeGetSymbols = Object.getOwnPropertySymbols;
+var getSymbols = !nativeGetSymbols ? stubArray_default : function(object) {
+  if (object == null) {
+    return [];
+  }
+  object = Object(object);
+  return arrayFilter_default(nativeGetSymbols(object), function(symbol) {
+    return propertyIsEnumerable.call(object, symbol);
+  });
+};
+var getSymbols_default = getSymbols;
+
+// node_modules/lodash-es/_baseTimes.js
+function baseTimes(n, iteratee) {
+  var index = -1, result = Array(n);
+  while (++index < n) {
+    result[index] = iteratee(index);
+  }
+  return result;
+}
+var baseTimes_default = baseTimes;
+
+// node_modules/lodash-es/isObjectLike.js
+function isObjectLike(value) {
+  return value != null && typeof value == "object";
+}
+var isObjectLike_default = isObjectLike;
+
+// node_modules/lodash-es/_baseIsArguments.js
+var argsTag = "[object Arguments]";
+function baseIsArguments(value) {
+  return isObjectLike_default(value) && baseGetTag_default(value) == argsTag;
+}
+var baseIsArguments_default = baseIsArguments;
+
+// node_modules/lodash-es/isArguments.js
+var objectProto7 = Object.prototype;
+var hasOwnProperty5 = objectProto7.hasOwnProperty;
+var propertyIsEnumerable2 = objectProto7.propertyIsEnumerable;
+var isArguments = baseIsArguments_default(/* @__PURE__ */ function() {
+  return arguments;
+}()) ? baseIsArguments_default : function(value) {
+  return isObjectLike_default(value) && hasOwnProperty5.call(value, "callee") && !propertyIsEnumerable2.call(value, "callee");
+};
+var isArguments_default = isArguments;
+
+// node_modules/lodash-es/stubFalse.js
+function stubFalse() {
+  return false;
+}
+var stubFalse_default = stubFalse;
+
+// node_modules/lodash-es/isBuffer.js
+var freeExports = typeof exports == "object" && exports && !exports.nodeType && exports;
+var freeModule = freeExports && typeof module == "object" && module && !module.nodeType && module;
+var moduleExports = freeModule && freeModule.exports === freeExports;
+var Buffer = moduleExports ? root_default.Buffer : void 0;
+var nativeIsBuffer = Buffer ? Buffer.isBuffer : void 0;
+var isBuffer = nativeIsBuffer || stubFalse_default;
+var isBuffer_default = isBuffer;
+
+// node_modules/lodash-es/_isIndex.js
+var MAX_SAFE_INTEGER = 9007199254740991;
+var reIsUint = /^(?:0|[1-9]\d*)$/;
+function isIndex(value, length) {
+  var type = typeof value;
+  length = length == null ? MAX_SAFE_INTEGER : length;
+  return !!length && (type == "number" || type != "symbol" && reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
+}
+var isIndex_default = isIndex;
+
+// node_modules/lodash-es/isLength.js
+var MAX_SAFE_INTEGER2 = 9007199254740991;
+function isLength(value) {
+  return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER2;
+}
+var isLength_default = isLength;
+
+// node_modules/lodash-es/_baseIsTypedArray.js
+var argsTag2 = "[object Arguments]";
+var arrayTag = "[object Array]";
+var boolTag2 = "[object Boolean]";
+var dateTag2 = "[object Date]";
+var errorTag2 = "[object Error]";
+var funcTag2 = "[object Function]";
+var mapTag2 = "[object Map]";
+var numberTag2 = "[object Number]";
+var objectTag = "[object Object]";
+var regexpTag2 = "[object RegExp]";
+var setTag2 = "[object Set]";
+var stringTag2 = "[object String]";
+var weakMapTag = "[object WeakMap]";
+var arrayBufferTag2 = "[object ArrayBuffer]";
+var dataViewTag2 = "[object DataView]";
+var float32Tag = "[object Float32Array]";
+var float64Tag = "[object Float64Array]";
+var int8Tag = "[object Int8Array]";
+var int16Tag = "[object Int16Array]";
+var int32Tag = "[object Int32Array]";
+var uint8Tag = "[object Uint8Array]";
+var uint8ClampedTag = "[object Uint8ClampedArray]";
+var uint16Tag = "[object Uint16Array]";
+var uint32Tag = "[object Uint32Array]";
+var typedArrayTags = {};
+typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;
+typedArrayTags[argsTag2] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag2] = typedArrayTags[boolTag2] = typedArrayTags[dataViewTag2] = typedArrayTags[dateTag2] = typedArrayTags[errorTag2] = typedArrayTags[funcTag2] = typedArrayTags[mapTag2] = typedArrayTags[numberTag2] = typedArrayTags[objectTag] = typedArrayTags[regexpTag2] = typedArrayTags[setTag2] = typedArrayTags[stringTag2] = typedArrayTags[weakMapTag] = false;
+function baseIsTypedArray(value) {
+  return isObjectLike_default(value) && isLength_default(value.length) && !!typedArrayTags[baseGetTag_default(value)];
+}
+var baseIsTypedArray_default = baseIsTypedArray;
+
+// node_modules/lodash-es/_baseUnary.js
+function baseUnary(func) {
+  return function(value) {
+    return func(value);
+  };
+}
+var baseUnary_default = baseUnary;
+
+// node_modules/lodash-es/_nodeUtil.js
+var freeExports2 = typeof exports == "object" && exports && !exports.nodeType && exports;
+var freeModule2 = freeExports2 && typeof module == "object" && module && !module.nodeType && module;
+var moduleExports2 = freeModule2 && freeModule2.exports === freeExports2;
+var freeProcess = moduleExports2 && freeGlobal_default.process;
+var nodeUtil = function() {
+  try {
+    var types = freeModule2 && freeModule2.require && freeModule2.require("util").types;
+    if (types) {
+      return types;
+    }
+    return freeProcess && freeProcess.binding && freeProcess.binding("util");
+  } catch (e) {
+  }
+}();
+var nodeUtil_default = nodeUtil;
+
+// node_modules/lodash-es/isTypedArray.js
+var nodeIsTypedArray = nodeUtil_default && nodeUtil_default.isTypedArray;
+var isTypedArray = nodeIsTypedArray ? baseUnary_default(nodeIsTypedArray) : baseIsTypedArray_default;
+var isTypedArray_default = isTypedArray;
+
+// node_modules/lodash-es/_arrayLikeKeys.js
+var objectProto8 = Object.prototype;
+var hasOwnProperty6 = objectProto8.hasOwnProperty;
+function arrayLikeKeys(value, inherited) {
+  var isArr = isArray_default(value), isArg = !isArr && isArguments_default(value), isBuff = !isArr && !isArg && isBuffer_default(value), isType = !isArr && !isArg && !isBuff && isTypedArray_default(value), skipIndexes = isArr || isArg || isBuff || isType, result = skipIndexes ? baseTimes_default(value.length, String) : [], length = result.length;
+  for (var key in value) {
+    if ((inherited || hasOwnProperty6.call(value, key)) && !(skipIndexes && // Safari 9 has enumerable `arguments.length` in strict mode.
+    (key == "length" || // Node.js 0.10 has enumerable non-index properties on buffers.
+    isBuff && (key == "offset" || key == "parent") || // PhantomJS 2 has enumerable non-index properties on typed arrays.
+    isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || // Skip index properties.
+    isIndex_default(key, length)))) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+var arrayLikeKeys_default = arrayLikeKeys;
+
+// node_modules/lodash-es/_isPrototype.js
+var objectProto9 = Object.prototype;
+function isPrototype(value) {
+  var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto9;
+  return value === proto;
+}
+var isPrototype_default = isPrototype;
+
+// node_modules/lodash-es/_overArg.js
+function overArg(func, transform) {
+  return function(arg) {
+    return func(transform(arg));
+  };
+}
+var overArg_default = overArg;
+
+// node_modules/lodash-es/_nativeKeys.js
+var nativeKeys = overArg_default(Object.keys, Object);
+var nativeKeys_default = nativeKeys;
+
+// node_modules/lodash-es/_baseKeys.js
+var objectProto10 = Object.prototype;
+var hasOwnProperty7 = objectProto10.hasOwnProperty;
+function baseKeys(object) {
+  if (!isPrototype_default(object)) {
+    return nativeKeys_default(object);
+  }
+  var result = [];
+  for (var key in Object(object)) {
+    if (hasOwnProperty7.call(object, key) && key != "constructor") {
+      result.push(key);
+    }
+  }
+  return result;
+}
+var baseKeys_default = baseKeys;
+
+// node_modules/lodash-es/isArrayLike.js
+function isArrayLike(value) {
+  return value != null && isLength_default(value.length) && !isFunction_default(value);
+}
+var isArrayLike_default = isArrayLike;
+
+// node_modules/lodash-es/keys.js
+function keys(object) {
+  return isArrayLike_default(object) ? arrayLikeKeys_default(object) : baseKeys_default(object);
+}
+var keys_default = keys;
+
+// node_modules/lodash-es/_getAllKeys.js
+function getAllKeys(object) {
+  return baseGetAllKeys_default(object, keys_default, getSymbols_default);
+}
+var getAllKeys_default = getAllKeys;
+
+// node_modules/lodash-es/_equalObjects.js
+var COMPARE_PARTIAL_FLAG3 = 1;
+var objectProto11 = Object.prototype;
+var hasOwnProperty8 = objectProto11.hasOwnProperty;
+function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
+  var isPartial = bitmask & COMPARE_PARTIAL_FLAG3, objProps = getAllKeys_default(object), objLength = objProps.length, othProps = getAllKeys_default(other), othLength = othProps.length;
+  if (objLength != othLength && !isPartial) {
+    return false;
+  }
+  var index = objLength;
+  while (index--) {
+    var key = objProps[index];
+    if (!(isPartial ? key in other : hasOwnProperty8.call(other, key))) {
+      return false;
+    }
+  }
+  var objStacked = stack.get(object);
+  var othStacked = stack.get(other);
+  if (objStacked && othStacked) {
+    return objStacked == other && othStacked == object;
+  }
+  var result = true;
+  stack.set(object, other);
+  stack.set(other, object);
+  var skipCtor = isPartial;
+  while (++index < objLength) {
+    key = objProps[index];
+    var objValue = object[key], othValue = other[key];
+    if (customizer) {
+      var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack);
+    }
+    if (!(compared === void 0 ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack) : compared)) {
+      result = false;
+      break;
+    }
+    skipCtor || (skipCtor = key == "constructor");
+  }
+  if (result && !skipCtor) {
+    var objCtor = object.constructor, othCtor = other.constructor;
+    if (objCtor != othCtor && ("constructor" in object && "constructor" in other) && !(typeof objCtor == "function" && objCtor instanceof objCtor && typeof othCtor == "function" && othCtor instanceof othCtor)) {
+      result = false;
+    }
+  }
+  stack["delete"](object);
+  stack["delete"](other);
+  return result;
+}
+var equalObjects_default = equalObjects;
+
+// node_modules/lodash-es/_DataView.js
+var DataView = getNative_default(root_default, "DataView");
+var DataView_default = DataView;
+
+// node_modules/lodash-es/_Promise.js
+var Promise2 = getNative_default(root_default, "Promise");
+var Promise_default = Promise2;
+
+// node_modules/lodash-es/_Set.js
+var Set2 = getNative_default(root_default, "Set");
+var Set_default = Set2;
+
+// node_modules/lodash-es/_WeakMap.js
+var WeakMap = getNative_default(root_default, "WeakMap");
+var WeakMap_default = WeakMap;
+
+// node_modules/lodash-es/_getTag.js
+var mapTag3 = "[object Map]";
+var objectTag2 = "[object Object]";
+var promiseTag = "[object Promise]";
+var setTag3 = "[object Set]";
+var weakMapTag2 = "[object WeakMap]";
+var dataViewTag3 = "[object DataView]";
+var dataViewCtorString = toSource_default(DataView_default);
+var mapCtorString = toSource_default(Map_default);
+var promiseCtorString = toSource_default(Promise_default);
+var setCtorString = toSource_default(Set_default);
+var weakMapCtorString = toSource_default(WeakMap_default);
+var getTag = baseGetTag_default;
+if (DataView_default && getTag(new DataView_default(new ArrayBuffer(1))) != dataViewTag3 || Map_default && getTag(new Map_default()) != mapTag3 || Promise_default && getTag(Promise_default.resolve()) != promiseTag || Set_default && getTag(new Set_default()) != setTag3 || WeakMap_default && getTag(new WeakMap_default()) != weakMapTag2) {
+  getTag = function(value) {
+    var result = baseGetTag_default(value), Ctor = result == objectTag2 ? value.constructor : void 0, ctorString = Ctor ? toSource_default(Ctor) : "";
+    if (ctorString) {
+      switch (ctorString) {
+        case dataViewCtorString:
+          return dataViewTag3;
+        case mapCtorString:
+          return mapTag3;
+        case promiseCtorString:
+          return promiseTag;
+        case setCtorString:
+          return setTag3;
+        case weakMapCtorString:
+          return weakMapTag2;
+      }
+    }
+    return result;
+  };
+}
+var getTag_default = getTag;
+
+// node_modules/lodash-es/_baseIsEqualDeep.js
+var COMPARE_PARTIAL_FLAG4 = 1;
+var argsTag3 = "[object Arguments]";
+var arrayTag2 = "[object Array]";
+var objectTag3 = "[object Object]";
+var objectProto12 = Object.prototype;
+var hasOwnProperty9 = objectProto12.hasOwnProperty;
+function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
+  var objIsArr = isArray_default(object), othIsArr = isArray_default(other), objTag = objIsArr ? arrayTag2 : getTag_default(object), othTag = othIsArr ? arrayTag2 : getTag_default(other);
+  objTag = objTag == argsTag3 ? objectTag3 : objTag;
+  othTag = othTag == argsTag3 ? objectTag3 : othTag;
+  var objIsObj = objTag == objectTag3, othIsObj = othTag == objectTag3, isSameTag = objTag == othTag;
+  if (isSameTag && isBuffer_default(object)) {
+    if (!isBuffer_default(other)) {
+      return false;
+    }
+    objIsArr = true;
+    objIsObj = false;
+  }
+  if (isSameTag && !objIsObj) {
+    stack || (stack = new Stack_default());
+    return objIsArr || isTypedArray_default(object) ? equalArrays_default(object, other, bitmask, customizer, equalFunc, stack) : equalByTag_default(object, other, objTag, bitmask, customizer, equalFunc, stack);
+  }
+  if (!(bitmask & COMPARE_PARTIAL_FLAG4)) {
+    var objIsWrapped = objIsObj && hasOwnProperty9.call(object, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty9.call(other, "__wrapped__");
+    if (objIsWrapped || othIsWrapped) {
+      var objUnwrapped = objIsWrapped ? object.value() : object, othUnwrapped = othIsWrapped ? other.value() : other;
+      stack || (stack = new Stack_default());
+      return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
+    }
+  }
+  if (!isSameTag) {
+    return false;
+  }
+  stack || (stack = new Stack_default());
+  return equalObjects_default(object, other, bitmask, customizer, equalFunc, stack);
+}
+var baseIsEqualDeep_default = baseIsEqualDeep;
+
+// node_modules/lodash-es/_baseIsEqual.js
+function baseIsEqual(value, other, bitmask, customizer, stack) {
+  if (value === other) {
+    return true;
+  }
+  if (value == null || other == null || !isObjectLike_default(value) && !isObjectLike_default(other)) {
+    return value !== value && other !== other;
+  }
+  return baseIsEqualDeep_default(value, other, bitmask, customizer, baseIsEqual, stack);
+}
+var baseIsEqual_default = baseIsEqual;
+
+// node_modules/lodash-es/isEqual.js
+function isEqual(value, other) {
+  return baseIsEqual_default(value, other);
+}
+var isEqual_default = isEqual;
+
+// src/lib/v1/JoggerConnection.ts
+import { Vector3 as Vector32 } from "three/src/math/Vector3.js";
+var JoggerConnection = class _JoggerConnection {
+  constructor(motionStream, opts = {}) {
+    this.motionStream = motionStream;
+    this.opts = opts;
+    // Currently a separate websocket is needed for each mode, pester API people
+    // to merge these for simplicity
+    this.cartesianWebsocket = null;
+    this.jointWebsocket = null;
+    this.cartesianJoggingOpts = {};
+  }
+  static open(_0, _1) {
+    return __async(this, arguments, function* (nova, motionGroupId, opts = {}) {
+      const motionStream = yield nova.connectMotionStream(motionGroupId);
+      return new _JoggerConnection(motionStream, opts);
+    });
+  }
+  get motionGroupId() {
+    return this.motionStream.motionGroupId;
+  }
+  get nova() {
+    return this.motionStream.nova;
+  }
+  get numJoints() {
+    return this.motionStream.joints.length;
+  }
+  get activeJoggingMode() {
+    if (this.cartesianWebsocket) return "cartesian";
+    if (this.jointWebsocket) return "joint";
+    return "increment";
+  }
+  get activeWebsocket() {
+    return this.cartesianWebsocket || this.jointWebsocket;
+  }
+  stop() {
+    return __async(this, null, function* () {
+      if (this.cartesianWebsocket) {
+        this.cartesianWebsocket.sendJson({
+          motion_group: this.motionGroupId,
+          position_direction: { x: 0, y: 0, z: 0 },
+          rotation_direction: { x: 0, y: 0, z: 0 },
+          position_velocity: 0,
+          rotation_velocity: 0,
+          tcp: this.cartesianJoggingOpts.tcpId,
+          coordinate_system: this.cartesianJoggingOpts.coordSystemId
+        });
+      }
+      if (this.jointWebsocket) {
+        this.jointWebsocket.sendJson({
+          motion_group: this.motionGroupId,
+          joint_velocities: new Array(this.numJoints).fill(0)
+        });
+      }
+    });
+  }
+  dispose() {
+    if (this.cartesianWebsocket) {
+      this.cartesianWebsocket.dispose();
+    }
+    if (this.jointWebsocket) {
+      this.jointWebsocket.dispose();
+    }
+  }
+  setJoggingMode(mode, cartesianJoggingOpts) {
+    console.log("Setting jogging mode to", mode);
+    if (cartesianJoggingOpts) {
+      if (!isEqual_default(this.cartesianJoggingOpts, cartesianJoggingOpts)) {
+        if (this.cartesianWebsocket) {
+          this.cartesianWebsocket.dispose();
+          this.cartesianWebsocket = null;
+        }
+      }
+      this.cartesianJoggingOpts = cartesianJoggingOpts;
+    }
+    if (mode !== "cartesian" && this.cartesianWebsocket) {
+      this.cartesianWebsocket.dispose();
+      this.cartesianWebsocket = null;
+    }
+    if (mode !== "joint" && this.jointWebsocket) {
+      this.jointWebsocket.dispose();
+      this.jointWebsocket = null;
+    }
+    if (mode === "cartesian" && !this.cartesianWebsocket) {
+      this.cartesianWebsocket = this.nova.openReconnectingWebsocket(
+        `/motion-groups/move-tcp`
+      );
+      this.cartesianWebsocket.addEventListener(
+        "message",
+        (ev) => {
+          const data = tryParseJson(ev.data);
+          if (data && "error" in data) {
+            if (this.opts.onError) {
+              this.opts.onError(ev.data);
+            } else {
+              throw new Error(ev.data);
+            }
+          }
+        }
+      );
+    }
+    if (mode === "joint" && !this.jointWebsocket) {
+      this.jointWebsocket = this.nova.openReconnectingWebsocket(
+        `/motion-groups/move-joint`
+      );
+      this.jointWebsocket.addEventListener("message", (ev) => {
+        const data = tryParseJson(ev.data);
+        if (data && "error" in data) {
+          if (this.opts.onError) {
+            this.opts.onError(ev.data);
+          } else {
+            throw new Error(ev.data);
+          }
+        }
+      });
+    }
+  }
+  /**
+   * Start rotation of a single robot joint at the specified velocity
+   */
+  startJointRotation(_0) {
+    return __async(this, arguments, function* ({
+      joint,
+      direction,
+      velocityRadsPerSec
+    }) {
+      if (!this.jointWebsocket) {
+        throw new Error(
+          "Joint jogging websocket not connected; call setJoggingMode first"
+        );
+      }
+      const jointVelocities = new Array(this.numJoints).fill(0);
+      jointVelocities[joint] = direction === "-" ? -velocityRadsPerSec : velocityRadsPerSec;
+      this.jointWebsocket.sendJson({
+        motion_group: this.motionGroupId,
+        joint_velocities: jointVelocities
+      });
+    });
+  }
+  /**
+   * Start the TCP moving along a specified axis at a given velocity
+   */
+  startTCPTranslation(_0) {
+    return __async(this, arguments, function* ({
+      axis,
+      direction,
+      velocityMmPerSec
+    }) {
+      if (!this.cartesianWebsocket) {
+        throw new Error(
+          "Cartesian jogging websocket not connected; call setJoggingMode first"
+        );
+      }
+      const zeroVector = { x: 0, y: 0, z: 0 };
+      const joggingVector = Object.assign({}, zeroVector);
+      joggingVector[axis] = direction === "-" ? -1 : 1;
+      this.cartesianWebsocket.sendJson({
+        motion_group: this.motionGroupId,
+        position_direction: joggingVector,
+        rotation_direction: zeroVector,
+        position_velocity: velocityMmPerSec,
+        rotation_velocity: 0,
+        tcp: this.cartesianJoggingOpts.tcpId,
+        coordinate_system: this.cartesianJoggingOpts.coordSystemId
+      });
+    });
+  }
+  /**
+   * Start the TCP rotating around a specified axis at a given velocity
+   */
+  startTCPRotation(_0) {
+    return __async(this, arguments, function* ({
+      axis,
+      direction,
+      velocityRadsPerSec
+    }) {
+      if (!this.cartesianWebsocket) {
+        throw new Error(
+          "Cartesian jogging websocket not connected; call setJoggingMode first"
+        );
+      }
+      const zeroVector = { x: 0, y: 0, z: 0 };
+      const joggingVector = Object.assign({}, zeroVector);
+      joggingVector[axis] = direction === "-" ? -1 : 1;
+      this.cartesianWebsocket.sendJson({
+        motion_group: this.motionGroupId,
+        position_direction: zeroVector,
+        rotation_direction: joggingVector,
+        position_velocity: 0,
+        rotation_velocity: velocityRadsPerSec,
+        tcp: this.cartesianJoggingOpts.tcpId,
+        coordinate_system: this.cartesianJoggingOpts.coordSystemId
+      });
+    });
+  }
+  /**
+   * Move the robot by a fixed distance in a single cartesian
+   * axis, either rotating or translating relative to the TCP.
+   * Promise resolves only after the motion has completed.
+   */
+  runIncrementalCartesianMotion(_0) {
+    return __async(this, arguments, function* ({
+      currentTcpPose,
+      currentJoints,
+      coordSystemId,
+      velocityInRelevantUnits,
+      axis,
+      direction,
+      motion
+    }) {
+      var _a;
+      const commands = [];
+      if (!isSameCoordinateSystem(currentTcpPose.coordinate_system, coordSystemId)) {
+        throw new Error(
+          `Current TCP pose coordinate system ${currentTcpPose.coordinate_system} does not match target coordinate system ${coordSystemId}`
+        );
+      }
+      if (motion.type === "translate") {
+        const targetTcpPosition = Object.assign({}, currentTcpPose.position);
+        targetTcpPosition[axis] += motion.distanceMm * (direction === "-" ? -1 : 1);
+        commands.push({
+          settings: {
+            limits_override: {
+              tcp_velocity_limit: velocityInRelevantUnits
+            }
+          },
+          line: {
+            position: targetTcpPosition,
+            orientation: currentTcpPose.orientation,
+            coordinate_system: coordSystemId
+          }
+        });
+      } else if (motion.type === "rotate") {
+        const currentRotationVector = new Vector32(
+          currentTcpPose.orientation["x"],
+          currentTcpPose.orientation["y"],
+          currentTcpPose.orientation["z"]
+        );
+        const currentRotationRad = currentRotationVector.length();
+        const currentRotationDirection = currentRotationVector.clone().normalize();
+        const differenceRotationRad = motion.distanceRads * (direction === "-" ? -1 : 1);
+        const differenceRotationDirection = new Vector32(0, 0, 0);
+        differenceRotationDirection[axis] = 1;
+        const f1 = Math.cos(0.5 * differenceRotationRad) * Math.cos(0.5 * currentRotationRad);
+        const f2 = Math.sin(0.5 * differenceRotationRad) * Math.sin(0.5 * currentRotationRad);
+        const f3 = Math.sin(0.5 * differenceRotationRad) * Math.cos(0.5 * currentRotationRad);
+        const f4 = Math.cos(0.5 * differenceRotationRad) * Math.sin(0.5 * currentRotationRad);
+        const dotProduct = differenceRotationDirection.dot(
+          currentRotationDirection
+        );
+        const crossProduct = differenceRotationDirection.clone().cross(currentRotationDirection);
+        const newRotationRad = 2 * Math.acos(f1 - f2 * dotProduct);
+        const f5 = newRotationRad / Math.sin(0.5 * newRotationRad);
+        const targetTcpOrientation = new Vector32().addScaledVector(crossProduct, f2).addScaledVector(differenceRotationDirection, f3).addScaledVector(currentRotationDirection, f4).multiplyScalar(f5);
+        commands.push({
+          settings: {
+            limits_override: {
+              tcp_orientation_velocity_limit: velocityInRelevantUnits
+            }
+          },
+          line: {
+            position: currentTcpPose.position,
+            orientation: targetTcpOrientation,
+            coordinate_system: coordSystemId
+          }
+        });
+      }
+      const motionPlanRes = yield this.nova.api.motion.planMotion({
+        motion_group: this.motionGroupId,
+        start_joint_position: currentJoints,
+        tcp: this.cartesianJoggingOpts.tcpId,
+        commands
+      });
+      const plannedMotion = (_a = motionPlanRes.plan_successful_response) == null ? void 0 : _a.motion;
+      if (!plannedMotion) {
+        throw new Error(
+          `Failed to plan jogging increment motion ${JSON.stringify(motionPlanRes)}`
+        );
+      }
+      yield this.nova.api.motion.streamMoveForward(
+        plannedMotion,
+        100,
+        void 0,
+        void 0,
+        void 0,
+        {
+          // Might take a while at low velocity
+          timeout: 1e3 * 60
+        }
+      );
+    });
+  }
+  /**
+   * Rotate a single robot joint by a fixed number of radians
+   * Promise resolves only after the motion has completed.
+   */
+  runIncrementalJointRotation(_0) {
+    return __async(this, arguments, function* ({
+      joint,
+      currentJoints,
+      velocityRadsPerSec,
+      direction,
+      distanceRads
+    }) {
+      var _a;
+      const targetJoints = [...currentJoints.joints];
+      targetJoints[joint] += distanceRads * (direction === "-" ? -1 : 1);
+      const jointVelocityLimits = new Array(
+        currentJoints.joints.length
+      ).fill(velocityRadsPerSec);
+      const motionPlanRes = yield this.nova.api.motion.planMotion({
+        motion_group: this.motionGroupId,
+        start_joint_position: currentJoints,
+        commands: [
+          {
+            settings: {
+              limits_override: {
+                joint_velocity_limits: {
+                  joints: jointVelocityLimits
+                }
+              }
+            },
+            joint_ptp: {
+              joints: targetJoints
+            }
+          }
+        ]
+      });
+      const plannedMotion = (_a = motionPlanRes.plan_successful_response) == null ? void 0 : _a.motion;
+      if (!plannedMotion) {
+        console.error("Failed to plan jogging increment motion", motionPlanRes);
+        return;
+      }
+      yield this.nova.api.motion.streamMoveForward(
+        plannedMotion,
+        100,
+        void 0,
+        void 0,
+        void 0,
+        {
+          // Might take a while at low velocity
+          timeout: 1e3 * 60
+        }
+      );
+    });
+  }
+};
+
+// src/lib/v1/MotionStreamConnection.ts
+import { makeAutoObservable as makeAutoObservable2, runInAction as runInAction2 } from "mobx";
+import { Vector3 as Vector33 } from "three";
+var MOTION_DELTA_THRESHOLD2 = 1e-4;
+function unwrapRotationVector(newRotationVectorApi, currentRotationVectorApi) {
+  const currentRotationVector = new Vector33(
+    currentRotationVectorApi.x,
+    currentRotationVectorApi.y,
+    currentRotationVectorApi.z
+  );
+  const newRotationVector = new Vector33(
+    newRotationVectorApi.x,
+    newRotationVectorApi.y,
+    newRotationVectorApi.z
+  );
+  const currentAngle = currentRotationVector.length();
+  const currentAxis = currentRotationVector.normalize();
+  let newAngle = newRotationVector.length();
+  let newAxis = newRotationVector.normalize();
+  if (newAxis.dot(currentAxis) < 0) {
+    newAngle = -newAngle;
+    newAxis = newAxis.multiplyScalar(-1);
+  }
+  let angleDifference = newAngle - currentAngle;
+  angleDifference -= 2 * Math.PI * Math.floor((angleDifference + Math.PI) / (2 * Math.PI));
+  newAngle = currentAngle + angleDifference;
+  return newAxis.multiplyScalar(newAngle);
+}
+var MotionStreamConnection = class _MotionStreamConnection {
+  constructor(nova, controller, motionGroup, initialMotionState, motionStateSocket) {
+    this.nova = nova;
+    this.controller = controller;
+    this.motionGroup = motionGroup;
+    this.initialMotionState = initialMotionState;
+    this.motionStateSocket = motionStateSocket;
+    this.rapidlyChangingMotionState = initialMotionState;
+    motionStateSocket.addEventListener("message", (event) => {
+      var _a;
+      const motionStateResponse = (_a = tryParseJson(event.data)) == null ? void 0 : _a.result;
+      if (!motionStateResponse) {
+        throw new Error(
+          `Failed to get motion state for ${this.motionGroupId}: ${event.data}`
+        );
+      }
+      if (!jointValuesEqual(
+        this.rapidlyChangingMotionState.state.joint_position.joints,
+        motionStateResponse.state.joint_position.joints,
+        MOTION_DELTA_THRESHOLD2
+      )) {
+        runInAction2(() => {
+          this.rapidlyChangingMotionState.state = motionStateResponse.state;
+        });
+      }
+      if (!tcpPoseEqual(
+        this.rapidlyChangingMotionState.tcp_pose,
+        motionStateResponse.tcp_pose,
+        MOTION_DELTA_THRESHOLD2
+      )) {
+        runInAction2(() => {
+          if (this.rapidlyChangingMotionState.tcp_pose == void 0) {
+            this.rapidlyChangingMotionState.tcp_pose = motionStateResponse.tcp_pose;
+          } else {
+            this.rapidlyChangingMotionState.tcp_pose = {
+              position: motionStateResponse.tcp_pose.position,
+              orientation: unwrapRotationVector(
+                motionStateResponse.tcp_pose.orientation,
+                this.rapidlyChangingMotionState.tcp_pose.orientation
+              ),
+              tcp: motionStateResponse.tcp_pose.tcp,
+              coordinate_system: motionStateResponse.tcp_pose.coordinate_system
+            };
+          }
+        });
+      }
+    });
+    makeAutoObservable2(this);
+  }
+  static open(nova, motionGroupId) {
+    return __async(this, null, function* () {
+      var _a;
+      const { instances: controllers } = yield nova.api.controller.listControllers();
+      const [_motionGroupIndex, controllerId] = motionGroupId.split("@");
+      const controller = controllers.find((c) => c.controller === controllerId);
+      const motionGroup = controller == null ? void 0 : controller.physical_motion_groups.find(
+        (mg) => mg.motion_group === motionGroupId
+      );
+      if (!controller || !motionGroup) {
+        throw new Error(
+          `Controller ${controllerId} or motion group ${motionGroupId} not found`
+        );
+      }
+      const motionStateSocket = nova.openReconnectingWebsocket(
+        `/motion-groups/${motionGroupId}/state-stream`
+      );
+      const firstMessage = yield motionStateSocket.firstMessage();
+      console.log("got first message", firstMessage);
+      const initialMotionState = (_a = tryParseJson(firstMessage.data)) == null ? void 0 : _a.result;
+      if (!initialMotionState) {
+        throw new Error(
+          `Unable to parse initial motion state message ${firstMessage.data}`
+        );
+      }
+      console.log(
+        `Connected motion state websocket to motion group ${motionGroup.motion_group}. Initial state:
+  `,
+        initialMotionState
+      );
+      return new _MotionStreamConnection(
+        nova,
+        controller,
+        motionGroup,
+        initialMotionState,
+        motionStateSocket
+      );
+    });
+  }
+  get motionGroupId() {
+    return this.motionGroup.motion_group;
+  }
+  get controllerId() {
+    return this.controller.controller;
+  }
+  get modelFromController() {
+    return this.motionGroup.model_from_controller;
+  }
+  get wandelscriptIdentifier() {
+    const num = this.motionGroupId.split("@")[0];
+    return `${this.controllerId.replaceAll("-", "_")}_${num}`;
+  }
+  get joints() {
+    return this.initialMotionState.state.joint_position.joints.map((_, i) => {
+      return {
+        index: i
+      };
+    });
+  }
+  dispose() {
+    this.motionStateSocket.close();
+  }
+};
+
+// src/lib/v1/NovaCellAPIClient.ts
+import {
+  ApplicationApi,
+  CellApi,
+  ControllerApi,
+  ControllerIOsApi,
+  CoordinateSystemsApi,
+  DeviceConfigurationApi,
+  LibraryProgramApi,
+  LibraryProgramMetadataApi,
+  LibraryRecipeApi,
+  LibraryRecipeMetadataApi,
+  MotionApi,
+  MotionGroupApi,
+  MotionGroupInfosApi,
+  MotionGroupJoggingApi,
+  MotionGroupKinematicApi,
+  ProgramApi,
+  ProgramValuesApi,
+  StoreCollisionComponentsApi,
+  StoreCollisionScenesApi,
+  StoreObjectApi,
+  SystemApi,
+  VirtualRobotApi,
+  VirtualRobotBehaviorApi,
+  VirtualRobotModeApi,
+  VirtualRobotSetupApi
+} from "@wandelbots/nova-api/v1";
+import axios from "axios";
+var NovaCellAPIClient = class {
+  constructor(cellId, opts) {
+    this.cellId = cellId;
+    this.opts = opts;
+    this.system = this.withUnwrappedResponsesOnly(SystemApi);
+    this.cell = this.withUnwrappedResponsesOnly(CellApi);
+    this.deviceConfig = this.withCellId(DeviceConfigurationApi);
+    this.motionGroup = this.withCellId(MotionGroupApi);
+    this.motionGroupInfos = this.withCellId(MotionGroupInfosApi);
+    this.controller = this.withCellId(ControllerApi);
+    this.program = this.withCellId(ProgramApi);
+    this.programValues = this.withCellId(ProgramValuesApi);
+    this.controllerIOs = this.withCellId(ControllerIOsApi);
+    this.motionGroupKinematic = this.withCellId(MotionGroupKinematicApi);
+    this.motion = this.withCellId(MotionApi);
+    this.coordinateSystems = this.withCellId(CoordinateSystemsApi);
+    this.application = this.withCellId(ApplicationApi);
+    this.applicationGlobal = this.withUnwrappedResponsesOnly(ApplicationApi);
+    this.motionGroupJogging = this.withCellId(MotionGroupJoggingApi);
+    this.virtualRobot = this.withCellId(VirtualRobotApi);
+    this.virtualRobotSetup = this.withCellId(VirtualRobotSetupApi);
+    this.virtualRobotMode = this.withCellId(VirtualRobotModeApi);
+    this.virtualRobotBehavior = this.withCellId(VirtualRobotBehaviorApi);
+    this.libraryProgramMetadata = this.withCellId(LibraryProgramMetadataApi);
+    this.libraryProgram = this.withCellId(LibraryProgramApi);
+    this.libraryRecipeMetadata = this.withCellId(LibraryRecipeMetadataApi);
+    this.libraryRecipe = this.withCellId(LibraryRecipeApi);
+    this.storeObject = this.withCellId(StoreObjectApi);
+    this.storeCollisionComponents = this.withCellId(
+      StoreCollisionComponentsApi
+    );
+    this.storeCollisionScenes = this.withCellId(StoreCollisionScenesApi);
+  }
+  /**
+   * Some TypeScript sorcery which alters the API class methods so you don't
+   * have to pass the cell id to every single one, and de-encapsulates the
+   * response data
+   */
+  withCellId(ApiConstructor) {
+    var _a, _b;
+    const apiClient = new ApiConstructor(
+      __spreadProps(__spreadValues({}, this.opts), {
+        isJsonMime: (mime) => {
+          return mime === "application/json";
+        }
+      }),
+      (_a = this.opts.basePath) != null ? _a : "",
+      (_b = this.opts.axiosInstance) != null ? _b : axios.create()
+    );
+    for (const key of Reflect.ownKeys(Reflect.getPrototypeOf(apiClient))) {
+      if (key !== "constructor" && typeof apiClient[key] === "function") {
+        const originalFunction = apiClient[key];
+        apiClient[key] = (...args) => {
+          return originalFunction.apply(apiClient, [this.cellId, ...args]).then((res) => res.data);
+        };
+      }
+    }
+    return apiClient;
+  }
+  /**
+   * As withCellId, but only does the response unwrapping
+   */
+  withUnwrappedResponsesOnly(ApiConstructor) {
+    var _a, _b;
+    const apiClient = new ApiConstructor(
+      __spreadProps(__spreadValues({}, this.opts), {
+        isJsonMime: (mime) => {
+          return mime === "application/json";
+        }
+      }),
+      (_a = this.opts.basePath) != null ? _a : "",
+      (_b = this.opts.axiosInstance) != null ? _b : axios.create()
+    );
+    for (const key of Reflect.ownKeys(Reflect.getPrototypeOf(apiClient))) {
+      if (key !== "constructor" && typeof apiClient[key] === "function") {
+        const originalFunction = apiClient[key];
+        apiClient[key] = (...args) => {
+          return originalFunction.apply(apiClient, args).then((res) => res.data);
+        };
+      }
+    }
+    return apiClient;
+  }
+};
+
+// src/lib/v1/NovaClient.ts
+import axios2, { isAxiosError } from "axios";
+import urlJoin from "url-join";
+
+// src/lib/v1/mock/MockNovaInstance.ts
+import { AxiosError } from "axios";
+import * as pathToRegexp from "path-to-regexp";
+var MockNovaInstance = class {
+  constructor() {
+    this.connections = [];
+  }
+  handleAPIRequest(config) {
+    return __async(this, null, function* () {
+      var _a, _b, _c;
+      const apiHandlers = [
+        {
+          method: "GET",
+          path: "/cells/:cellId/controllers",
+          handle() {
+            return {
+              instances: [
+                {
+                  controller: "mock-ur5e",
+                  model_name: "UniversalRobots::Controller",
+                  host: "mock-ur5e",
+                  allow_software_install_on_controller: true,
+                  physical_motion_groups: [
+                    {
+                      motion_group: "0@mock-ur5e",
+                      name_from_controller: "UR5e",
+                      active: false,
+                      model_from_controller: "UniversalRobots_UR5e"
+                    }
+                  ],
+                  has_error: false,
+                  error_details: ""
+                }
+              ]
+            };
+          }
+        },
+        {
+          method: "GET",
+          path: "/cells/:cellId/controllers/:controllerId",
+          handle() {
+            return {
+              configuration: {
+                kind: "VirtualController",
+                manufacturer: "universalrobots",
+                position: "[0,-1.571,-1.571,-1.571,1.571,-1.571,0]",
+                type: "universalrobots-ur5e"
+              },
+              name: "mock-ur5"
+            };
+          }
+        },
+        {
+          method: "GET",
+          path: "/cells/:cellId/motion-groups/:motionGroupId/specification",
+          handle() {
+            return {
+              dh_parameters: [
+                {
+                  alpha: 1.5707963267948966,
+                  theta: 0,
+                  a: 0,
+                  d: 162.25,
+                  reverse_rotation_direction: false
+                },
+                {
+                  alpha: 0,
+                  theta: 0,
+                  a: -425,
+                  d: 0,
+                  reverse_rotation_direction: false
+                },
+                {
+                  alpha: 0,
+                  theta: 0,
+                  a: -392.2,
+                  d: 0,
+                  reverse_rotation_direction: false
+                },
+                {
+                  alpha: 1.5707963267948966,
+                  theta: 0,
+                  a: 0,
+                  d: 133.3,
+                  reverse_rotation_direction: false
+                },
+                {
+                  alpha: -1.5707963267948966,
+                  theta: 0,
+                  a: 0,
+                  d: 99.7,
+                  reverse_rotation_direction: false
+                },
+                {
+                  alpha: 0,
+                  theta: 0,
+                  a: 0,
+                  d: 99.6,
+                  reverse_rotation_direction: false
+                }
+              ],
+              mechanical_joint_limits: [
+                {
+                  joint: "JOINTNAME_AXIS_1",
+                  lower_limit: -6.335545063018799,
+                  upper_limit: 6.335545063018799,
+                  unlimited: false
+                },
+                {
+                  joint: "JOINTNAME_AXIS_2",
+                  lower_limit: -6.335545063018799,
+                  upper_limit: 6.335545063018799,
+                  unlimited: false
+                },
+                {
+                  joint: "JOINTNAME_AXIS_3",
+                  lower_limit: -6.335545063018799,
+                  upper_limit: 6.335545063018799,
+                  unlimited: false
+                },
+                {
+                  joint: "JOINTNAME_AXIS_4",
+                  lower_limit: -6.335545063018799,
+                  upper_limit: 6.335545063018799,
+                  unlimited: false
+                },
+                {
+                  joint: "JOINTNAME_AXIS_5",
+                  lower_limit: -6.335545063018799,
+                  upper_limit: 6.335545063018799,
+                  unlimited: false
+                },
+                {
+                  joint: "JOINTNAME_AXIS_6",
+                  lower_limit: -6.335545063018799,
+                  upper_limit: 6.335545063018799,
+                  unlimited: false
+                }
+              ]
+            };
+          }
+        },
+        {
+          method: "GET",
+          path: "/cells/:cellId/motion-groups/:motionGroupId/safety-setup",
+          handle() {
+            return {
+              safety_settings: [
+                {
+                  safety_state: "SAFETY_NORMAL",
+                  settings: {
+                    joint_position_limits: [
+                      {
+                        joint: "JOINTNAME_AXIS_1",
+                        lower_limit: -2.96705961227417,
+                        upper_limit: 2.96705961227417,
+                        unlimited: false
+                      },
+                      {
+                        joint: "JOINTNAME_AXIS_2",
+                        lower_limit: -1.7453292608261108,
+                        upper_limit: 2.7925267219543457,
+                        unlimited: false
+                      },
+                      {
+                        joint: "JOINTNAME_AXIS_3",
+                        lower_limit: -3.3161256313323975,
+                        upper_limit: 0.40142571926116943,
+                        unlimited: false
+                      },
+                      {
+                        joint: "JOINTNAME_AXIS_4",
+                        lower_limit: -3.4906585216522217,
+                        upper_limit: 3.4906585216522217,
+                        unlimited: false
+                      },
+                      {
+                        joint: "JOINTNAME_AXIS_5",
+                        lower_limit: -2.4434609413146973,
+                        upper_limit: 2.4434609413146973,
+                        unlimited: false
+                      },
+                      {
+                        joint: "JOINTNAME_AXIS_6",
+                        lower_limit: -4.71238899230957,
+                        upper_limit: 4.71238899230957,
+                        unlimited: false
+                      }
+                    ],
+                    joint_velocity_limits: [
+                      {
+                        joint: "JOINTNAME_AXIS_1",
+                        limit: 3.1415927410125732
+                      },
+                      {
+                        joint: "JOINTNAME_AXIS_2",
+                        limit: 3.1415927410125732
+                      },
+                      {
+                        joint: "JOINTNAME_AXIS_3",
+                        limit: 3.4906585216522217
+                      },
+                      {
+                        joint: "JOINTNAME_AXIS_4",
+                        limit: 6.108652591705322
+                      },
+                      {
+                        joint: "JOINTNAME_AXIS_5",
+                        limit: 6.108652591705322
+                      },
+                      {
+                        joint: "JOINTNAME_AXIS_6",
+                        limit: 6.981317043304443
+                      }
+                    ],
+                    joint_acceleration_limits: [],
+                    joint_torque_limits: [],
+                    tcp_velocity_limit: 1800
+                  }
+                }
+              ],
+              safety_zones: [
+                {
+                  id: 1,
+                  priority: 0,
+                  geometry: {
+                    compound: {
+                      child_geometries: [
+                        {
+                          convex_hull: {
+                            vertices: [
+                              {
+                                x: -800,
+                                y: -1330,
+                                z: -1820
+                              },
+                              {
+                                x: 1650,
+                                y: -1330,
+                                z: -1820
+                              },
+                              {
+                                x: 1650,
+                                y: 1330,
+                                z: -1820
+                              },
+                              {
+                                x: -800,
+                                y: 1330,
+                                z: -1820
+                              }
+                            ]
+                          },
+                          init_pose: {
+                            position: {
+                              x: 0,
+                              y: 0,
+                              z: 0
+                            },
+                            orientation: {
+                              x: 0,
+                              y: 0,
+                              z: 0,
+                              w: 1
+                            }
+                          },
+                          id: "box"
+                        },
+                        {
+                          convex_hull: {
+                            vertices: [
+                              {
+                                x: -800,
+                                y: -1330,
+                                z: -1820
+                              },
+                              {
+                                x: 1650,
+                                y: -1330,
+                                z: -1820
+                              },
+                              {
+                                x: 1650,
+                                y: -1330,
+                                z: 1500
+                              },
+                              {
+                                x: -800,
+                                y: -1330,
+                                z: 1500
+                              }
+                            ]
+                          },
+                          init_pose: {
+                            position: {
+                              x: 0,
+                              y: 0,
+                              z: 0
+                            },
+                            orientation: {
+                              x: 0,
+                              y: 0,
+                              z: 0,
+                              w: 1
+                            }
+                          },
+                          id: "box"
+                        },
+                        {
+                          convex_hull: {
+                            vertices: [
+                              {
+                                x: -800,
+                                y: -1330,
+                                z: -1820
+                              },
+                              {
+                                x: -800,
+                                y: 1330,
+                                z: -1820
+                              },
+                              {
+                                x: -800,
+                                y: 1330,
+                                z: 1500
+                              },
+                              {
+                                x: -800,
+                                y: -1330,
+                                z: 1500
+                              }
+                            ]
+                          },
+                          init_pose: {
+                            position: {
+                              x: 0,
+                              y: 0,
+                              z: 0
+                            },
+                            orientation: {
+                              x: 0,
+                              y: 0,
+                              z: 0,
+                              w: 1
+                            }
+                          },
+                          id: "box"
+                        },
+                        {
+                          convex_hull: {
+                            vertices: [
+                              {
+                                x: 1650,
+                                y: 1330,
+                                z: 1500
+                              },
+                              {
+                                x: -800,
+                                y: 1330,
+                                z: 1500
+                              },
+                              {
+                                x: -800,
+                                y: -1330,
+                                z: 1500
+                              },
+                              {
+                                x: 1650,
+                                y: -1330,
+                                z: 1500
+                              }
+                            ]
+                          },
+                          init_pose: {
+                            position: {
+                              x: 0,
+                              y: 0,
+                              z: 0
+                            },
+                            orientation: {
+                              x: 0,
+                              y: 0,
+                              z: 0,
+                              w: 1
+                            }
+                          },
+                          id: "box"
+                        },
+                        {
+                          convex_hull: {
+                            vertices: [
+                              {
+                                x: 1650,
+                                y: 1330,
+                                z: 1500
+                              },
+                              {
+                                x: -800,
+                                y: 1330,
+                                z: 1500
+                              },
+                              {
+                                x: -800,
+                                y: 1330,
+                                z: -1820
+                              },
+                              {
+                                x: 1650,
+                                y: 1330,
+                                z: -1820
+                              }
+                            ]
+                          },
+                          init_pose: {
+                            position: {
+                              x: 0,
+                              y: 0,
+                              z: 0
+                            },
+                            orientation: {
+                              x: 0,
+                              y: 0,
+                              z: 0,
+                              w: 1
+                            }
+                          },
+                          id: "box"
+                        },
+                        {
+                          convex_hull: {
+                            vertices: [
+                              {
+                                x: 1650,
+                                y: 1330,
+                                z: 1500
+                              },
+                              {
+                                x: 1650,
+                                y: -1330,
+                                z: 1500
+                              },
+                              {
+                                x: 1650,
+                                y: -1330,
+                                z: -1820
+                              },
+                              {
+                                x: 1650,
+                                y: 1330,
+                                z: -1820
+                              }
+                            ]
+                          },
+                          init_pose: {
+                            position: {
+                              x: 0,
+                              y: 0,
+                              z: 0
+                            },
+                            orientation: {
+                              x: 0,
+                              y: 0,
+                              z: 0,
+                              w: 1
+                            }
+                          },
+                          id: "box"
+                        }
+                      ]
+                    },
+                    init_pose: {
+                      position: {
+                        x: 0,
+                        y: 0,
+                        z: 0
+                      },
+                      orientation: {
+                        x: 0,
+                        y: 0,
+                        z: 0,
+                        w: 1
+                      }
+                    },
+                    id: "Cell workzone"
+                  },
+                  motion_group_uid: 1
+                },
+                {
+                  id: 2,
+                  priority: 0,
+                  geometry: {
+                    convex_hull: {
+                      vertices: [
+                        {
+                          x: 1650,
+                          y: 1330,
+                          z: -1850
+                        },
+                        {
+                          x: 865,
+                          y: 1330,
+                          z: -1850
+                        },
+                        {
+                          x: 865,
+                          y: -720,
+                          z: -1850
+                        },
+                        {
+                          x: 1650,
+                          y: -720,
+                          z: -1850
+                        },
+                        {
+                          x: 1650,
+                          y: 1330,
+                          z: -920
+                        },
+                        {
+                          x: 865,
+                          y: 1330,
+                          z: -920
+                        },
+                        {
+                          x: 865,
+                          y: -720,
+                          z: -920
+                        },
+                        {
+                          x: 1650,
+                          y: -720,
+                          z: -920
+                        }
+                      ]
+                    },
+                    init_pose: {
+                      position: {
+                        x: 0,
+                        y: 0,
+                        z: 0
+                      },
+                      orientation: {
+                        x: 0,
+                        y: 0,
+                        z: 0,
+                        w: 1
+                      }
+                    },
+                    id: "Transport"
+                  },
+                  motion_group_uid: 1
+                },
+                {
+                  id: 3,
+                  priority: 0,
+                  geometry: {
+                    convex_hull: {
+                      vertices: [
+                        {
+                          x: 1650,
+                          y: 1330,
+                          z: -600
+                        },
+                        {
+                          x: 865,
+                          y: 1330,
+                          z: -600
+                        },
+                        {
+                          x: 865,
+                          y: 430,
+                          z: -600
+                        },
+                        {
+                          x: 1650,
+                          y: 430,
+                          z: -600
+                        },
+                        {
+                          x: 1650,
+                          y: 1330,
+                          z: -1250
+                        },
+                        {
+                          x: 865,
+                          y: 1330,
+                          z: -1250
+                        },
+                        {
+                          x: 865,
+                          y: 430,
+                          z: -1250
+                        },
+                        {
+                          x: 1650,
+                          y: 430,
+                          z: -1250
+                        }
+                      ]
+                    },
+                    init_pose: {
+                      position: {
+                        x: 0,
+                        y: 0,
+                        z: 0
+                      },
+                      orientation: {
+                        x: 0,
+                        y: 0,
+                        z: 0,
+                        w: 1
+                      }
+                    },
+                    id: "Tunel"
+                  },
+                  motion_group_uid: 1
+                },
+                {
+                  id: 4,
+                  priority: 0,
+                  geometry: {
+                    convex_hull: {
+                      vertices: [
+                        {
+                          x: 1650,
+                          y: -760,
+                          z: -440
+                        },
+                        {
+                          x: 900,
+                          y: -760,
+                          z: -440
+                        },
+                        {
+                          x: 900,
+                          y: -1330,
+                          z: -440
+                        },
+                        {
+                          x: 1650,
+                          y: -1330,
+                          z: -440
+                        },
+                        {
+                          x: 1650,
+                          y: -760,
+                          z: -1800
+                        },
+                        {
+                          x: 900,
+                          y: -760,
+                          z: -1800
+                        },
+                        {
+                          x: 900,
+                          y: -1330,
+                          z: -1800
+                        },
+                        {
+                          x: 1650,
+                          y: -1330,
+                          z: -1800
+                        }
+                      ]
+                    },
+                    init_pose: {
+                      position: {
+                        x: 0,
+                        y: 0,
+                        z: 0
+                      },
+                      orientation: {
+                        x: 0,
+                        y: 0,
+                        z: 0,
+                        w: 1
+                      }
+                    },
+                    id: "Fanuc controller"
+                  },
+                  motion_group_uid: 1
+                },
+                {
+                  id: 6,
+                  priority: 0,
+                  geometry: {
+                    convex_hull: {
+                      vertices: [
+                        {
+                          x: -200,
+                          y: -200,
+                          z: -1900
+                        },
+                        {
+                          x: 200,
+                          y: -200,
+                          z: -1900
+                        },
+                        {
+                          x: 200,
+                          y: 200,
+                          z: -1900
+                        },
+                        {
+                          x: -200,
+                          y: 200,
+                          z: -1900
+                        },
+                        {
+                          x: -200,
+                          y: -200,
+                          z: -350
+                        },
+                        {
+                          x: 200,
+                          y: -200,
+                          z: -350
+                        },
+                        {
+                          x: 200,
+                          y: 200,
+                          z: -350
+                        },
+                        {
+                          x: -200,
+                          y: 200,
+                          z: -350
+                        }
+                      ]
+                    },
+                    init_pose: {
+                      position: {
+                        x: 0,
+                        y: 0,
+                        z: 0
+                      },
+                      orientation: {
+                        x: 0,
+                        y: 0,
+                        z: 0,
+                        w: 1
+                      }
+                    },
+                    id: "Robot base"
+                  },
+                  motion_group_uid: 1
+                }
+              ],
+              robot_model_geometries: [
+                {
+                  link_index: 1,
+                  geometry: {
+                    sphere: {
+                      radius: 270
+                    },
+                    init_pose: {
+                      position: {
+                        x: -70,
+                        y: -70,
+                        z: -50
+                      },
+                      orientation: {
+                        x: 0,
+                        y: 0,
+                        z: 0,
+                        w: 1
+                      }
+                    },
+                    id: "link1_sphere"
+                  }
+                },
+                {
+                  link_index: 2,
+                  geometry: {
+                    capsule: {
+                      radius: 160,
+                      cylinder_height: 800
+                    },
+                    init_pose: {
+                      position: {
+                        x: -450,
+                        y: 40,
+                        z: 170
+                      },
+                      orientation: {
+                        x: 0,
+                        y: -0.7071067811865475,
+                        z: 0,
+                        w: 0.7071067811865476
+                      }
+                    },
+                    id: "link2_capsule"
+                  }
+                },
+                {
+                  link_index: 3,
+                  geometry: {
+                    sphere: {
+                      radius: 270
+                    },
+                    init_pose: {
+                      position: {
+                        x: -110,
+                        y: 10,
+                        z: -100
+                      },
+                      orientation: {
+                        x: 0,
+                        y: 0,
+                        z: 0,
+                        w: 1
+                      }
+                    },
+                    id: "link3_sphere"
+                  }
+                },
+                {
+                  link_index: 4,
+                  geometry: {
+                    capsule: {
+                      radius: 110,
+                      cylinder_height: 600
+                    },
+                    init_pose: {
+                      position: {
+                        x: 0,
+                        y: 300,
+                        z: 40
+                      },
+                      orientation: {
+                        x: -0.7071067811865475,
+                        y: 0,
+                        z: 0,
+                        w: 0.7071067811865476
+                      }
+                    },
+                    id: "link4_capsule"
+                  }
+                },
+                {
+                  link_index: 5,
+                  geometry: {
+                    sphere: {
+                      radius: 75
+                    },
+                    init_pose: {
+                      position: {
+                        x: 0,
+                        y: 0,
+                        z: -50
+                      },
+                      orientation: {
+                        x: 0,
+                        y: 0,
+                        z: 0,
+                        w: 1
+                      }
+                    },
+                    id: "link5_sphere"
+                  }
+                }
+              ],
+              tool_geometries: []
+            };
+          }
+        },
+        {
+          method: "GET",
+          path: "/cells/:cellId/coordinate-systems",
+          handle() {
+            return {
+              coordinatesystems: [
+                {
+                  coordinate_system: "",
+                  name: "world",
+                  reference_uid: "",
+                  position: {
+                    x: 0,
+                    y: 0,
+                    z: 0
+                  },
+                  rotation: {
+                    angles: [0, 0, 0],
+                    type: "ROTATION_VECTOR"
+                  }
+                }
+              ]
+            };
+          }
+        },
+        {
+          method: "GET",
+          path: "/cells/:cellId/motion-groups/:motionGroupId/tcps",
+          handle() {
+            return {
+              tcps: [
+                {
+                  id: "Flange",
+                  readable_name: "Default-Flange",
+                  position: {
+                    x: 0,
+                    y: 0,
+                    z: 0
+                  },
+                  rotation: {
+                    angles: [0, 0, 0, 0],
+                    type: "ROTATION_VECTOR"
+                  }
+                },
+                {
+                  id: "complex-tcp-position",
+                  readable_name: "Complex TCP Position",
+                  position: {
+                    x: -200,
+                    y: 300,
+                    z: 150
+                  },
+                  rotation: {
+                    angles: [
+                      -0.12139440409113832,
+                      -0.06356210998212003,
+                      -0.2023240068185639,
+                      0
+                    ],
+                    type: "ROTATION_VECTOR"
+                  }
+                }
+              ]
+            };
+          }
+        }
+      ];
+      const method = ((_a = config.method) == null ? void 0 : _a.toUpperCase()) || "GET";
+      const path = "/cells" + ((_c = (_b = config.url) == null ? void 0 : _b.split("/cells")[1]) == null ? void 0 : _c.split("?")[0]);
+      for (const handler of apiHandlers) {
+        const match2 = pathToRegexp.match(handler.path)(path || "");
+        if (method === handler.method && match2) {
+          const json = handler.handle();
+          return {
+            status: 200,
+            statusText: "Success",
+            data: JSON.stringify(json),
+            headers: {},
+            config,
+            request: {
+              responseURL: config.url
+            }
+          };
+        }
+      }
+      throw new AxiosError(
+        `No mock handler matched this request: ${method} ${path}`,
+        "404",
+        config
+      );
+    });
+  }
+  handleWebsocketConnection(socket) {
+    this.connections.push(socket);
+    setTimeout(() => {
+      socket.dispatchEvent(new Event("open"));
+      console.log("Websocket connection opened from", socket.url);
+      if (socket.url.includes("/state-stream")) {
+        socket.dispatchEvent(
+          new MessageEvent("message", {
+            data: JSON.stringify(defaultMotionState)
+          })
+        );
+      }
+      if (socket.url.includes("/move-joint")) {
+        socket.dispatchEvent(
+          new MessageEvent("message", {
+            data: JSON.stringify({
+              result: {
+                motion_group: "0@ur",
+                state: {
+                  controller: "ur",
+                  operation_mode: "OPERATION_MODE_AUTO",
+                  safety_state: "SAFETY_STATE_NORMAL",
+                  timestamp: "2024-09-18T12:48:26.096266444Z",
+                  velocity_override: 100,
+                  motion_groups: [
+                    {
+                      motion_group: "0@ur",
+                      controller: "ur",
+                      joint_position: {
+                        joints: [
+                          1.3492152690887451,
+                          -1.5659207105636597,
+                          1.6653711795806885,
+                          -1.0991662740707397,
+                          -1.829018235206604,
+                          1.264623761177063
+                        ]
+                      },
+                      joint_velocity: {
+                        joints: [0, 0, 0, 0, 0, 0]
+                      },
+                      flange_pose: {
+                        position: {
+                          x: 6.437331889439328,
+                          y: -628.4123774830913,
+                          z: 577.0569957147832
+                        },
+                        orientation: {
+                          x: -1.683333649797158,
+                          y: -1.9783363827298732,
+                          z: -0.4928031860165713
+                        },
+                        coordinate_system: ""
+                      },
+                      tcp_pose: {
+                        position: {
+                          x: 6.437331889439328,
+                          y: -628.4123774830913,
+                          z: 577.0569957147832
+                        },
+                        orientation: {
+                          x: -1.683333649797158,
+                          y: -1.9783363827298732,
+                          z: -0.4928031860165713
+                        },
+                        coordinate_system: "",
+                        tcp: "Flange"
+                      },
+                      velocity: {
+                        linear: {
+                          x: 0,
+                          y: 0,
+                          z: 0
+                        },
+                        angular: {
+                          x: -0,
+                          y: 0,
+                          z: 0
+                        },
+                        coordinate_system: ""
+                      },
+                      force: {
+                        force: {
+                          x: 0,
+                          y: 0,
+                          z: 0
+                        },
+                        moment: {
+                          x: 0,
+                          y: 0,
+                          z: 0
+                        },
+                        coordinate_system: ""
+                      },
+                      joint_limit_reached: {
+                        limit_reached: [
+                          false,
+                          false,
+                          false,
+                          false,
+                          false,
+                          false
+                        ]
+                      },
+                      joint_current: {
+                        joints: [0, 0, 0, 0, 0, 0]
+                      },
+                      sequence_number: "671259"
+                    }
+                  ],
+                  sequence_number: "671259"
+                },
+                movement_state: "MOVEMENT_STATE_MOVING"
+              }
+            })
+          })
+        );
+      }
+      if (socket.url.includes("/move-tcp")) {
+        socket.dispatchEvent(
+          new MessageEvent("message", {
+            data: JSON.stringify({
+              result: {
+                motion_group: "0@ur",
+                state: {
+                  controller: "ur",
+                  operation_mode: "OPERATION_MODE_AUTO",
+                  safety_state: "SAFETY_STATE_NORMAL",
+                  timestamp: "2024-09-18T12:43:12.188335774Z",
+                  velocity_override: 100,
+                  motion_groups: [
+                    {
+                      motion_group: "0@ur",
+                      controller: "ur",
+                      joint_position: {
+                        joints: [
+                          1.3352527618408203,
+                          -1.5659207105636597,
+                          1.6653711795806885,
+                          -1.110615611076355,
+                          -1.829018235206604,
+                          1.264623761177063
+                        ]
+                      },
+                      joint_velocity: {
+                        joints: [0, 0, 0, 0, 0, 0]
+                      },
+                      flange_pose: {
+                        position: {
+                          x: -2.763015284002938,
+                          y: -630.2151479701106,
+                          z: 577.524509114342
+                        },
+                        orientation: {
+                          x: -1.704794877102097,
+                          y: -1.9722372952861567,
+                          z: -0.4852079204210754
+                        },
+                        coordinate_system: ""
+                      },
+                      tcp_pose: {
+                        position: {
+                          x: -2.763015284002938,
+                          y: -630.2151479701106,
+                          z: 577.524509114342
+                        },
+                        orientation: {
+                          x: -1.704794877102097,
+                          y: -1.9722372952861567,
+                          z: -0.4852079204210754
+                        },
+                        coordinate_system: "",
+                        tcp: "Flange"
+                      },
+                      velocity: {
+                        linear: {
+                          x: 0,
+                          y: 0,
+                          z: 0
+                        },
+                        angular: {
+                          x: -0,
+                          y: 0,
+                          z: 0
+                        },
+                        coordinate_system: ""
+                      },
+                      force: {
+                        force: {
+                          x: 0,
+                          y: 0,
+                          z: 0
+                        },
+                        moment: {
+                          x: 0,
+                          y: 0,
+                          z: 0
+                        },
+                        coordinate_system: ""
+                      },
+                      joint_limit_reached: {
+                        limit_reached: [
+                          false,
+                          false,
+                          false,
+                          false,
+                          false,
+                          false
+                        ]
+                      },
+                      joint_current: {
+                        joints: [0, 0, 0, 0, 0, 0]
+                      },
+                      sequence_number: "627897"
+                    }
+                  ],
+                  sequence_number: "627897"
+                },
+                movement_state: "MOVEMENT_STATE_MOVING"
+              }
+            })
+          })
+        );
+      }
+    }, 10);
+  }
+  handleWebsocketMessage(socket, message) {
+    console.log(`Received message on ${socket.url}`, message);
+  }
+};
+var defaultMotionState = {
+  result: {
+    state: {
+      motion_group: "0@universalrobots-ur5e",
+      controller: "universalrobots-ur5e",
+      joint_position: {
+        joints: [
+          1.1699999570846558,
+          -1.5700000524520874,
+          1.3600000143051147,
+          1.0299999713897705,
+          1.2899999618530273,
+          1.2799999713897705
+        ]
+      },
+      joint_velocity: {
+        joints: [0, 0, 0, 0, 0, 0]
+      },
+      flange_pose: {
+        position: {
+          x: 1.3300010259703043,
+          y: -409.2680714682808,
+          z: 531.0203477065281
+        },
+        orientation: {
+          x: 1.7564919306270736,
+          y: -1.7542521568325058,
+          z: 0.7326972590614671
+        },
+        coordinate_system: ""
+      },
+      tcp_pose: {
+        position: {
+          x: 1.3300010259703043,
+          y: -409.2680714682808,
+          z: 531.0203477065281
+        },
+        orientation: {
+          x: 1.7564919306270736,
+          y: -1.7542521568325058,
+          z: 0.7326972590614671
+        },
+        coordinate_system: "",
+        tcp: "Flange"
+      },
+      velocity: {
+        linear: {
+          x: 0,
+          y: 0,
+          z: 0
+        },
+        angular: {
+          x: 0,
+          y: 0,
+          z: 0
+        },
+        coordinate_system: ""
+      },
+      force: {
+        force: {
+          x: 0,
+          y: 0,
+          z: 0
+        },
+        moment: {
+          x: 0,
+          y: 0,
+          z: 0
+        },
+        coordinate_system: ""
+      },
+      joint_limit_reached: {
+        limit_reached: [false, false, false, false, false, false]
+      },
+      joint_current: {
+        joints: [0, 0, 0, 0, 0, 0]
+      }
+    },
+    tcp_pose: {
+      position: {
+        x: 302.90748476115556,
+        y: -152.87065869452337,
+        z: 424.0454619321661
+      },
+      orientation: {
+        x: 2.3403056115045353,
+        y: -1.1706836379431356,
+        z: 0.9772511964246311
+      },
+      coordinate_system: "",
+      tcp: "Flange"
+    }
+  }
+};
+
+// src/lib/v1/NovaClient.ts
+var NovaClient = class {
+  constructor(config) {
+    this.authPromise = null;
+    this.accessToken = null;
+    var _a;
+    const cellId = (_a = config.cellId) != null ? _a : "cell";
+    this.config = __spreadValues({
+      cellId
+    }, config);
+    this.accessToken = config.accessToken || availableStorage.getString("wbjs.access_token") || null;
+    if (this.config.instanceUrl === "https://mock.example.com") {
+      this.mock = new MockNovaInstance();
+    }
+    const axiosInstance = axios2.create({
+      baseURL: urlJoin(this.config.instanceUrl, "/api/v1")
+    });
+    axiosInstance.interceptors.request.use((request) => __async(this, null, function* () {
+      if (!request.headers.Authorization) {
+        if (this.accessToken) {
+          request.headers.Authorization = `Bearer ${this.accessToken}`;
+        } else if (this.config.username && this.config.password) {
+          request.headers.Authorization = `Basic ${btoa(config.username + ":" + config.password)}`;
+        }
+      }
+      return request;
+    }));
+    if (typeof window !== "undefined") {
+      axiosInstance.interceptors.response.use(
+        (r) => r,
+        (error) => __async(this, null, function* () {
+          var _a2, _b;
+          if (isAxiosError(error)) {
+            if (((_a2 = error.response) == null ? void 0 : _a2.status) === 401) {
+              try {
+                yield this.renewAuthentication();
+                if (error.config) {
+                  if (this.accessToken) {
+                    error.config.headers.Authorization = `Bearer ${this.accessToken}`;
+                  } else {
+                    delete error.config.headers.Authorization;
+                  }
+                  return axiosInstance.request(error.config);
+                }
+              } catch (err) {
+                return Promise.reject(err);
+              }
+            } else if (((_b = error.response) == null ? void 0 : _b.status) === 503) {
+              const res = yield fetch(window.location.href);
+              if (res.status === 503) {
+                window.location.reload();
+              }
+            }
+          }
+          return Promise.reject(error);
+        })
+      );
+    }
+    this.api = new NovaCellAPIClient(cellId, __spreadProps(__spreadValues({}, config), {
+      basePath: urlJoin(this.config.instanceUrl, "/api/v1"),
+      isJsonMime: (mime) => {
+        return mime === "application/json";
+      },
+      baseOptions: __spreadValues(__spreadValues({}, this.mock ? {
+        adapter: (config2) => {
+          return this.mock.handleAPIRequest(config2);
+        }
+      } : {}), config.baseOptions),
+      axiosInstance
+    }));
+  }
+  renewAuthentication() {
+    return __async(this, null, function* () {
+      if (this.authPromise) {
+        return;
+      }
+      this.authPromise = loginWithAuth0(this.config.instanceUrl);
+      try {
+        this.accessToken = yield this.authPromise;
+        if (this.accessToken) {
+          availableStorage.setString("wbjs.access_token", this.accessToken);
+        } else {
+          availableStorage.delete("wbjs.access_token");
+        }
+      } finally {
+        this.authPromise = null;
+      }
+    });
+  }
+  makeWebsocketURL(path) {
+    const url = new URL(
+      urlJoin(
+        this.config.instanceUrl,
+        `/api/v1/cells/${this.config.cellId}`,
+        path
+      )
+    );
+    url.protocol = url.protocol.replace("http", "ws");
+    url.protocol = url.protocol.replace("https", "wss");
+    if (this.accessToken) {
+      url.searchParams.append("token", this.accessToken);
+    } else if (this.config.username && this.config.password) {
+      url.username = this.config.username;
+      url.password = this.config.password;
+    }
+    return url.toString();
+  }
+  /**
+   * Retrieve an AutoReconnectingWebsocket to the given path on the Nova instance.
+   * If you explicitly want to reconnect an existing websocket, call `reconnect`
+   * on the returned object.
+   */
+  openReconnectingWebsocket(path) {
+    return new AutoReconnectingWebsocket(this.makeWebsocketURL(path), {
+      mock: this.mock
+    });
+  }
+  /**
+   * Connect to the motion state websocket(s) for a given motion group
+   */
+  connectMotionStream(motionGroupId) {
+    return __async(this, null, function* () {
+      return yield MotionStreamConnection.open(this, motionGroupId);
+    });
+  }
+  /**
+   * Connect to the jogging websocket(s) for a given motion group
+   */
+  connectJogger(motionGroupId) {
+    return __async(this, null, function* () {
+      return yield JoggerConnection.open(this, motionGroupId);
+    });
+  }
+  connectMotionGroups(motionGroupIds) {
+    return __async(this, null, function* () {
+      const { instances } = yield this.api.controller.listControllers();
+      return Promise.all(
+        motionGroupIds.map(
+          (motionGroupId) => ConnectedMotionGroup.connect(this, motionGroupId, instances)
+        )
+      );
+    });
+  }
+  connectMotionGroup(motionGroupId) {
+    return __async(this, null, function* () {
+      const motionGroups = yield this.connectMotionGroups([motionGroupId]);
+      return motionGroups[0];
+    });
+  }
+};
+
+// src/lib/v1/ProgramStateConnection.ts
+import { AxiosError as AxiosError2 } from "axios";
+import { makeAutoObservable as makeAutoObservable3, runInAction as runInAction3 } from "mobx";
+var ProgramState = /* @__PURE__ */ ((ProgramState2) => {
+  ProgramState2["NotStarted"] = "not started";
+  ProgramState2["Running"] = "running";
+  ProgramState2["Stopped"] = "stopped";
+  ProgramState2["Failed"] = "failed";
+  ProgramState2["Completed"] = "completed";
+  return ProgramState2;
+})(ProgramState || {});
+var ProgramStateConnection = class {
+  constructor(nova) {
+    this.nova = nova;
+    this.currentProgram = {};
+    this.logs = [];
+    this.executionState = "idle";
+    this.currentlyExecutingProgramRunnerId = null;
+    makeAutoObservable3(this, {}, { autoBind: true });
+    this.programStateSocket = nova.openReconnectingWebsocket(`/programs/state`);
+    this.programStateSocket.addEventListener("message", (ev) => {
+      const msg = tryParseJson(ev.data);
+      if (!msg) {
+        console.error("Failed to parse program state message", ev.data);
+        return;
+      }
+      if (msg.type === "update") {
+        this.handleProgramStateMessage(msg);
+      }
+    });
+  }
+  /** Handle a program state update from the backend */
+  handleProgramStateMessage(msg) {
+    return __async(this, null, function* () {
+      var _a;
+      const { runner } = msg;
+      if (runner.id !== this.currentlyExecutingProgramRunnerId) return;
+      if (runner.state === "failed" /* Failed */) {
+        try {
+          const runnerState = yield this.nova.api.program.getProgramRunner(
+            runner.id
+          );
+          const stdout = runnerState.stdout;
+          if (stdout) {
+            this.log(stdout);
+          }
+          this.logError(
+            `Program runner ${runner.id} failed with error: ${runnerState.error}
+${runnerState.traceback}`
+          );
+        } catch (err) {
+          this.logError(
+            `Failed to retrieve results for program ${runner.id}: ${err}`
+          );
+        }
+        this.currentProgram.state = "failed" /* Failed */;
+        this.gotoIdleState();
+      } else if (runner.state === "stopped" /* Stopped */) {
+        try {
+          const runnerState = yield this.nova.api.program.getProgramRunner(
+            runner.id
+          );
+          const stdout = runnerState.stdout;
+          if (stdout) {
+            this.log(stdout);
+          }
+          this.currentProgram.state = "stopped" /* Stopped */;
+          this.log(`Program runner ${runner.id} stopped`);
+        } catch (err) {
+          this.logError(
+            `Failed to retrieve results for program ${runner.id}: ${err}`
+          );
+        }
+        this.gotoIdleState();
+      } else if (runner.state === "completed" /* Completed */) {
+        try {
+          const runnerState = yield this.nova.api.program.getProgramRunner(
+            runner.id
+          );
+          const stdout = runnerState.stdout;
+          if (stdout) {
+            this.log(stdout);
+          }
+          this.log(
+            `Program runner ${runner.id} finished successfully in ${(_a = runner.execution_time) == null ? void 0 : _a.toFixed(2)} seconds`
+          );
+          this.currentProgram.state = "completed" /* Completed */;
+        } catch (err) {
+          this.logError(
+            `Failed to retrieve results for program ${runner.id}: ${err}`
+          );
+        }
+        this.gotoIdleState();
+      } else if (runner.state === "running" /* Running */) {
+        this.currentProgram.state = "running" /* Running */;
+        this.log(`Program runner ${runner.id} now running`);
+      } else if (runner.state !== "not started" /* NotStarted */) {
+        console.error(runner);
+        this.logError(
+          `Program runner ${runner.id} entered unexpected state: ${runner.state}`
+        );
+        this.currentProgram.state = "not started" /* NotStarted */;
+        this.gotoIdleState();
+      }
+    });
+  }
+  /** Call when a program is no longer executing */
+  gotoIdleState() {
+    runInAction3(() => {
+      this.executionState = "idle";
+    });
+    this.currentlyExecutingProgramRunnerId = null;
+  }
+  executeProgram(wandelscript, initial_state, activeRobot) {
+    return __async(this, null, function* () {
+      this.currentProgram = {
+        wandelscript,
+        state: "not started" /* NotStarted */
+      };
+      const { currentProgram: openProgram } = this;
+      if (!openProgram) return;
+      runInAction3(() => {
+        this.executionState = "starting";
+      });
+      if (activeRobot) {
+        try {
+          yield this.nova.api.motionGroupJogging.stopJogging(
+            activeRobot.motionGroupId
+          );
+        } catch (err) {
+          console.error(err);
+        }
+      }
+      const trimmedCode = openProgram.wandelscript.replaceAll(/^\s*$/gm, "");
+      try {
+        const programRunnerRef = yield this.nova.api.program.createProgramRunner(
+          {
+            code: trimmedCode,
+            initial_state,
+            default_robot: activeRobot == null ? void 0 : activeRobot.wandelscriptIdentifier
+          },
+          {
+            headers: {
+              "Content-Type": "application/json"
+            }
+          }
+        );
+        this.log(`Created program runner ${programRunnerRef.id}"`);
+        runInAction3(() => {
+          this.executionState = "executing";
+        });
+        this.currentlyExecutingProgramRunnerId = programRunnerRef.id;
+      } catch (error) {
+        if (error instanceof AxiosError2 && error.response && error.request) {
+          this.logError(
+            `${error.response.status} ${error.response.statusText} from ${error.response.config.url} ${JSON.stringify(error.response.data)}`
+          );
+        } else {
+          this.logError(JSON.stringify(error));
+        }
+        runInAction3(() => {
+          this.executionState = "idle";
+        });
+      }
+    });
+  }
+  stopProgram() {
+    return __async(this, null, function* () {
+      if (!this.currentlyExecutingProgramRunnerId) return;
+      runInAction3(() => {
+        this.executionState = "stopping";
+      });
+      try {
+        yield this.nova.api.program.stopProgramRunner(
+          this.currentlyExecutingProgramRunnerId
+        );
+      } catch (err) {
+        runInAction3(() => {
+          this.executionState = "executing";
+        });
+        throw err;
+      }
+    });
+  }
+  reset() {
+    this.currentProgram = {};
+  }
+  log(message) {
+    console.log(message);
+    this.logs.push({
+      timestamp: Date.now(),
+      message
+    });
+  }
+  logError(message) {
+    console.log(message);
+    this.logs.push({
+      timestamp: Date.now(),
+      message,
+      level: "error"
+    });
+  }
+};
+export {
+  ConnectedMotionGroup,
+  JoggerConnection,
+  MotionStreamConnection,
+  NovaCellAPIClient,
+  NovaClient,
+  ProgramState,
+  ProgramStateConnection,
+  getLatestTrajectories
+};
+//# sourceMappingURL=index.js.map