x_ite 8.7.8 → 8.8.0

package/dist/assets/components/VolumeRendering.js

@@ -1,4 +1,4 @@
-/* X_ITE v8.7.8 */(() => { // webpackBootstrap
+/* X_ITE v8.8.0 */(() => { // webpackBootstrap
 /******/ 	"use strict";
 /******/ 	// The require scope
 /******/ 	var __webpack_require__ = {};
@@ -39,31 +39,31 @@ var __webpack_exports__ = {};
 // UNUSED EXPORTS: default
 
 ;// CONCATENATED MODULE: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"x_ite/Components\")"
-const Components_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.7.8")] .require ("x_ite/Components");
+const Components_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.8.0")] .require ("x_ite/Components");
 var Components_default = /*#__PURE__*/__webpack_require__.n(Components_namespaceObject);
 ;// CONCATENATED MODULE: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"x_ite/Components/Texturing/PixelTexture\")"
-const PixelTexture_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.7.8")] .require ("x_ite/Components/Texturing/PixelTexture");
+const PixelTexture_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.8.0")] .require ("x_ite/Components/Texturing/PixelTexture");
 var PixelTexture_default = /*#__PURE__*/__webpack_require__.n(PixelTexture_namespaceObject);
 ;// CONCATENATED MODULE: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"x_ite/Components/Texturing/TextureProperties\")"
-const TextureProperties_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.7.8")] .require ("x_ite/Components/Texturing/TextureProperties");
+const TextureProperties_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.8.0")] .require ("x_ite/Components/Texturing/TextureProperties");
 var TextureProperties_default = /*#__PURE__*/__webpack_require__.n(TextureProperties_namespaceObject);
 ;// CONCATENATED MODULE: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"x_ite/Fields\")"
-const Fields_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.7.8")] .require ("x_ite/Fields");
+const Fields_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.8.0")] .require ("x_ite/Fields");
 var Fields_default = /*#__PURE__*/__webpack_require__.n(Fields_namespaceObject);
 ;// CONCATENATED MODULE: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"x_ite/Base/X3DFieldDefinition\")"
-const X3DFieldDefinition_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.7.8")] .require ("x_ite/Base/X3DFieldDefinition");
+const X3DFieldDefinition_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.8.0")] .require ("x_ite/Base/X3DFieldDefinition");
 var X3DFieldDefinition_default = /*#__PURE__*/__webpack_require__.n(X3DFieldDefinition_namespaceObject);
 ;// CONCATENATED MODULE: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"x_ite/Base/FieldDefinitionArray\")"
-const FieldDefinitionArray_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.7.8")] .require ("x_ite/Base/FieldDefinitionArray");
+const FieldDefinitionArray_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.8.0")] .require ("x_ite/Base/FieldDefinitionArray");
 var FieldDefinitionArray_default = /*#__PURE__*/__webpack_require__.n(FieldDefinitionArray_namespaceObject);
 ;// CONCATENATED MODULE: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"x_ite/Components/Core/X3DNode\")"
-const X3DNode_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.7.8")] .require ("x_ite/Components/Core/X3DNode");
+const X3DNode_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.8.0")] .require ("x_ite/Components/Core/X3DNode");
 var X3DNode_default = /*#__PURE__*/__webpack_require__.n(X3DNode_namespaceObject);
 ;// CONCATENATED MODULE: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"x_ite/Base/X3DConstants\")"
-const X3DConstants_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.7.8")] .require ("x_ite/Base/X3DConstants");
+const X3DConstants_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.8.0")] .require ("x_ite/Base/X3DConstants");
 var X3DConstants_default = /*#__PURE__*/__webpack_require__.n(X3DConstants_namespaceObject);
 ;// CONCATENATED MODULE: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"x_ite/Namespace\")"
-const Namespace_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.7.8")] .require ("x_ite/Namespace");
+const Namespace_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.8.0")] .require ("x_ite/Namespace");
 var Namespace_default = /*#__PURE__*/__webpack_require__.n(Namespace_namespaceObject);
 ;// CONCATENATED MODULE: ./src/x_ite/Components/VolumeRendering/X3DVolumeRenderStyleNode.js
 /*******************************************************************************
@@ -125,32 +125,31 @@ function X3DVolumeRenderStyleNode (executionContext)
    this .volumeDataNodes = new Set ();
 }
 
-X3DVolumeRenderStyleNode .prototype = Object .assign (Object .create ((X3DNode_default()).prototype),
+Object .assign (Object .setPrototypeOf (X3DVolumeRenderStyleNode .prototype, (X3DNode_default()).prototype),
 {
-   constructor: X3DVolumeRenderStyleNode,
-   addShaderFields: function (shaderNode)
+   addShaderFields (shaderNode)
    { },
-   getUniformsText: function ()
+   getUniformsText ()
    {
       return "";
    },
-   getFunctionsText: function ()
+   getFunctionsText ()
    {
       return "";
    },
-   getVolumeData: function ()
+   getVolumeData ()
    {
       return this .volumeDataNodes;
    },
-   addVolumeData: function (volumeDataNode)
+   addVolumeData (volumeDataNode)
    {
       this .volumeDataNodes .add (volumeDataNode);
    },
-   removeVolumeData: function (volumeDataNode)
+   removeVolumeData (volumeDataNode)
    {
       this .volumeDataNodes .delete (volumeDataNode);
    },
-   getNormalText: function (surfaceNormalsNode)
+   getNormalText (surfaceNormalsNode)
    {
       let string = "";
 
@@ -190,6 +189,20 @@ X3DVolumeRenderStyleNode .prototype = Object .assign (Object .create ((X3DNode_d
    },
 });
 
+Object .defineProperties (X3DVolumeRenderStyleNode,
+{
+   typeName:
+   {
+      value: "X3DVolumeRenderStyleNode",
+      enumerable: true,
+   },
+   componentName:
+   {
+      value: "VolumeRendering",
+      enumerable: true,
+   },
+});
+
 const __default__ = X3DVolumeRenderStyleNode;
 ;
 
@@ -248,14 +261,25 @@ Namespace_default().set ("x_ite/Components/VolumeRendering/X3DVolumeRenderStyleN
 
 function X3DComposableVolumeRenderStyleNode (executionContext)
 {
-   VolumeRendering_X3DVolumeRenderStyleNode.call (this, executionContext);
+   VolumeRendering_X3DVolumeRenderStyleNode .call (this, executionContext);
 
    this .addType ((X3DConstants_default()).X3DComposableVolumeRenderStyleNode);
 }
 
-X3DComposableVolumeRenderStyleNode .prototype = Object .assign (Object .create (VolumeRendering_X3DVolumeRenderStyleNode.prototype),
+Object .setPrototypeOf (X3DComposableVolumeRenderStyleNode .prototype, VolumeRendering_X3DVolumeRenderStyleNode .prototype);
+
+Object .defineProperties (X3DComposableVolumeRenderStyleNode,
 {
-   constructor: X3DComposableVolumeRenderStyleNode,
+   typeName:
+   {
+      value: "X3DComposableVolumeRenderStyleNode",
+      enumerable: true,
+   },
+   componentName:
+   {
+      value: "VolumeRendering",
+      enumerable: true,
+   },
 });
 
 const X3DComposableVolumeRenderStyleNode_default_ = X3DComposableVolumeRenderStyleNode;
@@ -264,7 +288,7 @@ const X3DComposableVolumeRenderStyleNode_default_ = X3DComposableVolumeRenderSty
 Namespace_default().set ("x_ite/Components/VolumeRendering/X3DComposableVolumeRenderStyleNode", X3DComposableVolumeRenderStyleNode_default_);
 /* harmony default export */ const VolumeRendering_X3DComposableVolumeRenderStyleNode = (X3DComposableVolumeRenderStyleNode_default_);
 ;// CONCATENATED MODULE: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"x_ite/Base/X3DCast\")"
-const X3DCast_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.7.8")] .require ("x_ite/Base/X3DCast");
+const X3DCast_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.8.0")] .require ("x_ite/Base/X3DCast");
 var X3DCast_default = /*#__PURE__*/__webpack_require__.n(X3DCast_namespaceObject);
 ;// CONCATENATED MODULE: ./src/x_ite/Components/VolumeRendering/OpacityMapVolumeStyle.js
 /*******************************************************************************
@@ -323,38 +347,16 @@ var X3DCast_default = /*#__PURE__*/__webpack_require__.n(X3DCast_namespaceObject
 
 function OpacityMapVolumeStyle (executionContext)
 {
-   VolumeRendering_X3DComposableVolumeRenderStyleNode.call (this, executionContext);
+   VolumeRendering_X3DComposableVolumeRenderStyleNode .call (this, executionContext);
 
    this .addType ((X3DConstants_default()).OpacityMapVolumeStyle);
 }
 
-OpacityMapVolumeStyle .prototype = Object .assign (Object .create (VolumeRendering_X3DComposableVolumeRenderStyleNode.prototype),
+Object .assign (Object .setPrototypeOf (OpacityMapVolumeStyle .prototype, VolumeRendering_X3DComposableVolumeRenderStyleNode .prototype),
 {
-   constructor: OpacityMapVolumeStyle,
-   [Symbol .for ("X_ITE.X3DBaseNode.fieldDefinitions")]: new (FieldDefinitionArray_default()) ([
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "enabled",          new (Fields_default()).SFBool (true)),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "metadata",         new (Fields_default()).SFNode ()),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "transferFunction", new (Fields_default()).SFNode ()),
-   ]),
-   getTypeName: function ()
-   {
-      return "OpacityMapVolumeStyle";
-   },
-   getComponentName: function ()
-   {
-      return "VolumeRendering";
-   },
-   getContainerField: function ()
-   {
-      return "renderStyle";
-   },
-   getSpecificationRange: function ()
-   {
-      return ["3.3", "Infinity"];
-   },
-   initialize: function ()
+   initialize ()
    {
-      VolumeRendering_X3DComposableVolumeRenderStyleNode.prototype.initialize.call (this);
+      VolumeRendering_X3DComposableVolumeRenderStyleNode .prototype .initialize .call (this);
 
       const gl = this .getBrowser () .getContext ();
 
@@ -365,7 +367,7 @@ OpacityMapVolumeStyle .prototype = Object .assign (Object .create (VolumeRenderi
 
       this .set_transferFunction__ ();
    },
-   set_transferFunction__: function ()
+   set_transferFunction__ ()
    {
       this .transferFunctionNode = X3DCast_default() ((X3DConstants_default()).X3DTexture2DNode, this ._transferFunction);
 
@@ -375,14 +377,14 @@ OpacityMapVolumeStyle .prototype = Object .assign (Object .create (VolumeRenderi
       if (! this .transferFunctionNode)
          this .transferFunctionNode = this .getBrowser () .getDefaultTransferFunction ();
    },
-   addShaderFields: function (shaderNode)
+   addShaderFields (shaderNode)
    {
       if (! this ._enabled .getValue ())
          return;
 
       shaderNode .addUserDefinedField ((X3DConstants_default()).inputOutput, "transferFunction_" + this .getId (), new (Fields_default()).SFNode (this .transferFunctionNode));
    },
-   getUniformsText: function ()
+   getUniformsText ()
    {
       if (! this ._enabled .getValue ())
          return "";
@@ -418,7 +420,7 @@ OpacityMapVolumeStyle .prototype = Object .assign (Object .create (VolumeRenderi
 
       return string;
    },
-   getFunctionsText: function ()
+   getFunctionsText ()
    {
       if (! this ._enabled .getValue ())
          return "";
@@ -434,6 +436,39 @@ OpacityMapVolumeStyle .prototype = Object .assign (Object .create (VolumeRenderi
    },
 });
 
+Object .defineProperties (OpacityMapVolumeStyle,
+{
+   typeName:
+   {
+      value: "OpacityMapVolumeStyle",
+      enumerable: true,
+   },
+   componentName:
+   {
+      value: "VolumeRendering",
+      enumerable: true,
+   },
+   containerField:
+   {
+      value: "renderStyle",
+      enumerable: true,
+   },
+   specificationRange:
+   {
+      value: Object .freeze (["3.3", "Infinity"]),
+      enumerable: true,
+   },
+   fieldDefinitions:
+   {
+      value: new (FieldDefinitionArray_default()) ([
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "enabled",          new (Fields_default()).SFBool (true)),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "metadata",         new (Fields_default()).SFNode ()),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "transferFunction", new (Fields_default()).SFNode ()),
+      ]),
+      enumerable: true,
+   },
+});
+
 const OpacityMapVolumeStyle_default_ = OpacityMapVolumeStyle;
 ;
 
@@ -499,9 +534,9 @@ const
 
 function X3DVolumeRenderingContext () { }
 
-X3DVolumeRenderingContext .prototype =
+Object .assign (X3DVolumeRenderingContext .prototype,
 {
-   getDefaultVoxels: function ()
+   getDefaultVoxels ()
    {
       this [_defaultVoxelsNode] = this .getPrivateScene () .createNode ("PixelTexture3D", false);
       this [_defaultVoxelsNode] ._image = [1, 1, 1, 1, 255];
@@ -517,7 +552,7 @@ X3DVolumeRenderingContext .prototype =
 
       return this [_defaultVoxelsNode];
    },
-   getDefaultVolumeStyle: function ()
+   getDefaultVolumeStyle ()
    {
       this [_defaultVolumeStyle] = new VolumeRendering_OpacityMapVolumeStyle (this .getPrivateScene ());
       this [_defaultVolumeStyle] .setPrivate (true);
@@ -529,7 +564,7 @@ X3DVolumeRenderingContext .prototype =
 
       return this [_defaultVolumeStyle];
    },
-   getDefaultBlendedVolumeStyle: function ()
+   getDefaultBlendedVolumeStyle ()
    {
       this [_defaultBlendedVolumeStyle] = new VolumeRendering_OpacityMapVolumeStyle (this .getPrivateScene ());
       this [_defaultBlendedVolumeStyle] .setPrivate (true);
@@ -541,7 +576,7 @@ X3DVolumeRenderingContext .prototype =
 
       return this [_defaultBlendedVolumeStyle];
    },
-   getDefaultTransferFunction: function ()
+   getDefaultTransferFunction ()
    {
       const textureProperties = new (TextureProperties_default()) (this .getPrivateScene ());
       textureProperties ._boundaryModeS       = "CLAMP_TO_EDGE";
@@ -568,15 +603,13 @@ X3DVolumeRenderingContext .prototype =
 
       return this [_defaultTransferFunction];
    },
-};
+});
 
 const X3DVolumeRenderingContext_default_ = X3DVolumeRenderingContext;
 ;
 
 Namespace_default().set ("x_ite/Browser/VolumeRendering/X3DVolumeRenderingContext", X3DVolumeRenderingContext_default_);
 /* harmony default export */ const VolumeRendering_X3DVolumeRenderingContext = (X3DVolumeRenderingContext_default_);
-;// CONCATENATED MODULE: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"x_ite/DEBUG\")"
-const DEBUG_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.7.8")] .require ("x_ite/DEBUG");
 ;// CONCATENATED MODULE: ./src/x_ite/Components/VolumeRendering/BlendedVolumeStyle.js
 /*******************************************************************************
  *
@@ -632,48 +665,18 @@ const DEBUG_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.7.8")] .require
 
 
 
-
 function BlendedVolumeStyle (executionContext)
 {
-   VolumeRendering_X3DComposableVolumeRenderStyleNode.call (this, executionContext);
+   VolumeRendering_X3DComposableVolumeRenderStyleNode .call (this, executionContext);
 
    this .addType ((X3DConstants_default()).BlendedVolumeStyle);
 }
 
-BlendedVolumeStyle .prototype = Object .assign (Object .create (VolumeRendering_X3DComposableVolumeRenderStyleNode.prototype),
+Object .assign (Object .setPrototypeOf (BlendedVolumeStyle .prototype, VolumeRendering_X3DComposableVolumeRenderStyleNode .prototype),
 {
-   constructor: BlendedVolumeStyle,
-   [Symbol .for ("X_ITE.X3DBaseNode.fieldDefinitions")]: new (FieldDefinitionArray_default()) ([
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "metadata",                new (Fields_default()).SFNode ()),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "enabled",                 new (Fields_default()).SFBool (true)),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "weightConstant1",         new (Fields_default()).SFFloat (0.5)),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "weightConstant2",         new (Fields_default()).SFFloat (0.5)),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "weightFunction1",         new (Fields_default()).SFString ("CONSTANT")),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "weightFunction2",         new (Fields_default()).SFString ("CONSTANT")),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "weightTransferFunction1", new (Fields_default()).SFNode ()),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "weightTransferFunction2", new (Fields_default()).SFNode ()),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "renderStyle",             new (Fields_default()).SFNode ()),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "voxels",                  new (Fields_default()).SFNode ()),
-   ]),
-   getTypeName: function ()
+   initialize ()
    {
-      return "BlendedVolumeStyle";
-   },
-   getComponentName: function ()
-   {
-      return "VolumeRendering";
-   },
-   getContainerField: function ()
-   {
-      return "renderStyle";
-   },
-   getSpecificationRange: function ()
-   {
-      return ["3.3", "Infinity"];
-   },
-   initialize: function ()
-   {
-      VolumeRendering_X3DComposableVolumeRenderStyleNode.prototype.initialize.call (this);
+      VolumeRendering_X3DComposableVolumeRenderStyleNode .prototype .initialize .call (this);
 
       const gl = this .getBrowser () .getContext ();
 
@@ -690,29 +693,29 @@ BlendedVolumeStyle .prototype = Object .assign (Object .create (VolumeRendering_
       this .set_renderStyle__ ();
       this .set_voxels__ ();
    },
-   addVolumeData: function (volumeDataNode)
+   addVolumeData (volumeDataNode)
    {
-      VolumeRendering_X3DComposableVolumeRenderStyleNode.prototype.addVolumeData.call (this, volumeDataNode);
+      VolumeRendering_X3DComposableVolumeRenderStyleNode .prototype .addVolumeData .call (this, volumeDataNode);
 
       if (this .renderStyleNode)
          this .renderStyleNode .addVolumeData (volumeDataNode);
    },
-   removeVolumeData: function (volumeDataNode)
+   removeVolumeData (volumeDataNode)
    {
-      VolumeRendering_X3DComposableVolumeRenderStyleNode.prototype.removeVolumeData.call (this, volumeDataNode);
+      VolumeRendering_X3DComposableVolumeRenderStyleNode .prototype .removeVolumeData .call (this, volumeDataNode);
 
       if (this .renderStyleNode)
          this .renderStyleNode .removeVolumeData (volumeDataNode);
    },
-   set_weightTransferFunction1__: function ()
+   set_weightTransferFunction1__ ()
    {
       this .weightTransferFunction1Node = X3DCast_default() ((X3DConstants_default()).X3DTexture2DNode, this ._weightTransferFunction1);
    },
-   set_weightTransferFunction2__: function ()
+   set_weightTransferFunction2__ ()
    {
       this .weightTransferFunction2Node = X3DCast_default() ((X3DConstants_default()).X3DTexture2DNode, this ._weightTransferFunction2);
    },
-   set_renderStyle__: function ()
+   set_renderStyle__ ()
    {
       if (this .renderStyleNode)
       {
@@ -732,11 +735,11 @@ BlendedVolumeStyle .prototype = Object .assign (Object .create (VolumeRendering_
             this .renderStyleNode .addVolumeData (volumeDataNode);
       }
    },
-   set_voxels__: function ()
+   set_voxels__ ()
    {
       this .voxelsNode = X3DCast_default() ((X3DConstants_default()).X3DTexture3DNode, this ._voxels);
    },
-   addShaderFields: function (shaderNode)
+   addShaderFields (shaderNode)
    {
       if (! this ._enabled .getValue ())
          return;
@@ -760,7 +763,7 @@ BlendedVolumeStyle .prototype = Object .assign (Object .create (VolumeRendering_
       if (this .renderStyleNode)
          this .renderStyleNode .addShaderFields (shaderNode);
    },
-   getUniformsText: function ()
+   getUniformsText ()
    {
       if (! this ._enabled .getValue ())
          return "";
@@ -903,7 +906,7 @@ BlendedVolumeStyle .prototype = Object .assign (Object .create (VolumeRendering_
 
       return string;
    },
-   getFunctionsText: function ()
+   getFunctionsText ()
    {
       if (! this ._enabled .getValue ())
          return "";
@@ -922,6 +925,46 @@ BlendedVolumeStyle .prototype = Object .assign (Object .create (VolumeRendering_
    },
 });
 
+Object .defineProperties (BlendedVolumeStyle,
+{
+   typeName:
+   {
+      value: "BlendedVolumeStyle",
+      enumerable: true,
+   },
+   componentName:
+   {
+      value: "VolumeRendering",
+      enumerable: true,
+   },
+   containerField:
+   {
+      value: "renderStyle",
+      enumerable: true,
+   },
+   specificationRange:
+   {
+      value: Object .freeze (["3.3", "Infinity"]),
+      enumerable: true,
+   },
+   fieldDefinitions:
+   {
+      value: new (FieldDefinitionArray_default()) ([
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "metadata",                new (Fields_default()).SFNode ()),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "enabled",                 new (Fields_default()).SFBool (true)),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "weightConstant1",         new (Fields_default()).SFFloat (0.5)),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "weightConstant2",         new (Fields_default()).SFFloat (0.5)),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "weightFunction1",         new (Fields_default()).SFString ("CONSTANT")),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "weightFunction2",         new (Fields_default()).SFString ("CONSTANT")),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "weightTransferFunction1", new (Fields_default()).SFNode ()),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "weightTransferFunction2", new (Fields_default()).SFNode ()),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "renderStyle",             new (Fields_default()).SFNode ()),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "voxels",                  new (Fields_default()).SFNode ()),
+      ]),
+      enumerable: true,
+   },
+});
+
 const BlendedVolumeStyle_default_ = BlendedVolumeStyle;
 ;
 
@@ -983,38 +1026,14 @@ Namespace_default().set ("x_ite/Components/VolumeRendering/BlendedVolumeStyle",
 
 function BoundaryEnhancementVolumeStyle (executionContext)
 {
-   VolumeRendering_X3DComposableVolumeRenderStyleNode.call (this, executionContext);
+   VolumeRendering_X3DComposableVolumeRenderStyleNode .call (this, executionContext);
 
    this .addType ((X3DConstants_default()).BoundaryEnhancementVolumeStyle);
 }
 
-BoundaryEnhancementVolumeStyle .prototype = Object .assign (Object .create (VolumeRendering_X3DComposableVolumeRenderStyleNode.prototype),
+Object .assign (Object .setPrototypeOf (BoundaryEnhancementVolumeStyle .prototype, VolumeRendering_X3DComposableVolumeRenderStyleNode .prototype),
 {
-   constructor: BoundaryEnhancementVolumeStyle,
-   [Symbol .for ("X_ITE.X3DBaseNode.fieldDefinitions")]: new (FieldDefinitionArray_default()) ([
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "metadata",        new (Fields_default()).SFNode ()),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "enabled",         new (Fields_default()).SFBool (true)),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "retainedOpacity", new (Fields_default()).SFFloat (0.2)),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "boundaryOpacity", new (Fields_default()).SFFloat (0.9)),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "opacityFactor",   new (Fields_default()).SFFloat (2)),
-   ]),
-   getTypeName: function ()
-   {
-      return "BoundaryEnhancementVolumeStyle";
-   },
-   getComponentName: function ()
-   {
-      return "VolumeRendering";
-   },
-   getContainerField: function ()
-   {
-      return "renderStyle";
-   },
-   getSpecificationRange: function ()
-   {
-      return ["3.3", "Infinity"];
-   },
-   addShaderFields: function (shaderNode)
+   addShaderFields (shaderNode)
    {
       if (! this ._enabled .getValue ())
          return;
@@ -1023,7 +1042,7 @@ BoundaryEnhancementVolumeStyle .prototype = Object .assign (Object .create (Volu
       shaderNode .addUserDefinedField ((X3DConstants_default()).inputOutput, "boundaryOpacity_" + this .getId (), this ._boundaryOpacity .copy ());
       shaderNode .addUserDefinedField ((X3DConstants_default()).inputOutput, "opacityFactor_"   + this .getId (), this ._opacityFactor   .copy ());
    },
-   getUniformsText: function ()
+   getUniformsText ()
    {
       if (! this ._enabled .getValue ())
          return "";
@@ -1054,7 +1073,7 @@ BoundaryEnhancementVolumeStyle .prototype = Object .assign (Object .create (Volu
 
       return string;
    },
-   getFunctionsText: function ()
+   getFunctionsText ()
    {
       if (! this ._enabled .getValue ())
          return "";
@@ -1070,6 +1089,41 @@ BoundaryEnhancementVolumeStyle .prototype = Object .assign (Object .create (Volu
    },
 });
 
+Object .defineProperties (BoundaryEnhancementVolumeStyle,
+{
+   typeName:
+   {
+      value: "BoundaryEnhancementVolumeStyle",
+      enumerable: true,
+   },
+   componentName:
+   {
+      value: "VolumeRendering",
+      enumerable: true,
+   },
+   containerField:
+   {
+      value: "renderStyle",
+      enumerable: true,
+   },
+   specificationRange:
+   {
+      value: Object .freeze (["3.3", "Infinity"]),
+      enumerable: true,
+   },
+   fieldDefinitions:
+   {
+      value: new (FieldDefinitionArray_default()) ([
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "metadata",        new (Fields_default()).SFNode ()),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "enabled",         new (Fields_default()).SFBool (true)),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "retainedOpacity", new (Fields_default()).SFFloat (0.2)),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "boundaryOpacity", new (Fields_default()).SFFloat (0.9)),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "opacityFactor",   new (Fields_default()).SFFloat (2)),
+      ]),
+      enumerable: true,
+   },
+});
+
 const BoundaryEnhancementVolumeStyle_default_ = BoundaryEnhancementVolumeStyle;
 ;
 
@@ -1132,41 +1186,16 @@ Namespace_default().set ("x_ite/Components/VolumeRendering/BoundaryEnhancementVo
 
 function CartoonVolumeStyle (executionContext)
 {
-   VolumeRendering_X3DComposableVolumeRenderStyleNode.call (this, executionContext);
+   VolumeRendering_X3DComposableVolumeRenderStyleNode .call (this, executionContext);
 
    this .addType ((X3DConstants_default()).CartoonVolumeStyle);
 }
 
-CartoonVolumeStyle .prototype = Object .assign (Object .create (VolumeRendering_X3DComposableVolumeRenderStyleNode.prototype),
+Object .assign (Object .setPrototypeOf (CartoonVolumeStyle .prototype, VolumeRendering_X3DComposableVolumeRenderStyleNode .prototype),
 {
-   constructor: CartoonVolumeStyle,
-   [Symbol .for ("X_ITE.X3DBaseNode.fieldDefinitions")]: new (FieldDefinitionArray_default()) ([
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "metadata",        new (Fields_default()).SFNode ()),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "enabled",         new (Fields_default()).SFBool (true)),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "colorSteps",      new (Fields_default()).SFInt32 (4)),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "orthogonalColor", new (Fields_default()).SFColorRGBA (1, 1, 1, 1)),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "parallelColor",   new (Fields_default()).SFColorRGBA (0, 0, 0, 1)),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "surfaceNormals",  new (Fields_default()).SFNode ()),
-   ]),
-   getTypeName: function ()
-   {
-      return "CartoonVolumeStyle";
-   },
-   getComponentName: function ()
+   initialize ()
    {
-      return "VolumeRendering";
-   },
-   getContainerField: function ()
-   {
-      return "renderStyle";
-   },
-   getSpecificationRange: function ()
-   {
-      return ["3.3", "Infinity"];
-   },
-   initialize: function ()
-   {
-      VolumeRendering_X3DComposableVolumeRenderStyleNode.prototype.initialize.call (this);
+      VolumeRendering_X3DComposableVolumeRenderStyleNode .prototype .initialize .call (this);
 
       const gl = this .getBrowser () .getContext ();
 
@@ -1177,11 +1206,11 @@ CartoonVolumeStyle .prototype = Object .assign (Object .create (VolumeRendering_
 
       this .set_surfaceNormals__ ();
    },
-   set_surfaceNormals__: function ()
+   set_surfaceNormals__ ()
    {
       this .surfaceNormalsNode = X3DCast_default() ((X3DConstants_default()).X3DTexture3DNode, this ._surfaceNormals);
    },
-   addShaderFields: function (shaderNode)
+   addShaderFields (shaderNode)
    {
       if (! this ._enabled .getValue ())
          return;
@@ -1193,7 +1222,7 @@ CartoonVolumeStyle .prototype = Object .assign (Object .create (VolumeRendering_
       if (this .surfaceNormalsNode)
          shaderNode .addUserDefinedField ((X3DConstants_default()).inputOutput, "surfaceNormals_" + this .getId (), new (Fields_default()).SFNode (this .surfaceNormalsNode));
    },
-   getUniformsText: function ()
+   getUniformsText ()
    {
       if (! this ._enabled .getValue ())
          return "";
@@ -1359,7 +1388,7 @@ CartoonVolumeStyle .prototype = Object .assign (Object .create (VolumeRendering_
 
       return string;
    },
-   getFunctionsText: function ()
+   getFunctionsText ()
    {
       if (! this ._enabled .getValue ())
          return "";
@@ -1375,6 +1404,42 @@ CartoonVolumeStyle .prototype = Object .assign (Object .create (VolumeRendering_
    },
 });
 
+Object .defineProperties (CartoonVolumeStyle,
+{
+   typeName:
+   {
+      value: "CartoonVolumeStyle",
+      enumerable: true,
+   },
+   componentName:
+   {
+      value: "VolumeRendering",
+      enumerable: true,
+   },
+   containerField:
+   {
+      value: "renderStyle",
+      enumerable: true,
+   },
+   specificationRange:
+   {
+      value: Object .freeze (["3.3", "Infinity"]),
+      enumerable: true,
+   },
+   fieldDefinitions:
+   {
+      value: new (FieldDefinitionArray_default()) ([
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "metadata",        new (Fields_default()).SFNode ()),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "enabled",         new (Fields_default()).SFBool (true)),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "colorSteps",      new (Fields_default()).SFInt32 (4)),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "orthogonalColor", new (Fields_default()).SFColorRGBA (1, 1, 1, 1)),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "parallelColor",   new (Fields_default()).SFColorRGBA (0, 0, 0, 1)),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "surfaceNormals",  new (Fields_default()).SFNode ()),
+      ]),
+      enumerable: true,
+   },
+});
+
 const CartoonVolumeStyle_default_ = CartoonVolumeStyle;
 ;
 
@@ -1437,40 +1502,18 @@ Namespace_default().set ("x_ite/Components/VolumeRendering/CartoonVolumeStyle",
 
 function ComposedVolumeStyle (executionContext)
 {
-   VolumeRendering_X3DComposableVolumeRenderStyleNode.call (this, executionContext);
+   VolumeRendering_X3DComposableVolumeRenderStyleNode .call (this, executionContext);
 
    this .addType ((X3DConstants_default()).ComposedVolumeStyle);
 
    this .renderStyleNodes = [ ];
 }
 
-ComposedVolumeStyle .prototype = Object .assign (Object .create (VolumeRendering_X3DComposableVolumeRenderStyleNode.prototype),
+Object .assign (Object .setPrototypeOf (ComposedVolumeStyle .prototype, VolumeRendering_X3DComposableVolumeRenderStyleNode .prototype),
 {
-   constructor: ComposedVolumeStyle,
-   [Symbol .for ("X_ITE.X3DBaseNode.fieldDefinitions")]: new (FieldDefinitionArray_default()) ([
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "metadata",    new (Fields_default()).SFNode ()),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "enabled",     new (Fields_default()).SFBool (true)),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "renderStyle", new (Fields_default()).MFNode ()),
-   ]),
-   getTypeName: function ()
-   {
-      return "ComposedVolumeStyle";
-   },
-   getComponentName: function ()
-   {
-      return "VolumeRendering";
-   },
-   getContainerField: function ()
-   {
-      return "renderStyle";
-   },
-   getSpecificationRange: function ()
+   initialize ()
    {
-      return ["3.3", "Infinity"];
-   },
-   initialize: function ()
-   {
-      VolumeRendering_X3DComposableVolumeRenderStyleNode.prototype.initialize.call (this);
+      VolumeRendering_X3DComposableVolumeRenderStyleNode .prototype .initialize .call (this);
 
       const gl = this .getBrowser () .getContext ();
 
@@ -1481,21 +1524,21 @@ ComposedVolumeStyle .prototype = Object .assign (Object .create (VolumeRendering
 
       this .set_renderStyle__ ();
    },
-   addVolumeData: function (volumeDataNode)
+   addVolumeData (volumeDataNode)
    {
-      VolumeRendering_X3DComposableVolumeRenderStyleNode.prototype.addVolumeData.call (this, volumeDataNode);
+      VolumeRendering_X3DComposableVolumeRenderStyleNode .prototype .addVolumeData .call (this, volumeDataNode);
 
       for (const renderStyleNode of this .renderStyleNodes)
          renderStyleNode .addVolumeData (volumeDataNode);
    },
-   removeVolumeData: function (volumeDataNode)
+   removeVolumeData (volumeDataNode)
    {
-      VolumeRendering_X3DComposableVolumeRenderStyleNode.prototype.removeVolumeData.call (this, volumeDataNode);
+      VolumeRendering_X3DComposableVolumeRenderStyleNode .prototype .removeVolumeData .call (this, volumeDataNode);
 
       for (const renderStyleNode of this .renderStyleNodes)
          renderStyleNode .removeVolumeData (volumeDataNode);
    },
-   set_renderStyle__: function ()
+   set_renderStyle__ ()
    {
       const renderStyleNodes = this .renderStyleNodes;
 
@@ -1525,7 +1568,7 @@ ComposedVolumeStyle .prototype = Object .assign (Object .create (VolumeRendering
             renderStyleNode .addVolumeData (volumeDataNode);
       }
    },
-   addShaderFields: function (shaderNode)
+   addShaderFields (shaderNode)
    {
       if (! this ._enabled .getValue ())
          return;
@@ -1533,7 +1576,7 @@ ComposedVolumeStyle .prototype = Object .assign (Object .create (VolumeRendering
       for (const renderStyleNode of this .renderStyleNodes)
          renderStyleNode .addShaderFields (shaderNode);
    },
-   getUniformsText: function ()
+   getUniformsText ()
    {
       if (! this ._enabled .getValue ())
          return "";
@@ -1557,7 +1600,7 @@ ComposedVolumeStyle .prototype = Object .assign (Object .create (VolumeRendering
 
       return string;
    },
-   getFunctionsText: function ()
+   getFunctionsText ()
    {
       if (! this ._enabled .getValue ())
          return "";
@@ -1573,6 +1616,39 @@ ComposedVolumeStyle .prototype = Object .assign (Object .create (VolumeRendering
    }
 });
 
+Object .defineProperties (ComposedVolumeStyle,
+{
+   typeName:
+   {
+      value: "ComposedVolumeStyle",
+      enumerable: true,
+   },
+   componentName:
+   {
+      value: "VolumeRendering",
+      enumerable: true,
+   },
+   containerField:
+   {
+      value: "renderStyle",
+      enumerable: true,
+   },
+   specificationRange:
+   {
+      value: Object .freeze (["3.3", "Infinity"]),
+      enumerable: true,
+   },
+   fieldDefinitions:
+   {
+      value: new (FieldDefinitionArray_default()) ([
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "metadata",    new (Fields_default()).SFNode ()),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "enabled",     new (Fields_default()).SFBool (true)),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "renderStyle", new (Fields_default()).MFNode ()),
+      ]),
+      enumerable: true,
+   },
+});
+
 const ComposedVolumeStyle_default_ = ComposedVolumeStyle;
 ;
 
@@ -1635,40 +1711,16 @@ Namespace_default().set ("x_ite/Components/VolumeRendering/ComposedVolumeStyle",
 
 function EdgeEnhancementVolumeStyle (executionContext)
 {
-   VolumeRendering_X3DComposableVolumeRenderStyleNode.call (this, executionContext);
+   VolumeRendering_X3DComposableVolumeRenderStyleNode .call (this, executionContext);
 
    this .addType ((X3DConstants_default()).EdgeEnhancementVolumeStyle);
 }
 
-EdgeEnhancementVolumeStyle .prototype = Object .assign (Object .create (VolumeRendering_X3DComposableVolumeRenderStyleNode.prototype),
+Object .assign (Object .setPrototypeOf (EdgeEnhancementVolumeStyle .prototype, VolumeRendering_X3DComposableVolumeRenderStyleNode .prototype),
 {
-   constructor: EdgeEnhancementVolumeStyle,
-   [Symbol .for ("X_ITE.X3DBaseNode.fieldDefinitions")]: new (FieldDefinitionArray_default()) ([
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "metadata",          new (Fields_default()).SFNode ()),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "enabled",           new (Fields_default()).SFBool (true)),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "edgeColor",         new (Fields_default()).SFColorRGBA (0, 0, 0, 1)),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "gradientThreshold", new (Fields_default()).SFFloat (0.4)),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "surfaceNormals",    new (Fields_default()).SFNode ()),
-   ]),
-   getTypeName: function ()
+   initialize ()
    {
-      return "EdgeEnhancementVolumeStyle";
-   },
-   getComponentName: function ()
-   {
-      return "VolumeRendering";
-   },
-   getContainerField: function ()
-   {
-      return "renderStyle";
-   },
-   getSpecificationRange: function ()
-   {
-      return ["3.3", "Infinity"];
-   },
-   initialize: function ()
-   {
-      VolumeRendering_X3DComposableVolumeRenderStyleNode.prototype.initialize.call (this);
+      VolumeRendering_X3DComposableVolumeRenderStyleNode .prototype .initialize .call (this);
 
       const gl = this .getBrowser () .getContext ();
 
@@ -1679,11 +1731,11 @@ EdgeEnhancementVolumeStyle .prototype = Object .assign (Object .create (VolumeRe
 
       this .set_surfaceNormals__ ();
    },
-   set_surfaceNormals__: function ()
+   set_surfaceNormals__ ()
    {
       this .surfaceNormalsNode = X3DCast_default() ((X3DConstants_default()).X3DTexture3DNode, this ._surfaceNormals);
    },
-   addShaderFields: function (shaderNode)
+   addShaderFields (shaderNode)
    {
       if (! this ._enabled .getValue ())
          return;
@@ -1694,7 +1746,7 @@ EdgeEnhancementVolumeStyle .prototype = Object .assign (Object .create (VolumeRe
       if (this .surfaceNormalsNode)
          shaderNode .addUserDefinedField ((X3DConstants_default()).inputOutput, "surfaceNormals_" + this .getId (), new (Fields_default()).SFNode (this .surfaceNormalsNode));
    },
-   getUniformsText: function ()
+   getUniformsText ()
    {
       if (! this ._enabled .getValue ())
          return "";
@@ -1731,7 +1783,7 @@ EdgeEnhancementVolumeStyle .prototype = Object .assign (Object .create (VolumeRe
 
       return string;
    },
-   getFunctionsText: function ()
+   getFunctionsText ()
    {
       if (! this ._enabled .getValue ())
          return "";
@@ -1747,22 +1799,57 @@ EdgeEnhancementVolumeStyle .prototype = Object .assign (Object .create (VolumeRe
    },
 });
 
+Object .defineProperties (EdgeEnhancementVolumeStyle,
+{
+   typeName:
+   {
+      value: "EdgeEnhancementVolumeStyle",
+      enumerable: true,
+   },
+   componentName:
+   {
+      value: "VolumeRendering",
+      enumerable: true,
+   },
+   containerField:
+   {
+      value: "renderStyle",
+      enumerable: true,
+   },
+   specificationRange:
+   {
+      value: Object .freeze (["3.3", "Infinity"]),
+      enumerable: true,
+   },
+   fieldDefinitions:
+   {
+      value: new (FieldDefinitionArray_default()) ([
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "metadata",          new (Fields_default()).SFNode ()),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "enabled",           new (Fields_default()).SFBool (true)),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "edgeColor",         new (Fields_default()).SFColorRGBA (0, 0, 0, 1)),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "gradientThreshold", new (Fields_default()).SFFloat (0.4)),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "surfaceNormals",    new (Fields_default()).SFNode ()),
+      ]),
+      enumerable: true,
+   },
+});
+
 const EdgeEnhancementVolumeStyle_default_ = EdgeEnhancementVolumeStyle;
 ;
 
 Namespace_default().set ("x_ite/Components/VolumeRendering/EdgeEnhancementVolumeStyle", EdgeEnhancementVolumeStyle_default_);
 /* harmony default export */ const VolumeRendering_EdgeEnhancementVolumeStyle = (EdgeEnhancementVolumeStyle_default_);
 ;// CONCATENATED MODULE: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"x_ite/Components/Core/X3DChildNode\")"
-const X3DChildNode_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.7.8")] .require ("x_ite/Components/Core/X3DChildNode");
+const X3DChildNode_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.8.0")] .require ("x_ite/Components/Core/X3DChildNode");
 var X3DChildNode_default = /*#__PURE__*/__webpack_require__.n(X3DChildNode_namespaceObject);
 ;// CONCATENATED MODULE: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"x_ite/Components/Grouping/X3DBoundedObject\")"
-const X3DBoundedObject_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.7.8")] .require ("x_ite/Components/Grouping/X3DBoundedObject");
+const X3DBoundedObject_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.8.0")] .require ("x_ite/Components/Grouping/X3DBoundedObject");
 var X3DBoundedObject_default = /*#__PURE__*/__webpack_require__.n(X3DBoundedObject_namespaceObject);
 ;// CONCATENATED MODULE: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"x_ite/Browser/Core/TextureQuality\")"
-const TextureQuality_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.7.8")] .require ("x_ite/Browser/Core/TextureQuality");
+const TextureQuality_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.8.0")] .require ("x_ite/Browser/Core/TextureQuality");
 var TextureQuality_default = /*#__PURE__*/__webpack_require__.n(TextureQuality_namespaceObject);
 ;// CONCATENATED MODULE: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"x_ite/Components/Shape/UnlitMaterial\")"
-const UnlitMaterial_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.7.8")] .require ("x_ite/Components/Shape/UnlitMaterial");
+const UnlitMaterial_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.8.0")] .require ("x_ite/Components/Shape/UnlitMaterial");
 var UnlitMaterial_default = /*#__PURE__*/__webpack_require__.n(UnlitMaterial_namespaceObject);
 ;// CONCATENATED MODULE: ./src/x_ite/Browser/VolumeRendering/VolumeStyle.vs.js
 const VolumeStyle_vs_default_ = /* glsl */ `#version 300 es
@@ -1920,26 +2007,13 @@ function VolumeMaterial (executionContext, volumeDataNode)
    this .volumeShaderNodes = new Map ();
 }
 
-VolumeMaterial .prototype = Object .assign (Object .create ((UnlitMaterial_default()).prototype),
+Object .assign (Object .setPrototypeOf (VolumeMaterial .prototype, (UnlitMaterial_default()).prototype),
 {
-   constructor: VolumeMaterial,
-   getTypeName: function ()
-   {
-      return "VolumeMaterial";
-   },
-   getComponentName: function ()
-   {
-      return "Shape";
-   },
-   getContainerField: function ()
-   {
-      return "material";
-   },
-   getVolumeShaders: function ()
+   getVolumeShaders ()
    {
       return this .volumeShaderNodes;
    },
-   getShader: function (geometryContext, renderContext)
+   getShader (geometryContext, renderContext)
    {
       const { fogNode, objectsCount } = renderContext;
 
@@ -1953,7 +2027,7 @@ VolumeMaterial .prototype = Object .assign (Object .create ((UnlitMaterial_defau
 
       return this .volumeShaderNodes .get (key) || this .createShader (key, geometryContext, renderContext);
    },
-   createShader: function (key, geometryContext, renderContext)
+   createShader (key, geometryContext, renderContext)
    {
       const
          browser = this .getBrowser (),
@@ -1961,19 +2035,26 @@ VolumeMaterial .prototype = Object .assign (Object .create ((UnlitMaterial_defau
 
       const { fogNode, objectsCount } = renderContext;
 
-      if (fogNode)
-         options .push ("X3D_FOG");
+      switch (fogNode ?.getFogType ())
+      {
+         case 1:
+            options .push ("X3D_FOG", "X3D_FOG_LINEAR");
+            break;
+         case 2:
+            options .push ("X3D_FOG", "X3D_FOG_EXPONENTIAL");
+            break;
+      }
 
       if (objectsCount [0])
       {
          options .push ("X3D_CLIP_PLANES")
-         options .push ("X3D_NUM_CLIP_PLANES " + Math .min (objectsCount [0], browser .getMaxClipPlanes ()));
+         options .push (`X3D_NUM_CLIP_PLANES ${Math .min (objectsCount [0], browser .getMaxClipPlanes ())}`);
       }
 
       if (objectsCount [1])
       {
          options .push ("X3D_LIGHTING")
-         options .push ("X3D_NUM_LIGHTS " + Math .min (objectsCount [1], browser .getMaxLights ()));
+         options .push (`X3D_NUM_LIGHTS ${Math .min (objectsCount [1], browser .getMaxLights ())}`);
       }
 
       const shaderNode = this .volumeDataNode .createShader (options, VolumeStyle_vs, VolumeStyle_fs);
@@ -1982,19 +2063,42 @@ VolumeMaterial .prototype = Object .assign (Object .create ((UnlitMaterial_defau
 
       return shaderNode;
    },
-   setShaderUniforms: function (gl, shaderObject, renderObject, textureTransformMapping, textureCoordinateMapping)
+   setShaderUniforms (gl, shaderObject, renderObject, textureTransformMapping, textureCoordinateMapping)
    {
       this .volumeDataNode .setShaderUniforms (gl, shaderObject);
    },
 });
 
+Object .defineProperties (VolumeMaterial,
+{
+   typeName:
+   {
+      value: "VolumeMaterial",
+      enumerable: true,
+   },
+   componentName:
+   {
+      value: "Shape",
+      enumerable: true,
+   },
+   containerField:
+   {
+      value: "material",
+      enumerable: true,
+   },
+   fieldDefinitions:
+   {
+      value: (UnlitMaterial_default()).fieldDefinitions,
+   },
+});
+
 const VolumeMaterial_default_ = VolumeMaterial;
 ;
 
 Namespace_default().set ("x_ite/Browser/VolumeRendering/VolumeMaterial", VolumeMaterial_default_);
 /* harmony default export */ const VolumeRendering_VolumeMaterial = (VolumeMaterial_default_);
 ;// CONCATENATED MODULE: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"standard/Math/Numbers/Vector3\")"
-const Vector3_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.7.8")] .require ("standard/Math/Numbers/Vector3");
+const Vector3_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.8.0")] .require ("standard/Math/Numbers/Vector3");
 var Vector3_default = /*#__PURE__*/__webpack_require__.n(Vector3_namespaceObject);
 ;// CONCATENATED MODULE: ./src/x_ite/Components/VolumeRendering/X3DVolumeDataNode.js
 /*******************************************************************************
@@ -2075,14 +2179,13 @@ function X3DVolumeDataNode (executionContext)
    this .setCameraObject (true);
 }
 
-X3DVolumeDataNode .prototype = Object .assign (Object .create ((X3DChildNode_default()).prototype),
+Object .assign (Object .setPrototypeOf (X3DVolumeDataNode .prototype, (X3DChildNode_default()).prototype),
    (X3DBoundedObject_default()).prototype,
 {
-   constructor: X3DVolumeDataNode,
-   initialize: function ()
+   initialize ()
    {
-      X3DChildNode_default().prototype.initialize.call (this);
-      X3DBoundedObject_default().prototype.initialize.call (this);
+      X3DChildNode_default().prototype .initialize .call (this);
+      X3DBoundedObject_default().prototype .initialize .call (this);
 
       const
          browser = this .getBrowser (),
@@ -2139,26 +2242,26 @@ X3DVolumeDataNode .prototype = Object .assign (Object .create ((X3DChildNode_def
 
       this .set_textureTransform__ ();
    },
-   getBBox: function (bbox, shadows)
+   getBBox (bbox, shadows)
    {
       if (this ._bboxSize .getValue () .equals (this .getDefaultBBoxSize ()))
          return bbox .set (this ._dimensions .getValue (), (Vector3_default()).Zero);
 
       return bbox .set (this ._bboxSize .getValue (), this ._bboxCenter .getValue ());
    },
-   getAppearance: function ()
+   getAppearance ()
    {
       return this .appearanceNode;
    },
-   updateShader: function ()
+   updateShader ()
    {
       this .volumeMaterialNode .getVolumeShaders () .clear ();
    },
-   addShaderUniformNames: function (uniformNames)
+   addShaderUniformNames (uniformNames)
    {
       uniformNames .push ("x3d_TextureNormalMatrix");
    },
-   getNumPlanes: function ()
+   getNumPlanes ()
    {
       switch (this .getBrowser () .getBrowserOptions () .getTextureQuality ())
       {
@@ -2178,7 +2281,7 @@ X3DVolumeDataNode .prototype = Object .assign (Object .create ((X3DChildNode_def
 
       return 200;
    },
-   set_dimensions__: function ()
+   set_dimensions__ ()
    {
       const
          NUM_PLANES = this .getNumPlanes (),
@@ -2204,11 +2307,11 @@ X3DVolumeDataNode .prototype = Object .assign (Object .create ((X3DChildNode_def
                                                                  1 / this ._dimensions .y,
                                                                  1 / this ._dimensions .z);
    },
-   set_textureTransform__: function ()
+   set_textureTransform__ ()
    {
       this .textureNormalMatrixArray .set (this .textureTransformNode .getMatrix () .submatrix .inverse ());
    },
-   traverse: function (type, renderObject)
+   traverse (type, renderObject)
    {
       this .proximitySensorNode .traverse (type, renderObject);
       this .transformNode       .traverse (type, renderObject);
@@ -2217,10 +2320,24 @@ X3DVolumeDataNode .prototype = Object .assign (Object .create ((X3DChildNode_def
    {
       gl .uniformMatrix3fv (shaderObject .x3d_TextureNormalMatrix, true, this .textureNormalMatrixArray);
    },
-   dispose: function ()
+   dispose ()
+   {
+      X3DBoundedObject_default().prototype .dispose .call (this);
+      X3DChildNode_default().prototype .dispose .call (this);
+   },
+});
+
+Object .defineProperties (X3DVolumeDataNode,
+{
+   typeName:
+   {
+      value: "X3DVolumeDataNode",
+      enumerable: true,
+   },
+   componentName:
    {
-      X3DBoundedObject_default().prototype.dispose.call (this);
-      X3DChildNode_default().prototype.dispose.call (this);
+      value: "VolumeRendering",
+      enumerable: true,
    },
 });
 
@@ -2230,10 +2347,10 @@ const X3DVolumeDataNode_default_ = X3DVolumeDataNode;
 Namespace_default().set ("x_ite/Components/VolumeRendering/X3DVolumeDataNode", X3DVolumeDataNode_default_);
 /* harmony default export */ const VolumeRendering_X3DVolumeDataNode = (X3DVolumeDataNode_default_);
 ;// CONCATENATED MODULE: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"x_ite/Components/Shaders/ComposedShader\")"
-const ComposedShader_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.7.8")] .require ("x_ite/Components/Shaders/ComposedShader");
+const ComposedShader_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.8.0")] .require ("x_ite/Components/Shaders/ComposedShader");
 var ComposedShader_default = /*#__PURE__*/__webpack_require__.n(ComposedShader_namespaceObject);
 ;// CONCATENATED MODULE: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"x_ite/Components/Shaders/ShaderPart\")"
-const ShaderPart_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.7.8")] .require ("x_ite/Components/Shaders/ShaderPart");
+const ShaderPart_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.8.0")] .require ("x_ite/Components/Shaders/ShaderPart");
 var ShaderPart_default = /*#__PURE__*/__webpack_require__.n(ShaderPart_namespaceObject);
 ;// CONCATENATED MODULE: ./src/x_ite/Components/VolumeRendering/IsoSurfaceVolumeData.js
 /*******************************************************************************
@@ -2294,49 +2411,18 @@ var ShaderPart_default = /*#__PURE__*/__webpack_require__.n(ShaderPart_namespace
 
 function IsoSurfaceVolumeData (executionContext)
 {
-   VolumeRendering_X3DVolumeDataNode.call (this, executionContext);
+   VolumeRendering_X3DVolumeDataNode .call (this, executionContext);
 
    this .addType ((X3DConstants_default()).IsoSurfaceVolumeData);
 
    this .renderStyleNodes = [ ];
 }
 
-IsoSurfaceVolumeData .prototype = Object .assign (Object .create (VolumeRendering_X3DVolumeDataNode.prototype),
+Object .assign (Object .setPrototypeOf (IsoSurfaceVolumeData .prototype, VolumeRendering_X3DVolumeDataNode .prototype),
 {
-   constructor: IsoSurfaceVolumeData,
-   [Symbol .for ("X_ITE.X3DBaseNode.fieldDefinitions")]: new (FieldDefinitionArray_default()) ([
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "metadata",         new (Fields_default()).SFNode ()),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "dimensions",       new (Fields_default()).SFVec3f (1, 1, 1)),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "contourStepSize",  new (Fields_default()).SFFloat (0)),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "surfaceValues",    new (Fields_default()).MFFloat ()),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "surfaceTolerance", new (Fields_default()).SFFloat (0)),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "visible",          new (Fields_default()).SFBool (true)),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "bboxDisplay",      new (Fields_default()).SFBool ()),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).initializeOnly, "bboxCenter",       new (Fields_default()).SFVec3f (0, 0, 0)),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).initializeOnly, "bboxSize",         new (Fields_default()).SFVec3f (-1, -1, -1)),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "renderStyle",      new (Fields_default()).MFNode ()),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "gradients",        new (Fields_default()).SFNode ()),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "voxels",           new (Fields_default()).SFNode ()),
-   ]),
-   getTypeName: function ()
+   initialize ()
    {
-      return "IsoSurfaceVolumeData";
-   },
-   getComponentName: function ()
-   {
-      return "VolumeRendering";
-   },
-   getContainerField: function ()
-   {
-      return "children";
-   },
-   getSpecificationRange: function ()
-   {
-      return ["3.3", "Infinity"];
-   },
-   initialize: function ()
-   {
-      VolumeRendering_X3DVolumeDataNode.prototype.initialize.call (this);
+      VolumeRendering_X3DVolumeDataNode .prototype .initialize .call (this);
 
       const gl = this .getBrowser () .getContext ();
 
@@ -2359,11 +2445,11 @@ IsoSurfaceVolumeData .prototype = Object .assign (Object .create (VolumeRenderin
 
       this .updateShader ();
    },
-   set_gradients__: function ()
+   set_gradients__ ()
    {
       this .gradientsNode = X3DCast_default() ((X3DConstants_default()).X3DTexture3DNode, this ._gradients);
    },
-   set_renderStyle__: function ()
+   set_renderStyle__ ()
    {
       const renderStyleNodes = this .renderStyleNodes;
 
@@ -2389,7 +2475,7 @@ IsoSurfaceVolumeData .prototype = Object .assign (Object .create (VolumeRenderin
          renderStyleNode .addVolumeData (this);
       }
    },
-   set_voxels__: function ()
+   set_voxels__ ()
    {
       this .voxelsNode = X3DCast_default() ((X3DConstants_default()).X3DTexture3DNode, this ._voxels);
 
@@ -2398,9 +2484,9 @@ IsoSurfaceVolumeData .prototype = Object .assign (Object .create (VolumeRenderin
       else
          this .getAppearance () ._texture = this .getBrowser () .getDefaultVoxels ();
    },
-   createShader: function (options, vs, fs)
+   createShader (options, vs, fs)
    {
-      // if (DEBUG)
+      // if (DEVELOPMENT)
       //    console .log ("Creating VolumeData Shader ...");
 
       const opacityMapVolumeStyle = this .getBrowser () .getDefaultVolumeStyle ();
@@ -2543,7 +2629,7 @@ IsoSurfaceVolumeData .prototype = Object .assign (Object .create (VolumeRenderin
       fs = fs .replace (/\/\/ VOLUME_STYLES_UNIFORMS\n/,  styleUniforms);
       fs = fs .replace (/\/\/ VOLUME_STYLES_FUNCTIONS\n/, styleFunctions);
 
-      // if (DEBUG)
+      // if (DEVELOPMENT)
       //    this .getBrowser () .print (fs);
 
       const vertexShader = new (ShaderPart_default()) (this .getExecutionContext ());
@@ -2590,6 +2676,48 @@ IsoSurfaceVolumeData .prototype = Object .assign (Object .create (VolumeRenderin
    },
 });
 
+Object .defineProperties (IsoSurfaceVolumeData,
+{
+   typeName:
+   {
+      value: "IsoSurfaceVolumeData",
+      enumerable: true,
+   },
+   componentName:
+   {
+      value: "VolumeRendering",
+      enumerable: true,
+   },
+   containerField:
+   {
+      value: "children",
+      enumerable: true,
+   },
+   specificationRange:
+   {
+      value: Object .freeze (["3.3", "Infinity"]),
+      enumerable: true,
+   },
+   fieldDefinitions:
+   {
+      value: new (FieldDefinitionArray_default()) ([
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "metadata",         new (Fields_default()).SFNode ()),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "dimensions",       new (Fields_default()).SFVec3f (1, 1, 1)),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "contourStepSize",  new (Fields_default()).SFFloat (0)),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "surfaceValues",    new (Fields_default()).MFFloat ()),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "surfaceTolerance", new (Fields_default()).SFFloat (0)),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "visible",          new (Fields_default()).SFBool (true)),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "bboxDisplay",      new (Fields_default()).SFBool ()),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).initializeOnly, "bboxCenter",       new (Fields_default()).SFVec3f (0, 0, 0)),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).initializeOnly, "bboxSize",         new (Fields_default()).SFVec3f (-1, -1, -1)),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "renderStyle",      new (Fields_default()).MFNode ()),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "gradients",        new (Fields_default()).SFNode ()),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "voxels",           new (Fields_default()).SFNode ()),
+      ]),
+      enumerable: true,
+   },
+});
+
 const IsoSurfaceVolumeData_default_ = IsoSurfaceVolumeData;
 ;
 
@@ -2651,44 +2779,21 @@ Namespace_default().set ("x_ite/Components/VolumeRendering/IsoSurfaceVolumeData"
 
 function ProjectionVolumeStyle (executionContext)
 {
-   VolumeRendering_X3DVolumeRenderStyleNode.call (this, executionContext);
+   VolumeRendering_X3DVolumeRenderStyleNode .call (this, executionContext);
 
    this .addType ((X3DConstants_default()).ProjectionVolumeStyle);
 }
 
-ProjectionVolumeStyle .prototype = Object .assign (Object .create (VolumeRendering_X3DVolumeRenderStyleNode.prototype),
+Object .assign (Object .setPrototypeOf (ProjectionVolumeStyle .prototype, VolumeRendering_X3DVolumeRenderStyleNode .prototype),
 {
-   constructor: ProjectionVolumeStyle,
-   [Symbol .for ("X_ITE.X3DBaseNode.fieldDefinitions")]: new (FieldDefinitionArray_default()) ([
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "metadata",           new (Fields_default()).SFNode ()),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "enabled",            new (Fields_default()).SFBool (true)),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "type",               new (Fields_default()).SFString ("MAX")),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "intensityThreshold", new (Fields_default()).SFFloat (0)),
-   ]),
-   getTypeName: function ()
-   {
-      return "ProjectionVolumeStyle";
-   },
-   getComponentName: function ()
-   {
-      return "VolumeRendering";
-   },
-   getContainerField: function ()
-   {
-      return "renderStyle";
-   },
-   getSpecificationRange: function ()
-   {
-      return ["3.3", "Infinity"];
-   },
-   addShaderFields: function (shaderNode)
+   addShaderFields (shaderNode)
    {
       if (! this ._enabled .getValue ())
          return;
 
       shaderNode .addUserDefinedField ((X3DConstants_default()).inputOutput, "intensityThreshold_" + this .getId (), this ._intensityThreshold .copy ());
    },
-   getUniformsText: function ()
+   getUniformsText ()
    {
       if (! this ._enabled .getValue ())
          return "";
@@ -2798,7 +2903,7 @@ ProjectionVolumeStyle .prototype = Object .assign (Object .create (VolumeRenderi
 
       return string;
    },
-   getFunctionsText: function ()
+   getFunctionsText ()
    {
       if (! this ._enabled .getValue ())
          return "";
@@ -2814,6 +2919,40 @@ ProjectionVolumeStyle .prototype = Object .assign (Object .create (VolumeRenderi
    },
 });
 
+Object .defineProperties (ProjectionVolumeStyle,
+{
+   typeName:
+   {
+      value: "ProjectionVolumeStyle",
+      enumerable: true,
+   },
+   componentName:
+   {
+      value: "VolumeRendering",
+      enumerable: true,
+   },
+   containerField:
+   {
+      value: "renderStyle",
+      enumerable: true,
+   },
+   specificationRange:
+   {
+      value: Object .freeze (["3.3", "Infinity"]),
+      enumerable: true,
+   },
+   fieldDefinitions:
+   {
+      value: new (FieldDefinitionArray_default()) ([
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "metadata",           new (Fields_default()).SFNode ()),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "enabled",            new (Fields_default()).SFBool (true)),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "type",               new (Fields_default()).SFString ("MAX")),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "intensityThreshold", new (Fields_default()).SFFloat (0)),
+      ]),
+      enumerable: true,
+   },
+});
+
 const ProjectionVolumeStyle_default_ = ProjectionVolumeStyle;
 ;
 
@@ -2878,7 +3017,7 @@ Namespace_default().set ("x_ite/Components/VolumeRendering/ProjectionVolumeStyle
 
 function SegmentedVolumeData (executionContext)
 {
-   VolumeRendering_X3DVolumeDataNode.call (this, executionContext);
+   VolumeRendering_X3DVolumeDataNode .call (this, executionContext);
 
    this .addType ((X3DConstants_default()).SegmentedVolumeData);
 
@@ -2886,40 +3025,11 @@ function SegmentedVolumeData (executionContext)
    this .renderStyleNodes       = [ ];
 }
 
-SegmentedVolumeData .prototype = Object .assign (Object .create (VolumeRendering_X3DVolumeDataNode.prototype),
+Object .assign (Object .setPrototypeOf (SegmentedVolumeData .prototype, VolumeRendering_X3DVolumeDataNode .prototype),
 {
-   constructor: SegmentedVolumeData,
-   [Symbol .for ("X_ITE.X3DBaseNode.fieldDefinitions")]: new (FieldDefinitionArray_default()) ([
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "metadata",           new (Fields_default()).SFNode ()),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "dimensions",         new (Fields_default()).SFVec3f (1, 1, 1)),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "segmentEnabled",     new (Fields_default()).MFBool ()),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "visible",            new (Fields_default()).SFBool (true)),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "bboxDisplay",        new (Fields_default()).SFBool ()),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).initializeOnly, "bboxCenter",         new (Fields_default()).SFVec3f (0, 0, 0)),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).initializeOnly, "bboxSize",           new (Fields_default()).SFVec3f (-1, -1, -1)),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "segmentIdentifiers", new (Fields_default()).SFNode ()),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "renderStyle",        new (Fields_default()).MFNode ()),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "voxels",             new (Fields_default()).SFNode ()),
-   ]),
-   getTypeName: function ()
-   {
-      return "SegmentedVolumeData";
-   },
-   getComponentName: function ()
-   {
-      return "VolumeRendering";
-   },
-   getContainerField: function ()
-   {
-      return "children";
-   },
-   getSpecificationRange: function ()
-   {
-      return ["3.3", "Infinity"];
-   },
-   initialize: function ()
+   initialize ()
    {
-      VolumeRendering_X3DVolumeDataNode.prototype.initialize.call (this);
+      VolumeRendering_X3DVolumeDataNode .prototype .initialize .call (this);
 
       const gl = this .getBrowser () .getContext ();
 
@@ -2941,15 +3051,15 @@ SegmentedVolumeData .prototype = Object .assign (Object .create (VolumeRendering
 
       this .updateShader ();
    },
-   getSegmentEnabled: function (index)
+   getSegmentEnabled (index)
    {
       return index < this ._segmentEnabled .length ? this ._segmentEnabled [index] : true;
    },
-   set_segmentIdentifiers__: function ()
+   set_segmentIdentifiers__ ()
    {
       this .segmentIdentifiersNode = X3DCast_default() ((X3DConstants_default()).X3DTexture3DNode, this ._segmentIdentifiers);
    },
-   set_renderStyle__: function ()
+   set_renderStyle__ ()
    {
       const renderStyleNodes = this .renderStyleNodes;
 
@@ -2975,7 +3085,7 @@ SegmentedVolumeData .prototype = Object .assign (Object .create (VolumeRendering
          renderStyleNode .addVolumeData (this);
       }
    },
-   set_voxels__: function ()
+   set_voxels__ ()
    {
       this .voxelsNode = X3DCast_default() ((X3DConstants_default()).X3DTexture3DNode, this ._voxels);
 
@@ -2984,9 +3094,9 @@ SegmentedVolumeData .prototype = Object .assign (Object .create (VolumeRendering
       else
          this .getAppearance () ._texture = this .getBrowser () .getDefaultVoxels ();
    },
-   createShader: function (options, vs, fs)
+   createShader (options, vs, fs)
    {
-      // if (DEBUG)
+      // if (DEVELOPMENT)
       //    console .log ("Creating SegmentedVolumeData Shader ...");
 
       const opacityMapVolumeStyle = this .getBrowser () .getDefaultVolumeStyle ();
@@ -3040,7 +3150,7 @@ SegmentedVolumeData .prototype = Object .assign (Object .create (VolumeRendering
       fs = fs .replace (/\/\/ VOLUME_STYLES_UNIFORMS\n/,  styleUniforms);
       fs = fs .replace (/\/\/ VOLUME_STYLES_FUNCTIONS\n/, styleFunctions);
 
-      // if (DEBUG)
+      // if (DEVELOPMENT)
       //    this .getBrowser () .print (fs);
 
       const vertexShader = new (ShaderPart_default()) (this .getExecutionContext ());
@@ -3087,6 +3197,46 @@ SegmentedVolumeData .prototype = Object .assign (Object .create (VolumeRendering
    },
 });
 
+Object .defineProperties (SegmentedVolumeData,
+{
+   typeName:
+   {
+      value: "SegmentedVolumeData",
+      enumerable: true,
+   },
+   componentName:
+   {
+      value: "VolumeRendering",
+      enumerable: true,
+   },
+   containerField:
+   {
+      value: "children",
+      enumerable: true,
+   },
+   specificationRange:
+   {
+      value: Object .freeze (["3.3", "Infinity"]),
+      enumerable: true,
+   },
+   fieldDefinitions:
+   {
+      value: new (FieldDefinitionArray_default()) ([
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "metadata",           new (Fields_default()).SFNode ()),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "dimensions",         new (Fields_default()).SFVec3f (1, 1, 1)),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "segmentEnabled",     new (Fields_default()).MFBool ()),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "visible",            new (Fields_default()).SFBool (true)),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "bboxDisplay",        new (Fields_default()).SFBool ()),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).initializeOnly, "bboxCenter",         new (Fields_default()).SFVec3f (0, 0, 0)),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).initializeOnly, "bboxSize",           new (Fields_default()).SFVec3f (-1, -1, -1)),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "segmentIdentifiers", new (Fields_default()).SFNode ()),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "renderStyle",        new (Fields_default()).MFNode ()),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "voxels",             new (Fields_default()).SFNode ()),
+      ]),
+      enumerable: true,
+   },
+});
+
 const SegmentedVolumeData_default_ = SegmentedVolumeData;
 ;
 
@@ -3149,42 +3299,16 @@ Namespace_default().set ("x_ite/Components/VolumeRendering/SegmentedVolumeData",
 
 function ShadedVolumeStyle (executionContext)
 {
-   VolumeRendering_X3DComposableVolumeRenderStyleNode.call (this, executionContext);
+   VolumeRendering_X3DComposableVolumeRenderStyleNode .call (this, executionContext);
 
    this .addType ((X3DConstants_default()).ShadedVolumeStyle);
 }
 
-ShadedVolumeStyle .prototype = Object .assign (Object .create (VolumeRendering_X3DComposableVolumeRenderStyleNode.prototype),
+Object .assign (Object .setPrototypeOf (ShadedVolumeStyle .prototype, VolumeRendering_X3DComposableVolumeRenderStyleNode .prototype),
 {
-   constructor: ShadedVolumeStyle,
-   [Symbol .for ("X_ITE.X3DBaseNode.fieldDefinitions")]: new (FieldDefinitionArray_default()) ([
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "metadata",       new (Fields_default()).SFNode ()),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "enabled",        new (Fields_default()).SFBool (true)),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "lighting",       new (Fields_default()).SFBool ()),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "shadows",        new (Fields_default()).SFBool ()),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).initializeOnly, "phaseFunction",  new (Fields_default()).SFString ("Henyey-Greenstein")),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "material",       new (Fields_default()).SFNode ()),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "surfaceNormals", new (Fields_default()).SFNode ()),
-   ]),
-   getTypeName: function ()
-   {
-      return "ShadedVolumeStyle";
-   },
-   getComponentName: function ()
-   {
-      return "VolumeRendering";
-   },
-   getContainerField: function ()
-   {
-      return "renderStyle";
-   },
-   getSpecificationRange: function ()
+   initialize ()
    {
-      return ["3.3", "Infinity"];
-   },
-   initialize: function ()
-   {
-      VolumeRendering_X3DComposableVolumeRenderStyleNode.prototype.initialize.call (this);
+      VolumeRendering_X3DComposableVolumeRenderStyleNode .prototype .initialize .call (this);
 
       const gl = this .getBrowser () .getContext ();
 
@@ -3197,7 +3321,7 @@ ShadedVolumeStyle .prototype = Object .assign (Object .create (VolumeRendering_X
       this .set_material__ ();
       this .set_surfaceNormals__ ();
    },
-   set_material__: function ()
+   set_material__ ()
    {
       if (this .materialNode)
          this .materialNode .removeInterest ("addNodeEvent", this);
@@ -3207,11 +3331,11 @@ ShadedVolumeStyle .prototype = Object .assign (Object .create (VolumeRendering_X
       if (this .materialNode)
          this .materialNode .addInterest ("addNodeEvent", this);
    },
-   set_surfaceNormals__: function ()
+   set_surfaceNormals__ ()
    {
       this .surfaceNormalsNode = X3DCast_default() ((X3DConstants_default()).X3DTexture3DNode, this ._surfaceNormals);
    },
-   addShaderFields: function (shaderNode)
+   addShaderFields (shaderNode)
    {
       if (! this ._enabled .getValue ())
          return;
@@ -3229,7 +3353,7 @@ ShadedVolumeStyle .prototype = Object .assign (Object .create (VolumeRendering_X
       if (this .surfaceNormalsNode)
          shaderNode .addUserDefinedField ((X3DConstants_default()).inputOutput, "surfaceNormals_" + this .getId (), new (Fields_default()).SFNode (this .surfaceNormalsNode));
    },
-   getUniformsText: function ()
+   getUniformsText ()
    {
       if (! this ._enabled .getValue ())
          return "";
@@ -3345,7 +3469,7 @@ ShadedVolumeStyle .prototype = Object .assign (Object .create (VolumeRendering_X
 
       return string;
    },
-   getFunctionsText: function ()
+   getFunctionsText ()
    {
       if (! this ._enabled .getValue ())
          return "";
@@ -3361,6 +3485,43 @@ ShadedVolumeStyle .prototype = Object .assign (Object .create (VolumeRendering_X
    },
 });
 
+Object .defineProperties (ShadedVolumeStyle,
+{
+   typeName:
+   {
+      value: "ShadedVolumeStyle",
+      enumerable: true,
+   },
+   componentName:
+   {
+      value: "VolumeRendering",
+      enumerable: true,
+   },
+   containerField:
+   {
+      value: "renderStyle",
+      enumerable: true,
+   },
+   specificationRange:
+   {
+      value: Object .freeze (["3.3", "Infinity"]),
+      enumerable: true,
+   },
+   fieldDefinitions:
+   {
+      value: new (FieldDefinitionArray_default()) ([
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "metadata",       new (Fields_default()).SFNode ()),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "enabled",        new (Fields_default()).SFBool (true)),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "lighting",       new (Fields_default()).SFBool ()),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "shadows",        new (Fields_default()).SFBool ()),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).initializeOnly, "phaseFunction",  new (Fields_default()).SFString ("Henyey-Greenstein")),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "material",       new (Fields_default()).SFNode ()),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "surfaceNormals", new (Fields_default()).SFNode ()),
+      ]),
+      enumerable: true,
+   },
+});
+
 const ShadedVolumeStyle_default_ = ShadedVolumeStyle;
 ;
 
@@ -3423,41 +3584,16 @@ Namespace_default().set ("x_ite/Components/VolumeRendering/ShadedVolumeStyle", S
 
 function SilhouetteEnhancementVolumeStyle (executionContext)
 {
-   VolumeRendering_X3DComposableVolumeRenderStyleNode.call (this, executionContext);
+   VolumeRendering_X3DComposableVolumeRenderStyleNode .call (this, executionContext);
 
    this .addType ((X3DConstants_default()).SilhouetteEnhancementVolumeStyle);
 }
 
-SilhouetteEnhancementVolumeStyle .prototype = Object .assign (Object .create (VolumeRendering_X3DComposableVolumeRenderStyleNode.prototype),
+Object .assign (Object .setPrototypeOf (SilhouetteEnhancementVolumeStyle .prototype, VolumeRendering_X3DComposableVolumeRenderStyleNode .prototype),
 {
-   constructor: SilhouetteEnhancementVolumeStyle,
-   [Symbol .for ("X_ITE.X3DBaseNode.fieldDefinitions")]: new (FieldDefinitionArray_default()) ([
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "metadata",                  new (Fields_default()).SFNode ()),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "enabled",                   new (Fields_default()).SFBool (true)),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "silhouetteRetainedOpacity", new (Fields_default()).SFFloat (1)),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "silhouetteBoundaryOpacity", new (Fields_default()).SFFloat (0)),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "silhouetteSharpness",       new (Fields_default()).SFFloat (0.5)),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "surfaceNormals",            new (Fields_default()).SFNode ()),
-   ]),
-   getTypeName: function ()
-   {
-      return "SilhouetteEnhancementVolumeStyle";
-   },
-   getComponentName: function ()
-   {
-      return "VolumeRendering";
-   },
-   getContainerField: function ()
-   {
-      return "renderStyle";
-   },
-   getSpecificationRange: function ()
-   {
-      return ["3.3", "Infinity"];
-   },
-   initialize: function ()
+   initialize ()
    {
-      VolumeRendering_X3DComposableVolumeRenderStyleNode.prototype.initialize.call (this);
+      VolumeRendering_X3DComposableVolumeRenderStyleNode .prototype .initialize .call (this);
 
       const gl = this .getBrowser () .getContext ();
 
@@ -3468,11 +3604,11 @@ SilhouetteEnhancementVolumeStyle .prototype = Object .assign (Object .create (Vo
 
       this .set_surfaceNormals__ ();
    },
-   set_surfaceNormals__: function ()
+   set_surfaceNormals__ ()
    {
       this .surfaceNormalsNode = X3DCast_default() ((X3DConstants_default()).X3DTexture3DNode, this ._surfaceNormals);
    },
-   addShaderFields: function (shaderNode)
+   addShaderFields (shaderNode)
    {
       if (! this ._enabled .getValue ())
          return;
@@ -3484,7 +3620,7 @@ SilhouetteEnhancementVolumeStyle .prototype = Object .assign (Object .create (Vo
       if (this .surfaceNormalsNode)
          shaderNode .addUserDefinedField ((X3DConstants_default()).inputOutput, "surfaceNormals_" + this .getId (), new (Fields_default()).SFNode (this .surfaceNormalsNode));
    },
-   getUniformsText: function ()
+   getUniformsText ()
    {
       if (! this ._enabled .getValue ())
          return "";
@@ -3518,7 +3654,7 @@ SilhouetteEnhancementVolumeStyle .prototype = Object .assign (Object .create (Vo
 
       return string;
    },
-   getFunctionsText: function ()
+   getFunctionsText ()
    {
       if (! this ._enabled .getValue ())
          return "";
@@ -3534,6 +3670,42 @@ SilhouetteEnhancementVolumeStyle .prototype = Object .assign (Object .create (Vo
    },
 });
 
+Object .defineProperties (SilhouetteEnhancementVolumeStyle,
+{
+   typeName:
+   {
+      value: "SilhouetteEnhancementVolumeStyle",
+      enumerable: true,
+   },
+   componentName:
+   {
+      value: "VolumeRendering",
+      enumerable: true,
+   },
+   containerField:
+   {
+      value: "renderStyle",
+      enumerable: true,
+   },
+   specificationRange:
+   {
+      value: Object .freeze (["3.3", "Infinity"]),
+      enumerable: true,
+   },
+   fieldDefinitions:
+   {
+      value: new (FieldDefinitionArray_default()) ([
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "metadata",                  new (Fields_default()).SFNode ()),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "enabled",                   new (Fields_default()).SFBool (true)),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "silhouetteRetainedOpacity", new (Fields_default()).SFFloat (1)),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "silhouetteBoundaryOpacity", new (Fields_default()).SFFloat (0)),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "silhouetteSharpness",       new (Fields_default()).SFFloat (0.5)),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "surfaceNormals",            new (Fields_default()).SFNode ()),
+      ]),
+      enumerable: true,
+   },
+});
+
 const SilhouetteEnhancementVolumeStyle_default_ = SilhouetteEnhancementVolumeStyle;
 ;
 
@@ -3596,40 +3768,16 @@ Namespace_default().set ("x_ite/Components/VolumeRendering/SilhouetteEnhancement
 
 function ToneMappedVolumeStyle (executionContext)
 {
-   VolumeRendering_X3DComposableVolumeRenderStyleNode.call (this, executionContext);
+   VolumeRendering_X3DComposableVolumeRenderStyleNode .call (this, executionContext);
 
    this .addType ((X3DConstants_default()).ToneMappedVolumeStyle);
 }
 
-ToneMappedVolumeStyle .prototype = Object .assign (Object .create (VolumeRendering_X3DComposableVolumeRenderStyleNode.prototype),
+Object .assign (Object .setPrototypeOf (ToneMappedVolumeStyle .prototype, VolumeRendering_X3DComposableVolumeRenderStyleNode .prototype),
 {
-   constructor: ToneMappedVolumeStyle,
-   [Symbol .for ("X_ITE.X3DBaseNode.fieldDefinitions")]: new (FieldDefinitionArray_default()) ([
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "metadata",       new (Fields_default()).SFNode ()),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "enabled",        new (Fields_default()).SFBool (true)),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "coolColor",      new (Fields_default()).SFColorRGBA (0, 0, 1, 0)),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "warmColor",      new (Fields_default()).SFColorRGBA (1, 1, 0, 0)),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "surfaceNormals", new (Fields_default()).SFNode ()),
-   ]),
-   getTypeName: function ()
-   {
-      return "ToneMappedVolumeStyle";
-   },
-   getComponentName: function ()
-   {
-      return "VolumeRendering";
-   },
-   getContainerField: function ()
+   initialize ()
    {
-      return "renderStyle";
-   },
-   getSpecificationRange: function ()
-   {
-      return ["3.3", "Infinity"];
-   },
-   initialize: function ()
-   {
-      VolumeRendering_X3DComposableVolumeRenderStyleNode.prototype.initialize.call (this);
+      VolumeRendering_X3DComposableVolumeRenderStyleNode .prototype .initialize .call (this);
 
       const gl = this .getBrowser () .getContext ();
 
@@ -3640,11 +3788,11 @@ ToneMappedVolumeStyle .prototype = Object .assign (Object .create (VolumeRenderi
 
       this .set_surfaceNormals__ ();
    },
-   set_surfaceNormals__: function ()
+   set_surfaceNormals__ ()
    {
       this .surfaceNormalsNode = X3DCast_default() ((X3DConstants_default()).X3DTexture3DNode, this ._surfaceNormals);
    },
-   addShaderFields: function (shaderNode)
+   addShaderFields (shaderNode)
    {
       if (! this ._enabled .getValue ())
          return;
@@ -3655,7 +3803,7 @@ ToneMappedVolumeStyle .prototype = Object .assign (Object .create (VolumeRenderi
       if (this .surfaceNormalsNode)
          shaderNode .addUserDefinedField ((X3DConstants_default()).inputOutput, "surfaceNormals_" + this .getId (), new (Fields_default()).SFNode (this .surfaceNormalsNode));
    },
-   getUniformsText: function ()
+   getUniformsText ()
    {
       if (! this ._enabled .getValue ())
          return "";
@@ -3698,7 +3846,7 @@ ToneMappedVolumeStyle .prototype = Object .assign (Object .create (VolumeRenderi
 
       return string;
    },
-   getFunctionsText: function ()
+   getFunctionsText ()
    {
       if (! this ._enabled .getValue ())
          return "";
@@ -3714,6 +3862,41 @@ ToneMappedVolumeStyle .prototype = Object .assign (Object .create (VolumeRenderi
    },
 });
 
+Object .defineProperties (ToneMappedVolumeStyle,
+{
+   typeName:
+   {
+      value: "ToneMappedVolumeStyle",
+      enumerable: true,
+   },
+   componentName:
+   {
+      value: "VolumeRendering",
+      enumerable: true,
+   },
+   containerField:
+   {
+      value: "renderStyle",
+      enumerable: true,
+   },
+   specificationRange:
+   {
+      value: Object .freeze (["3.3", "Infinity"]),
+      enumerable: true,
+   },
+   fieldDefinitions:
+   {
+      value: new (FieldDefinitionArray_default()) ([
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "metadata",       new (Fields_default()).SFNode ()),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "enabled",        new (Fields_default()).SFBool (true)),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "coolColor",      new (Fields_default()).SFColorRGBA (0, 0, 1, 0)),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "warmColor",      new (Fields_default()).SFColorRGBA (1, 1, 0, 0)),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput, "surfaceNormals", new (Fields_default()).SFNode ()),
+      ]),
+      enumerable: true,
+   },
+});
+
 const ToneMappedVolumeStyle_default_ = ToneMappedVolumeStyle;
 ;
 
@@ -3778,45 +3961,18 @@ Namespace_default().set ("x_ite/Components/VolumeRendering/ToneMappedVolumeStyle
 
 function VolumeData (executionContext)
 {
-   VolumeRendering_X3DVolumeDataNode.call (this, executionContext);
+   VolumeRendering_X3DVolumeDataNode .call (this, executionContext);
 
    this .addType ((X3DConstants_default()).VolumeData);
 
    this .renderStyleNode = null;
   }
 
-VolumeData .prototype = Object .assign (Object .create (VolumeRendering_X3DVolumeDataNode.prototype),
+Object .assign (Object .setPrototypeOf (VolumeData .prototype, VolumeRendering_X3DVolumeDataNode .prototype),
 {
-   constructor: VolumeData,
-   [Symbol .for ("X_ITE.X3DBaseNode.fieldDefinitions")]: new (FieldDefinitionArray_default()) ([
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "metadata",    new (Fields_default()).SFNode ()),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "dimensions",  new (Fields_default()).SFVec3f (1, 1, 1)),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "visible",     new (Fields_default()).SFBool (true)),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "bboxDisplay", new (Fields_default()).SFBool ()),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).initializeOnly, "bboxCenter",  new (Fields_default()).SFVec3f (0, 0, 0)),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).initializeOnly, "bboxSize",    new (Fields_default()).SFVec3f (-1, -1, -1)),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "renderStyle", new (Fields_default()).SFNode ()),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "voxels",      new (Fields_default()).SFNode ()),
-   ]),
-   getTypeName: function ()
+   initialize ()
    {
-      return "VolumeData";
-   },
-   getComponentName: function ()
-   {
-      return "VolumeRendering";
-   },
-   getContainerField: function ()
-   {
-      return "children";
-   },
-   getSpecificationRange: function ()
-   {
-      return ["3.3", "Infinity"];
-   },
-   initialize: function ()
-   {
-      VolumeRendering_X3DVolumeDataNode.prototype.initialize.call (this);
+      VolumeRendering_X3DVolumeDataNode .prototype .initialize .call (this);
 
       const gl = this .getBrowser () .getContext ();
 
@@ -3835,7 +3991,7 @@ VolumeData .prototype = Object .assign (Object .create (VolumeRendering_X3DVolum
 
       this .updateShader ();
    },
-   set_renderStyle__: function ()
+   set_renderStyle__ ()
    {
       if (this .renderStyleNode)
       {
@@ -3851,7 +4007,7 @@ VolumeData .prototype = Object .assign (Object .create (VolumeRendering_X3DVolum
          this .renderStyleNode .addVolumeData (this);
       }
    },
-   set_voxels__: function ()
+   set_voxels__ ()
    {
       this .voxelsNode = X3DCast_default() ((X3DConstants_default()).X3DTexture3DNode, this ._voxels);
 
@@ -3860,9 +4016,9 @@ VolumeData .prototype = Object .assign (Object .create (VolumeRendering_X3DVolum
       else
          this .getAppearance () ._texture = this .getBrowser () .getDefaultVoxels ();
    },
-   createShader: function (options, vs, fs)
+   createShader (options, vs, fs)
    {
-      // if (DEBUG)
+      // if (DEVELOPMENT)
       //    console .log ("Creating VolumeData Shader ...");
 
       const opacityMapVolumeStyle = this .getBrowser () .getDefaultVolumeStyle ();
@@ -3880,7 +4036,7 @@ VolumeData .prototype = Object .assign (Object .create (VolumeRendering_X3DVolum
       fs = fs .replace (/\/\/ VOLUME_STYLES_UNIFORMS\n/,  styleUniforms);
       fs = fs .replace (/\/\/ VOLUME_STYLES_FUNCTIONS\n/, styleFunctions);
 
-      // if (DEBUG)
+      // if (DEVELOPMENT)
       //    this .getBrowser () .print (fs);
 
       const vertexShader = new (ShaderPart_default()) (this .getExecutionContext ());
@@ -3921,6 +4077,44 @@ VolumeData .prototype = Object .assign (Object .create (VolumeRendering_X3DVolum
    },
 });
 
+Object .defineProperties (VolumeData,
+{
+   typeName:
+   {
+      value: "VolumeData",
+      enumerable: true,
+   },
+   componentName:
+   {
+      value: "VolumeRendering",
+      enumerable: true,
+   },
+   containerField:
+   {
+      value: "children",
+      enumerable: true,
+   },
+   specificationRange:
+   {
+      value: Object .freeze (["3.3", "Infinity"]),
+      enumerable: true,
+   },
+   fieldDefinitions:
+   {
+      value: new (FieldDefinitionArray_default()) ([
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "metadata",    new (Fields_default()).SFNode ()),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "dimensions",  new (Fields_default()).SFVec3f (1, 1, 1)),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "visible",     new (Fields_default()).SFBool (true)),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "bboxDisplay", new (Fields_default()).SFBool ()),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).initializeOnly, "bboxCenter",  new (Fields_default()).SFVec3f (0, 0, 0)),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).initializeOnly, "bboxSize",    new (Fields_default()).SFVec3f (-1, -1, -1)),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "renderStyle", new (Fields_default()).SFNode ()),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "voxels",      new (Fields_default()).SFNode ()),
+      ]),
+      enumerable: true,
+   },
+});
+
 const VolumeData_default_ = VolumeData;
 ;
 
@@ -3993,30 +4187,30 @@ Namespace_default().set ("x_ite/Components/VolumeRendering/VolumeData", VolumeDa
 
 
 
-Components_default().addComponent ({
+Components_default().add ({
    name: "VolumeRendering",
-   types:
-   {
-      BlendedVolumeStyle:               VolumeRendering_BlendedVolumeStyle,
-      BoundaryEnhancementVolumeStyle:   VolumeRendering_BoundaryEnhancementVolumeStyle,
-      CartoonVolumeStyle:               VolumeRendering_CartoonVolumeStyle,
-      ComposedVolumeStyle:              VolumeRendering_ComposedVolumeStyle,
-      EdgeEnhancementVolumeStyle:       VolumeRendering_EdgeEnhancementVolumeStyle,
-      IsoSurfaceVolumeData:             VolumeRendering_IsoSurfaceVolumeData,
-      OpacityMapVolumeStyle:            VolumeRendering_OpacityMapVolumeStyle,
-      ProjectionVolumeStyle:            VolumeRendering_ProjectionVolumeStyle,
-      SegmentedVolumeData:              VolumeRendering_SegmentedVolumeData,
-      ShadedVolumeStyle:                VolumeRendering_ShadedVolumeStyle,
-      SilhouetteEnhancementVolumeStyle: VolumeRendering_SilhouetteEnhancementVolumeStyle,
-      ToneMappedVolumeStyle:            VolumeRendering_ToneMappedVolumeStyle,
-      VolumeData:                       VolumeRendering_VolumeData,
-   },
-   abstractTypes:
-   {
-      X3DComposableVolumeRenderStyleNode: VolumeRendering_X3DComposableVolumeRenderStyleNode,
-      X3DVolumeDataNode:                  VolumeRendering_X3DVolumeDataNode,
-      X3DVolumeRenderStyleNode:           VolumeRendering_X3DVolumeRenderStyleNode,
-   },
+   concreteNodes:
+   [
+      VolumeRendering_BlendedVolumeStyle,
+      VolumeRendering_BoundaryEnhancementVolumeStyle,
+      VolumeRendering_CartoonVolumeStyle,
+      VolumeRendering_ComposedVolumeStyle,
+      VolumeRendering_EdgeEnhancementVolumeStyle,
+      VolumeRendering_IsoSurfaceVolumeData,
+      VolumeRendering_OpacityMapVolumeStyle,
+      VolumeRendering_ProjectionVolumeStyle,
+      VolumeRendering_SegmentedVolumeData,
+      VolumeRendering_ShadedVolumeStyle,
+      VolumeRendering_SilhouetteEnhancementVolumeStyle,
+      VolumeRendering_ToneMappedVolumeStyle,
+      VolumeRendering_VolumeData,
+   ],
+   abstractNodes:
+   [
+      VolumeRendering_X3DComposableVolumeRenderStyleNode,
+      VolumeRendering_X3DVolumeDataNode,
+      VolumeRendering_X3DVolumeRenderStyleNode,
+   ],
    browserContext: VolumeRendering_X3DVolumeRenderingContext,
 });