@kitware/vtk.js 28.10.2 → 28.11.0

package/Rendering/Misc/RemoteView.js

@@ -1,193 +1,192 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkCanvasView from './CanvasView.js';
 import vtkImageStream from '../../IO/Core/ImageStream.js';
 import vtkInteractorStyleRemoteMouse from '../../Interaction/Style/InteractorStyleRemoteMouse.js';
 import vtkRenderWindowInteractor from '../Core/RenderWindowInteractor.js';
 
-var SHARED_IMAGE_STREAM = vtkImageStream.newInstance();
-var connectImageStream = SHARED_IMAGE_STREAM.connect;
-var disconnectImageStream = SHARED_IMAGE_STREAM.disconnect; // ----------------------------------------------------------------------------
+const SHARED_IMAGE_STREAM = vtkImageStream.newInstance();
+const connectImageStream = SHARED_IMAGE_STREAM.connect;
+const disconnectImageStream = SHARED_IMAGE_STREAM.disconnect;
+
+// ----------------------------------------------------------------------------
 // vtkRemoteView methods
 // ----------------------------------------------------------------------------
 
 function vtkRemoteView(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkRemoteView'); // Constructor
+  model.classHierarchy.push('vtkRemoteView');
 
+  // Constructor
   model.canvasView = vtkCanvasView.newInstance();
   model.interactorStyle = vtkInteractorStyleRemoteMouse.newInstance();
   model.interactor = vtkRenderWindowInteractor.newInstance();
   model.interactor.setView(model.canvasView);
   model.interactor.initialize();
-  model.interactor.setInteractorStyle(model.interactorStyle); // Mouse
+  model.interactor.setInteractorStyle(model.interactorStyle);
 
-  model.interactorStyle.onRemoteMouseEvent(function (e) {
+  // Mouse
+  model.interactorStyle.onRemoteMouseEvent(e => {
     if (model.session && model.rpcMouseEvent) {
       model.session.call(model.rpcMouseEvent, [e]);
     }
-  }); // Wheel
-
-  model.interactorStyle.onRemoteWheelEvent(function (e) {
+  });
+  // Wheel
+  model.interactorStyle.onRemoteWheelEvent(e => {
     if (model.session && model.rpcWheelEvent) {
       model.session.call(model.rpcWheelEvent, [e]);
     }
-  }); // Gesture
-
-  model.interactorStyle.onRemoteGestureEvent(function (e) {
+  });
+  // Gesture
+  model.interactorStyle.onRemoteGestureEvent(e => {
     if (model.session && model.rpcGestureEvent) {
       model.session.call(model.rpcGestureEvent, [e]);
     }
-  }); // --------------------------------------------------------------------------
+  });
+
+  // --------------------------------------------------------------------------
   // API
   // --------------------------------------------------------------------------
 
-  publicAPI.delete = macro.chain(function () {
+  publicAPI.delete = macro.chain(() => {
     model.session = null;
-
     if (model.canvasView) {
       model.canvasView.setViewStream(null);
       model.canvasView.delete();
     }
-
     if (model.interactor) {
       model.interactor.delete();
     }
-
     if (model.viewStream) {
       model.viewStream.delete();
     }
-  }, publicAPI.delete); // --------------------------------------------------------------------------
+  }, publicAPI.delete);
+
+  // --------------------------------------------------------------------------
   // remote handing
   // --------------------------------------------------------------------------
 
-  publicAPI.setViewStream = function (viewStream) {
+  publicAPI.setViewStream = viewStream => {
     model.viewStream = viewStream;
-    model.canvasView.setViewStream(model.viewStream); // Configure image quality
+    model.canvasView.setViewStream(model.viewStream);
 
+    // Configure image quality
     model.viewStream.setStillQuality(model.stillQuality);
     model.viewStream.setStillRatio(model.stillRatio);
     model.viewStream.setInteractiveQuality(model.interactiveQuality);
-    model.viewStream.setInteractiveRatio(model.interactiveRatio); // Link user interactions
+    model.viewStream.setInteractiveRatio(model.interactiveRatio);
 
+    // Link user interactions
     model.interactor.onStartAnimation(model.viewStream.startInteraction);
     model.interactor.onEndAnimation(model.viewStream.endInteraction);
     publicAPI.setViewId(viewStream.getViewId());
   };
-
-  publicAPI.setViewId = function (id) {
+  publicAPI.setViewId = id => {
     if (!model.viewStream) {
       publicAPI.setViewStream(SHARED_IMAGE_STREAM.createViewStream(id));
     }
-
     model.viewStream.setViewId(id);
     model.interactorStyle.setRemoteEventAddOn({
       view: id
     });
     publicAPI.modified();
-  }; // --------------------------------------------------------------------------
+  };
+
+  // --------------------------------------------------------------------------
   // DOM handling
   // --------------------------------------------------------------------------
 
-
-  publicAPI.setContainer = function (container) {
+  publicAPI.setContainer = container => {
     if (model.container) {
       model.interactor.unbindEvents(container);
-    } // Capture container
-
+    }
 
+    // Capture container
     model.container = container;
-    model.canvasView.setContainer(model.container); // Attach listeners
+    model.canvasView.setContainer(model.container);
 
+    // Attach listeners
     if (container) {
       model.interactor.bindEvents(container);
       publicAPI.resize();
     }
-  }; // --------------------------------------------------------------------------
+  };
 
+  // --------------------------------------------------------------------------
 
-  publicAPI.resize = function () {
+  publicAPI.resize = () => {
     if (model.container && model.canvasView) {
-      var _model$container$getB = model.container.getBoundingClientRect(),
-          width = _model$container$getB.width,
-          height = _model$container$getB.height;
-
+      const {
+        width,
+        height
+      } = model.container.getBoundingClientRect();
       model.canvasView.setSize(width, height);
       publicAPI.render();
     }
-  }; // --------------------------------------------------------------------------
+  };
 
+  // --------------------------------------------------------------------------
 
-  publicAPI.render = function () {
+  publicAPI.render = () => {
     if (model.viewStream) {
       model.viewStream.render();
     }
-  }; // --------------------------------------------------------------------------
+  };
 
+  // --------------------------------------------------------------------------
 
-  publicAPI.resetCamera = function () {
+  publicAPI.resetCamera = () => {
     if (model.viewStream) {
       model.viewStream.resetCamera();
     }
-  }; // --------------------------------------------------------------------------
+  };
+
+  // --------------------------------------------------------------------------
   // viewStream setters
   // --------------------------------------------------------------------------
-
-
-  var internal = {
+  const internal = {
     modified: publicAPI.modified
   };
   macro.set(internal, model, ['interactiveQuality', 'interactiveRatio', 'stillQuality', 'stillRatio']);
-
-  publicAPI.setInteractiveQuality = function (q) {
-    var changeDetected = internal.setInteractiveQuality(q);
-
+  publicAPI.setInteractiveQuality = q => {
+    const changeDetected = internal.setInteractiveQuality(q);
     if (model.viewStream && changeDetected) {
       model.viewStream.setInteractiveQuality(model.interactiveQuality);
     }
-
     return changeDetected;
   };
-
-  publicAPI.setInteractiveRatio = function (r) {
-    var changeDetected = internal.setInteractiveRatio(r);
-
+  publicAPI.setInteractiveRatio = r => {
+    const changeDetected = internal.setInteractiveRatio(r);
     if (model.viewStream && changeDetected) {
       model.viewStream.setInteractiveRatio(model.interactiveRatio);
     }
-
     return changeDetected;
   };
-
-  publicAPI.setStillQuality = function (q) {
-    var changeDetected = internal.setStillQuality(q);
-
+  publicAPI.setStillQuality = q => {
+    const changeDetected = internal.setStillQuality(q);
     if (model.viewStream && changeDetected) {
       model.viewStream.setStillQuality(model.stillQuality);
     }
-
     return changeDetected;
   };
-
-  publicAPI.setStillRatio = function (r) {
-    var changeDetected = internal.setStillRatio(r);
-
+  publicAPI.setStillRatio = r => {
+    const changeDetected = internal.setStillRatio(r);
     if (model.viewStream && changeDetected) {
       model.viewStream.setStillRatio(model.stillRatio);
     }
-
     return changeDetected;
-  }; // Initialize viewStream if available
-
+  };
 
+  // Initialize viewStream if available
   if (model.viewStream) {
     publicAPI.setViewStream(model.viewStream);
   }
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   viewId: '-1',
   interactiveQuality: 60,
   interactiveRatio: 1 / window.devicePixelRatio,
@@ -196,26 +195,33 @@ var DEFAULT_VALUES = {
   rpcMouseEvent: 'viewport.mouse.interaction',
   rpcGestureEvent: null,
   rpcWheelEvent: null
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   Object.assign(model, DEFAULT_VALUES, initialValues);
   macro.obj(publicAPI, model, initialValues);
   macro.get(publicAPI, model, ['container', 'viewStream', 'canvasView', 'interactor', 'interactorStyle', 'interactiveQuality', 'interactiveRatio', 'stillQuality', 'stillRatio']);
-  macro.setGet(publicAPI, model, ['session', 'rpcMouseEvent', 'rpcGestureEvent', 'rpcWheelEvent']); // Object methods
+  macro.setGet(publicAPI, model, ['session', 'rpcMouseEvent', 'rpcGestureEvent', 'rpcWheelEvent']);
 
+  // Object methods
   vtkRemoteView(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkRemoteView');
 
-var newInstance = macro.newInstance(extend, 'vtkRemoteView'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 var vtkRemoteView$1 = {
-  newInstance: newInstance,
-  extend: extend,
-  SHARED_IMAGE_STREAM: SHARED_IMAGE_STREAM,
-  connectImageStream: connectImageStream,
-  disconnectImageStream: disconnectImageStream
+  newInstance,
+  extend,
+  SHARED_IMAGE_STREAM,
+  connectImageStream,
+  disconnectImageStream
 };
 
 export { connectImageStream, vtkRemoteView$1 as default, disconnectImageStream, extend, newInstance };

package/Rendering/Misc/RenderWindowWithControlBar.js

@@ -1,5 +1,4 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkGenericRenderWindow from './GenericRenderWindow.js';
 import { s as style } from './RenderWindowWithControlBar/RenderWindowWithControlBar.module.css.js';
 import '../../Common/Core/Points.js';
@@ -8,94 +7,95 @@ import '../../Common/DataModel/PolyData.js';
 import '../Core/Actor.js';
 import '../Core/Mapper.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; }
-
-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; }
+// ----------------------------------------------------------------------------
 // Utility functions to control style
 // ----------------------------------------------------------------------------
 
-var CONTROL_STYLE = {
-  left: function left(size) {
+const CONTROL_STYLE = {
+  left(size) {
     return {
       top: '0',
       left: '0',
       bottom: '0',
       right: 'unset',
       height: 'unset',
-      width: "".concat(size, "px")
+      width: `${size}px`
     };
   },
-  right: function right(size) {
+  right(size) {
     return {
       top: '0',
       right: '0',
       bottom: '0',
       left: 'unset',
       height: 'unset',
-      width: "".concat(size, "px")
+      width: `${size}px`
     };
   },
-  top: function top(size) {
+  top(size) {
     return {
       top: '0',
       left: '0',
       right: '0',
       bottom: 'unset',
       width: 'unset',
-      height: "".concat(size, "px")
+      height: `${size}px`
     };
   },
-  bottom: function bottom(size) {
+  bottom(size) {
     return {
       bottom: '0',
       left: '0',
       right: '0',
       top: 'unset',
       width: 'unset',
-      height: "".concat(size, "px")
+      height: `${size}px`
     };
   }
 };
-
 function applyControlStyle(el, position, size) {
-  var styleToApply = CONTROL_STYLE[position](size);
-  Object.keys(styleToApply).forEach(function (key) {
+  const styleToApply = CONTROL_STYLE[position](size);
+  Object.keys(styleToApply).forEach(key => {
     el.style[key] = styleToApply[key];
   });
-} // ----------------------------------------------------------------------------
+}
 
+// ----------------------------------------------------------------------------
 
 function vtkRenderWindowWithControlBar(publicAPI, model) {
-  var superClass = _objectSpread({}, publicAPI);
-
+  const superClass = {
+    ...publicAPI
+  };
   function resetStyleToZero(key) {
     model.renderWindowContainer.style[key] = '0px';
   }
-
   function updateControlerStyle() {
     ['left', 'right', 'top', 'bottom'].forEach(resetStyleToZero);
-    model.renderWindowContainer.style[model.controlPosition] = "".concat(model.controlSize, "px");
+    model.renderWindowContainer.style[model.controlPosition] = `${model.controlSize}px`;
     applyControlStyle(model.controlContainer, model.controlPosition, model.controlSize);
-  } // Create container for the vtkGenericRenderWindow
-
+  }
 
+  // Create container for the vtkGenericRenderWindow
   model.renderWindowContainer = document.createElement('div');
   model.renderWindowContainer.classList.add(style.renderWindow);
-  superClass.setContainer(model.renderWindowContainer); // Create container for controls
+  superClass.setContainer(model.renderWindowContainer);
 
+  // Create container for controls
   model.controlContainer = document.createElement('div');
-  model.controlContainer.classList.add(style.control); // Handle DOM container relocation
+  model.controlContainer.classList.add(style.control);
 
-  publicAPI.setContainer = function (el) {
+  // Handle DOM container relocation
+  publicAPI.setContainer = el => {
     if (model.rootContainer) {
       model.rootContainer.removeChild(model.container);
       model.rootContainer.removeChild(model.controlContainer);
       model.rootContainer.classList.remove(style.rootContainer);
-    } // Switch container
-
+    }
 
-    model.rootContainer = el; // Bind to new container
+    // Switch container
+    model.rootContainer = el;
 
+    // Bind to new container
     if (model.rootContainer) {
       model.rootContainer.appendChild(model.container);
       model.rootContainer.appendChild(model.controlContainer);
@@ -104,52 +104,58 @@ function vtkRenderWindowWithControlBar(publicAPI, model) {
       publicAPI.resize();
     }
   };
-
-  publicAPI.setControlSize = function (size) {
+  publicAPI.setControlSize = size => {
     model.controlSize = size;
     updateControlerStyle();
     publicAPI.modified();
   };
-
-  publicAPI.setControlPosition = function (pos) {
+  publicAPI.setControlPosition = pos => {
     model.controlPosition = pos;
     updateControlerStyle();
     publicAPI.modified();
-  }; // Handle size
-
+  };
 
+  // Handle size
   if (model.listenWindowResize) {
     window.addEventListener('resize', publicAPI.resize);
   }
-
   updateControlerStyle();
   publicAPI.resize();
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   rootContainer: null,
   controlPosition: 'left',
   controlSize: 10
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Object methods
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
+  // Object methods
   vtkGenericRenderWindow.extend(publicAPI, model);
-  macro.get(publicAPI, model, ['rootContainer', 'controlContainer', 'renderWindowContainer']); // Object specific methods
+  macro.get(publicAPI, model, ['rootContainer', 'controlContainer', 'renderWindowContainer']);
 
+  // Object specific methods
   vtkRenderWindowWithControlBar(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkRenderWindowWithControlBar');
 
-var newInstance = macro.newInstance(extend, 'vtkRenderWindowWithControlBar'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 var vtkRenderWindowWithControlBar$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkRenderWindowWithControlBar$1 as default, extend, newInstance };

package/Rendering/Misc/SynchronizableRenderWindow/BehaviorManager/CameraSynchronizer.js

@@ -1,45 +1,40 @@
-import { newInstance as newInstance$1, obj, setGet, setGetArray, chain } from '../../../../macros.js';
+import { n as newInstance$1, o as obj, e as setGet, l as setGetArray, h as chain } from '../../../../macros2.js';
 import { l as normalize } from '../../../../Common/Core/Math/index.js';
 
-var MODE_RESET_CAMERA = 'resetcamera';
-var MODE_ORIENTATION = 'orientation';
-var MODE_SAME = 'same';
-var SynchronizationMode = {
-  MODE_RESET_CAMERA: MODE_RESET_CAMERA,
-  MODE_ORIENTATION: MODE_ORIENTATION,
-  MODE_SAME: MODE_SAME
+const MODE_RESET_CAMERA = 'resetcamera';
+const MODE_ORIENTATION = 'orientation';
+const MODE_SAME = 'same';
+const SynchronizationMode = {
+  MODE_RESET_CAMERA,
+  MODE_ORIENTATION,
+  MODE_SAME
 };
-
 function vtkCameraSynchronizer(publicAPI, model) {
   model.classHierarchy.push('vtkCameraSynchronizer');
-  var cameraState = new Float64Array(9);
-  var direction = new Float64Array(3);
-  var subscriptions = [];
-
+  const cameraState = new Float64Array(9);
+  const direction = new Float64Array(3);
+  const subscriptions = [];
   function updateListeners() {
     while (subscriptions.length) {
       subscriptions.pop().unsubscribe();
     }
-
     if (!model.srcRenderer || !model.dstRenderer) {
       return;
     }
-
-    var srcCamera = model.srcRenderer.getActiveCamera();
-    var interactor = model.srcRenderer.getRenderWindow().getInteractor();
-    subscriptions.push(srcCamera.onModified(function () {
+    const srcCamera = model.srcRenderer.getActiveCamera();
+    const interactor = model.srcRenderer.getRenderWindow().getInteractor();
+    subscriptions.push(srcCamera.onModified(() => {
       if (!interactor.isAnimating()) {
         publicAPI.update();
       }
     }));
     subscriptions.push(interactor.onAnimation(publicAPI.update));
     subscriptions.push(interactor.onEndAnimation(publicAPI.update));
-  } // Update listeners automatically
-
+  }
 
+  // Update listeners automatically
   model._srcRendererChanged = updateListeners;
   model._dstRendererChanged = updateListeners;
-
   function updatePreviousValues(position, focalPoint, viewUp) {
     if (cameraState[0] !== position[0] || cameraState[1] !== position[1] || cameraState[2] !== position[2] || cameraState[3] !== focalPoint[0] || cameraState[4] !== focalPoint[1] || cameraState[5] !== focalPoint[2] || cameraState[6] !== viewUp[0] || cameraState[7] !== viewUp[1] || cameraState[8] !== viewUp[2]) {
       cameraState[0] = position[0];
@@ -53,26 +48,21 @@ function vtkCameraSynchronizer(publicAPI, model) {
       cameraState[8] = viewUp[2];
       return cameraState;
     }
-
     return false;
   }
-
-  publicAPI.update = function () {
+  publicAPI.update = () => {
     if (!model.active || !model.srcRenderer || !model.dstRenderer) {
       return;
     }
-
-    var srcCamera = model.srcRenderer.getActiveCamera();
-    var dstCamera = model.dstRenderer.getActiveCamera();
-    var position = srcCamera.getReferenceByName('position');
-    var focalPoint = srcCamera.getReferenceByName('focalPoint');
-    var viewUp = srcCamera.getReferenceByName('viewUp');
-    var change = updatePreviousValues(position, focalPoint, viewUp);
-
+    const srcCamera = model.srcRenderer.getActiveCamera();
+    const dstCamera = model.dstRenderer.getActiveCamera();
+    const position = srcCamera.getReferenceByName('position');
+    const focalPoint = srcCamera.getReferenceByName('focalPoint');
+    const viewUp = srcCamera.getReferenceByName('viewUp');
+    const change = updatePreviousValues(position, focalPoint, viewUp);
     if (!change) {
       return;
     }
-
     if (model.mode === MODE_ORIENTATION) {
       direction[0] = change[0] - change[3];
       direction[1] = change[1] - change[4];
@@ -86,44 +76,46 @@ function vtkCameraSynchronizer(publicAPI, model) {
       dstCamera.setFocalPoint(change[3], change[4], change[5]);
       dstCamera.setViewUp(change[6], change[7], change[8]);
     }
-
     if (model.mode === MODE_RESET_CAMERA) {
       model.dstRenderer.resetCamera();
     }
   };
+  publicAPI.delete = chain(() => publicAPI.setSrcRenderer(null),
+  // Will clear any listener
+  publicAPI.delete);
 
-  publicAPI.delete = chain(function () {
-    return publicAPI.setSrcRenderer(null);
-  }, // Will clear any listener
-  publicAPI.delete); // If src/dstRenderer provided at constructor register listeners
-
+  // If src/dstRenderer provided at constructor register listeners
   updateListeners();
 }
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   mode: MODE_ORIENTATION,
   focalPoint: [0, 0, 0],
   distance: 6.8,
-  active: true // srcRenderer: null,
+  active: true
+  // srcRenderer: null,
   // dstRenderer: null,
-
 };
+
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Build VTK API
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
+  // Build VTK API
   obj(publicAPI, model);
   setGet(publicAPI, model, ['mode', 'active', 'srcRenderer', 'dstRenderer', 'distance']);
-  setGetArray(publicAPI, model, ['focalPoint'], 3, 0); // Object methods
+  setGetArray(publicAPI, model, ['focalPoint'], 3, 0);
 
+  // Object methods
   vtkCameraSynchronizer(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = newInstance$1(extend, 'vtkCameraSynchronizer');
+const newInstance = newInstance$1(extend, 'vtkCameraSynchronizer');
 var vtkCameraSynchronizer$1 = {
-  newInstance: newInstance,
-  extend: extend,
-  SynchronizationMode: SynchronizationMode
+  newInstance,
+  extend,
+  SynchronizationMode
 };
 
 export { DEFAULT_VALUES, MODE_ORIENTATION, MODE_RESET_CAMERA, MODE_SAME, SynchronizationMode, vtkCameraSynchronizer$1 as default, extend, newInstance };