@kitware/vtk.js 28.10.1 → 28.11.0

package/Interaction/Style/InteractorStyleManipulator.js

@@ -1,77 +1,83 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkInteractorStyle from '../../Rendering/Core/InteractorStyle.js';
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+const {
+  vtkDebugMacro
+} = macro;
+const {
+  States
+} = vtkInteractorStyle;
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-var vtkDebugMacro = macro.vtkDebugMacro;
-var States = vtkInteractorStyle.States; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // Event Types
 // ----------------------------------------------------------------------------
 
-var START_INTERACTION_EVENT = {
+const START_INTERACTION_EVENT = {
   type: 'StartInteractionEvent'
 };
-var INTERACTION_EVENT = {
+const INTERACTION_EVENT = {
   type: 'InteractionEvent'
 };
-var END_INTERACTION_EVENT = {
+const END_INTERACTION_EVENT = {
   type: 'EndInteractionEvent'
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 // Global methods
 // ----------------------------------------------------------------------------
 
 function translateCamera(renderer, rwi, toX, toY, fromX, fromY) {
-  var cam = renderer.getActiveCamera();
-  var viewFocus = cam.getFocalPoint();
+  const cam = renderer.getActiveCamera();
+  let viewFocus = cam.getFocalPoint();
   viewFocus = rwi.getInteractorStyle().computeWorldToDisplay(renderer, viewFocus[0], viewFocus[1], viewFocus[2]);
-  var focalDepth = viewFocus[2];
-  var newPickPoint = rwi.getInteractorStyle().computeDisplayToWorld(renderer, toX, toY, focalDepth);
-  var oldPickPoint = rwi.getInteractorStyle().computeDisplayToWorld(renderer, fromX, fromY, focalDepth); // camera motion is reversed
+  const focalDepth = viewFocus[2];
+  const newPickPoint = rwi.getInteractorStyle().computeDisplayToWorld(renderer, toX, toY, focalDepth);
+  const oldPickPoint = rwi.getInteractorStyle().computeDisplayToWorld(renderer, fromX, fromY, focalDepth);
 
-  var motionVector = [oldPickPoint[0] - newPickPoint[0], oldPickPoint[1] - newPickPoint[1], oldPickPoint[2] - newPickPoint[2]];
+  // camera motion is reversed
+  const motionVector = [oldPickPoint[0] - newPickPoint[0], oldPickPoint[1] - newPickPoint[1], oldPickPoint[2] - newPickPoint[2]];
   viewFocus = cam.getFocalPoint();
-  var viewPoint = cam.getPosition();
+  const viewPoint = cam.getPosition();
   cam.setFocalPoint(motionVector[0] + viewFocus[0], motionVector[1] + viewFocus[1], motionVector[2] + viewFocus[2]);
   cam.setPosition(motionVector[0] + viewPoint[0], motionVector[1] + viewPoint[1], motionVector[2] + viewPoint[2]);
 }
-
 function dollyToPosition(fact, position, renderer, rwi) {
-  var cam = renderer.getActiveCamera();
-
+  const cam = renderer.getActiveCamera();
   if (cam.getParallelProjection()) {
     // Zoom relatively to the cursor
-    var view = rwi.getView();
-    var aSize = view.getViewportSize(renderer);
-    var viewport = renderer.getViewport();
-    var viewSize = view.getSize();
-    var w = aSize[0];
-    var h = aSize[1];
-    var x0 = w / 2;
-    var y0 = h / 2;
-    var x1 = position.x - viewport[0] * viewSize[0];
-    var y1 = position.y - viewport[1] * viewSize[1];
+    const view = rwi.getView();
+    const aSize = view.getViewportSize(renderer);
+    const viewport = renderer.getViewport();
+    const viewSize = view.getSize();
+    const w = aSize[0];
+    const h = aSize[1];
+    const x0 = w / 2;
+    const y0 = h / 2;
+    const x1 = position.x - viewport[0] * viewSize[0];
+    const y1 = position.y - viewport[1] * viewSize[1];
     translateCamera(renderer, rwi, x0, y0, x1, y1);
     cam.setParallelScale(cam.getParallelScale() / fact);
     translateCamera(renderer, rwi, x1, y1, x0, y0);
   } else {
     // Zoom relatively to the cursor position
+
     // Move focal point to cursor position
-    var viewFocus = cam.getFocalPoint();
-    var norm = cam.getViewPlaneNormal();
+    let viewFocus = cam.getFocalPoint();
+    const norm = cam.getViewPlaneNormal();
     viewFocus = rwi.getInteractorStyle().computeWorldToDisplay(renderer, viewFocus[0], viewFocus[1], viewFocus[2]);
-    var newFp = rwi.getInteractorStyle().computeDisplayToWorld(renderer, position.x, position.y, viewFocus[2]);
-    cam.setFocalPoint(newFp[0], newFp[1], newFp[2]); // Move camera in/out along projection direction
+    const newFp = rwi.getInteractorStyle().computeDisplayToWorld(renderer, position.x, position.y, viewFocus[2]);
+    cam.setFocalPoint(newFp[0], newFp[1], newFp[2]);
 
+    // Move camera in/out along projection direction
     cam.dolly(fact);
-    renderer.resetCameraClippingRange(); // Find new focal point
+    renderer.resetCameraClippingRange();
 
-    var newCameraPos = cam.getPosition();
+    // Find new focal point
+    const newCameraPos = cam.getPosition();
     viewFocus = cam.getFocalPoint();
-    var newPoint = [0, 0, 0];
-    var t = norm[0] * (viewFocus[0] - newCameraPos[0]) + norm[1] * (viewFocus[1] - newCameraPos[1]) + norm[2] * (viewFocus[2] - newCameraPos[2]);
-    t /= Math.pow(norm[0], 2) + Math.pow(norm[1], 2) + Math.pow(norm[2], 2);
+    const newPoint = [0, 0, 0];
+    let t = norm[0] * (viewFocus[0] - newCameraPos[0]) + norm[1] * (viewFocus[1] - newCameraPos[1]) + norm[2] * (viewFocus[2] - newCameraPos[2]);
+    t /= norm[0] ** 2 + norm[1] ** 2 + norm[2] ** 2;
     newPoint[0] = newCameraPos[0] + norm[0] * t;
     newPoint[1] = newCameraPos[1] + norm[1] * t;
     newPoint[2] = newCameraPos[2] + norm[2] * t;
@@ -79,34 +85,33 @@ function dollyToPosition(fact, position, renderer, rwi) {
     renderer.resetCameraClippingRange();
   }
 }
-
 function dollyByFactor(interactor, renderer, factor) {
   if (Number.isNaN(factor)) {
     return;
   }
-
-  var camera = renderer.getActiveCamera();
-
+  const camera = renderer.getActiveCamera();
   if (camera.getParallelProjection()) {
     camera.setParallelScale(camera.getParallelScale() / factor);
   } else {
     camera.dolly(factor);
     renderer.resetCameraClippingRange();
   }
-
   if (interactor.getLightFollowCamera()) {
     renderer.updateLightsGeometryToFollowCamera();
   }
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Static API
 // ----------------------------------------------------------------------------
 
+const STATIC = {
+  dollyToPosition,
+  translateCamera,
+  dollyByFactor
+};
 
-var STATIC = {
-  dollyToPosition: dollyToPosition,
-  translateCamera: translateCamera,
-  dollyByFactor: dollyByFactor
-}; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // vtkInteractorStyleManipulator methods
 // ----------------------------------------------------------------------------
 
@@ -120,159 +125,130 @@ function vtkInteractorStyleManipulator(publicAPI, model) {
   model.currentManipulator = null;
   model.currentWheelManipulator = null;
   model.centerOfRotation = [0, 0, 0];
-  model.rotationFactor = 1; //-------------------------------------------------------------------------
+  model.rotationFactor = 1;
 
-  publicAPI.removeAllManipulators = function () {
+  //-------------------------------------------------------------------------
+  publicAPI.removeAllManipulators = () => {
     publicAPI.removeAllMouseManipulators();
     publicAPI.removeAllKeyboardManipulators();
     publicAPI.removeAllVRManipulators();
     publicAPI.removeAllGestureManipulators();
-  }; //-------------------------------------------------------------------------
-
+  };
 
-  publicAPI.removeAllMouseManipulators = function () {
+  //-------------------------------------------------------------------------
+  publicAPI.removeAllMouseManipulators = () => {
     model.mouseManipulators = [];
-  }; //-------------------------------------------------------------------------
-
+  };
 
-  publicAPI.removeAllKeyboardManipulators = function () {
+  //-------------------------------------------------------------------------
+  publicAPI.removeAllKeyboardManipulators = () => {
     model.keyboardManipulators = [];
-  }; //-------------------------------------------------------------------------
-
+  };
 
-  publicAPI.removeAllVRManipulators = function () {
+  //-------------------------------------------------------------------------
+  publicAPI.removeAllVRManipulators = () => {
     model.vrManipulators = [];
-  }; //-------------------------------------------------------------------------
-
+  };
 
-  publicAPI.removeAllGestureManipulators = function () {
+  //-------------------------------------------------------------------------
+  publicAPI.removeAllGestureManipulators = () => {
     model.gestureManipulators = [];
-  }; //-------------------------------------------------------------------------
-
-
-  var removeManipulator = function removeManipulator(manipulator, list) {
-    var index = list.indexOf(manipulator);
+  };
 
+  //-------------------------------------------------------------------------
+  const removeManipulator = (manipulator, list) => {
+    const index = list.indexOf(manipulator);
     if (index === -1) {
       return false;
     }
-
     list.splice(index, 1);
     publicAPI.modified();
     return true;
-  }; //-------------------------------------------------------------------------
-
-
-  publicAPI.removeMouseManipulator = function (manipulator) {
-    return removeManipulator(manipulator, model.mouseManipulators);
-  }; //-------------------------------------------------------------------------
-
-
-  publicAPI.removeKeyboardManipulator = function (manipulator) {
-    return removeManipulator(manipulator, model.keyboardManipulators);
-  }; //-------------------------------------------------------------------------
-
-
-  publicAPI.removeVRManipulator = function (manipulator) {
-    return removeManipulator(manipulator, model.vrManipulators);
-  }; //-------------------------------------------------------------------------
+  };
 
+  //-------------------------------------------------------------------------
+  publicAPI.removeMouseManipulator = manipulator => removeManipulator(manipulator, model.mouseManipulators);
 
-  publicAPI.removeGestureManipulator = function (manipulator) {
-    return removeManipulator(manipulator, model.gestureManipulators);
-  }; //-------------------------------------------------------------------------
+  //-------------------------------------------------------------------------
+  publicAPI.removeKeyboardManipulator = manipulator => removeManipulator(manipulator, model.keyboardManipulators);
 
+  //-------------------------------------------------------------------------
+  publicAPI.removeVRManipulator = manipulator => removeManipulator(manipulator, model.vrManipulators);
 
-  var addManipulator = function addManipulator(manipulator, list) {
-    var index = list.indexOf(manipulator);
+  //-------------------------------------------------------------------------
+  publicAPI.removeGestureManipulator = manipulator => removeManipulator(manipulator, model.gestureManipulators);
 
+  //-------------------------------------------------------------------------
+  const addManipulator = (manipulator, list) => {
+    const index = list.indexOf(manipulator);
     if (index !== -1) {
       return false;
     }
-
     list.push(manipulator);
     publicAPI.modified();
     return true;
-  }; //-------------------------------------------------------------------------
-
-
-  publicAPI.addMouseManipulator = function (manipulator) {
-    return addManipulator(manipulator, model.mouseManipulators);
-  }; //-------------------------------------------------------------------------
-
-
-  publicAPI.addKeyboardManipulator = function (manipulator) {
-    return addManipulator(manipulator, model.keyboardManipulators);
-  }; //-------------------------------------------------------------------------
-
-
-  publicAPI.addVRManipulator = function (manipulator) {
-    return addManipulator(manipulator, model.vrManipulators);
-  }; //-------------------------------------------------------------------------
-
-
-  publicAPI.addGestureManipulator = function (manipulator) {
-    return addManipulator(manipulator, model.gestureManipulators);
-  }; //-------------------------------------------------------------------------
-
+  };
 
-  publicAPI.getNumberOfMouseManipulators = function () {
-    return model.mouseManipulators.length;
-  }; //-------------------------------------------------------------------------
+  //-------------------------------------------------------------------------
+  publicAPI.addMouseManipulator = manipulator => addManipulator(manipulator, model.mouseManipulators);
 
+  //-------------------------------------------------------------------------
+  publicAPI.addKeyboardManipulator = manipulator => addManipulator(manipulator, model.keyboardManipulators);
 
-  publicAPI.getNumberOfKeyboardManipulators = function () {
-    return model.keyboardManipulators.length;
-  }; //-------------------------------------------------------------------------
+  //-------------------------------------------------------------------------
+  publicAPI.addVRManipulator = manipulator => addManipulator(manipulator, model.vrManipulators);
 
+  //-------------------------------------------------------------------------
+  publicAPI.addGestureManipulator = manipulator => addManipulator(manipulator, model.gestureManipulators);
 
-  publicAPI.getNumberOfVRManipulators = function () {
-    return model.vrManipulators.length;
-  }; //-------------------------------------------------------------------------
+  //-------------------------------------------------------------------------
+  publicAPI.getNumberOfMouseManipulators = () => model.mouseManipulators.length;
 
+  //-------------------------------------------------------------------------
+  publicAPI.getNumberOfKeyboardManipulators = () => model.keyboardManipulators.length;
 
-  publicAPI.getNumberOfGestureManipulators = function () {
-    return model.gestureManipulators.length;
-  }; //-------------------------------------------------------------------------
+  //-------------------------------------------------------------------------
+  publicAPI.getNumberOfVRManipulators = () => model.vrManipulators.length;
 
+  //-------------------------------------------------------------------------
+  publicAPI.getNumberOfGestureManipulators = () => model.gestureManipulators.length;
 
-  publicAPI.resetCurrentManipulator = function () {
+  //-------------------------------------------------------------------------
+  publicAPI.resetCurrentManipulator = () => {
     model.currentManipulator = null;
     model.currentWheelManipulator = null;
-  }; //-------------------------------------------------------------------------
+  };
+
+  //-------------------------------------------------------------------------
   // Mouse
   //-------------------------------------------------------------------------
-
-
-  publicAPI.handleLeftButtonPress = function (callData) {
+  publicAPI.handleLeftButtonPress = callData => {
     model.previousPosition = callData.position;
     publicAPI.onButtonDown(1, callData);
-  }; //-------------------------------------------------------------------------
-
+  };
 
-  publicAPI.handleMiddleButtonPress = function (callData) {
+  //-------------------------------------------------------------------------
+  publicAPI.handleMiddleButtonPress = callData => {
     model.previousPosition = callData.position;
     publicAPI.onButtonDown(2, callData);
-  }; //-------------------------------------------------------------------------
-
+  };
 
-  publicAPI.handleRightButtonPress = function (callData) {
+  //-------------------------------------------------------------------------
+  publicAPI.handleRightButtonPress = callData => {
     model.previousPosition = callData.position;
     publicAPI.onButtonDown(3, callData);
-  }; //-------------------------------------------------------------------------
-
+  };
 
-  publicAPI.handleButton3D = function (ed) {
+  //-------------------------------------------------------------------------
+  publicAPI.handleButton3D = ed => {
     if (!ed) {
       return;
-    } // Look for a matching 3D camera interactor.
-
+    }
 
+    // Look for a matching 3D camera interactor.
     model.currentManipulator = publicAPI.findVRManipulator(ed.device, ed.input, ed.pressed);
-
     if (model.currentManipulator) {
       model.currentManipulator.onButton3D(publicAPI, ed.pokedRenderer, model.state, ed.device, ed.input, ed.pressed);
-
       if (ed.pressed) {
         publicAPI.startCameraPose();
       } else {
@@ -281,387 +257,326 @@ function vtkInteractorStyleManipulator(publicAPI, model) {
     } else {
       vtkDebugMacro('No manipulator found');
     }
-  }; //-------------------------------------------------------------------------
-
+  };
 
-  publicAPI.handleMove3D = function (ed) {
+  //-------------------------------------------------------------------------
+  publicAPI.handleMove3D = ed => {
     if (model.currentManipulator && model.state === States.IS_CAMERA_POSE) {
       model.currentManipulator.onMove3D(publicAPI, ed.pokedRenderer, model.state, ed);
     }
-  }; //-------------------------------------------------------------------------
-
+  };
 
-  publicAPI.onButtonDown = function (button, callData) {
+  //-------------------------------------------------------------------------
+  publicAPI.onButtonDown = (button, callData) => {
     // Must not be processing an interaction to start another.
     if (model.currentManipulator) {
       return;
-    } // Look for a matching camera interactor.
-
+    }
 
+    // Look for a matching camera interactor.
     model.currentManipulator = publicAPI.findMouseManipulator(button, callData.shiftKey, callData.controlKey, callData.altKey);
-
     if (model.currentManipulator) {
       if (model.currentManipulator.setCenter) {
         model.currentManipulator.setCenter(model.centerOfRotation);
       }
-
       if (model.currentManipulator.setRotationFactor) {
         model.currentManipulator.setRotationFactor(model.rotationFactor);
       }
-
       model.currentManipulator.startInteraction();
       model.currentManipulator.onButtonDown(model._interactor, callData.pokedRenderer, callData.position);
-
       model._interactor.requestAnimation(publicAPI.onButtonDown);
-
       publicAPI.invokeStartInteractionEvent(START_INTERACTION_EVENT);
     } else {
       vtkDebugMacro('No manipulator found');
     }
-  }; //-------------------------------------------------------------------------
-
+  };
 
-  publicAPI.findMouseManipulator = function (button, shift, control, alt) {
+  //-------------------------------------------------------------------------
+  publicAPI.findMouseManipulator = (button, shift, control, alt) => {
     // Look for a matching camera manipulator
-    var manipulator = null;
-    var count = model.mouseManipulators.length;
-
+    let manipulator = null;
+    let count = model.mouseManipulators.length;
     while (count--) {
-      var manip = model.mouseManipulators[count];
-
+      const manip = model.mouseManipulators[count];
       if (manip && manip.getButton() === button && manip.getShift() === shift && manip.getControl() === control && manip.getAlt() === alt && manip.isDragEnabled()) {
         manipulator = manip;
       }
     }
-
     return manipulator;
-  }; //-------------------------------------------------------------------------
-
+  };
 
-  publicAPI.findVRManipulator = function (device, input) {
+  //-------------------------------------------------------------------------
+  publicAPI.findVRManipulator = (device, input) => {
     // Look for a matching camera manipulator
-    var manipulator = null;
-    var count = model.vrManipulators.length;
-
+    let manipulator = null;
+    let count = model.vrManipulators.length;
     while (count--) {
-      var manip = model.vrManipulators[count];
-
+      const manip = model.vrManipulators[count];
       if (manip && manip.getDevice() === device && manip.getInput() === input) {
         manipulator = manip;
       }
     }
-
     return manipulator;
-  }; //-------------------------------------------------------------------------
-
+  };
 
-  publicAPI.handleLeftButtonRelease = function () {
+  //-------------------------------------------------------------------------
+  publicAPI.handleLeftButtonRelease = () => {
     publicAPI.onButtonUp(1);
-  }; //-------------------------------------------------------------------------
-
+  };
 
-  publicAPI.handleMiddleButtonRelease = function () {
+  //-------------------------------------------------------------------------
+  publicAPI.handleMiddleButtonRelease = () => {
     publicAPI.onButtonUp(2);
-  }; //-------------------------------------------------------------------------
-
+  };
 
-  publicAPI.handleRightButtonRelease = function () {
+  //-------------------------------------------------------------------------
+  publicAPI.handleRightButtonRelease = () => {
     publicAPI.onButtonUp(3);
-  }; //-------------------------------------------------------------------------
-
+  };
 
-  publicAPI.onButtonUp = function (button) {
+  //-------------------------------------------------------------------------
+  publicAPI.onButtonUp = button => {
     if (!model.currentManipulator) {
       return;
     }
-
     if (model.currentManipulator.getButton && model.currentManipulator.getButton() === button) {
       model.currentManipulator.onButtonUp(model._interactor);
       model.currentManipulator.endInteraction();
       model.currentManipulator = null;
-
       model._interactor.cancelAnimation(publicAPI.onButtonDown);
-
       publicAPI.invokeEndInteractionEvent(END_INTERACTION_EVENT);
     }
-  }; //-------------------------------------------------------------------------
-
+  };
 
-  publicAPI.handleStartMouseWheel = function (callData) {
+  //-------------------------------------------------------------------------
+  publicAPI.handleStartMouseWheel = callData => {
     // Must not be processing a wheel interaction to start another.
     if (model.currentWheelManipulator) {
       return;
     }
-
-    var manipulator = null;
-    var count = model.mouseManipulators.length;
-
+    let manipulator = null;
+    let count = model.mouseManipulators.length;
     while (count--) {
-      var manip = model.mouseManipulators[count];
-
+      const manip = model.mouseManipulators[count];
       if (manip && manip.isScrollEnabled() && manip.getShift() === callData.shiftKey && manip.getControl() === callData.controlKey && manip.getAlt() === callData.altKey) {
         manipulator = manip;
       }
     }
-
     if (manipulator) {
       model.currentWheelManipulator = manipulator;
       model.currentWheelManipulator.onStartScroll(model._interactor, callData.pokedRenderer, callData.spinY);
       model.currentWheelManipulator.startInteraction();
-
       model._interactor.requestAnimation(publicAPI.handleStartMouseWheel);
-
       publicAPI.invokeStartInteractionEvent(START_INTERACTION_EVENT);
     } else {
       vtkDebugMacro('No manipulator found');
     }
-  }; //-------------------------------------------------------------------------
-
+  };
 
-  publicAPI.handleEndMouseWheel = function () {
+  //-------------------------------------------------------------------------
+  publicAPI.handleEndMouseWheel = () => {
     if (!model.currentWheelManipulator) {
       return;
     }
-
     if (model.currentWheelManipulator.onEndScroll) {
       model.currentWheelManipulator.onEndScroll(model._interactor);
       model.currentWheelManipulator.endInteraction();
       model.currentWheelManipulator = null;
-
       model._interactor.cancelAnimation(publicAPI.handleStartMouseWheel);
-
       publicAPI.invokeEndInteractionEvent(END_INTERACTION_EVENT);
     }
-  }; //-------------------------------------------------------------------------
-
+  };
 
-  publicAPI.handleMouseWheel = function (callData) {
+  //-------------------------------------------------------------------------
+  publicAPI.handleMouseWheel = callData => {
     if (model.currentWheelManipulator && model.currentWheelManipulator.onScroll) {
       model.currentWheelManipulator.onScroll(model._interactor, callData.pokedRenderer, callData.spinY, model.cachedMousePosition);
       publicAPI.invokeInteractionEvent(INTERACTION_EVENT);
     }
-  }; //-------------------------------------------------------------------------
-
+  };
 
-  publicAPI.handleMouseMove = function (callData) {
+  //-------------------------------------------------------------------------
+  publicAPI.handleMouseMove = callData => {
     model.cachedMousePosition = callData.position;
-
     if (model.currentManipulator && model.currentManipulator.onMouseMove) {
       model.currentManipulator.onMouseMove(model._interactor, callData.pokedRenderer, callData.position);
       publicAPI.invokeInteractionEvent(INTERACTION_EVENT);
     }
-  }; //-------------------------------------------------------------------------
+  };
+
+  //-------------------------------------------------------------------------
   // Keyboard
   //-------------------------------------------------------------------------
-
-
-  publicAPI.handleKeyPress = function (callData) {
-    model.keyboardManipulators.filter(function (m) {
-      return m.onKeyPress;
-    }).forEach(function (manipulator) {
+  publicAPI.handleKeyPress = callData => {
+    model.keyboardManipulators.filter(m => m.onKeyPress).forEach(manipulator => {
       manipulator.onKeyPress(model._interactor, callData.pokedRenderer, callData.key);
       publicAPI.invokeInteractionEvent(INTERACTION_EVENT);
     });
-  }; //-------------------------------------------------------------------------
-
+  };
 
-  publicAPI.handleKeyDown = function (callData) {
-    model.keyboardManipulators.filter(function (m) {
-      return m.onKeyDown;
-    }).forEach(function (manipulator) {
+  //-------------------------------------------------------------------------
+  publicAPI.handleKeyDown = callData => {
+    model.keyboardManipulators.filter(m => m.onKeyDown).forEach(manipulator => {
       manipulator.onKeyDown(model._interactor, callData.pokedRenderer, callData.key);
       publicAPI.invokeInteractionEvent(INTERACTION_EVENT);
     });
-  }; //-------------------------------------------------------------------------
-
+  };
 
-  publicAPI.handleKeyUp = function (callData) {
-    model.keyboardManipulators.filter(function (m) {
-      return m.onKeyUp;
-    }).forEach(function (manipulator) {
+  //-------------------------------------------------------------------------
+  publicAPI.handleKeyUp = callData => {
+    model.keyboardManipulators.filter(m => m.onKeyUp).forEach(manipulator => {
       manipulator.onKeyUp(model._interactor, callData.pokedRenderer, callData.key);
       publicAPI.invokeInteractionEvent(INTERACTION_EVENT);
     });
-  }; //-------------------------------------------------------------------------
+  };
+
+  //-------------------------------------------------------------------------
   // Gesture
   //-------------------------------------------------------------------------
 
-
-  publicAPI.handleStartPinch = function (callData) {
+  publicAPI.handleStartPinch = callData => {
     publicAPI.startDolly();
-    var count = model.gestureManipulators.length;
-
+    let count = model.gestureManipulators.length;
     while (count--) {
-      var manipulator = model.gestureManipulators[count];
-
+      const manipulator = model.gestureManipulators[count];
       if (manipulator && manipulator.isPinchEnabled()) {
         manipulator.onStartPinch(model._interactor, callData.scale);
         manipulator.startInteraction();
       }
     }
-
     model._interactor.requestAnimation(publicAPI.handleStartPinch);
-
     publicAPI.invokeStartInteractionEvent(START_INTERACTION_EVENT);
-  }; //--------------------------------------------------------------------------
-
+  };
 
-  publicAPI.handleEndPinch = function () {
+  //--------------------------------------------------------------------------
+  publicAPI.handleEndPinch = () => {
     publicAPI.endDolly();
-    var count = model.gestureManipulators.length;
-
+    let count = model.gestureManipulators.length;
     while (count--) {
-      var manipulator = model.gestureManipulators[count];
-
+      const manipulator = model.gestureManipulators[count];
       if (manipulator && manipulator.isPinchEnabled()) {
         manipulator.onEndPinch(model._interactor);
         manipulator.endInteraction();
       }
     }
-
     model._interactor.cancelAnimation(publicAPI.handleStartPinch);
-
     publicAPI.invokeEndInteractionEvent(END_INTERACTION_EVENT);
-  }; //----------------------------------------------------------------------------
-
+  };
 
-  publicAPI.handleStartRotate = function (callData) {
+  //----------------------------------------------------------------------------
+  publicAPI.handleStartRotate = callData => {
     publicAPI.startRotate();
-    var count = model.gestureManipulators.length;
-
+    let count = model.gestureManipulators.length;
     while (count--) {
-      var manipulator = model.gestureManipulators[count];
-
+      const manipulator = model.gestureManipulators[count];
       if (manipulator && manipulator.isRotateEnabled()) {
         manipulator.onStartRotate(model._interactor, callData.rotation);
         manipulator.startInteraction();
       }
     }
-
     model._interactor.requestAnimation(publicAPI.handleStartRotate);
-
     publicAPI.invokeStartInteractionEvent(START_INTERACTION_EVENT);
-  }; //--------------------------------------------------------------------------
-
+  };
 
-  publicAPI.handleEndRotate = function () {
+  //--------------------------------------------------------------------------
+  publicAPI.handleEndRotate = () => {
     publicAPI.endRotate();
-    var count = model.gestureManipulators.length;
-
+    let count = model.gestureManipulators.length;
     while (count--) {
-      var manipulator = model.gestureManipulators[count];
-
+      const manipulator = model.gestureManipulators[count];
       if (manipulator && manipulator.isRotateEnabled()) {
         manipulator.onEndRotate(model._interactor);
         manipulator.endInteraction();
       }
     }
-
     model._interactor.cancelAnimation(publicAPI.handleStartRotate);
-
     publicAPI.invokeEndInteractionEvent(END_INTERACTION_EVENT);
-  }; //----------------------------------------------------------------------------
-
+  };
 
-  publicAPI.handleStartPan = function (callData) {
+  //----------------------------------------------------------------------------
+  publicAPI.handleStartPan = callData => {
     publicAPI.startPan();
-    var count = model.gestureManipulators.length;
-
+    let count = model.gestureManipulators.length;
     while (count--) {
-      var manipulator = model.gestureManipulators[count];
-
+      const manipulator = model.gestureManipulators[count];
       if (manipulator && manipulator.isPanEnabled()) {
         manipulator.onStartPan(model._interactor, callData.translation);
         manipulator.startInteraction();
       }
     }
-
     model._interactor.requestAnimation(publicAPI.handleStartPan);
-
     publicAPI.invokeStartInteractionEvent(START_INTERACTION_EVENT);
-  }; //--------------------------------------------------------------------------
-
+  };
 
-  publicAPI.handleEndPan = function () {
+  //--------------------------------------------------------------------------
+  publicAPI.handleEndPan = () => {
     publicAPI.endPan();
-    var count = model.gestureManipulators.length;
-
+    let count = model.gestureManipulators.length;
     while (count--) {
-      var manipulator = model.gestureManipulators[count];
-
+      const manipulator = model.gestureManipulators[count];
       if (manipulator && manipulator.isPanEnabled()) {
         manipulator.onEndPan(model._interactor);
         manipulator.endInteraction();
       }
     }
-
     model._interactor.cancelAnimation(publicAPI.handleStartPan);
-
     publicAPI.invokeEndInteractionEvent(END_INTERACTION_EVENT);
-  }; //----------------------------------------------------------------------------
-
-
-  publicAPI.handlePinch = function (callData) {
-    var count = model.gestureManipulators.length;
-    var actionCount = 0;
+  };
 
+  //----------------------------------------------------------------------------
+  publicAPI.handlePinch = callData => {
+    let count = model.gestureManipulators.length;
+    let actionCount = 0;
     while (count--) {
-      var manipulator = model.gestureManipulators[count];
-
+      const manipulator = model.gestureManipulators[count];
       if (manipulator && manipulator.isPinchEnabled()) {
         manipulator.onPinch(model._interactor, callData.pokedRenderer, callData.scale);
         actionCount++;
       }
     }
-
     if (actionCount) {
       publicAPI.invokeInteractionEvent(INTERACTION_EVENT);
     }
-  }; //----------------------------------------------------------------------------
-
-
-  publicAPI.handlePan = function (callData) {
-    var count = model.gestureManipulators.length;
-    var actionCount = 0;
+  };
 
+  //----------------------------------------------------------------------------
+  publicAPI.handlePan = callData => {
+    let count = model.gestureManipulators.length;
+    let actionCount = 0;
     while (count--) {
-      var manipulator = model.gestureManipulators[count];
-
+      const manipulator = model.gestureManipulators[count];
       if (manipulator && manipulator.isPanEnabled()) {
         manipulator.onPan(model._interactor, callData.pokedRenderer, callData.translation);
         actionCount++;
       }
     }
-
     if (actionCount) {
       publicAPI.invokeInteractionEvent(INTERACTION_EVENT);
     }
-  }; //----------------------------------------------------------------------------
-
-
-  publicAPI.handleRotate = function (callData) {
-    var count = model.gestureManipulators.length;
-    var actionCount = 0;
+  };
 
+  //----------------------------------------------------------------------------
+  publicAPI.handleRotate = callData => {
+    let count = model.gestureManipulators.length;
+    let actionCount = 0;
     while (count--) {
-      var manipulator = model.gestureManipulators[count];
-
+      const manipulator = model.gestureManipulators[count];
       if (manipulator && manipulator.isRotateEnabled()) {
         manipulator.onRotate(model._interactor, callData.pokedRenderer, callData.rotation);
         actionCount++;
       }
     }
-
     if (actionCount) {
       publicAPI.invokeInteractionEvent(INTERACTION_EVENT);
     }
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   cachedMousePosition: null,
   currentManipulator: null,
   currentWheelManipulator: null,
@@ -671,26 +586,36 @@ var DEFAULT_VALUES = {
   // gestureManipulators: null,
   centerOfRotation: [0, 0, 0],
   rotationFactor: 1
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Inheritance
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
-  vtkInteractorStyle.extend(publicAPI, model, initialValues); // Create get-set macros
+  // Inheritance
+  vtkInteractorStyle.extend(publicAPI, model, initialValues);
 
+  // Create get-set macros
   macro.setGet(publicAPI, model, ['rotationFactor']);
   macro.get(publicAPI, model, ['mouseManipulators', 'keyboardManipulators', 'vrManipulators', 'gestureManipulators']);
-  macro.setGetArray(publicAPI, model, ['centerOfRotation'], 3); // Object specific methods
+  macro.setGetArray(publicAPI, model, ['centerOfRotation'], 3);
 
+  // Object specific methods
   vtkInteractorStyleManipulator(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = macro.newInstance(extend, 'vtkInteractorStyleManipulator'); // ----------------------------------------------------------------------------
+const newInstance = macro.newInstance(extend, 'vtkInteractorStyleManipulator');
 
-var vtkInteractorStyleManipulator$1 = _objectSpread({
-  newInstance: newInstance,
-  extend: extend
-}, STATIC);
+// ----------------------------------------------------------------------------
+
+var vtkInteractorStyleManipulator$1 = {
+  newInstance,
+  extend,
+  ...STATIC
+};
 
 export { STATIC, vtkInteractorStyleManipulator$1 as default, extend, newInstance };