@kitware/vtk.js 28.10.2 → 28.11.0

package/Filters/Sources/PlaneSource.js

@@ -1,73 +1,76 @@
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import { mat4, vec3 } from 'gl-matrix';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 import { s as subtract, l as normalize, d as dot, j as cross, r as radiansFromDegrees } from '../../Common/Core/Math/index.js';
 import vtkMatrixBuilder from '../../Common/Core/MatrixBuilder.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 
-var vtkWarningMacro = macro.vtkWarningMacro;
-var EPSILON = 1e-6; // ----------------------------------------------------------------------------
+const {
+  vtkWarningMacro
+} = macro;
+const EPSILON = 1e-6;
+
+// ----------------------------------------------------------------------------
 // vtkPlaneSource methods
 // ----------------------------------------------------------------------------
 
 function vtkPlaneSource(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkPlaneSource');
-
-  publicAPI.requestData = function (inData, outData) {
+  publicAPI.requestData = (inData, outData) => {
     if (model.deleted) {
       return;
     }
+    const dataset = outData[0];
 
-    var dataset = outData[0]; // Check input
-
-    var pointDataType = dataset ? dataset.getPoints().getDataType() : model.pointType;
-    var pd = vtkPolyData.newInstance();
-    var v10 = [];
-    var v20 = [];
+    // Check input
+    const pointDataType = dataset ? dataset.getPoints().getDataType() : model.pointType;
+    const pd = vtkPolyData.newInstance();
+    const v10 = [];
+    const v20 = [];
     subtract(model.point1, model.origin, v10);
     subtract(model.point2, model.origin, v20);
-
     if (!publicAPI.updatePlane(v10, v20)) {
       vtkWarningMacro('Bad plane definition');
       return;
-    } // hand create a plane with special scalars
-
+    }
 
-    var xres = model.xResolution;
-    var yres = model.yResolution;
-    var numPts = (xres + 1) * (yres + 1);
-    var numPolys = xres * yres; // Points
+    // hand create a plane with special scalars
+    const xres = model.xResolution;
+    const yres = model.yResolution;
+    const numPts = (xres + 1) * (yres + 1);
+    const numPolys = xres * yres;
 
-    var points = macro.newTypedArray(pointDataType, numPts * 3);
-    pd.getPoints().setData(points, 3); // Cells
+    // Points
+    const points = macro.newTypedArray(pointDataType, numPts * 3);
+    pd.getPoints().setData(points, 3);
 
-    var polys = new Uint32Array(5 * numPolys);
-    pd.getPolys().setData(polys, 1); // Normals
+    // Cells
+    const polys = new Uint32Array(5 * numPolys);
+    pd.getPolys().setData(polys, 1);
 
-    var normalsData = new Float32Array(numPts * 3);
-    var normals = vtkDataArray.newInstance({
+    // Normals
+    const normalsData = new Float32Array(numPts * 3);
+    const normals = vtkDataArray.newInstance({
       numberOfComponents: 3,
       values: normalsData,
       name: 'Normals'
     });
-    pd.getPointData().setNormals(normals); // Texture coords
+    pd.getPointData().setNormals(normals);
 
-    var tcData = new Float32Array(numPts * 2);
-    var tcoords = vtkDataArray.newInstance({
+    // Texture coords
+    const tcData = new Float32Array(numPts * 2);
+    const tcoords = vtkDataArray.newInstance({
       numberOfComponents: 2,
       values: tcData,
       name: 'TextureCoordinates'
     });
     pd.getPointData().setTCoords(tcoords);
-    var tc = new Float32Array(2);
-    var idx = 0;
-
-    for (var j = 0; j < yres + 1; j++) {
+    const tc = new Float32Array(2);
+    let idx = 0;
+    for (let j = 0; j < yres + 1; j++) {
       tc[1] = j / yres;
-
-      for (var i = 0; i < xres + 1; i++) {
+      for (let i = 0; i < xres + 1; i++) {
         tc[0] = i / xres;
         points[idx * 3] = model.origin[0] + tc[0] * v10[0] + tc[1] * v20[0];
         points[idx * 3 + 1] = model.origin[1] + tc[0] * v10[1] + tc[1] * v20[1];
@@ -79,41 +82,36 @@ function vtkPlaneSource(publicAPI, model) {
         normalsData[idx * 3 + 2] = model.normal[2];
         idx++;
       }
-    } // Generate polygon connectivity
-    //
-
+    }
 
+    // Generate polygon connectivity
+    //
     idx = 0;
-
-    for (var _j = 0; _j < yres; _j++) {
-      for (var _i = 0; _i < xres; _i++) {
+    for (let j = 0; j < yres; j++) {
+      for (let i = 0; i < xres; i++) {
         polys[idx * 5 + 0] = 4;
-        polys[idx * 5 + 1] = _i + _j * (xres + 1);
+        polys[idx * 5 + 1] = i + j * (xres + 1);
         polys[idx * 5 + 2] = polys[idx * 5 + 1] + 1;
         polys[idx * 5 + 3] = polys[idx * 5 + 1] + xres + 2;
         polys[idx * 5 + 4] = polys[idx * 5 + 1] + xres + 1;
         idx++;
       }
-    } // Update output
-
+    }
 
+    // Update output
     outData[0] = pd;
   };
-
   publicAPI.setNormal = function () {
-    var n = [];
-
+    let n = [];
     if (arguments.length === 1 || Array.isArray(arguments.length <= 0 ? undefined : arguments[0])) {
-      n = _toConsumableArray(arguments.length <= 0 ? undefined : arguments[0]);
+      n = [...(arguments.length <= 0 ? undefined : arguments[0])];
     } else if (arguments.length === 3) {
       n = [arguments.length <= 0 ? undefined : arguments[0], arguments.length <= 1 ? undefined : arguments[1], arguments.length <= 2 ? undefined : arguments[2]];
     }
-
     if (normalize(n) !== 0) {
-      var dp = dot(model.normal, n);
-      var theta = 0;
-      var rotationVector = [];
-
+      const dp = dot(model.normal, n);
+      let theta = 0;
+      const rotationVector = [];
       if (dp < 1.0) {
         if (dp <= -1.0) {
           theta = radiansFromDegrees(180.0);
@@ -122,26 +120,23 @@ function vtkPlaneSource(publicAPI, model) {
           cross(model.normal, n, rotationVector);
           theta = Math.acos(dp);
         }
-
         publicAPI.rotate(theta, rotationVector);
       }
     }
   };
+
   /**
    * Rotate plane around a given axis
    * @param {float} theta Angle (radian) to rotate about
    * @param {vec3} rotationAxis Axis to rotate around
    */
-
-
-  publicAPI.rotate = function (angle, rotationAxis) {
+  publicAPI.rotate = (angle, rotationAxis) => {
     if (Math.abs(angle) < EPSILON) {
       return;
-    } // Create rotation matrix
-
-
-    var transform = mat4.identity(new Float64Array(16));
-    var negCenter = [];
+    }
+    // Create rotation matrix
+    const transform = mat4.identity(new Float64Array(16));
+    const negCenter = [];
     vec3.negate(negCenter, model.center);
     mat4.translate(transform, transform, model.center);
     mat4.rotate(transform, transform, angle, rotationAxis);
@@ -152,105 +147,99 @@ function vtkPlaneSource(publicAPI, model) {
     vtkMatrixBuilder.buildFromRadian().rotate(angle, rotationAxis).apply(model.normal);
     publicAPI.modified();
   };
-
   publicAPI.setCenter = function () {
-    var c = [];
-
+    let c = [];
     if (arguments.length === 1 || Array.isArray(arguments.length <= 0 ? undefined : arguments[0])) {
-      c = _toConsumableArray(arguments.length <= 0 ? undefined : arguments[0]);
+      c = [...(arguments.length <= 0 ? undefined : arguments[0])];
     } else if (arguments.length === 3) {
       c = [arguments.length <= 0 ? undefined : arguments[0], arguments.length <= 1 ? undefined : arguments[1], arguments.length <= 2 ? undefined : arguments[2]];
     }
-
     if (!vec3.exactEquals(c, model.center)) {
-      var v1 = [];
+      const v1 = [];
       subtract(model.point1, model.origin, v1);
-      var v2 = [];
+      const v2 = [];
       subtract(model.point2, model.origin, v2);
-
-      for (var i = 0; i < 3; i++) {
+      for (let i = 0; i < 3; i++) {
         model.center[i] = c[i];
         model.origin[i] = model.center[i] - 0.5 * (v1[i] + v2[i]);
         model.point1[i] = model.origin[i] + v1[i];
         model.point2[i] = model.origin[i] + v2[i];
       }
-
       publicAPI.modified();
     }
   };
-
   publicAPI.setPoint1 = function () {
-    var point1 = [];
-
+    let point1 = [];
     if (arguments.length === 1 || Array.isArray(arguments.length <= 0 ? undefined : arguments[0])) {
-      point1 = _toConsumableArray(arguments.length <= 0 ? undefined : arguments[0]);
+      point1 = [...(arguments.length <= 0 ? undefined : arguments[0])];
     } else if (arguments.length === 3) {
       point1 = [arguments.length <= 0 ? undefined : arguments[0], arguments.length <= 1 ? undefined : arguments[1], arguments.length <= 2 ? undefined : arguments[2]];
     }
-
     if (!vec3.exactEquals(point1, model.point1)) {
-      var v1 = [];
-      var v2 = [];
-      model.point1 = _toConsumableArray(point1);
+      const v1 = [];
+      const v2 = [];
+      model.point1 = [...point1];
       subtract(model.point1, model.origin, v1);
-      subtract(model.point2, model.origin, v2); // set plane normal
+      subtract(model.point2, model.origin, v2);
 
+      // set plane normal
       publicAPI.updatePlane(v1, v2);
       publicAPI.modified();
     }
   };
-
   publicAPI.setPoint2 = function () {
-    var point2 = [];
-
+    let point2 = [];
     if (arguments.length === 1 || Array.isArray(arguments.length <= 0 ? undefined : arguments[0])) {
-      point2 = _toConsumableArray(arguments.length <= 0 ? undefined : arguments[0]);
+      point2 = [...(arguments.length <= 0 ? undefined : arguments[0])];
     } else if (arguments.length === 3) {
       point2 = [arguments.length <= 0 ? undefined : arguments[0], arguments.length <= 1 ? undefined : arguments[1], arguments.length <= 2 ? undefined : arguments[2]];
     }
-
     if (!vec3.exactEquals(point2, model.point2)) {
-      var v1 = [];
-      var v2 = [];
-      model.point2 = _toConsumableArray(point2);
+      const v1 = [];
+      const v2 = [];
+      model.point2 = [...point2];
       subtract(model.point1, model.origin, v1);
-      subtract(model.point2, model.origin, v2); // set plane normal
+      subtract(model.point2, model.origin, v2);
 
+      // set plane normal
       publicAPI.updatePlane(v1, v2);
       publicAPI.modified();
     }
   };
-
-  publicAPI.updatePlane = function (v1, v2) {
+  publicAPI.updatePlane = (v1, v2) => {
     // set plane center
-    for (var i = 0; i < 3; i++) {
+    for (let i = 0; i < 3; i++) {
       model.center[i] = model.origin[i] + 0.5 * (v1[i] + v2[i]);
-    } // set plane normal
-
+    }
 
+    // set plane normal
     cross(v1, v2, model.normal);
     return normalize(model.normal) !== 0.0;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   xResolution: 10,
   yResolution: 10,
   origin: [0, 0, 0],
   point1: [1, 0, 0],
   point2: [0, 1, 0],
   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] : {};
   Object.assign(model, DEFAULT_VALUES, initialValues);
   model.normal = [0, 0, 1];
-  model.center = [0, 0, 0]; // Build VTK API
+  model.center = [0, 0, 0];
 
+  // Build VTK API
   macro.obj(publicAPI, model);
   macro.setGet(publicAPI, model, ['xResolution', 'yResolution']);
   macro.setGetArray(publicAPI, model, ['origin'], 3);
@@ -259,13 +248,17 @@ function extend(publicAPI, model) {
   vtkPlaneSource(publicAPI, model);
   publicAPI.setPoint1(model.point1);
   publicAPI.setPoint2(model.point2);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkPlaneSource');
 
-var newInstance = macro.newInstance(extend, 'vtkPlaneSource'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 var vtkPlaneSource$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkPlaneSource$1 as default, extend, newInstance };

package/Filters/Sources/PointSource.js

@@ -1,87 +1,96 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import { x as random } from '../../Common/Core/Math/index.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 
+// ----------------------------------------------------------------------------
 // vtkPointSource methods
 // ----------------------------------------------------------------------------
 
 function vtkPointSource(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkPointSource');
-
-  publicAPI.requestData = function (inData, outData) {
+  publicAPI.requestData = (inData, outData) => {
     if (model.deleted) {
       return;
     }
+    const dataset = outData[0];
 
-    var dataset = outData[0]; // Check input
-
-    var pointDataType = dataset ? dataset.getPoints().getDataType() : model.pointType;
-    var pd = vtkPolyData.newInstance(); // hand create a point cloud
+    // Check input
+    const pointDataType = dataset ? dataset.getPoints().getDataType() : model.pointType;
+    const pd = vtkPolyData.newInstance();
 
-    var numPts = model.numberOfPoints; // Points
+    // hand create a point cloud
+    const numPts = model.numberOfPoints;
 
-    var points = macro.newTypedArray(pointDataType, numPts * 3);
-    pd.getPoints().setData(points, 3); // Cells
+    // Points
+    const points = macro.newTypedArray(pointDataType, numPts * 3);
+    pd.getPoints().setData(points, 3);
 
-    var verts = new Uint32Array(numPts + 1);
+    // Cells
+    const verts = new Uint32Array(numPts + 1);
     pd.getVerts().setData(verts, 1);
-    var cosphi;
-    var sinphi;
-    var rho;
-    var radius;
-    var theta;
-
-    for (var i = 0; i < numPts; i++) {
+    let cosphi;
+    let sinphi;
+    let rho;
+    let radius;
+    let theta;
+    for (let i = 0; i < numPts; i++) {
       cosphi = 1 - 2.0 * random();
       sinphi = Math.sqrt(1 - cosphi * cosphi);
-      rho = model.radius * Math.pow(random(), 0.33333333);
+      rho = model.radius * random() ** 0.33333333;
       radius = rho * sinphi;
       theta = 2.0 * Math.PI * random();
       points[i * 3] = model.center[0] + radius * Math.cos(theta);
       points[i * 3 + 1] = model.center[1] + radius * Math.sin(theta);
       points[i * 3 + 2] = model.center[2] + rho * cosphi;
-    } // Generate point connectivity
-    //
-
+    }
 
+    // Generate point connectivity
+    //
     verts[0] = numPts;
+    for (let i = 0; i < numPts; i++) {
+      verts[i + 1] = i;
+    }
 
-    for (var _i = 0; _i < numPts; _i++) {
-      verts[_i + 1] = _i;
-    } // Update output
-
-
+    // Update output
     outData[0] = pd;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   numberOfPoints: 10,
   center: [0, 0, 0],
   radius: 0.5,
   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, ['numberOfPoints', 'radius']);
   macro.setGetArray(publicAPI, model, ['center'], 3);
   macro.algo(publicAPI, model, 0, 1);
   vtkPointSource(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = macro.newInstance(extend, 'vtkPointSource'); // ----------------------------------------------------------------------------
+const newInstance = macro.newInstance(extend, 'vtkPointSource');
+
+// ----------------------------------------------------------------------------
 
 var vtkPointSource$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkPointSource$1 as default, extend, newInstance };

package/Filters/Sources/RTAnalyticSource.js

@@ -1,84 +1,79 @@
-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';
 
-function vtkRTAnalyticSource(publicAPI, model) {
-  var _this = this;
+// ----------------------------------------------------------------------------
 
+function vtkRTAnalyticSource(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkRTAnalyticSource');
-
-  publicAPI.requestData = function (inData, outData) {
+  publicAPI.requestData = (inData, outData) => {
     if (model.deleted) {
       return;
     }
-
-    var state = {};
-    var dataset = {
+    const state = {};
+    const dataset = {
       type: 'vtkImageData',
       mtime: model.mtime,
       metadata: {
         source: 'vtkRTAnalyticSource',
-        state: state
+        state
       }
-    }; // Add parameter used to create dataset as metadata.state[*]
+    };
 
-    ['standardDeviation', 'center', 'frequency', 'magnitude', 'maximum'].forEach(function (field) {
+    // Add parameter used to create dataset as metadata.state[*]
+    ['standardDeviation', 'center', 'frequency', 'magnitude', 'maximum'].forEach(field => {
       state[field] = [].concat(model[field]);
     });
-    var id = vtkImageData.newInstance(dataset);
+    const id = vtkImageData.newInstance(dataset);
     id.setSpacing(1.0, 1.0, 1.0);
-    id.setExtent.apply(_this, model.wholeExtent);
+    id.setExtent.apply(this, model.wholeExtent);
     id.setOrigin(0.0, 0.0, 0.0);
     id.setDirection(model.dataDirection);
-    var dims = [0, 0, 0];
-    dims = dims.map(function (_, i) {
-      return model.wholeExtent[i * 2 + 1] - model.wholeExtent[i * 2] + 1;
-    });
-    var newArray = new Uint8Array(dims[0] * dims[1] * dims[2]);
-    var temp2 = 1.0 / (2.0 * model.standardDeviation * model.standardDeviation);
-    var xval = 0;
-    var yval = 0;
-    var zval = 0;
-    var scale = [1.0 / (model.wholeExtent[1] - model.wholeExtent[0]), 1.0 / (model.wholeExtent[3] - model.wholeExtent[2]), 1.0 / (model.wholeExtent[5] - model.wholeExtent[4])];
-    var i = 0;
-
-    for (var z = model.wholeExtent[4]; z <= model.wholeExtent[5]; z++) {
+    let dims = [0, 0, 0];
+    dims = dims.map((_, i) => model.wholeExtent[i * 2 + 1] - model.wholeExtent[i * 2] + 1);
+    const newArray = new Uint8Array(dims[0] * dims[1] * dims[2]);
+    const temp2 = 1.0 / (2.0 * model.standardDeviation * model.standardDeviation);
+    let xval = 0;
+    let yval = 0;
+    let zval = 0;
+    const scale = [1.0 / (model.wholeExtent[1] - model.wholeExtent[0]), 1.0 / (model.wholeExtent[3] - model.wholeExtent[2]), 1.0 / (model.wholeExtent[5] - model.wholeExtent[4])];
+    let i = 0;
+    for (let z = model.wholeExtent[4]; z <= model.wholeExtent[5]; z++) {
       zval = (model.center[2] - z) * scale[2];
-      var zfactor = model.magnitude[2] * Math.cos(model.frequency[2] * zval);
+      const zfactor = model.magnitude[2] * Math.cos(model.frequency[2] * zval);
       zval *= zval;
-
-      for (var y = model.wholeExtent[2]; y <= model.wholeExtent[3]; y++) {
+      for (let y = model.wholeExtent[2]; y <= model.wholeExtent[3]; y++) {
         yval = (model.center[1] - y) * scale[1];
-        var yfactor = model.magnitude[1] * Math.sin(model.frequency[1] * yval);
+        const yfactor = model.magnitude[1] * Math.sin(model.frequency[1] * yval);
         yval *= yval;
-
-        for (var x = model.wholeExtent[0]; x <= model.wholeExtent[1]; x++) {
+        for (let x = model.wholeExtent[0]; x <= model.wholeExtent[1]; x++) {
           xval = (model.center[0] - x) * scale[0];
-          var sum = zval + yval + xval * xval;
-          var xfactor = model.magnitude[0] * Math.sin(model.frequency[0] * xval);
+          const sum = zval + yval + xval * xval;
+          const xfactor = model.magnitude[0] * Math.sin(model.frequency[0] * xval);
           newArray[i] = model.maximum * Math.exp(-sum * temp2) + xfactor + yfactor + zfactor + model.offset;
           i++;
         }
       }
     }
-
-    var da = vtkDataArray.newInstance({
+    const da = vtkDataArray.newInstance({
       numberOfComponents: 1,
       values: newArray
     });
     da.setName('scalars');
-    var cpd = id.getPointData();
-    cpd.setScalars(da); // Update output
+    const cpd = id.getPointData();
+    cpd.setScalars(da);
 
+    // Update output
     outData[0] = id;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   offset: 40,
   maximum: 120,
   center: [0, 0, 0],
@@ -87,12 +82,15 @@ var DEFAULT_VALUES = {
   standardDeviation: 0.5,
   wholeExtent: [-10, 10, -10, 10, -10, 10],
   dataDirection: [1, 0, 0, 0, 1, 0, 0, 0, 1]
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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, ['offset', 'maximum', 'standardDeviation']);
   macro.setGetArray(publicAPI, model, ['center', 'frequency', 'magnitude'], 3);
@@ -100,13 +98,17 @@ function extend(publicAPI, model) {
   macro.setGetArray(publicAPI, model, ['dataDirection'], 9);
   macro.algo(publicAPI, model, 0, 1);
   vtkRTAnalyticSource(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = macro.newInstance(extend, 'vtkRTAnalyticSource'); // ----------------------------------------------------------------------------
+const newInstance = macro.newInstance(extend, 'vtkRTAnalyticSource');
+
+// ----------------------------------------------------------------------------
 
 var vtkRTAnalyticSource$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkRTAnalyticSource$1 as default, extend, newInstance };