@kitware/vtk.js 28.10.2 → 28.11.0

package/IO/Misc/ElevationReader.js

@@ -1,4 +1,4 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import vtkCellArray from '../../Common/Core/CellArray.js';
@@ -8,89 +8,90 @@ import '../Core/DataAccessHelper/LiteHttpDataAccessHelper.js';
 // import 'vtk.js/Sources/IO/Core/DataAccessHelper/HttpDataAccessHelper'; // HTTP + gz
 // import 'vtk.js/Sources/IO/Core/DataAccessHelper/HtmlDataAccessHelper'; // html + base64 + zip
 // import 'vtk.js/Sources/IO/Core/DataAccessHelper/JSZipDataAccessHelper'; // zip
+
 // ----------------------------------------------------------------------------
 // vtkElevationReader methods
 // ----------------------------------------------------------------------------
 
 function vtkElevationReader(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkElevationReader'); // Create default dataAccessHelper if not available
+  model.classHierarchy.push('vtkElevationReader');
 
+  // Create default dataAccessHelper if not available
   if (!model.dataAccessHelper) {
     model.dataAccessHelper = DataAccessHelper.get('http');
-  } // Internal method to fetch Array
-
+  }
 
+  // Internal method to fetch Array
   function fetchCSV(url, options) {
     return model.dataAccessHelper.fetchText(publicAPI, url, options);
-  } // Set DataSet url
-
+  }
 
-  publicAPI.setUrl = function (url, options) {
-    model.url = url; // Fetch metadata
+  // Set DataSet url
+  publicAPI.setUrl = (url, options) => {
+    model.url = url;
 
+    // Fetch metadata
     return publicAPI.loadData(options);
-  }; // Fetch the actual data arrays
-
-
-  publicAPI.loadData = function (options) {
-    return fetchCSV(model.url, options).then(function (csv) {
-      publicAPI.parseAsText(csv);
-      return true;
-    });
   };
 
-  publicAPI.parseAsText = function (csv) {
+  // Fetch the actual data arrays
+  publicAPI.loadData = options => fetchCSV(model.url, options).then(csv => {
+    publicAPI.parseAsText(csv);
+    return true;
+  });
+  publicAPI.parseAsText = csv => {
     model.csv = csv;
-    model.elevation = []; // Parse data
+    model.elevation = [];
 
-    var lines = model.csv.split('\n');
-    lines.forEach(function (line, lineIdx) {
-      model.elevation.push(line.split(',').map(function (str) {
-        return Number(str);
-      }));
+    // Parse data
+    const lines = model.csv.split('\n');
+    lines.forEach((line, lineIdx) => {
+      model.elevation.push(line.split(',').map(str => Number(str)));
     });
     publicAPI.modified();
   };
-
-  publicAPI.requestData = function (inData, outData) {
-    var polydata = vtkPolyData.newInstance();
+  publicAPI.requestData = (inData, outData) => {
+    const polydata = vtkPolyData.newInstance();
     polydata.getPoints().setData(new Float32Array(0, 0, 0, 1, 1, 1), 3);
-
     if (model.elevation) {
-      var jSize = model.elevation.length;
-      var iSize = model.elevation[0].length; // Handle points and polys
+      const jSize = model.elevation.length;
+      const iSize = model.elevation[0].length;
 
-      var points = polydata.getPoints();
+      // Handle points and polys
+      const points = polydata.getPoints();
       points.setNumberOfPoints(iSize * jSize, 3);
-      var pointValues = points.getData();
-      var polys = vtkCellArray.newInstance({
+      const pointValues = points.getData();
+      const polys = vtkCellArray.newInstance({
         size: 5 * (iSize - 1) * (jSize - 1)
       });
       polydata.setPolys(polys);
-      var polysValues = polys.getData();
-      var cellOffset = 0; // Texture coords
+      const polysValues = polys.getData();
+      let cellOffset = 0;
 
-      var tcData = new Float32Array(iSize * jSize * 2);
-      var tcoords = vtkDataArray.newInstance({
+      // Texture coords
+      const tcData = new Float32Array(iSize * jSize * 2);
+      const tcoords = vtkDataArray.newInstance({
         numberOfComponents: 2,
         values: tcData,
         name: 'TextureCoordinates'
       });
       polydata.getPointData().setTCoords(tcoords);
+      for (let j = 0; j < jSize; j++) {
+        for (let i = 0; i < iSize; i++) {
+          const offsetIdx = j * iSize + i;
+          const offsetPt = 3 * offsetIdx;
 
-      for (var j = 0; j < jSize; j++) {
-        for (var i = 0; i < iSize; i++) {
-          var offsetIdx = j * iSize + i;
-          var offsetPt = 3 * offsetIdx; // Fill points coordinates
-
+          // Fill points coordinates
           pointValues[offsetPt + 0] = model.origin[0] + i * model.xSpacing * model.xDirection;
           pointValues[offsetPt + 1] = model.origin[1] + j * model.ySpacing * model.yDirection;
-          pointValues[offsetPt + 2] = model.origin[2] + model.elevation[j][i] * model.zScaling; // fill in tcoords
+          pointValues[offsetPt + 2] = model.origin[2] + model.elevation[j][i] * model.zScaling;
 
+          // fill in tcoords
           tcData[offsetIdx * 2] = i / (iSize - 1.0);
-          tcData[offsetIdx * 2 + 1] = 1.0 - j / (jSize - 1.0); // Fill polys
+          tcData[offsetIdx * 2 + 1] = 1.0 - j / (jSize - 1.0);
 
+          // Fill polys
           if (i > 0 && j > 0) {
             polysValues[cellOffset++] = 4;
             polysValues[cellOffset++] = offsetIdx;
@@ -101,49 +102,55 @@ function vtkElevationReader(publicAPI, model) {
         }
       }
     }
-
     model.output[0] = polydata;
-  }; // return Busy state
+  };
 
+  // return Busy state
+  publicAPI.isBusy = () => !!model.requestCount;
+}
 
-  publicAPI.isBusy = function () {
-    return !!model.requestCount;
-  };
-} // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   origin: [0, 0, 0],
   xSpacing: 1,
   ySpacing: 1,
   zScaling: 1,
   xDirection: 1,
   yDirection: -1,
-  requestCount: 0 // dataAccessHelper: null,
+  requestCount: 0
+  // dataAccessHelper: null,
   // url: null,
+};
 
-}; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Build VTK API
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
+  // Build VTK API
   macro.obj(publicAPI, model);
   macro.get(publicAPI, model, ['url']);
   macro.setGet(publicAPI, model, ['dataAccessHelper', 'xSpacing', 'ySpacing', 'zScaling', 'xDirection', 'yDirection']);
   macro.algo(publicAPI, model, 0, 1);
-  macro.event(publicAPI, model, 'busy'); // Object methods
+  macro.event(publicAPI, model, 'busy');
 
+  // Object methods
   vtkElevationReader(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = macro.newInstance(extend, 'vtkElevationReader'); // ----------------------------------------------------------------------------
+const newInstance = macro.newInstance(extend, 'vtkElevationReader');
+
+// ----------------------------------------------------------------------------
 
 var vtkElevationReader$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkElevationReader$1 as default, extend, newInstance };

package/IO/Misc/HttpDataSetLODsLoader.js

@@ -1,4 +1,4 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import DataAccessHelper from '../Core/DataAccessHelper.js';
 import vtkHttpDataSetReader from '../Core/HttpDataSetReader.js';
 import '../Core/DataAccessHelper/LiteHttpDataAccessHelper.js';
@@ -7,87 +7,82 @@ import '../Core/DataAccessHelper/LiteHttpDataAccessHelper.js';
 // import 'vtk.js/Sources/IO/Core/DataAccessHelper/HtmlDataAccessHelper'; // html + base64 + zip
 // import 'vtk.js/Sources/IO/Core/DataAccessHelper/JSZipDataAccessHelper'; // zip
 
-var vtkErrorMacro = macro.vtkErrorMacro; // ----------------------------------------------------------------------------
+const {
+  vtkErrorMacro
+} = macro;
+
+// ----------------------------------------------------------------------------
 // vtkHttpDataSetLODsLoader methods
 // ----------------------------------------------------------------------------
 
 function vtkHttpDataSetLODsLoader(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkHttpDataSetLODsLoader');
-  var internal = {
+  const internal = {
     downloadStack: []
-  }; //--------------------------------------------------------------------------
+  };
+
+  //--------------------------------------------------------------------------
 
-  publicAPI.startDownloads = function () {
+  publicAPI.startDownloads = () => {
     if (!model.mapper) {
       vtkErrorMacro('Mapper was not set.');
       return;
     }
-
     if (!model.files || model.files.length === 0) {
       vtkErrorMacro('No files set.');
       return;
     }
-
-    var baseUrl = model.baseUrl;
-
+    let baseUrl = model.baseUrl;
     if (baseUrl && !baseUrl.endsWith('/')) {
       baseUrl += '/';
-    } // Create the download stack
-
+    }
 
+    // Create the download stack
     internal.downloadStack = [];
-    model.files.forEach(function (file) {
-      return internal.downloadStack.push("".concat(baseUrl).concat(file));
-    });
-
-    var downloadNextSource = function downloadNextSource() {
-      var url = internal.downloadStack.shift();
-      var nextSource = vtkHttpDataSetReader.newInstance({
+    model.files.forEach(file => internal.downloadStack.push(`${baseUrl}${file}`));
+    const downloadNextSource = () => {
+      const url = internal.downloadStack.shift();
+      const nextSource = vtkHttpDataSetReader.newInstance({
         dataAccessHelper: DataAccessHelper.get('http')
       });
       model.currentSource = nextSource;
-      var options = {
+      const options = {
         compression: 'zip',
         loadData: true,
         fullpath: true
       };
-      nextSource.setUrl(url, options).then(function () {
+      nextSource.setUrl(url, options).then(() => {
         model.mapper.setInputConnection(nextSource.getOutputPort());
-
         if (model.sceneItem) {
           // Apply settings to the new source
-          var settings = model.sceneItem.defaultSettings;
-
+          const settings = model.sceneItem.defaultSettings;
           if (settings.mapper) {
             if (settings.mapper.colorByArrayName) {
               nextSource.enableArray(settings.mapper.colorByArrayName, settings.mapper.colorByArrayName);
             }
           }
-
           model.sceneItem.source = nextSource;
         }
-
         if (model.stepFinishedCallback) {
           // In clients like paraview glance, the callback might
           // involve setting the current source on a proxy
           model.stepFinishedCallback();
         }
-
         if (internal.downloadStack.length !== 0) {
           setTimeout(downloadNextSource, model.waitTimeBetweenDownloads);
         }
       });
     };
-
     setTimeout(downloadNextSource, model.waitTimeToStart);
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   baseUrl: '',
   // The currentSource is set internally to the most recently
   // created source. It might be useful to access it in a callback
@@ -100,24 +95,32 @@ var DEFAULT_VALUES = {
   // These are in milliseconds
   waitTimeToStart: 4000,
   waitTimeBetweenDownloads: 0
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   Object.assign(model, DEFAULT_VALUES, initialValues);
-  macro.obj(publicAPI, model); // Create get-set macros
+  macro.obj(publicAPI, model);
 
+  // Create get-set macros
   macro.setGet(publicAPI, model, ['baseUrl', 'files', 'mapper', 'sceneItem', 'stepFinishedCallback', 'waitTimeToStart', 'waitTimeBetweenDownloads']);
-  macro.get(publicAPI, model, ['currentSource']); // Object specific methods
+  macro.get(publicAPI, model, ['currentSource']);
 
+  // Object specific methods
   vtkHttpDataSetLODsLoader(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkHttpDataSetLODsLoader');
 
-var newInstance = macro.newInstance(extend, 'vtkHttpDataSetLODsLoader'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 var vtkHttpDataSetLODsLoader$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkHttpDataSetLODsLoader$1 as default, extend, newInstance };

package/IO/Misc/ITKImageReader.js

@@ -1,101 +1,114 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import ITKHelper from '../../Common/DataModel/ITKHelper.js';
 
-var convertItkToVtkImage = ITKHelper.convertItkToVtkImage;
-var readImageArrayBuffer = null;
-
-var resultPreprocessor = function resultPreprocessor(result) {
-  return result;
-};
-
+const {
+  convertItkToVtkImage
+} = ITKHelper;
+let readImageArrayBuffer = null;
+let resultPreprocessor = result => result;
 function getArrayName(filename) {
-  var idx = filename.lastIndexOf('.');
-  var name = idx > -1 ? filename.substring(0, idx) : filename;
-  return "Scalars ".concat(name);
+  const idx = filename.lastIndexOf('.');
+  const name = idx > -1 ? filename.substring(0, idx) : filename;
+  return `Scalars ${name}`;
 }
-
 function setReadImageArrayBufferFromITK(fn) {
-  readImageArrayBuffer = fn; // itk.js 9.0.0 introduced breaking changes, which can be detected
-  // by an updated function signature.
+  readImageArrayBuffer = fn;
 
+  // itk.js 9.0.0 introduced breaking changes, which can be detected
+  // by an updated function signature.
   if (readImageArrayBuffer.length === 4) {
     // first arg is a webworker if reuse is desired.
-    readImageArrayBuffer = function readImageArrayBuffer() {
+    readImageArrayBuffer = function () {
       for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
         args[_key] = arguments[_key];
       }
+      return fn(null, ...args);
+    };
 
-      return fn.apply(void 0, [null].concat(args));
-    }; // an object is now passed out which includes a webworker which we
+    // an object is now passed out which includes a webworker which we
     // should terminate
-
-
-    resultPreprocessor = function resultPreprocessor(_ref) {
-      var webWorker = _ref.webWorker,
-          image = _ref.image;
+    resultPreprocessor = _ref => {
+      let {
+        webWorker,
+        image
+      } = _ref;
       webWorker.terminate();
       return image;
     };
   }
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // vtkITKImageReader methods
 // ----------------------------------------------------------------------------
 
-
 function vtkITKImageReader(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkITKImageReader'); // Returns a promise to signal when image is ready
+  model.classHierarchy.push('vtkITKImageReader');
 
-  publicAPI.parseAsArrayBuffer = function (arrayBuffer) {
+  // Returns a promise to signal when image is ready
+  publicAPI.parseAsArrayBuffer = arrayBuffer => {
     if (!arrayBuffer || arrayBuffer === model.rawDataBuffer) {
       return Promise.resolve();
     }
-
     model.rawDataBuffer = arrayBuffer;
-    return readImageArrayBuffer(arrayBuffer, model.fileName).then(resultPreprocessor).then(function (itkImage) {
-      var imageData = convertItkToVtkImage(itkImage, {
+    return readImageArrayBuffer(arrayBuffer, model.fileName).then(resultPreprocessor).then(itkImage => {
+      const imageData = convertItkToVtkImage(itkImage, {
         scalarArrayName: model.arrayName || getArrayName(model.fileName)
       });
       model.output[0] = imageData;
       publicAPI.modified();
     });
   };
-
-  publicAPI.requestData = function (inData, outData) {
+  publicAPI.requestData = (inData, outData) => {
     publicAPI.parseAsArrayBuffer(model.rawDataBuffer, model.fileName);
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   fileName: '',
   // If null/undefined a unique array will be generated
   arrayName: null
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Build VTK API
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
+  // Build VTK API
   macro.obj(publicAPI, model);
   macro.algo(publicAPI, model, 0, 1);
-  macro.setGet(publicAPI, model, ['fileName', 'arrayName']); // vtkITKImageReader methods
+  macro.setGet(publicAPI, model, ['fileName', 'arrayName']);
 
-  vtkITKImageReader(publicAPI, model); // Check that ITK function has been injected
+  // vtkITKImageReader methods
+  vtkITKImageReader(publicAPI, model);
 
+  // Check that ITK function has been injected
   if (!readImageArrayBuffer) {
-    console.error("\n      // Dependency needs to be added inside your project\n      import readImageArrayBuffer from 'itk/readImageArrayBuffer';\n      vtkITKImageReader.setReadImageArrayBufferFromITK(readImageArrayBuffer);\n      ");
+    console.error(`
+      // Dependency needs to be added inside your project
+      import readImageArrayBuffer from 'itk/readImageArrayBuffer';
+      vtkITKImageReader.setReadImageArrayBufferFromITK(readImageArrayBuffer);
+      `);
   }
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkITKImageReader');
 
-var newInstance = macro.newInstance(extend, 'vtkITKImageReader'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 var vtkITKImageReader$1 = {
-  newInstance: newInstance,
-  extend: extend,
-  setReadImageArrayBufferFromITK: setReadImageArrayBufferFromITK
+  newInstance,
+  extend,
+  setReadImageArrayBufferFromITK
 };
 
 export { vtkITKImageReader$1 as default, extend, newInstance };

package/IO/Misc/ITKPolyDataReader.js

@@ -1,87 +1,99 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtk from '../../vtk.js';
 
-var readPolyDataArrayBuffer = null;
-
-var resultPreprocessor = function resultPreprocessor(result) {
-  return result;
-};
-
+let readPolyDataArrayBuffer = null;
+let resultPreprocessor = result => result;
 function setReadPolyDataArrayBufferFromITK(fn) {
-  readPolyDataArrayBuffer = fn; // first arg is a webworker if reuse is desired.
+  readPolyDataArrayBuffer = fn;
 
-  readPolyDataArrayBuffer = function readPolyDataArrayBuffer() {
+  // first arg is a webworker if reuse is desired.
+  readPolyDataArrayBuffer = function () {
     for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
       args[_key] = arguments[_key];
     }
+    return fn(null, ...args);
+  };
 
-    return fn.apply(void 0, [null].concat(args));
-  }; // an object is now passed out which includes a webworker which we
+  // an object is now passed out which includes a webworker which we
   // should terminate
-
-
-  resultPreprocessor = function resultPreprocessor(_ref) {
-    var webWorker = _ref.webWorker,
-        polyData = _ref.polyData;
+  resultPreprocessor = _ref => {
+    let {
+      webWorker,
+      polyData
+    } = _ref;
     webWorker.terminate();
     return polyData;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // vtkITKPolyDataReader methods
 // ----------------------------------------------------------------------------
 
-
 function vtkITKPolyDataReader(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkITKPolyDataReader'); // Returns a promise to signal when polyData is ready
+  model.classHierarchy.push('vtkITKPolyDataReader');
 
-  publicAPI.parseAsArrayBuffer = function (arrayBuffer) {
+  // Returns a promise to signal when polyData is ready
+  publicAPI.parseAsArrayBuffer = arrayBuffer => {
     if (!arrayBuffer || arrayBuffer === model.rawDataBuffer) {
       return Promise.resolve();
     }
-
     model.rawDataBuffer = arrayBuffer;
-    return readPolyDataArrayBuffer(arrayBuffer, model.fileName).then(resultPreprocessor).then(function (polyData) {
+    return readPolyDataArrayBuffer(arrayBuffer, model.fileName).then(resultPreprocessor).then(polyData => {
       model.output[0] = vtk(polyData);
       publicAPI.modified();
     });
   };
-
-  publicAPI.requestData = function (inData, outData) {
+  publicAPI.requestData = (inData, outData) => {
     publicAPI.parseAsArrayBuffer(model.rawDataBuffer, model.fileName);
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   fileName: '',
   // If null/undefined a unique array will be generated
   arrayName: null
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Build VTK API
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
+  // Build VTK API
   macro.obj(publicAPI, model);
   macro.algo(publicAPI, model, 0, 1);
-  macro.setGet(publicAPI, model, ['fileName', 'arrayName']); // vtkITKPolyDataReader methods
+  macro.setGet(publicAPI, model, ['fileName', 'arrayName']);
 
-  vtkITKPolyDataReader(publicAPI, model); // Check that ITK function has been injected
+  // vtkITKPolyDataReader methods
+  vtkITKPolyDataReader(publicAPI, model);
 
+  // Check that ITK function has been injected
   if (!readPolyDataArrayBuffer) {
-    console.error("\n      // Dependency needs to be added inside your project\n      import readPolyDataArrayBuffer from 'itk/readPolyDataArrayBuffer';\n      vtkITKPolyDataReader.setReadPolyDataArrayBufferFromITK(readPolyDataArrayBuffer);\n      ");
+    console.error(`
+      // Dependency needs to be added inside your project
+      import readPolyDataArrayBuffer from 'itk/readPolyDataArrayBuffer';
+      vtkITKPolyDataReader.setReadPolyDataArrayBufferFromITK(readPolyDataArrayBuffer);
+      `);
   }
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = macro.newInstance(extend, 'vtkITKPolyDataReader'); // ----------------------------------------------------------------------------
+const newInstance = macro.newInstance(extend, 'vtkITKPolyDataReader');
+
+// ----------------------------------------------------------------------------
 
 var vtkITKPolyDataReader$1 = {
-  newInstance: newInstance,
-  extend: extend,
-  setReadPolyDataArrayBufferFromITK: setReadPolyDataArrayBufferFromITK
+  newInstance,
+  extend,
+  setReadPolyDataArrayBufferFromITK
 };
 
 export { vtkITKPolyDataReader$1 as default, extend, newInstance };