@kitware/vtk.js 28.10.1 → 28.11.0

package/Common/Transform/LandmarkTransform.js

@@ -1,35 +1,33 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import { mat4, mat3 } from 'gl-matrix';
 import Constants from './LandmarkTransform/Constants.js';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import { p as jacobiN, q as perpendiculars } from '../Core/Math/index.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 {
+  Mode
+} = 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 Mode = Constants.Mode; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // vtkLandmarkTransform methods
 // ----------------------------------------------------------------------------
 
 function vtkLandmarkTransform(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkLandmarkTransform');
-
   function update() {
     mat4.identity(model.matrix);
-    var N_PTS = model.sourceLandmark.getNumberOfPoints();
-
+    const N_PTS = model.sourceLandmark.getNumberOfPoints();
     if (model.targetLandmark.getNumberOfPoints() !== N_PTS || model.sourceLandmark === null || model.targetLandmark === null || N_PTS === 0) {
       console.error('Error : Bad inputs of vtkLandmarkTransform');
       return model.matrix;
-    } // -- find the centroid of each set --
-
+    }
 
-    var sourceCentroid = [0, 0, 0];
-    var targetCentroid = [0, 0, 0];
-    var p = [0, 0, 0];
+    // -- find the centroid of each set --
 
-    for (var i = 0; i < N_PTS; i++) {
+    const sourceCentroid = [0, 0, 0];
+    const targetCentroid = [0, 0, 0];
+    const p = [0, 0, 0];
+    for (let i = 0; i < N_PTS; i++) {
       model.sourceLandmark.getPoint(i, p);
       sourceCentroid[0] += p[0];
       sourceCentroid[1] += p[1];
@@ -39,13 +37,14 @@ function vtkLandmarkTransform(publicAPI, model) {
       targetCentroid[1] += p[1];
       targetCentroid[2] += p[2];
     }
-
     sourceCentroid[0] /= N_PTS;
     sourceCentroid[1] /= N_PTS;
     sourceCentroid[2] /= N_PTS;
     targetCentroid[0] /= N_PTS;
     targetCentroid[1] /= N_PTS;
-    targetCentroid[2] /= N_PTS; // -- if only one point, stop right here
+    targetCentroid[2] /= N_PTS;
+
+    // -- if only one point, stop right here
 
     if (N_PTS === 1) {
       mat4.identity(model.matrix);
@@ -53,69 +52,73 @@ function vtkLandmarkTransform(publicAPI, model) {
       model.matrix[13] = targetCentroid[1] - sourceCentroid[1];
       model.matrix[14] = targetCentroid[2] - sourceCentroid[2];
       return model.matrix;
-    } // -- build the 3x3 matrix M --
-
+    }
 
-    var M = new Float64Array(9);
-    var AAT = new Float64Array(9);
-    var a = [0, 0, 0];
-    var b = [0, 0, 0];
-    var sa = 0.0;
-    var sb = 0.0;
+    // -- build the 3x3 matrix M --
 
-    for (var pt = 0; pt < N_PTS; pt++) {
+    const M = new Float64Array(9);
+    const AAT = new Float64Array(9);
+    const a = [0, 0, 0];
+    const b = [0, 0, 0];
+    let sa = 0.0;
+    let sb = 0.0;
+    for (let pt = 0; pt < N_PTS; pt++) {
       // get the origin-centred point (a) in the source set
       model.sourceLandmark.getPoint(pt, a);
       a[0] -= sourceCentroid[0];
       a[1] -= sourceCentroid[1];
-      a[2] -= sourceCentroid[2]; // get the origin-centred point (b) in the target set
+      a[2] -= sourceCentroid[2];
 
+      // get the origin-centred point (b) in the target set
       model.targetLandmark.getPoint(pt, b);
       b[0] -= targetCentroid[0];
       b[1] -= targetCentroid[1];
-      b[2] -= targetCentroid[2]; // accumulate the products a*T(b) into the matrix M
+      b[2] -= targetCentroid[2];
 
-      for (var _i = 0; _i < 3; _i++) {
-        M[3 * 0 + _i] += a[_i] * b[0];
-        M[3 * 1 + _i] += a[_i] * b[1];
-        M[3 * 2 + _i] += a[_i] * b[2]; // for the affine transform, compute ((a.a^t)^-1 . a.b^t)^t.
-        // a.b^t is already in M.  here we put a.a^t in AAT.
+      // accumulate the products a*T(b) into the matrix M
+      for (let i = 0; i < 3; i++) {
+        M[3 * 0 + i] += a[i] * b[0];
+        M[3 * 1 + i] += a[i] * b[1];
+        M[3 * 2 + i] += a[i] * b[2];
 
+        // for the affine transform, compute ((a.a^t)^-1 . a.b^t)^t.
+        // a.b^t is already in M.  here we put a.a^t in AAT.
         if (model.mode === Mode.AFFINE) {
-          AAT[3 * 0 + _i] += a[_i] * a[0];
-          AAT[3 * 1 + _i] += a[_i] * a[1];
-          AAT[3 * 2 + _i] += a[_i] * a[2];
+          AAT[3 * 0 + i] += a[i] * a[0];
+          AAT[3 * 1 + i] += a[i] * a[1];
+          AAT[3 * 2 + i] += a[i] * a[2];
         }
-      } // accumulate scale factors (if desired)
-
-
+      }
+      // accumulate scale factors (if desired)
       sa += a[0] * a[0] + a[1] * a[1] + a[2] * a[2];
       sb += b[0] * b[0] + b[1] * b[1] + b[2] * b[2];
     }
-
     if (model.mode === Mode.AFFINE) {
       // AAT = (a.a^t)^-1
-      mat3.invert(AAT, AAT); // M = (a.a^t)^-1 . a.b^t
+      mat3.invert(AAT, AAT);
 
-      mat3.multiply(M, AAT, M); // this->Matrix = M^t
+      // M = (a.a^t)^-1 . a.b^t
+      mat3.multiply(M, AAT, M);
 
-      for (var _i2 = 0; _i2 < 3; ++_i2) {
-        for (var j = 0; j < 3; ++j) {
-          model.matrix[4 * j + _i2] = M[4 * _i2 + j];
+      // this->Matrix = M^t
+      for (let i = 0; i < 3; ++i) {
+        for (let j = 0; j < 3; ++j) {
+          model.matrix[4 * j + i] = M[4 * i + j];
         }
       }
     } else {
-      var scale = Math.sqrt(sb / sa); // -- build the 4x4 matrix N --
+      const scale = Math.sqrt(sb / sa);
 
-      var N = new Float64Array(16); // on-diagonal elements
+      // -- build the 4x4 matrix N --
 
+      const N = new Float64Array(16);
+      // on-diagonal elements
       N[0] = M[0] + M[4] + M[8];
       N[5] = M[0] - M[4] - M[8];
       N[10] = -M[0] + M[4] - M[8];
-      N[15] = -M[0] - M[4] + M[8]; // off-diagonal elements
-
+      N[15] = -M[0] - M[4] + M[8];
+      // off-diagonal elements
       /* eslint-disable no-multi-assign */
-
       N[4] = N[1] = M[7] - M[5];
       N[8] = N[2] = M[2] - M[6];
       N[12] = N[3] = M[3] - M[1];
@@ -123,43 +126,43 @@ function vtkLandmarkTransform(publicAPI, model) {
       N[13] = N[7] = M[2] + M[6];
       N[14] = N[11] = M[7] + M[5];
       /* eslint-enable no-multi-assign */
+
       // -- eigen-decompose N (is symmetric) --
       // prettier-ignore
+      const eigenVectors = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0];
+      const eigenValues = [0.0, 0.0, 0.0, 0.0];
+      jacobiN(N, 4, eigenValues, eigenVectors);
 
-      var eigenVectors = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0];
-      var eigenValues = [0.0, 0.0, 0.0, 0.0];
-      jacobiN(N, 4, eigenValues, eigenVectors); // The eigenvector with the largest eigenvalue is the quaternion we want
+      // The eigenvector with the largest eigenvalue is the quaternion we want
       // (they are sorted in decreasing order for us by JacobiN)
+      let w;
+      let x;
+      let y;
+      let z;
 
-      var w;
-      var x;
-      var y;
-      var z; // first; if points are collinear, choose the quaternion that
+      // first; if points are collinear, choose the quaternion that
       // results in the smallest rotation
-
       if (eigenValues[0] === eigenValues[1] || N_PTS === 2) {
-        var s0 = [0, 0, 0];
-        var t0 = [0, 0, 0];
-        var s1 = [0, 0, 0];
-        var t1 = [0, 0, 0];
+        const s0 = [0, 0, 0];
+        const t0 = [0, 0, 0];
+        const s1 = [0, 0, 0];
+        const t1 = [0, 0, 0];
         model.sourceLandmark.getPoint(0, s0);
         model.targetLandmark.getPoint(0, t0);
         model.sourceLandmark.getPoint(1, s1);
         model.targetLandmark.getPoint(1, t1);
-        var ds = [0, 0, 0];
-        var dt = [0, 0, 0];
-        var rs = 0;
-        var rt = 0;
-
-        for (var _i3 = 0; _i3 < 3; _i3++) {
-          ds[_i3] = s1[_i3] - s0[_i3]; // vector between points
-
-          rs = ds[_i3] * ds[_i3] + rs;
-          dt[_i3] = t1[_i3] - t0[_i3];
-          rt = dt[_i3] * dt[_i3] + rt;
-        } // normalize the two vectors
-
+        const ds = [0, 0, 0];
+        const dt = [0, 0, 0];
+        let rs = 0;
+        let rt = 0;
+        for (let i = 0; i < 3; i++) {
+          ds[i] = s1[i] - s0[i]; // vector between points
+          rs = ds[i] * ds[i] + rs;
+          dt[i] = t1[i] - t0[i];
+          rt = dt[i] * dt[i] + rt;
+        }
 
+        // normalize the two vectors
         rs = Math.sqrt(rs);
         ds[0] /= rs;
         ds[1] /= rs;
@@ -167,17 +170,18 @@ function vtkLandmarkTransform(publicAPI, model) {
         rt = Math.sqrt(rt);
         dt[0] /= rt;
         dt[1] /= rt;
-        dt[2] /= rt; // take dot & cross product
+        dt[2] /= rt;
 
+        // take dot & cross product
         w = ds[0] * dt[0] + ds[1] * dt[1] + ds[2] * dt[2];
         x = ds[1] * dt[2] - ds[2] * dt[1];
         y = ds[2] * dt[0] - ds[0] * dt[2];
         z = ds[0] * dt[1] - ds[1] * dt[0];
-        var r = Math.sqrt(x * x + y * y + z * z);
-        var theta = Math.atan2(r, w); // construct quaternion
+        let r = Math.sqrt(x * x + y * y + z * z);
+        const theta = Math.atan2(r, w);
 
+        // construct quaternion
         w = Math.cos(theta / 2);
-
         if (r !== 0) {
           r = Math.sin(theta / 2) / r;
           x *= r;
@@ -198,19 +202,20 @@ function vtkLandmarkTransform(publicAPI, model) {
         x = eigenVectors[4];
         y = eigenVectors[8];
         z = eigenVectors[12];
-      } // convert quaternion to a rotation matrix
-
-
-      var ww = w * w;
-      var wx = w * x;
-      var wy = w * y;
-      var wz = w * z;
-      var xx = x * x;
-      var yy = y * y;
-      var zz = z * z;
-      var xy = x * y;
-      var xz = x * z;
-      var yz = y * z;
+      }
+
+      // convert quaternion to a rotation matrix
+
+      const ww = w * w;
+      const wx = w * x;
+      const wy = w * y;
+      const wz = w * z;
+      const xx = x * x;
+      const yy = y * y;
+      const zz = z * z;
+      const xy = x * y;
+      const xz = x * z;
+      const yz = y * z;
       model.matrix[0] = ww + xx - yy - zz;
       model.matrix[1] = 2.0 * (wz + xy);
       model.matrix[2] = 2.0 * (-wy + xz);
@@ -219,60 +224,71 @@ function vtkLandmarkTransform(publicAPI, model) {
       model.matrix[6] = 2.0 * (wx + yz);
       model.matrix[8] = 2.0 * (wy + xz);
       model.matrix[9] = 2.0 * (-wx + yz);
-      model.matrix[10] = ww - xx - yy + zz; // add in the scale factor (if desired)
+      model.matrix[10] = ww - xx - yy + zz;
 
+      // add in the scale factor (if desired)
       if (model.mode !== Mode.RIGID_BODY) {
-        for (var _i4 = 0; _i4 < 3; _i4++) {
-          model.matrix[4 * 0 + _i4] = model.matrix[4 * 0 + _i4] * scale;
-          model.matrix[4 * 1 + _i4] = model.matrix[4 * 1 + _i4] * scale;
-          model.matrix[4 * 2 + _i4] = model.matrix[4 * 2 + _i4] * scale;
+        for (let i = 0; i < 3; i++) {
+          model.matrix[4 * 0 + i] = model.matrix[4 * 0 + i] * scale;
+          model.matrix[4 * 1 + i] = model.matrix[4 * 1 + i] * scale;
+          model.matrix[4 * 2 + i] = model.matrix[4 * 2 + i] * scale;
         }
       }
-    } // the translation is given by the difference in the transformed source
-    // centroid and the target centroid
-
+    }
 
-    var sx = model.matrix[0] * sourceCentroid[0] + model.matrix[4] * sourceCentroid[1] + model.matrix[8] * sourceCentroid[2];
-    var sy = model.matrix[1] * sourceCentroid[0] + model.matrix[5] * sourceCentroid[1] + model.matrix[9] * sourceCentroid[2];
-    var sz = model.matrix[2] * sourceCentroid[0] + model.matrix[6] * sourceCentroid[1] + model.matrix[10] * sourceCentroid[2];
+    // the translation is given by the difference in the transformed source
+    // centroid and the target centroid
+    const sx = model.matrix[0] * sourceCentroid[0] + model.matrix[4] * sourceCentroid[1] + model.matrix[8] * sourceCentroid[2];
+    const sy = model.matrix[1] * sourceCentroid[0] + model.matrix[5] * sourceCentroid[1] + model.matrix[9] * sourceCentroid[2];
+    const sz = model.matrix[2] * sourceCentroid[0] + model.matrix[6] * sourceCentroid[1] + model.matrix[10] * sourceCentroid[2];
     model.matrix[12] = targetCentroid[0] - sx;
     model.matrix[13] = targetCentroid[1] - sy;
-    model.matrix[14] = targetCentroid[2] - sz; // fill the bottom row of the 4x4 matrix
+    model.matrix[14] = targetCentroid[2] - sz;
 
+    // fill the bottom row of the 4x4 matrix
     model.matrix[3] = 0.0;
     model.matrix[7] = 0.0;
     model.matrix[11] = 0.0;
     model.matrix[15] = 1.0;
     return model.matrix;
-  } // Expose method
-
+  }
 
+  // Expose method
   publicAPI.update = update;
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   mode: Mode.SIMILARITY
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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);
-  macro.obj(publicAPI, model); // Internal objects initialization
+  macro.obj(publicAPI, model);
 
+  // Internal objects initialization
   model.matrix = mat4.identity(new Float64Array(16));
   macro.setGet(publicAPI, model, ['sourceLandmark', 'targetLandmark', 'mode']);
   macro.get(publicAPI, model, ['matrix']);
   vtkLandmarkTransform(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = macro.newInstance(extend, 'vtkLandmarkTransform'); // ----------------------------------------------------------------------------
+const newInstance = macro.newInstance(extend, 'vtkLandmarkTransform');
+
+// ----------------------------------------------------------------------------
 
-var vtkLandmarkTransform$1 = _objectSpread({
-  newInstance: newInstance,
-  extend: extend
-}, Constants);
+var vtkLandmarkTransform$1 = {
+  newInstance,
+  extend,
+  ...Constants
+};
 
 export { vtkLandmarkTransform$1 as default, extend, newInstance };

package/Common/Transform/Transform.js

@@ -1,29 +1,24 @@
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import { IDENTITY } from '../Core/Math/Constants.js';
 import { vec3, mat4 } from 'gl-matrix';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import { f as vtkMath } from '../Core/Math/index.js';
 
+// ----------------------------------------------------------------------------
 // vtkTransform methods
 // ----------------------------------------------------------------------------
 // eslint-disable-next-line import/no-mutable-exports
-
-var newInstance;
-
+let newInstance;
 function vtkTransform(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkAbstractTransform', 'vtkHomogeneousTransform', 'vtkTransform');
-
-  publicAPI.transformPoint = function (point, out) {
+  publicAPI.transformPoint = (point, out) => {
     vec3.transformMat4(out, point, model.matrix);
     return out;
   };
-
-  publicAPI.transformPoints = function (points, out) {
-    var inPoint = new Float64Array(3);
-    var outPoint = new Float64Array(3);
-
-    for (var i = 0; i < points.length; i += 3) {
+  publicAPI.transformPoints = (points, out) => {
+    const inPoint = new Float64Array(3);
+    const outPoint = new Float64Array(3);
+    for (let i = 0; i < points.length; i += 3) {
       inPoint[0] = points[i];
       inPoint[1] = points[i + 1];
       inPoint[2] = points[i + 2];
@@ -32,98 +27,88 @@ function vtkTransform(publicAPI, model) {
       out[i + 1] = outPoint[1];
       out[i + 2] = outPoint[2];
     }
-
     return out;
   };
+
   /**
    * Sets the internal state of the transform to PreMultiply.
    * All subsequent operations will occur before those already represented in the current transformation.
    * In homogeneous matrix notation, M = M*A where M is the current transformation matrix and A is the applied matrix.
    * The default is PreMultiply.
    */
-
-
-  publicAPI.preMultiply = function () {
+  publicAPI.preMultiply = () => {
     publicAPI.setPreMultiplyFlag(true);
   };
+
   /**
    * Sets the internal state of the transform to PostMultiply.
    * All subsequent operations will occur after those already represented in the current transformation.
    * In homogeneous matrix notation, M = A*M where M is the current transformation matrix and A is the applied matrix.
    * The default is PreMultiply.
    */
-
-
-  publicAPI.postMultiply = function () {
+  publicAPI.postMultiply = () => {
     publicAPI.setPreMultiplyFlag(false);
   };
-
-  publicAPI.transformMatrix = function (matrix, out) {
+  publicAPI.transformMatrix = (matrix, out) => {
     if (model.preMultiplyFlag) {
       mat4.multiply(out, model.matrix, matrix);
     } else {
       mat4.multiply(out, matrix, model.matrix);
     }
-
     return out;
-  }; // Apply the transform to each matrix in the same way as transformMatrix
-  // `matrices` can be a contiguous array of float or an array of array
-
-
-  publicAPI.transformMatrices = function (matrices, out) {
-    var inMat = new Float64Array(16);
-    var outMat = new Float64Array(16);
-    var transform = model.preMultiplyFlag ? function () {
-      return mat4.multiply(outMat, model.matrix, inMat);
-    } : function () {
-      return mat4.multiply(outMat, inMat, model.matrix);
-    };
+  };
 
-    for (var i = 0; i < matrices.length; i += 16) {
-      for (var j = 0; j < 16; ++j) {
+  // Apply the transform to each matrix in the same way as transformMatrix
+  // `matrices` can be a contiguous array of float or an array of array
+  publicAPI.transformMatrices = (matrices, out) => {
+    const inMat = new Float64Array(16);
+    const outMat = new Float64Array(16);
+    const transform = model.preMultiplyFlag ? () => mat4.multiply(outMat, model.matrix, inMat) : () => mat4.multiply(outMat, inMat, model.matrix);
+    for (let i = 0; i < matrices.length; i += 16) {
+      for (let j = 0; j < 16; ++j) {
         inMat[j] = matrices[i + j];
       }
-
       transform();
-
-      for (var _j = 0; _j < 16; ++_j) {
-        out[i + _j] = outMat[_j];
+      for (let j = 0; j < 16; ++j) {
+        out[i + j] = outMat[j];
       }
     }
-
     return out;
   };
+  publicAPI.getInverse = () => newInstance({
+    matrix: vtkMath.invertMatrix(Array.from(model.matrix), [], 4),
+    preMultiplyFlag: model.preMultiplyFlag
+  });
+}
 
-  publicAPI.getInverse = function () {
-    return newInstance({
-      matrix: vtkMath.invertMatrix(Array.from(model.matrix), [], 4),
-      preMultiplyFlag: model.preMultiplyFlag
-    });
-  };
-} // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   preMultiplyFlag: false,
-  matrix: _toConsumableArray(IDENTITY)
-}; // ----------------------------------------------------------------------------
+  matrix: [...IDENTITY]
+};
+
+// ----------------------------------------------------------------------------
 
 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);
   macro.obj(publicAPI, model);
   macro.setGet(publicAPI, model, ['preMultiplyFlag']);
   macro.setGetArray(publicAPI, model, ['matrix'], 16);
   vtkTransform(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
+// ----------------------------------------------------------------------------
 newInstance = macro.newInstance(extend, 'vtkTransform');
 
+// ----------------------------------------------------------------------------
+
 var vtkTransform$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkTransform$1 as default, extend, newInstance };

package/Common/Transform.js

@@ -2,8 +2,8 @@ import vtkLandmarkTransform from './Transform/LandmarkTransform.js';
 import vtkTransform from './Transform/Transform.js';
 
 var Transform = {
-  vtkLandmarkTransform: vtkLandmarkTransform,
-  vtkTransform: vtkTransform
+  vtkLandmarkTransform,
+  vtkTransform
 };
 
 export { Transform as default };

package/Common/index.js

@@ -4,10 +4,10 @@ import Transform from './Transform.js';
 import System from './System.js';
 
 var Common = {
-  Core: Core,
-  DataModel: DataModel,
-  Transform: Transform,
-  System: System
+  Core,
+  DataModel,
+  Transform,
+  System
 };
 
 export { Common as default };