@kitware/vtk.js 28.10.2 → 28.11.1

package/Filters/General.js

@@ -21,27 +21,27 @@ import vtkWarpScalar from './General/WarpScalar.js';
 import vtkWindowedSincPolyDataFilter from './General/WindowedSincPolyDataFilter.js';
 
 var General = {
-  vtkAppendPolyData: vtkAppendPolyData,
-  vtkCalculator: vtkCalculator,
-  vtkClipClosedSurface: vtkClipClosedSurface,
-  vtkClosedPolyLineToSurfaceFilter: vtkClosedPolyLineToSurfaceFilter,
-  vtkContourTriangulator: vtkContourTriangulator,
-  vtkImageCropFilter: vtkImageCropFilter,
-  vtkImageMarchingCubes: vtkImageMarchingCubes,
-  vtkImageMarchingSquares: vtkImageMarchingSquares,
-  vtkImageOutlineFilter: vtkImageOutlineFilter,
-  vtkImageSliceFilter: vtkImageSliceFilter,
-  vtkImageStreamline: vtkImageStreamline,
-  vtkLineFilter: vtkLineFilter,
-  vtkMoleculeToRepresentation: vtkMoleculeToRepresentation,
-  vtkOBBTree: vtkOBBTree,
-  vtkOutlineFilter: vtkOutlineFilter,
-  vtkPaintFilter: vtkPaintFilter,
-  vtkScalarToRGBA: vtkScalarToRGBA,
-  vtkTriangleFilter: vtkTriangleFilter,
-  vtkTubeFilter: vtkTubeFilter,
-  vtkWarpScalar: vtkWarpScalar,
-  vtkWindowedSincPolyDataFilter: vtkWindowedSincPolyDataFilter
+  vtkAppendPolyData,
+  vtkCalculator,
+  vtkClipClosedSurface,
+  vtkClosedPolyLineToSurfaceFilter,
+  vtkContourTriangulator,
+  vtkImageCropFilter,
+  vtkImageMarchingCubes,
+  vtkImageMarchingSquares,
+  vtkImageOutlineFilter,
+  vtkImageSliceFilter,
+  vtkImageStreamline,
+  vtkLineFilter,
+  vtkMoleculeToRepresentation,
+  vtkOBBTree,
+  vtkOutlineFilter,
+  vtkPaintFilter,
+  vtkScalarToRGBA,
+  vtkTriangleFilter,
+  vtkTubeFilter,
+  vtkWarpScalar,
+  vtkWindowedSincPolyDataFilter
 };
 
 export { General as default };

package/Filters/Sources/Arrow2DSource/Constants.js

@@ -1,11 +1,11 @@
-var ShapeType = {
+const ShapeType = {
   TRIANGLE: 'triangle',
   STAR: 'star',
   ARROW_4: 'arrow4points',
   ARROW_6: 'arrow6points'
 };
 var Constants = {
-  ShapeType: ShapeType
+  ShapeType
 };
 
 export { ShapeType, Constants as default };

package/Filters/Sources/Arrow2DSource.js

@@ -1,42 +1,38 @@
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkMatrixBuilder from '../../Common/Core/MatrixBuilder.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import Constants from './Arrow2DSource/Constants.js';
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+const {
+  ShapeType
+} = Constants;
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-var ShapeType = Constants.ShapeType; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // vtkArrow2DSource methods
 // ----------------------------------------------------------------------------
 
 function vtkStarSource(publicAPI, model) {
-  var dataset = vtkPolyData.newInstance();
-  var points = macro.newTypedArray(model.pointType, 10 * 3);
-  var edges = new Uint32Array(11);
+  const dataset = vtkPolyData.newInstance();
+  const points = macro.newTypedArray(model.pointType, 10 * 3);
+  const edges = new Uint32Array(11);
   edges[0] = 10;
-
-  for (var i = 0; i < 10; i++) {
-    var radius = i % 2 === 1 ? model.height : model.height * 0.4;
+  for (let i = 0; i < 10; i++) {
+    const radius = i % 2 === 1 ? model.height : model.height * 0.4;
     points[3 * i + 0] = radius * Math.cos((2 * i - 1) * Math.PI / 10);
     points[3 * i + 1] = radius * Math.sin((2 * i - 1) * Math.PI / 10);
     points[3 * i + 2] = 0;
     edges[1 + i] = i;
   }
-
   dataset.getPoints().setData(points, 3);
   dataset.getPolys().setData(edges, 1);
   return dataset;
 }
-
 function vtk6PointsArrow(publicAPI, model) {
-  var dataset = vtkPolyData.newInstance();
-  var points = macro.newTypedArray(model.pointType, 6 * 3);
-  var thickOp = model.height * 0.5 * model.thickness;
-  var offsetOp = model.height * 0.5 - thickOp;
-  var baseOffsetOp = (model.height * 0.9 + thickOp - offsetOp - (model.height * 0.5 - thickOp - offsetOp)) * (1 - model.base);
+  const dataset = vtkPolyData.newInstance();
+  const points = macro.newTypedArray(model.pointType, 6 * 3);
+  const thickOp = model.height * 0.5 * model.thickness;
+  const offsetOp = model.height * 0.5 - thickOp;
+  const baseOffsetOp = (model.height * 0.9 + thickOp - offsetOp - (model.height * 0.5 - thickOp - offsetOp)) * (1 - model.base);
   points[0] = model.width / 2 * -1 - thickOp;
   points[1] = model.height / 4 - offsetOp - baseOffsetOp;
   points[2] = 0.0;
@@ -54,20 +50,20 @@ function vtk6PointsArrow(publicAPI, model) {
   points[14] = 0.0;
   points[15] = model.width / 3 * -1;
   points[16] = model.height * 0.1 - thickOp - offsetOp - baseOffsetOp;
-  points[17] = 0.0; // prettier-ignore
+  points[17] = 0.0;
 
-  var cells = Uint8Array.from([3, 0, 1, 5, 3, 1, 4, 5, 3, 1, 4, 3, 3, 1, 2, 3]);
+  // prettier-ignore
+  const cells = Uint8Array.from([3, 0, 1, 5, 3, 1, 4, 5, 3, 1, 4, 3, 3, 1, 2, 3]);
   dataset.getPoints().setData(points, 3);
   dataset.getPolys().setData(cells, 1);
   return dataset;
 }
-
 function vtk4PointsArrow(publicAPI, model) {
-  var dataset = vtkPolyData.newInstance();
-  var points = macro.newTypedArray(model.pointType, 4 * 3);
-  var thickOp = model.height / 3 * model.thickness;
-  var offsetOp = model.height / 3 - thickOp;
-  var baseOffsetOp = (model.height - offsetOp - (model.height / 3 - thickOp - offsetOp)) * (1 - model.base);
+  const dataset = vtkPolyData.newInstance();
+  const points = macro.newTypedArray(model.pointType, 4 * 3);
+  const thickOp = model.height / 3 * model.thickness;
+  const offsetOp = model.height / 3 - thickOp;
+  const baseOffsetOp = (model.height - offsetOp - (model.height / 3 - thickOp - offsetOp)) * (1 - model.base);
   points[0] = model.width / 2 * -1;
   points[1] = 0.0 - offsetOp - baseOffsetOp;
   points[2] = 0.0;
@@ -80,16 +76,15 @@ function vtk4PointsArrow(publicAPI, model) {
   points[9] = 0.0;
   points[10] = model.height / 3 - thickOp - offsetOp - baseOffsetOp;
   points[11] = 0.0;
-  var cells = Uint8Array.from([3, 0, 1, 3, 3, 1, 2, 3]);
+  const cells = Uint8Array.from([3, 0, 1, 3, 3, 1, 2, 3]);
   dataset.getPoints().setData(points, 3);
   dataset.getPolys().setData(cells, 1);
   return dataset;
 }
-
 function vtkTriangleSource(publicAPI, model) {
-  var dataset = vtkPolyData.newInstance();
-  var points = macro.newTypedArray(model.pointType, 3 * 3);
-  var baseOffsetOp = model.height * (1 - model.base);
+  const dataset = vtkPolyData.newInstance();
+  const points = macro.newTypedArray(model.pointType, 3 * 3);
+  const baseOffsetOp = model.height * (1 - model.base);
   points[0] = model.width / 2 * -1;
   points[1] = 0.0 - baseOffsetOp;
   points[2] = 0.0;
@@ -99,25 +94,25 @@ function vtkTriangleSource(publicAPI, model) {
   points[6] = model.width / 2;
   points[7] = 0.0 - baseOffsetOp;
   points[8] = 0.0;
-  var cells = Uint8Array.from([3, 0, 1, 2]);
+  const cells = Uint8Array.from([3, 0, 1, 2]);
   dataset.getPoints().setData(points, 3);
   dataset.getPolys().setData(cells, 1);
   return dataset;
 }
-
 function vtkArrow2DSource(publicAPI, model) {
-  var _shapeToSource;
-
-  var shapeToSource = (_shapeToSource = {}, _defineProperty(_shapeToSource, ShapeType.TRIANGLE, vtkTriangleSource), _defineProperty(_shapeToSource, ShapeType.STAR, vtkStarSource), _defineProperty(_shapeToSource, ShapeType.ARROW_4, vtk4PointsArrow), _defineProperty(_shapeToSource, ShapeType.ARROW_6, vtk6PointsArrow), _shapeToSource);
-
-  publicAPI.requestData = function (inData, outData) {
-    var _vtkMatrixBuilder$bui;
-
+  const shapeToSource = {
+    [ShapeType.TRIANGLE]: vtkTriangleSource,
+    [ShapeType.STAR]: vtkStarSource,
+    [ShapeType.ARROW_4]: vtk4PointsArrow,
+    [ShapeType.ARROW_6]: vtk6PointsArrow
+  };
+  publicAPI.requestData = (inData, outData) => {
     outData[0] = shapeToSource[model.shape](publicAPI, model);
-
-    (_vtkMatrixBuilder$bui = vtkMatrixBuilder.buildFromRadian()).translate.apply(_vtkMatrixBuilder$bui, _toConsumableArray(model.center)).rotateFromDirections([1, 0, 0], model.direction).apply(outData[0].getPoints().getData());
+    vtkMatrixBuilder.buildFromRadian().translate(...model.center).rotateFromDirections([1, 0, 0], model.direction).apply(outData[0].getPoints().getData());
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
@@ -131,37 +126,42 @@ function vtkArrow2DSource(publicAPI, model) {
  * base modifies the position which lowers the source on x axis for 0 and moves
  * the source up on x axis for 1
  */
-
-
 function defaultValues(initialValues) {
-  return _objectSpread({
+  return {
     base: 0,
     center: [0, 0, 0],
     height: 1.0,
     direction: [1, 0, 0],
     pointType: 'Float64Array',
     thickness: 0,
-    width: 1.0
-  }, initialValues);
-} // ----------------------------------------------------------------------------
+    width: 1.0,
+    ...initialValues
+  };
+}
 
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, defaultValues(initialValues)); // Build VTK API
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, defaultValues(initialValues));
 
+  // Build VTK API
   macro.obj(publicAPI, model);
   macro.setGet(publicAPI, model, ['height', 'width', 'thickness', 'base']);
   macro.setGetArray(publicAPI, model, ['center', 'direction'], 3);
   macro.algo(publicAPI, model, 0, 1);
   vtkArrow2DSource(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkArrow2DSource');
 
-var newInstance = macro.newInstance(extend, 'vtkArrow2DSource'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 var vtkArrow2DSource$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkArrow2DSource$1 as default, extend, newInstance };

package/Filters/Sources/ArrowSource.js

@@ -1,70 +1,73 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkAppendPolyData from '../General/AppendPolyData.js';
 import vtkConeSource from './ConeSource.js';
 import vtkCylinderSource from './CylinderSource.js';
 import vtkMatrixBuilder from '../../Common/Core/MatrixBuilder.js';
 
+// ----------------------------------------------------------------------------
 // vtkArrowSource methods
 // ----------------------------------------------------------------------------
 
 function vtkArrowSource(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkArrowSource');
-
   function requestData(inData, outData) {
     if (model.deleted) {
       return;
     }
-
-    var cylinder = vtkCylinderSource.newInstance({
+    const cylinder = vtkCylinderSource.newInstance({
       capping: true
     });
     cylinder.setResolution(model.shaftResolution);
     cylinder.setRadius(model.shaftRadius);
     cylinder.setHeight(1.0 - model.tipLength);
     cylinder.setCenter(0, (1.0 - model.tipLength) * 0.5, 0.0);
-    var cylinderPD = cylinder.getOutputData();
-    var cylinderPts = cylinderPD.getPoints().getData();
-    var cylinderNormals = cylinderPD.getPointData().getNormals().getData(); // Apply transformation to the cylinder
+    const cylinderPD = cylinder.getOutputData();
+    const cylinderPts = cylinderPD.getPoints().getData();
+    const cylinderNormals = cylinderPD.getPointData().getNormals().getData();
 
+    // Apply transformation to the cylinder
     vtkMatrixBuilder.buildFromDegree().rotateZ(-90).apply(cylinderPts).apply(cylinderNormals);
-    var cone = vtkConeSource.newInstance();
+    const cone = vtkConeSource.newInstance();
     cone.setResolution(model.tipResolution);
     cone.setHeight(model.tipLength);
     cone.setRadius(model.tipRadius);
-    var conePD = cone.getOutputData();
-    var conePts = conePD.getPoints().getData(); // Apply transformation to the cone
+    const conePD = cone.getOutputData();
+    const conePts = conePD.getPoints().getData();
 
+    // Apply transformation to the cone
     vtkMatrixBuilder.buildFromRadian().translate(1.0 - model.tipLength * 0.5, 0.0, 0.0).apply(conePts);
-    var append = vtkAppendPolyData.newInstance();
+    const append = vtkAppendPolyData.newInstance();
     append.setInputData(cylinderPD);
     append.addInputData(conePD);
-    var appendPD = append.getOutputData();
-    var appendPts = appendPD.getPoints().getData(); // Center the arrow about [0, 0, 0]
-
+    const appendPD = append.getOutputData();
+    const appendPts = appendPD.getPoints().getData();
+    // Center the arrow about [0, 0, 0]
     vtkMatrixBuilder.buildFromRadian().translate(-0.5 + model.tipLength * 0.5, 0.0, 0.0).apply(appendPts);
-
     if (model.invert) {
       // Apply transformation to the arrow
-      vtkMatrixBuilder.buildFromRadian().rotateFromDirections([1, 0, 0], model.direction).scale(-1, -1, -1).apply(appendPts); // Update output
+      vtkMatrixBuilder.buildFromRadian().rotateFromDirections([1, 0, 0], model.direction).scale(-1, -1, -1).apply(appendPts);
 
+      // Update output
       outData[0] = appendPD;
     } else {
       // Apply transformation to the arrow
-      vtkMatrixBuilder.buildFromRadian().rotateFromDirections([1, 0, 0], model.direction).scale(1, 1, 1).apply(appendPts); // Update output
+      vtkMatrixBuilder.buildFromRadian().rotateFromDirections([1, 0, 0], model.direction).scale(1, 1, 1).apply(appendPts);
 
+      // Update output
       outData[0] = append.getOutputData();
     }
-  } // Expose methods
-
+  }
 
+  // Expose methods
   publicAPI.requestData = requestData;
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   tipResolution: 6,
   tipRadius: 0.1,
   tipLength: 0.35,
@@ -73,24 +76,31 @@ var DEFAULT_VALUES = {
   invert: false,
   direction: [1.0, 0.0, 0.0],
   pointType: 'Float64Array'
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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.setGet(publicAPI, model, ['tipResolution', 'tipRadius', 'tipLength', 'shaftResolution', 'shaftRadius', 'invert']);
   macro.setGetArray(publicAPI, model, ['direction'], 3);
   macro.algo(publicAPI, model, 0, 1);
   vtkArrowSource(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkArrowSource'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkArrowSource');
+
+// ----------------------------------------------------------------------------
 
 var vtkArrowSource$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkArrowSource$1 as default, extend, newInstance };

package/Filters/Sources/CircleSource.js

@@ -1,101 +1,101 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import vtkMatrixBuilder from '../../Common/Core/MatrixBuilder.js';
 import { w as multiplyScalar } from '../../Common/Core/Math/index.js';
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+// ----------------------------------------------------------------------------
 // vtkCircleSource methods
 // ----------------------------------------------------------------------------
 
 function vtkCircleSource(publicAPI, model) {
   // Set our classname
   model.classHierarchy.push('vtkCircleSource');
-
   function requestData(inData, outData) {
-    var _vtkMatrixBuilder$bui, _vtkMatrixBuilder$bui2;
-
     if (model.deleted) {
       return;
     }
+    let dataset = outData[0];
 
-    var dataset = outData[0]; // Points
+    // Points
+    const points = macro.newTypedArray(model.pointType, model.resolution * 3);
 
-    var points = macro.newTypedArray(model.pointType, model.resolution * 3); // Lines/cells
+    // Lines/cells
     // [# of points in line, vert_index_0, vert_index_1, ..., vert_index_0]
-
-    var edges = new Uint32Array(model.resolution + 2);
-    edges[0] = model.resolution + 1; // generate polydata
-
-    var angle = 2.0 * Math.PI / model.resolution;
-
-    for (var i = 0; i < model.resolution; i++) {
-      var x = model.center[0];
-      var y = model.radius * Math.cos(i * angle) + model.center[1];
-      var z = model.radius * Math.sin(i * angle) + model.center[2];
+    const edges = new Uint32Array(model.resolution + 2);
+    edges[0] = model.resolution + 1;
+
+    // generate polydata
+    const angle = 2.0 * Math.PI / model.resolution;
+    for (let i = 0; i < model.resolution; i++) {
+      const x = model.center[0];
+      const y = model.radius * Math.cos(i * angle) + model.center[1];
+      const z = model.radius * Math.sin(i * angle) + model.center[2];
       points.set([x, y, z], i * 3);
       edges[i + 1] = i;
-    } // connect endpoints
-
+    }
 
+    // connect endpoints
     edges[edges.length - 1] = edges[1];
     dataset = vtkPolyData.newInstance();
     dataset.getPoints().setData(points, 3);
-
     if (model.lines) {
       dataset.getLines().setData(edges, 1);
     }
-
     if (model.face) {
       dataset.getPolys().setData(edges, 1);
-    } // translate an eventual center different to [0, 0, 0] to ensure rotation is correct
-
-
-    (_vtkMatrixBuilder$bui = (_vtkMatrixBuilder$bui2 = vtkMatrixBuilder.buildFromRadian()).translate.apply(_vtkMatrixBuilder$bui2, _toConsumableArray(model.center)).rotateFromDirections([1, 0, 0], model.direction)).translate.apply(_vtkMatrixBuilder$bui, _toConsumableArray(multiplyScalar(_toConsumableArray(model.center), -1))).apply(points); // Update output
+    }
 
+    // translate an eventual center different to [0, 0, 0] to ensure rotation is correct
+    vtkMatrixBuilder.buildFromRadian().translate(...model.center).rotateFromDirections([1, 0, 0], model.direction).translate(...multiplyScalar([...model.center], -1)).apply(points);
 
+    // Update output
     outData[0] = dataset;
-  } // Expose methods
-
+  }
 
+  // Expose methods
   publicAPI.requestData = requestData;
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
 function defaultValues(initialValues) {
-  return _objectSpread({
+  return {
     face: true,
     center: [0, 0, 0],
     lines: false,
     direction: [1, 0, 0],
     pointType: 'Float64Array',
     radius: 1.0,
-    resolution: 6
-  }, initialValues);
-} // ----------------------------------------------------------------------------
+    resolution: 6,
+    ...initialValues
+  };
+}
 
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, defaultValues(initialValues)); // Build VTK API
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, defaultValues(initialValues));
 
+  // Build VTK API
   macro.obj(publicAPI, model);
   macro.setGet(publicAPI, model, ['radius', 'resolution', 'lines', 'face']);
   macro.setGetArray(publicAPI, model, ['center', 'direction'], 3);
   macro.algo(publicAPI, model, 0, 1);
   vtkCircleSource(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = macro.newInstance(extend, 'vtkCircleSource'); // ----------------------------------------------------------------------------
+const newInstance = macro.newInstance(extend, 'vtkCircleSource');
+
+// ----------------------------------------------------------------------------
 
 var vtkCircleSource$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkCircleSource$1 as default, extend, newInstance };