@kitware/vtk.js 28.10.1 → 28.11.0

package/Rendering/Core/Coordinate/Constants.js

@@ -1,4 +1,4 @@
-var Coordinate = {
+const Coordinate = {
   DISPLAY: 0,
   NORMALIZED_DISPLAY: 1,
   VIEWPORT: 2,
@@ -8,7 +8,7 @@ var Coordinate = {
   WORLD: 6
 };
 var Constants = {
-  Coordinate: Coordinate
+  Coordinate
 };
 
 export { Coordinate, Constants as default };

package/Rendering/Core/Coordinate.js

@@ -1,184 +1,151 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import Constants from './Coordinate/Constants.js';
-import { L as round, K as floor } from '../../Common/Core/Math/index.js';
+import { L as round, G as floor } from '../../Common/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 {
+  Coordinate
+} = Constants;
+const {
+  vtkErrorMacro
+} = macro;
 
-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 Coordinate = Constants.Coordinate;
-var vtkErrorMacro = macro.vtkErrorMacro; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // vtkActor methods
 // ----------------------------------------------------------------------------
 
 function vtkCoordinate(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkCoordinate');
-
   publicAPI.setValue = function () {
     if (model.deleted) {
       vtkErrorMacro('instance deleted - cannot call any method');
       return false;
     }
-
     for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
       args[_key] = arguments[_key];
     }
-
-    var array = args; // allow an array passed as a single arg.
-
+    let array = args;
+    // allow an array passed as a single arg.
     if (array.length === 1 && Array.isArray(array[0])) {
       array = array[0];
     }
-
     if (array.length === 2) {
       publicAPI.setValue(array[0], array[1], 0.0);
       return true;
     }
-
     if (array.length !== 3) {
       throw new RangeError('Invalid number of values for array setter');
     }
-
-    var changeDetected = false;
-    model.value.forEach(function (item, index) {
+    let changeDetected = false;
+    model.value.forEach((item, index) => {
       if (item !== array[index]) {
         if (changeDetected) {
           return;
         }
-
         changeDetected = true;
       }
     });
-
     if (changeDetected) {
       model.value = [].concat(array);
       publicAPI.modified();
     }
-
     return true;
   };
-
-  publicAPI.setCoordinateSystemToDisplay = function () {
+  publicAPI.setCoordinateSystemToDisplay = () => {
     publicAPI.setCoordinateSystem(Coordinate.DISPLAY);
   };
-
-  publicAPI.setCoordinateSystemToNormalizedDisplay = function () {
+  publicAPI.setCoordinateSystemToNormalizedDisplay = () => {
     publicAPI.setCoordinateSystem(Coordinate.NORMALIZED_DISPLAY);
   };
-
-  publicAPI.setCoordinateSystemToViewport = function () {
+  publicAPI.setCoordinateSystemToViewport = () => {
     publicAPI.setCoordinateSystem(Coordinate.VIEWPORT);
   };
-
-  publicAPI.setCoordinateSystemToNormalizedViewport = function () {
+  publicAPI.setCoordinateSystemToNormalizedViewport = () => {
     publicAPI.setCoordinateSystem(Coordinate.NORMALIZED_VIEWPORT);
   };
-
-  publicAPI.setCoordinateSystemToProjection = function () {
+  publicAPI.setCoordinateSystemToProjection = () => {
     publicAPI.setCoordinateSystem(Coordinate.PROJECTION);
   };
-
-  publicAPI.setCoordinateSystemToView = function () {
+  publicAPI.setCoordinateSystemToView = () => {
     publicAPI.setCoordinateSystem(Coordinate.VIEW);
   };
-
-  publicAPI.setCoordinateSystemToWorld = function () {
+  publicAPI.setCoordinateSystemToWorld = () => {
     publicAPI.setCoordinateSystem(Coordinate.WORLD);
   };
-
-  publicAPI.getCoordinateSystemAsString = function () {
-    return macro.enumToString(Coordinate, model.coordinateSystem);
-  };
-
-  publicAPI.getComputedWorldValue = function (ren) {
-    var val = model.computedWorldValue;
-
+  publicAPI.getCoordinateSystemAsString = () => macro.enumToString(Coordinate, model.coordinateSystem);
+  publicAPI.getComputedWorldValue = ren => {
+    let val = model.computedWorldValue;
     if (model.computing) {
       return val;
     }
-
     model.computing = 1;
     val[0] = model.value[0];
     val[1] = model.value[1];
-    val[2] = model.value[2]; // Use our renderer if is defined
-
-    var renderer = ren;
+    val[2] = model.value[2];
 
+    // Use our renderer if is defined
+    let renderer = ren;
     if (model.renderer) {
       renderer = model.renderer;
     }
-
     if (!renderer) {
       if (model.coordinateSystem === Coordinate.WORLD) {
         if (model.referenceCoordinate) {
-          var refValue = model.referenceCoordinate.getComputedWorldValue(renderer);
+          const refValue = model.referenceCoordinate.getComputedWorldValue(renderer);
           val[0] += refValue[0];
           val[1] += refValue[1];
           val[2] += refValue[2];
         }
-
         model.computing = 0;
       } else {
         vtkErrorMacro('Attempt to compute world coordinates from another coordinate system without a renderer');
       }
-
       return val;
-    } // convert to current coordinate system
-
-
-    var view = null;
+    }
 
+    // convert to current coordinate system
+    let view = null;
     if (renderer && renderer.getRenderWindow().getViews()) {
       view = renderer.getRenderWindow().getViews()[0];
     } else {
       return model.computedWorldValue;
     }
-
-    var dims = view.getViewportSize(renderer);
-    var aspect = dims[0] / dims[1];
-
+    const dims = view.getViewportSize(renderer);
+    const aspect = dims[0] / dims[1];
     if (model.referenceCoordinate && model.coordinateSystem !== Coordinate.WORLD) {
-      var fval = model.referenceCoordinate.getComputedDoubleDisplayValue(renderer);
-      var _refValue = [fval[0], fval[1], 0.0];
-
+      const fval = model.referenceCoordinate.getComputedDoubleDisplayValue(renderer);
+      let refValue = [fval[0], fval[1], 0.0];
       switch (model.coordinateSystem) {
         case Coordinate.NORMALIZED_DISPLAY:
-          _refValue = view.displayToNormalizedDisplay(_refValue[0], _refValue[1], _refValue[2]);
+          refValue = view.displayToNormalizedDisplay(refValue[0], refValue[1], refValue[2]);
           break;
-
         case Coordinate.VIEWPORT:
-          _refValue = view.displayToNormalizedDisplay(_refValue[0], _refValue[1], _refValue[2]);
-          _refValue = view.normalizedDisplayToViewport(_refValue[0], _refValue[1], _refValue[2], renderer);
+          refValue = view.displayToNormalizedDisplay(refValue[0], refValue[1], refValue[2]);
+          refValue = view.normalizedDisplayToViewport(refValue[0], refValue[1], refValue[2], renderer);
           break;
-
         case Coordinate.NORMALIZED_VIEWPORT:
-          _refValue = view.displayToNormalizedDisplay(_refValue[0], _refValue[1], _refValue[2]);
-          _refValue = view.normalizedDisplayToViewport(_refValue[0], _refValue[1], _refValue[2], renderer);
-          _refValue = view.viewportToNormalizedViewport(_refValue[0], _refValue[1], _refValue[2], renderer);
+          refValue = view.displayToNormalizedDisplay(refValue[0], refValue[1], refValue[2]);
+          refValue = view.normalizedDisplayToViewport(refValue[0], refValue[1], refValue[2], renderer);
+          refValue = view.viewportToNormalizedViewport(refValue[0], refValue[1], refValue[2], renderer);
           break;
-
         case Coordinate.PROJECTION:
-          _refValue = view.displayToNormalizedDisplay(_refValue[0], _refValue[1], _refValue[2]);
-          _refValue = view.normalizedDisplayToViewport(_refValue[0], _refValue[1], _refValue[2], renderer);
-          _refValue = view.viewportToNormalizedViewport(_refValue[0], _refValue[1], _refValue[2], renderer);
-          _refValue = renderer.normalizedViewportToProjection(_refValue[0], _refValue[1], _refValue[2]);
+          refValue = view.displayToNormalizedDisplay(refValue[0], refValue[1], refValue[2]);
+          refValue = view.normalizedDisplayToViewport(refValue[0], refValue[1], refValue[2], renderer);
+          refValue = view.viewportToNormalizedViewport(refValue[0], refValue[1], refValue[2], renderer);
+          refValue = renderer.normalizedViewportToProjection(refValue[0], refValue[1], refValue[2]);
           break;
-
         case Coordinate.VIEW:
-          _refValue = view.displayToNormalizedDisplay(_refValue[0], _refValue[1], _refValue[2]);
-          _refValue = view.normalizedDisplayToViewport(_refValue[0], _refValue[1], _refValue[2], renderer);
-          _refValue = view.viewportToNormalizedViewport(_refValue[0], _refValue[1], _refValue[2], renderer);
-          _refValue = renderer.normalizedViewportToProjection(_refValue[0], _refValue[1], _refValue[2]);
-          _refValue = renderer.projectionToView(_refValue[0], _refValue[1], _refValue[2], aspect);
+          refValue = view.displayToNormalizedDisplay(refValue[0], refValue[1], refValue[2]);
+          refValue = view.normalizedDisplayToViewport(refValue[0], refValue[1], refValue[2], renderer);
+          refValue = view.viewportToNormalizedViewport(refValue[0], refValue[1], refValue[2], renderer);
+          refValue = renderer.normalizedViewportToProjection(refValue[0], refValue[1], refValue[2]);
+          refValue = renderer.projectionToView(refValue[0], refValue[1], refValue[2], aspect);
           break;
       }
-
-      val[0] += _refValue[0];
-      val[1] += _refValue[1];
-      val[2] += _refValue[2];
+      val[0] += refValue[0];
+      val[1] += refValue[1];
+      val[2] += refValue[2];
     }
-
     switch (model.coordinateSystem) {
       case Coordinate.DISPLAY:
         val = view.displayToNormalizedDisplay(val[0], val[1], val[2]);
@@ -188,7 +155,6 @@ function vtkCoordinate(publicAPI, model) {
         val = renderer.projectionToView(val[0], val[1], val[2], aspect);
         val = renderer.viewToWorld(val[0], val[1], val[2]);
         break;
-
       case Coordinate.NORMALIZED_DISPLAY:
         val = view.normalizedDisplayToViewport(val[0], val[1], val[2], renderer);
         val = view.viewportToNormalizedViewport(val[0], val[1], val[2], renderer);
@@ -196,126 +162,98 @@ function vtkCoordinate(publicAPI, model) {
         val = renderer.projectionToView(val[0], val[1], val[2], aspect);
         val = renderer.viewToWorld(val[0], val[1], val[2]);
         break;
-
       case Coordinate.VIEWPORT:
         val = view.viewportToNormalizedViewport(val[0], val[1], val[2], renderer);
         val = renderer.normalizedViewportToProjection(val[0], val[1], val[2]);
         val = renderer.projectionToView(val[0], val[1], val[2], aspect);
         val = renderer.viewToWorld(val[0], val[1], val[2]);
         break;
-
       case Coordinate.NORMALIZED_VIEWPORT:
         val = renderer.normalizedViewportToProjection(val[0], val[1], val[2]);
         val = renderer.projectionToView(val[0], val[1], val[2], aspect);
         val = renderer.viewToWorld(val[0], val[1], val[2]);
         break;
-
       case Coordinate.PROJECTION:
         val = renderer.projectionToView(val[0], val[1], val[2], aspect);
         val = renderer.viewToWorld(val[0], val[1], val[2]);
         break;
-
       case Coordinate.VIEW:
         val = renderer.viewToWorld(val[0], val[1], val[2]);
         break;
     }
-
     if (model.referenceCoordinate && model.coordinateSystem === Coordinate.WORLD) {
-      var _refValue2 = publicAPI.getComputedWorldValue(renderer);
-
-      val[0] += _refValue2[0];
-      val[1] += _refValue2[1];
-      val[2] += _refValue2[2];
+      const refValue = publicAPI.getComputedWorldValue(renderer);
+      val[0] += refValue[0];
+      val[1] += refValue[1];
+      val[2] += refValue[2];
     }
-
     model.computing = 0;
     model.computedWorldValue = val.slice(0);
     return val;
   };
-
-  publicAPI.getComputedViewportValue = function (ren) {
-    var f = publicAPI.getComputedDoubleViewportValue(ren);
+  publicAPI.getComputedViewportValue = ren => {
+    const f = publicAPI.getComputedDoubleViewportValue(ren);
     return [round(f[0]), round(f[1])];
   };
-
-  publicAPI.getComputedDisplayValue = function (ren) {
-    var val = publicAPI.getComputedDoubleDisplayValue(ren);
+  publicAPI.getComputedDisplayValue = ren => {
+    const val = publicAPI.getComputedDoubleDisplayValue(ren);
     return [floor(val[0]), floor(val[1])];
   };
-
-  publicAPI.getComputedLocalDisplayValue = function (ren) {
+  publicAPI.getComputedLocalDisplayValue = ren => {
     // Use our renderer if it is defined
-    var renderer = ren;
-
+    let renderer = ren;
     if (model.renderer) {
       renderer = model.renderer;
     }
-
-    var val = publicAPI.getComputedDisplayValue(renderer);
-
+    let val = publicAPI.getComputedDisplayValue(renderer);
     if (!renderer) {
       vtkErrorMacro('Attempt to convert to local display coordinates without a renderer');
       return val;
     }
-
-    var view = null;
-
+    let view = null;
     if (renderer && renderer.getRenderWindow().getViews()) {
       view = renderer.getRenderWindow().getViews()[0];
     } else {
       return val;
     }
-
     val = view.displayToLocalDisplay(val[0], val[1], val[2]);
     return [round(val[0]), round(val[1])];
   };
-
-  publicAPI.getComputedDoubleViewportValue = function (ren) {
-    var renderer = ren;
-
+  publicAPI.getComputedDoubleViewportValue = ren => {
+    let renderer = ren;
     if (model.renderer) {
       renderer = model.renderer;
     }
-
-    var val = publicAPI.getComputedDoubleDisplayValue(renderer);
-
+    let val = publicAPI.getComputedDoubleDisplayValue(renderer);
     if (!renderer) {
       return val;
     }
-
-    var view = null;
-
+    let view = null;
     if (renderer && renderer.getRenderWindow().getViews()) {
       view = renderer.getRenderWindow().getViews()[0];
     } else {
       return val;
     }
-
     val = view.displayToNormalizedDisplay(val[0], val[1], val[2]);
     val = view.normalizedDisplayToViewport(val[0], val[1], val[2], renderer);
     return [val[0], val[1]];
   };
-
-  publicAPI.getComputedDoubleDisplayValue = function (ren) {
+  publicAPI.getComputedDoubleDisplayValue = ren => {
     if (model.computing) {
       return model.computedDoubleDisplayValue;
     }
-
     model.computing = 1;
-    var val = model.value.slice(0);
-    var renderer = ren;
-
+    let val = model.value.slice(0);
+    let renderer = ren;
     if (model.renderer) {
       renderer = model.renderer;
     }
-
     if (!renderer) {
       if (model.coordinateSystem === Coordinate.DISPLAY) {
         model.computedDoubleDisplayValue[0] = val[0];
         model.computedDoubleDisplayValue[1] = val[1];
-
         if (model.referenceCoordinate) {
-          var refValue = model.referenceCoordinate.getComputedDoubleDisplayValue();
+          const refValue = model.referenceCoordinate.getComputedDoubleDisplayValue();
           model.computedDoubleDisplayValue[0] += refValue[0];
           model.computedDoubleDisplayValue[1] += refValue[1];
         }
@@ -324,32 +262,25 @@ function vtkCoordinate(publicAPI, model) {
         model.computedDoubleDisplayValue[1] = Number.MAX_VALUE;
         vtkErrorMacro('Request for coordinate transformation without required viewport');
       }
-
       return model.computedDoubleDisplayValue;
     }
-
-    var view = null;
-
+    let view = null;
     if (renderer && renderer.getRenderWindow().getViews()) {
       view = renderer.getRenderWindow().getViews()[0];
     } else {
       return val;
     }
-
-    var dims = view.getViewportSize(renderer);
-    var aspect = dims[0] / dims[1];
-
+    const dims = view.getViewportSize(renderer);
+    const aspect = dims[0] / dims[1];
     switch (model.coordinateSystem) {
       case Coordinate.WORLD:
         {
           if (model.referenceCoordinate) {
-            var _refValue3 = model.referenceCoordinate.getComputedWorldValue(renderer);
-
-            val[0] += _refValue3[0];
-            val[1] += _refValue3[1];
-            val[2] += _refValue3[2];
+            const refValue = model.referenceCoordinate.getComputedWorldValue(renderer);
+            val[0] += refValue[0];
+            val[1] += refValue[1];
+            val[2] += refValue[2];
           }
-
           val = renderer.worldToView(val[0], val[1], val[2]);
           val = renderer.viewToProjection(val[0], val[1], val[2], aspect);
           val = renderer.projectionToNormalizedViewport(val[0], val[1], val[2]);
@@ -358,7 +289,6 @@ function vtkCoordinate(publicAPI, model) {
           val = view.normalizedDisplayToDisplay(val[0], val[1], val[2]);
           break;
         }
-
       case Coordinate.VIEW:
         {
           val = renderer.viewToProjection(val[0], val[1], val[2], aspect);
@@ -368,7 +298,6 @@ function vtkCoordinate(publicAPI, model) {
           val = view.normalizedDisplayToDisplay(val[0], val[1], val[2]);
           break;
         }
-
       case Coordinate.PROJECTION:
         {
           val = renderer.projectionToNormalizedViewport(val[0], val[1], val[2]);
@@ -377,100 +306,83 @@ function vtkCoordinate(publicAPI, model) {
           val = view.normalizedDisplayToDisplay(val[0], val[1], val[2]);
           break;
         }
-
       case Coordinate.NORMALIZED_VIEWPORT:
         {
           val = view.normalizedViewportToViewport(val[0], val[1], val[2], renderer);
-
           if (model.referenceCoordinate) {
-            var _refValue4 = model.referenceCoordinate.getComputedDoubleViewportValue(renderer);
-
-            val[0] += _refValue4[0];
-            val[1] += _refValue4[1];
+            const refValue = model.referenceCoordinate.getComputedDoubleViewportValue(renderer);
+            val[0] += refValue[0];
+            val[1] += refValue[1];
           }
-
           val = view.viewportToNormalizedDisplay(val[0], val[1], val[2], renderer);
           val = view.normalizedDisplayToDisplay(val[0], val[1], val[2]);
           break;
         }
-
       case Coordinate.VIEWPORT:
         {
           if (model.referenceCoordinate) {
-            var _refValue5 = model.referenceCoordinate.getComputedDoubleViewportValue(renderer);
-
-            val[0] += _refValue5[0];
-            val[1] += _refValue5[1];
+            const refValue = model.referenceCoordinate.getComputedDoubleViewportValue(renderer);
+            val[0] += refValue[0];
+            val[1] += refValue[1];
           }
-
           val = view.viewportToNormalizedDisplay(val[0], val[1], val[2], renderer);
           val = view.normalizedDisplayToDisplay(val[0], val[1], val[2]);
           break;
         }
-
       case Coordinate.NORMALIZED_DISPLAY:
         val = view.normalizedDisplayToDisplay(val[0], val[1], val[2]);
         break;
-
       case Coordinate.USERDEFINED:
         val = model.value.slice(0);
         break;
-    } // if we have a reference coordinate and we haven't handled it yet
-
+    }
 
+    // if we have a reference coordinate and we haven't handled it yet
     if (model.referenceCoordinate && (model.coordinateSystem === Coordinate.DISPLAY || model.coordinateSystem === Coordinate.NORMALIZED_DISPLAY)) {
-      var _refValue6 = model.referenceCoordinate.getComputedDoubleDisplayValue(renderer);
-
-      val[0] += _refValue6[0];
-      val[1] += _refValue6[1];
+      const refValue = model.referenceCoordinate.getComputedDoubleDisplayValue(renderer);
+      val[0] += refValue[0];
+      val[1] += refValue[1];
     }
-
     model.computedDoubleDisplayValue[0] = val[0];
     model.computedDoubleDisplayValue[1] = val[1];
     model.computing = 0;
     return model.computedDoubleDisplayValue;
   };
-
-  publicAPI.getComputedValue = function (ren) {
-    var renderer = ren;
-
+  publicAPI.getComputedValue = ren => {
+    let renderer = ren;
     if (model.renderer) {
       renderer = model.renderer;
     }
-
     switch (model.coordinateSystem) {
       case Coordinate.WORLD:
         return publicAPI.getComputedWorldValue(renderer);
-
       case Coordinate.VIEW:
       case Coordinate.NORMALIZED_VIEWPORT:
       case Coordinate.VIEWPORT:
         {
-          var val = publicAPI.getComputedViewportValue(renderer);
+          const val = publicAPI.getComputedViewportValue(renderer);
           model.computedWorldValue[0] = val[0];
           model.computedWorldValue[1] = val[1];
           break;
         }
-
       case Coordinate.NORMALIZED_DISPLAY:
       case Coordinate.DISPLAY:
         {
-          var _val = model.getComputedDisplayValue(renderer);
-
-          model.computedWorldValue[0] = _val[0];
-          model.computedWorldValue[1] = _val[1];
+          const val = model.getComputedDisplayValue(renderer);
+          model.computedWorldValue[0] = val[0];
+          model.computedWorldValue[1] = val[1];
           break;
         }
     }
-
     return model.computedWorldValue;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   coordinateSystem: Coordinate.WORLD,
   value: [0.0, 0.0, 0.0],
   renderer: null,
@@ -478,26 +390,35 @@ var DEFAULT_VALUES = {
   computing: 0,
   computedWorldValue: [0.0, 0.0, 0.0],
   computedDoubleDisplayValue: [0.0, 0.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);
-  macro.obj(publicAPI, model); // Build VTK API
+  macro.obj(publicAPI, model);
 
+  // Build VTK API
   macro.set(publicAPI, model, ['property']);
   macro.get(publicAPI, model, ['value']);
   macro.setGet(publicAPI, model, ['coordinateSystem', 'referenceCoordinate', 'renderer']);
-  macro.getArray(publicAPI, model, ['value'], 3); // Object methods
+  macro.getArray(publicAPI, model, ['value'], 3);
 
+  // Object methods
   vtkCoordinate(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkCoordinate');
 
-var newInstance = macro.newInstance(extend, 'vtkCoordinate'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
-var vtkCoordinate$1 = _objectSpread({
-  newInstance: newInstance,
-  extend: extend
-}, Constants);
+var vtkCoordinate$1 = {
+  newInstance,
+  extend,
+  ...Constants
+};
 
 export { vtkCoordinate$1 as default, extend, newInstance };