@kitware/vtk.js 20.1.4 → 20.2.3

package/Common/Core/MatrixBuilder.js

@@ -1,16 +1,14 @@
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
 import _createClass from '@babel/runtime/helpers/createClass';
-import { t as toRadian } from '../../vendor/gl-matrix/esm/common.js';
-import { i as identity, f as fromRotation, m as multiply, r as rotate, a as rotateX, b as rotateY, c as rotateZ, t as translate, s as scale, d as copy } from '../../vendor/gl-matrix/esm/mat4.js';
-import { s as set, n as normalize, d as dot, c as cross, l as length, v as vec3, t as transformMat4 } from '../../vendor/gl-matrix/esm/vec3.js';
+import { mat4, vec3, glMatrix } from 'gl-matrix';
 import { a as areMatricesEqual } from './Math/index.js';
 
 var NoOp = function NoOp(v) {
   return v;
 };
 
-var IDENTITY = identity(new Float64Array(16));
+var IDENTITY = mat4.identity(new Float64Array(16));
 var EPSILON = 1e-6;
 
 var Transform = /*#__PURE__*/function () {
@@ -19,9 +17,9 @@ var Transform = /*#__PURE__*/function () {
 
     _classCallCheck(this, Transform);
 
-    this.matrix = identity(new Float64Array(16));
+    this.matrix = mat4.identity(new Float64Array(16));
     this.tmp = new Float64Array(3);
-    this.angleConv = useDegree ? toRadian : NoOp;
+    this.angleConv = useDegree ? glMatrix.toRadian : NoOp;
   }
 
   _createClass(Transform, [{
@@ -30,82 +28,82 @@ var Transform = /*#__PURE__*/function () {
       var src = new Float64Array(3);
       var dst = new Float64Array(3);
       var transf = new Float64Array(16);
-      set(src, originDirection[0], originDirection[1], originDirection[2]);
-      set(dst, targetDirection[0], targetDirection[1], targetDirection[2]);
-      normalize(src, src);
-      normalize(dst, dst);
-      var cosAlpha = dot(src, dst);
+      vec3.set(src, originDirection[0], originDirection[1], originDirection[2]);
+      vec3.set(dst, targetDirection[0], targetDirection[1], targetDirection[2]);
+      vec3.normalize(src, src);
+      vec3.normalize(dst, dst);
+      var cosAlpha = vec3.dot(src, dst);
 
       if (cosAlpha >= 1) {
         return this;
       }
 
-      cross(this.tmp, src, dst);
+      vec3.cross(this.tmp, src, dst);
 
-      if (length(this.tmp) < EPSILON) {
+      if (vec3.length(this.tmp) < EPSILON) {
         // cross product is 0, so pick arbitrary axis perpendicular
         // to originDirection.
-        cross(this.tmp, [1, 0, 0], originDirection);
+        vec3.cross(this.tmp, [1, 0, 0], originDirection);
 
-        if (length(this.tmp) < EPSILON) {
-          cross(this.tmp, [0, 1, 0], originDirection);
+        if (vec3.length(this.tmp) < EPSILON) {
+          vec3.cross(this.tmp, [0, 1, 0], originDirection);
         }
       }
 
-      fromRotation(transf, Math.acos(cosAlpha), this.tmp);
-      multiply(this.matrix, this.matrix, transf);
+      mat4.fromRotation(transf, Math.acos(cosAlpha), this.tmp);
+      mat4.multiply(this.matrix, this.matrix, transf);
       return this;
     }
   }, {
     key: "rotate",
-    value: function rotate$1(angle, axis) {
-      set.apply(vec3, [this.tmp].concat(_toConsumableArray(axis)));
-      normalize(this.tmp, this.tmp);
-      rotate(this.matrix, this.matrix, this.angleConv(angle), this.tmp);
+    value: function rotate(angle, axis) {
+      vec3.set.apply(vec3, [this.tmp].concat(_toConsumableArray(axis)));
+      vec3.normalize(this.tmp, this.tmp);
+      mat4.rotate(this.matrix, this.matrix, this.angleConv(angle), this.tmp);
       return this;
     }
   }, {
     key: "rotateX",
-    value: function rotateX$1(angle) {
-      rotateX(this.matrix, this.matrix, this.angleConv(angle));
+    value: function rotateX(angle) {
+      mat4.rotateX(this.matrix, this.matrix, this.angleConv(angle));
       return this;
     }
   }, {
     key: "rotateY",
-    value: function rotateY$1(angle) {
-      rotateY(this.matrix, this.matrix, this.angleConv(angle));
+    value: function rotateY(angle) {
+      mat4.rotateY(this.matrix, this.matrix, this.angleConv(angle));
       return this;
     }
   }, {
     key: "rotateZ",
-    value: function rotateZ$1(angle) {
-      rotateZ(this.matrix, this.matrix, this.angleConv(angle));
+    value: function rotateZ(angle) {
+      mat4.rotateZ(this.matrix, this.matrix, this.angleConv(angle));
       return this;
     }
   }, {
     key: "translate",
-    value: function translate$1(x, y, z) {
-      set(this.tmp, x, y, z);
-      translate(this.matrix, this.matrix, this.tmp);
+    value: function translate(x, y, z) {
+      vec3.set(this.tmp, x, y, z);
+      mat4.translate(this.matrix, this.matrix, this.tmp);
       return this;
     }
   }, {
     key: "scale",
-    value: function scale$1(sx, sy, sz) {
-      set(this.tmp, sx, sy, sz);
-      scale(this.matrix, this.matrix, this.tmp);
+    value: function scale(sx, sy, sz) {
+      vec3.set(this.tmp, sx, sy, sz);
+      mat4.scale(this.matrix, this.matrix, this.tmp);
       return this;
     }
   }, {
     key: "multiply",
-    value: function multiply$1(mat4x4) {
-      multiply(this.matrix, this.matrix, mat4x4);
+    value: function multiply(mat4x4) {
+      mat4.multiply(this.matrix, this.matrix, mat4x4);
       return this;
     }
   }, {
     key: "identity",
-    value: function identity$1() {
-      identity(this.matrix);
+    value: function identity() {
+      mat4.identity(this.matrix);
       return this;
     } //-----------
 
@@ -123,8 +121,8 @@ var Transform = /*#__PURE__*/function () {
       var size = nbIterations === -1 ? typedArray.length : offset + nbIterations * 3;
 
       for (var i = offset; i < size; i += 3) {
-        set(this.tmp, typedArray[i], typedArray[i + 1], typedArray[i + 2]);
-        transformMat4(this.tmp, this.tmp, this.matrix);
+        vec3.set(this.tmp, typedArray[i], typedArray[i + 1], typedArray[i + 2]);
+        vec3.transformMat4(this.tmp, this.tmp, this.matrix);
         typedArray[i] = this.tmp[0];
         typedArray[i + 1] = this.tmp[1];
         typedArray[i + 2] = this.tmp[2];
@@ -142,7 +140,7 @@ var Transform = /*#__PURE__*/function () {
     key: "setMatrix",
     value: function setMatrix(mat4x4) {
       if (!!mat4x4 && mat4x4.length === 16) {
-        copy(this.matrix, mat4x4);
+        mat4.copy(this.matrix, mat4x4);
       }
 
       return this;

package/Common/DataModel/Box.d.ts

@@ -0,0 +1,73 @@
+import { vtkObject } from '@kitware/vtk.js/interfaces' ;
+import { Bounds, Point } from '@kitware/vtk.js/types';
+
+
+export interface IBoxInitialValues {
+    bbox?: Bounds;
+}
+
+export interface vtkBox extends vtkObject {
+
+    /**
+     * Add the bounds for the box.
+     * @param {Bounds} bounds 
+     */
+    addBounds(bounds: Bounds): void;
+
+    /**
+     * 
+     * @param other 
+     */
+    addBox(other: any): void;
+
+    /**
+     * 
+     * @param {Point} x The point coordinate.
+     */
+    evaluateFunction(x: Point): number;
+
+    /**
+     * 
+	 * @param {Number} x The x coordinate.
+	 * @param {Number} y The y coordinate.
+	 * @param {Number} z The z coordinate.
+     */
+    evaluateFunction(x: number, y: number, z: number ): number;
+
+    /**
+     * Get the bounds for the box.
+     */
+    getBounds(): Bounds;
+
+    /**
+     * Set the bounds for the box.
+     * @param {Bounds} bounds The bounds for the box.
+     */
+    setBounds(bounds: Bounds): void;
+}
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with vtkBox characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {IBoxInitialValues} [initialValues] (default: {})
+ */
+export function extend(publicAPI: object, model: object, initialValues?: IBoxInitialValues): void;
+
+/**
+ * Method used to create a new instance of vtkBox.
+ * @param {IBoxInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(initialValues?: IBoxInitialValues): vtkBox;
+
+/**
+ * vtkBox provides methods for creating a 1D cubic spline object from given
+ * parameters, and allows for the calculation of the spline value and derivative
+ * at any given point inside the spline intervals.
+ */
+export declare const vtkBox: {
+	newInstance: typeof newInstance,
+	extend: typeof extend
+};
+export default vtkBox;

package/Common/DataModel/ImageData.js

@@ -5,9 +5,7 @@ import vtkBoundingBox from './BoundingBox.js';
 import vtkDataSet from './DataSet.js';
 import vtkStructuredData from './StructuredData.js';
 import { StructuredType } from './StructuredData/Constants.js';
-import { i as identity } from '../../vendor/gl-matrix/esm/mat3.js';
-import { s as set, t as transformMat4 } from '../../vendor/gl-matrix/esm/vec3.js';
-import { e as fromTranslation, s as scale, g as invert } from '../../vendor/gl-matrix/esm/mat4.js';
+import { mat3, vec3, mat4 } from 'gl-matrix';
 
 var vtkErrorMacro = macro.vtkErrorMacro; // ----------------------------------------------------------------------------
 // vtkImageData methods
@@ -205,7 +203,7 @@ function vtkImageData(publicAPI, model) {
     var bounds = [vout[0], vout[0], vout[1], vout[1], vout[2], vout[2]];
 
     for (var i = 3; i < 24; i += 3) {
-      set(idx, corners[i], corners[i + 1], corners[i + 2]);
+      vec3.set(idx, corners[i], corners[i + 1], corners[i + 2]);
       publicAPI.indexToWorld(idx, vout);
 
       if (vout[0] < bounds[0]) {
@@ -238,7 +236,7 @@ function vtkImageData(publicAPI, model) {
 
 
   publicAPI.computeTransforms = function () {
-    fromTranslation(model.indexToWorld, model.origin);
+    mat4.fromTranslation(model.indexToWorld, model.origin);
     model.indexToWorld[0] = model.direction[0];
     model.indexToWorld[1] = model.direction[1];
     model.indexToWorld[2] = model.direction[2];
@@ -248,8 +246,8 @@ function vtkImageData(publicAPI, model) {
     model.indexToWorld[8] = model.direction[6];
     model.indexToWorld[9] = model.direction[7];
     model.indexToWorld[10] = model.direction[8];
-    scale(model.indexToWorld, model.indexToWorld, model.spacing);
-    invert(model.worldToIndex, model.indexToWorld);
+    mat4.scale(model.indexToWorld, model.indexToWorld, model.spacing);
+    mat4.invert(model.worldToIndex, model.indexToWorld);
   }; //
   // The direction matrix is a 3x3 basis for the I, J, K axes
   // of the image. The rows of the matrix correspond to the
@@ -303,7 +301,7 @@ function vtkImageData(publicAPI, model) {
 
   publicAPI.indexToWorld = function (ain) {
     var aout = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
-    transformMat4(aout, ain, model.indexToWorld);
+    vec3.transformMat4(aout, ain, model.indexToWorld);
     return aout;
   };
 
@@ -311,7 +309,7 @@ function vtkImageData(publicAPI, model) {
 
   publicAPI.worldToIndex = function (ain) {
     var aout = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
-    transformMat4(aout, ain, model.worldToIndex);
+    vec3.transformMat4(aout, ain, model.worldToIndex);
     return aout;
   };
 
@@ -324,8 +322,8 @@ function vtkImageData(publicAPI, model) {
     vtkBoundingBox.computeCornerPoints(bin, in1, in2);
     var out1 = [0, 0, 0];
     var out2 = [0, 0, 0];
-    transformMat4(out1, in1, model.indexToWorld);
-    transformMat4(out2, in2, model.indexToWorld);
+    vec3.transformMat4(out1, in1, model.indexToWorld);
+    vec3.transformMat4(out2, in2, model.indexToWorld);
     return computeBoundsFromPoints(out1, out2, bout);
   };
 
@@ -336,8 +334,8 @@ function vtkImageData(publicAPI, model) {
     vtkBoundingBox.computeCornerPoints(bin, in1, in2);
     var out1 = [0, 0, 0];
     var out2 = [0, 0, 0];
-    transformMat4(out1, in1, model.worldToIndex);
-    transformMat4(out2, in2, model.worldToIndex);
+    vec3.transformMat4(out1, in1, model.worldToIndex);
+    vec3.transformMat4(out2, in2, model.worldToIndex);
     return computeBoundsFromPoints(out1, out2, bout);
   }; // Make sure the transform is correct
 
@@ -513,7 +511,7 @@ function extend(publicAPI, model) {
   vtkDataSet.extend(publicAPI, model, initialValues);
 
   if (!model.direction) {
-    model.direction = identity(new Float64Array(9));
+    model.direction = mat3.identity(new Float64Array(9));
   } else if (Array.isArray(model.direction)) {
     model.direction = new Float64Array(model.direction.slice(0, 9));
   }

package/Common/Transform/LandmarkTransform.js

@@ -1,9 +1,8 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { mat4, mat3 } from 'gl-matrix';
 import Constants from './LandmarkTransform/Constants.js';
 import macro from '../../macros.js';
 import { o as jacobiN, p as perpendiculars } from '../Core/Math/index.js';
-import { i as identity } from '../../vendor/gl-matrix/esm/mat4.js';
-import { a as invert, m as multiply } from '../../vendor/gl-matrix/esm/mat3.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; }
 
@@ -30,7 +29,7 @@ function vtkLandmarkTransform(publicAPI, model) {
   }
 
   function update() {
-    identity(model.matrix);
+    mat4.identity(model.matrix);
     var N_PTS = model.sourceLandmark.getNumberOfPoints();
 
     if (model.targetLandmark.getNumberOfPoints() !== N_PTS || model.sourceLandmark === null || model.targetLandmark === null || N_PTS === 0) {
@@ -62,7 +61,7 @@ function vtkLandmarkTransform(publicAPI, model) {
     targetCentroid[2] /= N_PTS; // -- if only one point, stop right here
 
     if (N_PTS === 1) {
-      identity(model.matrix);
+      mat4.identity(model.matrix);
       model.matrix.elem[12] = targetCentroid[0] - sourceCentroid[0];
       model.matrix.elem[13] = targetCentroid[1] - sourceCentroid[1];
       model.matrix.elem[14] = targetCentroid[2] - sourceCentroid[2];
@@ -109,9 +108,9 @@ function vtkLandmarkTransform(publicAPI, model) {
 
     if (model.mode === Mode.AFFINE) {
       // AAT = (a.a^t)^-1
-      invert(AAT, AAT); // M = (a.a^t)^-1 . a.b^t
+      mat3.invert(AAT, AAT); // M = (a.a^t)^-1 . a.b^t
 
-      multiply(M, AAT, M); // this->Matrix = M^t
+      mat3.multiply(M, AAT, M); // this->Matrix = M^t
 
       for (var _i2 = 0; _i2 < 3; ++_i2) {
         for (var j = 0; j < 3; ++j) {
@@ -276,7 +275,7 @@ function extend(publicAPI, model) {
   Object.assign(model, DEFAULT_VALUES, initialValues);
   macro.obj(publicAPI, model); // Internal objects initialization
 
-  model.matrix = identity(new Float64Array(16));
+  model.matrix = mat4.identity(new Float64Array(16));
   macro.setGet(publicAPI, model, ['sourceLandmark', 'targetLandmark', 'mode']);
   macro.get(publicAPI, model, ['matrix']);
   vtkLandmarkTransform(publicAPI, model);

package/Filters/General/PaintFilter/PaintFilter.worker.js

@@ -1,8 +1,8 @@
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
-import { r as registerWebworker } from '../../../vendor/webworker-promise/lib/register.js';
+import registerWebworker from 'webworker-promise/lib/register';
 import { SlicingMode } from '../../../Rendering/Core/ImageMapper/Constants.js';
-import { a as subtract, b as scale, e as scaleAndAdd } from '../../../vendor/gl-matrix/esm/vec3.js';
+import { vec3 } from 'gl-matrix';
 
 var globals = {
   // single-component labelmap
@@ -182,14 +182,14 @@ function handlePaintTriangles(_ref4) {
     var point2 = triangleList.subarray(9 * i + 6, 9 * i + 9);
     var v1 = [0, 0, 0];
     var v2 = [0, 0, 0];
-    subtract(v1, point1, point0);
-    subtract(v2, point2, point0);
+    vec3.subtract(v1, point1, point0);
+    vec3.subtract(v2, point2, point0);
     var step1 = [0, 0, 0];
     var numStep1 = 2 * Math.max(Math.abs(v1[0]), Math.abs(v1[1]), Math.abs(v1[2]));
-    scale(step1, v1, 1 / numStep1);
+    vec3.scale(step1, v1, 1 / numStep1);
     var step2 = [0, 0, 0];
     var numStep2 = 2 * Math.max(Math.abs(v2[0]), Math.abs(v2[1]), Math.abs(v2[2]));
-    scale(step2, v2, 1 / numStep2);
+    vec3.scale(step2, v2, 1 / numStep2);
     var jStride = globals.dimensions[0];
     var kStride = globals.dimensions[0] * globals.dimensions[1];
 
@@ -199,8 +199,8 @@ function handlePaintTriangles(_ref4) {
       for (var v = 0; v <= maxV + 1; v++) {
         var point = _toConsumableArray(point0);
 
-        scaleAndAdd(point, point, step1, u);
-        scaleAndAdd(point, point, step2, v);
+        vec3.scaleAndAdd(point, point, step1, u);
+        vec3.scaleAndAdd(point, point, step2, v);
         point[0] = Math.round(point[0]);
         point[1] = Math.round(point[1]);
         point[2] = Math.round(point[2]);

package/Filters/General/PaintFilter.js

@@ -1,11 +1,11 @@
 import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
-import { s as src } from '../../vendor/webworker-promise/src/index.js';
+import { vec3 } from 'gl-matrix';
+import WebworkerPromise from 'webworker-promise';
 import macro from '../../macros.js';
 import vtkImageData from '../../Common/DataModel/ImageData.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 import vtkPolygon from '../../Common/DataModel/Polygon.js';
 import { W as WorkerFactory } from '../../_virtual/rollup-plugin-worker-loader__module_Sources/Filters/General/PaintFilter/PaintFilter.worker.js';
-import { t as transformMat4, a as subtract } from '../../vendor/gl-matrix/esm/vec3.js';
 
 var vtkErrorMacro = macro.vtkErrorMacro; // ----------------------------------------------------------------------------
 // vtkPaintFilter methods
@@ -41,7 +41,7 @@ function vtkPaintFilter(publicAPI, model) {
     if (model.labelMap) {
       if (!workerPromise) {
         worker = new WorkerFactory();
-        workerPromise = new src(worker);
+        workerPromise = new WebworkerPromise(worker);
       }
 
       workerPromise.exec('start', {
@@ -123,7 +123,7 @@ function vtkPaintFilter(publicAPI, model) {
     if (workerPromise) {
       var worldPt = [point[0], point[1], point[2]];
       var indexPt = [0, 0, 0];
-      transformMat4(indexPt, worldPt, model.maskWorldToIndex);
+      vec3.transformMat4(indexPt, worldPt, model.maskWorldToIndex);
       indexPt[0] = Math.round(indexPt[0]);
       indexPt[1] = Math.round(indexPt[1]);
       indexPt[2] = Math.round(indexPt[2]);
@@ -143,8 +143,8 @@ function vtkPaintFilter(publicAPI, model) {
     if (workerPromise) {
       var index1 = [0, 0, 0];
       var index2 = [0, 0, 0];
-      transformMat4(index1, point1, model.maskWorldToIndex);
-      transformMat4(index2, point2, model.maskWorldToIndex);
+      vec3.transformMat4(index1, point1, model.maskWorldToIndex);
+      vec3.transformMat4(index2, point2, model.maskWorldToIndex);
       index1[0] = Math.round(index1[0]);
       index1[1] = Math.round(index1[1]);
       index1[2] = Math.round(index1[2]);
@@ -164,10 +164,10 @@ function vtkPaintFilter(publicAPI, model) {
       var realCenter = [0, 0, 0];
       var origin = [0, 0, 0];
       var realScale3 = [0, 0, 0];
-      transformMat4(realCenter, center, model.maskWorldToIndex);
-      transformMat4(origin, origin, model.maskWorldToIndex);
-      transformMat4(realScale3, scale3, model.maskWorldToIndex);
-      subtract(realScale3, realScale3, origin);
+      vec3.transformMat4(realCenter, center, model.maskWorldToIndex);
+      vec3.transformMat4(origin, origin, model.maskWorldToIndex);
+      vec3.transformMat4(realScale3, scale3, model.maskWorldToIndex);
+      vec3.subtract(realScale3, realScale3, origin);
       realScale3 = realScale3.map(function (s) {
         return s === 0 ? 0.25 : Math.abs(s);
       });
@@ -206,7 +206,7 @@ function vtkPaintFilter(publicAPI, model) {
       for (var _i3 = 0; _i3 < numPoints; _i3++) {
         var point = points.slice(3 * _i3, 3 * _i3 + 3);
         var voxel = triangleList.subarray(3 * _i3, 3 * _i3 + 3);
-        transformMat4(voxel, point, model.maskWorldToIndex);
+        vec3.transformMat4(voxel, point, model.maskWorldToIndex);
       }
 
       workerPromise.exec('paintTriangles', {

package/Filters/Sources/CubeSource.d.ts

@@ -1,4 +1,5 @@
 import { vtkAlgorithm, vtkObject } from '@kitware/vtk.js/interfaces';
+import { Bounds, Point } from '@kitware/vtk.js/types';
 
 /**
  *
@@ -7,7 +8,7 @@ export interface ICircleSourceInitialValues {
 	xLength?: number;
 	yLength?: number;
 	zLength?: number;
-	center?: number[];
+	center?: Point;
 	rotations?: number[];
 	pointType?: string;
 	generate3DTextureCoordinates?: boolean;
@@ -27,12 +28,12 @@ export interface vtkCubeSource extends vtkCubeSourceBase {
 	 * Get the center of the cube.
 	 * @default [0.0, 0.0, 0.0]
 	 */
-	getCenter(): number[];
+	getCenter(): Point;
 
 	/**
 	 * Get the center of the cube.
 	 */
-	getCenterByReference(): number[];
+	getCenterByReference(): Point;
 
 	/**
 	 *
@@ -90,9 +91,9 @@ export interface vtkCubeSource extends vtkCubeSourceBase {
 
 	/**
 	 * Convenience methods allows creation of cube by specifying bounding box.
-	 * @param bounds
+	 * @param {Bounds} bounds The bounds for the cube.
 	 */
-	setBounds(bounds: number[]): boolean;
+	setBounds(bounds: Bounds): boolean;
 
 	/**
 	 * Set the center of the cube.
@@ -108,7 +109,7 @@ export interface vtkCubeSource extends vtkCubeSourceBase {
 	 * @param center
 	 * @default [0, 0, 0]
 	 */
-	setCenterFrom(center: number[]): boolean;
+	setCenterFrom(center: Point): boolean;
 
 	/**
 	 *

package/Filters/Sources/PlaneSource.js

@@ -1,11 +1,10 @@
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
+import { mat4, vec3 } from 'gl-matrix';
 import macro from '../../macros.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 import { g as subtract, l as normalize, d as dot, j as cross, r as radiansFromDegrees } from '../../Common/Core/Math/index.js';
 import vtkMatrixBuilder from '../../Common/Core/MatrixBuilder.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
-import { i as identity, t as translate, r as rotate } from '../../vendor/gl-matrix/esm/mat4.js';
-import { f as negate, t as transformMat4, g as exactEquals } from '../../vendor/gl-matrix/esm/vec3.js';
 
 var vtkWarningMacro = macro.vtkWarningMacro;
 var EPSILON = 1e-6; // ----------------------------------------------------------------------------
@@ -141,15 +140,15 @@ function vtkPlaneSource(publicAPI, model) {
     } // Create rotation matrix
 
 
-    var transform = identity(new Float64Array(16));
+    var transform = mat4.identity(new Float64Array(16));
     var negCenter = [];
-    negate(negCenter, model.center);
-    translate(transform, transform, model.center);
-    rotate(transform, transform, angle, rotationAxis);
-    translate(transform, transform, negCenter);
-    transformMat4(model.origin, model.origin, transform);
-    transformMat4(model.point1, model.point1, transform);
-    transformMat4(model.point2, model.point2, transform);
+    vec3.negate(negCenter, model.center);
+    mat4.translate(transform, transform, model.center);
+    mat4.rotate(transform, transform, angle, rotationAxis);
+    mat4.translate(transform, transform, negCenter);
+    vec3.transformMat4(model.origin, model.origin, transform);
+    vec3.transformMat4(model.point1, model.point1, transform);
+    vec3.transformMat4(model.point2, model.point2, transform);
     vtkMatrixBuilder.buildFromRadian().rotate(angle, rotationAxis).apply(model.normal);
     publicAPI.modified();
   };
@@ -163,7 +162,7 @@ function vtkPlaneSource(publicAPI, model) {
       c = [arguments.length <= 0 ? undefined : arguments[0], arguments.length <= 1 ? undefined : arguments[1], arguments.length <= 2 ? undefined : arguments[2]];
     }
 
-    if (!exactEquals(c, model.center)) {
+    if (!vec3.exactEquals(c, model.center)) {
       var v1 = [];
       subtract(model.point1, model.origin, v1);
       var v2 = [];
@@ -189,7 +188,7 @@ function vtkPlaneSource(publicAPI, model) {
       point1 = [arguments.length <= 0 ? undefined : arguments[0], arguments.length <= 1 ? undefined : arguments[1], arguments.length <= 2 ? undefined : arguments[2]];
     }
 
-    if (!exactEquals(point1, model.point1)) {
+    if (!vec3.exactEquals(point1, model.point1)) {
       var v1 = [];
       var v2 = [];
       model.point1 = _toConsumableArray(point1);
@@ -210,7 +209,7 @@ function vtkPlaneSource(publicAPI, model) {
       point2 = [arguments.length <= 0 ? undefined : arguments[0], arguments.length <= 1 ? undefined : arguments[1], arguments.length <= 2 ? undefined : arguments[2]];
     }
 
-    if (!exactEquals(point2, model.point2)) {
+    if (!vec3.exactEquals(point2, model.point2)) {
       var v1 = [];
       var v2 = [];
       model.point2 = _toConsumableArray(point2);

package/IO/Core/BinaryHelper.js

@@ -5,10 +5,8 @@
  * expect proper Unicode or any other encoding.
  */
 function arrayBufferToString(arrayBuffer) {
-  {
-    var decoder = new TextDecoder('latin1');
-    return decoder.decode(arrayBuffer);
-  } // fallback on platforms w/o TextDecoder
+  var decoder = new TextDecoder('latin1');
+  return decoder.decode(arrayBuffer);
 }
 /**
  * Extracts binary data out of a file ArrayBuffer given a prefix/suffix.

package/IO/Core/DataAccessHelper/HtmlDataAccessHelper.js

@@ -1,4 +1,4 @@
-import { p as pako } from '../../../vendor/pako/dist/pako.esm.mjs.js';
+import pako from 'pako';
 import macro from '../../../macros.js';
 import Base64 from '../../../Common/Core/Base64.js';
 import Endian from '../../../Common/Core/Endian.js';

package/IO/Core/DataAccessHelper/HttpDataAccessHelper.js

@@ -1,5 +1,5 @@
 import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
-import { p as pako } from '../../../vendor/pako/dist/pako.esm.mjs.js';
+import pako from 'pako';
 import macro from '../../../macros.js';
 import Endian from '../../../Common/Core/Endian.js';
 import { DataTypeByteSize } from '../../../Common/Core/DataArray/Constants.js';

package/IO/Core/DataAccessHelper/JSZipDataAccessHelper.js

@@ -1,5 +1,5 @@
-import { J as JSZip } from '../../../vendor/jszip/dist/jszip.min.js';
-import { p as pako } from '../../../vendor/pako/dist/pako.esm.mjs.js';
+import JSZip from 'jszip';
+import pako from 'pako';
 import macro from '../../../macros.js';
 import Endian from '../../../Common/Core/Endian.js';
 import { DataTypeByteSize } from '../../../Common/Core/DataArray/Constants.js';

package/IO/Core/ZipMultiDataSetReader.js

@@ -1,5 +1,5 @@
 import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
-import { J as JSZip } from '../../vendor/jszip/dist/jszip.min.js';
+import JSZip from 'jszip';
 import DataAccessHelper from './DataAccessHelper.js';
 import macro from '../../macros.js';
 import './DataAccessHelper/HttpDataAccessHelper.js';

package/IO/Core/ZipMultiDataSetWriter.js

@@ -1,4 +1,4 @@
-import { J as JSZip } from '../../vendor/jszip/dist/jszip.min.js';
+import JSZip from 'jszip';
 import macro from '../../macros.js';
 import vtkSerializer from './Serializer.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';