@ohif/app 3.13.0-beta.88 → 3.13.0-beta.89

package/dist/{5491.bundle.4866d2ecb20dd089e071.js → 1124.bundle.3c1b947a1884362c1241.js}

@@ -1,4 +1,4 @@
-(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[5491],{
+(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[1124],{
 
 /***/ 45043
 (module) {
@@ -4059,9 +4059,7 @@ function createRangeHelper() {
     }
   };
 }
-function computeRange(values) {
-  let component = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-  let numberOfComponents = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
+function computeRange(values, component = 0, numberOfComponents = 1) {
   if (component < 0 && numberOfComponents > 1) {
     // Compute magnitude
     const size = values.length;
@@ -4077,8 +4075,7 @@ function computeRange(values) {
   }
   return fastComputeRange(values, component < 0 ? 0 : component, numberOfComponents);
 }
-function ensureRangeSize(rangeArray) {
-  let size = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+function ensureRangeSize(rangeArray, size = 0) {
   const ranges = rangeArray || [];
   // Pad ranges with null value to get the
   while (ranges.length <= size) {
@@ -4184,10 +4181,7 @@ function vtkDataArray(publicAPI, model) {
   // Description:
   // Return the data component at the location specified by tupleIdx and
   // compIdx.
-  publicAPI.getComponent = function (tupleIdx) {
-    let compIdx = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-    return model.values[tupleIdx * model.numberOfComponents + compIdx];
-  };
+  publicAPI.getComponent = (tupleIdx, compIdx = 0) => model.values[tupleIdx * model.numberOfComponents + compIdx];
 
   // Description:
   // Set the data component at the location specified by tupleIdx and compIdx
@@ -4212,8 +4206,7 @@ function vtkDataArray(publicAPI, model) {
     publicAPI.setComponent(idx, comp, value);
   };
   publicAPI.getData = () => model.size === model.values.length ? model.values : model.values.subarray(0, model.size);
-  publicAPI.getRange = function () {
-    let componentIndex = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : -1;
+  publicAPI.getRange = (componentIndex = -1) => {
     let rangeIdx = componentIndex;
     if (rangeIdx < 0) {
       // If scalar data, then store in slot 0 (same as componentIndex = 0).
@@ -4251,8 +4244,7 @@ function vtkDataArray(publicAPI, model) {
     model.rangeTuple[1] = range.max;
     return model.rangeTuple;
   };
-  publicAPI.getRanges = function () {
-    let computeRanges = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+  publicAPI.getRanges = (computeRanges = true) => {
     if (!computeRanges) {
       return structuredClone(model.ranges);
     }
@@ -4318,8 +4310,7 @@ function vtkDataArray(publicAPI, model) {
     const idx = model.size / model.numberOfComponents;
     return publicAPI.insertTuples(idx, tuples);
   };
-  publicAPI.findTuple = function (tuple) {
-    let precision = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : EPSILON;
+  publicAPI.findTuple = (tuple, precision = EPSILON) => {
     for (let i = 0; i < model.size; i += model.numberOfComponents) {
       if (Math.abs(tuple[0] - model.values[i]) <= precision) {
         let match = true;
@@ -4336,8 +4327,7 @@ function vtkDataArray(publicAPI, model) {
     }
     return -1;
   };
-  publicAPI.getTuple = function (idx) {
-    let tupleToFill = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  publicAPI.getTuple = (idx, tupleToFill = []) => {
     const numberOfComponents = model.numberOfComponents || 1;
     const offset = idx * numberOfComponents;
     // Check most common component sizes first
@@ -4368,10 +4358,7 @@ function vtkDataArray(publicAPI, model) {
     const arr = publicAPI.getData().subarray(from, to);
     return arr.length > 0 ? arr : null;
   };
-  publicAPI.getTupleLocation = function () {
-    let idx = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
-    return idx * model.numberOfComponents;
-  };
+  publicAPI.getTupleLocation = (idx = 1) => idx * model.numberOfComponents;
   publicAPI.getNumberOfComponents = () => model.numberOfComponents;
   publicAPI.getNumberOfValues = () => model.size;
   publicAPI.getNumberOfTuples = () => model.size / model.numberOfComponents;
@@ -4513,8 +4500,7 @@ const DEFAULT_VALUES = {
 
 // ----------------------------------------------------------------------------
 
-function extend(publicAPI, model) {
-  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+function extend(publicAPI, model, initialValues = {}) {
   Object.assign(model, DEFAULT_VALUES, initialValues);
   if (Array.isArray(initialValues.values) && initialValues.dataType === undefined) {
     console.warn('vtkDataArray.newInstance: no dataType provided, converting to Float32Array');
@@ -4649,7 +4635,7 @@ var Constants = {
 /* harmony export */   n: () => (/* binding */ norm),
 /* harmony export */   s: () => (/* binding */ subtract)
 /* harmony export */ });
-/* unused harmony exports $, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, _, a, a$, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE, aF, aG, aH, aI, aJ, aK, aL, aM, aN, aO, aP, aQ, aR, aS, aT, aU, aV, aW, aX, aY, aZ, a_, aa, ab, ac, ad, ae, af, ag, ah, ai, aj, ak, al, am, an, ao, ap, aq, ar, as, at, au, av, aw, ax, ay, az, b0, b1, f, g, h, i, l, m, o, p, q, r, t, u, v, w, x, y, z */
+/* unused harmony exports $, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, _, a, a$, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE, aF, aG, aH, aI, aJ, aK, aL, aM, aN, aO, aP, aQ, aR, aS, aT, aU, aV, aW, aX, aY, aZ, a_, aa, ab, ac, ad, ae, af, ag, ah, ai, aj, ak, al, am, an, ao, ap, aq, ar, as, at, au, av, aw, ax, ay, az, b0, b1, b2, f, g, h, i, l, m, o, p, q, r, t, u, v, w, x, y, z */
 /* harmony import */ var seedrandom__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(56037);
 /* harmony import */ var _macros2_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(90027);
 /* harmony import */ var _Constants_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(29330);
@@ -4698,8 +4684,7 @@ function swapColumnsMatrix_nxn(matrix, n, column1, column2) {
 // Global methods
 // ----------------------------------------------------------------------------
 
-function createArray() {
-  let size = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 3;
+function createArray(size = 3) {
   // faster than Array.from and/or while loop
   const res = Array(size);
   for (let i = 0; i < size; ++i) {
@@ -4730,9 +4715,7 @@ const {
   min,
   max
 } = Math;
-function arrayMin(arr) {
-  let offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-  let stride = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
+function arrayMin(arr, offset = 0, stride = 1) {
   let minValue = Infinity;
   for (let i = offset, len = arr.length; i < len; i += stride) {
     if (arr[i] < minValue) {
@@ -4741,9 +4724,7 @@ function arrayMin(arr) {
   }
   return minValue;
 }
-function arrayMax(arr) {
-  let offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-  let stride = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
+function arrayMax(arr, offset = 0, stride = 1) {
   let maxValue = -Infinity;
   for (let i = offset, len = arr.length; i < len; i += stride) {
     if (maxValue < arr[i]) {
@@ -4752,9 +4733,7 @@ function arrayMax(arr) {
   }
   return maxValue;
 }
-function arrayRange(arr) {
-  let offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-  let stride = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
+function arrayRange(arr, offset = 0, stride = 1) {
   let minValue = Infinity;
   let maxValue = -Infinity;
   for (let i = offset, len = arr.length; i < len; i += stride) {
@@ -4819,9 +4798,7 @@ function randomSeed(seed) {
 function getSeed() {
   return randomSeedValue;
 }
-function random() {
-  let minValue = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
-  let maxValue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+function random(minValue = 0, maxValue = 1) {
   const delta = maxValue - minValue;
   return minValue + delta * Math.random();
 }
@@ -4885,8 +4862,7 @@ function cross(x, y, out) {
   out[2] = Zz;
   return out;
 }
-function norm(x) {
-  let n = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 3;
+function norm(x, n = 3) {
   switch (n) {
     case 1:
       return Math.abs(x);
@@ -5081,10 +5057,7 @@ function columnsToMat3(column0, column1, column2, mat) {
   }
   return mat;
 }
-function determinant2x2() {
-  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-    args[_key] = arguments[_key];
-  }
+function determinant2x2(...args) {
   if (args.length === 2) {
     return args[0][0] * args[1][1] - args[1][0] * args[0][1];
   }
@@ -5306,8 +5279,7 @@ function determinant3x3(mat_3x3) {
  * @param {Array} b an array of numbers (vector, point, matrix...)
  * @param {Number} eps tolerance
  */
-function areEquals(a, b) {
-  let eps = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _Constants_js__WEBPACK_IMPORTED_MODULE_2__/* .EPSILON */ .p8;
+function areEquals(a, b, eps = _Constants_js__WEBPACK_IMPORTED_MODULE_2__/* .EPSILON */ .p8) {
   if (a.length !== b.length) {
     return false;
   }
@@ -5333,12 +5305,10 @@ function identity(n, mat) {
   }
   return mat;
 }
-function isIdentity(mat) {
-  let eps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _Constants_js__WEBPACK_IMPORTED_MODULE_2__/* .EPSILON */ .p8;
+function isIdentity(mat, eps = _Constants_js__WEBPACK_IMPORTED_MODULE_2__/* .EPSILON */ .p8) {
   return areMatricesEqual(mat, _Constants_js__WEBPACK_IMPORTED_MODULE_2__/* .IDENTITY */ .zK, eps);
 }
-function isIdentity3x3(mat) {
-  let eps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _Constants_js__WEBPACK_IMPORTED_MODULE_2__/* .EPSILON */ .p8;
+function isIdentity3x3(mat, eps = _Constants_js__WEBPACK_IMPORTED_MODULE_2__/* .EPSILON */ .p8) {
   return areMatricesEqual(mat, _Constants_js__WEBPACK_IMPORTED_MODULE_2__/* .IDENTITY_3X3 */ .GY, eps);
 }
 function quaternionToMatrix3x3(quat_4, mat_3x3) {
@@ -5367,8 +5337,7 @@ function quaternionToMatrix3x3(quat_4, mat_3x3) {
   mat_3x3[5] = (yz - wx) * f;
   mat_3x3[8] = zz * f + s;
 }
-function roundNumber(num) {
-  let digits = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+function roundNumber(num, digits = 0) {
   if (!`${num}`.includes('e')) {
     return +`${Math.round(`${num}e+${digits}`)}e-${digits}`;
   }
@@ -5379,9 +5348,7 @@ function roundNumber(num) {
   }
   return +`${Math.round(`${+arr[0]}e${sig}${+arr[1] + digits}`)}e-${digits}`;
 }
-function roundVector(vector) {
-  let out = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [0, 0, 0];
-  let digits = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+function roundVector(vector, out = [0, 0, 0], digits = 0) {
   out[0] = roundNumber(vector[0], digits);
   out[1] = roundNumber(vector[1], digits);
   out[2] = roundNumber(vector[2], digits);
@@ -5984,9 +5951,7 @@ function solveLinearSystem(A, x, size) {
 }
 
 // Note that A is modified during the inversion !
-function invertMatrix(A, AI, size) {
-  let index = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
-  let column = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;
+function invertMatrix(A, AI, size, index = null, column = null) {
   const tmp1Size = index || createArray(size);
   const tmp2Size = column || createArray(size);
 
@@ -6078,8 +6043,7 @@ function solveHomogeneousLeastSquares(numberOfSamples, xt, xOrder, mt) {
   }
   return 1;
 }
-function solveLeastSquares(numberOfSamples, xt, xOrder, yt, yOrder, mt) {
-  let checkHomogeneous = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : true;
+function solveLeastSquares(numberOfSamples, xt, xOrder, yt, yOrder, mt, checkHomogeneous = true) {
   // check dimensional consistency
   if (numberOfSamples < xOrder || numberOfSamples < yOrder) {
     vtkWarningMacro('Insufficient number of samples. Underdetermined.');
@@ -6203,8 +6167,7 @@ function solveLeastSquares(numberOfSamples, xt, xOrder, yt, yOrder, mt) {
   }
   return successFlag;
 }
-function hex2float(hexStr) {
-  let outFloatArray = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [0, 0.5, 1];
+function hex2float(hexStr, outFloatArray = [0, 0.5, 1]) {
   switch (hexStr.length) {
     case 3:
       // abc => #aabbcc
@@ -6370,7 +6333,6 @@ function lab2xyz(lab, xyz) {
   xyz[1] = ref_Y * var_Y; // ref_Y = 1.000
   xyz[2] = ref_Z * var_Z; // ref_Z = 1.089
 }
-
 function xyz2lab(xyz, lab) {
   const [x, y, z] = xyz;
   const ref_X = 0.9505;
@@ -6488,8 +6450,7 @@ function clampValue(value, minValue, maxValue) {
   }
   return value;
 }
-function clampVector(vector, minVector, maxVector) {
-  let out = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [0, 0, 0];
+function clampVector(vector, minVector, maxVector, out = [0, 0, 0]) {
   out[0] = clampValue(vector[0], minVector[0], maxVector[0]);
   out[1] = clampValue(vector[1], minVector[1], maxVector[1]);
   out[2] = clampValue(vector[2], minVector[2], maxVector[2]);
@@ -6596,7 +6557,6 @@ function createUninitializedBounds() {
   Number.MAX_VALUE, -Number.MAX_VALUE // Z
   ]);
 }
-
 function getMajorAxisIndex(vector) {
   let maxValue = -1;
   let axisIndex = -1;
@@ -6609,6 +6569,18 @@ function getMajorAxisIndex(vector) {
   }
   return axisIndex;
 }
+function getMinorAxisIndex(vector) {
+  let minValue = Infinity;
+  let axisIndex = -1;
+  for (let i = 0; i < vector.length; i++) {
+    const value = Math.abs(vector[i]);
+    if (value < minValue) {
+      axisIndex = i;
+      minValue = value;
+    }
+  }
+  return axisIndex;
+}
 
 // Return the closest orthogonal matrix of 1, -1 and 0
 // It works for both column major and row major matrices
@@ -6616,8 +6588,7 @@ function getMajorAxisIndex(vector) {
 // the greatest absolute value from the remaining row and columns
 // For each association, a -1 or a 1 is set in the output, depending on
 // the sign of the value in the original matrix
-function getSparseOrthogonalMatrix(matrix) {
-  let n = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 3;
+function getSparseOrthogonalMatrix(matrix, n = 3) {
   // Initialize rows and columns to available indices
   const rows = new Array(n);
   const cols = new Array(n);
@@ -6666,8 +6637,7 @@ function floatToHex2(value) {
   }
   return `0${integer.toString(16)}`;
 }
-function floatRGB2HexCode(rgbArray) {
-  let prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '#';
+function floatRGB2HexCode(rgbArray, prefix = '#') {
   return `${prefix}${rgbArray.map(floatToHex2).join('')}`;
 }
 function floatToChar(f) {
@@ -6793,6 +6763,7 @@ var vtkMath = {
   // JS add-on
   createUninitializedBounds,
   getMajorAxisIndex,
+  getMinorAxisIndex,
   getSparseOrthogonalMatrix,
   floatToHex2,
   floatRGB2HexCode,
@@ -6915,6 +6886,7 @@ var vtkMath$1 = /*#__PURE__*/Object.freeze({
   isNan: isNan,
   createUninitializedBounds: createUninitializedBounds,
   getMajorAxisIndex: getMajorAxisIndex,
+  getMinorAxisIndex: getMinorAxisIndex,
   getSparseOrthogonalMatrix: getSparseOrthogonalMatrix,
   floatToHex2: floatToHex2,
   floatRGB2HexCode: floatRGB2HexCode,
@@ -6964,20 +6936,17 @@ const CellGhostTypes = {
   // the cell is on the exterior of the data set
   HIDDENCELL: 32 // the cell is needed to maintain connectivity, but the data values should be ignored.
 };
-
 const PointGhostTypes = {
   DUPLICATEPOINT: 1,
   // the cell is present on multiple processors
   HIDDENPOINT: 2 // the point is needed to maintain connectivity, but the data values should be ignored.
 };
-
 const AttributeCopyOperations = {
   COPYTUPLE: 0,
   INTERPOLATE: 1,
   PASSDATA: 2,
   ALLCOPY: 3 // all of the above
 };
-
 const ghostArrayName = 'vtkGhostType';
 const DesiredOutputPrecision = {
   DEFAULT: 0,
@@ -6986,7 +6955,6 @@ const DesiredOutputPrecision = {
   // use Float32Array
   DOUBLE: 2 // use Float64Array
 };
-
 var Constants = {
   AttributeCopyOperations,
   AttributeLimitTypes,
@@ -7036,14 +7004,11 @@ const {
 function vtkImageData(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkImageData');
-  publicAPI.setExtent = function () {
+  publicAPI.setExtent = (...inExtent) => {
     if (model.deleted) {
       vtkErrorMacro('instance deleted - cannot call any method');
       return false;
     }
-    for (var _len = arguments.length, inExtent = new Array(_len), _key = 0; _key < _len; _key++) {
-      inExtent[_key] = arguments[_key];
-    }
     const extentArray = inExtent.length === 1 ? inExtent[0] : inExtent;
     if (extentArray.length !== 6) {
       return false;
@@ -7056,7 +7021,7 @@ function vtkImageData(publicAPI, model) {
     }
     return changeDetected;
   };
-  publicAPI.setDimensions = function () {
+  publicAPI.setDimensions = (...dims) => {
     let i;
     let j;
     let k;
@@ -7064,15 +7029,15 @@ function vtkImageData(publicAPI, model) {
       vtkErrorMacro('instance deleted - cannot call any method');
       return;
     }
-    if (arguments.length === 1) {
-      const array = arguments.length <= 0 ? undefined : arguments[0];
+    if (dims.length === 1) {
+      const array = dims[0];
       i = array[0];
       j = array[1];
       k = array[2];
-    } else if (arguments.length === 3) {
-      i = arguments.length <= 0 ? undefined : arguments[0];
-      j = arguments.length <= 1 ? undefined : arguments[1];
-      k = arguments.length <= 2 ? undefined : arguments[2];
+    } else if (dims.length === 3) {
+      i = dims[0];
+      j = dims[1];
+      k = dims[2];
     } else {
       vtkErrorMacro('Bad dimension specification');
       return;
@@ -7190,26 +7155,18 @@ function vtkImageData(publicAPI, model) {
     gl_matrix__WEBPACK_IMPORTED_MODULE_6__/* .mat4.scale */ .pB.scale(model.indexToWorld, model.indexToWorld, model.spacing);
     gl_matrix__WEBPACK_IMPORTED_MODULE_6__/* .mat4.invert */ .pB.invert(model.worldToIndex, model.indexToWorld);
   };
-  publicAPI.indexToWorld = function (ain) {
-    let aout = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  publicAPI.indexToWorld = (ain, aout = []) => {
     gl_matrix__WEBPACK_IMPORTED_MODULE_6__/* .vec3.transformMat4 */ .eR.transformMat4(aout, ain, model.indexToWorld);
     return aout;
   };
   publicAPI.indexToWorldVec3 = publicAPI.indexToWorld;
-  publicAPI.worldToIndex = function (ain) {
-    let aout = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  publicAPI.worldToIndex = (ain, aout = []) => {
     gl_matrix__WEBPACK_IMPORTED_MODULE_6__/* .vec3.transformMat4 */ .eR.transformMat4(aout, ain, model.worldToIndex);
     return aout;
   };
   publicAPI.worldToIndexVec3 = publicAPI.worldToIndex;
-  publicAPI.indexToWorldBounds = function (bin) {
-    let bout = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
-    return _BoundingBox_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"].transformBounds */ .Ay.transformBounds(bin, model.indexToWorld, bout);
-  };
-  publicAPI.worldToIndexBounds = function (bin) {
-    let bout = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
-    return _BoundingBox_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"].transformBounds */ .Ay.transformBounds(bin, model.worldToIndex, bout);
-  };
+  publicAPI.indexToWorldBounds = (bin, bout = []) => _BoundingBox_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"].transformBounds */ .Ay.transformBounds(bin, model.indexToWorld, bout);
+  publicAPI.worldToIndexBounds = (bin, bout = []) => _BoundingBox_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"].transformBounds */ .Ay.transformBounds(bin, model.worldToIndex, bout);
 
   // Make sure the transform is correct
   model._onOriginChanged = publicAPI.computeTransforms;
@@ -7217,8 +7174,7 @@ function vtkImageData(publicAPI, model) {
   model._onSpacingChanged = publicAPI.computeTransforms;
   publicAPI.computeTransforms();
   publicAPI.getCenter = () => _BoundingBox_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"].getCenter */ .Ay.getCenter(publicAPI.getBounds());
-  publicAPI.computeHistogram = function (worldBounds) {
-    let voxelFunction = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+  publicAPI.computeHistogram = (worldBounds, voxelFunction = null) => {
     const bounds = [0, 0, 0, 0, 0, 0];
     publicAPI.worldToIndexBounds(worldBounds, bounds);
     const point1 = [0, 0, 0];
@@ -7268,8 +7224,7 @@ function vtkImageData(publicAPI, model) {
 
   // TODO: use the unimplemented `vtkDataSetAttributes` for scalar length, that is currently also a TODO (GetNumberOfComponents).
   // Scalar data could be tuples for color information?
-  publicAPI.computeIncrements = function (extent) {
-    let numberOfComponents = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+  publicAPI.computeIncrements = (extent, numberOfComponents = 1) => {
     const increments = [];
     let incr = numberOfComponents;
 
@@ -7286,8 +7241,7 @@ function vtkImageData(publicAPI, model) {
    * @param {Number[]} index the localized `[i,j,k]` pixel array position. Float values will be rounded.
    * @return {Number} the corresponding flattened index in the scalar array
    */
-  publicAPI.computeOffsetIndex = _ref => {
-    let [i, j, k] = _ref;
+  publicAPI.computeOffsetIndex = ([i, j, k]) => {
     const extent = publicAPI.getExtent();
     const numberOfComponents = publicAPI.getPointData().getScalars().getNumberOfComponents();
     const increments = publicAPI.computeIncrements(extent, numberOfComponents);
@@ -7321,8 +7275,7 @@ function vtkImageData(publicAPI, model) {
    * @param {Number?} comp the scalar component index for multi-component scalars
    * @return {Number|NaN} the corresponding pixel's scalar value
    */
-  publicAPI.getScalarValueFromWorld = function (xyz) {
-    let comp = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  publicAPI.getScalarValueFromWorld = (xyz, comp = 0) => {
     const numberOfComponents = publicAPI.getPointData().getScalars().getNumberOfComponents();
     if (comp < 0 || comp >= numberOfComponents) {
       vtkErrorMacro(`GetScalarPointer: Scalar Component ${comp} is not within bounds. Current Scalar numberOfComponents: ${numberOfComponents}`);
@@ -7367,8 +7320,7 @@ const DEFAULT_VALUES = {
 
 // ----------------------------------------------------------------------------
 
-function extend(publicAPI, model) {
-  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+function extend(publicAPI, model, initialValues = {}) {
   Object.assign(model, DEFAULT_VALUES, initialValues);
 
   // Inheritance
@@ -7405,6 +7357,276 @@ var vtkImageData$1 = {
 
 
 
+/***/ },
+
+/***/ 49794
+(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   Ay: () => (/* binding */ vtkPlane$1)
+/* harmony export */ });
+/* unused harmony exports STATIC, extend, newInstance, vtkPlane */
+/* harmony import */ var _Core_Math_index_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(8047);
+/* harmony import */ var _macros2_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(90027);
+/* harmony import */ var _ImplicitFunction_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(53001);
+
+
+
+
+const PLANE_TOLERANCE = 1.0e-6;
+const COINCIDE = 'coincide';
+const DISJOINT = 'disjoint';
+
+// ----------------------------------------------------------------------------
+// Global methods
+// ----------------------------------------------------------------------------
+
+function evaluate(normal, origin, x) {
+  return normal[0] * (x[0] - origin[0]) + normal[1] * (x[1] - origin[1]) + normal[2] * (x[2] - origin[2]);
+}
+function distanceToPlane(x, origin, normal) {
+  const distance = normal[0] * (x[0] - origin[0]) + normal[1] * (x[1] - origin[1]) + normal[2] * (x[2] - origin[2]);
+  return Math.abs(distance);
+}
+function projectPoint(x, origin, normal, xproj) {
+  const xo = [];
+  (0,_Core_Math_index_js__WEBPACK_IMPORTED_MODULE_0__.s)(x, origin, xo);
+  const t = (0,_Core_Math_index_js__WEBPACK_IMPORTED_MODULE_0__.d)(normal, xo);
+  xproj[0] = x[0] - t * normal[0];
+  xproj[1] = x[1] - t * normal[1];
+  xproj[2] = x[2] - t * normal[2];
+}
+function projectVector(v, normal, vproj) {
+  const t = (0,_Core_Math_index_js__WEBPACK_IMPORTED_MODULE_0__.d)(v, normal);
+  let n2 = (0,_Core_Math_index_js__WEBPACK_IMPORTED_MODULE_0__.d)(normal, normal);
+  if (n2 === 0) {
+    n2 = 1.0;
+  }
+  vproj[0] = v[0] - t * normal[0] / n2;
+  vproj[1] = v[1] - t * normal[1] / n2;
+  vproj[2] = v[2] - t * normal[2] / n2;
+  return vproj;
+}
+function generalizedProjectPoint(x, origin, normal, xproj) {
+  const xo = [];
+  (0,_Core_Math_index_js__WEBPACK_IMPORTED_MODULE_0__.s)(x, origin, xo);
+  const t = (0,_Core_Math_index_js__WEBPACK_IMPORTED_MODULE_0__.d)(normal, xo);
+  const n2 = (0,_Core_Math_index_js__WEBPACK_IMPORTED_MODULE_0__.d)(normal, normal);
+  if (n2 !== 0) {
+    xproj[0] = x[0] - t * normal[0] / n2;
+    xproj[1] = x[1] - t * normal[1] / n2;
+    xproj[2] = x[2] - t * normal[2] / n2;
+  } else {
+    xproj[0] = x[0];
+    xproj[1] = x[1];
+    xproj[2] = x[2];
+  }
+}
+function intersectWithLine(p1, p2, origin, normal) {
+  const outObj = {
+    intersection: false,
+    betweenPoints: false,
+    t: Number.MAX_VALUE,
+    x: []
+  };
+  const p21 = [];
+  const p1Origin = [];
+  // Compute line vector
+  (0,_Core_Math_index_js__WEBPACK_IMPORTED_MODULE_0__.s)(p2, p1, p21);
+  (0,_Core_Math_index_js__WEBPACK_IMPORTED_MODULE_0__.s)(origin, p1, p1Origin);
+
+  // Compute denominator.  If ~0, line and plane are parallel.
+  // const num = vtkMath.dot(normal, origin) - vtkMath.dot(normal, p1);
+  const num = (0,_Core_Math_index_js__WEBPACK_IMPORTED_MODULE_0__.d)(normal, p1Origin);
+  const den = (0,_Core_Math_index_js__WEBPACK_IMPORTED_MODULE_0__.d)(normal, p21);
+
+  // If denominator with respect to numerator is "zero", then the line and
+  // plane are considered parallel.
+  let fabsden;
+  let fabstolerance;
+
+  // Trying to avoid an expensive call to fabs()
+  if (den < 0.0) {
+    fabsden = -den;
+  } else {
+    fabsden = den;
+  }
+  if (num < 0.0) {
+    fabstolerance = -num * PLANE_TOLERANCE;
+  } else {
+    fabstolerance = num * PLANE_TOLERANCE;
+  }
+  if (fabsden <= fabstolerance) {
+    return outObj;
+  }
+
+  // Where on the line between p1 and p2 is the intersection
+  // If between 0 and 1, it is between the two points. If < 0 it's before p1, if > 1 it's after p2
+  outObj.t = num / den;
+  outObj.x[0] = p1[0] + outObj.t * p21[0];
+  outObj.x[1] = p1[1] + outObj.t * p21[1];
+  outObj.x[2] = p1[2] + outObj.t * p21[2];
+  outObj.intersection = true;
+  outObj.betweenPoints = outObj.t >= 0.0 && outObj.t <= 1.0;
+  return outObj;
+}
+function intersectWithPlane(plane1Origin, plane1Normal, plane2Origin, plane2Normal) {
+  const outObj = {
+    intersection: false,
+    l0: [],
+    l1: [],
+    error: null
+  };
+  const cross$1 = [];
+  (0,_Core_Math_index_js__WEBPACK_IMPORTED_MODULE_0__.j)(plane1Normal, plane2Normal, cross$1);
+  const absCross = cross$1.map(n => Math.abs(n));
+
+  // test if the two planes are parallel
+  if (absCross[0] + absCross[1] + absCross[2] < PLANE_TOLERANCE) {
+    // test if disjoint or coincide
+    const v = [];
+    (0,_Core_Math_index_js__WEBPACK_IMPORTED_MODULE_0__.s)(plane1Origin, plane2Origin, v);
+    if ((0,_Core_Math_index_js__WEBPACK_IMPORTED_MODULE_0__.d)(plane1Normal, v) === 0) {
+      outObj.error = COINCIDE;
+    } else {
+      outObj.error = DISJOINT;
+    }
+    return outObj;
+  }
+
+  // Plane1 and Plane2 intersect in a line
+  // first determine max abs coordinate of the cross product
+  let maxc;
+  if (absCross[0] > absCross[1] && absCross[0] > absCross[2]) {
+    maxc = 'x';
+  } else if (absCross[1] > absCross[2]) {
+    maxc = 'y';
+  } else {
+    maxc = 'z';
+  }
+
+  // To get a point on the intersect line, zero the max coord, and solve for the other two
+  const iP = []; // intersectionPoint
+  // the constants in the 2 plane equations
+  const d1 = -(0,_Core_Math_index_js__WEBPACK_IMPORTED_MODULE_0__.d)(plane1Normal, plane1Origin);
+  const d2 = -(0,_Core_Math_index_js__WEBPACK_IMPORTED_MODULE_0__.d)(plane2Normal, plane2Origin);
+
+  // eslint-disable-next-line default-case
+  switch (maxc) {
+    case 'x':
+      // intersect with x=0
+      iP[0] = 0;
+      iP[1] = (d2 * plane1Normal[2] - d1 * plane2Normal[2]) / cross$1[0];
+      iP[2] = (d1 * plane2Normal[1] - d2 * plane1Normal[1]) / cross$1[0];
+      break;
+    case 'y':
+      // intersect with y=0
+      iP[0] = (d1 * plane2Normal[2] - d2 * plane1Normal[2]) / cross$1[1];
+      iP[1] = 0;
+      iP[2] = (d2 * plane1Normal[0] - d1 * plane2Normal[0]) / cross$1[1];
+      break;
+    case 'z':
+      // intersect with z=0
+      iP[0] = (d2 * plane1Normal[1] - d1 * plane2Normal[1]) / cross$1[2];
+      iP[1] = (d1 * plane2Normal[0] - d2 * plane1Normal[0]) / cross$1[2];
+      iP[2] = 0;
+      break;
+  }
+  outObj.l0 = iP;
+  (0,_Core_Math_index_js__WEBPACK_IMPORTED_MODULE_0__.k)(iP, cross$1, outObj.l1);
+  outObj.intersection = true;
+  return outObj;
+}
+
+// ----------------------------------------------------------------------------
+// Static API
+// ----------------------------------------------------------------------------
+
+const STATIC = {
+  evaluate,
+  distanceToPlane,
+  projectPoint,
+  projectVector,
+  generalizedProjectPoint,
+  intersectWithLine,
+  intersectWithPlane,
+  DISJOINT,
+  COINCIDE
+};
+
+// ----------------------------------------------------------------------------
+// vtkPlane methods
+// ----------------------------------------------------------------------------
+
+function vtkPlane(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkPlane');
+  publicAPI.distanceToPlane = x => distanceToPlane(x, model.origin, model.normal);
+  publicAPI.projectPoint = (x, xproj) => {
+    projectPoint(x, model.origin, model.normal, xproj);
+  };
+  publicAPI.projectVector = (v, vproj) => projectVector(v, model.normal, vproj);
+  publicAPI.push = distance => {
+    if (distance === 0.0) {
+      return;
+    }
+    for (let i = 0; i < 3; i++) {
+      model.origin[i] += distance * model.normal[i];
+    }
+  };
+  publicAPI.generalizedProjectPoint = (x, xproj) => {
+    generalizedProjectPoint(x, model.origin, model.normal, xproj);
+  };
+  publicAPI.evaluateFunction = (x, y, z) => {
+    if (!Array.isArray(x)) {
+      return model.normal[0] * (x - model.origin[0]) + model.normal[1] * (y - model.origin[1]) + model.normal[2] * (z - model.origin[2]);
+    }
+    return model.normal[0] * (x[0] - model.origin[0]) + model.normal[1] * (x[1] - model.origin[1]) + model.normal[2] * (x[2] - model.origin[2]);
+  };
+  publicAPI.evaluateGradient = xyz => {
+    const retVal = [model.normal[0], model.normal[1], model.normal[2]];
+    return retVal;
+  };
+  publicAPI.intersectWithLine = (p1, p2) => intersectWithLine(p1, p2, model.origin, model.normal);
+  publicAPI.intersectWithPlane = (planeOrigin, planeNormal) => intersectWithPlane(planeOrigin, planeNormal, model.origin, model.normal);
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+const DEFAULT_VALUES = {
+  normal: [0.0, 0.0, 1.0],
+  origin: [0.0, 0.0, 0.0]
+};
+
+// ----------------------------------------------------------------------------
+
+function extend(publicAPI, model, initialValues = {}) {
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+
+  // Object methods
+  _ImplicitFunction_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"].extend */ .Ay.extend(publicAPI, model, initialValues);
+  _macros2_js__WEBPACK_IMPORTED_MODULE_1__.m.setGetArray(publicAPI, model, ['normal', 'origin'], 3);
+  vtkPlane(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = _macros2_js__WEBPACK_IMPORTED_MODULE_1__.m.newInstance(extend, 'vtkPlane');
+
+// ----------------------------------------------------------------------------
+
+var vtkPlane$1 = {
+  newInstance,
+  extend,
+  ...STATIC
+};
+
+
+
+
 /***/ },
 
 /***/ 90027
@@ -7466,20 +7688,20 @@ function setLoggerFunction(name, fn) {
     loggerFunctions[name] = fn || noOp;
   }
 }
-function vtkLogMacro() {
-  loggerFunctions.log(...arguments);
+function vtkLogMacro(...args) {
+  loggerFunctions.log(...args);
 }
-function vtkInfoMacro() {
-  loggerFunctions.info(...arguments);
+function vtkInfoMacro(...args) {
+  loggerFunctions.info(...args);
 }
-function vtkDebugMacro() {
-  loggerFunctions.debug(...arguments);
+function vtkDebugMacro(...args) {
+  loggerFunctions.debug(...args);
 }
-function vtkErrorMacro() {
-  loggerFunctions.error(...arguments);
+function vtkErrorMacro(...args) {
+  loggerFunctions.error(...args);
 }
-function vtkWarningMacro() {
-  loggerFunctions.warn(...arguments);
+function vtkWarningMacro(...args) {
+  loggerFunctions.warn(...args);
 }
 const ERROR_ONCE_MAP = {};
 function vtkOnceErrorMacro(str) {
@@ -7509,16 +7731,10 @@ try {
 } catch {
   // ignore
 }
-function newTypedArray(type) {
-  for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-    args[_key - 1] = arguments[_key];
-  }
+function newTypedArray(type, ...args) {
   return new (TYPED_ARRAYS[type] || Float64Array)(...args);
 }
-function newTypedArrayFrom(type) {
-  for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
-    args[_key2 - 1] = arguments[_key2];
-  }
+function newTypedArrayFrom(type, ...args) {
   return (TYPED_ARRAYS[type] || Float64Array).from(...args);
 }
 
@@ -7540,9 +7756,7 @@ function uncapitalize(str) {
 // Convert byte size into a well formatted string
 // ----------------------------------------------------------------------------
 
-function formatBytesToProperUnit(size) {
-  let precision = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 2;
-  let chunkSize = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1000;
+function formatBytesToProperUnit(size, precision = 2, chunkSize = 1000) {
   const units = ['TB', 'GB', 'MB', 'KB'];
   let value = Number(size);
   let currentUnit = 'B';
@@ -7557,8 +7771,7 @@ function formatBytesToProperUnit(size) {
 // Convert thousand number with proper separator
 // ----------------------------------------------------------------------------
 
-function formatNumbersWithThousandSeparator(n) {
-  let separator = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ' ';
+function formatNumbersWithThousandSeparator(n, separator = ' ') {
   const sections = [];
   let size = n;
   while (size > 1000) {
@@ -7649,9 +7862,7 @@ function measurePromiseExecution(promise, callback) {
 // vtkObject: modified(), onModified(callback), delete()
 // ----------------------------------------------------------------------------
 
-function obj() {
-  let publicAPI = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  let model = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+function obj(publicAPI = {}, model = {}) {
   // Ensure each instance as a unique ref of array
   safeArrays(model);
   const callbacks = [];
@@ -7711,14 +7922,8 @@ function obj() {
     }
     return false;
   };
-  publicAPI.getClassName = function () {
-    let depth = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
-    return model.classHierarchy[model.classHierarchy.length - 1 - depth];
-  };
-  publicAPI.set = function () {
-    let map = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    let noWarning = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-    let noFunction = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  publicAPI.getClassName = (depth = 0) => model.classHierarchy[model.classHierarchy.length - 1 - depth];
+  publicAPI.set = (map = {}, noWarning = false, noFunction = false) => {
     let ret = false;
     Object.keys(map).forEach(name => {
       const fn = noFunction ? null : publicAPI[`set${capitalize(name)}`];
@@ -7737,10 +7942,7 @@ function obj() {
     });
     return ret;
   };
-  publicAPI.get = function () {
-    for (var _len3 = arguments.length, list = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
-      list[_key3] = arguments[_key3];
-    }
+  publicAPI.get = (...list) => {
     if (!list.length) {
       return model;
     }
@@ -7797,8 +7999,7 @@ function obj() {
   };
 
   // Add shallowCopy(otherInstance) support
-  publicAPI.shallowCopy = function (other) {
-    let debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  publicAPI.shallowCopy = (other, debug = false) => {
     if (other.getClassName() !== publicAPI.getClassName()) {
       throw new Error(`Cannot ShallowCopy ${other.getClassName()} into ${publicAPI.getClassName()}`);
     }
@@ -7903,10 +8104,7 @@ const objectSetterMap = {
       vtkWarningMacro('Setter of type "object" with a single "param" field is not supported');
     }
     const onChanged = `_on${_capitalize(field.name)}Changed`;
-    return function () {
-      for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
-        args[_key4] = arguments[_key4];
-      }
+    return (...args) => {
       let value;
       if (args.length > 1 && field.params?.length) {
         value = field.params.reduce((acc, prop, idx) => Object.assign(acc, {
@@ -7990,21 +8188,17 @@ function getArray(publicAPI, model, fieldNames) {
 // set...From: fast path to copy the content of an array to the current one without call to modified.
 // ----------------------------------------------------------------------------
 
-function setArray(publicAPI, model, fieldNames, size) {
-  let defaultVal = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : undefined;
+function setArray(publicAPI, model, fieldNames, size, defaultVal = undefined) {
   fieldNames.forEach(field => {
     if (model[field] && size && model[field].length !== size) {
       throw new RangeError(`Invalid initial number of values for array (${field})`);
     }
     const onChanged = `_on${_capitalize(field)}Changed`;
-    publicAPI[`set${_capitalize(field)}`] = function () {
+    publicAPI[`set${_capitalize(field)}`] = (...args) => {
       if (model.deleted) {
         vtkErrorMacro('instance deleted - cannot call any method');
         return false;
       }
-      for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
-        args[_key5] = arguments[_key5];
-      }
       let array = args;
       let changeDetected;
       let needCopy = false;
@@ -8056,8 +8250,7 @@ function setArray(publicAPI, model, fieldNames, size) {
 // set/get XXX: add setter and getter for object of type array
 // ----------------------------------------------------------------------------
 
-function setGetArray(publicAPI, model, fieldNames, size) {
-  let defaultVal = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : undefined;
+function setGetArray(publicAPI, model, fieldNames, size, defaultVal = undefined) {
   getArray(publicAPI, model, fieldNames);
   setArray(publicAPI, model, fieldNames, size, defaultVal);
 }
@@ -8100,8 +8293,7 @@ function algo(publicAPI, model, numberOfInputs, numberOfOutputs) {
   model.numberOfInputs = numberOfInputs;
 
   // Methods
-  function setInputData(dataset) {
-    let port = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  function setInputData(dataset, port = 0) {
     if (model.deleted) {
       vtkErrorMacro('instance deleted - cannot call any method');
       return;
@@ -8118,15 +8310,13 @@ function algo(publicAPI, model, numberOfInputs, numberOfOutputs) {
       }
     }
   }
-  function getInputData() {
-    let port = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+  function getInputData(port = 0) {
     if (model.inputConnection[port]) {
       model.inputData[port] = model.inputConnection[port]();
     }
     return model.inputData[port];
   }
-  function setInputConnection(outputPort) {
-    let port = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  function setInputConnection(outputPort, port = 0) {
     if (model.deleted) {
       vtkErrorMacro('instance deleted - cannot call any method');
       return;
@@ -8141,8 +8331,7 @@ function algo(publicAPI, model, numberOfInputs, numberOfOutputs) {
     model.inputData[port] = null;
     model.inputConnection[port] = outputPort;
   }
-  function getInputConnection() {
-    let port = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+  function getInputConnection(port = 0) {
     return model.inputConnection[port];
   }
   function getPortToFill() {
@@ -8169,8 +8358,7 @@ function algo(publicAPI, model, numberOfInputs, numberOfOutputs) {
     }
     setInputData(dataset, getPortToFill());
   }
-  function getOutputData() {
-    let port = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+  function getOutputData(port = 0) {
     if (model.deleted) {
       vtkErrorMacro('instance deleted - cannot call any method');
       return null;
@@ -8204,8 +8392,7 @@ function algo(publicAPI, model, numberOfInputs, numberOfOutputs) {
     }
     return false;
   };
-  function getOutputPort() {
-    let port = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+  function getOutputPort(port = 0) {
     const outputPortAccess = () => getOutputData(port);
     // Add reference to filter
     outputPortAccess.filter = publicAPI;
@@ -8256,8 +8443,7 @@ function algo(publicAPI, model, numberOfInputs, numberOfOutputs) {
     }
     return null;
   };
-  publicAPI.setInputArrayToProcess = function (inputPort, arrayName, fieldAssociation) {
-    let attributeType = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'Scalars';
+  publicAPI.setInputArrayToProcess = (inputPort, arrayName, fieldAssociation, attributeType = 'Scalars') => {
     while (model.inputArrayToProcess.length < inputPort) {
       model.inputArrayToProcess.push(null);
     }
@@ -8309,7 +8495,6 @@ function event(publicAPI, model, eventName) {
       if (!cb) {
         continue; // eslint-disable-line
       }
-
       if (priority < 0) {
         setTimeout(() => cb.apply(publicAPI, arguments), 1 - priority);
       } else {
@@ -8322,10 +8507,8 @@ function event(publicAPI, model, eventName) {
     }
     /* eslint-enable prefer-rest-params */
   }
-
   publicAPI[`invoke${_capitalize(eventName)}`] = invoke;
-  publicAPI[`on${_capitalize(eventName)}`] = function (callback) {
-    let priority = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0.0;
+  publicAPI[`on${_capitalize(eventName)}`] = (callback, priority = 0.0) => {
     if (!callback.apply) {
       console.error(`Invalid callback for event ${eventName}`);
       return null;
@@ -8341,10 +8524,7 @@ function event(publicAPI, model, eventName) {
   };
   publicAPI.delete = () => {
     previousDelete();
-    callbacks.forEach(_ref => {
-      let [cbID] = _ref;
-      return off(cbID);
-    });
+    callbacks.forEach(([cbID]) => off(cbID));
   };
 }
 
@@ -8353,8 +8533,7 @@ function event(publicAPI, model, eventName) {
 // ----------------------------------------------------------------------------
 
 function newInstance(extend, className) {
-  const constructor = function () {
-    let initialValues = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  const constructor = (initialValues = {}) => {
     const model = {};
     const publicAPI = {};
     extend(publicAPI, model, initialValues);
@@ -8372,16 +8551,8 @@ function newInstance(extend, className) {
 // Chain function calls
 // ----------------------------------------------------------------------------
 
-function chain() {
-  for (var _len6 = arguments.length, fn = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
-    fn[_key6] = arguments[_key6];
-  }
-  return function () {
-    for (var _len7 = arguments.length, args = new Array(_len7), _key7 = 0; _key7 < _len7; _key7++) {
-      args[_key7] = arguments[_key7];
-    }
-    return fn.filter(i => !!i).map(i => i(...args));
-  };
+function chain(...fn) {
+  return (...args) => fn.filter(i => !!i).map(i => i(...args));
 }
 
 // ----------------------------------------------------------------------------
@@ -8391,9 +8562,7 @@ function chain() {
 function isVtkObject(instance) {
   return instance && instance.isA && instance.isA('vtkObject');
 }
-function traverseInstanceTree(instance, extractFunction) {
-  let accumulator = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
-  let visitedInstances = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
+function traverseInstanceTree(instance, extractFunction, accumulator = [], visitedInstances = []) {
   if (isVtkObject(instance)) {
     if (visitedInstances.indexOf(instance) >= 0) {
       // avoid cycles
@@ -8428,13 +8597,9 @@ function traverseInstanceTree(instance, extractFunction) {
 // leading edge, instead of the trailing.
 
 function debounce(func, wait, immediate) {
-  var _this = this;
   let timeout;
-  const debounced = function () {
-    for (var _len8 = arguments.length, args = new Array(_len8), _key8 = 0; _key8 < _len8; _key8++) {
-      args[_key8] = arguments[_key8];
-    }
-    const context = _this;
+  const debounced = (...args) => {
+    const context = this;
     const later = () => {
       timeout = null;
       if (!immediate) {
@@ -8466,10 +8631,7 @@ function throttle(callback, delay) {
       argsToUse = null;
     }
   }
-  function wrapper() {
-    for (var _len9 = arguments.length, args = new Array(_len9), _key9 = 0; _key9 < _len9; _key9++) {
-      args[_key9] = arguments[_key9];
-    }
+  function wrapper(...args) {
     if (isThrottled) {
       argsToUse = args;
       return;
@@ -8494,8 +8656,7 @@ function throttle(callback, delay) {
 //  deleteKey(key) : Boolean
 // ----------------------------------------------------------------------------
 
-function keystore(publicAPI, model) {
-  let initialKeystore = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+function keystore(publicAPI, model, initialKeystore = {}) {
   model.keystore = Object.assign(model.keystore || {}, initialKeystore);
   publicAPI.setKey = (key, value) => {
     model.keystore[key] = value;
@@ -8557,8 +8718,7 @@ function proxy(publicAPI, model) {
     registerProperties(model.ui, ROOT_GROUP_NAME);
     publicAPI.modified();
   };
-  function listProxyProperties() {
-    let gName = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ROOT_GROUP_NAME;
+  function listProxyProperties(gName = ROOT_GROUP_NAME) {
     return groupChildrenNames[gName];
   }
   publicAPI.updateProxyProperty = (propertyName, propUI) => {
@@ -8595,8 +8755,7 @@ function proxy(publicAPI, model) {
     }
   };
   model.propertyLinkMap = {};
-  publicAPI.getPropertyLink = function (id) {
-    let persistent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  publicAPI.getPropertyLink = (id, persistent = false) => {
     if (model.propertyLinkMap[id]) {
       return model.propertyLinkMap[id];
     }
@@ -8604,8 +8763,7 @@ function proxy(publicAPI, model) {
     const links = [];
     let count = 0;
     let updateInProgress = false;
-    function update(source) {
-      let force = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    function update(source, force = false) {
       if (updateInProgress) {
         return null;
       }
@@ -8654,8 +8812,7 @@ function proxy(publicAPI, model) {
         links.splice(indexToDelete.pop(), 1);
       }
     }
-    function bind(instance, propertyName) {
-      let updateMe = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    function bind(instance, propertyName, updateMe = false) {
       const subscription = instance.onModified(update);
       const other = links[0];
       links.push({
@@ -8692,8 +8849,7 @@ function proxy(publicAPI, model) {
   };
 
   // extract values
-  function getProperties() {
-    let groupName = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ROOT_GROUP_NAME;
+  function getProperties(groupName = ROOT_GROUP_NAME) {
     const values = [];
     const id = model.proxyId;
     const propertyNames = listProxyProperties(groupName) || [];
@@ -8820,9 +8976,7 @@ function proxyPropertyMapping(publicAPI, model, map) {
 //   get / set Representation ( string ) => push state to various internal objects
 // ----------------------------------------------------------------------------
 
-function proxyPropertyState(publicAPI, model) {
-  let state = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  let defaults = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+function proxyPropertyState(publicAPI, model, state = {}, defaults = {}) {
   model.this = publicAPI;
   function applyState(map) {
     const modelKeys = Object.keys(map);