@graphty/graphty-element 2.3.1 → 2.4.1

package/dist/chunks/{NodeStyle-DKj7HjMJ.js → NodeStyle-CtmA7dXi.js}

@@ -63,7 +63,7 @@ const u = {
   "bottom",
   "bottom-left",
   "bottom-right"
-]), d = t.enum(["left", "center", "right"]), _ = t.enum(["none", "pulse", "bounce", "shake", "glow", "fill"]), E = t.enum([
+]), d = t.enum(["left", "center", "right"]), _ = t.enum(["none", "pulse", "bounce", "shake", "glow", "fill"]), s = t.enum([
   "notification",
   "label",
   "label-success",
@@ -73,7 +73,7 @@ const u = {
   "icon",
   "progress",
   "dot"
-]), s = t.enum(["linear", "radial"]), O = t.enum(["vertical", "horizontal", "diagonal"]), R = t.enum(["round", "bevel", "miter"]), c = t.strictObject({
+]), E = t.enum(["linear", "radial"]), O = t.enum(["vertical", "horizontal", "diagonal"]), R = t.enum(["round", "bevel", "miter"]), c = t.strictObject({
   width: t.number(),
   color: a,
   spacing: t.number()
@@ -130,7 +130,7 @@ const u = {
   // Background effects
   backgroundPadding: t.number().default(0).optional(),
   backgroundGradient: t.boolean().default(!1).optional(),
-  backgroundGradientType: s.default("linear").optional(),
+  backgroundGradientType: E.default("linear").optional(),
   backgroundGradientColors: t.array(a).optional(),
   backgroundGradientDirection: O.default("vertical").optional(),
   // Pointer/Arrow
@@ -144,7 +144,7 @@ const u = {
   animation: _.default("none").optional(),
   animationSpeed: t.number().default(1).optional(),
   // Badge
-  badge: E.optional(),
+  badge: s.optional(),
   icon: t.string().optional(),
   iconPosition: t.enum(["left", "right"]).default("left").optional(),
   progress: t.number().min(0).max(1).optional(),
@@ -205,7 +205,7 @@ const u = {
   // Repeating wave period meshes
   "zigzag"
   // Repeating zigzag period meshes
-]), m = t.strictObject({
+]), f = t.strictObject({
   type: b.optional(),
   animationSpeed: t.number().min(0).optional(),
   width: t.number().positive().optional(),
@@ -234,7 +234,7 @@ const u = {
 }), g = t.strictObject({
   arrowHead: n.optional(),
   arrowTail: n.optional(),
-  line: m.optional(),
+  line: f.optional(),
   label: e.prefault({ location: "top" }).optional()
   // effects: glow // https://playground.babylonjs.com/#H1LRZ3#35
 }), S = {
@@ -250,7 +250,7 @@ const u = {
   arrowHead: n.parse({
     type: "normal"
   })
-}, f = t.enum([
+}, m = t.enum([
   "box",
   "sphere",
   "cylinder",
@@ -280,7 +280,7 @@ const u = {
   shape: t.strictObject({
     // 0 is legal and draws the smallest visible node; hide a node with `visible: false`.
     size: t.number().nonnegative().optional(),
-    type: f.optional()
+    type: m.optional()
     // custom mesh https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/custom/custom
     // import mesh https://doc.babylonjs.com/typedoc/functions/BABYLON.ImportMeshAsync
   }).optional(),
@@ -334,14 +334,16 @@ const u = {
   }
 };
 export {
-  g as E,
-  f as N,
+  I as E,
+  m as N,
   r as P,
   e as R,
   L as S,
-  U as a,
-  C as b,
-  T as c,
+  b as a,
+  g as b,
+  U as c,
   S as d,
-  u as e
+  C as e,
+  T as f,
+  u as g
 };

package/dist/chunks/{VoiceInputAdapter-Dr9Gcmds.js → VoiceInputAdapter-CDNKQgUK.js}

@@ -1,4 +1,4 @@
-import { i as ke, j as up } from "./algorithms-CpX56sUB.js";
+import { i as ke, j as up } from "./algorithms-B87OPYw4.js";
 var ee = { exports: {} };
 var fp = ee.exports, oo;
 function op() {

package/dist/chunks/{XRPivotCameraController-BbfgZWpS.js → XRPivotCameraController-JdlLBcD7.js}

@@ -1,15 +1,38 @@
-import { Vector3 as f, Quaternion as E, Ray as R, WebXRState as T } from "@babylonjs/core";
-import { P as M } from "./index-C0mIoumR.js";
+import { Vector3 as f, Quaternion as E, Ray as N, WebXRState as D } from "@babylonjs/core";
+import { P as I } from "./index-6GDfNfwJ.js";
 import "@babylonjs/core/Culling/ray";
-import { G as x } from "./GraphtyLogger-5KEttFUo.js";
-function v(H, t = 0.15) {
-  if (Math.abs(H) < t)
+import { G as y } from "./GraphtyLogger-kbOx2zq3.js";
+function x(c, t = 0.15) {
+  if (Math.abs(c) < t)
     return 0;
-  const e = Math.sign(H), i = (Math.abs(H) - t) / (1 - t);
+  const e = Math.sign(c), i = (Math.abs(c) - t) / (1 - t);
   return e * Math.pow(i, 2);
 }
-const p = x.getLogger(["graphty", "camera", "xr", "input"]);
-class O {
+const P = 0.15, O = 0.04, k = 0.03, L = 0.08, w = 0.02, A = 2, _ = 0.04, X = 0.06, T = 1e-4;
+function F(c, t) {
+  return c < (t ? X : _);
+}
+function z(c) {
+  return Math.max(0, 1 - c / _);
+}
+function G(c, t) {
+  const e = x(c.x, P), i = x(c.y, P), n = x(t.x, P), s = x(t.y, P), o = e * O, r = i * k, a = Math.abs(o) > T || Math.abs(r) > T;
+  return {
+    yaw: a ? o : 0,
+    pitch: a ? r : 0,
+    zoom: Math.abs(s) > T ? 1 + s * w : 1,
+    pan: Math.abs(n) > T ? n * L : 0
+  };
+}
+function W(c, t, e, i) {
+  const n = 1 + (e - c) * A, s = 2 - Math.max(0.9, Math.min(1.1, n)), o = f.Cross(t, i), r = o.length();
+  if (r <= T)
+    return { zoom: s, axis: null, angle: 0 };
+  const a = Math.acos(Math.max(-1, Math.min(1, f.Dot(t, i))));
+  return { zoom: s, axis: o.scaleInPlace(1 / r), angle: -a };
+}
+const p = y.getLogger(["graphty", "camera", "xr", "input"]);
+class V {
   // Reference to scene for onBeforeRenderObservable and picking
   /**
    * Creates a new XRInputHandler instance.
@@ -17,7 +40,7 @@ class O {
    * @param xr - The WebXR experience instance
    */
   constructor(t, e) {
-    this.enabled = !1, this.setupControllers = /* @__PURE__ */ new Map(), this.controllerCleanup = /* @__PURE__ */ new Map(), this.gestureControllers = /* @__PURE__ */ new Map(), this.leftStick = { x: 0, y: 0 }, this.rightStick = { x: 0, y: 0 }, this.leftHand = null, this.rightHand = null, this.previousDistance = null, this.previousDirection = null, this.wasPinching = { left: !1, right: !1 }, this.handTrackingFeature = null, this.DEADZONE = 0.15, this.YAW_SPEED = 0.04, this.PITCH_SPEED = 0.03, this.PAN_SPEED = 0.08, this.ZOOM_SPEED = 0.02, this.GESTURE_ZOOM_SENSITIVITY = 2, this._PINCH_START = 0.7, this._PINCH_END = 0.5, this.lastControllerRemovedTime = 0, this.INPUT_SWITCH_DELAY_MS = 100, this.isDraggingNode = !1, this.draggedNodeHandler = null, this.dragHand = null, this.lastDragHandPosition = null, this.VELOCITY_SLOW_THRESHOLD = 5e-3, this.VELOCITY_FAST_THRESHOLD = 0.03, this.AMP_SLOW = 5, this._AMP_MEDIUM = 10, this.AMP_FAST = 20, this.lastDragTime = 0, this.SMOOTHING_FACTOR = 0.7, this.smoothedDelta = null, this.DRAG_THRESHOLD = 0.08, this.dragStartHandPosition = null, this.dragThresholdExceeded = !1, this.frameCount = 0, this.dragUpdateCount = 0, this.pivotController = t, this.xr = e, this.scene = e.baseExperience.sessionManager.scene;
+    this.enabled = !1, this.setupControllers = /* @__PURE__ */ new Map(), this.controllerCleanup = /* @__PURE__ */ new Map(), this.gestureControllers = /* @__PURE__ */ new Map(), this.leftStick = { x: 0, y: 0 }, this.rightStick = { x: 0, y: 0 }, this.leftHand = null, this.rightHand = null, this.previousDistance = null, this.previousDirection = null, this.wasPinching = { left: !1, right: !1 }, this.handTrackingFeature = null, this.lastControllerRemovedTime = 0, this.INPUT_SWITCH_DELAY_MS = 100, this.isDraggingNode = !1, this.draggedNodeHandler = null, this.dragHand = null, this.lastDragHandPosition = null, this.VELOCITY_SLOW_THRESHOLD = 5e-3, this.VELOCITY_FAST_THRESHOLD = 0.03, this.AMP_SLOW = 5, this._AMP_MEDIUM = 10, this.AMP_FAST = 20, this.lastDragTime = 0, this.SMOOTHING_FACTOR = 0.7, this.smoothedDelta = null, this.DRAG_THRESHOLD = 0.08, this.dragStartHandPosition = null, this.dragThresholdExceeded = !1, this.frameCount = 0, this.dragUpdateCount = 0, this.pivotController = t, this.xr = e, this.scene = e.baseExperience.sessionManager.scene;
   }
   /**
    * Enable input handling.
@@ -27,10 +50,10 @@ class O {
     this.enabled || (this.enabled = !0, this.enableHandTracking(), this.xr.input.onControllerAddedObservable.add((t) => {
       const i = performance.now() - this.lastControllerRemovedTime;
       if (i < this.INPUT_SWITCH_DELAY_MS && this.lastControllerRemovedTime > 0) {
-        const s = this.INPUT_SWITCH_DELAY_MS - i;
+        const n = this.INPUT_SWITCH_DELAY_MS - i;
         setTimeout(() => {
           this.setupController(t), this.addGestureController(t);
-        }, s);
+        }, n);
       } else
         this.setupController(t), this.addGestureController(t);
     }), this.xr.input.onControllerRemovedObservable.add((t) => {
@@ -83,73 +106,73 @@ class O {
     const { handedness: e } = t.inputSource, { uniqueId: i } = t;
     if (this.setupControllers.has(i))
       return;
-    const { inputSource: s } = t;
-    if (s.profiles.some(
-      (n) => n.includes("hand") || n.includes("generic-trigger-touchpad")
+    const { inputSource: n } = t;
+    if (n.profiles.some(
+      (a) => a.includes("hand") || a.includes("generic-trigger-touchpad")
     ))
       return;
-    const a = (n) => {
+    const o = (a) => {
       if (this.setupControllers.has(i))
         return;
-      const l = n.getComponent("xr-standard-thumbstick");
+      const l = a.getComponent("xr-standard-thumbstick");
       if (!l)
         return;
       this.setupControllers.set(i, !0);
-      const h = e === "left";
-      let u = !1;
-      const m = (S) => {
-        if (u)
+      const u = e === "left";
+      let v = !1;
+      const m = (b) => {
+        if (v)
           return;
-        const { x: b } = S, { y: P } = S;
-        h ? (this.leftStick.x = b, this.leftStick.y = P) : (this.rightStick.x = b, this.rightStick.y = P);
-      }, C = l.onAxisValueChangedObservable.add(m), D = this.scene;
+        const { x: S } = b, { y: R } = b;
+        u ? (this.leftStick.x = S, this.leftStick.y = R) : (this.rightStick.x = S, this.rightStick.y = R);
+      }, H = l.onAxisValueChangedObservable.add(m), C = this.scene;
       let g = null;
-      const N = () => {
-        if (u || !this.enabled)
+      const M = () => {
+        if (v || !this.enabled)
           return;
         if (!this.setupControllers.has(i)) {
-          g && (D.onBeforeRenderObservable.remove(g), g = null);
+          g && (C.onBeforeRenderObservable.remove(g), g = null);
           return;
         }
         if (l._disposed) {
-          g && (D.onBeforeRenderObservable.remove(g), g = null);
+          g && (C.onBeforeRenderObservable.remove(g), g = null);
           return;
         }
-        const S = l.axes.x, b = l.axes.y;
-        h ? (this.leftStick.x = S, this.leftStick.y = b) : (this.rightStick.x = S, this.rightStick.y = b);
+        const b = l.axes.x, S = l.axes.y;
+        u ? (this.leftStick.x = b, this.leftStick.y = S) : (this.rightStick.x = b, this.rightStick.y = S);
       };
-      g = D.onBeforeRenderObservable.add(N), this.controllerCleanup.set(i, () => {
-        if (u = !0, C)
+      g = C.onBeforeRenderObservable.add(M), this.controllerCleanup.set(i, () => {
+        if (v = !0, H)
           try {
-            l.onAxisValueChangedObservable.remove(C);
+            l.onAxisValueChangedObservable.remove(H);
           } catch {
           }
         if (g)
           try {
-            D.onBeforeRenderObservable.remove(g);
+            C.onBeforeRenderObservable.remove(g);
           } catch {
           }
       });
-    }, o = t;
-    if (o.motionController)
-      a(o.motionController);
+    }, r = t;
+    if (r.motionController)
+      o(r.motionController);
     else {
-      o.onMotionControllerInitObservable.add((l) => {
-        a(l);
+      r.onMotionControllerInitObservable.add((l) => {
+        o(l);
       });
-      let n = 0;
+      let a = 0;
       const d = setInterval(() => {
-        if (n++, this.setupControllers.has(i) || n > 20) {
+        if (a++, this.setupControllers.has(i) || a > 20) {
           clearInterval(d);
           return;
         }
-        o.motionController && (a(o.motionController), clearInterval(d));
+        r.motionController && (o(r.motionController), clearInterval(d));
       }, 100);
     }
   }
   cleanupController(t) {
-    const { uniqueId: e } = t, { handedness: i } = t.inputSource, s = this.controllerCleanup.get(e);
-    s && (s(), this.controllerCleanup.delete(e)), this.setupControllers.delete(e), i === "left" ? this.leftStick = { x: 0, y: 0 } : i === "right" && (this.rightStick = { x: 0, y: 0 }), this.lastControllerRemovedTime = performance.now();
+    const { uniqueId: e } = t, { handedness: i } = t.inputSource, n = this.controllerCleanup.get(e);
+    n && (n(), this.controllerCleanup.delete(e)), this.setupControllers.delete(e), i === "left" ? this.leftStick = { x: 0, y: 0 } : i === "right" && (this.rightStick = { x: 0, y: 0 }), this.lastControllerRemovedTime = performance.now();
   }
   /**
    * Process input each frame.
@@ -164,18 +187,8 @@ class O {
    * Right stick: X = pan, Y = zoom
    */
   processThumbsticks() {
-    const t = this.leftStick.x, e = this.leftStick.y, i = this.rightStick.x, s = this.rightStick.y, r = v(t, this.DEADZONE), a = v(e, this.DEADZONE), o = v(i, this.DEADZONE), n = v(s, this.DEADZONE);
-    if (!(r !== 0 || a !== 0 || o !== 0 || n !== 0))
-      return;
-    const l = r * this.YAW_SPEED, h = a * this.PITCH_SPEED;
-    if ((Math.abs(l) > 1e-4 || Math.abs(h) > 1e-4) && this.pivotController.rotate(l, h), Math.abs(n) > 1e-4) {
-      const u = 1 + n * this.ZOOM_SPEED;
-      this.pivotController.zoom(u);
-    }
-    if (Math.abs(o) > 1e-4) {
-      const u = o * this.PAN_SPEED;
-      this.pivotController.panViewRelative(u, 0);
-    }
+    const { yaw: t, pitch: e, zoom: i, pan: n } = G(this.leftStick, this.rightStick);
+    (t !== 0 || e !== 0) && this.pivotController.rotate(t, e), i !== 1 && this.pivotController.zoom(i), n !== 0 && this.pivotController.panViewRelative(n, 0);
   }
   /**
    * Process two-hand gesture input for zoom and rotation.
@@ -185,19 +198,18 @@ class O {
   processHandGesturesInternal() {
     if (!this.leftHand?.isPinching || !this.rightHand?.isPinching)
       return;
-    const t = this.leftHand.position, e = this.rightHand.position, i = f.Distance(t, e), r = e.subtract(t).normalize();
+    const t = this.leftHand.position, e = this.rightHand.position, i = f.Distance(t, e), s = e.subtract(t).normalize();
     if (this.previousDistance === null || this.previousDirection === null) {
-      this.previousDistance = i, this.previousDirection = r.clone();
+      this.previousDistance = i, this.previousDirection = s.clone();
       return;
     }
-    const o = 1 + (i - this.previousDistance) * this.GESTURE_ZOOM_SENSITIVITY;
-    this.pivotController.zoom(2 - Math.max(0.9, Math.min(1.1, o)));
-    const n = f.Cross(this.previousDirection, r), d = n.length();
-    if (d > 1e-4) {
-      const l = f.Dot(this.previousDirection, r), h = Math.acos(Math.max(-1, Math.min(1, l)));
-      n.scaleInPlace(1 / d), this.pivotController.rotateAroundAxis(n, -h);
-    }
-    this.previousDistance = i, this.previousDirection = r.clone();
+    const { zoom: o, axis: r, angle: a } = W(
+      this.previousDistance,
+      this.previousDirection,
+      i,
+      s
+    );
+    this.pivotController.zoom(o), r && this.pivotController.rotateAroundAxis(r, a), this.previousDistance = i, this.previousDirection = s.clone();
   }
   /**
    * Update hand states from controllers (trigger) or hand tracking.
@@ -219,22 +231,22 @@ class O {
         break;
       }
     if (e) {
-      const { controller: i } = e, { grip: s } = i, r = i;
-      if (s && r.motionController)
+      const { controller: i } = e, { grip: n } = i, s = i;
+      if (n && s.motionController)
         try {
-          const a = s.position;
-          if (isFinite(a.x) && isFinite(a.y) && isFinite(a.z)) {
-            const o = r.motionController.getComponent("xr-standard-trigger");
-            if (o) {
-              const n = o.value ?? 0;
-              if (o.pressed === !0 || n > 0.5)
-                return this.wasPinching[t] || p.debug("Trigger press", { handedness: t, value: n }), this.wasPinching[t] = !0, {
-                  position: a.clone(),
-                  rotation: s.rotationQuaternion?.clone() ?? E.Identity(),
+          const o = n.position;
+          if (isFinite(o.x) && isFinite(o.y) && isFinite(o.z)) {
+            const r = s.motionController.getComponent("xr-standard-trigger");
+            if (r) {
+              const a = r.value ?? 0;
+              if (r.pressed === !0 || a > 0.5)
+                return this.wasPinching[t] || p.debug("Trigger press", { handedness: t, value: a }), this.wasPinching[t] = !0, {
+                  position: o.clone(),
+                  rotation: n.rotationQuaternion?.clone() ?? E.Identity(),
                   isPinching: !0,
-                  pinchStrength: n
+                  pinchStrength: a
                 };
-              this.wasPinching[t] && (p.debug("Trigger release", { handedness: t, value: n }), this.wasPinching[t] = !1, this.resetGestureState());
+              this.wasPinching[t] && (p.debug("Trigger release", { handedness: t, value: a }), this.wasPinching[t] = !1, this.resetGestureState());
             }
           }
         } catch {
@@ -242,19 +254,19 @@ class O {
     }
     if (this.handTrackingFeature)
       try {
-        const s = this.handTrackingFeature.getHandByHandedness?.(t);
-        if (s) {
-          const r = s.getJointMesh("wrist"), a = s.getJointMesh("thumb-tip"), o = s.getJointMesh("index-finger-tip");
-          if (r && a && o) {
-            if (!isFinite(r.position.x) || !isFinite(a.position.x))
+        const n = this.handTrackingFeature.getHandByHandedness?.(t);
+        if (n) {
+          const s = n.getJointMesh("wrist"), o = n.getJointMesh("thumb-tip"), r = n.getJointMesh("index-finger-tip");
+          if (s && o && r) {
+            if (!isFinite(s.position.x) || !isFinite(o.position.x))
               return null;
-            const n = f.Distance(a.position, o.position), d = 0.04, l = 0.06, h = this.wasPinching[t], u = h ? n < l : n < d;
-            if (u !== h && (p.debug(u ? "Pinch start" : "Pinch end", { handedness: t, distance: n }), u || this.resetGestureState()), this.wasPinching[t] = u, u)
+            const a = f.Distance(o.position, r.position), d = this.wasPinching[t], l = F(a, d);
+            if (l !== d && (p.debug(l ? "Pinch start" : "Pinch end", { handedness: t, distance: a }), l || this.resetGestureState()), this.wasPinching[t] = l, l)
               return {
-                position: r.position.clone(),
-                rotation: r.rotationQuaternion?.clone() ?? E.Identity(),
+                position: s.position.clone(),
+                rotation: s.rotationQuaternion?.clone() ?? E.Identity(),
                 isPinching: !0,
-                pinchStrength: Math.max(0, 1 - n / d)
+                pinchStrength: z(a)
               };
           }
         }
@@ -312,61 +324,61 @@ class O {
    */
   tryStartNodeDrag(t, e) {
     let i = null;
-    for (const h of this.gestureControllers.values())
-      if (h.handedness === t) {
-        ({ controller: i } = h);
+    for (const u of this.gestureControllers.values())
+      if (u.handedness === t) {
+        ({ controller: i } = u);
         break;
       }
     if (!i)
       return;
-    const s = new R(f.Zero(), f.Forward(), 100), r = i;
-    if (r.getWorldPointerRayToRef)
-      r.getWorldPointerRayToRef(s);
+    const n = new N(f.Zero(), f.Forward(), 100), s = i;
+    if (s.getWorldPointerRayToRef)
+      s.getWorldPointerRayToRef(n);
     else {
-      const h = i.grip ?? i.pointer;
-      s.origin = h.position.clone(), s.direction = h.forward.clone();
+      const u = i.grip ?? i.pointer;
+      n.origin = u.position.clone(), n.direction = u.forward.clone();
     }
-    const a = this.scene.pickWithRay(s, (h) => h.isPickable && h.isEnabled());
-    if (!a?.hit || !a.pickedMesh)
+    const o = this.scene.pickWithRay(n, (u) => u.isPickable && u.isEnabled());
+    if (!o?.hit || !o.pickedMesh)
       return;
-    const o = this.findDragHandlerForMesh(a.pickedMesh);
-    if (!o)
+    const r = this.findDragHandlerForMesh(o.pickedMesh);
+    if (!r)
       return;
-    const d = o.getNode().mesh.position, { pickedPoint: l } = a;
+    const d = r.getNode().mesh.position, { pickedPoint: l } = o;
     p.debug("Drag start", {
       handedness: t,
       handPos: { x: e.x, y: e.y, z: e.z },
       nodePos: { x: d.x, y: d.y, z: d.z },
       pickPt: l ? { x: l.x, y: l.y, z: l.z } : null
-    }), this.isDraggingNode = !0, this.draggedNodeHandler = o, this.dragHand = t, this.lastDragHandPosition = e.clone(), this.dragStartHandPosition = e.clone(), this.dragThresholdExceeded = !1, this.lastDragTime = performance.now();
+    }), this.isDraggingNode = !0, this.draggedNodeHandler = r, this.dragHand = t, this.lastDragHandPosition = e.clone(), this.dragStartHandPosition = e.clone(), this.dragThresholdExceeded = !1, this.lastDragTime = performance.now();
   }
   updateNodeDrag(t) {
     if (!this.draggedNodeHandler || !this.lastDragHandPosition || !this.dragStartHandPosition)
       return;
     const e = performance.now();
     if (!this.dragThresholdExceeded) {
-      const C = f.Distance(t, this.dragStartHandPosition);
-      if (C < this.DRAG_THRESHOLD) {
+      const H = f.Distance(t, this.dragStartHandPosition);
+      if (H < this.DRAG_THRESHOLD) {
         this.lastDragHandPosition = t.clone(), this.lastDragTime = e;
         return;
       }
-      this.dragThresholdExceeded = !0, p.debug("Drag threshold exceeded", { distance: C });
-      const D = this.draggedNodeHandler.getNode();
-      this.draggedNodeHandler.onDragStart(D.mesh.position.clone()), this.lastDragHandPosition = t.clone(), this.lastDragTime = e;
+      this.dragThresholdExceeded = !0, p.debug("Drag threshold exceeded", { distance: H });
+      const C = this.draggedNodeHandler.getNode();
+      this.draggedNodeHandler.onDragStart(C.mesh.position.clone()), this.lastDragHandPosition = t.clone(), this.lastDragTime = e;
       return;
     }
-    const i = t.subtract(this.lastDragHandPosition), s = i.length();
-    if (s < 1e-4)
+    const i = t.subtract(this.lastDragHandPosition), n = i.length();
+    if (n < 1e-4)
       return;
     this.dragUpdateCount++;
-    const r = e - this.lastDragTime, a = Math.max(r / 1e3, 1e-3), o = s / a, n = this.calculateVelocityBasedGain(o), d = this.transformDeltaToSceneSpace(i);
-    d.scaleInPlace(n), this.smoothedDelta === null ? this.smoothedDelta = d.clone() : (this.smoothedDelta.scaleInPlace(this.SMOOTHING_FACTOR), this.smoothedDelta.addInPlace(d.scale(1 - this.SMOOTHING_FACTOR)));
+    const s = e - this.lastDragTime, o = Math.max(s / 1e3, 1e-3), r = n / o, a = this.calculateVelocityBasedGain(r), d = this.transformDeltaToSceneSpace(i);
+    d.scaleInPlace(a), this.smoothedDelta === null ? this.smoothedDelta = d.clone() : (this.smoothedDelta.scaleInPlace(this.SMOOTHING_FACTOR), this.smoothedDelta.addInPlace(d.scale(1 - this.SMOOTHING_FACTOR)));
     const l = this.smoothedDelta.clone(), m = this.draggedNodeHandler.getNode().mesh.position.clone().add(l);
     this.dragUpdateCount <= 5 && p.trace("Drag update", {
       updateCount: this.dragUpdateCount,
       delta: { x: i.x, y: i.y, z: i.z },
-      velocity: o,
-      amplification: n,
+      velocity: r,
+      amplification: a,
       newPos: { x: m.x, y: m.y, z: m.z }
     }), this.draggedNodeHandler.setPositionDirect(m), this.lastDragHandPosition = t.clone(), this.lastDragTime = e;
   }
@@ -437,15 +449,15 @@ class O {
     return this.isDraggingNode;
   }
 }
-const c = x.getLogger(["graphty", "camera", "xr"]);
-class A {
+const h = y.getLogger(["graphty", "camera", "xr"]);
+class q {
   /**
    * Creates a new XRPivotCameraController instance.
    * @param scene - The Babylon.js scene
    * @param xr - The WebXR experience instance
    */
   constructor(t, e) {
-    this.frameCount = 0, this.scene = t, this.xr = e, this.pivotController = new M(t), this.inputHandler = new O(this.pivotController, e), c.debug("Created"), this.setupXRListeners();
+    this.frameCount = 0, this.scene = t, this.xr = e, this.pivotController = new I(t), this.inputHandler = new V(this.pivotController, e), h.debug("Created"), this.setupXRListeners();
   }
   /**
    * Setup listeners for XR state changes.
@@ -453,13 +465,13 @@ class A {
    * When exiting XR, disables input and unparents camera.
    */
   setupXRListeners() {
-    c.debug("Setting up XR state listeners");
+    h.debug("Setting up XR state listeners");
     const t = this.xr.baseExperience.state;
-    c.debug("Current XR state", { state: T[t] }), t === T.IN_XR && (c.debug("Already in XR, enabling immediately"), this.enableXRMode()), this.xr.baseExperience.onStateChangedObservable.add((e) => {
-      const i = T[e];
-      c.debug("XR state changed", { state: i }), e === T.IN_XR ? this.enableXRMode() : e === T.NOT_IN_XR && this.disableXRMode();
+    h.debug("Current XR state", { state: D[t] }), t === D.IN_XR && (h.debug("Already in XR, enabling immediately"), this.enableXRMode()), this.xr.baseExperience.onStateChangedObservable.add((e) => {
+      const i = D[e];
+      h.debug("XR state changed", { state: i }), e === D.IN_XR ? this.enableXRMode() : e === D.NOT_IN_XR && this.disableXRMode();
     }), this.xr.baseExperience.onInitialXRPoseSetObservable.add((e) => {
-      c.debug("Initial XR pose set", {
+      h.debug("Initial XR pose set", {
         cameraName: e.name,
         position: { x: e.position.x, y: e.position.y, z: e.position.z }
       });
@@ -470,10 +482,10 @@ class A {
    */
   enableXRMode() {
     const { camera: t } = this.xr.baseExperience;
-    t.parent = this.pivotController.pivot, c.debug("XR camera parented to pivot", {
+    t.parent = this.pivotController.pivot, h.debug("XR camera parented to pivot", {
       pivotName: this.pivotController.pivot.name,
       cameraName: t.name
-    }), this.parentHandMeshesToPivot(), this.inputHandler.enable(), c.debug("Input handler enabled");
+    }), this.parentHandMeshesToPivot(), this.inputHandler.enable(), h.debug("Input handler enabled");
   }
   /**
    * Parent hand tracking joint meshes to the pivot.
@@ -484,26 +496,26 @@ class A {
     try {
       const { featuresManager: t } = this.xr.baseExperience, e = t.getEnabledFeature("xr-hand-tracking");
       if (!e) {
-        c.debug("No hand tracking feature to parent");
+        h.debug("No hand tracking feature to parent");
         return;
       }
       const i = e;
-      i.leftHand?.handMesh && (i.leftHand.handMesh.parent = this.pivotController.pivot, c.debug("Left hand mesh parented to pivot")), i.rightHand?.handMesh && (i.rightHand.handMesh.parent = this.pivotController.pivot, c.debug("Right hand mesh parented to pivot"));
-      const s = this.scene.meshes.filter((r) => r.name.includes("hand") || r.name.includes("Hand"));
-      if (s.length > 0) {
-        c.debug("Found hand-related meshes", { count: s.length });
-        for (const r of s)
-          r.parent || (r.parent = this.pivotController.pivot, c.debug("Parented mesh", { name: r.name }));
+      i.leftHand?.handMesh && (i.leftHand.handMesh.parent = this.pivotController.pivot, h.debug("Left hand mesh parented to pivot")), i.rightHand?.handMesh && (i.rightHand.handMesh.parent = this.pivotController.pivot, h.debug("Right hand mesh parented to pivot"));
+      const n = this.scene.meshes.filter((s) => s.name.includes("hand") || s.name.includes("Hand"));
+      if (n.length > 0) {
+        h.debug("Found hand-related meshes", { count: n.length });
+        for (const s of n)
+          s.parent || (s.parent = this.pivotController.pivot, h.debug("Parented mesh", { name: s.name }));
       }
     } catch (t) {
-      c.warn("Error parenting hand meshes", { error: String(t) });
+      h.warn("Error parenting hand meshes", { error: String(t) });
     }
   }
   /**
    * Disable XR mode - unparent camera and disable input.
    */
   disableXRMode() {
-    c.debug("Exiting XR, disabling input"), this.inputHandler.disable(), this.xr.baseExperience.camera.parent = null;
+    h.debug("Exiting XR, disabling input"), this.inputHandler.disable(), this.xr.baseExperience.camera.parent = null;
   }
   /**
    * Update input handling.
@@ -512,7 +524,7 @@ class A {
   update() {
     if (this.frameCount++, this.frameCount % 300 === 0) {
       const { camera: t } = this.xr.baseExperience, { pivot: e } = this.pivotController;
-      c.trace("Heartbeat", {
+      h.trace("Heartbeat", {
         frame: this.frameCount,
         inputEnabled: this.inputHandler.isEnabled(),
         cameraParent: t.parent ? t.parent.name : "null",
@@ -558,5 +570,5 @@ class A {
   }
 }
 export {
-  A as XRPivotCameraController
+  q as XRPivotCameraController
 };