@woosh/meep-engine 2.96.0 → 2.98.0

package/build/meep.cjs

@@ -53177,7 +53177,7 @@ const SCRATCH_UINT32_TRAVERSAL_STACK = new Uint32Array(781250);
  */
 SCRATCH_UINT32_TRAVERSAL_STACK.pointer = 0;
 
-const fabsf$1 = Math.abs;
+const abs = Math.abs;
 
 /**
  * NOTES:
@@ -53214,7 +53214,7 @@ function aabb3_intersects_ray(
     const diff_x = origin_x - center_x;
 
 
-    if (diff_x * direction_x >= 0.0 && fabsf$1(diff_x) > extents_x) {
+    if (diff_x * direction_x >= 0.0 && abs(diff_x) > extents_x) {
         return false;
     }
 
@@ -53226,7 +53226,7 @@ function aabb3_intersects_ray(
     const diff_y = origin_y - center_y;
 
 
-    if (diff_y * direction_y >= 0.0 && fabsf$1(diff_y) > extents_y) {
+    if (diff_y * direction_y >= 0.0 && abs(diff_y) > extents_y) {
         return false;
     }
 
@@ -53238,28 +53238,28 @@ function aabb3_intersects_ray(
     const diff_z = origin_z - center_z;
 
 
-    if (diff_z * direction_z >= 0.0 && fabsf$1(diff_z) > extents_z) {
+    if (diff_z * direction_z >= 0.0 && abs(diff_z) > extents_z) {
         return false;
     }
 
-    const abs_direction_y = fabsf$1(direction_y);
-    const abs_direction_z = fabsf$1(direction_z);
+    const abs_direction_y = abs(direction_y);
+    const abs_direction_z = abs(direction_z);
 
-    const f0 = fabsf$1(direction_y * diff_z - direction_z * diff_y);
+    const f0 = abs(direction_y * diff_z - direction_z * diff_y);
 
     if (f0 > extents_y * abs_direction_z + extents_z * abs_direction_y) {
         return false;
     }
 
-    const abs_direction_x = fabsf$1(direction_x);
+    const abs_direction_x = abs(direction_x);
 
-    const f1 = fabsf$1(direction_z * diff_x - direction_x * diff_z);
+    const f1 = abs(direction_z * diff_x - direction_x * diff_z);
 
     if (f1 > extents_x * abs_direction_z + extents_z * abs_direction_x) {
         return false;
     }
 
-    const f2 = fabsf$1(direction_x * diff_y - direction_y * diff_x);
+    const f2 = abs(direction_x * diff_y - direction_y * diff_x);
 
     return f2 <= extents_x * abs_direction_y + extents_y * abs_direction_x;
 }
@@ -53338,8 +53338,8 @@ function bvh_query_leaves_ray(
         if (child_1 !== NULL_NODE) {
 
             // this is not a leaf node, push children onto traversal stack
-            stack$9[stack$9.pointer++] = child_1;
             stack$9[stack$9.pointer++] = uint32[address + COLUMN_CHILD_2];
+            stack$9[stack$9.pointer++] = child_1;
 
         } else {
             // leaf node
@@ -54953,19 +54953,22 @@ function ceilPowerOfTwo(v) {
  * @param {number} b_offset
  * @param {number} length How many elements should be moved
  */
-function array_swap(a, a_offset, b, b_offset, length) {
-
-    let i, j, k;
+function array_swap(
+    a, a_offset,
+    b, b_offset,
+    length
+) {
 
-    for (k = 0; k < length; k++) {
-        i = a_offset + k;
-        j = b_offset + k;
+    for (let k = 0; k < length; k++) {
+        const i = a_offset + k;
+        const j = b_offset + k;
 
-        const t = b[j];
+        const swap = b[j];
 
         b[j] = a[i];
-        a[i] = t;
+        a[i] = swap;
     }
+
 }
 
 //
@@ -58825,25 +58828,138 @@ class TerrainTileManager {
     }
 }
 
+class WebGLRendererPool {
+
+    used = new Set();
+
+    get() {
+        const canvas = document.createElement('canvas');
+        const context = canvas.getContext('webgl2', { antialias: true });
+
+        const renderer = new WebGLRenderer({
+            alpha: true,
+            context,
+            canvas
+        });
+
+        this.used.add(renderer);
+        return renderer;
+    }
+
+    /**
+     *
+     * @param {THREE.WebGLRenderer} renderer
+     * @returns {boolean}
+     */
+    release(renderer) {
+        if (!this.used.has(renderer)) {
+            //not from this pool
+            return false;
+        }
+        this.used.delete(renderer);
+
+        renderer.forceContextLoss();
+        renderer.dispose();
+        renderer.domElement = null;
+
+        return true;
+    }
+
+    /**
+     * After callback returns, renderer is released back into the pool
+     * @template T
+     * @param {function(renderer:WebGLRenderer):T} callback
+     * @param {*} [thisArg]
+     */
+    use(callback, thisArg) {
+
+        const renderer = this.get();
+
+        try {
+            const result = callback.call(thisArg, renderer);
+
+            if (result instanceof Promise) {
+            }
+
+            return result;
+
+        } finally {
+
+            this.release(renderer);
+        }
+
+    }
+
+    /**
+     * @template T
+     * @param {function(renderer:WebGLRenderer):Promise<T>} callback
+     * @param {*} [thisArg]
+     */
+    async useAsync(callback, thisArg) {
+
+        const renderer = this.get();
+
+        try {
+            await callback.call(thisArg, renderer);
+        } finally {
+            this.release(renderer);
+        }
+    }
+
+    static global = new WebGLRendererPool();
+}
+
+/**
+ *
+ * @param {Sampler2D} sampler
+ * @param {THREE.DataTexture} texture
+ */
+function writeSample2DDataToDataTexture(sampler, texture) {
+    if (sampler.itemSize === 1) {
+        if (texture.format !== RedFormat && texture.format !== LuminanceFormat) {
+            throw new Error('itemSize is 1 and texture.format is not RedFormat');
+        }
+    } else if (sampler.itemSize === 2) {
+        if (texture.format !== RGFormat) {
+            throw new Error('itemSize is 2 and texture.format is not RGFormat');
+        }
+    } else if (sampler.itemSize === 3) {
+        if (texture.format !== RGBFormat) {
+            throw new Error('itemSize is 2 and texture.format is not RGBFormat');
+        }
+    } else if (sampler.itemSize === 4) {
+        if (texture.format !== RGBAFormat) {
+            throw new Error('itemSize is 2 and texture.format is not RGBAFormat');
+        }
+    } else {
+        throw new Error('Unsupported itemSize');
+    }
+
+    if (texture.image.data !== sampler.data) {
+        // dispose of previous texture data
+        texture.dispose();
+    }
+
+    texture.image.data = sampler.data;
+    texture.image.width = sampler.width;
+    texture.image.height = sampler.height;
+
+    texture.needsUpdate = true;
+}
+
 /**
  * Created by Alex on 10/11/2014.
  */
 
-const AmbientOcclusionShader = function () {
+
+const NormalMapShader = function () {
     return {
 
         uniforms: {
 
-            "normalMap": { type: "t", value: null },
             "heightMap": { type: "t", value: null },
-            "world_size": { type: "v2", value: new Vector2$1(512, 512) },
-            "rayLength": { type: 'f', value: 17 }
-
-        },
+            "resolution": { type: "v2", value: new Vector2$1(512, 512) }
 
-        defines: {
-            'NUM_SAMPLES': 64,
-            'NUM_RINGS': 7,
         },
 
         vertexShader: [
@@ -58859,102 +58975,53 @@ const AmbientOcclusionShader = function () {
 
         ].join("\n"),
 
+        /**
+         * Reference: https://stackoverflow.com/questions/49640250/calculate-normals-from-heightmap
+         */
         fragmentShader: [
-            `
-            uniform sampler2D normalMap;
-            uniform sampler2D heightMap;
-            uniform float rayLength;
-            uniform vec2 world_size;
+            "uniform vec2 resolution;",
+            "uniform sampler2D heightMap;",
 
-            varying vec2 vUv;
+            "#define sqrt2 1.41421356237;",
+
+            "varying vec2 vUv;",
+
+            "void main() {",
+            "   float uStep = 1.0/resolution.x;",
+            "   float vStep = 1.0/resolution.y;",
+            //
+            //
+            "   float top = texture2D( heightMap, vUv + vec2(0, -vStep)).x;",
+            "   float bottom = texture2D( heightMap, vUv + vec2(0, +vStep)).x;",
+            "   float left = texture2D( heightMap, vUv + vec2(-uStep, 0)).x;",
+            "   float right = texture2D( heightMap, vUv + vec2(+uStep, 0)).x;",
+            //
+
+            "   float dX = (right ) - ( left);",
+            "   float dY = (  bottom ) - (  top);",
+            "   float dZ = 2.0;",
+            "   vec3 n = normalize(vec3(dX, dY, dZ));",
+
+            "   gl_FragColor = vec4( n*0.5+0.5, 1.0 );",
+
+            "}"
 
-            vec3 get(float x, float y){
-               vec2 _uv = vUv.xy + vec2(x,y) / world_size;
-               float h = texture2D(heightMap, _uv).x;
-               return vec3( _uv.x * world_size.x, h, _uv.y * world_size.y );
-            }
-            
-            float hash1( float n )
-            {
-                return fract( n*17.0*fract( n*0.3183099 ) );
-            }
-            
-            float hash1( vec2 p )
-            {
-                p  = 50.0*fract( p*0.3183099 );
-                return fract( p.x*p.y*(p.x+p.y) );
-            }
-            
-            // Non-sin based hash function, fast and has good randomness
-            float hash12(vec2 p){
-                vec3 p3  = fract(vec3(p.xyx) * .1031);
-                p3 += dot(p3, p3.yzx + 33.33);
-                return fract((p3.x + p3.y) * p3.z);
-            }
-            
-            const float bias = 0.001;
-            
-            float pow2(float x){
-                return x*x;
-            }
-    
-            float getOcclusion(vec3 origin, vec3 normal, vec3 hit_position){
-                vec3 viewDelta = hit_position - origin;
-                
-                float viewDistance = length( viewDelta );
-                
-                float vn = dot( normal, viewDelta );
-                float a2 = (vn) / viewDistance - bias;
-                float a1 = (1.0 + pow2( viewDistance ) );
-                
-                return max(0.0, a2) / a1;
-            }
-                
-            const float PI2 = 6.28318530717958;
-            const float kernelRadius = 100.0;
-    
-            const float ANGLE_STEP = PI2 * float( NUM_RINGS ) / float( NUM_SAMPLES );
-            const float INV_NUM_SAMPLES = 1.0 / float( NUM_SAMPLES );
-            
-            float getAmbientOcclusion(vec3 world_position, vec3 world_normal){
-                // jsfiddle that shows sample pattern: https://jsfiddle.net/a16ff1p7/
-                float angle = hash12( vUv  ) * PI2;
-                vec2 radius = vec2( rayLength * INV_NUM_SAMPLES );
-                
-                float occlusionSum = 0.0;
-                float weightSum = 0.0;
-                
-                for( int i = 0; i < NUM_SAMPLES; i ++ ) {
-                    vec2 sampleUv = vec2( cos( angle ), sin( angle ) ) * radius * float(i+1);
-                    
-                    angle += ANGLE_STEP;
-                        
-                    vec3 sample_pos = get(sampleUv.x, sampleUv.y);
-                
-                    occlusionSum += getOcclusion(world_position, world_normal, sample_pos);
-                    weightSum += 1.0;
-                }
-                
-                return occlusionSum/weightSum;
-            }
-            
-            void main() {
-               vec3 pos = get(0.0, 0.0);
-               
-               vec3 normal = texture2D( normalMap, vUv ).xzy;
-               
-               float occlusion = getAmbientOcclusion(pos, normal);
-               
-               float incident = 1.0 - occlusion;
-               
-               gl_FragColor = vec4(pow(incident,10.0), 0.0, 0.0, 1.0);
-            }
-            `
         ].join('\n')
 
     }
 };
 
+const FULL_SCREEN_QUAD_VERTEX_SHADER = `        
+        varying vec2 vUv;
+
+        void main() {
+
+            vUv = uv;
+                
+            gl_Position = vec4( (uv - 0.5)*2.0, 0.0, 1.0 );
+            
+        }`;
+
 const FULL_SCREEN_TRIANGLE_GEOMETRY = new BufferGeometry();
 FULL_SCREEN_TRIANGLE_GEOMETRY.setAttribute(
     'position',
@@ -58972,17 +59039,6 @@ FULL_SCREEN_TRIANGLE_GEOMETRY.setAttribute(
     )
 );
 
-const FULL_SCREEN_QUAD_VERTEX_SHADER = `        
-        varying vec2 vUv;
-
-        void main() {
-
-            vUv = uv;
-                
-            gl_Position = vec4( (uv - 0.5)*2.0, 0.0, 1.0 );
-            
-        }`;
-
 /**
  * Created by Alex on 09/11/2014.
  */
@@ -58994,7 +59050,7 @@ const FULL_SCREEN_QUAD_VERTEX_SHADER = `
  * @param {number} width
  * @param {number} height
  * @param {{vertexShader?:string,fragmentShader:string, uniforms?:Object, defines?:Object}} processShader
- * @param {Uint8Array} [destination]
+ * @param {Uint8Array|Uint8ClampedArray} [destination]
  * @return {{array: Uint8Array, renderer: WebGLRenderer}}
  */
 function processTexture(
@@ -59005,7 +59061,7 @@ function processTexture(
     destination
 ) {
     if (destination === undefined) {
-        destination = new Uint8Array(width * height * 4);
+        destination = new Uint8ClampedArray(width * height * 4);
     }
 
     //make a webgl renderer with orthographic camera
@@ -59175,6 +59231,207 @@ function sampler2DtoFloat32Texture(sampler) {
     return texture;
 }
 
+/**
+ * Created by Alex on 15/11/2014.
+ */
+
+
+
+function convertChannel(v) {
+    return (v) / 255 - 0.5;
+}
+
+/**
+ *
+ * @param {number[]|Uint8Array} source
+ * @returns {Float32Array}
+ */
+function rgbaArray2RGB(source) {
+    const length = source.length;
+    const numPixels = Math.floor(length / 4);
+    const target = new Float32Array(numPixels * 3);
+    //
+    let h;
+    for (let i = 0; i < numPixels; i++) {
+        const j = i * 4;
+        const k = i * 3;
+        //normalize source to normal vectors
+        let x = convertChannel(source[j]);
+        let y = convertChannel(source[j + 1]);
+        let z = convertChannel(source[j + 2]);
+        //
+        h = Math.sqrt(x * x + y * y + z * z);
+
+        x /= h;
+        y /= h;
+        z /= h;
+        //
+        target[k] = x;
+        target[k + 1] = y;
+        target[k + 2] = z;
+    }
+    return target;
+}
+
+/**
+ *
+ * @param {WebGLRenderer} renderer
+ * @param {Sampler2D} sampler
+ * @returns {Sampler2D}
+ */
+function heightMap2NormalMap(renderer, sampler) {
+
+    const width = sampler.width;
+    const height = sampler.height;
+
+    const texture = sampler2DtoFloat32Texture(sampler);
+
+    //construct shader
+    const shader = new NormalMapShader();
+    shader.uniforms.heightMap.value = texture;
+    shader.uniforms.resolution.value.set(width, height);
+
+    //perform filtering
+    const result = processTexture(renderer, width, height, shader);
+
+    //create the sampler
+    const array = result.array;
+    const rgb = rgbaArray2RGB(array);
+
+    //reduce array's alpha component
+    return new Sampler2D(rgb, 3, width, height);
+}
+
+/**
+ * Created by Alex on 10/11/2014.
+ */
+
+const AmbientOcclusionShader = function () {
+    return {
+
+        uniforms: {
+
+            "normalMap": { type: "t", value: null },
+            "heightMap": { type: "t", value: null },
+            "world_size": { type: "v2", value: new Vector2$1(512, 512) },
+            "rayLength": { type: 'f', value: 17 }
+
+        },
+
+        defines: {
+            'NUM_SAMPLES': 64,
+            'NUM_RINGS': 7,
+        },
+
+        vertexShader: [
+
+            "varying vec2 vUv;",
+
+            "void main() {",
+
+            "vUv = uv;",
+            "gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+
+            "}"
+
+        ].join("\n"),
+
+        fragmentShader: [
+            `
+            uniform sampler2D normalMap;
+            uniform sampler2D heightMap;
+            uniform float rayLength;
+            uniform vec2 world_size;
+
+            varying vec2 vUv;
+
+            vec3 get(float x, float y){
+               vec2 _uv = vUv.xy + vec2(x,y) / world_size;
+               float h = texture2D(heightMap, _uv).x;
+               return vec3( _uv.x * world_size.x, h, _uv.y * world_size.y );
+            }
+            
+            float hash1( float n )
+            {
+                return fract( n*17.0*fract( n*0.3183099 ) );
+            }
+            
+            float hash1( vec2 p )
+            {
+                p  = 50.0*fract( p*0.3183099 );
+                return fract( p.x*p.y*(p.x+p.y) );
+            }
+            
+            // Non-sin based hash function, fast and has good randomness
+            float hash12(vec2 p){
+                vec3 p3  = fract(vec3(p.xyx) * .1031);
+                p3 += dot(p3, p3.yzx + 33.33);
+                return fract((p3.x + p3.y) * p3.z);
+            }
+            
+            const float bias = 0.001;
+            
+            float pow2(float x){
+                return x*x;
+            }
+    
+            float getOcclusion(vec3 origin, vec3 normal, vec3 hit_position){
+                vec3 viewDelta = hit_position - origin;
+                
+                float viewDistance = length( viewDelta );
+                
+                float vn = dot( normal, viewDelta );
+                float a2 = (vn) / viewDistance - bias;
+                float a1 = (1.0 + pow2( viewDistance ) );
+                
+                return max(0.0, a2) / a1;
+            }
+                
+            const float PI2 = 6.28318530717958;
+            const float kernelRadius = 100.0;
+    
+            const float ANGLE_STEP = PI2 * float( NUM_RINGS ) / float( NUM_SAMPLES );
+            const float INV_NUM_SAMPLES = 1.0 / float( NUM_SAMPLES );
+            
+            float getAmbientOcclusion(vec3 world_position, vec3 world_normal){
+                // jsfiddle that shows sample pattern: https://jsfiddle.net/a16ff1p7/
+                float angle = hash12( vUv  ) * PI2;
+                vec2 radius = vec2( rayLength * INV_NUM_SAMPLES );
+                
+                float occlusionSum = 0.0;
+                float weightSum = 0.0;
+                
+                for( int i = 0; i < NUM_SAMPLES; i ++ ) {
+                    vec2 sampleUv = vec2( cos( angle ), sin( angle ) ) * radius * float(i+1);
+                    
+                    angle += ANGLE_STEP;
+                        
+                    vec3 sample_pos = get(sampleUv.x, sampleUv.y);
+                
+                    occlusionSum += getOcclusion(world_position, world_normal, sample_pos);
+                    weightSum += 1.0;
+                }
+                
+                return occlusionSum/weightSum;
+            }
+            
+            void main() {
+               vec3 pos = get(0.0, 0.0);
+               
+               vec3 normal = texture2D( normalMap, vUv ).xzy;
+               
+               float occlusion = getAmbientOcclusion(pos, normal);
+               
+               float incident = 1.0 - occlusion;
+               
+               gl_FragColor = vec4(pow(incident,10.0), 0.0, 0.0, 1.0);
+            }
+            `
+        ].join('\n')
+
+    }
+};
+
 const KERNEL_SIZE = 15;
 
 const fragment$1 = `
@@ -59372,219 +59629,6 @@ function normalMap2OcclusionMap(
     return result;
 }
 
-/**
- * Created by Alex on 10/11/2014.
- */
-
-
-const NormalMapShader = function () {
-    return {
-
-        uniforms: {
-
-            "heightMap": { type: "t", value: null },
-            "resolution": { type: "v2", value: new Vector2$1(512, 512) }
-
-        },
-
-        vertexShader: [
-
-            "varying vec2 vUv;",
-
-            "void main() {",
-
-            "vUv = uv;",
-            "gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
-
-            "}"
-
-        ].join("\n"),
-
-        /**
-         * Reference: https://stackoverflow.com/questions/49640250/calculate-normals-from-heightmap
-         */
-        fragmentShader: [
-            "uniform vec2 resolution;",
-            "uniform sampler2D heightMap;",
-
-            "#define sqrt2 1.41421356237;",
-
-            "varying vec2 vUv;",
-
-            "void main() {",
-            "   float uStep = 1.0/resolution.x;",
-            "   float vStep = 1.0/resolution.y;",
-            //
-            //
-            "   float top = texture2D( heightMap, vUv + vec2(0, -vStep)).x;",
-            "   float bottom = texture2D( heightMap, vUv + vec2(0, +vStep)).x;",
-            "   float left = texture2D( heightMap, vUv + vec2(-uStep, 0)).x;",
-            "   float right = texture2D( heightMap, vUv + vec2(+uStep, 0)).x;",
-            //
-
-            "   float dX = (right ) - ( left);",
-            "   float dY = (  bottom ) - (  top);",
-            "   float dZ = 2.0;",
-            "   vec3 n = normalize(vec3(dX, dY, dZ));",
-
-            "   gl_FragColor = vec4( n*0.5+0.5, 1.0 );",
-
-            "}"
-
-        ].join('\n')
-
-    }
-};
-
-/**
- * Created by Alex on 15/11/2014.
- */
-
-
-
-function convertChannel(v) {
-    return (v) / 255 - 0.5;
-}
-
-/**
- *
- * @param {number[]|Uint8Array} source
- * @returns {Float32Array}
- */
-function rgbaArray2RGB(source) {
-    const length = source.length;
-    const numPixels = Math.floor(length / 4);
-    const target = new Float32Array(numPixels * 3);
-    //
-    let h;
-    for (let i = 0; i < numPixels; i++) {
-        const j = i * 4;
-        const k = i * 3;
-        //normalize source to normal vectors
-        let x = convertChannel(source[j]);
-        let y = convertChannel(source[j + 1]);
-        let z = convertChannel(source[j + 2]);
-        //
-        h = Math.sqrt(x * x + y * y + z * z);
-
-        x /= h;
-        y /= h;
-        z /= h;
-        //
-        target[k] = x;
-        target[k + 1] = y;
-        target[k + 2] = z;
-    }
-    return target;
-}
-
-/**
- *
- * @param {WebGLRenderer} renderer
- * @param {Sampler2D} sampler
- * @returns {Sampler2D}
- */
-function heightMap2NormalMap(renderer, sampler) {
-
-    const width = sampler.width;
-    const height = sampler.height;
-
-    const texture = sampler2DtoFloat32Texture(sampler);
-
-    //construct shader
-    const shader = new NormalMapShader();
-    shader.uniforms.heightMap.value = texture;
-    shader.uniforms.resolution.value.set(width, height);
-
-    //perform filtering
-    const result = processTexture(renderer, width, height, shader);
-
-    //create the sampler
-    const array = result.array;
-    const rgb = rgbaArray2RGB(array);
-
-    //reduce array's alpha component
-    return new Sampler2D(rgb, 3, width, height);
-}
-
-class WebGLRendererPool {
-
-    used = new Set();
-
-    get(options) {
-        const canvas = document.createElement('canvas');
-        const context = canvas.getContext('webgl2', { antialias: true });
-
-        const renderer = new WebGLRenderer({
-            alpha: true,
-            context,
-            canvas
-        });
-
-        this.used.add(renderer);
-        return renderer;
-    }
-
-    /**
-     *
-     * @param {THREE.WebGLRenderer} renderer
-     * @returns {boolean}
-     */
-    release(renderer) {
-        if (!this.used.has(renderer)) {
-            //not from this pool
-            return false;
-        }
-        this.used.delete(renderer);
-
-        renderer.forceContextLoss();
-        renderer.dispose();
-        renderer.domElement = null;
-
-        return true;
-    }
-
-    static global = new WebGLRendererPool();
-}
-
-/**
- *
- * @param {Sampler2D} sampler
- * @param {THREE.DataTexture} texture
- */
-function writeSample2DDataToDataTexture(sampler, texture) {
-    if (sampler.itemSize === 1) {
-        if (texture.format !== RedFormat && texture.format !== LuminanceFormat) {
-            throw new Error('itemSize is 1 and texture.format is not RedFormat');
-        }
-    } else if (sampler.itemSize === 2) {
-        if (texture.format !== RGFormat) {
-            throw new Error('itemSize is 2 and texture.format is not RGFormat');
-        }
-    } else if (sampler.itemSize === 3) {
-        if (texture.format !== RGBFormat) {
-            throw new Error('itemSize is 2 and texture.format is not RGBFormat');
-        }
-    } else if (sampler.itemSize === 4) {
-        if (texture.format !== RGBAFormat) {
-            throw new Error('itemSize is 2 and texture.format is not RGBAFormat');
-        }
-    } else {
-        throw new Error('Unsupported itemSize');
-    }
-
-    if (texture.image.data !== sampler.data) {
-        // dispose of previous texture data
-        texture.dispose();
-    }
-
-    texture.image.data = sampler.data;
-    texture.image.width = sampler.width;
-    texture.image.height = sampler.height;
-
-    texture.needsUpdate = true;
-}
-
 /**
  *
  * @param {WebGLRenderer} renderer
@@ -59653,32 +59697,25 @@ function promiseSamplerAO(
 function buildLightTexture({
                                       texture,
                                       heightSampler,
-                                      resolution= new Vector2(texture.image.width, texture.image.height),
+                                      resolution = new Vector2(texture.image.width, texture.image.height),
                                       rayLength = 11,
                                       worldSize = resolution
                                   }) {
 
-    const renderer = WebGLRendererPool.global.get();
-
-    const normal = promiseSamplerNormal(renderer, heightSampler);
-    const ao = promiseSamplerAO({
-        renderer: renderer,
-        pSamplerNormal: normal,
-        samplerHeight: heightSampler,
-        resolution: resolution,
-        rayLength: rayLength,
-        worldSize
-    });
+    return WebGLRendererPool.global.useAsync(async renderer => {
+        const normal = promiseSamplerNormal(renderer, heightSampler);
 
-    const promise = ao.then(sampler => {
-        writeSample2DDataToDataTexture(sampler, texture);
-    });
+        const ao = await promiseSamplerAO({
+            renderer: renderer,
+            pSamplerNormal: normal,
+            samplerHeight: heightSampler,
+            resolution: resolution,
+            rayLength: rayLength,
+            worldSize
+        });
 
-    Promise.all([normal, ao]).finally(() => {
-        WebGLRendererPool.global.release(renderer);
+        writeSample2DDataToDataTexture(ao, texture);
     });
-
-    return promise;
 }
 
 const GridTransformKind = {
@@ -59767,7 +59804,7 @@ function invokeObjectHash(object) {
  * @param {number} index0
  * @param {number} index1
  */
-function arraySwapElements(array, index0, index1) {
+function array_swap_one(array, index0, index1) {
     const t = array[index0];
 
     array[index0] = array[index1];
@@ -59821,7 +59858,7 @@ function generate_next_linear_congruential_index(index, mask) {
 /**
  * @template K,V
  */
-class MapEntry {
+class HashMapEntry {
     /**
      *
      * @param {K} key
@@ -59909,7 +59946,7 @@ const UNDEFINED_BIN_INDEX = ~0;
 
 /**
  * @template K,V
- * @param {MapEntry<K,V>} record
+ * @param {HashMapEntry<K,V>} record
  * @param {number} hash
  * @param {K} key
  * @param {function(a:K,b:K):boolean} equality_op
@@ -59949,7 +59986,7 @@ class HashMap {
 
     /**
      * Note that dead entries are marked as such with a special reserved hash values, so records can be reused for new entries
-     * @type {Array<MapEntry<K,V>>}
+     * @type {Array<HashMapEntry<K,V>>}
      */
     #entries = new Array(0);
 
@@ -60127,7 +60164,7 @@ class HashMap {
             entry.key = k;
             entry.value = v;
         } else {
-            this.#entries[i] = new MapEntry(k, v, hash);
+            this.#entries[i] = new HashMapEntry(k, v, hash);
         }
 
         return i;
@@ -60135,7 +60172,7 @@ class HashMap {
 
     /**
      *
-     * @param {MapEntry<K,V>} entry
+     * @param {HashMapEntry<K,V>} entry
      */
     #deallocate(entry) {
 
@@ -60392,7 +60429,7 @@ class HashMap {
             }
 
             /**
-             * @type {MapEntry<K,V>}
+             * @type {HashMapEntry<K,V>}
              */
             const entry = this.#entries[bin - ENTRY_BASE];
 
@@ -60443,7 +60480,7 @@ class HashMap {
 
             if (new_index !== existing_entry_index) {
                 // move entries to the new position, compacting holes
-                arraySwapElements(entries, new_index, existing_entry_index);
+                array_swap_one(entries, new_index, existing_entry_index);
             }
 
             let bin_index = this.#compute_bin_index(hash);
@@ -60497,7 +60534,7 @@ class HashMap {
             }
 
             /**
-             * @type {MapEntry<K,V>}
+             * @type {HashMapEntry<K,V>}
              */
             const entry = entries[bin - ENTRY_BASE];
 
@@ -60568,7 +60605,7 @@ class HashMap {
             }
 
             /**
-             * @type {MapEntry<K,V>}
+             * @type {HashMapEntry<K,V>}
              */
             const entry = entries[bin - ENTRY_BASE];
 
@@ -67266,6 +67303,37 @@ function computeFileExtension(path) {
     }
 }
 
+/**
+ * @param {Uint8Array} input
+ * @param {number} width
+ * @param {number} height
+ * @param {number} channel_count
+ */
+function flipArrayInPlace(input, width, height, channel_count = 4) {
+    const row_size = width * channel_count;
+    let t, x0, x1;
+    let i = 0;
+    const column_count = height >> 1;
+
+    for (; i < column_count; i++) {
+
+        //swap lines
+        const k = (height - i - 1) * row_size;
+        const m = i * row_size;
+
+        for (let j = 0; j < row_size; j++) {
+            x0 = m + j;
+            x1 = k + j;
+
+            t = input[x0];
+
+            input[x0] = input[x1];
+            input[x1] = t;
+        }
+
+    }
+}
+
 /**
  * @author alteredq / http://alteredqualia.com/
  *
@@ -67312,37 +67380,6 @@ const CopyShader = {
 
 };
 
-/**
- * @param {Uint8Array} input
- * @param {number} width
- * @param {number} height
- * @param {number} channel_count
- */
-function flipArrayInPlace(input, width, height, channel_count = 4) {
-    const row_size = width * channel_count;
-    let t, x0, x1;
-    let i = 0;
-    const column_count = height >> 1;
-
-    for (; i < column_count; i++) {
-
-        //swap lines
-        const k = (height - i - 1) * row_size;
-        const m = i * row_size;
-
-        for (let j = 0; j < row_size; j++) {
-            x0 = m + j;
-            x1 = k + j;
-
-            t = input[x0];
-
-            input[x0] = input[x1];
-            input[x1] = t;
-        }
-
-    }
-}
-
 const DEFAULT_TEXTURE_WIDTH = 512;
 const DEFAULT_TEXTURE_HEIGHT = 512;
 
@@ -67351,39 +67388,47 @@ const DEFAULT_TEXTURE_HEIGHT = 512;
  * @param {Texture} texture
  * @param {number} [width]
  * @param {number} [height]
- * @param {boolean} flipY
+ * @param {boolean} [flipY]
  * @return {Sampler2D}
  */
-function convertTexture2Sampler2D(texture, width, height, flipY = true) {
+function convertTexture2Sampler2D(
+    texture,
+    width,
+    height,
+    flipY = true
+) {
+    let _height = height;
+    let _width = width;
+
     // TODO take channel count into account
 
-    if (width === undefined || height === undefined) {
+    if (_width === undefined || _height === undefined) {
 
         //figure out texture size
         const image = texture.image;
 
         if (image !== undefined && image !== null) {
-            if (width === undefined) {
+            if (_width === undefined) {
                 if (typeof image.width === "number") {
-                    width = image.width;
+                    _width = image.width;
                 } else {
-                    width = DEFAULT_TEXTURE_WIDTH;
+                    _width = DEFAULT_TEXTURE_WIDTH;
                 }
             }
-            if (height === undefined) {
+            if (_height === undefined) {
                 if (typeof image.height === "number") {
-                    height = image.height;
+                    _height = image.height;
                 } else {
-                    height = DEFAULT_TEXTURE_HEIGHT;
+                    _height = DEFAULT_TEXTURE_HEIGHT;
                 }
             }
         } else {
-            if (width === undefined) {
-                width = DEFAULT_TEXTURE_WIDTH;
+            if (_width === undefined) {
+                _width = DEFAULT_TEXTURE_WIDTH;
             }
 
-            if (height === undefined) {
-                height = DEFAULT_TEXTURE_HEIGHT;
+            if (_height === undefined) {
+                _height = DEFAULT_TEXTURE_HEIGHT;
             }
         }
 
@@ -67391,34 +67436,32 @@ function convertTexture2Sampler2D(texture, width, height, flipY = true) {
 
     // TODO add special case for DataTexture
 
-    const renderer = WebGLRendererPool.global.get({});
+    const built = WebGLRendererPool.global.use(renderer => {
+
+        const ctx = renderer.getContext();
 
-    const ctx = renderer.getContext();
+        //support for compressed textures
+        ctx.getExtension("WEBGL_compressed_texture_s3tc");
 
-    //support for compressed textures
-    ctx.getExtension("WEBGL_compressed_texture_s3tc");
+        return processTexture(renderer, _width, _height, {
+            vertexShader: CopyShader.vertexShader,
+            fragmentShader: CopyShader.fragmentShader,
+            uniforms: {
+                tDiffuse: {
+                    value: texture,
+                    type: 't'
+                },
+                opacity: { value: 1.0 }
+            }
+        });
 
-    const built = processTexture(renderer, width, height, {
-        vertexShader: CopyShader.vertexShader,
-        fragmentShader: CopyShader.fragmentShader,
-        uniforms: {
-            tDiffuse: {
-                value: texture,
-                type: 't'
-            },
-            opacity: { value: 1.0 }
-        }
     });
 
-    WebGLRendererPool.global.release(renderer);
-
     if (flipY) {
-        flipArrayInPlace(built.array, width, height);
+        flipArrayInPlace(built.array, _width, _height);
     }
 
-    const sampler = new Sampler2D(built.array, 4, width, height);
-
-    return sampler;
+    return new Sampler2D(built.array, 4, _width, _height);
 }
 
 /**
@@ -69049,10 +69092,14 @@ class Camera {
      * @param {Camera|THREE.PerspectiveCamera|THREE.OrthographicCamera} camera
      * @param {number} x
      * @param {number} y
-     * @param {Vector3} source
-     * @param {Vector3} direction
+     * @param {Vector3} out_source
+     * @param {Vector3} out_direction
      */
-    static projectRay(camera, x, y, source, direction) {
+    static projectRay(
+        camera,
+        x, y,
+        out_source, out_direction
+    ) {
 
         // assert.ok(x >= -1, `X(=${x}) must be greater than or equal to -1.0, not a clip-space coordinate`);
         // assert.ok(x <= 1, `X(=${x}) must be less than or equal to 1.0, not a clip-space coordinate`);
@@ -69061,7 +69108,10 @@ class Camera {
         // assert.ok(y <= 1, `Y(=${y}) must be less than or equal to 1.0, not a clip-space coordinate`);
 
         if (camera.isPerspectiveCamera || camera.isOrthographicCamera) {
-            scratch_v3_1.setFromMatrixPosition(camera.matrixWorld.elements);
+            const m4_world = camera.matrixWorld.elements;
+            const m4_projection_inverse = camera.projectionMatrixInverse.elements;
+
+            scratch_v3_1.setFromMatrixPosition(m4_world);
 
             scratch_v3_0.set(x, y, 0.5);
 
@@ -69070,16 +69120,16 @@ class Camera {
             unprojectPoint(
                 scratch_v3_0,
                 scratch_v3_0,
-                camera.projectionMatrixInverse.elements,
-                camera.matrixWorld.elements
+                m4_projection_inverse,
+                m4_world
             );
 
             //get direction
             scratch_v3_0.sub(scratch_v3_1);
             scratch_v3_0.normalize();
 
-            source.copy(scratch_v3_1);
-            direction.copy(scratch_v3_0);
+            out_source.copy(scratch_v3_1);
+            out_direction.copy(scratch_v3_0);
 
         } else {
             throw new Error('Unsupported camera type');
@@ -69974,13 +70024,15 @@ BitSet.prototype.setShrinkFactor = function (x) {
 
 /**
  *
- * @param {number} numBits
+ * @param {number} bit_count
  */
-BitSet.prototype.setCapacity = function (numBits) {
-    if (this.__length > numBits) {
-        throw  new Error(`Current length is greater than requested size`);
+BitSet.prototype.setCapacity = function (bit_count) {
+
+    if (this.__length > bit_count) {
+        throw  new Error(`Current length(=${this.__length}) is greater than requested size(=${bit_count})`);
     }
-    this.__resize(numBits);
+
+    this.__resize(bit_count);
 };
 
 /**
@@ -71492,8 +71544,17 @@ class Graph {
      */
     findPath(start, goal) {
         const start_node_container = this.__nodes.get(start);
+
+        if (start_node_container === undefined) {
+            throw new Error(`Start node not found in the graph '${start}'`);
+        }
+
         const goal_node_container = this.__nodes.get(goal);
 
+        if (goal_node_container === undefined) {
+            throw new Error(`Goal node not found in the graph '${goal}'`);
+        }
+
         const open = new Set();
         open.add(start_node_container);
 
@@ -74579,7 +74640,7 @@ function arrayQuickSort(
     data,
     score_function, score_function_context,
     start, end,
-    swap_operator = arraySwapElements, swap_context = undefined
+    swap_operator = array_swap_one, swap_context = undefined
 ) {
     if (start >= end) {
         // section of 0 size, nothing to sort
@@ -81304,6 +81365,7 @@ class Token {
      * @param {T} type
      */
     constructor(value, start, end, name, type) {
+
         /**
          * @readonly
          * @type {V}
@@ -81353,8 +81415,7 @@ class Token {
      * @return {number}
      */
     hash() {
-        // TODO make an actual hash
-        return 0;
+        return this.start ^ (this.end << 16);
     }
 }
 
@@ -81370,10 +81431,71 @@ const TooltipTokenType = {
     ReferenceValue: 4,
 };
 
-function ParserError(position, message, input) {
-    this.position = position;
-    this.message = message;
-    this.input = input;
+/**
+ * Repeat a given piece of text a {@link count} times
+ * @example "ABC_" repeated 2 times results in "ABC_ABC_"
+ * @param {string} what
+ * @param {number} count
+ * @return {string}
+ */
+function string_repeat(what, count) {
+
+    if (count <= 0) {
+        // special case
+        return "";
+    }
+
+    let out = what;
+
+    for (let i = 1; i < count; i++) {
+        out += what;
+    }
+
+    return out;
+}
+
+class ParserError extends Error {
+    /**
+     *
+     * @param {number} position
+     * @param {string} message
+     * @param {string} input
+     */
+    constructor(
+        position,
+        message,
+        input
+    ) {
+
+        super();
+
+        this.position = position;
+        this.message = message;
+        this.input = input;
+    }
+
+    getDetails() {
+        const input = this.input;
+        const position = this.position;
+
+        // get snippet around where the problem has occurred
+        const input_start = max2(0, position - 10);
+
+        const input_end = min2(input.length, position + 10);
+
+        const snippet = input.slice(input_start, input_end);
+
+        const offset_into_snippet = position - input_start;
+
+        // a piece of text with marker to show where the error occurs
+        const arrow_text = string_repeat(" ", offset_into_snippet) + "^";
+
+        return snippet + "\n" + arrow_text;
+    }
+
+    toString() {
+        return `[ParseError] ${this.message}. Error at position ${this.position} near:\n${this.getDetails()}`
+    }
 }
 
 /**
@@ -81469,28 +81591,6 @@ class KeyValuePair {
     }
 }
 
-/**
- *
- * @param {string} text
- * @param {number} cursor
- * @param {number} length
- * @returns {number}
- */
-function skipWhitespace(text, cursor, length) {
-    let i = cursor;
-    let char;
-    while (i < length) {
-        char = text.charAt(i);
-
-        if (char === ' ' || char === '\n' || char === '\t') {
-            i++;
-        } else {
-            break;
-        }
-    }
-    return i;
-}
-
 /**
  *
  * @enum {string}
@@ -81505,7 +81605,7 @@ const DataType = {
 };
 
 /**
- * @enum {{LiteralString: string, LiteralNumber: string, LiteralBoolean: string}}
+ * @enum {string}
  */
 const TokenType = {
     LiteralString: "literal-string",
@@ -81523,6 +81623,7 @@ const TokenType = {
  * @returns {Token}
  */
 function readBooleanToken(text, cursor, length) {
+
     const firstChar = text.charAt(cursor);
 
     let value;
@@ -81549,96 +81650,6 @@ function readBooleanToken(text, cursor, length) {
     return new Token(value, cursor, end, TokenType.LiteralBoolean, DataType.Boolean);
 }
 
-/**
- *
- * @param {string} text
- * @param {number} cursor
- * @returns {string}
- */
-function readQuote(text, cursor) {
-    const char = text.charAt(cursor);
-
-    if (char !== '"' && char !== '\'') {
-        throw new ParserError(cursor, "Expected \", found " + char + " instead", text);
-    }
-
-    return char;
-}
-
-/**
- *
- * @param {string} text
- * @param {number} cursor
- * @param {number} length
- * @returns {Token}
- */
-function readStringToken(text, cursor, length) {
-    let i = cursor;
-
-    const openingQuote = readQuote(text, i);
-
-    i++;
-
-    let char;
-
-    let value = '';
-    const lastPossibleChar = length - 1;
-
-    for (; i < lastPossibleChar; i++) {
-        char = text.charAt(i);
-
-        if (char === '\\') {
-            i++;
-            //read escape sequence
-            char = text.charAt(i);
-
-            switch (char) {
-                case 'n':
-                    value += '\n';
-                    break;
-                case 't':
-                    value += '\t';
-                    break;
-                case 'r':
-                    value += '\r';
-                    break;
-                case 'b':
-                    value += '\b';
-                    break;
-                case 'f':
-                    value += '\f';
-                    break;
-                case 'v':
-                    value += '\v';
-                    break;
-                case '0':
-                    value += '\0';
-                    break;
-                case '\\':
-                case "'":
-                case '"':
-                default:
-                    value += char;
-                    break;
-            }
-        } else if (char !== openingQuote) {
-            value += char;
-        } else {
-            break;
-        }
-    }
-
-    char = text.charAt(i);
-
-    if (char !== openingQuote) {
-        throw new ParserError(cursor, "Expected string terminator : " + openingQuote + ", but found '" + char + "' instead", text);
-    }
-
-    i++;
-
-    return new Token(value, cursor, i, TokenType.LiteralString, DataType.String);
-}
-
 /**
  *
  * @param {string} text
@@ -81647,6 +81658,7 @@ function readStringToken(text, cursor, length) {
  * @returns {Token}
  */
 function readHexToken(text, cursor, length) {
+
     const c0 = text.charAt(cursor);
     const c1 = text.charAt(cursor + 1);
 
@@ -81728,7 +81740,7 @@ function readHexToken(text, cursor, length) {
     }
 
 
-    return new Token(value, cursor, i, null, DataType.Number);
+    return new Token(value, cursor, i, "uint", DataType.Number);
 }
 
 /**
@@ -81739,6 +81751,7 @@ function readHexToken(text, cursor, length) {
  * @returns {Token}
  */
 function readUnsignedIntegerToken(text, cursor, length) {
+
     let i = cursor;
 
     let value = 0;
@@ -81790,7 +81803,32 @@ function readUnsignedIntegerToken(text, cursor, length) {
     }
 
 
-    return new Token(value, cursor, i, null, DataType.Number);
+    return new Token(value, cursor, i, "uint", DataType.Number);
+}
+
+/**
+ *
+ * @param {string} text
+ * @param {number} cursor
+ * @param {number} length
+ * @returns {number}
+ */
+function skipWhitespace(text, cursor, length) {
+
+    let i = cursor;
+    let char;
+
+    while (i < length) {
+        char = text.charAt(i);
+
+        if (char === ' ' || char === '\n' || char === '\t') {
+            i++;
+        } else {
+            break;
+        }
+    }
+
+    return i;
 }
 
 /**
@@ -81801,6 +81839,7 @@ function readUnsignedIntegerToken(text, cursor, length) {
  * @returns {Token}
  */
 function readNumberToken(text, cursor, length) {
+
     let i = cursor;
 
     //read optional sign
@@ -81860,6 +81899,97 @@ function readNumberToken(text, cursor, length) {
     return new Token(value, cursor, i, TokenType.LiteralNumber, DataType.Number);
 }
 
+/**
+ *
+ * @param {string} text
+ * @param {number} cursor
+ * @returns {string}
+ */
+function readQuote(text, cursor) {
+    const char = text.charAt(cursor);
+
+    if (char !== '"' && char !== '\'') {
+        throw new ParserError(cursor, "Expected \", found " + char + " instead", text);
+    }
+
+    return char;
+}
+
+/**
+ *
+ * @param {string} text
+ * @param {number} cursor
+ * @param {number} length
+ * @returns {Token}
+ */
+function readStringToken(text, cursor, length) {
+
+    let i = cursor;
+
+    const openingQuote = readQuote(text, i);
+
+    i++;
+
+    let char;
+
+    let value = '';
+    const lastPossibleChar = length - 1;
+
+    for (; i < lastPossibleChar; i++) {
+        char = text.charAt(i);
+
+        if (char === '\\') {
+            i++;
+            //read escape sequence
+            char = text.charAt(i);
+
+            switch (char) {
+                case 'n':
+                    value += '\n';
+                    break;
+                case 't':
+                    value += '\t';
+                    break;
+                case 'r':
+                    value += '\r';
+                    break;
+                case 'b':
+                    value += '\b';
+                    break;
+                case 'f':
+                    value += '\f';
+                    break;
+                case 'v':
+                    value += '\v';
+                    break;
+                case '0':
+                    value += '\0';
+                    break;
+                case '\\':
+                case "'":
+                case '"':
+                default:
+                    value += char;
+                    break;
+            }
+        } else if (char !== openingQuote) {
+            value += char;
+        } else {
+            break;
+        }
+    }
+
+    char = text.charAt(i);
+
+    if (char !== openingQuote) {
+        throw new ParserError(cursor, "Expected string terminator : " + openingQuote + ", but found '" + char + "' instead", text);
+    }
+
+    i++;
+
+    return new Token(value, cursor, i, TokenType.LiteralString, DataType.String);
+}
+
 /**
  *
  * @param {string} text
@@ -81918,6 +82048,7 @@ function readArrayLiteral(text, cursor, length) {
  * @returns {Token}
  */
 function readLiteralToken(text, cursor, length) {
+
     const firstChar = text.charAt(cursor);
 
     switch (firstChar) {
@@ -82205,22 +82336,20 @@ function seedVariablesIntoTemplateString(template, seed) {
 }
 
 /**
- * Calculate the Jaro-Winkler distance between two strings
- * @param {string} first The string to compare
- * @param {string} second The string to compare with
- * @returns {number} similarity score, higher value means strings are more similar
+ * Calculate Jaro distance between two strings, this is a measure of string similarity. Higher value means more similarity.
+ * @param {string} first
+ * @param {string} second
+ * @param {number} first_length
+ * @param {number} second_length
+ * @return {number}
  */
-function string_jaro_winkler(first, second) {
-    const l1 = first.length;
-    const l2 = second.length;
-
-    if (l1 === 0 && l2 === 0) {
-        // special case for empty string
-        return 1;
-    }
+function string_jaro_distance(
+    first, second,
+    first_length, second_length
+) {
 
-    const matches1 = BitSet.fixedSize(l1);
-    const matches2 = BitSet.fixedSize(l2);
+    const matches1 = BitSet.fixedSize(first_length);
+    const matches2 = BitSet.fixedSize(second_length);
 
     const matches = getMatching(first, second, matches1, matches2);
 
@@ -82228,15 +82357,9 @@ function string_jaro_winkler(first, second) {
         return 0;
     }
 
-    // Calculate the Jaro distance:
     const transpositions = getTranspositions(first, second, matches1, matches2);
-    const similarity = (matches / l1 + matches / l2 + (matches - transpositions) / matches) / 3;
+    return (matches / first_length + matches / second_length + (matches - transpositions) / matches) / 3;
 
-    // Transform to Jaro-Winkler:
-    // Prefix scale gives more favorable ratings to strings that share common prefixes:
-    const prefix_scale = 0.1;
-    const prefix = getPrefix(first, second, min3(l1, l2, 4));
-    return similarity + prefix * prefix_scale * (1 - similarity);
 }
 
 /**
@@ -82298,8 +82421,12 @@ function getMatching(a1, a2, matches1, matches2) {
  * @param {string} a2 The second string to compare
  * @param {BitSet} matches1
  * @param {BitSet} matches2
+ * @returns {number}
  */
-function getTranspositions(a1, a2, matches1, matches2) {
+function getTranspositions(
+    a1, a2,
+    matches1, matches2
+) {
     let transpositions = 0;
 
     // Loop to find transpositions:
@@ -82330,6 +82457,36 @@ function getTranspositions(a1, a2, matches1, matches2) {
     }
 
     return Math.floor(transpositions * 0.5);
+}
+
+/**
+ * Calculate the Jaro-Winkler distance between two strings
+ * @param {string} first The string to compare
+ * @param {string} second The string to compare with
+ * @returns {number} similarity score, higher value means strings are more similar
+ */
+function string_jaro_winkler(first, second) {
+    const l1 = first.length;
+    const l2 = second.length;
+
+    if (l1 === 0 && l2 === 0) {
+        // special case for empty string
+        return 1;
+    }
+
+    // Calculate the Jaro distance:
+    const similarity = string_jaro_distance(first, second, l1, l2);
+
+    if (similarity === 0) {
+        // no similarity at all
+        return 0;
+    }
+
+    // Transform to Jaro-Winkler:
+    // Prefix scale gives more favorable ratings to strings that share common prefixes:
+    const prefix_scale = 0.1;
+    const prefix = getPrefix(first, second, min3(l1, l2, 4));
+    return similarity + prefix * prefix_scale * (1 - similarity);
 }
 
 /**
@@ -83871,11 +84028,14 @@ class BinaryHeap {
     }
 }
 
+/**
+ * Decorator that wraps another map and lets you observe mutations
+ * @template K,V
+ */
 class ObservedMap {
     /**
      * @template K,V
      * @constructor
-     * @property {number} size
      */
     constructor(source = new Map()) {
         this.on = {
@@ -83958,10 +84118,11 @@ const STATUS_NORMAL = 2;
 class Deque {
     /**
      * @template T
+     * @param {number} [min_size]
      */
-    constructor(minSize = DEFAULT_SIZE) {
+    constructor(min_size = DEFAULT_SIZE) {
 
-        const size = ceilPowerOfTwo(max2(1, minSize));
+        const size = ceilPowerOfTwo(max2(1, min_size));
 
         /**
          * Using static array allocator to preserve data locality.
@@ -83972,15 +84133,31 @@ class Deque {
          */
         this.__data = new Array(size);
 
+        /**
+         *
+         * @type {number}
+         * @private
+         */
         this.__head = 0;
+        /**
+         *
+         * @type {number}
+         * @private
+         */
         this.__tail = 0;
 
+        /**
+         *
+         * @type {number}
+         * @private
+         */
         this.__status = STATUS_EMPTY;
     }
 
     /**
      *
      * @param {boolean} adding
+     * @private
      */
     resetStatus(adding) {
         const head = this.__head;
@@ -83999,11 +84176,12 @@ class Deque {
      * @returns {number}
      * @private
      */
-    __circularBiggerPos(current) {
-        // TODO this can be done faster using mod operator (%)
+    __circular_next_position(current) {
         const next = current + 1;
 
-        return (next >= this.__data.length) ? 0 : next;
+        const length = this.__data.length;
+
+        return (next >= length) ? 0 : next;
     }
 
     /**
@@ -84012,43 +84190,57 @@ class Deque {
      * @returns {number}
      * @private
      */
-    __circularSmallerPos(current) {
+    __circular_previous_position(current) {
         const prev = current - 1;
         return (prev < 0) ? (this.__data.length - 1) : prev;
     }
 
-    __checkAndExpand() {
+    __check_and_expand() {
         const status = this.__status;
+
         if (status !== STATUS_FULL) {
+            // queue still has space, we're done
             return;
         }
+
         const length = this.__data.length;
 
-        if (Number.MAX_SAFE_INTEGER === length) {
+        if (UINT32_MAX === length) {
             throw new Error('Maximum array size exceeded');
         }
 
-        let newLength = length * 2;
+        let new_length = length * 2;
+
         // bigger than Integer.MAX_VALUE
-        if (newLength < 0) {
-            newLength = Number.MAX_SAFE_INTEGER;
+        if (new_length > UINT32_MAX) {
+            new_length = UINT32_MAX;
         }
 
-        const newElements = new Array(newLength);
+        /**
+         *
+         * @type {T[]}
+         */
+        const new_data = new Array(new_length);
 
-        // copy front portion of data
         const head = this.__head;
 
-        array_copy(this.__data, head, newElements, 0, length - head);
-        array_copy(this.__data, 0, newElements, length - head, head);
+        // copy the front portion
+        array_copy(this.__data, head, new_data, 0, length - head);
+        // copy the remainder
+        array_copy(this.__data, 0, new_data, length - head, head);
 
         this.__head = 0;
         this.__tail = length;
+
         this.__status = STATUS_NORMAL;
 
-        this.__data = newElements;
+        this.__data = new_data;
     }
 
+    /**
+     *
+     * @return {boolean}
+     */
     isEmpty() {
         return this.size() === 0;
     }
@@ -84060,7 +84252,7 @@ class Deque {
 
             do {
                 this.__data[cursor] = undefined;
-                cursor = this.__circularBiggerPos(cursor);
+                cursor = this.__circular_next_position(cursor);
             } while (cursor !== tail);
 
             this.__status = STATUS_EMPTY;
@@ -84089,32 +84281,45 @@ class Deque {
     /**
      *
      * @param {number} current
-     * @param {boolean} frontShift
+     * @param {boolean} shift_front should we shift elements before the removed element or after?
      * @private
      */
-    __removeInternal(current, frontShift) {
+    __remove_internal(current, shift_front) {
         let cursor = current;
-        if (frontShift) {
+
+        if (shift_front) {
+
+            // shift towards tail
+
             const head = this.__head;
+
             while (cursor !== head) {
-                const next = this.__circularSmallerPos(cursor);
+                const next = this.__circular_previous_position(cursor);
                 this.__data[cursor] = this.__data[next];
                 cursor = next;
             }
-            this.__head = this.__circularBiggerPos(head);
+
+            this.__head = this.__circular_next_position(head);
+
         } else {
+
+            // shift towards head
+
             const tail = this.__tail;
 
             while (cursor !== tail) {
-                const next = this.__circularBiggerPos(cursor);
+                const next = this.__circular_next_position(cursor);
                 this.__data[cursor] = this.__data[next];
                 cursor = next;
             }
 
-            this.__tail = this.__circularSmallerPos(tail);
+            this.__tail = this.__circular_previous_position(tail);
+
         }
 
+        // fill in slot of last moved element
         this.__data[cursor] = undefined;
+
         this.resetStatus(false);
     }
 
@@ -84130,7 +84335,7 @@ class Deque {
             return false;
         }
 
-        this.__removeInternal(i, true);
+        this.__remove_internal(i, true);
 
         return true;
     }
@@ -84174,20 +84379,20 @@ class Deque {
      * @param {T} e
      */
     addFirst(e) {
-        this.__checkAndExpand();
-        this.__head = this.__circularSmallerPos(this.__head);
+        this.__check_and_expand();
+        this.__head = this.__circular_previous_position(this.__head);
         this.__data[this.__head] = e;
         this.resetStatus(true);
     }
 
     /**
      * Remove element from the front of the queue
-     * @returns {T}
+     * @returns {T|undefined}
      */
     removeFirst() {
         const element = this.__data[this.__head];
         this.__data[this.__head] = undefined;
-        this.__head = this.__circularBiggerPos(this.__head);
+        this.__head = this.__circular_next_position(this.__head);
         this.resetStatus(false);
         return element;
     }
@@ -84205,9 +84410,9 @@ class Deque {
      * @param {T} e
      */
     addLast(e) {
-        this.__checkAndExpand();
+        this.__check_and_expand();
         this.__data[this.__tail] = e;
-        this.__tail = this.__circularBiggerPos(this.__tail);
+        this.__tail = this.__circular_next_position(this.__tail);
         this.resetStatus(true);
     }
 
@@ -84216,7 +84421,7 @@ class Deque {
      * @returns {T}
      */
     removeLast() {
-        const last = this.__circularSmallerPos(this.__tail);
+        const last = this.__circular_previous_position(this.__tail);
         const element = this.__data[last];
         this.__data[last] = undefined;
         this.__tail = last;
@@ -84227,10 +84432,10 @@ class Deque {
 
     /**
      * Peek element from the end of the queue without removing it
-     * @returns {T}
+     * @returns {T|undefined}
      */
     getLast() {
-        const last = this.__circularSmallerPos(this.__tail);
+        const last = this.__circular_previous_position(this.__tail);
         return this.__data[last];
     }
 }
@@ -85938,35 +86143,44 @@ Preloader.prototype.load = function (assetManager) {
     return this;
 };
 
-class AbstractMetric {
-    /**
-     *
-     * @param {number} value
-     * @returns {void}
-     */
-    record(value) {
-        throw new Error('Not implemented');
-    }
+/**
+ * @template V
+ * @param {V[]} data
+ * @param {number} [start]
+ * @param {number} [end]
+ * @return {number}
+ */
+function array_compute_max(data, start = 0, end = data.length) {
+    let result = Number.NEGATIVE_INFINITY;
 
-    /**
-     * @returns {number|undefined}
-     */
-    getLastRecord() {
-        throw new Error('Not implemented');
+    for (let i = start; i < end; i++) {
+        const value = data[i];
+        if (value > result) {
+            result = value;
+        }
     }
 
-    /**
-     *
-     * @param {MetricStatistics} result
-     * @returns {boolean} whether metric was successfully computed or not
-     */
-    computeStats(result) {
-        throw new Error('Not implemented');
-    }
+    return result;
+}
+
+/**
+ * @template V
+ * @param {V[]} data
+ * @param {number} [start]
+ * @param {number} [end]
+ * @return {number}
+ */
+function array_compute_min(data, start = 0, end = data.length) {
+    let result = Number.POSITIVE_INFINITY;
 
-    clear() {
-        throw new Error('Not implemented');
+    for (let i = start; i < end; i++) {
+        const value = data[i];
+        if (value < result) {
+            result = value;
+        }
     }
+
+    return result;
 }
 
 class RingBuffer {
@@ -86236,44 +86450,35 @@ function computeStatisticalPartialMedian(values, start, end) {
     return copy[position];
 }
 
-/**
- * @template V
- * @param {V[]} data
- * @param {number} [start]
- * @param {number} [end]
- * @return {number}
- */
-function computeArrayMax(data, start = 0, end = data.length) {
-    let result = Number.NEGATIVE_INFINITY;
-
-    for (let i = start; i < end; i++) {
-        const value = data[i];
-        if (value > result) {
-            result = value;
-        }
+class AbstractMetric {
+    /**
+     *
+     * @param {number} value
+     * @returns {void}
+     */
+    record(value) {
+        throw new Error('Not implemented');
     }
 
-    return result;
-}
-
-/**
- * @template V
- * @param {V[]} data
- * @param {number} [start]
- * @param {number} [end]
- * @return {number}
- */
-function computeArrayMin(data, start = 0, end = data.length) {
-    let result = Number.POSITIVE_INFINITY;
+    /**
+     * @returns {number|undefined}
+     */
+    getLastRecord() {
+        throw new Error('Not implemented');
+    }
 
-    for (let i = start; i < end; i++) {
-        const value = data[i];
-        if (value < result) {
-            result = value;
-        }
+    /**
+     *
+     * @param {MetricStatistics} result
+     * @returns {boolean} whether metric was successfully computed or not
+     */
+    computeStats(result) {
+        throw new Error('Not implemented');
     }
 
-    return result;
+    clear() {
+        throw new Error('Not implemented');
+    }
 }
 
 class RingBufferMetric extends AbstractMetric {
@@ -86330,8 +86535,8 @@ class RingBufferMetric extends AbstractMetric {
 
             result.mean = computeStatisticalMean(array, 0, data_count);
             result.median = computeStatisticalPartialMedian(array, 0, data_count - 1);
-            result.max = computeArrayMax(array, 0, data_count);
-            result.min = computeArrayMin(array, 0, data_count);
+            result.max = array_compute_max(array, 0, data_count);
+            result.min = array_compute_min(array, 0, data_count);
 
             return true;
 
@@ -110035,7 +110240,7 @@ class LightManager {
     __build_view_frustum(camera) {
         frustum_from_camera(camera, this.__view_frustum, false);
 
-        arraySwapElements(this.__view_frustum.planes, 4, 5);
+        array_swap_one(this.__view_frustum.planes, 4, 5);
 
         this.__build_view_frustum_points();
     }