@kitware/vtk.js 20.1.4 → 20.2.3

package/IO/Geometry/STLWriter.js

@@ -1,8 +1,8 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { vec3 } from 'gl-matrix';
 import macro from '../../macros.js';
 import vtkTriangle from '../../Common/DataModel/Triangle.js';
 import { FormatTypes } from './STLWriter/Constants.js';
-import { t as transformMat4 } from '../../vendor/gl-matrix/esm/vec3.js';
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
 
@@ -118,9 +118,9 @@ function writeSTL(polyData) {
       v3 = [points[polys[i] * 3], points[polys[i] * 3 + 1], points[polys[i++] * 3 + 2]];
 
       if (transform) {
-        transformMat4(v1, v1, transform);
-        transformMat4(v2, v2, transform);
-        transformMat4(v3, v3, transform);
+        vec3.transformMat4(v1, v1, transform);
+        vec3.transformMat4(v2, v2, transform);
+        vec3.transformMat4(v3, v3, transform);
       }
 
       vtkTriangle.computeNormal(v1, v2, v3, n);

package/IO/Misc/OBJReader.d.ts

@@ -10,10 +10,10 @@ interface IOBJReaderOptions {
 /**
  * 
  */
-export interface IElevationReaderInitialValues {
+export interface IOBJReaderInitialValues {
 	numberOfOutputs?: number;
 	requestCount?: number;
-	splitMode?: null | string;
+	splitMode?: string;
 }
 
 type vtkOBJReaderBase = vtkObject & Omit<vtkAlgorithm,
@@ -74,6 +74,7 @@ export interface vtkOBJReader extends vtkOBJReaderBase {
 	 * @param {String} content The content to parse. 
 	 */
 	parseAsText(content: string): void;
+
 	/**
 	 *
 	 * @param inData 
@@ -89,9 +90,9 @@ export interface vtkOBJReader extends vtkOBJReaderBase {
 
 	/**
 	 * 
-	 * @param {Null | String} splitMode 
+	 * @param {String} splitMode 
 	 */
-	setSplitMode(splitMode: null | string): boolean;
+	setSplitMode(splitMode: string): boolean;
 
 	/**
 	 * Set the url of the object to load.
@@ -106,15 +107,15 @@ export interface vtkOBJReader extends vtkOBJReaderBase {
  *
  * @param publicAPI object on which methods will be bounds (public)
  * @param model object on which data structure will be bounds (protected)
- * @param {IElevationReaderInitialValues} [initialValues] (default: {})
+ * @param {IOBJReaderInitialValues} [initialValues] (default: {})
  */
-export function extend(publicAPI: object, model: object, initialValues?: IElevationReaderInitialValues): void;
+export function extend(publicAPI: object, model: object, initialValues?: IOBJReaderInitialValues): void;
 
 /**
  * Method used to create a new instance of vtkOBJReader
- * @param {IElevationReaderInitialValues} [initialValues] for pre-setting some of its content
+ * @param {IOBJReaderInitialValues} [initialValues] for pre-setting some of its content
  */
-export function newInstance(initialValues?: IElevationReaderInitialValues): vtkOBJReader;
+export function newInstance(initialValues?: IOBJReaderInitialValues): vtkOBJReader;
 
 
 /**

package/IO/Misc/SkyboxReader.js

@@ -1,7 +1,7 @@
 import macro from '../../macros.js';
 import ImageHelper from '../../Common/Core/ImageHelper.js';
 import vtkTexture from '../../Rendering/Core/Texture.js';
-import { J as JSZip } from '../../vendor/jszip/dist/jszip.min.js';
+import JSZip from 'jszip';
 
 // vtkSkyboxReader methods
 // ----------------------------------------------------------------------------

package/IO/XML/XMLReader.js

@@ -1,13 +1,12 @@
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
-import '../../vendor/xmlbuilder2/lib/xmlbuilder2.min.js';
-import { p as pako } from '../../vendor/pako/dist/pako.esm.mjs.js';
+import { create } from 'xmlbuilder2';
+import pako from 'pako';
 import DataAccessHelper from '../Core/DataAccessHelper.js';
 import Base64 from '../../Common/Core/Base64.js';
 import macro from '../../macros.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 import BinaryHelper from '../Core/BinaryHelper.js';
 import '../Core/DataAccessHelper/LiteHttpDataAccessHelper.js';
-import { x as xmlbuilder2_min } from '../../_vendor/xmlbuilder2/lib/xmlbuilder2.min.js_commonjs-module.js';
 
 // import 'vtk.js/Sources/IO/Core/DataAccessHelper/HttpDataAccessHelper'; // HTTP + zip
 // import 'vtk.js/Sources/IO/Core/DataAccessHelper/HtmlDataAccessHelper'; // html + base64 + zip
@@ -25,7 +24,7 @@ function findFirstTag(node, tagName) {
 
 function parseXML(xmlStr) {
   // see xmlbuilder2 docs on the object format
-  return xmlbuilder2_min.exports.create(xmlStr);
+  return create(xmlStr);
 }
 
 function extractAppendedData(buffer) {

package/IO/XML/XMLWriter.js

@@ -1,9 +1,8 @@
-import '../../vendor/xmlbuilder2/lib/xmlbuilder2.min.js';
-import { f as fromByteArray_1 } from '../../vendor/base64-js/index.js';
-import { p as pako } from '../../vendor/pako/dist/pako.esm.mjs.js';
+import { create } from 'xmlbuilder2';
+import pako from 'pako';
 import macro from '../../macros.js';
+import { fromArrayBuffer } from '../../Common/Core/Base64.js';
 import { FormatTypes, TYPED_ARRAY } from './XMLWriter/Constants.js';
-import { x as xmlbuilder2_min } from '../../_vendor/xmlbuilder2/lib/xmlbuilder2.min.js_commonjs-module.js';
 
 // Global methods
 // ----------------------------------------------------------------------------
@@ -66,7 +65,7 @@ function processDataArray(dataArray, format, blockSize) {
         uint8Offset += header[3 + _blockId];
       }
 
-      return fromByteArray_1(headerUint8) + fromByteArray_1(uint8);
+      return fromArrayBuffer(headerUint8.buffer) + fromArrayBuffer(uint8.buffer);
     }
 
     throw new Error('Only vtkZLibDataCompressor is supported');
@@ -87,7 +86,7 @@ function vtkXMLWriter(publicAPI, model) {
   model.classHierarchy.push('vtkXMLWriter'); // Can be overridden in subclass
 
   publicAPI.create = function (dataObject) {
-    return xmlbuilder2_min.exports.create().ele('VTKFile').att('type', model.dataType).att('version', '0.1').att('byte_order', 'LittleEndian').att('header_type', 'UInt32').att('compressor', model.format === FormatTypes.ASCII ? '' : 'vtkZLibDataCompressor');
+    return create().ele('VTKFile').att('type', model.dataType).att('version', '0.1').att('byte_order', 'LittleEndian').att('header_type', 'UInt32').att('compressor', model.format === FormatTypes.ASCII ? '' : 'vtkZLibDataCompressor');
   };
 
   publicAPI.write = function (object) {

package/Imaging/Core/ImageReslice.js

@@ -1,4 +1,5 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { mat4, vec4 } from 'gl-matrix';
 import macro from '../../macros.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 import { VtkDataTypes } from '../../Common/Core/DataArray/Constants.js';
@@ -9,8 +10,6 @@ import vtkImagePointDataIterator from './ImagePointDataIterator.js';
 import { InterpolationMode, ImageBorderMode } from './AbstractImageInterpolator/Constants.js';
 import { vtkInterpolationMathRound, vtkInterpolationMathClamp, vtkInterpolationMathFloor } from './AbstractImageInterpolator/InterpolationInfo.js';
 import Constants from './ImageReslice/Constants.js';
-import { i as identity, h as exactEquals, d as copy, g as invert, m as multiply } from '../../vendor/gl-matrix/esm/mat4.js';
-import { t as transformMat4 } from '../../vendor/gl-matrix/esm/vec4.js';
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
 
@@ -100,11 +99,11 @@ function vtkImageReslice(publicAPI, model) {
 
   publicAPI.setResliceAxes = function (resliceAxes) {
     if (!model.resliceAxes) {
-      model.resliceAxes = identity(new Float64Array(16));
+      model.resliceAxes = mat4.identity(new Float64Array(16));
     }
 
-    if (!exactEquals(model.resliceAxes, resliceAxes)) {
-      copy(model.resliceAxes, resliceAxes);
+    if (!mat4.exactEquals(model.resliceAxes, resliceAxes)) {
+      mat4.copy(model.resliceAxes, resliceAxes);
       publicAPI.modified();
       return true;
     }
@@ -137,11 +136,11 @@ function vtkImageReslice(publicAPI, model) {
     if (model.resliceAxes) {
       matrix = model.resliceAxes;
     } else {
-      matrix = identity(new Float64Array(16));
+      matrix = mat4.identity(new Float64Array(16));
     }
 
     var imatrix = new Float64Array(16);
-    invert(imatrix, matrix);
+    mat4.invert(imatrix, matrix);
     var inCenter = [origin[0] + 0.5 * (inWholeExt[0] + inWholeExt[1]) * inSpacing[0], origin[1] + 0.5 * (inWholeExt[2] + inWholeExt[3]) * inSpacing[1], origin[2] + 0.5 * (inWholeExt[4] + inWholeExt[5]) * inSpacing[2]];
     var maxBounds = null;
 
@@ -582,19 +581,19 @@ function vtkImageReslice(publicAPI, model) {
   publicAPI.getIndexMatrix = function (input, output) {
     // first verify that we have to update the matrix
     if (indexMatrix === null) {
-      indexMatrix = identity(new Float64Array(16));
+      indexMatrix = mat4.identity(new Float64Array(16));
     }
 
     var inOrigin = input.getOrigin();
     var inSpacing = input.getSpacing();
     var outOrigin = output.getOrigin();
     var outSpacing = output.getSpacing();
-    var transform = identity(new Float64Array(16));
-    var inMatrix = identity(new Float64Array(16));
-    var outMatrix = identity(new Float64Array(16));
+    var transform = mat4.identity(new Float64Array(16));
+    var inMatrix = mat4.identity(new Float64Array(16));
+    var outMatrix = mat4.identity(new Float64Array(16));
 
     if (model.resliceAxes) {
-      copy(transform, model.resliceAxes);
+      mat4.copy(transform, model.resliceAxes);
     }
 
     if (model.resliceTransform) ; // check to see if we have an identity matrix
@@ -617,17 +616,17 @@ function vtkImageReslice(publicAPI, model) {
     if (!isIdentity) {
       // transform.PreMultiply();
       // transform.Concatenate(outMatrix);
-      multiply(transform, transform, outMatrix); // the optimizedTransform requires data coords, not
+      mat4.multiply(transform, transform, outMatrix); // the optimizedTransform requires data coords, not
       // index coords, as its input
 
       {
         // transform->PostMultiply();
         // transform->Concatenate(inMatrix);
-        multiply(transform, inMatrix, transform);
+        mat4.multiply(transform, inMatrix, transform);
       }
     }
 
-    copy(indexMatrix, transform);
+    mat4.copy(indexMatrix, transform);
     return indexMatrix;
   };
 
@@ -639,9 +638,9 @@ function vtkImageReslice(publicAPI, model) {
     var matrix = new Float64Array(16);
 
     if (model.resliceAxes) {
-      invert(matrix, model.resliceAxes);
+      mat4.invert(matrix, model.resliceAxes);
     } else {
-      identity(matrix);
+      mat4.identity(matrix);
     }
 
     var bounds = [Number.MAX_VALUE, -Number.MAX_VALUE, Number.MAX_VALUE, -Number.MAX_VALUE, Number.MAX_VALUE, -Number.MAX_VALUE];
@@ -655,7 +654,7 @@ function vtkImageReslice(publicAPI, model) {
 
       if (model.resliceTransform) ;
 
-      transformMat4(point, point, matrix);
+      vec4.transformMat4(point, point, matrix);
       var f = 1.0 / point[3];
       point[0] *= f;
       point[1] *= f;
@@ -837,7 +836,7 @@ function vtkImageReslice(publicAPI, model) {
 
   publicAPI.applyTransform = function (newTrans, inPoint, inOrigin, inInvSpacing) {
     inPoint[3] = 1;
-    transformMat4(inPoint, inPoint, newTrans);
+    vec4.transformMat4(inPoint, inPoint, newTrans);
     inPoint[0] -= inOrigin[0];
     inPoint[1] -= inOrigin[1];
     inPoint[2] -= inOrigin[2];

package/Interaction/Manipulators/MouseCameraAxisRotateManipulator.js

@@ -1,11 +1,10 @@
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
+import { mat4, vec3 } from 'gl-matrix';
 import macro from '../../macros.js';
 import vtkCompositeCameraManipulator from './CompositeCameraManipulator.js';
 import vtkCompositeMouseManipulator from './CompositeMouseManipulator.js';
 import { r as radiansFromDegrees, j as cross } from '../../Common/Core/Math/index.js';
 import vtkMatrixBuilder from '../../Common/Core/MatrixBuilder.js';
-import { i as identity, t as translate, r as rotate } from '../../vendor/gl-matrix/esm/mat4.js';
-import { t as transformMat4, a as subtract, n as normalize, d as dot, h as distance, e as scaleAndAdd, c as cross$1, l as length } from '../../vendor/gl-matrix/esm/vec3.js';
 
 // vtkMouseCameraAxisRotateManipulator methods
 // ----------------------------------------------------------------------------
@@ -36,34 +35,34 @@ function vtkMouseCameraAxisRotateManipulator(publicAPI, model) {
     var cameraFp = camera.getFocalPoint();
     var cameraViewUp = camera.getViewUp();
     var cameraDirection = camera.getDirectionOfProjection();
-    identity(trans);
+    mat4.identity(trans);
     var center = model.center,
         rotationFactor = model.rotationFactor,
         rotationAxis = model.rotationAxis; // Translate to center
 
-    translate(trans, trans, center);
+    mat4.translate(trans, trans, center);
     var dx = model.previousPosition.x - position.x;
     var dy = model.previousPosition.y - position.y;
     var size = interactor.getView().getSize(); // Azimuth
 
-    rotate(trans, trans, radiansFromDegrees(360.0 * dx / size[0] * rotationFactor), rotationAxis); // Elevation
+    mat4.rotate(trans, trans, radiansFromDegrees(360.0 * dx / size[0] * rotationFactor), rotationAxis); // Elevation
 
     cross(cameraDirection, cameraViewUp, v2);
-    rotate(trans, trans, radiansFromDegrees(-360.0 * dy / size[1] * rotationFactor), v2); // Translate back
+    mat4.rotate(trans, trans, radiansFromDegrees(-360.0 * dy / size[1] * rotationFactor), v2); // Translate back
 
     centerNeg[0] = -center[0];
     centerNeg[1] = -center[1];
     centerNeg[2] = -center[2];
-    translate(trans, trans, centerNeg); // Apply transformation to camera position, focal point, and view up
+    mat4.translate(trans, trans, centerNeg); // Apply transformation to camera position, focal point, and view up
 
-    transformMat4(newCamPos, cameraPos, trans);
-    transformMat4(newFp, cameraFp, trans); // what is the current direction from the fp
+    vec3.transformMat4(newCamPos, cameraPos, trans);
+    vec3.transformMat4(newFp, cameraFp, trans); // what is the current direction from the fp
     // to the camera
 
-    subtract(fpDirection, newCamPos, newFp);
-    normalize(fpDirection, fpDirection); // make the top sticky to avoid accidental flips
+    vec3.subtract(fpDirection, newCamPos, newFp);
+    vec3.normalize(fpDirection, fpDirection); // make the top sticky to avoid accidental flips
 
-    if (Math.abs(dot(fpDirection, rotationAxis)) > 0.95) {
+    if (Math.abs(vec3.dot(fpDirection, rotationAxis)) > 0.95) {
       // this can be smarter where it still allows Azimuth here
       // but prevents the elevation part
       model.previousPosition = position;
@@ -72,41 +71,41 @@ function vtkMouseCameraAxisRotateManipulator(publicAPI, model) {
 
     if (model.useHalfAxis) {
       // what is the current distance from pos to center of rotation
-      var distance$1 = distance(newCamPos, center); // what is the current direction from the center of rotation
+      var distance = vec3.distance(newCamPos, center); // what is the current direction from the center of rotation
       // to the camera
 
-      subtract(direction, newCamPos, center);
-      normalize(direction, direction); // project the rotation axis onto the direction
+      vec3.subtract(direction, newCamPos, center);
+      vec3.normalize(direction, direction); // project the rotation axis onto the direction
       // so we know how much below the half plane we are
 
-      var dotP = dot(rotationAxis, direction);
+      var dotP = vec3.dot(rotationAxis, direction);
 
       if (dotP < 0) {
         // adjust the new camera position to bring it up to the half plane
-        scaleAndAdd(newCamPos, newCamPos, rotationAxis, -dotP * distance$1); // the above step will change the distance which might feel odd
+        vec3.scaleAndAdd(newCamPos, newCamPos, rotationAxis, -dotP * distance); // the above step will change the distance which might feel odd
         // so the next couple lines restore the distance to the center
         // what is the new direction from the center of rotation
         // to the camera
 
-        subtract(direction, newCamPos, center);
-        normalize(direction, direction);
-        scaleAndAdd(newCamPos, center, direction, distance$1); // compute original cam direction to center
+        vec3.subtract(direction, newCamPos, center);
+        vec3.normalize(direction, direction);
+        vec3.scaleAndAdd(newCamPos, center, direction, distance); // compute original cam direction to center
 
-        subtract(v2, cameraPos, center);
-        normalize(v2, v2); // const rAngle = 0.0;
+        vec3.subtract(v2, cameraPos, center);
+        vec3.normalize(v2, v2); // const rAngle = 0.0;
 
-        var acosR = Math.min(1.0, Math.max(-1.0, dot(direction, v2)));
+        var acosR = Math.min(1.0, Math.max(-1.0, vec3.dot(direction, v2)));
         var rAngle = Math.acos(acosR); // 0 to pi
 
-        cross$1(v2, v2, direction);
-        normalize(v2, v2);
-        subtract(newFp, cameraFp, center);
-        var fpDist = length(newFp); // Note it normalizes the vector to be rotated
+        vec3.cross(v2, v2, direction);
+        vec3.normalize(v2, v2);
+        vec3.subtract(newFp, cameraFp, center);
+        var fpDist = vec3.length(newFp); // Note it normalizes the vector to be rotated
 
         var result = _toConsumableArray(newFp);
 
         vtkMatrixBuilder.buildFromRadian().rotate(rAngle, v2).apply(result);
-        scaleAndAdd(newFp, center, result, fpDist);
+        vec3.scaleAndAdd(newFp, center, result, fpDist);
       }
     }
 

package/Interaction/Manipulators/MouseCameraTrackballRollManipulator.js

@@ -1,9 +1,8 @@
+import { mat4, vec3 } from 'gl-matrix';
 import macro from '../../macros.js';
 import vtkCompositeCameraManipulator from './CompositeCameraManipulator.js';
 import vtkCompositeMouseManipulator from './CompositeMouseManipulator.js';
 import { r as radiansFromDegrees, y as degreesFromRadians } from '../../Common/Core/Math/index.js';
-import { i as identity, t as translate, r as rotate } from '../../vendor/gl-matrix/esm/mat4.js';
-import { t as transformMat4 } from '../../vendor/gl-matrix/esm/vec3.js';
 
 // vtkMouseCameraTrackballRollManipulator methods
 // ----------------------------------------------------------------------------
@@ -52,23 +51,23 @@ function vtkMouseCameraTrackballRollManipulator(publicAPI, model) {
 
     var angle = degreesFromRadians((x1 * y2 - y1 * x2) / (Math.sqrt(x1 * x1 + y1 * y1) * Math.sqrt(x2 * x2 + y2 * y2)));
     var center = model.center;
-    identity(transform);
+    mat4.identity(transform);
     centerNeg[0] = -center[0];
     centerNeg[1] = -center[1];
     centerNeg[2] = -center[2]; // Translate to center
 
-    translate(transform, transform, center); // roll
+    mat4.translate(transform, transform, center); // roll
 
-    rotate(transform, transform, radiansFromDegrees(angle), axis); // Translate back
+    mat4.rotate(transform, transform, radiansFromDegrees(angle), axis); // Translate back
 
-    translate(transform, transform, centerNeg); // Apply transformation to camera position, focal point, and view up
+    mat4.translate(transform, transform, centerNeg); // Apply transformation to camera position, focal point, and view up
 
-    transformMat4(newCamPos, cameraPos, transform);
-    transformMat4(newFp, cameraFp, transform);
+    vec3.transformMat4(newCamPos, cameraPos, transform);
+    vec3.transformMat4(newFp, cameraFp, transform);
     direction[0] = viewUp[0] + cameraPos[0];
     direction[1] = viewUp[1] + cameraPos[1];
     direction[2] = viewUp[2] + cameraPos[2];
-    transformMat4(newViewUp, direction, transform);
+    vec3.transformMat4(newViewUp, direction, transform);
     camera.setPosition(newCamPos[0], newCamPos[1], newCamPos[2]);
     camera.setFocalPoint(newFp[0], newFp[1], newFp[2]);
     camera.setViewUp(newViewUp[0] - newCamPos[0], newViewUp[1] - newCamPos[1], newViewUp[2] - newCamPos[2]);

package/Interaction/Manipulators/MouseCameraTrackballRotateManipulator.js

@@ -1,9 +1,8 @@
+import { mat4, vec3 } from 'gl-matrix';
 import macro from '../../macros.js';
 import vtkCompositeCameraManipulator from './CompositeCameraManipulator.js';
 import vtkCompositeMouseManipulator from './CompositeMouseManipulator.js';
 import { t as multiplyScalar, d as dot, k as add, r as radiansFromDegrees, j as cross } from '../../Common/Core/Math/index.js';
-import { i as identity, t as translate, r as rotate } from '../../vendor/gl-matrix/esm/mat4.js';
-import { i as copy, t as transformMat4 } from '../../vendor/gl-matrix/esm/vec3.js';
 
 // vtkMouseCameraTrackballRotateManipulator methods
 // ----------------------------------------------------------------------------
@@ -31,7 +30,7 @@ function vtkMouseCameraTrackballRotateManipulator(publicAPI, model) {
     var camera = renderer.getActiveCamera();
     var cameraPos = camera.getPosition();
     var cameraFp = camera.getFocalPoint();
-    identity(trans);
+    mat4.identity(trans);
     var center = model.center,
         rotationFactor = model.rotationFactor;
 
@@ -49,38 +48,38 @@ function vtkMouseCameraTrackballRotateManipulator(publicAPI, model) {
 
     if (model.useWorldUpVec) {
       var centerOfRotation = new Float64Array(3);
-      copy(centerOfRotation, model.worldUpVec); // Compute projection of cameraPos onto worldUpVec
+      vec3.copy(centerOfRotation, model.worldUpVec); // Compute projection of cameraPos onto worldUpVec
 
       multiplyScalar(centerOfRotation, dot(cameraPos, model.worldUpVec) / dot(model.worldUpVec, model.worldUpVec));
       add(center, centerOfRotation, centerOfRotation);
-      translate(trans, trans, centerOfRotation);
-      rotate(trans, trans, radiansFromDegrees(360.0 * dx / size[0] * rotationFactor), model.worldUpVec); // Translate back
+      mat4.translate(trans, trans, centerOfRotation);
+      mat4.rotate(trans, trans, radiansFromDegrees(360.0 * dx / size[0] * rotationFactor), model.worldUpVec); // Translate back
 
       centerOfRotation[0] = -centerOfRotation[0];
       centerOfRotation[1] = -centerOfRotation[1];
       centerOfRotation[2] = -centerOfRotation[2];
-      translate(trans, trans, centerOfRotation);
-      translate(trans, trans, center);
+      mat4.translate(trans, trans, centerOfRotation);
+      mat4.translate(trans, trans, center);
     } else {
-      translate(trans, trans, center);
-      rotate(trans, trans, radiansFromDegrees(360.0 * dx / size[0] * rotationFactor), viewUp);
+      mat4.translate(trans, trans, center);
+      mat4.rotate(trans, trans, radiansFromDegrees(360.0 * dx / size[0] * rotationFactor), viewUp);
     } // Elevation
 
 
     cross(camera.getDirectionOfProjection(), viewUp, v2);
-    rotate(trans, trans, radiansFromDegrees(-360.0 * dy / size[1] * rotationFactor), v2); // Translate back
+    mat4.rotate(trans, trans, radiansFromDegrees(-360.0 * dy / size[1] * rotationFactor), v2); // Translate back
 
     centerNeg[0] = -center[0];
     centerNeg[1] = -center[1];
     centerNeg[2] = -center[2];
-    translate(trans, trans, centerNeg); // Apply transformation to camera position, focal point, and view up
+    mat4.translate(trans, trans, centerNeg); // Apply transformation to camera position, focal point, and view up
 
-    transformMat4(newCamPos, cameraPos, trans);
-    transformMat4(newFp, cameraFp, trans);
+    vec3.transformMat4(newCamPos, cameraPos, trans);
+    vec3.transformMat4(newFp, cameraFp, trans);
     direction[0] = viewUp[0] + cameraPos[0];
     direction[1] = viewUp[1] + cameraPos[1];
     direction[2] = viewUp[2] + cameraPos[2];
-    transformMat4(newViewUp, direction, trans);
+    vec3.transformMat4(newViewUp, direction, trans);
     camera.setPosition(newCamPos[0], newCamPos[1], newCamPos[2]);
     camera.setFocalPoint(newFp[0], newFp[1], newFp[2]);
     camera.setViewUp(newViewUp[0] - newCamPos[0], newViewUp[1] - newCamPos[1], newViewUp[2] - newCamPos[2]);

package/Interaction/Manipulators/MouseCameraUnicamRotateManipulator.js

@@ -8,10 +8,9 @@ import vtkMapper from '../../Rendering/Core/Mapper.js';
 import vtkPointPicker from '../../Rendering/Core/PointPicker.js';
 import vtkSphereSource from '../../Filters/Sources/SphereSource.js';
 import { FieldAssociations } from '../../Common/DataModel/DataSet/Constants.js';
+import { mat4, vec3 } from 'gl-matrix';
 import macro from '../../macros.js';
 import { z as areEquals, l as normalize, d as dot, A as clampValue, g as subtract, j as cross, t as multiplyScalar, f as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
-import { i as identity, t as translate, r as rotate } from '../../vendor/gl-matrix/esm/mat4.js';
-import { t as transformMat4 } from '../../vendor/gl-matrix/esm/vec3.js';
 
 var States = vtkInteractorStyleConstants.States; // ----------------------------------------------------------------------------
 // vtkMouseCameraUnicamRotateManipulator methods
@@ -79,25 +78,25 @@ function vtkMouseCameraUnicamRotateManipulator(publicAPI, model) {
     cameraPosition[3] = 1.0;
     cameraFocalPoint[3] = 1.0;
     cameraViewUp[3] = 0.0;
-    var transform = identity(new Float64Array(16));
-    translate(transform, transform, [cx, cy, cz]);
-    rotate(transform, transform, angle, [ax, ay, az]);
-    translate(transform, transform, [-cx, -cy, -cz]);
+    var transform = mat4.identity(new Float64Array(16));
+    mat4.translate(transform, transform, [cx, cy, cz]);
+    mat4.rotate(transform, transform, angle, [ax, ay, az]);
+    mat4.translate(transform, transform, [-cx, -cy, -cz]);
     var newCameraPosition = [];
     var newCameraFocalPoint = [];
-    transformMat4(newCameraPosition, cameraPosition, transform);
-    transformMat4(newCameraFocalPoint, cameraFocalPoint, transform);
-    identity(transform);
-    rotate(transform, transform, angle, [ax, ay, az]);
+    vec3.transformMat4(newCameraPosition, cameraPosition, transform);
+    vec3.transformMat4(newCameraFocalPoint, cameraFocalPoint, transform);
+    mat4.identity(transform);
+    mat4.rotate(transform, transform, angle, [ax, ay, az]);
     var newCameraViewUp = [];
-    transformMat4(newCameraViewUp, cameraViewUp, transform);
+    vec3.transformMat4(newCameraViewUp, cameraViewUp, transform);
     camera.setPosition.apply(camera, newCameraPosition);
     camera.setFocalPoint.apply(camera, newCameraFocalPoint);
     camera.setViewUp.apply(camera, newCameraViewUp);
   }; //----------------------------------------------------------------------------
 
 
-  var rotate$1 = function rotate(interactor, position) {
+  var rotate = function rotate(interactor, position) {
     var _interactor$getView;
 
     var renderer = interactor.findPokedRenderer();
@@ -300,7 +299,7 @@ function vtkMouseCameraUnicamRotateManipulator(publicAPI, model) {
     }
 
     model.state = States.IS_ROTATE;
-    rotate$1(interactor, position);
+    rotate(interactor, position);
     model.previousPosition = position;
   }; //--------------------------------------------------------------------------
 

package/Interaction/Widgets/ImageCroppingRegionsWidget.js

@@ -6,8 +6,7 @@ import vtkPlane from '../../Common/DataModel/Plane.js';
 import vtkAbstractWidget from './AbstractWidget.js';
 import vtkImageCroppingRegionsRepresentation from './ImageCroppingRegionsRepresentation.js';
 import Constants from './ImageCroppingRegionsWidget/Constants.js';
-import { i as identity } from '../../vendor/gl-matrix/esm/mat4.js';
-import { t as transformMat4 } from '../../vendor/gl-matrix/esm/vec3.js';
+import { mat4, vec3 } from 'gl-matrix';
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
 
@@ -42,8 +41,8 @@ function vtkImageCroppingRegionsWidget(publicAPI, model) {
   model.classHierarchy.push('vtkImageCroppingRegionsWidget'); // camera subscription
 
   var cameraSub = null;
-  model.indexToWorld = identity(new Float64Array(16));
-  model.worldToIndex = identity(new Float64Array(16));
+  model.indexToWorld = mat4.identity(new Float64Array(16));
+  model.worldToIndex = mat4.identity(new Float64Array(16));
   var handlesCache = null;
   model.widgetState = {
     activeHandleIndex: -1,
@@ -54,13 +53,13 @@ function vtkImageCroppingRegionsWidget(publicAPI, model) {
 
   function worldToIndex(ain) {
     var vout = [];
-    transformMat4(vout, ain, model.worldToIndex);
+    vec3.transformMat4(vout, ain, model.worldToIndex);
     return vout;
   }
 
   function indexToWorld(ain) {
     var vout = [];
-    transformMat4(vout, ain, model.indexToWorld);
+    vec3.transformMat4(vout, ain, model.indexToWorld);
     return vout;
   } // Overridden method
 

package/Interaction/Widgets/PiecewiseGaussianWidget/ComputeHistogram.worker.js

@@ -1,4 +1,4 @@
-import { r as registerWebworker } from '../../../vendor/webworker-promise/lib/register.js';
+import registerWebworker from 'webworker-promise/lib/register';
 
 /* eslint-disable */
 // prettier-ignore

package/Interaction/Widgets/PiecewiseGaussianWidget.js

@@ -3,7 +3,7 @@ import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import macro from '../../macros.js';
 import { C as arrayRange } from '../../Common/Core/Math/index.js';
-import { s as src } from '../../vendor/webworker-promise/src/index.js';
+import WebworkerPromise from 'webworker-promise';
 import { W as WorkerFactory } from '../../_virtual/rollup-plugin-worker-loader__module_Sources/Interaction/Widgets/PiecewiseGaussianWidget/ComputeHistogram.worker.js';
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
@@ -522,7 +522,7 @@ function vtkPiecewiseGaussianWidget(publicAPI, model) {
     while (arrayIndex < array.length) {
       var worker = new WorkerFactory();
       workers.push(worker);
-      var workerPromise = new src(worker);
+      var workerPromise = new WebworkerPromise(worker);
       var arrayStart = arrayIndex;
       var arrayEnd = Math.min(arrayIndex + arrayStride, array.length - 1);
       var subArray = new array.constructor(array.slice(arrayStart, arrayEnd + 1));