@kitware/vtk.js 28.10.2 → 28.11.0

package/Rendering/OpenGL/Renderer.js

@@ -1,23 +1,26 @@
-import { newInstance as newInstance$1, get, setGet, moveToProtected, vtkDebugMacro as vtkDebugMacro$1 } from '../../macros.js';
+import { n as newInstance$1, g as get, e as setGet, i as moveToProtected, c as macro } from '../../macros2.js';
 import vtkViewNode from '../SceneGraph/ViewNode.js';
 import { registerOverride } from './ViewNodeFactory.js';
 
-var vtkDebugMacro = vtkDebugMacro$1; // ----------------------------------------------------------------------------
+const {
+  vtkDebugMacro
+} = macro;
+
+// ----------------------------------------------------------------------------
 // vtkOpenGLRenderer methods
 // ----------------------------------------------------------------------------
-
 /* eslint-disable no-bitwise */
 
 function vtkOpenGLRenderer(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkOpenGLRenderer'); // Builds myself.
+  model.classHierarchy.push('vtkOpenGLRenderer');
 
-  publicAPI.buildPass = function (prepass) {
+  // Builds myself.
+  publicAPI.buildPass = prepass => {
     if (prepass) {
       if (!model.renderable) {
         return;
       }
-
       publicAPI.updateLights();
       publicAPI.prepareNodes();
       publicAPI.addMissingNode(model.renderable.getActiveCamera());
@@ -25,195 +28,180 @@ function vtkOpenGLRenderer(publicAPI, model) {
       publicAPI.removeUnusedNodes();
     }
   };
-
-  publicAPI.updateLights = function () {
-    var count = 0;
-    var lights = model.renderable.getLightsByReference();
-
-    for (var index = 0; index < lights.length; ++index) {
+  publicAPI.updateLights = () => {
+    let count = 0;
+    const lights = model.renderable.getLightsByReference();
+    for (let index = 0; index < lights.length; ++index) {
       if (lights[index].getSwitch() > 0.0) {
         count++;
       }
     }
-
     if (!count) {
       vtkDebugMacro('No lights are on, creating one.');
       model.renderable.createLight();
     }
-
     return count;
   };
-
-  publicAPI.zBufferPass = function (prepass) {
+  publicAPI.zBufferPass = prepass => {
     if (prepass) {
-      var clearMask = 0;
-      var gl = model.context;
-
+      let clearMask = 0;
+      const gl = model.context;
       if (!model.renderable.getTransparent()) {
         model.context.clearColor(1.0, 0.0, 0.0, 1.0);
         clearMask |= gl.COLOR_BUFFER_BIT;
       }
-
       if (!model.renderable.getPreserveDepthBuffer()) {
         gl.clearDepth(1.0);
         clearMask |= gl.DEPTH_BUFFER_BIT;
         model.context.depthMask(true);
       }
-
-      var ts = publicAPI.getTiledSizeAndOrigin();
+      const ts = publicAPI.getTiledSizeAndOrigin();
       gl.enable(gl.SCISSOR_TEST);
       gl.scissor(ts.lowerLeftU, ts.lowerLeftV, ts.usize, ts.vsize);
       gl.viewport(ts.lowerLeftU, ts.lowerLeftV, ts.usize, ts.vsize);
       gl.colorMask(true, true, true, true);
-
       if (clearMask) {
         gl.clear(clearMask);
       }
-
       gl.enable(gl.DEPTH_TEST);
     }
   };
+  publicAPI.opaqueZBufferPass = prepass => publicAPI.zBufferPass(prepass);
 
-  publicAPI.opaqueZBufferPass = function (prepass) {
-    return publicAPI.zBufferPass(prepass);
-  }; // Renders myself
-
-
-  publicAPI.cameraPass = function (prepass) {
+  // Renders myself
+  publicAPI.cameraPass = prepass => {
     if (prepass) {
       publicAPI.clear();
     }
   };
-
-  publicAPI.getAspectRatio = function () {
-    var size = model._parent.getSizeByReference();
-
-    var viewport = model.renderable.getViewportByReference();
+  publicAPI.getAspectRatio = () => {
+    const size = model._parent.getSizeByReference();
+    const viewport = model.renderable.getViewportByReference();
     return size[0] * (viewport[2] - viewport[0]) / ((viewport[3] - viewport[1]) * size[1]);
   };
+  publicAPI.getTiledSizeAndOrigin = () => {
+    const vport = model.renderable.getViewportByReference();
 
-  publicAPI.getTiledSizeAndOrigin = function () {
-    var vport = model.renderable.getViewportByReference(); // if there is no window assume 0 1
+    // if there is no window assume 0 1
+    const tileViewPort = [0.0, 0.0, 1.0, 1.0];
 
-    var tileViewPort = [0.0, 0.0, 1.0, 1.0]; // find the lower left corner of the viewport, taking into account the
+    // find the lower left corner of the viewport, taking into account the
     // lower left boundary of this tile
+    const vpu = vport[0] - tileViewPort[0];
+    const vpv = vport[1] - tileViewPort[1];
 
-    var vpu = vport[0] - tileViewPort[0];
-    var vpv = vport[1] - tileViewPort[1]; // store the result as a pixel value
-
-    var ndvp = model._parent.normalizedDisplayToDisplay(vpu, vpv);
+    // store the result as a pixel value
+    const ndvp = model._parent.normalizedDisplayToDisplay(vpu, vpv);
+    const lowerLeftU = Math.round(ndvp[0]);
+    const lowerLeftV = Math.round(ndvp[1]);
 
-    var lowerLeftU = Math.round(ndvp[0]);
-    var lowerLeftV = Math.round(ndvp[1]); // find the upper right corner of the viewport, taking into account the
+    // find the upper right corner of the viewport, taking into account the
     // lower left boundary of this tile
+    const vpu2 = vport[2] - tileViewPort[0];
+    const vpv2 = vport[3] - tileViewPort[1];
+    const ndvp2 = model._parent.normalizedDisplayToDisplay(vpu2, vpv2);
 
-    var vpu2 = vport[2] - tileViewPort[0];
-    var vpv2 = vport[3] - tileViewPort[1];
-
-    var ndvp2 = model._parent.normalizedDisplayToDisplay(vpu2, vpv2); // now compute the size of the intersection of the viewport with the
+    // now compute the size of the intersection of the viewport with the
     // current tile
-
-
-    var usize = Math.round(ndvp2[0]) - lowerLeftU;
-    var vsize = Math.round(ndvp2[1]) - lowerLeftV;
-
+    let usize = Math.round(ndvp2[0]) - lowerLeftU;
+    let vsize = Math.round(ndvp2[1]) - lowerLeftV;
     if (usize < 0) {
       usize = 0;
     }
-
     if (vsize < 0) {
       vsize = 0;
     }
-
     return {
-      usize: usize,
-      vsize: vsize,
-      lowerLeftU: lowerLeftU,
-      lowerLeftV: lowerLeftV
+      usize,
+      vsize,
+      lowerLeftU,
+      lowerLeftV
     };
   };
-
-  publicAPI.clear = function () {
-    var clearMask = 0;
-    var gl = model.context;
-
+  publicAPI.clear = () => {
+    let clearMask = 0;
+    const gl = model.context;
     if (!model.renderable.getTransparent()) {
-      var background = model.renderable.getBackgroundByReference(); // renderable ensures that background has 4 entries.
-
+      const background = model.renderable.getBackgroundByReference();
+      // renderable ensures that background has 4 entries.
       model.context.clearColor(background[0], background[1], background[2], background[3]);
       clearMask |= gl.COLOR_BUFFER_BIT;
     }
-
     if (!model.renderable.getPreserveDepthBuffer()) {
       gl.clearDepth(1.0);
       clearMask |= gl.DEPTH_BUFFER_BIT;
       model.context.depthMask(true);
     }
-
     gl.colorMask(true, true, true, true);
-    var ts = publicAPI.getTiledSizeAndOrigin();
+    const ts = publicAPI.getTiledSizeAndOrigin();
     gl.enable(gl.SCISSOR_TEST);
     gl.scissor(ts.lowerLeftU, ts.lowerLeftV, ts.usize, ts.vsize);
     gl.viewport(ts.lowerLeftU, ts.lowerLeftV, ts.usize, ts.vsize);
-
     if (clearMask) {
       gl.clear(clearMask);
     }
-
     gl.enable(gl.DEPTH_TEST);
     /* eslint-enable no-bitwise */
   };
 
-  publicAPI.releaseGraphicsResources = function () {
+  publicAPI.releaseGraphicsResources = () => {
     if (model.selector !== null) {
       model.selector.releaseGraphicsResources();
     }
   };
-
-  publicAPI.setOpenGLRenderWindow = function (rw) {
+  publicAPI.setOpenGLRenderWindow = rw => {
     if (model._openGLRenderWindow === rw) {
       return;
     }
-
     publicAPI.releaseGraphicsResources();
     model._openGLRenderWindow = rw;
     model.context = null;
-
     if (rw) {
       model.context = model._openGLRenderWindow.getContext();
     }
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   context: null,
   // _openGLRenderWindow: null,
   selector: null
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Inheritance
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
-  vtkViewNode.extend(publicAPI, model, initialValues); // Build VTK API
+  // Inheritance
+  vtkViewNode.extend(publicAPI, model, initialValues);
 
+  // Build VTK API
   get(publicAPI, model, ['shaderCache']);
   setGet(publicAPI, model, ['selector']);
-  moveToProtected(publicAPI, model, ['openGLRenderWindow']); // Object methods
+  moveToProtected(publicAPI, model, ['openGLRenderWindow']);
 
+  // Object methods
   vtkOpenGLRenderer(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = newInstance$1(extend, 'vtkOpenGLRenderer'); // ----------------------------------------------------------------------------
+const newInstance = newInstance$1(extend, 'vtkOpenGLRenderer');
+
+// ----------------------------------------------------------------------------
 
 var vtkRenderer = {
-  newInstance: newInstance,
-  extend: extend
-}; // Register ourself to OpenGL backend if imported
+  newInstance,
+  extend
+};
 
+// Register ourself to OpenGL backend if imported
 registerOverride('vtkRenderer', newInstance);
 
 export { vtkRenderer as default, extend, newInstance };

package/Rendering/OpenGL/ReplacementShaderMapper.js

@@ -1,18 +1,17 @@
 import vtkShaderProgram from './ShaderProgram.js';
 
 function implementReplaceShaderCoincidentOffset(publicAPI, model) {
+  publicAPI.replaceShaderCoincidentOffset = (shaders, ren, actor) => {
+    const cp = publicAPI.getCoincidentParameters(ren, actor);
 
-  publicAPI.replaceShaderCoincidentOffset = function (shaders, ren, actor) {
-    var cp = publicAPI.getCoincidentParameters(ren, actor); // if we need an offset handle it here
+    // if we need an offset handle it here
     // The value of .000016 is suitable for depth buffers
     // of at least 16 bit depth. We do not query the depth
     // right now because we would need some mechanism to
     // cache the result taking into account FBO changes etc.
-
     if (cp && (cp.factor !== 0.0 || cp.offset !== 0.0)) {
-      var FSSource = shaders.Fragment;
+      let FSSource = shaders.Fragment;
       FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::Coincident::Dec', ['uniform float cfactor;', 'uniform float coffset;']).result;
-
       if (model.context.getExtension('EXT_frag_depth')) {
         if (cp.factor !== 0.0) {
           FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::UniformFlow::Impl', ['float cscale = length(vec2(dFdx(gl_FragCoord.z),dFdy(gl_FragCoord.z)));', '//VTK::UniformFlow::Impl'], false).result;
@@ -21,7 +20,6 @@ function implementReplaceShaderCoincidentOffset(publicAPI, model) {
           FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::Depth::Impl', 'gl_FragDepthEXT = gl_FragCoord.z + 0.000016*coffset;').result;
         }
       }
-
       if (model._openGLRenderWindow.getWebgl2()) {
         if (cp.factor !== 0.0) {
           FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::UniformFlow::Impl', ['float cscale = length(vec2(dFdx(gl_FragCoord.z),dFdy(gl_FragCoord.z)));', '//VTK::UniformFlow::Impl'], false).result;
@@ -30,93 +28,77 @@ function implementReplaceShaderCoincidentOffset(publicAPI, model) {
           FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::Depth::Impl', 'gl_FragDepth = gl_FragCoord.z + 0.000016*coffset;').result;
         }
       }
-
       shaders.Fragment = FSSource;
     }
   };
 }
-
 function implementBuildShadersWithReplacements(publicAPI, model) {
-
-  publicAPI.applyShaderReplacements = function (shaders, viewSpec, pre) {
-    var shaderReplacements = null;
-
+  publicAPI.applyShaderReplacements = (shaders, viewSpec, pre) => {
+    let shaderReplacements = null;
     if (viewSpec) {
       shaderReplacements = viewSpec.ShaderReplacements;
     }
-
     if (shaderReplacements) {
-      for (var i = 0; i < shaderReplacements.length; i++) {
-        var currReplacement = shaderReplacements[i];
-
+      for (let i = 0; i < shaderReplacements.length; i++) {
+        const currReplacement = shaderReplacements[i];
         if (pre && currReplacement.replaceFirst || !pre && !currReplacement.replaceFirst) {
-          var shaderType = currReplacement.shaderType;
-          var ssrc = shaders[shaderType];
-          var substituteRes = vtkShaderProgram.substitute(ssrc, currReplacement.originalValue, currReplacement.replacementValue, currReplacement.replaceAll);
+          const shaderType = currReplacement.shaderType;
+          const ssrc = shaders[shaderType];
+          const substituteRes = vtkShaderProgram.substitute(ssrc, currReplacement.originalValue, currReplacement.replacementValue, currReplacement.replaceAll);
           shaders[shaderType] = substituteRes.result;
         }
       }
     }
   };
-
-  publicAPI.buildShaders = function (shaders, ren, actor) {
+  publicAPI.buildShaders = (shaders, ren, actor) => {
     publicAPI.getReplacedShaderTemplate(shaders, ren, actor);
-    model.lastRenderPassShaderReplacement = model.currentRenderPass ? model.currentRenderPass.getShaderReplacement() : null; // apply any renderPassReplacements
+    model.lastRenderPassShaderReplacement = model.currentRenderPass ? model.currentRenderPass.getShaderReplacement() : null;
 
+    // apply any renderPassReplacements
     if (model.lastRenderPassShaderReplacement) {
       model.lastRenderPassShaderReplacement(shaders);
     }
+    const openGLSpec = model.renderable.getViewSpecificProperties().OpenGL;
 
-    var openGLSpec = model.renderable.getViewSpecificProperties().OpenGL; // user specified pre replacements
-
+    // user specified pre replacements
     publicAPI.applyShaderReplacements(shaders, openGLSpec, true);
-    publicAPI.replaceShaderValues(shaders, ren, actor); // user specified post replacements
+    publicAPI.replaceShaderValues(shaders, ren, actor);
 
+    // user specified post replacements
     publicAPI.applyShaderReplacements(shaders, openGLSpec);
   };
-
-  publicAPI.getReplacedShaderTemplate = function (shaders, ren, actor) {
-    var openGLSpecProp = model.renderable.getViewSpecificProperties().OpenGL;
+  publicAPI.getReplacedShaderTemplate = (shaders, ren, actor) => {
+    const openGLSpecProp = model.renderable.getViewSpecificProperties().OpenGL;
     publicAPI.getShaderTemplate(shaders, ren, actor);
-    var vertexShaderCode = shaders.Vertex;
-
+    let vertexShaderCode = shaders.Vertex;
     if (openGLSpecProp) {
-      var vertexSpecProp = openGLSpecProp.VertexShaderCode;
-
+      const vertexSpecProp = openGLSpecProp.VertexShaderCode;
       if (vertexSpecProp !== undefined && vertexSpecProp !== '') {
         vertexShaderCode = vertexSpecProp;
       }
     }
-
     shaders.Vertex = vertexShaderCode;
-    var fragmentShaderCode = shaders.Fragment;
-
+    let fragmentShaderCode = shaders.Fragment;
     if (openGLSpecProp) {
-      var fragmentSpecProp = openGLSpecProp.FragmentShaderCode;
-
+      const fragmentSpecProp = openGLSpecProp.FragmentShaderCode;
       if (fragmentSpecProp !== undefined && fragmentSpecProp !== '') {
         fragmentShaderCode = fragmentSpecProp;
       }
     }
-
     shaders.Fragment = fragmentShaderCode;
-    var geometryShaderCode = shaders.Geometry;
-
+    let geometryShaderCode = shaders.Geometry;
     if (openGLSpecProp) {
-      var geometrySpecProp = openGLSpecProp.GeometryShaderCode;
-
+      const geometrySpecProp = openGLSpecProp.GeometryShaderCode;
       if (geometrySpecProp !== undefined) {
         geometryShaderCode = geometrySpecProp;
       }
     }
-
     shaders.Geometry = geometryShaderCode;
   };
 }
-
 var vtkReplacementShaderMapper = {
-  implementReplaceShaderCoincidentOffset: implementReplaceShaderCoincidentOffset,
-  implementBuildShadersWithReplacements: implementBuildShadersWithReplacements
+  implementReplaceShaderCoincidentOffset,
+  implementBuildShadersWithReplacements
 };
 
 export { vtkReplacementShaderMapper as default };

package/Rendering/OpenGL/ScalarBarActor.js

@@ -1,63 +1,70 @@
-import { newInstance as newInstance$1 } from '../../macros.js';
+import { n as newInstance$1 } from '../../macros2.js';
 import vtkScalarBarActor from '../Core/ScalarBarActor.js';
 import vtkViewNode from '../SceneGraph/ViewNode.js';
 import { registerOverride } from './ViewNodeFactory.js';
 
+// ----------------------------------------------------------------------------
 // vtkOpenGLScalarBarActor methods
 // ----------------------------------------------------------------------------
 
 function vtkOpenGLScalarBarActor(publicAPI, model) {
-  model.classHierarchy.push('vtkOpenGLScalarBarActor'); // Builds myself.
+  model.classHierarchy.push('vtkOpenGLScalarBarActor');
 
-  publicAPI.buildPass = function (prepass) {
+  // Builds myself.
+  publicAPI.buildPass = prepass => {
     if (prepass) {
       model._openGLRenderer = publicAPI.getFirstAncestorOfType('vtkOpenGLRenderer');
       model._openGLRenderWindow = model._openGLRenderer.getParent();
-
       if (!model.scalarBarActorHelper.getRenderable()) {
         model.scalarBarActorHelper.setRenderable(model.renderable);
       }
-
       publicAPI.prepareNodes();
       publicAPI.addMissingNode(model.scalarBarActorHelper.getBarActor());
       publicAPI.addMissingNode(model.scalarBarActorHelper.getTmActor());
       publicAPI.removeUnusedNodes();
     }
   };
-
-  publicAPI.opaquePass = function (prepass, renderPass) {
+  publicAPI.opaquePass = (prepass, renderPass) => {
     if (prepass) {
-      var camera = model._openGLRenderer ? model._openGLRenderer.getRenderable().getActiveCamera() : null;
-
-      var tsize = model._openGLRenderer.getTiledSizeAndOrigin();
-
+      const camera = model._openGLRenderer ? model._openGLRenderer.getRenderable().getActiveCamera() : null;
+      const tsize = model._openGLRenderer.getTiledSizeAndOrigin();
       model.scalarBarActorHelper.updateAPISpecificData([tsize.usize, tsize.vsize], camera, model._openGLRenderWindow.getRenderable());
     }
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
+const DEFAULT_VALUES = {};
 
-var DEFAULT_VALUES = {}; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Inheritance
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
+  // Inheritance
   vtkViewNode.extend(publicAPI, model, initialValues);
-  model.scalarBarActorHelper = vtkScalarBarActor.newScalarBarActorHelper(); // Object methods
+  model.scalarBarActorHelper = vtkScalarBarActor.newScalarBarActorHelper();
 
+  // Object methods
   vtkOpenGLScalarBarActor(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = newInstance$1(extend, 'vtkOpenGLScalarBarActor');
 
-var newInstance = newInstance$1(extend, 'vtkOpenGLScalarBarActor'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 var index = {
-  newInstance: newInstance,
-  extend: extend
-}; // Register ourself to OpenGL backend if imported
+  newInstance,
+  extend
+};
 
+// Register ourself to OpenGL backend if imported
 registerOverride('vtkScalarBarActor', newInstance);
 
 export { index as default, extend, newInstance };

package/Rendering/OpenGL/Shader.js

@@ -1,6 +1,11 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
+
+const {
+  vtkErrorMacro
+} = macro;
+
+// export const SHADER_TYPES = ['Vertex', 'Fragment', 'Geometry', 'Unknown'];
 
-var vtkErrorMacro = macro.vtkErrorMacro; // export const SHADER_TYPES = ['Vertex', 'Fragment', 'Geometry', 'Unknown'];
 // ----------------------------------------------------------------------------
 // vtkShader methods
 // ----------------------------------------------------------------------------
@@ -8,20 +13,17 @@ var vtkErrorMacro = macro.vtkErrorMacro; // export const SHADER_TYPES = ['Vertex
 function vtkShader(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkShader');
-
-  publicAPI.compile = function () {
-    var stype = model.context.VERTEX_SHADER;
-
+  publicAPI.compile = () => {
+    let stype = model.context.VERTEX_SHADER;
     if (!model.source || !model.source.length || model.shaderType === 'Unknown') {
       return false;
-    } // Ensure we delete the previous shader if necessary.
-
+    }
 
+    // Ensure we delete the previous shader if necessary.
     if (model.handle !== 0) {
       model.context.deleteShader(model.handle);
       model.handle = 0;
     }
-
     switch (model.shaderType) {
       // case vtkShader::Geometry:
       //   type = GL_GEOMETRY_SHADER;
@@ -29,68 +31,72 @@ function vtkShader(publicAPI, model) {
       case 'Fragment':
         stype = model.context.FRAGMENT_SHADER;
         break;
-
       case 'Vertex':
       default:
         stype = model.context.VERTEX_SHADER;
         break;
     }
-
     model.handle = model.context.createShader(stype);
     model.context.shaderSource(model.handle, model.source);
     model.context.compileShader(model.handle);
-    var isCompiled = model.context.getShaderParameter(model.handle, model.context.COMPILE_STATUS);
-
+    const isCompiled = model.context.getShaderParameter(model.handle, model.context.COMPILE_STATUS);
     if (!isCompiled) {
-      var lastError = model.context.getShaderInfoLog(model.handle);
-      vtkErrorMacro("Error compiling shader '".concat(model.source, "': ").concat(lastError));
+      const lastError = model.context.getShaderInfoLog(model.handle);
+      vtkErrorMacro(`Error compiling shader '${model.source}': ${lastError}`);
       model.context.deleteShader(model.handle);
       model.handle = 0;
       return false;
-    } // The shader compiled, store its handle and return success.
-
+    }
 
+    // The shader compiled, store its handle and return success.
     return true;
   };
-
-  publicAPI.cleanup = function () {
+  publicAPI.cleanup = () => {
     if (model.shaderType === 'Unknown' || model.handle === 0) {
       return;
     }
-
     model.context.deleteShader(model.handle);
     model.handle = 0;
     model.dirty = true;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   shaderType: 'Unknown',
   source: '',
   error: '',
   handle: 0,
   dirty: false,
   context: 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.setGet(publicAPI, model, ['shaderType', 'source', 'error', 'handle', 'context']); // Object methods
+  macro.setGet(publicAPI, model, ['shaderType', 'source', 'error', 'handle', 'context']);
 
+  // Object methods
   vtkShader(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkShader');
 
-var newInstance = macro.newInstance(extend, 'vtkShader'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 var vtkShader$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkShader$1 as default, extend, newInstance };