@kitware/vtk.js 28.10.2 → 28.11.0

package/Interaction/Style/InteractorStyleTrackballCamera.js

@@ -1,23 +1,27 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkInteractorStyle from '../../Rendering/Core/InteractorStyle.js';
 import vtkInteractorStyleConstants from '../../Rendering/Core/InteractorStyle/Constants.js';
 import { A as degreesFromRadians } from '../../Common/Core/Math/index.js';
 import { Device, Input } from '../../Rendering/Core/RenderWindowInteractor/Constants.js';
 
-var States = vtkInteractorStyleConstants.States;
+const {
+  States
+} = vtkInteractorStyleConstants;
+
 /* eslint-disable no-lonely-if */
+
 // ----------------------------------------------------------------------------
 // vtkInteractorStyleTrackballCamera methods
 // ----------------------------------------------------------------------------
 
 function vtkInteractorStyleTrackballCamera(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkInteractorStyleTrackballCamera'); // Public API methods
-
-  publicAPI.handleMouseMove = function (callData) {
-    var pos = callData.position;
-    var renderer = callData.pokedRenderer;
+  model.classHierarchy.push('vtkInteractorStyleTrackballCamera');
 
+  // Public API methods
+  publicAPI.handleMouseMove = callData => {
+    const pos = callData.position;
+    const renderer = callData.pokedRenderer;
     switch (model.state) {
       case States.IS_ROTATE:
         publicAPI.handleMouseRotate(renderer, pos);
@@ -25,21 +29,18 @@ function vtkInteractorStyleTrackballCamera(publicAPI, model) {
           type: 'InteractionEvent'
         });
         break;
-
       case States.IS_PAN:
         publicAPI.handleMousePan(renderer, pos);
         publicAPI.invokeInteractionEvent({
           type: 'InteractionEvent'
         });
         break;
-
       case States.IS_DOLLY:
         publicAPI.handleMouseDolly(renderer, pos);
         publicAPI.invokeInteractionEvent({
           type: 'InteractionEvent'
         });
         break;
-
       case States.IS_SPIN:
         publicAPI.handleMouseSpin(renderer, pos);
         publicAPI.invokeInteractionEvent({
@@ -47,50 +48,49 @@ function vtkInteractorStyleTrackballCamera(publicAPI, model) {
         });
         break;
     }
-
     model.previousPosition = pos;
-  }; //----------------------------------------------------------------------------
-
+  };
 
-  publicAPI.handleButton3D = function (ed) {
+  //----------------------------------------------------------------------------
+  publicAPI.handleButton3D = ed => {
     if (ed && ed.pressed && ed.device === Device.RightController && (ed.input === Input.Trigger || ed.input === Input.TrackPad)) {
       publicAPI.startCameraPose();
       return;
     }
-
     if (ed && !ed.pressed && ed.device === Device.RightController && (ed.input === Input.Trigger || ed.input === Input.TrackPad) && model.state === States.IS_CAMERA_POSE) {
-      publicAPI.endCameraPose(); // return;
+      publicAPI.endCameraPose();
+      // return;
     }
   };
 
-  publicAPI.handleMove3D = function (ed) {
+  publicAPI.handleMove3D = ed => {
     switch (model.state) {
       case States.IS_CAMERA_POSE:
         publicAPI.updateCameraPose(ed);
         break;
     }
   };
-
-  publicAPI.updateCameraPose = function (ed) {
+  publicAPI.updateCameraPose = ed => {
     // move the world in the direction of the
     // controller
-    var camera = ed.pokedRenderer.getActiveCamera();
-    var oldTrans = camera.getPhysicalTranslation(); // look at the y axis to determine how fast / what direction to move
+    const camera = ed.pokedRenderer.getActiveCamera();
+    const oldTrans = camera.getPhysicalTranslation();
 
-    var speed = 0.5; // ed.gamepad.axes[1];
-    // 0.05 meters / frame movement
+    // look at the y axis to determine how fast / what direction to move
+    const speed = 0.5; // ed.gamepad.axes[1];
 
-    var pscale = speed * 0.05 * camera.getPhysicalScale(); // convert orientation to world coordinate direction
+    // 0.05 meters / frame movement
+    const pscale = speed * 0.05 * camera.getPhysicalScale();
 
-    var dir = camera.physicalOrientationToWorldDirection([ed.orientation.x, ed.orientation.y, ed.orientation.z, ed.orientation.w]);
+    // convert orientation to world coordinate direction
+    const dir = camera.physicalOrientationToWorldDirection([ed.orientation.x, ed.orientation.y, ed.orientation.z, ed.orientation.w]);
     camera.setPhysicalTranslation(oldTrans[0] + dir[0] * pscale, oldTrans[1] + dir[1] * pscale, oldTrans[2] + dir[2] * pscale);
-  }; //----------------------------------------------------------------------------
-
+  };
 
-  publicAPI.handleLeftButtonPress = function (callData) {
-    var pos = callData.position;
+  //----------------------------------------------------------------------------
+  publicAPI.handleLeftButtonPress = callData => {
+    const pos = callData.position;
     model.previousPosition = pos;
-
     if (callData.shiftKey) {
       if (callData.controlKey || callData.altKey) {
         publicAPI.startDolly();
@@ -104,270 +104,267 @@ function vtkInteractorStyleTrackballCamera(publicAPI, model) {
         publicAPI.startRotate();
       }
     }
-  }; //--------------------------------------------------------------------------
-
+  };
 
-  publicAPI.handleLeftButtonRelease = function () {
+  //--------------------------------------------------------------------------
+  publicAPI.handleLeftButtonRelease = () => {
     switch (model.state) {
       case States.IS_DOLLY:
         publicAPI.endDolly();
         break;
-
       case States.IS_PAN:
         publicAPI.endPan();
         break;
-
       case States.IS_SPIN:
         publicAPI.endSpin();
         break;
-
       case States.IS_ROTATE:
         publicAPI.endRotate();
         break;
     }
-  }; //----------------------------------------------------------------------------
-
+  };
 
-  publicAPI.handleStartMouseWheel = function () {
+  //----------------------------------------------------------------------------
+  publicAPI.handleStartMouseWheel = () => {
     publicAPI.startDolly();
-  }; //--------------------------------------------------------------------------
-
+  };
 
-  publicAPI.handleEndMouseWheel = function () {
+  //--------------------------------------------------------------------------
+  publicAPI.handleEndMouseWheel = () => {
     publicAPI.endDolly();
-  }; //----------------------------------------------------------------------------
-
+  };
 
-  publicAPI.handleStartPinch = function (callData) {
+  //----------------------------------------------------------------------------
+  publicAPI.handleStartPinch = callData => {
     model.previousScale = callData.scale;
     publicAPI.startDolly();
-  }; //--------------------------------------------------------------------------
-
+  };
 
-  publicAPI.handleEndPinch = function () {
+  //--------------------------------------------------------------------------
+  publicAPI.handleEndPinch = () => {
     publicAPI.endDolly();
-  }; //----------------------------------------------------------------------------
-
+  };
 
-  publicAPI.handleStartRotate = function (callData) {
+  //----------------------------------------------------------------------------
+  publicAPI.handleStartRotate = callData => {
     model.previousRotation = callData.rotation;
     publicAPI.startRotate();
-  }; //--------------------------------------------------------------------------
-
+  };
 
-  publicAPI.handleEndRotate = function () {
+  //--------------------------------------------------------------------------
+  publicAPI.handleEndRotate = () => {
     publicAPI.endRotate();
-  }; //----------------------------------------------------------------------------
-
+  };
 
-  publicAPI.handleStartPan = function (callData) {
+  //----------------------------------------------------------------------------
+  publicAPI.handleStartPan = callData => {
     model.previousTranslation = callData.translation;
     publicAPI.startPan();
-  }; //--------------------------------------------------------------------------
-
+  };
 
-  publicAPI.handleEndPan = function () {
+  //--------------------------------------------------------------------------
+  publicAPI.handleEndPan = () => {
     publicAPI.endPan();
-  }; //----------------------------------------------------------------------------
-
+  };
 
-  publicAPI.handlePinch = function (callData) {
+  //----------------------------------------------------------------------------
+  publicAPI.handlePinch = callData => {
     publicAPI.dollyByFactor(callData.pokedRenderer, callData.scale / model.previousScale);
     model.previousScale = callData.scale;
-  }; //----------------------------------------------------------------------------
-
+  };
 
-  publicAPI.handlePan = function (callData) {
-    var camera = callData.pokedRenderer.getActiveCamera(); // Calculate the focal depth since we'll be using it a lot
+  //----------------------------------------------------------------------------
+  publicAPI.handlePan = callData => {
+    const camera = callData.pokedRenderer.getActiveCamera();
 
-    var viewFocus = camera.getFocalPoint();
+    // Calculate the focal depth since we'll be using it a lot
+    let viewFocus = camera.getFocalPoint();
     viewFocus = publicAPI.computeWorldToDisplay(callData.pokedRenderer, viewFocus[0], viewFocus[1], viewFocus[2]);
-    var focalDepth = viewFocus[2];
-    var trans = callData.translation;
-    var lastTrans = model.previousTranslation;
-    var newPickPoint = publicAPI.computeDisplayToWorld(callData.pokedRenderer, viewFocus[0] + trans[0] - lastTrans[0], viewFocus[1] + trans[1] - lastTrans[1], focalDepth); // Has to recalc old mouse point since the viewport has moved,
-    // so can't move it outside the loop
+    const focalDepth = viewFocus[2];
+    const trans = callData.translation;
+    const lastTrans = model.previousTranslation;
+    const newPickPoint = publicAPI.computeDisplayToWorld(callData.pokedRenderer, viewFocus[0] + trans[0] - lastTrans[0], viewFocus[1] + trans[1] - lastTrans[1], focalDepth);
 
-    var oldPickPoint = publicAPI.computeDisplayToWorld(callData.pokedRenderer, viewFocus[0], viewFocus[1], focalDepth); // Camera motion is reversed
+    // Has to recalc old mouse point since the viewport has moved,
+    // so can't move it outside the loop
+    const oldPickPoint = publicAPI.computeDisplayToWorld(callData.pokedRenderer, viewFocus[0], viewFocus[1], focalDepth);
 
-    var motionVector = [];
+    // Camera motion is reversed
+    const motionVector = [];
     motionVector[0] = oldPickPoint[0] - newPickPoint[0];
     motionVector[1] = oldPickPoint[1] - newPickPoint[1];
     motionVector[2] = oldPickPoint[2] - newPickPoint[2];
     viewFocus = camera.getFocalPoint();
-    var viewPoint = camera.getPosition();
+    const viewPoint = camera.getPosition();
     camera.setFocalPoint(motionVector[0] + viewFocus[0], motionVector[1] + viewFocus[1], motionVector[2] + viewFocus[2]);
     camera.setPosition(motionVector[0] + viewPoint[0], motionVector[1] + viewPoint[1], motionVector[2] + viewPoint[2]);
-
     if (model._interactor.getLightFollowCamera()) {
       callData.pokedRenderer.updateLightsGeometryToFollowCamera();
     }
-
     camera.orthogonalizeViewUp();
     model.previousTranslation = callData.translation;
-  }; //----------------------------------------------------------------------------
-
+  };
 
-  publicAPI.handleRotate = function (callData) {
-    var camera = callData.pokedRenderer.getActiveCamera();
+  //----------------------------------------------------------------------------
+  publicAPI.handleRotate = callData => {
+    const camera = callData.pokedRenderer.getActiveCamera();
     camera.roll(callData.rotation - model.previousRotation);
     camera.orthogonalizeViewUp();
     model.previousRotation = callData.rotation;
-  }; //--------------------------------------------------------------------------
-
+  };
 
-  publicAPI.handleMouseRotate = function (renderer, position) {
+  //--------------------------------------------------------------------------
+  publicAPI.handleMouseRotate = (renderer, position) => {
     if (!model.previousPosition) {
       return;
     }
-
-    var rwi = model._interactor;
-    var dx = position.x - model.previousPosition.x;
-    var dy = position.y - model.previousPosition.y;
-    var size = rwi.getView().getViewportSize(renderer);
-    var deltaElevation = -0.1;
-    var deltaAzimuth = -0.1;
-
+    const rwi = model._interactor;
+    const dx = position.x - model.previousPosition.x;
+    const dy = position.y - model.previousPosition.y;
+    const size = rwi.getView().getViewportSize(renderer);
+    let deltaElevation = -0.1;
+    let deltaAzimuth = -0.1;
     if (size[0] && size[1]) {
       deltaElevation = -20.0 / size[1];
       deltaAzimuth = -20.0 / size[0];
     }
-
-    var rxf = dx * deltaAzimuth * model.motionFactor;
-    var ryf = dy * deltaElevation * model.motionFactor;
-    var camera = renderer.getActiveCamera();
-
+    const rxf = dx * deltaAzimuth * model.motionFactor;
+    const ryf = dy * deltaElevation * model.motionFactor;
+    const camera = renderer.getActiveCamera();
     if (!Number.isNaN(rxf) && !Number.isNaN(ryf)) {
       camera.azimuth(rxf);
       camera.elevation(ryf);
       camera.orthogonalizeViewUp();
     }
-
     if (model.autoAdjustCameraClippingRange) {
       renderer.resetCameraClippingRange();
     }
-
     if (rwi.getLightFollowCamera()) {
       renderer.updateLightsGeometryToFollowCamera();
     }
-  }; //--------------------------------------------------------------------------
-
+  };
 
-  publicAPI.handleMouseSpin = function (renderer, position) {
+  //--------------------------------------------------------------------------
+  publicAPI.handleMouseSpin = (renderer, position) => {
     if (!model.previousPosition) {
       return;
     }
-
-    var rwi = model._interactor;
-    var camera = renderer.getActiveCamera();
-    var center = rwi.getView().getViewportCenter(renderer);
-    var oldAngle = degreesFromRadians(Math.atan2(model.previousPosition.y - center[1], model.previousPosition.x - center[0]));
-    var newAngle = degreesFromRadians(Math.atan2(position.y - center[1], position.x - center[0])) - oldAngle;
-
+    const rwi = model._interactor;
+    const camera = renderer.getActiveCamera();
+    const center = rwi.getView().getViewportCenter(renderer);
+    const oldAngle = degreesFromRadians(Math.atan2(model.previousPosition.y - center[1], model.previousPosition.x - center[0]));
+    const newAngle = degreesFromRadians(Math.atan2(position.y - center[1], position.x - center[0])) - oldAngle;
     if (!Number.isNaN(newAngle)) {
       camera.roll(newAngle);
       camera.orthogonalizeViewUp();
     }
-  }; //--------------------------------------------------------------------------
-
+  };
 
-  publicAPI.handleMousePan = function (renderer, position) {
+  //--------------------------------------------------------------------------
+  publicAPI.handleMousePan = (renderer, position) => {
     if (!model.previousPosition) {
       return;
     }
+    const camera = renderer.getActiveCamera();
 
-    var camera = renderer.getActiveCamera(); // Calculate the focal depth since we'll be using it a lot
-
-    var viewFocus = camera.getFocalPoint();
+    // Calculate the focal depth since we'll be using it a lot
+    let viewFocus = camera.getFocalPoint();
     viewFocus = publicAPI.computeWorldToDisplay(renderer, viewFocus[0], viewFocus[1], viewFocus[2]);
-    var focalDepth = viewFocus[2];
-    var newPickPoint = publicAPI.computeDisplayToWorld(renderer, position.x, position.y, focalDepth); // Has to recalc old mouse point since the viewport has moved,
-    // so can't move it outside the loop
+    const focalDepth = viewFocus[2];
+    const newPickPoint = publicAPI.computeDisplayToWorld(renderer, position.x, position.y, focalDepth);
 
-    var oldPickPoint = publicAPI.computeDisplayToWorld(renderer, model.previousPosition.x, model.previousPosition.y, focalDepth); // Camera motion is reversed
+    // Has to recalc old mouse point since the viewport has moved,
+    // so can't move it outside the loop
+    const oldPickPoint = publicAPI.computeDisplayToWorld(renderer, model.previousPosition.x, model.previousPosition.y, focalDepth);
 
-    var motionVector = [];
+    // Camera motion is reversed
+    const motionVector = [];
     motionVector[0] = oldPickPoint[0] - newPickPoint[0];
     motionVector[1] = oldPickPoint[1] - newPickPoint[1];
     motionVector[2] = oldPickPoint[2] - newPickPoint[2];
     viewFocus = camera.getFocalPoint();
-    var viewPoint = camera.getPosition();
+    const viewPoint = camera.getPosition();
     camera.setFocalPoint(motionVector[0] + viewFocus[0], motionVector[1] + viewFocus[1], motionVector[2] + viewFocus[2]);
     camera.setPosition(motionVector[0] + viewPoint[0], motionVector[1] + viewPoint[1], motionVector[2] + viewPoint[2]);
-
     if (model._interactor.getLightFollowCamera()) {
       renderer.updateLightsGeometryToFollowCamera();
     }
-  }; //----------------------------------------------------------------------------
-
+  };
 
-  publicAPI.handleMouseDolly = function (renderer, position) {
+  //----------------------------------------------------------------------------
+  publicAPI.handleMouseDolly = (renderer, position) => {
     if (!model.previousPosition) {
       return;
     }
+    const dy = position.y - model.previousPosition.y;
+    const rwi = model._interactor;
+    const center = rwi.getView().getViewportCenter(renderer);
+    const dyf = model.motionFactor * dy / center[1];
+    publicAPI.dollyByFactor(renderer, 1.1 ** dyf);
+  };
 
-    var dy = position.y - model.previousPosition.y;
-    var rwi = model._interactor;
-    var center = rwi.getView().getViewportCenter(renderer);
-    var dyf = model.motionFactor * dy / center[1];
-    publicAPI.dollyByFactor(renderer, Math.pow(1.1, dyf));
-  }; //----------------------------------------------------------------------------
-
-
-  publicAPI.handleMouseWheel = function (callData) {
-    var dyf = 1 - callData.spinY / model.zoomFactor;
+  //----------------------------------------------------------------------------
+  publicAPI.handleMouseWheel = callData => {
+    const dyf = 1 - callData.spinY / model.zoomFactor;
     publicAPI.dollyByFactor(callData.pokedRenderer, dyf);
-  }; //----------------------------------------------------------------------------
-
+  };
 
-  publicAPI.dollyByFactor = function (renderer, factor) {
+  //----------------------------------------------------------------------------
+  publicAPI.dollyByFactor = (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);
-
       if (model.autoAdjustCameraClippingRange) {
         renderer.resetCameraClippingRange();
       }
     }
-
     if (model._interactor.getLightFollowCamera()) {
       renderer.updateLightsGeometryToFollowCamera();
     }
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   motionFactor: 10.0,
   zoomFactor: 10.0
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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);
 
-  macro.setGet(publicAPI, model, ['motionFactor', 'zoomFactor']); // For more macro methods, see "Sources/macros.js"
-  // Object specific methods
+  // Create get-set macros
+  macro.setGet(publicAPI, model, ['motionFactor', 'zoomFactor']);
+
+  // For more macro methods, see "Sources/macros.js"
 
+  // Object specific methods
   vtkInteractorStyleTrackballCamera(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = macro.newInstance(extend, 'vtkInteractorStyleTrackballCamera'); // ----------------------------------------------------------------------------
+const newInstance = macro.newInstance(extend, 'vtkInteractorStyleTrackballCamera');
+
+// ----------------------------------------------------------------------------
 
 var vtkInteractorStyleTrackballCamera$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkInteractorStyleTrackballCamera$1 as default, extend, newInstance };

package/Interaction/Style/InteractorStyleUnicam.js

@@ -1,7 +1,8 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkInteractorStyleManipulator from './InteractorStyleManipulator.js';
 import vtkMouseCameraUnicamManipulator from '../Manipulators/MouseCameraUnicamManipulator.js';
 
+// ----------------------------------------------------------------------------
 // vtkInteractorStyleUnicam methods
 // ----------------------------------------------------------------------------
 
@@ -11,67 +12,58 @@ function vtkInteractorStyleUnicam(publicAPI, model) {
     button: 1
   });
   publicAPI.addMouseManipulator(model.unicamManipulator);
-
-  publicAPI.getUseWorldUpVec = function () {
-    return model.unicamManipulator.getUseWorldUpVec();
-  };
-
-  publicAPI.setUseWorldUpVec = function (useWorldUpVec) {
+  publicAPI.getUseWorldUpVec = () => model.unicamManipulator.getUseWorldUpVec();
+  publicAPI.setUseWorldUpVec = useWorldUpVec => {
     model.unicamManipulator.setUseWorldUpVec(useWorldUpVec);
   };
-
-  publicAPI.getWorldUpVec = function () {
-    return model.unicamManipulator.getWorldUpVec();
-  };
-
-  publicAPI.setWorldUpVec = function (x, y, z) {
+  publicAPI.getWorldUpVec = () => model.unicamManipulator.getWorldUpVec();
+  publicAPI.setWorldUpVec = (x, y, z) => {
     model.unicamManipulator.setWorldUpVec(x, y, z);
   };
-
-  publicAPI.getUseHardwareSelector = function () {
-    return model.unicamManipulator.getUseHardwareSelector();
-  };
-
-  publicAPI.setUseHardwareSelector = function (useHardwareSelector) {
+  publicAPI.getUseHardwareSelector = () => model.unicamManipulator.getUseHardwareSelector();
+  publicAPI.setUseHardwareSelector = useHardwareSelector => {
     model.unicamManipulator.setUseHardwareSelector(useHardwareSelector);
   };
-
-  publicAPI.getFocusSphereColor = function () {
+  publicAPI.getFocusSphereColor = () => {
     model.unicamManipulator.getFocusSphereColor();
   };
-
-  publicAPI.setFocusSphereColor = function (r, g, b) {
+  publicAPI.setFocusSphereColor = (r, g, b) => {
     model.unicamManipulator.setFocusSphereColor(r, g, b);
   };
-
-  publicAPI.getFocusSphereRadiusFactor = function () {
-    return model.unicamManipulator.getFocusSphereRadiusFactor();
-  };
-
-  publicAPI.setFocusSphereRadiusFactor = function (focusSphereRadiusFactor) {
+  publicAPI.getFocusSphereRadiusFactor = () => model.unicamManipulator.getFocusSphereRadiusFactor();
+  publicAPI.setFocusSphereRadiusFactor = focusSphereRadiusFactor => {
     model.unicamManipulator.setFocusSphereRadiusFactor(focusSphereRadiusFactor);
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
+const DEFAULT_VALUES = {};
 
-var DEFAULT_VALUES = {}; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 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);
 
-  vtkInteractorStyleManipulator.extend(publicAPI, model, initialValues); // Object specific methods
+  // Inheritance
+  vtkInteractorStyleManipulator.extend(publicAPI, model, initialValues);
 
+  // Object specific methods
   vtkInteractorStyleUnicam(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = macro.newInstance(extend, 'vtkInteractorStyleUnicam'); // ----------------------------------------------------------------------------
+const newInstance = macro.newInstance(extend, 'vtkInteractorStyleUnicam');
+
+// ----------------------------------------------------------------------------
 
 var index = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { index as default, extend, newInstance };

package/Interaction/Style.js

@@ -5,11 +5,11 @@ import vtkInteractorStyleRemoteMouse from './Style/InteractorStyleRemoteMouse.js
 import vtkInteractorStyleTrackballCamera from './Style/InteractorStyleTrackballCamera.js';
 
 var Style = {
-  vtkInteractorStyleImage: vtkInteractorStyleImage,
-  vtkInteractorStyleManipulator: vtkInteractorStyleManipulator,
-  vtkInteractorStyleMPRSlice: vtkInteractorStyleMPRSlice,
-  vtkInteractorStyleRemoteMouse: vtkInteractorStyleRemoteMouse,
-  vtkInteractorStyleTrackballCamera: vtkInteractorStyleTrackballCamera
+  vtkInteractorStyleImage,
+  vtkInteractorStyleManipulator,
+  vtkInteractorStyleMPRSlice,
+  vtkInteractorStyleRemoteMouse,
+  vtkInteractorStyleTrackballCamera
 };
 
 export { Style as default };

package/Interaction/UI/CornerAnnotation/CornerAnnotation.module.css.js

@@ -1,6 +1,6 @@
 import { s as styleInject } from '../../../vendor/style-inject/dist/style-inject.es.js';
 
-var css_248z = ".CornerAnnotation-module_container__2mZcn {\n  display: flex;\n  align-items: stretch;\n  justify-content: space-between;\n  flex-direction: column;\n  -webkit-user-select: none;\n     -moz-user-select: none;\n      -ms-user-select: none;\n          user-select: none;\n  z-index: 100;\n  position: absolute;\n  top: 0;\n  left: 0;\n  width: 100%;\n  height: 100%;\n}\n\n.CornerAnnotation-module_row__23t97 {\n  flex: 1;\n  display: flex;\n  justify-content: space-between;\n  flex-direction: row;\n}\n\n.CornerAnnotation-module_topRow__1OP5f {\n  align-items: flex-start;\n}\n\n.CornerAnnotation-module_middleRow__1xYK_ {\n  align-items: center;\n}\n\n.CornerAnnotation-module_bottomRow__1V34_ {\n  align-items: flex-end;\n}\n\n.CornerAnnotation-module_item__BavOy {\n  flex: 1;\n  padding: 5px;\n}\n\n.CornerAnnotation-module_east__xyYFe {\n  text-align: right;\n}\n\n.CornerAnnotation-module_west__3DsS- {\n  text-align: left;\n}\n\n.CornerAnnotation-module_north__2jPzf {\n  text-align: center;\n}\n\n.CornerAnnotation-module_south__FZyGo {\n  text-align: center;\n}\n\n.CornerAnnotation-module_northEast__-GjXi {\n}\n\n.CornerAnnotation-module_northWest__23pUR {\n}\n\n.CornerAnnotation-module_southEast__tmLmN {\n}\n\n.CornerAnnotation-module_southWest__FLNPM {\n}\n\n";
+var css_248z = ".CornerAnnotation-module_container__2mZcn {\n  display: flex;\n  align-items: stretch;\n  justify-content: space-between;\n  flex-direction: column;\n  -webkit-user-select: none;\n     -moz-user-select: none;\n          user-select: none;\n  z-index: 100;\n  position: absolute;\n  top: 0;\n  left: 0;\n  width: 100%;\n  height: 100%;\n}\n\n.CornerAnnotation-module_row__23t97 {\n  flex: 1;\n  display: flex;\n  justify-content: space-between;\n  flex-direction: row;\n}\n\n.CornerAnnotation-module_topRow__1OP5f {\n  align-items: flex-start;\n}\n\n.CornerAnnotation-module_middleRow__1xYK_ {\n  align-items: center;\n}\n\n.CornerAnnotation-module_bottomRow__1V34_ {\n  align-items: flex-end;\n}\n\n.CornerAnnotation-module_item__BavOy {\n  flex: 1;\n  padding: 5px;\n}\n\n.CornerAnnotation-module_east__xyYFe {\n  text-align: right;\n}\n\n.CornerAnnotation-module_west__3DsS- {\n  text-align: left;\n}\n\n.CornerAnnotation-module_north__2jPzf {\n  text-align: center;\n}\n\n.CornerAnnotation-module_south__FZyGo {\n  text-align: center;\n}\n\n.CornerAnnotation-module_northEast__-GjXi {\n}\n\n.CornerAnnotation-module_northWest__23pUR {\n}\n\n.CornerAnnotation-module_southEast__tmLmN {\n}\n\n.CornerAnnotation-module_southWest__FLNPM {\n}\n\n";
 var style = {"container":"CornerAnnotation-module_container__2mZcn","row":"CornerAnnotation-module_row__23t97","topRow":"CornerAnnotation-module_topRow__1OP5f CornerAnnotation-module_row__23t97","middleRow":"CornerAnnotation-module_middleRow__1xYK_ CornerAnnotation-module_row__23t97","bottomRow":"CornerAnnotation-module_bottomRow__1V34_ CornerAnnotation-module_row__23t97","item":"CornerAnnotation-module_item__BavOy","east":"CornerAnnotation-module_east__xyYFe CornerAnnotation-module_item__BavOy","west":"CornerAnnotation-module_west__3DsS- CornerAnnotation-module_item__BavOy","north":"CornerAnnotation-module_north__2jPzf CornerAnnotation-module_item__BavOy","south":"CornerAnnotation-module_south__FZyGo CornerAnnotation-module_item__BavOy","northEast":"CornerAnnotation-module_northEast__-GjXi CornerAnnotation-module_east__xyYFe CornerAnnotation-module_item__BavOy","northWest":"CornerAnnotation-module_northWest__23pUR CornerAnnotation-module_west__3DsS- CornerAnnotation-module_item__BavOy","southEast":"CornerAnnotation-module_southEast__tmLmN CornerAnnotation-module_east__xyYFe CornerAnnotation-module_item__BavOy","southWest":"CornerAnnotation-module_southWest__FLNPM CornerAnnotation-module_west__3DsS- CornerAnnotation-module_item__BavOy"};
 styleInject(css_248z);