@kitware/vtk.js 28.10.2 → 28.11.1

package/Common/DataModel/Quad.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 vtkCell from './Cell.js';
 import { e as distance2BetweenPoints } from '../Core/Math/index.js';
 import { CellType } from './CellTypes/Constants.js';
@@ -15,65 +14,47 @@ function intersectionStruct() {
     t: -1
   };
 }
-
 function vtkQuad(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkQuad');
-
-  publicAPI.getCellDimension = function () {
-    return 2;
-  };
-
-  publicAPI.getCellType = function () {
-    return CellType.VTK_QUAD;
-  };
-
-  publicAPI.getNumberOfEdges = function () {
-    return 4;
-  };
-
-  publicAPI.getNumberOfFaces = function () {
-    return 0;
-  };
-
-  publicAPI.intersectWithLine = function (p1, p2, tol, x, pcoords) {
-    var _points, _points2, _points3, _points4, _points5, _points6, _points7, _points8, _points9, _points10, _points11, _points12;
-
-    var outObj = {
+  publicAPI.getCellDimension = () => 2;
+  publicAPI.getCellType = () => CellType.VTK_QUAD;
+  publicAPI.getNumberOfEdges = () => 4;
+  publicAPI.getNumberOfFaces = () => 0;
+  publicAPI.intersectWithLine = (p1, p2, tol, x, pcoords) => {
+    let outObj = {
       subId: 0,
       t: Number.MAX_VALUE,
       intersect: 0,
       betweenPoints: false
     };
-    var diagonalCase;
-    var point0 = model.points.getPoint(0, []);
-    var point1 = model.points.getPoint(1, []);
-    var point2 = model.points.getPoint(2, []);
-    var point3 = model.points.getPoint(3, []);
-    var d1 = distance2BetweenPoints(point0, point2);
-    var d2 = distance2BetweenPoints(point1, point3);
+    let diagonalCase;
+    const point0 = model.points.getPoint(0, []);
+    const point1 = model.points.getPoint(1, []);
+    const point2 = model.points.getPoint(2, []);
+    const point3 = model.points.getPoint(3, []);
+    const d1 = distance2BetweenPoints(point0, point2);
+    const d2 = distance2BetweenPoints(point1, point3);
+
     /* Figure out how to uniquely tessellate the quad. Watch out for
      * equivalent triangulations (i.e., the triangulation is equivalent
      * no matter where the diagonal). In this case use the point ids as
      * a tie breaker to ensure unique triangulation across the quad.
      */
-    // rare case; discriminate based on point id
 
+    // rare case; discriminate based on point id
     if (d1 === d2) {
       // find the maximum id
-      var id;
-      var maxId = 0;
-      var maxIdx = 0;
-
-      for (var i = 0; i < 4; i++) {
+      let id;
+      let maxId = 0;
+      let maxIdx = 0;
+      for (let i = 0; i < 4; i++) {
         id = model.pointsIds[i];
-
         if (id > maxId) {
           maxId = id;
           maxIdx = i;
         }
       }
-
       if (maxIdx === 0 || maxIdx === 2) {
         diagonalCase = 0;
       } else {
@@ -84,9 +65,7 @@ function vtkQuad(publicAPI, model) {
     } else {
       diagonalCase = 1;
     }
-
-    var points = null;
-
+    let points = null;
     if (!model.triangle) {
       model.triangle = vtkTriangle.newInstance();
       points = vtkPoints.newInstance();
@@ -95,34 +74,24 @@ function vtkQuad(publicAPI, model) {
     } else {
       points = model.triangle.getPoints();
     }
-
-    var firstIntersect;
-    var firstIntersectTmpObj = intersectionStruct();
-    var secondIntersect;
-    var secondIntersectTmpObj = intersectionStruct();
-    var useFirstIntersection;
-    var useSecondIntersection;
-
+    let firstIntersect;
+    const firstIntersectTmpObj = intersectionStruct();
+    let secondIntersect;
+    const secondIntersectTmpObj = intersectionStruct();
+    let useFirstIntersection;
+    let useSecondIntersection;
     switch (diagonalCase) {
       case 0:
-        (_points = points).setPoint.apply(_points, [0].concat(_toConsumableArray(point0)));
-
-        (_points2 = points).setPoint.apply(_points2, [1].concat(_toConsumableArray(point1)));
-
-        (_points3 = points).setPoint.apply(_points3, [2].concat(_toConsumableArray(point2)));
-
+        points.setPoint(0, ...point0);
+        points.setPoint(1, ...point1);
+        points.setPoint(2, ...point2);
         firstIntersect = model.triangle.intersectWithLine(p1, p2, tol, firstIntersectTmpObj.x, firstIntersectTmpObj.pCoords);
-
-        (_points4 = points).setPoint.apply(_points4, [0].concat(_toConsumableArray(point2)));
-
-        (_points5 = points).setPoint.apply(_points5, [1].concat(_toConsumableArray(point3)));
-
-        (_points6 = points).setPoint.apply(_points6, [2].concat(_toConsumableArray(point0)));
-
+        points.setPoint(0, ...point2);
+        points.setPoint(1, ...point3);
+        points.setPoint(2, ...point0);
         secondIntersect = model.triangle.intersectWithLine(p1, p2, tol, secondIntersectTmpObj.x, secondIntersectTmpObj.pCoords);
         useFirstIntersection = firstIntersect.intersect && secondIntersect.intersect ? firstIntersect.t <= secondIntersect.t : firstIntersect.intersect;
         useSecondIntersection = firstIntersect.intersect && secondIntersect.intersect ? secondIntersect.t < firstIntersect.t : secondIntersect.intersect;
-
         if (useFirstIntersection) {
           outObj = firstIntersect;
           x[0] = firstIntersectTmpObj.x[0];
@@ -140,28 +109,18 @@ function vtkQuad(publicAPI, model) {
           pcoords[1] = 1 - secondIntersectTmpObj.pCoords[1];
           pcoords[2] = secondIntersectTmpObj.pCoords[2];
         }
-
         break;
-
       case 1:
-        (_points7 = points).setPoint.apply(_points7, [0].concat(_toConsumableArray(point0)));
-
-        (_points8 = points).setPoint.apply(_points8, [1].concat(_toConsumableArray(point1)));
-
-        (_points9 = points).setPoint.apply(_points9, [2].concat(_toConsumableArray(point3)));
-
+        points.setPoint(0, ...point0);
+        points.setPoint(1, ...point1);
+        points.setPoint(2, ...point3);
         firstIntersect = model.triangle.intersectWithLine(p1, p2, tol, firstIntersectTmpObj.x, firstIntersectTmpObj.pCoords);
-
-        (_points10 = points).setPoint.apply(_points10, [0].concat(_toConsumableArray(point2)));
-
-        (_points11 = points).setPoint.apply(_points11, [1].concat(_toConsumableArray(point3)));
-
-        (_points12 = points).setPoint.apply(_points12, [2].concat(_toConsumableArray(point1)));
-
+        points.setPoint(0, ...point2);
+        points.setPoint(1, ...point3);
+        points.setPoint(2, ...point1);
         secondIntersect = model.triangle.intersectWithLine(p1, p2, tol, secondIntersectTmpObj.x, secondIntersectTmpObj.pCoords);
         useFirstIntersection = firstIntersect.intersect && secondIntersect.intersect ? firstIntersect.t <= secondIntersect.t : firstIntersect.intersect;
         useSecondIntersection = firstIntersect.intersect && secondIntersect.intersect ? secondIntersect.t < firstIntersect.t : secondIntersect.intersect;
-
         if (useFirstIntersection) {
           outObj = firstIntersect;
           x[0] = firstIntersectTmpObj.x[0];
@@ -179,57 +138,59 @@ function vtkQuad(publicAPI, model) {
           pcoords[1] = 1 - secondIntersectTmpObj.pCoords[1];
           pcoords[2] = secondIntersectTmpObj.pCoords[2];
         }
-
         break;
     }
-
     return outObj;
   };
-
-  publicAPI.interpolationFunctions = function (pcoords, weights) {
-    var rm = 1 - pcoords[0];
-    var sm = 1 - pcoords[1];
+  publicAPI.interpolationFunctions = (pcoords, weights) => {
+    const rm = 1 - pcoords[0];
+    const sm = 1 - pcoords[1];
     weights[0] = rm * sm;
     weights[1] = pcoords[0] * sm;
     weights[2] = pcoords[0] * pcoords[1];
     weights[3] = rm * pcoords[1];
   };
+  publicAPI.evaluateLocation = (pcoords, x, weights) => {
+    const point = [];
 
-  publicAPI.evaluateLocation = function (pcoords, x, weights) {
-    var point = []; // Calculate the weights
-
+    // Calculate the weights
     publicAPI.interpolationFunctions(pcoords, weights);
     x[0] = 0.0;
     x[1] = 0.0;
     x[2] = 0.0;
-
-    for (var i = 0; i < 4; i++) {
+    for (let i = 0; i < 4; i++) {
       model.points.getPoint(i, point);
-
-      for (var j = 0; j < 3; j++) {
+      for (let j = 0; j < 3; j++) {
         x[j] += point[j] * weights[i];
       }
     }
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
+const DEFAULT_VALUES = {};
 
-var DEFAULT_VALUES = {}; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 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);
   vtkCell.extend(publicAPI, model, initialValues);
   vtkQuad(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkQuad');
 
-var newInstance = macro.newInstance(extend, 'vtkQuad'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 var vtkQuad$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkQuad$1 as default, extend, newInstance };

package/Common/DataModel/SelectionNode/Constants.js

@@ -14,8 +14,9 @@
  * THRESHOLDS means the points and cells with values within a set of ranges
  * getContentType() returns -1 if the content type is not set.
  */
+
 // Specify how data arrays can be used by data objects
-var SelectionContent = {
+const SelectionContent = {
   GLOBALIDS: 0,
   PEDIGREEIDS: 1,
   VALUES: 2,
@@ -26,7 +27,7 @@ var SelectionContent = {
   BLOCKS: 7,
   QUERY: 8
 };
-var SelectionField = {
+const SelectionField = {
   CELL: 0,
   POINT: 1,
   FIELD: 2,
@@ -35,8 +36,8 @@ var SelectionField = {
   ROW: 5
 };
 var Constants = {
-  SelectionContent: SelectionContent,
-  SelectionField: SelectionField
+  SelectionContent,
+  SelectionField
 };
 
 export { SelectionContent, SelectionField, Constants as default };

package/Common/DataModel/SelectionNode.js

@@ -1,48 +1,52 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import Constants from './SelectionNode/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; }
+// ----------------------------------------------------------------------------
 // vtkSelectionNode methods
 // ----------------------------------------------------------------------------
 
 function vtkSelectionNode(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkSelectionNode');
+  publicAPI.getBounds = () => model.points.getBounds();
+}
 
-  publicAPI.getBounds = function () {
-    return model.points.getBounds();
-  };
-} // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   contentType: -1,
   fieldType: -1,
   properties: null,
   selectionList: []
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Inheritance
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
+  // Inheritance
   macro.obj(publicAPI, model);
   model.properties = {};
-  macro.setGet(publicAPI, model, ['contentType', 'fieldType', 'properties', 'selectionList']); // Object specific methods
+  macro.setGet(publicAPI, model, ['contentType', 'fieldType', 'properties', 'selectionList']);
 
+  // Object specific methods
   vtkSelectionNode(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = macro.newInstance(extend, 'vtkSelectionNode'); // ----------------------------------------------------------------------------
+const newInstance = macro.newInstance(extend, 'vtkSelectionNode');
+
+// ----------------------------------------------------------------------------
 
-var vtkSelectionNode$1 = _objectSpread({
-  newInstance: newInstance,
-  extend: extend
-}, Constants);
+var vtkSelectionNode$1 = {
+  newInstance,
+  extend,
+  ...Constants
+};
 
 export { vtkSelectionNode$1 as default, extend, newInstance };

package/Common/DataModel/Sphere.js

@@ -1,76 +1,81 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkBoundingBox from './BoundingBox.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 VTK_SMALL_NUMBER = 1e-12;
 
-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 VTK_SMALL_NUMBER = 1e-12; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // Global methods
 // ----------------------------------------------------------------------------
 
 function evaluate(radius, center, x) {
   return (x[0] - center[0]) * (x[0] - center[0]) + (x[1] - center[1]) * (x[1] - center[1]) + (x[2] - center[2]) * (x[2] - center[2]) - radius * radius;
 }
-
 function isPointIn3DEllipse(point, bounds) {
-  var center = vtkBoundingBox.getCenter(bounds);
-  var scale3 = vtkBoundingBox.computeScale3(bounds);
-  scale3 = scale3.map(function (x) {
-    return Math.max(Math.abs(x), VTK_SMALL_NUMBER);
-  });
-  var radius = [(point[0] - center[0]) / scale3[0], (point[1] - center[1]) / scale3[1], (point[2] - center[2]) / scale3[2]];
+  const center = vtkBoundingBox.getCenter(bounds);
+  let scale3 = vtkBoundingBox.computeScale3(bounds);
+  scale3 = scale3.map(x => Math.max(Math.abs(x), VTK_SMALL_NUMBER));
+  const radius = [(point[0] - center[0]) / scale3[0], (point[1] - center[1]) / scale3[1], (point[2] - center[2]) / scale3[2]];
   return radius[0] * radius[0] + radius[1] * radius[1] + radius[2] * radius[2] <= 1;
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Static API
 // ----------------------------------------------------------------------------
 
+const STATIC = {
+  evaluate,
+  isPointIn3DEllipse
+};
 
-var STATIC = {
-  evaluate: evaluate,
-  isPointIn3DEllipse: isPointIn3DEllipse
-}; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // vtkSphere methods
 // ----------------------------------------------------------------------------
 
 function vtkSphere(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkSphere');
-
-  publicAPI.evaluateFunction = function (xyz) {
-    var retVal = (xyz[0] - model.center[0]) * (xyz[0] - model.center[0]) + (xyz[1] - model.center[1]) * (xyz[1] - model.center[1]) + (xyz[2] - model.center[2]) * (xyz[2] - model.center[2]) - model.radius * model.radius;
+  publicAPI.evaluateFunction = xyz => {
+    const retVal = (xyz[0] - model.center[0]) * (xyz[0] - model.center[0]) + (xyz[1] - model.center[1]) * (xyz[1] - model.center[1]) + (xyz[2] - model.center[2]) * (xyz[2] - model.center[2]) - model.radius * model.radius;
     return retVal;
   };
-
-  publicAPI.evaluateGradient = function (xyz) {
-    var retVal = [2.0 - (xyz[0] - model.center[0]), 2.0 - (xyz[1] - model.center[1]), 2.0 - (xyz[2] - model.center[2])];
+  publicAPI.evaluateGradient = xyz => {
+    const retVal = [2.0 - (xyz[0] - model.center[0]), 2.0 - (xyz[1] - model.center[1]), 2.0 - (xyz[2] - model.center[2])];
     return retVal;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   radius: 0.5,
   center: [0.0, 0.0, 0.0]
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Object methods
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
+  // Object methods
   macro.obj(publicAPI, model);
   macro.setGet(publicAPI, model, ['radius']);
   macro.setGetArray(publicAPI, model, ['center'], 3);
   vtkSphere(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkSphere'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkSphere');
+
+// ----------------------------------------------------------------------------
 
-var vtkSphere$1 = _objectSpread({
-  newInstance: newInstance,
-  extend: extend
-}, STATIC);
+var vtkSphere$1 = {
+  newInstance,
+  extend,
+  ...STATIC
+};
 
 export { STATIC, vtkSphere$1 as default, extend, newInstance };

package/Common/DataModel/Spline1D/Constants.js

@@ -4,14 +4,15 @@
 // SECOND_DERIVATIVE : second derivative at boundary point is the boundary value given.
 // SECOND_DERIVATIVE_INTERIOR_POINT : desired second derivative at boundary point is the boundary value given times second derivative
 // at first interior point.
-var BoundaryCondition = {
+
+const BoundaryCondition = {
   DEFAULT: 0,
   DERIVATIVE: 1,
   SECOND_DERIVATIVE: 2,
   SECOND_DERIVATIVE_INTERIOR_POINT: 3
 };
 var Constants = {
-  BoundaryCondition: BoundaryCondition
+  BoundaryCondition
 };
 
 export { BoundaryCondition, Constants as default };

package/Common/DataModel/Spline1D.js

@@ -1,46 +1,62 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 
-var vtkErrorMacro = macro.vtkErrorMacro; // ----------------------------------------------------------------------------
+const {
+  vtkErrorMacro
+} = macro;
+
+// ----------------------------------------------------------------------------
 // vtkSpline1D methods
 // ----------------------------------------------------------------------------
 
 function vtkSpline1D(publicAPI, model) {
   // Set our classname
-  model.classHierarchy.push('vtkSpline1D'); // --------------------------------------------------------------------------
+  model.classHierarchy.push('vtkSpline1D');
+
+  // --------------------------------------------------------------------------
 
-  publicAPI.computeCloseCoefficients = function (size, work, x, y) {
-    vtkErrorMacro("".concat(model.classHierarchy.slice(-1)[0], " should implement computeCloseCoefficients"));
-  }; // --------------------------------------------------------------------------
+  publicAPI.computeCloseCoefficients = (size, work, x, y) => {
+    vtkErrorMacro(`${model.classHierarchy.slice(-1)[0]} should implement computeCloseCoefficients`);
+  };
 
+  // --------------------------------------------------------------------------
 
   publicAPI.computeOpenCoefficients = function (size, work, x, y) {
-    vtkErrorMacro("".concat(model.classHierarchy.slice(-1)[0], " should implement computeOpenCoefficients"));
-  }; // --------------------------------------------------------------------------
+    vtkErrorMacro(`${model.classHierarchy.slice(-1)[0]} should implement computeOpenCoefficients`);
+  };
 
+  // --------------------------------------------------------------------------
 
-  publicAPI.getValue = function (intervalIndex, t) {
-    vtkErrorMacro("".concat(model.classHierarchy.slice(-1)[0], " should implement getValue"));
+  publicAPI.getValue = (intervalIndex, t) => {
+    vtkErrorMacro(`${model.classHierarchy.slice(-1)[0]} should implement getValue`);
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
+const DEFAULT_VALUES = {};
 
-var DEFAULT_VALUES = {}; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 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);
   vtkSpline1D(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkSpline1D');
 
-var newInstance = macro.newInstance(extend, 'vtkSpline1D'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 var vtkSpline1D$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkSpline1D$1 as default, extend, newInstance };

package/Common/DataModel/Spline3D/Constants.js

@@ -1,9 +1,9 @@
-var splineKind = {
+const splineKind = {
   CARDINAL_SPLINE: 'CARDINAL_SPLINE',
   KOCHANEK_SPLINE: 'KOCHANEK_SPLINE'
 };
 var Constants = {
-  splineKind: splineKind
+  splineKind
 };
 
 export { Constants as default, splineKind };