x_ite 8.7.8 → 8.8.0

package/src/assets/components/TextureProjector.js

@@ -50,17 +50,17 @@ import TextureProjector         from "../../x_ite/Components/TextureProjector/Te
 import TextureProjectorParallel from "../../x_ite/Components/TextureProjector/TextureProjectorParallel.js";
 import X3DTextureProjectorNode  from "../../x_ite/Components/TextureProjector/X3DTextureProjectorNode.js";
 
-Components .addComponent ({
+Components .add ({
    name: "TextureProjector",
-   types:
-   {
-      TextureProjector:         TextureProjector,
-      TextureProjectorParallel: TextureProjectorParallel,
-   },
-   abstractTypes:
-   {
-      X3DTextureProjectorNode: X3DTextureProjectorNode,
-   },
+   concreteNodes:
+   [
+      TextureProjector,
+      TextureProjectorParallel,
+   ],
+   abstractNodes:
+   [
+      X3DTextureProjectorNode,
+   ],
 });
 
 export default undefined;

package/src/assets/components/Texturing3D.js

@@ -56,23 +56,23 @@ import TextureTransform3D       from "../../x_ite/Components/Texturing3D/Texture
 import TextureTransformMatrix3D from "../../x_ite/Components/Texturing3D/TextureTransformMatrix3D.js";
 import X3DTexture3DNode         from "../../x_ite/Components/Texturing3D/X3DTexture3DNode.js";
 
-Components .addComponent ({
+Components .add ({
    name: "Texturing3D",
-   types:
-   {
-      ComposedTexture3D:        ComposedTexture3D,
-      ImageTexture3D:           ImageTexture3D,
-      ImageTextureAtlas:        ImageTextureAtlas, // non-standard
-      PixelTexture3D:           PixelTexture3D,
-      TextureCoordinate3D:      TextureCoordinate3D,
-      TextureCoordinate4D:      TextureCoordinate4D,
-      TextureTransform3D:       TextureTransform3D,
-      TextureTransformMatrix3D: TextureTransformMatrix3D,
-   },
-   abstractTypes:
-   {
-      X3DTexture3DNode: X3DTexture3DNode, // Not implemented yet.
-   },
+   concreteNodes:
+   [
+      ComposedTexture3D,
+      ImageTexture3D,
+      ImageTextureAtlas, // non-standard
+      PixelTexture3D,
+      TextureCoordinate3D,
+      TextureCoordinate4D,
+      TextureTransform3D,
+      TextureTransformMatrix3D,
+   ],
+   abstractNodes:
+   [
+      X3DTexture3DNode,
+   ],
 });
 
 export default undefined;

package/src/assets/components/VolumeRendering.js

@@ -64,30 +64,30 @@ import X3DComposableVolumeRenderStyleNode from "../../x_ite/Components/VolumeRen
 import X3DVolumeDataNode                  from "../../x_ite/Components/VolumeRendering/X3DVolumeDataNode.js";
 import X3DVolumeRenderStyleNode           from "../../x_ite/Components/VolumeRendering/X3DVolumeRenderStyleNode.js";
 
-Components .addComponent ({
+Components .add ({
    name: "VolumeRendering",
-   types:
-   {
-      BlendedVolumeStyle:               BlendedVolumeStyle,
-      BoundaryEnhancementVolumeStyle:   BoundaryEnhancementVolumeStyle,
-      CartoonVolumeStyle:               CartoonVolumeStyle,
-      ComposedVolumeStyle:              ComposedVolumeStyle,
-      EdgeEnhancementVolumeStyle:       EdgeEnhancementVolumeStyle,
-      IsoSurfaceVolumeData:             IsoSurfaceVolumeData,
-      OpacityMapVolumeStyle:            OpacityMapVolumeStyle,
-      ProjectionVolumeStyle:            ProjectionVolumeStyle,
-      SegmentedVolumeData:              SegmentedVolumeData,
-      ShadedVolumeStyle:                ShadedVolumeStyle,
-      SilhouetteEnhancementVolumeStyle: SilhouetteEnhancementVolumeStyle,
-      ToneMappedVolumeStyle:            ToneMappedVolumeStyle,
-      VolumeData:                       VolumeData,
-   },
-   abstractTypes:
-   {
-      X3DComposableVolumeRenderStyleNode: X3DComposableVolumeRenderStyleNode,
-      X3DVolumeDataNode:                  X3DVolumeDataNode,
-      X3DVolumeRenderStyleNode:           X3DVolumeRenderStyleNode,
-   },
+   concreteNodes:
+   [
+      BlendedVolumeStyle,
+      BoundaryEnhancementVolumeStyle,
+      CartoonVolumeStyle,
+      ComposedVolumeStyle,
+      EdgeEnhancementVolumeStyle,
+      IsoSurfaceVolumeData,
+      OpacityMapVolumeStyle,
+      ProjectionVolumeStyle,
+      SegmentedVolumeData,
+      ShadedVolumeStyle,
+      SilhouetteEnhancementVolumeStyle,
+      ToneMappedVolumeStyle,
+      VolumeData,
+   ],
+   abstractNodes:
+   [
+      X3DComposableVolumeRenderStyleNode,
+      X3DVolumeDataNode,
+      X3DVolumeRenderStyleNode,
+   ],
    browserContext: X3DVolumeRenderingContext,
 });
 

package/src/assets/components/X_ITE.js

@@ -48,14 +48,15 @@
 import Components from "../../x_ite/Components.js";
 import BlendMode  from "../../x_ite/Components/X_ITE/BlendMode.js";
 
-Components .addComponent ({
+Components .add ({
    name: "X_ITE",
-   types:
-   {
-      BlendMode: BlendMode,
-   },
-   abstractTypes:
-   { },
+   concreteNodes:
+   [
+      BlendMode,
+   ],
+   abstractNodes:
+   [
+   ],
 });
 
 export default undefined;

package/src/assets/shaders/webgl1/include/Shadow.glsl.js

@@ -245,21 +245,19 @@ getShadowIntensity (const in int index, const in x3d_LightSourceParameters light
          if (any (greaterThan (abs (shadowCoord .xy - 0.5), vec2 (0.5))))
             return 0.0;
 
-         float dx0 = - texelSize .x;
-         float dy0 = - texelSize .y;
-         float dx1 = + texelSize .x;
-         float dy1 = + texelSize .y;
+         vec2 d0 = - texelSize;
+         vec2 d1 =   texelSize;
 
          float value = (
-            texture2DCompare (index, shadowCoord .xy + vec2 (dx0, dy0), shadowCoord .z) +
-            texture2DCompare (index, shadowCoord .xy + vec2 (0.0, dy0), shadowCoord .z) +
-            texture2DCompare (index, shadowCoord .xy + vec2 (dx1, dy0), shadowCoord .z) +
-            texture2DCompare (index, shadowCoord .xy + vec2 (dx0, 0.0), shadowCoord .z) +
+            texture2DCompare (index, shadowCoord .xy + d0,                  shadowCoord .z) +
+            texture2DCompare (index, shadowCoord .xy + vec2 (0.0,   d0 .y), shadowCoord .z) +
+            texture2DCompare (index, shadowCoord .xy + vec2 (d1 .x, d0 .y), shadowCoord .z) +
+            texture2DCompare (index, shadowCoord .xy + vec2 (d0 .x, 0.0),   shadowCoord .z) +
             texture2DCompare (index, shadowCoord .xy, shadowCoord .z) +
-            texture2DCompare (index, shadowCoord .xy + vec2 (dx1, 0.0), shadowCoord .z) +
-            texture2DCompare (index, shadowCoord .xy + vec2 (dx0, dy1), shadowCoord .z) +
-            texture2DCompare (index, shadowCoord .xy + vec2 (0.0, dy1), shadowCoord .z) +
-            texture2DCompare (index, shadowCoord .xy + vec2 (dx1, dy1), shadowCoord .z)
+            texture2DCompare (index, shadowCoord .xy + vec2 (d1 .x, 0.0),   shadowCoord .z) +
+            texture2DCompare (index, shadowCoord .xy + vec2 (d0 .x, d1 .y), shadowCoord .z) +
+            texture2DCompare (index, shadowCoord .xy + vec2 (0.0,   d1 .y), shadowCoord .z) +
+            texture2DCompare (index, shadowCoord .xy + d1,                  shadowCoord .z)
          ) * (1.0 / 9.0);
 
          return light .shadowIntensity * value;
@@ -275,22 +273,20 @@ getShadowIntensity (const in int index, const in x3d_LightSourceParameters light
          if (any (greaterThan (abs (shadowCoord .xy - 0.5), vec2 (0.5))))
             return 0.0;
 
-         float dx0 = - texelSize.x;
-         float dy0 = - texelSize.y;
-         float dx1 = + texelSize.x;
-         float dy1 = + texelSize.y;
+         vec2 d0 = - texelSize;
+         vec2 d1 =   texelSize;
 
          float value = (
-            texture2DShadowLerp (index, texelSize, float (shadowMapSize), shadowCoord .xy + vec2 (dx0, dy0), shadowCoord .z) +
-            texture2DShadowLerp (index, texelSize, float (shadowMapSize), shadowCoord .xy + vec2 (0.0, dy0), shadowCoord .z) +
-            texture2DShadowLerp (index, texelSize, float (shadowMapSize), shadowCoord .xy + vec2 (dx1, dy0), shadowCoord .z) +
-            texture2DShadowLerp (index, texelSize, float (shadowMapSize), shadowCoord .xy + vec2 (dx0, 0.0), shadowCoord .z) +
+            texture2DShadowLerp (index, texelSize, float (shadowMapSize), shadowCoord .xy + d0,                  shadowCoord .z) +
+            texture2DShadowLerp (index, texelSize, float (shadowMapSize), shadowCoord .xy + vec2 (0.0,   d0 .y), shadowCoord .z) +
+            texture2DShadowLerp (index, texelSize, float (shadowMapSize), shadowCoord .xy + vec2 (d1 .x, d0 .y), shadowCoord .z) +
+            texture2DShadowLerp (index, texelSize, float (shadowMapSize), shadowCoord .xy + vec2 (d0 .x, 0.0),   shadowCoord .z) +
             texture2DShadowLerp (index, texelSize, float (shadowMapSize), shadowCoord .xy, shadowCoord .z) +
-            texture2DShadowLerp (index, texelSize, float (shadowMapSize), shadowCoord .xy + vec2 (dx1, 0.0), shadowCoord .z) +
-            texture2DShadowLerp (index, texelSize, float (shadowMapSize), shadowCoord .xy + vec2 (dx0, dy1), shadowCoord .z) +
-            texture2DShadowLerp (index, texelSize, float (shadowMapSize), shadowCoord .xy + vec2 (0.0, dy1), shadowCoord .z) +
-            texture2DShadowLerp (index, texelSize, float (shadowMapSize), shadowCoord .xy + vec2 (dx1, dy1), shadowCoord .z)
-         ) * ( 1.0 / 9.0 );
+            texture2DShadowLerp (index, texelSize, float (shadowMapSize), shadowCoord .xy + vec2 (d1 .x, 0.0),   shadowCoord .z) +
+            texture2DShadowLerp (index, texelSize, float (shadowMapSize), shadowCoord .xy + vec2 (d0 .x, d1 .y), shadowCoord .z) +
+            texture2DShadowLerp (index, texelSize, float (shadowMapSize), shadowCoord .xy + vec2 (0.0, d1 .y),   shadowCoord .z) +
+            texture2DShadowLerp (index, texelSize, float (shadowMapSize), shadowCoord .xy + d1,                  shadowCoord .z)
+         ) * (1.0 / 9.0);
 
          return light .shadowIntensity * value;
 

package/src/assets/shaders/webgl2/include/Shadow.glsl.js

@@ -259,21 +259,19 @@ getShadowIntensity (const in int index, const in x3d_LightSourceParameters light
          if (any (greaterThan (abs (shadowCoord .xy - 0.5), vec2 (0.5))))
             return 0.0;
 
-         float dx0 = - texelSize .x;
-         float dy0 = - texelSize .y;
-         float dx1 = + texelSize .x;
-         float dy1 = + texelSize .y;
+         vec2 d0 = - texelSize;
+         vec2 d1 =   texelSize;
 
          float value = (
-            texture2DCompare (index, shadowCoord .xy + vec2 (dx0, dy0), shadowCoord .z) +
-            texture2DCompare (index, shadowCoord .xy + vec2 (0.0, dy0), shadowCoord .z) +
-            texture2DCompare (index, shadowCoord .xy + vec2 (dx1, dy0), shadowCoord .z) +
-            texture2DCompare (index, shadowCoord .xy + vec2 (dx0, 0.0), shadowCoord .z) +
-            texture2DCompare (index, shadowCoord .xy, shadowCoord .z) +
-            texture2DCompare (index, shadowCoord .xy + vec2 (dx1, 0.0), shadowCoord .z) +
-            texture2DCompare (index, shadowCoord .xy + vec2 (dx0, dy1), shadowCoord .z) +
-            texture2DCompare (index, shadowCoord .xy + vec2 (0.0, dy1), shadowCoord .z) +
-            texture2DCompare (index, shadowCoord .xy + vec2 (dx1, dy1), shadowCoord .z)
+            texture2DCompare (index, shadowCoord .xy + d0,                  shadowCoord .z) +
+            texture2DCompare (index, shadowCoord .xy + vec2 (0.0,   d0 .y), shadowCoord .z) +
+            texture2DCompare (index, shadowCoord .xy + vec2 (d1 .x, d0 .y), shadowCoord .z) +
+            texture2DCompare (index, shadowCoord .xy + vec2 (d0 .x, 0.0),   shadowCoord .z) +
+            texture2DCompare (index, shadowCoord .xy,                       shadowCoord .z) +
+            texture2DCompare (index, shadowCoord .xy + vec2 (d1 .x, 0.0),   shadowCoord .z) +
+            texture2DCompare (index, shadowCoord .xy + vec2 (d0 .x, d1 .y), shadowCoord .z) +
+            texture2DCompare (index, shadowCoord .xy + vec2 (0.0,   d1 .y), shadowCoord .z) +
+            texture2DCompare (index, shadowCoord .xy + d1,                  shadowCoord .z)
          ) * (1.0 / 9.0);
 
          return light .shadowIntensity * value;
@@ -289,22 +287,20 @@ getShadowIntensity (const in int index, const in x3d_LightSourceParameters light
          if (any (greaterThan (abs (shadowCoord .xy - 0.5), vec2 (0.5))))
             return 0.0;
 
-         float dx0 = - texelSize.x;
-         float dy0 = - texelSize.y;
-         float dx1 = + texelSize.x;
-         float dy1 = + texelSize.y;
+         vec2 d0 = - texelSize;
+         vec2 d1 =   texelSize;
 
          float value = (
-            texture2DShadowLerp (index, texelSize, float (shadowMapSize), shadowCoord .xy + vec2 (dx0, dy0), shadowCoord .z) +
-            texture2DShadowLerp (index, texelSize, float (shadowMapSize), shadowCoord .xy + vec2 (0.0, dy0), shadowCoord .z) +
-            texture2DShadowLerp (index, texelSize, float (shadowMapSize), shadowCoord .xy + vec2 (dx1, dy0), shadowCoord .z) +
-            texture2DShadowLerp (index, texelSize, float (shadowMapSize), shadowCoord .xy + vec2 (dx0, 0.0), shadowCoord .z) +
-            texture2DShadowLerp (index, texelSize, float (shadowMapSize), shadowCoord .xy, shadowCoord .z) +
-            texture2DShadowLerp (index, texelSize, float (shadowMapSize), shadowCoord .xy + vec2 (dx1, 0.0), shadowCoord .z) +
-            texture2DShadowLerp (index, texelSize, float (shadowMapSize), shadowCoord .xy + vec2 (dx0, dy1), shadowCoord .z) +
-            texture2DShadowLerp (index, texelSize, float (shadowMapSize), shadowCoord .xy + vec2 (0.0, dy1), shadowCoord .z) +
-            texture2DShadowLerp (index, texelSize, float (shadowMapSize), shadowCoord .xy + vec2 (dx1, dy1), shadowCoord .z)
-         ) * ( 1.0 / 9.0 );
+            texture2DShadowLerp (index, texelSize, float (shadowMapSize), shadowCoord .xy + d0,                  shadowCoord .z) +
+            texture2DShadowLerp (index, texelSize, float (shadowMapSize), shadowCoord .xy + vec2 (0.0,   d0 .y), shadowCoord .z) +
+            texture2DShadowLerp (index, texelSize, float (shadowMapSize), shadowCoord .xy + vec2 (d1 .x, d0 .y), shadowCoord .z) +
+            texture2DShadowLerp (index, texelSize, float (shadowMapSize), shadowCoord .xy + vec2 (d0 .x, 0.0),   shadowCoord .z) +
+            texture2DShadowLerp (index, texelSize, float (shadowMapSize), shadowCoord .xy,                       shadowCoord .z) +
+            texture2DShadowLerp (index, texelSize, float (shadowMapSize), shadowCoord .xy + vec2 (d1 .x, 0.0),   shadowCoord .z) +
+            texture2DShadowLerp (index, texelSize, float (shadowMapSize), shadowCoord .xy + vec2 (d0 .x, d1 .y), shadowCoord .z) +
+            texture2DShadowLerp (index, texelSize, float (shadowMapSize), shadowCoord .xy + vec2 (0.0,   d1 .y), shadowCoord .z) +
+            texture2DShadowLerp (index, texelSize, float (shadowMapSize), shadowCoord .xy + d1,                  shadowCoord .z)
+         ) * (1.0 / 9.0);
 
          return light .shadowIntensity * value;
 

package/src/bookmarks.js

@@ -56,7 +56,7 @@ const Bookmarks = (function ()
       this .element = element;
    }
 
-   Bookmarks .prototype =
+   Object .assign (Bookmarks .prototype,
    {
       setup: function (array)
       {
@@ -152,7 +152,7 @@ const Bookmarks = (function ()
 
          console .log (`Scene loaded in ${loadTime .toPrecision (3)}s.`)
       },
-   };
+   });
 
    return Bookmarks;
 }) ();

package/src/lib/jquery.js

@@ -1,39 +1,51 @@
-$.decodeText = function (input)
+Object .assign ($,
 {
-   if (typeof input === "string")
-      return input;
-
-   return new TextDecoder () .decode (input);
-};
+   decodeText (input)
+   {
+      if (typeof input === "string")
+         return input;
 
-$.ungzip = function (arrayBuffer)
-{
-   try
+      return new TextDecoder () .decode (input);
+   },
+   ungzip (arrayBuffer)
    {
-      return pako .ungzip (arrayBuffer, { to: "raw" }) .buffer;
-   }
-   catch (exception)
+      try
+      {
+         return pako .ungzip (arrayBuffer, { to: "raw" }) .buffer;
+      }
+      catch (exception)
+      {
+         return arrayBuffer;
+      }
+   },
+   toLowerCaseFirst (string)
    {
-      return arrayBuffer;
-   }
-};
-
-$.toLowerCaseFirst = function (string)
-{
-   return string [0] .toLowerCase () + string .slice (1);
-};
+      return string [0] .toLowerCase () + string .slice (1);
+   },
+   try (callback)
+   {
+      try { return callback () } catch { }
+   },
+   enum (object, property, defaultValue)
+   {
+      return object .hasOwnProperty (property) ? object [property] : defaultValue;
+   },
+});
 
-$.fn.isInViewport = function ()
+Object .assign ($.fn,
 {
-   const
-      $this          = $(this),
-      $window        = $(window),
-      elementTop     = $this .offset () .top,
-      elementBottom  = elementTop + $this .outerHeight (),
-      viewportTop    = $window .scrollTop (),
-      viewportBottom = viewportTop + $window .height ();
+   isInViewport ()
+   {
+      const
+         $this          = $(this),
+         $window        = $(window),
+         elementTop     = $this .offset () .top,
+         elementBottom  = elementTop + $this .outerHeight (),
+         viewportTop    = $window .scrollTop (),
+         viewportBottom = viewportTop + $window .height ();
 
-   return elementBottom > viewportTop && elementTop < viewportBottom;
-};
+      return elementBottom > viewportTop && elementTop < viewportBottom;
+   },
+});
 
 export default $;

package/src/standard/Geospatial/Geodetic.js

@@ -63,10 +63,9 @@ function Geodetic (spheroid, latitudeFirst, radians)
    this .ecc2           = 1 - this .c2a2;
 }
 
-Geodetic .prototype =
+Object .assign (Geodetic .prototype,
 {
-   constructor: Geodetic,
-   convert: function (geodetic, result)
+   convert (geodetic, result)
    {
       const elevation = geodetic .z;
 
@@ -91,7 +90,7 @@ Geodetic .prototype =
 
       return this .convertRadians (latitude, longitude, elevation, result);
    },
-   convertRadians: function (latitude, longitude, elevation, result)
+   convertRadians (latitude, longitude, elevation, result)
    {
       const
          slat  = Math .sin (latitude),
@@ -104,7 +103,7 @@ Geodetic .prototype =
                           Nhl * Math .sin (longitude),
                           (N * this .c2a2 + elevation) * slat);
    },
-   apply: function (geocentric, result)
+   apply (geocentric, result)
    {
       this .applyRadians (geocentric, result);
 
@@ -124,7 +123,7 @@ Geodetic .prototype =
 
       return result;
    },
-   applyRadians: function (geocentric, result)
+   applyRadians (geocentric, result)
    {
       const
          x = geocentric .x,
@@ -166,7 +165,7 @@ Geodetic .prototype =
 
       return result .set (latitude, longitude, elevation);
    },
-   normal: function (geocentric, result)
+   normal (geocentric, result)
    {
       const geodetic = this .applyRadians (geocentric, result);
 
@@ -184,7 +183,7 @@ Geodetic .prototype =
       return result .set (nx, ny, nz);
    },
    /*
-   lerp: function (s, d, t)
+   lerp (s, d, t)
    {
       var
          source     =  this .source      .assign (s),
@@ -253,6 +252,6 @@ Geodetic .prototype =
    source: new Vector3 (0, 0, 0),
    destination: new Vector3 (0, 0, 0),
    */
-};
+});
 
 export default Geodetic;

package/src/standard/Geospatial/UniversalTransverseMercator.js

@@ -84,10 +84,9 @@ function UniversalTransverseMercator (spheroid, zone, northernHemisphere, northi
    this .geodeticConverter  = new Geodetic (spheroid, true, true);
 }
 
-UniversalTransverseMercator .prototype =
+Object .assign (UniversalTransverseMercator .prototype,
 {
-   constructor: UniversalTransverseMercator,
-   convert: function (utm, result)
+   convert (utm, result)
    {
       // https://gist.github.com/duedal/840476
 
@@ -150,7 +149,7 @@ UniversalTransverseMercator .prototype =
 
       return this .geodeticConverter .convertRadians (latitude, longitude, utm .z, result);
    },
-   apply: function (geocentric, result)
+   apply (geocentric, result)
    {
       // https://gist.github.com/duedal/840476
 
@@ -201,6 +200,6 @@ UniversalTransverseMercator .prototype =
 
       return result .set (northing, easting, geodetic .z);
    },
-};
+});
 
 export default UniversalTransverseMercator;

package/src/standard/Math/Algorithm.js

@@ -45,35 +45,30 @@
  *
  ******************************************************************************/
 
-export default class Algorithm
+const Algorithm =
 {
-   static radians (value)
+   radians (value)
    {
       return value * (Math .PI / 180);
-   }
-
-   static degrees (value)
+   },
+   degrees (value)
    {
       return value * (180 / Math .PI);
-   }
-
-   static random (min, max)
+   },
+   random (min, max)
    {
       return min + Math .random () * (max - min);
-   }
-
-   static fract (value)
+   },
+   fract (value)
    {
       return value % 1;
-   }
-
-   static clamp (value, min, max)
+   },
+   clamp (value, min, max)
    {
       // https://registry.khronos.org/OpenGL-Refpages/gl4/html/clamp.xhtml
       return Math .min (Math .max (value, min), max);
-   }
-
-   static interval (value, low, high)
+   },
+   interval (value, low, high)
    {
       if (value >= high)
          return ((value - low) % (high - low)) + low;
@@ -82,14 +77,12 @@ export default class Algorithm
          return ((value - high) % (high - low)) + high;
 
       return value;
-   }
-
-   static lerp (source, destination, t)
+   },
+   lerp (source, destination, t)
    {
       return source + t * (destination - source);
-   }
-
-   static slerp (source, destination, t)
+   },
+   slerp (source, destination, t)
    {
       let cosom = source .dot (destination);
 
@@ -117,9 +110,8 @@ export default class Algorithm
       source .w = source .w * scale0 + destination .w * scale1;
 
       return source;
-   }
-
-   static simpleSlerp (source, destination, t)
+   },
+   simpleSlerp (source, destination, t)
    {
       const cosom = source .dot (destination);
 
@@ -140,36 +132,31 @@ export default class Algorithm
       source .w = source .w * scale0 + destination .w * scale1;
 
       return source;
-   }
-
-   static isPowerOfTwo (n)
+   },
+   isPowerOfTwo (n)
    {
       return ((n - 1) & n) === 0;
-   }
-
-   static nextPowerOfTwo (n)
+   },
+   nextPowerOfTwo (n)
    {
       ///  Returns the next power of two of @a n. If n is a power of two, n is returned.
 
-      if (this .isPowerOfTwo (n))
+      if (Algorithm .isPowerOfTwo (n))
          return n;
 
       return 1 << (32 - Math .clz32 (n));
-   }
-
-   static bitCount (n)
+   },
+   bitCount (n)
    {
       n = n - ((n >>> 1) & 0x55555555);
       n = (n & 0x33333333) + ((n >>> 2) & 0x33333333);
       return ((n + (n >>> 4) & 0xF0F0F0F) * 0x1010101) >>> 24;
-   }
-
-   static cmp (lhs, rhs)
+   },
+   cmp (lhs, rhs)
    {
       return lhs > rhs ? 1 : lhs < rhs ? -1 : 0;
-   }
-
-   // static lexicographicallyCompare (lhs, rhs)
+   },
+   // lexicographicallyCompare (lhs, rhs)
    // {
    //    const
    //       length1 = lhs .length,
@@ -185,19 +172,16 @@ export default class Algorithm
    //    }
 
    //    return Algorithm .cmp (length1, length2);
-   // }
-
-   static less (lhs, rhs)
+   // },
+   less (lhs, rhs)
    {
       return lhs < rhs;
-   }
-
-   static greater (lhs, rhs)
+   },
+   greater (lhs, rhs)
    {
       return lhs > rhs;
-   }
-
-   static lowerBound (array, first, last, value, comp = this.less)
+   },
+   lowerBound (array, first, last, value, comp = Algorithm.less)
    {
       // https://en.cppreference.com/w/cpp/algorithm/lower_bound
 
@@ -221,9 +205,8 @@ export default class Algorithm
       }
 
       return first;
-   }
-
-   static upperBound (array, first, last, value, comp = this.less)
+   },
+   upperBound (array, first, last, value, comp = Algorithm.less)
    {
       // sen.cppreference.com/w/cpp/algorithm/upper_bound
 
@@ -248,5 +231,7 @@ export default class Algorithm
       }
 
       return first;
-   }
-}
+   },
+};
+
+export default Algorithm;