@kitware/vtk.js 28.10.2 → 28.11.1

package/Widgets/Representations/ImplicitPlaneRepresentation.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 vtkClosedPolyLineToSurfaceFilter from '../../Filters/General/ClosedPolyLineToSurfaceFilter.js';
 import vtkCubeSource from '../../Filters/Sources/CubeSource.js';
@@ -16,9 +16,15 @@ import vtkWidgetRepresentation from './WidgetRepresentation.js';
 import WidgetManagerConst from '../Core/WidgetManager/Constants.js';
 import PropertyConst from '../../Rendering/Core/Property/Constants.js';
 
-var RenderingTypes = WidgetManagerConst.RenderingTypes;
-var Interpolation = PropertyConst.Interpolation,
-    Representation = PropertyConst.Representation; // ----------------------------------------------------------------------------
+const {
+  RenderingTypes
+} = WidgetManagerConst;
+const {
+  Interpolation,
+  Representation
+} = PropertyConst;
+
+// ----------------------------------------------------------------------------
 // Static methods to build state
 // ----------------------------------------------------------------------------
 
@@ -35,13 +41,14 @@ function generateState() {
   }).addField({
     name: 'updateMethodName'
   }).build();
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Representation style
 // ----------------------------------------------------------------------------
 
-
-var STYLE_PIPELINE_NAMES = ['plane', 'outline', 'normal', 'origin', 'display2D'];
-var STYLE_DEFAULT = {
+const STYLE_PIPELINE_NAMES = ['plane', 'outline', 'normal', 'origin', 'display2D'];
+const STYLE_DEFAULT = {
   active: {
     plane: {
       opacity: 1,
@@ -81,13 +88,17 @@ var STYLE_DEFAULT = {
       interpolation: Interpolation.FLAT
     }
   }
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 // vtkImplicitPlaneRepresentation methods
 // ----------------------------------------------------------------------------
 
 function vtkImplicitPlaneRepresentation(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkImplicitPlaneRepresentation'); // --------------------------------------------------------------------------
+  model.classHierarchy.push('vtkImplicitPlaneRepresentation');
+
+  // --------------------------------------------------------------------------
   // Internal polydata dataset
   // --------------------------------------------------------------------------
 
@@ -136,10 +147,10 @@ function vtkImplicitPlaneRepresentation(publicAPI, model) {
       pickable: false,
       _parentProp: publicAPI
     })
-  }; // Plane generation pipeline
+  };
 
+  // Plane generation pipeline
   model._pipelines.plane.source.setInputConnection(model._pipelines.outline.source.getOutputPort());
-
   vtkWidgetRepresentation.connectPipeline(model._pipelines.outline);
   vtkWidgetRepresentation.connectPipeline(model._pipelines.plane);
   vtkWidgetRepresentation.connectPipeline(model._pipelines.origin);
@@ -149,170 +160,158 @@ function vtkImplicitPlaneRepresentation(publicAPI, model) {
   publicAPI.addActor(model._pipelines.plane.actor);
   publicAPI.addActor(model._pipelines.origin.actor);
   publicAPI.addActor(model._pipelines.normal.actor);
-  publicAPI.addActor(model._pipelines.display2D.actor); // --------------------------------------------------------------------------
+  publicAPI.addActor(model._pipelines.display2D.actor);
 
-  publicAPI.requestData = function (inData, outData) {
-    var state = inData[0];
-    var origin = state.getOrigin();
+  // --------------------------------------------------------------------------
 
+  publicAPI.requestData = (inData, outData) => {
+    const state = inData[0];
+    const origin = state.getOrigin();
     if (!origin) {
       return;
     }
-
-    var normal = state.getNormal();
-    var bounds = state.getBounds();
+    const normal = state.getNormal();
+    const bounds = state.getBounds();
     model.plane.setOrigin(origin);
-    model.plane.setNormal(normal); // --------------------------------
+    model.plane.setNormal(normal);
+
+    // --------------------------------
     // Update cube parameters
     // --------------------------------
 
     model._pipelines.outline.source.setCenter((bounds[0] + bounds[1]) * 0.5, (bounds[2] + bounds[3]) * 0.5, (bounds[4] + bounds[5]) * 0.5);
-
-    var xRange = bounds[1] - bounds[0];
-    var yRange = bounds[3] - bounds[2];
-    var zRange = bounds[5] - bounds[4];
-
+    const xRange = bounds[1] - bounds[0];
+    const yRange = bounds[3] - bounds[2];
+    const zRange = bounds[5] - bounds[4];
     model._pipelines.outline.source.setXLength(xRange);
-
     model._pipelines.outline.source.setYLength(yRange);
+    model._pipelines.outline.source.setZLength(zRange);
 
-    model._pipelines.outline.source.setZLength(zRange); // --------------------------------
+    // --------------------------------
     // Update normal parameters
     // --------------------------------
 
-
-    var pixelScale = 1;
-
+    let pixelScale = 1;
     if (model.scaleInPixels) {
       pixelScale = getPixelWorldHeightAtCoord(origin, model.displayScaleParams);
     }
-
     model._pipelines.normal.source.set({
       height: Math.max(xRange, yRange, zRange),
       radius: model.handleSizeRatio * Math.min(xRange, yRange, zRange) * model.axisScale * pixelScale,
       resolution: model.sphereResolution
     });
-
-    var yAxis = model._pipelines.normal.source.getOutputData();
-
-    var newAxis = vtkPolyData.newInstance();
+    const yAxis = model._pipelines.normal.source.getOutputData();
+    const newAxis = vtkPolyData.newInstance();
     newAxis.shallowCopy(yAxis);
     newAxis.getPoints().setData(Float32Array.from(yAxis.getPoints().getData()), 3);
     newAxis.getPointData().removeAllArrays();
     model.matrix.identity().translate(origin[0], origin[1], origin[2]).rotateFromDirections([0, 1, 0], normal).apply(newAxis.getPoints().getData());
+    model._pipelines.normal.mapper.setInputData(newAxis);
 
-    model._pipelines.normal.mapper.setInputData(newAxis); // --------------------------------
+    // --------------------------------
     // Update origin parameters
     // --------------------------------
 
-
     model._pipelines.origin.actor.setPosition(origin);
+    const handleScale = model.handleSizeRatio * Math.min(xRange, yRange, zRange) * pixelScale;
+    model._pipelines.origin.actor.setScale(handleScale, handleScale, handleScale);
 
-    var handleScale = model.handleSizeRatio * Math.min(xRange, yRange, zRange) * pixelScale;
-
-    model._pipelines.origin.actor.setScale(handleScale, handleScale, handleScale); // --------------------------------
+    // --------------------------------
     // Update style since state changed
     // --------------------------------
 
-
     vtkWidgetRepresentation.applyStyles(model._pipelines, model.representationStyle, state.getActive() && state.getActiveHandle());
-    var output = vtkPolyData.newInstance();
+    const output = vtkPolyData.newInstance();
     output.shallowCopy(model._pipelines.plane.filter.getOutputData());
     outData[0] = output;
-  }; // --------------------------------------------------------------------------
+  };
+
+  // --------------------------------------------------------------------------
   // Set/Get Forwarding
   // --------------------------------------------------------------------------
 
-
-  publicAPI.setSphereResolution = function (res) {
+  publicAPI.setSphereResolution = res => {
     model.sphereResolution = res;
     return model._pipelines.origin.source.setPhiResolution(res) && model._pipelines.origin.source.setThetaResolution(res);
   };
+  publicAPI.setRepresentationStyle = style => {
+    model.representationStyle = vtkWidgetRepresentation.mergeStyles(STYLE_PIPELINE_NAMES, model.representationStyle, style);
 
-  publicAPI.setRepresentationStyle = function (style) {
-    model.representationStyle = vtkWidgetRepresentation.mergeStyles(STYLE_PIPELINE_NAMES, model.representationStyle, style); // Apply static and inactive
-
-    vtkWidgetRepresentation.applyStyles(model._pipelines, model.representationStyle); // Force requestData to execute
+    // Apply static and inactive
+    vtkWidgetRepresentation.applyStyles(model._pipelines, model.representationStyle);
 
+    // Force requestData to execute
     publicAPI.modified();
-  }; // --------------------------------------------------------------------------
+  };
+
+  // --------------------------------------------------------------------------
   // WidgetRepresentation API
   // --------------------------------------------------------------------------
 
-
-  publicAPI.updateActorVisibility = function (renderingType, ctxVisible, hVisible) {
-    var planeVisible = model.planeVisible,
-        originVisible = model.originVisible,
-        normalVisible = model.normalVisible,
-        outlineVisible = model.outlineVisible;
-
+  publicAPI.updateActorVisibility = (renderingType, ctxVisible, hVisible) => {
+    const {
+      planeVisible,
+      originVisible,
+      normalVisible,
+      outlineVisible
+    } = model;
     if (renderingType === RenderingTypes.PICKING_BUFFER) {
       model._pipelines.plane.actor.setVisibility(planeVisible);
-
       model._pipelines.origin.actor.setVisibility(originVisible);
-
-      model._pipelines.normal.actor.setVisibility(normalVisible); //
-
-
+      model._pipelines.normal.actor.setVisibility(normalVisible);
+      //
       model._pipelines.plane.actor.getProperty().setOpacity(1);
     } else {
       model._pipelines.outline.actor.setVisibility(outlineVisible && ctxVisible);
-
       model._pipelines.plane.actor.setVisibility(planeVisible && hVisible);
-
       model._pipelines.origin.actor.setVisibility(originVisible && hVisible);
-
-      model._pipelines.normal.actor.setVisibility(normalVisible && hVisible); //
-
-
-      var state = model.inputData[0];
-
+      model._pipelines.normal.actor.setVisibility(normalVisible && hVisible);
+      //
+      const state = model.inputData[0];
       if (state) {
         vtkWidgetRepresentation.applyStyles(model._pipelines, model.representationStyle, state.getActive() && state.getActiveHandle());
       }
     }
-  }; // --------------------------------------------------------------------------
+  };
 
+  // --------------------------------------------------------------------------
 
-  publicAPI.getSelectedState = function (prop, compositeID) {
+  publicAPI.getSelectedState = (prop, compositeID) => {
     // We only have one state to control us
     // we may want to update some field on the state to highlight the
     // selected handle later on...
-    var state = model.inputData[0];
+    const state = model.inputData[0];
     state.setActiveHandle(prop);
-
     switch (prop) {
       case model._pipelines.plane.actor:
         state.setUpdateMethodName('updateFromPlane');
         break;
-
       case model._pipelines.origin.actor:
         state.setUpdateMethodName('updateFromOrigin');
         break;
-
       case model._pipelines.normal.actor:
         state.setUpdateMethodName('updateFromNormal');
         break;
-
       default:
         state.setUpdateMethodName('updateFromPlane');
         break;
     }
-
     return state;
-  }; // --------------------------------------------------------------------------
+  };
+
+  // --------------------------------------------------------------------------
   // Initialization
   // --------------------------------------------------------------------------
 
-
   publicAPI.setRepresentationStyle(STYLE_DEFAULT);
   publicAPI.setSphereResolution(model.sphereResolution);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   sphereResolution: 24,
   handleSizeRatio: 0.05,
   axisScale: 0.1,
@@ -320,24 +319,31 @@ var DEFAULT_VALUES = {
   originVisible: true,
   planeVisible: true,
   outlineVisible: 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);
   vtkWidgetRepresentation.extend(publicAPI, model, initialValues);
   macro.get(publicAPI, model, ['sphereResolution', 'representationStyle']);
-  macro.setGet(publicAPI, model, ['handleSizeRatio', 'axisScale', 'normalVisible', 'originVisible', 'planeVisible', 'outlineVisible']); // Object specific methods
+  macro.setGet(publicAPI, model, ['handleSizeRatio', 'axisScale', 'normalVisible', 'originVisible', 'planeVisible', 'outlineVisible']);
 
+  // Object specific methods
   vtkImplicitPlaneRepresentation(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkImplicitPlaneRepresentation'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkImplicitPlaneRepresentation');
+
+// ----------------------------------------------------------------------------
 
 var vtkImplicitPlaneRepresentation$1 = {
-  newInstance: newInstance,
-  extend: extend,
-  generateState: generateState
+  newInstance,
+  extend,
+  generateState
 };
 
 export { vtkImplicitPlaneRepresentation$1 as default, extend, newInstance };

package/Widgets/Representations/LineHandleRepresentation.js

@@ -1,21 +1,21 @@
-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 vtkGlyphRepresentation from './GlyphRepresentation.js';
 import vtkPixelSpaceCallbackMapper from '../../Rendering/Core/PixelSpaceCallbackMapper.js';
 import vtkCylinderSource from '../../Filters/Sources/CylinderSource.js';
 import { allocateArray } from './WidgetRepresentation.js';
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+const INFINITE_RATIO = 100000;
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-var INFINITE_RATIO = 100000; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // vtkLineHandleRepresentation methods
 // ----------------------------------------------------------------------------
 
 function vtkLineHandleRepresentation(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkLineHandleRepresentation'); // --------------------------------------------------------------------------
+  model.classHierarchy.push('vtkLineHandleRepresentation');
+
+  // --------------------------------------------------------------------------
   // Generic rendering pipeline
   // --------------------------------------------------------------------------
 
@@ -27,90 +27,93 @@ function vtkLineHandleRepresentation(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.setGlyphResolution = macro.chain(publicAPI.setGlyphResolution, model._pipeline.glyph.setThetaResolution, model._pipeline.glyph.setPhiResolution); // --------------------------------------------------------------------------
+  publicAPI.setGlyphResolution = macro.chain(publicAPI.setGlyphResolution, model._pipeline.glyph.setThetaResolution, model._pipeline.glyph.setPhiResolution);
+
+  // --------------------------------------------------------------------------
 
   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);
   };
+
   /**
    * Overwrite scale3 to optionally make lines infinite
    */
-
-
-  var superScale3 = publicAPI.getScale3();
-  publicAPI.setScale3(function (polyData, states) {
+  const superScale3 = publicAPI.getScale3();
+  publicAPI.setScale3((polyData, states) => {
     superScale3(polyData, states);
-
     if (model.infiniteLine) {
-      var scales = allocateArray(polyData, 'scale', states.length, 'Float32Array', 3).getData();
-
-      for (var i = 0; i < states.length; ++i) {
+      const scales = allocateArray(polyData, 'scale', states.length, 'Float32Array', 3).getData();
+      for (let i = 0; i < states.length; ++i) {
         scales[3 * i + 2] = INFINITE_RATIO;
       }
     }
   });
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
 function defaultValues(initialValues) {
-  var _initialValues$glyphR;
-
-  return _objectSpread({
+  return {
     infiniteLine: true,
     glyphResolution: 4,
     _pipeline: {
       glyph: vtkCylinderSource.newInstance({
-        resolution: (_initialValues$glyphR = initialValues.glyphResolution) !== null && _initialValues$glyphR !== void 0 ? _initialValues$glyphR : 4,
+        resolution: initialValues.glyphResolution ?? 4,
         direction: [0, 0, 1]
       })
-    }
-  }, 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, ['infiniteLine', 'glyphResolution']); // Object specific methods
+  macro.setGet(publicAPI, model, ['infiniteLine', 'glyphResolution']);
 
+  // Object specific methods
   vtkLineHandleRepresentation(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkLineHandleRepresentation'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkLineHandleRepresentation');
+
+// ----------------------------------------------------------------------------
 
 var vtkLineHandleRepresentation$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkLineHandleRepresentation$1 as default, extend, newInstance };

package/Widgets/Representations/OutlineContextRepresentation.js

@@ -1,5 +1,4 @@
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
-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';
@@ -7,19 +6,21 @@ import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 import { LINE_ARRAY, BOUNDS_MAP } from '../../Filters/General/OutlineFilter.js';
 
+// ----------------------------------------------------------------------------
 // vtkOutlineContextRepresentation methods
 // ----------------------------------------------------------------------------
+
 // Represents a box outline given 8 points as corners.
 // Does not work with an arbitrary set of points. An oriented bounding box
 // algorithm may be implemented in the future.
-
 function vtkOutlineContextRepresentation(publicAPI, model) {
-  var _model$actor$getPrope;
-
   // Set our className
-  model.classHierarchy.push('vtkOutlineContextRepresentation'); // internal bounding box
+  model.classHierarchy.push('vtkOutlineContextRepresentation');
 
-  model.bbox = _toConsumableArray(vtkBoundingBox.INIT_BOUNDS); // --------------------------------------------------------------------------
+  // internal bounding box
+  model.bbox = [...vtkBoundingBox.INIT_BOUNDS];
+
+  // --------------------------------------------------------------------------
   // Internal polydata dataset
   // --------------------------------------------------------------------------
 
@@ -28,7 +29,9 @@ function vtkOutlineContextRepresentation(publicAPI, model) {
   });
   model.points = new Float32Array(8 * 3);
   model.internalPolyData.getPoints().setData(model.points, 3);
-  model.internalPolyData.getLines().setData(Uint16Array.from(LINE_ARRAY)); // --------------------------------------------------------------------------
+  model.internalPolyData.getLines().setData(Uint16Array.from(LINE_ARRAY));
+
+  // --------------------------------------------------------------------------
   // Generic rendering pipeline
   // --------------------------------------------------------------------------
 
@@ -38,60 +41,63 @@ function vtkOutlineContextRepresentation(publicAPI, model) {
   model.actor = vtkActor.newInstance({
     parentProp: publicAPI
   });
-
-  (_model$actor$getPrope = model.actor.getProperty()).setEdgeColor.apply(_model$actor$getPrope, _toConsumableArray(model.edgeColor));
-
+  model.actor.getProperty().setEdgeColor(...model.edgeColor);
   model.mapper.setInputConnection(publicAPI.getOutputPort());
   model.actor.setMapper(model.mapper);
-  publicAPI.addActor(model.actor); // --------------------------------------------------------------------------
+  publicAPI.addActor(model.actor);
 
-  publicAPI.requestData = function (inData, outData) {
-    var list = publicAPI.getRepresentationStates(inData[0]).filter(function (state) {
-      return state.getOrigin && state.getOrigin();
-    });
-    vtkBoundingBox.reset(model.bbox);
-
-    for (var i = 0; i < list.length; i++) {
-      var pt = list[i].getOrigin();
+  // --------------------------------------------------------------------------
 
+  publicAPI.requestData = (inData, outData) => {
+    const list = publicAPI.getRepresentationStates(inData[0]).filter(state => state.getOrigin && state.getOrigin());
+    vtkBoundingBox.reset(model.bbox);
+    for (let i = 0; i < list.length; i++) {
+      const pt = list[i].getOrigin();
       if (pt) {
-        vtkBoundingBox.addPoint.apply(vtkBoundingBox, [model.bbox].concat(_toConsumableArray(pt)));
+        vtkBoundingBox.addPoint(model.bbox, ...pt);
       }
-    } // BOUNDS_MAP.length should equal model.points.length
-
-
-    for (var _i = 0; _i < BOUNDS_MAP.length; _i++) {
-      model.points[_i] = model.bbox[BOUNDS_MAP[_i]];
     }
 
+    // BOUNDS_MAP.length should equal model.points.length
+    for (let i = 0; i < BOUNDS_MAP.length; i++) {
+      model.points[i] = model.bbox[BOUNDS_MAP[i]];
+    }
     model.internalPolyData.getPoints().modified();
     model.internalPolyData.modified();
     outData[0] = model.internalPolyData;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   edgeColor: [1, 1, 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);
   vtkContextRepresentation.extend(publicAPI, model, initialValues);
   macro.setGetArray(publicAPI, model, ['edgeColor'], 3);
-  macro.get(publicAPI, model, ['mapper', 'actor']); // Object specific methods
+  macro.get(publicAPI, model, ['mapper', 'actor']);
 
+  // Object specific methods
   vtkOutlineContextRepresentation(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkOutlineContextRepresentation');
 
-var newInstance = macro.newInstance(extend, 'vtkOutlineContextRepresentation'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 var vtkOutlineContextRepresentation$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkOutlineContextRepresentation$1 as default, extend, newInstance };