x_ite 8.7.8 → 8.8.0

package/dist/assets/components/CubeMapTexturing.js

@@ -1,11 +1,11 @@
-/* X_ITE v8.7.8 */(() => { // webpackBootstrap
+/* X_ITE v8.8.0 */(() => { // webpackBootstrap
 /******/ 	"use strict";
 /******/ 	var __webpack_modules__ = ({
 
 /***/ 355:
 /***/ ((module) => {
 
-module.exports = window [Symbol .for ("X_ITE.X3D-8.7.8")] .require ("lib/jquery");
+module.exports = window [Symbol .for ("X_ITE.X3D-8.8.0")] .require ("lib/jquery");
 
 /***/ })
 
@@ -73,25 +73,25 @@ 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/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/Texturing/X3DSingleTextureNode\")"
-const X3DSingleTextureNode_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.7.8")] .require ("x_ite/Components/Texturing/X3DSingleTextureNode");
+const X3DSingleTextureNode_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.8.0")] .require ("x_ite/Components/Texturing/X3DSingleTextureNode");
 var X3DSingleTextureNode_default = /*#__PURE__*/__webpack_require__.n(X3DSingleTextureNode_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/CubeMapTexturing/X3DEnvironmentTextureNode.js
 /*******************************************************************************
@@ -164,22 +164,21 @@ function X3DEnvironmentTextureNode (executionContext)
    ];
 }
 
-X3DEnvironmentTextureNode .prototype = Object .assign (Object .create ((X3DSingleTextureNode_default()).prototype),
+Object .assign (Object .setPrototypeOf (X3DEnvironmentTextureNode .prototype, (X3DSingleTextureNode_default()).prototype),
 {
-   constructor: X3DEnvironmentTextureNode,
-   getTarget: function ()
+   getTarget ()
    {
       return this .target;
    },
-   getTextureType: function ()
+   getTextureType ()
    {
       return 4;
    },
-   getTextureTypeString: function ()
+   getTextureTypeString ()
    {
       return "CUBE";
    },
-   getTargets: function ()
+   getTargets ()
    {
       return this .targets;
    },
@@ -199,9 +198,9 @@ X3DEnvironmentTextureNode .prototype = Object .assign (Object .create ((X3DSingl
          this .setTransparent (false);
       };
    })(),
-   updateTextureParameters: function ()
+   updateTextureParameters ()
    {
-      X3DSingleTextureNode_default().prototype.updateTextureParameters.call (this,
+      X3DSingleTextureNode_default().prototype .updateTextureParameters .call (this,
                                                                       this .target,
                                                                       this ._textureProperties .getValue (),
                                                                       this .texturePropertiesNode,
@@ -211,7 +210,7 @@ X3DEnvironmentTextureNode .prototype = Object .assign (Object .create ((X3DSingl
                                                                       false,
                                                                       false);
    },
-   setShaderUniforms: function (gl, shaderObject, renderObject, channel = shaderObject .x3d_Texture [0])
+   setShaderUniforms (gl, shaderObject, renderObject, channel = shaderObject .x3d_Texture [0])
    {
       const textureUnit = this .getBrowser () .getTextureCubeUnit ();
 
@@ -221,16 +220,30 @@ X3DEnvironmentTextureNode .prototype = Object .assign (Object .create ((X3DSingl
    },
 });
 
+Object .defineProperties (X3DEnvironmentTextureNode,
+{
+   typeName:
+   {
+      value: "X3DEnvironmentTextureNode",
+      enumerable: true,
+   },
+   componentName:
+   {
+      value: "CubeMapTexturing",
+      enumerable: true,
+   },
+});
+
 const __default__ = X3DEnvironmentTextureNode;
 ;
 
 Namespace_default().set ("x_ite/Components/CubeMapTexturing/X3DEnvironmentTextureNode", __default__);
 /* harmony default export */ const CubeMapTexturing_X3DEnvironmentTextureNode = (__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: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"standard/Utility/BitSet\")"
-const BitSet_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.7.8")] .require ("standard/Utility/BitSet");
+const BitSet_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.8.0")] .require ("standard/Utility/BitSet");
 var BitSet_default = /*#__PURE__*/__webpack_require__.n(BitSet_namespaceObject);
 ;// CONCATENATED MODULE: ./src/x_ite/Components/CubeMapTexturing/ComposedCubeMapTexture.js
 /*******************************************************************************
@@ -290,7 +303,7 @@ var BitSet_default = /*#__PURE__*/__webpack_require__.n(BitSet_namespaceObject);
 
 function ComposedCubeMapTexture (executionContext)
 {
-   CubeMapTexturing_X3DEnvironmentTextureNode.call (this, executionContext);
+   CubeMapTexturing_X3DEnvironmentTextureNode .call (this, executionContext);
 
    this .addType ((X3DConstants_default()).ComposedCubeMapTexture);
 
@@ -310,39 +323,11 @@ function ComposedCubeMapTexture (executionContext)
    this .textureBits  = new (BitSet_default()) ();
 }
 
-ComposedCubeMapTexture .prototype = Object .assign (Object .create (CubeMapTexturing_X3DEnvironmentTextureNode.prototype),
+Object .assign (Object .setPrototypeOf (ComposedCubeMapTexture .prototype, CubeMapTexturing_X3DEnvironmentTextureNode .prototype),
 {
-   constructor: ComposedCubeMapTexture,
-   [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,    "description",       new (Fields_default()).SFString ()),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "frontTexture",      new (Fields_default()).SFNode ()),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "backTexture",       new (Fields_default()).SFNode ()),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "leftTexture",       new (Fields_default()).SFNode ()),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "rightTexture",      new (Fields_default()).SFNode ()),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "bottomTexture",     new (Fields_default()).SFNode ()),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "topTexture",        new (Fields_default()).SFNode ()),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).initializeOnly, "textureProperties", new (Fields_default()).SFNode ()),
-   ]),
-   getTypeName: function ()
+   initialize ()
    {
-      return "ComposedCubeMapTexture";
-   },
-   getComponentName: function ()
-   {
-      return "CubeMapTexturing";
-   },
-   getContainerField: function ()
-   {
-      return "texture";
-   },
-   getSpecificationRange: function ()
-   {
-      return ["3.1", "Infinity"];
-   },
-   initialize: function ()
-   {
-      CubeMapTexturing_X3DEnvironmentTextureNode.prototype.initialize.call (this);
+      CubeMapTexturing_X3DEnvironmentTextureNode .prototype .initialize .call (this);
 
       const gl = this .getBrowser () .getContext ();
 
@@ -369,7 +354,7 @@ ComposedCubeMapTexture .prototype = Object .assign (Object .create (CubeMapTextu
       this .set_texture__ (this ._topTexture,    4);
       this .set_texture__ (this ._bottomTexture, 5);
    },
-   set_texture__: function (node, index)
+   set_texture__ (node, index)
    {
       let textureNode = this .textureNodes [index];
 
@@ -381,17 +366,17 @@ ComposedCubeMapTexture .prototype = Object .assign (Object .create (CubeMapTextu
 
       this .set_loadState__ (textureNode, index);
    },
-   set_loadState__: function (textureNode, index)
+   set_loadState__ (textureNode, index)
    {
       this .setTextureBit (index, textureNode, textureNode ?.checkLoadState () ?? (X3DConstants_default()).NOT_STARTED);
 
       this ._update .addEvent ();
    },
-   setTextureBit: function (bit, textureNode, loadState)
+   setTextureBit (bit, textureNode, loadState)
    {
       this .textureBits .set (bit, loadState === (X3DConstants_default()).COMPLETE_STATE || textureNode ?.getWidth ());
    },
-   isComplete: function ()
+   isComplete ()
    {
       if (+this .textureBits !== 0b111111)
          return false;
@@ -411,7 +396,7 @@ ComposedCubeMapTexture .prototype = Object .assign (Object .create (CubeMapTextu
 
       return true;
    },
-   update: function ()
+   update ()
    {
       if (this .isComplete ())
       {
@@ -471,19 +456,58 @@ ComposedCubeMapTexture .prototype = Object .assign (Object .create (CubeMapTextu
    },
 });
 
+Object .defineProperties (ComposedCubeMapTexture,
+{
+   typeName:
+   {
+      value: "ComposedCubeMapTexture",
+      enumerable: true,
+   },
+   componentName:
+   {
+      value: "CubeMapTexturing",
+      enumerable: true,
+   },
+   containerField:
+   {
+      value: "texture",
+      enumerable: true,
+   },
+   specificationRange:
+   {
+      value: Object .freeze (["3.1", "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,    "description",       new (Fields_default()).SFString ()),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "frontTexture",      new (Fields_default()).SFNode ()),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "backTexture",       new (Fields_default()).SFNode ()),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "leftTexture",       new (Fields_default()).SFNode ()),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "rightTexture",      new (Fields_default()).SFNode ()),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "bottomTexture",     new (Fields_default()).SFNode ()),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "topTexture",        new (Fields_default()).SFNode ()),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).initializeOnly, "textureProperties", new (Fields_default()).SFNode ()),
+      ]),
+      enumerable: true,
+   },
+});
+
 const ComposedCubeMapTexture_default_ = ComposedCubeMapTexture;
 ;
 
 Namespace_default().set ("x_ite/Components/CubeMapTexturing/ComposedCubeMapTexture", ComposedCubeMapTexture_default_);
 /* harmony default export */ const CubeMapTexturing_ComposedCubeMapTexture = (ComposedCubeMapTexture_default_);
 ;// CONCATENATED MODULE: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"x_ite/Base/X3DBaseNode\")"
-const X3DBaseNode_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.7.8")] .require ("x_ite/Base/X3DBaseNode");
+const X3DBaseNode_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.8.0")] .require ("x_ite/Base/X3DBaseNode");
 var X3DBaseNode_default = /*#__PURE__*/__webpack_require__.n(X3DBaseNode_namespaceObject);
 ;// CONCATENATED MODULE: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"x_ite/Rendering/X3DRenderObject\")"
-const X3DRenderObject_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.7.8")] .require ("x_ite/Rendering/X3DRenderObject");
+const X3DRenderObject_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.8.0")] .require ("x_ite/Rendering/X3DRenderObject");
 var X3DRenderObject_default = /*#__PURE__*/__webpack_require__.n(X3DRenderObject_namespaceObject);
 ;// CONCATENATED MODULE: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"x_ite/Rendering/TraverseType\")"
-const TraverseType_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.7.8")] .require ("x_ite/Rendering/TraverseType");
+const TraverseType_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.8.0")] .require ("x_ite/Rendering/TraverseType");
 var TraverseType_default = /*#__PURE__*/__webpack_require__.n(TraverseType_namespaceObject);
 ;// CONCATENATED MODULE: ./src/x_ite/Rendering/DependentRenderer.js
 /*******************************************************************************
@@ -545,66 +569,65 @@ function DependentRenderer (executionContext)
    this .renderObject = null;
 }
 
-DependentRenderer .prototype = Object .assign (Object .create ((X3DBaseNode_default()).prototype),
+Object .assign (Object .setPrototypeOf (DependentRenderer .prototype, (X3DBaseNode_default()).prototype),
    (X3DRenderObject_default()).prototype,
 {
-   constructor: DependentRenderer,
-   initialize: function ()
+   initialize ()
    {
-      X3DBaseNode_default().prototype.initialize.call (this);
-      X3DRenderObject_default().prototype.initialize.call (this);
+      X3DBaseNode_default().prototype .initialize .call (this);
+      X3DRenderObject_default().prototype .initialize .call (this);
    },
-   isIndependent: function ()
+   isIndependent ()
    {
       return false;
    },
-   setRenderer: function (value)
+   setRenderer (value)
    {
       this .renderObject = value;
    },
-   getLayer: function ()
+   getLayer ()
    {
       return this .renderObject .getLayer ();
    },
-   getBackground: function ()
+   getBackground ()
    {
       return this .renderObject .getBackground ();
    },
-   getFog: function ()
+   getFog ()
    {
       return this .renderObject .getFog ();
    },
-   getNavigationInfo: function ()
+   getNavigationInfo ()
    {
       return this .renderObject .getNavigationInfo ();
    },
-   getViewpoint: function ()
+   getViewpoint ()
    {
       return this .renderObject .getViewpoint ();
    },
-   getLightContainer: function ()
+   getLightContainer ()
    {
       return this .renderObject .getLights () [this .lightIndex ++];
    },
-   render: function (type, callback, group)
+   render (type, callback, group)
    {
       switch (type)
       {
          case (TraverseType_default()).COLLISION:
          {
-            X3DRenderObject_default().prototype.render.call (this, type, callback, group);
+            X3DRenderObject_default().prototype .render .call (this, type, callback, group);
             break;
          }
          case (TraverseType_default()).SHADOW:
          {
-            X3DRenderObject_default().prototype.render.call (this, type, callback, group);
+            X3DRenderObject_default().prototype .render .call (this, type, callback, group);
             break;
          }
          case (TraverseType_default()).DISPLAY:
          {
             this .lightIndex = 0;
 
-            X3DRenderObject_default().prototype.render.call (this, type, callback, group);
+            X3DRenderObject_default().prototype .render .call (this, type, callback, group);
 
             for (const light of this .renderObject .getLights ())
                light .modelViewMatrix .pop ();
@@ -624,28 +647,28 @@ const DependentRenderer_default_ = DependentRenderer;
 Namespace_default().set ("x_ite/Rendering/DependentRenderer", DependentRenderer_default_);
 /* harmony default export */ const Rendering_DependentRenderer = (DependentRenderer_default_);
 ;// CONCATENATED MODULE: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"x_ite/Rendering/TextureBuffer\")"
-const TextureBuffer_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.7.8")] .require ("x_ite/Rendering/TextureBuffer");
+const TextureBuffer_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.8.0")] .require ("x_ite/Rendering/TextureBuffer");
 var TextureBuffer_default = /*#__PURE__*/__webpack_require__.n(TextureBuffer_namespaceObject);
 ;// CONCATENATED MODULE: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"standard/Math/Geometry/Camera\")"
-const Camera_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.7.8")] .require ("standard/Math/Geometry/Camera");
+const Camera_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.8.0")] .require ("standard/Math/Geometry/Camera");
 var Camera_default = /*#__PURE__*/__webpack_require__.n(Camera_namespaceObject);
 ;// CONCATENATED MODULE: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"standard/Math/Geometry/ViewVolume\")"
-const ViewVolume_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.7.8")] .require ("standard/Math/Geometry/ViewVolume");
+const ViewVolume_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.8.0")] .require ("standard/Math/Geometry/ViewVolume");
 var ViewVolume_default = /*#__PURE__*/__webpack_require__.n(ViewVolume_namespaceObject);
 ;// CONCATENATED MODULE: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"standard/Math/Numbers/Rotation4\")"
-const Rotation4_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.7.8")] .require ("standard/Math/Numbers/Rotation4");
+const Rotation4_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.8.0")] .require ("standard/Math/Numbers/Rotation4");
 var Rotation4_default = /*#__PURE__*/__webpack_require__.n(Rotation4_namespaceObject);
 ;// 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: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"standard/Math/Numbers/Vector4\")"
-const Vector4_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.7.8")] .require ("standard/Math/Numbers/Vector4");
+const Vector4_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.8.0")] .require ("standard/Math/Numbers/Vector4");
 var Vector4_default = /*#__PURE__*/__webpack_require__.n(Vector4_namespaceObject);
 ;// CONCATENATED MODULE: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"standard/Math/Numbers/Matrix4\")"
-const Matrix4_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.7.8")] .require ("standard/Math/Numbers/Matrix4");
+const Matrix4_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.8.0")] .require ("standard/Math/Numbers/Matrix4");
 var Matrix4_default = /*#__PURE__*/__webpack_require__.n(Matrix4_namespaceObject);
 ;// CONCATENATED MODULE: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"standard/Math/Algorithm\")"
-const Algorithm_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.7.8")] .require ("standard/Math/Algorithm");
+const Algorithm_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.8.0")] .require ("standard/Math/Algorithm");
 var Algorithm_default = /*#__PURE__*/__webpack_require__.n(Algorithm_namespaceObject);
 ;// CONCATENATED MODULE: ./src/x_ite/Components/CubeMapTexturing/GeneratedCubeMapTexture.js
 /*******************************************************************************
@@ -713,7 +736,7 @@ var Algorithm_default = /*#__PURE__*/__webpack_require__.n(Algorithm_namespaceOb
 
 function GeneratedCubeMapTexture (executionContext)
 {
-   CubeMapTexturing_X3DEnvironmentTextureNode.call (this, executionContext);
+   CubeMapTexturing_X3DEnvironmentTextureNode .call (this, executionContext);
 
    this .addType ((X3DConstants_default()).GeneratedCubeMapTexture);
 
@@ -723,35 +746,11 @@ function GeneratedCubeMapTexture (executionContext)
    this .viewVolume        = new (ViewVolume_default()) ();
 }
 
-GeneratedCubeMapTexture .prototype = Object .assign (Object .create (CubeMapTexturing_X3DEnvironmentTextureNode.prototype),
+Object .assign (Object .setPrototypeOf (GeneratedCubeMapTexture .prototype, CubeMapTexturing_X3DEnvironmentTextureNode .prototype),
 {
-   constructor: GeneratedCubeMapTexture,
-   [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,    "description",       new (Fields_default()).SFString ()),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "update",            new (Fields_default()).SFString ("NONE")),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).initializeOnly, "size",              new (Fields_default()).SFInt32 (128)),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).initializeOnly, "textureProperties", new (Fields_default()).SFNode ()),
-   ]),
-   getTypeName: function ()
+   initialize ()
    {
-      return "GeneratedCubeMapTexture";
-   },
-   getComponentName: function ()
-   {
-      return "CubeMapTexturing";
-   },
-   getContainerField: function ()
-   {
-      return "texture";
-   },
-   getSpecificationRange: function ()
-   {
-      return ["3.0", "Infinity"];
-   },
-   initialize: function ()
-   {
-      CubeMapTexturing_X3DEnvironmentTextureNode.prototype.initialize.call (this);
+      CubeMapTexturing_X3DEnvironmentTextureNode .prototype .initialize .call (this);
 
       this ._size .addInterest ("set_size__", this);
 
@@ -759,7 +758,7 @@ GeneratedCubeMapTexture .prototype = Object .assign (Object .create (CubeMapText
 
       this .set_size__ ();
    },
-   set_size__: function ()
+   set_size__ ()
    {
       const
          browser = this .getBrowser (),
@@ -794,7 +793,7 @@ GeneratedCubeMapTexture .prototype = Object .assign (Object .create (CubeMapText
          this .frameBuffer = null;
       }
    },
-   traverse: function (type, renderObject)
+   traverse (type, renderObject)
    {
       // TraverseType .DISPLAY
 
@@ -923,7 +922,7 @@ GeneratedCubeMapTexture .prototype = Object .assign (Object .create (CubeMapText
 
       return function (gl, shaderObject, renderObject, channel)
       {
-         CubeMapTexturing_X3DEnvironmentTextureNode.prototype.setShaderUniforms.call (this, gl, shaderObject, renderObject, channel);
+         CubeMapTexturing_X3DEnvironmentTextureNode .prototype .setShaderUniforms .call (this, gl, shaderObject, renderObject, channel);
 
          if (renderObject === this .dependentRenderer)
             gl .uniformMatrix4fv (shaderObject .x3d_ModelViewMatrix, false, zeros);
@@ -931,20 +930,55 @@ GeneratedCubeMapTexture .prototype = Object .assign (Object .create (CubeMapText
    })(),
 });
 
+Object .defineProperties (GeneratedCubeMapTexture,
+{
+   typeName:
+   {
+      value: "GeneratedCubeMapTexture",
+      enumerable: true,
+   },
+   componentName:
+   {
+      value: "CubeMapTexturing",
+      enumerable: true,
+   },
+   containerField:
+   {
+      value: "texture",
+      enumerable: true,
+   },
+   specificationRange:
+   {
+      value: Object .freeze (["3.0", "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,    "description",       new (Fields_default()).SFString ()),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "update",            new (Fields_default()).SFString ("NONE")),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).initializeOnly, "size",              new (Fields_default()).SFInt32 (128)),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).initializeOnly, "textureProperties", new (Fields_default()).SFNode ()),
+      ]),
+      enumerable: true,
+   },
+});
+
 const GeneratedCubeMapTexture_default_ = GeneratedCubeMapTexture;
 ;
 
 Namespace_default().set ("x_ite/Components/CubeMapTexturing/GeneratedCubeMapTexture", GeneratedCubeMapTexture_default_);
 /* harmony default export */ const CubeMapTexturing_GeneratedCubeMapTexture = (GeneratedCubeMapTexture_default_);
 ;// CONCATENATED MODULE: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"x_ite/Components/Networking/X3DUrlObject\")"
-const X3DUrlObject_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.7.8")] .require ("x_ite/Components/Networking/X3DUrlObject");
+const X3DUrlObject_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.8.0")] .require ("x_ite/Components/Networking/X3DUrlObject");
 var X3DUrlObject_default = /*#__PURE__*/__webpack_require__.n(X3DUrlObject_namespaceObject);
 ;// CONCATENATED MODULE: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"standard/Math/Numbers/Vector2\")"
-const Vector2_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.7.8")] .require ("standard/Math/Numbers/Vector2");
+const Vector2_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.8.0")] .require ("standard/Math/Numbers/Vector2");
 var Vector2_default = /*#__PURE__*/__webpack_require__.n(Vector2_namespaceObject);
-;// 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");
-var DEBUG_default = /*#__PURE__*/__webpack_require__.n(DEBUG_namespaceObject);
+;// CONCATENATED MODULE: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"x_ite/DEVELOPMENT\")"
+const DEVELOPMENT_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.8.0")] .require ("x_ite/DEVELOPMENT");
+var DEVELOPMENT_default = /*#__PURE__*/__webpack_require__.n(DEVELOPMENT_namespaceObject);
 ;// CONCATENATED MODULE: ./src/x_ite/Components/CubeMapTexturing/ImageCubeMapTexture.js
 /* provided dependency */ var $ = __webpack_require__(355);
 /*******************************************************************************
@@ -1017,7 +1051,7 @@ const offsets = [
 
 function ImageCubeMapTexture (executionContext)
 {
-   CubeMapTexturing_X3DEnvironmentTextureNode.call (this, executionContext);
+   CubeMapTexturing_X3DEnvironmentTextureNode .call (this, executionContext);
    X3DUrlObject_default().call (this, executionContext);
 
    this .addType ((X3DConstants_default()).ImageCubeMapTexture);
@@ -1027,39 +1061,13 @@ function ImageCubeMapTexture (executionContext)
    this .urlStack = new (Fields_default()).MFString ();
 }
 
-ImageCubeMapTexture .prototype = Object .assign (Object .create (CubeMapTexturing_X3DEnvironmentTextureNode.prototype),
+Object .assign (Object .setPrototypeOf (ImageCubeMapTexture .prototype, CubeMapTexturing_X3DEnvironmentTextureNode .prototype),
    (X3DUrlObject_default()).prototype,
 {
-   constructor: ImageCubeMapTexture,
-   [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,    "description",          new (Fields_default()).SFString ()),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "load",                 new (Fields_default()).SFBool (true)),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "url",                  new (Fields_default()).MFString ()),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "autoRefresh",          new (Fields_default()).SFTime ()),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "autoRefreshTimeLimit", new (Fields_default()).SFTime (3600)),
-      new (X3DFieldDefinition_default()) ((X3DConstants_default()).initializeOnly, "textureProperties",    new (Fields_default()).SFNode ()),
-   ]),
-   getTypeName: function ()
+   initialize ()
    {
-      return "ImageCubeMapTexture";
-   },
-   getComponentName: function ()
-   {
-      return "CubeMapTexturing";
-   },
-   getContainerField: function ()
-   {
-      return "texture";
-   },
-   getSpecificationRange: function ()
-   {
-      return ["3.0", "Infinity"];
-   },
-   initialize: function ()
-   {
-      CubeMapTexturing_X3DEnvironmentTextureNode.prototype.initialize.call (this);
-      X3DUrlObject_default().prototype.initialize.call (this);
+      CubeMapTexturing_X3DEnvironmentTextureNode .prototype .initialize .call (this);
+      X3DUrlObject_default().prototype .initialize .call (this);
 
       // Upload default data.
 
@@ -1078,16 +1086,16 @@ ImageCubeMapTexture .prototype = Object .assign (Object .create (CubeMapTexturin
 
       this .requestImmediateLoad () .catch (Function .prototype);
    },
-   unloadData: function ()
+   unloadData ()
    {
       this .clearTexture ();
    },
-   loadData: function ()
+   loadData ()
    {
       this .urlStack .setValue (this ._url);
       this .loadNext ();
    },
-   loadNext: function ()
+   loadNext ()
    {
       if (this .urlStack .length === 0)
       {
@@ -1108,16 +1116,16 @@ ImageCubeMapTexture .prototype = Object .assign (Object .create (CubeMapTexturin
 
       this .image .attr ("src", this .URL .href);
    },
-   setError: function ()
+   setError ()
    {
       if (this .URL .protocol !== "data:")
          console .warn (`Error loading image '${decodeURI (this .URL .href)}'`);
 
       this .loadNext ();
    },
-   setImage: function ()
+   setImage ()
    {
-      if ((DEBUG_default()))
+      if ((DEVELOPMENT_default()))
       {
           if (this .URL .protocol !== "data:")
             console .info (`Done loading image cube map texture '${decodeURI (this .URL .href)}'`);
@@ -1206,10 +1214,47 @@ ImageCubeMapTexture .prototype = Object .assign (Object .create (CubeMapTexturin
          this .setError ();
       }
    },
-   dispose: function ()
+   dispose ()
+   {
+      X3DUrlObject_default().prototype .dispose .call (this);
+      CubeMapTexturing_X3DEnvironmentTextureNode .prototype .dispose .call (this);
+   },
+});
+
+Object .defineProperties (ImageCubeMapTexture,
+{
+   typeName:
+   {
+      value: "ImageCubeMapTexture",
+      enumerable: true,
+   },
+   componentName:
+   {
+      value: "CubeMapTexturing",
+      enumerable: true,
+   },
+   containerField:
+   {
+      value: "texture",
+      enumerable: true,
+   },
+   specificationRange:
+   {
+      value: Object .freeze (["3.0", "Infinity"]),
+      enumerable: true,
+   },
+   fieldDefinitions:
    {
-      X3DUrlObject_default().prototype.dispose.call (this);
-      CubeMapTexturing_X3DEnvironmentTextureNode.prototype.dispose.call (this);
+      value: new (FieldDefinitionArray_default()) ([
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "metadata",             new (Fields_default()).SFNode ()),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "description",          new (Fields_default()).SFString ()),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "load",                 new (Fields_default()).SFBool (true)),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "url",                  new (Fields_default()).MFString ()),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "autoRefresh",          new (Fields_default()).SFTime ()),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "autoRefreshTimeLimit", new (Fields_default()).SFTime (3600)),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).initializeOnly, "textureProperties",    new (Fields_default()).SFNode ()),
+      ]),
+      enumerable: true,
    },
 });
 
@@ -1272,18 +1317,18 @@ Namespace_default().set ("x_ite/Components/CubeMapTexturing/ImageCubeMapTexture"
 
 
 
-Components_default().addComponent ({
+Components_default().add ({
    name: "CubeMapTexturing",
-   types:
-   {
-      ComposedCubeMapTexture:  CubeMapTexturing_ComposedCubeMapTexture,
-      GeneratedCubeMapTexture: CubeMapTexturing_GeneratedCubeMapTexture,
-      ImageCubeMapTexture:     CubeMapTexturing_ImageCubeMapTexture,
-   },
-   abstractTypes:
-   {
-      X3DEnvironmentTextureNode: CubeMapTexturing_X3DEnvironmentTextureNode,
-   },
+   concreteNodes:
+   [
+      CubeMapTexturing_ComposedCubeMapTexture,
+      CubeMapTexturing_GeneratedCubeMapTexture,
+      CubeMapTexturing_ImageCubeMapTexture,
+   ],
+   abstractNodes:
+   [
+      CubeMapTexturing_X3DEnvironmentTextureNode,
+   ],
 });
 
 const CubeMapTexturing_default_ = undefined;