@kitware/vtk.js 28.10.2 → 28.11.0

package/Common/DataModel/KochanekSpline1D.js

@@ -1,65 +1,63 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkSpline1D from './Spline1D.js';
 import { BoundaryCondition } from './Spline1D/Constants.js';
 
-var VTK_EPSILON = 0.0001; // ----------------------------------------------------------------------------
+const VTK_EPSILON = 0.0001;
+
+// ----------------------------------------------------------------------------
 // vtkKochanekSpline1D methods
 // ----------------------------------------------------------------------------
 
 function vtkKochanekSpline1D(publicAPI, model) {
   // Set our classname
-  model.classHierarchy.push('vtkKochanekSpline1D'); // --------------------------------------------------------------------------
+  model.classHierarchy.push('vtkKochanekSpline1D');
+
+  // --------------------------------------------------------------------------
 
-  publicAPI.computeCloseCoefficients = function (size, work, x, y) {
+  publicAPI.computeCloseCoefficients = (size, work, x, y) => {
     if (!model.coefficients || model.coefficients.length !== 4 * size) {
       model.coefficients = new Float32Array(4 * size);
     }
-
-    var N = size - 1;
-
-    for (var i = 1; i < N; i++) {
-      var _cs = y[i] - y[i - 1];
-
-      var _cd = y[i + 1] - y[i];
-
-      var _ds = _cs * ((1 - model.tension) * (1 - model.continuity) * (1 + model.bias)) + _cd * ((1 - model.tension) * (1 + model.continuity) * (1 - model.bias));
-
-      var _dd = _cs * ((1 - model.tension) * (1 + model.continuity) * (1 + model.bias)) + _cd * ((1 - model.tension) * (1 - model.continuity) * (1 - model.bias)); // adjust deriviatives for non uniform spacing between nodes
-
-
-      var _n = x[i + 1] - x[i];
-
-      var _n2 = x[i] - x[i - 1];
-
-      _ds *= _n2 / (_n2 + _n);
-      _dd *= _n / (_n2 + _n);
+    const N = size - 1;
+    for (let i = 1; i < N; i++) {
+      const cs = y[i] - y[i - 1];
+      const cd = y[i + 1] - y[i];
+      let ds = cs * ((1 - model.tension) * (1 - model.continuity) * (1 + model.bias)) + cd * ((1 - model.tension) * (1 + model.continuity) * (1 - model.bias));
+      let dd = cs * ((1 - model.tension) * (1 + model.continuity) * (1 + model.bias)) + cd * ((1 - model.tension) * (1 - model.continuity) * (1 - model.bias));
+
+      // adjust deriviatives for non uniform spacing between nodes
+      const n1 = x[i + 1] - x[i];
+      const n0 = x[i] - x[i - 1];
+      ds *= n0 / (n0 + n1);
+      dd *= n1 / (n0 + n1);
       model.coefficients[4 * i + 0] = y[i];
-      model.coefficients[4 * i + 1] = _dd;
-      model.coefficients[4 * i + 2] = _ds;
-    } // Calculate the deriviatives at the end points
-
+      model.coefficients[4 * i + 1] = dd;
+      model.coefficients[4 * i + 2] = ds;
+    }
 
+    // Calculate the deriviatives at the end points
     model.coefficients[4 * 0 + 0] = y[0];
     model.coefficients[4 * N + 0] = y[N];
     model.coefficients[4 * N + 1] = 0;
     model.coefficients[4 * N + 2] = 0;
-    model.coefficients[4 * N + 3] = 0; // The curve is continuous and closed at P0=Pn
+    model.coefficients[4 * N + 3] = 0;
 
-    var cs = y[N] - y[N - 1];
-    var cd = y[1] - y[0];
-    var ds = cs * ((1 - model.tension) * (1 - model.continuity) * (1 + model.bias)) + cd * ((1 - model.tension) * (1 + model.continuity) * (1 - model.bias));
-    var dd = cs * ((1 - model.tension) * (1 + model.continuity) * (1 + model.bias)) + cd * ((1 - model.tension) * (1 - model.continuity) * (1 - model.bias)); // adjust deriviatives for non uniform spacing between nodes
+    // The curve is continuous and closed at P0=Pn
+    const cs = y[N] - y[N - 1];
+    const cd = y[1] - y[0];
+    let ds = cs * ((1 - model.tension) * (1 - model.continuity) * (1 + model.bias)) + cd * ((1 - model.tension) * (1 + model.continuity) * (1 - model.bias));
+    let dd = cs * ((1 - model.tension) * (1 + model.continuity) * (1 + model.bias)) + cd * ((1 - model.tension) * (1 - model.continuity) * (1 - model.bias));
 
-    var n1 = x[1] - x[0];
-    var n0 = x[N] - x[N - 1];
+    // adjust deriviatives for non uniform spacing between nodes
+    const n1 = x[1] - x[0];
+    const n0 = x[N] - x[N - 1];
     ds *= n0 / (n0 + n1);
     dd *= n1 / (n0 + n1);
     model.coefficients[4 * 0 + 1] = dd;
     model.coefficients[4 * 0 + 2] = ds;
     model.coefficients[4 * N + 1] = dd;
     model.coefficients[4 * N + 2] = ds;
-
-    for (var _i = 0; _i < N; _i++) {
+    for (let i = 0; i < N; i++) {
       //
       // c0    = P ;    c1    = DD ;
       //   i      i       i       i
@@ -73,50 +71,48 @@ function vtkKochanekSpline1D(publicAPI, model) {
       // c3  =  2P  - 2P    +  DD  + DS   ;
       //   i      i     i+1      i     i+1
       //
-      model.coefficients[4 * _i + 2] = -3 * y[_i] + 3 * y[_i + 1] + -2 * model.coefficients[4 * _i + 1] + -1 * model.coefficients[4 * (_i + 1) + 2];
-      model.coefficients[4 * _i + 3] = 2 * y[_i] + -2 * y[_i + 1] + 1 * model.coefficients[4 * _i + 1] + 1 * model.coefficients[4 * (_i + 1) + 2];
+      model.coefficients[4 * i + 2] = -3 * y[i] + 3 * y[i + 1] + -2 * model.coefficients[4 * i + 1] + -1 * model.coefficients[4 * (i + 1) + 2];
+      model.coefficients[4 * i + 3] = 2 * y[i] + -2 * y[i + 1] + 1 * model.coefficients[4 * i + 1] + 1 * model.coefficients[4 * (i + 1) + 2];
     }
-  }; // --------------------------------------------------------------------------
+  };
 
+  // --------------------------------------------------------------------------
 
   publicAPI.computeOpenCoefficients = function (size, work, x, y) {
-    var options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
-
+    let options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
     if (!model.coefficients || model.coefficients.length !== 4 * size) {
       model.coefficients = new Float32Array(4 * size);
     }
-
-    var N = size - 1;
-
-    for (var i = 1; i < N; i++) {
-      var cs = y[i] - y[i - 1];
-      var cd = y[i + 1] - y[i];
-      var ds = cs * ((1 - model.tension) * (1 - model.continuity) * (1 + model.bias)) + cd * ((1 - model.tension) * (1 + model.continuity) * (1 - model.bias));
-      var dd = cs * ((1 - model.tension) * (1 + model.continuity) * (1 + model.bias)) + cd * ((1 - model.tension) * (1 - model.continuity) * (1 - model.bias)); // adjust deriviatives for non uniform spacing between nodes
-
-      var n1 = x[i + 1] - x[i];
-      var n0 = x[i] - x[i - 1];
+    const N = size - 1;
+    for (let i = 1; i < N; i++) {
+      const cs = y[i] - y[i - 1];
+      const cd = y[i + 1] - y[i];
+      let ds = cs * ((1 - model.tension) * (1 - model.continuity) * (1 + model.bias)) + cd * ((1 - model.tension) * (1 + model.continuity) * (1 - model.bias));
+      let dd = cs * ((1 - model.tension) * (1 + model.continuity) * (1 + model.bias)) + cd * ((1 - model.tension) * (1 - model.continuity) * (1 - model.bias));
+
+      // adjust deriviatives for non uniform spacing between nodes
+      const n1 = x[i + 1] - x[i];
+      const n0 = x[i] - x[i - 1];
       ds *= n0 / (n0 + n1);
       dd *= n1 / (n0 + n1);
       model.coefficients[4 * i + 0] = y[i];
       model.coefficients[4 * i + 1] = dd;
       model.coefficients[4 * i + 2] = ds;
     }
-
     model.coefficients[4 * 0 + 0] = y[0];
-    model.coefficients[4 * N + 0] = y[N]; // Calculate the deriviatives at the end points
+    model.coefficients[4 * N + 0] = y[N];
+
+    // Calculate the deriviatives at the end points
 
     switch (options.leftConstraint) {
       // desired slope at leftmost point is leftValue
       case BoundaryCondition.DERIVATIVE:
         model.coefficients[4 * 0 + 1] = options.leftValue;
         break;
-
       case BoundaryCondition.SECOND_DERIVATIVE:
         // desired second derivative at leftmost point is leftValue
         model.coefficients[4 * 0 + 1] = (6 * (y[1] - y[0]) - 2 * model.coefficients[4 * 1 + 2] - options.leftValue) / 4;
         break;
-
       case BoundaryCondition.SECOND_DERIVATIVE_INTERIOR_POINT:
         // desired second derivative at leftmost point is leftValue
         // times second derivative at first interior point
@@ -125,27 +121,22 @@ function vtkKochanekSpline1D(publicAPI, model) {
         } else {
           model.coefficients[4 * 0 + 1] = 0.0;
         }
-
         break;
-
       case BoundaryCondition.DEFAULT:
       default:
         // desired slope at leftmost point is derivative from two points
         model.coefficients[4 * 0 + 1] = y[2] - y[0];
         break;
     }
-
     switch (options.rightConstraint) {
       case BoundaryCondition.DERIVATIVE:
         // desired slope at rightmost point is leftValue
         model.coefficients[4 * N + 2] = options.leftValue;
         break;
-
       case BoundaryCondition.SECOND_DERIVATIVE:
         // desired second derivative at rightmost point is leftValue
         model.coefficients[4 * N + 2] = (6 * (y[N] - y[N - 1]) - 2 * model.coefficients[4 * (N - 1) + 1] + options.leftValue) / 4.0;
         break;
-
       case BoundaryCondition.SECOND_DERIVATIVE_INTERIOR_POINT:
         // desired second derivative at rightmost point is leftValue
         // times second derivative at last interior point
@@ -154,17 +145,14 @@ function vtkKochanekSpline1D(publicAPI, model) {
         } else {
           model.coefficients[4 * N + 2] = 0.0;
         }
-
         break;
-
       case BoundaryCondition.DEFAULT:
       default:
         // desired slope at rightmost point is rightValue
         model.coefficients[4 * N + 2] = y[N] - y[N - 2];
         break;
     }
-
-    for (var _i2 = 0; _i2 < N; _i2++) {
+    for (let i = 0; i < N; i++) {
       //
       // c0    = P ;    c1    = DD ;
       //   i      i       i       i
@@ -178,42 +166,51 @@ function vtkKochanekSpline1D(publicAPI, model) {
       // c3  =  2P  - 2P    +  DD  + DS   ;
       //   i      i     i+1      i     i+1
       //
-      model.coefficients[4 * _i2 + 2] = -3 * y[_i2] + 3 * y[_i2 + 1] + -2 * model.coefficients[4 * _i2 + 1] + -1 * model.coefficients[4 * (_i2 + 1) + 2];
-      model.coefficients[4 * _i2 + 3] = 2 * y[_i2] + -2 * y[_i2 + 1] + 1 * model.coefficients[4 * _i2 + 1] + 1 * model.coefficients[4 * (_i2 + 1) + 2];
+      model.coefficients[4 * i + 2] = -3 * y[i] + 3 * y[i + 1] + -2 * model.coefficients[4 * i + 1] + -1 * model.coefficients[4 * (i + 1) + 2];
+      model.coefficients[4 * i + 3] = 2 * y[i] + -2 * y[i + 1] + 1 * model.coefficients[4 * i + 1] + 1 * model.coefficients[4 * (i + 1) + 2];
     }
-  }; // --------------------------------------------------------------------------
+  };
 
+  // --------------------------------------------------------------------------
 
-  publicAPI.getValue = function (intervalIndex, t) {
-    var t2 = t * t;
-    var t3 = t * t * t;
+  publicAPI.getValue = (intervalIndex, t) => {
+    const t2 = t * t;
+    const t3 = t * t * t;
     return model.coefficients[4 * intervalIndex + 3] * t3 + model.coefficients[4 * intervalIndex + 2] * t2 + model.coefficients[4 * intervalIndex + 1] * t + model.coefficients[4 * intervalIndex + 0];
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   tension: 0,
   bias: 0,
   continuity: 0
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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);
-  vtkSpline1D.extend(publicAPI, model, initialValues); // Build VTK API
+  vtkSpline1D.extend(publicAPI, model, initialValues);
 
+  // Build VTK API
   macro.obj(publicAPI, model);
   vtkKochanekSpline1D(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkKochanekSpline1D');
 
-var newInstance = macro.newInstance(extend, 'vtkKochanekSpline1D'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 var vtkKochanekSpline1D$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkKochanekSpline1D$1 as default, extend, newInstance };

package/Common/DataModel/Line/Constants.js

@@ -1,10 +1,10 @@
-var IntersectionState = {
+const IntersectionState = {
   NO_INTERSECTION: 0,
   YES_INTERSECTION: 1,
   ON_LINE: 2
 };
 var Constants = {
-  IntersectionState: IntersectionState
+  IntersectionState
 };
 
 export { IntersectionState, Constants as default };

package/Common/DataModel/Line.js

@@ -1,43 +1,41 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import Constants from './Line/Constants.js';
 import vtkCell from './Cell.js';
 import { d as dot, e as distance2BetweenPoints, s as subtract, g as solveLinearSystem } from '../Core/Math/index.js';
 import { quat } from 'gl-matrix';
 
-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 {
+  IntersectionState
+} = Constants;
 
-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 IntersectionState = Constants.IntersectionState; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // Global methods
 // ----------------------------------------------------------------------------
-
 function distanceToLine(x, p1, p2) {
-  var closestPoint = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
-  var outObj = {
+  let closestPoint = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
+  const outObj = {
     t: Number.MIN_VALUE,
     distance: 0
   };
-  var p21 = [];
-  var closest; // Determine appropriate vector
-
+  const p21 = [];
+  let closest;
+  // Determine appropriate vector
   p21[0] = p2[0] - p1[0];
   p21[1] = p2[1] - p1[1];
-  p21[2] = p2[2] - p1[2]; // Get parametric location
-
-  var num = p21[0] * (x[0] - p1[0]) + p21[1] * (x[1] - p1[1]) + p21[2] * (x[2] - p1[2]);
-  var denom = dot(p21, p21); // trying to avoid an expensive fabs
+  p21[2] = p2[2] - p1[2];
 
-  var tolerance = 1e-5 * num;
+  // Get parametric location
+  const num = p21[0] * (x[0] - p1[0]) + p21[1] * (x[1] - p1[1]) + p21[2] * (x[2] - p1[2]);
+  const denom = dot(p21, p21);
 
+  // trying to avoid an expensive fabs
+  let tolerance = 1e-5 * num;
   if (denom !== 0.0) {
     outObj.t = num / denom;
   }
-
   if (tolerance < 0.0) {
     tolerance = -tolerance;
   }
-
   if (-tolerance < denom && denom < tolerance) {
     closest = p1;
   } else if (denom <= 0.0 || outObj.t < 0.0) {
@@ -52,92 +50,84 @@ function distanceToLine(x, p1, p2) {
     p21[1] = p1[1] + outObj.t * p21[1];
     p21[2] = p1[2] + outObj.t * p21[2];
   }
-
   if (closestPoint) {
     closestPoint[0] = closest[0];
     closestPoint[1] = closest[1];
     closestPoint[2] = closest[2];
   }
-
   outObj.distance = distance2BetweenPoints(closest, x);
   return outObj;
 }
-
 function intersection(a1, a2, b1, b2, u, v) {
-  var a21 = [];
-  var b21 = [];
-  var b1a1 = [];
+  const a21 = [];
+  const b21 = [];
+  const b1a1 = [];
   u[0] = 0.0;
-  v[0] = 0.0; // Determine line vectors.
+  v[0] = 0.0;
 
+  // Determine line vectors.
   subtract(a2, a1, a21);
   subtract(b2, b1, b21);
-  subtract(b1, a1, b1a1); // Compute the system (least squares) matrix.
+  subtract(b1, a1, b1a1);
 
-  var A = [dot(a21, a21), -dot(a21, b21), -dot(a21, b21), dot(b21, b21)]; // Compute the least squares system constant term.
+  // Compute the system (least squares) matrix.
+  const A = [dot(a21, a21), -dot(a21, b21), -dot(a21, b21), dot(b21, b21)];
 
-  var c = [];
+  // Compute the least squares system constant term.
+  const c = [];
   c[0] = dot(a21, b1a1);
-  c[1] = -dot(b21, b1a1); // Solve the system of equations
-
+  c[1] = -dot(b21, b1a1);
+  // Solve the system of equations
   if (solveLinearSystem(A, c, 2) === 0) {
     // The lines are colinear. Therefore, one of the four endpoints is the
     // point of closest approach
-    var minDist = Number.MAX_VALUE;
-    var p = [a1, a2, b1, b2];
-    var l1 = [b1, b1, a1, a1];
-    var l2 = [b2, b2, a2, a2];
-    var uv1 = [v[0], v[0], u[0], u[0]];
-    var uv2 = [u[0], u[0], v[0], v[0]];
-    var obj;
-
-    for (var i = 0; i < 4; i++) {
+    let minDist = Number.MAX_VALUE;
+    const p = [a1, a2, b1, b2];
+    const l1 = [b1, b1, a1, a1];
+    const l2 = [b2, b2, a2, a2];
+    [v[0], v[0], u[0], u[0]];
+    [u[0], u[0], v[0], v[0]];
+    let obj;
+    for (let i = 0; i < 4; i++) {
       obj = distanceToLine(p[i], l1[i], l2[i]);
-
       if (obj.distance < minDist) {
         minDist = obj.distance;
-        uv1[i] = obj.t;
-        uv2[i] = i % 2;
       }
     }
-
     return IntersectionState.ON_LINE;
   }
-
   u[0] = c[0];
-  v[0] = c[1]; // Check parametric coordinates for intersection.
+  v[0] = c[1];
 
+  // Check parametric coordinates for intersection.
   if (u[0] >= 0.0 && u[0] <= 1.0 && v[0] >= 0.0 && v[0] <= 1.0) {
     return IntersectionState.YES_INTERSECTION;
   }
-
   return IntersectionState.NO_INTERSECTION;
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Static API
 // ----------------------------------------------------------------------------
 
+const STATIC = {
+  distanceToLine,
+  intersection
+};
 
-var STATIC = {
-  distanceToLine: distanceToLine,
-  intersection: intersection
-}; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // vtkLine methods
 // ----------------------------------------------------------------------------
 
 function vtkLine(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkLine');
-
   function isBetweenPoints(t) {
     return t >= 0.0 && t <= 1.0;
   }
-
-  publicAPI.getCellDimension = function () {
-    return 1;
-  };
-
-  publicAPI.intersectWithLine = function (p1, p2, tol, x, pcoords) {
-    var outObj = {
+  publicAPI.getCellDimension = () => 1;
+  publicAPI.intersectWithLine = (p1, p2, tol, x, pcoords) => {
+    const outObj = {
       intersect: 0,
       t: Number.MAX_VALUE,
       subId: 0,
@@ -145,138 +135,125 @@ function vtkLine(publicAPI, model) {
     };
     pcoords[1] = 0.0;
     pcoords[2] = 0.0;
-    var projXYZ = [];
-    var a1 = [];
-    var a2 = [];
+    const projXYZ = [];
+    const a1 = [];
+    const a2 = [];
     model.points.getPoint(0, a1);
     model.points.getPoint(1, a2);
-    var u = [];
-    var v = [];
-    var intersect = intersection(p1, p2, a1, a2, u, v);
+    const u = [];
+    const v = [];
+    const intersect = intersection(p1, p2, a1, a2, u, v);
     outObj.t = u[0];
     outObj.betweenPoints = isBetweenPoints(outObj.t);
     pcoords[0] = v[0];
-
     if (intersect === IntersectionState.YES_INTERSECTION) {
       // make sure we are within tolerance
-      for (var i = 0; i < 3; i++) {
+      for (let i = 0; i < 3; i++) {
         x[i] = a1[i] + pcoords[0] * (a2[i] - a1[i]);
         projXYZ[i] = p1[i] + outObj.t * (p2[i] - p1[i]);
       }
-
       if (distance2BetweenPoints(x, projXYZ) <= tol * tol) {
         outObj.intersect = 1;
         return outObj;
       }
     } else {
-      var outDistance; // check to see if it lies within tolerance
+      let outDistance;
+      // check to see if it lies within tolerance
       // one of the parametric coords must be outside 0-1
-
       if (outObj.t < 0.0) {
         outDistance = distanceToLine(p1, a1, a2, x);
-
         if (outDistance.distance <= tol * tol) {
           outObj.t = 0.0;
           outObj.intersect = 1;
           outObj.betweenPoints = true; // Intersection is near p1
-
           return outObj;
         }
-
         return outObj;
       }
-
       if (outObj.t > 1.0) {
         outDistance = distanceToLine(p2, a1, a2, x);
-
         if (outDistance.distance <= tol * tol) {
           outObj.t = 1.0;
           outObj.intersect = 1;
           outObj.betweenPoints = true; // Intersection is near p2
-
           return outObj;
         }
-
         return outObj;
       }
-
       if (pcoords[0] < 0.0) {
         pcoords[0] = 0.0;
         outDistance = distanceToLine(a1, p1, p2, x);
         outObj.t = outDistance.t;
-
         if (outDistance.distance <= tol * tol) {
           outObj.intersect = 1;
           return outObj;
         }
-
         return outObj;
       }
-
       if (pcoords[0] > 1.0) {
         pcoords[0] = 1.0;
         outDistance = distanceToLine(a2, p1, p2, x);
         outObj.t = outDistance.t;
-
         if (outDistance.distance <= tol * tol) {
           outObj.intersect = 1;
           return outObj;
         }
-
         return outObj;
       }
     }
-
     return outObj;
   };
-
-  publicAPI.evaluateLocation = function (pcoords, x, weights) {
-    var a1 = [];
-    var a2 = [];
+  publicAPI.evaluateLocation = (pcoords, x, weights) => {
+    const a1 = [];
+    const a2 = [];
     model.points.getPoint(0, a1);
     model.points.getPoint(1, a2);
-
-    for (var i = 0; i < 3; i++) {
+    for (let i = 0; i < 3; i++) {
       x[i] = a1[i] + pcoords[0] * (a2[i] - a1[i]);
     }
-
     weights[0] = 1.0 - pcoords[0];
     weights[1] = pcoords[0];
   };
-
-  publicAPI.evaluateOrientation = function (pcoords, q, weights) {
+  publicAPI.evaluateOrientation = (pcoords, q, weights) => {
     if (model.orientations) {
       quat.slerp(q, model.orientations[0], model.orientations[1], pcoords[0]);
       weights[0] = 1.0 - pcoords[0];
       weights[1] = pcoords[0];
       return true;
     }
-
     return false;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   orientations: null // an array of two quat or null
+};
 
-}; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 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);
   macro.setGet(publicAPI, model, ['orientations']);
   vtkLine(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkLine');
 
-var newInstance = macro.newInstance(extend, 'vtkLine'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
-var vtkLine$1 = _objectSpread(_objectSpread({
-  newInstance: newInstance,
-  extend: extend
-}, STATIC), Constants);
+var vtkLine$1 = {
+  newInstance,
+  extend,
+  ...STATIC,
+  ...Constants
+};
 
 export { STATIC, vtkLine$1 as default, extend, newInstance };