Only BufferGeometry is supported.
Every BufferGeometry helper (e.g. BoxBufferGeometry) has
been renamed to shorter name (e.g. BoxGeometry)

As it leverages many deprecated methods

replace with copy() + invert()

critical and high vulnerabilities were caused by dependencies
related with Jest

Previous code was setting `_position` to an empty array.
This was causing some bugs where the _position array was not filled
with the proper values and remained empty.

`ALPHATEST` was previously used as a flag and a value in three.js `alphatest_fragment` chunk.
It was superseded by the `USE_ALPHATEST` flag and the `alphaTest` value passed as a uniform.
The declaration of the `alphaTest` uniform is made in the `alphatest_pars_fragment` chunk.

A SpotLight must have its distance set in real world coordinates.
This was resulting in very dark scenes, where the position of the light or its intensity must take into account the bounding box.
Directional Lights do not require this settings. They light the scene in a uniform manner from afar.

3.14 is the value recommanded in Three.js documentation when converting colorspaces
Ambient intensity of 1 is the default.

By default the outputColorSpace is set to rgb.
Internal colors are set to linear rgb space.
`compositeMaterial` derives from custom ShaderMaterial. Correct color depends on the `colorspace_fragment` chunk beign executed in the corresponding fragment shader.

original value was 0.2.
Recommended multiplicator is PI and 0.63 seems to give comparable results with the previous version.

The pattern here is that when a color is set as a string or an hex number, it requires conversion from RGB to linear.
On contrary, if a color is set via a Color object, it is assumed that this one is already encoded in linear color space.

Because we are now using Three.js defaults

ColorMakers are called when creating BufferArrays to populate the `color` uniform.
4 methods can be applied (atomColorToArray, bondColorToArray, volumeColorToArray, positionColorToArray).
Each of these, calls a related method (e.g. `atomColor`) to get a color that is defined in RGB Colorspace, encoded as an integer between 0 and 2**24.
This color is then converted to a tuple of 3 values which are passed along all the other vertices colors to the shaders codes as a uniform.
Prior code was using a decorator to convert the output color of each coloring function, to linear space and then to hex.
This hex value was then later processed to be split and normalized in the array buffer.
The change here makes the linearization at the last step, after the normalization which should avoid clamping due to the double conversion that was happening previously

A banding effect was due to a loss of precision when copying the texture between render targets as linear encoding requires more precision.

It seems the relative units might have changed between the camera and the point of focus.
Pushing the fog near plane further back, seems to visually match with previous version results.