@woosh/meep-engine 2.62.0 → 2.64.0

package/build/meep.module.js

@@ -53506,8 +53506,8 @@ class Vector2 {
      * @returns {number}
      */
     hash() {
-        const x = Math.sin(this.x) * 1367130550;
-        const y = Math.sin(this.y) * 1367130550;
+        const x = computeHashFloat(this.x);
+        const y = computeHashFloat(this.y);
 
         let hash = ((x << 5) - x) + y;
 
@@ -53644,6 +53644,7 @@ Vector2.one = Object.freeze(new Vector2(1, 1));
  * @type {boolean}
  */
 Vector2.prototype.isVector2 = true;
+
 /**
  *
  * @param {number} x0
@@ -55588,79 +55589,314 @@ ObservedValue.prototype.fromJSON = function (value) {
     this.set(value);
 };
 
-/**
- * Created by Alex on 28/01/2017.
- */
-
-function prepareObject(object) {
-    //turn off automatic matrix re-calculations each frame
-    object.matrixAutoUpdate = false;
-    //disable frustum culling
-    object.frustumCulled = false;
-}
-
-/**
- *
- * @param {BufferGeometry} [geometry]
- * @param {Material} [material]
- * @returns {Mesh}
- */
-function createMesh(geometry, material) {
-    const result = new Mesh(geometry, material);
-
-    prepareObject(result);
-
-    return result;
-}
-
-/**
- *
- * @param {BufferGeometry} geometry
- * @param {THREE.Material} material
- * @returns {THREE.SkinnedMesh}
- */
-function createSkinnedMesh(geometry, material) {
-    const result = new SkinnedMesh(geometry, material);
-
-    prepareObject(result);
-
-    return result;
-}
-
-/**
- *
- * @param {Material} material
- */
-function prepareMaterial(material) {
-
-    //make shadows render from front side, this avoids artifacts due to gaps in geometry that can't be seen from the front
-    material.shadowSide = DoubleSide;
-
-    if (typeof material.envMapIntensity === 'number' && material.envMapIntensity !== 1) {
-        // make material react to environment map in the same way as others
-        material.envMapIntensity = 1;
-    }
-}
-
-/**
- *
- * @returns {Group}
- */
-function createGroup() {
-    const result = new Group();
-
-    prepareObject(result);
-
-    return result;
-}
-
-var ThreeFactory = {
-    createMesh,
-    createSkinnedMesh,
-    createGroup,
-    prepareMaterial
+/**
+ * Common utilities
+ * @module glMatrix
+ */
+var ARRAY_TYPE = typeof Float32Array !== 'undefined' ? Float32Array : Array;
+if (!Math.hypot) Math.hypot = function () {
+  var y = 0,
+      i = arguments.length;
+
+  while (i--) {
+    y += arguments[i] * arguments[i];
+  }
+
+  return Math.sqrt(y);
 };
 
+/**
+ * 4x4 Matrix<br>Format: column-major, when typed out it looks like row-major<br>The matrices are being post multiplied.
+ * @module mat4
+ */
+
+/**
+ * Creates a new identity mat4
+ *
+ * @returns {mat4} a new 4x4 matrix
+ */
+
+function create$1() {
+  var out = new ARRAY_TYPE(16);
+
+  if (ARRAY_TYPE != Float32Array) {
+    out[1] = 0;
+    out[2] = 0;
+    out[3] = 0;
+    out[4] = 0;
+    out[6] = 0;
+    out[7] = 0;
+    out[8] = 0;
+    out[9] = 0;
+    out[11] = 0;
+    out[12] = 0;
+    out[13] = 0;
+    out[14] = 0;
+  }
+
+  out[0] = 1;
+  out[5] = 1;
+  out[10] = 1;
+  out[15] = 1;
+  return out;
+}
+/**
+ * Copy the values from one mat4 to another
+ *
+ * @param {mat4} out the receiving matrix
+ * @param {ReadonlyMat4} a the source matrix
+ * @returns {mat4} out
+ */
+
+function copy(out, a) {
+  out[0] = a[0];
+  out[1] = a[1];
+  out[2] = a[2];
+  out[3] = a[3];
+  out[4] = a[4];
+  out[5] = a[5];
+  out[6] = a[6];
+  out[7] = a[7];
+  out[8] = a[8];
+  out[9] = a[9];
+  out[10] = a[10];
+  out[11] = a[11];
+  out[12] = a[12];
+  out[13] = a[13];
+  out[14] = a[14];
+  out[15] = a[15];
+  return out;
+}
+/**
+ * Inverts a mat4
+ *
+ * @param {mat4} out the receiving matrix
+ * @param {ReadonlyMat4} a the source matrix
+ * @returns {mat4} out
+ */
+
+function invert(out, a) {
+  var a00 = a[0],
+      a01 = a[1],
+      a02 = a[2],
+      a03 = a[3];
+  var a10 = a[4],
+      a11 = a[5],
+      a12 = a[6],
+      a13 = a[7];
+  var a20 = a[8],
+      a21 = a[9],
+      a22 = a[10],
+      a23 = a[11];
+  var a30 = a[12],
+      a31 = a[13],
+      a32 = a[14],
+      a33 = a[15];
+  var b00 = a00 * a11 - a01 * a10;
+  var b01 = a00 * a12 - a02 * a10;
+  var b02 = a00 * a13 - a03 * a10;
+  var b03 = a01 * a12 - a02 * a11;
+  var b04 = a01 * a13 - a03 * a11;
+  var b05 = a02 * a13 - a03 * a12;
+  var b06 = a20 * a31 - a21 * a30;
+  var b07 = a20 * a32 - a22 * a30;
+  var b08 = a20 * a33 - a23 * a30;
+  var b09 = a21 * a32 - a22 * a31;
+  var b10 = a21 * a33 - a23 * a31;
+  var b11 = a22 * a33 - a23 * a32; // Calculate the determinant
+
+  var det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
+
+  if (!det) {
+    return null;
+  }
+
+  det = 1.0 / det;
+  out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det;
+  out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * det;
+  out[2] = (a31 * b05 - a32 * b04 + a33 * b03) * det;
+  out[3] = (a22 * b04 - a21 * b05 - a23 * b03) * det;
+  out[4] = (a12 * b08 - a10 * b11 - a13 * b07) * det;
+  out[5] = (a00 * b11 - a02 * b08 + a03 * b07) * det;
+  out[6] = (a32 * b02 - a30 * b05 - a33 * b01) * det;
+  out[7] = (a20 * b05 - a22 * b02 + a23 * b01) * det;
+  out[8] = (a10 * b10 - a11 * b08 + a13 * b06) * det;
+  out[9] = (a01 * b08 - a00 * b10 - a03 * b06) * det;
+  out[10] = (a30 * b04 - a31 * b02 + a33 * b00) * det;
+  out[11] = (a21 * b02 - a20 * b04 - a23 * b00) * det;
+  out[12] = (a11 * b07 - a10 * b09 - a12 * b06) * det;
+  out[13] = (a00 * b09 - a01 * b07 + a02 * b06) * det;
+  out[14] = (a31 * b01 - a30 * b03 - a32 * b00) * det;
+  out[15] = (a20 * b03 - a21 * b01 + a22 * b00) * det;
+  return out;
+}
+/**
+ * Multiplies two mat4s
+ *
+ * @param {mat4} out the receiving matrix
+ * @param {ReadonlyMat4} a the first operand
+ * @param {ReadonlyMat4} b the second operand
+ * @returns {mat4} out
+ */
+
+function multiply(out, a, b) {
+  var a00 = a[0],
+      a01 = a[1],
+      a02 = a[2],
+      a03 = a[3];
+  var a10 = a[4],
+      a11 = a[5],
+      a12 = a[6],
+      a13 = a[7];
+  var a20 = a[8],
+      a21 = a[9],
+      a22 = a[10],
+      a23 = a[11];
+  var a30 = a[12],
+      a31 = a[13],
+      a32 = a[14],
+      a33 = a[15]; // Cache only the current line of the second matrix
+
+  var b0 = b[0],
+      b1 = b[1],
+      b2 = b[2],
+      b3 = b[3];
+  out[0] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+  out[1] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+  out[2] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+  out[3] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+  b0 = b[4];
+  b1 = b[5];
+  b2 = b[6];
+  b3 = b[7];
+  out[4] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+  out[5] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+  out[6] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+  out[7] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+  b0 = b[8];
+  b1 = b[9];
+  b2 = b[10];
+  b3 = b[11];
+  out[8] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+  out[9] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+  out[10] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+  out[11] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+  b0 = b[12];
+  b1 = b[13];
+  b2 = b[14];
+  b3 = b[15];
+  out[12] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+  out[13] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+  out[14] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+  out[15] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+  return out;
+}
+
+/**
+ * 3 Dimensional Vector
+ * @module vec3
+ */
+
+/**
+ * Creates a new, empty vec3
+ *
+ * @returns {vec3} a new 3D vector
+ */
+
+function create() {
+  var out = new ARRAY_TYPE(3);
+
+  if (ARRAY_TYPE != Float32Array) {
+    out[0] = 0;
+    out[1] = 0;
+    out[2] = 0;
+  }
+
+  return out;
+}
+/**
+ * Creates a new vec3 initialized with the given values
+ *
+ * @param {Number} x X component
+ * @param {Number} y Y component
+ * @param {Number} z Z component
+ * @returns {vec3} a new 3D vector
+ */
+
+function fromValues(x, y, z) {
+  var out = new ARRAY_TYPE(3);
+  out[0] = x;
+  out[1] = y;
+  out[2] = z;
+  return out;
+}
+/**
+ * Transforms the vec3 with a mat4.
+ * 4th vector component is implicitly '1'
+ *
+ * @param {vec3} out the receiving vector
+ * @param {ReadonlyVec3} a the vector to transform
+ * @param {ReadonlyMat4} m matrix to transform with
+ * @returns {vec3} out
+ */
+
+function transformMat4(out, a, m) {
+  var x = a[0],
+      y = a[1],
+      z = a[2];
+  var w = m[3] * x + m[7] * y + m[11] * z + m[15];
+  w = w || 1.0;
+  out[0] = (m[0] * x + m[4] * y + m[8] * z + m[12]) / w;
+  out[1] = (m[1] * x + m[5] * y + m[9] * z + m[13]) / w;
+  out[2] = (m[2] * x + m[6] * y + m[10] * z + m[14]) / w;
+  return out;
+}
+/**
+ * Perform some operation over an array of vec3s.
+ *
+ * @param {Array} a the array of vectors to iterate over
+ * @param {Number} stride Number of elements between the start of each vec3. If 0 assumes tightly packed
+ * @param {Number} offset Number of elements to skip at the beginning of the array
+ * @param {Number} count Number of vec3s to iterate over. If 0 iterates over entire array
+ * @param {Function} fn Function to call for each vector in the array
+ * @param {Object} [arg] additional argument to pass to fn
+ * @returns {Array} a
+ * @function
+ */
+
+(function () {
+  var vec = create();
+  return function (a, stride, offset, count, fn, arg) {
+    var i, l;
+
+    if (!stride) {
+      stride = 3;
+    }
+
+    if (!offset) {
+      offset = 0;
+    }
+
+    if (count) {
+      l = Math.min(count * stride + offset, a.length);
+    } else {
+      l = a.length;
+    }
+
+    for (i = offset; i < l; i += stride) {
+      vec[0] = a[i];
+      vec[1] = a[i + 1];
+      vec[2] = a[i + 2];
+      fn(vec, vec, arg);
+      a[i] = vec[0];
+      a[i + 1] = vec[1];
+      a[i + 2] = vec[2];
+    }
+
+    return a;
+  };
+})();
+
 class IndexedBinaryBVHVisitor {
     /**
      *
@@ -56374,6 +56610,445 @@ class SurfacePoint3 {
     }
 }
 
+/**
+ * Compute fraction of linear interpolation
+ * @param {number} a
+ * @param {number} b
+ * @param {number} value
+ * @returns {number} fraction
+ */
+function inverseLerp(a, b, value) {
+    const range = b - a;
+    const scaledValue = value - a;
+
+    if (range === 0) {
+
+        // avoid division by zero error
+
+        // this is arbitrary output, as actual answer is undefined
+
+        return 0;
+    }
+
+    return scaledValue / range;
+}
+
+/**
+ *
+ * @param {number} min
+ * @param {number} max
+ * @constructor
+ */
+
+class NumericInterval {
+    /**
+     *
+     * @param {number} [min=-Infinity]
+     * @param {number} [max=Infinity]
+     * @constructor
+     */
+    constructor(
+        min = Number.NEGATIVE_INFINITY,
+        max = Number.POSITIVE_INFINITY
+    ) {
+        assert.isNumber(min, 'min');
+        assert.isNumber(max, 'max');
+
+        assert.ok(max >= min, `max=${max} must be >= than min=${min}`);
+
+        /**
+         *
+         * @type {number}
+         */
+        this.min = min;
+        /**
+         *
+         * @type {number}
+         */
+        this.max = max;
+
+        this.onChanged = new Signal();
+    }
+
+
+    /**
+     *
+     * @param {number} min
+     * @param {number} max
+     */
+    set(min, max) {
+        assert.isNumber(min, 'min');
+        assert.isNumber(max, 'max');
+
+        assert.notNaN(min, 'min');
+        assert.notNaN(max, 'max');
+
+        assert.greaterThanOrEqual(max, min, `max [${max}] must be >= than min[${min}]`);
+
+        const oldMin = this.min;
+        const oldMax = this.max;
+
+        if (min !== oldMin || max !== oldMax) {
+            this.min = min;
+            this.max = max;
+
+            if (this.onChanged.hasHandlers()) {
+                this.onChanged.send4(min, max, oldMin, oldMax);
+            }
+        }
+    }
+
+    /**
+     *
+     * @param {NumericInterval} other
+     */
+    copy(other) {
+        this.set(other.min, other.max);
+    }
+
+    /**
+     *
+     * @param {number} value
+     */
+    multiplyScalar(value) {
+        const v0 = this.min * value;
+        const v1 = this.max * value;
+
+        if (v0 > v1) {
+            //probably negative scale
+            this.set(v1, v0);
+        } else {
+
+            this.set(v0, v1);
+        }
+    }
+
+    /**
+     * Performs inverse linear interpolation on a given input
+     * @param {number} v
+     * @returns {number}
+     */
+    normalizeValue(v) {
+        return inverseLerp(this.min, this.max, v);
+    }
+
+    /**
+     * Both min and max are exactly 0
+     * @returns {boolean}
+     */
+    isZero() {
+        return this.min === 0 && this.max === 0;
+    }
+
+    /**
+     * Whether min and max are the same
+     * In other words if span is 0
+     * @returns {boolean}
+     */
+    isExact() {
+        return this.min === this.max;
+    }
+
+    /**
+     *
+     * @returns {number}
+     */
+    computeAverage() {
+        return (this.min + this.max) / 2;
+    }
+
+    /**
+     *
+     * @param {function} random Random number generator function, must return values between 0 and 1
+     * @returns {number}
+     */
+    sampleRandom(random) {
+        assert.equal(typeof random, 'function', `random must be a function, instead was ${typeof random}`);
+
+        return this.min + random() * (this.max - this.min);
+    }
+
+    fromJSON(json) {
+        this.set(json.min, json.max);
+    }
+
+    toJSON() {
+        return {
+            min: this.min,
+            max: this.max
+        };
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     */
+    toBinaryBuffer(buffer) {
+        buffer.writeFloat64(this.min);
+        buffer.writeFloat64(this.max);
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     */
+    fromBinaryBuffer(buffer) {
+        this.min = buffer.readFloat64();
+        this.max = buffer.readFloat64();
+    }
+
+    /**
+     *
+     * @param {NumericInterval} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return this.min === other.min && this.max === other.max;
+    }
+
+    /**
+     *
+     * @returns {number}
+     */
+    hash() {
+        let hash = computeHashFloat(this.min);
+
+        hash = ((hash << 5) - hash) + computeHashFloat(this.max);
+
+        return hash;
+    }
+
+    /**
+     * Distance between min and max (= max - min)
+     * @returns {number}
+     */
+    get span() {
+        return this.max - this.min;
+    }
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+NumericInterval.prototype.isNumericInterval = true;
+
+/**
+ * @readonly
+ * @type {NumericInterval}
+ */
+NumericInterval.one_one = Object.freeze(new NumericInterval(1, 1));
+/**
+ * @readonly
+ * @type {NumericInterval}
+ */
+NumericInterval.zero_zero = Object.freeze(new NumericInterval(0, 0));
+
+class ObservedInteger extends Number {
+    /**
+     * @readonly
+     * @type {Signal}
+     */
+    onChanged = new Signal();
+
+    /**
+     *
+     * @param {Number} [value]
+     * @constructor
+     */
+    constructor(value = 0) {
+        super();
+
+        assert.isNumber(value, 'value');
+        assert.ok(Number.isInteger(value) || !Number.isFinite(value), `Value must be an integer, instead was ${value}`);
+
+
+        /**
+         *
+         * @type {Number}
+         * @private
+         */
+        this.__value = value;
+
+    }
+
+    /**
+     *
+     * @returns {Number}
+     */
+    valueOf() {
+        return this.getValue();
+    }
+
+    toString() {
+        return this.getValue().toString();
+    }
+
+    /**
+     *
+     * @param {Number} value
+     * @returns {ObservedInteger}
+     */
+    set(value) {
+        assert.isNumber(value, 'value');
+        assert.ok(Number.isInteger(value) || !Number.isFinite(value), `Value must be an integer, instead was ${value}`);
+
+        const oldValue = this.__value;
+        if (oldValue !== value) {
+            this.__value = value;
+            this.onChanged.send2(value, oldValue);
+        }
+
+        return this;
+    }
+
+    /**
+     * Set value without dispatching change notification
+     * @param {number} value
+     */
+    setSilent(value) {
+        assert.isNumber(value, 'value');
+        assert.ok(Number.isInteger(value) || !Number.isFinite(value), `Value must be an integer, instead was ${value}`);
+
+        this.__value = value;
+    }
+
+    /**
+     *
+     * @return {boolean}
+     */
+    isZero() {
+        return this.getValue() === 0;
+    }
+
+    /**
+     *
+     * @param {ObservedInteger} other
+     */
+    subtract(other) {
+        this._add(-other.getValue());
+    }
+
+    /**
+     *
+     * @param {number} value
+     */
+    _subtract(value) {
+        this.set(this.getValue() - value);
+    }
+
+    /**
+     *
+     * @param {ObservedInteger} other
+     */
+    add(other) {
+        this._add(other.getValue());
+    }
+
+    /**
+     *
+     * @param {number} value
+     */
+    _add(value) {
+        this.set(this.getValue() + value);
+    }
+
+    /**
+     * Increment the stored value by 1, same as adding 1
+     */
+    increment() {
+        this.set(this.getValue() + 1);
+    }
+
+    /**
+     * Decrement the stored value by 1, same as subtracting 1
+     */
+    decrement() {
+        this.set(this.getValue() - 1);
+    }
+
+    /**
+     *
+     * @returns {Number}
+     */
+    getValue() {
+        return this.__value;
+    }
+
+    /**
+     *
+     * @param {ObservedInteger} other
+     */
+    copy(other) {
+        this.set(other.__value);
+    }
+
+    /**
+     *
+     * @param {ObservedInteger} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return this.__value === other.__value;
+    }
+
+    /**
+     *
+     * @returns {Number}
+     */
+    hash() {
+        return this.__value;
+    }
+
+    toJSON() {
+        return this.__value;
+    }
+
+    fromJSON(obj) {
+        this.set(obj);
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     */
+    toBinaryBuffer(buffer) {
+        const v = this.__value;
+
+        if (v === Infinity) {
+            buffer.writeInt32(2147483647);
+        } else if (v === -Infinity) {
+            buffer.writeInt32(-2147483648);
+        } else {
+            //TODO it's possible to write encoded Infinity values by accident
+            buffer.writeInt32(v);
+        }
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     */
+    fromBinaryBuffer(buffer) {
+        const value = buffer.readInt32();
+
+        if (value === 2147483647) {
+            this.set(Infinity);
+        } else if (value === -2147483648) {
+            this.set(-Infinity);
+        } else {
+            this.set(value);
+        }
+    }
+}
+
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+ObservedInteger.prototype.isObservedInteger = true;
+
 /**
  * NOTE: adapted from http://www.geometrictools.com/GTEngine/Include/Mathematics/GteIntrRay3Triangle3.h
  * @source https://en.wikipedia.org/wiki/M%C3%B6ller%E2%80%93Trumbore_intersection_algorithm (Möller and Trumbore, « Fast, Minimum Storage Ray-Triangle Intersection », Journal of Graphics Tools, vol. 2,‎ 1997, p. 21–28)
@@ -56623,332 +57298,24 @@ function ray3_array_apply_matrix4(output, output_offset, input, input_offset, m4
     return true;
 }
 
-/**
- * Common utilities
- * @module glMatrix
- */
-var ARRAY_TYPE = typeof Float32Array !== 'undefined' ? Float32Array : Array;
-if (!Math.hypot) Math.hypot = function () {
-  var y = 0,
-      i = arguments.length;
-
-  while (i--) {
-    y += arguments[i] * arguments[i];
-  }
-
-  return Math.sqrt(y);
-};
-
-/**
- * 4x4 Matrix<br>Format: column-major, when typed out it looks like row-major<br>The matrices are being post multiplied.
- * @module mat4
- */
-
-/**
- * Creates a new identity mat4
- *
- * @returns {mat4} a new 4x4 matrix
- */
-
-function create$1() {
-  var out = new ARRAY_TYPE(16);
-
-  if (ARRAY_TYPE != Float32Array) {
-    out[1] = 0;
-    out[2] = 0;
-    out[3] = 0;
-    out[4] = 0;
-    out[6] = 0;
-    out[7] = 0;
-    out[8] = 0;
-    out[9] = 0;
-    out[11] = 0;
-    out[12] = 0;
-    out[13] = 0;
-    out[14] = 0;
-  }
-
-  out[0] = 1;
-  out[5] = 1;
-  out[10] = 1;
-  out[15] = 1;
-  return out;
-}
-/**
- * Copy the values from one mat4 to another
- *
- * @param {mat4} out the receiving matrix
- * @param {ReadonlyMat4} a the source matrix
- * @returns {mat4} out
- */
-
-function copy(out, a) {
-  out[0] = a[0];
-  out[1] = a[1];
-  out[2] = a[2];
-  out[3] = a[3];
-  out[4] = a[4];
-  out[5] = a[5];
-  out[6] = a[6];
-  out[7] = a[7];
-  out[8] = a[8];
-  out[9] = a[9];
-  out[10] = a[10];
-  out[11] = a[11];
-  out[12] = a[12];
-  out[13] = a[13];
-  out[14] = a[14];
-  out[15] = a[15];
-  return out;
-}
-/**
- * Inverts a mat4
- *
- * @param {mat4} out the receiving matrix
- * @param {ReadonlyMat4} a the source matrix
- * @returns {mat4} out
- */
-
-function invert(out, a) {
-  var a00 = a[0],
-      a01 = a[1],
-      a02 = a[2],
-      a03 = a[3];
-  var a10 = a[4],
-      a11 = a[5],
-      a12 = a[6],
-      a13 = a[7];
-  var a20 = a[8],
-      a21 = a[9],
-      a22 = a[10],
-      a23 = a[11];
-  var a30 = a[12],
-      a31 = a[13],
-      a32 = a[14],
-      a33 = a[15];
-  var b00 = a00 * a11 - a01 * a10;
-  var b01 = a00 * a12 - a02 * a10;
-  var b02 = a00 * a13 - a03 * a10;
-  var b03 = a01 * a12 - a02 * a11;
-  var b04 = a01 * a13 - a03 * a11;
-  var b05 = a02 * a13 - a03 * a12;
-  var b06 = a20 * a31 - a21 * a30;
-  var b07 = a20 * a32 - a22 * a30;
-  var b08 = a20 * a33 - a23 * a30;
-  var b09 = a21 * a32 - a22 * a31;
-  var b10 = a21 * a33 - a23 * a31;
-  var b11 = a22 * a33 - a23 * a32; // Calculate the determinant
-
-  var det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
-
-  if (!det) {
-    return null;
-  }
-
-  det = 1.0 / det;
-  out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det;
-  out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * det;
-  out[2] = (a31 * b05 - a32 * b04 + a33 * b03) * det;
-  out[3] = (a22 * b04 - a21 * b05 - a23 * b03) * det;
-  out[4] = (a12 * b08 - a10 * b11 - a13 * b07) * det;
-  out[5] = (a00 * b11 - a02 * b08 + a03 * b07) * det;
-  out[6] = (a32 * b02 - a30 * b05 - a33 * b01) * det;
-  out[7] = (a20 * b05 - a22 * b02 + a23 * b01) * det;
-  out[8] = (a10 * b10 - a11 * b08 + a13 * b06) * det;
-  out[9] = (a01 * b08 - a00 * b10 - a03 * b06) * det;
-  out[10] = (a30 * b04 - a31 * b02 + a33 * b00) * det;
-  out[11] = (a21 * b02 - a20 * b04 - a23 * b00) * det;
-  out[12] = (a11 * b07 - a10 * b09 - a12 * b06) * det;
-  out[13] = (a00 * b09 - a01 * b07 + a02 * b06) * det;
-  out[14] = (a31 * b01 - a30 * b03 - a32 * b00) * det;
-  out[15] = (a20 * b03 - a21 * b01 + a22 * b00) * det;
-  return out;
-}
-/**
- * Multiplies two mat4s
- *
- * @param {mat4} out the receiving matrix
- * @param {ReadonlyMat4} a the first operand
- * @param {ReadonlyMat4} b the second operand
- * @returns {mat4} out
- */
-
-function multiply(out, a, b) {
-  var a00 = a[0],
-      a01 = a[1],
-      a02 = a[2],
-      a03 = a[3];
-  var a10 = a[4],
-      a11 = a[5],
-      a12 = a[6],
-      a13 = a[7];
-  var a20 = a[8],
-      a21 = a[9],
-      a22 = a[10],
-      a23 = a[11];
-  var a30 = a[12],
-      a31 = a[13],
-      a32 = a[14],
-      a33 = a[15]; // Cache only the current line of the second matrix
-
-  var b0 = b[0],
-      b1 = b[1],
-      b2 = b[2],
-      b3 = b[3];
-  out[0] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
-  out[1] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
-  out[2] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
-  out[3] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
-  b0 = b[4];
-  b1 = b[5];
-  b2 = b[6];
-  b3 = b[7];
-  out[4] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
-  out[5] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
-  out[6] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
-  out[7] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
-  b0 = b[8];
-  b1 = b[9];
-  b2 = b[10];
-  b3 = b[11];
-  out[8] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
-  out[9] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
-  out[10] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
-  out[11] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
-  b0 = b[12];
-  b1 = b[13];
-  b2 = b[14];
-  b3 = b[15];
-  out[12] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
-  out[13] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
-  out[14] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
-  out[15] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
-  return out;
-}
-
-/**
- * 3 Dimensional Vector
- * @module vec3
- */
-
-/**
- * Creates a new, empty vec3
- *
- * @returns {vec3} a new 3D vector
- */
-
-function create() {
-  var out = new ARRAY_TYPE(3);
-
-  if (ARRAY_TYPE != Float32Array) {
-    out[0] = 0;
-    out[1] = 0;
-    out[2] = 0;
-  }
-
-  return out;
-}
-/**
- * Creates a new vec3 initialized with the given values
- *
- * @param {Number} x X component
- * @param {Number} y Y component
- * @param {Number} z Z component
- * @returns {vec3} a new 3D vector
- */
-
-function fromValues(x, y, z) {
-  var out = new ARRAY_TYPE(3);
-  out[0] = x;
-  out[1] = y;
-  out[2] = z;
-  return out;
-}
-/**
- * Transforms the vec3 with a mat4.
- * 4th vector component is implicitly '1'
- *
- * @param {vec3} out the receiving vector
- * @param {ReadonlyVec3} a the vector to transform
- * @param {ReadonlyMat4} m matrix to transform with
- * @returns {vec3} out
- */
-
-function transformMat4(out, a, m) {
-  var x = a[0],
-      y = a[1],
-      z = a[2];
-  var w = m[3] * x + m[7] * y + m[11] * z + m[15];
-  w = w || 1.0;
-  out[0] = (m[0] * x + m[4] * y + m[8] * z + m[12]) / w;
-  out[1] = (m[1] * x + m[5] * y + m[9] * z + m[13]) / w;
-  out[2] = (m[2] * x + m[6] * y + m[10] * z + m[14]) / w;
-  return out;
-}
-/**
- * Perform some operation over an array of vec3s.
- *
- * @param {Array} a the array of vectors to iterate over
- * @param {Number} stride Number of elements between the start of each vec3. If 0 assumes tightly packed
- * @param {Number} offset Number of elements to skip at the beginning of the array
- * @param {Number} count Number of vec3s to iterate over. If 0 iterates over entire array
- * @param {Function} fn Function to call for each vector in the array
- * @param {Object} [arg] additional argument to pass to fn
- * @returns {Array} a
- * @function
- */
-
-(function () {
-  var vec = create();
-  return function (a, stride, offset, count, fn, arg) {
-    var i, l;
-
-    if (!stride) {
-      stride = 3;
-    }
-
-    if (!offset) {
-      offset = 0;
-    }
-
-    if (count) {
-      l = Math.min(count * stride + offset, a.length);
-    } else {
-      l = a.length;
-    }
-
-    for (i = offset; i < l; i += stride) {
-      vec[0] = a[i];
-      vec[1] = a[i + 1];
-      vec[2] = a[i + 2];
-      fn(vec, vec, arg);
-      a[i] = vec[0];
-      a[i + 1] = vec[1];
-      a[i + 2] = vec[2];
-    }
-
-    return a;
-  };
-})();
-
-/**
- *
- * @param {number[]|ArrayLike<number>|Float32Array} output
- * @param {number} origin_x
- * @param {number} origin_y
- * @param {number} origin_z
- * @param {number} direction_x
- * @param {number} direction_y
- * @param {number} direction_z
- */
-function ray3_array_compose(output, origin_x, origin_y, origin_z, direction_x, direction_y, direction_z) {
-    output[0] = origin_x;
-    output[1] = origin_y;
-    output[2] = origin_z;
-
-    output[3] = direction_x;
-    output[4] = direction_y;
-    output[5] = direction_z;
+/**
+ *
+ * @param {number[]|ArrayLike<number>|Float32Array} output
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} direction_x
+ * @param {number} direction_y
+ * @param {number} direction_z
+ */
+function ray3_array_compose(output, origin_x, origin_y, origin_z, direction_x, direction_y, direction_z) {
+    output[0] = origin_x;
+    output[1] = origin_y;
+    output[2] = origin_z;
+
+    output[3] = direction_x;
+    output[4] = direction_y;
+    output[5] = direction_z;
 }
 
 const hit$1 = new Vector3();
@@ -56982,640 +57349,278 @@ function bindGeometryFace(indices, vertices, index) {
 
 const vNormal = new Vector3$1();
 
-function bindGeometryFaceNormal(indices, normals, index) {
-
-    const index3 = index * 3;
-
-    const a = indices[index3] * 3;
-    const b = indices[index3 + 1] * 3;
-    const c = indices[index3 + 2] * 3;
-
-    //read vertex normals
-    const naX = normals[a];
-    const naY = normals[a + 1];
-    const naZ = normals[a + 2];
-
-    const nbX = normals[b];
-    const nbY = normals[b + 1];
-    const nbZ = normals[b + 2];
-
-    const ncX = normals[c];
-    const ncY = normals[c + 1];
-    const ncZ = normals[c + 2];
-
-    //add normals
-    const nsX = (naX + nbX + ncX);
-    const nsY = (naY + nbY + ncY);
-    const nsZ = (naZ + nbZ + ncZ);
-
-    //normalize
-    const l = v3_length(nsX, nsY, nsZ);
-    const m = 1 / l;
-
-    const nx = nsX * m;
-    const ny = nsY * m;
-    const nz = nsZ * m;
-
-    vNormal.set(nx, ny, nz);
-}
-
-
-function extractFaceIndexFromLeaf_default(leaf) {
-    return leaf.object;
-}
-
-class BVHGeometryRaycaster {
-    constructor() {
-        /**
-         *
-         * @type {BufferGeometry|null}
-         */
-        this.geometry = null;
-        /**
-         *
-         * @type {BinaryNode|null}
-         */
-        this.bvh = null;
-
-        /**
-         *
-         * @type {Vector2|null}
-         */
-        this.position = null;
-        /**
-         *
-         * @type {Vector2|null}
-         */
-        this.scale = null;
-        /**
-         *
-         * @type {number}
-         */
-        this.resolution = 0;
-
-        /**
-         *
-         * @type {Vector2|null}
-         */
-        this.size = null;
-
-        this.__bestDistance = 0;
-        this.__bestPosition = new Vector3$1();
-        this.__bestIndex = 0;
-
-
-        this.origin = new Vector3$1();
-        this.direction = new Vector3$1();
-
-        /**
-         *
-         * @type {Float32Array}
-         */
-        this.transform = new Float32Array(16);
-
-        array_copy(MATRIX_4_IDENTITY, 0, this.transform, 0, 16);
-
-        this.extractFaceIndexFromLeaf = extractFaceIndexFromLeaf_default;
-    }
-
-    /**
-     *
-     * @param {*} leaf
-     */
-    visitLeafIntersection(leaf) {
-
-        const geometry = this.geometry;
-
-        const geometryIndices = geometry.getIndex().array;
-        const geometryVertices = geometry.getAttribute('position').array;
-
-        const extractFaceIndexFromLeaf = this.extractFaceIndexFromLeaf;
-
-        const index = extractFaceIndexFromLeaf(leaf);
-
-        bindGeometryFace(geometryIndices, geometryVertices, index);
-
-        const hitFound = rayTriangleIntersection(hit$1, this.origin, this.direction, vA, vB, vC);
-
-        if (hitFound) {
-
-            const d = this.origin.distanceSqrTo(hit$1);
-            if (d < this.__bestDistance) {
-                this.__bestDistance = d;
-                this.__bestPosition.copy(hit$1);
-                this.__bestIndex = index;
-            }
-
-        }
-    }
-
-    /**
-     *
-     * @param {SurfacePoint3} hit
-     * @param {number} originX
-     * @param {number} originY
-     * @param {number} originZ
-     * @param {number} directionX
-     * @param {number} directionY
-     * @param {number} directionZ
-     * @returns {boolean}
-     */
-    raycast(
-        hit,
-        originX, originY, originZ,
-        directionX, directionY, directionZ
-    ) {
-
-        invert(m4_tmp, this.transform);
-
-        ray3_array_compose(
-            ray_tmp,
-            originX, originY, originZ,
-            directionX, directionY, directionZ
-        );
-
-        ray3_array_apply_matrix4(ray_tmp, 0,ray_tmp,0, m4_tmp);
-
-        const _originX = ray_tmp[0];
-        const _originY = ray_tmp[1];
-        const _originZ = ray_tmp[2];
-
-        const _directionX = ray_tmp[3];
-        const _directionY = ray_tmp[4];
-        const _directionZ = ray_tmp[5];
-
-        this.origin.set(_originX, _originY, _originZ);
-        this.direction.set(_directionX, _directionY, _directionZ);
-
-        this.__bestDistance = Number.POSITIVE_INFINITY;
-
-        this.bvh.traverseRayLeafIntersections(_originX, _originY, _originZ, _directionX, _directionY, _directionZ, this.visitLeafIntersection, this);
-
-        if (this.__bestDistance !== Number.POSITIVE_INFINITY) {
-
-            const geometry = this.geometry;
-
-            const geometryIndices = geometry.getIndex().array;
-            const geometryNormals = geometry.getAttribute('normal').array;
-
-            bindGeometryFaceNormal(geometryIndices, geometryNormals, this.__bestIndex);
-
-            hit.position.copy(this.__bestPosition);
-            hit.normal.copy(vNormal);
-
-            hit.applyMatrix4(this.transform);
-
-            return true;
-        } else {
-            //no hit
-            return false;
-        }
-    }
-}
-
-class ObservedInteger extends Number {
-    /**
-     * @readonly
-     * @type {Signal}
-     */
-    onChanged = new Signal();
-
-    /**
-     *
-     * @param {Number} [value]
-     * @constructor
-     */
-    constructor(value = 0) {
-        super();
-
-        assert.isNumber(value, 'value');
-        assert.ok(Number.isInteger(value) || !Number.isFinite(value), `Value must be an integer, instead was ${value}`);
-
-
-        /**
-         *
-         * @type {Number}
-         * @private
-         */
-        this.__value = value;
-
-    }
-
-    /**
-     *
-     * @returns {Number}
-     */
-    valueOf() {
-        return this.getValue();
-    }
-
-    toString() {
-        return this.getValue().toString();
-    }
-
-    /**
-     *
-     * @param {Number} value
-     * @returns {ObservedInteger}
-     */
-    set(value) {
-        assert.isNumber(value, 'value');
-        assert.ok(Number.isInteger(value) || !Number.isFinite(value), `Value must be an integer, instead was ${value}`);
-
-        const oldValue = this.__value;
-        if (oldValue !== value) {
-            this.__value = value;
-            this.onChanged.send2(value, oldValue);
-        }
-
-        return this;
-    }
-
-    /**
-     * Set value without dispatching change notification
-     * @param {number} value
-     */
-    setSilent(value) {
-        assert.isNumber(value, 'value');
-        assert.ok(Number.isInteger(value) || !Number.isFinite(value), `Value must be an integer, instead was ${value}`);
-
-        this.__value = value;
-    }
-
-    /**
-     *
-     * @return {boolean}
-     */
-    isZero() {
-        return this.getValue() === 0;
-    }
-
-    /**
-     *
-     * @param {ObservedInteger} other
-     */
-    subtract(other) {
-        this._add(-other.getValue());
-    }
-
-    /**
-     *
-     * @param {number} value
-     */
-    _subtract(value) {
-        this.set(this.getValue() - value);
-    }
-
-    /**
-     *
-     * @param {ObservedInteger} other
-     */
-    add(other) {
-        this._add(other.getValue());
-    }
-
-    /**
-     *
-     * @param {number} value
-     */
-    _add(value) {
-        this.set(this.getValue() + value);
-    }
-
-    /**
-     * Increment the stored value by 1, same as adding 1
-     */
-    increment() {
-        this.set(this.getValue() + 1);
-    }
-
-    /**
-     * Decrement the stored value by 1, same as subtracting 1
-     */
-    decrement() {
-        this.set(this.getValue() - 1);
-    }
-
-    /**
-     *
-     * @returns {Number}
-     */
-    getValue() {
-        return this.__value;
-    }
-
-    /**
-     *
-     * @param {ObservedInteger} other
-     */
-    copy(other) {
-        this.set(other.__value);
-    }
-
-    /**
-     *
-     * @param {ObservedInteger} other
-     * @returns {boolean}
-     */
-    equals(other) {
-        return this.__value === other.__value;
-    }
-
-    /**
-     *
-     * @returns {Number}
-     */
-    hash() {
-        return this.__value;
-    }
-
-    toJSON() {
-        return this.__value;
-    }
-
-    fromJSON(obj) {
-        this.set(obj);
-    }
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     */
-    toBinaryBuffer(buffer) {
-        const v = this.__value;
-
-        if (v === Infinity) {
-            buffer.writeInt32(2147483647);
-        } else if (v === -Infinity) {
-            buffer.writeInt32(-2147483648);
-        } else {
-            //TODO it's possible to write encoded Infinity values by accident
-            buffer.writeInt32(v);
-        }
-    }
+function bindGeometryFaceNormal(indices, normals, index) {
 
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     */
-    fromBinaryBuffer(buffer) {
-        const value = buffer.readInt32();
+    const index3 = index * 3;
 
-        if (value === 2147483647) {
-            this.set(Infinity);
-        } else if (value === -2147483648) {
-            this.set(-Infinity);
-        } else {
-            this.set(value);
-        }
-    }
-}
+    const a = indices[index3] * 3;
+    const b = indices[index3 + 1] * 3;
+    const c = indices[index3 + 2] * 3;
 
+    //read vertex normals
+    const naX = normals[a];
+    const naY = normals[a + 1];
+    const naZ = normals[a + 2];
 
-/**
- * @readonly
- * @type {boolean}
- */
-ObservedInteger.prototype.isObservedInteger = true;
-
-/**
- * Compute fraction of linear interpolation
- * @param {number} a
- * @param {number} b
- * @param {number} value
- * @returns {number} fraction
- */
-function inverseLerp(a, b, value) {
-    const range = b - a;
-    const scaledValue = value - a;
+    const nbX = normals[b];
+    const nbY = normals[b + 1];
+    const nbZ = normals[b + 2];
 
-    if (range === 0) {
+    const ncX = normals[c];
+    const ncY = normals[c + 1];
+    const ncZ = normals[c + 2];
 
-        // avoid division by zero error
+    //add normals
+    const nsX = (naX + nbX + ncX);
+    const nsY = (naY + nbY + ncY);
+    const nsZ = (naZ + nbZ + ncZ);
 
-        // this is arbitrary output, as actual answer is undefined
+    //normalize
+    const l = v3_length(nsX, nsY, nsZ);
+    const m = 1 / l;
 
-        return 0;
-    }
+    const nx = nsX * m;
+    const ny = nsY * m;
+    const nz = nsZ * m;
 
-    return scaledValue / range;
-}
-
-/**
- *
- * @param {number} min
- * @param {number} max
- * @constructor
- */
+    vNormal.set(nx, ny, nz);
+}
 
-class NumericInterval {
-    /**
-     *
-     * @param {number} [min=-Infinity]
-     * @param {number} [max=Infinity]
-     * @constructor
-     */
-    constructor(
-        min = Number.NEGATIVE_INFINITY,
-        max = Number.POSITIVE_INFINITY
-    ) {
-        assert.isNumber(min, 'min');
-        assert.isNumber(max, 'max');
 
-        assert.ok(max >= min, `max=${max} must be >= than min=${min}`);
+function extractFaceIndexFromLeaf_default(leaf) {
+    return leaf.object;
+}
 
+class BVHGeometryRaycaster {
+    constructor() {
         /**
          *
-         * @type {number}
+         * @type {BufferGeometry|null}
          */
-        this.min = min;
+        this.geometry = null;
+        /**
+         *
+         * @type {BinaryNode|null}
+         */
+        this.bvh = null;
+
+        /**
+         *
+         * @type {Vector2|null}
+         */
+        this.position = null;
+        /**
+         *
+         * @type {Vector2|null}
+         */
+        this.scale = null;
         /**
          *
          * @type {number}
          */
-        this.max = max;
+        this.resolution = 0;
 
-        this.onChanged = new Signal();
-    }
+        /**
+         *
+         * @type {Vector2|null}
+         */
+        this.size = null;
+
+        this.__bestDistance = 0;
+        this.__bestPosition = new Vector3$1();
+        this.__bestIndex = 0;
+
+
+        this.origin = new Vector3$1();
+        this.direction = new Vector3$1();
 
+        /**
+         *
+         * @type {Float32Array}
+         */
+        this.transform = new Float32Array(16);
+
+        array_copy(MATRIX_4_IDENTITY, 0, this.transform, 0, 16);
+
+        this.extractFaceIndexFromLeaf = extractFaceIndexFromLeaf_default;
+    }
 
     /**
      *
-     * @param {number} min
-     * @param {number} max
+     * @param {*} leaf
      */
-    set(min, max) {
-        assert.isNumber(min, 'min');
-        assert.isNumber(max, 'max');
+    visitLeafIntersection(leaf) {
 
-        assert.notNaN(min, 'min');
-        assert.notNaN(max, 'max');
+        const geometry = this.geometry;
 
-        assert.greaterThanOrEqual(max, min, `max [${max}] must be >= than min[${min}]`);
+        const geometryIndices = geometry.getIndex().array;
+        const geometryVertices = geometry.getAttribute('position').array;
 
-        const oldMin = this.min;
-        const oldMax = this.max;
+        const extractFaceIndexFromLeaf = this.extractFaceIndexFromLeaf;
 
-        if (min !== oldMin || max !== oldMax) {
-            this.min = min;
-            this.max = max;
+        const index = extractFaceIndexFromLeaf(leaf);
 
-            if (this.onChanged.hasHandlers()) {
-                this.onChanged.send4(min, max, oldMin, oldMax);
+        bindGeometryFace(geometryIndices, geometryVertices, index);
+
+        const hitFound = rayTriangleIntersection(hit$1, this.origin, this.direction, vA, vB, vC);
+
+        if (hitFound) {
+
+            const d = this.origin.distanceSqrTo(hit$1);
+            if (d < this.__bestDistance) {
+                this.__bestDistance = d;
+                this.__bestPosition.copy(hit$1);
+                this.__bestIndex = index;
             }
+
         }
     }
 
     /**
      *
-     * @param {NumericInterval} other
+     * @param {SurfacePoint3} hit
+     * @param {number} originX
+     * @param {number} originY
+     * @param {number} originZ
+     * @param {number} directionX
+     * @param {number} directionY
+     * @param {number} directionZ
+     * @returns {boolean}
      */
-    copy(other) {
-        this.set(other.min, other.max);
-    }
+    raycast(
+        hit,
+        originX, originY, originZ,
+        directionX, directionY, directionZ
+    ) {
 
-    /**
-     *
-     * @param {number} value
-     */
-    multiplyScalar(value) {
-        const v0 = this.min * value;
-        const v1 = this.max * value;
+        invert(m4_tmp, this.transform);
 
-        if (v0 > v1) {
-            //probably negative scale
-            this.set(v1, v0);
-        } else {
+        ray3_array_compose(
+            ray_tmp,
+            originX, originY, originZ,
+            directionX, directionY, directionZ
+        );
 
-            this.set(v0, v1);
-        }
-    }
+        ray3_array_apply_matrix4(ray_tmp, 0,ray_tmp,0, m4_tmp);
 
-    /**
-     * Performs inverse linear interpolation on a given input
-     * @param {number} v
-     * @returns {number}
-     */
-    normalizeValue(v) {
-        return inverseLerp(this.min, this.max, v);
-    }
+        const _originX = ray_tmp[0];
+        const _originY = ray_tmp[1];
+        const _originZ = ray_tmp[2];
 
-    /**
-     * Both min and max are exactly 0
-     * @returns {boolean}
-     */
-    isZero() {
-        return this.min === 0 && this.max === 0;
-    }
+        const _directionX = ray_tmp[3];
+        const _directionY = ray_tmp[4];
+        const _directionZ = ray_tmp[5];
 
-    /**
-     * Whether min and max are the same
-     * In other words if span is 0
-     * @returns {boolean}
-     */
-    isExact() {
-        return this.min === this.max;
-    }
+        this.origin.set(_originX, _originY, _originZ);
+        this.direction.set(_directionX, _directionY, _directionZ);
 
-    /**
-     *
-     * @returns {number}
-     */
-    computeAverage() {
-        return (this.min + this.max) / 2;
-    }
+        this.__bestDistance = Number.POSITIVE_INFINITY;
 
-    /**
-     *
-     * @param {function} random Random number generator function, must return values between 0 and 1
-     * @returns {number}
-     */
-    sampleRandom(random) {
-        assert.equal(typeof random, 'function', `random must be a function, instead was ${typeof random}`);
+        this.bvh.traverseRayLeafIntersections(_originX, _originY, _originZ, _directionX, _directionY, _directionZ, this.visitLeafIntersection, this);
 
-        return this.min + random() * (this.max - this.min);
-    }
+        if (this.__bestDistance !== Number.POSITIVE_INFINITY) {
 
-    fromJSON(json) {
-        this.set(json.min, json.max);
-    }
+            const geometry = this.geometry;
 
-    toJSON() {
-        return {
-            min: this.min,
-            max: this.max
-        };
-    }
+            const geometryIndices = geometry.getIndex().array;
+            const geometryNormals = geometry.getAttribute('normal').array;
 
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     */
-    toBinaryBuffer(buffer) {
-        buffer.writeFloat64(this.min);
-        buffer.writeFloat64(this.max);
-    }
+            bindGeometryFaceNormal(geometryIndices, geometryNormals, this.__bestIndex);
 
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     */
-    fromBinaryBuffer(buffer) {
-        this.min = buffer.readFloat64();
-        this.max = buffer.readFloat64();
-    }
+            hit.position.copy(this.__bestPosition);
+            hit.normal.copy(vNormal);
 
-    /**
-     *
-     * @param {NumericInterval} other
-     * @returns {boolean}
-     */
-    equals(other) {
-        return this.min === other.min && this.max === other.max;
+            hit.applyMatrix4(this.transform);
+
+            return true;
+        } else {
+            //no hit
+            return false;
+        }
     }
+}
+
+/**
+ * Created by Alex on 28/01/2017.
+ */
 
-    /**
-     *
-     * @returns {number}
-     */
-    hash() {
-        let hash = computeHashFloat(this.min);
+function prepareObject(object) {
+    //turn off automatic matrix re-calculations each frame
+    object.matrixAutoUpdate = false;
+    //disable frustum culling
+    object.frustumCulled = false;
+}
 
-        hash = ((hash << 5) - hash) + computeHashFloat(this.max);
+/**
+ *
+ * @param {BufferGeometry} [geometry]
+ * @param {Material} [material]
+ * @returns {Mesh}
+ */
+function createMesh(geometry, material) {
+    const result = new Mesh(geometry, material);
 
-        return hash;
-    }
+    prepareObject(result);
 
-    /**
-     * Distance between min and max (= max - min)
-     * @returns {number}
-     */
-    get span() {
-        return this.max - this.min;
-    }
+    return result;
 }
 
 /**
- * @readonly
- * @type {boolean}
+ *
+ * @param {BufferGeometry} geometry
+ * @param {THREE.Material} material
+ * @returns {THREE.SkinnedMesh}
  */
-NumericInterval.prototype.isNumericInterval = true;
+function createSkinnedMesh(geometry, material) {
+    const result = new SkinnedMesh(geometry, material);
+
+    prepareObject(result);
+
+    return result;
+}
 
 /**
- * @readonly
- * @type {NumericInterval}
+ *
+ * @param {Material} material
  */
-NumericInterval.one_one = Object.freeze(new NumericInterval(1, 1));
+function prepareMaterial(material) {
+
+    //make shadows render from front side, this avoids artifacts due to gaps in geometry that can't be seen from the front
+    material.shadowSide = DoubleSide;
+
+    if (typeof material.envMapIntensity === 'number' && material.envMapIntensity !== 1) {
+        // make material react to environment map in the same way as others
+        material.envMapIntensity = 1;
+    }
+}
+
 /**
- * @readonly
- * @type {NumericInterval}
+ *
+ * @returns {Group}
  */
-NumericInterval.zero_zero = Object.freeze(new NumericInterval(0, 0));
+function createGroup() {
+    const result = new Group();
+
+    prepareObject(result);
+
+    return result;
+}
+
+var ThreeFactory = {
+    createMesh,
+    createSkinnedMesh,
+    createGroup,
+    prepareMaterial
+};
 
 /**
  * Created by Alex on 09/11/2014.
  */
 
+
+const EMPTY_GEOMETRY = new BufferGeometry();
+const DEFAULT_MATERIAL = new MeshBasicMaterial();
+
 /**
  * terrain tile is a part of a 2d array
  */
@@ -57631,7 +57636,7 @@ class TerrainTile {
      * @type {Material}
      */
     material = null;
-    mesh = ThreeFactory.createMesh();
+    mesh = ThreeFactory.createMesh(EMPTY_GEOMETRY, DEFAULT_MATERIAL);
 
 
     /**
@@ -60075,70 +60080,70 @@ class TerrainTileManager {
 const raycastBVHVisitor = new RaycastBVHVisitor();
 const firstRayIntersectionTerrainBVHVisitor = new FirstRayIntersectionTerrainBVHVisitor();
 
-function TerrainPreview() {
+class TerrainPreview {
     /**
      *
      * @type {String}
      */
-    this.url = "";
+    url = "";
 
     /**
      *
      * @type {Vector2}
      */
-    this.offset = new Vector2(0, 0);
+    offset = new Vector2(0, 0);
     /**
      *
      * @type {Vector2}
      */
-    this.scale = new Vector2(1, 1);
-}
+    scale = new Vector2(1, 1);
 
-/**
- *
- * @param {TerrainPreview} other
- */
-TerrainPreview.prototype.copy = function (other) {
-    this.url = other.url;
-    this.scale.copy(other.scale);
-    this.offset.copy(other.offset);
-};
+    /**
+     *
+     * @param {TerrainPreview} other
+     */
+    copy(other) {
+        this.url = other.url;
+        this.scale.copy(other.scale);
+        this.offset.copy(other.offset);
+    }
 
-TerrainPreview.prototype.toJSON = function () {
-    return {
-        url: this.url,
-        offset: this.offset.toJSON(),
-        scale: this.scale.toJSON()
-    };
-};
+    toJSON() {
+        return {
+            url: this.url,
+            offset: this.offset.toJSON(),
+            scale: this.scale.toJSON()
+        };
+    }
 
-TerrainPreview.prototype.fromJSON = function (obj) {
-    this.url = obj.url;
-    this.offset.fromJSON(obj.offset);
-    this.scale.fromJSON(obj.scale);
-};
+    fromJSON(obj) {
+        this.url = obj.url;
+        this.offset.fromJSON(obj.offset);
+        this.scale.fromJSON(obj.scale);
+    }
 
-/**
- *
- * @param {BinaryBuffer} buffer
- */
-TerrainPreview.prototype.toBinaryBuffer = function (buffer) {
-    buffer.writeUTF8String(this.url);
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     */
+    toBinaryBuffer(buffer) {
+        buffer.writeUTF8String(this.url);
 
-    this.offset.toBinaryBuffer(buffer);
-    this.scale.toBinaryBuffer(buffer);
-};
+        this.offset.toBinaryBuffer(buffer);
+        this.scale.toBinaryBuffer(buffer);
+    }
 
-/**
- *
- * @param {BinaryBuffer} buffer
- */
-TerrainPreview.prototype.fromBinaryBuffer = function (buffer) {
-    this.url = buffer.readUTF8String();
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     */
+    fromBinaryBuffer(buffer) {
+        this.url = buffer.readUTF8String();
 
-    this.offset.fromBinaryBuffer(buffer);
-    this.scale.fromBinaryBuffer(buffer);
-};
+        this.offset.fromBinaryBuffer(buffer);
+        this.scale.fromBinaryBuffer(buffer);
+    }
+}
 
 /**
  * NOTE, trying to keep to IANA registry: https://www.iana.org/assignments/media-types/media-types.xhtml
@@ -62089,9 +62094,12 @@ class List {
     /**
      * Retrieve element at a given position in the list
      * @param {number} index
-     * @returns {T}
+     * @returns {T|undefined}
      */
     get(index) {
+        assert.isNumber(index, 'index');
+        assert.isNonNegativeInteger(index, 'index');
+
         return this.data[index];
     }
 
@@ -62101,6 +62109,9 @@ class List {
      * @param {T} value
      */
     set(index, value) {
+        assert.isNumber(index, 'index');
+        assert.isNonNegativeInteger(index, 'index');
+
         const oldValue = this.data[index];
 
         if (oldValue !== undefined) {
@@ -62221,7 +62232,7 @@ class List {
     /**
      * Replace the data, replacements is performed surgically, meaning that diff is computed and add/remove operations are performed on the set
      * This method is tailored to work well with visualisation as only elements that's missing from the new set is removed, and only elements that are new to are added
-     * Conversely, relevant events are dispatched that a visualisation can observe. This results in fewer changes required to the visualisation
+     * Conversely, relevant events are dispatched that can observe. This results in fewer changes required to the visualisation
      * @param {T[]} newOutput
      */
     patch(newOutput) {
@@ -68667,8 +68678,10 @@ class EBBVHLeafProxy {
     unlink() {
         assert.equal(this.is_linked, true, 'not linked');
 
-        this.#tree.remove_leaf(this.#node_id);
-        this.#tree.release_node(this.#node_id);
+        const node_id = this.#node_id;
+
+        this.#tree.remove_leaf(node_id);
+        this.#tree.release_node(node_id);
 
         this.#node_id = -1;
         this.#tree = null;
@@ -79034,7 +79047,7 @@ class ExplicitBinaryBoundingVolumeHierarchy {
     /**
      *
      * @param {number} id
-     * @param {number[]} result
+     * @param {number[]|Float32Array} result
      */
     node_get_aabb(id, result) {
         assert.isNonNegativeInteger(id, 'id');
@@ -80193,18 +80206,6 @@ function bvh_query_leaves_generic(
     return result_cursor - result_offset;
 }
 
-class BVHQuery {
-    /**
-     *
-     * @param {number} node
-     * @param {ExplicitBinaryBoundingVolumeHierarchy} tree
-     * @returns {boolean}
-     */
-    evaluate(node, tree) {
-        throw new Error('Not Implemented');
-    }
-}
-
 /**
  *
  * @param {ArrayLike<number>|number[]|Float32Array} aabb bounding box, order: x0,y0,z0,x1,y1,z1
@@ -80219,21 +80220,33 @@ function aabb3_array_intersects_ray_array(aabb, ray) {
     );
 }
 
+class BVHQuery {
+    /**
+     *
+     * @param {number} node
+     * @param {ExplicitBinaryBoundingVolumeHierarchy} tree
+     * @returns {boolean}
+     */
+    evaluate(node, tree) {
+        throw new Error('Not Implemented');
+    }
+}
+
 const scratch_aabb = [];
 
 class BVHQueryIntersectsRay extends BVHQuery {
-    constructor() {
-        super();
-
-        this.ray = [];
-    }
+    /**
+     *
+     * @type {number[]}
+     */
+    ray = [];
 
     /**
      *
      * @param {number[]|ArrayLike<number>} ray
      * @returns {BVHQueryIntersectsRay}
      */
-    static from(ray){
+    static from(ray) {
         const r = new BVHQueryIntersectsRay();
 
         r.ray = ray;
@@ -110003,7 +110016,7 @@ class WebEnginePlatform extends EnginePlatform {
 class Tag {
     /**
      * @private
-     * @type {String[]}
+     * @type {string[]}
      */
     values = [];
 
@@ -110185,41 +110198,31 @@ class Tag {
      * @return {boolean}
      */
     equals(other) {
-
-        const s0 = this.values;
-
-        const s1 = other.values;
-
-        const n0 = s0.length;
-        const n1 = s1.length;
-
-        if (n0 !== n1) {
-            //wrong length
-            return false;
-        }
-
-        for (let i = 0; i < n0; i++) {
-            const v0 = s0[i];
-            const v1 = s1[i];
-
-            if (v0 !== v1) {
-                return false;
-            }
-        }
-
-        return true;
+        return isArrayEqualStrict(this.values, other.values);
     }
 
     toJSON() {
         return this.values;
     }
 
+    /**
+     *
+     * @param {string[]|string} json
+     */
     fromJSON(json) {
+
+        this.clear();
+
         if (typeof json === "string") {
-            this.clear();
             this.add(json);
-        } else if (Array.isArray(json)) {
-            this.values = json;
+        } else {
+            assert.isArray(json, 'json');
+
+            const n = json.length;
+
+            for (let i = 0; i < n; i++) {
+                this.add(json[i]);
+            }
         }
     }