@kitware/vtk.js 28.10.2 → 28.11.0

package/Filters/Sources/SLICSource.js

@@ -1,62 +1,54 @@
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkImageData from '../../Common/DataModel/ImageData.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 
+// ----------------------------------------------------------------------------
 // Global methods
 // ----------------------------------------------------------------------------
 
 function generateCoordinates(origin, dimensions, spacing) {
-  var coordinates = new Float64Array(dimensions[0] * dimensions[1] * dimensions[2] * 3);
-  var offset = 0;
-
-  for (var k = 0; k < dimensions[2]; k++) {
-    var z = origin[2] + spacing[2] * k;
-
-    for (var j = 0; j < dimensions[1]; j++) {
-      var y = origin[1] + spacing[1] * j;
-
-      for (var i = 0; i < dimensions[0]; i++) {
-        var x = origin[0] + spacing[0] * i;
+  const coordinates = new Float64Array(dimensions[0] * dimensions[1] * dimensions[2] * 3);
+  let offset = 0;
+  for (let k = 0; k < dimensions[2]; k++) {
+    const z = origin[2] + spacing[2] * k;
+    for (let j = 0; j < dimensions[1]; j++) {
+      const y = origin[1] + spacing[1] * j;
+      for (let i = 0; i < dimensions[0]; i++) {
+        const x = origin[0] + spacing[0] * i;
         coordinates[offset++] = x;
         coordinates[offset++] = y;
         coordinates[offset++] = z;
       }
     }
   }
-
   return coordinates;
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // vtkSLICSource methods
 // ----------------------------------------------------------------------------
 
-
 function vtkSLICSource(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkSLICSource');
-
-  publicAPI.addCluster = function (centerX, centerY, centerZ, fnConst, fnDfDx, fnDfDy, fnDfDz) {
-    var id = model.clusters.length;
+  publicAPI.addCluster = (centerX, centerY, centerZ, fnConst, fnDfDx, fnDfDy, fnDfDz) => {
+    const id = model.clusters.length;
     model.clusters.push(new Float64Array([centerX, centerY, centerZ, fnConst, fnDfDx, fnDfDy, fnDfDz]));
     publicAPI.modified();
     return id;
   };
-
-  publicAPI.removeCluster = function (id) {
+  publicAPI.removeCluster = id => {
     model.clusters.splice(id, 1);
     publicAPI.modified();
   };
-
-  publicAPI.removeAllClusters = function () {
+  publicAPI.removeAllClusters = () => {
     model.clusters = [];
     publicAPI.modified();
   };
-
-  publicAPI.updateCluster = function (id, centerX, centerY, centerZ, fnConst, fnDfDx, fnDfDy, fnDfDz) {
+  publicAPI.updateCluster = (id, centerX, centerY, centerZ, fnConst, fnDfDx, fnDfDy, fnDfDz) => {
     if (!model.clusters[id]) {
       model.clusters[id] = new Float64Array(7);
     }
-
     model.clusters[id][0] = centerX;
     model.clusters[id][1] = centerY;
     model.clusters[id][2] = centerZ;
@@ -66,96 +58,94 @@ function vtkSLICSource(publicAPI, model) {
     model.clusters[id][6] = fnDfDz;
     publicAPI.modified();
   };
-
-  publicAPI.getNumberOfClusters = function () {
-    return model.clusters.length;
-  };
-
-  publicAPI.requestData = function (inData, outData) {
+  publicAPI.getNumberOfClusters = () => model.clusters.length;
+  publicAPI.requestData = (inData, outData) => {
     if (model.deleted) {
       return;
     }
-
-    var dataSize = model.dimensions[0] * model.dimensions[1] * model.dimensions[2];
-    var imageData = vtkImageData.newInstance();
-    imageData.setSpacing.apply(imageData, _toConsumableArray(model.spacing));
+    const dataSize = model.dimensions[0] * model.dimensions[1] * model.dimensions[2];
+    const imageData = vtkImageData.newInstance();
+    imageData.setSpacing(...model.spacing);
     imageData.setExtent(0, model.dimensions[0] - 1, 0, model.dimensions[1] - 1, 0, model.dimensions[2] - 1);
-    imageData.setOrigin.apply(imageData, _toConsumableArray(model.origin)); // Pixel centers
-
-    var centers = generateCoordinates(model.origin, model.dimensions, model.spacing); // Fill clusterIdxValues
-
-    var nbBytes = (model.clusters.length < 256 ? 8 : 0) || (model.clusters.length < 65536 ? 16 : 32);
-    var clusterIdxValues = macro.newTypedArray("Uint".concat(nbBytes, "Array"), dataSize);
-
-    var _loop = function _loop(i) {
-      var clusterDistance = Number.MAX_VALUE;
-      model.clusters.forEach(function (cluster, idx) {
-        var dist = (cluster[0] - centers[i * 3]) * (cluster[0] - centers[i * 3]) + (cluster[1] - centers[i * 3 + 1]) * (cluster[1] - centers[i * 3 + 1]) + (cluster[2] - centers[i * 3 + 2]) * (cluster[2] - centers[i * 3 + 2]);
-
+    imageData.setOrigin(...model.origin);
+
+    // Pixel centers
+    const centers = generateCoordinates(model.origin, model.dimensions, model.spacing);
+
+    // Fill clusterIdxValues
+    const nbBytes = (model.clusters.length < 256 ? 8 : 0) || (model.clusters.length < 65536 ? 16 : 32);
+    const clusterIdxValues = macro.newTypedArray(`Uint${nbBytes}Array`, dataSize);
+    for (let i = 0; i < dataSize; i++) {
+      let clusterDistance = Number.MAX_VALUE;
+      model.clusters.forEach((cluster, idx) => {
+        const dist = (cluster[0] - centers[i * 3]) * (cluster[0] - centers[i * 3]) + (cluster[1] - centers[i * 3 + 1]) * (cluster[1] - centers[i * 3 + 1]) + (cluster[2] - centers[i * 3 + 2]) * (cluster[2] - centers[i * 3 + 2]);
         if (dist < clusterDistance) {
           clusterDistance = dist;
           clusterIdxValues[i] = idx;
         }
       });
-    };
-
-    for (var i = 0; i < dataSize; i++) {
-      _loop(i);
     }
-
-    var clusters = vtkDataArray.newInstance({
+    const clusters = vtkDataArray.newInstance({
       name: model.clusterArrayName,
       numberOfComponents: 1,
       values: clusterIdxValues
     });
-    imageData.getPointData().addArray(clusters); // Fill scalarValues
+    imageData.getPointData().addArray(clusters);
 
-    var scalarValues = new Float32Array(dataSize);
-
-    for (var _i = 0; _i < dataSize; _i++) {
-      var cluster = model.clusters[clusterIdxValues[_i]];
-      scalarValues[_i] = cluster[3] + cluster[4] * (centers[_i * 3 + 0] - cluster[0]) + cluster[5] * (centers[_i * 3 + 1] - cluster[1]) + cluster[6] * (centers[_i * 3 + 2] - cluster[2]);
+    // Fill scalarValues
+    const scalarValues = new Float32Array(dataSize);
+    for (let i = 0; i < dataSize; i++) {
+      const cluster = model.clusters[clusterIdxValues[i]];
+      scalarValues[i] = cluster[3] + cluster[4] * (centers[i * 3 + 0] - cluster[0]) + cluster[5] * (centers[i * 3 + 1] - cluster[1]) + cluster[6] * (centers[i * 3 + 2] - cluster[2]);
     }
-
-    var scalars = vtkDataArray.newInstance({
+    const scalars = vtkDataArray.newInstance({
       name: model.scalarArrayName,
       numberOfComponents: 1,
       values: scalarValues
     });
-    imageData.getPointData().addArray(scalars); // Update output
+    imageData.getPointData().addArray(scalars);
 
+    // Update output
     outData[0] = imageData;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   clusters: [],
   spacing: [1.0, 1.0, 1.0],
   origin: [0.0, 0.0, 0.0],
   dimensions: [10, 10, 10],
   clusterArrayName: 'cluster',
   scalarArrayName: 'field'
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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
   macro.obj(publicAPI, model);
   macro.setGet(publicAPI, model, ['clusterArrayName', 'scalarArrayName']);
   macro.setGetArray(publicAPI, model, ['origin', 'spacing', 'dimensions'], 3);
   macro.algo(publicAPI, model, 0, 1);
   vtkSLICSource(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkSLICSource'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkSLICSource');
+
+// ----------------------------------------------------------------------------
 
 var vtkSLICSource$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkSLICSource$1 as default, extend, newInstance };

package/Filters/Sources/SphereSource.js

@@ -1,53 +1,58 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 
+// ----------------------------------------------------------------------------
 // vtkSphereSource methods
 // ----------------------------------------------------------------------------
 
 function vtkSphereSource(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkSphereSource');
-
-  publicAPI.requestData = function (inData, outData) {
+  publicAPI.requestData = (inData, outData) => {
     if (model.deleted) {
       return;
     }
-
-    var dataset = outData[0];
-    var pointDataType = dataset ? dataset.getPoints().getDataType() : model.pointType;
-    dataset = vtkPolyData.newInstance(); // ----------------------------------------------------------------------
-
-    var numPoles = 0; // Check data, determine increments, and convert to radians
-
-    var thetaResolution = model.thetaResolution;
-    var startTheta = model.startTheta < model.endTheta ? model.startTheta : model.endTheta;
+    let dataset = outData[0];
+    const pointDataType = dataset ? dataset.getPoints().getDataType() : model.pointType;
+    dataset = vtkPolyData.newInstance();
+
+    // ----------------------------------------------------------------------
+    let numPoles = 0;
+
+    // Check data, determine increments, and convert to radians
+    let {
+      thetaResolution
+    } = model;
+    let startTheta = model.startTheta < model.endTheta ? model.startTheta : model.endTheta;
     startTheta *= Math.PI / 180.0;
-    var endTheta = model.endTheta > model.startTheta ? model.endTheta : model.startTheta;
+    let endTheta = model.endTheta > model.startTheta ? model.endTheta : model.startTheta;
     endTheta *= Math.PI / 180.0;
-    var startPhi = model.startPhi < model.endPhi ? model.startPhi : model.endPhi;
+    let startPhi = model.startPhi < model.endPhi ? model.startPhi : model.endPhi;
     startPhi *= Math.PI / 180.0;
-    var endPhi = model.endPhi > model.startPhi ? model.endPhi : model.startPhi;
+    let endPhi = model.endPhi > model.startPhi ? model.endPhi : model.startPhi;
     endPhi *= Math.PI / 180.0;
-
     if (Math.abs(startTheta - endTheta) < 2.0 * Math.PI) {
       ++thetaResolution;
     }
+    const deltaTheta = (endTheta - startTheta) / model.thetaResolution;
+    const jStart = model.startPhi <= 0.0 ? 1 : 0;
+    const jEnd = model.phiResolution + (model.endPhi >= 180.0 ? -1 : 0);
+    const numPts = model.phiResolution * thetaResolution + 2;
+    const numPolys = model.phiResolution * 2 * model.thetaResolution;
 
-    var deltaTheta = (endTheta - startTheta) / model.thetaResolution;
-    var jStart = model.startPhi <= 0.0 ? 1 : 0;
-    var jEnd = model.phiResolution + (model.endPhi >= 180.0 ? -1 : 0);
-    var numPts = model.phiResolution * thetaResolution + 2;
-    var numPolys = model.phiResolution * 2 * model.thetaResolution; // Points
-
-    var pointIdx = 0;
-    var points = macro.newTypedArray(pointDataType, numPts * 3); // Normals
+    // Points
+    let pointIdx = 0;
+    let points = macro.newTypedArray(pointDataType, numPts * 3);
 
-    var normals = new Float32Array(numPts * 3); // Cells
+    // Normals
+    let normals = new Float32Array(numPts * 3);
 
-    var cellLocation = 0;
-    var polys = new Uint32Array(numPolys * 5); // Create north pole if needed
+    // Cells
+    let cellLocation = 0;
+    let polys = new Uint32Array(numPolys * 5);
 
+    // Create north pole if needed
     if (model.startPhi <= 0.0) {
       points[pointIdx * 3 + 0] = model.center[0];
       points[pointIdx * 3 + 1] = model.center[1];
@@ -57,9 +62,9 @@ function vtkSphereSource(publicAPI, model) {
       normals[pointIdx * 3 + 2] = 1;
       pointIdx++;
       numPoles++;
-    } // Create south pole if needed
-
+    }
 
+    // Create south pole if needed
     if (model.endPhi >= 180.0) {
       points[pointIdx * 3 + 0] = model.center[0];
       points[pointIdx * 3 + 1] = model.center[1];
@@ -70,67 +75,63 @@ function vtkSphereSource(publicAPI, model) {
       pointIdx++;
       numPoles++;
     }
-
-    var phiResolution = model.phiResolution - numPoles;
-    var deltaPhi = (endPhi - startPhi) / (model.phiResolution - 1); // Create intermediate points
-
-    for (var i = 0; i < thetaResolution; i++) {
-      var theta = startTheta + i * deltaTheta;
-
-      for (var j = jStart; j < jEnd; j++) {
-        var phi = startPhi + j * deltaPhi;
-        var radius = model.radius * Math.sin(phi);
+    const phiResolution = model.phiResolution - numPoles;
+    const deltaPhi = (endPhi - startPhi) / (model.phiResolution - 1);
+
+    // Create intermediate points
+    for (let i = 0; i < thetaResolution; i++) {
+      const theta = startTheta + i * deltaTheta;
+      for (let j = jStart; j < jEnd; j++) {
+        const phi = startPhi + j * deltaPhi;
+        const radius = model.radius * Math.sin(phi);
         normals[pointIdx * 3 + 0] = radius * Math.cos(theta);
         normals[pointIdx * 3 + 1] = radius * Math.sin(theta);
         normals[pointIdx * 3 + 2] = model.radius * Math.cos(phi);
         points[pointIdx * 3 + 0] = normals[pointIdx * 3 + 0] + model.center[0];
         points[pointIdx * 3 + 1] = normals[pointIdx * 3 + 1] + model.center[1];
         points[pointIdx * 3 + 2] = normals[pointIdx * 3 + 2] + model.center[2];
-        var norm = Math.sqrt(normals[pointIdx * 3 + 0] * normals[pointIdx * 3 + 0] + normals[pointIdx * 3 + 1] * normals[pointIdx * 3 + 1] + normals[pointIdx * 3 + 2] * normals[pointIdx * 3 + 2]);
+        let norm = Math.sqrt(normals[pointIdx * 3 + 0] * normals[pointIdx * 3 + 0] + normals[pointIdx * 3 + 1] * normals[pointIdx * 3 + 1] + normals[pointIdx * 3 + 2] * normals[pointIdx * 3 + 2]);
         norm = norm === 0 ? 1 : norm;
         normals[pointIdx * 3 + 0] /= norm;
         normals[pointIdx * 3 + 1] /= norm;
         normals[pointIdx * 3 + 2] /= norm;
         pointIdx++;
       }
-    } // Generate mesh connectivity
-
-
-    var base = phiResolution * thetaResolution;
+    }
 
+    // Generate mesh connectivity
+    const base = phiResolution * thetaResolution;
     if (Math.abs(startTheta - endTheta) < 2.0 * Math.PI) {
       --thetaResolution;
-    } // around north pole
-
+    }
 
+    // around north pole
     if (model.startPhi <= 0.0) {
-      for (var _i = 0; _i < thetaResolution; _i++) {
+      for (let i = 0; i < thetaResolution; i++) {
         polys[cellLocation++] = 3;
-        polys[cellLocation++] = phiResolution * _i + numPoles;
-        polys[cellLocation++] = phiResolution * (_i + 1) % base + numPoles;
+        polys[cellLocation++] = phiResolution * i + numPoles;
+        polys[cellLocation++] = phiResolution * (i + 1) % base + numPoles;
         polys[cellLocation++] = 0;
       }
-    } // around south pole
-
+    }
 
+    // around south pole
     if (model.endPhi >= 180.0) {
-      var numOffset = phiResolution - 1 + numPoles;
-
-      for (var _i2 = 0; _i2 < thetaResolution; _i2++) {
+      const numOffset = phiResolution - 1 + numPoles;
+      for (let i = 0; i < thetaResolution; i++) {
         polys[cellLocation++] = 3;
-        polys[cellLocation++] = phiResolution * _i2 + numOffset;
+        polys[cellLocation++] = phiResolution * i + numOffset;
         polys[cellLocation++] = numPoles - 1;
-        polys[cellLocation++] = phiResolution * (_i2 + 1) % base + numOffset;
+        polys[cellLocation++] = phiResolution * (i + 1) % base + numOffset;
       }
-    } // bands in-between poles
-
-
-    for (var _i3 = 0; _i3 < thetaResolution; _i3++) {
-      for (var _j = 0; _j < phiResolution - 1; _j++) {
-        var a = phiResolution * _i3 + _j + numPoles;
-        var b = a + 1;
-        var c = (phiResolution * (_i3 + 1) + _j) % base + numPoles + 1;
+    }
 
+    // bands in-between poles
+    for (let i = 0; i < thetaResolution; i++) {
+      for (let j = 0; j < phiResolution - 1; j++) {
+        const a = phiResolution * i + j + numPoles;
+        const b = a + 1;
+        const c = (phiResolution * (i + 1) + j) % base + numPoles + 1;
         if (!model.latLongTessellation) {
           polys[cellLocation++] = 3;
           polys[cellLocation++] = a;
@@ -148,29 +149,31 @@ function vtkSphereSource(publicAPI, model) {
           polys[cellLocation++] = c - 1;
         }
       }
-    } // Squeeze
-
+    }
 
+    // Squeeze
     points = points.subarray(0, pointIdx * 3);
     dataset.getPoints().setData(points, 3);
     normals = normals.subarray(0, pointIdx * 3);
-    var normalArray = vtkDataArray.newInstance({
+    const normalArray = vtkDataArray.newInstance({
       name: 'Normals',
       values: normals,
       numberOfComponents: 3
     });
     dataset.getPointData().setNormals(normalArray);
     polys = polys.subarray(0, cellLocation);
-    dataset.getPolys().setData(polys, 1); // Update output
+    dataset.getPolys().setData(polys, 1);
 
+    // Update output
     outData[0] = dataset;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   radius: 0.5,
   latLongTessellation: false,
   thetaResolution: 8,
@@ -181,24 +184,31 @@ var DEFAULT_VALUES = {
   endPhi: 180.0,
   center: [0, 0, 0],
   pointType: 'Float64Array'
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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
   macro.obj(publicAPI, model);
   macro.setGet(publicAPI, model, ['radius', 'latLongTessellation', 'thetaResolution', 'startTheta', 'endTheta', 'phiResolution', 'startPhi', 'endPhi']);
   macro.setGetArray(publicAPI, model, ['center'], 3);
   macro.algo(publicAPI, model, 0, 1);
   vtkSphereSource(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkSphereSource'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkSphereSource');
+
+// ----------------------------------------------------------------------------
 
 var vtkSphereSource$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkSphereSource$1 as default, extend, newInstance };

package/Filters/Sources/ViewFinderSource.js

@@ -1,14 +1,11 @@
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkMatrixBuilder from '../../Common/Core/MatrixBuilder.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 
 function vtkViewFinderSource(publicAPI, model) {
-  publicAPI.requestData = function (inData, outData) {
-    var _vtkMatrixBuilder$bui;
-
-    var dataset = vtkPolyData.newInstance();
-    var points = macro.newTypedArray(model.pointType, 3 * 16);
+  publicAPI.requestData = (inData, outData) => {
+    const dataset = vtkPolyData.newInstance();
+    const points = macro.newTypedArray(model.pointType, 3 * 16);
     points[0] = model.radius;
     points[1] = model.radius / model.width;
     points[2] = 0;
@@ -56,46 +53,52 @@ function vtkViewFinderSource(publicAPI, model) {
     points[44] = 0;
     points[45] = model.radius / model.width * -1;
     points[46] = (model.radius + model.spacing) * -1;
-    points[47] = 0; // prettier-ignore
-
-    var cells = Uint8Array.from([3, 0, 1, 2, 3, 2, 1, 3, 3, 4, 6, 5, 3, 6, 5, 7, 3, 8, 11, 9, 3, 8, 10, 11, 3, 12, 13, 15, 3, 12, 15, 14]);
-
-    (_vtkMatrixBuilder$bui = vtkMatrixBuilder.buildFromRadian()).translate.apply(_vtkMatrixBuilder$bui, _toConsumableArray(model.center)).rotateFromDirections([1, 0, 0], model.orientation).apply(points);
+    points[47] = 0;
 
+    // prettier-ignore
+    const cells = Uint8Array.from([3, 0, 1, 2, 3, 2, 1, 3, 3, 4, 6, 5, 3, 6, 5, 7, 3, 8, 11, 9, 3, 8, 10, 11, 3, 12, 13, 15, 3, 12, 15, 14]);
+    vtkMatrixBuilder.buildFromRadian().translate(...model.center).rotateFromDirections([1, 0, 0], model.orientation).apply(points);
     dataset.getPoints().setData(points, 3);
     dataset.getPolys().setData(cells, 1);
     outData[0] = dataset;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
-
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   radius: 1,
   spacing: 2,
   width: 4,
   pointType: 'Float64Array'
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   model.center = [0, 0, 0];
   model.orientation = [1, 0, 0];
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Build VTK API
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
+  // Build VTK API
   macro.obj(publicAPI, model);
   macro.setGet(publicAPI, model, ['radius', 'spacing', 'width']);
   macro.setGetArray(publicAPI, model, ['center', 'orientation'], 3);
   macro.algo(publicAPI, model, 0, 1);
   vtkViewFinderSource(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkArrow2DSource'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkArrow2DSource');
+
+// ----------------------------------------------------------------------------
 
 var vtkViewFinderSource$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkViewFinderSource$1 as default, extend, newInstance };

package/Filters/Sources.js

@@ -14,20 +14,20 @@ import vtkSLICSource from './Sources/SLICSource.js';
 import vtkSphereSource from './Sources/SphereSource.js';
 
 var Sources = {
-  vtkArrowSource: vtkArrowSource,
-  vtkCircleSource: vtkCircleSource,
-  vtkConcentricCylinderSource: vtkConcentricCylinderSource,
-  vtkConeSource: vtkConeSource,
-  vtkCubeSource: vtkCubeSource,
-  vtkCursor3D: vtkCursor3D,
-  vtkCylinderSource: vtkCylinderSource,
-  vtkImageGridSource: vtkImageGridSource,
-  vtkLineSource: vtkLineSource,
-  vtkPlaneSource: vtkPlaneSource,
-  vtkPointSource: vtkPointSource,
-  vtkRTAnalyticSource: vtkRTAnalyticSource,
-  vtkSLICSource: vtkSLICSource,
-  vtkSphereSource: vtkSphereSource
+  vtkArrowSource,
+  vtkCircleSource,
+  vtkConcentricCylinderSource,
+  vtkConeSource,
+  vtkCubeSource,
+  vtkCursor3D,
+  vtkCylinderSource,
+  vtkImageGridSource,
+  vtkLineSource,
+  vtkPlaneSource,
+  vtkPointSource,
+  vtkRTAnalyticSource,
+  vtkSLICSource,
+  vtkSphereSource
 };
 
 export { Sources as default };