@ohif/app 3.13.0-beta.35 → 3.13.0-beta.39

package/dist/{7537.bundle.1a18959ceec98634bc48.js → 7537.bundle.b784154ebd4c85946642.js}

@@ -330,6 +330,8 @@ class StatsOverlay {
 
 const stats_StatsOverlay = StatsOverlay.getInstance();
 
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/utilities/convertColorArrayToRgbString.js
+var convertColorArrayToRgbString = __webpack_require__(57652);
 ;// ../../../node_modules/@cornerstonejs/core/dist/esm/RenderingEngine/BaseRenderingEngine.js
 
 
@@ -345,6 +347,7 @@ const stats_StatsOverlay = StatsOverlay.getInstance();
 
 
 
+
 const VIEWPORT_MIN_SIZE = 2;
 class BaseRenderingEngine {
     constructor(id) {
@@ -526,14 +529,9 @@ class BaseRenderingEngine {
     }
     fillCanvasWithBackgroundColor(canvas, backgroundColor) {
         const ctx = canvas.getContext('2d');
-        let fillStyle;
-        if (backgroundColor) {
-            const rgb = backgroundColor.map((f) => Math.floor(255 * f));
-            fillStyle = `rgb(${rgb[0]}, ${rgb[1]}, ${rgb[2]})`;
-        }
-        else {
-            fillStyle = 'black';
-        }
+        const fillStyle = backgroundColor
+            ? (0,convertColorArrayToRgbString/* convertColorArrayToRgbString */.J)(backgroundColor)
+            : 'black';
         ctx.fillStyle = fillStyle;
         ctx.fillRect(0, 0, canvas.width, canvas.height);
     }
@@ -1139,6 +1137,9 @@ class BaseVolumeViewport extends Viewport/* default */.A {
     static get useCustomRenderingPipeline() {
         return false;
     }
+    isOrientationChangeable() {
+        return true;
+    }
     getSliceViewInfo() {
         throw new Error('Method not implemented.');
     }
@@ -2665,8 +2666,8 @@ var vtkAbstractImageMapper$1 = {
 
 // EXTERNAL MODULE: ../../../node_modules/gl-matrix/esm/index.js + 1 modules
 var esm = __webpack_require__(3823);
-// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/Plane.js + 1 modules
-var Plane = __webpack_require__(43884);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/Plane.js
+var Plane = __webpack_require__(49794);
 ;// ../../../node_modules/@kitware/vtk.js/Rendering/Core/AbstractImageMapper/helper.js
 
 
@@ -6954,7 +6955,7 @@ class VideoViewport extends Viewport/* default */.A {
 /* harmony export */ });
 /* harmony import */ var _kitware_vtk_js_Common_Core_MatrixBuilder__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(90364);
 /* harmony import */ var _kitware_vtk_js_Common_Core_Math__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(91352);
-/* harmony import */ var _kitware_vtk_js_Common_DataModel_Plane__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(43884);
+/* harmony import */ var _kitware_vtk_js_Common_DataModel_Plane__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(49794);
 /* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(3823);
 /* harmony import */ var _enums_Events__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(32643);
 /* harmony import */ var _enums_ViewportStatus__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(1814);
@@ -7064,6 +7065,9 @@ class Viewport {
     static get useCustomRenderingPipeline() {
         return false;
     }
+    isOrientationChangeable() {
+        return false;
+    }
     setRendered() {
         if (this.viewportStatus === _enums_ViewportStatus__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .A.NO_DATA ||
             this.viewportStatus === _enums_ViewportStatus__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .A.LOADING) {
@@ -8094,8 +8098,8 @@ __webpack_require__.d(__webpack_exports__, {
 
 // EXTERNAL MODULE: ../../../node_modules/gl-matrix/esm/index.js + 1 modules
 var esm = __webpack_require__(3823);
-// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/Plane.js + 1 modules
-var Plane = __webpack_require__(43884);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/Plane.js
+var Plane = __webpack_require__(49794);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/cache/cache.js
 var cache = __webpack_require__(49038);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/constants/index.js + 4 modules
@@ -19057,8 +19061,8 @@ var vtkRenderWindowInteractor$1 = {
 
 // EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/Core/Points.js
 var Points = __webpack_require__(74973);
-// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/PolyData.js + 11 modules
-var PolyData = __webpack_require__(12548);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/PolyData.js + 7 modules
+var PolyData = __webpack_require__(27480);
 // EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Rendering/Core/Actor.js
 var Core_Actor = __webpack_require__(44404);
 // EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Rendering/Core/Mapper.js + 1 modules
@@ -20731,8 +20735,8 @@ var DataAccessHelper = __webpack_require__(4437);
 var macros2 = __webpack_require__(90027);
 // EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/Core/DataArray.js
 var DataArray = __webpack_require__(445);
-// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/PolyData.js + 11 modules
-var PolyData = __webpack_require__(12548);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/PolyData.js + 7 modules
+var PolyData = __webpack_require__(27480);
 // EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/IO/Core/DataAccessHelper/LiteHttpDataAccessHelper.js + 1 modules
 var LiteHttpDataAccessHelper = __webpack_require__(97833);
 ;// ../../../node_modules/@kitware/vtk.js/IO/Geometry/PLYReader.js
@@ -26506,8 +26510,8 @@ var BoundingBox = __webpack_require__(24377);
 var DataArray = __webpack_require__(445);
 // EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Rendering/Core/Mapper.js + 1 modules
 var Mapper = __webpack_require__(81418);
-// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/PolyData.js + 11 modules
-var PolyData = __webpack_require__(12548);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/PolyData.js + 7 modules
+var PolyData = __webpack_require__(27480);
 // EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Rendering/Core/Texture.js
 var Texture = __webpack_require__(41090);
 ;// ../../../node_modules/@kitware/vtk.js/Rendering/Core/CubeAxesActor.js
@@ -31871,8 +31875,8 @@ var macros2 = __webpack_require__(90027);
 var esm = __webpack_require__(3823);
 // EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/Core/CellArray.js
 var CellArray = __webpack_require__(32461);
-// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/PolyData.js + 11 modules
-var PolyData = __webpack_require__(12548);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/PolyData.js + 7 modules
+var PolyData = __webpack_require__(27480);
 ;// ../../../node_modules/@kitware/vtk.js/Filters/General/ClosedPolyLineToSurfaceFilter.js
 
 
@@ -32180,8 +32184,8 @@ var vtkImageDataOutlineFilter$1 = {
 var Core_Math = __webpack_require__(8047);
 // EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Rendering/OpenGL/Texture.js + 1 modules
 var Texture = __webpack_require__(22323);
-// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/Plane.js + 1 modules
-var Plane = __webpack_require__(43884);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/Plane.js
+var Plane = __webpack_require__(49794);
 // EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Rendering/OpenGL/ReplacementShaderMapper.js
 var ReplacementShaderMapper = __webpack_require__(71705);
 // EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Rendering/OpenGL/ShaderProgram.js + 1 modules
@@ -35905,6 +35909,22 @@ class VoxelManager {
 }
 
 
+/***/ },
+
+/***/ 57652
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   J: () => (/* binding */ convertColorArrayToRgbString)
+/* harmony export */ });
+function convertColorArrayToRgbString(colorArr) {
+    return Array.isArray(colorArr)
+        ? `rgb(${colorArr.map((v) => Math.round(v * 255)).join(',')})`
+        : colorArr;
+}
+
+
 /***/ },
 
 /***/ 87784
@@ -36308,7 +36328,7 @@ function uuidv4() {
 
 "use strict";
 /* unused harmony export version */
-const version = '4.18.2';
+const version = '4.19.0';
 
 
 /***/ },
@@ -58221,6 +58241,310 @@ var vtkCell$1 = {
 
 
 
+/***/ },
+
+/***/ 82649
+(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   Ay: () => (/* binding */ vtkCellTypes$1)
+/* harmony export */ });
+/* unused harmony exports STATIC, extend, newInstance */
+/* harmony import */ var _macros2_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(90027);
+/* harmony import */ var _CellTypes_Constants_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(61091);
+
+
+
+// ----------------------------------------------------------------------------
+// Global methods
+// ----------------------------------------------------------------------------
+
+/**
+ * Given an int (as defined in vtkCellType.h) identifier for a class
+ * return it's classname.
+ */
+function getClassNameFromTypeId(typeId) {
+  return typeId < _CellTypes_Constants_js__WEBPACK_IMPORTED_MODULE_1__/* .CellTypesStrings */ .wV.length ? _CellTypes_Constants_js__WEBPACK_IMPORTED_MODULE_1__/* .CellTypesStrings */ .wV[typeId] : 'UnknownClass';
+}
+
+/**
+ * Given a data object classname, return it's int identified (as
+ * defined in vtkCellType.h)
+ */
+function getTypeIdFromClassName(cellTypeString) {
+  return _CellTypes_Constants_js__WEBPACK_IMPORTED_MODULE_1__/* .CellTypesStrings */ .wV.findIndex(cellTypeString);
+}
+
+/**
+ * This convenience method is a fast check to determine if a cell type
+ * represents a linear or nonlinear cell.  This is generally much more
+ * efficient than getting the appropriate vtkCell and checking its IsLinear
+ * method.
+ */
+function isLinear(type) {
+  return type < _CellTypes_Constants_js__WEBPACK_IMPORTED_MODULE_1__/* .CellType */ .vZ.VTK_QUADRATIC_EDGE || type === _CellTypes_Constants_js__WEBPACK_IMPORTED_MODULE_1__/* .CellType */ .vZ.VTK_CONVEX_POINT_SET || type === _CellTypes_Constants_js__WEBPACK_IMPORTED_MODULE_1__/* .CellType */ .vZ.VTK_POLYHEDRON;
+}
+function hasSubCells(cellType) {
+  return cellType === _CellTypes_Constants_js__WEBPACK_IMPORTED_MODULE_1__/* .CellType */ .vZ.VTK_TRIANGLE_STRIP || cellType === _CellTypes_Constants_js__WEBPACK_IMPORTED_MODULE_1__/* .CellType */ .vZ.VTK_POLY_LINE || cellType === _CellTypes_Constants_js__WEBPACK_IMPORTED_MODULE_1__/* .CellType */ .vZ.VTK_POLY_VERTEX;
+}
+
+// ----------------------------------------------------------------------------
+// Static API
+// ----------------------------------------------------------------------------
+
+const STATIC = {
+  getClassNameFromTypeId,
+  getTypeIdFromClassName,
+  isLinear,
+  hasSubCells
+};
+
+// ----------------------------------------------------------------------------
+// vtkCellTypes methods
+// ----------------------------------------------------------------------------
+
+function vtkCellTypes(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkCellTypes');
+
+  /**
+   * Allocate memory for this array. Delete old storage only if necessary.
+   */
+  publicAPI.allocate = function () {
+    let sz = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 512;
+    let ext = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1000;
+    model.size = sz > 0 ? sz : 1;
+    model.extend = ext > 0 ? ext : 1;
+    model.maxId = -1;
+    model.typeArray = new Uint8Array(sz);
+    model.locationArray = new Uint32Array(sz);
+  };
+
+  /**
+   * Add a cell at specified id.
+   */
+  publicAPI.insertCell = (cellId, type, loc) => {
+    model.typeArray[cellId] = type;
+    model.locationArray[cellId] = loc;
+    if (cellId > model.maxId) {
+      model.maxId = cellId;
+    }
+  };
+
+  /**
+   * Add a cell to the object in the next available slot.
+   */
+  publicAPI.insertNextCell = (type, loc) => {
+    publicAPI.insertCell(++model.maxId, type, loc);
+    return model.maxId;
+  };
+
+  /**
+   * Specify a group of cell types. This version is provided to maintain
+   * backwards compatibility and does a copy of the cellLocations
+   */
+  publicAPI.setCellTypes = (ncells, cellTypes, cellLocations) => {
+    model.size = ncells;
+    model.typeArray = cellTypes;
+    model.locationArray = cellLocations;
+    model.maxId = ncells - 1;
+  };
+
+  /**
+   * Return the location of the cell in the associated vtkCellArray.
+   */
+  publicAPI.getCellLocation = cellId => model.locationArray[cellId];
+
+  /**
+   * Delete cell by setting to nullptr cell type.
+   */
+  publicAPI.deleteCell = cellId => {
+    model.typeArray[cellId] = _CellTypes_Constants_js__WEBPACK_IMPORTED_MODULE_1__/* .CellType */ .vZ.VTK_EMPTY_CELL;
+  };
+
+  /**
+   * Return the number of types in the list.
+   */
+  publicAPI.getNumberOfTypes = () => model.maxId + 1;
+
+  /**
+   * Return true if type specified is contained in list; false otherwise.
+   */
+  publicAPI.isType = type => {
+    const numTypes = publicAPI.getNumberOfTypes();
+    for (let i = 0; i < numTypes; ++i) {
+      if (type === publicAPI.getCellType(i)) {
+        return true;
+      }
+    }
+    return false;
+  };
+
+  /**
+   * Add the type specified to the end of the list. Range checking is performed.
+   */
+  publicAPI.insertNextType = type => publicAPI.insertNextCell(type, -1);
+
+  /**
+   * Return the type of cell.
+   */
+  publicAPI.getCellType = cellId => model.typeArray[cellId];
+
+  /**
+   * Reclaim any extra memory.
+   */
+  // TODO: publicAPI.squeeze = () =>  {};
+
+  /**
+   * Initialize object without releasing memory.
+   */
+  publicAPI.reset = () => {
+    model.maxId = -1;
+  };
+
+  /**
+   * Standard DeepCopy method.  Since this object contains no reference
+   * to other objects, there is no ShallowCopy.
+   */
+  publicAPI.deepCopy = src => {
+    publicAPI.allocate(src.getSize(), src.getExtend());
+    model.typeArray.set(src.getTypeArray());
+    model.locationArray.set(src.getLocationArray());
+    model.maxId = src.getMaxId();
+  };
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+const DEFAULT_VALUES = {
+  // typeArray: null, // pointer to types array
+  // locationArray: null;   // pointer to array of offsets
+  size: 0,
+  // allocated size of data
+  maxId: -1,
+  // maximum index inserted thus far
+  extend: 1000 // grow array by this point
+};
+
+// ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+  _macros2_js__WEBPACK_IMPORTED_MODULE_0__.m.obj(publicAPI, model);
+  _macros2_js__WEBPACK_IMPORTED_MODULE_0__.m.get(publicAPI, model, ['size', 'maxId', 'extend']);
+  _macros2_js__WEBPACK_IMPORTED_MODULE_0__.m.getArray(publicAPI, model, ['typeArray', 'locationArray']);
+  vtkCellTypes(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = _macros2_js__WEBPACK_IMPORTED_MODULE_0__.m.newInstance(extend, 'vtkCellTypes');
+
+// ----------------------------------------------------------------------------
+
+var vtkCellTypes$1 = {
+  newInstance,
+  extend,
+  ...STATIC
+};
+
+
+
+
+/***/ },
+
+/***/ 61091
+(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   vZ: () => (/* binding */ CellType),
+/* harmony export */   wV: () => (/* binding */ CellTypesStrings)
+/* harmony export */ });
+/* unused harmony export default */
+const CellType = {
+  // Linear cells
+  VTK_EMPTY_CELL: 0,
+  VTK_VERTEX: 1,
+  VTK_POLY_VERTEX: 2,
+  VTK_LINE: 3,
+  VTK_POLY_LINE: 4,
+  VTK_TRIANGLE: 5,
+  VTK_TRIANGLE_STRIP: 6,
+  VTK_POLYGON: 7,
+  VTK_PIXEL: 8,
+  VTK_QUAD: 9,
+  VTK_TETRA: 10,
+  VTK_VOXEL: 11,
+  VTK_HEXAHEDRON: 12,
+  VTK_WEDGE: 13,
+  VTK_PYRAMID: 14,
+  VTK_PENTAGONAL_PRISM: 15,
+  VTK_HEXAGONAL_PRISM: 16,
+  // Quadratic, isoparametric cells
+  VTK_QUADRATIC_EDGE: 21,
+  VTK_QUADRATIC_TRIANGLE: 22,
+  VTK_QUADRATIC_QUAD: 23,
+  VTK_QUADRATIC_POLYGON: 36,
+  VTK_QUADRATIC_TETRA: 24,
+  VTK_QUADRATIC_HEXAHEDRON: 25,
+  VTK_QUADRATIC_WEDGE: 26,
+  VTK_QUADRATIC_PYRAMID: 27,
+  VTK_BIQUADRATIC_QUAD: 28,
+  VTK_TRIQUADRATIC_HEXAHEDRON: 29,
+  VTK_QUADRATIC_LINEAR_QUAD: 30,
+  VTK_QUADRATIC_LINEAR_WEDGE: 31,
+  VTK_BIQUADRATIC_QUADRATIC_WEDGE: 32,
+  VTK_BIQUADRATIC_QUADRATIC_HEXAHEDRON: 33,
+  VTK_BIQUADRATIC_TRIANGLE: 34,
+  // Cubic, isoparametric cell
+  VTK_CUBIC_LINE: 35,
+  // Special class of cells formed by convex group of points
+  VTK_CONVEX_POINT_SET: 41,
+  // Polyhedron cell (consisting of polygonal faces)
+  VTK_POLYHEDRON: 42,
+  // Higher order cells in parametric form
+  VTK_PARAMETRIC_CURVE: 51,
+  VTK_PARAMETRIC_SURFACE: 52,
+  VTK_PARAMETRIC_TRI_SURFACE: 53,
+  VTK_PARAMETRIC_QUAD_SURFACE: 54,
+  VTK_PARAMETRIC_TETRA_REGION: 55,
+  VTK_PARAMETRIC_HEX_REGION: 56,
+  // Higher order cells
+  VTK_HIGHER_ORDER_EDGE: 60,
+  VTK_HIGHER_ORDER_TRIANGLE: 61,
+  VTK_HIGHER_ORDER_QUAD: 62,
+  VTK_HIGHER_ORDER_POLYGON: 63,
+  VTK_HIGHER_ORDER_TETRAHEDRON: 64,
+  VTK_HIGHER_ORDER_WEDGE: 65,
+  VTK_HIGHER_ORDER_PYRAMID: 66,
+  VTK_HIGHER_ORDER_HEXAHEDRON: 67,
+  // Arbitrary order Lagrange elements (formulated separated from generic higher order cells)
+  VTK_LAGRANGE_CURVE: 68,
+  VTK_LAGRANGE_TRIANGLE: 69,
+  VTK_LAGRANGE_QUADRILATERAL: 70,
+  VTK_LAGRANGE_TETRAHEDRON: 71,
+  VTK_LAGRANGE_HEXAHEDRON: 72,
+  VTK_LAGRANGE_WEDGE: 73,
+  VTK_LAGRANGE_PYRAMID: 74,
+  VTK_NUMBER_OF_CELL_TYPES: 75
+};
+
+// This list should contain the cell class names in
+// the same order as in CellType.
+const CellTypesStrings = ['vtkEmptyCell', 'vtkVertex', 'vtkPolyVertex', 'vtkLine', 'vtkPolyLine', 'vtkTriangle', 'vtkTriangleStrip', 'vtkPolygon', 'vtkPixel', 'vtkQuad', 'vtkTetra', 'vtkVoxel', 'vtkHexahedron', 'vtkWedge', 'vtkPyramid', 'vtkPentagonalPrism', 'vtkHexagonalPrism', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'vtkQuadraticEdge', 'vtkQuadraticTriangle', 'vtkQuadraticQuad', 'vtkQuadraticTetra', 'vtkQuadraticHexahedron', 'vtkQuadraticWedge', 'vtkQuadraticPyramid', 'vtkBiQuadraticQuad', 'vtkTriQuadraticHexahedron', 'vtkQuadraticLinearQuad', 'vtkQuadraticLinearWedge', 'vtkBiQuadraticQuadraticWedge', 'vtkBiQuadraticQuadraticHexahedron', 'vtkBiQuadraticTriangle', 'vtkCubicLine', 'vtkQuadraticPolygon', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'vtkConvexPointSet', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'vtkParametricCurve', 'vtkParametricSurface', 'vtkParametricTriSurface', 'vtkParametricQuadSurface', 'vtkParametricTetraRegion', 'vtkParametricHexRegion', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'vtkHigherOrderEdge', 'vtkHigherOrderTriangle', 'vtkHigherOrderQuad', 'vtkHigherOrderPolygon', 'vtkHigherOrderTetrahedron', 'vtkHigherOrderWedge', 'vtkHigherOrderPyramid', 'vtkHigherOrderHexahedron'];
+var Constants = {
+  CellType,
+  CellTypesStrings
+};
+
+
+
+
 /***/ },
 
 /***/ 35856
@@ -59115,7 +59439,7 @@ var vtkPiecewiseFunction$1 = {
 
 /***/ },
 
-/***/ 12548
+/***/ 27480
 (__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
 
 "use strict";
@@ -59395,287 +59719,8 @@ var vtkCellLinks$1 = {
 
 
 
-;// ../../../node_modules/@kitware/vtk.js/Common/DataModel/CellTypes/Constants.js
-const CellType = {
-  // Linear cells
-  VTK_EMPTY_CELL: 0,
-  VTK_VERTEX: 1,
-  VTK_POLY_VERTEX: 2,
-  VTK_LINE: 3,
-  VTK_POLY_LINE: 4,
-  VTK_TRIANGLE: 5,
-  VTK_TRIANGLE_STRIP: 6,
-  VTK_POLYGON: 7,
-  VTK_PIXEL: 8,
-  VTK_QUAD: 9,
-  VTK_TETRA: 10,
-  VTK_VOXEL: 11,
-  VTK_HEXAHEDRON: 12,
-  VTK_WEDGE: 13,
-  VTK_PYRAMID: 14,
-  VTK_PENTAGONAL_PRISM: 15,
-  VTK_HEXAGONAL_PRISM: 16,
-  // Quadratic, isoparametric cells
-  VTK_QUADRATIC_EDGE: 21,
-  VTK_QUADRATIC_TRIANGLE: 22,
-  VTK_QUADRATIC_QUAD: 23,
-  VTK_QUADRATIC_POLYGON: 36,
-  VTK_QUADRATIC_TETRA: 24,
-  VTK_QUADRATIC_HEXAHEDRON: 25,
-  VTK_QUADRATIC_WEDGE: 26,
-  VTK_QUADRATIC_PYRAMID: 27,
-  VTK_BIQUADRATIC_QUAD: 28,
-  VTK_TRIQUADRATIC_HEXAHEDRON: 29,
-  VTK_QUADRATIC_LINEAR_QUAD: 30,
-  VTK_QUADRATIC_LINEAR_WEDGE: 31,
-  VTK_BIQUADRATIC_QUADRATIC_WEDGE: 32,
-  VTK_BIQUADRATIC_QUADRATIC_HEXAHEDRON: 33,
-  VTK_BIQUADRATIC_TRIANGLE: 34,
-  // Cubic, isoparametric cell
-  VTK_CUBIC_LINE: 35,
-  // Special class of cells formed by convex group of points
-  VTK_CONVEX_POINT_SET: 41,
-  // Polyhedron cell (consisting of polygonal faces)
-  VTK_POLYHEDRON: 42,
-  // Higher order cells in parametric form
-  VTK_PARAMETRIC_CURVE: 51,
-  VTK_PARAMETRIC_SURFACE: 52,
-  VTK_PARAMETRIC_TRI_SURFACE: 53,
-  VTK_PARAMETRIC_QUAD_SURFACE: 54,
-  VTK_PARAMETRIC_TETRA_REGION: 55,
-  VTK_PARAMETRIC_HEX_REGION: 56,
-  // Higher order cells
-  VTK_HIGHER_ORDER_EDGE: 60,
-  VTK_HIGHER_ORDER_TRIANGLE: 61,
-  VTK_HIGHER_ORDER_QUAD: 62,
-  VTK_HIGHER_ORDER_POLYGON: 63,
-  VTK_HIGHER_ORDER_TETRAHEDRON: 64,
-  VTK_HIGHER_ORDER_WEDGE: 65,
-  VTK_HIGHER_ORDER_PYRAMID: 66,
-  VTK_HIGHER_ORDER_HEXAHEDRON: 67,
-  // Arbitrary order Lagrange elements (formulated separated from generic higher order cells)
-  VTK_LAGRANGE_CURVE: 68,
-  VTK_LAGRANGE_TRIANGLE: 69,
-  VTK_LAGRANGE_QUADRILATERAL: 70,
-  VTK_LAGRANGE_TETRAHEDRON: 71,
-  VTK_LAGRANGE_HEXAHEDRON: 72,
-  VTK_LAGRANGE_WEDGE: 73,
-  VTK_LAGRANGE_PYRAMID: 74,
-  VTK_NUMBER_OF_CELL_TYPES: 75
-};
-
-// This list should contain the cell class names in
-// the same order as in CellType.
-const CellTypesStrings = ['vtkEmptyCell', 'vtkVertex', 'vtkPolyVertex', 'vtkLine', 'vtkPolyLine', 'vtkTriangle', 'vtkTriangleStrip', 'vtkPolygon', 'vtkPixel', 'vtkQuad', 'vtkTetra', 'vtkVoxel', 'vtkHexahedron', 'vtkWedge', 'vtkPyramid', 'vtkPentagonalPrism', 'vtkHexagonalPrism', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'vtkQuadraticEdge', 'vtkQuadraticTriangle', 'vtkQuadraticQuad', 'vtkQuadraticTetra', 'vtkQuadraticHexahedron', 'vtkQuadraticWedge', 'vtkQuadraticPyramid', 'vtkBiQuadraticQuad', 'vtkTriQuadraticHexahedron', 'vtkQuadraticLinearQuad', 'vtkQuadraticLinearWedge', 'vtkBiQuadraticQuadraticWedge', 'vtkBiQuadraticQuadraticHexahedron', 'vtkBiQuadraticTriangle', 'vtkCubicLine', 'vtkQuadraticPolygon', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'vtkConvexPointSet', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'vtkParametricCurve', 'vtkParametricSurface', 'vtkParametricTriSurface', 'vtkParametricQuadSurface', 'vtkParametricTetraRegion', 'vtkParametricHexRegion', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'vtkHigherOrderEdge', 'vtkHigherOrderTriangle', 'vtkHigherOrderQuad', 'vtkHigherOrderPolygon', 'vtkHigherOrderTetrahedron', 'vtkHigherOrderWedge', 'vtkHigherOrderPyramid', 'vtkHigherOrderHexahedron'];
-var Constants = {
-  CellType,
-  CellTypesStrings
-};
-
-
-
-;// ../../../node_modules/@kitware/vtk.js/Common/DataModel/CellTypes.js
-
-
-
-// ----------------------------------------------------------------------------
-// Global methods
-// ----------------------------------------------------------------------------
-
-/**
- * Given an int (as defined in vtkCellType.h) identifier for a class
- * return it's classname.
- */
-function getClassNameFromTypeId(typeId) {
-  return typeId < CellTypesStrings.length ? CellTypesStrings[typeId] : 'UnknownClass';
-}
-
-/**
- * Given a data object classname, return it's int identified (as
- * defined in vtkCellType.h)
- */
-function getTypeIdFromClassName(cellTypeString) {
-  return CellTypesStrings.findIndex(cellTypeString);
-}
-
-/**
- * This convenience method is a fast check to determine if a cell type
- * represents a linear or nonlinear cell.  This is generally much more
- * efficient than getting the appropriate vtkCell and checking its IsLinear
- * method.
- */
-function isLinear(type) {
-  return type < CellType.VTK_QUADRATIC_EDGE || type === CellType.VTK_CONVEX_POINT_SET || type === CellType.VTK_POLYHEDRON;
-}
-function hasSubCells(cellType) {
-  return cellType === CellType.VTK_TRIANGLE_STRIP || cellType === CellType.VTK_POLY_LINE || cellType === CellType.VTK_POLY_VERTEX;
-}
-
-// ----------------------------------------------------------------------------
-// Static API
-// ----------------------------------------------------------------------------
-
-const STATIC = {
-  getClassNameFromTypeId,
-  getTypeIdFromClassName,
-  isLinear,
-  hasSubCells
-};
-
-// ----------------------------------------------------------------------------
-// vtkCellTypes methods
-// ----------------------------------------------------------------------------
-
-function vtkCellTypes(publicAPI, model) {
-  // Set our className
-  model.classHierarchy.push('vtkCellTypes');
-
-  /**
-   * Allocate memory for this array. Delete old storage only if necessary.
-   */
-  publicAPI.allocate = function () {
-    let sz = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 512;
-    let ext = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1000;
-    model.size = sz > 0 ? sz : 1;
-    model.extend = ext > 0 ? ext : 1;
-    model.maxId = -1;
-    model.typeArray = new Uint8Array(sz);
-    model.locationArray = new Uint32Array(sz);
-  };
-
-  /**
-   * Add a cell at specified id.
-   */
-  publicAPI.insertCell = (cellId, type, loc) => {
-    model.typeArray[cellId] = type;
-    model.locationArray[cellId] = loc;
-    if (cellId > model.maxId) {
-      model.maxId = cellId;
-    }
-  };
-
-  /**
-   * Add a cell to the object in the next available slot.
-   */
-  publicAPI.insertNextCell = (type, loc) => {
-    publicAPI.insertCell(++model.maxId, type, loc);
-    return model.maxId;
-  };
-
-  /**
-   * Specify a group of cell types. This version is provided to maintain
-   * backwards compatibility and does a copy of the cellLocations
-   */
-  publicAPI.setCellTypes = (ncells, cellTypes, cellLocations) => {
-    model.size = ncells;
-    model.typeArray = cellTypes;
-    model.locationArray = cellLocations;
-    model.maxId = ncells - 1;
-  };
-
-  /**
-   * Return the location of the cell in the associated vtkCellArray.
-   */
-  publicAPI.getCellLocation = cellId => model.locationArray[cellId];
-
-  /**
-   * Delete cell by setting to nullptr cell type.
-   */
-  publicAPI.deleteCell = cellId => {
-    model.typeArray[cellId] = CellType.VTK_EMPTY_CELL;
-  };
-
-  /**
-   * Return the number of types in the list.
-   */
-  publicAPI.getNumberOfTypes = () => model.maxId + 1;
-
-  /**
-   * Return true if type specified is contained in list; false otherwise.
-   */
-  publicAPI.isType = type => {
-    const numTypes = publicAPI.getNumberOfTypes();
-    for (let i = 0; i < numTypes; ++i) {
-      if (type === publicAPI.getCellType(i)) {
-        return true;
-      }
-    }
-    return false;
-  };
-
-  /**
-   * Add the type specified to the end of the list. Range checking is performed.
-   */
-  publicAPI.insertNextType = type => publicAPI.insertNextCell(type, -1);
-
-  /**
-   * Return the type of cell.
-   */
-  publicAPI.getCellType = cellId => model.typeArray[cellId];
-
-  /**
-   * Reclaim any extra memory.
-   */
-  // TODO: publicAPI.squeeze = () =>  {};
-
-  /**
-   * Initialize object without releasing memory.
-   */
-  publicAPI.reset = () => {
-    model.maxId = -1;
-  };
-
-  /**
-   * Standard DeepCopy method.  Since this object contains no reference
-   * to other objects, there is no ShallowCopy.
-   */
-  publicAPI.deepCopy = src => {
-    publicAPI.allocate(src.getSize(), src.getExtend());
-    model.typeArray.set(src.getTypeArray());
-    model.locationArray.set(src.getLocationArray());
-    model.maxId = src.getMaxId();
-  };
-}
-
-// ----------------------------------------------------------------------------
-// Object factory
-// ----------------------------------------------------------------------------
-
-const CellTypes_DEFAULT_VALUES = {
-  // typeArray: null, // pointer to types array
-  // locationArray: null;   // pointer to array of offsets
-  size: 0,
-  // allocated size of data
-  maxId: -1,
-  // maximum index inserted thus far
-  extend: 1000 // grow array by this point
-};
-
-// ----------------------------------------------------------------------------
-
-function CellTypes_extend(publicAPI, model) {
-  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, CellTypes_DEFAULT_VALUES, initialValues);
-  macros2.m.obj(publicAPI, model);
-  macros2.m.get(publicAPI, model, ['size', 'maxId', 'extend']);
-  macros2.m.getArray(publicAPI, model, ['typeArray', 'locationArray']);
-  vtkCellTypes(publicAPI, model);
-}
-
-// ----------------------------------------------------------------------------
-
-const CellTypes_newInstance = macros2.m.newInstance(CellTypes_extend, 'vtkCellTypes');
-
-// ----------------------------------------------------------------------------
-
-var vtkCellTypes$1 = {
-  newInstance: CellTypes_newInstance,
-  extend: CellTypes_extend,
-  ...STATIC
-};
-
-
-
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/CellTypes.js
+var CellTypes = __webpack_require__(82649);
 // EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/Line.js
 var Line = __webpack_require__(35856);
 // EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/DataSet.js + 3 modules
@@ -59765,151 +59810,12 @@ var vtkPointSet$1 = {
 
 
 
-// EXTERNAL MODULE: ../../../node_modules/gl-matrix/esm/index.js + 1 modules
-var esm = __webpack_require__(3823);
-;// ../../../node_modules/@kitware/vtk.js/Common/DataModel/PolyLine.js
-
-
-
-
-
-function vtkPolyLine(publicAPI, model) {
-  model.classHierarchy.push('vtkPolyLine');
-  const line = Line/* default.newInstance */.Ay.newInstance();
-  line.getPoints().setNumberOfPoints(2);
-  publicAPI.getCellDimension = () => 1;
-  publicAPI.intersectWithLine = (t1, t2, p1, p2, tol, x, pcoords) => {
-    const outObj = {
-      intersect: 0,
-      t: Number.MAX_VALUE,
-      subId: 0,
-      betweenPoints: null
-    };
-    const numLines = publicAPI.getNumberOfPoints() - 1;
-    let pDistMin = Number.MAX_VALUE;
-    for (let subId = 0; subId < numLines; subId++) {
-      const pCoords = [0, 0, 0];
-      line.getPoints().getData().set(model.points.getData().subarray(3 * subId, 3 * (subId + 2)));
-      const lineIntersected = line.intersectWithLine(p1, p2, tol, x, pcoords);
-      if (lineIntersected.intersect === 1 && lineIntersected.t <= outObj.t + tol && lineIntersected.t >= t1 && lineIntersected.t <= t2) {
-        outObj.intersect = 1;
-        const pDist = line.getParametricDistance(pCoords);
-        if (pDist < pDistMin || pDist === pDistMin && lineIntersected.t < outObj.t) {
-          outObj.subId = subId;
-          outObj.t = lineIntersected.t;
-          pDistMin = pDist;
-          for (let k = 0; k < 3; k++) {
-            x[k];
-            pCoords[k];
-          }
-        }
-      }
-    }
-    return outObj;
-  };
-  publicAPI.evaluateLocation = (subId, pcoords, x, weights) => {
-    line.getPoints().getData().set(model.points.getData().subarray(3 * subId, 3 * (subId + 2)));
-    return line.evaluateLocation(pcoords, x, weights);
-  };
-  publicAPI.evaluateOrientation = (subId, pcoords, q, weights) => {
-    if (model.orientations) {
-      line.setOrientations([model.orientations[subId], model.orientations[subId + 1]]);
-    } else {
-      line.setOrientations(null);
-    }
-    return line.evaluateOrientation(pcoords, q, weights);
-  };
-  publicAPI.getDistancesToFirstPoint = () => {
-    const dTime = model.distancesTime.getMTime();
-    if (dTime < model.points.getMTime() || dTime < publicAPI.getMTime()) {
-      const numPoints = publicAPI.getNumberOfPoints();
-      if (!model.distances) {
-        model.distances = new Array(numPoints);
-      } else {
-        model.distances.length = numPoints;
-      }
-      if (numPoints > 0) {
-        const previousPoint = new Array(3);
-        const currentPoint = new Array(3);
-        let totalDistance = 0;
-        model.distances[0] = totalDistance;
-        model.points.getPoint(0, previousPoint);
-        for (let i = 1; i < numPoints; ++i) {
-          model.points.getPoint(i, currentPoint);
-          totalDistance += model.distanceFunction(previousPoint, currentPoint);
-          model.distances[i] = totalDistance;
-          esm/* vec3.copy */.eR.copy(previousPoint, currentPoint);
-        }
-      }
-      model.distancesTime.modified();
-    }
-    return model.distances;
-  };
-  publicAPI.findPointIdAtDistanceFromFirstPoint = distance => {
-    const distances = publicAPI.getDistancesToFirstPoint();
-    // At least two points to return an ID
-    if (distances.length < 2) {
-      return -1;
-    }
-    // Binary search in the distance array
-    let minId = 0;
-    let maxId = distances.length - 1;
-    if (distance < distances[minId] || distance > distances[maxId] || distances[maxId] === 0) {
-      return -1;
-    }
-    while (maxId - minId > 1) {
-      const midId = Math.floor((minId + maxId) / 2);
-      if (distances[midId] <= distance) {
-        minId = midId;
-      } else {
-        maxId = midId;
-      }
-    }
-    return minId;
-  };
-}
-
-// ----------------------------------------------------------------------------
-// Object factory
-// ----------------------------------------------------------------------------
-
-const PolyLine_DEFAULT_VALUES = {
-  orientations: null,
-  // an array of quat or null
-  distanceFunction: esm/* vec3.dist */.eR.dist
-};
-
-// ----------------------------------------------------------------------------
-
-function PolyLine_extend(publicAPI, model) {
-  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, PolyLine_DEFAULT_VALUES, initialValues);
-  Cell/* default.extend */.Ay.extend(publicAPI, model, initialValues);
-  macros2.m.setGet(publicAPI, model, ['orientations', 'distanceFunction']);
-  model.distancesTime = {};
-  macros2.m.obj(model.distancesTime, {
-    mtime: 0
-  });
-  vtkPolyLine(publicAPI, model);
-}
-
-// ----------------------------------------------------------------------------
-
-const PolyLine_newInstance = macros2.m.newInstance(PolyLine_extend, 'vtkPolyLine');
-
-// ----------------------------------------------------------------------------
-
-var vtkPolyLine$1 = {
-  newInstance: PolyLine_newInstance,
-  extend: PolyLine_extend
-};
-
-
-
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/PolyLine.js
+var PolyLine = __webpack_require__(21186);
 // EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/Core/Math/index.js
 var Core_Math = __webpack_require__(8047);
-// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/Plane.js + 1 modules
-var Plane = __webpack_require__(43884);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/Plane.js
+var Plane = __webpack_require__(49794);
 ;// ../../../node_modules/@kitware/vtk.js/Common/Core/PriorityQueue.js
 
 
@@ -59980,7 +59886,7 @@ var vtkPriorityQueue$1 = {
 // EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/BoundingBox.js
 var BoundingBox = __webpack_require__(24377);
 // EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/Line/Constants.js
-var Line_Constants = __webpack_require__(63530);
+var Constants = __webpack_require__(63530);
 ;// ../../../node_modules/@kitware/vtk.js/Common/DataModel/Polygon/Constants.js
 const EPSILON = 1e-6;
 const FLOAT_EPSILON = 1.1920929e-7;
@@ -60215,7 +60121,7 @@ function computeCentroid(poly, points) {
 // Static API
 // ----------------------------------------------------------------------------
 
-const Polygon_STATIC = {
+const STATIC = {
   PolygonWithPointIntersectionState: PolygonWithPointIntersectionState,
   pointInPolygon,
   getBounds,
@@ -60289,7 +60195,7 @@ function vtkPolygon(publicAPI, model) {
         if (!oneNegative) {
           oneNegative = sign <= 0 ? 1 : 0;
         }
-        if (Line/* default */.Ay.intersection(previous.point, next.point, vertex.point, previousVertex.point, [0], [0]) === Line_Constants/* IntersectionState */.Z.YES_INTERSECTION) {
+        if (Line/* default */.Ay.intersection(previous.point, next.point, vertex.point, previousVertex.point, [0], [0]) === Constants/* IntersectionState */.Z.YES_INTERSECTION) {
           return false;
         }
         currentSign = sign;
@@ -60406,211 +60312,17 @@ const Polygon_newInstance = macros2.m.newInstance(Polygon_extend, 'vtkPolygon');
 var vtkPolygon$1 = {
   newInstance: Polygon_newInstance,
   extend: Polygon_extend,
-  ...Polygon_STATIC
+  ...STATIC
 };
 
 
 
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/Quad.js
+var Quad = __webpack_require__(82021);
 // EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/Triangle.js
 var Triangle = __webpack_require__(96402);
-;// ../../../node_modules/@kitware/vtk.js/Common/DataModel/Quad.js
-
-
-
-
-
-
-
-function intersectionStruct() {
-  return {
-    intersected: false,
-    subId: -1,
-    x: [0.0, 0.0, 0.0],
-    pCoords: [0.0, 0.0, 0.0],
-    t: -1
-  };
-}
-function vtkQuad(publicAPI, model) {
-  // Set our className
-  model.classHierarchy.push('vtkQuad');
-  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
-    };
-    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 = (0,Core_Math.f)(point0, point2);
-    const d2 = (0,Core_Math.f)(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
-    if (d1 === d2) {
-      // find the maximum id
-      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 {
-        diagonalCase = 1;
-      }
-    } else if (d1 < d2) {
-      diagonalCase = 0;
-    } else {
-      diagonalCase = 1;
-    }
-    let points = null;
-    if (!model.triangle) {
-      model.triangle = Triangle/* default.newInstance */.Ay.newInstance();
-      points = Points/* default.newInstance */.Ay.newInstance();
-      points.setNumberOfPoints(3);
-      model.triangle.initialize(points);
-    } else {
-      points = model.triangle.getPoints();
-    }
-    let firstIntersect;
-    const firstIntersectTmpObj = intersectionStruct();
-    let secondIntersect;
-    const secondIntersectTmpObj = intersectionStruct();
-    let useFirstIntersection;
-    let useSecondIntersection;
-    switch (diagonalCase) {
-      case 0:
-        points.setPoint(0, ...point0);
-        points.setPoint(1, ...point1);
-        points.setPoint(2, ...point2);
-        firstIntersect = model.triangle.intersectWithLine(p1, p2, tol, firstIntersectTmpObj.x, firstIntersectTmpObj.pCoords);
-        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];
-          x[1] = firstIntersectTmpObj.x[1];
-          x[2] = firstIntersectTmpObj.x[2];
-          pcoords[0] = firstIntersectTmpObj.pCoords[0] + firstIntersectTmpObj.pCoords[1];
-          pcoords[1] = firstIntersectTmpObj.pCoords[1];
-          pcoords[2] = firstIntersectTmpObj.pCoords[2];
-        } else if (useSecondIntersection) {
-          outObj = secondIntersect;
-          x[0] = secondIntersectTmpObj.x[0];
-          x[1] = secondIntersectTmpObj.x[1];
-          x[2] = secondIntersectTmpObj.x[2];
-          pcoords[0] = 1.0 - (secondIntersectTmpObj.pCoords[0] + secondIntersectTmpObj.pCoords[1]);
-          pcoords[1] = 1 - secondIntersectTmpObj.pCoords[1];
-          pcoords[2] = secondIntersectTmpObj.pCoords[2];
-        }
-        break;
-      case 1:
-        points.setPoint(0, ...point0);
-        points.setPoint(1, ...point1);
-        points.setPoint(2, ...point3);
-        firstIntersect = model.triangle.intersectWithLine(p1, p2, tol, firstIntersectTmpObj.x, firstIntersectTmpObj.pCoords);
-        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];
-          x[1] = firstIntersectTmpObj.x[1];
-          x[2] = firstIntersectTmpObj.x[2];
-          pcoords[0] = firstIntersectTmpObj.pCoords[0];
-          pcoords[1] = firstIntersectTmpObj.pCoords[1];
-          pcoords[2] = firstIntersectTmpObj.pCoords[2];
-        } else if (useSecondIntersection) {
-          outObj = secondIntersect;
-          x[0] = secondIntersectTmpObj.x[0];
-          x[1] = secondIntersectTmpObj.x[1];
-          x[2] = secondIntersectTmpObj.x[2];
-          pcoords[0] = 1 - secondIntersectTmpObj.pCoords[0];
-          pcoords[1] = 1 - secondIntersectTmpObj.pCoords[1];
-          pcoords[2] = secondIntersectTmpObj.pCoords[2];
-        }
-        break;
-    }
-    return outObj;
-  };
-  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 = [];
-
-    // Calculate the weights
-    publicAPI.interpolationFunctions(pcoords, weights);
-    x[0] = 0.0;
-    x[1] = 0.0;
-    x[2] = 0.0;
-    for (let i = 0; i < 4; i++) {
-      model.points.getPoint(i, point);
-      for (let j = 0; j < 3; j++) {
-        x[j] += point[j] * weights[i];
-      }
-    }
-  };
-}
-
-// ----------------------------------------------------------------------------
-// Object factory
-// ----------------------------------------------------------------------------
-
-const Quad_DEFAULT_VALUES = {};
-
-// ----------------------------------------------------------------------------
-
-function Quad_extend(publicAPI, model) {
-  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, Quad_DEFAULT_VALUES, initialValues);
-  Cell/* default.extend */.Ay.extend(publicAPI, model, initialValues);
-  vtkQuad(publicAPI, model);
-}
-
-// ----------------------------------------------------------------------------
-
-const Quad_newInstance = macros2.m.newInstance(Quad_extend, 'vtkQuad');
-
-// ----------------------------------------------------------------------------
-
-var vtkQuad$1 = {
-  newInstance: Quad_newInstance,
-  extend: Quad_extend
-};
-
-
-
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/CellTypes/Constants.js
+var CellTypes_Constants = __webpack_require__(61091);
 ;// ../../../node_modules/@kitware/vtk.js/Common/DataModel/TriangleStrip.js
 
 
@@ -60680,7 +60392,7 @@ function vtkTriangleStrip(publicAPI, model) {
    * Get the cell type.
    * @returns {number} Cell type
    */
-  publicAPI.getCellType = () => CellType.VTK_TRIANGLE_STRIP;
+  publicAPI.getCellType = () => CellTypes_Constants/* CellType */.vZ.VTK_TRIANGLE_STRIP;
 
   /**
    * Get the cell dimension.
@@ -61037,13 +60749,13 @@ const {
   vtkWarningMacro
 } = macros2.m;
 const CELL_FACTORY = {
-  [CellType.VTK_LINE]: Line/* default */.Ay,
-  [CellType.VTK_QUAD]: vtkQuad$1,
-  [CellType.VTK_POLY_LINE]: Line/* default */.Ay,
-  [CellType.VTK_TRIANGLE]: Triangle/* default */.Ay,
-  [CellType.VTK_TRIANGLE_STRIP]: vtkTriangleStrip$1,
-  [CellType.VTK_POLY_LINE]: vtkPolyLine$1,
-  [CellType.VTK_POLYGON]: vtkPolygon$1
+  [CellTypes_Constants/* CellType */.vZ.VTK_LINE]: Line/* default */.Ay,
+  [CellTypes_Constants/* CellType */.vZ.VTK_QUAD]: Quad/* default */.Ay,
+  [CellTypes_Constants/* CellType */.vZ.VTK_POLY_LINE]: Line/* default */.Ay,
+  [CellTypes_Constants/* CellType */.vZ.VTK_TRIANGLE]: Triangle/* default */.Ay,
+  [CellTypes_Constants/* CellType */.vZ.VTK_TRIANGLE_STRIP]: vtkTriangleStrip$1,
+  [CellTypes_Constants/* CellType */.vZ.VTK_POLY_LINE]: PolyLine/* default */.Ay,
+  [CellTypes_Constants/* CellType */.vZ.VTK_POLYGON]: vtkPolygon$1
 };
 
 // ----------------------------------------------------------------------------
@@ -61109,7 +60821,7 @@ function vtkPolyData(publicAPI, model) {
       let nextCellPts = 0;
       model.verts.getCellSizes().forEach((numCellPts, index) => {
         pLocs[index] = nextCellPts;
-        pTypes[index] = numCellPts > 1 ? CellType.VTK_POLY_VERTEX : CellType.VTK_VERTEX;
+        pTypes[index] = numCellPts > 1 ? CellTypes_Constants/* CellType */.vZ.VTK_POLY_VERTEX : CellTypes_Constants/* CellType */.vZ.VTK_VERTEX;
         nextCellPts += numCellPts + 1;
       });
       pLocs = pLocs.subarray(nVerts);
@@ -61121,7 +60833,7 @@ function vtkPolyData(publicAPI, model) {
       let nextCellPts = 0;
       model.lines.getCellSizes().forEach((numCellPts, index) => {
         pLocs[index] = nextCellPts;
-        pTypes[index] = numCellPts > 2 ? CellType.VTK_POLY_LINE : CellType.VTK_LINE;
+        pTypes[index] = numCellPts > 2 ? CellTypes_Constants/* CellType */.vZ.VTK_POLY_LINE : CellTypes_Constants/* CellType */.vZ.VTK_LINE;
         if (numCellPts === 1) {
           vtkWarningMacro('Building VTK_LINE ', index, ' with only one point, but VTK_LINE needs at least two points. Check the input.');
         }
@@ -61138,13 +60850,13 @@ function vtkPolyData(publicAPI, model) {
         pLocs[index] = nextCellPts;
         switch (numCellPts) {
           case 3:
-            pTypes[index] = CellType.VTK_TRIANGLE;
+            pTypes[index] = CellTypes_Constants/* CellType */.vZ.VTK_TRIANGLE;
             break;
           case 4:
-            pTypes[index] = CellType.VTK_QUAD;
+            pTypes[index] = CellTypes_Constants/* CellType */.vZ.VTK_QUAD;
             break;
           default:
-            pTypes[index] = CellType.VTK_POLYGON;
+            pTypes[index] = CellTypes_Constants/* CellType */.vZ.VTK_POLYGON;
             break;
         }
         if (numCellPts < 3) {
@@ -61159,7 +60871,7 @@ function vtkPolyData(publicAPI, model) {
     // strips
     if (nStrips) {
       let nextCellPts = 0;
-      pTypes.fill(CellType.VTK_TRIANGLE_STRIP, 0, nStrips);
+      pTypes.fill(CellTypes_Constants/* CellType */.vZ.VTK_TRIANGLE_STRIP, 0, nStrips);
       model.strips.getCellSizes().forEach((numCellPts, index) => {
         pLocs[index] = nextCellPts;
         nextCellPts += numCellPts + 1;
@@ -61167,7 +60879,7 @@ function vtkPolyData(publicAPI, model) {
     }
 
     // set up the cell types data structure
-    model.cells = vtkCellTypes$1.newInstance();
+    model.cells = CellTypes/* default.newInstance */.Ay.newInstance();
     model.cells.setCellTypes(nCells, types, locs);
   };
 
@@ -61193,20 +60905,20 @@ function vtkPolyData(publicAPI, model) {
     const cellType = publicAPI.getCellType(cellId);
     let cells = null;
     switch (cellType) {
-      case CellType.VTK_VERTEX:
-      case CellType.VTK_POLY_VERTEX:
+      case CellTypes_Constants/* CellType */.vZ.VTK_VERTEX:
+      case CellTypes_Constants/* CellType */.vZ.VTK_POLY_VERTEX:
         cells = model.verts;
         break;
-      case CellType.VTK_LINE:
-      case CellType.VTK_POLY_LINE:
+      case CellTypes_Constants/* CellType */.vZ.VTK_LINE:
+      case CellTypes_Constants/* CellType */.vZ.VTK_POLY_LINE:
         cells = model.lines;
         break;
-      case CellType.VTK_TRIANGLE:
-      case CellType.VTK_QUAD:
-      case CellType.VTK_POLYGON:
+      case CellTypes_Constants/* CellType */.vZ.VTK_TRIANGLE:
+      case CellTypes_Constants/* CellType */.vZ.VTK_QUAD:
+      case CellTypes_Constants/* CellType */.vZ.VTK_POLYGON:
         cells = model.polys;
         break;
-      case CellType.VTK_TRIANGLE_STRIP:
+      case CellTypes_Constants/* CellType */.vZ.VTK_TRIANGLE_STRIP:
         cells = model.strips;
         break;
       default:
@@ -61285,6 +60997,373 @@ var vtkPolyData$1 = {
 
 
 
+/***/ },
+
+/***/ 21186
+(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   Ay: () => (/* binding */ vtkPolyLine$1)
+/* harmony export */ });
+/* unused harmony exports extend, newInstance */
+/* harmony import */ var _macros2_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(90027);
+/* harmony import */ var _Cell_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(14210);
+/* harmony import */ var _Line_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(35856);
+/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(3823);
+
+
+
+
+
+function vtkPolyLine(publicAPI, model) {
+  model.classHierarchy.push('vtkPolyLine');
+  const line = _Line_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"].newInstance */ .Ay.newInstance();
+  line.getPoints().setNumberOfPoints(2);
+  publicAPI.getCellDimension = () => 1;
+  publicAPI.intersectWithLine = (t1, t2, p1, p2, tol, x, pcoords) => {
+    const outObj = {
+      intersect: 0,
+      t: Number.MAX_VALUE,
+      subId: 0,
+      betweenPoints: null
+    };
+    const numLines = publicAPI.getNumberOfPoints() - 1;
+    let pDistMin = Number.MAX_VALUE;
+    for (let subId = 0; subId < numLines; subId++) {
+      const pCoords = [0, 0, 0];
+      line.getPoints().getData().set(model.points.getData().subarray(3 * subId, 3 * (subId + 2)));
+      const lineIntersected = line.intersectWithLine(p1, p2, tol, x, pcoords);
+      if (lineIntersected.intersect === 1 && lineIntersected.t <= outObj.t + tol && lineIntersected.t >= t1 && lineIntersected.t <= t2) {
+        outObj.intersect = 1;
+        const pDist = line.getParametricDistance(pCoords);
+        if (pDist < pDistMin || pDist === pDistMin && lineIntersected.t < outObj.t) {
+          outObj.subId = subId;
+          outObj.t = lineIntersected.t;
+          pDistMin = pDist;
+          for (let k = 0; k < 3; k++) {
+            x[k];
+            pCoords[k];
+          }
+        }
+      }
+    }
+    return outObj;
+  };
+  publicAPI.evaluateLocation = (subId, pcoords, x, weights) => {
+    line.getPoints().getData().set(model.points.getData().subarray(3 * subId, 3 * (subId + 2)));
+    return line.evaluateLocation(pcoords, x, weights);
+  };
+  publicAPI.evaluateOrientation = (subId, pcoords, q, weights) => {
+    if (model.orientations) {
+      line.setOrientations([model.orientations[subId], model.orientations[subId + 1]]);
+    } else {
+      line.setOrientations(null);
+    }
+    return line.evaluateOrientation(pcoords, q, weights);
+  };
+  publicAPI.getDistancesToFirstPoint = () => {
+    const dTime = model.distancesTime.getMTime();
+    if (dTime < model.points.getMTime() || dTime < publicAPI.getMTime()) {
+      const numPoints = publicAPI.getNumberOfPoints();
+      if (!model.distances) {
+        model.distances = new Array(numPoints);
+      } else {
+        model.distances.length = numPoints;
+      }
+      if (numPoints > 0) {
+        const previousPoint = new Array(3);
+        const currentPoint = new Array(3);
+        let totalDistance = 0;
+        model.distances[0] = totalDistance;
+        model.points.getPoint(0, previousPoint);
+        for (let i = 1; i < numPoints; ++i) {
+          model.points.getPoint(i, currentPoint);
+          totalDistance += model.distanceFunction(previousPoint, currentPoint);
+          model.distances[i] = totalDistance;
+          gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .vec3.copy */ .eR.copy(previousPoint, currentPoint);
+        }
+      }
+      model.distancesTime.modified();
+    }
+    return model.distances;
+  };
+  publicAPI.findPointIdAtDistanceFromFirstPoint = distance => {
+    const distances = publicAPI.getDistancesToFirstPoint();
+    // At least two points to return an ID
+    if (distances.length < 2) {
+      return -1;
+    }
+    // Binary search in the distance array
+    let minId = 0;
+    let maxId = distances.length - 1;
+    if (distance < distances[minId] || distance > distances[maxId] || distances[maxId] === 0) {
+      return -1;
+    }
+    while (maxId - minId > 1) {
+      const midId = Math.floor((minId + maxId) / 2);
+      if (distances[midId] <= distance) {
+        minId = midId;
+      } else {
+        maxId = midId;
+      }
+    }
+    return minId;
+  };
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+const DEFAULT_VALUES = {
+  orientations: null,
+  // an array of quat or null
+  distanceFunction: gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .vec3.dist */ .eR.dist
+};
+
+// ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+  _Cell_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"].extend */ .Ay.extend(publicAPI, model, initialValues);
+  _macros2_js__WEBPACK_IMPORTED_MODULE_0__.m.setGet(publicAPI, model, ['orientations', 'distanceFunction']);
+  model.distancesTime = {};
+  _macros2_js__WEBPACK_IMPORTED_MODULE_0__.m.obj(model.distancesTime, {
+    mtime: 0
+  });
+  vtkPolyLine(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = _macros2_js__WEBPACK_IMPORTED_MODULE_0__.m.newInstance(extend, 'vtkPolyLine');
+
+// ----------------------------------------------------------------------------
+
+var vtkPolyLine$1 = {
+  newInstance,
+  extend
+};
+
+
+
+
+/***/ },
+
+/***/ 82021
+(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   Ay: () => (/* binding */ vtkQuad$1)
+/* harmony export */ });
+/* unused harmony exports extend, newInstance */
+/* harmony import */ var _macros2_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(90027);
+/* harmony import */ var _Cell_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(14210);
+/* harmony import */ var _Core_Math_index_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(8047);
+/* harmony import */ var _CellTypes_Constants_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(61091);
+/* harmony import */ var _Triangle_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(96402);
+/* harmony import */ var _Core_Points_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(74973);
+
+
+
+
+
+
+
+function intersectionStruct() {
+  return {
+    intersected: false,
+    subId: -1,
+    x: [0.0, 0.0, 0.0],
+    pCoords: [0.0, 0.0, 0.0],
+    t: -1
+  };
+}
+function vtkQuad(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkQuad');
+  publicAPI.getCellDimension = () => 2;
+  publicAPI.getCellType = () => _CellTypes_Constants_js__WEBPACK_IMPORTED_MODULE_3__/* .CellType */ .vZ.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
+    };
+    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 = (0,_Core_Math_index_js__WEBPACK_IMPORTED_MODULE_2__.f)(point0, point2);
+    const d2 = (0,_Core_Math_index_js__WEBPACK_IMPORTED_MODULE_2__.f)(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
+    if (d1 === d2) {
+      // find the maximum id
+      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 {
+        diagonalCase = 1;
+      }
+    } else if (d1 < d2) {
+      diagonalCase = 0;
+    } else {
+      diagonalCase = 1;
+    }
+    let points = null;
+    if (!model.triangle) {
+      model.triangle = _Triangle_js__WEBPACK_IMPORTED_MODULE_4__/* ["default"].newInstance */ .Ay.newInstance();
+      points = _Core_Points_js__WEBPACK_IMPORTED_MODULE_5__/* ["default"].newInstance */ .Ay.newInstance();
+      points.setNumberOfPoints(3);
+      model.triangle.initialize(points);
+    } else {
+      points = model.triangle.getPoints();
+    }
+    let firstIntersect;
+    const firstIntersectTmpObj = intersectionStruct();
+    let secondIntersect;
+    const secondIntersectTmpObj = intersectionStruct();
+    let useFirstIntersection;
+    let useSecondIntersection;
+    switch (diagonalCase) {
+      case 0:
+        points.setPoint(0, ...point0);
+        points.setPoint(1, ...point1);
+        points.setPoint(2, ...point2);
+        firstIntersect = model.triangle.intersectWithLine(p1, p2, tol, firstIntersectTmpObj.x, firstIntersectTmpObj.pCoords);
+        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];
+          x[1] = firstIntersectTmpObj.x[1];
+          x[2] = firstIntersectTmpObj.x[2];
+          pcoords[0] = firstIntersectTmpObj.pCoords[0] + firstIntersectTmpObj.pCoords[1];
+          pcoords[1] = firstIntersectTmpObj.pCoords[1];
+          pcoords[2] = firstIntersectTmpObj.pCoords[2];
+        } else if (useSecondIntersection) {
+          outObj = secondIntersect;
+          x[0] = secondIntersectTmpObj.x[0];
+          x[1] = secondIntersectTmpObj.x[1];
+          x[2] = secondIntersectTmpObj.x[2];
+          pcoords[0] = 1.0 - (secondIntersectTmpObj.pCoords[0] + secondIntersectTmpObj.pCoords[1]);
+          pcoords[1] = 1 - secondIntersectTmpObj.pCoords[1];
+          pcoords[2] = secondIntersectTmpObj.pCoords[2];
+        }
+        break;
+      case 1:
+        points.setPoint(0, ...point0);
+        points.setPoint(1, ...point1);
+        points.setPoint(2, ...point3);
+        firstIntersect = model.triangle.intersectWithLine(p1, p2, tol, firstIntersectTmpObj.x, firstIntersectTmpObj.pCoords);
+        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];
+          x[1] = firstIntersectTmpObj.x[1];
+          x[2] = firstIntersectTmpObj.x[2];
+          pcoords[0] = firstIntersectTmpObj.pCoords[0];
+          pcoords[1] = firstIntersectTmpObj.pCoords[1];
+          pcoords[2] = firstIntersectTmpObj.pCoords[2];
+        } else if (useSecondIntersection) {
+          outObj = secondIntersect;
+          x[0] = secondIntersectTmpObj.x[0];
+          x[1] = secondIntersectTmpObj.x[1];
+          x[2] = secondIntersectTmpObj.x[2];
+          pcoords[0] = 1 - secondIntersectTmpObj.pCoords[0];
+          pcoords[1] = 1 - secondIntersectTmpObj.pCoords[1];
+          pcoords[2] = secondIntersectTmpObj.pCoords[2];
+        }
+        break;
+    }
+    return outObj;
+  };
+  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 = [];
+
+    // Calculate the weights
+    publicAPI.interpolationFunctions(pcoords, weights);
+    x[0] = 0.0;
+    x[1] = 0.0;
+    x[2] = 0.0;
+    for (let i = 0; i < 4; i++) {
+      model.points.getPoint(i, point);
+      for (let j = 0; j < 3; j++) {
+        x[j] += point[j] * weights[i];
+      }
+    }
+  };
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+const DEFAULT_VALUES = {};
+
+// ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+  _Cell_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"].extend */ .Ay.extend(publicAPI, model, initialValues);
+  vtkQuad(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = _macros2_js__WEBPACK_IMPORTED_MODULE_0__.m.newInstance(extend, 'vtkQuad');
+
+// ----------------------------------------------------------------------------
+
+var vtkQuad$1 = {
+  newInstance,
+  extend
+};
+
+
+
+
 /***/ },
 
 /***/ 96402
@@ -61299,7 +61378,7 @@ var vtkPolyData$1 = {
 /* harmony import */ var _Cell_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(14210);
 /* harmony import */ var _Core_Math_index_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(8047);
 /* harmony import */ var _Line_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(35856);
-/* harmony import */ var _Plane_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(43884);
+/* harmony import */ var _Plane_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(49794);
 
 
 
@@ -62022,7 +62101,7 @@ var vtkTriangle$1 = {
 /* unused harmony exports extend, newInstance */
 /* harmony import */ var _macros2_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(90027);
 /* harmony import */ var _Common_Core_DataArray_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(445);
-/* harmony import */ var _Common_DataModel_PolyData_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(12548);
+/* harmony import */ var _Common_DataModel_PolyData_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(27480);
 
 
 
@@ -62375,7 +62454,7 @@ var vtkCutter$1 = {
 /* harmony import */ var _macros2_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(90027);
 /* harmony import */ var _Common_Core_CellArray_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(32461);
 /* harmony import */ var _Common_Core_DataArray_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(445);
-/* harmony import */ var _Common_DataModel_PolyData_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(12548);
+/* harmony import */ var _Common_DataModel_PolyData_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(27480);
 /* harmony import */ var _Common_Core_MatrixBuilder_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(90364);
 
 
@@ -63013,8 +63092,8 @@ __webpack_require__.d(__webpack_exports__, {
 
 // EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/macros2.js
 var macros2 = __webpack_require__(90027);
-// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/PolyData.js + 11 modules
-var PolyData = __webpack_require__(12548);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/PolyData.js + 7 modules
+var PolyData = __webpack_require__(27480);
 // EXTERNAL MODULE: ../../../node_modules/xmlbuilder2/lib/xmlbuilder2.min.js
 var xmlbuilder2_min = __webpack_require__(14235);
 ;// ../../../node_modules/fflate/esm/browser.js