@kitware/vtk.js 28.10.1 → 28.11.0

package/Rendering/WebGPU.js

@@ -20,7 +20,7 @@ import './WebGPU/ViewNodeFactory.js';
 import './WebGPU/Volume.js';
 
 var WebGPU = {
-  vtkRenderWindow: vtkRenderWindow
+  vtkRenderWindow
 };
 
 export { WebGPU as default };

package/Rendering/index.js

@@ -5,11 +5,11 @@ import SceneGraph from './SceneGraph.js';
 import WebGPU from './WebGPU.js';
 
 var Rendering = {
-  Core: Core,
-  Misc: Misc,
-  OpenGL: OpenGL,
-  SceneGraph: SceneGraph,
-  WebGPU: WebGPU
+  Core,
+  Misc,
+  OpenGL,
+  SceneGraph,
+  WebGPU
 };
 
 export { Rendering as default };

package/Widgets/Core/AbstractWidget/Constants.js

@@ -1,6 +1,6 @@
-var WIDGET_PRIORITY = 0.5;
+const WIDGET_PRIORITY = 0.5;
 var Constants = {
-  WIDGET_PRIORITY: WIDGET_PRIORITY
+  WIDGET_PRIORITY
 };
 
 export { WIDGET_PRIORITY, Constants as default };

package/Widgets/Core/AbstractWidget.js

@@ -1,116 +1,103 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkInteractorObserver from '../../Rendering/Core/InteractorObserver.js';
 import vtkProp from '../../Rendering/Core/Prop.js';
 import { RenderingTypes } from './WidgetManager/Constants.js';
 import { WIDGET_PRIORITY } from './AbstractWidget/Constants.js';
 
+// ----------------------------------------------------------------------------
+
 function vtkAbstractWidget(publicAPI, model) {
   model.classHierarchy.push('vtkAbstractWidget');
-  model.actorToRepresentationMap = new WeakMap(); // --------------------------------------------------------------------------
+  model.actorToRepresentationMap = new WeakMap();
 
+  // --------------------------------------------------------------------------
   publicAPI.getBounds = model.widgetState.getBounds;
+  publicAPI.getNestedProps = () => model.representations;
+  // --------------------------------------------------------------------------
 
-  publicAPI.getNestedProps = function () {
-    return model.representations;
-  }; // --------------------------------------------------------------------------
-
-
-  publicAPI.activateHandle = function (_ref) {
-    var selectedState = _ref.selectedState,
-        representation = _ref.representation;
+  publicAPI.activateHandle = _ref => {
+    let {
+      selectedState,
+      representation
+    } = _ref;
     model.widgetState.activateOnly(selectedState);
     model.activeState = selectedState;
-
     if (selectedState && selectedState.updateManipulator) {
       selectedState.updateManipulator();
     }
-
     publicAPI.invokeActivateHandle({
-      selectedState: selectedState,
-      representation: representation
+      selectedState,
+      representation
     });
-
     if (publicAPI.updateCursor) {
       publicAPI.updateCursor();
     }
-  }; // --------------------------------------------------------------------------
+  };
 
+  // --------------------------------------------------------------------------
 
-  publicAPI.deactivateAllHandles = function () {
+  publicAPI.deactivateAllHandles = () => {
     model.widgetState.deactivate();
-  }; // --------------------------------------------------------------------------
+  };
 
+  // --------------------------------------------------------------------------
 
-  publicAPI.hasActor = function (actor) {
-    return model.actorToRepresentationMap.has(actor);
-  }; // --------------------------------------------------------------------------
+  publicAPI.hasActor = actor => model.actorToRepresentationMap.has(actor);
 
+  // --------------------------------------------------------------------------
 
-  publicAPI.grabFocus = function () {
+  publicAPI.grabFocus = () => {
     model.hasFocus = true;
   };
-
-  publicAPI.loseFocus = function () {
+  publicAPI.loseFocus = () => {
     model.hasFocus = false;
   };
+  publicAPI.hasFocus = () => model.hasFocus;
 
-  publicAPI.hasFocus = function () {
-    return model.hasFocus;
-  }; // --------------------------------------------------------------------------
-
-
-  publicAPI.placeWidget = function (bounds) {
-    return model.widgetState.placeWidget(bounds);
-  };
-
-  publicAPI.getPlaceFactor = function () {
-    return model.widgetState.getPlaceFactor();
-  };
+  // --------------------------------------------------------------------------
 
-  publicAPI.setPlaceFactor = function (factor) {
-    return model.widgetState.setPlaceFactor(factor);
-  }; // --------------------------------------------------------------------------
+  publicAPI.placeWidget = bounds => model.widgetState.placeWidget(bounds);
+  publicAPI.getPlaceFactor = () => model.widgetState.getPlaceFactor();
+  publicAPI.setPlaceFactor = factor => model.widgetState.setPlaceFactor(factor);
 
+  // --------------------------------------------------------------------------
 
-  publicAPI.getRepresentationFromActor = function (actor) {
-    return model.actorToRepresentationMap.get(actor);
-  }; // --------------------------------------------------------------------------
+  publicAPI.getRepresentationFromActor = actor => model.actorToRepresentationMap.get(actor);
 
+  // --------------------------------------------------------------------------
 
   publicAPI.updateRepresentationForRender = function () {
-    var renderingType = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : RenderingTypes.FRONT_BUFFER;
-
-    for (var i = 0; i < model.representations.length; i++) {
-      var representation = model.representations[i];
+    let renderingType = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : RenderingTypes.FRONT_BUFFER;
+    for (let i = 0; i < model.representations.length; i++) {
+      const representation = model.representations[i];
       representation.updateActorVisibility(renderingType, model.contextVisibility, model.handleVisibility);
     }
   };
+  publicAPI.getViewWidgets = () => model._factory.getViewWidgets();
 
-  publicAPI.getViewWidgets = function () {
-    return model._factory.getViewWidgets();
-  }; // --------------------------------------------------------------------------
+  // --------------------------------------------------------------------------
   // Initialization calls
   // --------------------------------------------------------------------------
 
-
   publicAPI.setPriority(WIDGET_PRIORITY);
-} // ----------------------------------------------------------------------------
+}
 
+// ----------------------------------------------------------------------------
 
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   contextVisibility: true,
   handleVisibility: true,
   hasFocus: false
 };
+
 /**
  * @param {*} publicAPI public methods to populate
  * @param {*} model internal values to populate
  * @param {object} initialValues Contains at least
  *   {viewType, _renderer, _camera, _openGLRenderWindow, _factory}
  */
-
 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);
   vtkProp.extend(publicAPI, model, initialValues);
   vtkInteractorObserver.extend(publicAPI, model, initialValues);
@@ -119,13 +106,17 @@ function extend(publicAPI, model) {
   macro.moveToProtected(publicAPI, model, ['widgetManager']);
   macro.event(publicAPI, model, 'ActivateHandle');
   vtkAbstractWidget(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkAbstractWidget');
 
-var newInstance = macro.newInstance(extend, 'vtkAbstractWidget'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 var vtkAbstractWidget$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkAbstractWidget$1 as default, extend, newInstance };

package/Widgets/Core/AbstractWidgetFactory.js

@@ -1,40 +1,37 @@
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkAbstractWidget from './AbstractWidget.js';
 import { extractRenderingComponents } from './WidgetManager.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; }
-
-function NoOp() {} // ----------------------------------------------------------------------------
+function NoOp() {}
 
+// ----------------------------------------------------------------------------
 
 function vtkAbstractWidgetFactory(publicAPI, model) {
-  model.classHierarchy.push('vtkAbstractWidgetFactory'); // DO NOT share on the model ------------------------------------------------
-
-  var viewToWidget = {}; // DO NOT share on the model ------------------------------------------------
-  // Can be called with just ViewId after the widget has been registered
+  model.classHierarchy.push('vtkAbstractWidgetFactory');
 
-  publicAPI.getWidgetForView = function (_ref) {
-    var viewId = _ref.viewId,
-        renderer = _ref.renderer,
-        viewType = _ref.viewType,
-        initialValues = _ref.initialValues;
+  // DO NOT share on the model ------------------------------------------------
+  const viewToWidget = {};
+  // DO NOT share on the model ------------------------------------------------
 
+  // Can be called with just ViewId after the widget has been registered
+  publicAPI.getWidgetForView = _ref => {
+    let {
+      viewId,
+      renderer,
+      viewType,
+      initialValues
+    } = _ref;
     if (!viewToWidget[viewId]) {
       if (!renderer) {
         return null;
       }
-
-      var _extractRenderingComp = extractRenderingComponents(renderer),
-          interactor = _extractRenderingComp.interactor,
-          apiSpecificRenderWindow = _extractRenderingComp.apiSpecificRenderWindow,
-          camera = _extractRenderingComp.camera;
-
-      var widgetModel = {};
-      var widgetPublicAPI = {};
+      const {
+        interactor,
+        apiSpecificRenderWindow,
+        camera
+      } = extractRenderingComponents(renderer);
+      const widgetModel = {};
+      const widgetPublicAPI = {};
       macro.obj(widgetPublicAPI, widgetModel);
       Object.assign(widgetPublicAPI, {
         onWidgetChange: publicAPI.onWidgetChange
@@ -42,180 +39,162 @@ function vtkAbstractWidgetFactory(publicAPI, model) {
       Object.assign(widgetModel, {
         widgetState: model.widgetState,
         manipulator: model.manipulator,
-        viewType: viewType,
-        renderer: renderer,
-        camera: camera,
-        apiSpecificRenderWindow: apiSpecificRenderWindow,
+        viewType,
+        renderer,
+        camera,
+        apiSpecificRenderWindow,
         factory: publicAPI
       });
       macro.moveToProtected(widgetPublicAPI, widgetModel, ['renderer', 'camera', 'apiSpecificRenderWindow', 'factory']);
       macro.get(widgetPublicAPI, widgetModel, ['viewType']);
       macro.safeArrays(widgetModel);
-      vtkAbstractWidget.extend(widgetPublicAPI, widgetModel, initialValues); // Create representations for that view
+      vtkAbstractWidget.extend(widgetPublicAPI, widgetModel, initialValues);
 
+      // Create representations for that view
       /* eslint-disable no-shadow */
-
-      var widgetInitialValues = initialValues; // Avoid shadowing
-
-      widgetModel.representations = publicAPI.getRepresentationsForViewType(viewType).map(function (_ref2) {
-        var builder = _ref2.builder,
-            labels = _ref2.labels,
-            initialValues = _ref2.initialValues;
-        return builder.newInstance(_objectSpread(_objectSpread({
+      const widgetInitialValues = initialValues; // Avoid shadowing
+      widgetModel.representations = publicAPI.getRepresentationsForViewType(viewType).map(_ref2 => {
+        let {
+          builder,
+          labels,
+          initialValues
+        } = _ref2;
+        return builder.newInstance({
           _parentProp: widgetPublicAPI,
-          labels: labels
-        }, initialValues), widgetInitialValues));
+          labels,
+          ...initialValues,
+          ...widgetInitialValues
+        });
       });
       /* eslint-enable no-shadow */
 
-      widgetModel.representations.forEach(function (r) {
+      widgetModel.representations.forEach(r => {
         r.setInputData(widgetModel.widgetState);
-        r.getActors().forEach(function (actor) {
+        r.getActors().forEach(actor => {
           widgetModel.actorToRepresentationMap.set(actor, r);
         });
       });
-      model.behavior(widgetPublicAPI, widgetModel); // Forward representation methods
-
-      ['coincidentTopologyParameters'].concat(_toConsumableArray(model.methodsToLink || [])).forEach(function (methodName) {
-        var _methods;
-
-        var set = "set".concat(macro.capitalize(methodName));
-        var get = "get".concat(macro.capitalize(methodName));
-        var methods = (_methods = {}, _defineProperty(_methods, methodName, []), _defineProperty(_methods, set, []), _defineProperty(_methods, get, []), _methods);
-        widgetModel.representations.forEach(function (representation) {
+      model.behavior(widgetPublicAPI, widgetModel);
+      // Forward representation methods
+      ['coincidentTopologyParameters', ...(model.methodsToLink || [])].forEach(methodName => {
+        const set = `set${macro.capitalize(methodName)}`;
+        const get = `get${macro.capitalize(methodName)}`;
+        const methods = {
+          [methodName]: [],
+          [set]: [],
+          [get]: []
+        };
+        widgetModel.representations.forEach(representation => {
           if (representation[methodName]) {
             methods[methodName].push(representation[methodName]);
           }
-
           if (representation[set]) {
             methods[set].push(representation[set]);
           }
-
           if (representation[get]) {
             methods[get].push(representation[get]);
           }
         });
-        Object.keys(methods).forEach(function (name) {
-          var calls = methods[name];
-
+        Object.keys(methods).forEach(name => {
+          const calls = methods[name];
           if (calls.length === 1) {
             widgetPublicAPI[name] = calls[0];
           } else if (calls.length > 1) {
-            widgetPublicAPI[name] = macro.chain.apply(macro, _toConsumableArray(calls));
+            widgetPublicAPI[name] = macro.chain(...calls);
           }
         });
-      }); // Custom delete to detach from parent
+      });
 
-      widgetPublicAPI.delete = macro.chain(function () {
+      // Custom delete to detach from parent
+      widgetPublicAPI.delete = macro.chain(() => {
         delete viewToWidget[viewId];
       }, widgetPublicAPI.delete);
       widgetPublicAPI.setInteractor(interactor);
-      var viewWidget = Object.freeze(widgetPublicAPI);
+      const viewWidget = Object.freeze(widgetPublicAPI);
       viewToWidget[viewId] = viewWidget;
       return viewWidget;
     }
-
     return viewToWidget[viewId];
-  }; // List of all the views the widget has been registered to.
-
-
-  publicAPI.getViewIds = function () {
-    return Object.keys(viewToWidget);
   };
 
-  publicAPI.getViewWidgets = function () {
-    return Object.values(viewToWidget);
-  }; // --------------------------------------------------------------------------
+  // List of all the views the widget has been registered to.
+  publicAPI.getViewIds = () => Object.keys(viewToWidget);
+  publicAPI.getViewWidgets = () => Object.values(viewToWidget);
+
+  // --------------------------------------------------------------------------
   // Widget visibility / enable
   // --------------------------------------------------------------------------
   // Call methods on all its view widgets
 
-
-  publicAPI.setVisibility = function (value) {
-    var viewIds = Object.keys(viewToWidget);
-
-    for (var i = 0; i < viewIds.length; i++) {
+  publicAPI.setVisibility = value => {
+    const viewIds = Object.keys(viewToWidget);
+    for (let i = 0; i < viewIds.length; i++) {
       viewToWidget[viewIds[i]].setVisibility(value);
     }
   };
-
-  publicAPI.setPickable = function (value) {
-    var viewIds = Object.keys(viewToWidget);
-
-    for (var i = 0; i < viewIds.length; i++) {
+  publicAPI.setPickable = value => {
+    const viewIds = Object.keys(viewToWidget);
+    for (let i = 0; i < viewIds.length; i++) {
       viewToWidget[viewIds[i]].setPickable(value);
     }
   };
-
-  publicAPI.setDragable = function (value) {
-    var viewIds = Object.keys(viewToWidget);
-
-    for (var i = 0; i < viewIds.length; i++) {
+  publicAPI.setDragable = value => {
+    const viewIds = Object.keys(viewToWidget);
+    for (let i = 0; i < viewIds.length; i++) {
       viewToWidget[viewIds[i]].setDragable(value);
     }
   };
-
-  publicAPI.setContextVisibility = function (value) {
-    var viewIds = Object.keys(viewToWidget);
-
-    for (var i = 0; i < viewIds.length; i++) {
+  publicAPI.setContextVisibility = value => {
+    const viewIds = Object.keys(viewToWidget);
+    for (let i = 0; i < viewIds.length; i++) {
       viewToWidget[viewIds[i]].setContextVisibility(value);
     }
   };
-
-  publicAPI.setHandleVisibility = function (value) {
-    var viewIds = Object.keys(viewToWidget);
-
-    for (var i = 0; i < viewIds.length; i++) {
+  publicAPI.setHandleVisibility = value => {
+    const viewIds = Object.keys(viewToWidget);
+    for (let i = 0; i < viewIds.length; i++) {
       viewToWidget[viewIds[i]].setHandleVisibility(value);
     }
-  }; // --------------------------------------------------------------------------
+  };
+
+  // --------------------------------------------------------------------------
   // Place Widget API
   // --------------------------------------------------------------------------
 
+  publicAPI.placeWidget = bounds => model.widgetState.placeWidget(bounds);
+  publicAPI.getPlaceFactor = () => model.widgetState.getPlaceFactor();
+  publicAPI.setPlaceFactor = factor => model.widgetState.setPlaceFactor(factor);
 
-  publicAPI.placeWidget = function (bounds) {
-    return model.widgetState.placeWidget(bounds);
-  };
-
-  publicAPI.getPlaceFactor = function () {
-    return model.widgetState.getPlaceFactor();
-  };
-
-  publicAPI.setPlaceFactor = function (factor) {
-    return model.widgetState.setPlaceFactor(factor);
-  }; // --------------------------------------------------------------------------
+  // --------------------------------------------------------------------------
   // Event Widget API
   // --------------------------------------------------------------------------
-
-
-  var unsubscribe = NoOp;
-  publicAPI.delete = macro.chain(publicAPI.delete, function () {
-    return unsubscribe();
-  });
-
+  let unsubscribe = NoOp;
+  publicAPI.delete = macro.chain(publicAPI.delete, () => unsubscribe());
   if (model.widgetState) {
-    unsubscribe = model.widgetState.onModified(function () {
-      return publicAPI.invokeWidgetChange(model.widgetState);
-    }).unsubscribe;
+    unsubscribe = model.widgetState.onModified(() => publicAPI.invokeWidgetChange(model.widgetState)).unsubscribe;
   }
-} // ----------------------------------------------------------------------------
+}
 
+// ----------------------------------------------------------------------------
 
 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, initialValues);
   macro.obj(publicAPI, model);
   macro.get(publicAPI, model, ['widgetState']);
   macro.event(publicAPI, model, 'WidgetChange');
   vtkAbstractWidgetFactory(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkAbstractWidget');
 
-var newInstance = macro.newInstance(extend, 'vtkAbstractWidget'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 var vtkAbstractWidgetFactory$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkAbstractWidgetFactory$1 as default, extend, newInstance };

package/Widgets/Core/StateBuilder/boundsMixin.js

@@ -1,71 +1,66 @@
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
-import macro from '../../../macros.js';
+import { m as macro } from '../../../macros2.js';
 import vtkBoundingBox from '../../../Common/DataModel/BoundingBox.js';
 
 function vtkBoundsMixin(publicAPI, model) {
-  var sourceBounds = [];
-
-  var bbox = _toConsumableArray(vtkBoundingBox.INIT_BOUNDS);
-
-  publicAPI.containsPoint = function (x, y, z) {
+  const sourceBounds = [];
+  const bbox = [...vtkBoundingBox.INIT_BOUNDS];
+  publicAPI.containsPoint = (x, y, z) => {
     if (Array.isArray(x)) {
       return vtkBoundingBox.containsPoint(bbox, x[0], x[1], x[2]);
     }
-
     return vtkBoundingBox.containsPoint(bbox, x, y, z);
   };
-
-  publicAPI.placeWidget = function (bounds) {
+  publicAPI.placeWidget = bounds => {
     model.bounds = [];
-    var center = [(bounds[0] + bounds[1]) / 2.0, (bounds[2] + bounds[3]) / 2.0, (bounds[4] + bounds[5]) / 2.0];
-
-    for (var i = 0; i < 6; i++) {
-      var axisCenter = center[Math.floor(i / 2)];
+    const center = [(bounds[0] + bounds[1]) / 2.0, (bounds[2] + bounds[3]) / 2.0, (bounds[4] + bounds[5]) / 2.0];
+    for (let i = 0; i < 6; i++) {
+      const axisCenter = center[Math.floor(i / 2)];
       sourceBounds[i] = bounds[i];
       model.bounds[i] = (bounds[i] - axisCenter) * model.placeFactor + axisCenter;
     }
-
     vtkBoundingBox.setBounds(bbox, model.bounds);
     publicAPI.invokeBoundsChange(model.bounds);
     publicAPI.modified();
   };
-
-  publicAPI.setPlaceFactor = function (factor) {
+  publicAPI.setPlaceFactor = factor => {
     if (model.placeFactor !== factor) {
       model.placeFactor = factor;
       model.bounds = [];
-      var center = [(sourceBounds[0] + sourceBounds[1]) / 2.0, (sourceBounds[2] + sourceBounds[3]) / 2.0, (sourceBounds[4] + sourceBounds[5]) / 2.0];
-
-      for (var i = 0; i < 6; i++) {
-        var axisCenter = center[Math.floor(i / 2)];
+      const center = [(sourceBounds[0] + sourceBounds[1]) / 2.0, (sourceBounds[2] + sourceBounds[3]) / 2.0, (sourceBounds[4] + sourceBounds[5]) / 2.0];
+      for (let i = 0; i < 6; i++) {
+        const axisCenter = center[Math.floor(i / 2)];
         model.bounds[i] = (sourceBounds[i] - axisCenter) * model.placeFactor + axisCenter;
       }
-
       vtkBoundingBox.setBounds(bbox, model.bounds);
       publicAPI.invokeBoundsChange(model.bounds);
       publicAPI.modified();
     }
   };
-} // ----------------------------------------------------------------------------
+}
 
+// ----------------------------------------------------------------------------
 
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   bounds: [-1, 1, -1, 1, -1, 1],
   placeFactor: 1
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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.setGetArray(publicAPI, model, ['bounds'], 6);
   macro.get(publicAPI, model, ['placeFactor']);
   macro.event(publicAPI, model, 'BoundsChange');
   model.bounds = model.bounds.slice();
   vtkBoundsMixin(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
 var bounds = {
-  extend: extend
+  extend
 };
 
 export { bounds as default, extend };