@kitware/vtk.js 28.10.2 → 28.11.0

package/Widgets/Representations/PolyLineRepresentation.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 vtkActor from '../../Rendering/Core/Actor.js';
 import vtkMapper from '../../Rendering/Core/Mapper.js';
 import { B as areEquals } from '../../Common/Core/Math/index.js';
@@ -10,29 +9,26 @@ import vtkWidgetRepresentation, { allocateArray } from './WidgetRepresentation.j
 import { RenderingTypes } from '../Core/WidgetManager/Constants.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.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; }
+// ----------------------------------------------------------------------------
 // vtkPolyLineRepresentation methods
 // ----------------------------------------------------------------------------
 
 function vtkPolyLineRepresentation(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkPolyLineRepresentation');
+  const superClass = {
+    ...publicAPI
+  };
 
-  var superClass = _objectSpread({}, publicAPI); // --------------------------------------------------------------------------
+  // --------------------------------------------------------------------------
   // Internal polydata dataset
   // --------------------------------------------------------------------------
-
-
-  var internalPolyData = vtkPolyData.newInstance({
+  const internalPolyData = vtkPolyData.newInstance({
     mtime: 0
   });
-
   function allocateSize(polyData, size) {
-    var closePolyLine = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-    var points = null;
-
+    let closePolyLine = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    let points = null;
     if (size < 2) {
       // FIXME: Why 1 point and not 0 ?
       points = allocateArray(polyData, 'points', 1).getData();
@@ -40,48 +36,40 @@ function vtkPolyLineRepresentation(publicAPI, model) {
       allocateArray(polyData, 'lines', 0).getData();
     } else if (!polyData.getPoints() || polyData.getPoints().length !== size * 3) {
       points = allocateArray(polyData, 'points', size).getData();
-      var cellSize = size + (closePolyLine ? 1 : 0);
-
+      const cellSize = size + (closePolyLine ? 1 : 0);
       if (polyData.getLines().getNumberOfCells() !== 1 || polyData.getLines().getCellSizes()[0] !== cellSize) {
-        var lines = allocateArray(polyData, 'lines', cellSize + 1); // +1 for the number of points
-
-        var cellData = lines.getData();
+        const lines = allocateArray(polyData, 'lines', cellSize + 1); // +1 for the number of points
+        const cellData = lines.getData();
         cellData[0] = cellSize;
-
-        for (var i = 1; i <= cellSize; i++) {
+        for (let i = 1; i <= cellSize; i++) {
           cellData[i] = i - 1;
         }
-
         if (closePolyLine) {
           cellData[cellSize] = 0;
         }
-
         lines.setData(cellData);
       }
     }
-
     return points;
   }
+
   /**
    * Change the line/tube thickness.
    * @param {number} lineThickness
    */
-
-
   function applyLineThickness(lineThickness) {
-    var scaledLineThickness = lineThickness;
-
+    let scaledLineThickness = lineThickness;
     if (publicAPI.getScaleInPixels() && internalPolyData) {
-      var center = vtkBoundingBox.getCenter(internalPolyData.getBounds());
+      const center = vtkBoundingBox.getCenter(internalPolyData.getBounds());
       scaledLineThickness *= getPixelWorldHeightAtCoord(center, model.displayScaleParams);
     }
-
     model._pipelines.tubes.filter.setRadius(scaledLineThickness);
-  } // --------------------------------------------------------------------------
+  }
+
+  // --------------------------------------------------------------------------
   // Generic rendering pipeline
   // --------------------------------------------------------------------------
 
-
   model._pipelines = {
     tubes: {
       source: publicAPI,
@@ -97,42 +85,39 @@ function vtkPolyLineRepresentation(publicAPI, model) {
     }
   };
   vtkWidgetRepresentation.connectPipeline(model._pipelines.tubes);
-  publicAPI.addActor(model._pipelines.tubes.actor); // --------------------------------------------------------------------------
-
-  publicAPI.requestData = function (inData, outData) {
-    var _state$getLineThickne, _state$getLineThickne2;
-
-    var state = inData[0];
-    outData[0] = internalPolyData; // Remove invalid and coincident points for tube filter.
-
-    var list = publicAPI.getRepresentationStates(state).reduce(function (subStates, subState) {
-      var subStateOrigin = subState.getOrigin && subState.getOrigin() ? subState.getOrigin() : null;
-      var previousSubStateOrigin = subStates.length && subStates[subStates.length - 1].getOrigin();
+  publicAPI.addActor(model._pipelines.tubes.actor);
 
+  // --------------------------------------------------------------------------
+  publicAPI.requestData = (inData, outData) => {
+    const state = inData[0];
+    outData[0] = internalPolyData;
+
+    // Remove invalid and coincident points for tube filter.
+    const list = publicAPI.getRepresentationStates(state).reduce((subStates, subState) => {
+      const subStateOrigin = subState.getOrigin && subState.getOrigin() ? subState.getOrigin() : null;
+      const previousSubStateOrigin = subStates.length && subStates[subStates.length - 1].getOrigin();
       if (!subStateOrigin || previousSubStateOrigin && areEquals(subStateOrigin, previousSubStateOrigin)) {
         return subStates;
       }
-
       subStates.push(subState);
       return subStates;
     }, []);
-    var size = list.length;
-    var points = allocateSize(outData[0], size, model.closePolyLine && size > 2);
-
+    const size = list.length;
+    const points = allocateSize(outData[0], size, model.closePolyLine && size > 2);
     if (points) {
-      for (var i = 0; i < size; i++) {
-        var coords = list[i].getOrigin();
+      for (let i = 0; i < size; i++) {
+        const coords = list[i].getOrigin();
         points[i * 3] = coords[0];
         points[i * 3 + 1] = coords[1];
         points[i * 3 + 2] = coords[2];
       }
     }
-
     outData[0].getPoints().modified();
     outData[0].modified();
-    var lineThickness = (_state$getLineThickne = (_state$getLineThickne2 = state.getLineThickness) === null || _state$getLineThickne2 === void 0 ? void 0 : _state$getLineThickne2.call(state)) !== null && _state$getLineThickne !== void 0 ? _state$getLineThickne : model.lineThickness;
+    const lineThickness = state.getLineThickness?.() ?? model.lineThickness;
     applyLineThickness(lineThickness);
   };
+
   /**
    * When mousing over the line, if behavior != CONTEXT,
    * returns the parent state.
@@ -140,53 +125,53 @@ function vtkPolyLineRepresentation(publicAPI, model) {
    * @param {number} compositeID
    * @returns {object}
    */
+  publicAPI.getSelectedState = (prop, compositeID) => model.inputData[0];
+  publicAPI.updateActorVisibility = (renderingType, ctxVisible, hVisible) => {
+    const state = model.inputData[0];
 
-
-  publicAPI.getSelectedState = function (prop, compositeID) {
-    return model.inputData[0];
-  };
-
-  publicAPI.updateActorVisibility = function (renderingType, ctxVisible, hVisible) {
-    var _state$getLineThickne3, _state$getLineThickne4;
-
-    var state = model.inputData[0]; // Make lines/tubes thicker for picking
-
-    var lineThickness = (_state$getLineThickne3 = (_state$getLineThickne4 = state.getLineThickness) === null || _state$getLineThickne4 === void 0 ? void 0 : _state$getLineThickne4.call(state)) !== null && _state$getLineThickne3 !== void 0 ? _state$getLineThickne3 : model.lineThickness;
-
+    // Make lines/tubes thicker for picking
+    let lineThickness = state.getLineThickness?.() ?? model.lineThickness;
     if (renderingType === RenderingTypes.PICKING_BUFFER) {
       lineThickness = Math.max(4, lineThickness);
     }
-
     applyLineThickness(lineThickness);
     return superClass.updateActorVisibility(renderingType, ctxVisible, hVisible);
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   threshold: Number.EPSILON,
   closePolyLine: false,
   lineThickness: 2,
   scaleInPixels: true
-}; // ----------------------------------------------------------------------------
-
-function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+};
 
-  var newDefault = _objectSpread(_objectSpread({}, DEFAULT_VALUES), initialValues);
+// ----------------------------------------------------------------------------
 
+function extend(publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  const newDefault = {
+    ...DEFAULT_VALUES,
+    ...initialValues
+  };
   vtkWidgetRepresentation.extend(publicAPI, model, newDefault);
   macro.setGet(publicAPI, model, ['threshold', 'closePolyLine', 'lineThickness']);
   vtkPolyLineRepresentation(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkPolyLineRepresentation');
 
-var newInstance = macro.newInstance(extend, 'vtkPolyLineRepresentation'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 var vtkPolyLineRepresentation$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkPolyLineRepresentation$1 as default, extend, newInstance };

package/Widgets/Representations/RectangleContextRepresentation.js

@@ -1,4 +1,4 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkActor from '../../Rendering/Core/Actor.js';
 import vtkContextRepresentation from './ContextRepresentation.js';
 import vtkMapper from '../../Rendering/Core/Mapper.js';
@@ -6,15 +6,17 @@ import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import { allocateArray } from './WidgetRepresentation.js';
 import { vec3 } from 'gl-matrix';
 
+// ----------------------------------------------------------------------------
 // vtkRectangleContextRepresentation methods
 // ----------------------------------------------------------------------------
 
 function vtkRectangleContextRepresentation(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkRectangleContextRepresentation'); // --------------------------------------------------------------------------
+  model.classHierarchy.push('vtkRectangleContextRepresentation');
+
+  // --------------------------------------------------------------------------
   // Generic rendering pipeline
   // --------------------------------------------------------------------------
-
   model.internalPolyData = vtkPolyData.newInstance({
     mtime: 0
   });
@@ -26,30 +28,31 @@ function vtkRectangleContextRepresentation(publicAPI, model) {
   model.actor.setMapper(model.mapper);
   model.actor.getProperty().setOpacity(0.2);
   model.actor.getProperty().setColor(0, 1, 0);
-  publicAPI.addActor(model.actor); // --------------------------------------------------------------------------
+  publicAPI.addActor(model.actor);
+
+  // --------------------------------------------------------------------------
 
-  publicAPI.setOpacity = function (opacity) {
+  publicAPI.setOpacity = opacity => {
     model.actor.getProperty().setOpacity(opacity);
-  }; // --------------------------------------------------------------------------
+  };
 
+  // --------------------------------------------------------------------------
 
-  publicAPI.requestData = function (inData, outData) {
+  publicAPI.requestData = (inData, outData) => {
     if (model.deleted) {
       return;
     }
-
-    var list = publicAPI.getRepresentationStates(inData[0]); // FIXME: support list > 1.
-
-    var state = list[0];
-
-    if (state !== null && state !== void 0 && state.getVisible() && state !== null && state !== void 0 && state.getOrigin()) {
-      var point1 = state.getOrigin();
-      var point2 = state.getCorner();
-      var diagonal = [0, 0, 0];
+    const list = publicAPI.getRepresentationStates(inData[0]);
+    // FIXME: support list > 1.
+    const state = list[0];
+    if (state?.getVisible() && state?.getOrigin()) {
+      const point1 = state.getOrigin();
+      const point2 = state.getCorner();
+      const diagonal = [0, 0, 0];
       vec3.subtract(diagonal, point2, point1);
-      var up = state.getUp();
-      var upComponent = vec3.dot(diagonal, up);
-      var points = allocateArray(model.internalPolyData, 'points', 4).getData();
+      const up = state.getUp();
+      const upComponent = vec3.dot(diagonal, up);
+      const points = allocateArray(model.internalPolyData, 'points', 4).getData();
       points[0] = point1[0];
       points[1] = point1[1];
       points[2] = point1[2];
@@ -62,14 +65,12 @@ function vtkRectangleContextRepresentation(publicAPI, model) {
       points[9] = point2[0] - upComponent * up[0];
       points[10] = point2[1] - upComponent * up[1];
       points[11] = point2[2] - upComponent * up[2];
-
       if (model.drawFace) {
-        var polys = new Uint32Array([4, 0, 1, 2, 3]);
+        const polys = new Uint32Array([4, 0, 1, 2, 3]);
         model.internalPolyData.getPolys().setData(polys, 1);
       }
-
       if (model.drawBorder) {
-        var line = new Uint32Array([5, 0, 1, 2, 3, 0]);
+        const line = new Uint32Array([5, 0, 1, 2, 3, 0]);
         model.internalPolyData.getLines().setData(line, 1);
       }
     } else {
@@ -77,40 +78,44 @@ function vtkRectangleContextRepresentation(publicAPI, model) {
       model.internalPolyData.getPolys().setData([], 0);
       model.internalPolyData.getLines().setData([], 0);
     }
-
     model.internalPolyData.modified();
     outData[0] = model.internalPolyData;
   };
+  publicAPI.getSelectedState = (prop, compositeID) => model.state;
+}
 
-  publicAPI.getSelectedState = function (prop, compositeID) {
-    return model.state;
-  };
-} // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   drawBorder: false,
   drawFace: true
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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);
   vtkContextRepresentation.extend(publicAPI, model, initialValues);
   macro.setGetArray(publicAPI, model, ['color'], 1);
   macro.setGet(publicAPI, model, ['drawBorder', 'drawFace']);
-  macro.get(publicAPI, model, ['mapper', 'actor']); // Object specific methods
+  macro.get(publicAPI, model, ['mapper', 'actor']);
 
+  // Object specific methods
   vtkRectangleContextRepresentation(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkRectangleContextRepresentation');
 
-var newInstance = macro.newInstance(extend, 'vtkRectangleContextRepresentation'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 var vtkRectangleContextRepresentation$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkRectangleContextRepresentation$1 as default, extend, newInstance };

package/Widgets/Representations/SphereContextRepresentation.js

@@ -1,61 +1,53 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkSphereSource from '../../Filters/Sources/SphereSource.js';
 import vtkGlyphRepresentation from './GlyphRepresentation.js';
 import { Behavior } from './WidgetRepresentation/Constants.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 vtkSphereContextRepresentation(publicAPI, model) {
   model.classHierarchy.push('vtkSphereContextRepresentation');
   publicAPI.setGlyphResolution = macro.chain(publicAPI.setGlyphResolution, model._pipeline.glyph.setThetaResolution, model._pipeline.glyph.setPhiResolution);
-
-  publicAPI.setDrawBorder = function (draw) {
+  publicAPI.setDrawBorder = draw => {
     model._pipeline.glyph.setLines(draw);
   };
-
-  publicAPI.setDrawFace = function (draw) {
+  publicAPI.setDrawFace = draw => {
     model._pipeline.glyph.setFace(draw);
   };
-
-  publicAPI.setOpacity = function (opacity) {
+  publicAPI.setOpacity = opacity => {
     model._pipeline.actor.getProperty().setOpacity(opacity);
   };
-
   model._pipeline.actor.getProperty().setOpacity(0.2);
 }
-
 function defaultValues(initialValues) {
-  var _initialValues$glyphR, _initialValues$glyphR2;
-
-  return _objectSpread({
+  return {
     glyphResolution: 32,
     drawBorder: false,
     drawFace: true,
     behavior: Behavior.CONTEXT,
     _pipeline: {
       glyph: vtkSphereSource.newInstance({
-        phiResolution: (_initialValues$glyphR = initialValues.glyphResolution) !== null && _initialValues$glyphR !== void 0 ? _initialValues$glyphR : 32,
-        thetaResolution: (_initialValues$glyphR2 = initialValues.glyphResolution) !== null && _initialValues$glyphR2 !== void 0 ? _initialValues$glyphR2 : 32
+        phiResolution: initialValues.glyphResolution ?? 32,
+        thetaResolution: initialValues.glyphResolution ?? 32
       })
-    }
-  }, initialValues);
-} // ----------------------------------------------------------------------------
+    },
+    ...initialValues
+  };
+}
 
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   vtkGlyphRepresentation.extend(publicAPI, model, defaultValues(initialValues));
   macro.setGet(publicAPI, model, ['glyphResolution']);
   vtkSphereContextRepresentation(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = macro.newInstance(extend, 'vtkSphereContextRepresentation');
+const newInstance = macro.newInstance(extend, 'vtkSphereContextRepresentation');
 var vtkSphereContextRepresentation$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkSphereContextRepresentation$1 as default, extend, newInstance };

package/Widgets/Representations/SphereHandleRepresentation.js

@@ -1,14 +1,17 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkActor from '../../Rendering/Core/Actor.js';
 import vtkGlyphRepresentation from './GlyphRepresentation.js';
 import vtkPixelSpaceCallbackMapper from '../../Rendering/Core/PixelSpaceCallbackMapper.js';
 
+// ----------------------------------------------------------------------------
 // vtkSphereHandleRepresentation methods
 // ----------------------------------------------------------------------------
 
 function vtkSphereHandleRepresentation(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkSphereHandleRepresentation'); // --------------------------------------------------------------------------
+  model.classHierarchy.push('vtkSphereHandleRepresentation');
+
+  // --------------------------------------------------------------------------
   // Generic rendering pipeline
   // --------------------------------------------------------------------------
 
@@ -20,64 +23,65 @@ function vtkSphereHandleRepresentation(publicAPI, model) {
   model.displayMapper = vtkPixelSpaceCallbackMapper.newInstance();
   model.displayActor = vtkActor.newInstance({
     parentProp: publicAPI
-  }); // model.displayActor.getProperty().setOpacity(0); // don't show in 3D
-
+  });
+  // model.displayActor.getProperty().setOpacity(0); // don't show in 3D
   model.displayActor.setMapper(model.displayMapper);
   model.displayMapper.setInputConnection(publicAPI.getOutputPort());
   publicAPI.addActor(model.displayActor);
-  model.alwaysVisibleActors = [model.displayActor]; // --------------------------------------------------------------------------
+  model.alwaysVisibleActors = [model.displayActor];
 
-  publicAPI.getGlyphResolution = function () {
-    return model._pipeline.glyph.getPhiResolution();
-  };
+  // --------------------------------------------------------------------------
 
-  publicAPI.setGlyphResolution = function (resolution) {
-    return model._pipeline.glyph.setPhiResolution(resolution) || model._pipeline.glyph.setThetaResolution(resolution);
-  }; // --------------------------------------------------------------------------
+  publicAPI.getGlyphResolution = () => model._pipeline.glyph.getPhiResolution();
+  publicAPI.setGlyphResolution = resolution => model._pipeline.glyph.setPhiResolution(resolution) || model._pipeline.glyph.setThetaResolution(resolution);
 
+  // --------------------------------------------------------------------------
 
   function callbackProxy(coords) {
     if (model.displayCallback) {
-      var filteredList = [];
-      var states = publicAPI.getRepresentationStates();
-
-      for (var i = 0; i < states.length; i++) {
+      const filteredList = [];
+      const states = publicAPI.getRepresentationStates();
+      for (let i = 0; i < states.length; i++) {
         if (states[i].getActive()) {
           filteredList.push(coords[i]);
         }
       }
-
       if (filteredList.length) {
         model.displayCallback(filteredList);
         return;
       }
     }
-
     model.displayCallback();
   }
-
-  publicAPI.setDisplayCallback = function (callback) {
+  publicAPI.setDisplayCallback = callback => {
     model.displayCallback = callback;
     model.displayMapper.setCallback(callback ? callbackProxy : null);
   };
-} // ----------------------------------------------------------------------------
-// Object factory
+}
+
 // ----------------------------------------------------------------------------
+// Object factory
 // ----------------------------------------------------------------------------
 
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  vtkGlyphRepresentation.extend(publicAPI, model, initialValues); // Object specific methods
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  vtkGlyphRepresentation.extend(publicAPI, model, initialValues);
 
+  // Object specific methods
   vtkSphereHandleRepresentation(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkSphereHandleRepresentation'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkSphereHandleRepresentation');
+
+// ----------------------------------------------------------------------------
 
 var vtkSphereHandleRepresentation$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkSphereHandleRepresentation$1 as default, extend, newInstance };