x_ite 8.7.9 → 8.8.1

package/src/x_ite/Components/PointingDeviceSensor/X3DPointingDeviceSensorNode.js

@@ -56,24 +56,21 @@ function X3DPointingDeviceSensorNode (executionContext)
    this .addType (X3DConstants .X3DPointingDeviceSensorNode);
 }
 
-X3DPointingDeviceSensorNode .prototype = Object .assign (Object .create (X3DSensorNode .prototype),
+Object .assign (Object .setPrototypeOf (X3DPointingDeviceSensorNode .prototype, X3DSensorNode .prototype),
 {
-   constructor: X3DPointingDeviceSensorNode,
-   initialize: function ()
+   initialize ()
    {
       X3DSensorNode .prototype .initialize .call (this);
 
-      this .getBrowser () .getBrowserOptions () ._PrivateSensors .addInterest ("set_live__", this);
-      this .getScene () .getPrivate () .addInterest ("set_live__", this);
       this .getLive () .addInterest ("set_live__", this);
 
       this ._enabled .addInterest ("set_live__", this);
 
       this .set_live__ ();
    },
-   set_live__: function ()
+   set_live__ ()
    {
-      if (((this .getLive () .getValue () && !this .getBrowser () .getBrowserOption ("PrivateSensors")) || this .getScene () .isPrivate () && this .getBrowser () .getBrowserOption ("PrivateSensors")) && this ._enabled .getValue ())
+      if (this .getLive () .getValue () && this ._enabled .getValue ())
       {
          this .getBrowser () .addPointingDeviceSensor (this);
 
@@ -92,7 +89,7 @@ X3DPointingDeviceSensorNode .prototype = Object .assign (Object .create (X3DSens
          this .push = Function .prototype;
       }
    },
-   set_over__: function (over, hit)
+   set_over__ (over, hit)
    {
       if (over !== this ._isOver .getValue ())
       {
@@ -102,14 +99,14 @@ X3DPointingDeviceSensorNode .prototype = Object .assign (Object .create (X3DSens
             this .getBrowser () .getNotification () ._string = this ._description;
       }
    },
-   set_active__: function (active, hit)
+   set_active__ (active, hit)
    {
       if (active !== this ._isActive .getValue ())
          this ._isActive = active
    },
-   set_motion__: function (hit)
+   set_motion__ (hit)
    { },
-   push: function (renderObject, sensors)
+   push (renderObject, sensors)
    {
       sensors .push (new PointingDeviceSensorContainer (this,
                                                         renderObject .getModelViewMatrix  () .get (),
@@ -118,4 +115,18 @@ X3DPointingDeviceSensorNode .prototype = Object .assign (Object .create (X3DSens
    },
 });
 
+Object .defineProperties (X3DPointingDeviceSensorNode,
+{
+   typeName:
+   {
+      value: "X3DPointingDeviceSensorNode",
+      enumerable: true,
+   },
+   componentName:
+   {
+      value: "PointingDeviceSensor",
+      enumerable: true,
+   },
+});
+
 export default X3DPointingDeviceSensorNode;

package/src/x_ite/Components/PointingDeviceSensor/X3DTouchSensorNode.js

@@ -57,10 +57,9 @@ function X3DTouchSensorNode (executionContext)
    this .addType (X3DConstants .X3DTouchSensorNode);
 }
 
-X3DTouchSensorNode .prototype = Object .assign (Object .create (X3DPointingDeviceSensorNode .prototype),
+Object .assign (Object .setPrototypeOf (X3DTouchSensorNode .prototype, X3DPointingDeviceSensorNode .prototype),
 {
-   constructor: X3DTouchSensorNode,
-   set_active__: function (active, hit)
+   set_active__ (active, hit)
    {
       X3DPointingDeviceSensorNode .prototype .set_active__ .call (this, active, hit);
 
@@ -90,4 +89,18 @@ X3DTouchSensorNode .prototype = Object .assign (Object .create (X3DPointingDevic
    })(),
 });
 
+Object .defineProperties (X3DTouchSensorNode,
+{
+   typeName:
+   {
+      value: "X3DTouchSensorNode",
+      enumerable: true,
+   },
+   componentName:
+   {
+      value: "PointingDeviceSensor",
+      enumerable: true,
+   },
+});
+
 export default X3DTouchSensorNode;

package/src/x_ite/Components/PointingDeviceSensor.js

@@ -45,7 +45,6 @@
  *
  ******************************************************************************/
 
-import SupportedNodes              from "../Configuration/SupportedNodes.js";
 import CylinderSensor              from "./PointingDeviceSensor/CylinderSensor.js";
 import PlaneSensor                 from "./PointingDeviceSensor/PlaneSensor.js";
 import SphereSensor                from "./PointingDeviceSensor/SphereSensor.js";
@@ -54,25 +53,19 @@ import X3DDragSensorNode           from "./PointingDeviceSensor/X3DDragSensorNod
 import X3DPointingDeviceSensorNode from "./PointingDeviceSensor/X3DPointingDeviceSensorNode.js";
 import X3DTouchSensorNode          from "./PointingDeviceSensor/X3DTouchSensorNode.js";
 
-const Types =
-{
-   CylinderSensor: CylinderSensor,
-   PlaneSensor:    PlaneSensor,
-   SphereSensor:   SphereSensor,
-   TouchSensor:    TouchSensor,
+export default {
+   name: "PointingDeviceSensor",
+   concreteNodes:
+   [
+      CylinderSensor,
+      PlaneSensor,
+      SphereSensor,
+      TouchSensor,
+   ],
+   abstractNodes:
+   [
+      X3DDragSensorNode,
+      X3DPointingDeviceSensorNode,
+      X3DTouchSensorNode,
+   ],
 };
-
-const AbstractTypes =
-{
-   X3DDragSensorNode:           X3DDragSensorNode,
-   X3DPointingDeviceSensorNode: X3DPointingDeviceSensorNode,
-   X3DTouchSensorNode:          X3DTouchSensorNode,
-};
-
-for (const typeName in Types)
-   SupportedNodes .addNodeType (typeName, Types [typeName]);
-
-for (const typeName in AbstractTypes)
-   SupportedNodes .addAbstractNodeType (typeName, AbstractTypes [typeName]);
-
-export default undefined;

package/src/x_ite/Components/Rendering/ClipPlane.js

@@ -62,14 +62,13 @@ function ClipPlaneContainer ()
    this .plane = new Plane3 (Vector3 .Zero, Vector3 .Zero);
 }
 
-ClipPlaneContainer .prototype =
+Object .assign (ClipPlaneContainer .prototype,
 {
-   constructor: ClipPlaneContainer,
-   isClipped: function (point)
+   isClipped (point)
    {
       return this .plane .getDistanceToPoint (point) < 0;
    },
-   set: function (clipPlane, modelViewMatrix)
+   set (clipPlane, modelViewMatrix)
    {
       const
          plane      = this .plane,
@@ -80,7 +79,7 @@ ClipPlaneContainer .prototype =
 
       plane .multRight (modelViewMatrix);
    },
-   setShaderUniforms: function (gl, shaderObject)
+   setShaderUniforms (gl, shaderObject)
    {
       const
          plane  = this .plane,
@@ -88,11 +87,11 @@ ClipPlaneContainer .prototype =
 
       gl .uniform4f (shaderObject .x3d_ClipPlane [shaderObject .numClipPlanes ++], normal .x, normal .y, normal .z, plane .distanceFromOrigin);
    },
-   dispose: function ()
+   dispose ()
    {
       ClipPlanes .push (this);
    },
-};
+});
 
 function ClipPlane (executionContext)
 {
@@ -104,31 +103,9 @@ function ClipPlane (executionContext)
    this .plane   = new Vector4 (0, 0, 0, 0);
 }
 
-ClipPlane .prototype = Object .assign (Object .create (X3DChildNode .prototype),
+Object .assign (Object .setPrototypeOf (ClipPlane .prototype, X3DChildNode .prototype),
 {
-   constructor: ClipPlane,
-   [Symbol .for ("X_ITE.X3DBaseNode.fieldDefinitions")]: new FieldDefinitionArray ([
-      new X3DFieldDefinition (X3DConstants .inputOutput, "metadata", new Fields .SFNode ()),
-      new X3DFieldDefinition (X3DConstants .inputOutput, "enabled",  new Fields .SFBool (true)),
-      new X3DFieldDefinition (X3DConstants .inputOutput, "plane",    new Fields .SFVec4f (0, 1, 0, 0)),
-   ]),
-   getTypeName: function ()
-   {
-      return "ClipPlane";
-   },
-   getComponentName: function ()
-   {
-      return "Rendering";
-   },
-   getContainerField: function ()
-   {
-      return "children";
-   },
-   getSpecificationRange: function ()
-   {
-      return ["3.2", "Infinity"];
-   },
-   initialize: function ()
+   initialize ()
    {
       X3DChildNode .prototype .initialize .call (this);
 
@@ -137,13 +114,13 @@ ClipPlane .prototype = Object .assign (Object .create (X3DChildNode .prototype),
 
       this .set_enabled__ ();
    },
-   set_enabled__: function ()
+   set_enabled__ ()
    {
       this .plane .assign (this ._plane .getValue ());
 
       this .enabled = this ._enabled .getValue () && ! this .plane .equals (Vector4 .Zero);
    },
-   push: function (renderObject)
+   push (renderObject)
    {
       if (this .enabled)
       {
@@ -156,7 +133,7 @@ ClipPlane .prototype = Object .assign (Object .create (X3DChildNode .prototype),
          ++ renderObject .getLocalObjectsCount () [0];
       }
    },
-   pop: function (renderObject)
+   pop (renderObject)
    {
       if (this .enabled)
       {
@@ -167,4 +144,37 @@ ClipPlane .prototype = Object .assign (Object .create (X3DChildNode .prototype),
    },
 });
 
+Object .defineProperties (ClipPlane,
+{
+   typeName:
+   {
+      value: "ClipPlane",
+      enumerable: true,
+   },
+   componentName:
+   {
+      value: "Rendering",
+      enumerable: true,
+   },
+   containerField:
+   {
+      value: "children",
+      enumerable: true,
+   },
+   specificationRange:
+   {
+      value: Object .freeze (["3.2", "Infinity"]),
+      enumerable: true,
+   },
+   fieldDefinitions:
+   {
+      value: new FieldDefinitionArray ([
+         new X3DFieldDefinition (X3DConstants .inputOutput, "metadata", new Fields .SFNode ()),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "enabled",  new Fields .SFBool (true)),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "plane",    new Fields .SFVec4f (0, 1, 0, 0)),
+      ]),
+      enumerable: true,
+   },
+});
+
 export default ClipPlane;

package/src/x_ite/Components/Rendering/Color.js

@@ -58,30 +58,9 @@ function Color (executionContext)
    this .addType (X3DConstants .Color);
 }
 
-Color .prototype = Object .assign (Object .create (X3DColorNode .prototype),
+Object .assign (Object .setPrototypeOf (Color .prototype, X3DColorNode .prototype),
 {
-   constructor: Color,
-   [Symbol .for ("X_ITE.X3DBaseNode.fieldDefinitions")]: new FieldDefinitionArray ([
-      new X3DFieldDefinition (X3DConstants .inputOutput, "metadata", new Fields .SFNode ()),
-      new X3DFieldDefinition (X3DConstants .inputOutput, "color",    new Fields .MFColor ()),
-   ]),
-   getTypeName: function ()
-   {
-      return "Color";
-   },
-   getComponentName: function ()
-   {
-      return "Rendering";
-   },
-   getContainerField: function ()
-   {
-      return "color";
-   },
-   getSpecificationRange: function ()
-   {
-      return ["2.0", "Infinity"];
-   },
-   initialize: function ()
+   initialize ()
    {
       X3DColorNode .prototype .initialize .call (this);
 
@@ -89,12 +68,12 @@ Color .prototype = Object .assign (Object .create (X3DColorNode .prototype),
 
       this .set_color__ ();
    },
-   set_color__: function ()
+   set_color__ ()
    {
       this .color  = this ._color .getValue ();
       this .length = this ._color .length;
    },
-   addColor: function (index, array)
+   addColor (index, array)
    {
       if (index >= 0 && index < this .length)
       {
@@ -117,7 +96,7 @@ Color .prototype = Object .assign (Object .create (X3DColorNode .prototype),
          array .push (1, 1, 1, 1);
       }
    },
-   addColors: function (array, min)
+   addColors (array, min)
    {
       if (this .length)
       {
@@ -149,4 +128,36 @@ Color .prototype = Object .assign (Object .create (X3DColorNode .prototype),
    },
 });
 
+Object .defineProperties (Color,
+{
+   typeName:
+   {
+      value: "Color",
+      enumerable: true,
+   },
+   componentName:
+   {
+      value: "Rendering",
+      enumerable: true,
+   },
+   containerField:
+   {
+      value: "color",
+      enumerable: true,
+   },
+   specificationRange:
+   {
+      value: Object .freeze (["2.0", "Infinity"]),
+      enumerable: true,
+   },
+   fieldDefinitions:
+   {
+      value: new FieldDefinitionArray ([
+         new X3DFieldDefinition (X3DConstants .inputOutput, "metadata", new Fields .SFNode ()),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "color",    new Fields .MFColor ()),
+      ]),
+      enumerable: true,
+   },
+});
+
 export default Color;

package/src/x_ite/Components/Rendering/ColorRGBA.js

@@ -60,30 +60,9 @@ function ColorRGBA (executionContext)
    this .setTransparent (true);
 }
 
-ColorRGBA .prototype = Object .assign (Object .create (X3DColorNode .prototype),
+Object .assign (Object .setPrototypeOf (ColorRGBA .prototype, X3DColorNode .prototype),
 {
-   constructor: ColorRGBA,
-   [Symbol .for ("X_ITE.X3DBaseNode.fieldDefinitions")]: new FieldDefinitionArray ([
-      new X3DFieldDefinition (X3DConstants .inputOutput, "metadata", new Fields .SFNode ()),
-      new X3DFieldDefinition (X3DConstants .inputOutput, "color",    new Fields .MFColorRGBA ()),
-   ]),
-   getTypeName: function ()
-   {
-      return "ColorRGBA";
-   },
-   getComponentName: function ()
-   {
-      return "Rendering";
-   },
-   getContainerField: function ()
-   {
-      return "color";
-   },
-   getSpecificationRange: function ()
-   {
-      return ["3.0", "Infinity"];
-   },
-   initialize: function ()
+   initialize ()
    {
       X3DColorNode .prototype .initialize .call (this);
 
@@ -91,12 +70,12 @@ ColorRGBA .prototype = Object .assign (Object .create (X3DColorNode .prototype),
 
       this .set_color__ ();
    },
-   set_color__: function ()
+   set_color__ ()
    {
       this .color  = this ._color .getValue ();
       this .length = this ._color .length;
    },
-   addColor: function (index, array)
+   addColor (index, array)
    {
       if (index >= 0 && index < this .length)
       {
@@ -119,7 +98,7 @@ ColorRGBA .prototype = Object .assign (Object .create (X3DColorNode .prototype),
          array .push (1, 1, 1, 1);
       }
    },
-   addColors: function (array, min)
+   addColors (array, min)
    {
       if (this .length)
       {
@@ -152,4 +131,36 @@ ColorRGBA .prototype = Object .assign (Object .create (X3DColorNode .prototype),
    },
 });
 
+Object .defineProperties (ColorRGBA,
+{
+   typeName:
+   {
+      value: "ColorRGBA",
+      enumerable: true,
+   },
+   componentName:
+   {
+      value: "Rendering",
+      enumerable: true,
+   },
+   containerField:
+   {
+      value: "color",
+      enumerable: true,
+   },
+   specificationRange:
+   {
+      value: Object .freeze (["3.0", "Infinity"]),
+      enumerable: true,
+   },
+   fieldDefinitions:
+   {
+      value: new FieldDefinitionArray ([
+         new X3DFieldDefinition (X3DConstants .inputOutput, "metadata", new Fields .SFNode ()),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "color",    new Fields .MFColorRGBA ()),
+      ]),
+      enumerable: true,
+   },
+});
+
 export default ColorRGBA;

package/src/x_ite/Components/Rendering/Coordinate.js

@@ -60,28 +60,37 @@ function Coordinate (executionContext)
    this ._point .setUnit ("length");
 }
 
-Coordinate .prototype = Object .assign (Object .create (X3DCoordinateNode .prototype),
+Object .setPrototypeOf (Coordinate .prototype, X3DCoordinateNode .prototype);
+
+Object .defineProperties (Coordinate,
 {
-   constructor: Coordinate,
-   [Symbol .for ("X_ITE.X3DBaseNode.fieldDefinitions")]: new FieldDefinitionArray ([
-      new X3DFieldDefinition (X3DConstants .inputOutput, "metadata", new Fields .SFNode ()),
-      new X3DFieldDefinition (X3DConstants .inputOutput, "point",    new Fields .MFVec3f ()),
-   ]),
-   getTypeName: function ()
+   typeName:
+   {
+      value: "Coordinate",
+      enumerable: true,
+   },
+   componentName:
    {
-      return "Coordinate";
+      value: "Rendering",
+      enumerable: true,
    },
-   getComponentName: function ()
+   containerField:
    {
-      return "Rendering";
+      value: "coord",
+      enumerable: true,
    },
-   getContainerField: function ()
+   specificationRange:
    {
-      return "coord";
+      value: Object .freeze (["2.0", "Infinity"]),
+      enumerable: true,
    },
-   getSpecificationRange: function ()
+   fieldDefinitions:
    {
-      return ["2.0", "Infinity"];
+      value: new FieldDefinitionArray ([
+         new X3DFieldDefinition (X3DConstants .inputOutput, "metadata", new Fields .SFNode ()),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "point",    new Fields .MFVec3f ()),
+      ]),
+      enumerable: true,
    },
 });
 

package/src/x_ite/Components/Rendering/IndexedLineSet.js

@@ -64,39 +64,9 @@ function IndexedLineSet (executionContext)
    this .coordNode    = null;
 }
 
-IndexedLineSet .prototype = Object .assign (Object .create (X3DLineGeometryNode .prototype),
+Object .assign (Object .setPrototypeOf (IndexedLineSet .prototype, X3DLineGeometryNode .prototype),
 {
-   constructor: IndexedLineSet,
-   [Symbol .for ("X_ITE.X3DBaseNode.fieldDefinitions")]: new FieldDefinitionArray ([
-      new X3DFieldDefinition (X3DConstants .inputOutput,    "metadata",       new Fields .SFNode ()),
-      new X3DFieldDefinition (X3DConstants .inputOnly,      "set_colorIndex", new Fields .MFInt32 ()),
-      new X3DFieldDefinition (X3DConstants .inputOnly,      "set_coordIndex", new Fields .MFInt32 ()),
-      new X3DFieldDefinition (X3DConstants .initializeOnly, "colorPerVertex", new Fields .SFBool (true)),
-      new X3DFieldDefinition (X3DConstants .initializeOnly, "colorIndex",     new Fields .MFInt32 ()),
-      new X3DFieldDefinition (X3DConstants .initializeOnly, "coordIndex",     new Fields .MFInt32 ()),
-      new X3DFieldDefinition (X3DConstants .inputOutput,    "attrib",         new Fields .MFNode ()),
-      new X3DFieldDefinition (X3DConstants .inputOutput,    "fogCoord",       new Fields .SFNode ()),
-      new X3DFieldDefinition (X3DConstants .inputOutput,    "color",          new Fields .SFNode ()),
-      new X3DFieldDefinition (X3DConstants .inputOutput,    "normal",         new Fields .SFNode ()),
-      new X3DFieldDefinition (X3DConstants .inputOutput,    "coord",          new Fields .SFNode ()),
-   ]),
-   getTypeName: function ()
-   {
-      return "IndexedLineSet";
-   },
-   getComponentName: function ()
-   {
-      return "Rendering";
-   },
-   getContainerField: function ()
-   {
-      return "geometry";
-   },
-   getSpecificationRange: function ()
-   {
-      return ["2.0", "Infinity"];
-   },
-   initialize: function ()
+   initialize ()
    {
       X3DLineGeometryNode .prototype .initialize .call (this);
 
@@ -114,7 +84,7 @@ IndexedLineSet .prototype = Object .assign (Object .create (X3DLineGeometryNode
       this .set_normal__ ();
       this .set_coord__ ();
    },
-   set_attrib__: function ()
+   set_attrib__ ()
    {
       const attribNodes = this .getAttrib ();
 
@@ -142,7 +112,7 @@ IndexedLineSet .prototype = Object .assign (Object .create (X3DLineGeometryNode
 
       this .updateVertexArrays ();
    },
-   set_fogCoord__: function ()
+   set_fogCoord__ ()
    {
       this .fogCoordNode ?.removeInterest ("requestRebuild", this);
 
@@ -150,7 +120,7 @@ IndexedLineSet .prototype = Object .assign (Object .create (X3DLineGeometryNode
 
       this .fogCoordNode ?.addInterest ("requestRebuild", this);
    },
-   set_color__: function ()
+   set_color__ ()
    {
       this .colorNode ?.removeInterest ("requestRebuild", this);
 
@@ -160,7 +130,7 @@ IndexedLineSet .prototype = Object .assign (Object .create (X3DLineGeometryNode
 
       this .setTransparent (this .colorNode ?.isTransparent () ?? false);
    },
-   set_normal__: function ()
+   set_normal__ ()
    {
       this .normalNode ?.removeInterest ("requestRebuild", this);
 
@@ -168,7 +138,7 @@ IndexedLineSet .prototype = Object .assign (Object .create (X3DLineGeometryNode
 
       this .normalNode ?.addInterest ("requestRebuild", this);
    },
-   set_coord__: function ()
+   set_coord__ ()
    {
       this .coordNode ?.removeInterest ("requestRebuild", this);
 
@@ -176,21 +146,21 @@ IndexedLineSet .prototype = Object .assign (Object .create (X3DLineGeometryNode
 
       this .coordNode ?.addInterest ("requestRebuild", this);
    },
-   getColorPerVertexIndex: function (index)
+   getColorPerVertexIndex (index)
    {
       if (index < this ._colorIndex .length)
          return this ._colorIndex [index];
 
       return this ._coordIndex [index];
    },
-   getColorIndex: function (index)
+   getColorIndex (index)
    {
       if (index < this ._colorIndex .length)
          return this ._colorIndex [index];
 
       return index;
    },
-   getPolylineIndices: function ()
+   getPolylineIndices ()
    {
       const
          coordIndex = this ._coordIndex,
@@ -226,7 +196,7 @@ IndexedLineSet .prototype = Object .assign (Object .create (X3DLineGeometryNode
 
       return polylines;
    },
-   build: function ()
+   build ()
    {
       if (! this .coordNode || this .coordNode .isEmpty ())
          return;
@@ -290,4 +260,45 @@ IndexedLineSet .prototype = Object .assign (Object .create (X3DLineGeometryNode
    },
 });
 
+Object .defineProperties (IndexedLineSet,
+{
+   typeName:
+   {
+      value: "IndexedLineSet",
+      enumerable: true,
+   },
+   componentName:
+   {
+      value: "Rendering",
+      enumerable: true,
+   },
+   containerField:
+   {
+      value: "geometry",
+      enumerable: true,
+   },
+   specificationRange:
+   {
+      value: Object .freeze (["2.0", "Infinity"]),
+      enumerable: true,
+   },
+   fieldDefinitions:
+   {
+      value: new FieldDefinitionArray ([
+         new X3DFieldDefinition (X3DConstants .inputOutput,    "metadata",       new Fields .SFNode ()),
+         new X3DFieldDefinition (X3DConstants .inputOnly,      "set_colorIndex", new Fields .MFInt32 ()),
+         new X3DFieldDefinition (X3DConstants .inputOnly,      "set_coordIndex", new Fields .MFInt32 ()),
+         new X3DFieldDefinition (X3DConstants .initializeOnly, "colorPerVertex", new Fields .SFBool (true)),
+         new X3DFieldDefinition (X3DConstants .initializeOnly, "colorIndex",     new Fields .MFInt32 ()),
+         new X3DFieldDefinition (X3DConstants .initializeOnly, "coordIndex",     new Fields .MFInt32 ()),
+         new X3DFieldDefinition (X3DConstants .inputOutput,    "attrib",         new Fields .MFNode ()),
+         new X3DFieldDefinition (X3DConstants .inputOutput,    "fogCoord",       new Fields .SFNode ()),
+         new X3DFieldDefinition (X3DConstants .inputOutput,    "color",          new Fields .SFNode ()),
+         new X3DFieldDefinition (X3DConstants .inputOutput,    "normal",         new Fields .SFNode ()),
+         new X3DFieldDefinition (X3DConstants .inputOutput,    "coord",          new Fields .SFNode ()),
+      ]),
+      enumerable: true,
+   },
+});
+
 export default IndexedLineSet;