@wandelbots/wandelbots-js-react-components 6.2.0 → 6.3.0-pr.ci-nova-dev-instance.642.8f90013

package/dist/chunks/MotionGroupVisualizer-DshWR1wY.js

@@ -0,0 +1,1653 @@
+import { jsx as r, jsxs as R, Fragment as W } from "react/jsx-runtime";
+import * as w from "three";
+import { Matrix4 as M, Vector3 as L, Quaternion as D } from "three";
+import { ConvexGeometry as ft, RoundedBoxGeometry as Ot } from "three-stdlib";
+import { Line as J, Environment as Gt, Lightformer as G, useGLTF as Et, Bounds as ot } from "@react-three/drei";
+import Ft, { useMemo as k, forwardRef as Ct, useRef as _, useImperativeHandle as Dt, useEffect as E, useState as A, useCallback as O, Suspense as gt } from "react";
+import { d as Ut, v as Vt, o as jt, e as F } from "./externalizeComponent-EDymnaGR.js";
+import { useTheme as Nt } from "@mui/material/styles";
+import S from "@mui/material/Box";
+import it from "@mui/material/Button";
+import Bt from "@mui/material/Card";
+import st from "@mui/material/Divider";
+import at from "@mui/material/Typography";
+import { useThree as yt, Canvas as ct } from "@react-three/fiber";
+import { observer as Wt } from "mobx-react-lite";
+import { useTranslation as Jt } from "react-i18next";
+import { c as wt, g as Z, b as lt } from "./useSmoothedMotionState-DyDgSVYX.js";
+import { Nova as Ht, Manufacturer as T, JointTypeEnum as B } from "@wandelbots/nova-js/v2";
+import { ErrorBoundary as bt } from "react-error-boundary";
+function $t(t) {
+  switch (t.shape_type) {
+    case "convex_hull":
+      return new ft(
+        t.vertices.map(
+          (e) => new w.Vector3(
+            e[0] / 1e3,
+            e[1] / 1e3,
+            e[2] / 1e3
+          )
+        )
+      );
+    case "box":
+      return new w.BoxGeometry(
+        t.size_x / 1e3,
+        t.size_y / 1e3,
+        t.size_z / 1e3
+      );
+    case "sphere":
+      return new w.SphereGeometry(t.radius / 1e3);
+    case "capsule":
+      return new w.CapsuleGeometry(
+        t.radius / 1e3,
+        t.cylinder_height / 1e3
+      );
+    case "cylinder":
+      return new w.CylinderGeometry(
+        t.radius / 1e3,
+        t.radius / 1e3,
+        t.height / 1e3
+      );
+    case "rectangle":
+      return new w.BoxGeometry(t.size_x / 1e3, t.size_y / 1e3, 0);
+    default:
+      return console.warn(`${t.shape_type} is not supported`), new w.BufferGeometry();
+  }
+}
+function qt({
+  name: t,
+  collider: n,
+  children: e
+}) {
+  var l, c;
+  const s = ((l = n.pose) == null ? void 0 : l.position) ?? [0, 0, 0], o = ((c = n.pose) == null ? void 0 : c.orientation) ?? [0, 0, 0];
+  return n.margin && console.warn(`${t} margin is not supported`), /* @__PURE__ */ r(
+    "mesh",
+    {
+      name: t,
+      position: new w.Vector3(
+        s[0],
+        s[1],
+        s[2]
+      ).divideScalar(1e3),
+      rotation: new w.Euler(o[0], o[1], o[2], "XYZ"),
+      geometry: $t(n.shape),
+      children: e
+    }
+  );
+}
+function Qt({
+  name: t,
+  colliders: n,
+  meshChildrenProvider: e,
+  ...s
+}) {
+  return /* @__PURE__ */ r("group", { name: t, ...s, children: Object.entries(n).map(([o, l]) => /* @__PURE__ */ r(
+    qt,
+    {
+      name: o,
+      collider: l,
+      children: e(o, l)
+    },
+    o
+  )) });
+}
+function Ve({
+  scene: t,
+  meshChildrenProvider: n
+}) {
+  const e = t.colliders;
+  return /* @__PURE__ */ r("group", { children: e && /* @__PURE__ */ r(
+    Qt,
+    {
+      meshChildrenProvider: n,
+      colliders: e
+    }
+  ) });
+}
+function Yt(t) {
+  const n = (t == null ? void 0 : t.position) ?? [], e = (t == null ? void 0 : t.orientation) ?? [], s = new L(
+    e[0] ?? 0,
+    e[1] ?? 0,
+    e[2] ?? 0
+  ), o = s.length(), l = o > 0 ? new D().setFromAxisAngle(s.normalize(), o) : new D();
+  return new M().compose(
+    new L(
+      n[0] ?? 0,
+      n[1] ?? 0,
+      n[2] ?? 0
+    ).divideScalar(1e3),
+    l,
+    new L(1, 1, 1)
+  );
+}
+function Xt(t, n = null, e = []) {
+  const s = Yt(n);
+  return t.map((o, l) => {
+    const c = s.clone(), i = (o.reverse_rotation_direction ? -1 : 1) * (e[l] ?? 0), p = o.type === "PRISMATIC_JOINT", a = (o.theta ?? 0) + (p ? 0 : i), h = (o.d ?? 0) + (p ? i : 0);
+    return s.multiply(new M().makeRotationZ(a)).multiply(
+      new M().makeTranslation((o.a ?? 0) / 1e3, 0, h / 1e3)
+    ).multiply(new M().makeRotationX(o.alpha ?? 0)), c;
+  });
+}
+const q = "#ff4b4b", ut = "#2fa8ff", Zt = "#8a8d9e", Kt = 96, zt = 0.15, te = new w.Vector3(0, 1, 0), ee = 0.2, ne = 2;
+function re(t) {
+  const { lower_limit: n, upper_limit: e } = t ?? {};
+  return typeof n != "number" || typeof e != "number" || !Number.isFinite(n) || !Number.isFinite(e) || !(n < e) ? null : { lower_limit: n, upper_limit: e };
+}
+function Q({
+  base: t,
+  direction: n,
+  size: e,
+  color: s,
+  opacity: o
+}) {
+  const l = new w.Quaternion().setFromUnitVectors(
+    te,
+    n.clone().normalize()
+  ), c = t.clone().addScaledVector(n.clone().normalize(), e / 2);
+  return /* @__PURE__ */ R("mesh", { position: c, quaternion: l, renderOrder: 10, children: [
+    /* @__PURE__ */ r("coneGeometry", { args: [e * 0.35, e, 16] }),
+    /* @__PURE__ */ r(
+      "meshBasicMaterial",
+      {
+        color: s,
+        depthTest: !1,
+        transparent: !0,
+        opacity: o
+      }
+    )
+  ] });
+}
+function Y({
+  points: t,
+  color: n,
+  width: e,
+  opacity: s
+}) {
+  return /* @__PURE__ */ r(
+    J,
+    {
+      points: t,
+      color: n,
+      lineWidth: e,
+      depthTest: !1,
+      transparent: !0,
+      opacity: s,
+      renderOrder: 10
+    }
+  );
+}
+function pt(t, n) {
+  const e = [...t];
+  let s = n;
+  for (; e.length > 1; ) {
+    const o = e[e.length - 1], l = e[e.length - 2], c = o.distanceTo(l);
+    if (c > s)
+      return e[e.length - 1] = o.clone().lerp(l, s / c), e;
+    s -= c, e.pop();
+  }
+  return e;
+}
+function oe(t, n, e, s) {
+  const o = e * t, l = e * n, c = Math.abs(l - o), i = Math.max(
+    2,
+    Math.ceil(c / (2 * Math.PI) * Kt)
+  );
+  return Array.from({ length: i + 1 }, (p, a) => {
+    const h = o + (l - o) * a / i, u = c * a / i / (2 * Math.PI), g = s * (1 + zt * u);
+    return new w.Vector3(
+      Math.cos(h) * g,
+      Math.sin(h) * g,
+      0
+    );
+  });
+}
+function ie(t, n, e, s) {
+  const o = t.theta ?? 0, l = t.d ?? 0, c = t.type === "PRISMATIC_JOINT", i = t.reverse_rotation_direction ? -1 : 1, { lower_limit: p, upper_limit: a } = n;
+  return k(() => {
+    const h = new w.Matrix4().makeRotationZ(o).multiply(
+      new w.Matrix4().makeTranslation(0, 0, c ? l / 1e3 : 0)
+    ), u = (v, P, C) => new w.Vector3(v, P, C).applyMatrix4(h), g = new w.Vector3().applyMatrix4(h), f = u(0, 0, e), d = (c ? [
+      u(e * 0.25, 0, i * p / 1e3),
+      u(e * 0.25, 0, i * a / 1e3)
+    ] : oe(p, a, i, e * 0.6)).map((v) => c ? v : v.applyMatrix4(h)), m = u(c ? e * 0.25 : e * 0.6, 0, 0), b = d.slice(1).reduce((v, P, C) => v + P.distanceTo(d[C]), 0), y = Math.min(s, b / 3), x = pt(
+      pt(d, y).reverse(),
+      y
+    ).reverse();
+    return {
+      axisPoints: [g, f],
+      axisTip: f,
+      origin: g,
+      restPoints: [g, m],
+      range: d,
+      limitPoints: x,
+      rangeStart: x[0],
+      rangeEnd: x[x.length - 1]
+    };
+  }, [o, l, c, i, e, p, a, s]);
+}
+function se({
+  frame: t,
+  dh: n,
+  limit: e,
+  size: s,
+  emphasis: o
+}) {
+  const l = o === "highlighted" ? ne : 1, c = o === "dimmed" ? ee : 1, i = s * 0.2 * (o === "highlighted" ? 1.4 : 1), p = 2 * l, {
+    axisPoints: a,
+    axisTip: h,
+    origin: u,
+    restPoints: g,
+    range: f,
+    limitPoints: d,
+    rangeStart: m,
+    rangeEnd: b
+  } = ie(n, e, s, i), { position: y, quaternion: x } = k(() => {
+    const v = new w.Vector3(), P = new w.Quaternion();
+    return t.decompose(v, P, new w.Vector3()), { position: v, quaternion: P };
+  }, [t]);
+  return /* @__PURE__ */ R("group", { position: y, quaternion: x, children: [
+    /* @__PURE__ */ r(
+      Y,
+      {
+        points: a,
+        color: ut,
+        width: p,
+        opacity: c
+      }
+    ),
+    /* @__PURE__ */ r(
+      Q,
+      {
+        base: h,
+        direction: h.clone().sub(u),
+        size: i,
+        color: ut,
+        opacity: c
+      }
+    ),
+    /* @__PURE__ */ r(
+      Y,
+      {
+        points: g,
+        color: Zt,
+        width: 1.5 * l,
+        opacity: c
+      }
+    ),
+    /* @__PURE__ */ r(
+      Y,
+      {
+        points: d,
+        color: q,
+        width: p,
+        opacity: c
+      }
+    ),
+    /* @__PURE__ */ r(
+      Q,
+      {
+        base: m,
+        direction: f[0].clone().sub(m),
+        size: m.distanceTo(f[0]),
+        color: q,
+        opacity: c
+      }
+    ),
+    /* @__PURE__ */ r(
+      Q,
+      {
+        base: b,
+        direction: f[f.length - 1].clone().sub(b),
+        size: b.distanceTo(f[f.length - 1]),
+        color: q,
+        opacity: c
+      }
+    )
+  ] });
+}
+function je({
+  dhParameters: t,
+  chainOffset: n = null,
+  limits: e,
+  jointPositions: s,
+  size: o = 0.15,
+  highlightedJoint: l = null
+}) {
+  const c = k(
+    () => Xt(t, n, s),
+    [t, n, s]
+  );
+  return /* @__PURE__ */ r("group", { children: c.map((i, p) => {
+    const a = re(e[p]);
+    return a ? /* @__PURE__ */ r(
+      se,
+      {
+        frame: i,
+        dh: t[p],
+        limit: a,
+        size: o,
+        emphasis: l === null ? "normal" : l === p ? "highlighted" : "dimmed"
+      },
+      p
+    ) : null;
+  }) });
+}
+function mt() {
+  return /* @__PURE__ */ r(Gt, { frames: 1, children: /* @__PURE__ */ r(ce, {}) });
+}
+const ae = [2, 0, 2, 0, 2, 0, 2, 0];
+function ce({ positions: t = ae }) {
+  return /* @__PURE__ */ R(W, { children: [
+    /* @__PURE__ */ r(
+      G,
+      {
+        intensity: 5,
+        "rotation-x": Math.PI / 2,
+        position: [0, 5, -9],
+        scale: [10, 10, 1]
+      }
+    ),
+    /* @__PURE__ */ r("group", { rotation: [0, 0.5, 0], children: /* @__PURE__ */ r("group", { children: t.map((n, e) => /* @__PURE__ */ r(
+      G,
+      {
+        form: "circle",
+        intensity: 5,
+        rotation: [Math.PI / 2, 0, 0],
+        position: [n, 4, e * 4],
+        scale: [3, 1, 1]
+      },
+      e
+    )) }) }),
+    /* @__PURE__ */ r(
+      G,
+      {
+        intensity: 40,
+        "rotation-y": Math.PI / 2,
+        position: [-5, 1, -1],
+        scale: [20, 0.1, 1]
+      }
+    ),
+    /* @__PURE__ */ r(
+      G,
+      {
+        intensity: 20,
+        "rotation-y": -Math.PI,
+        position: [-5, -2, -1],
+        scale: [20, 0.1, 1]
+      }
+    ),
+    /* @__PURE__ */ r(
+      G,
+      {
+        "rotation-y": Math.PI / 2,
+        position: [-5, -1, -1],
+        scale: [20, 0.5, 1],
+        intensity: 5
+      }
+    ),
+    /* @__PURE__ */ r(
+      G,
+      {
+        "rotation-y": -Math.PI / 2,
+        position: [10, 1, 0],
+        scale: [20, 1, 1],
+        intensity: 10
+      }
+    ),
+    /* @__PURE__ */ r(
+      G,
+      {
+        form: "ring",
+        color: "white",
+        intensity: 5,
+        scale: 10,
+        position: [-15, 4, -18],
+        target: [0, 0, 0]
+      }
+    )
+  ] });
+}
+const ht = {
+  attach: "material",
+  color: "#009f4d",
+  opacity: 0.2,
+  depthTest: !1,
+  depthWrite: !1,
+  transparent: !0,
+  polygonOffset: !0
+};
+function Ne({
+  safetyZones: t,
+  dhParameters: n,
+  ...e
+}) {
+  const s = k(
+    () => Ut(n ?? []),
+    [n]
+  ), o = (c, i) => {
+    var g, f;
+    if (!((g = i == null ? void 0 : i.pose) != null && g.position) || !((f = i == null ? void 0 : i.pose) != null && f.orientation))
+      return null;
+    const p = new w.Vector3(
+      i.pose.position[0] / 1e3,
+      i.pose.position[1] / 1e3,
+      i.pose.position[2] / 1e3
+    ), a = new w.Vector3(
+      i.pose.orientation[0],
+      i.pose.orientation[1],
+      i.pose.orientation[2]
+    );
+    let h;
+    const u = i.shape.shape_type === "plane" ? { ...ht, side: w.DoubleSide } : { ...ht, side: w.FrontSide };
+    switch (i.shape.shape_type) {
+      /**
+       * Plane shape, uses DH parameters to calculate the size of the plane (reach distance of a robot)
+       */
+      case "plane":
+        h = /* @__PURE__ */ r("planeGeometry", { args: [s, s] });
+        break;
+      /**
+       * Sphere shape
+       */
+      case "sphere": {
+        const d = (i == null ? void 0 : i.shape).radius / 1e3;
+        h = /* @__PURE__ */ r("sphereGeometry", { args: [d] });
+        break;
+      }
+      /**
+       * Capsule shape
+       */
+      case "capsule": {
+        const d = (i == null ? void 0 : i.shape).radius / 1e3, m = (i == null ? void 0 : i.shape).cylinder_height / 1e3;
+        h = /* @__PURE__ */ r("capsuleGeometry", { args: [d, m] });
+        break;
+      }
+      /**
+       * Convex hull, checks at first if the vertices are coplanar - if yes, adds a small offset for
+       * renderer to be able to visualize the convex hull.
+       */
+      case "convex_hull": {
+        const d = (i == null ? void 0 : i.shape).vertices.map(
+          (b) => new w.Vector3(b[0] / 1e3, b[1] / 1e3, b[2] / 1e3)
+        ), m = Vt(d);
+        if (m.isCoplanar && m.normal) {
+          const y = new w.Vector3().addVectors(
+            d[0],
+            m.normal.multiplyScalar(1e-4)
+          );
+          d.push(y);
+        }
+        try {
+          h = /* @__PURE__ */ r(
+            "primitive",
+            {
+              object: new ft(d),
+              attach: "geometry"
+            }
+          );
+        } catch (b) {
+          return console.log("Error creating ConvexGeometry:", b), null;
+        }
+        break;
+      }
+      /**
+       * Convex hull around four spheres. Sphere center points in x/y-plane,
+       * offset by either combination "+/- sizeX" or "+/- sizeY".
+       * Alternative description: Rectangle in x/y-plane with a 3D padding (source: nova-api docs)
+       *
+       * Basically a rounded box with a rectangular cross-section.
+       */
+      case "rectangular_capsule": {
+        const d = i.shape, m = d.radius / 1e3, b = d.sphere_center_distance_x / 1e3, y = d.sphere_center_distance_y / 1e3, x = m * 2;
+        h = /* @__PURE__ */ r(
+          "primitive",
+          {
+            object: new Ot(b, y, x, 2, m),
+            attach: "geometry"
+          }
+        );
+        break;
+      }
+      default:
+        console.warn(
+          "Unsupported safety zone shape type:",
+          i.shape.shape_type
+        ), h = null;
+    }
+    return /* @__PURE__ */ R(
+      "mesh",
+      {
+        renderOrder: c,
+        position: p,
+        quaternion: jt(a),
+        children: [
+          h,
+          /* @__PURE__ */ r("meshStandardMaterial", { ...u, polygonOffsetFactor: -c })
+        ]
+      },
+      `safety-zone-${i.shape.shape_type}-${c}`
+    );
+  }, l = k(() => Object.values(t ?? {}).map(
+    (c, i) => o(i, c)
+  ), [t, s]);
+  return /* @__PURE__ */ r("group", { ...e, children: l });
+}
+function Be({
+  trajectory: t,
+  ...n
+}) {
+  const e = (t == null ? void 0 : t.map((s) => {
+    if (s.position && s.position.length >= 3) {
+      const [o, l, c] = s.position;
+      if (Number.isFinite(o) && Number.isFinite(l) && Number.isFinite(c))
+        return new w.Vector3(o / 1e3, c / 1e3, -l / 1e3);
+    }
+    return null;
+  }).filter((s) => s !== null)) || [];
+  return /* @__PURE__ */ r("group", { ...n, children: e.length > 0 && /* @__PURE__ */ r(
+    J,
+    {
+      points: e,
+      lineWidth: 3,
+      polygonOffset: !0,
+      polygonOffsetFactor: 10,
+      polygonOffsetUnits: 10
+    }
+  ) });
+}
+const X = /* @__PURE__ */ new Map();
+async function H(t, n) {
+  if (X.has(t))
+    return X.get(t);
+  const e = (async () => {
+    var c;
+    const s = n || "", o = new Ht({ instanceUrl: s }), l = o.api.motionGroupModels;
+    (c = l.axios) != null && c.interceptors && l.axios.interceptors.request.use((i) => {
+      var p;
+      return (p = i.url) != null && p.includes("/glb") && (i.responseType = "blob"), i;
+    });
+    try {
+      const i = await o.api.motionGroupModels.getMotionGroupGlbModel(
+        t
+      );
+      return URL.createObjectURL(i);
+    } catch (i) {
+      throw console.error("Failed to fetch model:", i), i;
+    }
+  })();
+  return X.set(t, e), e;
+}
+function xt(t) {
+  function n(e) {
+    return e.children.length === 0 ? [e] : [e, ...e.children.flatMap((s) => n(s))];
+  }
+  return n(t).filter((e) => Mt(e));
+}
+function Rt(t) {
+  return t.name.endsWith("_FLG");
+}
+function Mt(t) {
+  return /_J[0-9]+$/.test(t.name);
+}
+function le(t, n) {
+  let e;
+  function s(o) {
+    if (Rt(o)) {
+      if (e)
+        throw Error(
+          `Found multiple flange groups in robot model ${n}; first ${e.name} then ${o.name}. Only one _FLG group is allowed.`
+        );
+      e = o;
+    }
+    Mt(o), o.children.map(s);
+  }
+  if (s(t.scene), !e)
+    throw Error(
+      `No flange group found in robot model ${n}. Flange must be identified with a name ending in _FLG.`
+    );
+  return { gltf: t };
+}
+const vt = Ct(
+  function({
+    rapidlyChangingMotionState: n,
+    dhParameters: e,
+    chainOffsetPosition: s,
+    chainOffsetQuaternion: o,
+    onRotationChanged: l,
+    children: c
+  }, i) {
+    const p = _(null), a = _([]), h = _(
+      n.joint_position.filter(
+        (y) => y !== void 0
+      )
+    ), { invalidate: u } = yt(), g = _(n);
+    g.current = n;
+    function f(y) {
+      p.current = y, y && d();
+    }
+    function d() {
+      p.current && (a.current = xt(p.current), m(), u());
+    }
+    Dt(i, () => ({ recollectJoints: d }));
+    function m() {
+      const y = h.current;
+      if (l)
+        l(a.current, y);
+      else
+        for (const [x, v] of a.current.entries()) {
+          const P = e[x], C = P.theta || 0, $ = P.reverse_rotation_direction ? -1 : 1;
+          v.rotation.y = $ * (y[x] || 0) + C;
+        }
+    }
+    function b(y) {
+      h.current = y.joint_position.filter(
+        (x) => x !== void 0
+      ), m(), u();
+    }
+    return wt(() => {
+      b(g.current);
+    }), E(() => {
+      b(n);
+    }, [n]), /* @__PURE__ */ r(
+      "group",
+      {
+        ref: f,
+        position: s,
+        quaternion: o,
+        children: c
+      }
+    );
+  }
+), ue = "line", pe = "mesh";
+function me({
+  rapidlyChangingMotionState: t,
+  dhParameters: n,
+  ...e
+}) {
+  const s = new M(), o = _([]), l = _([]);
+  Ft.useEffect(() => {
+    o.current = new Array(n.length).fill(null), l.current = new Array(n.length).fill(null);
+  }, [n.length]);
+  function c(a, h) {
+    const u = new L(), g = new D(), f = new L();
+    s.decompose(u, g, f);
+    const d = u.clone(), m = new M().makeRotationY(
+      a.theta + h * (a.reverse_rotation_direction ? -1 : 1)
+    ).multiply(new M().makeTranslation(0, a.d / 1e3, 0)).multiply(new M().makeTranslation(a.a / 1e3, 0, 0)).multiply(new M().makeRotationX(a.alpha));
+    return s.multiply(m), s.decompose(u, g, f), { a: d, b: u };
+  }
+  function i(a, h, u, g) {
+    if (!n)
+      return;
+    const f = n[a];
+    if (!f)
+      return;
+    const { a: d, b: m } = c(f, g);
+    h.geometry.setPositions([d.toArray(), m.toArray()].flat()), u.position.set(m.x, m.y, m.z);
+  }
+  function p(a, h) {
+    s.identity();
+    for (let u = 0; u < Math.min(a.length, h.length); u++) {
+      const g = o.current[u], f = l.current[u];
+      g && f && i(u, g, f, h[u]);
+    }
+  }
+  return /* @__PURE__ */ r(
+    vt,
+    {
+      rapidlyChangingMotionState: t,
+      dhParameters: n,
+      onRotationChanged: p,
+      children: /* @__PURE__ */ R("group", { ...e, name: "Scene", children: [
+        /* @__PURE__ */ R("mesh", { children: [
+          /* @__PURE__ */ r("sphereGeometry", { args: [0.01, 32, 32] }),
+          /* @__PURE__ */ r("meshStandardMaterial", { color: "black", depthTest: !0 })
+        ] }),
+        n == null ? void 0 : n.map((a, h) => {
+          const { a: u, b: g } = c(
+            a,
+            t.joint_position[h] ?? 0
+          ), f = `dhrobot_J0${h}`;
+          return /* @__PURE__ */ R("group", { name: f, children: [
+            /* @__PURE__ */ r(
+              J,
+              {
+                ref: (d) => {
+                  o.current[h] = d;
+                },
+                name: ue,
+                points: [u, g],
+                color: "white",
+                lineWidth: 5
+              }
+            ),
+            /* @__PURE__ */ R(
+              "mesh",
+              {
+                ref: (d) => {
+                  l.current[h] = d;
+                },
+                name: pe,
+                position: g,
+                children: [
+                  /* @__PURE__ */ r("sphereGeometry", { args: [0.01, 32, 32] }),
+                  /* @__PURE__ */ r("meshStandardMaterial", { color: "black", depthTest: !0 })
+                ]
+              },
+              `mesh_${h}`
+            )
+          ] }, f);
+        })
+      ] })
+    }
+  );
+}
+const he = console.warn;
+function _t() {
+  return E(() => {
+    console.warn = (t) => {
+      t !== "Cannot call the manual advancement of rafz whilst frameLoop is not set as demand" && he(t);
+    };
+  }, []), null;
+}
+function de(t) {
+  return t.type === "Mesh";
+}
+function fe({
+  url: t,
+  flangeRef: n,
+  postModelRender: e,
+  ...s
+}) {
+  const o = Et(t), c = le(o, "robot.glb").gltf, i = O(
+    (a) => {
+      a && e && e();
+    },
+    [e]
+  );
+  function p(a) {
+    try {
+      return de(a) ? a.geometry ? /* @__PURE__ */ r(
+        "mesh",
+        {
+          name: a.name,
+          geometry: a.geometry,
+          material: a.material,
+          position: a.position,
+          rotation: a.rotation
+        },
+        a.uuid
+      ) : /* @__PURE__ */ r(
+        "group",
+        {
+          name: a.name,
+          position: a.position,
+          rotation: a.rotation
+        },
+        a.uuid
+      ) : /* @__PURE__ */ r(
+        "group",
+        {
+          name: a.name,
+          position: a.position,
+          rotation: a.rotation,
+          ref: Rt(a) ? n : void 0,
+          children: a.children.map(p)
+        },
+        a.uuid
+      );
+    } catch (h) {
+      return console.warn("Error rendering node", a.name, h), null;
+    }
+  }
+  return /* @__PURE__ */ r("group", { ...s, dispose: null, ref: i, children: p(c.scene) });
+}
+function St({
+  modelURL: t,
+  flangeRef: n,
+  postModelRender: e,
+  ...s
+}) {
+  const [o, l] = A(null);
+  return E(() => {
+    let c = !1;
+    return (async () => {
+      try {
+        const p = typeof t == "string" ? t : await t;
+        c || l((a) => a === p ? a : p);
+      } catch (p) {
+        console.error("Failed to resolve model URL:", p);
+      }
+    })(), () => {
+      c = !0;
+    };
+  }, [t]), o ? /* @__PURE__ */ r(
+    fe,
+    {
+      url: o,
+      flangeRef: n,
+      postModelRender: e,
+      ...s
+    }
+  ) : null;
+}
+const Tt = (t, n) => {
+  t.userData.isGhost || (t.traverse((e) => {
+    if (e instanceof w.Mesh) {
+      e.material instanceof w.Material && (e.material.colorWrite = !1);
+      const s = e.clone(), o = e.clone();
+      s.material = new w.MeshStandardMaterial({
+        depthTest: !0,
+        depthWrite: !0,
+        colorWrite: !1,
+        polygonOffset: !0,
+        polygonOffsetFactor: -1,
+        side: w.DoubleSide
+      }), s.userData.isGhost = !0, o.material = new w.MeshStandardMaterial({
+        color: n,
+        opacity: 0.3,
+        depthTest: !0,
+        depthWrite: !1,
+        transparent: !0,
+        polygonOffset: !0,
+        polygonOffsetFactor: -2,
+        side: w.DoubleSide
+      }), o.userData.isGhost = !0, e.parent && (e.parent.add(s), e.parent.add(o));
+    }
+  }), t.userData.isGhost = !0);
+}, Pt = (t) => {
+  if (!t.userData.isGhost) return;
+  const n = [];
+  t.traverse((e) => {
+    var s;
+    e instanceof w.Mesh && ((s = e.userData) != null && s.isGhost ? n.push(e) : e.material instanceof w.Material && (e.material.colorWrite = !0));
+  }), n.forEach((e) => {
+    e.parent && e.parent.remove(e);
+  }), t.userData.isGhost = !1;
+}, Lt = F(
+  ({
+    rapidlyChangingMotionState: t,
+    modelFromController: n,
+    dhParameters: e,
+    chainOffsetPosition: s,
+    chainOffsetQuaternion: o,
+    getModel: l = H,
+    flangeRef: c,
+    postModelRender: i,
+    transparentColor: p,
+    instanceUrl: a,
+    ...h
+  }) => {
+    const [u, g] = A(null), f = _(null), d = O((x) => {
+      g(x);
+    }, []), m = O(() => {
+      var x;
+      (x = f.current) == null || x.recollectJoints(), i == null || i();
+    }, [i]);
+    E(() => {
+      u && (p ? Tt(u, p) : Pt(u));
+    }, [u, p]);
+    const b = k(() => {
+      const x = l(n, a);
+      if (!x)
+        throw new Error(
+          `No model found for robot "${n}". Ensure the model is available or provide a custom getModel function.`
+        );
+      return x;
+    }, [n, a, l]), y = /* @__PURE__ */ r(
+      me,
+      {
+        rapidlyChangingMotionState: t,
+        dhParameters: e,
+        ...h
+      }
+    );
+    return /* @__PURE__ */ R(
+      bt,
+      {
+        fallback: y,
+        onError: (x) => {
+          console.warn(x);
+        },
+        children: [
+          /* @__PURE__ */ r(gt, { fallback: y, children: /* @__PURE__ */ r("group", { ref: d, children: /* @__PURE__ */ r(
+            vt,
+            {
+              ref: f,
+              rapidlyChangingMotionState: t,
+              dhParameters: e,
+              chainOffsetPosition: s,
+              chainOffsetQuaternion: o,
+              children: /* @__PURE__ */ r(
+                St,
+                {
+                  modelURL: b,
+                  postModelRender: m,
+                  flangeRef: c,
+                  ...h
+                }
+              )
+            }
+          ) }) }),
+          /* @__PURE__ */ r(_t, {})
+        ]
+      }
+    );
+  }
+), ge = F(
+  ({ rapidlyChangingMotionState: t, ...n }) => {
+    const e = Z(
+      t
+    );
+    return /* @__PURE__ */ r(
+      Lt,
+      {
+        rapidlyChangingMotionState: e,
+        ...n
+      }
+    );
+  }
+);
+function ye({
+  connectedMotionGroup: t,
+  getModel: n = H,
+  flangeRef: e,
+  transparentColor: s,
+  postModelRender: o,
+  ...l
+}) {
+  if (!t.dhParameters)
+    return null;
+  const c = t.mountingPosition, i = t.mountingQuaternion;
+  return /* @__PURE__ */ r(
+    ge,
+    {
+      rapidlyChangingMotionState: t.rapidlyChangingMotionState,
+      modelFromController: t.modelFromController || "",
+      dhParameters: t.dhParameters,
+      getModel: n,
+      flangeRef: e,
+      transparentColor: s,
+      postModelRender: o,
+      chainOffsetPosition: c,
+      chainOffsetQuaternion: i,
+      ...l
+    }
+  );
+}
+const We = F(
+  Wt(
+    ({
+      robotName: t,
+      programState: n,
+      safetyState: e,
+      operationMode: s,
+      driveToHomeEnabled: o = !1,
+      onDriveToHomePress: l,
+      onDriveToHomeRelease: c,
+      connectedMotionGroup: i,
+      robotComponent: p = ye,
+      customContentComponent: a,
+      className: h
+    }) => {
+      var tt;
+      const u = Nt(), { t: g } = Jt(), [f, d] = A(!1), m = _(null), b = _(null), [y, x] = A(!1), [v, P] = A({ width: 400, height: 600 }), [C, $] = A(0);
+      E(() => {
+        const N = () => {
+          if (b.current) {
+            const { offsetWidth: nt, offsetHeight: rt } = b.current;
+            x(nt > rt), P({ width: nt, height: rt });
+          }
+        };
+        N();
+        const et = new ResizeObserver(N);
+        return b.current && et.observe(b.current), () => {
+          et.disconnect();
+        };
+      }, []);
+      const K = O(() => {
+        $((N) => N + 1);
+      }, []), U = O(() => {
+        !o || !l || (d(!0), l());
+      }, [o, l]), V = O(() => {
+        !o || !c || (d(!1), c());
+      }, [o, c]), z = O(() => {
+        f && c && (d(!1), c());
+      }, [f, c]), I = y ? v.width < 350 : v.height < 200, j = y ? v.height < 310 : v.height < 450;
+      return /* @__PURE__ */ r(
+        Bt,
+        {
+          ref: b,
+          className: h,
+          sx: {
+            width: "100%",
+            height: "100%",
+            display: "flex",
+            flexDirection: y ? "row" : "column",
+            position: "relative",
+            overflow: "hidden",
+            minWidth: { xs: 180, sm: 220, md: 250 },
+            minHeight: y ? { xs: 200, sm: 240, md: 260 } : { xs: 150, sm: 180, md: 220 },
+            // Allow progressive hiding in portrait mode
+            border: `1px solid ${u.palette.divider}`,
+            borderRadius: "18px",
+            boxShadow: "none",
+            backgroundColor: ((tt = u.palette.backgroundPaperElevation) == null ? void 0 : tt[8]) || "#292B3F",
+            backgroundImage: "none"
+            // Override any gradient from elevation
+          },
+          children: y ? /* @__PURE__ */ R(W, { children: [
+            /* @__PURE__ */ r(
+              S,
+              {
+                sx: {
+                  flex: "0 0 50%",
+                  position: "relative",
+                  height: "100%",
+                  minHeight: "100%",
+                  maxHeight: "100%",
+                  borderRadius: 1,
+                  m: { xs: 1.5, sm: 2, md: 3 },
+                  mr: { xs: 0.75, sm: 1, md: 1.5 },
+                  overflow: "hidden",
+                  // Prevent content from affecting container size
+                  display: I ? "none" : "block"
+                },
+                children: !I && /* @__PURE__ */ R(
+                  ct,
+                  {
+                    orthographic: !0,
+                    camera: {
+                      position: [3, 2, 3],
+                      zoom: 1
+                    },
+                    shadows: !0,
+                    frameloop: "demand",
+                    style: {
+                      borderRadius: u.shape.borderRadius,
+                      width: "100%",
+                      height: "100%",
+                      background: "transparent",
+                      position: "absolute",
+                      top: 0,
+                      left: 0
+                    },
+                    dpr: [1, 2],
+                    gl: { alpha: !0, antialias: !0 },
+                    children: [
+                      /* @__PURE__ */ r(mt, {}),
+                      /* @__PURE__ */ r(ot, { fit: !0, observe: !0, margin: 1, maxDuration: 1, children: /* @__PURE__ */ r(
+                        p,
+                        {
+                          connectedMotionGroup: i,
+                          postModelRender: K
+                        }
+                      ) })
+                    ]
+                  }
+                )
+              }
+            ),
+            /* @__PURE__ */ R(
+              S,
+              {
+                sx: {
+                  flex: "1",
+                  display: "flex",
+                  flexDirection: "column",
+                  justifyContent: "flex-start",
+                  width: I ? "100%" : "50%"
+                },
+                children: [
+                  /* @__PURE__ */ R(
+                    S,
+                    {
+                      sx: {
+                        p: { xs: 1.5, sm: 2, md: 3 },
+                        pb: { xs: 1, sm: 1.5, md: 2 },
+                        textAlign: "left"
+                      },
+                      children: [
+                        /* @__PURE__ */ r(at, { variant: "h6", component: "h2", sx: { mb: 1 }, children: t }),
+                        /* @__PURE__ */ r(
+                          lt,
+                          {
+                            programState: n,
+                            safetyState: e,
+                            operationMode: s
+                          }
+                        )
+                      ]
+                    }
+                  ),
+                  /* @__PURE__ */ R(
+                    S,
+                    {
+                      sx: {
+                        p: { xs: 1.5, sm: 2, md: 3 },
+                        pt: 0,
+                        flex: "1",
+                        display: "flex",
+                        flexDirection: "column",
+                        justifyContent: "space-between"
+                      },
+                      children: [
+                        !j && a && /* @__PURE__ */ R(S, { children: [
+                          /* @__PURE__ */ r(a, {}),
+                          /* @__PURE__ */ r(
+                            st,
+                            {
+                              sx: {
+                                mt: 1,
+                                mb: 0,
+                                borderColor: u.palette.divider,
+                                opacity: 0.5
+                              }
+                            }
+                          )
+                        ] }),
+                        /* @__PURE__ */ r(
+                          S,
+                          {
+                            sx: {
+                              mt: !j && a ? "auto" : 0
+                            },
+                            children: /* @__PURE__ */ r(
+                              S,
+                              {
+                                sx: {
+                                  display: "flex",
+                                  justifyContent: "flex-start",
+                                  mt: { xs: 1, sm: 1.5, md: 2 },
+                                  mb: { xs: 0.5, sm: 0.75, md: 1 }
+                                },
+                                children: /* @__PURE__ */ r(
+                                  it,
+                                  {
+                                    ref: m,
+                                    variant: "contained",
+                                    color: "secondary",
+                                    size: "small",
+                                    disabled: !o,
+                                    onMouseDown: U,
+                                    onMouseUp: V,
+                                    onMouseLeave: z,
+                                    onTouchStart: U,
+                                    onTouchEnd: V,
+                                    sx: {
+                                      textTransform: "none",
+                                      px: 1.5,
+                                      py: 0.5
+                                    },
+                                    children: g("RobotCard.DriveToHome.bt")
+                                  }
+                                )
+                              }
+                            )
+                          }
+                        )
+                      ]
+                    }
+                  )
+                ]
+              }
+            )
+          ] }) : /* @__PURE__ */ r(W, { children: /* @__PURE__ */ R(
+            S,
+            {
+              sx: {
+                p: 3,
+                height: "100%",
+                display: "flex",
+                flexDirection: "column"
+              },
+              children: [
+                /* @__PURE__ */ R(S, { children: [
+                  /* @__PURE__ */ r(at, { variant: "h6", component: "h2", sx: { mb: 1 }, children: t }),
+                  /* @__PURE__ */ r(
+                    lt,
+                    {
+                      programState: n,
+                      safetyState: e,
+                      operationMode: s
+                    }
+                  )
+                ] }),
+                /* @__PURE__ */ r(
+                  S,
+                  {
+                    sx: {
+                      flex: I ? 0 : 1,
+                      position: "relative",
+                      minHeight: I ? 0 : { xs: 120, sm: 150, md: 200 },
+                      height: I ? 0 : "auto",
+                      borderRadius: 1,
+                      overflow: "hidden",
+                      display: I ? "none" : "block"
+                    },
+                    children: !I && /* @__PURE__ */ R(
+                      ct,
+                      {
+                        orthographic: !0,
+                        camera: {
+                          position: [3, 2, 3],
+                          zoom: 1
+                        },
+                        shadows: !0,
+                        frameloop: "demand",
+                        style: {
+                          borderRadius: u.shape.borderRadius,
+                          width: "100%",
+                          height: "100%",
+                          background: "transparent",
+                          position: "absolute"
+                        },
+                        dpr: [1, 2],
+                        gl: { alpha: !0, antialias: !0 },
+                        children: [
+                          /* @__PURE__ */ r(mt, {}),
+                          /* @__PURE__ */ r(ot, { fit: !0, clip: !0, observe: !0, margin: 1, maxDuration: 1, children: /* @__PURE__ */ r(
+                            p,
+                            {
+                              connectedMotionGroup: i,
+                              postModelRender: K
+                            }
+                          ) })
+                        ]
+                      }
+                    )
+                  }
+                ),
+                /* @__PURE__ */ R(S, { children: [
+                  !j && a && /* @__PURE__ */ R(W, { children: [
+                    /* @__PURE__ */ r(a, {}),
+                    /* @__PURE__ */ r(
+                      st,
+                      {
+                        sx: {
+                          mt: 1,
+                          mb: 0,
+                          borderColor: u.palette.divider,
+                          opacity: 0.5
+                        }
+                      }
+                    )
+                  ] }),
+                  /* @__PURE__ */ r(
+                    S,
+                    {
+                      sx: {
+                        display: "flex",
+                        justifyContent: "flex-start",
+                        mt: !j && a ? { xs: 1, sm: 2, md: 5 } : { xs: 0.5, sm: 1, md: 2 },
+                        mb: { xs: 0.5, sm: 0.75, md: 1 }
+                      },
+                      children: /* @__PURE__ */ r(
+                        it,
+                        {
+                          ref: m,
+                          variant: "contained",
+                          color: "secondary",
+                          size: "small",
+                          disabled: !o,
+                          onMouseDown: U,
+                          onMouseUp: V,
+                          onMouseLeave: z,
+                          onTouchStart: U,
+                          onTouchEnd: V,
+                          sx: {
+                            textTransform: "none",
+                            px: 1.5,
+                            py: 0.5
+                          },
+                          children: g("RobotCard.DriveToHome.bt")
+                        }
+                      )
+                    }
+                  )
+                ] })
+              ]
+            }
+          ) })
+        }
+      );
+    }
+  )
+), Je = Array(6).fill(2 * Math.PI);
+function It({
+  rapidlyChangingMotionState: t,
+  dhParameters: n,
+  chainOffsetPosition: e,
+  chainOffsetQuaternion: s,
+  onTranslationChanged: o,
+  children: l
+}) {
+  const c = _([]), i = _(
+    t.joint_position.filter(
+      (f) => f !== void 0
+    )
+  ), { invalidate: p } = yt(), a = _(t);
+  a.current = t;
+  function h(f) {
+    f && (c.current = xt(f), u(), p());
+  }
+  function u() {
+    const f = i.current;
+    if (o)
+      o(c.current, f);
+    else
+      for (const [d, m] of c.current.entries()) {
+        const y = n[d].reverse_rotation_direction ? -1 : 1;
+        m.position.y = y * (f[d] || 0) / 1e3;
+      }
+  }
+  function g(f) {
+    i.current = f.joint_position.filter(
+      (d) => d !== void 0
+    ), u(), p();
+  }
+  return wt(() => {
+    g(a.current);
+  }), /* @__PURE__ */ r(
+    "group",
+    {
+      ref: h,
+      position: e,
+      quaternion: s,
+      children: l
+    }
+  );
+}
+function kt({
+  rapidlyChangingMotionState: t,
+  dhParameters: n,
+  ...e
+}) {
+  const s = new M(), o = _(null), l = _(null);
+  function c(a) {
+    const h = new M();
+    for (let d = 0; d < n.length; d++) {
+      const m = n[d], b = a[d] ?? 0, y = new M().makeRotationY(m.theta).multiply(
+        new M().makeTranslation(
+          m.a / 1e3,
+          (m.d + b * (m.reverse_rotation_direction ? -1 : 1)) / 1e3,
+          0
+        )
+      ).multiply(new M().makeRotationX(m.alpha));
+      h.multiply(y);
+    }
+    const u = new L(), g = new D(), f = new L();
+    return h.decompose(u, g, f), u;
+  }
+  const i = c(
+    t.joint_position
+  );
+  function p(a, h) {
+    s.identity();
+    let u = new L();
+    for (let m = 0; m < n.length; m++) {
+      const b = h[m] ?? 0, y = n[m], x = new M().makeRotationY(y.theta).multiply(
+        new M().makeTranslation(
+          y.a / 1e3,
+          (y.d + b * (y.reverse_rotation_direction ? -1 : 1)) / 1e3,
+          0
+        )
+      ).multiply(new M().makeRotationX(y.alpha));
+      s.multiply(x);
+    }
+    const g = new L(), f = new D(), d = new L();
+    if (s.decompose(g, f, d), u = g, o.current && o.current.position.set(
+      u.x,
+      u.y,
+      u.z
+    ), l.current) {
+      const m = l.current.geometry;
+      m != null && m.setPositions && m.setPositions([
+        0,
+        0,
+        0,
+        u.x,
+        u.y,
+        u.z
+      ]);
+    }
+  }
+  return /* @__PURE__ */ r(
+    It,
+    {
+      rapidlyChangingMotionState: t,
+      dhParameters: n,
+      onTranslationChanged: p,
+      children: /* @__PURE__ */ R("group", { ...e, name: "Scene", children: [
+        /* @__PURE__ */ R("mesh", { name: "Base", position: [0, 0, 0], children: [
+          /* @__PURE__ */ r("sphereGeometry", { args: [0.02, 32, 32] }),
+          /* @__PURE__ */ r("meshStandardMaterial", { color: "green", depthTest: !0 })
+        ] }),
+        /* @__PURE__ */ r(
+          J,
+          {
+            ref: l,
+            points: [new L(0, 0, 0), i],
+            color: "White",
+            lineWidth: 5
+          }
+        ),
+        /* @__PURE__ */ R("mesh", { ref: o, name: "TCP", position: i, children: [
+          /* @__PURE__ */ r("sphereGeometry", { args: [0.025, 32, 32] }),
+          /* @__PURE__ */ r("meshStandardMaterial", { color: "red", depthTest: !0 })
+        ] })
+      ] })
+    }
+  );
+}
+const At = F(
+  ({
+    rapidlyChangingMotionState: t,
+    modelFromController: n,
+    dhParameters: e,
+    chainOffsetPosition: s,
+    chainOffsetQuaternion: o,
+    getModel: l = H,
+    flangeRef: c,
+    postModelRender: i,
+    transparentColor: p,
+    instanceUrl: a,
+    ...h
+  }) => {
+    const [u, g] = A(null), f = O((m) => {
+      g(m);
+    }, []);
+    E(() => {
+      u && (p ? Tt(u, p) : Pt(u));
+    }, [u, p]);
+    const d = /* @__PURE__ */ r(
+      kt,
+      {
+        rapidlyChangingMotionState: t,
+        dhParameters: e,
+        ...h
+      }
+    );
+    return /* @__PURE__ */ R(
+      bt,
+      {
+        fallback: d,
+        onError: (m) => {
+          console.warn(m);
+        },
+        children: [
+          /* @__PURE__ */ r(gt, { fallback: d, children: /* @__PURE__ */ r("group", { ref: f, children: /* @__PURE__ */ r(
+            It,
+            {
+              rapidlyChangingMotionState: t,
+              dhParameters: e,
+              chainOffsetPosition: s,
+              chainOffsetQuaternion: o,
+              children: /* @__PURE__ */ r(
+                St,
+                {
+                  modelURL: (() => {
+                    const m = l(n, a);
+                    if (!m) {
+                      const b = new Blob([], { type: "model/gltf-binary" }), y = new File(
+                        [b],
+                        `${n}.glb`,
+                        { type: "model/gltf-binary" }
+                      );
+                      return Promise.resolve(URL.createObjectURL(y));
+                    }
+                    return m;
+                  })(),
+                  postModelRender: i,
+                  flangeRef: c,
+                  ...h
+                }
+              )
+            }
+          ) }) }),
+          /* @__PURE__ */ r(_t, {})
+        ]
+      }
+    );
+  }
+), we = F(
+  ({ rapidlyChangingMotionState: t, ...n }) => {
+    const e = Z(
+      t
+    );
+    return /* @__PURE__ */ r(
+      At,
+      {
+        rapidlyChangingMotionState: e,
+        ...n
+      }
+    );
+  }
+);
+function He({
+  connectedMotionGroup: t,
+  getModel: n = H,
+  flangeRef: e,
+  transparentColor: s,
+  postModelRender: o,
+  ...l
+}) {
+  if (!t.dhParameters)
+    return null;
+  const c = t.mountingPosition, i = t.mountingQuaternion, p = t.modelFromController || "";
+  return p && n(p) ? /* @__PURE__ */ r(
+    we,
+    {
+      rapidlyChangingMotionState: t.rapidlyChangingMotionState,
+      modelFromController: p,
+      dhParameters: t.dhParameters,
+      getModel: n,
+      flangeRef: e,
+      transparentColor: s,
+      postModelRender: o,
+      chainOffsetPosition: c,
+      chainOffsetQuaternion: i,
+      ...l
+    }
+  ) : /* @__PURE__ */ r(
+    kt,
+    {
+      rapidlyChangingMotionState: t.rapidlyChangingMotionState,
+      dhParameters: t.dhParameters,
+      chainOffsetPosition: c,
+      chainOffsetQuaternion: i,
+      ...l
+    }
+  );
+}
+const dt = {
+  [T.Abb]: [0, 0, 0, 0, Math.PI / 2, 0, 0],
+  [T.Fanuc]: [0, 0, 0, 0, -Math.PI / 2, 0, 0],
+  [T.Yaskawa]: [0, 0, 0, 0, -Math.PI / 2, 0, 0],
+  [T.Kuka]: [
+    0,
+    -Math.PI / 2,
+    Math.PI / 2,
+    0,
+    Math.PI / 2,
+    0,
+    0
+  ],
+  [T.Universalrobots]: [
+    0,
+    -Math.PI / 2,
+    -Math.PI / 2,
+    -Math.PI / 2,
+    Math.PI / 2,
+    -Math.PI / 2,
+    0
+  ],
+  [T.Staubli]: [0, -Math.PI / 2, Math.PI / 2, 0, 0, 0, 0]
+};
+function be(t) {
+  const [n] = t.split("_");
+  switch (n) {
+    case "ABB":
+      return T.Abb;
+    case "FANUC":
+      return T.Fanuc;
+    case "YASKAWA":
+      return T.Yaskawa;
+    case "KUKA":
+      return T.Kuka;
+    case "UniversalRobots":
+      return T.Universalrobots;
+    case "STAUBLI":
+      return T.Staubli;
+    default:
+      return null;
+  }
+}
+function $e(t, n) {
+  const e = be(t);
+  return e && e in dt ? dt[e] : n || null;
+}
+const xe = F((t) => {
+  const { inverseSolver: n, dhParameters: e, ...s } = t, [o, l] = A(
+    B.RevoluteJoint
+  );
+  E(() => {
+    e.length && l(e[0].type ?? B.RevoluteJoint);
+  }, [e]);
+  const c = k(() => n === null && o === B.RevoluteJoint, [n, o]), i = k(() => n === null && o === B.PrismaticJoint, [n, o]);
+  return k(() => !!n, [n]) || c ? /* @__PURE__ */ r(Lt, { dhParameters: e, ...s }) : i ? /* @__PURE__ */ r(At, { dhParameters: e, ...s }) : null;
+}), qe = F((t) => {
+  const n = Z(
+    t.rapidlyChangingMotionState
+  );
+  return /* @__PURE__ */ r(
+    xe,
+    {
+      ...t,
+      rapidlyChangingMotionState: n
+    }
+  );
+});
+export {
+  Ve as C,
+  je as J,
+  He as L,
+  dt as M,
+  mt as P,
+  ye as R,
+  Ne as S,
+  Be as T,
+  qe as a,
+  xe as b,
+  We as c,
+  we as d,
+  At as e,
+  ge as f,
+  Lt as g,
+  Je as h,
+  H as i,
+  be as j,
+  $e as k
+};