From 11bd428c0721f9d80b31a371d01ebf371884ed75 Mon Sep 17 00:00:00 2001
From: Nathan Bierema <nbierema@gmail.com>
Date: Sun, 3 Mar 2024 10:46:59 -0500
Subject: [PATCH 01/36] fix(types): stub TextureEncoding (#347)

---
 src/objects/Reflector.d.ts | 3 ++-
 src/objects/Refractor.d.ts | 3 ++-
 src/objects/Water2.d.ts    | 3 ++-
 src/types/shared.ts        | 7 +++++++
 4 files changed, 13 insertions(+), 3 deletions(-)

diff --git a/src/objects/Reflector.d.ts b/src/objects/Reflector.d.ts
index bdae2e9e..491e75c5 100644
--- a/src/objects/Reflector.d.ts
+++ b/src/objects/Reflector.d.ts
@@ -1,4 +1,5 @@
-import { Mesh, BufferGeometry, Color, TextureEncoding, WebGLRenderTarget, PerspectiveCamera } from 'three'
+import { Mesh, BufferGeometry, Color, WebGLRenderTarget, PerspectiveCamera } from 'three'
+import { TextureEncoding } from '../types/shared'
 
 export interface ReflectorOptions {
   color?: Color | string | number
diff --git a/src/objects/Refractor.d.ts b/src/objects/Refractor.d.ts
index 37b5bb7f..83ed8e1f 100644
--- a/src/objects/Refractor.d.ts
+++ b/src/objects/Refractor.d.ts
@@ -1,4 +1,5 @@
-import { Mesh, BufferGeometry, Color, TextureEncoding, WebGLRenderTarget, PerspectiveCamera } from 'three'
+import { Mesh, BufferGeometry, Color, WebGLRenderTarget, PerspectiveCamera } from 'three'
+import { TextureEncoding } from '../types/shared'
 
 export interface RefractorOptions {
   color?: Color | string | number
diff --git a/src/objects/Water2.d.ts b/src/objects/Water2.d.ts
index 23a53e91..2bfdc53d 100644
--- a/src/objects/Water2.d.ts
+++ b/src/objects/Water2.d.ts
@@ -1,4 +1,5 @@
-import { BufferGeometry, Color, Mesh, ShaderMaterial, Texture, TextureEncoding, Vector2 } from 'three'
+import { BufferGeometry, Color, Mesh, ShaderMaterial, Texture, Vector2 } from 'three'
+import { TextureEncoding } from '../types/shared'
 
 export interface Water2Options {
   color?: Color | string | number
diff --git a/src/types/shared.ts b/src/types/shared.ts
index f13fe65b..c8edf4be 100644
--- a/src/types/shared.ts
+++ b/src/types/shared.ts
@@ -19,3 +19,10 @@ export type TypedArrayConstructors =
   | Uint32Array['constructor']
   | Float32Array['constructor']
   | Float64Array['constructor']
+
+type LinearEncoding = 3000
+type sRGBEncoding = 3001
+/**
+ * Stub for `TextureEncoding` type since it was removed in r162.
+ */
+export type TextureEncoding = LinearEncoding | sRGBEncoding

From ba6a58d46e2c8d24f574da4b3537ada54a37dce3 Mon Sep 17 00:00:00 2001
From: Nathan Bierema <nbierema@gmail.com>
Date: Sun, 3 Mar 2024 10:47:21 -0500
Subject: [PATCH 02/36] fix(types): Remove usages of ambient THREE namespace
 (#346)

---
 src/animation/MMDPhysics.d.ts     | 8 ++++----
 src/controls/OrbitControls.ts     | 7 ++-----
 src/utils/RoughnessMipmapper.d.ts | 4 ++--
 3 files changed, 8 insertions(+), 11 deletions(-)

diff --git a/src/animation/MMDPhysics.d.ts b/src/animation/MMDPhysics.d.ts
index eb3f20e2..fcdf615c 100644
--- a/src/animation/MMDPhysics.d.ts
+++ b/src/animation/MMDPhysics.d.ts
@@ -1,4 +1,4 @@
-import { Bone, Euler, Matrix4, Object3D, Quaternion, SkinnedMesh, Vector3 } from 'three'
+import { Bone, Euler, Matrix4, MeshBasicMaterial, Object3D, Quaternion, SkinnedMesh, Vector3 } from 'three'
 
 export interface MMDPhysicsParameter {
   unitStep?: number | undefined
@@ -110,10 +110,10 @@ export class Constraint {
 }
 
 export class MMDPhysicsHelper extends Object3D {
-  mesh: THREE.SkinnedMesh
+  mesh: SkinnedMesh
   physics: MMDPhysics
-  materials: [THREE.MeshBasicMaterial, THREE.MeshBasicMaterial, THREE.MeshBasicMaterial]
+  materials: [MeshBasicMaterial, MeshBasicMaterial, MeshBasicMaterial]
 
-  constructor(mesh: THREE.SkinnedMesh, physics: MMDPhysics)
+  constructor(mesh: SkinnedMesh, physics: MMDPhysics)
   dispose(): void
 }
diff --git a/src/controls/OrbitControls.ts b/src/controls/OrbitControls.ts
index c2341e9b..c25da9b9 100644
--- a/src/controls/OrbitControls.ts
+++ b/src/controls/OrbitControls.ts
@@ -274,10 +274,7 @@ class OrbitControls extends EventDispatcher {
 
         // adjust the camera position based on zoom only if we're not zooming to the cursor or if it's an ortho camera
         // we adjust zoom later in these cases
-        if (
-          (scope.zoomToCursor && performCursorZoom) ||
-          (scope.object as THREE.OrthographicCamera).isOrthographicCamera
-        ) {
+        if ((scope.zoomToCursor && performCursorZoom) || (scope.object as OrthographicCamera).isOrthographicCamera) {
           spherical.radius = clampDistance(spherical.radius)
         } else {
           spherical.radius = clampDistance(spherical.radius * scale)
@@ -317,7 +314,7 @@ class OrbitControls extends EventDispatcher {
             const radiusDelta = prevRadius - newRadius
             scope.object.position.addScaledVector(dollyDirection, radiusDelta)
             scope.object.updateMatrixWorld()
-          } else if ((scope.object as THREE.OrthographicCamera).isOrthographicCamera) {
+          } else if ((scope.object as OrthographicCamera).isOrthographicCamera) {
             // adjust the ortho camera position based on zoom changes
             const mouseBefore = new Vector3(mouse.x, mouse.y, 0)
             mouseBefore.unproject(scope.object)
diff --git a/src/utils/RoughnessMipmapper.d.ts b/src/utils/RoughnessMipmapper.d.ts
index 80c0f292..f51fe9e4 100644
--- a/src/utils/RoughnessMipmapper.d.ts
+++ b/src/utils/RoughnessMipmapper.d.ts
@@ -1,8 +1,8 @@
-import { WebGLRenderer } from 'three'
+import { Material, WebGLRenderer } from 'three'
 
 export class RoughnessMipmapper {
   constructor(renderer: WebGLRenderer)
 
-  generateMipmaps(material: THREE.Material): void
+  generateMipmaps(material: Material): void
   dispose(): void
 }

From 017639d81eb65b3a69b334ec1792efcf6f4a2215 Mon Sep 17 00:00:00 2001
From: Jesse <excalibr8@yahoo.com>
Date: Tue, 19 Mar 2024 18:32:11 -0400
Subject: [PATCH 03/36] fix(KTX2Loader): remove parse overload from types

---
 src/loaders/KTX2Loader.d.ts | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/src/loaders/KTX2Loader.d.ts b/src/loaders/KTX2Loader.d.ts
index 9fb50dba..5bc8c66e 100644
--- a/src/loaders/KTX2Loader.d.ts
+++ b/src/loaders/KTX2Loader.d.ts
@@ -7,10 +7,4 @@ export class KTX2Loader extends CompressedTextureLoader {
   setWorkerLimit(limit: number): KTX2Loader
   detectSupport(renderer: WebGLRenderer): KTX2Loader
   dispose(): KTX2Loader
-
-  parse(
-    buffer: ArrayBuffer,
-    onLoad: (texture: CompressedTexture) => void,
-    onError?: (event: ErrorEvent) => void,
-  ): KTX2Loader
 }

From c61652b2915951b7c0206e6ff586a95dfd34e4ad Mon Sep 17 00:00:00 2001
From: Scott Vorthmann <scott@vorthmann.org>
Date: Sat, 27 Apr 2024 01:08:26 -0700
Subject: [PATCH 04/36] Fixed rotation defect in VRMLLoader.js (#355)

---
 src/loaders/VRMLLoader.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/loaders/VRMLLoader.js b/src/loaders/VRMLLoader.js
index 7b693b91..cb820d64 100644
--- a/src/loaders/VRMLLoader.js
+++ b/src/loaders/VRMLLoader.js
@@ -719,7 +719,7 @@ class VRMLLoader extends Loader {
             break
 
           case 'rotation':
-            const axis = new Vector3(fieldValues[0], fieldValues[1], fieldValues[2])
+            const axis = new Vector3(fieldValues[0], fieldValues[1], fieldValues[2]).normalize()
             const angle = fieldValues[3]
             object.quaternion.setFromAxisAngle(axis, angle)
             break

From e1f6d3e9fb3d49e53924a09bd00ba59a93c422b8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ankit=20Kumar=20=28=E0=A4=85=E0=A4=82=E0=A4=95=E0=A4=BF?=
 =?UTF-8?q?=E0=A4=A4=20=E0=A4=95=E0=A5=81=E0=A4=AE=E0=A4=BE=E0=A4=B0=29?=
 <ankits.kvmdam@hotmail.com>
Date: Sat, 27 Apr 2024 21:11:16 +0900
Subject: [PATCH 05/36] fix(OrbitControls): restore touchAction on dispose

---
 src/controls/OrbitControls.ts | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/controls/OrbitControls.ts b/src/controls/OrbitControls.ts
index c25da9b9..87af957d 100644
--- a/src/controls/OrbitControls.ts
+++ b/src/controls/OrbitControls.ts
@@ -413,6 +413,10 @@ class OrbitControls extends EventDispatcher {
     }
 
     this.dispose = (): void => {
+      // Enabling touch scroll
+      if(scope.domElement) {
+        scope.domElement.style.touchAction = 'auto'
+      }
       scope.domElement?.removeEventListener('contextmenu', onContextMenu)
       scope.domElement?.removeEventListener('pointerdown', onPointerDown)
       scope.domElement?.removeEventListener('pointercancel', onPointerCancel)

From fb716b0a814f0db0b37e7b8f22894520e7d58218 Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Sat, 27 Apr 2024 18:51:20 -0500
Subject: [PATCH 06/36] fix(RGBELoader): upstream fixes (#358)

---
 src/loaders/RGBELoader.js | 114 +++++++++++++++++---------------------
 1 file changed, 50 insertions(+), 64 deletions(-)

diff --git a/src/loaders/RGBELoader.js b/src/loaders/RGBELoader.js
index cc05475c..6c5fc8d6 100644
--- a/src/loaders/RGBELoader.js
+++ b/src/loaders/RGBELoader.js
@@ -13,10 +13,7 @@ class RGBELoader extends DataTextureLoader {
   // adapted from http://www.graphics.cornell.edu/~bjw/rgbe.html
 
   parse(buffer) {
-    const /* return codes for rgbe routines */
-      //RGBE_RETURN_SUCCESS = 0,
-      RGBE_RETURN_FAILURE = -1,
-      /* default error routine.  change this to change error handling */
+    const /* default error routine.  change this to change error handling */
       rgbe_read_error = 1,
       rgbe_write_error = 2,
       rgbe_format_error = 3,
@@ -24,20 +21,15 @@ class RGBELoader extends DataTextureLoader {
       rgbe_error = function (rgbe_error_code, msg) {
         switch (rgbe_error_code) {
           case rgbe_read_error:
-            console.error('THREE.RGBELoader Read Error: ' + (msg || ''))
-            break
+            throw new Error('THREE.RGBELoader: Read Error: ' + (msg || ''))
           case rgbe_write_error:
-            console.error('THREE.RGBELoader Write Error: ' + (msg || ''))
-            break
+            throw new Error('THREE.RGBELoader: Write Error: ' + (msg || ''))
           case rgbe_format_error:
-            console.error('THREE.RGBELoader Bad File Format: ' + (msg || ''))
-            break
+            throw new Error('THREE.RGBELoader: Bad File Format: ' + (msg || ''))
           default:
           case rgbe_memory_error:
-            console.error('THREE.RGBELoader: Error: ' + (msg || ''))
+            throw new Error('THREE.RGBELoader: Memory Error: ' + (msg || ''))
         }
-
-        return RGBE_RETURN_FAILURE
       },
       /* offsets to red, green, and blue components in a data (float) pixel */
       //RGBE_DATA_RED = 0,
@@ -113,12 +105,12 @@ class RGBELoader extends DataTextureLoader {
         let line, match
 
         if (buffer.pos >= buffer.byteLength || !(line = fgets(buffer))) {
-          return rgbe_error(rgbe_read_error, 'no header found')
+          rgbe_error(rgbe_read_error, 'no header found')
         }
 
         /* if you want to require the magic token then uncomment the next line */
         if (!(match = line.match(magic_token_re))) {
-          return rgbe_error(rgbe_format_error, 'bad initial token')
+          rgbe_error(rgbe_format_error, 'bad initial token')
         }
 
         header.valid |= RGBE_VALID_PROGRAMTYPE
@@ -158,11 +150,11 @@ class RGBELoader extends DataTextureLoader {
         }
 
         if (!(header.valid & RGBE_VALID_FORMAT)) {
-          return rgbe_error(rgbe_format_error, 'missing format specifier')
+          rgbe_error(rgbe_format_error, 'missing format specifier')
         }
 
         if (!(header.valid & RGBE_VALID_DIMENSIONS)) {
-          return rgbe_error(rgbe_format_error, 'missing image size specifier')
+          rgbe_error(rgbe_format_error, 'missing image size specifier')
         }
 
         return header
@@ -184,13 +176,13 @@ class RGBELoader extends DataTextureLoader {
         }
 
         if (scanline_width !== ((buffer[2] << 8) | buffer[3])) {
-          return rgbe_error(rgbe_format_error, 'wrong scanline width')
+          rgbe_error(rgbe_format_error, 'wrong scanline width')
         }
 
         const data_rgba = new Uint8Array(4 * w * h)
 
         if (!data_rgba.length) {
-          return rgbe_error(rgbe_memory_error, 'unable to allocate buffer space')
+          rgbe_error(rgbe_memory_error, 'unable to allocate buffer space')
         }
 
         let offset = 0,
@@ -204,7 +196,7 @@ class RGBELoader extends DataTextureLoader {
         // read in each successive scanline
         while (num_scanlines > 0 && pos < buffer.byteLength) {
           if (pos + 4 > buffer.byteLength) {
-            return rgbe_error(rgbe_read_error)
+            rgbe_error(rgbe_read_error)
           }
 
           rgbeStart[0] = buffer[pos++]
@@ -213,7 +205,7 @@ class RGBELoader extends DataTextureLoader {
           rgbeStart[3] = buffer[pos++]
 
           if (2 != rgbeStart[0] || 2 != rgbeStart[1] || ((rgbeStart[2] << 8) | rgbeStart[3]) != scanline_width) {
-            return rgbe_error(rgbe_format_error, 'bad rgbe scanline format')
+            rgbe_error(rgbe_format_error, 'bad rgbe scanline format')
           }
 
           // read each of the four channels for the scanline into the buffer
@@ -227,7 +219,7 @@ class RGBELoader extends DataTextureLoader {
             if (isEncodedRun) count -= 128
 
             if (0 === count || ptr + count > ptr_end) {
-              return rgbe_error(rgbe_format_error, 'bad scanline data')
+              rgbe_error(rgbe_format_error, 'bad scanline data')
             }
 
             if (isEncodedRun) {
@@ -291,58 +283,52 @@ class RGBELoader extends DataTextureLoader {
     byteArray.pos = 0
     const rgbe_header_info = RGBE_ReadHeader(byteArray)
 
-    if (RGBE_RETURN_FAILURE !== rgbe_header_info) {
-      const w = rgbe_header_info.width,
-        h = rgbe_header_info.height,
-        image_rgba_data = RGBE_ReadPixels_RLE(byteArray.subarray(byteArray.pos), w, h)
-
-      if (RGBE_RETURN_FAILURE !== image_rgba_data) {
-        let data, type
-        let numElements
-
-        switch (this.type) {
-          case FloatType:
-            numElements = image_rgba_data.length / 4
-            const floatArray = new Float32Array(numElements * 4)
+    const w = rgbe_header_info.width,
+      h = rgbe_header_info.height,
+      image_rgba_data = RGBE_ReadPixels_RLE(byteArray.subarray(byteArray.pos), w, h)
 
-            for (let j = 0; j < numElements; j++) {
-              RGBEByteToRGBFloat(image_rgba_data, j * 4, floatArray, j * 4)
-            }
+    let data, type
+    let numElements
 
-            data = floatArray
-            type = FloatType
-            break
+    switch (this.type) {
+      case FloatType:
+        numElements = image_rgba_data.length / 4
+        const floatArray = new Float32Array(numElements * 4)
 
-          case HalfFloatType:
-            numElements = image_rgba_data.length / 4
-            const halfArray = new Uint16Array(numElements * 4)
+        for (let j = 0; j < numElements; j++) {
+          RGBEByteToRGBFloat(image_rgba_data, j * 4, floatArray, j * 4)
+        }
 
-            for (let j = 0; j < numElements; j++) {
-              RGBEByteToRGBHalf(image_rgba_data, j * 4, halfArray, j * 4)
-            }
+        data = floatArray
+        type = FloatType
+        break
 
-            data = halfArray
-            type = HalfFloatType
-            break
+      case HalfFloatType:
+        numElements = image_rgba_data.length / 4
+        const halfArray = new Uint16Array(numElements * 4)
 
-          default:
-            console.error('THREE.RGBELoader: unsupported type: ', this.type)
-            break
+        for (let j = 0; j < numElements; j++) {
+          RGBEByteToRGBHalf(image_rgba_data, j * 4, halfArray, j * 4)
         }
 
-        return {
-          width: w,
-          height: h,
-          data: data,
-          header: rgbe_header_info.string,
-          gamma: rgbe_header_info.gamma,
-          exposure: rgbe_header_info.exposure,
-          type: type,
-        }
-      }
+        data = halfArray
+        type = HalfFloatType
+        break
+
+      default:
+        throw new Error('THREE.RGBELoader: Unsupported type: ' + this.type)
+        break
     }
 
-    return null
+    return {
+      width: w,
+      height: h,
+      data: data,
+      header: rgbe_header_info.string,
+      gamma: rgbe_header_info.gamma,
+      exposure: rgbe_header_info.exposure,
+      type: type,
+    }
   }
 
   setDataType(value) {

From ea1e4bfeb69f802068c39b8a5cf6348ce48903d6 Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Sat, 27 Apr 2024 19:12:33 -0500
Subject: [PATCH 07/36] fix(SVGLoader): upstream fixes (#359)

---
 src/loaders/SVGLoader.js | 278 ++++++++++++++++++++++++++++++++-------
 1 file changed, 229 insertions(+), 49 deletions(-)

diff --git a/src/loaders/SVGLoader.js b/src/loaders/SVGLoader.js
index 7f1e1bac..b8879e62 100644
--- a/src/loaders/SVGLoader.js
+++ b/src/loaders/SVGLoader.js
@@ -13,6 +13,8 @@ import {
   Vector3,
 } from 'three'
 
+const COLOR_SPACE_SVG = 'srgb'
+
 class SVGLoader extends Loader {
   constructor(manager) {
     super(manager)
@@ -59,12 +61,13 @@ class SVGLoader extends Loader {
 
       const transform = getNodeTransform(node)
 
-      let traverseChildNodes = true
+      let isDefsNode = false
 
       let path = null
 
       switch (node.nodeName) {
         case 'svg':
+          style = parseStyle(node, style)
           break
 
         case 'style':
@@ -111,16 +114,14 @@ class SVGLoader extends Loader {
           break
 
         case 'defs':
-          traverseChildNodes = false
-          break
-
-        case 'mask':
-          traverseChildNodes = false
+          isDefsNode = true
           break
 
         case 'use':
           style = parseStyle(node, style)
-          const usedNodeId = node.href.baseVal.substring(1)
+
+          const href = node.getAttributeNS('http://www.w3.org/1999/xlink', 'href') || ''
+          const usedNodeId = href.substring(1)
           const usedNode = node.viewportElement.getElementById(usedNodeId)
           if (usedNode) {
             parseNode(usedNode, style)
@@ -136,7 +137,7 @@ class SVGLoader extends Loader {
 
       if (path) {
         if (style.fill !== undefined && style.fill !== 'none') {
-          path.color.setStyle(style.fill)
+          path.color.setStyle(style.fill, COLOR_SPACE_SVG)
         }
 
         transformPath(path, currentTransform)
@@ -146,12 +147,19 @@ class SVGLoader extends Loader {
         path.userData = { node: node, style: style }
       }
 
-      if (traverseChildNodes) {
-        const nodes = node.childNodes
+      const childNodes = node.childNodes
 
-        for (let i = 0; i < nodes.length; i++) {
-          parseNode(nodes[i], style)
+      for (let i = 0; i < childNodes.length; i++) {
+        const node = childNodes[i]
+
+        if (isDefsNode && node.nodeName !== 'style' && node.nodeName !== 'defs') {
+          // Ignore everything in defs except CSS style definitions
+          // and nested defs, because it is OK by the standard to have
+          // <style/> there.
+          continue
         }
+
+        parseNode(node, style)
       }
 
       if (transform) {
@@ -177,6 +185,8 @@ class SVGLoader extends Loader {
 
       const d = node.getAttribute('d')
 
+      if (d === '' || d === 'none') return null
+
       // console.log( d );
 
       const commands = d.match(/[a-df-z][^a-df-z]*/gi)
@@ -185,7 +195,7 @@ class SVGLoader extends Loader {
         const command = commands[i]
 
         const type = command.charAt(0)
-        const data = command.substr(1).trim()
+        const data = command.slice(1).trim()
 
         if (isFirstPoint === true) {
           doSetFirstPoint = true
@@ -572,7 +582,10 @@ class SVGLoader extends Loader {
           .map((i) => i.trim())
 
         for (let j = 0; j < selectorList.length; j++) {
-          stylesheets[selectorList[j]] = Object.assign(stylesheets[selectorList[j]] || {}, stylesheet.style)
+          // Remove empty rules
+          const definitions = Object.fromEntries(Object.entries(stylesheet.style).filter(([, v]) => v !== ''))
+
+          stylesheets[selectorList[j]] = Object.assign(stylesheets[selectorList[j]] || {}, definitions)
         }
       }
     }
@@ -711,7 +724,7 @@ class SVGLoader extends Loader {
         index++
       }
 
-      const regex = /(-?[\d\.?]+)[,|\s](-?[\d\.?]+)/g
+      const regex = /([+-]?\d*\.?\d+(?:e[+-]?\d+)?)(?:,|\s)([+-]?\d*\.?\d+(?:e[+-]?\d+)?)/g
 
       const path = new ShapePath()
 
@@ -738,7 +751,7 @@ class SVGLoader extends Loader {
         index++
       }
 
-      const regex = /(-?[\d\.?]+)[,|\s](-?[\d\.?]+)/g
+      const regex = /([+-]?\d*\.?\d+(?:e[+-]?\d+)?)(?:,|\s)([+-]?\d*\.?\d+(?:e[+-]?\d+)?)/g
 
       const path = new ShapePath()
 
@@ -818,13 +831,12 @@ class SVGLoader extends Loader {
       }
 
       function addStyle(svgName, jsName, adjustFunction) {
-        if (adjustFunction === undefined) {
+        if (adjustFunction === undefined)
           adjustFunction = function copy(v) {
             if (v.startsWith('url')) console.warn('SVGLoader: url access in attributes is not implemented.')
 
             return v
           }
-        }
 
         if (node.hasAttribute(svgName)) style[jsName] = adjustFunction(node.getAttribute(svgName))
         if (stylesheetStyles[svgName]) style[jsName] = adjustFunction(stylesheetStyles[svgName])
@@ -1172,9 +1184,9 @@ class SVGLoader extends Loader {
           const closeParPos = transformText.length
 
           if (openParPos > 0 && openParPos < closeParPos) {
-            const transformType = transformText.substr(0, openParPos)
+            const transformType = transformText.slice(0, openParPos)
 
-            const array = parseFloats(transformText.substr(openParPos + 1, closeParPos - openParPos - 1))
+            const array = parseFloats(transformText.slice(openParPos + 1))
 
             currentTransform.identity()
 
@@ -1182,7 +1194,7 @@ class SVGLoader extends Loader {
               case 'translate':
                 if (array.length >= 1) {
                   const tx = array[0]
-                  let ty = tx
+                  let ty = 0
 
                   if (array.length >= 2) {
                     ty = array[1]
@@ -1200,7 +1212,7 @@ class SVGLoader extends Loader {
                   let cy = 0
 
                   // Angle
-                  angle = (-array[0] * Math.PI) / 180
+                  angle = (array[0] * Math.PI) / 180
 
                   if (array.length >= 3) {
                     // Center x, y
@@ -1209,10 +1221,10 @@ class SVGLoader extends Loader {
                   }
 
                   // Rotate around center (cx, cy)
-                  tempTransform1.identity().translate(-cx, -cy)
-                  tempTransform2.identity().rotate(angle)
+                  tempTransform1.makeTranslation(-cx, -cy)
+                  tempTransform2.makeRotation(angle)
                   tempTransform3.multiplyMatrices(tempTransform2, tempTransform1)
-                  tempTransform1.identity().translate(cx, cy)
+                  tempTransform1.makeTranslation(cx, cy)
                   currentTransform.multiplyMatrices(tempTransform1, tempTransform3)
                 }
 
@@ -1269,7 +1281,92 @@ class SVGLoader extends Loader {
         v2.set(tempV3.x, tempV3.y)
       }
 
-      const isRotated = isTransformRotated(m)
+      function transfEllipseGeneric(curve) {
+        // For math description see:
+        // https://math.stackexchange.com/questions/4544164
+
+        const a = curve.xRadius
+        const b = curve.yRadius
+
+        const cosTheta = Math.cos(curve.aRotation)
+        const sinTheta = Math.sin(curve.aRotation)
+
+        const v1 = new Vector3(a * cosTheta, a * sinTheta, 0)
+        const v2 = new Vector3(-b * sinTheta, b * cosTheta, 0)
+
+        const f1 = v1.applyMatrix3(m)
+        const f2 = v2.applyMatrix3(m)
+
+        const mF = tempTransform0.set(f1.x, f2.x, 0, f1.y, f2.y, 0, 0, 0, 1)
+
+        const mFInv = tempTransform1.copy(mF).invert()
+        const mFInvT = tempTransform2.copy(mFInv).transpose()
+        const mQ = mFInvT.multiply(mFInv)
+        const mQe = mQ.elements
+
+        const ed = eigenDecomposition(mQe[0], mQe[1], mQe[4])
+        const rt1sqrt = Math.sqrt(ed.rt1)
+        const rt2sqrt = Math.sqrt(ed.rt2)
+
+        curve.xRadius = 1 / rt1sqrt
+        curve.yRadius = 1 / rt2sqrt
+        curve.aRotation = Math.atan2(ed.sn, ed.cs)
+
+        const isFullEllipse = (curve.aEndAngle - curve.aStartAngle) % (2 * Math.PI) < Number.EPSILON
+
+        // Do not touch angles of a full ellipse because after transformation they
+        // would converge to a sinle value effectively removing the whole curve
+
+        if (!isFullEllipse) {
+          const mDsqrt = tempTransform1.set(rt1sqrt, 0, 0, 0, rt2sqrt, 0, 0, 0, 1)
+
+          const mRT = tempTransform2.set(ed.cs, ed.sn, 0, -ed.sn, ed.cs, 0, 0, 0, 1)
+
+          const mDRF = mDsqrt.multiply(mRT).multiply(mF)
+
+          const transformAngle = (phi) => {
+            const { x: cosR, y: sinR } = new Vector3(Math.cos(phi), Math.sin(phi), 0).applyMatrix3(mDRF)
+
+            return Math.atan2(sinR, cosR)
+          }
+
+          curve.aStartAngle = transformAngle(curve.aStartAngle)
+          curve.aEndAngle = transformAngle(curve.aEndAngle)
+
+          if (isTransformFlipped(m)) {
+            curve.aClockwise = !curve.aClockwise
+          }
+        }
+      }
+
+      function transfEllipseNoSkew(curve) {
+        // Faster shortcut if no skew is applied
+        // (e.g, a euclidean transform of a group containing the ellipse)
+
+        const sx = getTransformScaleX(m)
+        const sy = getTransformScaleY(m)
+
+        curve.xRadius *= sx
+        curve.yRadius *= sy
+
+        // Extract rotation angle from the matrix of form:
+        //
+        //  | cosθ sx   -sinθ sy |
+        //  | sinθ sx    cosθ sy |
+        //
+        // Remembering that tanθ = sinθ / cosθ; and that
+        // `sx`, `sy`, or both might be zero.
+        const theta =
+          sx > Number.EPSILON ? Math.atan2(m.elements[1], m.elements[0]) : Math.atan2(-m.elements[3], m.elements[4])
+
+        curve.aRotation += theta
+
+        if (isTransformFlipped(m)) {
+          curve.aStartAngle *= -1
+          curve.aEndAngle *= -1
+          curve.aClockwise = !curve.aClockwise
+        }
+      }
 
       const subPaths = path.subPaths
 
@@ -1293,24 +1390,41 @@ class SVGLoader extends Loader {
             transfVec2(curve.v1)
             transfVec2(curve.v2)
           } else if (curve.isEllipseCurve) {
-            if (isRotated) {
-              console.warn('SVGLoader: Elliptic arc or ellipse rotation or skewing is not implemented.')
-            }
+            // Transform ellipse center point
 
             tempV2.set(curve.aX, curve.aY)
             transfVec2(tempV2)
             curve.aX = tempV2.x
             curve.aY = tempV2.y
 
-            curve.xRadius *= getTransformScaleX(m)
-            curve.yRadius *= getTransformScaleY(m)
+            // Transform ellipse shape parameters
+
+            if (isTransformSkewed(m)) {
+              transfEllipseGeneric(curve)
+            } else {
+              transfEllipseNoSkew(curve)
+            }
           }
         }
       }
     }
 
-    function isTransformRotated(m) {
-      return m.elements[1] !== 0 || m.elements[3] !== 0
+    function isTransformFlipped(m) {
+      const te = m.elements
+      return te[0] * te[4] - te[1] * te[3] < 0
+    }
+
+    function isTransformSkewed(m) {
+      const te = m.elements
+      const basisDot = te[0] * te[3] + te[1] * te[4]
+
+      // Shortcut for trivial rotations and transformations
+      if (basisDot === 0) return false
+
+      const sx = getTransformScaleX(m)
+      const sy = getTransformScaleY(m)
+
+      return Math.abs(basisDot / (sx * sy)) > Number.EPSILON
     }
 
     function getTransformScaleX(m) {
@@ -1323,6 +1437,65 @@ class SVGLoader extends Loader {
       return Math.sqrt(te[3] * te[3] + te[4] * te[4])
     }
 
+    // Calculates the eigensystem of a real symmetric 2x2 matrix
+    //    [ A  B ]
+    //    [ B  C ]
+    // in the form
+    //    [ A  B ]  =  [ cs  -sn ] [ rt1   0  ] [  cs  sn ]
+    //    [ B  C ]     [ sn   cs ] [  0   rt2 ] [ -sn  cs ]
+    // where rt1 >= rt2.
+    //
+    // Adapted from: https://www.mpi-hd.mpg.de/personalhomes/globes/3x3/index.html
+    // -> Algorithms for real symmetric matrices -> Analytical (2x2 symmetric)
+    function eigenDecomposition(A, B, C) {
+      let rt1, rt2, cs, sn, t
+      const sm = A + C
+      const df = A - C
+      const rt = Math.sqrt(df * df + 4 * B * B)
+
+      if (sm > 0) {
+        rt1 = 0.5 * (sm + rt)
+        t = 1 / rt1
+        rt2 = A * t * C - B * t * B
+      } else if (sm < 0) {
+        rt2 = 0.5 * (sm - rt)
+      } else {
+        // This case needs to be treated separately to avoid div by 0
+
+        rt1 = 0.5 * rt
+        rt2 = -0.5 * rt
+      }
+
+      // Calculate eigenvectors
+
+      if (df > 0) {
+        cs = df + rt
+      } else {
+        cs = df - rt
+      }
+
+      if (Math.abs(cs) > 2 * Math.abs(B)) {
+        t = (-2 * B) / cs
+        sn = 1 / Math.sqrt(1 + t * t)
+        cs = t * sn
+      } else if (Math.abs(B) === 0) {
+        cs = 1
+        sn = 0
+      } else {
+        t = (-0.5 * cs) / B
+        cs = 1 / Math.sqrt(1 + t * t)
+        sn = t * cs
+      }
+
+      if (df > 0) {
+        t = cs
+        cs = -sn
+        sn = t
+      }
+
+      return { rt1, rt2, cs, sn }
+    }
+
     //
 
     const paths = []
@@ -1620,8 +1793,6 @@ class SVGLoader extends Loader {
     // TODO
 
     // prepare paths for hole detection
-    let identifier = 0
-
     let scanlineMinX = BIGNUMBER
     let scanlineMaxX = -BIGNUMBER
 
@@ -1667,16 +1838,26 @@ class SVGLoader extends Loader {
         curves: p.curves,
         points: points,
         isCW: ShapeUtils.isClockWise(points),
-        identifier: identifier++,
+        identifier: -1,
         boundingBox: new Box2(new Vector2(minX, minY), new Vector2(maxX, maxY)),
       }
     })
 
     simplePaths = simplePaths.filter((sp) => sp.points.length > 1)
 
+    for (let identifier = 0; identifier < simplePaths.length; identifier++) {
+      simplePaths[identifier].identifier = identifier
+    }
+
     // check if path is solid or a hole
     const isAHole = simplePaths.map((p) =>
-      isHoleTo(p, simplePaths, scanlineMinX, scanlineMaxX, shapePath.userData.style.fillRule),
+      isHoleTo(
+        p,
+        simplePaths,
+        scanlineMinX,
+        scanlineMaxX,
+        shapePath.userData ? shapePath.userData.style.fillRule : undefined,
+      ),
     )
 
     const shapesToReturn = []
@@ -1724,7 +1905,7 @@ class SVGLoader extends Loader {
   }
 
   static pointsToStroke(points, style, arcDivisions, minDistance) {
-    // Generates a stroke with some witdh around the given path.
+    // Generates a stroke with some width around the given path.
     // The path can be open or closed (last point equals to first point)
     // Param points: Array of Vector2D (the path). Minimum 2 points.
     // Param style: Object with SVG properties as returned by SVGLoader.getStrokeStyle(), or SVGLoader.parse() in the path.userData.style object
@@ -1821,9 +2002,7 @@ class SVGLoader extends Loader {
         if (isClosed) {
           // Skip duplicated initial point
           nextPoint = points[1]
-        } else {
-          nextPoint = undefined
-        }
+        } else nextPoint = undefined
       } else {
         nextPoint = points[iPoint + 1]
       }
@@ -1861,7 +2040,7 @@ class SVGLoader extends Loader {
         const dot = Math.abs(normal1.dot(tempV2_3))
 
         // If path is straight, don't create join
-        if (dot !== 0) {
+        if (dot > Number.EPSILON) {
           // Compute inner and outer segment intersections
           const miterSide = strokeWidth2 / dot
           tempV2_3.multiplyScalar(-miterSide)
@@ -2158,8 +2337,8 @@ class SVGLoader extends Loader {
       addVertex(currentPointL, u1, 0)
 
       addVertex(lastPointR, u0, 1)
-      addVertex(currentPointL, u1, 1)
-      addVertex(currentPointR, u1, 0)
+      addVertex(currentPointL, u1, 0)
+      addVertex(currentPointR, u1, 1)
     }
 
     function makeSegmentWithBevelJoin(joinIsOnLeftSide, innerSideModified, u) {
@@ -2196,8 +2375,8 @@ class SVGLoader extends Loader {
           // Bevel join triangle
 
           addVertex(currentPointR, u, 1)
-          addVertex(nextPointR, u, 0)
-          addVertex(innerPoint, u, 0.5)
+          addVertex(innerPoint, u, 0)
+          addVertex(nextPointR, u, 1)
         }
       } else {
         // Bevel join triangle. The segment triangles are done in the main loop
@@ -2281,7 +2460,8 @@ class SVGLoader extends Loader {
               tempV2_4.toArray(vertices, 3 * 3)
             } else {
               tempV2_3.toArray(vertices, 1 * 3)
-              tempV2_3.toArray(vertices, 3 * 3)
+              // using tempV2_4 to update 3rd vertex if the uv.y of 3rd vertex is 1
+              uvs[3 * 2 + 1] === 1 ? tempV2_4.toArray(vertices, 3 * 3) : tempV2_3.toArray(vertices, 3 * 3)
               tempV2_4.toArray(vertices, 0 * 3)
             }
           } else {
@@ -2299,8 +2479,8 @@ class SVGLoader extends Loader {
               tempV2_4.toArray(vertices, vl - 2 * 3)
               tempV2_4.toArray(vertices, vl - 4 * 3)
             } else {
-              tempV2_3.toArray(vertices, vl - 2 * 3)
-              tempV2_4.toArray(vertices, vl - 1 * 3)
+              tempV2_4.toArray(vertices, vl - 2 * 3)
+              tempV2_3.toArray(vertices, vl - 1 * 3)
               tempV2_4.toArray(vertices, vl - 4 * 3)
             }
           }

From f357e50196992447548fbc654655a0d60bce8c44 Mon Sep 17 00:00:00 2001
From: satelllte <20585619+satelllte@users.noreply.github.com>
Date: Tue, 30 Apr 2024 12:46:06 +0300
Subject: [PATCH 08/36] fix(OrbitControls): make "wheel" listener passive
 (#353)

---
 src/controls/OrbitControls.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/controls/OrbitControls.ts b/src/controls/OrbitControls.ts
index 87af957d..0dab03b6 100644
--- a/src/controls/OrbitControls.ts
+++ b/src/controls/OrbitControls.ts
@@ -409,7 +409,7 @@ class OrbitControls extends EventDispatcher {
       scope.domElement.addEventListener('contextmenu', onContextMenu)
       scope.domElement.addEventListener('pointerdown', onPointerDown)
       scope.domElement.addEventListener('pointercancel', onPointerCancel)
-      scope.domElement.addEventListener('wheel', onMouseWheel)
+      scope.domElement.addEventListener('wheel', onMouseWheel, { passive: true })
     }
 
     this.dispose = (): void => {

From 0a5de570f8f0f61ea2603b6fc99d73c7b59070a7 Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Thu, 2 May 2024 08:14:37 -0500
Subject: [PATCH 09/36] fix(OrbitControls): don't preventDefault in wheel
 (#360)

---
 src/controls/OrbitControls.ts | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/src/controls/OrbitControls.ts b/src/controls/OrbitControls.ts
index 0dab03b6..705d9efa 100644
--- a/src/controls/OrbitControls.ts
+++ b/src/controls/OrbitControls.ts
@@ -414,7 +414,7 @@ class OrbitControls extends EventDispatcher {
 
     this.dispose = (): void => {
       // Enabling touch scroll
-      if(scope.domElement) {
+      if (scope.domElement) {
         scope.domElement.style.touchAction = 'auto'
       }
       scope.domElement?.removeEventListener('contextmenu', onContextMenu)
@@ -949,8 +949,6 @@ class OrbitControls extends EventDispatcher {
         return
       }
 
-      event.preventDefault()
-
       // @ts-ignore
       scope.dispatchEvent(startEvent)
 

From d0dc70da1de3d7f1d812860a2de58c5b7ba2829d Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Fri, 10 May 2024 18:55:14 -0500
Subject: [PATCH 10/36] fix(OrbitControls): revert passive wheel (#362)

---
 src/controls/OrbitControls.ts | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/controls/OrbitControls.ts b/src/controls/OrbitControls.ts
index 705d9efa..87af957d 100644
--- a/src/controls/OrbitControls.ts
+++ b/src/controls/OrbitControls.ts
@@ -409,12 +409,12 @@ class OrbitControls extends EventDispatcher {
       scope.domElement.addEventListener('contextmenu', onContextMenu)
       scope.domElement.addEventListener('pointerdown', onPointerDown)
       scope.domElement.addEventListener('pointercancel', onPointerCancel)
-      scope.domElement.addEventListener('wheel', onMouseWheel, { passive: true })
+      scope.domElement.addEventListener('wheel', onMouseWheel)
     }
 
     this.dispose = (): void => {
       // Enabling touch scroll
-      if (scope.domElement) {
+      if(scope.domElement) {
         scope.domElement.style.touchAction = 'auto'
       }
       scope.domElement?.removeEventListener('contextmenu', onContextMenu)
@@ -949,6 +949,8 @@ class OrbitControls extends EventDispatcher {
         return
       }
 
+      event.preventDefault()
+
       // @ts-ignore
       scope.dispatchEvent(startEvent)
 

From bdfe295d6e725a8109b49d7ccf266a2b05ab4424 Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Sun, 12 May 2024 04:07:14 -0500
Subject: [PATCH 11/36] feat(GLTFLoader): dispersion (#363)

---
 src/loaders/GLTFLoader.js | 356 ++++++++++++++++++++++++++++----------
 1 file changed, 262 insertions(+), 94 deletions(-)

diff --git a/src/loaders/GLTFLoader.js b/src/loaders/GLTFLoader.js
index 74a3a121..83909fba 100644
--- a/src/loaders/GLTFLoader.js
+++ b/src/loaders/GLTFLoader.js
@@ -60,10 +60,16 @@ import {
   Vector2,
   Vector3,
   VectorKeyframeTrack,
+  InstancedBufferAttribute,
 } from 'three'
 import { toTrianglesDrawMode } from '../utils/BufferGeometryUtils'
 import { version } from '../_polyfill/constants'
 
+const SRGBColorSpace = 'srgb'
+const LinearSRGBColorSpace = 'srgb-linear'
+const sRGBEncoding = 3001
+const LinearEncoding = 3000
+
 class GLTFLoader extends Loader {
   constructor(manager) {
     super(manager)
@@ -78,6 +84,10 @@ class GLTFLoader extends Loader {
       return new GLTFMaterialsClearcoatExtension(parser)
     })
 
+    this.register(function (parser) {
+      return new GLTFMaterialsDispersionExtension(parser)
+    })
+
     this.register(function (parser) {
       return new GLTFTextureBasisUExtension(parser)
     })
@@ -122,6 +132,10 @@ class GLTFLoader extends Loader {
       return new GLTFMaterialsAnisotropyExtension(parser)
     })
 
+    this.register(function (parser) {
+      return new GLTFMaterialsBumpExtension(parser)
+    })
+
     this.register(function (parser) {
       return new GLTFLightsExtension(parser)
     })
@@ -143,7 +157,13 @@ class GLTFLoader extends Loader {
     if (this.resourcePath !== '') {
       resourcePath = this.resourcePath
     } else if (this.path !== '') {
-      resourcePath = this.path
+      // If a base path is set, resources will be relative paths from that plus the relative path of the gltf file
+      // Example  path = 'https://my-cnd-server.com/', url = 'assets/models/model.gltf'
+      // resourcePath = 'https://my-cnd-server.com/assets/models/'
+      // referenced resource 'model.bin' will be loaded from 'https://my-cnd-server.com/assets/models/model.bin'
+      // referenced resource '../textures/texture.png' will be loaded from 'https://my-cnd-server.com/assets/textures/texture.png'
+      const relativeUrl = LoaderUtils.extractUrlBase(url)
+      resourcePath = LoaderUtils.resolveURL(relativeUrl, this.path)
     } else {
       resourcePath = LoaderUtils.extractUrlBase(url)
     }
@@ -273,6 +293,9 @@ class GLTFLoader extends Loader {
 
     for (let i = 0; i < this.pluginCallbacks.length; i++) {
       const plugin = this.pluginCallbacks[i](parser)
+
+      if (!plugin.name) console.error('THREE.GLTFLoader: Invalid plugin found: missing name')
+
       plugins[plugin.name] = plugin
 
       // Workaround to avoid determining as unknown extension
@@ -359,6 +382,7 @@ const EXTENSIONS = {
   KHR_DRACO_MESH_COMPRESSION: 'KHR_draco_mesh_compression',
   KHR_LIGHTS_PUNCTUAL: 'KHR_lights_punctual',
   KHR_MATERIALS_CLEARCOAT: 'KHR_materials_clearcoat',
+  KHR_MATERIALS_DISPERSION: 'KHR_materials_dispersion',
   KHR_MATERIALS_IOR: 'KHR_materials_ior',
   KHR_MATERIALS_SHEEN: 'KHR_materials_sheen',
   KHR_MATERIALS_SPECULAR: 'KHR_materials_specular',
@@ -371,6 +395,7 @@ const EXTENSIONS = {
   KHR_TEXTURE_TRANSFORM: 'KHR_texture_transform',
   KHR_MESH_QUANTIZATION: 'KHR_mesh_quantization',
   KHR_MATERIALS_EMISSIVE_STRENGTH: 'KHR_materials_emissive_strength',
+  EXT_MATERIALS_BUMP: 'EXT_materials_bump',
   EXT_TEXTURE_WEBP: 'EXT_texture_webp',
   EXT_TEXTURE_AVIF: 'EXT_texture_avif',
   EXT_MESHOPT_COMPRESSION: 'EXT_meshopt_compression',
@@ -419,7 +444,8 @@ class GLTFLightsExtension {
 
     const color = new Color(0xffffff)
 
-    if (lightDef.color !== undefined) color.fromArray(lightDef.color)
+    if (lightDef.color !== undefined)
+      color.setRGB(lightDef.color[0], lightDef.color[1], lightDef.color[2], LinearSRGBColorSpace)
 
     const range = lightDef.range !== undefined ? lightDef.range : 0
 
@@ -520,12 +546,12 @@ class GLTFMaterialsUnlitExtension {
       if (Array.isArray(metallicRoughness.baseColorFactor)) {
         const array = metallicRoughness.baseColorFactor
 
-        materialParams.color.fromArray(array)
+        materialParams.color.setRGB(array[0], array[1], array[2], LinearSRGBColorSpace)
         materialParams.opacity = array[3]
       }
 
       if (metallicRoughness.baseColorTexture !== undefined) {
-        pending.push(parser.assignTexture(materialParams, 'map', metallicRoughness.baseColorTexture, 3001)) // sRGBEncoding
+        pending.push(parser.assignTexture(materialParams, 'map', metallicRoughness.baseColorTexture, SRGBColorSpace))
       }
     }
 
@@ -624,6 +650,42 @@ class GLTFMaterialsClearcoatExtension {
   }
 }
 
+/**
+ * Materials dispersion Extension
+ *
+ * Specification: https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_materials_dispersion
+ */
+class GLTFMaterialsDispersionExtension {
+  constructor(parser) {
+    this.parser = parser
+    this.name = EXTENSIONS.KHR_MATERIALS_DISPERSION
+  }
+
+  getMaterialType(materialIndex) {
+    const parser = this.parser
+    const materialDef = parser.json.materials[materialIndex]
+
+    if (!materialDef.extensions || !materialDef.extensions[this.name]) return null
+
+    return MeshPhysicalMaterial
+  }
+
+  extendMaterialParams(materialIndex, materialParams) {
+    const parser = this.parser
+    const materialDef = parser.json.materials[materialIndex]
+
+    if (!materialDef.extensions || !materialDef.extensions[this.name]) {
+      return Promise.resolve()
+    }
+
+    const extension = materialDef.extensions[this.name]
+
+    materialParams.dispersion = extension.dispersion !== undefined ? extension.dispersion : 0
+
+    return Promise.resolve()
+  }
+}
+
 /**
  * Iridescence Materials Extension
  *
@@ -727,7 +789,8 @@ class GLTFMaterialsSheenExtension {
     const extension = materialDef.extensions[this.name]
 
     if (extension.sheenColorFactor !== undefined) {
-      materialParams.sheenColor.fromArray(extension.sheenColorFactor)
+      const colorFactor = extension.sheenColorFactor
+      materialParams.sheenColor.setRGB(colorFactor[0], colorFactor[1], colorFactor[2], LinearSRGBColorSpace)
     }
 
     if (extension.sheenRoughnessFactor !== undefined) {
@@ -735,7 +798,7 @@ class GLTFMaterialsSheenExtension {
     }
 
     if (extension.sheenColorTexture !== undefined) {
-      pending.push(parser.assignTexture(materialParams, 'sheenColorMap', extension.sheenColorTexture, 3001)) // sRGBEncoding
+      pending.push(parser.assignTexture(materialParams, 'sheenColorMap', extension.sheenColorTexture, SRGBColorSpace))
     }
 
     if (extension.sheenRoughnessTexture !== undefined) {
@@ -832,7 +895,12 @@ class GLTFMaterialsVolumeExtension {
     materialParams.attenuationDistance = extension.attenuationDistance || Infinity
 
     const colorArray = extension.attenuationColor || [1, 1, 1]
-    materialParams.attenuationColor = new Color(colorArray[0], colorArray[1], colorArray[2])
+    materialParams.attenuationColor = new Color().setRGB(
+      colorArray[0],
+      colorArray[1],
+      colorArray[2],
+      LinearSRGBColorSpace,
+    )
 
     return Promise.all(pending)
   }
@@ -913,11 +981,11 @@ class GLTFMaterialsSpecularExtension {
     }
 
     const colorArray = extension.specularColorFactor || [1, 1, 1]
-    materialParams.specularColor = new Color(colorArray[0], colorArray[1], colorArray[2])
+    materialParams.specularColor = new Color().setRGB(colorArray[0], colorArray[1], colorArray[2], LinearSRGBColorSpace)
 
     if (extension.specularColorTexture !== undefined) {
       pending.push(
-        parser.assignTexture(materialParams, 'specularColorMap', extension.specularColorTexture, 3001), // sRGBEncoding
+        parser.assignTexture(materialParams, 'specularColorMap', extension.specularColorTexture, SRGBColorSpace),
       )
     }
 
@@ -925,6 +993,48 @@ class GLTFMaterialsSpecularExtension {
   }
 }
 
+/**
+ * Materials bump Extension
+ *
+ * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/EXT_materials_bump
+ */
+class GLTFMaterialsBumpExtension {
+  constructor(parser) {
+    this.parser = parser
+    this.name = EXTENSIONS.EXT_MATERIALS_BUMP
+  }
+
+  getMaterialType(materialIndex) {
+    const parser = this.parser
+    const materialDef = parser.json.materials[materialIndex]
+
+    if (!materialDef.extensions || !materialDef.extensions[this.name]) return null
+
+    return MeshPhysicalMaterial
+  }
+
+  extendMaterialParams(materialIndex, materialParams) {
+    const parser = this.parser
+    const materialDef = parser.json.materials[materialIndex]
+
+    if (!materialDef.extensions || !materialDef.extensions[this.name]) {
+      return Promise.resolve()
+    }
+
+    const pending = []
+
+    const extension = materialDef.extensions[this.name]
+
+    materialParams.bumpScale = extension.bumpFactor !== undefined ? extension.bumpFactor : 1.0
+
+    if (extension.bumpTexture !== undefined) {
+      pending.push(parser.assignTexture(materialParams, 'bumpMap', extension.bumpTexture))
+    }
+
+    return Promise.all(pending)
+  }
+}
+
 /**
  * Materials anisotropy Extension
  *
@@ -1293,7 +1403,10 @@ class GLTFMeshGpuInstancing {
 
         // Add instance attributes to the geometry, excluding TRS.
         for (const attributeName in attributes) {
-          if (attributeName !== 'TRANSLATION' && attributeName !== 'ROTATION' && attributeName !== 'SCALE') {
+          if (attributeName === '_COLOR_0') {
+            const attr = attributes[attributeName]
+            instancedMesh.instanceColor = new InstancedBufferAttribute(attr.array, attr.itemSize, attr.normalized)
+          } else if (attributeName !== 'TRANSLATION' && attributeName !== 'ROTATION' && attributeName !== 'SCALE') {
             mesh.geometry.setAttribute(attributeName, attributes[attributeName])
           }
         }
@@ -1419,7 +1532,7 @@ class GLTFDracoMeshCompressionExtension {
     }
 
     return parser.getDependency('bufferView', bufferViewIndex).then(function (bufferView) {
-      return new Promise(function (resolve) {
+      return new Promise(function (resolve, reject) {
         dracoLoader.decodeDracoFile(
           bufferView,
           function (geometry) {
@@ -1434,6 +1547,8 @@ class GLTFDracoMeshCompressionExtension {
           },
           threeAttributeMap,
           attributeTypeMap,
+          LinearSRGBColorSpace,
+          reject,
         )
       })
     })
@@ -2003,11 +2118,15 @@ class GLTFParser {
 
         assignExtrasToUserData(result, json)
 
-        Promise.all(
+        return Promise.all(
           parser._invokeAll(function (ext) {
             return ext.afterRoot && ext.afterRoot(result)
           }),
         ).then(function () {
+          for (const scene of result.scenes) {
+            scene.updateMatrixWorld()
+          }
+
           onLoad(result)
         })
       })
@@ -2531,6 +2650,8 @@ class GLTFParser {
           URL.revokeObjectURL(sourceURI)
         }
 
+        assignExtrasToUserData(texture, sourceDef)
+
         texture.userData.mimeType = sourceDef.mimeType || getImageURIMimeType(sourceDef.uri)
 
         return texture
@@ -2551,7 +2672,7 @@ class GLTFParser {
    * @param {Object} mapDef
    * @return {Promise<Texture>}
    */
-  assignTexture(materialParams, mapName, mapDef, encoding) {
+  assignTexture(materialParams, mapName, mapDef, colorSpace) {
     const parser = this
 
     return this.getDependency('texture', mapDef.index).then(function (texture) {
@@ -2573,9 +2694,14 @@ class GLTFParser {
         }
       }
 
-      if (encoding !== undefined) {
-        if ('colorSpace' in texture) texture.colorSpace = encoding === 3001 ? 'srgb' : 'srgb-linear'
-        else texture.encoding = encoding
+      if (colorSpace !== undefined) {
+        // Convert from legacy encoding to colorSpace
+        if (typeof colorSpace === 'number')
+          colorSpace = colorSpace === sRGBEncoding ? SRGBColorSpace : LinearSRGBColorSpace
+
+        // Set colorSpace if able, fallback to legacy encoding
+        if ('colorSpace' in texture) texture.colorSpace = colorSpace
+        else texture.encoding = colorSpace === SRGBColorSpace ? sRGBEncoding : LinearEncoding
       }
 
       materialParams[mapName] = texture
@@ -2703,12 +2829,12 @@ class GLTFParser {
       if (Array.isArray(metallicRoughness.baseColorFactor)) {
         const array = metallicRoughness.baseColorFactor
 
-        materialParams.color.fromArray(array)
+        materialParams.color.setRGB(array[0], array[1], array[2], LinearSRGBColorSpace)
         materialParams.opacity = array[3]
       }
 
       if (metallicRoughness.baseColorTexture !== undefined) {
-        pending.push(parser.assignTexture(materialParams, 'map', metallicRoughness.baseColorTexture, 3001)) // sRGBEncoding
+        pending.push(parser.assignTexture(materialParams, 'map', metallicRoughness.baseColorTexture, SRGBColorSpace))
       }
 
       materialParams.metalness = metallicRoughness.metallicFactor !== undefined ? metallicRoughness.metallicFactor : 1.0
@@ -2773,11 +2899,17 @@ class GLTFParser {
     }
 
     if (materialDef.emissiveFactor !== undefined && materialType !== MeshBasicMaterial) {
-      materialParams.emissive = new Color().fromArray(materialDef.emissiveFactor)
+      const emissiveFactor = materialDef.emissiveFactor
+      materialParams.emissive = new Color().setRGB(
+        emissiveFactor[0],
+        emissiveFactor[1],
+        emissiveFactor[2],
+        LinearSRGBColorSpace,
+      )
     }
 
     if (materialDef.emissiveTexture !== undefined && materialType !== MeshBasicMaterial) {
-      pending.push(parser.assignTexture(materialParams, 'emissiveMap', materialDef.emissiveTexture, 3001)) // sRGBEncoding
+      pending.push(parser.assignTexture(materialParams, 'emissiveMap', materialDef.emissiveTexture, SRGBColorSpace))
     }
 
     return Promise.all(pending).then(function () {
@@ -3069,6 +3201,7 @@ class GLTFParser {
    */
   loadAnimation(animationIndex) {
     const json = this.json
+    const parser = this
 
     const animationDef = json.animations[animationIndex]
     const animationName = animationDef.name ? animationDef.name : 'animation_' + animationIndex
@@ -3120,84 +3253,16 @@ class GLTFParser {
 
         if (node === undefined) continue
 
-        node.updateMatrix()
-
-        let TypedKeyframeTrack
-
-        switch (PATH_PROPERTIES[target.path]) {
-          case PATH_PROPERTIES.weights:
-            TypedKeyframeTrack = NumberKeyframeTrack
-            break
-
-          case PATH_PROPERTIES.rotation:
-            TypedKeyframeTrack = QuaternionKeyframeTrack
-            break
-
-          case PATH_PROPERTIES.position:
-          case PATH_PROPERTIES.scale:
-          default:
-            TypedKeyframeTrack = VectorKeyframeTrack
-            break
-        }
-
-        const targetName = node.name ? node.name : node.uuid
-
-        const interpolation =
-          sampler.interpolation !== undefined ? INTERPOLATION[sampler.interpolation] : InterpolateLinear
-
-        const targetNames = []
-
-        if (PATH_PROPERTIES[target.path] === PATH_PROPERTIES.weights) {
-          node.traverse(function (object) {
-            if (object.morphTargetInfluences) {
-              targetNames.push(object.name ? object.name : object.uuid)
-            }
-          })
-        } else {
-          targetNames.push(targetName)
+        if (node.updateMatrix) {
+          node.updateMatrix()
         }
 
-        let outputArray = outputAccessor.array
-
-        if (outputAccessor.normalized) {
-          const scale = getNormalizedComponentScale(outputArray.constructor)
-          const scaled = new Float32Array(outputArray.length)
+        const createdTracks = parser._createAnimationTracks(node, inputAccessor, outputAccessor, sampler, target)
 
-          for (let j = 0, jl = outputArray.length; j < jl; j++) {
-            scaled[j] = outputArray[j] * scale
+        if (createdTracks) {
+          for (let k = 0; k < createdTracks.length; k++) {
+            tracks.push(createdTracks[k])
           }
-
-          outputArray = scaled
-        }
-
-        for (let j = 0, jl = targetNames.length; j < jl; j++) {
-          const track = new TypedKeyframeTrack(
-            targetNames[j] + '.' + PATH_PROPERTIES[target.path],
-            inputAccessor.array,
-            outputArray,
-            interpolation,
-          )
-
-          // Override interpolation with custom factory method.
-          if (sampler.interpolation === 'CUBICSPLINE') {
-            track.createInterpolant = function InterpolantFactoryMethodGLTFCubicSpline(result) {
-              // A CUBICSPLINE keyframe in glTF has three output values for each input value,
-              // representing inTangent, splineVertex, and outTangent. As a result, track.getValueSize()
-              // must be divided by three to get the interpolant's sampleSize argument.
-
-              const interpolantType =
-                this instanceof QuaternionKeyframeTrack
-                  ? GLTFCubicSplineQuaternionInterpolant
-                  : GLTFCubicSplineInterpolant
-
-              return new interpolantType(this.times, this.values, this.getValueSize() / 3, result)
-            }
-
-            // Mark as CUBICSPLINE. `track.getInterpolation()` doesn't support custom interpolants.
-            track.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline = true
-          }
-
-          tracks.push(track)
         }
       }
 
@@ -3439,6 +3504,109 @@ class GLTFParser {
       return scene
     })
   }
+
+  _createAnimationTracks(node, inputAccessor, outputAccessor, sampler, target) {
+    const tracks = []
+
+    const targetName = node.name ? node.name : node.uuid
+    const targetNames = []
+
+    if (PATH_PROPERTIES[target.path] === PATH_PROPERTIES.weights) {
+      node.traverse(function (object) {
+        if (object.morphTargetInfluences) {
+          targetNames.push(object.name ? object.name : object.uuid)
+        }
+      })
+    } else {
+      targetNames.push(targetName)
+    }
+
+    let TypedKeyframeTrack
+
+    switch (PATH_PROPERTIES[target.path]) {
+      case PATH_PROPERTIES.weights:
+        TypedKeyframeTrack = NumberKeyframeTrack
+        break
+
+      case PATH_PROPERTIES.rotation:
+        TypedKeyframeTrack = QuaternionKeyframeTrack
+        break
+
+      case PATH_PROPERTIES.position:
+      case PATH_PROPERTIES.scale:
+        TypedKeyframeTrack = VectorKeyframeTrack
+        break
+
+      default:
+        switch (outputAccessor.itemSize) {
+          case 1:
+            TypedKeyframeTrack = NumberKeyframeTrack
+            break
+          case 2:
+          case 3:
+          default:
+            TypedKeyframeTrack = VectorKeyframeTrack
+            break
+        }
+
+        break
+    }
+
+    const interpolation = sampler.interpolation !== undefined ? INTERPOLATION[sampler.interpolation] : InterpolateLinear
+
+    const outputArray = this._getArrayFromAccessor(outputAccessor)
+
+    for (let j = 0, jl = targetNames.length; j < jl; j++) {
+      const track = new TypedKeyframeTrack(
+        targetNames[j] + '.' + PATH_PROPERTIES[target.path],
+        inputAccessor.array,
+        outputArray,
+        interpolation,
+      )
+
+      // Override interpolation with custom factory method.
+      if (sampler.interpolation === 'CUBICSPLINE') {
+        this._createCubicSplineTrackInterpolant(track)
+      }
+
+      tracks.push(track)
+    }
+
+    return tracks
+  }
+
+  _getArrayFromAccessor(accessor) {
+    let outputArray = accessor.array
+
+    if (accessor.normalized) {
+      const scale = getNormalizedComponentScale(outputArray.constructor)
+      const scaled = new Float32Array(outputArray.length)
+
+      for (let j = 0, jl = outputArray.length; j < jl; j++) {
+        scaled[j] = outputArray[j] * scale
+      }
+
+      outputArray = scaled
+    }
+
+    return outputArray
+  }
+
+  _createCubicSplineTrackInterpolant(track) {
+    track.createInterpolant = function InterpolantFactoryMethodGLTFCubicSpline(result) {
+      // A CUBICSPLINE keyframe in glTF has three output values for each input value,
+      // representing inTangent, splineVertex, and outTangent. As a result, track.getValueSize()
+      // must be divided by three to get the interpolant's sampleSize argument.
+
+      const interpolantType =
+        this instanceof QuaternionKeyframeTrack ? GLTFCubicSplineQuaternionInterpolant : GLTFCubicSplineInterpolant
+
+      return new interpolantType(this.times, this.values, this.getValueSize() / 3, result)
+    }
+
+    // Mark as CUBICSPLINE. `track.getInterpolation()` doesn't support custom interpolants.
+    track.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline = true
+  }
 }
 
 /**

From 430ffd76fed22748dd1ba533b73eaa8286eeaabd Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Fri, 24 May 2024 17:56:48 -0500
Subject: [PATCH 12/36] fix: use correct value for LinearSRGBColorSpace (#368)

---
 src/math/Lut.js          | 8 ++++----
 src/objects/Reflector.js | 2 +-
 src/objects/Refractor.js | 2 +-
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/math/Lut.js b/src/math/Lut.js
index a1eadbfa..55425077 100644
--- a/src/math/Lut.js
+++ b/src/math/Lut.js
@@ -57,8 +57,8 @@ class Lut {
           const min = this.map[j][0]
           const max = this.map[j + 1][0]
 
-          minColor.setHex(this.map[j][1], 'linear-srgb')
-          maxColor.setHex(this.map[j + 1][1], 'linear-srgb')
+          minColor.setHex(this.map[j][1], 'srgb-linear')
+          maxColor.setHex(this.map[j + 1][1], 'srgb-linear')
 
           const color = new Color().lerpColors(minColor, maxColor, (alpha - min) / (max - min))
 
@@ -131,8 +131,8 @@ class Lut {
           const min = this.map[j - 1][0]
           const max = this.map[j][0]
 
-          minColor.setHex(this.map[j - 1][1], 'linear-srgb')
-          maxColor.setHex(this.map[j][1], 'linear-srgb')
+          minColor.setHex(this.map[j - 1][1], 'srgb-linear')
+          maxColor.setHex(this.map[j][1], 'srgb-linear')
 
           finalColor.lerpColors(minColor, maxColor, (i - min) / (max - min))
 
diff --git a/src/objects/Reflector.js b/src/objects/Reflector.js
index ce8ee99e..5d326eb6 100644
--- a/src/objects/Reflector.js
+++ b/src/objects/Reflector.js
@@ -213,7 +213,7 @@ class Reflector extends Mesh {
 
       renderer.xr.enabled = false // Avoid camera modification
       renderer.shadowMap.autoUpdate = false // Avoid re-computing shadows
-      if ('outputColorSpace' in renderer) renderer.outputColorSpace = 'linear-srgb'
+      if ('outputColorSpace' in renderer) renderer.outputColorSpace = 'srgb-linear'
       else renderer.outputEncoding = 3000 // LinearEncoding
       renderer.toneMapping = NoToneMapping
 
diff --git a/src/objects/Refractor.js b/src/objects/Refractor.js
index dedd6c64..09dda320 100644
--- a/src/objects/Refractor.js
+++ b/src/objects/Refractor.js
@@ -241,7 +241,7 @@ class Refractor extends Mesh {
 
       renderer.xr.enabled = false // avoid camera modification
       renderer.shadowMap.autoUpdate = false // avoid re-computing shadows
-      if ('outputColorSpace' in renderer) renderer.outputColorSpace = 'linear-srgb'
+      if ('outputColorSpace' in renderer) renderer.outputColorSpace = 'srgb-linear'
       else renderer.outputEncoding = 3000 // LinearEncoding
       renderer.toneMapping = NoToneMapping
 

From 5bf732433fd1bcb73ed13709b31fd3779ac3f2d0 Mon Sep 17 00:00:00 2001
From: Guillaume Esquevin <esquevin@users.noreply.github.com>
Date: Wed, 29 May 2024 15:45:50 +0200
Subject: [PATCH 13/36] fix(OrbitControls): upstream fixes (#365)

---
 src/controls/OrbitControls.ts | 10 +++-------
 1 file changed, 3 insertions(+), 7 deletions(-)

diff --git a/src/controls/OrbitControls.ts b/src/controls/OrbitControls.ts
index 87af957d..9bcbe3d1 100644
--- a/src/controls/OrbitControls.ts
+++ b/src/controls/OrbitControls.ts
@@ -408,18 +408,18 @@ class OrbitControls extends EventDispatcher {
       scope.domElement.style.touchAction = 'none'
       scope.domElement.addEventListener('contextmenu', onContextMenu)
       scope.domElement.addEventListener('pointerdown', onPointerDown)
-      scope.domElement.addEventListener('pointercancel', onPointerCancel)
+      scope.domElement.addEventListener('pointercancel', onPointerUp)
       scope.domElement.addEventListener('wheel', onMouseWheel)
     }
 
     this.dispose = (): void => {
       // Enabling touch scroll
-      if(scope.domElement) {
+      if (scope.domElement) {
         scope.domElement.style.touchAction = 'auto'
       }
       scope.domElement?.removeEventListener('contextmenu', onContextMenu)
       scope.domElement?.removeEventListener('pointerdown', onPointerDown)
-      scope.domElement?.removeEventListener('pointercancel', onPointerCancel)
+      scope.domElement?.removeEventListener('pointercancel', onPointerUp)
       scope.domElement?.removeEventListener('wheel', onMouseWheel)
       scope.domElement?.ownerDocument.removeEventListener('pointermove', onPointerMove)
       scope.domElement?.ownerDocument.removeEventListener('pointerup', onPointerUp)
@@ -858,10 +858,6 @@ class OrbitControls extends EventDispatcher {
       state = STATE.NONE
     }
 
-    function onPointerCancel(event: PointerEvent) {
-      removePointer(event)
-    }
-
     function onMouseDown(event: MouseEvent) {
       let mouseAction
 

From 880e2eb089fc5344ffa0f5dc6c88486ee948c189 Mon Sep 17 00:00:00 2001
From: Patrick-van-Halm-360Fabriek
 <99954741+Patrick-van-Halm-360Fabriek@users.noreply.github.com>
Date: Wed, 29 May 2024 15:46:18 +0200
Subject: [PATCH 14/36] fix(USDZExporter): alpha issues in diffuse map (#364)

---
 src/exporters/USDZExporter.ts | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/src/exporters/USDZExporter.ts b/src/exporters/USDZExporter.ts
index eb8227c7..9d7b958e 100644
--- a/src/exporters/USDZExporter.ts
+++ b/src/exporters/USDZExporter.ts
@@ -323,6 +323,19 @@ ${array.join('')}
         `${pad}color3f inputs:diffuseColor.connect = </Materials/Material_${material.id}/Texture_${material.map.id}_diffuse.outputs:rgb>`,
       )
 
+      // Include alpha input
+      if (material.transparent || material.alphaTest > 0.0) {
+        inputs.push(`${pad}float inputs:opacity.connect = </Materials/Material_${material.id}/Texture_${material.map.id}_diffuse.outputs:a>`);
+      }
+
+      // Check if alpha test is bigger than minimum of 0.01, if not and it is transparent still apply a 0.01 alpha clip in order to remove white blur in transparent place.
+      if (material.alphaTest > 0.01) {
+        inputs.push(`${pad}float inputs:opacityThreshold = ${material.alphaTest}`);
+      }
+      else if(material.transparent || material.alphaTest > 0.0) {
+        inputs.push(`${pad}float inputs:opacityThreshold = 0.01`);
+      }
+      
       samplers.push(this.buildTexture(material, material.map, 'diffuse', material.color))
     } else {
       inputs.push(`${pad}color3f inputs:diffuseColor = ${this.buildColor(material.color)}`)
@@ -412,6 +425,7 @@ ${samplers.join('\n')}
 
     this.textures[id] = texture
 
+    // Add the alpha output for when transparency is set or the alpha test is above 0
     return `
       def Shader "Transform2d_${mapType}" (
           sdrMetadata = {
@@ -436,6 +450,7 @@ ${samplers.join('\n')}
           float outputs:g
           float outputs:b
           float3 outputs:rgb
+          ${material.transparent || material.alphaTest > 0.0 ? 'float outputs:a' : ''}
       }`
   }
 

From eab87ab825a9edf7988acdb300851e824d2c1602 Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Sat, 1 Jun 2024 05:24:21 -0500
Subject: [PATCH 15/36] fix(loaders): vendor decodeText for r165 deprecation
 (#371)

---
 src/_polyfill/LoaderUtils.js | 25 +++++++++++++++++++++++++
 src/loaders/3MFLoader.js     |  7 ++++---
 src/loaders/AMFLoader.js     |  3 ++-
 src/loaders/FBXLoader.js     |  5 +++--
 src/loaders/GLTFLoader.js    |  9 +++++----
 src/loaders/PCDLoader.js     |  3 ++-
 src/loaders/PLYLoader.js     |  3 ++-
 src/loaders/STLLoader.js     |  3 ++-
 src/loaders/VTKLoader.js     |  7 ++++---
 src/loaders/XLoader.js       |  5 +++--
 10 files changed, 52 insertions(+), 18 deletions(-)
 create mode 100644 src/_polyfill/LoaderUtils.js

diff --git a/src/_polyfill/LoaderUtils.js b/src/_polyfill/LoaderUtils.js
new file mode 100644
index 00000000..ad68a6e1
--- /dev/null
+++ b/src/_polyfill/LoaderUtils.js
@@ -0,0 +1,25 @@
+export function decodeText(array) {
+  if (typeof TextDecoder !== 'undefined') {
+    return new TextDecoder().decode(array)
+  }
+
+  // Avoid the String.fromCharCode.apply(null, array) shortcut, which
+  // throws a "maximum call stack size exceeded" error for large arrays.
+
+  let s = ''
+
+  for (let i = 0, il = array.length; i < il; i++) {
+    // Implicitly assumes little-endian.
+    s += String.fromCharCode(array[i])
+  }
+
+  try {
+    // merges multi-byte utf-8 characters.
+
+    return decodeURIComponent(escape(s))
+  } catch (e) {
+    // see https://github.com/mrdoob/three.js/issues/16358
+
+    return s
+  }
+}
diff --git a/src/loaders/3MFLoader.js b/src/loaders/3MFLoader.js
index 5b00a4a3..8f2006b3 100644
--- a/src/loaders/3MFLoader.js
+++ b/src/loaders/3MFLoader.js
@@ -20,6 +20,7 @@ import {
   TextureLoader,
 } from 'three'
 import { unzipSync } from 'fflate'
+import { decodeText } from '../_polyfill/LoaderUtils'
 
 /**
  *
@@ -121,14 +122,14 @@ class ThreeMFLoader extends Loader {
       //
 
       const relsView = zip[relsName]
-      const relsFileText = LoaderUtils.decodeText(relsView)
+      const relsFileText = decodeText(relsView)
       const rels = parseRelsXml(relsFileText)
 
       //
 
       if (modelRelsName) {
         const relsView = zip[modelRelsName]
-        const relsFileText = LoaderUtils.decodeText(relsView)
+        const relsFileText = decodeText(relsView)
         modelRels = parseRelsXml(relsFileText)
       }
 
@@ -138,7 +139,7 @@ class ThreeMFLoader extends Loader {
         const modelPart = modelPartNames[i]
         const view = zip[modelPart]
 
-        const fileText = LoaderUtils.decodeText(view)
+        const fileText = decodeText(view)
         const xmlData = new DOMParser().parseFromString(fileText, 'application/xml')
 
         if (xmlData.documentElement.nodeName.toLowerCase() !== 'model') {
diff --git a/src/loaders/AMFLoader.js b/src/loaders/AMFLoader.js
index 0e0d4972..f87f2431 100644
--- a/src/loaders/AMFLoader.js
+++ b/src/loaders/AMFLoader.js
@@ -10,6 +10,7 @@ import {
   MeshPhongMaterial,
 } from 'three'
 import { unzipSync } from 'fflate'
+import { decodeText } from '../_polyfill/LoaderUtils'
 
 /**
  * Description: Early release of an AMF Loader following the pattern of the
@@ -90,7 +91,7 @@ class AMFLoader extends Loader {
         view = new DataView(zip[file].buffer)
       }
 
-      const fileText = LoaderUtils.decodeText(view)
+      const fileText = decodeText(view)
       const xmlData = new DOMParser().parseFromString(fileText, 'application/xml')
 
       if (xmlData.documentElement.nodeName.toLowerCase() !== 'amf') {
diff --git a/src/loaders/FBXLoader.js b/src/loaders/FBXLoader.js
index 7410e737..c0d179d0 100644
--- a/src/loaders/FBXLoader.js
+++ b/src/loaders/FBXLoader.js
@@ -42,6 +42,7 @@ import {
 } from 'three'
 import { unzlibSync } from 'fflate'
 import { NURBSCurve } from '../curves/NURBSCurve'
+import { decodeText } from '../_polyfill/LoaderUtils'
 
 /**
  * Loader loads FBX file and generates Group representing FBX scene.
@@ -3005,7 +3006,7 @@ class BinaryReader {
     const nullByte = a.indexOf(0)
     if (nullByte >= 0) a = a.slice(0, nullByte)
 
-    return LoaderUtils.decodeText(new Uint8Array(a))
+    return decodeText(new Uint8Array(a))
   }
 }
 
@@ -3268,7 +3269,7 @@ function convertArrayBufferToString(buffer, from, to) {
   if (from === undefined) from = 0
   if (to === undefined) to = buffer.byteLength
 
-  return LoaderUtils.decodeText(new Uint8Array(buffer, from, to))
+  return decodeText(new Uint8Array(buffer, from, to))
 }
 
 function append(a, b) {
diff --git a/src/loaders/GLTFLoader.js b/src/loaders/GLTFLoader.js
index 83909fba..c4b7d01c 100644
--- a/src/loaders/GLTFLoader.js
+++ b/src/loaders/GLTFLoader.js
@@ -64,6 +64,7 @@ import {
 } from 'three'
 import { toTrianglesDrawMode } from '../utils/BufferGeometryUtils'
 import { version } from '../_polyfill/constants'
+import { decodeText } from '../_polyfill/LoaderUtils'
 
 const SRGBColorSpace = 'srgb'
 const LinearSRGBColorSpace = 'srgb-linear'
@@ -257,7 +258,7 @@ class GLTFLoader extends Loader {
     if (typeof data === 'string') {
       json = JSON.parse(data)
     } else if (data instanceof ArrayBuffer) {
-      const magic = LoaderUtils.decodeText(new Uint8Array(data.slice(0, 4)))
+      const magic = decodeText(new Uint8Array(data.slice(0, 4)))
 
       if (magic === BINARY_EXTENSION_HEADER_MAGIC) {
         try {
@@ -269,7 +270,7 @@ class GLTFLoader extends Loader {
 
         json = JSON.parse(extensions[EXTENSIONS.KHR_BINARY_GLTF].content)
       } else {
-        json = JSON.parse(LoaderUtils.decodeText(new Uint8Array(data)))
+        json = JSON.parse(decodeText(new Uint8Array(data)))
       }
     } else {
       json = data
@@ -1446,7 +1447,7 @@ class GLTFBinaryExtension {
     const headerView = new DataView(data, 0, BINARY_EXTENSION_HEADER_LENGTH)
 
     this.header = {
-      magic: LoaderUtils.decodeText(new Uint8Array(data.slice(0, 4))),
+      magic: decodeText(new Uint8Array(data.slice(0, 4))),
       version: headerView.getUint32(4, true),
       length: headerView.getUint32(8, true),
     }
@@ -1470,7 +1471,7 @@ class GLTFBinaryExtension {
 
       if (chunkType === BINARY_EXTENSION_CHUNK_TYPES.JSON) {
         const contentArray = new Uint8Array(data, BINARY_EXTENSION_HEADER_LENGTH + chunkIndex, chunkLength)
-        this.content = LoaderUtils.decodeText(contentArray)
+        this.content = decodeText(contentArray)
       } else if (chunkType === BINARY_EXTENSION_CHUNK_TYPES.BIN) {
         const byteOffset = BINARY_EXTENSION_HEADER_LENGTH + chunkIndex
         this.body = data.slice(byteOffset, byteOffset + chunkLength)
diff --git a/src/loaders/PCDLoader.js b/src/loaders/PCDLoader.js
index eebba248..4f39f304 100644
--- a/src/loaders/PCDLoader.js
+++ b/src/loaders/PCDLoader.js
@@ -1,4 +1,5 @@
 import { BufferGeometry, FileLoader, Float32BufferAttribute, Loader, LoaderUtils, Points, PointsMaterial } from 'three'
+import { decodeText } from '../_polyfill/LoaderUtils'
 
 class PCDLoader extends Loader {
   constructor(manager) {
@@ -158,7 +159,7 @@ class PCDLoader extends Loader {
       return PCDheader
     }
 
-    const textData = LoaderUtils.decodeText(new Uint8Array(data))
+    const textData = decodeText(new Uint8Array(data))
 
     // parse header (always ascii format)
 
diff --git a/src/loaders/PLYLoader.js b/src/loaders/PLYLoader.js
index 8e752406..c57b0786 100644
--- a/src/loaders/PLYLoader.js
+++ b/src/loaders/PLYLoader.js
@@ -1,4 +1,5 @@
 import { BufferGeometry, FileLoader, Float32BufferAttribute, Loader, LoaderUtils } from 'three'
+import { decodeText } from '../_polyfill/LoaderUtils'
 
 /**
  * Description: A THREE loader for PLY ASCII files (known as the Polygon
@@ -421,7 +422,7 @@ class PLYLoader extends Loader {
     const scope = this
 
     if (data instanceof ArrayBuffer) {
-      const text = LoaderUtils.decodeText(new Uint8Array(data))
+      const text = decodeText(new Uint8Array(data))
       const header = parseHeader(text)
 
       geometry = header.format === 'ascii' ? parseASCII(text, header) : parseBinary(data, header)
diff --git a/src/loaders/STLLoader.js b/src/loaders/STLLoader.js
index 25d08020..536366a9 100644
--- a/src/loaders/STLLoader.js
+++ b/src/loaders/STLLoader.js
@@ -7,6 +7,7 @@ import {
   LoaderUtils,
   Vector3,
 } from 'three'
+import { decodeText } from '../_polyfill/LoaderUtils'
 
 /**
  * Description: A THREE loader for STL ASCII files, as created by Solidworks and other CAD programs.
@@ -305,7 +306,7 @@ class STLLoader extends Loader {
 
     function ensureString(buffer) {
       if (typeof buffer !== 'string') {
-        return LoaderUtils.decodeText(new Uint8Array(buffer))
+        return decodeText(new Uint8Array(buffer))
       }
 
       return buffer
diff --git a/src/loaders/VTKLoader.js b/src/loaders/VTKLoader.js
index f8ce42e8..b9105c59 100644
--- a/src/loaders/VTKLoader.js
+++ b/src/loaders/VTKLoader.js
@@ -1,5 +1,6 @@
 import { BufferAttribute, BufferGeometry, FileLoader, Float32BufferAttribute, Loader, LoaderUtils } from 'three'
 import { unzlibSync } from 'fflate'
+import { decodeText } from '../_polyfill/LoaderUtils'
 
 class VTKLoader extends Loader {
   constructor(manager) {
@@ -885,12 +886,12 @@ class VTKLoader extends Loader {
     }
 
     // get the 5 first lines of the files to check if there is the key word binary
-    var meta = LoaderUtils.decodeText(new Uint8Array(data, 0, 250)).split('\n')
+    var meta = decodeText(new Uint8Array(data, 0, 250)).split('\n')
 
     if (meta[0].indexOf('xml') !== -1) {
-      return parseXML(LoaderUtils.decodeText(data))
+      return parseXML(decodeText(data))
     } else if (meta[2].includes('ASCII')) {
-      return parseASCII(LoaderUtils.decodeText(data))
+      return parseASCII(decodeText(data))
     } else {
       return parseBinary(data)
     }
diff --git a/src/loaders/XLoader.js b/src/loaders/XLoader.js
index 49ff0616..60cba98b 100644
--- a/src/loaders/XLoader.js
+++ b/src/loaders/XLoader.js
@@ -19,6 +19,7 @@ import {
   Vector2,
   Vector3,
 } from 'three'
+import { decodeText } from '../_polyfill/LoaderUtils'
 
 var XLoader = (function () {
   var classCallCheck = function (instance, Constructor) {
@@ -363,7 +364,7 @@ var XLoader = (function () {
         key: '_ensureString',
         value: function _ensureString(buf) {
           if (typeof buf !== 'string') {
-            return LoaderUtils.decodeText(new Uint8Array(buf))
+            return decodeText(new Uint8Array(buf))
           } else {
             return buf
           }
@@ -381,7 +382,7 @@ var XLoader = (function () {
       {
         key: '_parseBinary',
         value: function _parseBinary(data) {
-          return this._parseASCII(LoaderUtils.decodeText(new Uint8Array(data)))
+          return this._parseASCII(decodeText(new Uint8Array(data)))
         },
       },
       {

From 22fb85ee2ca0609bc587e59bbff8f58a77d4eba4 Mon Sep 17 00:00:00 2001
From: Roel Kok <roel@roelkok.net>
Date: Thu, 4 Jul 2024 00:39:48 +0200
Subject: [PATCH 16/36] fix(KTX2Loader): web worker scope (#374)

---
 src/loaders/KTX2Loader.js | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/src/loaders/KTX2Loader.js b/src/loaders/KTX2Loader.js
index fa600f74..f2b25571 100644
--- a/src/loaders/KTX2Loader.js
+++ b/src/loaders/KTX2Loader.js
@@ -129,9 +129,12 @@ class KTX2Loader extends Loader {
     let transcoderPending
     let BasisModule
 
-    const EngineFormat = KTX2Loader.EngineFormat
-    const TranscoderFormat = KTX2Loader.TranscoderFormat
-    const BasisFormat = KTX2Loader.BasisFormat
+    /** @type KTX2Loader.EngineFormat */
+    const EngineFormat = _EngineFormat
+    /** @type KTX2Loader.TranscoderFormat */
+    const TranscoderFormat = _TranscoderFormat
+    /** @type KTX2Loader.BasisFormat */
+    const BasisFormat = _BasisFormat
 
     self.addEventListener('message', function (e) {
       const message = e.data

From 40a4d33f64741adf589ac331dda36e309573e85c Mon Sep 17 00:00:00 2001
From: Nathan Bierema <nbierema@gmail.com>
Date: Thu, 25 Jul 2024 18:13:22 -0400
Subject: [PATCH 17/36] fix(types): compatibility with @types/three@0.167.0
 (#375)

The `Matrix` interface was removed in [@types/three@0.167.0](https://github.com/three-types/three-ts-types/releases/tag/r167). `Matrix4` seems like the better type anyway.
---
 src/deprecated/Geometry.d.ts | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/deprecated/Geometry.d.ts b/src/deprecated/Geometry.d.ts
index 7a11aac5..a64f55de 100644
--- a/src/deprecated/Geometry.d.ts
+++ b/src/deprecated/Geometry.d.ts
@@ -7,7 +7,6 @@ import {
   Sphere,
   Matrix4,
   BufferGeometry,
-  Matrix,
   Mesh,
   Bone,
   AnimationClip,
@@ -232,7 +231,7 @@ export class Geometry extends EventDispatcher {
    */
   computeBoundingSphere(): void
 
-  merge(geometry: Geometry, matrix?: Matrix, materialIndexOffset?: number): void
+  merge(geometry: Geometry, matrix?: Matrix4, materialIndexOffset?: number): void
 
   mergeMesh(mesh: Mesh): void
 

From d89e3c32a1eb97e9415e2c361e18af081bc66a25 Mon Sep 17 00:00:00 2001
From: Rodri <hamuyrodrigo@gmail.com>
Date: Mon, 5 Aug 2024 14:34:41 +0100
Subject: [PATCH 18/36] feat: remove need for manually assigning Line2 material
 resolution (#376)

---
 src/lines/LineMaterial.js  |  1 -
 src/lines/LineSegments2.js | 38 ++++++++++++++++++++++++++++++--------
 src/lines/Wireframe.js     | 16 +++++++++++++++-
 3 files changed, 45 insertions(+), 10 deletions(-)

diff --git a/src/lines/LineMaterial.js b/src/lines/LineMaterial.js
index 728beb17..3c4959de 100644
--- a/src/lines/LineMaterial.js
+++ b/src/lines/LineMaterial.js
@@ -7,7 +7,6 @@
  *  dashSize: <float>,
  *  dashOffset: <float>,
  *  gapSize: <float>,
- *  resolution: <Vector2>, // to be set by renderer
  * }
  */
 
diff --git a/src/lines/LineSegments2.js b/src/lines/LineSegments2.js
index f9feecf0..71ac7b21 100644
--- a/src/lines/LineSegments2.js
+++ b/src/lines/LineSegments2.js
@@ -13,6 +13,8 @@ import {
 import { LineSegmentsGeometry } from '../lines/LineSegmentsGeometry'
 import { LineMaterial } from '../lines/LineMaterial'
 
+const _viewport = new Vector4();
+
 const _start = new Vector3()
 const _end = new Vector3()
 
@@ -29,7 +31,7 @@ const _box = new Box3()
 const _sphere = new Sphere()
 const _clipToWorldVector = new Vector4()
 
-let _ray, _instanceStart, _instanceEnd, _lineWidth
+let _ray, _lineWidth
 
 // Returns the margin required to expand by in world space given the distance from the camera,
 // line width, resolution, and camera projection
@@ -48,9 +50,18 @@ function getWorldSpaceHalfWidth(camera, distance, resolution) {
 }
 
 function raycastWorldUnits(lineSegments, intersects) {
-  for (let i = 0, l = _instanceStart.count; i < l; i++) {
-    _line.start.fromBufferAttribute(_instanceStart, i)
-    _line.end.fromBufferAttribute(_instanceEnd, i)
+
+  const matrixWorld = lineSegments.matrixWorld;
+  const geometry = lineSegments.geometry;
+  const instanceStart = geometry.attributes.instanceStart;
+  const instanceEnd = geometry.attributes.instanceEnd;
+  const segmentCount = Math.min(geometry.instanceCount, instanceStart.count);
+
+  for (let i = 0, l = segmentCount; i < l; i++) {
+    _line.start.fromBufferAttribute(instanceStart, i)
+    _line.end.fromBufferAttribute(instanceEnd, i)
+
+    _line.applyMatrix4(matrixWorld);
 
     const pointOnLine = new Vector3()
     const point = new Vector3()
@@ -82,6 +93,7 @@ function raycastScreenSpace(lineSegments, camera, intersects) {
   const geometry = lineSegments.geometry
   const instanceStart = geometry.attributes.instanceStart
   const instanceEnd = geometry.attributes.instanceEnd
+  const segmentCount = Math.min(geometry.instanceCount, instanceStart.count);
 
   const near = -camera.near
 
@@ -107,7 +119,7 @@ function raycastScreenSpace(lineSegments, camera, intersects) {
 
   _mvMatrix.multiplyMatrices(camera.matrixWorldInverse, matrixWorld)
 
-  for (let i = 0, l = instanceStart.count; i < l; i++) {
+  for (let i = 0, l = segmentCount; i < l; i++) {
     _start4.fromBufferAttribute(instanceStart, i)
     _end4.fromBufferAttribute(instanceEnd, i)
 
@@ -247,9 +259,6 @@ class LineSegments2 extends Mesh {
 
     _lineWidth = material.linewidth + threshold
 
-    _instanceStart = geometry.attributes.instanceStart
-    _instanceEnd = geometry.attributes.instanceEnd
-
     // check if we intersect the sphere bounds
     if (geometry.boundingSphere === null) {
       geometry.computeBoundingSphere()
@@ -300,6 +309,19 @@ class LineSegments2 extends Mesh {
       raycastScreenSpace(this, camera, intersects)
     }
   }
+
+  onBeforeRender(renderer) {
+
+    const uniforms = this.material.uniforms;
+
+    if (uniforms && uniforms.resolution) {
+
+      renderer.getViewport(_viewport);
+      this.material.uniforms.resolution.value.set(_viewport.z, _viewport.w);
+
+    }
+
+  }
 }
 
 export { LineSegments2 }
diff --git a/src/lines/Wireframe.js b/src/lines/Wireframe.js
index 2e193dd4..5c3bfe87 100644
--- a/src/lines/Wireframe.js
+++ b/src/lines/Wireframe.js
@@ -1,9 +1,10 @@
-import { InstancedInterleavedBuffer, InterleavedBufferAttribute, Mesh, Vector3 } from 'three'
+import { InstancedInterleavedBuffer, InterleavedBufferAttribute, Mesh, Vector3, Vector4 } from 'three'
 import { LineSegmentsGeometry } from '../lines/LineSegmentsGeometry'
 import { LineMaterial } from '../lines/LineMaterial'
 
 const _start = new Vector3()
 const _end = new Vector3()
+const _viewport = new Vector4();
 
 class Wireframe extends Mesh {
   constructor(geometry = new LineSegmentsGeometry(), material = new LineMaterial({ color: Math.random() * 0xffffff })) {
@@ -38,6 +39,19 @@ class Wireframe extends Mesh {
 
     return this
   }
+
+  onBeforeRender(renderer) {
+
+    const uniforms = this.material.uniforms;
+
+    if (uniforms && uniforms.resolution) {
+
+      renderer.getViewport(_viewport);
+      this.material.uniforms.resolution.value.set(_viewport.z, _viewport.w);
+
+    }
+
+  }
 }
 
 export { Wireframe }

From 002e78046af8da5ca68e36c8abd7cad178ac943a Mon Sep 17 00:00:00 2001
From: Kosuke-KIDO-datalabs
 <103032063+Kosuke-KIDO-datalabs@users.noreply.github.com>
Date: Mon, 5 Aug 2024 22:36:54 +0900
Subject: [PATCH 19/36] feat: refactor control classes to use readonly for
 target property (#370)

---
 src/controls/ArcballControls.ts     | 2 +-
 src/controls/FirstPersonControls.ts | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/controls/ArcballControls.ts b/src/controls/ArcballControls.ts
index c64a77a3..8a65882d 100644
--- a/src/controls/ArcballControls.ts
+++ b/src/controls/ArcballControls.ts
@@ -190,7 +190,7 @@ class ArcballControls extends EventDispatcher {
   public minZoom: number
   public maxZoom: number
 
-  private target: Vector3
+  readonly target: Vector3
   private _currentTarget: Vector3
 
   private _tbRadius: number
diff --git a/src/controls/FirstPersonControls.ts b/src/controls/FirstPersonControls.ts
index 79fdd5de..e6bbd251 100644
--- a/src/controls/FirstPersonControls.ts
+++ b/src/controls/FirstPersonControls.ts
@@ -49,7 +49,7 @@ export class FirstPersonControls extends EventDispatcher {
 
   private lookDirection = new Vector3()
   private spherical = new Spherical()
-  private target = new Vector3()
+  readonly target = new Vector3()
 
   constructor(object: Camera, domElement?: HTMLElement | null) {
     super()

From 442de298a1945ea3fc20ec700912f4ad543a5ab1 Mon Sep 17 00:00:00 2001
From: Rodri <hamuyrodrigo@gmail.com>
Date: Mon, 5 Aug 2024 22:48:13 +0100
Subject: [PATCH 20/36] fix: BufferGeometry rename uv2 to uv1 (#377)

---
 src/_polyfill/uv1.ts                |  7 ++++++
 src/exporters/ColladaExporter.ts    |  5 ++--
 src/lines/LineSegments2.js          |  5 ++--
 src/loaders/ColladaLoader.js        | 27 ++++++++++----------
 src/loaders/FBXLoader.js            | 10 +++-----
 src/loaders/LWOLoader.js            |  3 ++-
 src/misc/ProgressiveLightmap.js     | 21 ++++++++--------
 src/modifiers/TessellateModifier.ts | 39 +++++++++++++++--------------
 8 files changed, 63 insertions(+), 54 deletions(-)
 create mode 100644 src/_polyfill/uv1.ts

diff --git a/src/_polyfill/uv1.ts b/src/_polyfill/uv1.ts
new file mode 100644
index 00000000..ffb3949c
--- /dev/null
+++ b/src/_polyfill/uv1.ts
@@ -0,0 +1,7 @@
+import { version } from "./constants";
+
+/** uv2 renamed to uv1 in r125
+ * 
+ * https://github.com/mrdoob/three.js/pull/25943
+*/
+export const UV1 = version >= 125 ? 'uv1' : 'uv2'
\ No newline at end of file
diff --git a/src/exporters/ColladaExporter.ts b/src/exporters/ColladaExporter.ts
index bcc5a567..549e5571 100644
--- a/src/exporters/ColladaExporter.ts
+++ b/src/exporters/ColladaExporter.ts
@@ -14,6 +14,7 @@ import {
   Texture,
 } from 'three'
 import type { TypedArray, TypedArrayConstructors } from '../types/shared'
+import { UV1 } from '../_polyfill/uv1'
 
 /**
  * https://github.com/gkjohnson/collada-exporter-js
@@ -346,9 +347,9 @@ class ColladaExporter {
       }
 
       // serialize lightmap uvs
-      if ('uv2' in bufferGeometry.attributes) {
+      if (UV1 in bufferGeometry.attributes) {
         const uvName = `${meshid}-texcoord2`
-        gnode += this.getAttribute(bufferGeometry.attributes.uv2, uvName, ['S', 'T'], 'float')
+        gnode += this.getAttribute(bufferGeometry.attributes[UV1], uvName, ['S', 'T'], 'float')
         triangleInputs += `<input semantic="TEXCOORD" source="#${uvName}" offset="0" set="1" />`
       }
 
diff --git a/src/lines/LineSegments2.js b/src/lines/LineSegments2.js
index 71ac7b21..b514fe81 100644
--- a/src/lines/LineSegments2.js
+++ b/src/lines/LineSegments2.js
@@ -12,6 +12,7 @@ import {
 } from 'three'
 import { LineSegmentsGeometry } from '../lines/LineSegmentsGeometry'
 import { LineMaterial } from '../lines/LineMaterial'
+import { UV1 } from '../_polyfill/uv1'
 
 const _viewport = new Vector4();
 
@@ -78,7 +79,7 @@ function raycastWorldUnits(lineSegments, intersects) {
         face: null,
         faceIndex: i,
         uv: null,
-        uv2: null,
+        [UV1]: null,
       })
     }
   }
@@ -199,7 +200,7 @@ function raycastScreenSpace(lineSegments, camera, intersects) {
         face: null,
         faceIndex: i,
         uv: null,
-        uv2: null,
+        [UV1]: null,
       })
     }
   }
diff --git a/src/loaders/ColladaLoader.js b/src/loaders/ColladaLoader.js
index 6b534f87..f79af8c5 100644
--- a/src/loaders/ColladaLoader.js
+++ b/src/loaders/ColladaLoader.js
@@ -39,6 +39,7 @@ import {
   VectorKeyframeTrack,
 } from 'three'
 import { TGALoader } from '../loaders/TGALoader'
+import { UV1 } from '../_polyfill/uv1'
 
 class ColladaLoader extends Loader {
   constructor(manager) {
@@ -1866,7 +1867,7 @@ class ColladaLoader extends Loader {
       const position = { array: [], stride: 0 }
       const normal = { array: [], stride: 0 }
       const uv = { array: [], stride: 0 }
-      const uv2 = { array: [], stride: 0 }
+      const uv1 = { array: [], stride: 0 }
       const color = { array: [], stride: 0 }
 
       const skinIndex = { array: [], stride: 4 }
@@ -1981,7 +1982,7 @@ class ColladaLoader extends Loader {
                     break
 
                   case 'TEXCOORD1':
-                    buildGeometryData(primitive, sources[id], input.offset, uv2.array)
+                    buildGeometryData(primitive, sources[id], input.offset, uv1.array)
                     uv.stride = sources[id].stride
                     break
 
@@ -2008,8 +2009,8 @@ class ColladaLoader extends Loader {
               break
 
             case 'TEXCOORD1':
-              buildGeometryData(primitive, sources[input.id], input.offset, uv2.array)
-              uv2.stride = sources[input.id].stride
+              buildGeometryData(primitive, sources[input.id], input.offset, uv1.array)
+              uv1.stride = sources[input.id].stride
               break
           }
         }
@@ -2025,7 +2026,7 @@ class ColladaLoader extends Loader {
       }
       if (color.array.length > 0) geometry.setAttribute('color', new Float32BufferAttribute(color.array, color.stride))
       if (uv.array.length > 0) geometry.setAttribute('uv', new Float32BufferAttribute(uv.array, uv.stride))
-      if (uv2.array.length > 0) geometry.setAttribute('uv2', new Float32BufferAttribute(uv2.array, uv2.stride))
+      if (uv1.array.length > 0) geometry.setAttribute(UV1, new Float32BufferAttribute(uv1.array, uv1.stride))
 
       if (skinIndex.array.length > 0) {
         geometry.setAttribute('skinIndex', new Float32BufferAttribute(skinIndex.array, skinIndex.stride))
@@ -2496,14 +2497,14 @@ class ColladaLoader extends Loader {
             if (value > joint.limits.max || value < joint.limits.min) {
               console.warn(
                 'THREE.ColladaLoader: Joint ' +
-                  jointIndex +
-                  ' value ' +
-                  value +
-                  ' outside of limits (min: ' +
-                  joint.limits.min +
-                  ', max: ' +
-                  joint.limits.max +
-                  ').',
+                jointIndex +
+                ' value ' +
+                value +
+                ' outside of limits (min: ' +
+                joint.limits.min +
+                ', max: ' +
+                joint.limits.max +
+                ').',
               )
             } else if (joint.static) {
               console.warn('THREE.ColladaLoader: Joint ' + jointIndex + ' is static.')
diff --git a/src/loaders/FBXLoader.js b/src/loaders/FBXLoader.js
index c0d179d0..e171ec87 100644
--- a/src/loaders/FBXLoader.js
+++ b/src/loaders/FBXLoader.js
@@ -43,6 +43,7 @@ import {
 import { unzlibSync } from 'fflate'
 import { NURBSCurve } from '../curves/NURBSCurve'
 import { decodeText } from '../_polyfill/LoaderUtils'
+import { UV1 } from '../_polyfill/uv1'
 
 /**
  * Loader loads FBX file and generates Group representing FBX scene.
@@ -1274,13 +1275,8 @@ class GeometryParser {
     }
 
     buffers.uvs.forEach(function (uvBuffer, i) {
-      // subsequent uv buffers are called 'uv1', 'uv2', ...
-      let name = 'uv' + (i + 1).toString()
-
-      // the first uv buffer is just called 'uv'
-      if (i === 0) {
-        name = 'uv'
-      }
+      if (UV1 === 'uv2') i++;
+      const name = i === 0 ? 'uv' : `uv${i}`;
 
       geo.setAttribute(name, new Float32BufferAttribute(buffers.uvs[i], 2))
     })
diff --git a/src/loaders/LWOLoader.js b/src/loaders/LWOLoader.js
index 8ae1c5a6..6ec856de 100644
--- a/src/loaders/LWOLoader.js
+++ b/src/loaders/LWOLoader.js
@@ -40,6 +40,7 @@ import {
 } from 'three'
 
 import { IFFParser } from './lwo/IFFParser.js'
+import { UV1 } from '../_polyfill/uv1.ts'
 
 let _lwoTree
 
@@ -148,7 +149,7 @@ class LWOTreeParser {
 
     const materials = this.getMaterials(geometry.userData.matNames, layer.geometry.type)
 
-    this.duplicateUVs(geometry, materials)
+    if (UV1 === 'uv2') this.duplicateUVs(geometry, materials)
 
     if (layer.geometry.type === 'points') mesh = new Points(geometry, materials)
     else if (layer.geometry.type === 'lines') mesh = new LineSegments(geometry, materials)
diff --git a/src/misc/ProgressiveLightmap.js b/src/misc/ProgressiveLightmap.js
index 70719d55..b117170d 100644
--- a/src/misc/ProgressiveLightmap.js
+++ b/src/misc/ProgressiveLightmap.js
@@ -9,6 +9,7 @@ import {
   Mesh,
 } from 'three'
 import potpack from 'potpack'
+import { UV1 } from '../_polyfill/uv1'
 
 /**
  * Progressive Light Map Accumulator, by [zalo](https://github.com/zalo/)
@@ -52,16 +53,16 @@ class ProgressiveLightMap {
       shader.vertexShader =
         '#define USE_LIGHTMAP\n' +
         shader.vertexShader.slice(0, -1) +
-        '	gl_Position = vec4((uv2 - 0.5) * 2.0, 1.0, 1.0); }'
+        `	gl_Position = vec4((${UV1} - 0.5) * 2.0, 1.0, 1.0); }`
 
       // Fragment Shader: Set Pixels to average in the Previous frame's Shadows
       const bodyStart = shader.fragmentShader.indexOf('void main() {')
       shader.fragmentShader =
-        'varying vec2 vUv2;\n' +
+        `varying vec2 v${UV1 === 'uv1' ? UV1 : 'Uv2'};\n` +
         shader.fragmentShader.slice(0, bodyStart) +
         '	uniform sampler2D previousShadowMap;\n	uniform float averagingWindow;\n' +
         shader.fragmentShader.slice(bodyStart - 1, -1) +
-        `\nvec3 texelOld = texture2D(previousShadowMap, vUv2).rgb;
+        `\nvec3 texelOld = texture2D(previousShadowMap, v${UV1 === 'uv1' ? UV1 : 'Uv2'}).rgb;
 				gl_FragColor.rgb = mix(texelOld, gl_FragColor.rgb, 1.0/averagingWindow);
 			}`
 
@@ -79,7 +80,7 @@ class ProgressiveLightMap {
   }
 
   /**
-   * Sets these objects' materials' lightmaps and modifies their uv2's.
+   * Sets these objects' materials' lightmaps and modifies their uv1's.
    * @param {Object3D} objects An array of objects and lights to set up your lightmap.
    */
   addObjectsToLightMap(objects) {
@@ -124,14 +125,14 @@ class ProgressiveLightMap {
     // Pack the objects' lightmap UVs into the same global space
     const dimensions = potpack(this.uv_boxes)
     this.uv_boxes.forEach((box) => {
-      const uv2 = objects[box.index].geometry.getAttribute('uv').clone()
-      for (let i = 0; i < uv2.array.length; i += uv2.itemSize) {
-        uv2.array[i] = (uv2.array[i] + box.x + padding) / dimensions.w
-        uv2.array[i + 1] = (uv2.array[i + 1] + box.y + padding) / dimensions.h
+      const uv1 = objects[box.index].geometry.getAttribute('uv').clone()
+      for (let i = 0; i < uv1.array.length; i += uv1.itemSize) {
+        uv1.array[i] = (uv1.array[i] + box.x + padding) / dimensions.w
+        uv1.array[i + 1] = (uv1.array[i + 1] + box.y + padding) / dimensions.h
       }
 
-      objects[box.index].geometry.setAttribute('uv2', uv2)
-      objects[box.index].geometry.getAttribute('uv2').needsUpdate = true
+      objects[box.index].geometry.setAttribute(UV1, uv1)
+      objects[box.index].geometry.getAttribute(UV1).needsUpdate = true
     })
   }
 
diff --git a/src/modifiers/TessellateModifier.ts b/src/modifiers/TessellateModifier.ts
index 152f53f7..05d240de 100644
--- a/src/modifiers/TessellateModifier.ts
+++ b/src/modifiers/TessellateModifier.ts
@@ -1,4 +1,5 @@
 import { BufferGeometry, Color, Float32BufferAttribute, Vector2, Vector3 } from 'three'
+import { UV1 } from '../_polyfill/uv1'
 
 /**
  * Break faces with edges longer than maxEdgeLength
@@ -57,19 +58,19 @@ class TessellateModifier {
     const hasNormals = attributes.normal !== undefined
     const hasColors = attributes.color !== undefined
     const hasUVs = attributes.uv !== undefined
-    const hasUV2s = attributes.uv2 !== undefined
+    const hasUV1s = attributes[UV1] !== undefined
 
     let positions = attributes.position.array
     let normals = hasNormals ? attributes.normal.array : null
     let colors = hasColors ? attributes.color.array : null
     let uvs = hasUVs ? attributes.uv.array : null
-    let uv2s = hasUV2s ? attributes.uv2.array : null
+    let uv1s = hasUV1s ? attributes.uv1.array : null
 
     let positions2 = (positions as unknown) as number[]
     let normals2 = (normals as unknown) as number[]
     let colors2 = (colors as unknown) as number[]
     let uvs2 = (uvs as unknown) as number[]
-    let uv2s2 = (uv2s as unknown) as number[]
+    let uv1s2 = (uv1s as unknown) as number[]
 
     let iteration = 0
     let tessellating = true
@@ -113,14 +114,14 @@ class TessellateModifier {
         uvs2.push(u3.x, u3.y)
       }
 
-      if (hasUV2s) {
+      if (hasUV1s) {
         const u21 = u2s[a]
         const u22 = u2s[b]
         const u23 = u2s[c]
 
-        uv2s2.push(u21.x, u21.y)
-        uv2s2.push(u22.x, u22.y)
-        uv2s2.push(u23.x, u23.y)
+        uv1s2.push(u21.x, u21.y)
+        uv1s2.push(u22.x, u22.y)
+        uv1s2.push(u23.x, u23.y)
       }
     }
 
@@ -146,9 +147,9 @@ class TessellateModifier {
         uvs2 = []
       }
 
-      if (hasUV2s) {
-        uv2s = uv2s2 as any
-        uv2s2 = []
+      if (hasUV1s) {
+        uv1s = uv1s2 as any
+        uv1s2 = []
       }
 
       for (let i = 0, i2 = 0, il = positions.length; i < il; i += 9, i2 += 6) {
@@ -174,10 +175,10 @@ class TessellateModifier {
           uc.fromArray(uvs, i2 + 4)
         }
 
-        if (hasUV2s && uv2s) {
-          u2a.fromArray(uv2s, i2 + 0)
-          u2b.fromArray(uv2s, i2 + 2)
-          u2c.fromArray(uv2s, i2 + 4)
+        if (hasUV1s && uv1s) {
+          u2a.fromArray(uv1s, i2 + 0)
+          u2b.fromArray(uv1s, i2 + 2)
+          u2c.fromArray(uv1s, i2 + 4)
         }
 
         const dab = va.distanceToSquared(vb)
@@ -192,7 +193,7 @@ class TessellateModifier {
             if (hasNormals) nm.lerpVectors(na, nb, 0.5)
             if (hasColors) cm.lerpColors(ca, cb, 0.5)
             if (hasUVs) um.lerpVectors(ua, ub, 0.5)
-            if (hasUV2s) u2m.lerpVectors(u2a, u2b, 0.5)
+            if (hasUV1s) u2m.lerpVectors(u2a, u2b, 0.5)
 
             addTriangle(0, 3, 2)
             addTriangle(3, 1, 2)
@@ -201,7 +202,7 @@ class TessellateModifier {
             if (hasNormals) nm.lerpVectors(nb, nc, 0.5)
             if (hasColors) cm.lerpColors(cb, cc, 0.5)
             if (hasUVs) um.lerpVectors(ub, uc, 0.5)
-            if (hasUV2s) u2m.lerpVectors(u2b, u2c, 0.5)
+            if (hasUV1s) u2m.lerpVectors(u2b, u2c, 0.5)
 
             addTriangle(0, 1, 3)
             addTriangle(3, 2, 0)
@@ -210,7 +211,7 @@ class TessellateModifier {
             if (hasNormals) nm.lerpVectors(na, nc, 0.5)
             if (hasColors) cm.lerpColors(ca, cc, 0.5)
             if (hasUVs) um.lerpVectors(ua, uc, 0.5)
-            if (hasUV2s) u2m.lerpVectors(u2a, u2c, 0.5)
+            if (hasUV1s) u2m.lerpVectors(u2a, u2c, 0.5)
 
             addTriangle(0, 1, 3)
             addTriangle(3, 1, 2)
@@ -237,8 +238,8 @@ class TessellateModifier {
       geometry2.setAttribute('uv', new Float32BufferAttribute(uvs2 as any, 2))
     }
 
-    if (hasUV2s) {
-      geometry2.setAttribute('uv2', new Float32BufferAttribute(uv2s2 as any, 2))
+    if (hasUV1s) {
+      geometry2.setAttribute(UV1, new Float32BufferAttribute(uv1s2 as any, 2))
     }
 
     return geometry2

From 0d281eaddc7487336793cfc866d97f6c9c824f20 Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Sat, 10 Aug 2024 05:22:54 -0500
Subject: [PATCH 21/36] fix(OrbitControls): remove document validation

---
 src/controls/OrbitControls.ts | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/src/controls/OrbitControls.ts b/src/controls/OrbitControls.ts
index 9bcbe3d1..a0d33673 100644
--- a/src/controls/OrbitControls.ts
+++ b/src/controls/OrbitControls.ts
@@ -396,11 +396,6 @@ class OrbitControls extends EventDispatcher {
 
     // https://github.com/mrdoob/three.js/issues/20575
     this.connect = (domElement: HTMLElement): void => {
-      if ((domElement as any) === document) {
-        console.error(
-          'THREE.OrbitControls: "document" should not be used as the target "domElement". Please use "renderer.domElement" instead.',
-        )
-      }
       scope.domElement = domElement
       // disables touch scroll
       // touch-action needs to be defined for pointer events to work on mobile

From 9d656b26c80e2c356df0d016ba7fddc55da50577 Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Thu, 12 Sep 2024 16:39:53 -0500
Subject: [PATCH 22/36] feat(EffectComposer): add dispose (#378)

---
 src/postprocessing/EffectComposer.ts | 7 +++++++
 src/postprocessing/Pass.ts           | 2 ++
 src/postprocessing/ShaderPass.ts     | 5 +++++
 3 files changed, 14 insertions(+)

diff --git a/src/postprocessing/EffectComposer.ts b/src/postprocessing/EffectComposer.ts
index 42c21ea0..30927665 100644
--- a/src/postprocessing/EffectComposer.ts
+++ b/src/postprocessing/EffectComposer.ts
@@ -195,6 +195,13 @@ class EffectComposer<TRenderTarget extends WebGLRenderTarget = WebGLRenderTarget
 
     this.setSize(this._width, this._height)
   }
+
+  public dispose() {
+    this.renderTarget1.dispose()
+    this.renderTarget2.dispose()
+
+    this.copyPass.dispose()
+  }
 }
 
 export { EffectComposer }
diff --git a/src/postprocessing/Pass.ts b/src/postprocessing/Pass.ts
index 83c756b9..c69f0c9b 100644
--- a/src/postprocessing/Pass.ts
+++ b/src/postprocessing/Pass.ts
@@ -24,6 +24,8 @@ class Pass {
   ): void {
     console.error('THREE.Pass: .render() must be implemented in derived pass.')
   }
+
+  public dispose() {}
 }
 
 // Helper for passes that need to fill the viewport with a single quad.
diff --git a/src/postprocessing/ShaderPass.ts b/src/postprocessing/ShaderPass.ts
index 48ab0588..f1bc6ed6 100644
--- a/src/postprocessing/ShaderPass.ts
+++ b/src/postprocessing/ShaderPass.ts
@@ -52,6 +52,11 @@ class ShaderPass extends Pass {
       this.fsQuad.render(renderer)
     }
   }
+
+  public dispose() {
+    this.fsQuad.dispose()
+    this.material.dispose()
+  }
 }
 
 export { ShaderPass }

From 232a4cd791ff1895acd3e08b83c054f65cb5838c Mon Sep 17 00:00:00 2001
From: Kojiro Futamura <gumob.dev@gmail.com>
Date: Mon, 7 Oct 2024 15:29:20 +0900
Subject: [PATCH 23/36] fix: Add support for sRGBTransferOETF to fix the
 runtime error `'LinearTosRGB' : no matching overloaded function found` (#380)

---
 src/shaders/GammaCorrectionShader.ts | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/shaders/GammaCorrectionShader.ts b/src/shaders/GammaCorrectionShader.ts
index 4e194ea9..00f0425d 100644
--- a/src/shaders/GammaCorrectionShader.ts
+++ b/src/shaders/GammaCorrectionShader.ts
@@ -37,7 +37,11 @@ export const GammaCorrectionShader: IGammaCorrectionShader = {
 
     '	vec4 tex = texture2D( tDiffuse, vUv );',
 
-    '	gl_FragColor = LinearTosRGB( tex );',
+    '	#ifdef LinearTosRGB',
+    '		gl_FragColor = LinearTosRGB( tex );',
+    '	#else',
+    '		gl_FragColor = sRGBTransferOETF( tex );',
+    '	#endif',
 
     '}',
   ].join('\n'),

From 363c0f96f37c849efcbc6fe710c72b59087113ec Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Wed, 30 Oct 2024 16:17:44 +0100
Subject: [PATCH 24/36] chore(CI): upgrade Node (#384)

---
 .github/workflows/main.yml | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index 629b998e..f10bbe22 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -15,11 +15,11 @@ jobs:
         with:
           access_token: ${{ secrets.GITHUB_TOKEN }}
       - name: Checkout repo
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
       - name: Setup node
-        uses: actions/setup-node@v2
+        uses: actions/setup-node@v4
         with:
-          node-version: '14.x'
+          node-version: '20.x'
       - name: Install deps
         run: yarn install
       - name: Check for regressions
@@ -40,11 +40,11 @@ jobs:
         with:
           access_token: ${{ secrets.GITHUB_TOKEN }}
       - name: Checkout repo
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
       - name: Setup node
-        uses: actions/setup-node@v2
+        uses: actions/setup-node@v4
         with:
-          node-version: '14.x'
+          node-version: '20.x'
       - name: Install deps
         # this runs a build script so there is no dedicated build
         run: yarn install

From 98aaa0b9386712e42b6e28173db07b4dba55a444 Mon Sep 17 00:00:00 2001
From: Yoojun Zhou <hereisnotyoojun@outlook.com>
Date: Wed, 30 Oct 2024 23:21:36 +0800
Subject: [PATCH 25/36] feat(OrbitControls): expose zoom methods for
 programmatical controls (#383)

---
 src/controls/OrbitControls.ts | 55 ++++++++++++++++++++++++++++-------
 1 file changed, 44 insertions(+), 11 deletions(-)

diff --git a/src/controls/OrbitControls.ts b/src/controls/OrbitControls.ts
index a0d33673..979d08d8 100644
--- a/src/controls/OrbitControls.ts
+++ b/src/controls/OrbitControls.ts
@@ -99,6 +99,8 @@ class OrbitControls extends EventDispatcher {
   setPolarAngle: (x: number) => void
   setAzimuthalAngle: (x: number) => void
   getDistance: () => number
+  // Not used in most scenarios, however they can be useful for specific use cases
+  getZoomScale: () => number
 
   listenToKeyEvents: (domElement: HTMLElement) => void
   stopListenToKeyEvents: () => void
@@ -108,6 +110,16 @@ class OrbitControls extends EventDispatcher {
   connect: (domElement: HTMLElement) => void
   dispose: () => void
 
+  // Dolly in programmatically
+  dollyIn: (dollyScale?: number) => void
+  // Dolly out programmatically
+  dollyOut: (dollyScale?: number) => void
+  // Get the current scale
+  getScale: () => number
+  // Set the current scale (these are not used in most scenarios, however they can be useful for specific use cases)
+  setScale: (newScale: number) => void
+  
+
   constructor(object: PerspectiveCamera | OrthographicCamera, domElement?: HTMLElement) {
     super()
 
@@ -564,28 +576,24 @@ class OrbitControls extends EventDispatcher {
       }
     })()
 
-    function dollyOut(dollyScale: number) {
+    function setScale(newScale: number) {
       if (
         (scope.object instanceof PerspectiveCamera && scope.object.isPerspectiveCamera) ||
         (scope.object instanceof OrthographicCamera && scope.object.isOrthographicCamera)
       ) {
-        scale /= dollyScale
+        scale = newScale
       } else {
         console.warn('WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.')
         scope.enableZoom = false
       }
     }
 
+    function dollyOut(dollyScale: number) {
+      setScale(scale / dollyScale)
+    }
+
     function dollyIn(dollyScale: number) {
-      if (
-        (scope.object instanceof PerspectiveCamera && scope.object.isPerspectiveCamera) ||
-        (scope.object instanceof OrthographicCamera && scope.object.isOrthographicCamera)
-      ) {
-        scale *= dollyScale
-      } else {
-        console.warn('WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.')
-        scope.enableZoom = false
-      }
+      setScale(scale * dollyScale)
     }
 
     function updateMouseParameters(event: MouseEvent): void {
@@ -1079,6 +1087,31 @@ class OrbitControls extends EventDispatcher {
       return pointerPositions[pointer.pointerId]
     }
 
+    // Add dolly in/out methods for public API
+
+    this.dollyIn = (dollyScale = getZoomScale()) => {
+      dollyIn(dollyScale)
+      scope.update()
+    }
+
+    this.dollyOut = (dollyScale = getZoomScale()) => {
+        dollyOut(dollyScale)
+        scope.update()
+    }
+
+    this.getScale = () => {
+        return scale;
+    }
+
+    this.setScale = (newScale) => {
+        setScale(newScale)
+        scope.update()
+    }
+
+    this.getZoomScale = () => {
+        return getZoomScale();
+    }
+
     // connect events
     if (domElement !== undefined) this.connect(domElement)
     // force an update at start

From 344c894d7e25a4edfb8bd0b39c4494f82783f787 Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Wed, 30 Oct 2024 10:55:58 -0500
Subject: [PATCH 26/36] chore: remove broken check

---
 .github/workflows/main.yml | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index f10bbe22..3e14379f 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -15,11 +15,11 @@ jobs:
         with:
           access_token: ${{ secrets.GITHUB_TOKEN }}
       - name: Checkout repo
-        uses: actions/checkout@v4
+        uses: actions/checkout@v2
       - name: Setup node
-        uses: actions/setup-node@v4
+        uses: actions/setup-node@v2
         with:
-          node-version: '20.x'
+          node-version: '14.x'
       - name: Install deps
         run: yarn install
       - name: Check for regressions
@@ -28,8 +28,9 @@ jobs:
         run: yarn build
       - name: Check for SSR compat
         run: node dist/index.cjs && node dist/index.js
-      - name: Check NPM config
-        run: npx publint@latest dist
+      # TODO: upgrade Nodes
+      # - name: Check NPM config
+      #   run: npx publint@latest dist
   release:
     needs: test
     runs-on: ubuntu-latest
@@ -40,11 +41,11 @@ jobs:
         with:
           access_token: ${{ secrets.GITHUB_TOKEN }}
       - name: Checkout repo
-        uses: actions/checkout@v4
+        uses: actions/checkout@v2
       - name: Setup node
-        uses: actions/setup-node@v4
+        uses: actions/setup-node@v2
         with:
-          node-version: '20.x'
+          node-version: '14.x'
       - name: Install deps
         # this runs a build script so there is no dedicated build
         run: yarn install

From 6b51b6dfaa4af721616945c0b0f9787afdd0a3f8 Mon Sep 17 00:00:00 2001
From: satelllte <20585619+satelllte@users.noreply.github.com>
Date: Tue, 12 Nov 2024 15:34:57 +0200
Subject: [PATCH 27/36] PointerLockControls: remove "moz", "webkit" prefixes
 for "MouseEvent.movementX" (#385)

---
 src/controls/PointerLockControls.ts | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/controls/PointerLockControls.ts b/src/controls/PointerLockControls.ts
index 55fa7f78..1aa7f2b9 100644
--- a/src/controls/PointerLockControls.ts
+++ b/src/controls/PointerLockControls.ts
@@ -33,11 +33,9 @@ class PointerLockControls extends EventDispatcher {
 
   private onMouseMove = (event: MouseEvent): void => {
     if (!this.domElement || this.isLocked === false) return
-    const movementX = event.movementX || (event as any).mozMovementX || (event as any).webkitMovementX || 0
-    const movementY = event.movementY || (event as any).mozMovementY || (event as any).webkitMovementY || 0
     _euler.setFromQuaternion(this.camera.quaternion)
-    _euler.y -= movementX * 0.002 * this.pointerSpeed
-    _euler.x -= movementY * 0.002 * this.pointerSpeed
+    _euler.y -= event.movementX * 0.002 * this.pointerSpeed
+    _euler.x -= event.movementY * 0.002 * this.pointerSpeed
     _euler.x = Math.max(_PI_2 - this.maxPolarAngle, Math.min(_PI_2 - this.minPolarAngle, _euler.x))
     this.camera.quaternion.setFromEuler(_euler)
     // @ts-ignore

From 5d9e6ec1ec760a62cf65d900d79f8e0b12996fd6 Mon Sep 17 00:00:00 2001
From: Rodri <hamuyrodrigo@gmail.com>
Date: Wed, 11 Dec 2024 16:29:42 +0000
Subject: [PATCH 28/36] fix: controls event dispatcher types (#388)

---
 src/controls/ArcballControls.ts             |   5 +-
 src/controls/DeviceOrientationControls.ts   |   6 +-
 src/controls/DragControls.ts                |  32 ++++-
 src/controls/EventDispatcher.ts             | 139 ++++++++++++++++++++
 src/controls/FirstPersonControls.ts         |   6 +-
 src/controls/FlyControls.ts                 |  12 +-
 src/controls/OrbitControls.ts               |   5 +-
 src/controls/PointerLockControls.ts         |  22 +++-
 src/controls/StandardControlsEventMap.ts    |  16 +++
 src/controls/TrackballControls.ts           |   6 +-
 src/controls/experimental/CameraControls.ts |   4 +-
 11 files changed, 235 insertions(+), 18 deletions(-)
 create mode 100644 src/controls/EventDispatcher.ts
 create mode 100644 src/controls/StandardControlsEventMap.ts

diff --git a/src/controls/ArcballControls.ts b/src/controls/ArcballControls.ts
index 8a65882d..9a64a49c 100644
--- a/src/controls/ArcballControls.ts
+++ b/src/controls/ArcballControls.ts
@@ -18,8 +18,9 @@ import {
   OrthographicCamera,
   Mesh,
   Material,
-  EventDispatcher,
 } from 'three'
+import { EventDispatcher } from './EventDispatcher'
+import { StandardControlsEventMap } from './StandardControlsEventMap'
 
 type Camera = OrthographicCamera | PerspectiveCamera
 type Operation = 'PAN' | 'ROTATE' | 'ZOOM' | 'FOV'
@@ -82,7 +83,7 @@ const _endEvent = { type: 'end' }
  * @param {HTMLElement=null} domElement Renderer's dom element
  * @param {Scene=null} scene The scene to be rendered
  */
-class ArcballControls extends EventDispatcher {
+class ArcballControls extends EventDispatcher<StandardControlsEventMap> {
   private camera: OrthographicCamera | PerspectiveCamera | null
   private domElement: HTMLElement | null | undefined
   private scene: Scene | null | undefined
diff --git a/src/controls/DeviceOrientationControls.ts b/src/controls/DeviceOrientationControls.ts
index ab6a821a..b3cfe689 100644
--- a/src/controls/DeviceOrientationControls.ts
+++ b/src/controls/DeviceOrientationControls.ts
@@ -1,10 +1,12 @@
-import { Camera, Euler, EventDispatcher, MathUtils, Quaternion, Vector3 } from 'three'
+import { Camera, Euler, MathUtils, Quaternion, Vector3 } from 'three'
+import { EventDispatcher } from './EventDispatcher'
+import { StandardControlsEventMap } from './StandardControlsEventMap'
 
 /**
  * W3C Device Orientation control (http://w3c.github.io/deviceorientation/spec-source-orientation.html)
  */
 
-class DeviceOrientationControls extends EventDispatcher {
+class DeviceOrientationControls extends EventDispatcher<StandardControlsEventMap> {
   public object: Camera
 
   private changeEvent = { type: 'change' }
diff --git a/src/controls/DragControls.ts b/src/controls/DragControls.ts
index 86877de6..6c6fb52c 100644
--- a/src/controls/DragControls.ts
+++ b/src/controls/DragControls.ts
@@ -1,6 +1,34 @@
-import { Camera, EventDispatcher, Intersection, Matrix4, Object3D, Plane, Raycaster, Vector2, Vector3 } from 'three'
+import { Camera, Intersection, Matrix4, Object3D, Plane, Raycaster, Vector2, Vector3 } from 'three'
+import { EventDispatcher } from './EventDispatcher'
+
+export interface DragControlsEventMap {
+  /**
+   * Fires when the pointer is moved onto a 3D object, or onto one of its children.
+   */
+  hoveron: { object: Object3D };
+
+  /**
+   * Fires when the pointer is moved out of a 3D object.
+   */
+  hoveroff: { object: Object3D };
+
+  /**
+   * Fires when the user starts to drag a 3D object.
+   */
+  dragstart: { object: Object3D };
+
+  /**
+   * Fires when the user drags a 3D object.
+   */
+  drag: { object: Object3D };
+
+  /**
+   * Fires when the user has finished dragging a 3D object.
+   */
+  dragend: { object: Object3D };
+}
 
-class DragControls extends EventDispatcher {
+class DragControls extends EventDispatcher<DragControlsEventMap> {
   public enabled = true
   public transformGroup = false
 
diff --git a/src/controls/EventDispatcher.ts b/src/controls/EventDispatcher.ts
new file mode 100644
index 00000000..370c33b5
--- /dev/null
+++ b/src/controls/EventDispatcher.ts
@@ -0,0 +1,139 @@
+/*
+Due to @types/three r168 breaking change
+we have to manually copy the EventDispatcher class from three.js.
+So this files merges the declarations from https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/three/src/core/EventDispatcher.d.ts
+with the implementation from https://github.com/mrdoob/three.js/blob/dev/src/core/EventDispatcher.js
+More info in https://github.com/pmndrs/three-stdlib/issues/387
+*/
+
+/**
+ * The minimal basic Event that can be dispatched by a {@link EventDispatcher<>}.
+ */
+export interface BaseEvent<TEventType extends string = string> {
+    readonly type: TEventType;
+    // not defined in @types/three
+    target: any;
+}
+
+/**
+ * The minimal expected contract of a fired Event that was dispatched by a {@link EventDispatcher<>}.
+ */
+export interface Event<TEventType extends string = string, TTarget = unknown> {
+    readonly type: TEventType;
+    readonly target: TTarget;
+}
+
+export type EventListener<TEventData, TEventType extends string, TTarget> = (
+    event: TEventData & Event<TEventType, TTarget>,
+) => void;
+
+export class EventDispatcher<TEventMap extends {} = {}> {
+    // not defined in @types/three
+    private _listeners: any;
+
+    /**
+     * Adds a listener to an event type.
+     * @param type The type of event to listen to.
+     * @param listener The function that gets called when the event is fired.
+     */
+	addEventListener<T extends Extract<keyof TEventMap, string>>(
+        type: T,
+        listener: EventListener<TEventMap[T], T, this>,
+    ): void {
+
+		if ( this._listeners === undefined ) this._listeners = {};
+
+		const listeners = this._listeners;
+
+		if ( listeners[ type ] === undefined ) {
+
+			listeners[ type ] = [];
+
+		}
+
+		if ( listeners[ type ].indexOf( listener ) === - 1 ) {
+
+			listeners[ type ].push( listener );
+
+		}
+
+	}
+
+	/**
+     * Checks if listener is added to an event type.
+     * @param type The type of event to listen to.
+     * @param listener The function that gets called when the event is fired.
+     */
+    hasEventListener<T extends Extract<keyof TEventMap, string>>(
+        type: T,
+        listener: EventListener<TEventMap[T], T, this>,
+    ): boolean {
+
+		if ( this._listeners === undefined ) return false;
+
+		const listeners = this._listeners;
+
+		return listeners[ type ] !== undefined && listeners[ type ].indexOf( listener ) !== - 1;
+
+	}
+
+	/**
+     * Removes a listener from an event type.
+     * @param type The type of the listener that gets removed.
+     * @param listener The listener function that gets removed.
+     */
+    removeEventListener<T extends Extract<keyof TEventMap, string>>(
+        type: T,
+        listener: EventListener<TEventMap[T], T, this>,
+    ): void {
+
+		if ( this._listeners === undefined ) return;
+
+		const listeners = this._listeners;
+		const listenerArray = listeners[ type ];
+
+		if ( listenerArray !== undefined ) {
+
+			const index = listenerArray.indexOf( listener );
+
+			if ( index !== - 1 ) {
+
+				listenerArray.splice( index, 1 );
+
+			}
+
+		}
+
+	}
+
+	/**
+     * Fire an event type.
+     * @param event The event that gets fired.
+     */
+    dispatchEvent<T extends Extract<keyof TEventMap, string>>(event: BaseEvent<T> & TEventMap[T]): void {
+
+		if ( this._listeners === undefined ) return;
+
+		const listeners = this._listeners;
+		const listenerArray = listeners[ event.type ];
+
+		if ( listenerArray !== undefined ) {
+
+			event.target = this;
+
+			// Make a copy, in case listeners are removed while iterating.
+			const array = listenerArray.slice( 0 );
+
+			for ( let i = 0, l = array.length; i < l; i ++ ) {
+
+				array[ i ].call( this, event );
+
+			}
+
+			event.target = null;
+
+		}
+
+	}
+
+}
\ No newline at end of file
diff --git a/src/controls/FirstPersonControls.ts b/src/controls/FirstPersonControls.ts
index e6bbd251..b69983f6 100644
--- a/src/controls/FirstPersonControls.ts
+++ b/src/controls/FirstPersonControls.ts
@@ -1,8 +1,10 @@
-import { MathUtils, Spherical, Vector3, EventDispatcher, Camera } from 'three'
+import { MathUtils, Spherical, Vector3, Camera } from 'three'
+import { EventDispatcher } from './EventDispatcher'
+import { StandardControlsEventMap } from './StandardControlsEventMap'
 
 const targetPosition = new Vector3()
 
-export class FirstPersonControls extends EventDispatcher {
+export class FirstPersonControls extends EventDispatcher<{}> {
   public object: Camera
   public domElement?: HTMLElement | null
 
diff --git a/src/controls/FlyControls.ts b/src/controls/FlyControls.ts
index bbd8da7d..4d473bdc 100644
--- a/src/controls/FlyControls.ts
+++ b/src/controls/FlyControls.ts
@@ -1,10 +1,18 @@
-import { Camera, EventDispatcher, Quaternion, Vector3 } from 'three'
+import { Camera, Quaternion, Vector3 } from 'three'
+import { EventDispatcher } from './EventDispatcher'
 
 function contextmenu(event: Event): void {
   event.preventDefault()
 }
 
-class FlyControls extends EventDispatcher {
+export interface FlyControlsEventMap {
+  /**
+   * Fires when the camera has been transformed by the controls.
+   */
+  change: {};
+}
+
+class FlyControls extends EventDispatcher<FlyControlsEventMap> {
   public object: Camera
   public domElement: HTMLElement | Document = null!
 
diff --git a/src/controls/OrbitControls.ts b/src/controls/OrbitControls.ts
index 979d08d8..93d8a764 100644
--- a/src/controls/OrbitControls.ts
+++ b/src/controls/OrbitControls.ts
@@ -1,5 +1,4 @@
 import {
-  EventDispatcher,
   Matrix4,
   MOUSE,
   OrthographicCamera,
@@ -12,6 +11,8 @@ import {
   Ray,
   Plane,
 } from 'three'
+import { EventDispatcher } from './EventDispatcher'
+import { StandardControlsEventMap } from './StandardControlsEventMap'
 
 const _ray = new Ray()
 const _plane = new Plane()
@@ -26,7 +27,7 @@ const TILT_LIMIT = Math.cos(70 * (Math.PI / 180))
 
 const moduloWrapAround = (offset: number, capacity: number) => ((offset % capacity) + capacity) % capacity
 
-class OrbitControls extends EventDispatcher {
+class OrbitControls extends EventDispatcher<StandardControlsEventMap> {
   object: PerspectiveCamera | OrthographicCamera
   domElement: HTMLElement | undefined
   // Set to false to disable this control
diff --git a/src/controls/PointerLockControls.ts b/src/controls/PointerLockControls.ts
index 1aa7f2b9..ee93891e 100644
--- a/src/controls/PointerLockControls.ts
+++ b/src/controls/PointerLockControls.ts
@@ -1,4 +1,5 @@
-import { Euler, Camera, EventDispatcher, Vector3 } from 'three'
+import { Euler, Camera, Vector3 } from 'three'
+import { EventDispatcher } from './EventDispatcher'
 
 const _euler = new Euler(0, 0, 0, 'YXZ')
 const _vector = new Vector3()
@@ -7,7 +8,24 @@ const _lockEvent = { type: 'lock' }
 const _unlockEvent = { type: 'unlock' }
 const _PI_2 = Math.PI / 2
 
-class PointerLockControls extends EventDispatcher {
+export interface PointerLockControlsEventMap {
+  /**
+   * Fires when the user moves the mouse.
+   */
+  change: {};
+
+  /**
+   * Fires when the pointer lock status is "locked" (in other words: the mouse is captured).
+   */
+  lock: {};
+
+  /**
+   * Fires when the pointer lock status is "unlocked" (in other words: the mouse is not captured anymore).
+   */
+  unlock: {};
+}
+
+class PointerLockControls extends EventDispatcher<PointerLockControlsEventMap> {
   public camera: Camera
   public domElement?: HTMLElement
   public isLocked: boolean
diff --git a/src/controls/StandardControlsEventMap.ts b/src/controls/StandardControlsEventMap.ts
new file mode 100644
index 00000000..cd3bd3cc
--- /dev/null
+++ b/src/controls/StandardControlsEventMap.ts
@@ -0,0 +1,16 @@
+export interface StandardControlsEventMap {
+    /**
+     * Fires when the camera has been transformed by the controls.
+     */
+    change: {};
+  
+    /**
+     * Fires when an interaction was initiated.
+     */
+    start: {};
+  
+    /**
+     * Fires when an interaction has finished.
+     */
+    end: {};
+  }
\ No newline at end of file
diff --git a/src/controls/TrackballControls.ts b/src/controls/TrackballControls.ts
index b523b5a5..5991f4f9 100644
--- a/src/controls/TrackballControls.ts
+++ b/src/controls/TrackballControls.ts
@@ -1,6 +1,8 @@
-import { EventDispatcher, MOUSE, Quaternion, Vector2, Vector3, PerspectiveCamera, OrthographicCamera } from 'three'
+import { MOUSE, Quaternion, Vector2, Vector3, PerspectiveCamera, OrthographicCamera } from 'three'
+import { EventDispatcher } from './EventDispatcher'
+import { StandardControlsEventMap } from './StandardControlsEventMap'
 
-class TrackballControls extends EventDispatcher {
+class TrackballControls extends EventDispatcher<StandardControlsEventMap> {
   public enabled = true
 
   public screen = { left: 0, top: 0, width: 0, height: 0 }
diff --git a/src/controls/experimental/CameraControls.ts b/src/controls/experimental/CameraControls.ts
index c894ec6b..dd6e25c3 100644
--- a/src/controls/experimental/CameraControls.ts
+++ b/src/controls/experimental/CameraControls.ts
@@ -1,5 +1,4 @@
 import {
-  EventDispatcher,
   MOUSE,
   Matrix4,
   OrthographicCamera,
@@ -10,6 +9,7 @@ import {
   Vector2,
   Vector3,
 } from 'three'
+import { EventDispatcher } from '../EventDispatcher'
 
 export type CHANGE_EVENT = {
   type: 'change' | 'start' | 'end'
@@ -26,7 +26,7 @@ export const STATE = {
   TOUCH_DOLLY_ROTATE: 6,
 }
 
-class CameraControls extends EventDispatcher {
+class CameraControls extends EventDispatcher<Record<string, {}>> {
   object: PerspectiveCamera | OrthographicCamera
   domElement: HTMLElement
 

From 9bf7ea3377f079498de381c5ee7a8945032fca84 Mon Sep 17 00:00:00 2001
From: Antoine BERNIER <antoine.bernier@gmail.com>
Date: Thu, 12 Dec 2024 09:50:08 +0100
Subject: [PATCH 29/36] feat: `RaycasterHelper` (#389)

---
 src/helpers/RaycasterHelper.ts | 175 +++++++++++++++++++++++++++++++++
 1 file changed, 175 insertions(+)
 create mode 100644 src/helpers/RaycasterHelper.ts

diff --git a/src/helpers/RaycasterHelper.ts b/src/helpers/RaycasterHelper.ts
new file mode 100644
index 00000000..f5f57644
--- /dev/null
+++ b/src/helpers/RaycasterHelper.ts
@@ -0,0 +1,175 @@
+/**
+ * from https://github.com/gsimone/things/tree/main/packages/three-raycaster-helper
+ */
+
+import {
+  BufferAttribute,
+  BufferGeometry,
+  Float32BufferAttribute,
+  InstancedMesh,
+  Intersection,
+  Line,
+  LineBasicMaterial,
+  Mesh,
+  MeshBasicMaterial,
+  Object3D,
+  Raycaster,
+  SphereGeometry,
+  Vector3,
+} from 'three'
+
+const _o = new Object3D()
+const _v = new Vector3()
+
+class RaycasterHelper extends Object3D {
+  raycaster: Raycaster
+  hits: Intersection[]
+
+  origin: Mesh<SphereGeometry, MeshBasicMaterial>
+  near: Line<BufferGeometry, LineBasicMaterial>
+  far: Line<BufferGeometry, LineBasicMaterial>
+
+  nearToFar: Line<BufferGeometry, LineBasicMaterial>
+  originToNear: Line<BufferGeometry, LineBasicMaterial>
+
+  hitPoints: InstancedMesh
+
+  colors = {
+    near: 0xffffff,
+    far: 0xffffff,
+    originToNear: 0x333333,
+    nearToFar: 0xffffff,
+    origin: [0x0eec82, 0xff005b],
+  }
+
+  constructor(raycaster: Raycaster, public numberOfHitsToVisualize = 20) {
+    super()
+    this.raycaster = raycaster
+
+    this.hits = []
+
+    this.origin = new Mesh(new SphereGeometry(0.04, 32), new MeshBasicMaterial())
+    this.origin.name = 'RaycasterHelper_origin'
+    this.origin.raycast = () => null
+
+    const size = 0.1
+    let geometry = new BufferGeometry()
+    // prettier-ignore
+    geometry.setAttribute( 'position', new Float32BufferAttribute( [
+              - size, size, 0,
+              size, size, 0,
+              size, - size, 0,
+              - size, - size, 0,
+              - size, size, 0
+          ], 3 ) );
+
+    this.near = new Line(geometry, new LineBasicMaterial())
+    this.near.name = 'RaycasterHelper_near'
+    this.near.raycast = () => null
+
+    this.far = new Line(geometry, new LineBasicMaterial())
+    this.far.name = 'RaycasterHelper_far'
+    this.far.raycast = () => null
+
+    this.nearToFar = new Line(new BufferGeometry(), new LineBasicMaterial())
+    this.nearToFar.name = 'RaycasterHelper_nearToFar'
+    this.nearToFar.raycast = () => null
+
+    this.nearToFar.geometry.setFromPoints([_v, _v])
+
+    this.originToNear = new Line(this.nearToFar.geometry.clone(), new LineBasicMaterial())
+    this.originToNear.name = 'RaycasterHelper_originToNear'
+    this.originToNear.raycast = () => null
+
+    this.hitPoints = new InstancedMesh(new SphereGeometry(0.04), new MeshBasicMaterial(), this.numberOfHitsToVisualize)
+    this.hitPoints.name = 'RaycasterHelper_hits'
+    this.hitPoints.raycast = () => null
+
+    this.add(this.nearToFar)
+    this.add(this.originToNear)
+
+    this.add(this.near)
+    this.add(this.far)
+
+    this.add(this.origin)
+    this.add(this.hitPoints)
+
+    this.setColors()
+  }
+
+  setColors = (colors?: Partial<typeof this.colors>) => {
+    const _colors = {
+      ...this.colors,
+      ...colors,
+    }
+
+    this.near.material.color.set(_colors.near)
+    this.far.material.color.set(_colors.far)
+    this.nearToFar.material.color.set(_colors.nearToFar)
+    this.originToNear.material.color.set(_colors.originToNear)
+  }
+
+  update = () => {
+    const origin = this.raycaster.ray.origin
+    const direction = this.raycaster.ray.direction
+
+    this.origin.position.copy(origin)
+
+    this.near.position.copy(origin).add(direction.clone().multiplyScalar(this.raycaster.near))
+
+    this.far.position.copy(origin).add(direction.clone().multiplyScalar(this.raycaster.far))
+
+    this.far.lookAt(origin)
+    this.near.lookAt(origin)
+
+    let pos = this.nearToFar.geometry.getAttribute('position') as BufferAttribute
+    pos.set([...this.near.position.toArray(), ...this.far.position.toArray()])
+    pos.needsUpdate = true
+
+    pos = this.originToNear.geometry.getAttribute('position') as BufferAttribute
+    pos.set([...origin.toArray(), ...this.near.position.toArray()])
+    pos.needsUpdate = true
+
+    /**
+     * Update hit points visualization
+     */
+    for (let i = 0; i < this.numberOfHitsToVisualize; i++) {
+      const hit = this.hits?.[i]
+
+      if (hit) {
+        const { point } = hit
+        _o.position.copy(point)
+        _o.scale.setScalar(1)
+      } else {
+        _o.scale.setScalar(0)
+      }
+
+      _o.updateMatrix()
+
+      this.hitPoints.setMatrixAt(i, _o.matrix)
+    }
+
+    this.hitPoints.instanceMatrix.needsUpdate = true
+
+    /**
+     * Update the color of the origin based on wether there are hits.
+     */
+    this.origin.material.color.set(this.hits.length > 0 ? this.colors.origin[0] : this.colors.origin[1])
+  }
+
+  dispose = () => {
+    this.origin.geometry.dispose()
+    this.origin.material.dispose()
+    this.near.geometry.dispose()
+    this.near.material.dispose()
+    this.far.geometry.dispose()
+    this.far.material.dispose()
+    this.nearToFar.geometry.dispose()
+    this.nearToFar.material.dispose()
+    this.originToNear.geometry.dispose()
+    this.originToNear.material.dispose()
+    this.hitPoints.dispose()
+  }
+}
+
+export { RaycasterHelper }

From c840a9b68fd8d1bddf1427db80b33e44a682da68 Mon Sep 17 00:00:00 2001
From: Antoine BERNIER <antoine.bernier@gmail.com>
Date: Thu, 12 Dec 2024 10:04:41 +0100
Subject: [PATCH 30/36] fix: missing RaycasterHelper index export (#390)

---
 src/index.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/index.ts b/src/index.ts
index 7127a0a7..5f81f533 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -246,6 +246,7 @@ export * from './lines/Line2'
 export * from './lines/LineMaterial'
 export * from './lines/LineSegments2'
 export * from './helpers/LightProbeHelper'
+export * from './helpers/RaycasterHelper'
 export * from './helpers/VertexTangentsHelper'
 export * from './helpers/PositionalAudioHelper'
 export * from './helpers/VertexNormalsHelper'

From 1f41939ca4c8405e5294d437fd73afe789f3fb56 Mon Sep 17 00:00:00 2001
From: Antoine BERNIER <antoine.bernier@gmail.com>
Date: Thu, 12 Dec 2024 10:22:33 +0100
Subject: [PATCH 31/36] fix: upgrading semantic-release (#391)

---
 .github/workflows/main.yml | 12 ++----------
 release.config.js          |  8 +-------
 2 files changed, 3 insertions(+), 17 deletions(-)

diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index 3e14379f..0e153f3d 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -52,17 +52,9 @@ jobs:
       - name: Check build health
         run: yarn build
       - name: 🚀 Release
-        uses: cycjimmy/semantic-release-action@v2
+        uses: cycjimmy/semantic-release-action@v4
         with:
-          semantic_version: 17
-          extra_plugins: |
-            @semantic-release/git
-          branches: |
-            [
-              'main',
-              {name: 'beta', prerelease: true},
-              {name: 'alpha', prerelease: true}
-            ]
+          semantic_version: 24
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
diff --git a/release.config.js b/release.config.js
index 38284f07..355e5f96 100644
--- a/release.config.js
+++ b/release.config.js
@@ -1,4 +1,5 @@
 module.exports = {
+  branches: ['main', { name: 'beta', prerelease: true }, { name: 'alpha', prerelease: true }],
   plugins: [
     '@semantic-release/commit-analyzer',
     '@semantic-release/release-notes-generator',
@@ -9,12 +10,5 @@ module.exports = {
       },
     ],
     '@semantic-release/github',
-    [
-      '@semantic-release/git',
-      {
-        assets: ['package.json'],
-        message: 'chore(release): ${nextRelease.version}',
-      },
-    ],
   ],
 }

From f33f12270a209ad5f88820e83ea864e0df86e346 Mon Sep 17 00:00:00 2001
From: Nathan Bierema <nbierema@gmail.com>
Date: Tue, 7 Jan 2025 13:11:25 -0500
Subject: [PATCH 32/36] fix: type compatibility with @types/three@0.172.0
 (#394)

---
 src/postprocessing/Pass.ts     | 4 ++--
 src/utils/ShadowMapViewer.d.ts | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/postprocessing/Pass.ts b/src/postprocessing/Pass.ts
index c69f0c9b..8984538c 100644
--- a/src/postprocessing/Pass.ts
+++ b/src/postprocessing/Pass.ts
@@ -1,4 +1,4 @@
-import { OrthographicCamera, PlaneGeometry, Mesh, Material, Renderer, WebGLRenderer, WebGLRenderTarget } from 'three'
+import { OrthographicCamera, PlaneGeometry, Mesh, Material, WebGLRenderer, WebGLRenderTarget } from 'three'
 
 class Pass {
   // if set to true, the pass is processed by the composer
@@ -50,7 +50,7 @@ class FullScreenQuad<TMaterial extends Material = Material> {
     this.mesh.geometry.dispose()
   }
 
-  public render(renderer: Renderer): void {
+  public render(renderer: WebGLRenderer): void {
     renderer.render(this.mesh, this.camera)
   }
 }
diff --git a/src/utils/ShadowMapViewer.d.ts b/src/utils/ShadowMapViewer.d.ts
index 641c39e3..74b5e627 100644
--- a/src/utils/ShadowMapViewer.d.ts
+++ b/src/utils/ShadowMapViewer.d.ts
@@ -1,4 +1,4 @@
-import { Light, Renderer } from 'three'
+import { Light, WebGLRenderer } from 'three'
 
 export interface Size {
   width: number
@@ -18,7 +18,7 @@ export class ShadowMapViewer {
   enabled: boolean
   size: Size
   position: Position
-  render(renderer: Renderer): void
+  render(renderer: WebGLRenderer): void
   updateForWindowResize(): void
   update(): void
 }

From a9e93f287b2a32d3aaf93f212d44abb572567d4e Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Wed, 8 Jan 2025 13:31:29 -0600
Subject: [PATCH 33/36] fix: tree-shaking (#395)

---
 src/_polyfill/CapsuleGeometry.js           |   36 +-
 src/_polyfill/constants.ts                 |    2 +-
 src/animation/AnimationClipCreator.js      |   26 +-
 src/animation/CCDIKSolver.js               |   22 +-
 src/animation/MMDAnimationHelper.js        |    2 +-
 src/animation/MMDPhysics.js                |    8 +-
 src/controls/ArcballControls.ts            |    4 +-
 src/controls/FirstPersonControls.ts        |    2 +-
 src/controls/OrbitControls.ts              |   17 +-
 src/controls/PointerLockControls.ts        |   10 +-
 src/csm/CSM.js                             |    8 +-
 src/csm/CSMFrustum.js                      |    2 +-
 src/deprecated/Geometry.js                 | 1614 ++++----
 src/effects/AnaglyphEffect.js              |    4 +-
 src/effects/OutlineEffect.js               |    5 +-
 src/effects/ParallaxBarrierEffect.js       |    4 +-
 src/exporters/DRACOExporter.ts             |  302 +-
 src/exporters/GLTFExporter.js              |  392 +-
 src/geometries/LightningStrike.js          | 1314 +++----
 src/geometries/RoundedBoxGeometry.js       |    2 +-
 src/helpers/RaycasterHelper.ts             |    4 +-
 src/helpers/VertexNormalsHelper.js         |    6 +-
 src/helpers/VertexTangentsHelper.js        |    4 +-
 src/interactive/InteractiveGroup.js        |    2 +-
 src/interactive/SelectionBox.js            |   30 +-
 src/libs/chevrotain.js                     |    2 +-
 src/libs/lottie.js                         |    2 +-
 src/libs/opentype.js                       |    2 +-
 src/lights/LightProbeGenerator.js          |   10 +-
 src/lights/RectAreaLightUniformsLib.js     |    6 +-
 src/lines/LineMaterial.js                  |    5 +-
 src/lines/LineSegments2.js                 |   51 +-
 src/lines/LineSegmentsGeometry.js          |    4 +-
 src/lines/Wireframe.js                     |   16 +-
 src/loaders/BasisTextureLoader.js          |  963 ++---
 src/loaders/EXRLoader.js                   |    4 +-
 src/loaders/FBXLoader.js                   |    8 +-
 src/loaders/FontLoader.ts                  |    4 +-
 src/loaders/GLTFLoader.js                  |    4 +-
 src/loaders/KTX2Loader.js                  |  876 ++---
 src/loaders/LDrawLoader.js                 |   10 +-
 src/loaders/OBJLoader.js                   |   10 +-
 src/loaders/PRWMLoader.js                  |  104 +-
 src/loaders/SVGLoader.js                   | 3953 ++++++++++----------
 src/loaders/XLoader.js                     |    2 +-
 src/math/Capsule.js                        |    6 +-
 src/math/ColorConverter.js                 |   18 +-
 src/math/ConvexHull.js                     |  110 +-
 src/math/ImprovedNoise.js                  |    2 +-
 src/math/MeshSurfaceSampler.js             |    4 +-
 src/math/OBB.js                            |   28 +-
 src/math/Octree.js                         |   14 +-
 src/misc/ConvexObjectBreaker.js            |  658 ++--
 src/misc/Gyroscope.js                      |   12 +-
 src/modifiers/CurveModifier.ts             |    2 +-
 src/modifiers/SimplifyModifier.ts          |    4 +-
 src/objects/BatchedMesh.ts                 |    4 +-
 src/objects/GroundProjectedEnv.ts          |   14 +-
 src/objects/Lensflare.js                   |  390 +-
 src/objects/Reflector.js                   |  291 +-
 src/objects/ReflectorForSSRPass.js         |  384 +-
 src/objects/Refractor.js                   |  352 +-
 src/objects/ShadowMesh.js                  |    2 +-
 src/objects/Sky.ts                         |   86 +-
 src/objects/Water.js                       |    4 +-
 src/objects/Water2.js                      |  312 +-
 src/postprocessing/SAOPass.js              |  616 +--
 src/postprocessing/SSAOPass.js             |  572 +--
 src/postprocessing/SSRPass.js              |  932 ++---
 src/postprocessing/UnrealBloomPass.js      |  456 +--
 src/renderers/CSS2DRenderer.js             |   10 +-
 src/renderers/CSS3DRenderer.js             |   10 +-
 src/shaders/ACESFilmicToneMappingShader.ts |   87 +-
 src/shaders/AfterimageShader.ts            |   44 +-
 src/shaders/BasicShader.ts                 |   18 +-
 src/shaders/BleachBypassShader.ts          |   52 +-
 src/shaders/BlendShader.ts                 |   38 +-
 src/shaders/BokehShader.ts                 |  224 +-
 src/shaders/BokehShader2.ts                |  464 +--
 src/shaders/BrightnessContrastShader.ts    |   44 +-
 src/shaders/ColorCorrectionShader.ts       |   42 +-
 src/shaders/ColorifyShader.ts              |   38 +-
 src/shaders/ConvolutionShader.ts           |   48 +-
 src/shaders/CopyShader.ts                  |   32 +-
 src/shaders/DOFMipMapShader.ts             |   42 +-
 src/shaders/DepthLimitedBlurShader.ts      |  148 +-
 src/shaders/DigitalGlitch.ts               |  123 +-
 src/shaders/DotScreenShader.ts             |   56 +-
 src/shaders/FXAAShader.ts                  | 2178 +++++------
 src/shaders/FilmShader.ts                  |   58 +-
 src/shaders/FocusShader.ts                 |   86 +-
 src/shaders/FreiChenShader.ts              |  114 +-
 src/shaders/FresnelShader.ts               |   70 +-
 src/shaders/GammaCorrectionShader.ts       |   38 +-
 src/shaders/GodRaysShader.ts               |  196 +-
 src/shaders/HalftoneShader.ts              |  400 +-
 src/shaders/HorizontalTiltShiftShader.ts   |   54 +-
 src/shaders/HueSaturationShader.ts         |   64 +-
 src/shaders/KaleidoShader.ts               |   48 +-
 src/shaders/LuminosityHighPassShader.ts    |   48 +-
 src/shaders/LuminosityShader.ts            |   34 +-
 src/shaders/MirrorShader.ts                |   52 +-
 src/shaders/NormalMapShader.ts             |   42 +-
 src/shaders/ParallaxShader.ts              |  188 +-
 src/shaders/PixelShader.ts                 |   36 +-
 src/shaders/RGBShiftShader.ts              |   40 +-
 src/shaders/SAOShader.ts                   |  296 +-
 src/shaders/SMAAShader.ts                  |  478 +--
 src/shaders/SSAOShader.ts                  |  266 +-
 src/shaders/SSRShader.ts                   |    8 +-
 src/shaders/SepiaShader.ts                 |   40 +-
 src/shaders/SobelOperatorShader.ts         |   70 +-
 src/shaders/TechnicolorShader.ts           |   32 +-
 src/shaders/ToneMapShader.ts               |   70 +-
 src/shaders/ToonShader.ts                  |  330 +-
 src/shaders/TriangleBlurShader.ts          |   54 +-
 src/shaders/UnpackDepthRGBAShader.ts       |   34 +-
 src/shaders/VerticalTiltShiftShader.ts     |   54 +-
 src/shaders/VignetteShader.ts              |   38 +-
 src/shaders/VolumeShader.ts                |  516 +--
 src/shaders/WaterRefractionShader.ts       |   70 +-
 src/utils/GeometryCompressionUtils.js      |    4 +-
 src/utils/LDrawUtils.js                    |    6 +-
 src/utils/RoughnessMipmapper.js            |    6 +-
 src/webxr/ARButton.ts                      |  249 +-
 src/webxr/OculusHandPointerModel.js        |    4 +-
 src/webxr/VRButton.ts                      |  225 +-
 src/webxr/XRHandPrimitiveModel.js          |    4 +-
 128 files changed, 11692 insertions(+), 11559 deletions(-)

diff --git a/src/_polyfill/CapsuleGeometry.js b/src/_polyfill/CapsuleGeometry.js
index c2e655a5..8a5fc0ff 100644
--- a/src/_polyfill/CapsuleGeometry.js
+++ b/src/_polyfill/CapsuleGeometry.js
@@ -1,26 +1,30 @@
 import { Path, LatheGeometry } from 'three'
 
-class CapsuleGeometry extends LatheGeometry {
-  constructor(radius = 1, length = 1, capSegments = 4, radialSegments = 8) {
-    const path = new Path()
-    path.absarc(0, -length / 2, radius, Math.PI * 1.5, 0)
-    path.absarc(0, length / 2, radius, 0, Math.PI * 0.5)
+const CapsuleGeometry = /* @__PURE__ */ (() => {
+  class CapsuleGeometry extends LatheGeometry {
+    constructor(radius = 1, length = 1, capSegments = 4, radialSegments = 8) {
+      const path = new Path()
+      path.absarc(0, -length / 2, radius, Math.PI * 1.5, 0)
+      path.absarc(0, length / 2, radius, 0, Math.PI * 0.5)
 
-    super(path.getPoints(capSegments), radialSegments)
+      super(path.getPoints(capSegments), radialSegments)
 
-    this.type = 'CapsuleGeometry'
+      this.type = 'CapsuleGeometry'
 
-    this.parameters = {
-      radius: radius,
-      height: length,
-      capSegments: capSegments,
-      radialSegments: radialSegments,
+      this.parameters = {
+        radius: radius,
+        height: length,
+        capSegments: capSegments,
+        radialSegments: radialSegments,
+      }
     }
-  }
 
-  static fromJSON(data) {
-    return new CapsuleGeometry(data.radius, data.length, data.capSegments, data.radialSegments)
+    static fromJSON(data) {
+      return new CapsuleGeometry(data.radius, data.length, data.capSegments, data.radialSegments)
+    }
   }
-}
+
+  return CapsuleGeometry
+})()
 
 export { CapsuleGeometry }
diff --git a/src/_polyfill/constants.ts b/src/_polyfill/constants.ts
index 1237ca1f..aabfc441 100644
--- a/src/_polyfill/constants.ts
+++ b/src/_polyfill/constants.ts
@@ -1,3 +1,3 @@
 import { REVISION } from 'three'
 
-export const version = parseInt(REVISION.replace(/\D+/g, ''))
+export const version = /* @__PURE__ */ (() => parseInt(REVISION.replace(/\D+/g, '')))()
diff --git a/src/animation/AnimationClipCreator.js b/src/animation/AnimationClipCreator.js
index 2befa398..23ea4050 100644
--- a/src/animation/AnimationClipCreator.js
+++ b/src/animation/AnimationClipCreator.js
@@ -7,8 +7,8 @@ import {
   VectorKeyframeTrack,
 } from 'three'
 
-class AnimationClipCreator {
-  static CreateRotationAnimation(period, axis = 'x') {
+const AnimationClipCreator = {
+  CreateRotationAnimation(period, axis = 'x') {
     const times = [0, period],
       values = [0, 360]
 
@@ -17,9 +17,9 @@ class AnimationClipCreator {
     const track = new NumberKeyframeTrack(trackName, times, values)
 
     return new AnimationClip(null, period, [track])
-  }
+  },
 
-  static CreateScaleAxisAnimation(period, axis = 'x') {
+  CreateScaleAxisAnimation(period, axis = 'x') {
     const times = [0, period],
       values = [0, 1]
 
@@ -28,9 +28,9 @@ class AnimationClipCreator {
     const track = new NumberKeyframeTrack(trackName, times, values)
 
     return new AnimationClip(null, period, [track])
-  }
+  },
 
-  static CreateShakeAnimation(duration, shakeScale) {
+  CreateShakeAnimation(duration, shakeScale) {
     const times = [],
       values = [],
       tmp = new Vector3()
@@ -49,9 +49,9 @@ class AnimationClipCreator {
     const track = new VectorKeyframeTrack(trackName, times, values)
 
     return new AnimationClip(null, duration, [track])
-  }
+  },
 
-  static CreatePulsationAnimation(duration, pulseScale) {
+  CreatePulsationAnimation(duration, pulseScale) {
     const times = [],
       values = [],
       tmp = new Vector3()
@@ -68,9 +68,9 @@ class AnimationClipCreator {
     const track = new VectorKeyframeTrack(trackName, times, values)
 
     return new AnimationClip(null, duration, [track])
-  }
+  },
 
-  static CreateVisibilityAnimation(duration) {
+  CreateVisibilityAnimation(duration) {
     const times = [0, duration / 2, duration],
       values = [true, false, true]
 
@@ -79,9 +79,9 @@ class AnimationClipCreator {
     const track = new BooleanKeyframeTrack(trackName, times, values)
 
     return new AnimationClip(null, duration, [track])
-  }
+  },
 
-  static CreateMaterialColorAnimation(duration, colors) {
+  CreateMaterialColorAnimation(duration, colors) {
     const times = [],
       values = [],
       timeStep = duration / colors.length
@@ -98,7 +98,7 @@ class AnimationClipCreator {
     const track = new ColorKeyframeTrack(trackName, times, values)
 
     return new AnimationClip(null, duration, [track])
-  }
+  },
 }
 
 export { AnimationClipCreator }
diff --git a/src/animation/CCDIKSolver.js b/src/animation/CCDIKSolver.js
index 0e5650a0..75fff7e4 100644
--- a/src/animation/CCDIKSolver.js
+++ b/src/animation/CCDIKSolver.js
@@ -13,17 +13,17 @@ import {
   Vector3,
 } from 'three'
 
-const _q = new Quaternion()
-const _targetPos = new Vector3()
-const _targetVec = new Vector3()
-const _effectorPos = new Vector3()
-const _effectorVec = new Vector3()
-const _linkPos = new Vector3()
-const _invLinkQ = new Quaternion()
-const _linkScale = new Vector3()
-const _axis = new Vector3()
-const _vector = new Vector3()
-const _matrix = new Matrix4()
+const _q = /* @__PURE__ */ new Quaternion()
+const _targetPos = /* @__PURE__ */ new Vector3()
+const _targetVec = /* @__PURE__ */ new Vector3()
+const _effectorPos = /* @__PURE__ */ new Vector3()
+const _effectorVec = /* @__PURE__ */ new Vector3()
+const _linkPos = /* @__PURE__ */ new Vector3()
+const _invLinkQ = /* @__PURE__ */ new Quaternion()
+const _linkScale = /* @__PURE__ */ new Vector3()
+const _axis = /* @__PURE__ */ new Vector3()
+const _vector = /* @__PURE__ */ new Vector3()
+const _matrix = /* @__PURE__ */ new Matrix4()
 
 /**
  * CCD Algorithm
diff --git a/src/animation/MMDAnimationHelper.js b/src/animation/MMDAnimationHelper.js
index 8ec13284..396c7424 100644
--- a/src/animation/MMDAnimationHelper.js
+++ b/src/animation/MMDAnimationHelper.js
@@ -861,7 +861,7 @@ class AudioManager {
   }
 }
 
-const _q = new Quaternion()
+const _q = /* @__PURE__ */ new Quaternion()
 
 /**
  * Solver for Grant (Fuyo in Japanese. I just google translated because
diff --git a/src/animation/MMDPhysics.js b/src/animation/MMDPhysics.js
index c11992cc..22ea4ea2 100644
--- a/src/animation/MMDPhysics.js
+++ b/src/animation/MMDPhysics.js
@@ -1001,10 +1001,10 @@ class Constraint {
   }
 }
 
-const _position = new Vector3()
-const _quaternion = new Quaternion()
-const _scale = new Vector3()
-const _matrixWorldInv = new Matrix4()
+const _position = /* @__PURE__ */ new Vector3()
+const _quaternion = /* @__PURE__ */ new Quaternion()
+const _scale = /* @__PURE__ */ new Vector3()
+const _matrixWorldInv = /* @__PURE__ */ new Matrix4()
 
 class MMDPhysicsHelper extends Object3D {
   /**
diff --git a/src/controls/ArcballControls.ts b/src/controls/ArcballControls.ts
index 9a64a49c..c048168f 100644
--- a/src/controls/ArcballControls.ts
+++ b/src/controls/ArcballControls.ts
@@ -68,8 +68,8 @@ const _center = {
 
 //transformation matrices for gizmos and camera
 const _transformation: Transformation = {
-  camera: new Matrix4(),
-  gizmos: new Matrix4(),
+  camera: /* @__PURE__ */ new Matrix4(),
+  gizmos: /* @__PURE__ */ new Matrix4(),
 }
 
 //events
diff --git a/src/controls/FirstPersonControls.ts b/src/controls/FirstPersonControls.ts
index b69983f6..bc40ae9b 100644
--- a/src/controls/FirstPersonControls.ts
+++ b/src/controls/FirstPersonControls.ts
@@ -2,7 +2,7 @@ import { MathUtils, Spherical, Vector3, Camera } from 'three'
 import { EventDispatcher } from './EventDispatcher'
 import { StandardControlsEventMap } from './StandardControlsEventMap'
 
-const targetPosition = new Vector3()
+const targetPosition = /* @__PURE__ */ new Vector3()
 
 export class FirstPersonControls extends EventDispatcher<{}> {
   public object: Camera
diff --git a/src/controls/OrbitControls.ts b/src/controls/OrbitControls.ts
index 93d8a764..cad6a154 100644
--- a/src/controls/OrbitControls.ts
+++ b/src/controls/OrbitControls.ts
@@ -14,8 +14,8 @@ import {
 import { EventDispatcher } from './EventDispatcher'
 import { StandardControlsEventMap } from './StandardControlsEventMap'
 
-const _ray = new Ray()
-const _plane = new Plane()
+const _ray = /* @__PURE__ */ new Ray()
+const _plane = /* @__PURE__ */ new Plane()
 const TILT_LIMIT = Math.cos(70 * (Math.PI / 180))
 
 // This set of controls performs orbiting, dollying (zooming), and panning.
@@ -119,7 +119,6 @@ class OrbitControls extends EventDispatcher<StandardControlsEventMap> {
   getScale: () => number
   // Set the current scale (these are not used in most scenarios, however they can be useful for specific use cases)
   setScale: (newScale: number) => void
-  
 
   constructor(object: PerspectiveCamera | OrthographicCamera, domElement?: HTMLElement) {
     super()
@@ -1096,21 +1095,21 @@ class OrbitControls extends EventDispatcher<StandardControlsEventMap> {
     }
 
     this.dollyOut = (dollyScale = getZoomScale()) => {
-        dollyOut(dollyScale)
-        scope.update()
+      dollyOut(dollyScale)
+      scope.update()
     }
 
     this.getScale = () => {
-        return scale;
+      return scale
     }
 
     this.setScale = (newScale) => {
-        setScale(newScale)
-        scope.update()
+      setScale(newScale)
+      scope.update()
     }
 
     this.getZoomScale = () => {
-        return getZoomScale();
+      return getZoomScale()
     }
 
     // connect events
diff --git a/src/controls/PointerLockControls.ts b/src/controls/PointerLockControls.ts
index ee93891e..19d6fd0f 100644
--- a/src/controls/PointerLockControls.ts
+++ b/src/controls/PointerLockControls.ts
@@ -1,8 +1,8 @@
 import { Euler, Camera, Vector3 } from 'three'
 import { EventDispatcher } from './EventDispatcher'
 
-const _euler = new Euler(0, 0, 0, 'YXZ')
-const _vector = new Vector3()
+const _euler = /* @__PURE__ */ new Euler(0, 0, 0, 'YXZ')
+const _vector = /* @__PURE__ */ new Vector3()
 const _changeEvent = { type: 'change' }
 const _lockEvent = { type: 'lock' }
 const _unlockEvent = { type: 'unlock' }
@@ -12,17 +12,17 @@ export interface PointerLockControlsEventMap {
   /**
    * Fires when the user moves the mouse.
    */
-  change: {};
+  change: {}
 
   /**
    * Fires when the pointer lock status is "locked" (in other words: the mouse is captured).
    */
-  lock: {};
+  lock: {}
 
   /**
    * Fires when the pointer lock status is "unlocked" (in other words: the mouse is not captured anymore).
    */
-  unlock: {};
+  unlock: {}
 }
 
 class PointerLockControls extends EventDispatcher<PointerLockControlsEventMap> {
diff --git a/src/csm/CSM.js b/src/csm/CSM.js
index afa6cdee..ce5359af 100644
--- a/src/csm/CSM.js
+++ b/src/csm/CSM.js
@@ -2,10 +2,10 @@ import { Vector2, Vector3, DirectionalLight, MathUtils, ShaderChunk, Matrix4, Bo
 import { CSMFrustum } from './CSMFrustum'
 import { CSMShader } from './CSMShader'
 
-const _cameraToLightMatrix = new Matrix4()
-const _lightSpaceFrustum = new CSMFrustum()
-const _center = new Vector3()
-const _bbox = new Box3()
+const _cameraToLightMatrix = /* @__PURE__ */ new Matrix4()
+const _lightSpaceFrustum = /* @__PURE__ */ new CSMFrustum()
+const _center = /* @__PURE__ */ new Vector3()
+const _bbox = /* @__PURE__ */ new Box3()
 const _uniformArray = []
 const _logArray = []
 
diff --git a/src/csm/CSMFrustum.js b/src/csm/CSMFrustum.js
index ab8f7d15..3e375417 100644
--- a/src/csm/CSMFrustum.js
+++ b/src/csm/CSMFrustum.js
@@ -1,6 +1,6 @@
 import { Vector3, Matrix4 } from 'three'
 
-const inverseProjectionMatrix = new Matrix4()
+const inverseProjectionMatrix = /* @__PURE__ */ new Matrix4()
 
 class CSMFrustum {
   constructor(data) {
diff --git a/src/deprecated/Geometry.js b/src/deprecated/Geometry.js
index d4d5afc2..c720b2a2 100644
--- a/src/deprecated/Geometry.js
+++ b/src/deprecated/Geometry.js
@@ -14,330 +14,300 @@ import {
   Vector3,
 } from 'three'
 
-const _m1 = new Matrix4()
-const _obj = new Object3D()
-const _offset = new Vector3()
+const _m1 = /* @__PURE__ */ new Matrix4()
+const _obj = /* @__PURE__ */ new Object3D()
+const _offset = /* @__PURE__ */ new Vector3()
 
-class Geometry extends EventDispatcher {
-  static createBufferGeometryFromObject(object) {
-    let buffergeometry = new BufferGeometry()
+const Geometry = /* @__PURE__ */ (() => {
+  class Geometry extends EventDispatcher {
+    static createBufferGeometryFromObject(object) {
+      let buffergeometry = new BufferGeometry()
 
-    const geometry = object.geometry
+      const geometry = object.geometry
 
-    if (object.isPoints || object.isLine) {
-      const positions = new Float32BufferAttribute(geometry.vertices.length * 3, 3)
-      const colors = new Float32BufferAttribute(geometry.colors.length * 3, 3)
+      if (object.isPoints || object.isLine) {
+        const positions = new Float32BufferAttribute(geometry.vertices.length * 3, 3)
+        const colors = new Float32BufferAttribute(geometry.colors.length * 3, 3)
 
-      buffergeometry.setAttribute('position', positions.copyVector3sArray(geometry.vertices))
-      buffergeometry.setAttribute('color', colors.copyColorsArray(geometry.colors))
+        buffergeometry.setAttribute('position', positions.copyVector3sArray(geometry.vertices))
+        buffergeometry.setAttribute('color', colors.copyColorsArray(geometry.colors))
 
-      if (geometry.lineDistances && geometry.lineDistances.length === geometry.vertices.length) {
-        const lineDistances = new Float32BufferAttribute(geometry.lineDistances.length, 1)
+        if (geometry.lineDistances && geometry.lineDistances.length === geometry.vertices.length) {
+          const lineDistances = new Float32BufferAttribute(geometry.lineDistances.length, 1)
 
-        buffergeometry.setAttribute('lineDistance', lineDistances.copyArray(geometry.lineDistances))
-      }
+          buffergeometry.setAttribute('lineDistance', lineDistances.copyArray(geometry.lineDistances))
+        }
 
-      if (geometry.boundingSphere !== null) {
-        buffergeometry.boundingSphere = geometry.boundingSphere.clone()
-      }
+        if (geometry.boundingSphere !== null) {
+          buffergeometry.boundingSphere = geometry.boundingSphere.clone()
+        }
 
-      if (geometry.boundingBox !== null) {
-        buffergeometry.boundingBox = geometry.boundingBox.clone()
+        if (geometry.boundingBox !== null) {
+          buffergeometry.boundingBox = geometry.boundingBox.clone()
+        }
+      } else if (object.isMesh) {
+        buffergeometry = geometry.toBufferGeometry()
       }
-    } else if (object.isMesh) {
-      buffergeometry = geometry.toBufferGeometry()
+
+      return buffergeometry
     }
 
-    return buffergeometry
-  }
+    constructor() {
+      super()
+      this.isGeometry = true
+      this.uuid = MathUtils.generateUUID()
 
-  constructor() {
-    super()
-    this.isGeometry = true
-    this.uuid = MathUtils.generateUUID()
+      this.name = ''
+      this.type = 'Geometry'
 
-    this.name = ''
-    this.type = 'Geometry'
+      this.vertices = []
+      this.colors = []
+      this.faces = []
+      this.faceVertexUvs = [[]]
 
-    this.vertices = []
-    this.colors = []
-    this.faces = []
-    this.faceVertexUvs = [[]]
+      this.morphTargets = []
+      this.morphNormals = []
 
-    this.morphTargets = []
-    this.morphNormals = []
+      this.skinWeights = []
+      this.skinIndices = []
 
-    this.skinWeights = []
-    this.skinIndices = []
+      this.lineDistances = []
 
-    this.lineDistances = []
+      this.boundingBox = null
+      this.boundingSphere = null
 
-    this.boundingBox = null
-    this.boundingSphere = null
+      // update flags
 
-    // update flags
-
-    this.elementsNeedUpdate = false
-    this.verticesNeedUpdate = false
-    this.uvsNeedUpdate = false
-    this.normalsNeedUpdate = false
-    this.colorsNeedUpdate = false
-    this.lineDistancesNeedUpdate = false
-    this.groupsNeedUpdate = false
-  }
-
-  applyMatrix4(matrix) {
-    const normalMatrix = new Matrix3().getNormalMatrix(matrix)
-
-    for (let i = 0, il = this.vertices.length; i < il; i++) {
-      const vertex = this.vertices[i]
-      vertex.applyMatrix4(matrix)
+      this.elementsNeedUpdate = false
+      this.verticesNeedUpdate = false
+      this.uvsNeedUpdate = false
+      this.normalsNeedUpdate = false
+      this.colorsNeedUpdate = false
+      this.lineDistancesNeedUpdate = false
+      this.groupsNeedUpdate = false
     }
 
-    for (let i = 0, il = this.faces.length; i < il; i++) {
-      const face = this.faces[i]
-      face.normal.applyMatrix3(normalMatrix).normalize()
+    applyMatrix4(matrix) {
+      const normalMatrix = new Matrix3().getNormalMatrix(matrix)
 
-      for (let j = 0, jl = face.vertexNormals.length; j < jl; j++) {
-        face.vertexNormals[j].applyMatrix3(normalMatrix).normalize()
+      for (let i = 0, il = this.vertices.length; i < il; i++) {
+        const vertex = this.vertices[i]
+        vertex.applyMatrix4(matrix)
       }
-    }
 
-    if (this.boundingBox !== null) {
-      this.computeBoundingBox()
-    }
-
-    if (this.boundingSphere !== null) {
-      this.computeBoundingSphere()
-    }
+      for (let i = 0, il = this.faces.length; i < il; i++) {
+        const face = this.faces[i]
+        face.normal.applyMatrix3(normalMatrix).normalize()
 
-    this.verticesNeedUpdate = true
-    this.normalsNeedUpdate = true
+        for (let j = 0, jl = face.vertexNormals.length; j < jl; j++) {
+          face.vertexNormals[j].applyMatrix3(normalMatrix).normalize()
+        }
+      }
 
-    return this
-  }
+      if (this.boundingBox !== null) {
+        this.computeBoundingBox()
+      }
 
-  rotateX(angle) {
-    // rotate geometry around world x-axis
+      if (this.boundingSphere !== null) {
+        this.computeBoundingSphere()
+      }
 
-    _m1.makeRotationX(angle)
+      this.verticesNeedUpdate = true
+      this.normalsNeedUpdate = true
 
-    this.applyMatrix4(_m1)
+      return this
+    }
 
-    return this
-  }
+    rotateX(angle) {
+      // rotate geometry around world x-axis
 
-  rotateY(angle) {
-    // rotate geometry around world y-axis
+      _m1.makeRotationX(angle)
 
-    _m1.makeRotationY(angle)
+      this.applyMatrix4(_m1)
 
-    this.applyMatrix4(_m1)
+      return this
+    }
 
-    return this
-  }
+    rotateY(angle) {
+      // rotate geometry around world y-axis
 
-  rotateZ(angle) {
-    // rotate geometry around world z-axis
+      _m1.makeRotationY(angle)
 
-    _m1.makeRotationZ(angle)
+      this.applyMatrix4(_m1)
 
-    this.applyMatrix4(_m1)
+      return this
+    }
 
-    return this
-  }
+    rotateZ(angle) {
+      // rotate geometry around world z-axis
 
-  translate(x, y, z) {
-    // translate geometry
+      _m1.makeRotationZ(angle)
 
-    _m1.makeTranslation(x, y, z)
+      this.applyMatrix4(_m1)
 
-    this.applyMatrix4(_m1)
+      return this
+    }
 
-    return this
-  }
+    translate(x, y, z) {
+      // translate geometry
 
-  scale(x, y, z) {
-    // scale geometry
+      _m1.makeTranslation(x, y, z)
 
-    _m1.makeScale(x, y, z)
+      this.applyMatrix4(_m1)
 
-    this.applyMatrix4(_m1)
+      return this
+    }
 
-    return this
-  }
+    scale(x, y, z) {
+      // scale geometry
 
-  lookAt(vector) {
-    _obj.lookAt(vector)
+      _m1.makeScale(x, y, z)
 
-    _obj.updateMatrix()
+      this.applyMatrix4(_m1)
 
-    this.applyMatrix4(_obj.matrix)
+      return this
+    }
 
-    return this
-  }
+    lookAt(vector) {
+      _obj.lookAt(vector)
 
-  fromBufferGeometry(geometry) {
-    const scope = this
+      _obj.updateMatrix()
 
-    const index = geometry.index !== null ? geometry.index : undefined
-    const attributes = geometry.attributes
+      this.applyMatrix4(_obj.matrix)
 
-    if (attributes.position === undefined) {
-      console.error('THREE.Geometry.fromBufferGeometry(): Position attribute required for conversion.')
       return this
     }
 
-    const position = attributes.position
-    const normal = attributes.normal
-    const color = attributes.color
-    const uv = attributes.uv
-    const uv2 = attributes.uv2
-
-    if (uv2 !== undefined) this.faceVertexUvs[1] = []
+    fromBufferGeometry(geometry) {
+      const scope = this
 
-    for (let i = 0; i < position.count; i++) {
-      scope.vertices.push(new Vector3().fromBufferAttribute(position, i))
+      const index = geometry.index !== null ? geometry.index : undefined
+      const attributes = geometry.attributes
 
-      if (color !== undefined) {
-        scope.colors.push(new Color().fromBufferAttribute(color, i))
+      if (attributes.position === undefined) {
+        console.error('THREE.Geometry.fromBufferGeometry(): Position attribute required for conversion.')
+        return this
       }
-    }
-
-    function addFace(a, b, c, materialIndex) {
-      const vertexColors =
-        color === undefined ? [] : [scope.colors[a].clone(), scope.colors[b].clone(), scope.colors[c].clone()]
 
-      const vertexNormals =
-        normal === undefined
-          ? []
-          : [
-              new Vector3().fromBufferAttribute(normal, a),
-              new Vector3().fromBufferAttribute(normal, b),
-              new Vector3().fromBufferAttribute(normal, c),
-            ]
+      const position = attributes.position
+      const normal = attributes.normal
+      const color = attributes.color
+      const uv = attributes.uv
+      const uv2 = attributes.uv2
 
-      const face = new Face3(a, b, c, vertexNormals, vertexColors, materialIndex)
+      if (uv2 !== undefined) this.faceVertexUvs[1] = []
 
-      scope.faces.push(face)
+      for (let i = 0; i < position.count; i++) {
+        scope.vertices.push(new Vector3().fromBufferAttribute(position, i))
 
-      if (uv !== undefined) {
-        scope.faceVertexUvs[0].push([
-          new Vector2().fromBufferAttribute(uv, a),
-          new Vector2().fromBufferAttribute(uv, b),
-          new Vector2().fromBufferAttribute(uv, c),
-        ])
+        if (color !== undefined) {
+          scope.colors.push(new Color().fromBufferAttribute(color, i))
+        }
       }
 
-      if (uv2 !== undefined) {
-        scope.faceVertexUvs[1].push([
-          new Vector2().fromBufferAttribute(uv2, a),
-          new Vector2().fromBufferAttribute(uv2, b),
-          new Vector2().fromBufferAttribute(uv2, c),
-        ])
+      function addFace(a, b, c, materialIndex) {
+        const vertexColors =
+          color === undefined ? [] : [scope.colors[a].clone(), scope.colors[b].clone(), scope.colors[c].clone()]
+
+        const vertexNormals =
+          normal === undefined
+            ? []
+            : [
+                new Vector3().fromBufferAttribute(normal, a),
+                new Vector3().fromBufferAttribute(normal, b),
+                new Vector3().fromBufferAttribute(normal, c),
+              ]
+
+        const face = new Face3(a, b, c, vertexNormals, vertexColors, materialIndex)
+
+        scope.faces.push(face)
+
+        if (uv !== undefined) {
+          scope.faceVertexUvs[0].push([
+            new Vector2().fromBufferAttribute(uv, a),
+            new Vector2().fromBufferAttribute(uv, b),
+            new Vector2().fromBufferAttribute(uv, c),
+          ])
+        }
+
+        if (uv2 !== undefined) {
+          scope.faceVertexUvs[1].push([
+            new Vector2().fromBufferAttribute(uv2, a),
+            new Vector2().fromBufferAttribute(uv2, b),
+            new Vector2().fromBufferAttribute(uv2, c),
+          ])
+        }
       }
-    }
 
-    const groups = geometry.groups
+      const groups = geometry.groups
 
-    if (groups.length > 0) {
-      for (let i = 0; i < groups.length; i++) {
-        const group = groups[i]
+      if (groups.length > 0) {
+        for (let i = 0; i < groups.length; i++) {
+          const group = groups[i]
 
-        const start = group.start
-        const count = group.count
+          const start = group.start
+          const count = group.count
 
-        for (let j = start, jl = start + count; j < jl; j += 3) {
-          if (index !== undefined) {
-            addFace(index.getX(j), index.getX(j + 1), index.getX(j + 2), group.materialIndex)
-          } else {
-            addFace(j, j + 1, j + 2, group.materialIndex)
+          for (let j = start, jl = start + count; j < jl; j += 3) {
+            if (index !== undefined) {
+              addFace(index.getX(j), index.getX(j + 1), index.getX(j + 2), group.materialIndex)
+            } else {
+              addFace(j, j + 1, j + 2, group.materialIndex)
+            }
           }
         }
-      }
-    } else {
-      if (index !== undefined) {
-        for (let i = 0; i < index.count; i += 3) {
-          addFace(index.getX(i), index.getX(i + 1), index.getX(i + 2))
-        }
       } else {
-        for (let i = 0; i < position.count; i += 3) {
-          addFace(i, i + 1, i + 2)
+        if (index !== undefined) {
+          for (let i = 0; i < index.count; i += 3) {
+            addFace(index.getX(i), index.getX(i + 1), index.getX(i + 2))
+          }
+        } else {
+          for (let i = 0; i < position.count; i += 3) {
+            addFace(i, i + 1, i + 2)
+          }
         }
       }
-    }
-
-    this.computeFaceNormals()
-
-    if (geometry.boundingBox !== null) {
-      this.boundingBox = geometry.boundingBox.clone()
-    }
 
-    if (geometry.boundingSphere !== null) {
-      this.boundingSphere = geometry.boundingSphere.clone()
-    }
-
-    return this
-  }
-
-  center() {
-    this.computeBoundingBox()
-
-    this.boundingBox.getCenter(_offset).negate()
-
-    this.translate(_offset.x, _offset.y, _offset.z)
-
-    return this
-  }
-
-  normalize() {
-    this.computeBoundingSphere()
+      this.computeFaceNormals()
 
-    const center = this.boundingSphere.center
-    const radius = this.boundingSphere.radius
+      if (geometry.boundingBox !== null) {
+        this.boundingBox = geometry.boundingBox.clone()
+      }
 
-    const s = radius === 0 ? 1 : 1.0 / radius
+      if (geometry.boundingSphere !== null) {
+        this.boundingSphere = geometry.boundingSphere.clone()
+      }
 
-    const matrix = new Matrix4()
-    matrix.set(s, 0, 0, -s * center.x, 0, s, 0, -s * center.y, 0, 0, s, -s * center.z, 0, 0, 0, 1)
+      return this
+    }
 
-    this.applyMatrix4(matrix)
+    center() {
+      this.computeBoundingBox()
 
-    return this
-  }
+      this.boundingBox.getCenter(_offset).negate()
 
-  computeFaceNormals() {
-    const cb = new Vector3(),
-      ab = new Vector3()
+      this.translate(_offset.x, _offset.y, _offset.z)
 
-    for (let f = 0, fl = this.faces.length; f < fl; f++) {
-      const face = this.faces[f]
+      return this
+    }
 
-      const vA = this.vertices[face.a]
-      const vB = this.vertices[face.b]
-      const vC = this.vertices[face.c]
+    normalize() {
+      this.computeBoundingSphere()
 
-      cb.subVectors(vC, vB)
-      ab.subVectors(vA, vB)
-      cb.cross(ab)
+      const center = this.boundingSphere.center
+      const radius = this.boundingSphere.radius
 
-      cb.normalize()
+      const s = radius === 0 ? 1 : 1.0 / radius
 
-      face.normal.copy(cb)
-    }
-  }
+      const matrix = new Matrix4()
+      matrix.set(s, 0, 0, -s * center.x, 0, s, 0, -s * center.y, 0, 0, s, -s * center.z, 0, 0, 0, 1)
 
-  computeVertexNormals(areaWeighted = true) {
-    const vertices = new Array(this.vertices.length)
+      this.applyMatrix4(matrix)
 
-    for (let v = 0, vl = this.vertices.length; v < vl; v++) {
-      vertices[v] = new Vector3()
+      return this
     }
 
-    if (areaWeighted) {
-      // vertex normals weighted by triangle areas
-      // http://www.iquilezles.org/www/articles/normals/normals.htm
-
+    computeFaceNormals() {
       const cb = new Vector3(),
         ab = new Vector3()
 
@@ -352,549 +322,584 @@ class Geometry extends EventDispatcher {
         ab.subVectors(vA, vB)
         cb.cross(ab)
 
-        vertices[face.a].add(cb)
-        vertices[face.b].add(cb)
-        vertices[face.c].add(cb)
+        cb.normalize()
+
+        face.normal.copy(cb)
       }
-    } else {
-      this.computeFaceNormals()
+    }
 
-      for (let f = 0, fl = this.faces.length; f < fl; f++) {
-        const face = this.faces[f]
+    computeVertexNormals(areaWeighted = true) {
+      const vertices = new Array(this.vertices.length)
 
-        vertices[face.a].add(face.normal)
-        vertices[face.b].add(face.normal)
-        vertices[face.c].add(face.normal)
+      for (let v = 0, vl = this.vertices.length; v < vl; v++) {
+        vertices[v] = new Vector3()
       }
-    }
 
-    for (let v = 0, vl = this.vertices.length; v < vl; v++) {
-      vertices[v].normalize()
-    }
+      if (areaWeighted) {
+        // vertex normals weighted by triangle areas
+        // http://www.iquilezles.org/www/articles/normals/normals.htm
 
-    for (let f = 0, fl = this.faces.length; f < fl; f++) {
-      const face = this.faces[f]
+        const cb = new Vector3(),
+          ab = new Vector3()
 
-      const vertexNormals = face.vertexNormals
+        for (let f = 0, fl = this.faces.length; f < fl; f++) {
+          const face = this.faces[f]
 
-      if (vertexNormals.length === 3) {
-        vertexNormals[0].copy(vertices[face.a])
-        vertexNormals[1].copy(vertices[face.b])
-        vertexNormals[2].copy(vertices[face.c])
-      } else {
-        vertexNormals[0] = vertices[face.a].clone()
-        vertexNormals[1] = vertices[face.b].clone()
-        vertexNormals[2] = vertices[face.c].clone()
-      }
-    }
+          const vA = this.vertices[face.a]
+          const vB = this.vertices[face.b]
+          const vC = this.vertices[face.c]
 
-    if (this.faces.length > 0) {
-      this.normalsNeedUpdate = true
-    }
-  }
+          cb.subVectors(vC, vB)
+          ab.subVectors(vA, vB)
+          cb.cross(ab)
 
-  computeFlatVertexNormals() {
-    this.computeFaceNormals()
+          vertices[face.a].add(cb)
+          vertices[face.b].add(cb)
+          vertices[face.c].add(cb)
+        }
+      } else {
+        this.computeFaceNormals()
 
-    for (let f = 0, fl = this.faces.length; f < fl; f++) {
-      const face = this.faces[f]
+        for (let f = 0, fl = this.faces.length; f < fl; f++) {
+          const face = this.faces[f]
 
-      const vertexNormals = face.vertexNormals
+          vertices[face.a].add(face.normal)
+          vertices[face.b].add(face.normal)
+          vertices[face.c].add(face.normal)
+        }
+      }
 
-      if (vertexNormals.length === 3) {
-        vertexNormals[0].copy(face.normal)
-        vertexNormals[1].copy(face.normal)
-        vertexNormals[2].copy(face.normal)
-      } else {
-        vertexNormals[0] = face.normal.clone()
-        vertexNormals[1] = face.normal.clone()
-        vertexNormals[2] = face.normal.clone()
+      for (let v = 0, vl = this.vertices.length; v < vl; v++) {
+        vertices[v].normalize()
       }
-    }
 
-    if (this.faces.length > 0) {
-      this.normalsNeedUpdate = true
-    }
-  }
+      for (let f = 0, fl = this.faces.length; f < fl; f++) {
+        const face = this.faces[f]
 
-  computeMorphNormals() {
-    // save original normals
-    // - create temp variables on first access
-    //   otherwise just copy (for faster repeated calls)
+        const vertexNormals = face.vertexNormals
 
-    for (let f = 0, fl = this.faces.length; f < fl; f++) {
-      const face = this.faces[f]
+        if (vertexNormals.length === 3) {
+          vertexNormals[0].copy(vertices[face.a])
+          vertexNormals[1].copy(vertices[face.b])
+          vertexNormals[2].copy(vertices[face.c])
+        } else {
+          vertexNormals[0] = vertices[face.a].clone()
+          vertexNormals[1] = vertices[face.b].clone()
+          vertexNormals[2] = vertices[face.c].clone()
+        }
+      }
 
-      if (!face.__originalFaceNormal) {
-        face.__originalFaceNormal = face.normal.clone()
-      } else {
-        face.__originalFaceNormal.copy(face.normal)
+      if (this.faces.length > 0) {
+        this.normalsNeedUpdate = true
       }
+    }
 
-      if (!face.__originalVertexNormals) face.__originalVertexNormals = []
+    computeFlatVertexNormals() {
+      this.computeFaceNormals()
+
+      for (let f = 0, fl = this.faces.length; f < fl; f++) {
+        const face = this.faces[f]
+
+        const vertexNormals = face.vertexNormals
 
-      for (let i = 0, il = face.vertexNormals.length; i < il; i++) {
-        if (!face.__originalVertexNormals[i]) {
-          face.__originalVertexNormals[i] = face.vertexNormals[i].clone()
+        if (vertexNormals.length === 3) {
+          vertexNormals[0].copy(face.normal)
+          vertexNormals[1].copy(face.normal)
+          vertexNormals[2].copy(face.normal)
         } else {
-          face.__originalVertexNormals[i].copy(face.vertexNormals[i])
+          vertexNormals[0] = face.normal.clone()
+          vertexNormals[1] = face.normal.clone()
+          vertexNormals[2] = face.normal.clone()
         }
       }
-    }
 
-    // use temp geometry to compute face and vertex normals for each morph
+      if (this.faces.length > 0) {
+        this.normalsNeedUpdate = true
+      }
+    }
 
-    const tmpGeo = new Geometry()
-    tmpGeo.faces = this.faces
+    computeMorphNormals() {
+      // save original normals
+      // - create temp variables on first access
+      //   otherwise just copy (for faster repeated calls)
 
-    for (let i = 0, il = this.morphTargets.length; i < il; i++) {
-      // create on first access
+      for (let f = 0, fl = this.faces.length; f < fl; f++) {
+        const face = this.faces[f]
 
-      if (!this.morphNormals[i]) {
-        this.morphNormals[i] = {}
-        this.morphNormals[i].faceNormals = []
-        this.morphNormals[i].vertexNormals = []
+        if (!face.__originalFaceNormal) {
+          face.__originalFaceNormal = face.normal.clone()
+        } else {
+          face.__originalFaceNormal.copy(face.normal)
+        }
 
-        const dstNormalsFace = this.morphNormals[i].faceNormals
-        const dstNormalsVertex = this.morphNormals[i].vertexNormals
+        if (!face.__originalVertexNormals) face.__originalVertexNormals = []
 
-        for (let f = 0, fl = this.faces.length; f < fl; f++) {
-          const faceNormal = new Vector3()
-          const vertexNormals = {
-            a: new Vector3(),
-            b: new Vector3(),
-            c: new Vector3(),
+        for (let i = 0, il = face.vertexNormals.length; i < il; i++) {
+          if (!face.__originalVertexNormals[i]) {
+            face.__originalVertexNormals[i] = face.vertexNormals[i].clone()
+          } else {
+            face.__originalVertexNormals[i].copy(face.vertexNormals[i])
           }
-
-          dstNormalsFace.push(faceNormal)
-          dstNormalsVertex.push(vertexNormals)
         }
       }
 
-      const morphNormals = this.morphNormals[i]
-
-      // set vertices to morph target
+      // use temp geometry to compute face and vertex normals for each morph
 
-      tmpGeo.vertices = this.morphTargets[i].vertices
+      const tmpGeo = new Geometry()
+      tmpGeo.faces = this.faces
 
-      // compute morph normals
+      for (let i = 0, il = this.morphTargets.length; i < il; i++) {
+        // create on first access
 
-      tmpGeo.computeFaceNormals()
-      tmpGeo.computeVertexNormals()
+        if (!this.morphNormals[i]) {
+          this.morphNormals[i] = {}
+          this.morphNormals[i].faceNormals = []
+          this.morphNormals[i].vertexNormals = []
 
-      // store morph normals
+          const dstNormalsFace = this.morphNormals[i].faceNormals
+          const dstNormalsVertex = this.morphNormals[i].vertexNormals
 
-      for (let f = 0, fl = this.faces.length; f < fl; f++) {
-        const face = this.faces[f]
+          for (let f = 0, fl = this.faces.length; f < fl; f++) {
+            const faceNormal = new Vector3()
+            const vertexNormals = {
+              a: new Vector3(),
+              b: new Vector3(),
+              c: new Vector3(),
+            }
 
-        const faceNormal = morphNormals.faceNormals[f]
-        const vertexNormals = morphNormals.vertexNormals[f]
+            dstNormalsFace.push(faceNormal)
+            dstNormalsVertex.push(vertexNormals)
+          }
+        }
 
-        faceNormal.copy(face.normal)
+        const morphNormals = this.morphNormals[i]
 
-        vertexNormals.a.copy(face.vertexNormals[0])
-        vertexNormals.b.copy(face.vertexNormals[1])
-        vertexNormals.c.copy(face.vertexNormals[2])
-      }
-    }
+        // set vertices to morph target
 
-    // restore original normals
+        tmpGeo.vertices = this.morphTargets[i].vertices
 
-    for (let f = 0, fl = this.faces.length; f < fl; f++) {
-      const face = this.faces[f]
+        // compute morph normals
 
-      face.normal = face.__originalFaceNormal
-      face.vertexNormals = face.__originalVertexNormals
-    }
-  }
+        tmpGeo.computeFaceNormals()
+        tmpGeo.computeVertexNormals()
 
-  computeBoundingBox() {
-    if (this.boundingBox === null) {
-      this.boundingBox = new Box3()
-    }
-
-    this.boundingBox.setFromPoints(this.vertices)
-  }
+        // store morph normals
 
-  computeBoundingSphere() {
-    if (this.boundingSphere === null) {
-      this.boundingSphere = new Sphere()
-    }
+        for (let f = 0, fl = this.faces.length; f < fl; f++) {
+          const face = this.faces[f]
 
-    this.boundingSphere.setFromPoints(this.vertices)
-  }
+          const faceNormal = morphNormals.faceNormals[f]
+          const vertexNormals = morphNormals.vertexNormals[f]
 
-  merge(geometry, matrix, materialIndexOffset = 0) {
-    if (!(geometry && geometry.isGeometry)) {
-      console.error('THREE.Geometry.merge(): geometry not an instance of THREE.Geometry.', geometry)
-      return
-    }
+          faceNormal.copy(face.normal)
 
-    let normalMatrix
-    const vertexOffset = this.vertices.length,
-      vertices1 = this.vertices,
-      vertices2 = geometry.vertices,
-      faces1 = this.faces,
-      faces2 = geometry.faces,
-      colors1 = this.colors,
-      colors2 = geometry.colors
-
-    if (matrix !== undefined) {
-      normalMatrix = new Matrix3().getNormalMatrix(matrix)
-    }
+          vertexNormals.a.copy(face.vertexNormals[0])
+          vertexNormals.b.copy(face.vertexNormals[1])
+          vertexNormals.c.copy(face.vertexNormals[2])
+        }
+      }
 
-    // vertices
+      // restore original normals
 
-    for (let i = 0, il = vertices2.length; i < il; i++) {
-      const vertex = vertices2[i]
+      for (let f = 0, fl = this.faces.length; f < fl; f++) {
+        const face = this.faces[f]
 
-      const vertexCopy = vertex.clone()
+        face.normal = face.__originalFaceNormal
+        face.vertexNormals = face.__originalVertexNormals
+      }
+    }
 
-      if (matrix !== undefined) vertexCopy.applyMatrix4(matrix)
+    computeBoundingBox() {
+      if (this.boundingBox === null) {
+        this.boundingBox = new Box3()
+      }
 
-      vertices1.push(vertexCopy)
+      this.boundingBox.setFromPoints(this.vertices)
     }
 
-    // colors
+    computeBoundingSphere() {
+      if (this.boundingSphere === null) {
+        this.boundingSphere = new Sphere()
+      }
 
-    for (let i = 0, il = colors2.length; i < il; i++) {
-      colors1.push(colors2[i].clone())
+      this.boundingSphere.setFromPoints(this.vertices)
     }
 
-    // faces
+    merge(geometry, matrix, materialIndexOffset = 0) {
+      if (!(geometry && geometry.isGeometry)) {
+        console.error('THREE.Geometry.merge(): geometry not an instance of THREE.Geometry.', geometry)
+        return
+      }
 
-    for (let i = 0, il = faces2.length; i < il; i++) {
-      const face = faces2[i]
-      let normal, color
-      const faceVertexNormals = face.vertexNormals,
-        faceVertexColors = face.vertexColors
+      let normalMatrix
+      const vertexOffset = this.vertices.length,
+        vertices1 = this.vertices,
+        vertices2 = geometry.vertices,
+        faces1 = this.faces,
+        faces2 = geometry.faces,
+        colors1 = this.colors,
+        colors2 = geometry.colors
+
+      if (matrix !== undefined) {
+        normalMatrix = new Matrix3().getNormalMatrix(matrix)
+      }
 
-      const faceCopy = new Face3(face.a + vertexOffset, face.b + vertexOffset, face.c + vertexOffset)
-      faceCopy.normal.copy(face.normal)
+      // vertices
 
-      if (normalMatrix !== undefined) {
-        faceCopy.normal.applyMatrix3(normalMatrix).normalize()
-      }
+      for (let i = 0, il = vertices2.length; i < il; i++) {
+        const vertex = vertices2[i]
 
-      for (let j = 0, jl = faceVertexNormals.length; j < jl; j++) {
-        normal = faceVertexNormals[j].clone()
+        const vertexCopy = vertex.clone()
 
-        if (normalMatrix !== undefined) {
-          normal.applyMatrix3(normalMatrix).normalize()
-        }
+        if (matrix !== undefined) vertexCopy.applyMatrix4(matrix)
 
-        faceCopy.vertexNormals.push(normal)
+        vertices1.push(vertexCopy)
       }
 
-      faceCopy.color.copy(face.color)
+      // colors
 
-      for (let j = 0, jl = faceVertexColors.length; j < jl; j++) {
-        color = faceVertexColors[j]
-        faceCopy.vertexColors.push(color.clone())
+      for (let i = 0, il = colors2.length; i < il; i++) {
+        colors1.push(colors2[i].clone())
       }
 
-      faceCopy.materialIndex = face.materialIndex + materialIndexOffset
+      // faces
 
-      faces1.push(faceCopy)
-    }
+      for (let i = 0, il = faces2.length; i < il; i++) {
+        const face = faces2[i]
+        let normal, color
+        const faceVertexNormals = face.vertexNormals,
+          faceVertexColors = face.vertexColors
 
-    // uvs
+        const faceCopy = new Face3(face.a + vertexOffset, face.b + vertexOffset, face.c + vertexOffset)
+        faceCopy.normal.copy(face.normal)
 
-    for (let i = 0, il = geometry.faceVertexUvs.length; i < il; i++) {
-      const faceVertexUvs2 = geometry.faceVertexUvs[i]
+        if (normalMatrix !== undefined) {
+          faceCopy.normal.applyMatrix3(normalMatrix).normalize()
+        }
 
-      if (this.faceVertexUvs[i] === undefined) this.faceVertexUvs[i] = []
+        for (let j = 0, jl = faceVertexNormals.length; j < jl; j++) {
+          normal = faceVertexNormals[j].clone()
 
-      for (let j = 0, jl = faceVertexUvs2.length; j < jl; j++) {
-        const uvs2 = faceVertexUvs2[j],
-          uvsCopy = []
+          if (normalMatrix !== undefined) {
+            normal.applyMatrix3(normalMatrix).normalize()
+          }
 
-        for (let k = 0, kl = uvs2.length; k < kl; k++) {
-          uvsCopy.push(uvs2[k].clone())
+          faceCopy.vertexNormals.push(normal)
         }
 
-        this.faceVertexUvs[i].push(uvsCopy)
-      }
-    }
-  }
+        faceCopy.color.copy(face.color)
 
-  mergeMesh(mesh) {
-    if (!(mesh && mesh.isMesh)) {
-      console.error('THREE.Geometry.mergeMesh(): mesh not an instance of THREE.Mesh.', mesh)
-      return
-    }
+        for (let j = 0, jl = faceVertexColors.length; j < jl; j++) {
+          color = faceVertexColors[j]
+          faceCopy.vertexColors.push(color.clone())
+        }
 
-    if (mesh.matrixAutoUpdate) mesh.updateMatrix()
+        faceCopy.materialIndex = face.materialIndex + materialIndexOffset
 
-    this.merge(mesh.geometry, mesh.matrix)
-  }
+        faces1.push(faceCopy)
+      }
 
-  /*
-   * Checks for duplicate vertices with hashmap.
-   * Duplicated vertices are removed
-   * and faces' vertices are updated.
-   */
+      // uvs
 
-  mergeVertices(precisionPoints = 4) {
-    const verticesMap = {} // Hashmap for looking up vertices by position coordinates (and making sure they are unique)
-    const unique = [],
-      changes = []
+      for (let i = 0, il = geometry.faceVertexUvs.length; i < il; i++) {
+        const faceVertexUvs2 = geometry.faceVertexUvs[i]
 
-    const precision = Math.pow(10, precisionPoints)
+        if (this.faceVertexUvs[i] === undefined) this.faceVertexUvs[i] = []
 
-    for (let i = 0, il = this.vertices.length; i < il; i++) {
-      const v = this.vertices[i]
-      const key = `${Math.round(v.x * precision)}_${Math.round(v.y * precision)}_${Math.round(v.z * precision)}`
+        for (let j = 0, jl = faceVertexUvs2.length; j < jl; j++) {
+          const uvs2 = faceVertexUvs2[j],
+            uvsCopy = []
 
-      if (verticesMap[key] === undefined) {
-        verticesMap[key] = i
-        unique.push(this.vertices[i])
-        changes[i] = unique.length - 1
-      } else {
-        //console.log('Duplicate vertex found. ', i, ' could be using ', verticesMap[key]);
-        changes[i] = changes[verticesMap[key]]
+          for (let k = 0, kl = uvs2.length; k < kl; k++) {
+            uvsCopy.push(uvs2[k].clone())
+          }
+
+          this.faceVertexUvs[i].push(uvsCopy)
+        }
       }
     }
 
-    // if faces are completely degenerate after merging vertices, we
-    // have to remove them from the geometry.
-    const faceIndicesToRemove = []
-
-    for (let i = 0, il = this.faces.length; i < il; i++) {
-      const face = this.faces[i]
+    mergeMesh(mesh) {
+      if (!(mesh && mesh.isMesh)) {
+        console.error('THREE.Geometry.mergeMesh(): mesh not an instance of THREE.Mesh.', mesh)
+        return
+      }
 
-      face.a = changes[face.a]
-      face.b = changes[face.b]
-      face.c = changes[face.c]
+      if (mesh.matrixAutoUpdate) mesh.updateMatrix()
 
-      const indices = [face.a, face.b, face.c]
+      this.merge(mesh.geometry, mesh.matrix)
+    }
 
-      // if any duplicate vertices are found in a Face3
-      // we have to remove the face as nothing can be saved
-      for (let n = 0; n < 3; n++) {
-        if (indices[n] === indices[(n + 1) % 3]) {
-          faceIndicesToRemove.push(i)
-          break
+    /*
+     * Checks for duplicate vertices with hashmap.
+     * Duplicated vertices are removed
+     * and faces' vertices are updated.
+     */
+
+    mergeVertices(precisionPoints = 4) {
+      const verticesMap = {} // Hashmap for looking up vertices by position coordinates (and making sure they are unique)
+      const unique = [],
+        changes = []
+
+      const precision = Math.pow(10, precisionPoints)
+
+      for (let i = 0, il = this.vertices.length; i < il; i++) {
+        const v = this.vertices[i]
+        const key = `${Math.round(v.x * precision)}_${Math.round(v.y * precision)}_${Math.round(v.z * precision)}`
+
+        if (verticesMap[key] === undefined) {
+          verticesMap[key] = i
+          unique.push(this.vertices[i])
+          changes[i] = unique.length - 1
+        } else {
+          //console.log('Duplicate vertex found. ', i, ' could be using ', verticesMap[key]);
+          changes[i] = changes[verticesMap[key]]
         }
       }
-    }
 
-    for (let i = faceIndicesToRemove.length - 1; i >= 0; i--) {
-      const idx = faceIndicesToRemove[i]
+      // if faces are completely degenerate after merging vertices, we
+      // have to remove them from the geometry.
+      const faceIndicesToRemove = []
 
-      this.faces.splice(idx, 1)
+      for (let i = 0, il = this.faces.length; i < il; i++) {
+        const face = this.faces[i]
 
-      for (let j = 0, jl = this.faceVertexUvs.length; j < jl; j++) {
-        this.faceVertexUvs[j].splice(idx, 1)
-      }
-    }
+        face.a = changes[face.a]
+        face.b = changes[face.b]
+        face.c = changes[face.c]
 
-    // Use unique set of vertices
+        const indices = [face.a, face.b, face.c]
 
-    const diff = this.vertices.length - unique.length
-    this.vertices = unique
-    return diff
-  }
-
-  setFromPoints(points) {
-    this.vertices = []
+        // if any duplicate vertices are found in a Face3
+        // we have to remove the face as nothing can be saved
+        for (let n = 0; n < 3; n++) {
+          if (indices[n] === indices[(n + 1) % 3]) {
+            faceIndicesToRemove.push(i)
+            break
+          }
+        }
+      }
 
-    for (let i = 0, l = points.length; i < l; i++) {
-      const point = points[i]
-      this.vertices.push(new Vector3(point.x, point.y, point.z || 0))
-    }
+      for (let i = faceIndicesToRemove.length - 1; i >= 0; i--) {
+        const idx = faceIndicesToRemove[i]
 
-    return this
-  }
+        this.faces.splice(idx, 1)
 
-  sortFacesByMaterialIndex() {
-    const faces = this.faces
-    const length = faces.length
+        for (let j = 0, jl = this.faceVertexUvs.length; j < jl; j++) {
+          this.faceVertexUvs[j].splice(idx, 1)
+        }
+      }
 
-    // tag faces
+      // Use unique set of vertices
 
-    for (let i = 0; i < length; i++) {
-      faces[i]._id = i
+      const diff = this.vertices.length - unique.length
+      this.vertices = unique
+      return diff
     }
 
-    // sort faces
+    setFromPoints(points) {
+      this.vertices = []
 
-    function materialIndexSort(a, b) {
-      return a.materialIndex - b.materialIndex
-    }
+      for (let i = 0, l = points.length; i < l; i++) {
+        const point = points[i]
+        this.vertices.push(new Vector3(point.x, point.y, point.z || 0))
+      }
 
-    faces.sort(materialIndexSort)
+      return this
+    }
 
-    // sort uvs
+    sortFacesByMaterialIndex() {
+      const faces = this.faces
+      const length = faces.length
 
-    const uvs1 = this.faceVertexUvs[0]
-    const uvs2 = this.faceVertexUvs[1]
+      // tag faces
 
-    let newUvs1, newUvs2
+      for (let i = 0; i < length; i++) {
+        faces[i]._id = i
+      }
 
-    if (uvs1 && uvs1.length === length) newUvs1 = []
-    if (uvs2 && uvs2.length === length) newUvs2 = []
+      // sort faces
 
-    for (let i = 0; i < length; i++) {
-      const id = faces[i]._id
+      function materialIndexSort(a, b) {
+        return a.materialIndex - b.materialIndex
+      }
 
-      if (newUvs1) newUvs1.push(uvs1[id])
-      if (newUvs2) newUvs2.push(uvs2[id])
-    }
+      faces.sort(materialIndexSort)
 
-    if (newUvs1) this.faceVertexUvs[0] = newUvs1
-    if (newUvs2) this.faceVertexUvs[1] = newUvs2
-  }
+      // sort uvs
 
-  toJSON() {
-    const data = {
-      metadata: {
-        version: 4.5,
-        type: 'Geometry',
-        generator: 'Geometry.toJSON',
-      },
-    }
+      const uvs1 = this.faceVertexUvs[0]
+      const uvs2 = this.faceVertexUvs[1]
 
-    // standard Geometry serialization
+      let newUvs1, newUvs2
 
-    data.uuid = this.uuid
-    data.type = this.type
-    if (this.name !== '') data.name = this.name
+      if (uvs1 && uvs1.length === length) newUvs1 = []
+      if (uvs2 && uvs2.length === length) newUvs2 = []
 
-    if (this.parameters !== undefined) {
-      const parameters = this.parameters
+      for (let i = 0; i < length; i++) {
+        const id = faces[i]._id
 
-      for (let key in parameters) {
-        if (parameters[key] !== undefined) data[key] = parameters[key]
+        if (newUvs1) newUvs1.push(uvs1[id])
+        if (newUvs2) newUvs2.push(uvs2[id])
       }
 
-      return data
+      if (newUvs1) this.faceVertexUvs[0] = newUvs1
+      if (newUvs2) this.faceVertexUvs[1] = newUvs2
     }
 
-    const vertices = []
+    toJSON() {
+      const data = {
+        metadata: {
+          version: 4.5,
+          type: 'Geometry',
+          generator: 'Geometry.toJSON',
+        },
+      }
 
-    for (let i = 0; i < this.vertices.length; i++) {
-      const vertex = this.vertices[i]
-      vertices.push(vertex.x, vertex.y, vertex.z)
-    }
+      // standard Geometry serialization
 
-    const faces = []
-    const normals = []
-    const normalsHash = {}
-    const colors = []
-    const colorsHash = {}
-    const uvs = []
-    const uvsHash = {}
+      data.uuid = this.uuid
+      data.type = this.type
+      if (this.name !== '') data.name = this.name
 
-    for (let i = 0; i < this.faces.length; i++) {
-      const face = this.faces[i]
+      if (this.parameters !== undefined) {
+        const parameters = this.parameters
 
-      const hasMaterial = true
-      const hasFaceUv = false // deprecated
-      const hasFaceVertexUv = this.faceVertexUvs[0][i] !== undefined
-      const hasFaceNormal = face.normal.length() > 0
-      const hasFaceVertexNormal = face.vertexNormals.length > 0
-      const hasFaceColor = face.color.r !== 1 || face.color.g !== 1 || face.color.b !== 1
-      const hasFaceVertexColor = face.vertexColors.length > 0
+        for (let key in parameters) {
+          if (parameters[key] !== undefined) data[key] = parameters[key]
+        }
 
-      let faceType = 0
+        return data
+      }
 
-      faceType = setBit(faceType, 0, 0) // isQuad
-      faceType = setBit(faceType, 1, hasMaterial)
-      faceType = setBit(faceType, 2, hasFaceUv)
-      faceType = setBit(faceType, 3, hasFaceVertexUv)
-      faceType = setBit(faceType, 4, hasFaceNormal)
-      faceType = setBit(faceType, 5, hasFaceVertexNormal)
-      faceType = setBit(faceType, 6, hasFaceColor)
-      faceType = setBit(faceType, 7, hasFaceVertexColor)
+      const vertices = []
 
-      faces.push(faceType)
-      faces.push(face.a, face.b, face.c)
-      faces.push(face.materialIndex)
+      for (let i = 0; i < this.vertices.length; i++) {
+        const vertex = this.vertices[i]
+        vertices.push(vertex.x, vertex.y, vertex.z)
+      }
 
-      if (hasFaceVertexUv) {
-        const faceVertexUvs = this.faceVertexUvs[0][i]
+      const faces = []
+      const normals = []
+      const normalsHash = {}
+      const colors = []
+      const colorsHash = {}
+      const uvs = []
+      const uvsHash = {}
+
+      for (let i = 0; i < this.faces.length; i++) {
+        const face = this.faces[i]
+
+        const hasMaterial = true
+        const hasFaceUv = false // deprecated
+        const hasFaceVertexUv = this.faceVertexUvs[0][i] !== undefined
+        const hasFaceNormal = face.normal.length() > 0
+        const hasFaceVertexNormal = face.vertexNormals.length > 0
+        const hasFaceColor = face.color.r !== 1 || face.color.g !== 1 || face.color.b !== 1
+        const hasFaceVertexColor = face.vertexColors.length > 0
+
+        let faceType = 0
+
+        faceType = setBit(faceType, 0, 0) // isQuad
+        faceType = setBit(faceType, 1, hasMaterial)
+        faceType = setBit(faceType, 2, hasFaceUv)
+        faceType = setBit(faceType, 3, hasFaceVertexUv)
+        faceType = setBit(faceType, 4, hasFaceNormal)
+        faceType = setBit(faceType, 5, hasFaceVertexNormal)
+        faceType = setBit(faceType, 6, hasFaceColor)
+        faceType = setBit(faceType, 7, hasFaceVertexColor)
+
+        faces.push(faceType)
+        faces.push(face.a, face.b, face.c)
+        faces.push(face.materialIndex)
+
+        if (hasFaceVertexUv) {
+          const faceVertexUvs = this.faceVertexUvs[0][i]
+
+          faces.push(getUvIndex(faceVertexUvs[0]), getUvIndex(faceVertexUvs[1]), getUvIndex(faceVertexUvs[2]))
+        }
 
-        faces.push(getUvIndex(faceVertexUvs[0]), getUvIndex(faceVertexUvs[1]), getUvIndex(faceVertexUvs[2]))
-      }
+        if (hasFaceNormal) {
+          faces.push(getNormalIndex(face.normal))
+        }
 
-      if (hasFaceNormal) {
-        faces.push(getNormalIndex(face.normal))
-      }
+        if (hasFaceVertexNormal) {
+          const vertexNormals = face.vertexNormals
 
-      if (hasFaceVertexNormal) {
-        const vertexNormals = face.vertexNormals
+          faces.push(
+            getNormalIndex(vertexNormals[0]),
+            getNormalIndex(vertexNormals[1]),
+            getNormalIndex(vertexNormals[2]),
+          )
+        }
 
-        faces.push(getNormalIndex(vertexNormals[0]), getNormalIndex(vertexNormals[1]), getNormalIndex(vertexNormals[2]))
-      }
+        if (hasFaceColor) {
+          faces.push(getColorIndex(face.color))
+        }
 
-      if (hasFaceColor) {
-        faces.push(getColorIndex(face.color))
-      }
+        if (hasFaceVertexColor) {
+          const vertexColors = face.vertexColors
 
-      if (hasFaceVertexColor) {
-        const vertexColors = face.vertexColors
+          faces.push(getColorIndex(vertexColors[0]), getColorIndex(vertexColors[1]), getColorIndex(vertexColors[2]))
+        }
+      }
 
-        faces.push(getColorIndex(vertexColors[0]), getColorIndex(vertexColors[1]), getColorIndex(vertexColors[2]))
+      function setBit(value, position, enabled) {
+        return enabled ? value | (1 << position) : value & ~(1 << position)
       }
-    }
 
-    function setBit(value, position, enabled) {
-      return enabled ? value | (1 << position) : value & ~(1 << position)
-    }
+      function getNormalIndex(normal) {
+        const hash = normal.x.toString() + normal.y.toString() + normal.z.toString()
+
+        if (normalsHash[hash] !== undefined) {
+          return normalsHash[hash]
+        }
 
-    function getNormalIndex(normal) {
-      const hash = normal.x.toString() + normal.y.toString() + normal.z.toString()
+        normalsHash[hash] = normals.length / 3
+        normals.push(normal.x, normal.y, normal.z)
 
-      if (normalsHash[hash] !== undefined) {
         return normalsHash[hash]
       }
 
-      normalsHash[hash] = normals.length / 3
-      normals.push(normal.x, normal.y, normal.z)
+      function getColorIndex(color) {
+        const hash = color.r.toString() + color.g.toString() + color.b.toString()
 
-      return normalsHash[hash]
-    }
+        if (colorsHash[hash] !== undefined) {
+          return colorsHash[hash]
+        }
 
-    function getColorIndex(color) {
-      const hash = color.r.toString() + color.g.toString() + color.b.toString()
+        colorsHash[hash] = colors.length
+        colors.push(color.getHex())
 
-      if (colorsHash[hash] !== undefined) {
         return colorsHash[hash]
       }
 
-      colorsHash[hash] = colors.length
-      colors.push(color.getHex())
+      function getUvIndex(uv) {
+        const hash = uv.x.toString() + uv.y.toString()
 
-      return colorsHash[hash]
-    }
+        if (uvsHash[hash] !== undefined) {
+          return uvsHash[hash]
+        }
 
-    function getUvIndex(uv) {
-      const hash = uv.x.toString() + uv.y.toString()
+        uvsHash[hash] = uvs.length / 2
+        uvs.push(uv.x, uv.y)
 
-      if (uvsHash[hash] !== undefined) {
         return uvsHash[hash]
       }
 
-      uvsHash[hash] = uvs.length / 2
-      uvs.push(uv.x, uv.y)
-
-      return uvsHash[hash]
-    }
-
-    data.data = {}
+      data.data = {}
 
-    data.data.vertices = vertices
-    data.data.normals = normals
-    if (colors.length > 0) data.data.colors = colors
-    if (uvs.length > 0) data.data.uvs = [uvs] // temporal backward compatibility
-    data.data.faces = faces
+      data.data.vertices = vertices
+      data.data.normals = normals
+      if (colors.length > 0) data.data.colors = colors
+      if (uvs.length > 0) data.data.uvs = [uvs] // temporal backward compatibility
+      data.data.faces = faces
 
-    return data
-  }
+      return data
+    }
 
-  clone() {
-    /*
+    clone() {
+      /*
 		 // Handle primitives
 
 		 const parameters = this.parameters;
@@ -918,290 +923,293 @@ class Geometry extends EventDispatcher {
 		 return new this.constructor().copy( this );
 		 */
 
-    return new Geometry().copy(this)
-  }
+      return new Geometry().copy(this)
+    }
 
-  copy(source) {
-    // reset
+    copy(source) {
+      // reset
 
-    this.vertices = []
-    this.colors = []
-    this.faces = []
-    this.faceVertexUvs = [[]]
-    this.morphTargets = []
-    this.morphNormals = []
-    this.skinWeights = []
-    this.skinIndices = []
-    this.lineDistances = []
-    this.boundingBox = null
-    this.boundingSphere = null
+      this.vertices = []
+      this.colors = []
+      this.faces = []
+      this.faceVertexUvs = [[]]
+      this.morphTargets = []
+      this.morphNormals = []
+      this.skinWeights = []
+      this.skinIndices = []
+      this.lineDistances = []
+      this.boundingBox = null
+      this.boundingSphere = null
 
-    // name
+      // name
 
-    this.name = source.name
+      this.name = source.name
 
-    // vertices
+      // vertices
 
-    const vertices = source.vertices
+      const vertices = source.vertices
 
-    for (let i = 0, il = vertices.length; i < il; i++) {
-      this.vertices.push(vertices[i].clone())
-    }
+      for (let i = 0, il = vertices.length; i < il; i++) {
+        this.vertices.push(vertices[i].clone())
+      }
 
-    // colors
+      // colors
 
-    const colors = source.colors
+      const colors = source.colors
 
-    for (let i = 0, il = colors.length; i < il; i++) {
-      this.colors.push(colors[i].clone())
-    }
+      for (let i = 0, il = colors.length; i < il; i++) {
+        this.colors.push(colors[i].clone())
+      }
 
-    // faces
+      // faces
 
-    const faces = source.faces
+      const faces = source.faces
 
-    for (let i = 0, il = faces.length; i < il; i++) {
-      this.faces.push(faces[i].clone())
-    }
+      for (let i = 0, il = faces.length; i < il; i++) {
+        this.faces.push(faces[i].clone())
+      }
 
-    // face vertex uvs
+      // face vertex uvs
 
-    for (let i = 0, il = source.faceVertexUvs.length; i < il; i++) {
-      const faceVertexUvs = source.faceVertexUvs[i]
+      for (let i = 0, il = source.faceVertexUvs.length; i < il; i++) {
+        const faceVertexUvs = source.faceVertexUvs[i]
 
-      if (this.faceVertexUvs[i] === undefined) {
-        this.faceVertexUvs[i] = []
-      }
+        if (this.faceVertexUvs[i] === undefined) {
+          this.faceVertexUvs[i] = []
+        }
 
-      for (let j = 0, jl = faceVertexUvs.length; j < jl; j++) {
-        const uvs = faceVertexUvs[j],
-          uvsCopy = []
+        for (let j = 0, jl = faceVertexUvs.length; j < jl; j++) {
+          const uvs = faceVertexUvs[j],
+            uvsCopy = []
 
-        for (let k = 0, kl = uvs.length; k < kl; k++) {
-          const uv = uvs[k]
+          for (let k = 0, kl = uvs.length; k < kl; k++) {
+            const uv = uvs[k]
 
-          uvsCopy.push(uv.clone())
-        }
+            uvsCopy.push(uv.clone())
+          }
 
-        this.faceVertexUvs[i].push(uvsCopy)
+          this.faceVertexUvs[i].push(uvsCopy)
+        }
       }
-    }
 
-    // morph targets
+      // morph targets
 
-    const morphTargets = source.morphTargets
+      const morphTargets = source.morphTargets
 
-    for (let i = 0, il = morphTargets.length; i < il; i++) {
-      const morphTarget = {}
-      morphTarget.name = morphTargets[i].name
+      for (let i = 0, il = morphTargets.length; i < il; i++) {
+        const morphTarget = {}
+        morphTarget.name = morphTargets[i].name
 
-      // vertices
+        // vertices
 
-      if (morphTargets[i].vertices !== undefined) {
-        morphTarget.vertices = []
+        if (morphTargets[i].vertices !== undefined) {
+          morphTarget.vertices = []
 
-        for (let j = 0, jl = morphTargets[i].vertices.length; j < jl; j++) {
-          morphTarget.vertices.push(morphTargets[i].vertices[j].clone())
+          for (let j = 0, jl = morphTargets[i].vertices.length; j < jl; j++) {
+            morphTarget.vertices.push(morphTargets[i].vertices[j].clone())
+          }
         }
-      }
 
-      // normals
+        // normals
 
-      if (morphTargets[i].normals !== undefined) {
-        morphTarget.normals = []
+        if (morphTargets[i].normals !== undefined) {
+          morphTarget.normals = []
 
-        for (let j = 0, jl = morphTargets[i].normals.length; j < jl; j++) {
-          morphTarget.normals.push(morphTargets[i].normals[j].clone())
+          for (let j = 0, jl = morphTargets[i].normals.length; j < jl; j++) {
+            morphTarget.normals.push(morphTargets[i].normals[j].clone())
+          }
         }
-      }
 
-      this.morphTargets.push(morphTarget)
-    }
+        this.morphTargets.push(morphTarget)
+      }
 
-    // morph normals
+      // morph normals
 
-    const morphNormals = source.morphNormals
+      const morphNormals = source.morphNormals
 
-    for (let i = 0, il = morphNormals.length; i < il; i++) {
-      const morphNormal = {}
+      for (let i = 0, il = morphNormals.length; i < il; i++) {
+        const morphNormal = {}
 
-      // vertex normals
+        // vertex normals
 
-      if (morphNormals[i].vertexNormals !== undefined) {
-        morphNormal.vertexNormals = []
+        if (morphNormals[i].vertexNormals !== undefined) {
+          morphNormal.vertexNormals = []
 
-        for (let j = 0, jl = morphNormals[i].vertexNormals.length; j < jl; j++) {
-          const srcVertexNormal = morphNormals[i].vertexNormals[j]
-          const destVertexNormal = {}
+          for (let j = 0, jl = morphNormals[i].vertexNormals.length; j < jl; j++) {
+            const srcVertexNormal = morphNormals[i].vertexNormals[j]
+            const destVertexNormal = {}
 
-          destVertexNormal.a = srcVertexNormal.a.clone()
-          destVertexNormal.b = srcVertexNormal.b.clone()
-          destVertexNormal.c = srcVertexNormal.c.clone()
+            destVertexNormal.a = srcVertexNormal.a.clone()
+            destVertexNormal.b = srcVertexNormal.b.clone()
+            destVertexNormal.c = srcVertexNormal.c.clone()
 
-          morphNormal.vertexNormals.push(destVertexNormal)
+            morphNormal.vertexNormals.push(destVertexNormal)
+          }
         }
-      }
 
-      // face normals
+        // face normals
 
-      if (morphNormals[i].faceNormals !== undefined) {
-        morphNormal.faceNormals = []
+        if (morphNormals[i].faceNormals !== undefined) {
+          morphNormal.faceNormals = []
 
-        for (let j = 0, jl = morphNormals[i].faceNormals.length; j < jl; j++) {
-          morphNormal.faceNormals.push(morphNormals[i].faceNormals[j].clone())
+          for (let j = 0, jl = morphNormals[i].faceNormals.length; j < jl; j++) {
+            morphNormal.faceNormals.push(morphNormals[i].faceNormals[j].clone())
+          }
         }
+
+        this.morphNormals.push(morphNormal)
       }
 
-      this.morphNormals.push(morphNormal)
-    }
+      // skin weights
 
-    // skin weights
+      const skinWeights = source.skinWeights
 
-    const skinWeights = source.skinWeights
+      for (let i = 0, il = skinWeights.length; i < il; i++) {
+        this.skinWeights.push(skinWeights[i].clone())
+      }
 
-    for (let i = 0, il = skinWeights.length; i < il; i++) {
-      this.skinWeights.push(skinWeights[i].clone())
-    }
+      // skin indices
 
-    // skin indices
+      const skinIndices = source.skinIndices
 
-    const skinIndices = source.skinIndices
+      for (let i = 0, il = skinIndices.length; i < il; i++) {
+        this.skinIndices.push(skinIndices[i].clone())
+      }
 
-    for (let i = 0, il = skinIndices.length; i < il; i++) {
-      this.skinIndices.push(skinIndices[i].clone())
-    }
+      // line distances
 
-    // line distances
+      const lineDistances = source.lineDistances
 
-    const lineDistances = source.lineDistances
+      for (let i = 0, il = lineDistances.length; i < il; i++) {
+        this.lineDistances.push(lineDistances[i])
+      }
 
-    for (let i = 0, il = lineDistances.length; i < il; i++) {
-      this.lineDistances.push(lineDistances[i])
-    }
+      // bounding box
 
-    // bounding box
+      const boundingBox = source.boundingBox
 
-    const boundingBox = source.boundingBox
+      if (boundingBox !== null) {
+        this.boundingBox = boundingBox.clone()
+      }
 
-    if (boundingBox !== null) {
-      this.boundingBox = boundingBox.clone()
-    }
+      // bounding sphere
 
-    // bounding sphere
+      const boundingSphere = source.boundingSphere
 
-    const boundingSphere = source.boundingSphere
+      if (boundingSphere !== null) {
+        this.boundingSphere = boundingSphere.clone()
+      }
 
-    if (boundingSphere !== null) {
-      this.boundingSphere = boundingSphere.clone()
-    }
+      // update flags
 
-    // update flags
+      this.elementsNeedUpdate = source.elementsNeedUpdate
+      this.verticesNeedUpdate = source.verticesNeedUpdate
+      this.uvsNeedUpdate = source.uvsNeedUpdate
+      this.normalsNeedUpdate = source.normalsNeedUpdate
+      this.colorsNeedUpdate = source.colorsNeedUpdate
+      this.lineDistancesNeedUpdate = source.lineDistancesNeedUpdate
+      this.groupsNeedUpdate = source.groupsNeedUpdate
 
-    this.elementsNeedUpdate = source.elementsNeedUpdate
-    this.verticesNeedUpdate = source.verticesNeedUpdate
-    this.uvsNeedUpdate = source.uvsNeedUpdate
-    this.normalsNeedUpdate = source.normalsNeedUpdate
-    this.colorsNeedUpdate = source.colorsNeedUpdate
-    this.lineDistancesNeedUpdate = source.lineDistancesNeedUpdate
-    this.groupsNeedUpdate = source.groupsNeedUpdate
+      return this
+    }
 
-    return this
-  }
+    toBufferGeometry() {
+      const geometry = new DirectGeometry().fromGeometry(this)
 
-  toBufferGeometry() {
-    const geometry = new DirectGeometry().fromGeometry(this)
+      const buffergeometry = new BufferGeometry()
 
-    const buffergeometry = new BufferGeometry()
+      const positions = new Float32Array(geometry.vertices.length * 3)
+      buffergeometry.setAttribute('position', new BufferAttribute(positions, 3).copyVector3sArray(geometry.vertices))
 
-    const positions = new Float32Array(geometry.vertices.length * 3)
-    buffergeometry.setAttribute('position', new BufferAttribute(positions, 3).copyVector3sArray(geometry.vertices))
+      if (geometry.normals.length > 0) {
+        const normals = new Float32Array(geometry.normals.length * 3)
+        buffergeometry.setAttribute('normal', new BufferAttribute(normals, 3).copyVector3sArray(geometry.normals))
+      }
 
-    if (geometry.normals.length > 0) {
-      const normals = new Float32Array(geometry.normals.length * 3)
-      buffergeometry.setAttribute('normal', new BufferAttribute(normals, 3).copyVector3sArray(geometry.normals))
-    }
+      if (geometry.colors.length > 0) {
+        const colors = new Float32Array(geometry.colors.length * 3)
+        buffergeometry.setAttribute('color', new BufferAttribute(colors, 3).copyColorsArray(geometry.colors))
+      }
 
-    if (geometry.colors.length > 0) {
-      const colors = new Float32Array(geometry.colors.length * 3)
-      buffergeometry.setAttribute('color', new BufferAttribute(colors, 3).copyColorsArray(geometry.colors))
-    }
+      if (geometry.uvs.length > 0) {
+        const uvs = new Float32Array(geometry.uvs.length * 2)
+        buffergeometry.setAttribute('uv', new BufferAttribute(uvs, 2).copyVector2sArray(geometry.uvs))
+      }
 
-    if (geometry.uvs.length > 0) {
-      const uvs = new Float32Array(geometry.uvs.length * 2)
-      buffergeometry.setAttribute('uv', new BufferAttribute(uvs, 2).copyVector2sArray(geometry.uvs))
-    }
+      if (geometry.uvs2.length > 0) {
+        const uvs2 = new Float32Array(geometry.uvs2.length * 2)
+        buffergeometry.setAttribute('uv2', new BufferAttribute(uvs2, 2).copyVector2sArray(geometry.uvs2))
+      }
 
-    if (geometry.uvs2.length > 0) {
-      const uvs2 = new Float32Array(geometry.uvs2.length * 2)
-      buffergeometry.setAttribute('uv2', new BufferAttribute(uvs2, 2).copyVector2sArray(geometry.uvs2))
-    }
+      // groups
 
-    // groups
+      buffergeometry.groups = geometry.groups
 
-    buffergeometry.groups = geometry.groups
+      // morphs
 
-    // morphs
+      for (let name in geometry.morphTargets) {
+        const array = []
+        const morphTargets = geometry.morphTargets[name]
 
-    for (let name in geometry.morphTargets) {
-      const array = []
-      const morphTargets = geometry.morphTargets[name]
+        for (let i = 0, l = morphTargets.length; i < l; i++) {
+          const morphTarget = morphTargets[i]
 
-      for (let i = 0, l = morphTargets.length; i < l; i++) {
-        const morphTarget = morphTargets[i]
+          const attribute = new Float32BufferAttribute(morphTarget.data.length * 3, 3)
+          attribute.name = morphTarget.name
 
-        const attribute = new Float32BufferAttribute(morphTarget.data.length * 3, 3)
-        attribute.name = morphTarget.name
+          array.push(attribute.copyVector3sArray(morphTarget.data))
+        }
 
-        array.push(attribute.copyVector3sArray(morphTarget.data))
+        buffergeometry.morphAttributes[name] = array
       }
 
-      buffergeometry.morphAttributes[name] = array
-    }
+      // skinning
+
+      if (geometry.skinIndices.length > 0) {
+        const skinIndices = new Float32BufferAttribute(geometry.skinIndices.length * 4, 4)
+        buffergeometry.setAttribute('skinIndex', skinIndices.copyVector4sArray(geometry.skinIndices))
+      }
 
-    // skinning
+      if (geometry.skinWeights.length > 0) {
+        const skinWeights = new Float32BufferAttribute(geometry.skinWeights.length * 4, 4)
+        buffergeometry.setAttribute('skinWeight', skinWeights.copyVector4sArray(geometry.skinWeights))
+      }
 
-    if (geometry.skinIndices.length > 0) {
-      const skinIndices = new Float32BufferAttribute(geometry.skinIndices.length * 4, 4)
-      buffergeometry.setAttribute('skinIndex', skinIndices.copyVector4sArray(geometry.skinIndices))
-    }
+      //
 
-    if (geometry.skinWeights.length > 0) {
-      const skinWeights = new Float32BufferAttribute(geometry.skinWeights.length * 4, 4)
-      buffergeometry.setAttribute('skinWeight', skinWeights.copyVector4sArray(geometry.skinWeights))
-    }
+      if (geometry.boundingSphere !== null) {
+        buffergeometry.boundingSphere = geometry.boundingSphere.clone()
+      }
 
-    //
+      if (geometry.boundingBox !== null) {
+        buffergeometry.boundingBox = geometry.boundingBox.clone()
+      }
 
-    if (geometry.boundingSphere !== null) {
-      buffergeometry.boundingSphere = geometry.boundingSphere.clone()
+      return buffergeometry
     }
 
-    if (geometry.boundingBox !== null) {
-      buffergeometry.boundingBox = geometry.boundingBox.clone()
+    computeTangents() {
+      console.error('THREE.Geometry: .computeTangents() has been removed.')
     }
 
-    return buffergeometry
-  }
-
-  computeTangents() {
-    console.error('THREE.Geometry: .computeTangents() has been removed.')
-  }
+    computeLineDistances() {
+      console.error(
+        'THREE.Geometry: .computeLineDistances() has been removed. Use THREE.Line.computeLineDistances() instead.',
+      )
+    }
 
-  computeLineDistances() {
-    console.error(
-      'THREE.Geometry: .computeLineDistances() has been removed. Use THREE.Line.computeLineDistances() instead.',
-    )
-  }
+    applyMatrix(matrix) {
+      console.warn('THREE.Geometry: .applyMatrix() has been renamed to .applyMatrix4().')
+      return this.applyMatrix4(matrix)
+    }
 
-  applyMatrix(matrix) {
-    console.warn('THREE.Geometry: .applyMatrix() has been renamed to .applyMatrix4().')
-    return this.applyMatrix4(matrix)
+    dispose() {
+      this.dispatchEvent({ type: 'dispose' })
+    }
   }
 
-  dispose() {
-    this.dispatchEvent({ type: 'dispose' })
-  }
-}
+  return Geometry
+})()
 
 class DirectGeometry {
   constructor() {
diff --git a/src/effects/AnaglyphEffect.js b/src/effects/AnaglyphEffect.js
index fdbdc8c3..7713e65e 100644
--- a/src/effects/AnaglyphEffect.js
+++ b/src/effects/AnaglyphEffect.js
@@ -10,8 +10,8 @@ import {
   ShaderMaterial,
   StereoCamera,
   WebGLRenderTarget,
-  REVISION,
 } from 'three'
+import { version } from '../_polyfill/constants'
 
 class AnaglyphEffect {
   constructor(renderer, width = 512, height = 512) {
@@ -96,7 +96,7 @@ class AnaglyphEffect {
         '			max( colorL.a, colorR.a ) );',
 
         '	#include <tonemapping_fragment>',
-        `	#include <${parseInt(REVISION.replace(/\D+/g, '')) >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>`,
+        `	#include <${version >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>`,
 
         '}',
       ].join('\n'),
diff --git a/src/effects/OutlineEffect.js b/src/effects/OutlineEffect.js
index 2999048c..581b2349 100644
--- a/src/effects/OutlineEffect.js
+++ b/src/effects/OutlineEffect.js
@@ -1,4 +1,5 @@
-import { BackSide, Color, ShaderMaterial, UniformsLib, UniformsUtils, REVISION } from 'three'
+import { BackSide, Color, ShaderMaterial, UniformsLib, UniformsUtils } from 'three'
+import { version } from '../_polyfill/constants'
 
 /**
  * Reference: https://en.wikipedia.org/wiki/Cel_shading
@@ -157,7 +158,7 @@ class OutlineEffect {
       '	gl_FragColor = vec4( outlineColor, outlineAlpha );',
 
       '	#include <tonemapping_fragment>',
-      `	#include <${parseInt(REVISION.replace(/\D+/g, '')) >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>`,
+      `	#include <${version >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>`,
       '	#include <fog_fragment>',
       '	#include <premultiplied_alpha_fragment>',
 
diff --git a/src/effects/ParallaxBarrierEffect.js b/src/effects/ParallaxBarrierEffect.js
index 00ae33f4..8cee4954 100644
--- a/src/effects/ParallaxBarrierEffect.js
+++ b/src/effects/ParallaxBarrierEffect.js
@@ -9,8 +9,8 @@ import {
   ShaderMaterial,
   StereoCamera,
   WebGLRenderTarget,
-  REVISION,
 } from 'three'
+import { version } from '../_polyfill/constants'
 
 class ParallaxBarrierEffect {
   constructor(renderer) {
@@ -62,7 +62,7 @@ class ParallaxBarrierEffect {
         '	}',
 
         '	#include <tonemapping_fragment>',
-        `	#include <${parseInt(REVISION.replace(/\D+/g, '')) >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>`,
+        `	#include <${version >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>`,
 
         '}',
       ].join('\n'),
diff --git a/src/exporters/DRACOExporter.ts b/src/exporters/DRACOExporter.ts
index 474d6097..8f15354b 100644
--- a/src/exporters/DRACOExporter.ts
+++ b/src/exporters/DRACOExporter.ts
@@ -17,191 +17,203 @@ import { BufferGeometry, Mesh, Points } from 'three'
 
 declare const DracoEncoderModule: () => EncoderModule
 
-class DRACOExporter {
-  // Encoder methods
-
-  public static MESH_EDGEBREAKER_ENCODING = 1
-  public static MESH_SEQUENTIAL_ENCODING = 0
-
-  // Geometry type
-
-  public static POINT_CLOUD = 0
-  public static TRIANGULAR_MESH = 1
-
-  // Attribute type
-  public static INVALID = -1
-  public static POSITION = 0
-  public static NORMAL = 1
-  public static COLOR = 2
-  public static TEX_COORD = 3
-  public static GENERIC = 4
-
-  public parse(
-    object: Mesh | Points,
-    options = {
-      decodeSpeed: 5,
-      encodeSpeed: 5,
-      encoderMethod: DRACOExporter.MESH_EDGEBREAKER_ENCODING,
-      quantization: [16, 8, 8, 8, 8],
-      exportUvs: true,
-      exportNormals: true,
-      exportColor: false,
-    },
-  ): Int8Array {
-    if (object instanceof BufferGeometry && object.isBufferGeometry) {
-      throw new Error('DRACOExporter: The first parameter of parse() is now an instance of Mesh or Points.')
-    }
+const DRACOExporter = /* @__PURE__ */ (() => {
+  class DRACOExporter {
+    // Encoder methods
+
+    public static MESH_EDGEBREAKER_ENCODING = 1
+    public static MESH_SEQUENTIAL_ENCODING = 0
+
+    // Geometry type
+
+    public static POINT_CLOUD = 0
+    public static TRIANGULAR_MESH = 1
+
+    // Attribute type
+    public static INVALID = -1
+    public static POSITION = 0
+    public static NORMAL = 1
+    public static COLOR = 2
+    public static TEX_COORD = 3
+    public static GENERIC = 4
+
+    public parse(
+      object: Mesh | Points,
+      options = {
+        decodeSpeed: 5,
+        encodeSpeed: 5,
+        encoderMethod: DRACOExporter.MESH_EDGEBREAKER_ENCODING,
+        quantization: [16, 8, 8, 8, 8],
+        exportUvs: true,
+        exportNormals: true,
+        exportColor: false,
+      },
+    ): Int8Array {
+      if (object instanceof BufferGeometry && object.isBufferGeometry) {
+        throw new Error('DRACOExporter: The first parameter of parse() is now an instance of Mesh or Points.')
+      }
 
-    if (DracoEncoderModule === undefined) {
-      throw new Error('THREE.DRACOExporter: required the draco_encoder to work.')
-    }
+      if (DracoEncoderModule === undefined) {
+        throw new Error('THREE.DRACOExporter: required the draco_encoder to work.')
+      }
 
-    const geometry = object.geometry
+      const geometry = object.geometry
 
-    const dracoEncoder = DracoEncoderModule()
-    const encoder = new dracoEncoder.Encoder()
-    let builder
-    let dracoObject
+      const dracoEncoder = DracoEncoderModule()
+      const encoder = new dracoEncoder.Encoder()
+      let builder
+      let dracoObject
 
-    if (!geometry.isBufferGeometry) {
-      throw new Error('THREE.DRACOExporter.parse(geometry, options): geometry is not a THREE.BufferGeometry instance.')
-    }
+      if (!geometry.isBufferGeometry) {
+        throw new Error(
+          'THREE.DRACOExporter.parse(geometry, options): geometry is not a THREE.BufferGeometry instance.',
+        )
+      }
 
-    if (object instanceof Mesh && object.isMesh) {
-      builder = new dracoEncoder.MeshBuilder()
-      dracoObject = new dracoEncoder.Mesh()
+      if (object instanceof Mesh && object.isMesh) {
+        builder = new dracoEncoder.MeshBuilder()
+        dracoObject = new dracoEncoder.Mesh()
 
-      const vertices = geometry.getAttribute('position')
-      // @ts-ignore
-      builder.AddFloatAttributeToMesh(
-        dracoObject,
-        dracoEncoder.POSITION,
-        vertices.count,
-        vertices.itemSize,
-        vertices.array,
-      )
+        const vertices = geometry.getAttribute('position')
+        // @ts-ignore
+        builder.AddFloatAttributeToMesh(
+          dracoObject,
+          dracoEncoder.POSITION,
+          vertices.count,
+          vertices.itemSize,
+          vertices.array,
+        )
 
-      const faces = geometry.getIndex()
+        const faces = geometry.getIndex()
 
-      if (faces !== null) {
-        builder.AddFacesToMesh(dracoObject, faces.count / 3, faces.array as Uint16Array | Uint32Array)
-      } else {
-        const faces = new (vertices.count > 65535 ? Uint32Array : Uint16Array)(vertices.count)
+        if (faces !== null) {
+          builder.AddFacesToMesh(dracoObject, faces.count / 3, faces.array as Uint16Array | Uint32Array)
+        } else {
+          const faces = new (vertices.count > 65535 ? Uint32Array : Uint16Array)(vertices.count)
 
-        for (let i = 0; i < faces.length; i++) {
-          faces[i] = i
-        }
+          for (let i = 0; i < faces.length; i++) {
+            faces[i] = i
+          }
 
-        builder.AddFacesToMesh(dracoObject, vertices.count, faces)
-      }
+          builder.AddFacesToMesh(dracoObject, vertices.count, faces)
+        }
 
-      if (options.exportNormals) {
-        const normals = geometry.getAttribute('normal')
-
-        if (normals !== undefined) {
-          // @ts-ignore
-          builder.AddFloatAttributeToMesh(
-            dracoObject,
-            dracoEncoder.NORMAL,
-            normals.count,
-            normals.itemSize,
-            normals.array,
-          )
+        if (options.exportNormals) {
+          const normals = geometry.getAttribute('normal')
+
+          if (normals !== undefined) {
+            // @ts-ignore
+            builder.AddFloatAttributeToMesh(
+              dracoObject,
+              dracoEncoder.NORMAL,
+              normals.count,
+              normals.itemSize,
+              normals.array,
+            )
+          }
         }
-      }
 
-      if (options.exportUvs) {
-        const uvs = geometry.getAttribute('uv')
+        if (options.exportUvs) {
+          const uvs = geometry.getAttribute('uv')
 
-        if (uvs !== undefined) {
-          // @ts-ignore
-          builder.AddFloatAttributeToMesh(dracoObject, dracoEncoder.TEX_COORD, uvs.count, uvs.itemSize, uvs.array)
+          if (uvs !== undefined) {
+            // @ts-ignore
+            builder.AddFloatAttributeToMesh(dracoObject, dracoEncoder.TEX_COORD, uvs.count, uvs.itemSize, uvs.array)
+          }
         }
-      }
-
-      if (options.exportColor) {
-        const colors = geometry.getAttribute('color')
 
-        if (colors !== undefined) {
-          // @ts-ignore
-          builder.AddFloatAttributeToMesh(dracoObject, dracoEncoder.COLOR, colors.count, colors.itemSize, colors.array)
+        if (options.exportColor) {
+          const colors = geometry.getAttribute('color')
+
+          if (colors !== undefined) {
+            // @ts-ignore
+            builder.AddFloatAttributeToMesh(
+              dracoObject,
+              dracoEncoder.COLOR,
+              colors.count,
+              colors.itemSize,
+              colors.array,
+            )
+          }
         }
-      }
-    } else if (object instanceof Points && object.isPoints) {
-      // @ts-ignore
-      builder = new dracoEncoder.PointCloudBuilder()
-      // @ts-ignore
-      dracoObject = new dracoEncoder.PointCloud()
+      } else if (object instanceof Points && object.isPoints) {
+        // @ts-ignore
+        builder = new dracoEncoder.PointCloudBuilder()
+        // @ts-ignore
+        dracoObject = new dracoEncoder.PointCloud()
 
-      const vertices = geometry.getAttribute('position')
-      builder.AddFloatAttribute(dracoObject, dracoEncoder.POSITION, vertices.count, vertices.itemSize, vertices.array)
+        const vertices = geometry.getAttribute('position')
+        builder.AddFloatAttribute(dracoObject, dracoEncoder.POSITION, vertices.count, vertices.itemSize, vertices.array)
 
-      if (options.exportColor) {
-        const colors = geometry.getAttribute('color')
+        if (options.exportColor) {
+          const colors = geometry.getAttribute('color')
 
-        if (colors !== undefined) {
-          builder.AddFloatAttribute(dracoObject, dracoEncoder.COLOR, colors.count, colors.itemSize, colors.array)
+          if (colors !== undefined) {
+            builder.AddFloatAttribute(dracoObject, dracoEncoder.COLOR, colors.count, colors.itemSize, colors.array)
+          }
         }
+      } else {
+        throw new Error('DRACOExporter: Unsupported object type.')
       }
-    } else {
-      throw new Error('DRACOExporter: Unsupported object type.')
-    }
 
-    //Compress using draco encoder
+      //Compress using draco encoder
 
-    const encodedData = new dracoEncoder.DracoInt8Array()
+      const encodedData = new dracoEncoder.DracoInt8Array()
 
-    //Sets the desired encoding and decoding speed for the given options from 0 (slowest speed, but the best compression) to 10 (fastest, but the worst compression).
+      //Sets the desired encoding and decoding speed for the given options from 0 (slowest speed, but the best compression) to 10 (fastest, but the worst compression).
 
-    const encodeSpeed = options.encodeSpeed !== undefined ? options.encodeSpeed : 5
-    const decodeSpeed = options.decodeSpeed !== undefined ? options.decodeSpeed : 5
+      const encodeSpeed = options.encodeSpeed !== undefined ? options.encodeSpeed : 5
+      const decodeSpeed = options.decodeSpeed !== undefined ? options.decodeSpeed : 5
 
-    encoder.SetSpeedOptions(encodeSpeed, decodeSpeed)
+      encoder.SetSpeedOptions(encodeSpeed, decodeSpeed)
 
-    // Sets the desired encoding method for a given geometry.
+      // Sets the desired encoding method for a given geometry.
 
-    if (options.encoderMethod !== undefined) {
-      encoder.SetEncodingMethod(options.encoderMethod)
-    }
+      if (options.encoderMethod !== undefined) {
+        encoder.SetEncodingMethod(options.encoderMethod)
+      }
 
-    // Sets the quantization (number of bits used to represent) compression options for a named attribute.
-    // The attribute values will be quantized in a box defined by the maximum extent of the attribute values.
-    if (options.quantization !== undefined) {
-      for (let i = 0; i < 5; i++) {
-        if (options.quantization[i] !== undefined) {
-          encoder.SetAttributeQuantization(i, options.quantization[i])
+      // Sets the quantization (number of bits used to represent) compression options for a named attribute.
+      // The attribute values will be quantized in a box defined by the maximum extent of the attribute values.
+      if (options.quantization !== undefined) {
+        for (let i = 0; i < 5; i++) {
+          if (options.quantization[i] !== undefined) {
+            encoder.SetAttributeQuantization(i, options.quantization[i])
+          }
         }
       }
-    }
 
-    let length
+      let length
 
-    if (object instanceof Mesh && object.isMesh) {
-      length = encoder.EncodeMeshToDracoBuffer(dracoObject, encodedData)
-    } else {
-      // @ts-ignore
-      length = encoder.EncodePointCloudToDracoBuffer(dracoObject, true, encodedData)
-    }
+      if (object instanceof Mesh && object.isMesh) {
+        length = encoder.EncodeMeshToDracoBuffer(dracoObject, encodedData)
+      } else {
+        // @ts-ignore
+        length = encoder.EncodePointCloudToDracoBuffer(dracoObject, true, encodedData)
+      }
 
-    dracoEncoder.destroy(dracoObject)
+      dracoEncoder.destroy(dracoObject)
 
-    if (length === 0) {
-      throw new Error('THREE.DRACOExporter: Draco encoding failed.')
-    }
+      if (length === 0) {
+        throw new Error('THREE.DRACOExporter: Draco encoding failed.')
+      }
 
-    //Copy encoded data to buffer.
-    const outputData = new Int8Array(new ArrayBuffer(length))
+      //Copy encoded data to buffer.
+      const outputData = new Int8Array(new ArrayBuffer(length))
 
-    for (let i = 0; i < length; i++) {
-      outputData[i] = encodedData.GetValue(i)
-    }
+      for (let i = 0; i < length; i++) {
+        outputData[i] = encodedData.GetValue(i)
+      }
 
-    dracoEncoder.destroy(encodedData)
-    dracoEncoder.destroy(encoder)
-    dracoEncoder.destroy(builder)
+      dracoEncoder.destroy(encodedData)
+      dracoEncoder.destroy(encoder)
+      dracoEncoder.destroy(builder)
 
-    return outputData
+      return outputData
+    }
   }
-}
+
+  return DRACOExporter
+})()
 
 export { DRACOExporter }
diff --git a/src/exporters/GLTFExporter.js b/src/exporters/GLTFExporter.js
index 143a42d5..b2c9736b 100644
--- a/src/exporters/GLTFExporter.js
+++ b/src/exporters/GLTFExporter.js
@@ -129,259 +129,263 @@ const KHR_mesh_quantization_ExtraAttrTypes = {
   TEXCOORD: ['byte', 'byte normalized', 'unsigned byte', 'short', 'short normalized', 'unsigned short'],
 }
 
-class GLTFExporter {
-  /**
-   * Static utility functions
-   */
-  static Utils = {
-    insertKeyframe: function (track, time) {
-      const tolerance = 0.001 // 1ms
-      const valueSize = track.getValueSize()
-
-      const times = new track.TimeBufferType(track.times.length + 1)
-      const values = new track.ValueBufferType(track.values.length + valueSize)
-      const interpolant = track.createInterpolant(new track.ValueBufferType(valueSize))
+const GLTFExporter = /* @__PURE__ */ (() => {
+  class GLTFExporter {
+    /**
+     * Static utility functions
+     */
+    static Utils = {
+      insertKeyframe: function (track, time) {
+        const tolerance = 0.001 // 1ms
+        const valueSize = track.getValueSize()
+
+        const times = new track.TimeBufferType(track.times.length + 1)
+        const values = new track.ValueBufferType(track.values.length + valueSize)
+        const interpolant = track.createInterpolant(new track.ValueBufferType(valueSize))
+
+        let index
+
+        if (track.times.length === 0) {
+          times[0] = time
+
+          for (let i = 0; i < valueSize; i++) {
+            values[i] = 0
+          }
 
-      let index
+          index = 0
+        } else if (time < track.times[0]) {
+          if (Math.abs(track.times[0] - time) < tolerance) return 0
 
-      if (track.times.length === 0) {
-        times[0] = time
+          times[0] = time
+          times.set(track.times, 1)
 
-        for (let i = 0; i < valueSize; i++) {
-          values[i] = 0
-        }
+          values.set(interpolant.evaluate(time), 0)
+          values.set(track.values, valueSize)
 
-        index = 0
-      } else if (time < track.times[0]) {
-        if (Math.abs(track.times[0] - time) < tolerance) return 0
+          index = 0
+        } else if (time > track.times[track.times.length - 1]) {
+          if (Math.abs(track.times[track.times.length - 1] - time) < tolerance) {
+            return track.times.length - 1
+          }
 
-        times[0] = time
-        times.set(track.times, 1)
+          times[times.length - 1] = time
+          times.set(track.times, 0)
 
-        values.set(interpolant.evaluate(time), 0)
-        values.set(track.values, valueSize)
+          values.set(track.values, 0)
+          values.set(interpolant.evaluate(time), track.values.length)
 
-        index = 0
-      } else if (time > track.times[track.times.length - 1]) {
-        if (Math.abs(track.times[track.times.length - 1] - time) < tolerance) {
-          return track.times.length - 1
-        }
+          index = times.length - 1
+        } else {
+          for (let i = 0; i < track.times.length; i++) {
+            if (Math.abs(track.times[i] - time) < tolerance) return i
 
-        times[times.length - 1] = time
-        times.set(track.times, 0)
+            if (track.times[i] < time && track.times[i + 1] > time) {
+              times.set(track.times.slice(0, i + 1), 0)
+              times[i + 1] = time
+              times.set(track.times.slice(i + 1), i + 2)
 
-        values.set(track.values, 0)
-        values.set(interpolant.evaluate(time), track.values.length)
+              values.set(track.values.slice(0, (i + 1) * valueSize), 0)
+              values.set(interpolant.evaluate(time), (i + 1) * valueSize)
+              values.set(track.values.slice((i + 1) * valueSize), (i + 2) * valueSize)
 
-        index = times.length - 1
-      } else {
-        for (let i = 0; i < track.times.length; i++) {
-          if (Math.abs(track.times[i] - time) < tolerance) return i
+              index = i + 1
 
-          if (track.times[i] < time && track.times[i + 1] > time) {
-            times.set(track.times.slice(0, i + 1), 0)
-            times[i + 1] = time
-            times.set(track.times.slice(i + 1), i + 2)
+              break
+            }
+          }
+        }
 
-            values.set(track.values.slice(0, (i + 1) * valueSize), 0)
-            values.set(interpolant.evaluate(time), (i + 1) * valueSize)
-            values.set(track.values.slice((i + 1) * valueSize), (i + 2) * valueSize)
+        track.times = times
+        track.values = values
 
-            index = i + 1
+        return index
+      },
 
-            break
+      mergeMorphTargetTracks: function (clip, root) {
+        const tracks = []
+        const mergedTracks = {}
+        const sourceTracks = clip.tracks
+
+        for (let i = 0; i < sourceTracks.length; ++i) {
+          let sourceTrack = sourceTracks[i]
+          const sourceTrackBinding = PropertyBinding.parseTrackName(sourceTrack.name)
+          const sourceTrackNode = PropertyBinding.findNode(root, sourceTrackBinding.nodeName)
+
+          if (
+            sourceTrackBinding.propertyName !== 'morphTargetInfluences' ||
+            sourceTrackBinding.propertyIndex === undefined
+          ) {
+            // Tracks that don't affect morph targets, or that affect all morph targets together, can be left as-is.
+            tracks.push(sourceTrack)
+            continue
           }
-        }
-      }
 
-      track.times = times
-      track.values = values
+          if (
+            sourceTrack.createInterpolant !== sourceTrack.InterpolantFactoryMethodDiscrete &&
+            sourceTrack.createInterpolant !== sourceTrack.InterpolantFactoryMethodLinear
+          ) {
+            if (sourceTrack.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline) {
+              // This should never happen, because glTF morph target animations
+              // affect all targets already.
+              throw new Error('THREE.GLTFExporter: Cannot merge tracks with glTF CUBICSPLINE interpolation.')
+            }
 
-      return index
-    },
-
-    mergeMorphTargetTracks: function (clip, root) {
-      const tracks = []
-      const mergedTracks = {}
-      const sourceTracks = clip.tracks
-
-      for (let i = 0; i < sourceTracks.length; ++i) {
-        let sourceTrack = sourceTracks[i]
-        const sourceTrackBinding = PropertyBinding.parseTrackName(sourceTrack.name)
-        const sourceTrackNode = PropertyBinding.findNode(root, sourceTrackBinding.nodeName)
-
-        if (
-          sourceTrackBinding.propertyName !== 'morphTargetInfluences' ||
-          sourceTrackBinding.propertyIndex === undefined
-        ) {
-          // Tracks that don't affect morph targets, or that affect all morph targets together, can be left as-is.
-          tracks.push(sourceTrack)
-          continue
-        }
+            console.warn('THREE.GLTFExporter: Morph target interpolation mode not yet supported. Using LINEAR instead.')
 
-        if (
-          sourceTrack.createInterpolant !== sourceTrack.InterpolantFactoryMethodDiscrete &&
-          sourceTrack.createInterpolant !== sourceTrack.InterpolantFactoryMethodLinear
-        ) {
-          if (sourceTrack.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline) {
-            // This should never happen, because glTF morph target animations
-            // affect all targets already.
-            throw new Error('THREE.GLTFExporter: Cannot merge tracks with glTF CUBICSPLINE interpolation.')
+            sourceTrack = sourceTrack.clone()
+            sourceTrack.setInterpolation(InterpolateLinear)
           }
 
-          console.warn('THREE.GLTFExporter: Morph target interpolation mode not yet supported. Using LINEAR instead.')
-
-          sourceTrack = sourceTrack.clone()
-          sourceTrack.setInterpolation(InterpolateLinear)
-        }
+          const targetCount = sourceTrackNode.morphTargetInfluences.length
+          const targetIndex = sourceTrackNode.morphTargetDictionary[sourceTrackBinding.propertyIndex]
 
-        const targetCount = sourceTrackNode.morphTargetInfluences.length
-        const targetIndex = sourceTrackNode.morphTargetDictionary[sourceTrackBinding.propertyIndex]
+          if (targetIndex === undefined) {
+            throw new Error('THREE.GLTFExporter: Morph target name not found: ' + sourceTrackBinding.propertyIndex)
+          }
 
-        if (targetIndex === undefined) {
-          throw new Error('THREE.GLTFExporter: Morph target name not found: ' + sourceTrackBinding.propertyIndex)
-        }
+          let mergedTrack
 
-        let mergedTrack
+          // If this is the first time we've seen this object, create a new
+          // track to store merged keyframe data for each morph target.
+          if (mergedTracks[sourceTrackNode.uuid] === undefined) {
+            mergedTrack = sourceTrack.clone()
 
-        // If this is the first time we've seen this object, create a new
-        // track to store merged keyframe data for each morph target.
-        if (mergedTracks[sourceTrackNode.uuid] === undefined) {
-          mergedTrack = sourceTrack.clone()
+            const values = new mergedTrack.ValueBufferType(targetCount * mergedTrack.times.length)
 
-          const values = new mergedTrack.ValueBufferType(targetCount * mergedTrack.times.length)
+            for (let j = 0; j < mergedTrack.times.length; j++) {
+              values[j * targetCount + targetIndex] = mergedTrack.values[j]
+            }
 
-          for (let j = 0; j < mergedTrack.times.length; j++) {
-            values[j * targetCount + targetIndex] = mergedTrack.values[j]
-          }
+            // We need to take into consideration the intended target node
+            // of our original un-merged morphTarget animation.
+            mergedTrack.name = (sourceTrackBinding.nodeName || '') + '.morphTargetInfluences'
+            mergedTrack.values = values
 
-          // We need to take into consideration the intended target node
-          // of our original un-merged morphTarget animation.
-          mergedTrack.name = (sourceTrackBinding.nodeName || '') + '.morphTargetInfluences'
-          mergedTrack.values = values
+            mergedTracks[sourceTrackNode.uuid] = mergedTrack
+            tracks.push(mergedTrack)
 
-          mergedTracks[sourceTrackNode.uuid] = mergedTrack
-          tracks.push(mergedTrack)
+            continue
+          }
 
-          continue
-        }
+          const sourceInterpolant = sourceTrack.createInterpolant(new sourceTrack.ValueBufferType(1))
 
-        const sourceInterpolant = sourceTrack.createInterpolant(new sourceTrack.ValueBufferType(1))
+          mergedTrack = mergedTracks[sourceTrackNode.uuid]
 
-        mergedTrack = mergedTracks[sourceTrackNode.uuid]
+          // For every existing keyframe of the merged track, write a (possibly
+          // interpolated) value from the source track.
+          for (let j = 0; j < mergedTrack.times.length; j++) {
+            mergedTrack.values[j * targetCount + targetIndex] = sourceInterpolant.evaluate(mergedTrack.times[j])
+          }
 
-        // For every existing keyframe of the merged track, write a (possibly
-        // interpolated) value from the source track.
-        for (let j = 0; j < mergedTrack.times.length; j++) {
-          mergedTrack.values[j * targetCount + targetIndex] = sourceInterpolant.evaluate(mergedTrack.times[j])
+          // For every existing keyframe of the source track, write a (possibly
+          // new) keyframe to the merged track. Values from the previous loop may
+          // be written again, but keyframes are de-duplicated.
+          for (let j = 0; j < sourceTrack.times.length; j++) {
+            const keyframeIndex = this.insertKeyframe(mergedTrack, sourceTrack.times[j])
+            mergedTrack.values[keyframeIndex * targetCount + targetIndex] = sourceTrack.values[j]
+          }
         }
 
-        // For every existing keyframe of the source track, write a (possibly
-        // new) keyframe to the merged track. Values from the previous loop may
-        // be written again, but keyframes are de-duplicated.
-        for (let j = 0; j < sourceTrack.times.length; j++) {
-          const keyframeIndex = this.insertKeyframe(mergedTrack, sourceTrack.times[j])
-          mergedTrack.values[keyframeIndex * targetCount + targetIndex] = sourceTrack.values[j]
-        }
-      }
+        clip.tracks = tracks
 
-      clip.tracks = tracks
+        return clip
+      },
+    }
 
-      return clip
-    },
-  }
+    constructor() {
+      this.pluginCallbacks = []
 
-  constructor() {
-    this.pluginCallbacks = []
+      this.register(function (writer) {
+        return new GLTFLightExtension(writer)
+      })
 
-    this.register(function (writer) {
-      return new GLTFLightExtension(writer)
-    })
+      this.register(function (writer) {
+        return new GLTFMaterialsUnlitExtension(writer)
+      })
 
-    this.register(function (writer) {
-      return new GLTFMaterialsUnlitExtension(writer)
-    })
+      this.register(function (writer) {
+        return new GLTFMaterialsTransmissionExtension(writer)
+      })
 
-    this.register(function (writer) {
-      return new GLTFMaterialsTransmissionExtension(writer)
-    })
+      this.register(function (writer) {
+        return new GLTFMaterialsVolumeExtension(writer)
+      })
 
-    this.register(function (writer) {
-      return new GLTFMaterialsVolumeExtension(writer)
-    })
+      this.register(function (writer) {
+        return new GLTFMaterialsIorExtension(writer)
+      })
 
-    this.register(function (writer) {
-      return new GLTFMaterialsIorExtension(writer)
-    })
+      this.register(function (writer) {
+        return new GLTFMaterialsSpecularExtension(writer)
+      })
 
-    this.register(function (writer) {
-      return new GLTFMaterialsSpecularExtension(writer)
-    })
+      this.register(function (writer) {
+        return new GLTFMaterialsClearcoatExtension(writer)
+      })
 
-    this.register(function (writer) {
-      return new GLTFMaterialsClearcoatExtension(writer)
-    })
+      this.register(function (writer) {
+        return new GLTFMaterialsIridescenceExtension(writer)
+      })
 
-    this.register(function (writer) {
-      return new GLTFMaterialsIridescenceExtension(writer)
-    })
+      this.register(function (writer) {
+        return new GLTFMaterialsSheenExtension(writer)
+      })
 
-    this.register(function (writer) {
-      return new GLTFMaterialsSheenExtension(writer)
-    })
+      this.register(function (writer) {
+        return new GLTFMaterialsAnisotropyExtension(writer)
+      })
 
-    this.register(function (writer) {
-      return new GLTFMaterialsAnisotropyExtension(writer)
-    })
+      this.register(function (writer) {
+        return new GLTFMaterialsEmissiveStrengthExtension(writer)
+      })
+    }
 
-    this.register(function (writer) {
-      return new GLTFMaterialsEmissiveStrengthExtension(writer)
-    })
-  }
+    register(callback) {
+      if (this.pluginCallbacks.indexOf(callback) === -1) {
+        this.pluginCallbacks.push(callback)
+      }
 
-  register(callback) {
-    if (this.pluginCallbacks.indexOf(callback) === -1) {
-      this.pluginCallbacks.push(callback)
+      return this
     }
 
-    return this
-  }
+    unregister(callback) {
+      if (this.pluginCallbacks.indexOf(callback) !== -1) {
+        this.pluginCallbacks.splice(this.pluginCallbacks.indexOf(callback), 1)
+      }
 
-  unregister(callback) {
-    if (this.pluginCallbacks.indexOf(callback) !== -1) {
-      this.pluginCallbacks.splice(this.pluginCallbacks.indexOf(callback), 1)
+      return this
     }
 
-    return this
-  }
+    /**
+     * Parse scenes and generate GLTF output
+     * @param  {Scene or [THREE.Scenes]} input   Scene or Array of THREE.Scenes
+     * @param  {Function} onDone  Callback on completed
+     * @param  {Function} onError  Callback on errors
+     * @param  {Object} options options
+     */
+    parse(input, onDone, onError, options) {
+      const writer = new GLTFWriter()
+      const plugins = []
 
-  /**
-   * Parse scenes and generate GLTF output
-   * @param  {Scene or [THREE.Scenes]} input   Scene or Array of THREE.Scenes
-   * @param  {Function} onDone  Callback on completed
-   * @param  {Function} onError  Callback on errors
-   * @param  {Object} options options
-   */
-  parse(input, onDone, onError, options) {
-    const writer = new GLTFWriter()
-    const plugins = []
+      for (let i = 0, il = this.pluginCallbacks.length; i < il; i++) {
+        plugins.push(this.pluginCallbacks[i](writer))
+      }
 
-    for (let i = 0, il = this.pluginCallbacks.length; i < il; i++) {
-      plugins.push(this.pluginCallbacks[i](writer))
+      writer.setPlugins(plugins)
+      writer.write(input, onDone, options).catch(onError)
     }
 
-    writer.setPlugins(plugins)
-    writer.write(input, onDone, options).catch(onError)
-  }
-
-  parseAsync(input, options) {
-    const scope = this
+    parseAsync(input, options) {
+      const scope = this
 
-    return new Promise(function (resolve, reject) {
-      scope.parse(input, resolve, reject, options)
-    })
+      return new Promise(function (resolve, reject) {
+        scope.parse(input, resolve, reject, options)
+      })
+    }
   }
-}
+
+  return GLTFExporter
+})()
 
 //------------------------------------------------------------------------------
 // Constants
@@ -441,7 +445,7 @@ const PATH_PROPERTIES = {
   morphTargetInfluences: 'weights',
 }
 
-const DEFAULT_SPECULAR_COLOR = new Color()
+const DEFAULT_SPECULAR_COLOR = /* @__PURE__ */ new Color()
 
 // GLB constants
 // https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#glb-file-format-specification
diff --git a/src/geometries/LightningStrike.js b/src/geometries/LightningStrike.js
index 36cb6bc0..fe434a24 100644
--- a/src/geometries/LightningStrike.js
+++ b/src/geometries/LightningStrike.js
@@ -109,811 +109,821 @@ import { SimplexNoise } from '../math/SimplexNoise'
  *
  */
 
-class LightningStrike extends BufferGeometry {
-  // Ray states
-  static RAY_INITIALIZED = 0
-  static RAY_UNBORN = 1
-  static RAY_PROPAGATING = 2
-  static RAY_STEADY = 3
-  static RAY_VANISHING = 4
-  static RAY_EXTINGUISHED = 5
+const LightningStrike = /* @__PURE__ */ (() => {
+  class LightningStrike extends BufferGeometry {
+    // Ray states
+    static RAY_INITIALIZED = 0
+    static RAY_UNBORN = 1
+    static RAY_PROPAGATING = 2
+    static RAY_STEADY = 3
+    static RAY_VANISHING = 4
+    static RAY_EXTINGUISHED = 5
 
-  static COS30DEG = Math.cos((30 * Math.PI) / 180)
-  static SIN30DEG = Math.sin((30 * Math.PI) / 180)
+    static COS30DEG = Math.cos((30 * Math.PI) / 180)
+    static SIN30DEG = Math.sin((30 * Math.PI) / 180)
 
-  constructor(rayParameters = {}) {
-    super()
+    constructor(rayParameters = {}) {
+      super()
 
-    this.isLightningStrike = true
+      this.isLightningStrike = true
 
-    this.type = 'LightningStrike'
+      this.type = 'LightningStrike'
 
-    // Set parameters, and set undefined parameters to default values
-    this.init(LightningStrike.copyParameters(rayParameters, rayParameters))
+      // Set parameters, and set undefined parameters to default values
+      this.init(LightningStrike.copyParameters(rayParameters, rayParameters))
 
-    // Creates and populates the mesh
-    this.createMesh()
-  }
-
-  static createRandomGenerator() {
-    const numSeeds = 2053
-    const seeds = []
-
-    for (let i = 0; i < numSeeds; i++) {
-      seeds.push(Math.random())
+      // Creates and populates the mesh
+      this.createMesh()
     }
 
-    const generator = {
-      currentSeed: 0,
+    static createRandomGenerator() {
+      const numSeeds = 2053
+      const seeds = []
 
-      random: function () {
-        const value = seeds[generator.currentSeed]
+      for (let i = 0; i < numSeeds; i++) {
+        seeds.push(Math.random())
+      }
 
-        generator.currentSeed = (generator.currentSeed + 1) % numSeeds
+      const generator = {
+        currentSeed: 0,
 
-        return value
-      },
+        random: function () {
+          const value = seeds[generator.currentSeed]
 
-      getSeed: function () {
-        return generator.currentSeed / numSeeds
-      },
+          generator.currentSeed = (generator.currentSeed + 1) % numSeeds
 
-      setSeed: function (seed) {
-        generator.currentSeed = Math.floor(seed * numSeeds) % numSeeds
-      },
-    }
+          return value
+        },
 
-    return generator
-  }
+        getSeed: function () {
+          return generator.currentSeed / numSeeds
+        },
 
-  static copyParameters(dest = {}, source = {}) {
-    const vecCopy = function (v) {
-      if (source === dest) {
-        return v
-      } else {
-        return v.clone()
+        setSeed: function (seed) {
+          generator.currentSeed = Math.floor(seed * numSeeds) % numSeeds
+        },
       }
-    }
 
-    ;(dest.sourceOffset = source.sourceOffset !== undefined ? vecCopy(source.sourceOffset) : new Vector3(0, 100, 0)),
-      (dest.destOffset = source.destOffset !== undefined ? vecCopy(source.destOffset) : new Vector3(0, 0, 0)),
-      (dest.timeScale = source.timeScale !== undefined ? source.timeScale : 1),
-      (dest.roughness = source.roughness !== undefined ? source.roughness : 0.9),
-      (dest.straightness = source.straightness !== undefined ? source.straightness : 0.7),
-      (dest.up0 = source.up0 !== undefined ? vecCopy(source.up0) : new Vector3(0, 0, 1))
-    ;(dest.up1 = source.up1 !== undefined ? vecCopy(source.up1) : new Vector3(0, 0, 1)),
-      (dest.radius0 = source.radius0 !== undefined ? source.radius0 : 1),
-      (dest.radius1 = source.radius1 !== undefined ? source.radius1 : 1),
-      (dest.radius0Factor = source.radius0Factor !== undefined ? source.radius0Factor : 0.5),
-      (dest.radius1Factor = source.radius1Factor !== undefined ? source.radius1Factor : 0.2),
-      (dest.minRadius = source.minRadius !== undefined ? source.minRadius : 0.2),
-      // These parameters should not be changed after lightning creation. They can be changed but the ray will change its form abruptly:
-
-      (dest.isEternal =
-        source.isEternal !== undefined
-          ? source.isEternal
-          : source.birthTime === undefined || source.deathTime === undefined),
-      (dest.birthTime = source.birthTime),
-      (dest.deathTime = source.deathTime),
-      (dest.propagationTimeFactor = source.propagationTimeFactor !== undefined ? source.propagationTimeFactor : 0.1),
-      (dest.vanishingTimeFactor = source.vanishingTimeFactor !== undefined ? source.vanishingTimeFactor : 0.9),
-      (dest.subrayPeriod = source.subrayPeriod !== undefined ? source.subrayPeriod : 4),
-      (dest.subrayDutyCycle = source.subrayDutyCycle !== undefined ? source.subrayDutyCycle : 0.6)
-
-    // These parameters cannot change after lightning creation:
-
-    dest.maxIterations = source.maxIterations !== undefined ? source.maxIterations : 9
-    dest.isStatic = source.isStatic !== undefined ? source.isStatic : false
-    dest.ramification = source.ramification !== undefined ? source.ramification : 5
-    dest.maxSubrayRecursion = source.maxSubrayRecursion !== undefined ? source.maxSubrayRecursion : 3
-    dest.recursionProbability = source.recursionProbability !== undefined ? source.recursionProbability : 0.6
-    dest.generateUVs = source.generateUVs !== undefined ? source.generateUVs : false
-    ;(dest.randomGenerator = source.randomGenerator),
-      (dest.noiseSeed = source.noiseSeed),
-      (dest.onDecideSubrayCreation = source.onDecideSubrayCreation),
-      (dest.onSubrayCreation = source.onSubrayCreation)
-
-    return dest
-  }
+      return generator
+    }
 
-  update(time) {
-    if (this.isStatic) return
+    static copyParameters(dest = {}, source = {}) {
+      const vecCopy = function (v) {
+        if (source === dest) {
+          return v
+        } else {
+          return v.clone()
+        }
+      }
 
-    if (
-      this.rayParameters.isEternal ||
-      (this.rayParameters.birthTime <= time && time <= this.rayParameters.deathTime)
-    ) {
-      this.updateMesh(time)
+      ;(dest.sourceOffset = source.sourceOffset !== undefined ? vecCopy(source.sourceOffset) : new Vector3(0, 100, 0)),
+        (dest.destOffset = source.destOffset !== undefined ? vecCopy(source.destOffset) : new Vector3(0, 0, 0)),
+        (dest.timeScale = source.timeScale !== undefined ? source.timeScale : 1),
+        (dest.roughness = source.roughness !== undefined ? source.roughness : 0.9),
+        (dest.straightness = source.straightness !== undefined ? source.straightness : 0.7),
+        (dest.up0 = source.up0 !== undefined ? vecCopy(source.up0) : new Vector3(0, 0, 1))
+      ;(dest.up1 = source.up1 !== undefined ? vecCopy(source.up1) : new Vector3(0, 0, 1)),
+        (dest.radius0 = source.radius0 !== undefined ? source.radius0 : 1),
+        (dest.radius1 = source.radius1 !== undefined ? source.radius1 : 1),
+        (dest.radius0Factor = source.radius0Factor !== undefined ? source.radius0Factor : 0.5),
+        (dest.radius1Factor = source.radius1Factor !== undefined ? source.radius1Factor : 0.2),
+        (dest.minRadius = source.minRadius !== undefined ? source.minRadius : 0.2),
+        // These parameters should not be changed after lightning creation. They can be changed but the ray will change its form abruptly:
+
+        (dest.isEternal =
+          source.isEternal !== undefined
+            ? source.isEternal
+            : source.birthTime === undefined || source.deathTime === undefined),
+        (dest.birthTime = source.birthTime),
+        (dest.deathTime = source.deathTime),
+        (dest.propagationTimeFactor = source.propagationTimeFactor !== undefined ? source.propagationTimeFactor : 0.1),
+        (dest.vanishingTimeFactor = source.vanishingTimeFactor !== undefined ? source.vanishingTimeFactor : 0.9),
+        (dest.subrayPeriod = source.subrayPeriod !== undefined ? source.subrayPeriod : 4),
+        (dest.subrayDutyCycle = source.subrayDutyCycle !== undefined ? source.subrayDutyCycle : 0.6)
+
+      // These parameters cannot change after lightning creation:
+
+      dest.maxIterations = source.maxIterations !== undefined ? source.maxIterations : 9
+      dest.isStatic = source.isStatic !== undefined ? source.isStatic : false
+      dest.ramification = source.ramification !== undefined ? source.ramification : 5
+      dest.maxSubrayRecursion = source.maxSubrayRecursion !== undefined ? source.maxSubrayRecursion : 3
+      dest.recursionProbability = source.recursionProbability !== undefined ? source.recursionProbability : 0.6
+      dest.generateUVs = source.generateUVs !== undefined ? source.generateUVs : false
+      ;(dest.randomGenerator = source.randomGenerator),
+        (dest.noiseSeed = source.noiseSeed),
+        (dest.onDecideSubrayCreation = source.onDecideSubrayCreation),
+        (dest.onSubrayCreation = source.onSubrayCreation)
+
+      return dest
+    }
 
-      if (time < this.subrays[0].endPropagationTime) {
-        this.state = LightningStrike.RAY_PROPAGATING
-      } else if (time > this.subrays[0].beginVanishingTime) {
-        this.state = LightningStrike.RAY_VANISHING
-      } else {
-        this.state = LightningStrike.RAY_STEADY
-      }
+    update(time) {
+      if (this.isStatic) return
 
-      this.visible = true
-    } else {
-      this.visible = false
+      if (
+        this.rayParameters.isEternal ||
+        (this.rayParameters.birthTime <= time && time <= this.rayParameters.deathTime)
+      ) {
+        this.updateMesh(time)
+
+        if (time < this.subrays[0].endPropagationTime) {
+          this.state = LightningStrike.RAY_PROPAGATING
+        } else if (time > this.subrays[0].beginVanishingTime) {
+          this.state = LightningStrike.RAY_VANISHING
+        } else {
+          this.state = LightningStrike.RAY_STEADY
+        }
 
-      if (time < this.rayParameters.birthTime) {
-        this.state = LightningStrike.RAY_UNBORN
+        this.visible = true
       } else {
-        this.state = LightningStrike.RAY_EXTINGUISHED
+        this.visible = false
+
+        if (time < this.rayParameters.birthTime) {
+          this.state = LightningStrike.RAY_UNBORN
+        } else {
+          this.state = LightningStrike.RAY_EXTINGUISHED
+        }
       }
     }
-  }
 
-  init(rayParameters) {
-    // Init all the state from the parameters
-
-    this.rayParameters = rayParameters
-
-    // These parameters cannot change after lightning creation:
-
-    this.maxIterations = rayParameters.maxIterations !== undefined ? Math.floor(rayParameters.maxIterations) : 9
-    rayParameters.maxIterations = this.maxIterations
-    this.isStatic = rayParameters.isStatic !== undefined ? rayParameters.isStatic : false
-    rayParameters.isStatic = this.isStatic
-    this.ramification = rayParameters.ramification !== undefined ? Math.floor(rayParameters.ramification) : 5
-    rayParameters.ramification = this.ramification
-    this.maxSubrayRecursion =
-      rayParameters.maxSubrayRecursion !== undefined ? Math.floor(rayParameters.maxSubrayRecursion) : 3
-    rayParameters.maxSubrayRecursion = this.maxSubrayRecursion
-    this.recursionProbability =
-      rayParameters.recursionProbability !== undefined ? rayParameters.recursionProbability : 0.6
-    rayParameters.recursionProbability = this.recursionProbability
-    this.generateUVs = rayParameters.generateUVs !== undefined ? rayParameters.generateUVs : false
-    rayParameters.generateUVs = this.generateUVs
-
-    // Random generator
-    if (rayParameters.randomGenerator !== undefined) {
-      this.randomGenerator = rayParameters.randomGenerator
-      this.seedGenerator = rayParameters.randomGenerator
-
-      if (rayParameters.noiseSeed !== undefined) {
-        this.seedGenerator.setSeed(rayParameters.noiseSeed)
+    init(rayParameters) {
+      // Init all the state from the parameters
+
+      this.rayParameters = rayParameters
+
+      // These parameters cannot change after lightning creation:
+
+      this.maxIterations = rayParameters.maxIterations !== undefined ? Math.floor(rayParameters.maxIterations) : 9
+      rayParameters.maxIterations = this.maxIterations
+      this.isStatic = rayParameters.isStatic !== undefined ? rayParameters.isStatic : false
+      rayParameters.isStatic = this.isStatic
+      this.ramification = rayParameters.ramification !== undefined ? Math.floor(rayParameters.ramification) : 5
+      rayParameters.ramification = this.ramification
+      this.maxSubrayRecursion =
+        rayParameters.maxSubrayRecursion !== undefined ? Math.floor(rayParameters.maxSubrayRecursion) : 3
+      rayParameters.maxSubrayRecursion = this.maxSubrayRecursion
+      this.recursionProbability =
+        rayParameters.recursionProbability !== undefined ? rayParameters.recursionProbability : 0.6
+      rayParameters.recursionProbability = this.recursionProbability
+      this.generateUVs = rayParameters.generateUVs !== undefined ? rayParameters.generateUVs : false
+      rayParameters.generateUVs = this.generateUVs
+
+      // Random generator
+      if (rayParameters.randomGenerator !== undefined) {
+        this.randomGenerator = rayParameters.randomGenerator
+        this.seedGenerator = rayParameters.randomGenerator
+
+        if (rayParameters.noiseSeed !== undefined) {
+          this.seedGenerator.setSeed(rayParameters.noiseSeed)
+        }
+      } else {
+        this.randomGenerator = LightningStrike.createRandomGenerator()
+        this.seedGenerator = Math
       }
-    } else {
-      this.randomGenerator = LightningStrike.createRandomGenerator()
-      this.seedGenerator = Math
-    }
 
-    // Ray creation callbacks
-    if (rayParameters.onDecideSubrayCreation !== undefined) {
-      this.onDecideSubrayCreation = rayParameters.onDecideSubrayCreation
-    } else {
-      this.createDefaultSubrayCreationCallbacks()
+      // Ray creation callbacks
+      if (rayParameters.onDecideSubrayCreation !== undefined) {
+        this.onDecideSubrayCreation = rayParameters.onDecideSubrayCreation
+      } else {
+        this.createDefaultSubrayCreationCallbacks()
 
-      if (rayParameters.onSubrayCreation !== undefined) {
-        this.onSubrayCreation = rayParameters.onSubrayCreation
+        if (rayParameters.onSubrayCreation !== undefined) {
+          this.onSubrayCreation = rayParameters.onSubrayCreation
+        }
       }
-    }
 
-    // Internal state
+      // Internal state
 
-    this.state = LightningStrike.RAY_INITIALIZED
+      this.state = LightningStrike.RAY_INITIALIZED
 
-    this.maxSubrays = Math.ceil(1 + Math.pow(this.ramification, Math.max(0, this.maxSubrayRecursion - 1)))
-    rayParameters.maxSubrays = this.maxSubrays
+      this.maxSubrays = Math.ceil(1 + Math.pow(this.ramification, Math.max(0, this.maxSubrayRecursion - 1)))
+      rayParameters.maxSubrays = this.maxSubrays
 
-    this.maxRaySegments = 2 * (1 << this.maxIterations)
+      this.maxRaySegments = 2 * (1 << this.maxIterations)
 
-    this.subrays = []
+      this.subrays = []
 
-    for (let i = 0; i < this.maxSubrays; i++) {
-      this.subrays.push(this.createSubray())
-    }
+      for (let i = 0; i < this.maxSubrays; i++) {
+        this.subrays.push(this.createSubray())
+      }
+
+      this.raySegments = []
 
-    this.raySegments = []
+      for (let i = 0; i < this.maxRaySegments; i++) {
+        this.raySegments.push(this.createSegment())
+      }
 
-    for (let i = 0; i < this.maxRaySegments; i++) {
-      this.raySegments.push(this.createSegment())
+      this.time = 0
+      this.timeFraction = 0
+      this.currentSegmentCallback = null
+      this.currentCreateTriangleVertices = this.generateUVs
+        ? this.createTriangleVerticesWithUVs
+        : this.createTriangleVerticesWithoutUVs
+      this.numSubrays = 0
+      this.currentSubray = null
+      this.currentSegmentIndex = 0
+      this.isInitialSegment = false
+      this.subrayProbability = 0
+
+      this.currentVertex = 0
+      this.currentIndex = 0
+      this.currentCoordinate = 0
+      this.currentUVCoordinate = 0
+      this.vertices = null
+      this.uvs = null
+      this.indices = null
+      this.positionAttribute = null
+      this.uvsAttribute = null
+
+      this.simplexX = new SimplexNoise(this.seedGenerator)
+      this.simplexY = new SimplexNoise(this.seedGenerator)
+      this.simplexZ = new SimplexNoise(this.seedGenerator)
+
+      // Temp vectors
+      this.forwards = new Vector3()
+      this.forwardsFill = new Vector3()
+      this.side = new Vector3()
+      this.down = new Vector3()
+      this.middlePos = new Vector3()
+      this.middleLinPos = new Vector3()
+      this.newPos = new Vector3()
+      this.vPos = new Vector3()
+      this.cross1 = new Vector3()
     }
 
-    this.time = 0
-    this.timeFraction = 0
-    this.currentSegmentCallback = null
-    this.currentCreateTriangleVertices = this.generateUVs
-      ? this.createTriangleVerticesWithUVs
-      : this.createTriangleVerticesWithoutUVs
-    this.numSubrays = 0
-    this.currentSubray = null
-    this.currentSegmentIndex = 0
-    this.isInitialSegment = false
-    this.subrayProbability = 0
-
-    this.currentVertex = 0
-    this.currentIndex = 0
-    this.currentCoordinate = 0
-    this.currentUVCoordinate = 0
-    this.vertices = null
-    this.uvs = null
-    this.indices = null
-    this.positionAttribute = null
-    this.uvsAttribute = null
-
-    this.simplexX = new SimplexNoise(this.seedGenerator)
-    this.simplexY = new SimplexNoise(this.seedGenerator)
-    this.simplexZ = new SimplexNoise(this.seedGenerator)
-
-    // Temp vectors
-    this.forwards = new Vector3()
-    this.forwardsFill = new Vector3()
-    this.side = new Vector3()
-    this.down = new Vector3()
-    this.middlePos = new Vector3()
-    this.middleLinPos = new Vector3()
-    this.newPos = new Vector3()
-    this.vPos = new Vector3()
-    this.cross1 = new Vector3()
-  }
+    createMesh() {
+      const maxDrawableSegmentsPerSubRay = 1 << this.maxIterations
 
-  createMesh() {
-    const maxDrawableSegmentsPerSubRay = 1 << this.maxIterations
+      const maxVerts = 3 * (maxDrawableSegmentsPerSubRay + 1) * this.maxSubrays
+      const maxIndices = 18 * maxDrawableSegmentsPerSubRay * this.maxSubrays
 
-    const maxVerts = 3 * (maxDrawableSegmentsPerSubRay + 1) * this.maxSubrays
-    const maxIndices = 18 * maxDrawableSegmentsPerSubRay * this.maxSubrays
+      this.vertices = new Float32Array(maxVerts * 3)
+      this.indices = new Uint32Array(maxIndices)
 
-    this.vertices = new Float32Array(maxVerts * 3)
-    this.indices = new Uint32Array(maxIndices)
+      if (this.generateUVs) {
+        this.uvs = new Float32Array(maxVerts * 2)
+      }
 
-    if (this.generateUVs) {
-      this.uvs = new Float32Array(maxVerts * 2)
-    }
+      // Populate the mesh
+      this.fillMesh(0)
 
-    // Populate the mesh
-    this.fillMesh(0)
+      this.setIndex(new Uint32BufferAttribute(this.indices, 1))
 
-    this.setIndex(new Uint32BufferAttribute(this.indices, 1))
+      this.positionAttribute = new Float32BufferAttribute(this.vertices, 3)
+      this.setAttribute('position', this.positionAttribute)
 
-    this.positionAttribute = new Float32BufferAttribute(this.vertices, 3)
-    this.setAttribute('position', this.positionAttribute)
+      if (this.generateUVs) {
+        this.uvsAttribute = new Float32BufferAttribute(new Float32Array(this.uvs), 2)
+        this.setAttribute('uv', this.uvsAttribute)
+      }
 
-    if (this.generateUVs) {
-      this.uvsAttribute = new Float32BufferAttribute(new Float32Array(this.uvs), 2)
-      this.setAttribute('uv', this.uvsAttribute)
-    }
+      if (!this.isStatic) {
+        this.index.usage = DynamicDrawUsage
+        this.positionAttribute.usage = DynamicDrawUsage
 
-    if (!this.isStatic) {
-      this.index.usage = DynamicDrawUsage
-      this.positionAttribute.usage = DynamicDrawUsage
+        if (this.generateUVs) {
+          this.uvsAttribute.usage = DynamicDrawUsage
+        }
+      }
+
+      // Store buffers for later modification
+      this.vertices = this.positionAttribute.array
+      this.indices = this.index.array
 
       if (this.generateUVs) {
-        this.uvsAttribute.usage = DynamicDrawUsage
+        this.uvs = this.uvsAttribute.array
       }
     }
 
-    // Store buffers for later modification
-    this.vertices = this.positionAttribute.array
-    this.indices = this.index.array
+    updateMesh(time) {
+      this.fillMesh(time)
 
-    if (this.generateUVs) {
-      this.uvs = this.uvsAttribute.array
-    }
-  }
+      this.drawRange.count = this.currentIndex
 
-  updateMesh(time) {
-    this.fillMesh(time)
+      this.index.needsUpdate = true
 
-    this.drawRange.count = this.currentIndex
+      this.positionAttribute.needsUpdate = true
 
-    this.index.needsUpdate = true
+      if (this.generateUVs) {
+        this.uvsAttribute.needsUpdate = true
+      }
+    }
 
-    this.positionAttribute.needsUpdate = true
+    fillMesh(time) {
+      const scope = this
 
-    if (this.generateUVs) {
-      this.uvsAttribute.needsUpdate = true
-    }
-  }
+      this.currentVertex = 0
+      this.currentIndex = 0
+      this.currentCoordinate = 0
+      this.currentUVCoordinate = 0
 
-  fillMesh(time) {
-    const scope = this
+      this.fractalRay(time, function fillVertices(segment) {
+        const subray = scope.currentSubray
 
-    this.currentVertex = 0
-    this.currentIndex = 0
-    this.currentCoordinate = 0
-    this.currentUVCoordinate = 0
+        if (time < subray.birthTime) {
+          //&& ( ! this.rayParameters.isEternal || scope.currentSubray.recursion > 0 ) ) {
 
-    this.fractalRay(time, function fillVertices(segment) {
-      const subray = scope.currentSubray
+          return
+        } else if (this.rayParameters.isEternal && scope.currentSubray.recursion == 0) {
+          // Eternal rays don't propagate nor vanish, but its subrays do
 
-      if (time < subray.birthTime) {
-        //&& ( ! this.rayParameters.isEternal || scope.currentSubray.recursion > 0 ) ) {
+          scope.createPrism(segment)
 
-        return
-      } else if (this.rayParameters.isEternal && scope.currentSubray.recursion == 0) {
-        // Eternal rays don't propagate nor vanish, but its subrays do
+          scope.onDecideSubrayCreation(segment, scope)
+        } else if (time < subray.endPropagationTime) {
+          if (scope.timeFraction >= segment.fraction0 * subray.propagationTimeFactor) {
+            // Ray propagation has arrived to this segment
 
-        scope.createPrism(segment)
+            scope.createPrism(segment)
 
-        scope.onDecideSubrayCreation(segment, scope)
-      } else if (time < subray.endPropagationTime) {
-        if (scope.timeFraction >= segment.fraction0 * subray.propagationTimeFactor) {
-          // Ray propagation has arrived to this segment
+            scope.onDecideSubrayCreation(segment, scope)
+          }
+        } else if (time < subray.beginVanishingTime) {
+          // Ray is steady (nor propagating nor vanishing)
 
           scope.createPrism(segment)
 
+          scope.onDecideSubrayCreation(segment, scope)
+        } else {
+          if (scope.timeFraction <= subray.vanishingTimeFactor + segment.fraction1 * (1 - subray.vanishingTimeFactor)) {
+            // Segment has not yet vanished
+
+            scope.createPrism(segment)
+          }
+
           scope.onDecideSubrayCreation(segment, scope)
         }
-      } else if (time < subray.beginVanishingTime) {
-        // Ray is steady (nor propagating nor vanishing)
+      })
+    }
 
-        scope.createPrism(segment)
+    addNewSubray(/*rayParameters*/) {
+      return this.subrays[this.numSubrays++]
+    }
 
-        scope.onDecideSubrayCreation(segment, scope)
-      } else {
-        if (scope.timeFraction <= subray.vanishingTimeFactor + segment.fraction1 * (1 - subray.vanishingTimeFactor)) {
-          // Segment has not yet vanished
+    initSubray(subray, rayParameters) {
+      subray.pos0.copy(rayParameters.sourceOffset)
+      subray.pos1.copy(rayParameters.destOffset)
+      subray.up0.copy(rayParameters.up0)
+      subray.up1.copy(rayParameters.up1)
+      subray.radius0 = rayParameters.radius0
+      subray.radius1 = rayParameters.radius1
+      subray.birthTime = rayParameters.birthTime
+      subray.deathTime = rayParameters.deathTime
+      subray.timeScale = rayParameters.timeScale
+      subray.roughness = rayParameters.roughness
+      subray.straightness = rayParameters.straightness
+      subray.propagationTimeFactor = rayParameters.propagationTimeFactor
+      subray.vanishingTimeFactor = rayParameters.vanishingTimeFactor
+
+      subray.maxIterations = this.maxIterations
+      subray.seed = rayParameters.noiseSeed !== undefined ? rayParameters.noiseSeed : 0
+      subray.recursion = 0
+    }
 
-          scope.createPrism(segment)
-        }
+    fractalRay(time, segmentCallback) {
+      this.time = time
+      this.currentSegmentCallback = segmentCallback
+      this.numSubrays = 0
 
-        scope.onDecideSubrayCreation(segment, scope)
-      }
-    })
-  }
+      // Add the top level subray
+      this.initSubray(this.addNewSubray(), this.rayParameters)
 
-  addNewSubray(/*rayParameters*/) {
-    return this.subrays[this.numSubrays++]
-  }
+      // Process all subrays that are being generated until consuming all of them
+      for (let subrayIndex = 0; subrayIndex < this.numSubrays; subrayIndex++) {
+        const subray = this.subrays[subrayIndex]
+        this.currentSubray = subray
 
-  initSubray(subray, rayParameters) {
-    subray.pos0.copy(rayParameters.sourceOffset)
-    subray.pos1.copy(rayParameters.destOffset)
-    subray.up0.copy(rayParameters.up0)
-    subray.up1.copy(rayParameters.up1)
-    subray.radius0 = rayParameters.radius0
-    subray.radius1 = rayParameters.radius1
-    subray.birthTime = rayParameters.birthTime
-    subray.deathTime = rayParameters.deathTime
-    subray.timeScale = rayParameters.timeScale
-    subray.roughness = rayParameters.roughness
-    subray.straightness = rayParameters.straightness
-    subray.propagationTimeFactor = rayParameters.propagationTimeFactor
-    subray.vanishingTimeFactor = rayParameters.vanishingTimeFactor
-
-    subray.maxIterations = this.maxIterations
-    subray.seed = rayParameters.noiseSeed !== undefined ? rayParameters.noiseSeed : 0
-    subray.recursion = 0
-  }
+        this.randomGenerator.setSeed(subray.seed)
 
-  fractalRay(time, segmentCallback) {
-    this.time = time
-    this.currentSegmentCallback = segmentCallback
-    this.numSubrays = 0
+        subray.endPropagationTime = MathUtils.lerp(subray.birthTime, subray.deathTime, subray.propagationTimeFactor)
+        subray.beginVanishingTime = MathUtils.lerp(subray.deathTime, subray.birthTime, 1 - subray.vanishingTimeFactor)
 
-    // Add the top level subray
-    this.initSubray(this.addNewSubray(), this.rayParameters)
+        const random1 = this.randomGenerator.random
+        subray.linPos0.set(random1(), random1(), random1()).multiplyScalar(1000)
+        subray.linPos1.set(random1(), random1(), random1()).multiplyScalar(1000)
 
-    // Process all subrays that are being generated until consuming all of them
-    for (let subrayIndex = 0; subrayIndex < this.numSubrays; subrayIndex++) {
-      const subray = this.subrays[subrayIndex]
-      this.currentSubray = subray
+        this.timeFraction = (time - subray.birthTime) / (subray.deathTime - subray.birthTime)
 
-      this.randomGenerator.setSeed(subray.seed)
+        this.currentSegmentIndex = 0
+        this.isInitialSegment = true
 
-      subray.endPropagationTime = MathUtils.lerp(subray.birthTime, subray.deathTime, subray.propagationTimeFactor)
-      subray.beginVanishingTime = MathUtils.lerp(subray.deathTime, subray.birthTime, 1 - subray.vanishingTimeFactor)
+        const segment = this.getNewSegment()
+        segment.iteration = 0
+        segment.pos0.copy(subray.pos0)
+        segment.pos1.copy(subray.pos1)
+        segment.linPos0.copy(subray.linPos0)
+        segment.linPos1.copy(subray.linPos1)
+        segment.up0.copy(subray.up0)
+        segment.up1.copy(subray.up1)
+        segment.radius0 = subray.radius0
+        segment.radius1 = subray.radius1
+        segment.fraction0 = 0
+        segment.fraction1 = 1
+        segment.positionVariationFactor = 1 - subray.straightness
 
-      const random1 = this.randomGenerator.random
-      subray.linPos0.set(random1(), random1(), random1()).multiplyScalar(1000)
-      subray.linPos1.set(random1(), random1(), random1()).multiplyScalar(1000)
+        this.subrayProbability =
+          (this.ramification * Math.pow(this.recursionProbability, subray.recursion)) / (1 << subray.maxIterations)
 
-      this.timeFraction = (time - subray.birthTime) / (subray.deathTime - subray.birthTime)
+        this.fractalRayRecursive(segment)
+      }
 
-      this.currentSegmentIndex = 0
-      this.isInitialSegment = true
-
-      const segment = this.getNewSegment()
-      segment.iteration = 0
-      segment.pos0.copy(subray.pos0)
-      segment.pos1.copy(subray.pos1)
-      segment.linPos0.copy(subray.linPos0)
-      segment.linPos1.copy(subray.linPos1)
-      segment.up0.copy(subray.up0)
-      segment.up1.copy(subray.up1)
-      segment.radius0 = subray.radius0
-      segment.radius1 = subray.radius1
-      segment.fraction0 = 0
-      segment.fraction1 = 1
-      segment.positionVariationFactor = 1 - subray.straightness
-
-      this.subrayProbability =
-        (this.ramification * Math.pow(this.recursionProbability, subray.recursion)) / (1 << subray.maxIterations)
-
-      this.fractalRayRecursive(segment)
+      this.currentSegmentCallback = null
+      this.currentSubray = null
     }
 
-    this.currentSegmentCallback = null
-    this.currentSubray = null
-  }
+    fractalRayRecursive(segment) {
+      // Leave recursion condition
+      if (segment.iteration >= this.currentSubray.maxIterations) {
+        this.currentSegmentCallback(segment)
 
-  fractalRayRecursive(segment) {
-    // Leave recursion condition
-    if (segment.iteration >= this.currentSubray.maxIterations) {
-      this.currentSegmentCallback(segment)
+        return
+      }
 
-      return
-    }
+      // Interpolation
+      this.forwards.subVectors(segment.pos1, segment.pos0)
+      let lForwards = this.forwards.length()
 
-    // Interpolation
-    this.forwards.subVectors(segment.pos1, segment.pos0)
-    let lForwards = this.forwards.length()
+      if (lForwards < 0.000001) {
+        this.forwards.set(0, 0, 0.01)
+        lForwards = this.forwards.length()
+      }
 
-    if (lForwards < 0.000001) {
-      this.forwards.set(0, 0, 0.01)
-      lForwards = this.forwards.length()
+      const middleRadius = (segment.radius0 + segment.radius1) * 0.5
+      const middleFraction = (segment.fraction0 + segment.fraction1) * 0.5
+
+      const timeDimension = this.time * this.currentSubray.timeScale * Math.pow(2, segment.iteration)
+
+      this.middlePos.lerpVectors(segment.pos0, segment.pos1, 0.5)
+      this.middleLinPos.lerpVectors(segment.linPos0, segment.linPos1, 0.5)
+      const p = this.middleLinPos
+
+      // Noise
+      this.newPos.set(
+        this.simplexX.noise4d(p.x, p.y, p.z, timeDimension),
+        this.simplexY.noise4d(p.x, p.y, p.z, timeDimension),
+        this.simplexZ.noise4d(p.x, p.y, p.z, timeDimension),
+      )
+
+      this.newPos.multiplyScalar(segment.positionVariationFactor * lForwards)
+      this.newPos.add(this.middlePos)
+
+      // Recursion
+
+      const newSegment1 = this.getNewSegment()
+      newSegment1.pos0.copy(segment.pos0)
+      newSegment1.pos1.copy(this.newPos)
+      newSegment1.linPos0.copy(segment.linPos0)
+      newSegment1.linPos1.copy(this.middleLinPos)
+      newSegment1.up0.copy(segment.up0)
+      newSegment1.up1.copy(segment.up1)
+      newSegment1.radius0 = segment.radius0
+      newSegment1.radius1 = middleRadius
+      newSegment1.fraction0 = segment.fraction0
+      newSegment1.fraction1 = middleFraction
+      newSegment1.positionVariationFactor = segment.positionVariationFactor * this.currentSubray.roughness
+      newSegment1.iteration = segment.iteration + 1
+
+      const newSegment2 = this.getNewSegment()
+      newSegment2.pos0.copy(this.newPos)
+      newSegment2.pos1.copy(segment.pos1)
+      newSegment2.linPos0.copy(this.middleLinPos)
+      newSegment2.linPos1.copy(segment.linPos1)
+      this.cross1.crossVectors(segment.up0, this.forwards.normalize())
+      newSegment2.up0.crossVectors(this.forwards, this.cross1).normalize()
+      newSegment2.up1.copy(segment.up1)
+      newSegment2.radius0 = middleRadius
+      newSegment2.radius1 = segment.radius1
+      newSegment2.fraction0 = middleFraction
+      newSegment2.fraction1 = segment.fraction1
+      newSegment2.positionVariationFactor = segment.positionVariationFactor * this.currentSubray.roughness
+      newSegment2.iteration = segment.iteration + 1
+
+      this.fractalRayRecursive(newSegment1)
+
+      this.fractalRayRecursive(newSegment2)
     }
 
-    const middleRadius = (segment.radius0 + segment.radius1) * 0.5
-    const middleFraction = (segment.fraction0 + segment.fraction1) * 0.5
-
-    const timeDimension = this.time * this.currentSubray.timeScale * Math.pow(2, segment.iteration)
-
-    this.middlePos.lerpVectors(segment.pos0, segment.pos1, 0.5)
-    this.middleLinPos.lerpVectors(segment.linPos0, segment.linPos1, 0.5)
-    const p = this.middleLinPos
-
-    // Noise
-    this.newPos.set(
-      this.simplexX.noise4d(p.x, p.y, p.z, timeDimension),
-      this.simplexY.noise4d(p.x, p.y, p.z, timeDimension),
-      this.simplexZ.noise4d(p.x, p.y, p.z, timeDimension),
-    )
-
-    this.newPos.multiplyScalar(segment.positionVariationFactor * lForwards)
-    this.newPos.add(this.middlePos)
-
-    // Recursion
-
-    const newSegment1 = this.getNewSegment()
-    newSegment1.pos0.copy(segment.pos0)
-    newSegment1.pos1.copy(this.newPos)
-    newSegment1.linPos0.copy(segment.linPos0)
-    newSegment1.linPos1.copy(this.middleLinPos)
-    newSegment1.up0.copy(segment.up0)
-    newSegment1.up1.copy(segment.up1)
-    newSegment1.radius0 = segment.radius0
-    newSegment1.radius1 = middleRadius
-    newSegment1.fraction0 = segment.fraction0
-    newSegment1.fraction1 = middleFraction
-    newSegment1.positionVariationFactor = segment.positionVariationFactor * this.currentSubray.roughness
-    newSegment1.iteration = segment.iteration + 1
-
-    const newSegment2 = this.getNewSegment()
-    newSegment2.pos0.copy(this.newPos)
-    newSegment2.pos1.copy(segment.pos1)
-    newSegment2.linPos0.copy(this.middleLinPos)
-    newSegment2.linPos1.copy(segment.linPos1)
-    this.cross1.crossVectors(segment.up0, this.forwards.normalize())
-    newSegment2.up0.crossVectors(this.forwards, this.cross1).normalize()
-    newSegment2.up1.copy(segment.up1)
-    newSegment2.radius0 = middleRadius
-    newSegment2.radius1 = segment.radius1
-    newSegment2.fraction0 = middleFraction
-    newSegment2.fraction1 = segment.fraction1
-    newSegment2.positionVariationFactor = segment.positionVariationFactor * this.currentSubray.roughness
-    newSegment2.iteration = segment.iteration + 1
-
-    this.fractalRayRecursive(newSegment1)
-
-    this.fractalRayRecursive(newSegment2)
-  }
-
-  createPrism(segment) {
-    // Creates one triangular prism and its vertices at the segment
+    createPrism(segment) {
+      // Creates one triangular prism and its vertices at the segment
 
-    this.forwardsFill.subVectors(segment.pos1, segment.pos0).normalize()
+      this.forwardsFill.subVectors(segment.pos1, segment.pos0).normalize()
 
-    if (this.isInitialSegment) {
-      this.currentCreateTriangleVertices(segment.pos0, segment.up0, this.forwardsFill, segment.radius0, 0)
+      if (this.isInitialSegment) {
+        this.currentCreateTriangleVertices(segment.pos0, segment.up0, this.forwardsFill, segment.radius0, 0)
 
-      this.isInitialSegment = false
-    }
+        this.isInitialSegment = false
+      }
 
-    this.currentCreateTriangleVertices(segment.pos1, segment.up0, this.forwardsFill, segment.radius1, segment.fraction1)
+      this.currentCreateTriangleVertices(
+        segment.pos1,
+        segment.up0,
+        this.forwardsFill,
+        segment.radius1,
+        segment.fraction1,
+      )
 
-    this.createPrismFaces()
-  }
+      this.createPrismFaces()
+    }
 
-  createTriangleVerticesWithoutUVs(pos, up, forwards, radius) {
-    // Create an equilateral triangle (only vertices)
+    createTriangleVerticesWithoutUVs(pos, up, forwards, radius) {
+      // Create an equilateral triangle (only vertices)
 
-    this.side.crossVectors(up, forwards).multiplyScalar(radius * LightningStrike.COS30DEG)
-    this.down.copy(up).multiplyScalar(-radius * LightningStrike.SIN30DEG)
+      this.side.crossVectors(up, forwards).multiplyScalar(radius * LightningStrike.COS30DEG)
+      this.down.copy(up).multiplyScalar(-radius * LightningStrike.SIN30DEG)
 
-    const p = this.vPos
-    const v = this.vertices
+      const p = this.vPos
+      const v = this.vertices
 
-    p.copy(pos).sub(this.side).add(this.down)
+      p.copy(pos).sub(this.side).add(this.down)
 
-    v[this.currentCoordinate++] = p.x
-    v[this.currentCoordinate++] = p.y
-    v[this.currentCoordinate++] = p.z
+      v[this.currentCoordinate++] = p.x
+      v[this.currentCoordinate++] = p.y
+      v[this.currentCoordinate++] = p.z
 
-    p.copy(pos).add(this.side).add(this.down)
+      p.copy(pos).add(this.side).add(this.down)
 
-    v[this.currentCoordinate++] = p.x
-    v[this.currentCoordinate++] = p.y
-    v[this.currentCoordinate++] = p.z
+      v[this.currentCoordinate++] = p.x
+      v[this.currentCoordinate++] = p.y
+      v[this.currentCoordinate++] = p.z
 
-    p.copy(up).multiplyScalar(radius).add(pos)
+      p.copy(up).multiplyScalar(radius).add(pos)
 
-    v[this.currentCoordinate++] = p.x
-    v[this.currentCoordinate++] = p.y
-    v[this.currentCoordinate++] = p.z
+      v[this.currentCoordinate++] = p.x
+      v[this.currentCoordinate++] = p.y
+      v[this.currentCoordinate++] = p.z
 
-    this.currentVertex += 3
-  }
+      this.currentVertex += 3
+    }
 
-  createTriangleVerticesWithUVs(pos, up, forwards, radius, u) {
-    // Create an equilateral triangle (only vertices)
+    createTriangleVerticesWithUVs(pos, up, forwards, radius, u) {
+      // Create an equilateral triangle (only vertices)
 
-    this.side.crossVectors(up, forwards).multiplyScalar(radius * LightningStrike.COS30DEG)
-    this.down.copy(up).multiplyScalar(-radius * LightningStrike.SIN30DEG)
+      this.side.crossVectors(up, forwards).multiplyScalar(radius * LightningStrike.COS30DEG)
+      this.down.copy(up).multiplyScalar(-radius * LightningStrike.SIN30DEG)
 
-    const p = this.vPos
-    const v = this.vertices
-    const uv = this.uvs
+      const p = this.vPos
+      const v = this.vertices
+      const uv = this.uvs
 
-    p.copy(pos).sub(this.side).add(this.down)
+      p.copy(pos).sub(this.side).add(this.down)
 
-    v[this.currentCoordinate++] = p.x
-    v[this.currentCoordinate++] = p.y
-    v[this.currentCoordinate++] = p.z
+      v[this.currentCoordinate++] = p.x
+      v[this.currentCoordinate++] = p.y
+      v[this.currentCoordinate++] = p.z
 
-    uv[this.currentUVCoordinate++] = u
-    uv[this.currentUVCoordinate++] = 0
+      uv[this.currentUVCoordinate++] = u
+      uv[this.currentUVCoordinate++] = 0
 
-    p.copy(pos).add(this.side).add(this.down)
+      p.copy(pos).add(this.side).add(this.down)
 
-    v[this.currentCoordinate++] = p.x
-    v[this.currentCoordinate++] = p.y
-    v[this.currentCoordinate++] = p.z
+      v[this.currentCoordinate++] = p.x
+      v[this.currentCoordinate++] = p.y
+      v[this.currentCoordinate++] = p.z
 
-    uv[this.currentUVCoordinate++] = u
-    uv[this.currentUVCoordinate++] = 0.5
+      uv[this.currentUVCoordinate++] = u
+      uv[this.currentUVCoordinate++] = 0.5
 
-    p.copy(up).multiplyScalar(radius).add(pos)
+      p.copy(up).multiplyScalar(radius).add(pos)
 
-    v[this.currentCoordinate++] = p.x
-    v[this.currentCoordinate++] = p.y
-    v[this.currentCoordinate++] = p.z
+      v[this.currentCoordinate++] = p.x
+      v[this.currentCoordinate++] = p.y
+      v[this.currentCoordinate++] = p.z
 
-    uv[this.currentUVCoordinate++] = u
-    uv[this.currentUVCoordinate++] = 1
+      uv[this.currentUVCoordinate++] = u
+      uv[this.currentUVCoordinate++] = 1
 
-    this.currentVertex += 3
-  }
+      this.currentVertex += 3
+    }
 
-  createPrismFaces(vertex /*, index*/) {
-    const indices = this.indices
-    vertex = this.currentVertex - 6
-
-    indices[this.currentIndex++] = vertex + 1
-    indices[this.currentIndex++] = vertex + 2
-    indices[this.currentIndex++] = vertex + 5
-    indices[this.currentIndex++] = vertex + 1
-    indices[this.currentIndex++] = vertex + 5
-    indices[this.currentIndex++] = vertex + 4
-    indices[this.currentIndex++] = vertex + 0
-    indices[this.currentIndex++] = vertex + 1
-    indices[this.currentIndex++] = vertex + 4
-    indices[this.currentIndex++] = vertex + 0
-    indices[this.currentIndex++] = vertex + 4
-    indices[this.currentIndex++] = vertex + 3
-    indices[this.currentIndex++] = vertex + 2
-    indices[this.currentIndex++] = vertex + 0
-    indices[this.currentIndex++] = vertex + 3
-    indices[this.currentIndex++] = vertex + 2
-    indices[this.currentIndex++] = vertex + 3
-    indices[this.currentIndex++] = vertex + 5
-  }
+    createPrismFaces(vertex /*, index*/) {
+      const indices = this.indices
+      vertex = this.currentVertex - 6
+
+      indices[this.currentIndex++] = vertex + 1
+      indices[this.currentIndex++] = vertex + 2
+      indices[this.currentIndex++] = vertex + 5
+      indices[this.currentIndex++] = vertex + 1
+      indices[this.currentIndex++] = vertex + 5
+      indices[this.currentIndex++] = vertex + 4
+      indices[this.currentIndex++] = vertex + 0
+      indices[this.currentIndex++] = vertex + 1
+      indices[this.currentIndex++] = vertex + 4
+      indices[this.currentIndex++] = vertex + 0
+      indices[this.currentIndex++] = vertex + 4
+      indices[this.currentIndex++] = vertex + 3
+      indices[this.currentIndex++] = vertex + 2
+      indices[this.currentIndex++] = vertex + 0
+      indices[this.currentIndex++] = vertex + 3
+      indices[this.currentIndex++] = vertex + 2
+      indices[this.currentIndex++] = vertex + 3
+      indices[this.currentIndex++] = vertex + 5
+    }
 
-  createDefaultSubrayCreationCallbacks() {
-    const random1 = this.randomGenerator.random
+    createDefaultSubrayCreationCallbacks() {
+      const random1 = this.randomGenerator.random
 
-    this.onDecideSubrayCreation = function (segment, lightningStrike) {
-      // Decide subrays creation at parent (sub)ray segment
+      this.onDecideSubrayCreation = function (segment, lightningStrike) {
+        // Decide subrays creation at parent (sub)ray segment
 
-      const subray = lightningStrike.currentSubray
+        const subray = lightningStrike.currentSubray
 
-      const period = lightningStrike.rayParameters.subrayPeriod
-      const dutyCycle = lightningStrike.rayParameters.subrayDutyCycle
+        const period = lightningStrike.rayParameters.subrayPeriod
+        const dutyCycle = lightningStrike.rayParameters.subrayDutyCycle
 
-      const phase0 =
-        lightningStrike.rayParameters.isEternal && subray.recursion == 0
-          ? -random1() * period
-          : MathUtils.lerp(subray.birthTime, subray.endPropagationTime, segment.fraction0) - random1() * period
+        const phase0 =
+          lightningStrike.rayParameters.isEternal && subray.recursion == 0
+            ? -random1() * period
+            : MathUtils.lerp(subray.birthTime, subray.endPropagationTime, segment.fraction0) - random1() * period
 
-      const phase = lightningStrike.time - phase0
-      const currentCycle = Math.floor(phase / period)
+        const phase = lightningStrike.time - phase0
+        const currentCycle = Math.floor(phase / period)
 
-      const childSubraySeed = random1() * (currentCycle + 1)
+        const childSubraySeed = random1() * (currentCycle + 1)
 
-      const isActive = phase % period <= dutyCycle * period
+        const isActive = phase % period <= dutyCycle * period
 
-      let probability = 0
+        let probability = 0
 
-      if (isActive) {
-        probability = lightningStrike.subrayProbability
-        // Distribution test: probability *= segment.fraction0 > 0.5 && segment.fraction0 < 0.9 ? 1 / 0.4 : 0;
-      }
+        if (isActive) {
+          probability = lightningStrike.subrayProbability
+          // Distribution test: probability *= segment.fraction0 > 0.5 && segment.fraction0 < 0.9 ? 1 / 0.4 : 0;
+        }
 
-      if (
-        subray.recursion < lightningStrike.maxSubrayRecursion &&
-        lightningStrike.numSubrays < lightningStrike.maxSubrays &&
-        random1() < probability
-      ) {
-        const childSubray = lightningStrike.addNewSubray()
-
-        const parentSeed = lightningStrike.randomGenerator.getSeed()
-        childSubray.seed = childSubraySeed
-        lightningStrike.randomGenerator.setSeed(childSubraySeed)
-
-        childSubray.recursion = subray.recursion + 1
-        childSubray.maxIterations = Math.max(1, subray.maxIterations - 1)
-
-        childSubray.linPos0.set(random1(), random1(), random1()).multiplyScalar(1000)
-        childSubray.linPos1.set(random1(), random1(), random1()).multiplyScalar(1000)
-        childSubray.up0.copy(subray.up0)
-        childSubray.up1.copy(subray.up1)
-        childSubray.radius0 = segment.radius0 * lightningStrike.rayParameters.radius0Factor
-        childSubray.radius1 = Math.min(
-          lightningStrike.rayParameters.minRadius,
-          segment.radius1 * lightningStrike.rayParameters.radius1Factor,
-        )
-
-        childSubray.birthTime = phase0 + currentCycle * period
-        childSubray.deathTime = childSubray.birthTime + period * dutyCycle
-
-        if (!lightningStrike.rayParameters.isEternal && subray.recursion == 0) {
-          childSubray.birthTime = Math.max(childSubray.birthTime, subray.birthTime)
-          childSubray.deathTime = Math.min(childSubray.deathTime, subray.deathTime)
+        if (
+          subray.recursion < lightningStrike.maxSubrayRecursion &&
+          lightningStrike.numSubrays < lightningStrike.maxSubrays &&
+          random1() < probability
+        ) {
+          const childSubray = lightningStrike.addNewSubray()
+
+          const parentSeed = lightningStrike.randomGenerator.getSeed()
+          childSubray.seed = childSubraySeed
+          lightningStrike.randomGenerator.setSeed(childSubraySeed)
+
+          childSubray.recursion = subray.recursion + 1
+          childSubray.maxIterations = Math.max(1, subray.maxIterations - 1)
+
+          childSubray.linPos0.set(random1(), random1(), random1()).multiplyScalar(1000)
+          childSubray.linPos1.set(random1(), random1(), random1()).multiplyScalar(1000)
+          childSubray.up0.copy(subray.up0)
+          childSubray.up1.copy(subray.up1)
+          childSubray.radius0 = segment.radius0 * lightningStrike.rayParameters.radius0Factor
+          childSubray.radius1 = Math.min(
+            lightningStrike.rayParameters.minRadius,
+            segment.radius1 * lightningStrike.rayParameters.radius1Factor,
+          )
+
+          childSubray.birthTime = phase0 + currentCycle * period
+          childSubray.deathTime = childSubray.birthTime + period * dutyCycle
+
+          if (!lightningStrike.rayParameters.isEternal && subray.recursion == 0) {
+            childSubray.birthTime = Math.max(childSubray.birthTime, subray.birthTime)
+            childSubray.deathTime = Math.min(childSubray.deathTime, subray.deathTime)
+          }
+
+          childSubray.timeScale = subray.timeScale * 2
+          childSubray.roughness = subray.roughness
+          childSubray.straightness = subray.straightness
+          childSubray.propagationTimeFactor = subray.propagationTimeFactor
+          childSubray.vanishingTimeFactor = subray.vanishingTimeFactor
+
+          lightningStrike.onSubrayCreation(segment, subray, childSubray, lightningStrike)
+
+          lightningStrike.randomGenerator.setSeed(parentSeed)
         }
+      }
 
-        childSubray.timeScale = subray.timeScale * 2
-        childSubray.roughness = subray.roughness
-        childSubray.straightness = subray.straightness
-        childSubray.propagationTimeFactor = subray.propagationTimeFactor
-        childSubray.vanishingTimeFactor = subray.vanishingTimeFactor
+      const vec1Pos = new Vector3()
+      const vec2Forward = new Vector3()
+      const vec3Side = new Vector3()
+      const vec4Up = new Vector3()
 
-        lightningStrike.onSubrayCreation(segment, subray, childSubray, lightningStrike)
+      this.onSubrayCreation = function (segment, parentSubray, childSubray, lightningStrike) {
+        // Decide childSubray origin and destination positions (pos0 and pos1) and possibly other properties of childSubray
 
-        lightningStrike.randomGenerator.setSeed(parentSeed)
+        // Just use the default cone position generator
+        lightningStrike.subrayCylinderPosition(segment, parentSubray, childSubray, 0.5, 0.6, 0.2)
       }
-    }
 
-    const vec1Pos = new Vector3()
-    const vec2Forward = new Vector3()
-    const vec3Side = new Vector3()
-    const vec4Up = new Vector3()
-
-    this.onSubrayCreation = function (segment, parentSubray, childSubray, lightningStrike) {
-      // Decide childSubray origin and destination positions (pos0 and pos1) and possibly other properties of childSubray
-
-      // Just use the default cone position generator
-      lightningStrike.subrayCylinderPosition(segment, parentSubray, childSubray, 0.5, 0.6, 0.2)
-    }
+      this.subrayConePosition = function (
+        segment,
+        parentSubray,
+        childSubray,
+        heightFactor,
+        sideWidthFactor,
+        minSideWidthFactor,
+      ) {
+        // Sets childSubray pos0 and pos1 in a cone
+
+        childSubray.pos0.copy(segment.pos0)
+
+        vec1Pos.subVectors(parentSubray.pos1, parentSubray.pos0)
+        vec2Forward.copy(vec1Pos).normalize()
+        vec1Pos.multiplyScalar(segment.fraction0 + (1 - segment.fraction0) * (random1() * heightFactor))
+        const length = vec1Pos.length()
+        vec3Side.crossVectors(parentSubray.up0, vec2Forward)
+        const angle = 2 * Math.PI * random1()
+        vec3Side.multiplyScalar(Math.cos(angle))
+        vec4Up.copy(parentSubray.up0).multiplyScalar(Math.sin(angle))
+
+        childSubray.pos1
+          .copy(vec3Side)
+          .add(vec4Up)
+          .multiplyScalar(length * sideWidthFactor * (minSideWidthFactor + random1() * (1 - minSideWidthFactor)))
+          .add(vec1Pos)
+          .add(parentSubray.pos0)
+      }
 
-    this.subrayConePosition = function (
-      segment,
-      parentSubray,
-      childSubray,
-      heightFactor,
-      sideWidthFactor,
-      minSideWidthFactor,
-    ) {
-      // Sets childSubray pos0 and pos1 in a cone
-
-      childSubray.pos0.copy(segment.pos0)
-
-      vec1Pos.subVectors(parentSubray.pos1, parentSubray.pos0)
-      vec2Forward.copy(vec1Pos).normalize()
-      vec1Pos.multiplyScalar(segment.fraction0 + (1 - segment.fraction0) * (random1() * heightFactor))
-      const length = vec1Pos.length()
-      vec3Side.crossVectors(parentSubray.up0, vec2Forward)
-      const angle = 2 * Math.PI * random1()
-      vec3Side.multiplyScalar(Math.cos(angle))
-      vec4Up.copy(parentSubray.up0).multiplyScalar(Math.sin(angle))
-
-      childSubray.pos1
-        .copy(vec3Side)
-        .add(vec4Up)
-        .multiplyScalar(length * sideWidthFactor * (minSideWidthFactor + random1() * (1 - minSideWidthFactor)))
-        .add(vec1Pos)
-        .add(parentSubray.pos0)
+      this.subrayCylinderPosition = function (
+        segment,
+        parentSubray,
+        childSubray,
+        heightFactor,
+        sideWidthFactor,
+        minSideWidthFactor,
+      ) {
+        // Sets childSubray pos0 and pos1 in a cylinder
+
+        childSubray.pos0.copy(segment.pos0)
+
+        vec1Pos.subVectors(parentSubray.pos1, parentSubray.pos0)
+        vec2Forward.copy(vec1Pos).normalize()
+        vec1Pos.multiplyScalar(segment.fraction0 + (1 - segment.fraction0) * ((2 * random1() - 1) * heightFactor))
+        const length = vec1Pos.length()
+        vec3Side.crossVectors(parentSubray.up0, vec2Forward)
+        const angle = 2 * Math.PI * random1()
+        vec3Side.multiplyScalar(Math.cos(angle))
+        vec4Up.copy(parentSubray.up0).multiplyScalar(Math.sin(angle))
+
+        childSubray.pos1
+          .copy(vec3Side)
+          .add(vec4Up)
+          .multiplyScalar(length * sideWidthFactor * (minSideWidthFactor + random1() * (1 - minSideWidthFactor)))
+          .add(vec1Pos)
+          .add(parentSubray.pos0)
+      }
     }
 
-    this.subrayCylinderPosition = function (
-      segment,
-      parentSubray,
-      childSubray,
-      heightFactor,
-      sideWidthFactor,
-      minSideWidthFactor,
-    ) {
-      // Sets childSubray pos0 and pos1 in a cylinder
-
-      childSubray.pos0.copy(segment.pos0)
-
-      vec1Pos.subVectors(parentSubray.pos1, parentSubray.pos0)
-      vec2Forward.copy(vec1Pos).normalize()
-      vec1Pos.multiplyScalar(segment.fraction0 + (1 - segment.fraction0) * ((2 * random1() - 1) * heightFactor))
-      const length = vec1Pos.length()
-      vec3Side.crossVectors(parentSubray.up0, vec2Forward)
-      const angle = 2 * Math.PI * random1()
-      vec3Side.multiplyScalar(Math.cos(angle))
-      vec4Up.copy(parentSubray.up0).multiplyScalar(Math.sin(angle))
-
-      childSubray.pos1
-        .copy(vec3Side)
-        .add(vec4Up)
-        .multiplyScalar(length * sideWidthFactor * (minSideWidthFactor + random1() * (1 - minSideWidthFactor)))
-        .add(vec1Pos)
-        .add(parentSubray.pos0)
+    createSubray() {
+      return {
+        seed: 0,
+        maxIterations: 0,
+        recursion: 0,
+        pos0: new Vector3(),
+        pos1: new Vector3(),
+        linPos0: new Vector3(),
+        linPos1: new Vector3(),
+        up0: new Vector3(),
+        up1: new Vector3(),
+        radius0: 0,
+        radius1: 0,
+        birthTime: 0,
+        deathTime: 0,
+        timeScale: 0,
+        roughness: 0,
+        straightness: 0,
+        propagationTimeFactor: 0,
+        vanishingTimeFactor: 0,
+        endPropagationTime: 0,
+        beginVanishingTime: 0,
+      }
     }
-  }
 
-  createSubray() {
-    return {
-      seed: 0,
-      maxIterations: 0,
-      recursion: 0,
-      pos0: new Vector3(),
-      pos1: new Vector3(),
-      linPos0: new Vector3(),
-      linPos1: new Vector3(),
-      up0: new Vector3(),
-      up1: new Vector3(),
-      radius0: 0,
-      radius1: 0,
-      birthTime: 0,
-      deathTime: 0,
-      timeScale: 0,
-      roughness: 0,
-      straightness: 0,
-      propagationTimeFactor: 0,
-      vanishingTimeFactor: 0,
-      endPropagationTime: 0,
-      beginVanishingTime: 0,
+    createSegment() {
+      return {
+        iteration: 0,
+        pos0: new Vector3(),
+        pos1: new Vector3(),
+        linPos0: new Vector3(),
+        linPos1: new Vector3(),
+        up0: new Vector3(),
+        up1: new Vector3(),
+        radius0: 0,
+        radius1: 0,
+        fraction0: 0,
+        fraction1: 0,
+        positionVariationFactor: 0,
+      }
     }
-  }
 
-  createSegment() {
-    return {
-      iteration: 0,
-      pos0: new Vector3(),
-      pos1: new Vector3(),
-      linPos0: new Vector3(),
-      linPos1: new Vector3(),
-      up0: new Vector3(),
-      up1: new Vector3(),
-      radius0: 0,
-      radius1: 0,
-      fraction0: 0,
-      fraction1: 0,
-      positionVariationFactor: 0,
+    getNewSegment() {
+      return this.raySegments[this.currentSegmentIndex++]
     }
-  }
 
-  getNewSegment() {
-    return this.raySegments[this.currentSegmentIndex++]
-  }
+    copy(source) {
+      super.copy(source)
 
-  copy(source) {
-    super.copy(source)
+      this.init(LightningStrike.copyParameters({}, source.rayParameters))
 
-    this.init(LightningStrike.copyParameters({}, source.rayParameters))
+      return this
+    }
 
-    return this
+    clone() {
+      return new this.constructor(LightningStrike.copyParameters({}, this.rayParameters))
+    }
   }
 
-  clone() {
-    return new this.constructor(LightningStrike.copyParameters({}, this.rayParameters))
-  }
-}
+  return LightningStrike
+})()
 
 export { LightningStrike }
diff --git a/src/geometries/RoundedBoxGeometry.js b/src/geometries/RoundedBoxGeometry.js
index 80c5f35b..3a10f247 100644
--- a/src/geometries/RoundedBoxGeometry.js
+++ b/src/geometries/RoundedBoxGeometry.js
@@ -1,6 +1,6 @@
 import { BoxGeometry, Vector3 } from 'three'
 
-const tempNormal = new Vector3()
+const tempNormal = /* @__PURE__ */ new Vector3()
 
 function getUv(faceDirVector, normal, uvAxis, projectionAxis, radius, sideLength) {
   const totArcLength = (2 * Math.PI * radius) / 4
diff --git a/src/helpers/RaycasterHelper.ts b/src/helpers/RaycasterHelper.ts
index f5f57644..ed093375 100644
--- a/src/helpers/RaycasterHelper.ts
+++ b/src/helpers/RaycasterHelper.ts
@@ -18,8 +18,8 @@ import {
   Vector3,
 } from 'three'
 
-const _o = new Object3D()
-const _v = new Vector3()
+const _o = /* @__PURE__ */ new Object3D()
+const _v = /* @__PURE__ */ new Vector3()
 
 class RaycasterHelper extends Object3D {
   raycaster: Raycaster
diff --git a/src/helpers/VertexNormalsHelper.js b/src/helpers/VertexNormalsHelper.js
index 18e8addb..b586a130 100644
--- a/src/helpers/VertexNormalsHelper.js
+++ b/src/helpers/VertexNormalsHelper.js
@@ -1,8 +1,8 @@
 import { BufferGeometry, Float32BufferAttribute, LineSegments, LineBasicMaterial, Matrix3, Vector3 } from 'three'
 
-const _v1 = new Vector3()
-const _v2 = new Vector3()
-const _normalMatrix = new Matrix3()
+const _v1 = /* @__PURE__ */ new Vector3()
+const _v2 = /* @__PURE__ */ new Vector3()
+const _normalMatrix = /* @__PURE__ */ new Matrix3()
 
 class VertexNormalsHelper extends LineSegments {
   constructor(object, size = 1, color = 0xff0000) {
diff --git a/src/helpers/VertexTangentsHelper.js b/src/helpers/VertexTangentsHelper.js
index 42d50ee5..a9af184a 100644
--- a/src/helpers/VertexTangentsHelper.js
+++ b/src/helpers/VertexTangentsHelper.js
@@ -1,7 +1,7 @@
 import { BufferGeometry, Float32BufferAttribute, LineSegments, LineBasicMaterial, Vector3 } from 'three'
 
-const _v1 = new Vector3()
-const _v2 = new Vector3()
+const _v1 = /* @__PURE__ */ new Vector3()
+const _v2 = /* @__PURE__ */ new Vector3()
 
 class VertexTangentsHelper extends LineSegments {
   constructor(object, size = 1, color = 0x00ffff) {
diff --git a/src/interactive/InteractiveGroup.js b/src/interactive/InteractiveGroup.js
index 704f4ffb..263e979b 100644
--- a/src/interactive/InteractiveGroup.js
+++ b/src/interactive/InteractiveGroup.js
@@ -1,6 +1,6 @@
 import { Group, Matrix4, Raycaster, Vector2 } from 'three'
 
-const _pointer = new Vector2()
+const _pointer = /* @__PURE__ */ new Vector2()
 const _event = { type: '', data: _pointer }
 
 class InteractiveGroup extends Group {
diff --git a/src/interactive/SelectionBox.js b/src/interactive/SelectionBox.js
index 4db0205e..dda5dd6e 100644
--- a/src/interactive/SelectionBox.js
+++ b/src/interactive/SelectionBox.js
@@ -1,24 +1,24 @@
 import { Frustum, Vector3 } from 'three'
 
-const frustum = new Frustum()
-const center = new Vector3()
+const frustum = /* @__PURE__ */ new Frustum()
+const center = /* @__PURE__ */ new Vector3()
 
-const tmpPoint = new Vector3()
+const tmpPoint = /* @__PURE__ */ new Vector3()
 
-const vecNear = new Vector3()
-const vecTopLeft = new Vector3()
-const vecTopRight = new Vector3()
-const vecDownRight = new Vector3()
-const vecDownLeft = new Vector3()
+const vecNear = /* @__PURE__ */ new Vector3()
+const vecTopLeft = /* @__PURE__ */ new Vector3()
+const vecTopRight = /* @__PURE__ */ new Vector3()
+const vecDownRight = /* @__PURE__ */ new Vector3()
+const vecDownLeft = /* @__PURE__ */ new Vector3()
 
-const vecFarTopLeft = new Vector3()
-const vecFarTopRight = new Vector3()
-const vecFarDownRight = new Vector3()
-const vecFarDownLeft = new Vector3()
+const vecFarTopLeft = /* @__PURE__ */ new Vector3()
+const vecFarTopRight = /* @__PURE__ */ new Vector3()
+const vecFarDownRight = /* @__PURE__ */ new Vector3()
+const vecFarDownLeft = /* @__PURE__ */ new Vector3()
 
-const vectemp1 = new Vector3()
-const vectemp2 = new Vector3()
-const vectemp3 = new Vector3()
+const vectemp1 = /* @__PURE__ */ new Vector3()
+const vectemp2 = /* @__PURE__ */ new Vector3()
+const vectemp3 = /* @__PURE__ */ new Vector3()
 
 class SelectionBox {
   constructor(camera, scene, deep) {
diff --git a/src/libs/chevrotain.js b/src/libs/chevrotain.js
index 8e23804d..4d8c0e48 100644
--- a/src/libs/chevrotain.js
+++ b/src/libs/chevrotain.js
@@ -1,4 +1,4 @@
-const { CstParser, Lexer, createToken } = (() => {
+const { CstParser, Lexer, createToken } = /* @__PURE__ */ (() => {
   /** Detect free variable `global` from Node.js. */
   var freeGlobal = typeof global == 'object' && global && global.Object === Object && global
 
diff --git a/src/libs/lottie.js b/src/libs/lottie.js
index 2c2d699d..e6e503df 100644
--- a/src/libs/lottie.js
+++ b/src/libs/lottie.js
@@ -1,4 +1,4 @@
-const lottie = (() => {
+const lottie = /* @__PURE__ */ (() => {
   if (typeof navigator === 'undefined' || typeof document === 'undefined') return {}
 
   const svgNS = 'http://www.w3.org/2000/svg'
diff --git a/src/libs/opentype.js b/src/libs/opentype.js
index ecb8c687..d8aa0d04 100644
--- a/src/libs/opentype.js
+++ b/src/libs/opentype.js
@@ -1,4 +1,4 @@
-const { parseBuffer } = (() => {
+const { parseBuffer } = /* @__PURE__ */ (() => {
   /**
    * https://opentype.js.org v1.3.4 | (c) Frederik De Bleser and other contributors | MIT License | Uses tiny-inflate by Devon Govett and string.prototype.codepointat polyfill by Mathias Bynens
    */
diff --git a/src/lights/LightProbeGenerator.js b/src/lights/LightProbeGenerator.js
index 216438e4..bd38bf06 100644
--- a/src/lights/LightProbeGenerator.js
+++ b/src/lights/LightProbeGenerator.js
@@ -1,8 +1,8 @@
 import { Color, LightProbe, SphericalHarmonics3, Vector3 } from 'three'
 
-class LightProbeGenerator {
+const LightProbeGenerator = {
   // https://www.ppsloan.org/publications/StupidSH36.pdf
-  static fromCubeTexture(cubeTexture) {
+  fromCubeTexture(cubeTexture) {
     let totalWeight = 0
 
     const coord = new Vector3()
@@ -122,9 +122,9 @@ class LightProbeGenerator {
     }
 
     return new LightProbe(sh)
-  }
+  },
 
-  static fromCubeRenderTarget(renderer, cubeRenderTarget) {
+  fromCubeRenderTarget(renderer, cubeRenderTarget) {
     // The renderTarget must be set to RGBA in order to make readRenderTargetPixels works
     let totalWeight = 0
 
@@ -229,7 +229,7 @@ class LightProbeGenerator {
     }
 
     return new LightProbe(sh)
-  }
+  },
 }
 
 export { LightProbeGenerator }
diff --git a/src/lights/RectAreaLightUniformsLib.js b/src/lights/RectAreaLightUniformsLib.js
index c14634f1..3f495939 100644
--- a/src/lights/RectAreaLightUniformsLib.js
+++ b/src/lights/RectAreaLightUniformsLib.js
@@ -28,8 +28,8 @@ import {
 // by Eric Heitz, Jonathan Dupuy, Stephen Hill and David Neubelt
 // code: https://github.com/selfshadow/ltc_code/
 
-class RectAreaLightUniformsLib {
-  static init() {
+const RectAreaLightUniformsLib = {
+  init() {
     // source: https://github.com/selfshadow/ltc_code/tree/master/fit/results/ltc.js
 
     const LTC_MAT_1 = [
@@ -32882,7 +32882,7 @@ class RectAreaLightUniformsLib {
 
     UniformsLib.LTC_HALF_1.needsUpdate = true
     UniformsLib.LTC_HALF_2.needsUpdate = true
-  }
+  },
 }
 
 export { RectAreaLightUniformsLib }
diff --git a/src/lines/LineMaterial.js b/src/lines/LineMaterial.js
index 3c4959de..8e54c9e8 100644
--- a/src/lines/LineMaterial.js
+++ b/src/lines/LineMaterial.js
@@ -10,7 +10,8 @@
  * }
  */
 
-import { ShaderMaterial, UniformsLib, UniformsUtils, Vector2, REVISION } from 'three'
+import { ShaderMaterial, UniformsLib, UniformsUtils, Vector2 } from 'three'
+import { version } from '../_polyfill/constants'
 
 class LineMaterial extends ShaderMaterial {
   constructor(parameters) {
@@ -437,7 +438,7 @@ class LineMaterial extends ShaderMaterial {
 					gl_FragColor = diffuseColor;
 
 					#include <tonemapping_fragment>
-					#include <${parseInt(REVISION.replace(/\D+/g, '')) >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>
+					#include <${version >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>
 					#include <fog_fragment>
 					#include <premultiplied_alpha_fragment>
 
diff --git a/src/lines/LineSegments2.js b/src/lines/LineSegments2.js
index b514fe81..461e240a 100644
--- a/src/lines/LineSegments2.js
+++ b/src/lines/LineSegments2.js
@@ -14,23 +14,23 @@ import { LineSegmentsGeometry } from '../lines/LineSegmentsGeometry'
 import { LineMaterial } from '../lines/LineMaterial'
 import { UV1 } from '../_polyfill/uv1'
 
-const _viewport = new Vector4();
+const _viewport = /* @__PURE__ */ new Vector4()
 
-const _start = new Vector3()
-const _end = new Vector3()
+const _start = /* @__PURE__ */ new Vector3()
+const _end = /* @__PURE__ */ new Vector3()
 
-const _start4 = new Vector4()
-const _end4 = new Vector4()
+const _start4 = /* @__PURE__ */ new Vector4()
+const _end4 = /* @__PURE__ */ new Vector4()
 
-const _ssOrigin = new Vector4()
-const _ssOrigin3 = new Vector3()
-const _mvMatrix = new Matrix4()
-const _line = new Line3()
-const _closestPoint = new Vector3()
+const _ssOrigin = /* @__PURE__ */ new Vector4()
+const _ssOrigin3 = /* @__PURE__ */ new Vector3()
+const _mvMatrix = /* @__PURE__ */ new Matrix4()
+const _line = /* @__PURE__ */ new Line3()
+const _closestPoint = /* @__PURE__ */ new Vector3()
 
-const _box = new Box3()
-const _sphere = new Sphere()
-const _clipToWorldVector = new Vector4()
+const _box = /* @__PURE__ */ new Box3()
+const _sphere = /* @__PURE__ */ new Sphere()
+const _clipToWorldVector = /* @__PURE__ */ new Vector4()
 
 let _ray, _lineWidth
 
@@ -51,18 +51,17 @@ function getWorldSpaceHalfWidth(camera, distance, resolution) {
 }
 
 function raycastWorldUnits(lineSegments, intersects) {
-
-  const matrixWorld = lineSegments.matrixWorld;
-  const geometry = lineSegments.geometry;
-  const instanceStart = geometry.attributes.instanceStart;
-  const instanceEnd = geometry.attributes.instanceEnd;
-  const segmentCount = Math.min(geometry.instanceCount, instanceStart.count);
+  const matrixWorld = lineSegments.matrixWorld
+  const geometry = lineSegments.geometry
+  const instanceStart = geometry.attributes.instanceStart
+  const instanceEnd = geometry.attributes.instanceEnd
+  const segmentCount = Math.min(geometry.instanceCount, instanceStart.count)
 
   for (let i = 0, l = segmentCount; i < l; i++) {
     _line.start.fromBufferAttribute(instanceStart, i)
     _line.end.fromBufferAttribute(instanceEnd, i)
 
-    _line.applyMatrix4(matrixWorld);
+    _line.applyMatrix4(matrixWorld)
 
     const pointOnLine = new Vector3()
     const point = new Vector3()
@@ -94,7 +93,7 @@ function raycastScreenSpace(lineSegments, camera, intersects) {
   const geometry = lineSegments.geometry
   const instanceStart = geometry.attributes.instanceStart
   const instanceEnd = geometry.attributes.instanceEnd
-  const segmentCount = Math.min(geometry.instanceCount, instanceStart.count);
+  const segmentCount = Math.min(geometry.instanceCount, instanceStart.count)
 
   const near = -camera.near
 
@@ -312,16 +311,12 @@ class LineSegments2 extends Mesh {
   }
 
   onBeforeRender(renderer) {
-
-    const uniforms = this.material.uniforms;
+    const uniforms = this.material.uniforms
 
     if (uniforms && uniforms.resolution) {
-
-      renderer.getViewport(_viewport);
-      this.material.uniforms.resolution.value.set(_viewport.z, _viewport.w);
-
+      renderer.getViewport(_viewport)
+      this.material.uniforms.resolution.value.set(_viewport.z, _viewport.w)
     }
-
   }
 }
 
diff --git a/src/lines/LineSegmentsGeometry.js b/src/lines/LineSegmentsGeometry.js
index 967b2fcb..5b1fb7bb 100644
--- a/src/lines/LineSegmentsGeometry.js
+++ b/src/lines/LineSegmentsGeometry.js
@@ -9,8 +9,8 @@ import {
   WireframeGeometry,
 } from 'three'
 
-const _box = new Box3()
-const _vector = new Vector3()
+const _box = /* @__PURE__ */ new Box3()
+const _vector = /* @__PURE__ */ new Vector3()
 
 class LineSegmentsGeometry extends InstancedBufferGeometry {
   constructor() {
diff --git a/src/lines/Wireframe.js b/src/lines/Wireframe.js
index 5c3bfe87..5d97668b 100644
--- a/src/lines/Wireframe.js
+++ b/src/lines/Wireframe.js
@@ -2,9 +2,9 @@ import { InstancedInterleavedBuffer, InterleavedBufferAttribute, Mesh, Vector3,
 import { LineSegmentsGeometry } from '../lines/LineSegmentsGeometry'
 import { LineMaterial } from '../lines/LineMaterial'
 
-const _start = new Vector3()
-const _end = new Vector3()
-const _viewport = new Vector4();
+const _start = /* @__PURE__ */ new Vector3()
+const _end = /* @__PURE__ */ new Vector3()
+const _viewport = /* @__PURE__ */ new Vector4()
 
 class Wireframe extends Mesh {
   constructor(geometry = new LineSegmentsGeometry(), material = new LineMaterial({ color: Math.random() * 0xffffff })) {
@@ -41,16 +41,12 @@ class Wireframe extends Mesh {
   }
 
   onBeforeRender(renderer) {
-
-    const uniforms = this.material.uniforms;
+    const uniforms = this.material.uniforms
 
     if (uniforms && uniforms.resolution) {
-
-      renderer.getViewport(_viewport);
-      this.material.uniforms.resolution.value.set(_viewport.z, _viewport.w);
-
+      renderer.getViewport(_viewport)
+      this.material.uniforms.resolution.value.set(_viewport.z, _viewport.w)
     }
-
   }
 }
 
diff --git a/src/loaders/BasisTextureLoader.js b/src/loaders/BasisTextureLoader.js
index f568464c..6d2babf6 100644
--- a/src/loaders/BasisTextureLoader.js
+++ b/src/loaders/BasisTextureLoader.js
@@ -32,135 +32,174 @@ import {
 
 const _taskCache = new WeakMap()
 
-class BasisTextureLoader extends Loader {
-  /* CONSTANTS */
+const BasisTextureLoader = /* @__PURE__ */ (() => {
+  class BasisTextureLoader extends Loader {
+    /* CONSTANTS */
 
-  static BasisFormat = {
-    ETC1S: 0,
-    UASTC_4x4: 1,
-  }
+    static BasisFormat = {
+      ETC1S: 0,
+      UASTC_4x4: 1,
+    }
 
-  static TranscoderFormat = {
-    ETC1: 0,
-    ETC2: 1,
-    BC1: 2,
-    BC3: 3,
-    BC4: 4,
-    BC5: 5,
-    BC7_M6_OPAQUE_ONLY: 6,
-    BC7_M5: 7,
-    PVRTC1_4_RGB: 8,
-    PVRTC1_4_RGBA: 9,
-    ASTC_4x4: 10,
-    ATC_RGB: 11,
-    ATC_RGBA_INTERPOLATED_ALPHA: 12,
-    RGBA32: 13,
-    RGB565: 14,
-    BGR565: 15,
-    RGBA4444: 16,
-  }
+    static TranscoderFormat = {
+      ETC1: 0,
+      ETC2: 1,
+      BC1: 2,
+      BC3: 3,
+      BC4: 4,
+      BC5: 5,
+      BC7_M6_OPAQUE_ONLY: 6,
+      BC7_M5: 7,
+      PVRTC1_4_RGB: 8,
+      PVRTC1_4_RGBA: 9,
+      ASTC_4x4: 10,
+      ATC_RGB: 11,
+      ATC_RGBA_INTERPOLATED_ALPHA: 12,
+      RGBA32: 13,
+      RGB565: 14,
+      BGR565: 15,
+      RGBA4444: 16,
+    }
 
-  static EngineFormat = {
-    RGBAFormat: RGBAFormat,
-    RGBA_ASTC_4x4_Format: RGBA_ASTC_4x4_Format,
-    RGBA_BPTC_Format: RGBA_BPTC_Format,
-    RGBA_ETC2_EAC_Format: RGBA_ETC2_EAC_Format,
-    RGBA_PVRTC_4BPPV1_Format: RGBA_PVRTC_4BPPV1_Format,
-    RGBA_S3TC_DXT5_Format: RGBA_S3TC_DXT5_Format,
-    RGB_ETC1_Format: RGB_ETC1_Format,
-    RGB_ETC2_Format: RGB_ETC2_Format,
-    RGB_PVRTC_4BPPV1_Format: RGB_PVRTC_4BPPV1_Format,
-    RGB_S3TC_DXT1_Format: RGB_S3TC_DXT1_Format,
-  }
+    static EngineFormat = {
+      RGBAFormat: RGBAFormat,
+      RGBA_ASTC_4x4_Format: RGBA_ASTC_4x4_Format,
+      RGBA_BPTC_Format: RGBA_BPTC_Format,
+      RGBA_ETC2_EAC_Format: RGBA_ETC2_EAC_Format,
+      RGBA_PVRTC_4BPPV1_Format: RGBA_PVRTC_4BPPV1_Format,
+      RGBA_S3TC_DXT5_Format: RGBA_S3TC_DXT5_Format,
+      RGB_ETC1_Format: RGB_ETC1_Format,
+      RGB_ETC2_Format: RGB_ETC2_Format,
+      RGB_PVRTC_4BPPV1_Format: RGB_PVRTC_4BPPV1_Format,
+      RGB_S3TC_DXT1_Format: RGB_S3TC_DXT1_Format,
+    }
 
-  /* WEB WORKER */
+    /* WEB WORKER */
 
-  static BasisWorker = function () {
-    let config
-    let transcoderPending
-    let BasisModule
+    static BasisWorker = function () {
+      let config
+      let transcoderPending
+      let BasisModule
 
-    const EngineFormat = _EngineFormat
-    const TranscoderFormat = _TranscoderFormat
-    const BasisFormat = _BasisFormat
+      const EngineFormat = _EngineFormat
+      const TranscoderFormat = _TranscoderFormat
+      const BasisFormat = _BasisFormat
 
-    onmessage = function (e) {
-      const message = e.data
+      onmessage = function (e) {
+        const message = e.data
 
-      switch (message.type) {
-        case 'init':
-          config = message.config
-          init(message.transcoderBinary)
-          break
+        switch (message.type) {
+          case 'init':
+            config = message.config
+            init(message.transcoderBinary)
+            break
 
-        case 'transcode':
-          transcoderPending.then(() => {
-            try {
-              const { width, height, hasAlpha, mipmaps, format } = message.taskConfig.lowLevel
-                ? transcodeLowLevel(message.taskConfig)
-                : transcode(message.buffers[0])
+          case 'transcode':
+            transcoderPending.then(() => {
+              try {
+                const { width, height, hasAlpha, mipmaps, format } = message.taskConfig.lowLevel
+                  ? transcodeLowLevel(message.taskConfig)
+                  : transcode(message.buffers[0])
 
-              const buffers = []
+                const buffers = []
 
-              for (let i = 0; i < mipmaps.length; ++i) {
-                buffers.push(mipmaps[i].data.buffer)
-              }
+                for (let i = 0; i < mipmaps.length; ++i) {
+                  buffers.push(mipmaps[i].data.buffer)
+                }
 
-              self.postMessage({ type: 'transcode', id: message.id, width, height, hasAlpha, mipmaps, format }, buffers)
-            } catch (error) {
-              console.error(error)
+                self.postMessage(
+                  { type: 'transcode', id: message.id, width, height, hasAlpha, mipmaps, format },
+                  buffers,
+                )
+              } catch (error) {
+                console.error(error)
 
-              self.postMessage({ type: 'error', id: message.id, error: error.message })
-            }
-          })
-          break
+                self.postMessage({ type: 'error', id: message.id, error: error.message })
+              }
+            })
+            break
+        }
       }
-    }
 
-    function init(wasmBinary) {
-      transcoderPending = new Promise((resolve) => {
-        BasisModule = { wasmBinary, onRuntimeInitialized: resolve }
-        BASIS(BasisModule)
-      }).then(() => {
-        BasisModule.initializeBasis()
-      })
-    }
+      function init(wasmBinary) {
+        transcoderPending = new Promise((resolve) => {
+          BasisModule = { wasmBinary, onRuntimeInitialized: resolve }
+          BASIS(BasisModule)
+        }).then(() => {
+          BasisModule.initializeBasis()
+        })
+      }
+
+      function transcodeLowLevel(taskConfig) {
+        const { basisFormat, width, height, hasAlpha } = taskConfig
+
+        const { transcoderFormat, engineFormat } = getTranscoderFormat(basisFormat, width, height, hasAlpha)
+
+        const blockByteLength = BasisModule.getBytesPerBlockOrPixel(transcoderFormat)
 
-    function transcodeLowLevel(taskConfig) {
-      const { basisFormat, width, height, hasAlpha } = taskConfig
+        assert(BasisModule.isFormatSupported(transcoderFormat), 'THREE.BasisTextureLoader: Unsupported format.')
 
-      const { transcoderFormat, engineFormat } = getTranscoderFormat(basisFormat, width, height, hasAlpha)
+        const mipmaps = []
 
-      const blockByteLength = BasisModule.getBytesPerBlockOrPixel(transcoderFormat)
+        if (basisFormat === BasisFormat.ETC1S) {
+          const transcoder = new BasisModule.LowLevelETC1SImageTranscoder()
 
-      assert(BasisModule.isFormatSupported(transcoderFormat), 'THREE.BasisTextureLoader: Unsupported format.')
+          const { endpointCount, endpointsData, selectorCount, selectorsData, tablesData } = taskConfig.globalData
 
-      const mipmaps = []
+          try {
+            let ok
 
-      if (basisFormat === BasisFormat.ETC1S) {
-        const transcoder = new BasisModule.LowLevelETC1SImageTranscoder()
+            ok = transcoder.decodePalettes(endpointCount, endpointsData, selectorCount, selectorsData)
 
-        const { endpointCount, endpointsData, selectorCount, selectorsData, tablesData } = taskConfig.globalData
+            assert(ok, 'THREE.BasisTextureLoader: decodePalettes() failed.')
 
-        try {
-          let ok
+            ok = transcoder.decodeTables(tablesData)
 
-          ok = transcoder.decodePalettes(endpointCount, endpointsData, selectorCount, selectorsData)
+            assert(ok, 'THREE.BasisTextureLoader: decodeTables() failed.')
 
-          assert(ok, 'THREE.BasisTextureLoader: decodePalettes() failed.')
+            for (let i = 0; i < taskConfig.levels.length; i++) {
+              const level = taskConfig.levels[i]
+              const imageDesc = taskConfig.globalData.imageDescs[i]
 
-          ok = transcoder.decodeTables(tablesData)
+              const dstByteLength = getTranscodedImageByteLength(transcoderFormat, level.width, level.height)
+              const dst = new Uint8Array(dstByteLength)
 
-          assert(ok, 'THREE.BasisTextureLoader: decodeTables() failed.')
+              ok = transcoder.transcodeImage(
+                transcoderFormat,
+                dst,
+                dstByteLength / blockByteLength,
+                level.data,
+                getWidthInBlocks(transcoderFormat, level.width),
+                getHeightInBlocks(transcoderFormat, level.height),
+                level.width,
+                level.height,
+                level.index,
+                imageDesc.rgbSliceByteOffset,
+                imageDesc.rgbSliceByteLength,
+                imageDesc.alphaSliceByteOffset,
+                imageDesc.alphaSliceByteLength,
+                imageDesc.imageFlags,
+                hasAlpha,
+                false,
+                0,
+                0,
+              )
 
+              assert(ok, 'THREE.BasisTextureLoader: transcodeImage() failed for level ' + level.index + '.')
+
+              mipmaps.push({ data: dst, width: level.width, height: level.height })
+            }
+          } finally {
+            transcoder.delete()
+          }
+        } else {
           for (let i = 0; i < taskConfig.levels.length; i++) {
             const level = taskConfig.levels[i]
-            const imageDesc = taskConfig.globalData.imageDescs[i]
 
             const dstByteLength = getTranscodedImageByteLength(transcoderFormat, level.width, level.height)
             const dst = new Uint8Array(dstByteLength)
 
-            ok = transcoder.transcodeImage(
+            const ok = BasisModule.transcodeUASTCImage(
               transcoderFormat,
               dst,
               dstByteLength / blockByteLength,
@@ -170,487 +209,455 @@ class BasisTextureLoader extends Loader {
               level.width,
               level.height,
               level.index,
-              imageDesc.rgbSliceByteOffset,
-              imageDesc.rgbSliceByteLength,
-              imageDesc.alphaSliceByteOffset,
-              imageDesc.alphaSliceByteLength,
-              imageDesc.imageFlags,
+              0,
+              level.data.byteLength,
+              0,
               hasAlpha,
               false,
               0,
               0,
+              -1,
+              -1,
             )
 
-            assert(ok, 'THREE.BasisTextureLoader: transcodeImage() failed for level ' + level.index + '.')
+            assert(ok, 'THREE.BasisTextureLoader: transcodeUASTCImage() failed for level ' + level.index + '.')
 
             mipmaps.push({ data: dst, width: level.width, height: level.height })
           }
-        } finally {
-          transcoder.delete()
-        }
-      } else {
-        for (let i = 0; i < taskConfig.levels.length; i++) {
-          const level = taskConfig.levels[i]
-
-          const dstByteLength = getTranscodedImageByteLength(transcoderFormat, level.width, level.height)
-          const dst = new Uint8Array(dstByteLength)
-
-          const ok = BasisModule.transcodeUASTCImage(
-            transcoderFormat,
-            dst,
-            dstByteLength / blockByteLength,
-            level.data,
-            getWidthInBlocks(transcoderFormat, level.width),
-            getHeightInBlocks(transcoderFormat, level.height),
-            level.width,
-            level.height,
-            level.index,
-            0,
-            level.data.byteLength,
-            0,
-            hasAlpha,
-            false,
-            0,
-            0,
-            -1,
-            -1,
-          )
-
-          assert(ok, 'THREE.BasisTextureLoader: transcodeUASTCImage() failed for level ' + level.index + '.')
-
-          mipmaps.push({ data: dst, width: level.width, height: level.height })
         }
+
+        return { width, height, hasAlpha, mipmaps, format: engineFormat }
       }
 
-      return { width, height, hasAlpha, mipmaps, format: engineFormat }
-    }
+      function transcode(buffer) {
+        const basisFile = new BasisModule.BasisFile(new Uint8Array(buffer))
 
-    function transcode(buffer) {
-      const basisFile = new BasisModule.BasisFile(new Uint8Array(buffer))
+        const basisFormat = basisFile.isUASTC() ? BasisFormat.UASTC_4x4 : BasisFormat.ETC1S
+        const width = basisFile.getImageWidth(0, 0)
+        const height = basisFile.getImageHeight(0, 0)
+        const levels = basisFile.getNumLevels(0)
+        const hasAlpha = basisFile.getHasAlpha()
 
-      const basisFormat = basisFile.isUASTC() ? BasisFormat.UASTC_4x4 : BasisFormat.ETC1S
-      const width = basisFile.getImageWidth(0, 0)
-      const height = basisFile.getImageHeight(0, 0)
-      const levels = basisFile.getNumLevels(0)
-      const hasAlpha = basisFile.getHasAlpha()
+        function cleanup() {
+          basisFile.close()
+          basisFile.delete()
+        }
 
-      function cleanup() {
-        basisFile.close()
-        basisFile.delete()
-      }
+        const { transcoderFormat, engineFormat } = getTranscoderFormat(basisFormat, width, height, hasAlpha)
 
-      const { transcoderFormat, engineFormat } = getTranscoderFormat(basisFormat, width, height, hasAlpha)
+        if (!width || !height || !levels) {
+          cleanup()
+          throw new Error('THREE.BasisTextureLoader:	Invalid texture')
+        }
 
-      if (!width || !height || !levels) {
-        cleanup()
-        throw new Error('THREE.BasisTextureLoader:	Invalid texture')
-      }
+        if (!basisFile.startTranscoding()) {
+          cleanup()
+          throw new Error('THREE.BasisTextureLoader: .startTranscoding failed')
+        }
 
-      if (!basisFile.startTranscoding()) {
-        cleanup()
-        throw new Error('THREE.BasisTextureLoader: .startTranscoding failed')
-      }
+        const mipmaps = []
 
-      const mipmaps = []
+        for (let mip = 0; mip < levels; mip++) {
+          const mipWidth = basisFile.getImageWidth(0, mip)
+          const mipHeight = basisFile.getImageHeight(0, mip)
+          const dst = new Uint8Array(basisFile.getImageTranscodedSizeInBytes(0, mip, transcoderFormat))
 
-      for (let mip = 0; mip < levels; mip++) {
-        const mipWidth = basisFile.getImageWidth(0, mip)
-        const mipHeight = basisFile.getImageHeight(0, mip)
-        const dst = new Uint8Array(basisFile.getImageTranscodedSizeInBytes(0, mip, transcoderFormat))
+          const status = basisFile.transcodeImage(dst, 0, mip, transcoderFormat, 0, hasAlpha)
 
-        const status = basisFile.transcodeImage(dst, 0, mip, transcoderFormat, 0, hasAlpha)
+          if (!status) {
+            cleanup()
+            throw new Error('THREE.BasisTextureLoader: .transcodeImage failed.')
+          }
 
-        if (!status) {
-          cleanup()
-          throw new Error('THREE.BasisTextureLoader: .transcodeImage failed.')
+          mipmaps.push({ data: dst, width: mipWidth, height: mipHeight })
         }
 
-        mipmaps.push({ data: dst, width: mipWidth, height: mipHeight })
+        cleanup()
+
+        return { width, height, hasAlpha, mipmaps, format: engineFormat }
       }
 
-      cleanup()
+      //
+
+      // Optimal choice of a transcoder target format depends on the Basis format (ETC1S or UASTC),
+      // device capabilities, and texture dimensions. The list below ranks the formats separately
+      // for ETC1S and UASTC.
+      //
+      // In some cases, transcoding UASTC to RGBA32 might be preferred for higher quality (at
+      // significant memory cost) compared to ETC1/2, BC1/3, and PVRTC. The transcoder currently
+      // chooses RGBA32 only as a last resort and does not expose that option to the caller.
+      const FORMAT_OPTIONS = [
+        {
+          if: 'astcSupported',
+          basisFormat: [BasisFormat.UASTC_4x4],
+          transcoderFormat: [TranscoderFormat.ASTC_4x4, TranscoderFormat.ASTC_4x4],
+          engineFormat: [EngineFormat.RGBA_ASTC_4x4_Format, EngineFormat.RGBA_ASTC_4x4_Format],
+          priorityETC1S: Infinity,
+          priorityUASTC: 1,
+          needsPowerOfTwo: false,
+        },
+        {
+          if: 'bptcSupported',
+          basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
+          transcoderFormat: [TranscoderFormat.BC7_M5, TranscoderFormat.BC7_M5],
+          engineFormat: [EngineFormat.RGBA_BPTC_Format, EngineFormat.RGBA_BPTC_Format],
+          priorityETC1S: 3,
+          priorityUASTC: 2,
+          needsPowerOfTwo: false,
+        },
+        {
+          if: 'dxtSupported',
+          basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
+          transcoderFormat: [TranscoderFormat.BC1, TranscoderFormat.BC3],
+          engineFormat: [EngineFormat.RGB_S3TC_DXT1_Format, EngineFormat.RGBA_S3TC_DXT5_Format],
+          priorityETC1S: 4,
+          priorityUASTC: 5,
+          needsPowerOfTwo: false,
+        },
+        {
+          if: 'etc2Supported',
+          basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
+          transcoderFormat: [TranscoderFormat.ETC1, TranscoderFormat.ETC2],
+          engineFormat: [EngineFormat.RGB_ETC2_Format, EngineFormat.RGBA_ETC2_EAC_Format],
+          priorityETC1S: 1,
+          priorityUASTC: 3,
+          needsPowerOfTwo: false,
+        },
+        {
+          if: 'etc1Supported',
+          basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
+          transcoderFormat: [TranscoderFormat.ETC1, TranscoderFormat.ETC1],
+          engineFormat: [EngineFormat.RGB_ETC1_Format, EngineFormat.RGB_ETC1_Format],
+          priorityETC1S: 2,
+          priorityUASTC: 4,
+          needsPowerOfTwo: false,
+        },
+        {
+          if: 'pvrtcSupported',
+          basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
+          transcoderFormat: [TranscoderFormat.PVRTC1_4_RGB, TranscoderFormat.PVRTC1_4_RGBA],
+          engineFormat: [EngineFormat.RGB_PVRTC_4BPPV1_Format, EngineFormat.RGBA_PVRTC_4BPPV1_Format],
+          priorityETC1S: 5,
+          priorityUASTC: 6,
+          needsPowerOfTwo: true,
+        },
+      ]
+
+      const ETC1S_OPTIONS = FORMAT_OPTIONS.sort(function (a, b) {
+        return a.priorityETC1S - b.priorityETC1S
+      })
+      const UASTC_OPTIONS = FORMAT_OPTIONS.sort(function (a, b) {
+        return a.priorityUASTC - b.priorityUASTC
+      })
 
-      return { width, height, hasAlpha, mipmaps, format: engineFormat }
-    }
+      function getTranscoderFormat(basisFormat, width, height, hasAlpha) {
+        let transcoderFormat
+        let engineFormat
 
-    //
-
-    // Optimal choice of a transcoder target format depends on the Basis format (ETC1S or UASTC),
-    // device capabilities, and texture dimensions. The list below ranks the formats separately
-    // for ETC1S and UASTC.
-    //
-    // In some cases, transcoding UASTC to RGBA32 might be preferred for higher quality (at
-    // significant memory cost) compared to ETC1/2, BC1/3, and PVRTC. The transcoder currently
-    // chooses RGBA32 only as a last resort and does not expose that option to the caller.
-    const FORMAT_OPTIONS = [
-      {
-        if: 'astcSupported',
-        basisFormat: [BasisFormat.UASTC_4x4],
-        transcoderFormat: [TranscoderFormat.ASTC_4x4, TranscoderFormat.ASTC_4x4],
-        engineFormat: [EngineFormat.RGBA_ASTC_4x4_Format, EngineFormat.RGBA_ASTC_4x4_Format],
-        priorityETC1S: Infinity,
-        priorityUASTC: 1,
-        needsPowerOfTwo: false,
-      },
-      {
-        if: 'bptcSupported',
-        basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
-        transcoderFormat: [TranscoderFormat.BC7_M5, TranscoderFormat.BC7_M5],
-        engineFormat: [EngineFormat.RGBA_BPTC_Format, EngineFormat.RGBA_BPTC_Format],
-        priorityETC1S: 3,
-        priorityUASTC: 2,
-        needsPowerOfTwo: false,
-      },
-      {
-        if: 'dxtSupported',
-        basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
-        transcoderFormat: [TranscoderFormat.BC1, TranscoderFormat.BC3],
-        engineFormat: [EngineFormat.RGB_S3TC_DXT1_Format, EngineFormat.RGBA_S3TC_DXT5_Format],
-        priorityETC1S: 4,
-        priorityUASTC: 5,
-        needsPowerOfTwo: false,
-      },
-      {
-        if: 'etc2Supported',
-        basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
-        transcoderFormat: [TranscoderFormat.ETC1, TranscoderFormat.ETC2],
-        engineFormat: [EngineFormat.RGB_ETC2_Format, EngineFormat.RGBA_ETC2_EAC_Format],
-        priorityETC1S: 1,
-        priorityUASTC: 3,
-        needsPowerOfTwo: false,
-      },
-      {
-        if: 'etc1Supported',
-        basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
-        transcoderFormat: [TranscoderFormat.ETC1, TranscoderFormat.ETC1],
-        engineFormat: [EngineFormat.RGB_ETC1_Format, EngineFormat.RGB_ETC1_Format],
-        priorityETC1S: 2,
-        priorityUASTC: 4,
-        needsPowerOfTwo: false,
-      },
-      {
-        if: 'pvrtcSupported',
-        basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
-        transcoderFormat: [TranscoderFormat.PVRTC1_4_RGB, TranscoderFormat.PVRTC1_4_RGBA],
-        engineFormat: [EngineFormat.RGB_PVRTC_4BPPV1_Format, EngineFormat.RGBA_PVRTC_4BPPV1_Format],
-        priorityETC1S: 5,
-        priorityUASTC: 6,
-        needsPowerOfTwo: true,
-      },
-    ]
-
-    const ETC1S_OPTIONS = FORMAT_OPTIONS.sort(function (a, b) {
-      return a.priorityETC1S - b.priorityETC1S
-    })
-    const UASTC_OPTIONS = FORMAT_OPTIONS.sort(function (a, b) {
-      return a.priorityUASTC - b.priorityUASTC
-    })
-
-    function getTranscoderFormat(basisFormat, width, height, hasAlpha) {
-      let transcoderFormat
-      let engineFormat
-
-      const options = basisFormat === BasisFormat.ETC1S ? ETC1S_OPTIONS : UASTC_OPTIONS
-
-      for (let i = 0; i < options.length; i++) {
-        const opt = options[i]
-
-        if (!config[opt.if]) continue
-        if (!opt.basisFormat.includes(basisFormat)) continue
-        if (opt.needsPowerOfTwo && !(isPowerOfTwo(width) && isPowerOfTwo(height))) continue
-
-        transcoderFormat = opt.transcoderFormat[hasAlpha ? 1 : 0]
-        engineFormat = opt.engineFormat[hasAlpha ? 1 : 0]
+        const options = basisFormat === BasisFormat.ETC1S ? ETC1S_OPTIONS : UASTC_OPTIONS
 
-        return { transcoderFormat, engineFormat }
-      }
-
-      console.warn('THREE.BasisTextureLoader: No suitable compressed texture format found. Decoding to RGBA32.')
+        for (let i = 0; i < options.length; i++) {
+          const opt = options[i]
 
-      transcoderFormat = TranscoderFormat.RGBA32
-      engineFormat = EngineFormat.RGBAFormat
+          if (!config[opt.if]) continue
+          if (!opt.basisFormat.includes(basisFormat)) continue
+          if (opt.needsPowerOfTwo && !(isPowerOfTwo(width) && isPowerOfTwo(height))) continue
 
-      return { transcoderFormat, engineFormat }
-    }
+          transcoderFormat = opt.transcoderFormat[hasAlpha ? 1 : 0]
+          engineFormat = opt.engineFormat[hasAlpha ? 1 : 0]
 
-    function assert(ok, message) {
-      if (!ok) throw new Error(message)
-    }
+          return { transcoderFormat, engineFormat }
+        }
 
-    function getWidthInBlocks(transcoderFormat, width) {
-      return Math.ceil(width / BasisModule.getFormatBlockWidth(transcoderFormat))
-    }
+        console.warn('THREE.BasisTextureLoader: No suitable compressed texture format found. Decoding to RGBA32.')
 
-    function getHeightInBlocks(transcoderFormat, height) {
-      return Math.ceil(height / BasisModule.getFormatBlockHeight(transcoderFormat))
-    }
+        transcoderFormat = TranscoderFormat.RGBA32
+        engineFormat = EngineFormat.RGBAFormat
 
-    function getTranscodedImageByteLength(transcoderFormat, width, height) {
-      const blockByteLength = BasisModule.getBytesPerBlockOrPixel(transcoderFormat)
+        return { transcoderFormat, engineFormat }
+      }
 
-      if (BasisModule.formatIsUncompressed(transcoderFormat)) {
-        return width * height * blockByteLength
+      function assert(ok, message) {
+        if (!ok) throw new Error(message)
       }
 
-      if (transcoderFormat === TranscoderFormat.PVRTC1_4_RGB || transcoderFormat === TranscoderFormat.PVRTC1_4_RGBA) {
-        // GL requires extra padding for very small textures:
-        // https://www.khronos.org/registry/OpenGL/extensions/IMG/IMG_texture_compression_pvrtc.txt
-        const paddedWidth = (width + 3) & ~3
-        const paddedHeight = (height + 3) & ~3
+      function getWidthInBlocks(transcoderFormat, width) {
+        return Math.ceil(width / BasisModule.getFormatBlockWidth(transcoderFormat))
+      }
 
-        return (Math.max(8, paddedWidth) * Math.max(8, paddedHeight) * 4 + 7) / 8
+      function getHeightInBlocks(transcoderFormat, height) {
+        return Math.ceil(height / BasisModule.getFormatBlockHeight(transcoderFormat))
       }
 
-      return getWidthInBlocks(transcoderFormat, width) * getHeightInBlocks(transcoderFormat, height) * blockByteLength
-    }
+      function getTranscodedImageByteLength(transcoderFormat, width, height) {
+        const blockByteLength = BasisModule.getBytesPerBlockOrPixel(transcoderFormat)
 
-    function isPowerOfTwo(value) {
-      if (value <= 2) return true
+        if (BasisModule.formatIsUncompressed(transcoderFormat)) {
+          return width * height * blockByteLength
+        }
 
-      return (value & (value - 1)) === 0 && value !== 0
-    }
-  }
+        if (transcoderFormat === TranscoderFormat.PVRTC1_4_RGB || transcoderFormat === TranscoderFormat.PVRTC1_4_RGBA) {
+          // GL requires extra padding for very small textures:
+          // https://www.khronos.org/registry/OpenGL/extensions/IMG/IMG_texture_compression_pvrtc.txt
+          const paddedWidth = (width + 3) & ~3
+          const paddedHeight = (height + 3) & ~3
 
-  constructor(manager) {
-    super(manager)
+          return (Math.max(8, paddedWidth) * Math.max(8, paddedHeight) * 4 + 7) / 8
+        }
 
-    this.transcoderPath = ''
-    this.transcoderBinary = null
-    this.transcoderPending = null
+        return getWidthInBlocks(transcoderFormat, width) * getHeightInBlocks(transcoderFormat, height) * blockByteLength
+      }
 
-    this.workerLimit = 4
-    this.workerPool = []
-    this.workerNextTaskID = 1
-    this.workerSourceURL = ''
-    this.workerConfig = null
-  }
+      function isPowerOfTwo(value) {
+        if (value <= 2) return true
 
-  setTranscoderPath(path) {
-    this.transcoderPath = path
+        return (value & (value - 1)) === 0 && value !== 0
+      }
+    }
 
-    return this
-  }
+    constructor(manager) {
+      super(manager)
 
-  setWorkerLimit(workerLimit) {
-    this.workerLimit = workerLimit
+      this.transcoderPath = ''
+      this.transcoderBinary = null
+      this.transcoderPending = null
 
-    return this
-  }
+      this.workerLimit = 4
+      this.workerPool = []
+      this.workerNextTaskID = 1
+      this.workerSourceURL = ''
+      this.workerConfig = null
+    }
 
-  detectSupport(renderer) {
-    this.workerConfig = {
-      astcSupported: renderer.extensions.has('WEBGL_compressed_texture_astc'),
-      etc1Supported: renderer.extensions.has('WEBGL_compressed_texture_etc1'),
-      etc2Supported: renderer.extensions.has('WEBGL_compressed_texture_etc'),
-      dxtSupported: renderer.extensions.has('WEBGL_compressed_texture_s3tc'),
-      bptcSupported: renderer.extensions.has('EXT_texture_compression_bptc'),
-      pvrtcSupported:
-        renderer.extensions.has('WEBGL_compressed_texture_pvrtc') ||
-        renderer.extensions.has('WEBKIT_WEBGL_compressed_texture_pvrtc'),
+    setTranscoderPath(path) {
+      this.transcoderPath = path
+
+      return this
     }
 
-    return this
-  }
+    setWorkerLimit(workerLimit) {
+      this.workerLimit = workerLimit
 
-  load(url, onLoad, onProgress, onError) {
-    const loader = new FileLoader(this.manager)
+      return this
+    }
 
-    loader.setResponseType('arraybuffer')
-    loader.setWithCredentials(this.withCredentials)
+    detectSupport(renderer) {
+      this.workerConfig = {
+        astcSupported: renderer.extensions.has('WEBGL_compressed_texture_astc'),
+        etc1Supported: renderer.extensions.has('WEBGL_compressed_texture_etc1'),
+        etc2Supported: renderer.extensions.has('WEBGL_compressed_texture_etc'),
+        dxtSupported: renderer.extensions.has('WEBGL_compressed_texture_s3tc'),
+        bptcSupported: renderer.extensions.has('EXT_texture_compression_bptc'),
+        pvrtcSupported:
+          renderer.extensions.has('WEBGL_compressed_texture_pvrtc') ||
+          renderer.extensions.has('WEBKIT_WEBGL_compressed_texture_pvrtc'),
+      }
 
-    const texture = new CompressedTexture()
+      return this
+    }
 
-    loader.load(
-      url,
-      (buffer) => {
-        // Check for an existing task using this buffer. A transferred buffer cannot be transferred
-        // again from this thread.
-        if (_taskCache.has(buffer)) {
-          const cachedTask = _taskCache.get(buffer)
+    load(url, onLoad, onProgress, onError) {
+      const loader = new FileLoader(this.manager)
 
-          return cachedTask.promise.then(onLoad).catch(onError)
-        }
+      loader.setResponseType('arraybuffer')
+      loader.setWithCredentials(this.withCredentials)
 
-        this._createTexture([buffer])
-          .then(function (_texture) {
-            texture.copy(_texture)
-            texture.needsUpdate = true
+      const texture = new CompressedTexture()
 
-            if (onLoad) onLoad(texture)
-          })
-          .catch(onError)
-      },
-      onProgress,
-      onError,
-    )
+      loader.load(
+        url,
+        (buffer) => {
+          // Check for an existing task using this buffer. A transferred buffer cannot be transferred
+          // again from this thread.
+          if (_taskCache.has(buffer)) {
+            const cachedTask = _taskCache.get(buffer)
 
-    return texture
-  }
+            return cachedTask.promise.then(onLoad).catch(onError)
+          }
 
-  /** Low-level transcoding API, exposed for use by KTX2Loader. */
-  parseInternalAsync(options) {
-    const { levels } = options
+          this._createTexture([buffer])
+            .then(function (_texture) {
+              texture.copy(_texture)
+              texture.needsUpdate = true
 
-    const buffers = new Set()
+              if (onLoad) onLoad(texture)
+            })
+            .catch(onError)
+        },
+        onProgress,
+        onError,
+      )
 
-    for (let i = 0; i < levels.length; i++) {
-      buffers.add(levels[i].data.buffer)
+      return texture
     }
 
-    return this._createTexture(Array.from(buffers), { ...options, lowLevel: true })
-  }
+    /** Low-level transcoding API, exposed for use by KTX2Loader. */
+    parseInternalAsync(options) {
+      const { levels } = options
 
-  /**
-   * @param {ArrayBuffer[]} buffers
-   * @param {object?} config
-   * @return {Promise<CompressedTexture>}
-   */
-  _createTexture(buffers, config = {}) {
-    let worker
-    let taskID
+      const buffers = new Set()
 
-    const taskConfig = config
-    let taskCost = 0
+      for (let i = 0; i < levels.length; i++) {
+        buffers.add(levels[i].data.buffer)
+      }
 
-    for (let i = 0; i < buffers.length; i++) {
-      taskCost += buffers[i].byteLength
+      return this._createTexture(Array.from(buffers), { ...options, lowLevel: true })
     }
 
-    const texturePending = this._allocateWorker(taskCost)
-      .then((_worker) => {
-        worker = _worker
-        taskID = this.workerNextTaskID++
+    /**
+     * @param {ArrayBuffer[]} buffers
+     * @param {object?} config
+     * @return {Promise<CompressedTexture>}
+     */
+    _createTexture(buffers, config = {}) {
+      let worker
+      let taskID
 
-        return new Promise((resolve, reject) => {
-          worker._callbacks[taskID] = { resolve, reject }
+      const taskConfig = config
+      let taskCost = 0
 
-          worker.postMessage({ type: 'transcode', id: taskID, buffers: buffers, taskConfig: taskConfig }, buffers)
-        })
-      })
-      .then((message) => {
-        const { mipmaps, width, height, format } = message
+      for (let i = 0; i < buffers.length; i++) {
+        taskCost += buffers[i].byteLength
+      }
 
-        const texture = new CompressedTexture(mipmaps, width, height, format, UnsignedByteType)
-        texture.minFilter = mipmaps.length === 1 ? LinearFilter : LinearMipmapLinearFilter
-        texture.magFilter = LinearFilter
-        texture.generateMipmaps = false
-        texture.needsUpdate = true
+      const texturePending = this._allocateWorker(taskCost)
+        .then((_worker) => {
+          worker = _worker
+          taskID = this.workerNextTaskID++
 
-        return texture
-      })
+          return new Promise((resolve, reject) => {
+            worker._callbacks[taskID] = { resolve, reject }
 
-    // Note: replaced '.finally()' with '.catch().then()' block - iOS 11 support (#19416)
-    texturePending
-      .catch(() => true)
-      .then(() => {
-        if (worker && taskID) {
-          worker._taskLoad -= taskCost
-          delete worker._callbacks[taskID]
-        }
-      })
+            worker.postMessage({ type: 'transcode', id: taskID, buffers: buffers, taskConfig: taskConfig }, buffers)
+          })
+        })
+        .then((message) => {
+          const { mipmaps, width, height, format } = message
 
-    // Cache the task result.
-    _taskCache.set(buffers[0], { promise: texturePending })
+          const texture = new CompressedTexture(mipmaps, width, height, format, UnsignedByteType)
+          texture.minFilter = mipmaps.length === 1 ? LinearFilter : LinearMipmapLinearFilter
+          texture.magFilter = LinearFilter
+          texture.generateMipmaps = false
+          texture.needsUpdate = true
 
-    return texturePending
-  }
+          return texture
+        })
 
-  _initTranscoder() {
-    if (!this.transcoderPending) {
-      // Load transcoder wrapper.
-      const jsLoader = new FileLoader(this.manager)
-      jsLoader.setPath(this.transcoderPath)
-      jsLoader.setWithCredentials(this.withCredentials)
-      const jsContent = new Promise((resolve, reject) => {
-        jsLoader.load('basis_transcoder.js', resolve, undefined, reject)
-      })
+      // Note: replaced '.finally()' with '.catch().then()' block - iOS 11 support (#19416)
+      texturePending
+        .catch(() => true)
+        .then(() => {
+          if (worker && taskID) {
+            worker._taskLoad -= taskCost
+            delete worker._callbacks[taskID]
+          }
+        })
 
-      // Load transcoder WASM binary.
-      const binaryLoader = new FileLoader(this.manager)
-      binaryLoader.setPath(this.transcoderPath)
-      binaryLoader.setResponseType('arraybuffer')
-      binaryLoader.setWithCredentials(this.withCredentials)
-      const binaryContent = new Promise((resolve, reject) => {
-        binaryLoader.load('basis_transcoder.wasm', resolve, undefined, reject)
-      })
+      // Cache the task result.
+      _taskCache.set(buffers[0], { promise: texturePending })
 
-      this.transcoderPending = Promise.all([jsContent, binaryContent]).then(([jsContent, binaryContent]) => {
-        const fn = BasisTextureLoader.BasisWorker.toString()
-
-        const body = [
-          '/* constants */',
-          'let _EngineFormat = ' + JSON.stringify(BasisTextureLoader.EngineFormat),
-          'let _TranscoderFormat = ' + JSON.stringify(BasisTextureLoader.TranscoderFormat),
-          'let _BasisFormat = ' + JSON.stringify(BasisTextureLoader.BasisFormat),
-          '/* basis_transcoder.js */',
-          jsContent,
-          '/* worker */',
-          fn.substring(fn.indexOf('{') + 1, fn.lastIndexOf('}')),
-        ].join('\n')
-
-        this.workerSourceURL = URL.createObjectURL(new Blob([body]))
-        this.transcoderBinary = binaryContent
-      })
+      return texturePending
     }
 
-    return this.transcoderPending
-  }
-
-  _allocateWorker(taskCost) {
-    return this._initTranscoder().then(() => {
-      if (this.workerPool.length < this.workerLimit) {
-        const worker = new Worker(this.workerSourceURL)
+    _initTranscoder() {
+      if (!this.transcoderPending) {
+        // Load transcoder wrapper.
+        const jsLoader = new FileLoader(this.manager)
+        jsLoader.setPath(this.transcoderPath)
+        jsLoader.setWithCredentials(this.withCredentials)
+        const jsContent = new Promise((resolve, reject) => {
+          jsLoader.load('basis_transcoder.js', resolve, undefined, reject)
+        })
 
-        worker._callbacks = {}
-        worker._taskLoad = 0
+        // Load transcoder WASM binary.
+        const binaryLoader = new FileLoader(this.manager)
+        binaryLoader.setPath(this.transcoderPath)
+        binaryLoader.setResponseType('arraybuffer')
+        binaryLoader.setWithCredentials(this.withCredentials)
+        const binaryContent = new Promise((resolve, reject) => {
+          binaryLoader.load('basis_transcoder.wasm', resolve, undefined, reject)
+        })
 
-        worker.postMessage({
-          type: 'init',
-          config: this.workerConfig,
-          transcoderBinary: this.transcoderBinary,
+        this.transcoderPending = Promise.all([jsContent, binaryContent]).then(([jsContent, binaryContent]) => {
+          const fn = BasisTextureLoader.BasisWorker.toString()
+
+          const body = [
+            '/* constants */',
+            'let _EngineFormat = ' + JSON.stringify(BasisTextureLoader.EngineFormat),
+            'let _TranscoderFormat = ' + JSON.stringify(BasisTextureLoader.TranscoderFormat),
+            'let _BasisFormat = ' + JSON.stringify(BasisTextureLoader.BasisFormat),
+            '/* basis_transcoder.js */',
+            jsContent,
+            '/* worker */',
+            fn.substring(fn.indexOf('{') + 1, fn.lastIndexOf('}')),
+          ].join('\n')
+
+          this.workerSourceURL = URL.createObjectURL(new Blob([body]))
+          this.transcoderBinary = binaryContent
         })
+      }
 
-        worker.onmessage = function (e) {
-          const message = e.data
+      return this.transcoderPending
+    }
 
-          switch (message.type) {
-            case 'transcode':
-              worker._callbacks[message.id].resolve(message)
-              break
+    _allocateWorker(taskCost) {
+      return this._initTranscoder().then(() => {
+        if (this.workerPool.length < this.workerLimit) {
+          const worker = new Worker(this.workerSourceURL)
 
-            case 'error':
-              worker._callbacks[message.id].reject(message)
-              break
+          worker._callbacks = {}
+          worker._taskLoad = 0
 
-            default:
-              console.error('THREE.BasisTextureLoader: Unexpected message, "' + message.type + '"')
-          }
-        }
+          worker.postMessage({
+            type: 'init',
+            config: this.workerConfig,
+            transcoderBinary: this.transcoderBinary,
+          })
 
-        this.workerPool.push(worker)
-      } else {
-        this.workerPool.sort(function (a, b) {
-          return a._taskLoad > b._taskLoad ? -1 : 1
-        })
-      }
+          worker.onmessage = function (e) {
+            const message = e.data
 
-      const worker = this.workerPool[this.workerPool.length - 1]
+            switch (message.type) {
+              case 'transcode':
+                worker._callbacks[message.id].resolve(message)
+                break
 
-      worker._taskLoad += taskCost
+              case 'error':
+                worker._callbacks[message.id].reject(message)
+                break
 
-      return worker
-    })
-  }
+              default:
+                console.error('THREE.BasisTextureLoader: Unexpected message, "' + message.type + '"')
+            }
+          }
+
+          this.workerPool.push(worker)
+        } else {
+          this.workerPool.sort(function (a, b) {
+            return a._taskLoad > b._taskLoad ? -1 : 1
+          })
+        }
 
-  dispose() {
-    for (let i = 0; i < this.workerPool.length; i++) {
-      this.workerPool[i].terminate()
+        const worker = this.workerPool[this.workerPool.length - 1]
+
+        worker._taskLoad += taskCost
+
+        return worker
+      })
     }
 
-    this.workerPool.length = 0
+    dispose() {
+      for (let i = 0; i < this.workerPool.length; i++) {
+        this.workerPool[i].terminate()
+      }
 
-    return this
+      this.workerPool.length = 0
+
+      return this
+    }
   }
-}
+
+  return BasisTextureLoader
+})()
 
 export { BasisTextureLoader }
diff --git a/src/loaders/EXRLoader.js b/src/loaders/EXRLoader.js
index fd311038..002bfefd 100644
--- a/src/loaders/EXRLoader.js
+++ b/src/loaders/EXRLoader.js
@@ -9,6 +9,7 @@ import {
   RGBAFormat,
 } from 'three'
 import { unzlibSync } from 'fflate'
+import { version } from '../_polyfill/constants'
 
 /**
  * OpenEXR loader currently supports uncompressed, ZIP(S), RLE, PIZ and DWA/B compression.
@@ -83,7 +84,8 @@ import { unzlibSync } from 'fflate'
 
 // // End of OpenEXR license -------------------------------------------------
 
-const hasColorSpace = 'colorSpace' in new Texture()
+// https://github.com/mrdoob/three.js/pull/25771
+const hasColorSpace = version >= 152
 
 class EXRLoader extends DataTextureLoader {
   constructor(manager) {
diff --git a/src/loaders/FBXLoader.js b/src/loaders/FBXLoader.js
index e171ec87..034e4bb3 100644
--- a/src/loaders/FBXLoader.js
+++ b/src/loaders/FBXLoader.js
@@ -1275,8 +1275,8 @@ class GeometryParser {
     }
 
     buffers.uvs.forEach(function (uvBuffer, i) {
-      if (UV1 === 'uv2') i++;
-      const name = i === 0 ? 'uv' : `uv${i}`;
+      if (UV1 === 'uv2') i++
+      const name = i === 0 ? 'uv' : `uv${i}`
 
       geo.setAttribute(name, new Float32BufferAttribute(buffers.uvs[i], 2))
     })
@@ -3113,8 +3113,8 @@ function getData(polygonVertexIndex, polygonIndex, vertexIndex, infoObject) {
   return slice(dataArray, infoObject.buffer, from, to)
 }
 
-const tempEuler = new Euler()
-const tempVec = new Vector3()
+const tempEuler = /* @__PURE__ */ new Euler()
+const tempVec = /* @__PURE__ */ new Vector3()
 
 // generate transformation from FBX transform data
 // ref: https://help.autodesk.com/view/FBX/2017/ENU/?guid=__files_GUID_10CDD63C_79C1_4F2D_BB28_AD2BE65A02ED_htm
diff --git a/src/loaders/FontLoader.ts b/src/loaders/FontLoader.ts
index cb0e4ee4..00aa0643 100644
--- a/src/loaders/FontLoader.ts
+++ b/src/loaders/FontLoader.ts
@@ -66,8 +66,8 @@ type FontData = {
 
 export class Font {
   public data: FontData
-  public static isFont: true
-  public static type: 'Font'
+  public isFont = true
+  public type = 'Font'
 
   constructor(data: FontData) {
     this.data = data
diff --git a/src/loaders/GLTFLoader.js b/src/loaders/GLTFLoader.js
index c4b7d01c..dd037655 100644
--- a/src/loaders/GLTFLoader.js
+++ b/src/loaders/GLTFLoader.js
@@ -1676,7 +1676,7 @@ class GLTFCubicSplineInterpolant extends Interpolant {
   }
 }
 
-const _q = new Quaternion()
+const _q = /* @__PURE__ */ new Quaternion()
 
 class GLTFCubicSplineQuaternionInterpolant extends GLTFCubicSplineInterpolant {
   interpolate_(i1, t0, t, t1) {
@@ -2006,7 +2006,7 @@ function getImageURIMimeType(uri) {
   return 'image/png'
 }
 
-const _identityMatrix = new Matrix4()
+const _identityMatrix = /* @__PURE__ */ new Matrix4()
 
 /* GLTF PARSER */
 
diff --git a/src/loaders/KTX2Loader.js b/src/loaders/KTX2Loader.js
index f2b25571..ae2758c7 100644
--- a/src/loaders/KTX2Loader.js
+++ b/src/loaders/KTX2Loader.js
@@ -81,534 +81,538 @@ let _activeLoaders = 0
 
 let _zstd
 
-class KTX2Loader extends Loader {
-  /* CONSTANTS */
+const KTX2Loader = /* @__PURE__ */ (() => {
+  class KTX2Loader extends Loader {
+    /* CONSTANTS */
 
-  static BasisFormat = {
-    ETC1S: 0,
-    UASTC_4x4: 1,
-  }
-
-  static TranscoderFormat = {
-    ETC1: 0,
-    ETC2: 1,
-    BC1: 2,
-    BC3: 3,
-    BC4: 4,
-    BC5: 5,
-    BC7_M6_OPAQUE_ONLY: 6,
-    BC7_M5: 7,
-    PVRTC1_4_RGB: 8,
-    PVRTC1_4_RGBA: 9,
-    ASTC_4x4: 10,
-    ATC_RGB: 11,
-    ATC_RGBA_INTERPOLATED_ALPHA: 12,
-    RGBA32: 13,
-    RGB565: 14,
-    BGR565: 15,
-    RGBA4444: 16,
-  }
-
-  static EngineFormat = {
-    RGBAFormat: RGBAFormat,
-    RGBA_ASTC_4x4_Format: RGBA_ASTC_4x4_Format,
-    RGBA_BPTC_Format: RGBA_BPTC_Format,
-    RGBA_ETC2_EAC_Format: RGBA_ETC2_EAC_Format,
-    RGBA_PVRTC_4BPPV1_Format: RGBA_PVRTC_4BPPV1_Format,
-    RGBA_S3TC_DXT5_Format: RGBA_S3TC_DXT5_Format,
-    RGB_ETC1_Format: RGB_ETC1_Format,
-    RGB_ETC2_Format: RGB_ETC2_Format,
-    RGB_PVRTC_4BPPV1_Format: RGB_PVRTC_4BPPV1_Format,
-    RGB_S3TC_DXT1_Format: RGB_S3TC_DXT1_Format,
-  }
+    static BasisFormat = {
+      ETC1S: 0,
+      UASTC_4x4: 1,
+    }
 
-  /* WEB WORKER */
-
-  static BasisWorker = function () {
-    let config
-    let transcoderPending
-    let BasisModule
-
-    /** @type KTX2Loader.EngineFormat */
-    const EngineFormat = _EngineFormat
-    /** @type KTX2Loader.TranscoderFormat */
-    const TranscoderFormat = _TranscoderFormat
-    /** @type KTX2Loader.BasisFormat */
-    const BasisFormat = _BasisFormat
-
-    self.addEventListener('message', function (e) {
-      const message = e.data
-
-      switch (message.type) {
-        case 'init':
-          config = message.config
-          init(message.transcoderBinary)
-          break
-
-        case 'transcode':
-          transcoderPending.then(() => {
-            try {
-              const { faces, buffers, width, height, hasAlpha, format, dfdFlags } = transcode(message.buffer)
-
-              self.postMessage(
-                { type: 'transcode', id: message.id, faces, width, height, hasAlpha, format, dfdFlags },
-                buffers,
-              )
-            } catch (error) {
-              console.error(error)
-
-              self.postMessage({ type: 'error', id: message.id, error: error.message })
-            }
-          })
-          break
-      }
-    })
+    static TranscoderFormat = {
+      ETC1: 0,
+      ETC2: 1,
+      BC1: 2,
+      BC3: 3,
+      BC4: 4,
+      BC5: 5,
+      BC7_M6_OPAQUE_ONLY: 6,
+      BC7_M5: 7,
+      PVRTC1_4_RGB: 8,
+      PVRTC1_4_RGBA: 9,
+      ASTC_4x4: 10,
+      ATC_RGB: 11,
+      ATC_RGBA_INTERPOLATED_ALPHA: 12,
+      RGBA32: 13,
+      RGB565: 14,
+      BGR565: 15,
+      RGBA4444: 16,
+    }
 
-    function init(wasmBinary) {
-      transcoderPending = new Promise((resolve) => {
-        BasisModule = { wasmBinary, onRuntimeInitialized: resolve }
-        BASIS(BasisModule)
-      }).then(() => {
-        BasisModule.initializeBasis()
+    static EngineFormat = {
+      RGBAFormat: RGBAFormat,
+      RGBA_ASTC_4x4_Format: RGBA_ASTC_4x4_Format,
+      RGBA_BPTC_Format: RGBA_BPTC_Format,
+      RGBA_ETC2_EAC_Format: RGBA_ETC2_EAC_Format,
+      RGBA_PVRTC_4BPPV1_Format: RGBA_PVRTC_4BPPV1_Format,
+      RGBA_S3TC_DXT5_Format: RGBA_S3TC_DXT5_Format,
+      RGB_ETC1_Format: RGB_ETC1_Format,
+      RGB_ETC2_Format: RGB_ETC2_Format,
+      RGB_PVRTC_4BPPV1_Format: RGB_PVRTC_4BPPV1_Format,
+      RGB_S3TC_DXT1_Format: RGB_S3TC_DXT1_Format,
+    }
 
-        if (BasisModule.KTX2File === undefined) {
-          console.warn('THREE.KTX2Loader: Please update Basis Universal transcoder.')
+    /* WEB WORKER */
+
+    static BasisWorker = function () {
+      let config
+      let transcoderPending
+      let BasisModule
+
+      /** @type KTX2Loader.EngineFormat */
+      const EngineFormat = _EngineFormat
+      /** @type KTX2Loader.TranscoderFormat */
+      const TranscoderFormat = _TranscoderFormat
+      /** @type KTX2Loader.BasisFormat */
+      const BasisFormat = _BasisFormat
+
+      self.addEventListener('message', function (e) {
+        const message = e.data
+
+        switch (message.type) {
+          case 'init':
+            config = message.config
+            init(message.transcoderBinary)
+            break
+
+          case 'transcode':
+            transcoderPending.then(() => {
+              try {
+                const { faces, buffers, width, height, hasAlpha, format, dfdFlags } = transcode(message.buffer)
+
+                self.postMessage(
+                  { type: 'transcode', id: message.id, faces, width, height, hasAlpha, format, dfdFlags },
+                  buffers,
+                )
+              } catch (error) {
+                console.error(error)
+
+                self.postMessage({ type: 'error', id: message.id, error: error.message })
+              }
+            })
+            break
         }
       })
-    }
-
-    function transcode(buffer) {
-      const ktx2File = new BasisModule.KTX2File(new Uint8Array(buffer))
-
-      function cleanup() {
-        ktx2File.close()
-        ktx2File.delete()
-      }
-
-      if (!ktx2File.isValid()) {
-        cleanup()
-        throw new Error('THREE.KTX2Loader:	Invalid or unsupported .ktx2 file')
-      }
-
-      const basisFormat = ktx2File.isUASTC() ? BasisFormat.UASTC_4x4 : BasisFormat.ETC1S
-      const width = ktx2File.getWidth()
-      const height = ktx2File.getHeight()
-      const layerCount = ktx2File.getLayers() || 1
-      const levelCount = ktx2File.getLevels()
-      const faceCount = ktx2File.getFaces()
-      const hasAlpha = ktx2File.getHasAlpha()
-      const dfdFlags = ktx2File.getDFDFlags()
 
-      const { transcoderFormat, engineFormat } = getTranscoderFormat(basisFormat, width, height, hasAlpha)
+      function init(wasmBinary) {
+        transcoderPending = new Promise((resolve) => {
+          BasisModule = { wasmBinary, onRuntimeInitialized: resolve }
+          BASIS(BasisModule)
+        }).then(() => {
+          BasisModule.initializeBasis()
 
-      if (!width || !height || !levelCount) {
-        cleanup()
-        throw new Error('THREE.KTX2Loader:	Invalid texture')
+          if (BasisModule.KTX2File === undefined) {
+            console.warn('THREE.KTX2Loader: Please update Basis Universal transcoder.')
+          }
+        })
       }
 
-      if (!ktx2File.startTranscoding()) {
-        cleanup()
-        throw new Error('THREE.KTX2Loader: .startTranscoding failed')
-      }
+      function transcode(buffer) {
+        const ktx2File = new BasisModule.KTX2File(new Uint8Array(buffer))
 
-      const faces = []
-      const buffers = []
+        function cleanup() {
+          ktx2File.close()
+          ktx2File.delete()
+        }
 
-      for (let face = 0; face < faceCount; face++) {
-        const mipmaps = []
+        if (!ktx2File.isValid()) {
+          cleanup()
+          throw new Error('THREE.KTX2Loader:	Invalid or unsupported .ktx2 file')
+        }
 
-        for (let mip = 0; mip < levelCount; mip++) {
-          const layerMips = []
+        const basisFormat = ktx2File.isUASTC() ? BasisFormat.UASTC_4x4 : BasisFormat.ETC1S
+        const width = ktx2File.getWidth()
+        const height = ktx2File.getHeight()
+        const layerCount = ktx2File.getLayers() || 1
+        const levelCount = ktx2File.getLevels()
+        const faceCount = ktx2File.getFaces()
+        const hasAlpha = ktx2File.getHasAlpha()
+        const dfdFlags = ktx2File.getDFDFlags()
 
-          let mipWidth, mipHeight
+        const { transcoderFormat, engineFormat } = getTranscoderFormat(basisFormat, width, height, hasAlpha)
 
-          for (let layer = 0; layer < layerCount; layer++) {
-            const levelInfo = ktx2File.getImageLevelInfo(mip, layer, face)
+        if (!width || !height || !levelCount) {
+          cleanup()
+          throw new Error('THREE.KTX2Loader:	Invalid texture')
+        }
 
-            if (
-              face === 0 &&
-              mip === 0 &&
-              layer === 0 &&
-              (levelInfo.origWidth % 4 !== 0 || levelInfo.origHeight % 4 !== 0)
-            ) {
-              console.warn('THREE.KTX2Loader: ETC1S and UASTC textures should use multiple-of-four dimensions.')
-            }
+        if (!ktx2File.startTranscoding()) {
+          cleanup()
+          throw new Error('THREE.KTX2Loader: .startTranscoding failed')
+        }
 
-            if (levelCount > 1) {
-              mipWidth = levelInfo.origWidth
-              mipHeight = levelInfo.origHeight
-            } else {
-              // Handles non-multiple-of-four dimensions in textures without mipmaps. Textures with
-              // mipmaps must use multiple-of-four dimensions, for some texture formats and APIs.
-              // See mrdoob/three.js#25908.
-              mipWidth = levelInfo.width
-              mipHeight = levelInfo.height
+        const faces = []
+        const buffers = []
+
+        for (let face = 0; face < faceCount; face++) {
+          const mipmaps = []
+
+          for (let mip = 0; mip < levelCount; mip++) {
+            const layerMips = []
+
+            let mipWidth, mipHeight
+
+            for (let layer = 0; layer < layerCount; layer++) {
+              const levelInfo = ktx2File.getImageLevelInfo(mip, layer, face)
+
+              if (
+                face === 0 &&
+                mip === 0 &&
+                layer === 0 &&
+                (levelInfo.origWidth % 4 !== 0 || levelInfo.origHeight % 4 !== 0)
+              ) {
+                console.warn('THREE.KTX2Loader: ETC1S and UASTC textures should use multiple-of-four dimensions.')
+              }
+
+              if (levelCount > 1) {
+                mipWidth = levelInfo.origWidth
+                mipHeight = levelInfo.origHeight
+              } else {
+                // Handles non-multiple-of-four dimensions in textures without mipmaps. Textures with
+                // mipmaps must use multiple-of-four dimensions, for some texture formats and APIs.
+                // See mrdoob/three.js#25908.
+                mipWidth = levelInfo.width
+                mipHeight = levelInfo.height
+              }
+
+              const dst = new Uint8Array(ktx2File.getImageTranscodedSizeInBytes(mip, layer, 0, transcoderFormat))
+              const status = ktx2File.transcodeImage(dst, mip, layer, face, transcoderFormat, 0, -1, -1)
+
+              if (!status) {
+                cleanup()
+                throw new Error('THREE.KTX2Loader: .transcodeImage failed.')
+              }
+
+              layerMips.push(dst)
             }
 
-            const dst = new Uint8Array(ktx2File.getImageTranscodedSizeInBytes(mip, layer, 0, transcoderFormat))
-            const status = ktx2File.transcodeImage(dst, mip, layer, face, transcoderFormat, 0, -1, -1)
+            const mipData = concat(layerMips)
 
-            if (!status) {
-              cleanup()
-              throw new Error('THREE.KTX2Loader: .transcodeImage failed.')
-            }
-
-            layerMips.push(dst)
+            mipmaps.push({ data: mipData, width: mipWidth, height: mipHeight })
+            buffers.push(mipData.buffer)
           }
 
-          const mipData = concat(layerMips)
-
-          mipmaps.push({ data: mipData, width: mipWidth, height: mipHeight })
-          buffers.push(mipData.buffer)
+          faces.push({ mipmaps, width, height, format: engineFormat })
         }
 
-        faces.push({ mipmaps, width, height, format: engineFormat })
+        cleanup()
+
+        return { faces, buffers, width, height, hasAlpha, format: engineFormat, dfdFlags }
       }
 
-      cleanup()
+      //
+
+      // Optimal choice of a transcoder target format depends on the Basis format (ETC1S or UASTC),
+      // device capabilities, and texture dimensions. The list below ranks the formats separately
+      // for ETC1S and UASTC.
+      //
+      // In some cases, transcoding UASTC to RGBA32 might be preferred for higher quality (at
+      // significant memory cost) compared to ETC1/2, BC1/3, and PVRTC. The transcoder currently
+      // chooses RGBA32 only as a last resort and does not expose that option to the caller.
+      const FORMAT_OPTIONS = [
+        {
+          if: 'astcSupported',
+          basisFormat: [BasisFormat.UASTC_4x4],
+          transcoderFormat: [TranscoderFormat.ASTC_4x4, TranscoderFormat.ASTC_4x4],
+          engineFormat: [EngineFormat.RGBA_ASTC_4x4_Format, EngineFormat.RGBA_ASTC_4x4_Format],
+          priorityETC1S: Infinity,
+          priorityUASTC: 1,
+          needsPowerOfTwo: false,
+        },
+        {
+          if: 'bptcSupported',
+          basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
+          transcoderFormat: [TranscoderFormat.BC7_M5, TranscoderFormat.BC7_M5],
+          engineFormat: [EngineFormat.RGBA_BPTC_Format, EngineFormat.RGBA_BPTC_Format],
+          priorityETC1S: 3,
+          priorityUASTC: 2,
+          needsPowerOfTwo: false,
+        },
+        {
+          if: 'dxtSupported',
+          basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
+          transcoderFormat: [TranscoderFormat.BC1, TranscoderFormat.BC3],
+          engineFormat: [EngineFormat.RGB_S3TC_DXT1_Format, EngineFormat.RGBA_S3TC_DXT5_Format],
+          priorityETC1S: 4,
+          priorityUASTC: 5,
+          needsPowerOfTwo: false,
+        },
+        {
+          if: 'etc2Supported',
+          basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
+          transcoderFormat: [TranscoderFormat.ETC1, TranscoderFormat.ETC2],
+          engineFormat: [EngineFormat.RGB_ETC2_Format, EngineFormat.RGBA_ETC2_EAC_Format],
+          priorityETC1S: 1,
+          priorityUASTC: 3,
+          needsPowerOfTwo: false,
+        },
+        {
+          if: 'etc1Supported',
+          basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
+          transcoderFormat: [TranscoderFormat.ETC1],
+          engineFormat: [EngineFormat.RGB_ETC1_Format],
+          priorityETC1S: 2,
+          priorityUASTC: 4,
+          needsPowerOfTwo: false,
+        },
+        {
+          if: 'pvrtcSupported',
+          basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
+          transcoderFormat: [TranscoderFormat.PVRTC1_4_RGB, TranscoderFormat.PVRTC1_4_RGBA],
+          engineFormat: [EngineFormat.RGB_PVRTC_4BPPV1_Format, EngineFormat.RGBA_PVRTC_4BPPV1_Format],
+          priorityETC1S: 5,
+          priorityUASTC: 6,
+          needsPowerOfTwo: true,
+        },
+      ]
+
+      const ETC1S_OPTIONS = FORMAT_OPTIONS.sort(function (a, b) {
+        return a.priorityETC1S - b.priorityETC1S
+      })
+      const UASTC_OPTIONS = FORMAT_OPTIONS.sort(function (a, b) {
+        return a.priorityUASTC - b.priorityUASTC
+      })
+
+      function getTranscoderFormat(basisFormat, width, height, hasAlpha) {
+        let transcoderFormat
+        let engineFormat
 
-      return { faces, buffers, width, height, hasAlpha, format: engineFormat, dfdFlags }
-    }
+        const options = basisFormat === BasisFormat.ETC1S ? ETC1S_OPTIONS : UASTC_OPTIONS
 
-    //
-
-    // Optimal choice of a transcoder target format depends on the Basis format (ETC1S or UASTC),
-    // device capabilities, and texture dimensions. The list below ranks the formats separately
-    // for ETC1S and UASTC.
-    //
-    // In some cases, transcoding UASTC to RGBA32 might be preferred for higher quality (at
-    // significant memory cost) compared to ETC1/2, BC1/3, and PVRTC. The transcoder currently
-    // chooses RGBA32 only as a last resort and does not expose that option to the caller.
-    const FORMAT_OPTIONS = [
-      {
-        if: 'astcSupported',
-        basisFormat: [BasisFormat.UASTC_4x4],
-        transcoderFormat: [TranscoderFormat.ASTC_4x4, TranscoderFormat.ASTC_4x4],
-        engineFormat: [EngineFormat.RGBA_ASTC_4x4_Format, EngineFormat.RGBA_ASTC_4x4_Format],
-        priorityETC1S: Infinity,
-        priorityUASTC: 1,
-        needsPowerOfTwo: false,
-      },
-      {
-        if: 'bptcSupported',
-        basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
-        transcoderFormat: [TranscoderFormat.BC7_M5, TranscoderFormat.BC7_M5],
-        engineFormat: [EngineFormat.RGBA_BPTC_Format, EngineFormat.RGBA_BPTC_Format],
-        priorityETC1S: 3,
-        priorityUASTC: 2,
-        needsPowerOfTwo: false,
-      },
-      {
-        if: 'dxtSupported',
-        basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
-        transcoderFormat: [TranscoderFormat.BC1, TranscoderFormat.BC3],
-        engineFormat: [EngineFormat.RGB_S3TC_DXT1_Format, EngineFormat.RGBA_S3TC_DXT5_Format],
-        priorityETC1S: 4,
-        priorityUASTC: 5,
-        needsPowerOfTwo: false,
-      },
-      {
-        if: 'etc2Supported',
-        basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
-        transcoderFormat: [TranscoderFormat.ETC1, TranscoderFormat.ETC2],
-        engineFormat: [EngineFormat.RGB_ETC2_Format, EngineFormat.RGBA_ETC2_EAC_Format],
-        priorityETC1S: 1,
-        priorityUASTC: 3,
-        needsPowerOfTwo: false,
-      },
-      {
-        if: 'etc1Supported',
-        basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
-        transcoderFormat: [TranscoderFormat.ETC1],
-        engineFormat: [EngineFormat.RGB_ETC1_Format],
-        priorityETC1S: 2,
-        priorityUASTC: 4,
-        needsPowerOfTwo: false,
-      },
-      {
-        if: 'pvrtcSupported',
-        basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
-        transcoderFormat: [TranscoderFormat.PVRTC1_4_RGB, TranscoderFormat.PVRTC1_4_RGBA],
-        engineFormat: [EngineFormat.RGB_PVRTC_4BPPV1_Format, EngineFormat.RGBA_PVRTC_4BPPV1_Format],
-        priorityETC1S: 5,
-        priorityUASTC: 6,
-        needsPowerOfTwo: true,
-      },
-    ]
-
-    const ETC1S_OPTIONS = FORMAT_OPTIONS.sort(function (a, b) {
-      return a.priorityETC1S - b.priorityETC1S
-    })
-    const UASTC_OPTIONS = FORMAT_OPTIONS.sort(function (a, b) {
-      return a.priorityUASTC - b.priorityUASTC
-    })
+        for (let i = 0; i < options.length; i++) {
+          const opt = options[i]
 
-    function getTranscoderFormat(basisFormat, width, height, hasAlpha) {
-      let transcoderFormat
-      let engineFormat
+          if (!config[opt.if]) continue
+          if (!opt.basisFormat.includes(basisFormat)) continue
+          if (hasAlpha && opt.transcoderFormat.length < 2) continue
+          if (opt.needsPowerOfTwo && !(isPowerOfTwo(width) && isPowerOfTwo(height))) continue
 
-      const options = basisFormat === BasisFormat.ETC1S ? ETC1S_OPTIONS : UASTC_OPTIONS
+          transcoderFormat = opt.transcoderFormat[hasAlpha ? 1 : 0]
+          engineFormat = opt.engineFormat[hasAlpha ? 1 : 0]
 
-      for (let i = 0; i < options.length; i++) {
-        const opt = options[i]
+          return { transcoderFormat, engineFormat }
+        }
 
-        if (!config[opt.if]) continue
-        if (!opt.basisFormat.includes(basisFormat)) continue
-        if (hasAlpha && opt.transcoderFormat.length < 2) continue
-        if (opt.needsPowerOfTwo && !(isPowerOfTwo(width) && isPowerOfTwo(height))) continue
+        console.warn('THREE.KTX2Loader: No suitable compressed texture format found. Decoding to RGBA32.')
 
-        transcoderFormat = opt.transcoderFormat[hasAlpha ? 1 : 0]
-        engineFormat = opt.engineFormat[hasAlpha ? 1 : 0]
+        transcoderFormat = TranscoderFormat.RGBA32
+        engineFormat = EngineFormat.RGBAFormat
 
         return { transcoderFormat, engineFormat }
       }
 
-      console.warn('THREE.KTX2Loader: No suitable compressed texture format found. Decoding to RGBA32.')
+      function isPowerOfTwo(value) {
+        if (value <= 2) return true
 
-      transcoderFormat = TranscoderFormat.RGBA32
-      engineFormat = EngineFormat.RGBAFormat
-
-      return { transcoderFormat, engineFormat }
-    }
-
-    function isPowerOfTwo(value) {
-      if (value <= 2) return true
+        return (value & (value - 1)) === 0 && value !== 0
+      }
 
-      return (value & (value - 1)) === 0 && value !== 0
-    }
+      /** Concatenates N byte arrays. */
+      function concat(arrays) {
+        if (arrays.length === 1) return arrays[0]
 
-    /** Concatenates N byte arrays. */
-    function concat(arrays) {
-      if (arrays.length === 1) return arrays[0]
+        let totalByteLength = 0
 
-      let totalByteLength = 0
+        for (let i = 0; i < arrays.length; i++) {
+          const array = arrays[i]
+          totalByteLength += array.byteLength
+        }
 
-      for (let i = 0; i < arrays.length; i++) {
-        const array = arrays[i]
-        totalByteLength += array.byteLength
-      }
+        const result = new Uint8Array(totalByteLength)
 
-      const result = new Uint8Array(totalByteLength)
+        let byteOffset = 0
 
-      let byteOffset = 0
+        for (let i = 0; i < arrays.length; i++) {
+          const array = arrays[i]
+          result.set(array, byteOffset)
 
-      for (let i = 0; i < arrays.length; i++) {
-        const array = arrays[i]
-        result.set(array, byteOffset)
+          byteOffset += array.byteLength
+        }
 
-        byteOffset += array.byteLength
+        return result
       }
-
-      return result
     }
-  }
 
-  constructor(manager) {
-    super(manager)
+    constructor(manager) {
+      super(manager)
 
-    this.transcoderPath = ''
-    this.transcoderBinary = null
-    this.transcoderPending = null
+      this.transcoderPath = ''
+      this.transcoderBinary = null
+      this.transcoderPending = null
 
-    this.workerPool = new WorkerPool()
-    this.workerSourceURL = ''
-    this.workerConfig = null
+      this.workerPool = new WorkerPool()
+      this.workerSourceURL = ''
+      this.workerConfig = null
 
-    if (typeof MSC_TRANSCODER !== 'undefined') {
-      console.warn(
-        'THREE.KTX2Loader: Please update to latest "basis_transcoder".' +
-          ' "msc_basis_transcoder" is no longer supported in three.js r125+.',
-      )
+      if (typeof MSC_TRANSCODER !== 'undefined') {
+        console.warn(
+          'THREE.KTX2Loader: Please update to latest "basis_transcoder".' +
+            ' "msc_basis_transcoder" is no longer supported in three.js r125+.',
+        )
+      }
     }
-  }
 
-  setTranscoderPath(path) {
-    this.transcoderPath = path
+    setTranscoderPath(path) {
+      this.transcoderPath = path
 
-    return this
-  }
-
-  setWorkerLimit(num) {
-    this.workerPool.setWorkerLimit(num)
+      return this
+    }
 
-    return this
-  }
+    setWorkerLimit(num) {
+      this.workerPool.setWorkerLimit(num)
 
-  detectSupport(renderer) {
-    this.workerConfig = {
-      astcSupported: renderer.extensions.has('WEBGL_compressed_texture_astc'),
-      etc1Supported: renderer.extensions.has('WEBGL_compressed_texture_etc1'),
-      etc2Supported: renderer.extensions.has('WEBGL_compressed_texture_etc'),
-      dxtSupported: renderer.extensions.has('WEBGL_compressed_texture_s3tc'),
-      bptcSupported: renderer.extensions.has('EXT_texture_compression_bptc'),
-      pvrtcSupported:
-        renderer.extensions.has('WEBGL_compressed_texture_pvrtc') ||
-        renderer.extensions.has('WEBKIT_WEBGL_compressed_texture_pvrtc'),
+      return this
     }
 
-    if (renderer.capabilities.isWebGL2) {
-      // https://github.com/mrdoob/three.js/pull/22928
-      this.workerConfig.etc1Supported = false
-    }
+    detectSupport(renderer) {
+      this.workerConfig = {
+        astcSupported: renderer.extensions.has('WEBGL_compressed_texture_astc'),
+        etc1Supported: renderer.extensions.has('WEBGL_compressed_texture_etc1'),
+        etc2Supported: renderer.extensions.has('WEBGL_compressed_texture_etc'),
+        dxtSupported: renderer.extensions.has('WEBGL_compressed_texture_s3tc'),
+        bptcSupported: renderer.extensions.has('EXT_texture_compression_bptc'),
+        pvrtcSupported:
+          renderer.extensions.has('WEBGL_compressed_texture_pvrtc') ||
+          renderer.extensions.has('WEBKIT_WEBGL_compressed_texture_pvrtc'),
+      }
 
-    return this
-  }
+      if (renderer.capabilities.isWebGL2) {
+        // https://github.com/mrdoob/three.js/pull/22928
+        this.workerConfig.etc1Supported = false
+      }
+
+      return this
+    }
 
-  init() {
-    if (!this.transcoderPending) {
-      // Load transcoder wrapper.
-      const jsLoader = new FileLoader(this.manager)
-      jsLoader.setPath(this.transcoderPath)
-      jsLoader.setWithCredentials(this.withCredentials)
-      const jsContent = jsLoader.loadAsync('basis_transcoder.js')
-
-      // Load transcoder WASM binary.
-      const binaryLoader = new FileLoader(this.manager)
-      binaryLoader.setPath(this.transcoderPath)
-      binaryLoader.setResponseType('arraybuffer')
-      binaryLoader.setWithCredentials(this.withCredentials)
-      const binaryContent = binaryLoader.loadAsync('basis_transcoder.wasm')
-
-      this.transcoderPending = Promise.all([jsContent, binaryContent]).then(([jsContent, binaryContent]) => {
-        const fn = KTX2Loader.BasisWorker.toString()
-
-        const body = [
-          '/* constants */',
-          'let _EngineFormat = ' + JSON.stringify(KTX2Loader.EngineFormat),
-          'let _TranscoderFormat = ' + JSON.stringify(KTX2Loader.TranscoderFormat),
-          'let _BasisFormat = ' + JSON.stringify(KTX2Loader.BasisFormat),
-          '/* basis_transcoder.js */',
-          jsContent,
-          '/* worker */',
-          fn.substring(fn.indexOf('{') + 1, fn.lastIndexOf('}')),
-        ].join('\n')
-
-        this.workerSourceURL = URL.createObjectURL(new Blob([body]))
-        this.transcoderBinary = binaryContent
-
-        this.workerPool.setWorkerCreator(() => {
-          const worker = new Worker(this.workerSourceURL)
-          const transcoderBinary = this.transcoderBinary.slice(0)
-
-          worker.postMessage({ type: 'init', config: this.workerConfig, transcoderBinary }, [transcoderBinary])
-
-          return worker
+    init() {
+      if (!this.transcoderPending) {
+        // Load transcoder wrapper.
+        const jsLoader = new FileLoader(this.manager)
+        jsLoader.setPath(this.transcoderPath)
+        jsLoader.setWithCredentials(this.withCredentials)
+        const jsContent = jsLoader.loadAsync('basis_transcoder.js')
+
+        // Load transcoder WASM binary.
+        const binaryLoader = new FileLoader(this.manager)
+        binaryLoader.setPath(this.transcoderPath)
+        binaryLoader.setResponseType('arraybuffer')
+        binaryLoader.setWithCredentials(this.withCredentials)
+        const binaryContent = binaryLoader.loadAsync('basis_transcoder.wasm')
+
+        this.transcoderPending = Promise.all([jsContent, binaryContent]).then(([jsContent, binaryContent]) => {
+          const fn = KTX2Loader.BasisWorker.toString()
+
+          const body = [
+            '/* constants */',
+            'let _EngineFormat = ' + JSON.stringify(KTX2Loader.EngineFormat),
+            'let _TranscoderFormat = ' + JSON.stringify(KTX2Loader.TranscoderFormat),
+            'let _BasisFormat = ' + JSON.stringify(KTX2Loader.BasisFormat),
+            '/* basis_transcoder.js */',
+            jsContent,
+            '/* worker */',
+            fn.substring(fn.indexOf('{') + 1, fn.lastIndexOf('}')),
+          ].join('\n')
+
+          this.workerSourceURL = URL.createObjectURL(new Blob([body]))
+          this.transcoderBinary = binaryContent
+
+          this.workerPool.setWorkerCreator(() => {
+            const worker = new Worker(this.workerSourceURL)
+            const transcoderBinary = this.transcoderBinary.slice(0)
+
+            worker.postMessage({ type: 'init', config: this.workerConfig, transcoderBinary }, [transcoderBinary])
+
+            return worker
+          })
         })
-      })
 
-      if (_activeLoaders > 0) {
-        // Each instance loads a transcoder and allocates workers, increasing network and memory cost.
+        if (_activeLoaders > 0) {
+          // Each instance loads a transcoder and allocates workers, increasing network and memory cost.
 
-        console.warn(
-          'THREE.KTX2Loader: Multiple active KTX2 loaders may cause performance issues.' +
-            ' Use a single KTX2Loader instance, or call .dispose() on old instances.',
-        )
+          console.warn(
+            'THREE.KTX2Loader: Multiple active KTX2 loaders may cause performance issues.' +
+              ' Use a single KTX2Loader instance, or call .dispose() on old instances.',
+          )
+        }
+
+        _activeLoaders++
       }
 
-      _activeLoaders++
+      return this.transcoderPending
     }
 
-    return this.transcoderPending
-  }
-
-  load(url, onLoad, onProgress, onError) {
-    if (this.workerConfig === null) {
-      throw new Error('THREE.KTX2Loader: Missing initialization with `.detectSupport( renderer )`.')
-    }
+    load(url, onLoad, onProgress, onError) {
+      if (this.workerConfig === null) {
+        throw new Error('THREE.KTX2Loader: Missing initialization with `.detectSupport( renderer )`.')
+      }
 
-    const loader = new FileLoader(this.manager)
+      const loader = new FileLoader(this.manager)
 
-    loader.setResponseType('arraybuffer')
-    loader.setWithCredentials(this.withCredentials)
+      loader.setResponseType('arraybuffer')
+      loader.setWithCredentials(this.withCredentials)
 
-    loader.load(
-      url,
-      (buffer) => {
-        // Check for an existing task using this buffer. A transferred buffer cannot be transferred
-        // again from this thread.
-        if (_taskCache.has(buffer)) {
-          const cachedTask = _taskCache.get(buffer)
+      loader.load(
+        url,
+        (buffer) => {
+          // Check for an existing task using this buffer. A transferred buffer cannot be transferred
+          // again from this thread.
+          if (_taskCache.has(buffer)) {
+            const cachedTask = _taskCache.get(buffer)
 
-          return cachedTask.promise.then(onLoad).catch(onError)
-        }
+            return cachedTask.promise.then(onLoad).catch(onError)
+          }
 
-        this._createTexture(buffer)
-          .then((texture) => (onLoad ? onLoad(texture) : null))
-          .catch(onError)
-      },
-      onProgress,
-      onError,
-    )
-  }
+          this._createTexture(buffer)
+            .then((texture) => (onLoad ? onLoad(texture) : null))
+            .catch(onError)
+        },
+        onProgress,
+        onError,
+      )
+    }
 
-  _createTextureFrom(transcodeResult, container) {
-    const { faces, width, height, format, type, error, dfdFlags } = transcodeResult
+    _createTextureFrom(transcodeResult, container) {
+      const { faces, width, height, format, type, error, dfdFlags } = transcodeResult
 
-    if (type === 'error') return Promise.reject(error)
+      if (type === 'error') return Promise.reject(error)
 
-    let texture
+      let texture
 
-    if (container.faceCount === 6) {
-      texture = new CompressedCubeTexture(faces, format, UnsignedByteType)
-    } else {
-      const mipmaps = faces[0].mipmaps
+      if (container.faceCount === 6) {
+        texture = new CompressedCubeTexture(faces, format, UnsignedByteType)
+      } else {
+        const mipmaps = faces[0].mipmaps
 
-      texture =
-        container.layerCount > 1
-          ? new CompressedArrayTexture(mipmaps, width, height, container.layerCount, format, UnsignedByteType)
-          : new CompressedTexture(mipmaps, width, height, format, UnsignedByteType)
-    }
+        texture =
+          container.layerCount > 1
+            ? new CompressedArrayTexture(mipmaps, width, height, container.layerCount, format, UnsignedByteType)
+            : new CompressedTexture(mipmaps, width, height, format, UnsignedByteType)
+      }
 
-    texture.minFilter = faces[0].mipmaps.length === 1 ? LinearFilter : LinearMipmapLinearFilter
-    texture.magFilter = LinearFilter
-    texture.generateMipmaps = false
-    texture.needsUpdate = true
+      texture.minFilter = faces[0].mipmaps.length === 1 ? LinearFilter : LinearMipmapLinearFilter
+      texture.magFilter = LinearFilter
+      texture.generateMipmaps = false
+      texture.needsUpdate = true
 
-    const colorSpace = parseColorSpace(container)
-    if ('colorSpace' in texture) texture.colorSpace = colorSpace
-    else texture.encoding = colorSpace === SRGBColorSpace ? sRGBEncoding : LinearEncoding
+      const colorSpace = parseColorSpace(container)
+      if ('colorSpace' in texture) texture.colorSpace = colorSpace
+      else texture.encoding = colorSpace === SRGBColorSpace ? sRGBEncoding : LinearEncoding
 
-    texture.premultiplyAlpha = !!(dfdFlags & KHR_DF_FLAG_ALPHA_PREMULTIPLIED)
+      texture.premultiplyAlpha = !!(dfdFlags & KHR_DF_FLAG_ALPHA_PREMULTIPLIED)
 
-    return texture
-  }
+      return texture
+    }
 
-  /**
-   * @param {ArrayBuffer} buffer
-   * @param {object?} config
-   * @return {Promise<CompressedTexture|CompressedArrayTexture|DataTexture|Data3DTexture>}
-   */
-  async _createTexture(buffer, config = {}) {
-    const container = read(new Uint8Array(buffer))
+    /**
+     * @param {ArrayBuffer} buffer
+     * @param {object?} config
+     * @return {Promise<CompressedTexture|CompressedArrayTexture|DataTexture|Data3DTexture>}
+     */
+    async _createTexture(buffer, config = {}) {
+      const container = read(new Uint8Array(buffer))
 
-    if (container.vkFormat !== VK_FORMAT_UNDEFINED) {
-      return createRawTexture(container)
-    }
+      if (container.vkFormat !== VK_FORMAT_UNDEFINED) {
+        return createRawTexture(container)
+      }
 
-    //
+      //
 
-    const taskConfig = config
-    const texturePending = this.init()
-      .then(() => {
-        return this.workerPool.postMessage({ type: 'transcode', buffer, taskConfig: taskConfig }, [buffer])
-      })
-      .then((e) => this._createTextureFrom(e.data, container))
+      const taskConfig = config
+      const texturePending = this.init()
+        .then(() => {
+          return this.workerPool.postMessage({ type: 'transcode', buffer, taskConfig: taskConfig }, [buffer])
+        })
+        .then((e) => this._createTextureFrom(e.data, container))
 
-    // Cache the task result.
-    _taskCache.set(buffer, { promise: texturePending })
+      // Cache the task result.
+      _taskCache.set(buffer, { promise: texturePending })
 
-    return texturePending
-  }
+      return texturePending
+    }
 
-  dispose() {
-    this.workerPool.dispose()
-    if (this.workerSourceURL) URL.revokeObjectURL(this.workerSourceURL)
+    dispose() {
+      this.workerPool.dispose()
+      if (this.workerSourceURL) URL.revokeObjectURL(this.workerSourceURL)
 
-    _activeLoaders--
+      _activeLoaders--
 
-    return this
+      return this
+    }
   }
-}
+
+  return KTX2Loader
+})()
 
 //
 // Parsing for non-Basis textures. These textures are may have supercompression
diff --git a/src/loaders/LDrawLoader.js b/src/loaders/LDrawLoader.js
index 41c39c67..ea6323a6 100644
--- a/src/loaders/LDrawLoader.js
+++ b/src/loaders/LDrawLoader.js
@@ -15,8 +15,8 @@ import {
   UniformsUtils,
   Vector3,
   Ray,
-  REVISION,
 } from 'three'
+import { version } from '../_polyfill/constants'
 
 // Special surface finish tag types.
 // Note: "MATERIAL" tag (e.g. GLITTER, SPECKLE) is not implemented
@@ -40,8 +40,8 @@ const FILE_LOCATION_NOT_FOUND = 6
 const MAIN_COLOUR_CODE = '16'
 const MAIN_EDGE_COLOUR_CODE = '24'
 
-const _tempVec0 = new Vector3()
-const _tempVec1 = new Vector3()
+const _tempVec0 = /* @__PURE__ */ new Vector3()
+const _tempVec1 = /* @__PURE__ */ new Vector3()
 
 class LDrawConditionalLineMaterial extends ShaderMaterial {
   constructor(parameters) {
@@ -129,7 +129,7 @@ class LDrawConditionalLineMaterial extends ShaderMaterial {
           outgoingLight = diffuseColor.rgb; // simple shader
           gl_FragColor = vec4(outgoingLight, diffuseColor.a);
           #include <tonemapping_fragment>
-          #include <${parseInt(REVISION.replace(/\D+/g, '')) >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>
+          #include <${version >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>
           #include <fog_fragment>
           #include <premultiplied_alpha_fragment>
         }
@@ -180,7 +180,7 @@ function generateFaceNormals(faces) {
   }
 }
 
-const _ray = new Ray()
+const _ray = /* @__PURE__ */ new Ray()
 function smoothNormals(faces, lineSegments, checkSubSegments = false) {
   // NOTE: 1e2 is pretty coarse but was chosen to quantize the resulting value because
   // it allows edges to be smoothed as expected (see minifig arms).
diff --git a/src/loaders/OBJLoader.js b/src/loaders/OBJLoader.js
index f5a5ffce..82ffde04 100644
--- a/src/loaders/OBJLoader.js
+++ b/src/loaders/OBJLoader.js
@@ -23,12 +23,12 @@ const _material_use_pattern = /^usemtl /
 // usemap map_name
 const _map_use_pattern = /^usemap /
 
-const _vA = new Vector3()
-const _vB = new Vector3()
-const _vC = new Vector3()
+const _vA = /* @__PURE__ */ new Vector3()
+const _vB = /* @__PURE__ */ new Vector3()
+const _vC = /* @__PURE__ */ new Vector3()
 
-const _ab = new Vector3()
-const _cb = new Vector3()
+const _ab = /* @__PURE__ */ new Vector3()
+const _cb = /* @__PURE__ */ new Vector3()
 
 function ParserState() {
   const state = {
diff --git a/src/loaders/PRWMLoader.js b/src/loaders/PRWMLoader.js
index b839b1bf..a2604cc8 100644
--- a/src/loaders/PRWMLoader.js
+++ b/src/loaders/PRWMLoader.js
@@ -168,65 +168,69 @@ function decodePrwm(buffer) {
 
 // Define the public interface
 
-class PRWMLoader extends Loader {
-  constructor(manager) {
-    super(manager)
-  }
+const PRWMLoader = /* @__PURE__ */ (() => {
+  class PRWMLoader extends Loader {
+    constructor(manager) {
+      super(manager)
+    }
 
-  load(url, onLoad, onProgress, onError) {
-    const scope = this
-
-    const loader = new FileLoader(scope.manager)
-    loader.setPath(scope.path)
-    loader.setResponseType('arraybuffer')
-    loader.setRequestHeader(scope.requestHeader)
-    loader.setWithCredentials(scope.withCredentials)
-
-    url = url.replace(/\*/g, isBigEndianPlatform() ? 'be' : 'le')
-
-    loader.load(
-      url,
-      function (arrayBuffer) {
-        try {
-          onLoad(scope.parse(arrayBuffer))
-        } catch (e) {
-          if (onError) {
-            onError(e)
-          } else {
-            console.error(e)
+    load(url, onLoad, onProgress, onError) {
+      const scope = this
+
+      const loader = new FileLoader(scope.manager)
+      loader.setPath(scope.path)
+      loader.setResponseType('arraybuffer')
+      loader.setRequestHeader(scope.requestHeader)
+      loader.setWithCredentials(scope.withCredentials)
+
+      url = url.replace(/\*/g, isBigEndianPlatform() ? 'be' : 'le')
+
+      loader.load(
+        url,
+        function (arrayBuffer) {
+          try {
+            onLoad(scope.parse(arrayBuffer))
+          } catch (e) {
+            if (onError) {
+              onError(e)
+            } else {
+              console.error(e)
+            }
+
+            scope.manager.itemError(url)
           }
+        },
+        onProgress,
+        onError,
+      )
+    }
 
-          scope.manager.itemError(url)
-        }
-      },
-      onProgress,
-      onError,
-    )
-  }
+    parse(arrayBuffer) {
+      const data = decodePrwm(arrayBuffer),
+        attributesKey = Object.keys(data.attributes),
+        bufferGeometry = new BufferGeometry()
+
+      for (let i = 0; i < attributesKey.length; i++) {
+        const attribute = data.attributes[attributesKey[i]]
+        bufferGeometry.setAttribute(
+          attributesKey[i],
+          new BufferAttribute(attribute.values, attribute.cardinality, attribute.normalized),
+        )
+      }
 
-  parse(arrayBuffer) {
-    const data = decodePrwm(arrayBuffer),
-      attributesKey = Object.keys(data.attributes),
-      bufferGeometry = new BufferGeometry()
+      if (data.indices !== null) {
+        bufferGeometry.setIndex(new BufferAttribute(data.indices, 1))
+      }
 
-    for (let i = 0; i < attributesKey.length; i++) {
-      const attribute = data.attributes[attributesKey[i]]
-      bufferGeometry.setAttribute(
-        attributesKey[i],
-        new BufferAttribute(attribute.values, attribute.cardinality, attribute.normalized),
-      )
+      return bufferGeometry
     }
 
-    if (data.indices !== null) {
-      bufferGeometry.setIndex(new BufferAttribute(data.indices, 1))
+    static isBigEndianPlatform() {
+      return isBigEndianPlatform()
     }
-
-    return bufferGeometry
   }
 
-  static isBigEndianPlatform() {
-    return isBigEndianPlatform()
-  }
-}
+  return PRWMLoader
+})()
 
 export { PRWMLoader }
diff --git a/src/loaders/SVGLoader.js b/src/loaders/SVGLoader.js
index b8879e62..8bbb51c2 100644
--- a/src/loaders/SVGLoader.js
+++ b/src/loaders/SVGLoader.js
@@ -15,2513 +15,2520 @@ import {
 
 const COLOR_SPACE_SVG = 'srgb'
 
-class SVGLoader extends Loader {
-  constructor(manager) {
-    super(manager)
+const SVGLoader = /* @__PURE__ */ (() => {
+  class SVGLoader extends Loader {
+    constructor(manager) {
+      super(manager)
 
-    // Default dots per inch
-    this.defaultDPI = 90
+      // Default dots per inch
+      this.defaultDPI = 90
 
-    // Accepted units: 'mm', 'cm', 'in', 'pt', 'pc', 'px'
-    this.defaultUnit = 'px'
-  }
+      // Accepted units: 'mm', 'cm', 'in', 'pt', 'pc', 'px'
+      this.defaultUnit = 'px'
+    }
 
-  load(url, onLoad, onProgress, onError) {
-    const scope = this
-
-    const loader = new FileLoader(scope.manager)
-    loader.setPath(scope.path)
-    loader.setRequestHeader(scope.requestHeader)
-    loader.setWithCredentials(scope.withCredentials)
-    loader.load(
-      url,
-      function (text) {
-        try {
-          onLoad(scope.parse(text))
-        } catch (e) {
-          if (onError) {
-            onError(e)
-          } else {
-            console.error(e)
+    load(url, onLoad, onProgress, onError) {
+      const scope = this
+
+      const loader = new FileLoader(scope.manager)
+      loader.setPath(scope.path)
+      loader.setRequestHeader(scope.requestHeader)
+      loader.setWithCredentials(scope.withCredentials)
+      loader.load(
+        url,
+        function (text) {
+          try {
+            onLoad(scope.parse(text))
+          } catch (e) {
+            if (onError) {
+              onError(e)
+            } else {
+              console.error(e)
+            }
+
+            scope.manager.itemError(url)
           }
+        },
+        onProgress,
+        onError,
+      )
+    }
 
-          scope.manager.itemError(url)
-        }
-      },
-      onProgress,
-      onError,
-    )
-  }
+    parse(text) {
+      const scope = this
 
-  parse(text) {
-    const scope = this
+      function parseNode(node, style) {
+        if (node.nodeType !== 1) return
 
-    function parseNode(node, style) {
-      if (node.nodeType !== 1) return
+        const transform = getNodeTransform(node)
 
-      const transform = getNodeTransform(node)
+        let isDefsNode = false
 
-      let isDefsNode = false
+        let path = null
 
-      let path = null
+        switch (node.nodeName) {
+          case 'svg':
+            style = parseStyle(node, style)
+            break
 
-      switch (node.nodeName) {
-        case 'svg':
-          style = parseStyle(node, style)
-          break
+          case 'style':
+            parseCSSStylesheet(node)
+            break
 
-        case 'style':
-          parseCSSStylesheet(node)
-          break
+          case 'g':
+            style = parseStyle(node, style)
+            break
 
-        case 'g':
-          style = parseStyle(node, style)
-          break
+          case 'path':
+            style = parseStyle(node, style)
+            if (node.hasAttribute('d')) path = parsePathNode(node)
+            break
 
-        case 'path':
-          style = parseStyle(node, style)
-          if (node.hasAttribute('d')) path = parsePathNode(node)
-          break
+          case 'rect':
+            style = parseStyle(node, style)
+            path = parseRectNode(node)
+            break
 
-        case 'rect':
-          style = parseStyle(node, style)
-          path = parseRectNode(node)
-          break
+          case 'polygon':
+            style = parseStyle(node, style)
+            path = parsePolygonNode(node)
+            break
 
-        case 'polygon':
-          style = parseStyle(node, style)
-          path = parsePolygonNode(node)
-          break
+          case 'polyline':
+            style = parseStyle(node, style)
+            path = parsePolylineNode(node)
+            break
 
-        case 'polyline':
-          style = parseStyle(node, style)
-          path = parsePolylineNode(node)
-          break
+          case 'circle':
+            style = parseStyle(node, style)
+            path = parseCircleNode(node)
+            break
 
-        case 'circle':
-          style = parseStyle(node, style)
-          path = parseCircleNode(node)
-          break
+          case 'ellipse':
+            style = parseStyle(node, style)
+            path = parseEllipseNode(node)
+            break
 
-        case 'ellipse':
-          style = parseStyle(node, style)
-          path = parseEllipseNode(node)
-          break
+          case 'line':
+            style = parseStyle(node, style)
+            path = parseLineNode(node)
+            break
 
-        case 'line':
-          style = parseStyle(node, style)
-          path = parseLineNode(node)
-          break
+          case 'defs':
+            isDefsNode = true
+            break
 
-        case 'defs':
-          isDefsNode = true
-          break
+          case 'use':
+            style = parseStyle(node, style)
 
-        case 'use':
-          style = parseStyle(node, style)
+            const href = node.getAttributeNS('http://www.w3.org/1999/xlink', 'href') || ''
+            const usedNodeId = href.substring(1)
+            const usedNode = node.viewportElement.getElementById(usedNodeId)
+            if (usedNode) {
+              parseNode(usedNode, style)
+            } else {
+              console.warn("SVGLoader: 'use node' references non-existent node id: " + usedNodeId)
+            }
 
-          const href = node.getAttributeNS('http://www.w3.org/1999/xlink', 'href') || ''
-          const usedNodeId = href.substring(1)
-          const usedNode = node.viewportElement.getElementById(usedNodeId)
-          if (usedNode) {
-            parseNode(usedNode, style)
-          } else {
-            console.warn("SVGLoader: 'use node' references non-existent node id: " + usedNodeId)
-          }
+            break
 
-          break
+          default:
+          // console.log( node );
+        }
 
-        default:
-        // console.log( node );
-      }
+        if (path) {
+          if (style.fill !== undefined && style.fill !== 'none') {
+            path.color.setStyle(style.fill, COLOR_SPACE_SVG)
+          }
 
-      if (path) {
-        if (style.fill !== undefined && style.fill !== 'none') {
-          path.color.setStyle(style.fill, COLOR_SPACE_SVG)
-        }
+          transformPath(path, currentTransform)
 
-        transformPath(path, currentTransform)
+          paths.push(path)
 
-        paths.push(path)
+          path.userData = { node: node, style: style }
+        }
 
-        path.userData = { node: node, style: style }
-      }
+        const childNodes = node.childNodes
 
-      const childNodes = node.childNodes
+        for (let i = 0; i < childNodes.length; i++) {
+          const node = childNodes[i]
 
-      for (let i = 0; i < childNodes.length; i++) {
-        const node = childNodes[i]
+          if (isDefsNode && node.nodeName !== 'style' && node.nodeName !== 'defs') {
+            // Ignore everything in defs except CSS style definitions
+            // and nested defs, because it is OK by the standard to have
+            // <style/> there.
+            continue
+          }
 
-        if (isDefsNode && node.nodeName !== 'style' && node.nodeName !== 'defs') {
-          // Ignore everything in defs except CSS style definitions
-          // and nested defs, because it is OK by the standard to have
-          // <style/> there.
-          continue
+          parseNode(node, style)
         }
 
-        parseNode(node, style)
-      }
+        if (transform) {
+          transformStack.pop()
 
-      if (transform) {
-        transformStack.pop()
-
-        if (transformStack.length > 0) {
-          currentTransform.copy(transformStack[transformStack.length - 1])
-        } else {
-          currentTransform.identity()
+          if (transformStack.length > 0) {
+            currentTransform.copy(transformStack[transformStack.length - 1])
+          } else {
+            currentTransform.identity()
+          }
         }
       }
-    }
-
-    function parsePathNode(node) {
-      const path = new ShapePath()
-
-      const point = new Vector2()
-      const control = new Vector2()
 
-      const firstPoint = new Vector2()
-      let isFirstPoint = true
-      let doSetFirstPoint = false
+      function parsePathNode(node) {
+        const path = new ShapePath()
 
-      const d = node.getAttribute('d')
+        const point = new Vector2()
+        const control = new Vector2()
 
-      if (d === '' || d === 'none') return null
+        const firstPoint = new Vector2()
+        let isFirstPoint = true
+        let doSetFirstPoint = false
 
-      // console.log( d );
-
-      const commands = d.match(/[a-df-z][^a-df-z]*/gi)
-
-      for (let i = 0, l = commands.length; i < l; i++) {
-        const command = commands[i]
-
-        const type = command.charAt(0)
-        const data = command.slice(1).trim()
-
-        if (isFirstPoint === true) {
-          doSetFirstPoint = true
-          isFirstPoint = false
-        }
+        const d = node.getAttribute('d')
 
-        let numbers
+        if (d === '' || d === 'none') return null
 
-        switch (type) {
-          case 'M':
-            numbers = parseFloats(data)
-            for (let j = 0, jl = numbers.length; j < jl; j += 2) {
-              point.x = numbers[j + 0]
-              point.y = numbers[j + 1]
-              control.x = point.x
-              control.y = point.y
+        // console.log( d );
 
-              if (j === 0) {
-                path.moveTo(point.x, point.y)
-              } else {
-                path.lineTo(point.x, point.y)
-              }
+        const commands = d.match(/[a-df-z][^a-df-z]*/gi)
 
-              if (j === 0) firstPoint.copy(point)
-            }
+        for (let i = 0, l = commands.length; i < l; i++) {
+          const command = commands[i]
 
-            break
+          const type = command.charAt(0)
+          const data = command.slice(1).trim()
 
-          case 'H':
-            numbers = parseFloats(data)
+          if (isFirstPoint === true) {
+            doSetFirstPoint = true
+            isFirstPoint = false
+          }
 
-            for (let j = 0, jl = numbers.length; j < jl; j++) {
-              point.x = numbers[j]
-              control.x = point.x
-              control.y = point.y
-              path.lineTo(point.x, point.y)
+          let numbers
 
-              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
-            }
+          switch (type) {
+            case 'M':
+              numbers = parseFloats(data)
+              for (let j = 0, jl = numbers.length; j < jl; j += 2) {
+                point.x = numbers[j + 0]
+                point.y = numbers[j + 1]
+                control.x = point.x
+                control.y = point.y
 
-            break
+                if (j === 0) {
+                  path.moveTo(point.x, point.y)
+                } else {
+                  path.lineTo(point.x, point.y)
+                }
 
-          case 'V':
-            numbers = parseFloats(data)
+                if (j === 0) firstPoint.copy(point)
+              }
 
-            for (let j = 0, jl = numbers.length; j < jl; j++) {
-              point.y = numbers[j]
-              control.x = point.x
-              control.y = point.y
-              path.lineTo(point.x, point.y)
+              break
 
-              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
-            }
+            case 'H':
+              numbers = parseFloats(data)
 
-            break
+              for (let j = 0, jl = numbers.length; j < jl; j++) {
+                point.x = numbers[j]
+                control.x = point.x
+                control.y = point.y
+                path.lineTo(point.x, point.y)
 
-          case 'L':
-            numbers = parseFloats(data)
+                if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
+              }
 
-            for (let j = 0, jl = numbers.length; j < jl; j += 2) {
-              point.x = numbers[j + 0]
-              point.y = numbers[j + 1]
-              control.x = point.x
-              control.y = point.y
-              path.lineTo(point.x, point.y)
+              break
 
-              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
-            }
+            case 'V':
+              numbers = parseFloats(data)
 
-            break
+              for (let j = 0, jl = numbers.length; j < jl; j++) {
+                point.y = numbers[j]
+                control.x = point.x
+                control.y = point.y
+                path.lineTo(point.x, point.y)
 
-          case 'C':
-            numbers = parseFloats(data)
-
-            for (let j = 0, jl = numbers.length; j < jl; j += 6) {
-              path.bezierCurveTo(
-                numbers[j + 0],
-                numbers[j + 1],
-                numbers[j + 2],
-                numbers[j + 3],
-                numbers[j + 4],
-                numbers[j + 5],
-              )
-              control.x = numbers[j + 2]
-              control.y = numbers[j + 3]
-              point.x = numbers[j + 4]
-              point.y = numbers[j + 5]
-
-              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
-            }
+                if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
+              }
 
-            break
+              break
 
-          case 'S':
-            numbers = parseFloats(data)
-
-            for (let j = 0, jl = numbers.length; j < jl; j += 4) {
-              path.bezierCurveTo(
-                getReflection(point.x, control.x),
-                getReflection(point.y, control.y),
-                numbers[j + 0],
-                numbers[j + 1],
-                numbers[j + 2],
-                numbers[j + 3],
-              )
-              control.x = numbers[j + 0]
-              control.y = numbers[j + 1]
-              point.x = numbers[j + 2]
-              point.y = numbers[j + 3]
-
-              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
-            }
+            case 'L':
+              numbers = parseFloats(data)
 
-            break
+              for (let j = 0, jl = numbers.length; j < jl; j += 2) {
+                point.x = numbers[j + 0]
+                point.y = numbers[j + 1]
+                control.x = point.x
+                control.y = point.y
+                path.lineTo(point.x, point.y)
 
-          case 'Q':
-            numbers = parseFloats(data)
+                if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
+              }
 
-            for (let j = 0, jl = numbers.length; j < jl; j += 4) {
-              path.quadraticCurveTo(numbers[j + 0], numbers[j + 1], numbers[j + 2], numbers[j + 3])
-              control.x = numbers[j + 0]
-              control.y = numbers[j + 1]
-              point.x = numbers[j + 2]
-              point.y = numbers[j + 3]
+              break
 
-              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
-            }
+            case 'C':
+              numbers = parseFloats(data)
+
+              for (let j = 0, jl = numbers.length; j < jl; j += 6) {
+                path.bezierCurveTo(
+                  numbers[j + 0],
+                  numbers[j + 1],
+                  numbers[j + 2],
+                  numbers[j + 3],
+                  numbers[j + 4],
+                  numbers[j + 5],
+                )
+                control.x = numbers[j + 2]
+                control.y = numbers[j + 3]
+                point.x = numbers[j + 4]
+                point.y = numbers[j + 5]
+
+                if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
+              }
 
-            break
+              break
 
-          case 'T':
-            numbers = parseFloats(data)
+            case 'S':
+              numbers = parseFloats(data)
+
+              for (let j = 0, jl = numbers.length; j < jl; j += 4) {
+                path.bezierCurveTo(
+                  getReflection(point.x, control.x),
+                  getReflection(point.y, control.y),
+                  numbers[j + 0],
+                  numbers[j + 1],
+                  numbers[j + 2],
+                  numbers[j + 3],
+                )
+                control.x = numbers[j + 0]
+                control.y = numbers[j + 1]
+                point.x = numbers[j + 2]
+                point.y = numbers[j + 3]
+
+                if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
+              }
 
-            for (let j = 0, jl = numbers.length; j < jl; j += 2) {
-              const rx = getReflection(point.x, control.x)
-              const ry = getReflection(point.y, control.y)
-              path.quadraticCurveTo(rx, ry, numbers[j + 0], numbers[j + 1])
-              control.x = rx
-              control.y = ry
-              point.x = numbers[j + 0]
-              point.y = numbers[j + 1]
+              break
 
-              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
-            }
+            case 'Q':
+              numbers = parseFloats(data)
 
-            break
+              for (let j = 0, jl = numbers.length; j < jl; j += 4) {
+                path.quadraticCurveTo(numbers[j + 0], numbers[j + 1], numbers[j + 2], numbers[j + 3])
+                control.x = numbers[j + 0]
+                control.y = numbers[j + 1]
+                point.x = numbers[j + 2]
+                point.y = numbers[j + 3]
 
-          case 'A':
-            numbers = parseFloats(data, [3, 4], 7)
-
-            for (let j = 0, jl = numbers.length; j < jl; j += 7) {
-              // skip command if start point == end point
-              if (numbers[j + 5] == point.x && numbers[j + 6] == point.y) continue
-
-              const start = point.clone()
-              point.x = numbers[j + 5]
-              point.y = numbers[j + 6]
-              control.x = point.x
-              control.y = point.y
-              parseArcCommand(
-                path,
-                numbers[j],
-                numbers[j + 1],
-                numbers[j + 2],
-                numbers[j + 3],
-                numbers[j + 4],
-                start,
-                point,
-              )
-
-              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
-            }
+                if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
+              }
 
-            break
+              break
 
-          case 'm':
-            numbers = parseFloats(data)
+            case 'T':
+              numbers = parseFloats(data)
 
-            for (let j = 0, jl = numbers.length; j < jl; j += 2) {
-              point.x += numbers[j + 0]
-              point.y += numbers[j + 1]
-              control.x = point.x
-              control.y = point.y
+              for (let j = 0, jl = numbers.length; j < jl; j += 2) {
+                const rx = getReflection(point.x, control.x)
+                const ry = getReflection(point.y, control.y)
+                path.quadraticCurveTo(rx, ry, numbers[j + 0], numbers[j + 1])
+                control.x = rx
+                control.y = ry
+                point.x = numbers[j + 0]
+                point.y = numbers[j + 1]
 
-              if (j === 0) {
-                path.moveTo(point.x, point.y)
-              } else {
-                path.lineTo(point.x, point.y)
+                if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
               }
 
-              if (j === 0) firstPoint.copy(point)
-            }
+              break
 
-            break
+            case 'A':
+              numbers = parseFloats(data, [3, 4], 7)
+
+              for (let j = 0, jl = numbers.length; j < jl; j += 7) {
+                // skip command if start point == end point
+                if (numbers[j + 5] == point.x && numbers[j + 6] == point.y) continue
+
+                const start = point.clone()
+                point.x = numbers[j + 5]
+                point.y = numbers[j + 6]
+                control.x = point.x
+                control.y = point.y
+                parseArcCommand(
+                  path,
+                  numbers[j],
+                  numbers[j + 1],
+                  numbers[j + 2],
+                  numbers[j + 3],
+                  numbers[j + 4],
+                  start,
+                  point,
+                )
+
+                if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
+              }
 
-          case 'h':
-            numbers = parseFloats(data)
+              break
 
-            for (let j = 0, jl = numbers.length; j < jl; j++) {
-              point.x += numbers[j]
-              control.x = point.x
-              control.y = point.y
-              path.lineTo(point.x, point.y)
+            case 'm':
+              numbers = parseFloats(data)
 
-              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
-            }
+              for (let j = 0, jl = numbers.length; j < jl; j += 2) {
+                point.x += numbers[j + 0]
+                point.y += numbers[j + 1]
+                control.x = point.x
+                control.y = point.y
 
-            break
-
-          case 'v':
-            numbers = parseFloats(data)
+                if (j === 0) {
+                  path.moveTo(point.x, point.y)
+                } else {
+                  path.lineTo(point.x, point.y)
+                }
 
-            for (let j = 0, jl = numbers.length; j < jl; j++) {
-              point.y += numbers[j]
-              control.x = point.x
-              control.y = point.y
-              path.lineTo(point.x, point.y)
+                if (j === 0) firstPoint.copy(point)
+              }
 
-              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
-            }
+              break
 
-            break
+            case 'h':
+              numbers = parseFloats(data)
 
-          case 'l':
-            numbers = parseFloats(data)
+              for (let j = 0, jl = numbers.length; j < jl; j++) {
+                point.x += numbers[j]
+                control.x = point.x
+                control.y = point.y
+                path.lineTo(point.x, point.y)
 
-            for (let j = 0, jl = numbers.length; j < jl; j += 2) {
-              point.x += numbers[j + 0]
-              point.y += numbers[j + 1]
-              control.x = point.x
-              control.y = point.y
-              path.lineTo(point.x, point.y)
+                if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
+              }
 
-              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
-            }
+              break
 
-            break
+            case 'v':
+              numbers = parseFloats(data)
 
-          case 'c':
-            numbers = parseFloats(data)
-
-            for (let j = 0, jl = numbers.length; j < jl; j += 6) {
-              path.bezierCurveTo(
-                point.x + numbers[j + 0],
-                point.y + numbers[j + 1],
-                point.x + numbers[j + 2],
-                point.y + numbers[j + 3],
-                point.x + numbers[j + 4],
-                point.y + numbers[j + 5],
-              )
-              control.x = point.x + numbers[j + 2]
-              control.y = point.y + numbers[j + 3]
-              point.x += numbers[j + 4]
-              point.y += numbers[j + 5]
-
-              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
-            }
+              for (let j = 0, jl = numbers.length; j < jl; j++) {
+                point.y += numbers[j]
+                control.x = point.x
+                control.y = point.y
+                path.lineTo(point.x, point.y)
 
-            break
+                if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
+              }
 
-          case 's':
-            numbers = parseFloats(data)
-
-            for (let j = 0, jl = numbers.length; j < jl; j += 4) {
-              path.bezierCurveTo(
-                getReflection(point.x, control.x),
-                getReflection(point.y, control.y),
-                point.x + numbers[j + 0],
-                point.y + numbers[j + 1],
-                point.x + numbers[j + 2],
-                point.y + numbers[j + 3],
-              )
-              control.x = point.x + numbers[j + 0]
-              control.y = point.y + numbers[j + 1]
-              point.x += numbers[j + 2]
-              point.y += numbers[j + 3]
-
-              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
-            }
+              break
 
-            break
+            case 'l':
+              numbers = parseFloats(data)
 
-          case 'q':
-            numbers = parseFloats(data)
-
-            for (let j = 0, jl = numbers.length; j < jl; j += 4) {
-              path.quadraticCurveTo(
-                point.x + numbers[j + 0],
-                point.y + numbers[j + 1],
-                point.x + numbers[j + 2],
-                point.y + numbers[j + 3],
-              )
-              control.x = point.x + numbers[j + 0]
-              control.y = point.y + numbers[j + 1]
-              point.x += numbers[j + 2]
-              point.y += numbers[j + 3]
-
-              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
-            }
+              for (let j = 0, jl = numbers.length; j < jl; j += 2) {
+                point.x += numbers[j + 0]
+                point.y += numbers[j + 1]
+                control.x = point.x
+                control.y = point.y
+                path.lineTo(point.x, point.y)
 
-            break
+                if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
+              }
 
-          case 't':
-            numbers = parseFloats(data)
+              break
 
-            for (let j = 0, jl = numbers.length; j < jl; j += 2) {
-              const rx = getReflection(point.x, control.x)
-              const ry = getReflection(point.y, control.y)
-              path.quadraticCurveTo(rx, ry, point.x + numbers[j + 0], point.y + numbers[j + 1])
-              control.x = rx
-              control.y = ry
-              point.x = point.x + numbers[j + 0]
-              point.y = point.y + numbers[j + 1]
+            case 'c':
+              numbers = parseFloats(data)
+
+              for (let j = 0, jl = numbers.length; j < jl; j += 6) {
+                path.bezierCurveTo(
+                  point.x + numbers[j + 0],
+                  point.y + numbers[j + 1],
+                  point.x + numbers[j + 2],
+                  point.y + numbers[j + 3],
+                  point.x + numbers[j + 4],
+                  point.y + numbers[j + 5],
+                )
+                control.x = point.x + numbers[j + 2]
+                control.y = point.y + numbers[j + 3]
+                point.x += numbers[j + 4]
+                point.y += numbers[j + 5]
+
+                if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
+              }
 
-              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
-            }
+              break
 
-            break
+            case 's':
+              numbers = parseFloats(data)
+
+              for (let j = 0, jl = numbers.length; j < jl; j += 4) {
+                path.bezierCurveTo(
+                  getReflection(point.x, control.x),
+                  getReflection(point.y, control.y),
+                  point.x + numbers[j + 0],
+                  point.y + numbers[j + 1],
+                  point.x + numbers[j + 2],
+                  point.y + numbers[j + 3],
+                )
+                control.x = point.x + numbers[j + 0]
+                control.y = point.y + numbers[j + 1]
+                point.x += numbers[j + 2]
+                point.y += numbers[j + 3]
+
+                if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
+              }
 
-          case 'a':
-            numbers = parseFloats(data, [3, 4], 7)
-
-            for (let j = 0, jl = numbers.length; j < jl; j += 7) {
-              // skip command if no displacement
-              if (numbers[j + 5] == 0 && numbers[j + 6] == 0) continue
-
-              const start = point.clone()
-              point.x += numbers[j + 5]
-              point.y += numbers[j + 6]
-              control.x = point.x
-              control.y = point.y
-              parseArcCommand(
-                path,
-                numbers[j],
-                numbers[j + 1],
-                numbers[j + 2],
-                numbers[j + 3],
-                numbers[j + 4],
-                start,
-                point,
-              )
-
-              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
-            }
+              break
 
-            break
+            case 'q':
+              numbers = parseFloats(data)
+
+              for (let j = 0, jl = numbers.length; j < jl; j += 4) {
+                path.quadraticCurveTo(
+                  point.x + numbers[j + 0],
+                  point.y + numbers[j + 1],
+                  point.x + numbers[j + 2],
+                  point.y + numbers[j + 3],
+                )
+                control.x = point.x + numbers[j + 0]
+                control.y = point.y + numbers[j + 1]
+                point.x += numbers[j + 2]
+                point.y += numbers[j + 3]
+
+                if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
+              }
 
-          case 'Z':
-          case 'z':
-            path.currentPath.autoClose = true
+              break
 
-            if (path.currentPath.curves.length > 0) {
-              // Reset point to beginning of Path
-              point.copy(firstPoint)
-              path.currentPath.currentPoint.copy(point)
-              isFirstPoint = true
-            }
+            case 't':
+              numbers = parseFloats(data)
 
-            break
+              for (let j = 0, jl = numbers.length; j < jl; j += 2) {
+                const rx = getReflection(point.x, control.x)
+                const ry = getReflection(point.y, control.y)
+                path.quadraticCurveTo(rx, ry, point.x + numbers[j + 0], point.y + numbers[j + 1])
+                control.x = rx
+                control.y = ry
+                point.x = point.x + numbers[j + 0]
+                point.y = point.y + numbers[j + 1]
 
-          default:
-            console.warn(command)
-        }
+                if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
+              }
 
-        // console.log( type, parseFloats( data ), parseFloats( data ).length  )
+              break
 
-        doSetFirstPoint = false
-      }
+            case 'a':
+              numbers = parseFloats(data, [3, 4], 7)
+
+              for (let j = 0, jl = numbers.length; j < jl; j += 7) {
+                // skip command if no displacement
+                if (numbers[j + 5] == 0 && numbers[j + 6] == 0) continue
+
+                const start = point.clone()
+                point.x += numbers[j + 5]
+                point.y += numbers[j + 6]
+                control.x = point.x
+                control.y = point.y
+                parseArcCommand(
+                  path,
+                  numbers[j],
+                  numbers[j + 1],
+                  numbers[j + 2],
+                  numbers[j + 3],
+                  numbers[j + 4],
+                  start,
+                  point,
+                )
+
+                if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
+              }
 
-      return path
-    }
+              break
 
-    function parseCSSStylesheet(node) {
-      if (!node.sheet || !node.sheet.cssRules || !node.sheet.cssRules.length) return
+            case 'Z':
+            case 'z':
+              path.currentPath.autoClose = true
 
-      for (let i = 0; i < node.sheet.cssRules.length; i++) {
-        const stylesheet = node.sheet.cssRules[i]
+              if (path.currentPath.curves.length > 0) {
+                // Reset point to beginning of Path
+                point.copy(firstPoint)
+                path.currentPath.currentPoint.copy(point)
+                isFirstPoint = true
+              }
 
-        if (stylesheet.type !== 1) continue
+              break
 
-        const selectorList = stylesheet.selectorText
-          .split(/,/gm)
-          .filter(Boolean)
-          .map((i) => i.trim())
+            default:
+              console.warn(command)
+          }
 
-        for (let j = 0; j < selectorList.length; j++) {
-          // Remove empty rules
-          const definitions = Object.fromEntries(Object.entries(stylesheet.style).filter(([, v]) => v !== ''))
+          // console.log( type, parseFloats( data ), parseFloats( data ).length  )
 
-          stylesheets[selectorList[j]] = Object.assign(stylesheets[selectorList[j]] || {}, definitions)
+          doSetFirstPoint = false
         }
-      }
-    }
 
-    /**
-     * https://www.w3.org/TR/SVG/implnote.html#ArcImplementationNotes
-     * https://mortoray.com/2017/02/16/rendering-an-svg-elliptical-arc-as-bezier-curves/ Appendix: Endpoint to center arc conversion
-     * From
-     * rx ry x-axis-rotation large-arc-flag sweep-flag x y
-     * To
-     * aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation
-     */
-
-    function parseArcCommand(path, rx, ry, x_axis_rotation, large_arc_flag, sweep_flag, start, end) {
-      if (rx == 0 || ry == 0) {
-        // draw a line if either of the radii == 0
-        path.lineTo(end.x, end.y)
-        return
+        return path
       }
 
-      x_axis_rotation = (x_axis_rotation * Math.PI) / 180
-
-      // Ensure radii are positive
-      rx = Math.abs(rx)
-      ry = Math.abs(ry)
-
-      // Compute (x1', y1')
-      const dx2 = (start.x - end.x) / 2.0
-      const dy2 = (start.y - end.y) / 2.0
-      const x1p = Math.cos(x_axis_rotation) * dx2 + Math.sin(x_axis_rotation) * dy2
-      const y1p = -Math.sin(x_axis_rotation) * dx2 + Math.cos(x_axis_rotation) * dy2
-
-      // Compute (cx', cy')
-      let rxs = rx * rx
-      let rys = ry * ry
-      const x1ps = x1p * x1p
-      const y1ps = y1p * y1p
-
-      // Ensure radii are large enough
-      const cr = x1ps / rxs + y1ps / rys
-
-      if (cr > 1) {
-        // scale up rx,ry equally so cr == 1
-        const s = Math.sqrt(cr)
-        rx = s * rx
-        ry = s * ry
-        rxs = rx * rx
-        rys = ry * ry
-      }
+      function parseCSSStylesheet(node) {
+        if (!node.sheet || !node.sheet.cssRules || !node.sheet.cssRules.length) return
 
-      const dq = rxs * y1ps + rys * x1ps
-      const pq = (rxs * rys - dq) / dq
-      let q = Math.sqrt(Math.max(0, pq))
-      if (large_arc_flag === sweep_flag) q = -q
-      const cxp = (q * rx * y1p) / ry
-      const cyp = (-q * ry * x1p) / rx
+        for (let i = 0; i < node.sheet.cssRules.length; i++) {
+          const stylesheet = node.sheet.cssRules[i]
 
-      // Step 3: Compute (cx, cy) from (cx', cy')
-      const cx = Math.cos(x_axis_rotation) * cxp - Math.sin(x_axis_rotation) * cyp + (start.x + end.x) / 2
-      const cy = Math.sin(x_axis_rotation) * cxp + Math.cos(x_axis_rotation) * cyp + (start.y + end.y) / 2
+          if (stylesheet.type !== 1) continue
 
-      // Step 4: Compute θ1 and Δθ
-      const theta = svgAngle(1, 0, (x1p - cxp) / rx, (y1p - cyp) / ry)
-      const delta = svgAngle((x1p - cxp) / rx, (y1p - cyp) / ry, (-x1p - cxp) / rx, (-y1p - cyp) / ry) % (Math.PI * 2)
+          const selectorList = stylesheet.selectorText
+            .split(/,/gm)
+            .filter(Boolean)
+            .map((i) => i.trim())
 
-      path.currentPath.absellipse(cx, cy, rx, ry, theta, theta + delta, sweep_flag === 0, x_axis_rotation)
-    }
+          for (let j = 0; j < selectorList.length; j++) {
+            // Remove empty rules
+            const definitions = Object.fromEntries(Object.entries(stylesheet.style).filter(([, v]) => v !== ''))
 
-    function svgAngle(ux, uy, vx, vy) {
-      const dot = ux * vx + uy * vy
-      const len = Math.sqrt(ux * ux + uy * uy) * Math.sqrt(vx * vx + vy * vy)
-      let ang = Math.acos(Math.max(-1, Math.min(1, dot / len))) // floating point precision, slightly over values appear
-      if (ux * vy - uy * vx < 0) ang = -ang
-      return ang
-    }
-
-    /*
-     * According to https://www.w3.org/TR/SVG/shapes.html#RectElementRXAttribute
-     * rounded corner should be rendered to elliptical arc, but bezier curve does the job well enough
-     */
-    function parseRectNode(node) {
-      const x = parseFloatWithUnits(node.getAttribute('x') || 0)
-      const y = parseFloatWithUnits(node.getAttribute('y') || 0)
-      const rx = parseFloatWithUnits(node.getAttribute('rx') || node.getAttribute('ry') || 0)
-      const ry = parseFloatWithUnits(node.getAttribute('ry') || node.getAttribute('rx') || 0)
-      const w = parseFloatWithUnits(node.getAttribute('width'))
-      const h = parseFloatWithUnits(node.getAttribute('height'))
-
-      // Ellipse arc to Bezier approximation Coefficient (Inversed). See:
-      // https://spencermortensen.com/articles/bezier-circle/
-      const bci = 1 - 0.551915024494
-
-      const path = new ShapePath()
-
-      // top left
-      path.moveTo(x + rx, y)
-
-      // top right
-      path.lineTo(x + w - rx, y)
-      if (rx !== 0 || ry !== 0) {
-        path.bezierCurveTo(x + w - rx * bci, y, x + w, y + ry * bci, x + w, y + ry)
+            stylesheets[selectorList[j]] = Object.assign(stylesheets[selectorList[j]] || {}, definitions)
+          }
+        }
       }
 
-      // bottom right
-      path.lineTo(x + w, y + h - ry)
-      if (rx !== 0 || ry !== 0) {
-        path.bezierCurveTo(x + w, y + h - ry * bci, x + w - rx * bci, y + h, x + w - rx, y + h)
-      }
+      /**
+       * https://www.w3.org/TR/SVG/implnote.html#ArcImplementationNotes
+       * https://mortoray.com/2017/02/16/rendering-an-svg-elliptical-arc-as-bezier-curves/ Appendix: Endpoint to center arc conversion
+       * From
+       * rx ry x-axis-rotation large-arc-flag sweep-flag x y
+       * To
+       * aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation
+       */
+
+      function parseArcCommand(path, rx, ry, x_axis_rotation, large_arc_flag, sweep_flag, start, end) {
+        if (rx == 0 || ry == 0) {
+          // draw a line if either of the radii == 0
+          path.lineTo(end.x, end.y)
+          return
+        }
 
-      // bottom left
-      path.lineTo(x + rx, y + h)
-      if (rx !== 0 || ry !== 0) {
-        path.bezierCurveTo(x + rx * bci, y + h, x, y + h - ry * bci, x, y + h - ry)
-      }
+        x_axis_rotation = (x_axis_rotation * Math.PI) / 180
+
+        // Ensure radii are positive
+        rx = Math.abs(rx)
+        ry = Math.abs(ry)
+
+        // Compute (x1', y1')
+        const dx2 = (start.x - end.x) / 2.0
+        const dy2 = (start.y - end.y) / 2.0
+        const x1p = Math.cos(x_axis_rotation) * dx2 + Math.sin(x_axis_rotation) * dy2
+        const y1p = -Math.sin(x_axis_rotation) * dx2 + Math.cos(x_axis_rotation) * dy2
+
+        // Compute (cx', cy')
+        let rxs = rx * rx
+        let rys = ry * ry
+        const x1ps = x1p * x1p
+        const y1ps = y1p * y1p
+
+        // Ensure radii are large enough
+        const cr = x1ps / rxs + y1ps / rys
+
+        if (cr > 1) {
+          // scale up rx,ry equally so cr == 1
+          const s = Math.sqrt(cr)
+          rx = s * rx
+          ry = s * ry
+          rxs = rx * rx
+          rys = ry * ry
+        }
 
-      // back to top left
-      path.lineTo(x, y + ry)
-      if (rx !== 0 || ry !== 0) {
-        path.bezierCurveTo(x, y + ry * bci, x + rx * bci, y, x + rx, y)
-      }
+        const dq = rxs * y1ps + rys * x1ps
+        const pq = (rxs * rys - dq) / dq
+        let q = Math.sqrt(Math.max(0, pq))
+        if (large_arc_flag === sweep_flag) q = -q
+        const cxp = (q * rx * y1p) / ry
+        const cyp = (-q * ry * x1p) / rx
+
+        // Step 3: Compute (cx, cy) from (cx', cy')
+        const cx = Math.cos(x_axis_rotation) * cxp - Math.sin(x_axis_rotation) * cyp + (start.x + end.x) / 2
+        const cy = Math.sin(x_axis_rotation) * cxp + Math.cos(x_axis_rotation) * cyp + (start.y + end.y) / 2
+
+        // Step 4: Compute θ1 and Δθ
+        const theta = svgAngle(1, 0, (x1p - cxp) / rx, (y1p - cyp) / ry)
+        const delta = svgAngle((x1p - cxp) / rx, (y1p - cyp) / ry, (-x1p - cxp) / rx, (-y1p - cyp) / ry) % (Math.PI * 2)
+
+        path.currentPath.absellipse(cx, cy, rx, ry, theta, theta + delta, sweep_flag === 0, x_axis_rotation)
+      }
+
+      function svgAngle(ux, uy, vx, vy) {
+        const dot = ux * vx + uy * vy
+        const len = Math.sqrt(ux * ux + uy * uy) * Math.sqrt(vx * vx + vy * vy)
+        let ang = Math.acos(Math.max(-1, Math.min(1, dot / len))) // floating point precision, slightly over values appear
+        if (ux * vy - uy * vx < 0) ang = -ang
+        return ang
+      }
+
+      /*
+       * According to https://www.w3.org/TR/SVG/shapes.html#RectElementRXAttribute
+       * rounded corner should be rendered to elliptical arc, but bezier curve does the job well enough
+       */
+      function parseRectNode(node) {
+        const x = parseFloatWithUnits(node.getAttribute('x') || 0)
+        const y = parseFloatWithUnits(node.getAttribute('y') || 0)
+        const rx = parseFloatWithUnits(node.getAttribute('rx') || node.getAttribute('ry') || 0)
+        const ry = parseFloatWithUnits(node.getAttribute('ry') || node.getAttribute('rx') || 0)
+        const w = parseFloatWithUnits(node.getAttribute('width'))
+        const h = parseFloatWithUnits(node.getAttribute('height'))
+
+        // Ellipse arc to Bezier approximation Coefficient (Inversed). See:
+        // https://spencermortensen.com/articles/bezier-circle/
+        const bci = 1 - 0.551915024494
+
+        const path = new ShapePath()
+
+        // top left
+        path.moveTo(x + rx, y)
+
+        // top right
+        path.lineTo(x + w - rx, y)
+        if (rx !== 0 || ry !== 0) {
+          path.bezierCurveTo(x + w - rx * bci, y, x + w, y + ry * bci, x + w, y + ry)
+        }
 
-      return path
-    }
+        // bottom right
+        path.lineTo(x + w, y + h - ry)
+        if (rx !== 0 || ry !== 0) {
+          path.bezierCurveTo(x + w, y + h - ry * bci, x + w - rx * bci, y + h, x + w - rx, y + h)
+        }
 
-    function parsePolygonNode(node) {
-      function iterator(match, a, b) {
-        const x = parseFloatWithUnits(a)
-        const y = parseFloatWithUnits(b)
+        // bottom left
+        path.lineTo(x + rx, y + h)
+        if (rx !== 0 || ry !== 0) {
+          path.bezierCurveTo(x + rx * bci, y + h, x, y + h - ry * bci, x, y + h - ry)
+        }
 
-        if (index === 0) {
-          path.moveTo(x, y)
-        } else {
-          path.lineTo(x, y)
+        // back to top left
+        path.lineTo(x, y + ry)
+        if (rx !== 0 || ry !== 0) {
+          path.bezierCurveTo(x, y + ry * bci, x + rx * bci, y, x + rx, y)
         }
 
-        index++
+        return path
       }
 
-      const regex = /([+-]?\d*\.?\d+(?:e[+-]?\d+)?)(?:,|\s)([+-]?\d*\.?\d+(?:e[+-]?\d+)?)/g
+      function parsePolygonNode(node) {
+        function iterator(match, a, b) {
+          const x = parseFloatWithUnits(a)
+          const y = parseFloatWithUnits(b)
 
-      const path = new ShapePath()
+          if (index === 0) {
+            path.moveTo(x, y)
+          } else {
+            path.lineTo(x, y)
+          }
 
-      let index = 0
+          index++
+        }
 
-      node.getAttribute('points').replace(regex, iterator)
+        const regex = /([+-]?\d*\.?\d+(?:e[+-]?\d+)?)(?:,|\s)([+-]?\d*\.?\d+(?:e[+-]?\d+)?)/g
 
-      path.currentPath.autoClose = true
+        const path = new ShapePath()
 
-      return path
-    }
+        let index = 0
 
-    function parsePolylineNode(node) {
-      function iterator(match, a, b) {
-        const x = parseFloatWithUnits(a)
-        const y = parseFloatWithUnits(b)
+        node.getAttribute('points').replace(regex, iterator)
 
-        if (index === 0) {
-          path.moveTo(x, y)
-        } else {
-          path.lineTo(x, y)
-        }
+        path.currentPath.autoClose = true
 
-        index++
+        return path
       }
 
-      const regex = /([+-]?\d*\.?\d+(?:e[+-]?\d+)?)(?:,|\s)([+-]?\d*\.?\d+(?:e[+-]?\d+)?)/g
+      function parsePolylineNode(node) {
+        function iterator(match, a, b) {
+          const x = parseFloatWithUnits(a)
+          const y = parseFloatWithUnits(b)
 
-      const path = new ShapePath()
+          if (index === 0) {
+            path.moveTo(x, y)
+          } else {
+            path.lineTo(x, y)
+          }
 
-      let index = 0
+          index++
+        }
 
-      node.getAttribute('points').replace(regex, iterator)
+        const regex = /([+-]?\d*\.?\d+(?:e[+-]?\d+)?)(?:,|\s)([+-]?\d*\.?\d+(?:e[+-]?\d+)?)/g
 
-      path.currentPath.autoClose = false
+        const path = new ShapePath()
 
-      return path
-    }
+        let index = 0
 
-    function parseCircleNode(node) {
-      const x = parseFloatWithUnits(node.getAttribute('cx') || 0)
-      const y = parseFloatWithUnits(node.getAttribute('cy') || 0)
-      const r = parseFloatWithUnits(node.getAttribute('r') || 0)
+        node.getAttribute('points').replace(regex, iterator)
 
-      const subpath = new Path()
-      subpath.absarc(x, y, r, 0, Math.PI * 2)
+        path.currentPath.autoClose = false
 
-      const path = new ShapePath()
-      path.subPaths.push(subpath)
+        return path
+      }
 
-      return path
-    }
+      function parseCircleNode(node) {
+        const x = parseFloatWithUnits(node.getAttribute('cx') || 0)
+        const y = parseFloatWithUnits(node.getAttribute('cy') || 0)
+        const r = parseFloatWithUnits(node.getAttribute('r') || 0)
 
-    function parseEllipseNode(node) {
-      const x = parseFloatWithUnits(node.getAttribute('cx') || 0)
-      const y = parseFloatWithUnits(node.getAttribute('cy') || 0)
-      const rx = parseFloatWithUnits(node.getAttribute('rx') || 0)
-      const ry = parseFloatWithUnits(node.getAttribute('ry') || 0)
+        const subpath = new Path()
+        subpath.absarc(x, y, r, 0, Math.PI * 2)
 
-      const subpath = new Path()
-      subpath.absellipse(x, y, rx, ry, 0, Math.PI * 2)
+        const path = new ShapePath()
+        path.subPaths.push(subpath)
 
-      const path = new ShapePath()
-      path.subPaths.push(subpath)
+        return path
+      }
 
-      return path
-    }
+      function parseEllipseNode(node) {
+        const x = parseFloatWithUnits(node.getAttribute('cx') || 0)
+        const y = parseFloatWithUnits(node.getAttribute('cy') || 0)
+        const rx = parseFloatWithUnits(node.getAttribute('rx') || 0)
+        const ry = parseFloatWithUnits(node.getAttribute('ry') || 0)
 
-    function parseLineNode(node) {
-      const x1 = parseFloatWithUnits(node.getAttribute('x1') || 0)
-      const y1 = parseFloatWithUnits(node.getAttribute('y1') || 0)
-      const x2 = parseFloatWithUnits(node.getAttribute('x2') || 0)
-      const y2 = parseFloatWithUnits(node.getAttribute('y2') || 0)
+        const subpath = new Path()
+        subpath.absellipse(x, y, rx, ry, 0, Math.PI * 2)
 
-      const path = new ShapePath()
-      path.moveTo(x1, y1)
-      path.lineTo(x2, y2)
-      path.currentPath.autoClose = false
+        const path = new ShapePath()
+        path.subPaths.push(subpath)
 
-      return path
-    }
+        return path
+      }
 
-    //
+      function parseLineNode(node) {
+        const x1 = parseFloatWithUnits(node.getAttribute('x1') || 0)
+        const y1 = parseFloatWithUnits(node.getAttribute('y1') || 0)
+        const x2 = parseFloatWithUnits(node.getAttribute('x2') || 0)
+        const y2 = parseFloatWithUnits(node.getAttribute('y2') || 0)
 
-    function parseStyle(node, style) {
-      style = Object.assign({}, style) // clone style
+        const path = new ShapePath()
+        path.moveTo(x1, y1)
+        path.lineTo(x2, y2)
+        path.currentPath.autoClose = false
 
-      let stylesheetStyles = {}
+        return path
+      }
 
-      if (node.hasAttribute('class')) {
-        const classSelectors = node
-          .getAttribute('class')
-          .split(/\s/)
-          .filter(Boolean)
-          .map((i) => i.trim())
+      //
 
-        for (let i = 0; i < classSelectors.length; i++) {
-          stylesheetStyles = Object.assign(stylesheetStyles, stylesheets['.' + classSelectors[i]])
-        }
-      }
+      function parseStyle(node, style) {
+        style = Object.assign({}, style) // clone style
 
-      if (node.hasAttribute('id')) {
-        stylesheetStyles = Object.assign(stylesheetStyles, stylesheets['#' + node.getAttribute('id')])
-      }
+        let stylesheetStyles = {}
 
-      function addStyle(svgName, jsName, adjustFunction) {
-        if (adjustFunction === undefined)
-          adjustFunction = function copy(v) {
-            if (v.startsWith('url')) console.warn('SVGLoader: url access in attributes is not implemented.')
+        if (node.hasAttribute('class')) {
+          const classSelectors = node
+            .getAttribute('class')
+            .split(/\s/)
+            .filter(Boolean)
+            .map((i) => i.trim())
 
-            return v
+          for (let i = 0; i < classSelectors.length; i++) {
+            stylesheetStyles = Object.assign(stylesheetStyles, stylesheets['.' + classSelectors[i]])
           }
+        }
 
-        if (node.hasAttribute(svgName)) style[jsName] = adjustFunction(node.getAttribute(svgName))
-        if (stylesheetStyles[svgName]) style[jsName] = adjustFunction(stylesheetStyles[svgName])
-        if (node.style && node.style[svgName] !== '') style[jsName] = adjustFunction(node.style[svgName])
-      }
+        if (node.hasAttribute('id')) {
+          stylesheetStyles = Object.assign(stylesheetStyles, stylesheets['#' + node.getAttribute('id')])
+        }
 
-      function clamp(v) {
-        return Math.max(0, Math.min(1, parseFloatWithUnits(v)))
-      }
+        function addStyle(svgName, jsName, adjustFunction) {
+          if (adjustFunction === undefined)
+            adjustFunction = function copy(v) {
+              if (v.startsWith('url')) console.warn('SVGLoader: url access in attributes is not implemented.')
 
-      function positive(v) {
-        return Math.max(0, parseFloatWithUnits(v))
-      }
+              return v
+            }
 
-      addStyle('fill', 'fill')
-      addStyle('fill-opacity', 'fillOpacity', clamp)
-      addStyle('fill-rule', 'fillRule')
-      addStyle('opacity', 'opacity', clamp)
-      addStyle('stroke', 'stroke')
-      addStyle('stroke-opacity', 'strokeOpacity', clamp)
-      addStyle('stroke-width', 'strokeWidth', positive)
-      addStyle('stroke-linejoin', 'strokeLineJoin')
-      addStyle('stroke-linecap', 'strokeLineCap')
-      addStyle('stroke-miterlimit', 'strokeMiterLimit', positive)
-      addStyle('visibility', 'visibility')
-
-      return style
-    }
+          if (node.hasAttribute(svgName)) style[jsName] = adjustFunction(node.getAttribute(svgName))
+          if (stylesheetStyles[svgName]) style[jsName] = adjustFunction(stylesheetStyles[svgName])
+          if (node.style && node.style[svgName] !== '') style[jsName] = adjustFunction(node.style[svgName])
+        }
 
-    // http://www.w3.org/TR/SVG11/implnote.html#PathElementImplementationNotes
+        function clamp(v) {
+          return Math.max(0, Math.min(1, parseFloatWithUnits(v)))
+        }
 
-    function getReflection(a, b) {
-      return a - (b - a)
-    }
+        function positive(v) {
+          return Math.max(0, parseFloatWithUnits(v))
+        }
 
-    // from https://github.com/ppvg/svg-numbers (MIT License)
+        addStyle('fill', 'fill')
+        addStyle('fill-opacity', 'fillOpacity', clamp)
+        addStyle('fill-rule', 'fillRule')
+        addStyle('opacity', 'opacity', clamp)
+        addStyle('stroke', 'stroke')
+        addStyle('stroke-opacity', 'strokeOpacity', clamp)
+        addStyle('stroke-width', 'strokeWidth', positive)
+        addStyle('stroke-linejoin', 'strokeLineJoin')
+        addStyle('stroke-linecap', 'strokeLineCap')
+        addStyle('stroke-miterlimit', 'strokeMiterLimit', positive)
+        addStyle('visibility', 'visibility')
 
-    function parseFloats(input, flags, stride) {
-      if (typeof input !== 'string') {
-        throw new TypeError('Invalid input: ' + typeof input)
+        return style
       }
 
-      // Character groups
-      const RE = {
-        SEPARATOR: /[ \t\r\n\,.\-+]/,
-        WHITESPACE: /[ \t\r\n]/,
-        DIGIT: /[\d]/,
-        SIGN: /[-+]/,
-        POINT: /\./,
-        COMMA: /,/,
-        EXP: /e/i,
-        FLAGS: /[01]/,
-      }
+      // http://www.w3.org/TR/SVG11/implnote.html#PathElementImplementationNotes
 
-      // States
-      const SEP = 0
-      const INT = 1
-      const FLOAT = 2
-      const EXP = 3
-
-      let state = SEP
-      let seenComma = true
-      let number = '',
-        exponent = ''
-      const result = []
-
-      function throwSyntaxError(current, i, partial) {
-        const error = new SyntaxError('Unexpected character "' + current + '" at index ' + i + '.')
-        error.partial = partial
-        throw error
+      function getReflection(a, b) {
+        return a - (b - a)
       }
 
-      function newNumber() {
-        if (number !== '') {
-          if (exponent === '') result.push(Number(number))
-          else result.push(Number(number) * Math.pow(10, Number(exponent)))
+      // from https://github.com/ppvg/svg-numbers (MIT License)
+
+      function parseFloats(input, flags, stride) {
+        if (typeof input !== 'string') {
+          throw new TypeError('Invalid input: ' + typeof input)
         }
 
-        number = ''
-        exponent = ''
-      }
+        // Character groups
+        const RE = {
+          SEPARATOR: /[ \t\r\n\,.\-+]/,
+          WHITESPACE: /[ \t\r\n]/,
+          DIGIT: /[\d]/,
+          SIGN: /[-+]/,
+          POINT: /\./,
+          COMMA: /,/,
+          EXP: /e/i,
+          FLAGS: /[01]/,
+        }
 
-      let current
-      const length = input.length
+        // States
+        const SEP = 0
+        const INT = 1
+        const FLOAT = 2
+        const EXP = 3
+
+        let state = SEP
+        let seenComma = true
+        let number = '',
+          exponent = ''
+        const result = []
+
+        function throwSyntaxError(current, i, partial) {
+          const error = new SyntaxError('Unexpected character "' + current + '" at index ' + i + '.')
+          error.partial = partial
+          throw error
+        }
 
-      for (let i = 0; i < length; i++) {
-        current = input[i]
+        function newNumber() {
+          if (number !== '') {
+            if (exponent === '') result.push(Number(number))
+            else result.push(Number(number) * Math.pow(10, Number(exponent)))
+          }
 
-        // check for flags
-        if (Array.isArray(flags) && flags.includes(result.length % stride) && RE.FLAGS.test(current)) {
-          state = INT
-          number = current
-          newNumber()
-          continue
+          number = ''
+          exponent = ''
         }
 
-        // parse until next number
-        if (state === SEP) {
-          // eat whitespace
-          if (RE.WHITESPACE.test(current)) {
-            continue
-          }
+        let current
+        const length = input.length
+
+        for (let i = 0; i < length; i++) {
+          current = input[i]
 
-          // start new number
-          if (RE.DIGIT.test(current) || RE.SIGN.test(current)) {
+          // check for flags
+          if (Array.isArray(flags) && flags.includes(result.length % stride) && RE.FLAGS.test(current)) {
             state = INT
             number = current
+            newNumber()
             continue
           }
 
-          if (RE.POINT.test(current)) {
-            state = FLOAT
-            number = current
-            continue
-          }
+          // parse until next number
+          if (state === SEP) {
+            // eat whitespace
+            if (RE.WHITESPACE.test(current)) {
+              continue
+            }
 
-          // throw on double commas (e.g. "1, , 2")
-          if (RE.COMMA.test(current)) {
-            if (seenComma) {
-              throwSyntaxError(current, i, result)
+            // start new number
+            if (RE.DIGIT.test(current) || RE.SIGN.test(current)) {
+              state = INT
+              number = current
+              continue
             }
 
-            seenComma = true
-          }
-        }
+            if (RE.POINT.test(current)) {
+              state = FLOAT
+              number = current
+              continue
+            }
 
-        // parse integer part
-        if (state === INT) {
-          if (RE.DIGIT.test(current)) {
-            number += current
-            continue
-          }
+            // throw on double commas (e.g. "1, , 2")
+            if (RE.COMMA.test(current)) {
+              if (seenComma) {
+                throwSyntaxError(current, i, result)
+              }
 
-          if (RE.POINT.test(current)) {
-            number += current
-            state = FLOAT
-            continue
+              seenComma = true
+            }
           }
 
-          if (RE.EXP.test(current)) {
-            state = EXP
-            continue
-          }
+          // parse integer part
+          if (state === INT) {
+            if (RE.DIGIT.test(current)) {
+              number += current
+              continue
+            }
 
-          // throw on double signs ("-+1"), but not on sign as separator ("-1-2")
-          if (RE.SIGN.test(current) && number.length === 1 && RE.SIGN.test(number[0])) {
-            throwSyntaxError(current, i, result)
-          }
-        }
+            if (RE.POINT.test(current)) {
+              number += current
+              state = FLOAT
+              continue
+            }
 
-        // parse decimal part
-        if (state === FLOAT) {
-          if (RE.DIGIT.test(current)) {
-            number += current
-            continue
-          }
+            if (RE.EXP.test(current)) {
+              state = EXP
+              continue
+            }
 
-          if (RE.EXP.test(current)) {
-            state = EXP
-            continue
+            // throw on double signs ("-+1"), but not on sign as separator ("-1-2")
+            if (RE.SIGN.test(current) && number.length === 1 && RE.SIGN.test(number[0])) {
+              throwSyntaxError(current, i, result)
+            }
           }
 
-          // throw on double decimal points (e.g. "1..2")
-          if (RE.POINT.test(current) && number[number.length - 1] === '.') {
-            throwSyntaxError(current, i, result)
-          }
-        }
+          // parse decimal part
+          if (state === FLOAT) {
+            if (RE.DIGIT.test(current)) {
+              number += current
+              continue
+            }
 
-        // parse exponent part
-        if (state === EXP) {
-          if (RE.DIGIT.test(current)) {
-            exponent += current
-            continue
+            if (RE.EXP.test(current)) {
+              state = EXP
+              continue
+            }
+
+            // throw on double decimal points (e.g. "1..2")
+            if (RE.POINT.test(current) && number[number.length - 1] === '.') {
+              throwSyntaxError(current, i, result)
+            }
           }
 
-          if (RE.SIGN.test(current)) {
-            if (exponent === '') {
+          // parse exponent part
+          if (state === EXP) {
+            if (RE.DIGIT.test(current)) {
               exponent += current
               continue
             }
 
-            if (exponent.length === 1 && RE.SIGN.test(exponent)) {
-              throwSyntaxError(current, i, result)
+            if (RE.SIGN.test(current)) {
+              if (exponent === '') {
+                exponent += current
+                continue
+              }
+
+              if (exponent.length === 1 && RE.SIGN.test(exponent)) {
+                throwSyntaxError(current, i, result)
+              }
             }
           }
-        }
 
-        // end of number
-        if (RE.WHITESPACE.test(current)) {
-          newNumber()
-          state = SEP
-          seenComma = false
-        } else if (RE.COMMA.test(current)) {
-          newNumber()
-          state = SEP
-          seenComma = true
-        } else if (RE.SIGN.test(current)) {
-          newNumber()
-          state = INT
-          number = current
-        } else if (RE.POINT.test(current)) {
-          newNumber()
-          state = FLOAT
-          number = current
-        } else {
-          throwSyntaxError(current, i, result)
+          // end of number
+          if (RE.WHITESPACE.test(current)) {
+            newNumber()
+            state = SEP
+            seenComma = false
+          } else if (RE.COMMA.test(current)) {
+            newNumber()
+            state = SEP
+            seenComma = true
+          } else if (RE.SIGN.test(current)) {
+            newNumber()
+            state = INT
+            number = current
+          } else if (RE.POINT.test(current)) {
+            newNumber()
+            state = FLOAT
+            number = current
+          } else {
+            throwSyntaxError(current, i, result)
+          }
         }
-      }
 
-      // add the last number found (if any)
-      newNumber()
+        // add the last number found (if any)
+        newNumber()
+
+        return result
+      }
+
+      // Units
+
+      const units = ['mm', 'cm', 'in', 'pt', 'pc', 'px']
+
+      // Conversion: [ fromUnit ][ toUnit ] (-1 means dpi dependent)
+      const unitConversion = {
+        mm: {
+          mm: 1,
+          cm: 0.1,
+          in: 1 / 25.4,
+          pt: 72 / 25.4,
+          pc: 6 / 25.4,
+          px: -1,
+        },
+        cm: {
+          mm: 10,
+          cm: 1,
+          in: 1 / 2.54,
+          pt: 72 / 2.54,
+          pc: 6 / 2.54,
+          px: -1,
+        },
+        in: {
+          mm: 25.4,
+          cm: 2.54,
+          in: 1,
+          pt: 72,
+          pc: 6,
+          px: -1,
+        },
+        pt: {
+          mm: 25.4 / 72,
+          cm: 2.54 / 72,
+          in: 1 / 72,
+          pt: 1,
+          pc: 6 / 72,
+          px: -1,
+        },
+        pc: {
+          mm: 25.4 / 6,
+          cm: 2.54 / 6,
+          in: 1 / 6,
+          pt: 72 / 6,
+          pc: 1,
+          px: -1,
+        },
+        px: {
+          px: 1,
+        },
+      }
+
+      function parseFloatWithUnits(string) {
+        let theUnit = 'px'
+
+        if (typeof string === 'string' || string instanceof String) {
+          for (let i = 0, n = units.length; i < n; i++) {
+            const u = units[i]
+
+            if (string.endsWith(u)) {
+              theUnit = u
+              string = string.substring(0, string.length - u.length)
+              break
+            }
+          }
+        }
 
-      return result
-    }
+        let scale = undefined
 
-    // Units
-
-    const units = ['mm', 'cm', 'in', 'pt', 'pc', 'px']
-
-    // Conversion: [ fromUnit ][ toUnit ] (-1 means dpi dependent)
-    const unitConversion = {
-      mm: {
-        mm: 1,
-        cm: 0.1,
-        in: 1 / 25.4,
-        pt: 72 / 25.4,
-        pc: 6 / 25.4,
-        px: -1,
-      },
-      cm: {
-        mm: 10,
-        cm: 1,
-        in: 1 / 2.54,
-        pt: 72 / 2.54,
-        pc: 6 / 2.54,
-        px: -1,
-      },
-      in: {
-        mm: 25.4,
-        cm: 2.54,
-        in: 1,
-        pt: 72,
-        pc: 6,
-        px: -1,
-      },
-      pt: {
-        mm: 25.4 / 72,
-        cm: 2.54 / 72,
-        in: 1 / 72,
-        pt: 1,
-        pc: 6 / 72,
-        px: -1,
-      },
-      pc: {
-        mm: 25.4 / 6,
-        cm: 2.54 / 6,
-        in: 1 / 6,
-        pt: 72 / 6,
-        pc: 1,
-        px: -1,
-      },
-      px: {
-        px: 1,
-      },
-    }
+        if (theUnit === 'px' && scope.defaultUnit !== 'px') {
+          // Conversion scale from  pixels to inches, then to default units
 
-    function parseFloatWithUnits(string) {
-      let theUnit = 'px'
+          scale = unitConversion['in'][scope.defaultUnit] / scope.defaultDPI
+        } else {
+          scale = unitConversion[theUnit][scope.defaultUnit]
 
-      if (typeof string === 'string' || string instanceof String) {
-        for (let i = 0, n = units.length; i < n; i++) {
-          const u = units[i]
+          if (scale < 0) {
+            // Conversion scale to pixels
 
-          if (string.endsWith(u)) {
-            theUnit = u
-            string = string.substring(0, string.length - u.length)
-            break
+            scale = unitConversion[theUnit]['in'] * scope.defaultDPI
           }
         }
-      }
 
-      let scale = undefined
-
-      if (theUnit === 'px' && scope.defaultUnit !== 'px') {
-        // Conversion scale from  pixels to inches, then to default units
-
-        scale = unitConversion['in'][scope.defaultUnit] / scope.defaultDPI
-      } else {
-        scale = unitConversion[theUnit][scope.defaultUnit]
+        return scale * parseFloat(string)
+      }
 
-        if (scale < 0) {
-          // Conversion scale to pixels
+      // Transforms
 
-          scale = unitConversion[theUnit]['in'] * scope.defaultDPI
+      function getNodeTransform(node) {
+        if (
+          !(
+            node.hasAttribute('transform') ||
+            (node.nodeName === 'use' && (node.hasAttribute('x') || node.hasAttribute('y')))
+          )
+        ) {
+          return null
         }
-      }
-
-      return scale * parseFloat(string)
-    }
 
-    // Transforms
+        const transform = parseNodeTransform(node)
 
-    function getNodeTransform(node) {
-      if (
-        !(
-          node.hasAttribute('transform') ||
-          (node.nodeName === 'use' && (node.hasAttribute('x') || node.hasAttribute('y')))
-        )
-      ) {
-        return null
-      }
+        if (transformStack.length > 0) {
+          transform.premultiply(transformStack[transformStack.length - 1])
+        }
 
-      const transform = parseNodeTransform(node)
+        currentTransform.copy(transform)
+        transformStack.push(transform)
 
-      if (transformStack.length > 0) {
-        transform.premultiply(transformStack[transformStack.length - 1])
+        return transform
       }
 
-      currentTransform.copy(transform)
-      transformStack.push(transform)
+      function parseNodeTransform(node) {
+        const transform = new Matrix3()
+        const currentTransform = tempTransform0
 
-      return transform
-    }
+        if (node.nodeName === 'use' && (node.hasAttribute('x') || node.hasAttribute('y'))) {
+          const tx = parseFloatWithUnits(node.getAttribute('x'))
+          const ty = parseFloatWithUnits(node.getAttribute('y'))
 
-    function parseNodeTransform(node) {
-      const transform = new Matrix3()
-      const currentTransform = tempTransform0
+          transform.translate(tx, ty)
+        }
 
-      if (node.nodeName === 'use' && (node.hasAttribute('x') || node.hasAttribute('y'))) {
-        const tx = parseFloatWithUnits(node.getAttribute('x'))
-        const ty = parseFloatWithUnits(node.getAttribute('y'))
+        if (node.hasAttribute('transform')) {
+          const transformsTexts = node.getAttribute('transform').split(')')
 
-        transform.translate(tx, ty)
-      }
+          for (let tIndex = transformsTexts.length - 1; tIndex >= 0; tIndex--) {
+            const transformText = transformsTexts[tIndex].trim()
 
-      if (node.hasAttribute('transform')) {
-        const transformsTexts = node.getAttribute('transform').split(')')
+            if (transformText === '') continue
 
-        for (let tIndex = transformsTexts.length - 1; tIndex >= 0; tIndex--) {
-          const transformText = transformsTexts[tIndex].trim()
+            const openParPos = transformText.indexOf('(')
+            const closeParPos = transformText.length
 
-          if (transformText === '') continue
+            if (openParPos > 0 && openParPos < closeParPos) {
+              const transformType = transformText.slice(0, openParPos)
 
-          const openParPos = transformText.indexOf('(')
-          const closeParPos = transformText.length
+              const array = parseFloats(transformText.slice(openParPos + 1))
 
-          if (openParPos > 0 && openParPos < closeParPos) {
-            const transformType = transformText.slice(0, openParPos)
+              currentTransform.identity()
 
-            const array = parseFloats(transformText.slice(openParPos + 1))
-
-            currentTransform.identity()
+              switch (transformType) {
+                case 'translate':
+                  if (array.length >= 1) {
+                    const tx = array[0]
+                    let ty = 0
 
-            switch (transformType) {
-              case 'translate':
-                if (array.length >= 1) {
-                  const tx = array[0]
-                  let ty = 0
+                    if (array.length >= 2) {
+                      ty = array[1]
+                    }
 
-                  if (array.length >= 2) {
-                    ty = array[1]
+                    currentTransform.translate(tx, ty)
                   }
 
-                  currentTransform.translate(tx, ty)
-                }
-
-                break
-
-              case 'rotate':
-                if (array.length >= 1) {
-                  let angle = 0
-                  let cx = 0
-                  let cy = 0
-
-                  // Angle
-                  angle = (array[0] * Math.PI) / 180
+                  break
 
-                  if (array.length >= 3) {
-                    // Center x, y
-                    cx = array[1]
-                    cy = array[2]
+                case 'rotate':
+                  if (array.length >= 1) {
+                    let angle = 0
+                    let cx = 0
+                    let cy = 0
+
+                    // Angle
+                    angle = (array[0] * Math.PI) / 180
+
+                    if (array.length >= 3) {
+                      // Center x, y
+                      cx = array[1]
+                      cy = array[2]
+                    }
+
+                    // Rotate around center (cx, cy)
+                    tempTransform1.makeTranslation(-cx, -cy)
+                    tempTransform2.makeRotation(angle)
+                    tempTransform3.multiplyMatrices(tempTransform2, tempTransform1)
+                    tempTransform1.makeTranslation(cx, cy)
+                    currentTransform.multiplyMatrices(tempTransform1, tempTransform3)
                   }
 
-                  // Rotate around center (cx, cy)
-                  tempTransform1.makeTranslation(-cx, -cy)
-                  tempTransform2.makeRotation(angle)
-                  tempTransform3.multiplyMatrices(tempTransform2, tempTransform1)
-                  tempTransform1.makeTranslation(cx, cy)
-                  currentTransform.multiplyMatrices(tempTransform1, tempTransform3)
-                }
+                  break
 
-                break
+                case 'scale':
+                  if (array.length >= 1) {
+                    const scaleX = array[0]
+                    let scaleY = scaleX
 
-              case 'scale':
-                if (array.length >= 1) {
-                  const scaleX = array[0]
-                  let scaleY = scaleX
+                    if (array.length >= 2) {
+                      scaleY = array[1]
+                    }
 
-                  if (array.length >= 2) {
-                    scaleY = array[1]
+                    currentTransform.scale(scaleX, scaleY)
                   }
 
-                  currentTransform.scale(scaleX, scaleY)
-                }
-
-                break
+                  break
 
-              case 'skewX':
-                if (array.length === 1) {
-                  currentTransform.set(1, Math.tan((array[0] * Math.PI) / 180), 0, 0, 1, 0, 0, 0, 1)
-                }
+                case 'skewX':
+                  if (array.length === 1) {
+                    currentTransform.set(1, Math.tan((array[0] * Math.PI) / 180), 0, 0, 1, 0, 0, 0, 1)
+                  }
 
-                break
+                  break
 
-              case 'skewY':
-                if (array.length === 1) {
-                  currentTransform.set(1, 0, 0, Math.tan((array[0] * Math.PI) / 180), 1, 0, 0, 0, 1)
-                }
+                case 'skewY':
+                  if (array.length === 1) {
+                    currentTransform.set(1, 0, 0, Math.tan((array[0] * Math.PI) / 180), 1, 0, 0, 0, 1)
+                  }
 
-                break
+                  break
 
-              case 'matrix':
-                if (array.length === 6) {
-                  currentTransform.set(array[0], array[2], array[4], array[1], array[3], array[5], 0, 0, 1)
-                }
+                case 'matrix':
+                  if (array.length === 6) {
+                    currentTransform.set(array[0], array[2], array[4], array[1], array[3], array[5], 0, 0, 1)
+                  }
 
-                break
+                  break
+              }
             }
-          }
 
-          transform.premultiply(currentTransform)
+            transform.premultiply(currentTransform)
+          }
         }
-      }
 
-      return transform
-    }
+        return transform
+      }
 
-    function transformPath(path, m) {
-      function transfVec2(v2) {
-        tempV3.set(v2.x, v2.y, 1).applyMatrix3(m)
+      function transformPath(path, m) {
+        function transfVec2(v2) {
+          tempV3.set(v2.x, v2.y, 1).applyMatrix3(m)
 
-        v2.set(tempV3.x, tempV3.y)
-      }
+          v2.set(tempV3.x, tempV3.y)
+        }
 
-      function transfEllipseGeneric(curve) {
-        // For math description see:
-        // https://math.stackexchange.com/questions/4544164
+        function transfEllipseGeneric(curve) {
+          // For math description see:
+          // https://math.stackexchange.com/questions/4544164
 
-        const a = curve.xRadius
-        const b = curve.yRadius
+          const a = curve.xRadius
+          const b = curve.yRadius
 
-        const cosTheta = Math.cos(curve.aRotation)
-        const sinTheta = Math.sin(curve.aRotation)
+          const cosTheta = Math.cos(curve.aRotation)
+          const sinTheta = Math.sin(curve.aRotation)
 
-        const v1 = new Vector3(a * cosTheta, a * sinTheta, 0)
-        const v2 = new Vector3(-b * sinTheta, b * cosTheta, 0)
+          const v1 = new Vector3(a * cosTheta, a * sinTheta, 0)
+          const v2 = new Vector3(-b * sinTheta, b * cosTheta, 0)
 
-        const f1 = v1.applyMatrix3(m)
-        const f2 = v2.applyMatrix3(m)
+          const f1 = v1.applyMatrix3(m)
+          const f2 = v2.applyMatrix3(m)
 
-        const mF = tempTransform0.set(f1.x, f2.x, 0, f1.y, f2.y, 0, 0, 0, 1)
+          const mF = tempTransform0.set(f1.x, f2.x, 0, f1.y, f2.y, 0, 0, 0, 1)
 
-        const mFInv = tempTransform1.copy(mF).invert()
-        const mFInvT = tempTransform2.copy(mFInv).transpose()
-        const mQ = mFInvT.multiply(mFInv)
-        const mQe = mQ.elements
+          const mFInv = tempTransform1.copy(mF).invert()
+          const mFInvT = tempTransform2.copy(mFInv).transpose()
+          const mQ = mFInvT.multiply(mFInv)
+          const mQe = mQ.elements
 
-        const ed = eigenDecomposition(mQe[0], mQe[1], mQe[4])
-        const rt1sqrt = Math.sqrt(ed.rt1)
-        const rt2sqrt = Math.sqrt(ed.rt2)
+          const ed = eigenDecomposition(mQe[0], mQe[1], mQe[4])
+          const rt1sqrt = Math.sqrt(ed.rt1)
+          const rt2sqrt = Math.sqrt(ed.rt2)
 
-        curve.xRadius = 1 / rt1sqrt
-        curve.yRadius = 1 / rt2sqrt
-        curve.aRotation = Math.atan2(ed.sn, ed.cs)
+          curve.xRadius = 1 / rt1sqrt
+          curve.yRadius = 1 / rt2sqrt
+          curve.aRotation = Math.atan2(ed.sn, ed.cs)
 
-        const isFullEllipse = (curve.aEndAngle - curve.aStartAngle) % (2 * Math.PI) < Number.EPSILON
+          const isFullEllipse = (curve.aEndAngle - curve.aStartAngle) % (2 * Math.PI) < Number.EPSILON
 
-        // Do not touch angles of a full ellipse because after transformation they
-        // would converge to a sinle value effectively removing the whole curve
+          // Do not touch angles of a full ellipse because after transformation they
+          // would converge to a sinle value effectively removing the whole curve
 
-        if (!isFullEllipse) {
-          const mDsqrt = tempTransform1.set(rt1sqrt, 0, 0, 0, rt2sqrt, 0, 0, 0, 1)
+          if (!isFullEllipse) {
+            const mDsqrt = tempTransform1.set(rt1sqrt, 0, 0, 0, rt2sqrt, 0, 0, 0, 1)
 
-          const mRT = tempTransform2.set(ed.cs, ed.sn, 0, -ed.sn, ed.cs, 0, 0, 0, 1)
+            const mRT = tempTransform2.set(ed.cs, ed.sn, 0, -ed.sn, ed.cs, 0, 0, 0, 1)
 
-          const mDRF = mDsqrt.multiply(mRT).multiply(mF)
+            const mDRF = mDsqrt.multiply(mRT).multiply(mF)
 
-          const transformAngle = (phi) => {
-            const { x: cosR, y: sinR } = new Vector3(Math.cos(phi), Math.sin(phi), 0).applyMatrix3(mDRF)
+            const transformAngle = (phi) => {
+              const { x: cosR, y: sinR } = new Vector3(Math.cos(phi), Math.sin(phi), 0).applyMatrix3(mDRF)
 
-            return Math.atan2(sinR, cosR)
-          }
+              return Math.atan2(sinR, cosR)
+            }
 
-          curve.aStartAngle = transformAngle(curve.aStartAngle)
-          curve.aEndAngle = transformAngle(curve.aEndAngle)
+            curve.aStartAngle = transformAngle(curve.aStartAngle)
+            curve.aEndAngle = transformAngle(curve.aEndAngle)
 
-          if (isTransformFlipped(m)) {
-            curve.aClockwise = !curve.aClockwise
+            if (isTransformFlipped(m)) {
+              curve.aClockwise = !curve.aClockwise
+            }
           }
         }
-      }
 
-      function transfEllipseNoSkew(curve) {
-        // Faster shortcut if no skew is applied
-        // (e.g, a euclidean transform of a group containing the ellipse)
+        function transfEllipseNoSkew(curve) {
+          // Faster shortcut if no skew is applied
+          // (e.g, a euclidean transform of a group containing the ellipse)
 
-        const sx = getTransformScaleX(m)
-        const sy = getTransformScaleY(m)
+          const sx = getTransformScaleX(m)
+          const sy = getTransformScaleY(m)
 
-        curve.xRadius *= sx
-        curve.yRadius *= sy
+          curve.xRadius *= sx
+          curve.yRadius *= sy
 
-        // Extract rotation angle from the matrix of form:
-        //
-        //  | cosθ sx   -sinθ sy |
-        //  | sinθ sx    cosθ sy |
-        //
-        // Remembering that tanθ = sinθ / cosθ; and that
-        // `sx`, `sy`, or both might be zero.
-        const theta =
-          sx > Number.EPSILON ? Math.atan2(m.elements[1], m.elements[0]) : Math.atan2(-m.elements[3], m.elements[4])
+          // Extract rotation angle from the matrix of form:
+          //
+          //  | cosθ sx   -sinθ sy |
+          //  | sinθ sx    cosθ sy |
+          //
+          // Remembering that tanθ = sinθ / cosθ; and that
+          // `sx`, `sy`, or both might be zero.
+          const theta =
+            sx > Number.EPSILON ? Math.atan2(m.elements[1], m.elements[0]) : Math.atan2(-m.elements[3], m.elements[4])
 
-        curve.aRotation += theta
+          curve.aRotation += theta
 
-        if (isTransformFlipped(m)) {
-          curve.aStartAngle *= -1
-          curve.aEndAngle *= -1
-          curve.aClockwise = !curve.aClockwise
+          if (isTransformFlipped(m)) {
+            curve.aStartAngle *= -1
+            curve.aEndAngle *= -1
+            curve.aClockwise = !curve.aClockwise
+          }
         }
-      }
 
-      const subPaths = path.subPaths
-
-      for (let i = 0, n = subPaths.length; i < n; i++) {
-        const subPath = subPaths[i]
-        const curves = subPath.curves
-
-        for (let j = 0; j < curves.length; j++) {
-          const curve = curves[j]
-
-          if (curve.isLineCurve) {
-            transfVec2(curve.v1)
-            transfVec2(curve.v2)
-          } else if (curve.isCubicBezierCurve) {
-            transfVec2(curve.v0)
-            transfVec2(curve.v1)
-            transfVec2(curve.v2)
-            transfVec2(curve.v3)
-          } else if (curve.isQuadraticBezierCurve) {
-            transfVec2(curve.v0)
-            transfVec2(curve.v1)
-            transfVec2(curve.v2)
-          } else if (curve.isEllipseCurve) {
-            // Transform ellipse center point
-
-            tempV2.set(curve.aX, curve.aY)
-            transfVec2(tempV2)
-            curve.aX = tempV2.x
-            curve.aY = tempV2.y
-
-            // Transform ellipse shape parameters
-
-            if (isTransformSkewed(m)) {
-              transfEllipseGeneric(curve)
-            } else {
-              transfEllipseNoSkew(curve)
+        const subPaths = path.subPaths
+
+        for (let i = 0, n = subPaths.length; i < n; i++) {
+          const subPath = subPaths[i]
+          const curves = subPath.curves
+
+          for (let j = 0; j < curves.length; j++) {
+            const curve = curves[j]
+
+            if (curve.isLineCurve) {
+              transfVec2(curve.v1)
+              transfVec2(curve.v2)
+            } else if (curve.isCubicBezierCurve) {
+              transfVec2(curve.v0)
+              transfVec2(curve.v1)
+              transfVec2(curve.v2)
+              transfVec2(curve.v3)
+            } else if (curve.isQuadraticBezierCurve) {
+              transfVec2(curve.v0)
+              transfVec2(curve.v1)
+              transfVec2(curve.v2)
+            } else if (curve.isEllipseCurve) {
+              // Transform ellipse center point
+
+              tempV2.set(curve.aX, curve.aY)
+              transfVec2(tempV2)
+              curve.aX = tempV2.x
+              curve.aY = tempV2.y
+
+              // Transform ellipse shape parameters
+
+              if (isTransformSkewed(m)) {
+                transfEllipseGeneric(curve)
+              } else {
+                transfEllipseNoSkew(curve)
+              }
             }
           }
         }
       }
-    }
 
-    function isTransformFlipped(m) {
-      const te = m.elements
-      return te[0] * te[4] - te[1] * te[3] < 0
-    }
-
-    function isTransformSkewed(m) {
-      const te = m.elements
-      const basisDot = te[0] * te[3] + te[1] * te[4]
-
-      // Shortcut for trivial rotations and transformations
-      if (basisDot === 0) return false
-
-      const sx = getTransformScaleX(m)
-      const sy = getTransformScaleY(m)
+      function isTransformFlipped(m) {
+        const te = m.elements
+        return te[0] * te[4] - te[1] * te[3] < 0
+      }
 
-      return Math.abs(basisDot / (sx * sy)) > Number.EPSILON
-    }
+      function isTransformSkewed(m) {
+        const te = m.elements
+        const basisDot = te[0] * te[3] + te[1] * te[4]
 
-    function getTransformScaleX(m) {
-      const te = m.elements
-      return Math.sqrt(te[0] * te[0] + te[1] * te[1])
-    }
+        // Shortcut for trivial rotations and transformations
+        if (basisDot === 0) return false
 
-    function getTransformScaleY(m) {
-      const te = m.elements
-      return Math.sqrt(te[3] * te[3] + te[4] * te[4])
-    }
+        const sx = getTransformScaleX(m)
+        const sy = getTransformScaleY(m)
 
-    // Calculates the eigensystem of a real symmetric 2x2 matrix
-    //    [ A  B ]
-    //    [ B  C ]
-    // in the form
-    //    [ A  B ]  =  [ cs  -sn ] [ rt1   0  ] [  cs  sn ]
-    //    [ B  C ]     [ sn   cs ] [  0   rt2 ] [ -sn  cs ]
-    // where rt1 >= rt2.
-    //
-    // Adapted from: https://www.mpi-hd.mpg.de/personalhomes/globes/3x3/index.html
-    // -> Algorithms for real symmetric matrices -> Analytical (2x2 symmetric)
-    function eigenDecomposition(A, B, C) {
-      let rt1, rt2, cs, sn, t
-      const sm = A + C
-      const df = A - C
-      const rt = Math.sqrt(df * df + 4 * B * B)
-
-      if (sm > 0) {
-        rt1 = 0.5 * (sm + rt)
-        t = 1 / rt1
-        rt2 = A * t * C - B * t * B
-      } else if (sm < 0) {
-        rt2 = 0.5 * (sm - rt)
-      } else {
-        // This case needs to be treated separately to avoid div by 0
-
-        rt1 = 0.5 * rt
-        rt2 = -0.5 * rt
+        return Math.abs(basisDot / (sx * sy)) > Number.EPSILON
       }
 
-      // Calculate eigenvectors
-
-      if (df > 0) {
-        cs = df + rt
-      } else {
-        cs = df - rt
+      function getTransformScaleX(m) {
+        const te = m.elements
+        return Math.sqrt(te[0] * te[0] + te[1] * te[1])
       }
 
-      if (Math.abs(cs) > 2 * Math.abs(B)) {
-        t = (-2 * B) / cs
-        sn = 1 / Math.sqrt(1 + t * t)
-        cs = t * sn
-      } else if (Math.abs(B) === 0) {
-        cs = 1
-        sn = 0
-      } else {
-        t = (-0.5 * cs) / B
-        cs = 1 / Math.sqrt(1 + t * t)
-        sn = t * cs
+      function getTransformScaleY(m) {
+        const te = m.elements
+        return Math.sqrt(te[3] * te[3] + te[4] * te[4])
       }
 
-      if (df > 0) {
-        t = cs
-        cs = -sn
-        sn = t
-      }
+      // Calculates the eigensystem of a real symmetric 2x2 matrix
+      //    [ A  B ]
+      //    [ B  C ]
+      // in the form
+      //    [ A  B ]  =  [ cs  -sn ] [ rt1   0  ] [  cs  sn ]
+      //    [ B  C ]     [ sn   cs ] [  0   rt2 ] [ -sn  cs ]
+      // where rt1 >= rt2.
+      //
+      // Adapted from: https://www.mpi-hd.mpg.de/personalhomes/globes/3x3/index.html
+      // -> Algorithms for real symmetric matrices -> Analytical (2x2 symmetric)
+      function eigenDecomposition(A, B, C) {
+        let rt1, rt2, cs, sn, t
+        const sm = A + C
+        const df = A - C
+        const rt = Math.sqrt(df * df + 4 * B * B)
+
+        if (sm > 0) {
+          rt1 = 0.5 * (sm + rt)
+          t = 1 / rt1
+          rt2 = A * t * C - B * t * B
+        } else if (sm < 0) {
+          rt2 = 0.5 * (sm - rt)
+        } else {
+          // This case needs to be treated separately to avoid div by 0
 
-      return { rt1, rt2, cs, sn }
-    }
+          rt1 = 0.5 * rt
+          rt2 = -0.5 * rt
+        }
 
-    //
+        // Calculate eigenvectors
 
-    const paths = []
-    const stylesheets = {}
+        if (df > 0) {
+          cs = df + rt
+        } else {
+          cs = df - rt
+        }
 
-    const transformStack = []
+        if (Math.abs(cs) > 2 * Math.abs(B)) {
+          t = (-2 * B) / cs
+          sn = 1 / Math.sqrt(1 + t * t)
+          cs = t * sn
+        } else if (Math.abs(B) === 0) {
+          cs = 1
+          sn = 0
+        } else {
+          t = (-0.5 * cs) / B
+          cs = 1 / Math.sqrt(1 + t * t)
+          sn = t * cs
+        }
 
-    const tempTransform0 = new Matrix3()
-    const tempTransform1 = new Matrix3()
-    const tempTransform2 = new Matrix3()
-    const tempTransform3 = new Matrix3()
-    const tempV2 = new Vector2()
-    const tempV3 = new Vector3()
+        if (df > 0) {
+          t = cs
+          cs = -sn
+          sn = t
+        }
 
-    const currentTransform = new Matrix3()
+        return { rt1, rt2, cs, sn }
+      }
 
-    const xml = new DOMParser().parseFromString(text, 'image/svg+xml') // application/xml
+      //
 
-    parseNode(xml.documentElement, {
-      fill: '#000',
-      fillOpacity: 1,
-      strokeOpacity: 1,
-      strokeWidth: 1,
-      strokeLineJoin: 'miter',
-      strokeLineCap: 'butt',
-      strokeMiterLimit: 4,
-    })
+      const paths = []
+      const stylesheets = {}
 
-    const data = { paths: paths, xml: xml.documentElement }
+      const transformStack = []
 
-    // console.log( paths );
-    return data
-  }
+      const tempTransform0 = new Matrix3()
+      const tempTransform1 = new Matrix3()
+      const tempTransform2 = new Matrix3()
+      const tempTransform3 = new Matrix3()
+      const tempV2 = new Vector2()
+      const tempV3 = new Vector3()
 
-  static createShapes(shapePath) {
-    // Param shapePath: a shapepath as returned by the parse function of this class
-    // Returns Shape object
+      const currentTransform = new Matrix3()
 
-    const BIGNUMBER = 999999999
+      const xml = new DOMParser().parseFromString(text, 'image/svg+xml') // application/xml
 
-    const IntersectionLocationType = {
-      ORIGIN: 0,
-      DESTINATION: 1,
-      BETWEEN: 2,
-      LEFT: 3,
-      RIGHT: 4,
-      BEHIND: 5,
-      BEYOND: 6,
-    }
+      parseNode(xml.documentElement, {
+        fill: '#000',
+        fillOpacity: 1,
+        strokeOpacity: 1,
+        strokeWidth: 1,
+        strokeLineJoin: 'miter',
+        strokeLineCap: 'butt',
+        strokeMiterLimit: 4,
+      })
 
-    const classifyResult = {
-      loc: IntersectionLocationType.ORIGIN,
-      t: 0,
-    }
+      const data = { paths: paths, xml: xml.documentElement }
 
-    function findEdgeIntersection(a0, a1, b0, b1) {
-      const x1 = a0.x
-      const x2 = a1.x
-      const x3 = b0.x
-      const x4 = b1.x
-      const y1 = a0.y
-      const y2 = a1.y
-      const y3 = b0.y
-      const y4 = b1.y
-      const nom1 = (x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3)
-      const nom2 = (x2 - x1) * (y1 - y3) - (y2 - y1) * (x1 - x3)
-      const denom = (y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1)
-      const t1 = nom1 / denom
-      const t2 = nom2 / denom
-
-      if ((denom === 0 && nom1 !== 0) || t1 <= 0 || t1 >= 1 || t2 < 0 || t2 > 1) {
-        //1. lines are parallel or edges don't intersect
+      // console.log( paths );
+      return data
+    }
 
-        return null
-      } else if (nom1 === 0 && denom === 0) {
-        //2. lines are colinear
-
-        //check if endpoints of edge2 (b0-b1) lies on edge1 (a0-a1)
-        for (let i = 0; i < 2; i++) {
-          classifyPoint(i === 0 ? b0 : b1, a0, a1)
-          //find position of this endpoints relatively to edge1
-          if (classifyResult.loc == IntersectionLocationType.ORIGIN) {
-            const point = i === 0 ? b0 : b1
-            return { x: point.x, y: point.y, t: classifyResult.t }
-          } else if (classifyResult.loc == IntersectionLocationType.BETWEEN) {
-            const x = +(x1 + classifyResult.t * (x2 - x1)).toPrecision(10)
-            const y = +(y1 + classifyResult.t * (y2 - y1)).toPrecision(10)
-            return { x: x, y: y, t: classifyResult.t }
+    static createShapes(shapePath) {
+      // Param shapePath: a shapepath as returned by the parse function of this class
+      // Returns Shape object
+
+      const BIGNUMBER = 999999999
+
+      const IntersectionLocationType = {
+        ORIGIN: 0,
+        DESTINATION: 1,
+        BETWEEN: 2,
+        LEFT: 3,
+        RIGHT: 4,
+        BEHIND: 5,
+        BEYOND: 6,
+      }
+
+      const classifyResult = {
+        loc: IntersectionLocationType.ORIGIN,
+        t: 0,
+      }
+
+      function findEdgeIntersection(a0, a1, b0, b1) {
+        const x1 = a0.x
+        const x2 = a1.x
+        const x3 = b0.x
+        const x4 = b1.x
+        const y1 = a0.y
+        const y2 = a1.y
+        const y3 = b0.y
+        const y4 = b1.y
+        const nom1 = (x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3)
+        const nom2 = (x2 - x1) * (y1 - y3) - (y2 - y1) * (x1 - x3)
+        const denom = (y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1)
+        const t1 = nom1 / denom
+        const t2 = nom2 / denom
+
+        if ((denom === 0 && nom1 !== 0) || t1 <= 0 || t1 >= 1 || t2 < 0 || t2 > 1) {
+          //1. lines are parallel or edges don't intersect
+
+          return null
+        } else if (nom1 === 0 && denom === 0) {
+          //2. lines are colinear
+
+          //check if endpoints of edge2 (b0-b1) lies on edge1 (a0-a1)
+          for (let i = 0; i < 2; i++) {
+            classifyPoint(i === 0 ? b0 : b1, a0, a1)
+            //find position of this endpoints relatively to edge1
+            if (classifyResult.loc == IntersectionLocationType.ORIGIN) {
+              const point = i === 0 ? b0 : b1
+              return { x: point.x, y: point.y, t: classifyResult.t }
+            } else if (classifyResult.loc == IntersectionLocationType.BETWEEN) {
+              const x = +(x1 + classifyResult.t * (x2 - x1)).toPrecision(10)
+              const y = +(y1 + classifyResult.t * (y2 - y1)).toPrecision(10)
+              return { x: x, y: y, t: classifyResult.t }
+            }
           }
-        }
 
-        return null
-      } else {
-        //3. edges intersect
+          return null
+        } else {
+          //3. edges intersect
 
-        for (let i = 0; i < 2; i++) {
-          classifyPoint(i === 0 ? b0 : b1, a0, a1)
+          for (let i = 0; i < 2; i++) {
+            classifyPoint(i === 0 ? b0 : b1, a0, a1)
 
-          if (classifyResult.loc == IntersectionLocationType.ORIGIN) {
-            const point = i === 0 ? b0 : b1
-            return { x: point.x, y: point.y, t: classifyResult.t }
+            if (classifyResult.loc == IntersectionLocationType.ORIGIN) {
+              const point = i === 0 ? b0 : b1
+              return { x: point.x, y: point.y, t: classifyResult.t }
+            }
           }
-        }
 
-        const x = +(x1 + t1 * (x2 - x1)).toPrecision(10)
-        const y = +(y1 + t1 * (y2 - y1)).toPrecision(10)
-        return { x: x, y: y, t: t1 }
+          const x = +(x1 + t1 * (x2 - x1)).toPrecision(10)
+          const y = +(y1 + t1 * (y2 - y1)).toPrecision(10)
+          return { x: x, y: y, t: t1 }
+        }
       }
-    }
 
-    function classifyPoint(p, edgeStart, edgeEnd) {
-      const ax = edgeEnd.x - edgeStart.x
-      const ay = edgeEnd.y - edgeStart.y
-      const bx = p.x - edgeStart.x
-      const by = p.y - edgeStart.y
-      const sa = ax * by - bx * ay
-
-      if (p.x === edgeStart.x && p.y === edgeStart.y) {
-        classifyResult.loc = IntersectionLocationType.ORIGIN
-        classifyResult.t = 0
-        return
-      }
+      function classifyPoint(p, edgeStart, edgeEnd) {
+        const ax = edgeEnd.x - edgeStart.x
+        const ay = edgeEnd.y - edgeStart.y
+        const bx = p.x - edgeStart.x
+        const by = p.y - edgeStart.y
+        const sa = ax * by - bx * ay
 
-      if (p.x === edgeEnd.x && p.y === edgeEnd.y) {
-        classifyResult.loc = IntersectionLocationType.DESTINATION
-        classifyResult.t = 1
-        return
-      }
+        if (p.x === edgeStart.x && p.y === edgeStart.y) {
+          classifyResult.loc = IntersectionLocationType.ORIGIN
+          classifyResult.t = 0
+          return
+        }
 
-      if (sa < -Number.EPSILON) {
-        classifyResult.loc = IntersectionLocationType.LEFT
-        return
-      }
+        if (p.x === edgeEnd.x && p.y === edgeEnd.y) {
+          classifyResult.loc = IntersectionLocationType.DESTINATION
+          classifyResult.t = 1
+          return
+        }
 
-      if (sa > Number.EPSILON) {
-        classifyResult.loc = IntersectionLocationType.RIGHT
-        return
-      }
+        if (sa < -Number.EPSILON) {
+          classifyResult.loc = IntersectionLocationType.LEFT
+          return
+        }
 
-      if (ax * bx < 0 || ay * by < 0) {
-        classifyResult.loc = IntersectionLocationType.BEHIND
-        return
-      }
+        if (sa > Number.EPSILON) {
+          classifyResult.loc = IntersectionLocationType.RIGHT
+          return
+        }
 
-      if (Math.sqrt(ax * ax + ay * ay) < Math.sqrt(bx * bx + by * by)) {
-        classifyResult.loc = IntersectionLocationType.BEYOND
-        return
-      }
+        if (ax * bx < 0 || ay * by < 0) {
+          classifyResult.loc = IntersectionLocationType.BEHIND
+          return
+        }
 
-      let t
+        if (Math.sqrt(ax * ax + ay * ay) < Math.sqrt(bx * bx + by * by)) {
+          classifyResult.loc = IntersectionLocationType.BEYOND
+          return
+        }
 
-      if (ax !== 0) {
-        t = bx / ax
-      } else {
-        t = by / ay
-      }
+        let t
 
-      classifyResult.loc = IntersectionLocationType.BETWEEN
-      classifyResult.t = t
-    }
+        if (ax !== 0) {
+          t = bx / ax
+        } else {
+          t = by / ay
+        }
+
+        classifyResult.loc = IntersectionLocationType.BETWEEN
+        classifyResult.t = t
+      }
 
-    function getIntersections(path1, path2) {
-      const intersectionsRaw = []
-      const intersections = []
+      function getIntersections(path1, path2) {
+        const intersectionsRaw = []
+        const intersections = []
 
-      for (let index = 1; index < path1.length; index++) {
-        const path1EdgeStart = path1[index - 1]
-        const path1EdgeEnd = path1[index]
+        for (let index = 1; index < path1.length; index++) {
+          const path1EdgeStart = path1[index - 1]
+          const path1EdgeEnd = path1[index]
 
-        for (let index2 = 1; index2 < path2.length; index2++) {
-          const path2EdgeStart = path2[index2 - 1]
-          const path2EdgeEnd = path2[index2]
+          for (let index2 = 1; index2 < path2.length; index2++) {
+            const path2EdgeStart = path2[index2 - 1]
+            const path2EdgeEnd = path2[index2]
 
-          const intersection = findEdgeIntersection(path1EdgeStart, path1EdgeEnd, path2EdgeStart, path2EdgeEnd)
+            const intersection = findEdgeIntersection(path1EdgeStart, path1EdgeEnd, path2EdgeStart, path2EdgeEnd)
 
-          if (
-            intersection !== null &&
-            intersectionsRaw.find(
-              (i) => i.t <= intersection.t + Number.EPSILON && i.t >= intersection.t - Number.EPSILON,
-            ) === undefined
-          ) {
-            intersectionsRaw.push(intersection)
-            intersections.push(new Vector2(intersection.x, intersection.y))
+            if (
+              intersection !== null &&
+              intersectionsRaw.find(
+                (i) => i.t <= intersection.t + Number.EPSILON && i.t >= intersection.t - Number.EPSILON,
+              ) === undefined
+            ) {
+              intersectionsRaw.push(intersection)
+              intersections.push(new Vector2(intersection.x, intersection.y))
+            }
           }
         }
+
+        return intersections
       }
 
-      return intersections
-    }
+      function getScanlineIntersections(scanline, boundingBox, paths) {
+        const center = new Vector2()
+        boundingBox.getCenter(center)
 
-    function getScanlineIntersections(scanline, boundingBox, paths) {
-      const center = new Vector2()
-      boundingBox.getCenter(center)
+        const allIntersections = []
 
-      const allIntersections = []
+        paths.forEach((path) => {
+          // check if the center of the bounding box is in the bounding box of the paths.
+          // this is a pruning method to limit the search of intersections in paths that can't envelop of the current path.
+          // if a path envelops another path. The center of that oter path, has to be inside the bounding box of the enveloping path.
+          if (path.boundingBox.containsPoint(center)) {
+            const intersections = getIntersections(scanline, path.points)
+
+            intersections.forEach((p) => {
+              allIntersections.push({ identifier: path.identifier, isCW: path.isCW, point: p })
+            })
+          }
+        })
 
-      paths.forEach((path) => {
-        // check if the center of the bounding box is in the bounding box of the paths.
-        // this is a pruning method to limit the search of intersections in paths that can't envelop of the current path.
-        // if a path envelops another path. The center of that oter path, has to be inside the bounding box of the enveloping path.
-        if (path.boundingBox.containsPoint(center)) {
-          const intersections = getIntersections(scanline, path.points)
+        allIntersections.sort((i1, i2) => {
+          return i1.point.x - i2.point.x
+        })
 
-          intersections.forEach((p) => {
-            allIntersections.push({ identifier: path.identifier, isCW: path.isCW, point: p })
-          })
+        return allIntersections
+      }
+
+      function isHoleTo(simplePath, allPaths, scanlineMinX, scanlineMaxX, _fillRule) {
+        if (_fillRule === null || _fillRule === undefined || _fillRule === '') {
+          _fillRule = 'nonzero'
         }
-      })
 
-      allIntersections.sort((i1, i2) => {
-        return i1.point.x - i2.point.x
-      })
+        const centerBoundingBox = new Vector2()
+        simplePath.boundingBox.getCenter(centerBoundingBox)
 
-      return allIntersections
-    }
+        const scanline = [
+          new Vector2(scanlineMinX, centerBoundingBox.y),
+          new Vector2(scanlineMaxX, centerBoundingBox.y),
+        ]
 
-    function isHoleTo(simplePath, allPaths, scanlineMinX, scanlineMaxX, _fillRule) {
-      if (_fillRule === null || _fillRule === undefined || _fillRule === '') {
-        _fillRule = 'nonzero'
-      }
+        const scanlineIntersections = getScanlineIntersections(scanline, simplePath.boundingBox, allPaths)
+
+        scanlineIntersections.sort((i1, i2) => {
+          return i1.point.x - i2.point.x
+        })
 
-      const centerBoundingBox = new Vector2()
-      simplePath.boundingBox.getCenter(centerBoundingBox)
+        const baseIntersections = []
+        const otherIntersections = []
 
-      const scanline = [new Vector2(scanlineMinX, centerBoundingBox.y), new Vector2(scanlineMaxX, centerBoundingBox.y)]
+        scanlineIntersections.forEach((i) => {
+          if (i.identifier === simplePath.identifier) {
+            baseIntersections.push(i)
+          } else {
+            otherIntersections.push(i)
+          }
+        })
 
-      const scanlineIntersections = getScanlineIntersections(scanline, simplePath.boundingBox, allPaths)
+        const firstXOfPath = baseIntersections[0].point.x
 
-      scanlineIntersections.sort((i1, i2) => {
-        return i1.point.x - i2.point.x
-      })
+        // build up the path hierarchy
+        const stack = []
+        let i = 0
 
-      const baseIntersections = []
-      const otherIntersections = []
+        while (i < otherIntersections.length && otherIntersections[i].point.x < firstXOfPath) {
+          if (stack.length > 0 && stack[stack.length - 1] === otherIntersections[i].identifier) {
+            stack.pop()
+          } else {
+            stack.push(otherIntersections[i].identifier)
+          }
 
-      scanlineIntersections.forEach((i) => {
-        if (i.identifier === simplePath.identifier) {
-          baseIntersections.push(i)
-        } else {
-          otherIntersections.push(i)
+          i++
         }
-      })
-
-      const firstXOfPath = baseIntersections[0].point.x
 
-      // build up the path hierarchy
-      const stack = []
-      let i = 0
+        stack.push(simplePath.identifier)
+
+        if (_fillRule === 'evenodd') {
+          const isHole = stack.length % 2 === 0 ? true : false
+          const isHoleFor = stack[stack.length - 2]
+
+          return { identifier: simplePath.identifier, isHole: isHole, for: isHoleFor }
+        } else if (_fillRule === 'nonzero') {
+          // check if path is a hole by counting the amount of paths with alternating rotations it has to cross.
+          let isHole = true
+          let isHoleFor = null
+          let lastCWValue = null
+
+          for (let i = 0; i < stack.length; i++) {
+            const identifier = stack[i]
+            if (isHole) {
+              lastCWValue = allPaths[identifier].isCW
+              isHole = false
+              isHoleFor = identifier
+            } else if (lastCWValue !== allPaths[identifier].isCW) {
+              lastCWValue = allPaths[identifier].isCW
+              isHole = true
+            }
+          }
 
-      while (i < otherIntersections.length && otherIntersections[i].point.x < firstXOfPath) {
-        if (stack.length > 0 && stack[stack.length - 1] === otherIntersections[i].identifier) {
-          stack.pop()
+          return { identifier: simplePath.identifier, isHole: isHole, for: isHoleFor }
         } else {
-          stack.push(otherIntersections[i].identifier)
+          console.warn('fill-rule: "' + _fillRule + '" is currently not implemented.')
         }
-
-        i++
       }
 
-      stack.push(simplePath.identifier)
-
-      if (_fillRule === 'evenodd') {
-        const isHole = stack.length % 2 === 0 ? true : false
-        const isHoleFor = stack[stack.length - 2]
-
-        return { identifier: simplePath.identifier, isHole: isHole, for: isHoleFor }
-      } else if (_fillRule === 'nonzero') {
-        // check if path is a hole by counting the amount of paths with alternating rotations it has to cross.
-        let isHole = true
-        let isHoleFor = null
-        let lastCWValue = null
-
-        for (let i = 0; i < stack.length; i++) {
-          const identifier = stack[i]
-          if (isHole) {
-            lastCWValue = allPaths[identifier].isCW
-            isHole = false
-            isHoleFor = identifier
-          } else if (lastCWValue !== allPaths[identifier].isCW) {
-            lastCWValue = allPaths[identifier].isCW
-            isHole = true
-          }
-        }
+      // check for self intersecting paths
+      // TODO
 
-        return { identifier: simplePath.identifier, isHole: isHole, for: isHoleFor }
-      } else {
-        console.warn('fill-rule: "' + _fillRule + '" is currently not implemented.')
-      }
-    }
+      // check intersecting paths
+      // TODO
+
+      // prepare paths for hole detection
+      let scanlineMinX = BIGNUMBER
+      let scanlineMaxX = -BIGNUMBER
 
-    // check for self intersecting paths
-    // TODO
+      let simplePaths = shapePath.subPaths.map((p) => {
+        const points = p.getPoints()
+        let maxY = -BIGNUMBER
+        let minY = BIGNUMBER
+        let maxX = -BIGNUMBER
+        let minX = BIGNUMBER
 
-    // check intersecting paths
-    // TODO
+        //points.forEach(p => p.y *= -1);
 
-    // prepare paths for hole detection
-    let scanlineMinX = BIGNUMBER
-    let scanlineMaxX = -BIGNUMBER
+        for (let i = 0; i < points.length; i++) {
+          const p = points[i]
 
-    let simplePaths = shapePath.subPaths.map((p) => {
-      const points = p.getPoints()
-      let maxY = -BIGNUMBER
-      let minY = BIGNUMBER
-      let maxX = -BIGNUMBER
-      let minX = BIGNUMBER
+          if (p.y > maxY) {
+            maxY = p.y
+          }
 
-      //points.forEach(p => p.y *= -1);
+          if (p.y < minY) {
+            minY = p.y
+          }
 
-      for (let i = 0; i < points.length; i++) {
-        const p = points[i]
+          if (p.x > maxX) {
+            maxX = p.x
+          }
 
-        if (p.y > maxY) {
-          maxY = p.y
+          if (p.x < minX) {
+            minX = p.x
+          }
         }
 
-        if (p.y < minY) {
-          minY = p.y
+        //
+        if (scanlineMaxX <= maxX) {
+          scanlineMaxX = maxX + 1
         }
 
-        if (p.x > maxX) {
-          maxX = p.x
+        if (scanlineMinX >= minX) {
+          scanlineMinX = minX - 1
         }
 
-        if (p.x < minX) {
-          minX = p.x
+        return {
+          curves: p.curves,
+          points: points,
+          isCW: ShapeUtils.isClockWise(points),
+          identifier: -1,
+          boundingBox: new Box2(new Vector2(minX, minY), new Vector2(maxX, maxY)),
         }
-      }
+      })
 
-      //
-      if (scanlineMaxX <= maxX) {
-        scanlineMaxX = maxX + 1
-      }
+      simplePaths = simplePaths.filter((sp) => sp.points.length > 1)
+
+      for (let identifier = 0; identifier < simplePaths.length; identifier++) {
+        simplePaths[identifier].identifier = identifier
+      }
+
+      // check if path is solid or a hole
+      const isAHole = simplePaths.map((p) =>
+        isHoleTo(
+          p,
+          simplePaths,
+          scanlineMinX,
+          scanlineMaxX,
+          shapePath.userData ? shapePath.userData.style.fillRule : undefined,
+        ),
+      )
+
+      const shapesToReturn = []
+      simplePaths.forEach((p) => {
+        const amIAHole = isAHole[p.identifier]
+
+        if (!amIAHole.isHole) {
+          const shape = new Shape()
+          shape.curves = p.curves
+          const holes = isAHole.filter((h) => h.isHole && h.for === p.identifier)
+          holes.forEach((h) => {
+            const hole = simplePaths[h.identifier]
+            const path = new Path()
+            path.curves = hole.curves
+            shape.holes.push(path)
+          })
+          shapesToReturn.push(shape)
+        }
+      })
 
-      if (scanlineMinX >= minX) {
-        scanlineMinX = minX - 1
-      }
+      return shapesToReturn
+    }
+
+    static getStrokeStyle(width, color, lineJoin, lineCap, miterLimit) {
+      // Param width: Stroke width
+      // Param color: As returned by THREE.Color.getStyle()
+      // Param lineJoin: One of "round", "bevel", "miter" or "miter-limit"
+      // Param lineCap: One of "round", "square" or "butt"
+      // Param miterLimit: Maximum join length, in multiples of the "width" parameter (join is truncated if it exceeds that distance)
+      // Returns style object
+
+      width = width !== undefined ? width : 1
+      color = color !== undefined ? color : '#000'
+      lineJoin = lineJoin !== undefined ? lineJoin : 'miter'
+      lineCap = lineCap !== undefined ? lineCap : 'butt'
+      miterLimit = miterLimit !== undefined ? miterLimit : 4
 
       return {
-        curves: p.curves,
-        points: points,
-        isCW: ShapeUtils.isClockWise(points),
-        identifier: -1,
-        boundingBox: new Box2(new Vector2(minX, minY), new Vector2(maxX, maxY)),
+        strokeColor: color,
+        strokeWidth: width,
+        strokeLineJoin: lineJoin,
+        strokeLineCap: lineCap,
+        strokeMiterLimit: miterLimit,
       }
-    })
+    }
 
-    simplePaths = simplePaths.filter((sp) => sp.points.length > 1)
+    static pointsToStroke(points, style, arcDivisions, minDistance) {
+      // Generates a stroke with some width around the given path.
+      // The path can be open or closed (last point equals to first point)
+      // Param points: Array of Vector2D (the path). Minimum 2 points.
+      // Param style: Object with SVG properties as returned by SVGLoader.getStrokeStyle(), or SVGLoader.parse() in the path.userData.style object
+      // Params arcDivisions: Arc divisions for round joins and endcaps. (Optional)
+      // Param minDistance: Points closer to this distance will be merged. (Optional)
+      // Returns BufferGeometry with stroke triangles (In plane z = 0). UV coordinates are generated ('u' along path. 'v' across it, from left to right)
 
-    for (let identifier = 0; identifier < simplePaths.length; identifier++) {
-      simplePaths[identifier].identifier = identifier
-    }
+      const vertices = []
+      const normals = []
+      const uvs = []
 
-    // check if path is solid or a hole
-    const isAHole = simplePaths.map((p) =>
-      isHoleTo(
-        p,
-        simplePaths,
-        scanlineMinX,
-        scanlineMaxX,
-        shapePath.userData ? shapePath.userData.style.fillRule : undefined,
-      ),
-    )
-
-    const shapesToReturn = []
-    simplePaths.forEach((p) => {
-      const amIAHole = isAHole[p.identifier]
-
-      if (!amIAHole.isHole) {
-        const shape = new Shape()
-        shape.curves = p.curves
-        const holes = isAHole.filter((h) => h.isHole && h.for === p.identifier)
-        holes.forEach((h) => {
-          const hole = simplePaths[h.identifier]
-          const path = new Path()
-          path.curves = hole.curves
-          shape.holes.push(path)
-        })
-        shapesToReturn.push(shape)
+      if (SVGLoader.pointsToStrokeWithBuffers(points, style, arcDivisions, minDistance, vertices, normals, uvs) === 0) {
+        return null
       }
-    })
 
-    return shapesToReturn
-  }
-
-  static getStrokeStyle(width, color, lineJoin, lineCap, miterLimit) {
-    // Param width: Stroke width
-    // Param color: As returned by THREE.Color.getStyle()
-    // Param lineJoin: One of "round", "bevel", "miter" or "miter-limit"
-    // Param lineCap: One of "round", "square" or "butt"
-    // Param miterLimit: Maximum join length, in multiples of the "width" parameter (join is truncated if it exceeds that distance)
-    // Returns style object
-
-    width = width !== undefined ? width : 1
-    color = color !== undefined ? color : '#000'
-    lineJoin = lineJoin !== undefined ? lineJoin : 'miter'
-    lineCap = lineCap !== undefined ? lineCap : 'butt'
-    miterLimit = miterLimit !== undefined ? miterLimit : 4
-
-    return {
-      strokeColor: color,
-      strokeWidth: width,
-      strokeLineJoin: lineJoin,
-      strokeLineCap: lineCap,
-      strokeMiterLimit: miterLimit,
-    }
-  }
+      const geometry = new BufferGeometry()
+      geometry.setAttribute('position', new Float32BufferAttribute(vertices, 3))
+      geometry.setAttribute('normal', new Float32BufferAttribute(normals, 3))
+      geometry.setAttribute('uv', new Float32BufferAttribute(uvs, 2))
 
-  static pointsToStroke(points, style, arcDivisions, minDistance) {
-    // Generates a stroke with some width around the given path.
-    // The path can be open or closed (last point equals to first point)
-    // Param points: Array of Vector2D (the path). Minimum 2 points.
-    // Param style: Object with SVG properties as returned by SVGLoader.getStrokeStyle(), or SVGLoader.parse() in the path.userData.style object
-    // Params arcDivisions: Arc divisions for round joins and endcaps. (Optional)
-    // Param minDistance: Points closer to this distance will be merged. (Optional)
-    // Returns BufferGeometry with stroke triangles (In plane z = 0). UV coordinates are generated ('u' along path. 'v' across it, from left to right)
-
-    const vertices = []
-    const normals = []
-    const uvs = []
-
-    if (SVGLoader.pointsToStrokeWithBuffers(points, style, arcDivisions, minDistance, vertices, normals, uvs) === 0) {
-      return null
+      return geometry
     }
 
-    const geometry = new BufferGeometry()
-    geometry.setAttribute('position', new Float32BufferAttribute(vertices, 3))
-    geometry.setAttribute('normal', new Float32BufferAttribute(normals, 3))
-    geometry.setAttribute('uv', new Float32BufferAttribute(uvs, 2))
+    static pointsToStrokeWithBuffers(points, style, arcDivisions, minDistance, vertices, normals, uvs, vertexOffset) {
+      // This function can be called to update existing arrays or buffers.
+      // Accepts same parameters as pointsToStroke, plus the buffers and optional offset.
+      // Param vertexOffset: Offset vertices to start writing in the buffers (3 elements/vertex for vertices and normals, and 2 elements/vertex for uvs)
+      // Returns number of written vertices / normals / uvs pairs
+      // if 'vertices' parameter is undefined no triangles will be generated, but the returned vertices count will still be valid (useful to preallocate the buffers)
+      // 'normals' and 'uvs' buffers are optional
+
+      const tempV2_1 = new Vector2()
+      const tempV2_2 = new Vector2()
+      const tempV2_3 = new Vector2()
+      const tempV2_4 = new Vector2()
+      const tempV2_5 = new Vector2()
+      const tempV2_6 = new Vector2()
+      const tempV2_7 = new Vector2()
+      const lastPointL = new Vector2()
+      const lastPointR = new Vector2()
+      const point0L = new Vector2()
+      const point0R = new Vector2()
+      const currentPointL = new Vector2()
+      const currentPointR = new Vector2()
+      const nextPointL = new Vector2()
+      const nextPointR = new Vector2()
+      const innerPoint = new Vector2()
+      const outerPoint = new Vector2()
+
+      arcDivisions = arcDivisions !== undefined ? arcDivisions : 12
+      minDistance = minDistance !== undefined ? minDistance : 0.001
+      vertexOffset = vertexOffset !== undefined ? vertexOffset : 0
+
+      // First ensure there are no duplicated points
+      points = removeDuplicatedPoints(points)
+
+      const numPoints = points.length
+
+      if (numPoints < 2) return 0
+
+      const isClosed = points[0].equals(points[numPoints - 1])
+
+      let currentPoint
+      let previousPoint = points[0]
+      let nextPoint
+
+      const strokeWidth2 = style.strokeWidth / 2
+
+      const deltaU = 1 / (numPoints - 1)
+      let u0 = 0,
+        u1
+
+      let innerSideModified
+      let joinIsOnLeftSide
+      let isMiter
+      let initialJoinIsOnLeftSide = false
+
+      let numVertices = 0
+      let currentCoordinate = vertexOffset * 3
+      let currentCoordinateUV = vertexOffset * 2
+
+      // Get initial left and right stroke points
+      getNormal(points[0], points[1], tempV2_1).multiplyScalar(strokeWidth2)
+      lastPointL.copy(points[0]).sub(tempV2_1)
+      lastPointR.copy(points[0]).add(tempV2_1)
+      point0L.copy(lastPointL)
+      point0R.copy(lastPointR)
+
+      for (let iPoint = 1; iPoint < numPoints; iPoint++) {
+        currentPoint = points[iPoint]
+
+        // Get next point
+        if (iPoint === numPoints - 1) {
+          if (isClosed) {
+            // Skip duplicated initial point
+            nextPoint = points[1]
+          } else nextPoint = undefined
+        } else {
+          nextPoint = points[iPoint + 1]
+        }
 
-    return geometry
-  }
+        // Normal of previous segment in tempV2_1
+        const normal1 = tempV2_1
+        getNormal(previousPoint, currentPoint, normal1)
 
-  static pointsToStrokeWithBuffers(points, style, arcDivisions, minDistance, vertices, normals, uvs, vertexOffset) {
-    // This function can be called to update existing arrays or buffers.
-    // Accepts same parameters as pointsToStroke, plus the buffers and optional offset.
-    // Param vertexOffset: Offset vertices to start writing in the buffers (3 elements/vertex for vertices and normals, and 2 elements/vertex for uvs)
-    // Returns number of written vertices / normals / uvs pairs
-    // if 'vertices' parameter is undefined no triangles will be generated, but the returned vertices count will still be valid (useful to preallocate the buffers)
-    // 'normals' and 'uvs' buffers are optional
-
-    const tempV2_1 = new Vector2()
-    const tempV2_2 = new Vector2()
-    const tempV2_3 = new Vector2()
-    const tempV2_4 = new Vector2()
-    const tempV2_5 = new Vector2()
-    const tempV2_6 = new Vector2()
-    const tempV2_7 = new Vector2()
-    const lastPointL = new Vector2()
-    const lastPointR = new Vector2()
-    const point0L = new Vector2()
-    const point0R = new Vector2()
-    const currentPointL = new Vector2()
-    const currentPointR = new Vector2()
-    const nextPointL = new Vector2()
-    const nextPointR = new Vector2()
-    const innerPoint = new Vector2()
-    const outerPoint = new Vector2()
-
-    arcDivisions = arcDivisions !== undefined ? arcDivisions : 12
-    minDistance = minDistance !== undefined ? minDistance : 0.001
-    vertexOffset = vertexOffset !== undefined ? vertexOffset : 0
-
-    // First ensure there are no duplicated points
-    points = removeDuplicatedPoints(points)
-
-    const numPoints = points.length
-
-    if (numPoints < 2) return 0
-
-    const isClosed = points[0].equals(points[numPoints - 1])
-
-    let currentPoint
-    let previousPoint = points[0]
-    let nextPoint
-
-    const strokeWidth2 = style.strokeWidth / 2
-
-    const deltaU = 1 / (numPoints - 1)
-    let u0 = 0,
-      u1
-
-    let innerSideModified
-    let joinIsOnLeftSide
-    let isMiter
-    let initialJoinIsOnLeftSide = false
-
-    let numVertices = 0
-    let currentCoordinate = vertexOffset * 3
-    let currentCoordinateUV = vertexOffset * 2
-
-    // Get initial left and right stroke points
-    getNormal(points[0], points[1], tempV2_1).multiplyScalar(strokeWidth2)
-    lastPointL.copy(points[0]).sub(tempV2_1)
-    lastPointR.copy(points[0]).add(tempV2_1)
-    point0L.copy(lastPointL)
-    point0R.copy(lastPointR)
-
-    for (let iPoint = 1; iPoint < numPoints; iPoint++) {
-      currentPoint = points[iPoint]
-
-      // Get next point
-      if (iPoint === numPoints - 1) {
-        if (isClosed) {
-          // Skip duplicated initial point
-          nextPoint = points[1]
-        } else nextPoint = undefined
-      } else {
-        nextPoint = points[iPoint + 1]
-      }
+        tempV2_3.copy(normal1).multiplyScalar(strokeWidth2)
+        currentPointL.copy(currentPoint).sub(tempV2_3)
+        currentPointR.copy(currentPoint).add(tempV2_3)
 
-      // Normal of previous segment in tempV2_1
-      const normal1 = tempV2_1
-      getNormal(previousPoint, currentPoint, normal1)
-
-      tempV2_3.copy(normal1).multiplyScalar(strokeWidth2)
-      currentPointL.copy(currentPoint).sub(tempV2_3)
-      currentPointR.copy(currentPoint).add(tempV2_3)
-
-      u1 = u0 + deltaU
-
-      innerSideModified = false
-
-      if (nextPoint !== undefined) {
-        // Normal of next segment in tempV2_2
-        getNormal(currentPoint, nextPoint, tempV2_2)
-
-        tempV2_3.copy(tempV2_2).multiplyScalar(strokeWidth2)
-        nextPointL.copy(currentPoint).sub(tempV2_3)
-        nextPointR.copy(currentPoint).add(tempV2_3)
-
-        joinIsOnLeftSide = true
-        tempV2_3.subVectors(nextPoint, previousPoint)
-        if (normal1.dot(tempV2_3) < 0) {
-          joinIsOnLeftSide = false
-        }
-
-        if (iPoint === 1) initialJoinIsOnLeftSide = joinIsOnLeftSide
-
-        tempV2_3.subVectors(nextPoint, currentPoint)
-        tempV2_3.normalize()
-        const dot = Math.abs(normal1.dot(tempV2_3))
-
-        // If path is straight, don't create join
-        if (dot > Number.EPSILON) {
-          // Compute inner and outer segment intersections
-          const miterSide = strokeWidth2 / dot
-          tempV2_3.multiplyScalar(-miterSide)
-          tempV2_4.subVectors(currentPoint, previousPoint)
-          tempV2_5.copy(tempV2_4).setLength(miterSide).add(tempV2_3)
-          innerPoint.copy(tempV2_5).negate()
-          const miterLength2 = tempV2_5.length()
-          const segmentLengthPrev = tempV2_4.length()
-          tempV2_4.divideScalar(segmentLengthPrev)
-          tempV2_6.subVectors(nextPoint, currentPoint)
-          const segmentLengthNext = tempV2_6.length()
-          tempV2_6.divideScalar(segmentLengthNext)
-          // Check that previous and next segments doesn't overlap with the innerPoint of intersection
-          if (tempV2_4.dot(innerPoint) < segmentLengthPrev && tempV2_6.dot(innerPoint) < segmentLengthNext) {
-            innerSideModified = true
-          }
+        u1 = u0 + deltaU
 
-          outerPoint.copy(tempV2_5).add(currentPoint)
-          innerPoint.add(currentPoint)
+        innerSideModified = false
 
-          isMiter = false
+        if (nextPoint !== undefined) {
+          // Normal of next segment in tempV2_2
+          getNormal(currentPoint, nextPoint, tempV2_2)
 
-          if (innerSideModified) {
-            if (joinIsOnLeftSide) {
-              nextPointR.copy(innerPoint)
-              currentPointR.copy(innerPoint)
-            } else {
-              nextPointL.copy(innerPoint)
-              currentPointL.copy(innerPoint)
-            }
-          } else {
-            // The segment triangles are generated here if there was overlapping
+          tempV2_3.copy(tempV2_2).multiplyScalar(strokeWidth2)
+          nextPointL.copy(currentPoint).sub(tempV2_3)
+          nextPointR.copy(currentPoint).add(tempV2_3)
 
-            makeSegmentTriangles()
+          joinIsOnLeftSide = true
+          tempV2_3.subVectors(nextPoint, previousPoint)
+          if (normal1.dot(tempV2_3) < 0) {
+            joinIsOnLeftSide = false
           }
 
-          switch (style.strokeLineJoin) {
-            case 'bevel':
-              makeSegmentWithBevelJoin(joinIsOnLeftSide, innerSideModified, u1)
-
-              break
-
-            case 'round':
-              // Segment triangles
+          if (iPoint === 1) initialJoinIsOnLeftSide = joinIsOnLeftSide
+
+          tempV2_3.subVectors(nextPoint, currentPoint)
+          tempV2_3.normalize()
+          const dot = Math.abs(normal1.dot(tempV2_3))
+
+          // If path is straight, don't create join
+          if (dot > Number.EPSILON) {
+            // Compute inner and outer segment intersections
+            const miterSide = strokeWidth2 / dot
+            tempV2_3.multiplyScalar(-miterSide)
+            tempV2_4.subVectors(currentPoint, previousPoint)
+            tempV2_5.copy(tempV2_4).setLength(miterSide).add(tempV2_3)
+            innerPoint.copy(tempV2_5).negate()
+            const miterLength2 = tempV2_5.length()
+            const segmentLengthPrev = tempV2_4.length()
+            tempV2_4.divideScalar(segmentLengthPrev)
+            tempV2_6.subVectors(nextPoint, currentPoint)
+            const segmentLengthNext = tempV2_6.length()
+            tempV2_6.divideScalar(segmentLengthNext)
+            // Check that previous and next segments doesn't overlap with the innerPoint of intersection
+            if (tempV2_4.dot(innerPoint) < segmentLengthPrev && tempV2_6.dot(innerPoint) < segmentLengthNext) {
+              innerSideModified = true
+            }
 
-              createSegmentTrianglesWithMiddleSection(joinIsOnLeftSide, innerSideModified)
+            outerPoint.copy(tempV2_5).add(currentPoint)
+            innerPoint.add(currentPoint)
 
-              // Join triangles
+            isMiter = false
 
+            if (innerSideModified) {
               if (joinIsOnLeftSide) {
-                makeCircularSector(currentPoint, currentPointL, nextPointL, u1, 0)
+                nextPointR.copy(innerPoint)
+                currentPointR.copy(innerPoint)
               } else {
-                makeCircularSector(currentPoint, nextPointR, currentPointR, u1, 1)
+                nextPointL.copy(innerPoint)
+                currentPointL.copy(innerPoint)
               }
+            } else {
+              // The segment triangles are generated here if there was overlapping
 
-              break
+              makeSegmentTriangles()
+            }
 
-            case 'miter':
-            case 'miter-clip':
-            default:
-              const miterFraction = (strokeWidth2 * style.strokeMiterLimit) / miterLength2
+            switch (style.strokeLineJoin) {
+              case 'bevel':
+                makeSegmentWithBevelJoin(joinIsOnLeftSide, innerSideModified, u1)
 
-              if (miterFraction < 1) {
-                // The join miter length exceeds the miter limit
+                break
 
-                if (style.strokeLineJoin !== 'miter-clip') {
-                  makeSegmentWithBevelJoin(joinIsOnLeftSide, innerSideModified, u1)
-                  break
-                } else {
-                  // Segment triangles
+              case 'round':
+                // Segment triangles
 
-                  createSegmentTrianglesWithMiddleSection(joinIsOnLeftSide, innerSideModified)
+                createSegmentTrianglesWithMiddleSection(joinIsOnLeftSide, innerSideModified)
 
-                  // Miter-clip join triangles
+                // Join triangles
 
-                  if (joinIsOnLeftSide) {
-                    tempV2_6.subVectors(outerPoint, currentPointL).multiplyScalar(miterFraction).add(currentPointL)
-                    tempV2_7.subVectors(outerPoint, nextPointL).multiplyScalar(miterFraction).add(nextPointL)
+                if (joinIsOnLeftSide) {
+                  makeCircularSector(currentPoint, currentPointL, nextPointL, u1, 0)
+                } else {
+                  makeCircularSector(currentPoint, nextPointR, currentPointR, u1, 1)
+                }
+
+                break
 
-                    addVertex(currentPointL, u1, 0)
-                    addVertex(tempV2_6, u1, 0)
-                    addVertex(currentPoint, u1, 0.5)
+              case 'miter':
+              case 'miter-clip':
+              default:
+                const miterFraction = (strokeWidth2 * style.strokeMiterLimit) / miterLength2
 
-                    addVertex(currentPoint, u1, 0.5)
-                    addVertex(tempV2_6, u1, 0)
-                    addVertex(tempV2_7, u1, 0)
+                if (miterFraction < 1) {
+                  // The join miter length exceeds the miter limit
 
-                    addVertex(currentPoint, u1, 0.5)
-                    addVertex(tempV2_7, u1, 0)
-                    addVertex(nextPointL, u1, 0)
+                  if (style.strokeLineJoin !== 'miter-clip') {
+                    makeSegmentWithBevelJoin(joinIsOnLeftSide, innerSideModified, u1)
+                    break
                   } else {
-                    tempV2_6.subVectors(outerPoint, currentPointR).multiplyScalar(miterFraction).add(currentPointR)
-                    tempV2_7.subVectors(outerPoint, nextPointR).multiplyScalar(miterFraction).add(nextPointR)
+                    // Segment triangles
 
-                    addVertex(currentPointR, u1, 1)
-                    addVertex(tempV2_6, u1, 1)
-                    addVertex(currentPoint, u1, 0.5)
+                    createSegmentTrianglesWithMiddleSection(joinIsOnLeftSide, innerSideModified)
 
-                    addVertex(currentPoint, u1, 0.5)
-                    addVertex(tempV2_6, u1, 1)
-                    addVertex(tempV2_7, u1, 1)
+                    // Miter-clip join triangles
 
-                    addVertex(currentPoint, u1, 0.5)
-                    addVertex(tempV2_7, u1, 1)
-                    addVertex(nextPointR, u1, 1)
-                  }
-                }
-              } else {
-                // Miter join segment triangles
+                    if (joinIsOnLeftSide) {
+                      tempV2_6.subVectors(outerPoint, currentPointL).multiplyScalar(miterFraction).add(currentPointL)
+                      tempV2_7.subVectors(outerPoint, nextPointL).multiplyScalar(miterFraction).add(nextPointL)
 
-                if (innerSideModified) {
-                  // Optimized segment + join triangles
+                      addVertex(currentPointL, u1, 0)
+                      addVertex(tempV2_6, u1, 0)
+                      addVertex(currentPoint, u1, 0.5)
 
-                  if (joinIsOnLeftSide) {
-                    addVertex(lastPointR, u0, 1)
-                    addVertex(lastPointL, u0, 0)
-                    addVertex(outerPoint, u1, 0)
+                      addVertex(currentPoint, u1, 0.5)
+                      addVertex(tempV2_6, u1, 0)
+                      addVertex(tempV2_7, u1, 0)
 
-                    addVertex(lastPointR, u0, 1)
-                    addVertex(outerPoint, u1, 0)
-                    addVertex(innerPoint, u1, 1)
-                  } else {
-                    addVertex(lastPointR, u0, 1)
-                    addVertex(lastPointL, u0, 0)
-                    addVertex(outerPoint, u1, 1)
+                      addVertex(currentPoint, u1, 0.5)
+                      addVertex(tempV2_7, u1, 0)
+                      addVertex(nextPointL, u1, 0)
+                    } else {
+                      tempV2_6.subVectors(outerPoint, currentPointR).multiplyScalar(miterFraction).add(currentPointR)
+                      tempV2_7.subVectors(outerPoint, nextPointR).multiplyScalar(miterFraction).add(nextPointR)
 
-                    addVertex(lastPointL, u0, 0)
-                    addVertex(innerPoint, u1, 0)
-                    addVertex(outerPoint, u1, 1)
-                  }
+                      addVertex(currentPointR, u1, 1)
+                      addVertex(tempV2_6, u1, 1)
+                      addVertex(currentPoint, u1, 0.5)
 
-                  if (joinIsOnLeftSide) {
-                    nextPointL.copy(outerPoint)
-                  } else {
-                    nextPointR.copy(outerPoint)
+                      addVertex(currentPoint, u1, 0.5)
+                      addVertex(tempV2_6, u1, 1)
+                      addVertex(tempV2_7, u1, 1)
+
+                      addVertex(currentPoint, u1, 0.5)
+                      addVertex(tempV2_7, u1, 1)
+                      addVertex(nextPointR, u1, 1)
+                    }
                   }
                 } else {
-                  // Add extra miter join triangles
-
-                  if (joinIsOnLeftSide) {
-                    addVertex(currentPointL, u1, 0)
-                    addVertex(outerPoint, u1, 0)
-                    addVertex(currentPoint, u1, 0.5)
-
-                    addVertex(currentPoint, u1, 0.5)
-                    addVertex(outerPoint, u1, 0)
-                    addVertex(nextPointL, u1, 0)
+                  // Miter join segment triangles
+
+                  if (innerSideModified) {
+                    // Optimized segment + join triangles
+
+                    if (joinIsOnLeftSide) {
+                      addVertex(lastPointR, u0, 1)
+                      addVertex(lastPointL, u0, 0)
+                      addVertex(outerPoint, u1, 0)
+
+                      addVertex(lastPointR, u0, 1)
+                      addVertex(outerPoint, u1, 0)
+                      addVertex(innerPoint, u1, 1)
+                    } else {
+                      addVertex(lastPointR, u0, 1)
+                      addVertex(lastPointL, u0, 0)
+                      addVertex(outerPoint, u1, 1)
+
+                      addVertex(lastPointL, u0, 0)
+                      addVertex(innerPoint, u1, 0)
+                      addVertex(outerPoint, u1, 1)
+                    }
+
+                    if (joinIsOnLeftSide) {
+                      nextPointL.copy(outerPoint)
+                    } else {
+                      nextPointR.copy(outerPoint)
+                    }
                   } else {
-                    addVertex(currentPointR, u1, 1)
-                    addVertex(outerPoint, u1, 1)
-                    addVertex(currentPoint, u1, 0.5)
-
-                    addVertex(currentPoint, u1, 0.5)
-                    addVertex(outerPoint, u1, 1)
-                    addVertex(nextPointR, u1, 1)
+                    // Add extra miter join triangles
+
+                    if (joinIsOnLeftSide) {
+                      addVertex(currentPointL, u1, 0)
+                      addVertex(outerPoint, u1, 0)
+                      addVertex(currentPoint, u1, 0.5)
+
+                      addVertex(currentPoint, u1, 0.5)
+                      addVertex(outerPoint, u1, 0)
+                      addVertex(nextPointL, u1, 0)
+                    } else {
+                      addVertex(currentPointR, u1, 1)
+                      addVertex(outerPoint, u1, 1)
+                      addVertex(currentPoint, u1, 0.5)
+
+                      addVertex(currentPoint, u1, 0.5)
+                      addVertex(outerPoint, u1, 1)
+                      addVertex(nextPointR, u1, 1)
+                    }
                   }
+
+                  isMiter = true
                 }
 
-                isMiter = true
-              }
+                break
+            }
+          } else {
+            // The segment triangles are generated here when two consecutive points are collinear
 
-              break
+            makeSegmentTriangles()
           }
         } else {
-          // The segment triangles are generated here when two consecutive points are collinear
+          // The segment triangles are generated here if it is the ending segment
 
           makeSegmentTriangles()
         }
-      } else {
-        // The segment triangles are generated here if it is the ending segment
-
-        makeSegmentTriangles()
-      }
 
-      if (!isClosed && iPoint === numPoints - 1) {
-        // Start line endcap
-        addCapGeometry(points[0], point0L, point0R, joinIsOnLeftSide, true, u0)
-      }
+        if (!isClosed && iPoint === numPoints - 1) {
+          // Start line endcap
+          addCapGeometry(points[0], point0L, point0R, joinIsOnLeftSide, true, u0)
+        }
 
-      // Increment loop variables
+        // Increment loop variables
 
-      u0 = u1
+        u0 = u1
 
-      previousPoint = currentPoint
+        previousPoint = currentPoint
 
-      lastPointL.copy(nextPointL)
-      lastPointR.copy(nextPointR)
-    }
+        lastPointL.copy(nextPointL)
+        lastPointR.copy(nextPointR)
+      }
 
-    if (!isClosed) {
-      // Ending line endcap
-      addCapGeometry(currentPoint, currentPointL, currentPointR, joinIsOnLeftSide, false, u1)
-    } else if (innerSideModified && vertices) {
-      // Modify path first segment vertices to adjust to the segments inner and outer intersections
+      if (!isClosed) {
+        // Ending line endcap
+        addCapGeometry(currentPoint, currentPointL, currentPointR, joinIsOnLeftSide, false, u1)
+      } else if (innerSideModified && vertices) {
+        // Modify path first segment vertices to adjust to the segments inner and outer intersections
 
-      let lastOuter = outerPoint
-      let lastInner = innerPoint
+        let lastOuter = outerPoint
+        let lastInner = innerPoint
 
-      if (initialJoinIsOnLeftSide !== joinIsOnLeftSide) {
-        lastOuter = innerPoint
-        lastInner = outerPoint
-      }
+        if (initialJoinIsOnLeftSide !== joinIsOnLeftSide) {
+          lastOuter = innerPoint
+          lastInner = outerPoint
+        }
 
-      if (joinIsOnLeftSide) {
-        if (isMiter || initialJoinIsOnLeftSide) {
-          lastInner.toArray(vertices, 0 * 3)
-          lastInner.toArray(vertices, 3 * 3)
+        if (joinIsOnLeftSide) {
+          if (isMiter || initialJoinIsOnLeftSide) {
+            lastInner.toArray(vertices, 0 * 3)
+            lastInner.toArray(vertices, 3 * 3)
 
-          if (isMiter) {
-            lastOuter.toArray(vertices, 1 * 3)
+            if (isMiter) {
+              lastOuter.toArray(vertices, 1 * 3)
+            }
           }
-        }
-      } else {
-        if (isMiter || !initialJoinIsOnLeftSide) {
-          lastInner.toArray(vertices, 1 * 3)
-          lastInner.toArray(vertices, 3 * 3)
+        } else {
+          if (isMiter || !initialJoinIsOnLeftSide) {
+            lastInner.toArray(vertices, 1 * 3)
+            lastInner.toArray(vertices, 3 * 3)
 
-          if (isMiter) {
-            lastOuter.toArray(vertices, 0 * 3)
+            if (isMiter) {
+              lastOuter.toArray(vertices, 0 * 3)
+            }
           }
         }
       }
-    }
 
-    return numVertices
+      return numVertices
 
-    // -- End of algorithm
+      // -- End of algorithm
 
-    // -- Functions
+      // -- Functions
 
-    function getNormal(p1, p2, result) {
-      result.subVectors(p2, p1)
-      return result.set(-result.y, result.x).normalize()
-    }
+      function getNormal(p1, p2, result) {
+        result.subVectors(p2, p1)
+        return result.set(-result.y, result.x).normalize()
+      }
 
-    function addVertex(position, u, v) {
-      if (vertices) {
-        vertices[currentCoordinate] = position.x
-        vertices[currentCoordinate + 1] = position.y
-        vertices[currentCoordinate + 2] = 0
+      function addVertex(position, u, v) {
+        if (vertices) {
+          vertices[currentCoordinate] = position.x
+          vertices[currentCoordinate + 1] = position.y
+          vertices[currentCoordinate + 2] = 0
 
-        if (normals) {
-          normals[currentCoordinate] = 0
-          normals[currentCoordinate + 1] = 0
-          normals[currentCoordinate + 2] = 1
-        }
+          if (normals) {
+            normals[currentCoordinate] = 0
+            normals[currentCoordinate + 1] = 0
+            normals[currentCoordinate + 2] = 1
+          }
 
-        currentCoordinate += 3
+          currentCoordinate += 3
 
-        if (uvs) {
-          uvs[currentCoordinateUV] = u
-          uvs[currentCoordinateUV + 1] = v
+          if (uvs) {
+            uvs[currentCoordinateUV] = u
+            uvs[currentCoordinateUV + 1] = v
 
-          currentCoordinateUV += 2
+            currentCoordinateUV += 2
+          }
         }
+
+        numVertices += 3
       }
 
-      numVertices += 3
-    }
+      function makeCircularSector(center, p1, p2, u, v) {
+        // param p1, p2: Points in the circle arc.
+        // p1 and p2 are in clockwise direction.
 
-    function makeCircularSector(center, p1, p2, u, v) {
-      // param p1, p2: Points in the circle arc.
-      // p1 and p2 are in clockwise direction.
+        tempV2_1.copy(p1).sub(center).normalize()
+        tempV2_2.copy(p2).sub(center).normalize()
 
-      tempV2_1.copy(p1).sub(center).normalize()
-      tempV2_2.copy(p2).sub(center).normalize()
+        let angle = Math.PI
+        const dot = tempV2_1.dot(tempV2_2)
+        if (Math.abs(dot) < 1) angle = Math.abs(Math.acos(dot))
 
-      let angle = Math.PI
-      const dot = tempV2_1.dot(tempV2_2)
-      if (Math.abs(dot) < 1) angle = Math.abs(Math.acos(dot))
+        angle /= arcDivisions
 
-      angle /= arcDivisions
+        tempV2_3.copy(p1)
 
-      tempV2_3.copy(p1)
+        for (let i = 0, il = arcDivisions - 1; i < il; i++) {
+          tempV2_4.copy(tempV2_3).rotateAround(center, angle)
 
-      for (let i = 0, il = arcDivisions - 1; i < il; i++) {
-        tempV2_4.copy(tempV2_3).rotateAround(center, angle)
+          addVertex(tempV2_3, u, v)
+          addVertex(tempV2_4, u, v)
+          addVertex(center, u, 0.5)
+
+          tempV2_3.copy(tempV2_4)
+        }
 
-        addVertex(tempV2_3, u, v)
         addVertex(tempV2_4, u, v)
+        addVertex(p2, u, v)
         addVertex(center, u, 0.5)
-
-        tempV2_3.copy(tempV2_4)
       }
 
-      addVertex(tempV2_4, u, v)
-      addVertex(p2, u, v)
-      addVertex(center, u, 0.5)
-    }
-
-    function makeSegmentTriangles() {
-      addVertex(lastPointR, u0, 1)
-      addVertex(lastPointL, u0, 0)
-      addVertex(currentPointL, u1, 0)
-
-      addVertex(lastPointR, u0, 1)
-      addVertex(currentPointL, u1, 0)
-      addVertex(currentPointR, u1, 1)
-    }
+      function makeSegmentTriangles() {
+        addVertex(lastPointR, u0, 1)
+        addVertex(lastPointL, u0, 0)
+        addVertex(currentPointL, u1, 0)
 
-    function makeSegmentWithBevelJoin(joinIsOnLeftSide, innerSideModified, u) {
-      if (innerSideModified) {
-        // Optimized segment + bevel triangles
+        addVertex(lastPointR, u0, 1)
+        addVertex(currentPointL, u1, 0)
+        addVertex(currentPointR, u1, 1)
+      }
 
-        if (joinIsOnLeftSide) {
-          // Path segments triangles
+      function makeSegmentWithBevelJoin(joinIsOnLeftSide, innerSideModified, u) {
+        if (innerSideModified) {
+          // Optimized segment + bevel triangles
 
-          addVertex(lastPointR, u0, 1)
-          addVertex(lastPointL, u0, 0)
-          addVertex(currentPointL, u1, 0)
+          if (joinIsOnLeftSide) {
+            // Path segments triangles
 
-          addVertex(lastPointR, u0, 1)
-          addVertex(currentPointL, u1, 0)
-          addVertex(innerPoint, u1, 1)
+            addVertex(lastPointR, u0, 1)
+            addVertex(lastPointL, u0, 0)
+            addVertex(currentPointL, u1, 0)
 
-          // Bevel join triangle
+            addVertex(lastPointR, u0, 1)
+            addVertex(currentPointL, u1, 0)
+            addVertex(innerPoint, u1, 1)
 
-          addVertex(currentPointL, u, 0)
-          addVertex(nextPointL, u, 0)
-          addVertex(innerPoint, u, 0.5)
-        } else {
-          // Path segments triangles
+            // Bevel join triangle
 
-          addVertex(lastPointR, u0, 1)
-          addVertex(lastPointL, u0, 0)
-          addVertex(currentPointR, u1, 1)
+            addVertex(currentPointL, u, 0)
+            addVertex(nextPointL, u, 0)
+            addVertex(innerPoint, u, 0.5)
+          } else {
+            // Path segments triangles
 
-          addVertex(lastPointL, u0, 0)
-          addVertex(innerPoint, u1, 0)
-          addVertex(currentPointR, u1, 1)
+            addVertex(lastPointR, u0, 1)
+            addVertex(lastPointL, u0, 0)
+            addVertex(currentPointR, u1, 1)
 
-          // Bevel join triangle
+            addVertex(lastPointL, u0, 0)
+            addVertex(innerPoint, u1, 0)
+            addVertex(currentPointR, u1, 1)
 
-          addVertex(currentPointR, u, 1)
-          addVertex(innerPoint, u, 0)
-          addVertex(nextPointR, u, 1)
-        }
-      } else {
-        // Bevel join triangle. The segment triangles are done in the main loop
+            // Bevel join triangle
 
-        if (joinIsOnLeftSide) {
-          addVertex(currentPointL, u, 0)
-          addVertex(nextPointL, u, 0)
-          addVertex(currentPoint, u, 0.5)
+            addVertex(currentPointR, u, 1)
+            addVertex(innerPoint, u, 0)
+            addVertex(nextPointR, u, 1)
+          }
         } else {
-          addVertex(currentPointR, u, 1)
-          addVertex(nextPointR, u, 0)
-          addVertex(currentPoint, u, 0.5)
+          // Bevel join triangle. The segment triangles are done in the main loop
+
+          if (joinIsOnLeftSide) {
+            addVertex(currentPointL, u, 0)
+            addVertex(nextPointL, u, 0)
+            addVertex(currentPoint, u, 0.5)
+          } else {
+            addVertex(currentPointR, u, 1)
+            addVertex(nextPointR, u, 0)
+            addVertex(currentPoint, u, 0.5)
+          }
         }
       }
-    }
 
-    function createSegmentTrianglesWithMiddleSection(joinIsOnLeftSide, innerSideModified) {
-      if (innerSideModified) {
-        if (joinIsOnLeftSide) {
-          addVertex(lastPointR, u0, 1)
-          addVertex(lastPointL, u0, 0)
-          addVertex(currentPointL, u1, 0)
+      function createSegmentTrianglesWithMiddleSection(joinIsOnLeftSide, innerSideModified) {
+        if (innerSideModified) {
+          if (joinIsOnLeftSide) {
+            addVertex(lastPointR, u0, 1)
+            addVertex(lastPointL, u0, 0)
+            addVertex(currentPointL, u1, 0)
 
-          addVertex(lastPointR, u0, 1)
-          addVertex(currentPointL, u1, 0)
-          addVertex(innerPoint, u1, 1)
+            addVertex(lastPointR, u0, 1)
+            addVertex(currentPointL, u1, 0)
+            addVertex(innerPoint, u1, 1)
 
-          addVertex(currentPointL, u0, 0)
-          addVertex(currentPoint, u1, 0.5)
-          addVertex(innerPoint, u1, 1)
+            addVertex(currentPointL, u0, 0)
+            addVertex(currentPoint, u1, 0.5)
+            addVertex(innerPoint, u1, 1)
 
-          addVertex(currentPoint, u1, 0.5)
-          addVertex(nextPointL, u0, 0)
-          addVertex(innerPoint, u1, 1)
-        } else {
-          addVertex(lastPointR, u0, 1)
-          addVertex(lastPointL, u0, 0)
-          addVertex(currentPointR, u1, 1)
+            addVertex(currentPoint, u1, 0.5)
+            addVertex(nextPointL, u0, 0)
+            addVertex(innerPoint, u1, 1)
+          } else {
+            addVertex(lastPointR, u0, 1)
+            addVertex(lastPointL, u0, 0)
+            addVertex(currentPointR, u1, 1)
 
-          addVertex(lastPointL, u0, 0)
-          addVertex(innerPoint, u1, 0)
-          addVertex(currentPointR, u1, 1)
+            addVertex(lastPointL, u0, 0)
+            addVertex(innerPoint, u1, 0)
+            addVertex(currentPointR, u1, 1)
 
-          addVertex(currentPointR, u0, 1)
-          addVertex(innerPoint, u1, 0)
-          addVertex(currentPoint, u1, 0.5)
+            addVertex(currentPointR, u0, 1)
+            addVertex(innerPoint, u1, 0)
+            addVertex(currentPoint, u1, 0.5)
 
-          addVertex(currentPoint, u1, 0.5)
-          addVertex(innerPoint, u1, 0)
-          addVertex(nextPointR, u0, 1)
+            addVertex(currentPoint, u1, 0.5)
+            addVertex(innerPoint, u1, 0)
+            addVertex(nextPointR, u0, 1)
+          }
         }
       }
-    }
 
-    function addCapGeometry(center, p1, p2, joinIsOnLeftSide, start, u) {
-      // param center: End point of the path
-      // param p1, p2: Left and right cap points
+      function addCapGeometry(center, p1, p2, joinIsOnLeftSide, start, u) {
+        // param center: End point of the path
+        // param p1, p2: Left and right cap points
 
-      switch (style.strokeLineCap) {
-        case 'round':
-          if (start) {
-            makeCircularSector(center, p2, p1, u, 0.5)
-          } else {
-            makeCircularSector(center, p1, p2, u, 0.5)
-          }
+        switch (style.strokeLineCap) {
+          case 'round':
+            if (start) {
+              makeCircularSector(center, p2, p1, u, 0.5)
+            } else {
+              makeCircularSector(center, p1, p2, u, 0.5)
+            }
 
-          break
+            break
 
-        case 'square':
-          if (start) {
-            tempV2_1.subVectors(p1, center)
-            tempV2_2.set(tempV2_1.y, -tempV2_1.x)
+          case 'square':
+            if (start) {
+              tempV2_1.subVectors(p1, center)
+              tempV2_2.set(tempV2_1.y, -tempV2_1.x)
 
-            tempV2_3.addVectors(tempV2_1, tempV2_2).add(center)
-            tempV2_4.subVectors(tempV2_2, tempV2_1).add(center)
+              tempV2_3.addVectors(tempV2_1, tempV2_2).add(center)
+              tempV2_4.subVectors(tempV2_2, tempV2_1).add(center)
 
-            // Modify already existing vertices
-            if (joinIsOnLeftSide) {
-              tempV2_3.toArray(vertices, 1 * 3)
-              tempV2_4.toArray(vertices, 0 * 3)
-              tempV2_4.toArray(vertices, 3 * 3)
+              // Modify already existing vertices
+              if (joinIsOnLeftSide) {
+                tempV2_3.toArray(vertices, 1 * 3)
+                tempV2_4.toArray(vertices, 0 * 3)
+                tempV2_4.toArray(vertices, 3 * 3)
+              } else {
+                tempV2_3.toArray(vertices, 1 * 3)
+                // using tempV2_4 to update 3rd vertex if the uv.y of 3rd vertex is 1
+                uvs[3 * 2 + 1] === 1 ? tempV2_4.toArray(vertices, 3 * 3) : tempV2_3.toArray(vertices, 3 * 3)
+                tempV2_4.toArray(vertices, 0 * 3)
+              }
             } else {
-              tempV2_3.toArray(vertices, 1 * 3)
-              // using tempV2_4 to update 3rd vertex if the uv.y of 3rd vertex is 1
-              uvs[3 * 2 + 1] === 1 ? tempV2_4.toArray(vertices, 3 * 3) : tempV2_3.toArray(vertices, 3 * 3)
-              tempV2_4.toArray(vertices, 0 * 3)
-            }
-          } else {
-            tempV2_1.subVectors(p2, center)
-            tempV2_2.set(tempV2_1.y, -tempV2_1.x)
+              tempV2_1.subVectors(p2, center)
+              tempV2_2.set(tempV2_1.y, -tempV2_1.x)
 
-            tempV2_3.addVectors(tempV2_1, tempV2_2).add(center)
-            tempV2_4.subVectors(tempV2_2, tempV2_1).add(center)
+              tempV2_3.addVectors(tempV2_1, tempV2_2).add(center)
+              tempV2_4.subVectors(tempV2_2, tempV2_1).add(center)
 
-            const vl = vertices.length
+              const vl = vertices.length
 
-            // Modify already existing vertices
-            if (joinIsOnLeftSide) {
-              tempV2_3.toArray(vertices, vl - 1 * 3)
-              tempV2_4.toArray(vertices, vl - 2 * 3)
-              tempV2_4.toArray(vertices, vl - 4 * 3)
-            } else {
-              tempV2_4.toArray(vertices, vl - 2 * 3)
-              tempV2_3.toArray(vertices, vl - 1 * 3)
-              tempV2_4.toArray(vertices, vl - 4 * 3)
+              // Modify already existing vertices
+              if (joinIsOnLeftSide) {
+                tempV2_3.toArray(vertices, vl - 1 * 3)
+                tempV2_4.toArray(vertices, vl - 2 * 3)
+                tempV2_4.toArray(vertices, vl - 4 * 3)
+              } else {
+                tempV2_4.toArray(vertices, vl - 2 * 3)
+                tempV2_3.toArray(vertices, vl - 1 * 3)
+                tempV2_4.toArray(vertices, vl - 4 * 3)
+              }
             }
-          }
 
-          break
+            break
 
-        case 'butt':
-        default:
-          // Nothing to do here
-          break
+          case 'butt':
+          default:
+            // Nothing to do here
+            break
+        }
       }
-    }
 
-    function removeDuplicatedPoints(points) {
-      // Creates a new array if necessary with duplicated points removed.
-      // This does not remove duplicated initial and ending points of a closed path.
+      function removeDuplicatedPoints(points) {
+        // Creates a new array if necessary with duplicated points removed.
+        // This does not remove duplicated initial and ending points of a closed path.
 
-      let dupPoints = false
-      for (let i = 1, n = points.length - 1; i < n; i++) {
-        if (points[i].distanceTo(points[i + 1]) < minDistance) {
-          dupPoints = true
-          break
+        let dupPoints = false
+        for (let i = 1, n = points.length - 1; i < n; i++) {
+          if (points[i].distanceTo(points[i + 1]) < minDistance) {
+            dupPoints = true
+            break
+          }
         }
-      }
 
-      if (!dupPoints) return points
+        if (!dupPoints) return points
 
-      const newPoints = []
-      newPoints.push(points[0])
+        const newPoints = []
+        newPoints.push(points[0])
 
-      for (let i = 1, n = points.length - 1; i < n; i++) {
-        if (points[i].distanceTo(points[i + 1]) >= minDistance) {
-          newPoints.push(points[i])
+        for (let i = 1, n = points.length - 1; i < n; i++) {
+          if (points[i].distanceTo(points[i + 1]) >= minDistance) {
+            newPoints.push(points[i])
+          }
         }
-      }
 
-      newPoints.push(points[points.length - 1])
+        newPoints.push(points[points.length - 1])
 
-      return newPoints
+        return newPoints
+      }
     }
   }
-}
+
+  return SVGLoader
+})()
 
 export { SVGLoader }
diff --git a/src/loaders/XLoader.js b/src/loaders/XLoader.js
index 60cba98b..073382b5 100644
--- a/src/loaders/XLoader.js
+++ b/src/loaders/XLoader.js
@@ -21,7 +21,7 @@ import {
 } from 'three'
 import { decodeText } from '../_polyfill/LoaderUtils'
 
-var XLoader = (function () {
+var XLoader = /* @__PURE__ */ (function () {
   var classCallCheck = function (instance, Constructor) {
     if (!(instance instanceof Constructor)) {
       throw new TypeError('Cannot call a class as a function')
diff --git a/src/math/Capsule.js b/src/math/Capsule.js
index bf2d12e1..63a0c956 100644
--- a/src/math/Capsule.js
+++ b/src/math/Capsule.js
@@ -1,8 +1,8 @@
 import { Vector3 } from 'three'
 
-const _v1 = new Vector3()
-const _v2 = new Vector3()
-const _v3 = new Vector3()
+const _v1 = /* @__PURE__ */ new Vector3()
+const _v2 = /* @__PURE__ */ new Vector3()
+const _v3 = /* @__PURE__ */ new Vector3()
 
 const EPS = 1e-10
 
diff --git a/src/math/ColorConverter.js b/src/math/ColorConverter.js
index 714a2c98..1fdd400b 100644
--- a/src/math/ColorConverter.js
+++ b/src/math/ColorConverter.js
@@ -2,8 +2,8 @@ import { MathUtils } from 'three'
 
 const _hsl = {}
 
-class ColorConverter {
-  static setHSV(color, h, s, v) {
+const ColorConverter = {
+  setHSV(color, h, s, v) {
     // https://gist.github.com/xpansive/1337890#file-index-js
 
     h = MathUtils.euclideanModulo(h, 1)
@@ -11,9 +11,9 @@ class ColorConverter {
     v = MathUtils.clamp(v, 0, 1)
 
     return color.setHSL(h, (s * v) / ((h = (2 - s) * v) < 1 ? h : 2 - h), h * 0.5)
-  }
+  },
 
-  static getHSV(color, target) {
+  getHSV(color, target) {
     color.getHSL(_hsl)
 
     // based on https://gist.github.com/xpansive/1337890#file-index-js
@@ -24,19 +24,19 @@ class ColorConverter {
     target.v = _hsl.l + _hsl.s
 
     return target
-  }
+  },
 
   // where c, m, y, k is between 0 and 1
 
-  static setCMYK(color, c, m, y, k) {
+  setCMYK(color, c, m, y, k) {
     const r = (1 - c) * (1 - k)
     const g = (1 - m) * (1 - k)
     const b = (1 - y) * (1 - k)
 
     return color.setRGB(r, g, b)
-  }
+  },
 
-  static getCMYK(color, target) {
+  getCMYK(color, target) {
     const r = color.r
     const g = color.g
     const b = color.b
@@ -52,7 +52,7 @@ class ColorConverter {
     target.k = k
 
     return target
-  }
+  },
 }
 
 export { ColorConverter }
diff --git a/src/math/ConvexHull.js b/src/math/ConvexHull.js
index bc345894..55633bc1 100644
--- a/src/math/ConvexHull.js
+++ b/src/math/ConvexHull.js
@@ -7,11 +7,11 @@ import { Line3, Plane, Triangle, Vector3 } from 'three'
 const Visible = 0
 const Deleted = 1
 
-const _v1 = new Vector3()
-const _line3 = new Line3()
-const _plane = new Plane()
-const _closestPoint = new Vector3()
-const _triangle = new Triangle()
+const _v1 = /* @__PURE__ */ new Vector3()
+const _line3 = /* @__PURE__ */ new Line3()
+const _plane = /* @__PURE__ */ new Plane()
+const _closestPoint = /* @__PURE__ */ new Vector3()
+const _triangle = /* @__PURE__ */ new Triangle()
 
 class ConvexHull {
   constructor() {
@@ -703,74 +703,78 @@ class ConvexHull {
 
 //
 
-class Face {
-  constructor() {
-    this.normal = new Vector3()
-    this.midpoint = new Vector3()
-    this.area = 0
+const Face = /* @__PURE__ */ (() => {
+  class Face {
+    constructor() {
+      this.normal = new Vector3()
+      this.midpoint = new Vector3()
+      this.area = 0
 
-    this.constant = 0 // signed distance from face to the origin
-    this.outside = null // reference to a vertex in a vertex list this face can see
-    this.mark = Visible
-    this.edge = null
-  }
+      this.constant = 0 // signed distance from face to the origin
+      this.outside = null // reference to a vertex in a vertex list this face can see
+      this.mark = Visible
+      this.edge = null
+    }
 
-  static create(a, b, c) {
-    const face = new Face()
+    static create(a, b, c) {
+      const face = new Face()
 
-    const e0 = new HalfEdge(a, face)
-    const e1 = new HalfEdge(b, face)
-    const e2 = new HalfEdge(c, face)
+      const e0 = new HalfEdge(a, face)
+      const e1 = new HalfEdge(b, face)
+      const e2 = new HalfEdge(c, face)
 
-    // join edges
+      // join edges
 
-    e0.next = e2.prev = e1
-    e1.next = e0.prev = e2
-    e2.next = e1.prev = e0
+      e0.next = e2.prev = e1
+      e1.next = e0.prev = e2
+      e2.next = e1.prev = e0
 
-    // main half edge reference
+      // main half edge reference
 
-    face.edge = e0
+      face.edge = e0
 
-    return face.compute()
-  }
+      return face.compute()
+    }
 
-  getEdge(i) {
-    let edge = this.edge
+    getEdge(i) {
+      let edge = this.edge
 
-    while (i > 0) {
-      edge = edge.next
-      i--
-    }
+      while (i > 0) {
+        edge = edge.next
+        i--
+      }
 
-    while (i < 0) {
-      edge = edge.prev
-      i++
+      while (i < 0) {
+        edge = edge.prev
+        i++
+      }
+
+      return edge
     }
 
-    return edge
-  }
+    compute() {
+      const a = this.edge.tail()
+      const b = this.edge.head()
+      const c = this.edge.next.head()
 
-  compute() {
-    const a = this.edge.tail()
-    const b = this.edge.head()
-    const c = this.edge.next.head()
+      _triangle.set(a.point, b.point, c.point)
 
-    _triangle.set(a.point, b.point, c.point)
+      _triangle.getNormal(this.normal)
+      _triangle.getMidpoint(this.midpoint)
+      this.area = _triangle.getArea()
 
-    _triangle.getNormal(this.normal)
-    _triangle.getMidpoint(this.midpoint)
-    this.area = _triangle.getArea()
+      this.constant = this.normal.dot(this.midpoint)
 
-    this.constant = this.normal.dot(this.midpoint)
+      return this
+    }
 
-    return this
+    distanceToPoint(point) {
+      return this.normal.dot(point) - this.constant
+    }
   }
 
-  distanceToPoint(point) {
-    return this.normal.dot(point) - this.constant
-  }
-}
+  return Face
+})()
 
 // Entity for a Doubly-Connected Edge List (DCEL).
 
diff --git a/src/math/ImprovedNoise.js b/src/math/ImprovedNoise.js
index d48fa581..f0d6981a 100644
--- a/src/math/ImprovedNoise.js
+++ b/src/math/ImprovedNoise.js
@@ -20,7 +20,7 @@ function init() {
   return _p
 }
 
-const _p = init()
+const _p = /* @__PURE__ */ init()
 
 function fade(t) {
   return t * t * t * (t * (t * 6 - 15) + 10)
diff --git a/src/math/MeshSurfaceSampler.js b/src/math/MeshSurfaceSampler.js
index 274736c4..51778207 100644
--- a/src/math/MeshSurfaceSampler.js
+++ b/src/math/MeshSurfaceSampler.js
@@ -11,8 +11,8 @@ import { Triangle, Vector3 } from 'three'
  * - https://stackoverflow.com/a/4322940/1314762
  */
 
-const _face = new Triangle()
-const _color = new Vector3()
+const _face = /* @__PURE__ */ new Triangle()
+const _color = /* @__PURE__ */ new Vector3()
 
 class MeshSurfaceSampler {
   constructor(mesh) {
diff --git a/src/math/OBB.js b/src/math/OBB.js
index c50b8032..b82b7514 100644
--- a/src/math/OBB.js
+++ b/src/math/OBB.js
@@ -4,13 +4,13 @@ import { Box3, MathUtils, Matrix4, Matrix3, Ray, Vector3 } from 'three'
 
 const a = {
   c: null, // center
-  u: [new Vector3(), new Vector3(), new Vector3()], // basis vectors
+  u: [/* @__PURE__ */ new Vector3(), /* @__PURE__ */ new Vector3(), /* @__PURE__ */ new Vector3()], // basis vectors
   e: [], // half width
 }
 
 const b = {
   c: null, // center
-  u: [new Vector3(), new Vector3(), new Vector3()], // basis vectors
+  u: [/* @__PURE__ */ new Vector3(), /* @__PURE__ */ new Vector3(), /* @__PURE__ */ new Vector3()], // basis vectors
   e: [], // half width
 }
 
@@ -18,17 +18,17 @@ const R = [[], [], []]
 const AbsR = [[], [], []]
 const t = []
 
-const xAxis = new Vector3()
-const yAxis = new Vector3()
-const zAxis = new Vector3()
-const v1 = new Vector3()
-const size = new Vector3()
-const closestPoint = new Vector3()
-const rotationMatrix = new Matrix3()
-const aabb = new Box3()
-const matrix = new Matrix4()
-const inverse = new Matrix4()
-const localRay = new Ray()
+const xAxis = /* @__PURE__ */ new Vector3()
+const yAxis = /* @__PURE__ */ new Vector3()
+const zAxis = /* @__PURE__ */ new Vector3()
+const v1 = /* @__PURE__ */ new Vector3()
+const size = /* @__PURE__ */ new Vector3()
+const closestPoint = /* @__PURE__ */ new Vector3()
+const rotationMatrix = /* @__PURE__ */ new Matrix3()
+const aabb = /* @__PURE__ */ new Box3()
+const matrix = /* @__PURE__ */ new Matrix4()
+const inverse = /* @__PURE__ */ new Matrix4()
+const localRay = /* @__PURE__ */ new Ray()
 
 // OBB
 
@@ -361,6 +361,6 @@ class OBB {
   }
 }
 
-const obb = new OBB()
+const obb = /* @__PURE__ */ new OBB()
 
 export { OBB }
diff --git a/src/math/Octree.js b/src/math/Octree.js
index 1a332e59..9882264b 100644
--- a/src/math/Octree.js
+++ b/src/math/Octree.js
@@ -1,13 +1,13 @@
 import { Box3, Line3, Plane, Sphere, Triangle, Vector3 } from 'three'
 import { Capsule } from '../math/Capsule'
 
-const _v1 = new Vector3()
-const _v2 = new Vector3()
-const _plane = new Plane()
-const _line1 = new Line3()
-const _line2 = new Line3()
-const _sphere = new Sphere()
-const _capsule = new Capsule()
+const _v1 = /* @__PURE__ */ new Vector3()
+const _v2 = /* @__PURE__ */ new Vector3()
+const _plane = /* @__PURE__ */ new Plane()
+const _line1 = /* @__PURE__ */ new Line3()
+const _line2 = /* @__PURE__ */ new Line3()
+const _sphere = /* @__PURE__ */ new Sphere()
+const _capsule = /* @__PURE__ */ new Capsule()
 
 class Octree {
   constructor(box) {
diff --git a/src/misc/ConvexObjectBreaker.js b/src/misc/ConvexObjectBreaker.js
index 76d72c63..891a2e57 100644
--- a/src/misc/ConvexObjectBreaker.js
+++ b/src/misc/ConvexObjectBreaker.js
@@ -30,423 +30,431 @@ import { ConvexGeometry } from '../geometries/ConvexGeometry'
  *
  */
 
-const _v1 = new Vector3()
-
-class ConvexObjectBreaker {
-  constructor(minSizeForBreak = 1.4, smallDelta = 0.0001) {
-    this.minSizeForBreak = minSizeForBreak
-    this.smallDelta = smallDelta
-
-    this.tempLine1 = new Line3()
-    this.tempPlane1 = new Plane()
-    this.tempPlane2 = new Plane()
-    this.tempPlane_Cut = new Plane()
-    this.tempCM1 = new Vector3()
-    this.tempCM2 = new Vector3()
-    this.tempVector3 = new Vector3()
-    this.tempVector3_2 = new Vector3()
-    this.tempVector3_3 = new Vector3()
-    this.tempVector3_P0 = new Vector3()
-    this.tempVector3_P1 = new Vector3()
-    this.tempVector3_P2 = new Vector3()
-    this.tempVector3_N0 = new Vector3()
-    this.tempVector3_N1 = new Vector3()
-    this.tempVector3_AB = new Vector3()
-    this.tempVector3_CB = new Vector3()
-    this.tempResultObjects = { object1: null, object2: null }
-
-    this.segments = []
-    const n = 30 * 30
-    for (let i = 0; i < n; i++) this.segments[i] = false
-  }
-
-  prepareBreakableObject(object, mass, velocity, angularVelocity, breakable) {
-    // object is a Object3d (normally a Mesh), must have a buffer geometry, and it must be convex.
-    // Its material property is propagated to its children (sub-pieces)
-    // mass must be > 0
+const _v1 = /* @__PURE__ */ new Vector3()
+
+const ConvexObjectBreaker = /* @__PURE__ */ (() => {
+  class ConvexObjectBreaker {
+    constructor(minSizeForBreak = 1.4, smallDelta = 0.0001) {
+      this.minSizeForBreak = minSizeForBreak
+      this.smallDelta = smallDelta
+
+      this.tempLine1 = new Line3()
+      this.tempPlane1 = new Plane()
+      this.tempPlane2 = new Plane()
+      this.tempPlane_Cut = new Plane()
+      this.tempCM1 = new Vector3()
+      this.tempCM2 = new Vector3()
+      this.tempVector3 = new Vector3()
+      this.tempVector3_2 = new Vector3()
+      this.tempVector3_3 = new Vector3()
+      this.tempVector3_P0 = new Vector3()
+      this.tempVector3_P1 = new Vector3()
+      this.tempVector3_P2 = new Vector3()
+      this.tempVector3_N0 = new Vector3()
+      this.tempVector3_N1 = new Vector3()
+      this.tempVector3_AB = new Vector3()
+      this.tempVector3_CB = new Vector3()
+      this.tempResultObjects = { object1: null, object2: null }
+
+      this.segments = []
+      const n = 30 * 30
+      for (let i = 0; i < n; i++) this.segments[i] = false
+    }
 
-    const userData = object.userData
-    userData.mass = mass
-    userData.velocity = velocity.clone()
-    userData.angularVelocity = angularVelocity.clone()
-    userData.breakable = breakable
-  }
+    prepareBreakableObject(object, mass, velocity, angularVelocity, breakable) {
+      // object is a Object3d (normally a Mesh), must have a buffer geometry, and it must be convex.
+      // Its material property is propagated to its children (sub-pieces)
+      // mass must be > 0
 
-  /*
-   * @param {int} maxRadialIterations Iterations for radial cuts.
-   * @param {int} maxRandomIterations Max random iterations for not-radial cuts
-   *
-   * Returns the array of pieces
-   */
-  subdivideByImpact(object, pointOfImpact, normal, maxRadialIterations, maxRandomIterations) {
-    const debris = []
+      const userData = object.userData
+      userData.mass = mass
+      userData.velocity = velocity.clone()
+      userData.angularVelocity = angularVelocity.clone()
+      userData.breakable = breakable
+    }
 
-    const tempPlane1 = this.tempPlane1
-    const tempPlane2 = this.tempPlane2
+    /*
+     * @param {int} maxRadialIterations Iterations for radial cuts.
+     * @param {int} maxRandomIterations Max random iterations for not-radial cuts
+     *
+     * Returns the array of pieces
+     */
+    subdivideByImpact(object, pointOfImpact, normal, maxRadialIterations, maxRandomIterations) {
+      const debris = []
 
-    this.tempVector3.addVectors(pointOfImpact, normal)
-    tempPlane1.setFromCoplanarPoints(pointOfImpact, object.position, this.tempVector3)
+      const tempPlane1 = this.tempPlane1
+      const tempPlane2 = this.tempPlane2
 
-    const maxTotalIterations = maxRandomIterations + maxRadialIterations
+      this.tempVector3.addVectors(pointOfImpact, normal)
+      tempPlane1.setFromCoplanarPoints(pointOfImpact, object.position, this.tempVector3)
 
-    const scope = this
+      const maxTotalIterations = maxRandomIterations + maxRadialIterations
 
-    function subdivideRadial(subObject, startAngle, endAngle, numIterations) {
-      if (Math.random() < numIterations * 0.05 || numIterations > maxTotalIterations) {
-        debris.push(subObject)
+      const scope = this
 
-        return
-      }
+      function subdivideRadial(subObject, startAngle, endAngle, numIterations) {
+        if (Math.random() < numIterations * 0.05 || numIterations > maxTotalIterations) {
+          debris.push(subObject)
 
-      let angle = Math.PI
+          return
+        }
 
-      if (numIterations === 0) {
-        tempPlane2.normal.copy(tempPlane1.normal)
-        tempPlane2.constant = tempPlane1.constant
-      } else {
-        if (numIterations <= maxRadialIterations) {
-          angle = (endAngle - startAngle) * (0.2 + 0.6 * Math.random()) + startAngle
+        let angle = Math.PI
 
-          // Rotate tempPlane2 at impact point around normal axis and the angle
-          scope.tempVector3_2.copy(object.position).sub(pointOfImpact).applyAxisAngle(normal, angle).add(pointOfImpact)
-          tempPlane2.setFromCoplanarPoints(pointOfImpact, scope.tempVector3, scope.tempVector3_2)
+        if (numIterations === 0) {
+          tempPlane2.normal.copy(tempPlane1.normal)
+          tempPlane2.constant = tempPlane1.constant
         } else {
-          angle = (0.5 * (numIterations & 1) + 0.2 * (2 - Math.random())) * Math.PI
-
-          // Rotate tempPlane2 at object position around normal axis and the angle
-          scope.tempVector3_2
-            .copy(pointOfImpact)
-            .sub(subObject.position)
-            .applyAxisAngle(normal, angle)
-            .add(subObject.position)
-          scope.tempVector3_3.copy(normal).add(subObject.position)
-          tempPlane2.setFromCoplanarPoints(subObject.position, scope.tempVector3_3, scope.tempVector3_2)
+          if (numIterations <= maxRadialIterations) {
+            angle = (endAngle - startAngle) * (0.2 + 0.6 * Math.random()) + startAngle
+
+            // Rotate tempPlane2 at impact point around normal axis and the angle
+            scope.tempVector3_2
+              .copy(object.position)
+              .sub(pointOfImpact)
+              .applyAxisAngle(normal, angle)
+              .add(pointOfImpact)
+            tempPlane2.setFromCoplanarPoints(pointOfImpact, scope.tempVector3, scope.tempVector3_2)
+          } else {
+            angle = (0.5 * (numIterations & 1) + 0.2 * (2 - Math.random())) * Math.PI
+
+            // Rotate tempPlane2 at object position around normal axis and the angle
+            scope.tempVector3_2
+              .copy(pointOfImpact)
+              .sub(subObject.position)
+              .applyAxisAngle(normal, angle)
+              .add(subObject.position)
+            scope.tempVector3_3.copy(normal).add(subObject.position)
+            tempPlane2.setFromCoplanarPoints(subObject.position, scope.tempVector3_3, scope.tempVector3_2)
+          }
         }
-      }
 
-      // Perform the cut
-      scope.cutByPlane(subObject, tempPlane2, scope.tempResultObjects)
+        // Perform the cut
+        scope.cutByPlane(subObject, tempPlane2, scope.tempResultObjects)
 
-      const obj1 = scope.tempResultObjects.object1
-      const obj2 = scope.tempResultObjects.object2
+        const obj1 = scope.tempResultObjects.object1
+        const obj2 = scope.tempResultObjects.object2
 
-      if (obj1) {
-        subdivideRadial(obj1, startAngle, angle, numIterations + 1)
-      }
+        if (obj1) {
+          subdivideRadial(obj1, startAngle, angle, numIterations + 1)
+        }
 
-      if (obj2) {
-        subdivideRadial(obj2, angle, endAngle, numIterations + 1)
+        if (obj2) {
+          subdivideRadial(obj2, angle, endAngle, numIterations + 1)
+        }
       }
-    }
 
-    subdivideRadial(object, 0, 2 * Math.PI, 0)
+      subdivideRadial(object, 0, 2 * Math.PI, 0)
 
-    return debris
-  }
-
-  cutByPlane(object, plane, output) {
-    // Returns breakable objects in output.object1 and output.object2 members, the resulting 2 pieces of the cut.
-    // object2 can be null if the plane doesn't cut the object.
-    // object1 can be null only in case of internal error
-    // Returned value is number of pieces, 0 for error.
+      return debris
+    }
 
-    const geometry = object.geometry
-    const coords = geometry.attributes.position.array
-    const normals = geometry.attributes.normal.array
+    cutByPlane(object, plane, output) {
+      // Returns breakable objects in output.object1 and output.object2 members, the resulting 2 pieces of the cut.
+      // object2 can be null if the plane doesn't cut the object.
+      // object1 can be null only in case of internal error
+      // Returned value is number of pieces, 0 for error.
 
-    const numPoints = coords.length / 3
-    let numFaces = numPoints / 3
+      const geometry = object.geometry
+      const coords = geometry.attributes.position.array
+      const normals = geometry.attributes.normal.array
 
-    let indices = geometry.getIndex()
+      const numPoints = coords.length / 3
+      let numFaces = numPoints / 3
 
-    if (indices) {
-      indices = indices.array
-      numFaces = indices.length / 3
-    }
+      let indices = geometry.getIndex()
 
-    function getVertexIndex(faceIdx, vert) {
-      // vert = 0, 1 or 2.
-
-      const idx = faceIdx * 3 + vert
+      if (indices) {
+        indices = indices.array
+        numFaces = indices.length / 3
+      }
 
-      return indices ? indices[idx] : idx
-    }
+      function getVertexIndex(faceIdx, vert) {
+        // vert = 0, 1 or 2.
 
-    const points1 = []
-    const points2 = []
+        const idx = faceIdx * 3 + vert
 
-    const delta = this.smallDelta
+        return indices ? indices[idx] : idx
+      }
 
-    // Reset segments mark
-    const numPointPairs = numPoints * numPoints
-    for (let i = 0; i < numPointPairs; i++) this.segments[i] = false
+      const points1 = []
+      const points2 = []
 
-    const p0 = this.tempVector3_P0
-    const p1 = this.tempVector3_P1
-    const n0 = this.tempVector3_N0
-    const n1 = this.tempVector3_N1
+      const delta = this.smallDelta
 
-    // Iterate through the faces to mark edges shared by coplanar faces
-    for (let i = 0; i < numFaces - 1; i++) {
-      const a1 = getVertexIndex(i, 0)
-      const b1 = getVertexIndex(i, 1)
-      const c1 = getVertexIndex(i, 2)
+      // Reset segments mark
+      const numPointPairs = numPoints * numPoints
+      for (let i = 0; i < numPointPairs; i++) this.segments[i] = false
 
-      // Assuming all 3 vertices have the same normal
-      n0.set(normals[a1], normals[a1] + 1, normals[a1] + 2)
+      const p0 = this.tempVector3_P0
+      const p1 = this.tempVector3_P1
+      const n0 = this.tempVector3_N0
+      const n1 = this.tempVector3_N1
 
-      for (let j = i + 1; j < numFaces; j++) {
-        const a2 = getVertexIndex(j, 0)
-        const b2 = getVertexIndex(j, 1)
-        const c2 = getVertexIndex(j, 2)
+      // Iterate through the faces to mark edges shared by coplanar faces
+      for (let i = 0; i < numFaces - 1; i++) {
+        const a1 = getVertexIndex(i, 0)
+        const b1 = getVertexIndex(i, 1)
+        const c1 = getVertexIndex(i, 2)
 
         // Assuming all 3 vertices have the same normal
-        n1.set(normals[a2], normals[a2] + 1, normals[a2] + 2)
-
-        const coplanar = 1 - n0.dot(n1) < delta
-
-        if (coplanar) {
-          if (a1 === a2 || a1 === b2 || a1 === c2) {
-            if (b1 === a2 || b1 === b2 || b1 === c2) {
-              this.segments[a1 * numPoints + b1] = true
-              this.segments[b1 * numPoints + a1] = true
-            } else {
-              this.segments[c1 * numPoints + a1] = true
-              this.segments[a1 * numPoints + c1] = true
+        n0.set(normals[a1], normals[a1] + 1, normals[a1] + 2)
+
+        for (let j = i + 1; j < numFaces; j++) {
+          const a2 = getVertexIndex(j, 0)
+          const b2 = getVertexIndex(j, 1)
+          const c2 = getVertexIndex(j, 2)
+
+          // Assuming all 3 vertices have the same normal
+          n1.set(normals[a2], normals[a2] + 1, normals[a2] + 2)
+
+          const coplanar = 1 - n0.dot(n1) < delta
+
+          if (coplanar) {
+            if (a1 === a2 || a1 === b2 || a1 === c2) {
+              if (b1 === a2 || b1 === b2 || b1 === c2) {
+                this.segments[a1 * numPoints + b1] = true
+                this.segments[b1 * numPoints + a1] = true
+              } else {
+                this.segments[c1 * numPoints + a1] = true
+                this.segments[a1 * numPoints + c1] = true
+              }
+            } else if (b1 === a2 || b1 === b2 || b1 === c2) {
+              this.segments[c1 * numPoints + b1] = true
+              this.segments[b1 * numPoints + c1] = true
             }
-          } else if (b1 === a2 || b1 === b2 || b1 === c2) {
-            this.segments[c1 * numPoints + b1] = true
-            this.segments[b1 * numPoints + c1] = true
           }
         }
       }
-    }
-
-    // Transform the plane to object local space
-    const localPlane = this.tempPlane_Cut
-    object.updateMatrix()
-    ConvexObjectBreaker.transformPlaneToLocalSpace(plane, object.matrix, localPlane)
 
-    // Iterate through the faces adding points to both pieces
-    for (let i = 0; i < numFaces; i++) {
-      const va = getVertexIndex(i, 0)
-      const vb = getVertexIndex(i, 1)
-      const vc = getVertexIndex(i, 2)
+      // Transform the plane to object local space
+      const localPlane = this.tempPlane_Cut
+      object.updateMatrix()
+      ConvexObjectBreaker.transformPlaneToLocalSpace(plane, object.matrix, localPlane)
 
-      for (let segment = 0; segment < 3; segment++) {
-        const i0 = segment === 0 ? va : segment === 1 ? vb : vc
-        const i1 = segment === 0 ? vb : segment === 1 ? vc : va
+      // Iterate through the faces adding points to both pieces
+      for (let i = 0; i < numFaces; i++) {
+        const va = getVertexIndex(i, 0)
+        const vb = getVertexIndex(i, 1)
+        const vc = getVertexIndex(i, 2)
 
-        const segmentState = this.segments[i0 * numPoints + i1]
+        for (let segment = 0; segment < 3; segment++) {
+          const i0 = segment === 0 ? va : segment === 1 ? vb : vc
+          const i1 = segment === 0 ? vb : segment === 1 ? vc : va
 
-        if (segmentState) continue // The segment already has been processed in another face
+          const segmentState = this.segments[i0 * numPoints + i1]
 
-        // Mark segment as processed (also inverted segment)
-        this.segments[i0 * numPoints + i1] = true
-        this.segments[i1 * numPoints + i0] = true
+          if (segmentState) continue // The segment already has been processed in another face
 
-        p0.set(coords[3 * i0], coords[3 * i0 + 1], coords[3 * i0 + 2])
-        p1.set(coords[3 * i1], coords[3 * i1 + 1], coords[3 * i1 + 2])
+          // Mark segment as processed (also inverted segment)
+          this.segments[i0 * numPoints + i1] = true
+          this.segments[i1 * numPoints + i0] = true
 
-        // mark: 1 for negative side, 2 for positive side, 3 for coplanar point
-        let mark0 = 0
+          p0.set(coords[3 * i0], coords[3 * i0 + 1], coords[3 * i0 + 2])
+          p1.set(coords[3 * i1], coords[3 * i1 + 1], coords[3 * i1 + 2])
 
-        let d = localPlane.distanceToPoint(p0)
+          // mark: 1 for negative side, 2 for positive side, 3 for coplanar point
+          let mark0 = 0
 
-        if (d > delta) {
-          mark0 = 2
-          points2.push(p0.clone())
-        } else if (d < -delta) {
-          mark0 = 1
-          points1.push(p0.clone())
-        } else {
-          mark0 = 3
-          points1.push(p0.clone())
-          points2.push(p0.clone())
-        }
+          let d = localPlane.distanceToPoint(p0)
 
-        // mark: 1 for negative side, 2 for positive side, 3 for coplanar point
-        let mark1 = 0
+          if (d > delta) {
+            mark0 = 2
+            points2.push(p0.clone())
+          } else if (d < -delta) {
+            mark0 = 1
+            points1.push(p0.clone())
+          } else {
+            mark0 = 3
+            points1.push(p0.clone())
+            points2.push(p0.clone())
+          }
 
-        d = localPlane.distanceToPoint(p1)
+          // mark: 1 for negative side, 2 for positive side, 3 for coplanar point
+          let mark1 = 0
+
+          d = localPlane.distanceToPoint(p1)
+
+          if (d > delta) {
+            mark1 = 2
+            points2.push(p1.clone())
+          } else if (d < -delta) {
+            mark1 = 1
+            points1.push(p1.clone())
+          } else {
+            mark1 = 3
+            points1.push(p1.clone())
+            points2.push(p1.clone())
+          }
 
-        if (d > delta) {
-          mark1 = 2
-          points2.push(p1.clone())
-        } else if (d < -delta) {
-          mark1 = 1
-          points1.push(p1.clone())
-        } else {
-          mark1 = 3
-          points1.push(p1.clone())
-          points2.push(p1.clone())
-        }
+          if ((mark0 === 1 && mark1 === 2) || (mark0 === 2 && mark1 === 1)) {
+            // Intersection of segment with the plane
 
-        if ((mark0 === 1 && mark1 === 2) || (mark0 === 2 && mark1 === 1)) {
-          // Intersection of segment with the plane
+            this.tempLine1.start.copy(p0)
+            this.tempLine1.end.copy(p1)
 
-          this.tempLine1.start.copy(p0)
-          this.tempLine1.end.copy(p1)
+            let intersection = new Vector3()
+            intersection = localPlane.intersectLine(this.tempLine1, intersection)
 
-          let intersection = new Vector3()
-          intersection = localPlane.intersectLine(this.tempLine1, intersection)
+            if (intersection === null) {
+              // Shouldn't happen
+              console.error('Internal error: segment does not intersect plane.')
+              output.segmentedObject1 = null
+              output.segmentedObject2 = null
+              return 0
+            }
 
-          if (intersection === null) {
-            // Shouldn't happen
-            console.error('Internal error: segment does not intersect plane.')
-            output.segmentedObject1 = null
-            output.segmentedObject2 = null
-            return 0
+            points1.push(intersection)
+            points2.push(intersection.clone())
           }
-
-          points1.push(intersection)
-          points2.push(intersection.clone())
         }
       }
-    }
 
-    // Calculate debris mass (very fast and imprecise):
-    const newMass = object.userData.mass * 0.5
+      // Calculate debris mass (very fast and imprecise):
+      const newMass = object.userData.mass * 0.5
 
-    // Calculate debris Center of Mass (again fast and imprecise)
-    this.tempCM1.set(0, 0, 0)
-    let radius1 = 0
-    const numPoints1 = points1.length
+      // Calculate debris Center of Mass (again fast and imprecise)
+      this.tempCM1.set(0, 0, 0)
+      let radius1 = 0
+      const numPoints1 = points1.length
 
-    if (numPoints1 > 0) {
-      for (let i = 0; i < numPoints1; i++) this.tempCM1.add(points1[i])
+      if (numPoints1 > 0) {
+        for (let i = 0; i < numPoints1; i++) this.tempCM1.add(points1[i])
 
-      this.tempCM1.divideScalar(numPoints1)
-      for (let i = 0; i < numPoints1; i++) {
-        const p = points1[i]
-        p.sub(this.tempCM1)
-        radius1 = Math.max(radius1, p.x, p.y, p.z)
+        this.tempCM1.divideScalar(numPoints1)
+        for (let i = 0; i < numPoints1; i++) {
+          const p = points1[i]
+          p.sub(this.tempCM1)
+          radius1 = Math.max(radius1, p.x, p.y, p.z)
+        }
+
+        this.tempCM1.add(object.position)
       }
 
-      this.tempCM1.add(object.position)
-    }
+      this.tempCM2.set(0, 0, 0)
+      let radius2 = 0
+      const numPoints2 = points2.length
+      if (numPoints2 > 0) {
+        for (let i = 0; i < numPoints2; i++) this.tempCM2.add(points2[i])
+
+        this.tempCM2.divideScalar(numPoints2)
+        for (let i = 0; i < numPoints2; i++) {
+          const p = points2[i]
+          p.sub(this.tempCM2)
+          radius2 = Math.max(radius2, p.x, p.y, p.z)
+        }
 
-    this.tempCM2.set(0, 0, 0)
-    let radius2 = 0
-    const numPoints2 = points2.length
-    if (numPoints2 > 0) {
-      for (let i = 0; i < numPoints2; i++) this.tempCM2.add(points2[i])
-
-      this.tempCM2.divideScalar(numPoints2)
-      for (let i = 0; i < numPoints2; i++) {
-        const p = points2[i]
-        p.sub(this.tempCM2)
-        radius2 = Math.max(radius2, p.x, p.y, p.z)
+        this.tempCM2.add(object.position)
       }
 
-      this.tempCM2.add(object.position)
-    }
-
-    let object1 = null
-    let object2 = null
+      let object1 = null
+      let object2 = null
 
-    let numObjects = 0
+      let numObjects = 0
 
-    if (numPoints1 > 4) {
-      object1 = new Mesh(new ConvexGeometry(points1), object.material)
-      object1.position.copy(this.tempCM1)
-      object1.quaternion.copy(object.quaternion)
+      if (numPoints1 > 4) {
+        object1 = new Mesh(new ConvexGeometry(points1), object.material)
+        object1.position.copy(this.tempCM1)
+        object1.quaternion.copy(object.quaternion)
 
-      this.prepareBreakableObject(
-        object1,
-        newMass,
-        object.userData.velocity,
-        object.userData.angularVelocity,
-        2 * radius1 > this.minSizeForBreak,
-      )
+        this.prepareBreakableObject(
+          object1,
+          newMass,
+          object.userData.velocity,
+          object.userData.angularVelocity,
+          2 * radius1 > this.minSizeForBreak,
+        )
 
-      numObjects++
-    }
+        numObjects++
+      }
 
-    if (numPoints2 > 4) {
-      object2 = new Mesh(new ConvexGeometry(points2), object.material)
-      object2.position.copy(this.tempCM2)
-      object2.quaternion.copy(object.quaternion)
+      if (numPoints2 > 4) {
+        object2 = new Mesh(new ConvexGeometry(points2), object.material)
+        object2.position.copy(this.tempCM2)
+        object2.quaternion.copy(object.quaternion)
 
-      this.prepareBreakableObject(
-        object2,
-        newMass,
-        object.userData.velocity,
-        object.userData.angularVelocity,
-        2 * radius2 > this.minSizeForBreak,
-      )
+        this.prepareBreakableObject(
+          object2,
+          newMass,
+          object.userData.velocity,
+          object.userData.angularVelocity,
+          2 * radius2 > this.minSizeForBreak,
+        )
 
-      numObjects++
-    }
+        numObjects++
+      }
 
-    output.object1 = object1
-    output.object2 = object2
+      output.object1 = object1
+      output.object2 = object2
 
-    return numObjects
-  }
+      return numObjects
+    }
 
-  static transformFreeVector(v, m) {
-    // input:
-    // vector interpreted as a free vector
-    // THREE.Matrix4 orthogonal matrix (matrix without scale)
+    static transformFreeVector(v, m) {
+      // input:
+      // vector interpreted as a free vector
+      // THREE.Matrix4 orthogonal matrix (matrix without scale)
 
-    const x = v.x,
-      y = v.y,
-      z = v.z
-    const e = m.elements
+      const x = v.x,
+        y = v.y,
+        z = v.z
+      const e = m.elements
 
-    v.x = e[0] * x + e[4] * y + e[8] * z
-    v.y = e[1] * x + e[5] * y + e[9] * z
-    v.z = e[2] * x + e[6] * y + e[10] * z
+      v.x = e[0] * x + e[4] * y + e[8] * z
+      v.y = e[1] * x + e[5] * y + e[9] * z
+      v.z = e[2] * x + e[6] * y + e[10] * z
 
-    return v
-  }
+      return v
+    }
 
-  static transformFreeVectorInverse(v, m) {
-    // input:
-    // vector interpreted as a free vector
-    // THREE.Matrix4 orthogonal matrix (matrix without scale)
+    static transformFreeVectorInverse(v, m) {
+      // input:
+      // vector interpreted as a free vector
+      // THREE.Matrix4 orthogonal matrix (matrix without scale)
 
-    const x = v.x,
-      y = v.y,
-      z = v.z
-    const e = m.elements
+      const x = v.x,
+        y = v.y,
+        z = v.z
+      const e = m.elements
 
-    v.x = e[0] * x + e[1] * y + e[2] * z
-    v.y = e[4] * x + e[5] * y + e[6] * z
-    v.z = e[8] * x + e[9] * y + e[10] * z
+      v.x = e[0] * x + e[1] * y + e[2] * z
+      v.y = e[4] * x + e[5] * y + e[6] * z
+      v.z = e[8] * x + e[9] * y + e[10] * z
 
-    return v
-  }
+      return v
+    }
 
-  static transformTiedVectorInverse(v, m) {
-    // input:
-    // vector interpreted as a tied (ordinary) vector
-    // THREE.Matrix4 orthogonal matrix (matrix without scale)
+    static transformTiedVectorInverse(v, m) {
+      // input:
+      // vector interpreted as a tied (ordinary) vector
+      // THREE.Matrix4 orthogonal matrix (matrix without scale)
 
-    const x = v.x,
-      y = v.y,
-      z = v.z
-    const e = m.elements
+      const x = v.x,
+        y = v.y,
+        z = v.z
+      const e = m.elements
 
-    v.x = e[0] * x + e[1] * y + e[2] * z - e[12]
-    v.y = e[4] * x + e[5] * y + e[6] * z - e[13]
-    v.z = e[8] * x + e[9] * y + e[10] * z - e[14]
+      v.x = e[0] * x + e[1] * y + e[2] * z - e[12]
+      v.y = e[4] * x + e[5] * y + e[6] * z - e[13]
+      v.z = e[8] * x + e[9] * y + e[10] * z - e[14]
 
-    return v
-  }
+      return v
+    }
 
-  static transformPlaneToLocalSpace(plane, m, resultPlane) {
-    resultPlane.normal.copy(plane.normal)
-    resultPlane.constant = plane.constant
+    static transformPlaneToLocalSpace(plane, m, resultPlane) {
+      resultPlane.normal.copy(plane.normal)
+      resultPlane.constant = plane.constant
 
-    const referencePoint = ConvexObjectBreaker.transformTiedVectorInverse(plane.coplanarPoint(_v1), m)
+      const referencePoint = ConvexObjectBreaker.transformTiedVectorInverse(plane.coplanarPoint(_v1), m)
 
-    ConvexObjectBreaker.transformFreeVectorInverse(resultPlane.normal, m)
+      ConvexObjectBreaker.transformFreeVectorInverse(resultPlane.normal, m)
 
-    // recalculate constant (like in setFromNormalAndCoplanarPoint)
-    resultPlane.constant = -referencePoint.dot(resultPlane.normal)
+      // recalculate constant (like in setFromNormalAndCoplanarPoint)
+      resultPlane.constant = -referencePoint.dot(resultPlane.normal)
+    }
   }
-}
+
+  return ConvexObjectBreaker
+})()
 
 export { ConvexObjectBreaker }
diff --git a/src/misc/Gyroscope.js b/src/misc/Gyroscope.js
index 0ab3fb72..570f40d3 100644
--- a/src/misc/Gyroscope.js
+++ b/src/misc/Gyroscope.js
@@ -1,12 +1,12 @@
 import { Object3D, Quaternion, Vector3 } from 'three'
 
-const _translationObject = new Vector3()
-const _quaternionObject = new Quaternion()
-const _scaleObject = new Vector3()
+const _translationObject = /* @__PURE__ */ new Vector3()
+const _quaternionObject = /* @__PURE__ */ new Quaternion()
+const _scaleObject = /* @__PURE__ */ new Vector3()
 
-const _translationWorld = new Vector3()
-const _quaternionWorld = new Quaternion()
-const _scaleWorld = new Vector3()
+const _translationWorld = /* @__PURE__ */ new Vector3()
+const _quaternionWorld = /* @__PURE__ */ new Quaternion()
+const _scaleWorld = /* @__PURE__ */ new Vector3()
 
 class Gyroscope extends Object3D {
   constructor() {
diff --git a/src/modifiers/CurveModifier.ts b/src/modifiers/CurveModifier.ts
index 2097a471..588a5865 100644
--- a/src/modifiers/CurveModifier.ts
+++ b/src/modifiers/CurveModifier.ts
@@ -250,7 +250,7 @@ export class Flow<TMesh extends Mesh = Mesh> {
     this.uniforms.pathOffset.value += amount
   }
 }
-const matrix = new Matrix4()
+const matrix = /* @__PURE__ */ new Matrix4()
 
 /**
  * A helper class for creating instanced versions of flow, where the instances are placed on the curve.
diff --git a/src/modifiers/SimplifyModifier.ts b/src/modifiers/SimplifyModifier.ts
index f5ae4779..d9d0348d 100644
--- a/src/modifiers/SimplifyModifier.ts
+++ b/src/modifiers/SimplifyModifier.ts
@@ -1,8 +1,8 @@
 import { BufferGeometry, Float32BufferAttribute, Vector3 } from 'three'
 import * as BufferGeometryUtils from '../utils/BufferGeometryUtils'
 
-const cb = new Vector3()
-const ab = new Vector3()
+const cb = /* @__PURE__ */ new Vector3()
+const ab = /* @__PURE__ */ new Vector3()
 
 function pushIfUnique<TItem>(array: TItem[], object: TItem): void {
   if (array.indexOf(object) === -1) array.push(object)
diff --git a/src/objects/BatchedMesh.ts b/src/objects/BatchedMesh.ts
index 8c2f7635..5c95ccb4 100644
--- a/src/objects/BatchedMesh.ts
+++ b/src/objects/BatchedMesh.ts
@@ -13,8 +13,8 @@ import {
 } from 'three'
 
 const ID_ATTR_NAME = '_batch_id_'
-const _identityMatrix = new Matrix4()
-const _zeroScaleMatrix = new Matrix4().set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1)
+const _identityMatrix = /* @__PURE__ */ new Matrix4()
+const _zeroScaleMatrix = /* @__PURE__ */ (() => new Matrix4().set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1))()
 
 // Custom shaders
 const batchingParsVertex = /* glsl */ `
diff --git a/src/objects/GroundProjectedEnv.ts b/src/objects/GroundProjectedEnv.ts
index 9012ec79..8787ae95 100644
--- a/src/objects/GroundProjectedEnv.ts
+++ b/src/objects/GroundProjectedEnv.ts
@@ -1,13 +1,5 @@
-import {
-  Mesh,
-  IcosahedronGeometry,
-  ShaderMaterial,
-  DoubleSide,
-  Texture,
-  CubeTexture,
-  BufferGeometry,
-  REVISION,
-} from 'three'
+import { Mesh, IcosahedronGeometry, ShaderMaterial, DoubleSide, Texture, CubeTexture, BufferGeometry } from 'three'
+import { version } from '../_polyfill/constants'
 
 export interface GroundProjectedEnvParameters {
   height?: number
@@ -114,7 +106,7 @@ export class GroundProjectedEnv extends Mesh<BufferGeometry, ShaderMaterial> {
             #endif
             gl_FragColor = vec4( outcolor, 1.0 );
             #include <tonemapping_fragment>
-            #include <${parseInt(REVISION.replace(/\D+/g, '')) >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>
+            #include <${version >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>
         }
         `
 
diff --git a/src/objects/Lensflare.js b/src/objects/Lensflare.js
index 70a698b1..736287ee 100644
--- a/src/objects/Lensflare.js
+++ b/src/objects/Lensflare.js
@@ -17,56 +17,45 @@ import {
   Vector4,
 } from 'three'
 
-const geometry = new BufferGeometry()
+const Lensflare = /* @__PURE__ */ (() => {
+  class Lensflare extends Mesh {
+    constructor() {
+      super(Lensflare.Geometry, new MeshBasicMaterial({ opacity: 0, transparent: true }))
 
-const float32Array = new Float32Array([-1, -1, 0, 0, 0, 1, -1, 0, 1, 0, 1, 1, 0, 1, 1, -1, 1, 0, 0, 1])
+      this.isLensflare = true
 
-const interleavedBuffer = new InterleavedBuffer(float32Array, 5)
+      this.type = 'Lensflare'
+      this.frustumCulled = false
+      this.renderOrder = Infinity
 
-geometry.setIndex([0, 1, 2, 0, 2, 3])
-geometry.setAttribute('position', new InterleavedBufferAttribute(interleavedBuffer, 3, 0, false))
-geometry.setAttribute('uv', new InterleavedBufferAttribute(interleavedBuffer, 2, 3, false))
+      //
 
-class Lensflare extends Mesh {
-  static Geometry = geometry
+      const positionScreen = new Vector3()
+      const positionView = new Vector3()
 
-  constructor() {
-    super(Lensflare.Geometry, new MeshBasicMaterial({ opacity: 0, transparent: true }))
+      // textures
+      const tempMap = new DataTexture(new Uint8Array(16 * 16 * 3), 16, 16, RGBAFormat)
+      tempMap.minFilter = NearestFilter
+      tempMap.magFilter = NearestFilter
+      tempMap.wrapS = ClampToEdgeWrapping
+      tempMap.wrapT = ClampToEdgeWrapping
 
-    this.isLensflare = true
+      const occlusionMap = new DataTexture(new Uint8Array(16 * 16 * 3), 16, 16, RGBAFormat)
+      occlusionMap.minFilter = NearestFilter
+      occlusionMap.magFilter = NearestFilter
+      occlusionMap.wrapS = ClampToEdgeWrapping
+      occlusionMap.wrapT = ClampToEdgeWrapping
 
-    this.type = 'Lensflare'
-    this.frustumCulled = false
-    this.renderOrder = Infinity
+      // material
 
-    //
+      const geometry = Lensflare.Geometry
 
-    const positionScreen = new Vector3()
-    const positionView = new Vector3()
-
-    // textures
-    const tempMap = new DataTexture(new Uint8Array(16 * 16 * 3), 16, 16, RGBAFormat)
-    tempMap.minFilter = NearestFilter
-    tempMap.magFilter = NearestFilter
-    tempMap.wrapS = ClampToEdgeWrapping
-    tempMap.wrapT = ClampToEdgeWrapping
-
-    const occlusionMap = new DataTexture(new Uint8Array(16 * 16 * 3), 16, 16, RGBAFormat)
-    occlusionMap.minFilter = NearestFilter
-    occlusionMap.magFilter = NearestFilter
-    occlusionMap.wrapS = ClampToEdgeWrapping
-    occlusionMap.wrapT = ClampToEdgeWrapping
-
-    // material
-
-    const geometry = Lensflare.Geometry
-
-    const material1a = new RawShaderMaterial({
-      uniforms: {
-        scale: { value: null },
-        screenPosition: { value: null },
-      },
-      vertexShader: /* glsl */ `
+      const material1a = new RawShaderMaterial({
+        uniforms: {
+          scale: { value: null },
+          screenPosition: { value: null },
+        },
+        vertexShader: /* glsl */ `
 
 				precision highp float;
 
@@ -81,7 +70,7 @@ class Lensflare extends Mesh {
 
 				}`,
 
-      fragmentShader: /* glsl */ `
+        fragmentShader: /* glsl */ `
 
 				precision highp float;
 
@@ -90,18 +79,18 @@ class Lensflare extends Mesh {
 					gl_FragColor = vec4( 1.0, 0.0, 1.0, 1.0 );
 
 				}`,
-      depthTest: true,
-      depthWrite: false,
-      transparent: false,
-    })
-
-    const material1b = new RawShaderMaterial({
-      uniforms: {
-        map: { value: tempMap },
-        scale: { value: null },
-        screenPosition: { value: null },
-      },
-      vertexShader: /* glsl */ `
+        depthTest: true,
+        depthWrite: false,
+        transparent: false,
+      })
+
+      const material1b = new RawShaderMaterial({
+        uniforms: {
+          map: { value: tempMap },
+          scale: { value: null },
+          screenPosition: { value: null },
+        },
+        vertexShader: /* glsl */ `
 
 				precision highp float;
 
@@ -121,7 +110,7 @@ class Lensflare extends Mesh {
 
 				}`,
 
-      fragmentShader: /* glsl */ `
+        fragmentShader: /* glsl */ `
 
 				precision highp float;
 
@@ -134,149 +123,173 @@ class Lensflare extends Mesh {
 					gl_FragColor = texture2D( map, vUV );
 
 				}`,
-      depthTest: false,
-      depthWrite: false,
-      transparent: false,
-    })
+        depthTest: false,
+        depthWrite: false,
+        transparent: false,
+      })
 
-    // the following object is used for occlusionMap generation
+      // the following object is used for occlusionMap generation
 
-    const mesh1 = new Mesh(geometry, material1a)
+      const mesh1 = new Mesh(geometry, material1a)
 
-    //
+      //
 
-    const elements = []
+      const elements = []
 
-    const shader = LensflareElement.Shader
+      const shader = LensflareElement.Shader
 
-    const material2 = new RawShaderMaterial({
-      uniforms: {
-        map: { value: null },
-        occlusionMap: { value: occlusionMap },
-        color: { value: new Color(0xffffff) },
-        scale: { value: new Vector2() },
-        screenPosition: { value: new Vector3() },
-      },
-      vertexShader: shader.vertexShader,
-      fragmentShader: shader.fragmentShader,
-      blending: AdditiveBlending,
-      transparent: true,
-      depthWrite: false,
-    })
+      const material2 = new RawShaderMaterial({
+        uniforms: {
+          map: { value: null },
+          occlusionMap: { value: occlusionMap },
+          color: { value: new Color(0xffffff) },
+          scale: { value: new Vector2() },
+          screenPosition: { value: new Vector3() },
+        },
+        vertexShader: shader.vertexShader,
+        fragmentShader: shader.fragmentShader,
+        blending: AdditiveBlending,
+        transparent: true,
+        depthWrite: false,
+      })
 
-    const mesh2 = new Mesh(geometry, material2)
+      const mesh2 = new Mesh(geometry, material2)
 
-    this.addElement = function (element) {
-      elements.push(element)
-    }
+      this.addElement = function (element) {
+        elements.push(element)
+      }
 
-    //
+      //
 
-    const scale = new Vector2()
-    const screenPositionPixels = new Vector2()
-    const validArea = new Box2()
-    const viewport = new Vector4()
+      const scale = new Vector2()
+      const screenPositionPixels = new Vector2()
+      const validArea = new Box2()
+      const viewport = new Vector4()
 
-    this.onBeforeRender = function (renderer, scene, camera) {
-      renderer.getCurrentViewport(viewport)
+      this.onBeforeRender = function (renderer, scene, camera) {
+        renderer.getCurrentViewport(viewport)
 
-      const invAspect = viewport.w / viewport.z
-      const halfViewportWidth = viewport.z / 2.0
-      const halfViewportHeight = viewport.w / 2.0
+        const invAspect = viewport.w / viewport.z
+        const halfViewportWidth = viewport.z / 2.0
+        const halfViewportHeight = viewport.w / 2.0
 
-      let size = 16 / viewport.w
-      scale.set(size * invAspect, size)
+        let size = 16 / viewport.w
+        scale.set(size * invAspect, size)
 
-      validArea.min.set(viewport.x, viewport.y)
-      validArea.max.set(viewport.x + (viewport.z - 16), viewport.y + (viewport.w - 16))
+        validArea.min.set(viewport.x, viewport.y)
+        validArea.max.set(viewport.x + (viewport.z - 16), viewport.y + (viewport.w - 16))
 
-      // calculate position in screen space
+        // calculate position in screen space
 
-      positionView.setFromMatrixPosition(this.matrixWorld)
-      positionView.applyMatrix4(camera.matrixWorldInverse)
+        positionView.setFromMatrixPosition(this.matrixWorld)
+        positionView.applyMatrix4(camera.matrixWorldInverse)
 
-      if (positionView.z > 0) return // lensflare is behind the camera
+        if (positionView.z > 0) return // lensflare is behind the camera
 
-      positionScreen.copy(positionView).applyMatrix4(camera.projectionMatrix)
+        positionScreen.copy(positionView).applyMatrix4(camera.projectionMatrix)
 
-      // horizontal and vertical coordinate of the lower left corner of the pixels to copy
+        // horizontal and vertical coordinate of the lower left corner of the pixels to copy
 
-      screenPositionPixels.x = viewport.x + positionScreen.x * halfViewportWidth + halfViewportWidth - 8
-      screenPositionPixels.y = viewport.y + positionScreen.y * halfViewportHeight + halfViewportHeight - 8
+        screenPositionPixels.x = viewport.x + positionScreen.x * halfViewportWidth + halfViewportWidth - 8
+        screenPositionPixels.y = viewport.y + positionScreen.y * halfViewportHeight + halfViewportHeight - 8
 
-      // screen cull
+        // screen cull
 
-      if (validArea.containsPoint(screenPositionPixels)) {
-        // save current RGB to temp texture
+        if (validArea.containsPoint(screenPositionPixels)) {
+          // save current RGB to temp texture
 
-        renderer.copyFramebufferToTexture(screenPositionPixels, tempMap)
+          renderer.copyFramebufferToTexture(screenPositionPixels, tempMap)
 
-        // render pink quad
+          // render pink quad
 
-        let uniforms = material1a.uniforms
-        uniforms['scale'].value = scale
-        uniforms['screenPosition'].value = positionScreen
+          let uniforms = material1a.uniforms
+          uniforms['scale'].value = scale
+          uniforms['screenPosition'].value = positionScreen
 
-        renderer.renderBufferDirect(camera, null, geometry, material1a, mesh1, null)
+          renderer.renderBufferDirect(camera, null, geometry, material1a, mesh1, null)
 
-        // copy result to occlusionMap
+          // copy result to occlusionMap
 
-        renderer.copyFramebufferToTexture(screenPositionPixels, occlusionMap)
+          renderer.copyFramebufferToTexture(screenPositionPixels, occlusionMap)
 
-        // restore graphics
+          // restore graphics
 
-        uniforms = material1b.uniforms
-        uniforms['scale'].value = scale
-        uniforms['screenPosition'].value = positionScreen
+          uniforms = material1b.uniforms
+          uniforms['scale'].value = scale
+          uniforms['screenPosition'].value = positionScreen
 
-        renderer.renderBufferDirect(camera, null, geometry, material1b, mesh1, null)
+          renderer.renderBufferDirect(camera, null, geometry, material1b, mesh1, null)
 
-        // render elements
+          // render elements
 
-        const vecX = -positionScreen.x * 2
-        const vecY = -positionScreen.y * 2
+          const vecX = -positionScreen.x * 2
+          const vecY = -positionScreen.y * 2
 
-        for (let i = 0, l = elements.length; i < l; i++) {
-          const element = elements[i]
+          for (let i = 0, l = elements.length; i < l; i++) {
+            const element = elements[i]
 
-          const uniforms = material2.uniforms
+            const uniforms = material2.uniforms
 
-          uniforms['color'].value.copy(element.color)
-          uniforms['map'].value = element.texture
-          uniforms['screenPosition'].value.x = positionScreen.x + vecX * element.distance
-          uniforms['screenPosition'].value.y = positionScreen.y + vecY * element.distance
+            uniforms['color'].value.copy(element.color)
+            uniforms['map'].value = element.texture
+            uniforms['screenPosition'].value.x = positionScreen.x + vecX * element.distance
+            uniforms['screenPosition'].value.y = positionScreen.y + vecY * element.distance
 
-          size = element.size / viewport.w
-          const invAspect = viewport.w / viewport.z
+            size = element.size / viewport.w
+            const invAspect = viewport.w / viewport.z
 
-          uniforms['scale'].value.set(size * invAspect, size)
+            uniforms['scale'].value.set(size * invAspect, size)
 
-          material2.uniformsNeedUpdate = true
+            material2.uniformsNeedUpdate = true
 
-          renderer.renderBufferDirect(camera, null, geometry, material2, mesh2, null)
+            renderer.renderBufferDirect(camera, null, geometry, material2, mesh2, null)
+          }
         }
       }
-    }
 
-    this.dispose = function () {
-      material1a.dispose()
-      material1b.dispose()
-      material2.dispose()
+      this.dispose = function () {
+        material1a.dispose()
+        material1b.dispose()
+        material2.dispose()
 
-      tempMap.dispose()
-      occlusionMap.dispose()
+        tempMap.dispose()
+        occlusionMap.dispose()
 
-      for (let i = 0, l = elements.length; i < l; i++) {
-        elements[i].texture.dispose()
+        for (let i = 0, l = elements.length; i < l; i++) {
+          elements[i].texture.dispose()
+        }
       }
     }
   }
-}
+
+  const _geometry = new BufferGeometry()
+  const interleavedBuffer = new InterleavedBuffer(
+    new Float32Array([-1, -1, 0, 0, 0, 1, -1, 0, 1, 0, 1, 1, 0, 1, 1, -1, 1, 0, 0, 1]),
+    5,
+  )
+
+  _geometry.setIndex([0, 1, 2, 0, 2, 3])
+  _geometry.setAttribute('position', new InterleavedBufferAttribute(interleavedBuffer, 3, 0, false))
+  _geometry.setAttribute('uv', new InterleavedBufferAttribute(interleavedBuffer, 2, 3, false))
+
+  Lensflare.Geometry = _geometry
+
+  return Lensflare
+})()
 
 //
 
-class LensflareElement {
-  static Shader = {
+const LensflareElement = /* @__PURE__ */ (() => {
+  class LensflareElement {
+    constructor(texture, size = 1, distance = 0, color = new Color(0xffffff)) {
+      this.texture = texture
+      this.size = size
+      this.distance = distance
+      this.color = color
+    }
+  }
+
+  LensflareElement.Shader = {
     uniforms: {
       map: { value: null },
       occlusionMap: { value: null },
@@ -287,69 +300,66 @@ class LensflareElement {
 
     vertexShader: /* glsl */ `
 
-		precision highp float;
+      precision highp float;
 
-		uniform vec3 screenPosition;
-		uniform vec2 scale;
+      uniform vec3 screenPosition;
+      uniform vec2 scale;
 
-		uniform sampler2D occlusionMap;
+      uniform sampler2D occlusionMap;
 
-		attribute vec3 position;
-		attribute vec2 uv;
+      attribute vec3 position;
+      attribute vec2 uv;
 
-		varying vec2 vUV;
-		varying float vVisibility;
+      varying vec2 vUV;
+      varying float vVisibility;
 
-		void main() {
+      void main() {
 
-			vUV = uv;
+        vUV = uv;
 
-			vec2 pos = position.xy;
+        vec2 pos = position.xy;
 
-			vec4 visibility = texture2D( occlusionMap, vec2( 0.1, 0.1 ) );
-			visibility += texture2D( occlusionMap, vec2( 0.5, 0.1 ) );
-			visibility += texture2D( occlusionMap, vec2( 0.9, 0.1 ) );
-			visibility += texture2D( occlusionMap, vec2( 0.9, 0.5 ) );
-			visibility += texture2D( occlusionMap, vec2( 0.9, 0.9 ) );
-			visibility += texture2D( occlusionMap, vec2( 0.5, 0.9 ) );
-			visibility += texture2D( occlusionMap, vec2( 0.1, 0.9 ) );
-			visibility += texture2D( occlusionMap, vec2( 0.1, 0.5 ) );
-			visibility += texture2D( occlusionMap, vec2( 0.5, 0.5 ) );
+        vec4 visibility = texture2D( occlusionMap, vec2( 0.1, 0.1 ) );
+        visibility += texture2D( occlusionMap, vec2( 0.5, 0.1 ) );
+        visibility += texture2D( occlusionMap, vec2( 0.9, 0.1 ) );
+        visibility += texture2D( occlusionMap, vec2( 0.9, 0.5 ) );
+        visibility += texture2D( occlusionMap, vec2( 0.9, 0.9 ) );
+        visibility += texture2D( occlusionMap, vec2( 0.5, 0.9 ) );
+        visibility += texture2D( occlusionMap, vec2( 0.1, 0.9 ) );
+        visibility += texture2D( occlusionMap, vec2( 0.1, 0.5 ) );
+        visibility += texture2D( occlusionMap, vec2( 0.5, 0.5 ) );
 
-			vVisibility =        visibility.r / 9.0;
-			vVisibility *= 1.0 - visibility.g / 9.0;
-			vVisibility *=       visibility.b / 9.0;
+        vVisibility =        visibility.r / 9.0;
+        vVisibility *= 1.0 - visibility.g / 9.0;
+        vVisibility *=       visibility.b / 9.0;
 
-			gl_Position = vec4( ( pos * scale + screenPosition.xy ).xy, screenPosition.z, 1.0 );
+        gl_Position = vec4( ( pos * scale + screenPosition.xy ).xy, screenPosition.z, 1.0 );
 
-		}`,
+      }
+    `,
 
     fragmentShader: /* glsl */ `
 
-		precision highp float;
+      precision highp float;
 
-		uniform sampler2D map;
-		uniform vec3 color;
+      uniform sampler2D map;
+      uniform vec3 color;
 
-		varying vec2 vUV;
-		varying float vVisibility;
+      varying vec2 vUV;
+      varying float vVisibility;
 
-		void main() {
+      void main() {
 
-			vec4 texture = texture2D( map, vUV );
-			texture.a *= vVisibility;
-			gl_FragColor = texture;
-			gl_FragColor.rgb *= color;
+        vec4 texture = texture2D( map, vUV );
+        texture.a *= vVisibility;
+        gl_FragColor = texture;
+        gl_FragColor.rgb *= color;
 
-		}`,
+      }
+    `,
   }
 
-  constructor(texture, size = 1, distance = 0, color = new Color(0xffffff)) {
-    this.texture = texture
-    this.size = size
-    this.distance = distance
-    this.color = color
-  }
-}
+  return LensflareElement
+})()
 
 export { Lensflare, LensflareElement }
diff --git a/src/objects/Reflector.js b/src/objects/Reflector.js
index 5d326eb6..d1fdd776 100644
--- a/src/objects/Reflector.js
+++ b/src/objects/Reflector.js
@@ -14,23 +14,24 @@ import {
 } from 'three'
 import { version } from '../_polyfill/constants'
 
-class Reflector extends Mesh {
-  static ReflectorShader = {
-    uniforms: {
-      color: {
-        value: null,
+const Reflector = /* @__PURE__ */ (() => {
+  class Reflector extends Mesh {
+    static ReflectorShader = {
+      uniforms: {
+        color: {
+          value: null,
+        },
+
+        tDiffuse: {
+          value: null,
+        },
+
+        textureMatrix: {
+          value: null,
+        },
       },
 
-      tDiffuse: {
-        value: null,
-      },
-
-      textureMatrix: {
-        value: null,
-      },
-    },
-
-    vertexShader: /* glsl */ `
+      vertexShader: /* glsl */ `
 		uniform mat4 textureMatrix;
 		varying vec4 vUv;
 
@@ -47,7 +48,7 @@ class Reflector extends Mesh {
 
 		}`,
 
-    fragmentShader: /* glsl */ `
+      fragmentShader: /* glsl */ `
 		uniform vec3 color;
 		uniform sampler2D tDiffuse;
 		varying vec4 vUv;
@@ -77,182 +78,190 @@ class Reflector extends Mesh {
 			#include <${version >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>
 
 		}`,
-  }
+    }
 
-  constructor(geometry, options = {}) {
-    super(geometry)
+    constructor(geometry, options = {}) {
+      super(geometry)
 
-    this.isReflector = true
+      this.isReflector = true
 
-    this.type = 'Reflector'
-    this.camera = new PerspectiveCamera()
+      this.type = 'Reflector'
+      this.camera = new PerspectiveCamera()
 
-    const scope = this
+      const scope = this
 
-    const color = options.color !== undefined ? new Color(options.color) : new Color(0x7f7f7f)
-    const textureWidth = options.textureWidth || 512
-    const textureHeight = options.textureHeight || 512
-    const clipBias = options.clipBias || 0
-    const shader = options.shader || Reflector.ReflectorShader
-    const multisample = options.multisample !== undefined ? options.multisample : 4
+      const color = options.color !== undefined ? new Color(options.color) : new Color(0x7f7f7f)
+      const textureWidth = options.textureWidth || 512
+      const textureHeight = options.textureHeight || 512
+      const clipBias = options.clipBias || 0
+      const shader = options.shader || Reflector.ReflectorShader
+      const multisample = options.multisample !== undefined ? options.multisample : 4
 
-    //
+      //
 
-    const reflectorPlane = new Plane()
-    const normal = new Vector3()
-    const reflectorWorldPosition = new Vector3()
-    const cameraWorldPosition = new Vector3()
-    const rotationMatrix = new Matrix4()
-    const lookAtPosition = new Vector3(0, 0, -1)
-    const clipPlane = new Vector4()
+      const reflectorPlane = new Plane()
+      const normal = new Vector3()
+      const reflectorWorldPosition = new Vector3()
+      const cameraWorldPosition = new Vector3()
+      const rotationMatrix = new Matrix4()
+      const lookAtPosition = new Vector3(0, 0, -1)
+      const clipPlane = new Vector4()
 
-    const view = new Vector3()
-    const target = new Vector3()
-    const q = new Vector4()
+      const view = new Vector3()
+      const target = new Vector3()
+      const q = new Vector4()
 
-    const textureMatrix = new Matrix4()
-    const virtualCamera = this.camera
+      const textureMatrix = new Matrix4()
+      const virtualCamera = this.camera
 
-    const renderTarget = new WebGLRenderTarget(textureWidth, textureHeight, {
-      samples: multisample,
-      type: HalfFloatType,
-    })
+      const renderTarget = new WebGLRenderTarget(textureWidth, textureHeight, {
+        samples: multisample,
+        type: HalfFloatType,
+      })
 
-    const material = new ShaderMaterial({
-      uniforms: UniformsUtils.clone(shader.uniforms),
-      fragmentShader: shader.fragmentShader,
-      vertexShader: shader.vertexShader,
-    })
+      const material = new ShaderMaterial({
+        uniforms: UniformsUtils.clone(shader.uniforms),
+        fragmentShader: shader.fragmentShader,
+        vertexShader: shader.vertexShader,
+      })
 
-    material.uniforms['tDiffuse'].value = renderTarget.texture
-    material.uniforms['color'].value = color
-    material.uniforms['textureMatrix'].value = textureMatrix
+      material.uniforms['tDiffuse'].value = renderTarget.texture
+      material.uniforms['color'].value = color
+      material.uniforms['textureMatrix'].value = textureMatrix
 
-    this.material = material
+      this.material = material
 
-    this.onBeforeRender = function (renderer, scene, camera) {
-      reflectorWorldPosition.setFromMatrixPosition(scope.matrixWorld)
-      cameraWorldPosition.setFromMatrixPosition(camera.matrixWorld)
+      this.onBeforeRender = function (renderer, scene, camera) {
+        reflectorWorldPosition.setFromMatrixPosition(scope.matrixWorld)
+        cameraWorldPosition.setFromMatrixPosition(camera.matrixWorld)
 
-      rotationMatrix.extractRotation(scope.matrixWorld)
+        rotationMatrix.extractRotation(scope.matrixWorld)
 
-      normal.set(0, 0, 1)
-      normal.applyMatrix4(rotationMatrix)
+        normal.set(0, 0, 1)
+        normal.applyMatrix4(rotationMatrix)
 
-      view.subVectors(reflectorWorldPosition, cameraWorldPosition)
+        view.subVectors(reflectorWorldPosition, cameraWorldPosition)
 
-      // Avoid rendering when reflector is facing away
+        // Avoid rendering when reflector is facing away
 
-      if (view.dot(normal) > 0) return
+        if (view.dot(normal) > 0) return
 
-      view.reflect(normal).negate()
-      view.add(reflectorWorldPosition)
+        view.reflect(normal).negate()
+        view.add(reflectorWorldPosition)
 
-      rotationMatrix.extractRotation(camera.matrixWorld)
+        rotationMatrix.extractRotation(camera.matrixWorld)
 
-      lookAtPosition.set(0, 0, -1)
-      lookAtPosition.applyMatrix4(rotationMatrix)
-      lookAtPosition.add(cameraWorldPosition)
+        lookAtPosition.set(0, 0, -1)
+        lookAtPosition.applyMatrix4(rotationMatrix)
+        lookAtPosition.add(cameraWorldPosition)
 
-      target.subVectors(reflectorWorldPosition, lookAtPosition)
-      target.reflect(normal).negate()
-      target.add(reflectorWorldPosition)
+        target.subVectors(reflectorWorldPosition, lookAtPosition)
+        target.reflect(normal).negate()
+        target.add(reflectorWorldPosition)
 
-      virtualCamera.position.copy(view)
-      virtualCamera.up.set(0, 1, 0)
-      virtualCamera.up.applyMatrix4(rotationMatrix)
-      virtualCamera.up.reflect(normal)
-      virtualCamera.lookAt(target)
+        virtualCamera.position.copy(view)
+        virtualCamera.up.set(0, 1, 0)
+        virtualCamera.up.applyMatrix4(rotationMatrix)
+        virtualCamera.up.reflect(normal)
+        virtualCamera.lookAt(target)
 
-      virtualCamera.far = camera.far // Used in WebGLBackground
+        virtualCamera.far = camera.far // Used in WebGLBackground
 
-      virtualCamera.updateMatrixWorld()
-      virtualCamera.projectionMatrix.copy(camera.projectionMatrix)
+        virtualCamera.updateMatrixWorld()
+        virtualCamera.projectionMatrix.copy(camera.projectionMatrix)
 
-      // Update the texture matrix
-      textureMatrix.set(0.5, 0.0, 0.0, 0.5, 0.0, 0.5, 0.0, 0.5, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.0, 1.0)
-      textureMatrix.multiply(virtualCamera.projectionMatrix)
-      textureMatrix.multiply(virtualCamera.matrixWorldInverse)
-      textureMatrix.multiply(scope.matrixWorld)
+        // Update the texture matrix
+        textureMatrix.set(0.5, 0.0, 0.0, 0.5, 0.0, 0.5, 0.0, 0.5, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.0, 1.0)
+        textureMatrix.multiply(virtualCamera.projectionMatrix)
+        textureMatrix.multiply(virtualCamera.matrixWorldInverse)
+        textureMatrix.multiply(scope.matrixWorld)
 
-      // Now update projection matrix with new clip plane, implementing code from: http://www.terathon.com/code/oblique.html
-      // Paper explaining this technique: http://www.terathon.com/lengyel/Lengyel-Oblique.pdf
-      reflectorPlane.setFromNormalAndCoplanarPoint(normal, reflectorWorldPosition)
-      reflectorPlane.applyMatrix4(virtualCamera.matrixWorldInverse)
+        // Now update projection matrix with new clip plane, implementing code from: http://www.terathon.com/code/oblique.html
+        // Paper explaining this technique: http://www.terathon.com/lengyel/Lengyel-Oblique.pdf
+        reflectorPlane.setFromNormalAndCoplanarPoint(normal, reflectorWorldPosition)
+        reflectorPlane.applyMatrix4(virtualCamera.matrixWorldInverse)
 
-      clipPlane.set(reflectorPlane.normal.x, reflectorPlane.normal.y, reflectorPlane.normal.z, reflectorPlane.constant)
+        clipPlane.set(
+          reflectorPlane.normal.x,
+          reflectorPlane.normal.y,
+          reflectorPlane.normal.z,
+          reflectorPlane.constant,
+        )
 
-      const projectionMatrix = virtualCamera.projectionMatrix
+        const projectionMatrix = virtualCamera.projectionMatrix
 
-      q.x = (Math.sign(clipPlane.x) + projectionMatrix.elements[8]) / projectionMatrix.elements[0]
-      q.y = (Math.sign(clipPlane.y) + projectionMatrix.elements[9]) / projectionMatrix.elements[5]
-      q.z = -1.0
-      q.w = (1.0 + projectionMatrix.elements[10]) / projectionMatrix.elements[14]
+        q.x = (Math.sign(clipPlane.x) + projectionMatrix.elements[8]) / projectionMatrix.elements[0]
+        q.y = (Math.sign(clipPlane.y) + projectionMatrix.elements[9]) / projectionMatrix.elements[5]
+        q.z = -1.0
+        q.w = (1.0 + projectionMatrix.elements[10]) / projectionMatrix.elements[14]
 
-      // Calculate the scaled plane vector
-      clipPlane.multiplyScalar(2.0 / clipPlane.dot(q))
+        // Calculate the scaled plane vector
+        clipPlane.multiplyScalar(2.0 / clipPlane.dot(q))
 
-      // Replacing the third row of the projection matrix
-      projectionMatrix.elements[2] = clipPlane.x
-      projectionMatrix.elements[6] = clipPlane.y
-      projectionMatrix.elements[10] = clipPlane.z + 1.0 - clipBias
-      projectionMatrix.elements[14] = clipPlane.w
+        // Replacing the third row of the projection matrix
+        projectionMatrix.elements[2] = clipPlane.x
+        projectionMatrix.elements[6] = clipPlane.y
+        projectionMatrix.elements[10] = clipPlane.z + 1.0 - clipBias
+        projectionMatrix.elements[14] = clipPlane.w
 
-      // Render
-      scope.visible = false
+        // Render
+        scope.visible = false
 
-      const currentRenderTarget = renderer.getRenderTarget()
+        const currentRenderTarget = renderer.getRenderTarget()
 
-      const currentXrEnabled = renderer.xr.enabled
-      const currentShadowAutoUpdate = renderer.shadowMap.autoUpdate
-      const currentToneMapping = renderer.toneMapping
+        const currentXrEnabled = renderer.xr.enabled
+        const currentShadowAutoUpdate = renderer.shadowMap.autoUpdate
+        const currentToneMapping = renderer.toneMapping
 
-      let isSRGB = false
-      if ('outputColorSpace' in renderer) isSRGB = renderer.outputColorSpace === 'srgb'
-      else isSRGB = renderer.outputEncoding === 3001 // sRGBEncoding
+        let isSRGB = false
+        if ('outputColorSpace' in renderer) isSRGB = renderer.outputColorSpace === 'srgb'
+        else isSRGB = renderer.outputEncoding === 3001 // sRGBEncoding
 
-      renderer.xr.enabled = false // Avoid camera modification
-      renderer.shadowMap.autoUpdate = false // Avoid re-computing shadows
-      if ('outputColorSpace' in renderer) renderer.outputColorSpace = 'srgb-linear'
-      else renderer.outputEncoding = 3000 // LinearEncoding
-      renderer.toneMapping = NoToneMapping
+        renderer.xr.enabled = false // Avoid camera modification
+        renderer.shadowMap.autoUpdate = false // Avoid re-computing shadows
+        if ('outputColorSpace' in renderer) renderer.outputColorSpace = 'srgb-linear'
+        else renderer.outputEncoding = 3000 // LinearEncoding
+        renderer.toneMapping = NoToneMapping
 
-      renderer.setRenderTarget(renderTarget)
+        renderer.setRenderTarget(renderTarget)
 
-      renderer.state.buffers.depth.setMask(true) // make sure the depth buffer is writable so it can be properly cleared, see #18897
+        renderer.state.buffers.depth.setMask(true) // make sure the depth buffer is writable so it can be properly cleared, see #18897
 
-      if (renderer.autoClear === false) renderer.clear()
-      renderer.render(scene, virtualCamera)
+        if (renderer.autoClear === false) renderer.clear()
+        renderer.render(scene, virtualCamera)
 
-      renderer.xr.enabled = currentXrEnabled
-      renderer.shadowMap.autoUpdate = currentShadowAutoUpdate
-      renderer.toneMapping = currentToneMapping
+        renderer.xr.enabled = currentXrEnabled
+        renderer.shadowMap.autoUpdate = currentShadowAutoUpdate
+        renderer.toneMapping = currentToneMapping
 
-      if ('outputColorSpace' in renderer) renderer.outputColorSpace = isSRGB ? 'srgb' : 'srgb-linear'
-      else renderer.outputEncoding = isSRGB ? 3001 : 3000
+        if ('outputColorSpace' in renderer) renderer.outputColorSpace = isSRGB ? 'srgb' : 'srgb-linear'
+        else renderer.outputEncoding = isSRGB ? 3001 : 3000
 
-      renderer.setRenderTarget(currentRenderTarget)
+        renderer.setRenderTarget(currentRenderTarget)
 
-      // Restore viewport
+        // Restore viewport
 
-      const viewport = camera.viewport
+        const viewport = camera.viewport
 
-      if (viewport !== undefined) {
-        renderer.state.viewport(viewport)
-      }
+        if (viewport !== undefined) {
+          renderer.state.viewport(viewport)
+        }
 
-      scope.visible = true
-    }
+        scope.visible = true
+      }
 
-    this.getRenderTarget = function () {
-      return renderTarget
-    }
+      this.getRenderTarget = function () {
+        return renderTarget
+      }
 
-    this.dispose = function () {
-      renderTarget.dispose()
-      scope.material.dispose()
+      this.dispose = function () {
+        renderTarget.dispose()
+        scope.material.dispose()
+      }
     }
   }
-}
+
+  return Reflector
+})()
 
 export { Reflector }
diff --git a/src/objects/ReflectorForSSRPass.js b/src/objects/ReflectorForSSRPass.js
index a03e7a82..4b8cde38 100644
--- a/src/objects/ReflectorForSSRPass.js
+++ b/src/objects/ReflectorForSSRPass.js
@@ -15,30 +15,31 @@ import {
   HalfFloatType,
 } from 'three'
 
-class ReflectorForSSRPass extends Mesh {
-  static ReflectorShader = {
-    defines: {
-      DISTANCE_ATTENUATION: true,
-      FRESNEL: true,
-    },
-
-    uniforms: {
-      color: { value: null },
-      tDiffuse: { value: null },
-      tDepth: { value: null },
-      textureMatrix: { value: new Matrix4() },
-      maxDistance: { value: 180 },
-      opacity: { value: 0.5 },
-      fresnelCoe: { value: null },
-      virtualCameraNear: { value: null },
-      virtualCameraFar: { value: null },
-      virtualCameraProjectionMatrix: { value: new Matrix4() },
-      virtualCameraMatrixWorld: { value: new Matrix4() },
-      virtualCameraProjectionMatrixInverse: { value: new Matrix4() },
-      resolution: { value: new Vector2() },
-    },
-
-    vertexShader: /* glsl */ `
+const ReflectorForSSRPass = /* @__PURE__ */ (() => {
+  class ReflectorForSSRPass extends Mesh {
+    static ReflectorShader = {
+      defines: {
+        DISTANCE_ATTENUATION: true,
+        FRESNEL: true,
+      },
+
+      uniforms: {
+        color: { value: null },
+        tDiffuse: { value: null },
+        tDepth: { value: null },
+        textureMatrix: { value: new Matrix4() },
+        maxDistance: { value: 180 },
+        opacity: { value: 0.5 },
+        fresnelCoe: { value: null },
+        virtualCameraNear: { value: null },
+        virtualCameraFar: { value: null },
+        virtualCameraProjectionMatrix: { value: new Matrix4() },
+        virtualCameraMatrixWorld: { value: new Matrix4() },
+        virtualCameraProjectionMatrixInverse: { value: new Matrix4() },
+        resolution: { value: new Vector2() },
+      },
+
+      vertexShader: /* glsl */ `
 		uniform mat4 textureMatrix;
 		varying vec4 vUv;
 
@@ -50,7 +51,7 @@ class ReflectorForSSRPass extends Mesh {
 
 		}`,
 
-    fragmentShader: /* glsl */ `
+      fragmentShader: /* glsl */ `
 		uniform vec3 color;
 		uniform sampler2D tDiffuse;
 		uniform sampler2D tDepth;
@@ -108,211 +109,214 @@ class ReflectorForSSRPass extends Mesh {
 			#endif
 		}
 	`,
-  }
-
-  constructor(geometry, options = {}) {
-    super(geometry)
-
-    this.isReflectorForSSRPass = true
-
-    this.type = 'ReflectorForSSRPass'
-
-    const scope = this
-
-    const color = options.color !== undefined ? new Color(options.color) : new Color(0x7f7f7f)
-    const textureWidth = options.textureWidth || 512
-    const textureHeight = options.textureHeight || 512
-    const clipBias = options.clipBias || 0
-    const shader = options.shader || ReflectorForSSRPass.ReflectorShader
-    const useDepthTexture = options.useDepthTexture === true
-    const yAxis = new Vector3(0, 1, 0)
-    const vecTemp0 = new Vector3()
-    const vecTemp1 = new Vector3()
-
-    //
-
-    scope.needsUpdate = false
-    scope.maxDistance = ReflectorForSSRPass.ReflectorShader.uniforms.maxDistance.value
-    scope.opacity = ReflectorForSSRPass.ReflectorShader.uniforms.opacity.value
-    scope.color = color
-    scope.resolution = options.resolution || new Vector2(window.innerWidth, window.innerHeight)
-
-    scope._distanceAttenuation = ReflectorForSSRPass.ReflectorShader.defines.DISTANCE_ATTENUATION
-    Object.defineProperty(scope, 'distanceAttenuation', {
-      get() {
-        return scope._distanceAttenuation
-      },
-      set(val) {
-        if (scope._distanceAttenuation === val) return
-        scope._distanceAttenuation = val
-        scope.material.defines.DISTANCE_ATTENUATION = val
-        scope.material.needsUpdate = true
-      },
-    })
-
-    scope._fresnel = ReflectorForSSRPass.ReflectorShader.defines.FRESNEL
-    Object.defineProperty(scope, 'fresnel', {
-      get() {
-        return scope._fresnel
-      },
-      set(val) {
-        if (scope._fresnel === val) return
-        scope._fresnel = val
-        scope.material.defines.FRESNEL = val
-        scope.material.needsUpdate = true
-      },
-    })
-
-    const normal = new Vector3()
-    const reflectorWorldPosition = new Vector3()
-    const cameraWorldPosition = new Vector3()
-    const rotationMatrix = new Matrix4()
-    const lookAtPosition = new Vector3(0, 0, -1)
+    }
 
-    const view = new Vector3()
-    const target = new Vector3()
+    constructor(geometry, options = {}) {
+      super(geometry)
+
+      this.isReflectorForSSRPass = true
+
+      this.type = 'ReflectorForSSRPass'
+
+      const scope = this
+
+      const color = options.color !== undefined ? new Color(options.color) : new Color(0x7f7f7f)
+      const textureWidth = options.textureWidth || 512
+      const textureHeight = options.textureHeight || 512
+      const clipBias = options.clipBias || 0
+      const shader = options.shader || ReflectorForSSRPass.ReflectorShader
+      const useDepthTexture = options.useDepthTexture === true
+      const yAxis = new Vector3(0, 1, 0)
+      const vecTemp0 = new Vector3()
+      const vecTemp1 = new Vector3()
+
+      //
+
+      scope.needsUpdate = false
+      scope.maxDistance = ReflectorForSSRPass.ReflectorShader.uniforms.maxDistance.value
+      scope.opacity = ReflectorForSSRPass.ReflectorShader.uniforms.opacity.value
+      scope.color = color
+      scope.resolution = options.resolution || new Vector2(window.innerWidth, window.innerHeight)
+
+      scope._distanceAttenuation = ReflectorForSSRPass.ReflectorShader.defines.DISTANCE_ATTENUATION
+      Object.defineProperty(scope, 'distanceAttenuation', {
+        get() {
+          return scope._distanceAttenuation
+        },
+        set(val) {
+          if (scope._distanceAttenuation === val) return
+          scope._distanceAttenuation = val
+          scope.material.defines.DISTANCE_ATTENUATION = val
+          scope.material.needsUpdate = true
+        },
+      })
+
+      scope._fresnel = ReflectorForSSRPass.ReflectorShader.defines.FRESNEL
+      Object.defineProperty(scope, 'fresnel', {
+        get() {
+          return scope._fresnel
+        },
+        set(val) {
+          if (scope._fresnel === val) return
+          scope._fresnel = val
+          scope.material.defines.FRESNEL = val
+          scope.material.needsUpdate = true
+        },
+      })
+
+      const normal = new Vector3()
+      const reflectorWorldPosition = new Vector3()
+      const cameraWorldPosition = new Vector3()
+      const rotationMatrix = new Matrix4()
+      const lookAtPosition = new Vector3(0, 0, -1)
+
+      const view = new Vector3()
+      const target = new Vector3()
+
+      const textureMatrix = new Matrix4()
+      const virtualCamera = new PerspectiveCamera()
+
+      let depthTexture
+
+      if (useDepthTexture) {
+        depthTexture = new DepthTexture()
+        depthTexture.type = UnsignedShortType
+        depthTexture.minFilter = NearestFilter
+        depthTexture.magFilter = NearestFilter
+      }
 
-    const textureMatrix = new Matrix4()
-    const virtualCamera = new PerspectiveCamera()
+      const parameters = {
+        depthTexture: useDepthTexture ? depthTexture : null,
+        type: HalfFloatType,
+      }
 
-    let depthTexture
+      const renderTarget = new WebGLRenderTarget(textureWidth, textureHeight, parameters)
 
-    if (useDepthTexture) {
-      depthTexture = new DepthTexture()
-      depthTexture.type = UnsignedShortType
-      depthTexture.minFilter = NearestFilter
-      depthTexture.magFilter = NearestFilter
-    }
+      const material = new ShaderMaterial({
+        transparent: useDepthTexture,
+        defines: Object.assign({}, ReflectorForSSRPass.ReflectorShader.defines, {
+          useDepthTexture,
+        }),
+        uniforms: UniformsUtils.clone(shader.uniforms),
+        fragmentShader: shader.fragmentShader,
+        vertexShader: shader.vertexShader,
+      })
 
-    const parameters = {
-      depthTexture: useDepthTexture ? depthTexture : null,
-      type: HalfFloatType,
-    }
+      material.uniforms['tDiffuse'].value = renderTarget.texture
+      material.uniforms['color'].value = scope.color
+      material.uniforms['textureMatrix'].value = textureMatrix
+      if (useDepthTexture) {
+        material.uniforms['tDepth'].value = renderTarget.depthTexture
+      }
 
-    const renderTarget = new WebGLRenderTarget(textureWidth, textureHeight, parameters)
-
-    const material = new ShaderMaterial({
-      transparent: useDepthTexture,
-      defines: Object.assign({}, ReflectorForSSRPass.ReflectorShader.defines, {
-        useDepthTexture,
-      }),
-      uniforms: UniformsUtils.clone(shader.uniforms),
-      fragmentShader: shader.fragmentShader,
-      vertexShader: shader.vertexShader,
-    })
-
-    material.uniforms['tDiffuse'].value = renderTarget.texture
-    material.uniforms['color'].value = scope.color
-    material.uniforms['textureMatrix'].value = textureMatrix
-    if (useDepthTexture) {
-      material.uniforms['tDepth'].value = renderTarget.depthTexture
-    }
+      this.material = material
 
-    this.material = material
+      const globalPlane = new Plane(new Vector3(0, 1, 0), clipBias)
+      const globalPlanes = [globalPlane]
 
-    const globalPlane = new Plane(new Vector3(0, 1, 0), clipBias)
-    const globalPlanes = [globalPlane]
+      this.doRender = function (renderer, scene, camera) {
+        material.uniforms['maxDistance'].value = scope.maxDistance
+        material.uniforms['color'].value = scope.color
+        material.uniforms['opacity'].value = scope.opacity
 
-    this.doRender = function (renderer, scene, camera) {
-      material.uniforms['maxDistance'].value = scope.maxDistance
-      material.uniforms['color'].value = scope.color
-      material.uniforms['opacity'].value = scope.opacity
+        vecTemp0.copy(camera.position).normalize()
+        vecTemp1.copy(vecTemp0).reflect(yAxis)
+        material.uniforms['fresnelCoe'].value = (vecTemp0.dot(vecTemp1) + 1) / 2 // TODO: Also need to use glsl viewPosition and viewNormal per pixel.
 
-      vecTemp0.copy(camera.position).normalize()
-      vecTemp1.copy(vecTemp0).reflect(yAxis)
-      material.uniforms['fresnelCoe'].value = (vecTemp0.dot(vecTemp1) + 1) / 2 // TODO: Also need to use glsl viewPosition and viewNormal per pixel.
+        reflectorWorldPosition.setFromMatrixPosition(scope.matrixWorld)
+        cameraWorldPosition.setFromMatrixPosition(camera.matrixWorld)
 
-      reflectorWorldPosition.setFromMatrixPosition(scope.matrixWorld)
-      cameraWorldPosition.setFromMatrixPosition(camera.matrixWorld)
+        rotationMatrix.extractRotation(scope.matrixWorld)
 
-      rotationMatrix.extractRotation(scope.matrixWorld)
+        normal.set(0, 0, 1)
+        normal.applyMatrix4(rotationMatrix)
 
-      normal.set(0, 0, 1)
-      normal.applyMatrix4(rotationMatrix)
+        view.subVectors(reflectorWorldPosition, cameraWorldPosition)
 
-      view.subVectors(reflectorWorldPosition, cameraWorldPosition)
+        // Avoid rendering when reflector is facing away
 
-      // Avoid rendering when reflector is facing away
+        if (view.dot(normal) > 0) return
 
-      if (view.dot(normal) > 0) return
+        view.reflect(normal).negate()
+        view.add(reflectorWorldPosition)
 
-      view.reflect(normal).negate()
-      view.add(reflectorWorldPosition)
+        rotationMatrix.extractRotation(camera.matrixWorld)
 
-      rotationMatrix.extractRotation(camera.matrixWorld)
+        lookAtPosition.set(0, 0, -1)
+        lookAtPosition.applyMatrix4(rotationMatrix)
+        lookAtPosition.add(cameraWorldPosition)
 
-      lookAtPosition.set(0, 0, -1)
-      lookAtPosition.applyMatrix4(rotationMatrix)
-      lookAtPosition.add(cameraWorldPosition)
+        target.subVectors(reflectorWorldPosition, lookAtPosition)
+        target.reflect(normal).negate()
+        target.add(reflectorWorldPosition)
 
-      target.subVectors(reflectorWorldPosition, lookAtPosition)
-      target.reflect(normal).negate()
-      target.add(reflectorWorldPosition)
+        virtualCamera.position.copy(view)
+        virtualCamera.up.set(0, 1, 0)
+        virtualCamera.up.applyMatrix4(rotationMatrix)
+        virtualCamera.up.reflect(normal)
+        virtualCamera.lookAt(target)
 
-      virtualCamera.position.copy(view)
-      virtualCamera.up.set(0, 1, 0)
-      virtualCamera.up.applyMatrix4(rotationMatrix)
-      virtualCamera.up.reflect(normal)
-      virtualCamera.lookAt(target)
+        virtualCamera.far = camera.far // Used in WebGLBackground
 
-      virtualCamera.far = camera.far // Used in WebGLBackground
+        virtualCamera.updateMatrixWorld()
+        virtualCamera.projectionMatrix.copy(camera.projectionMatrix)
 
-      virtualCamera.updateMatrixWorld()
-      virtualCamera.projectionMatrix.copy(camera.projectionMatrix)
+        material.uniforms['virtualCameraNear'].value = camera.near
+        material.uniforms['virtualCameraFar'].value = camera.far
+        material.uniforms['virtualCameraMatrixWorld'].value = virtualCamera.matrixWorld
+        material.uniforms['virtualCameraProjectionMatrix'].value = camera.projectionMatrix
+        material.uniforms['virtualCameraProjectionMatrixInverse'].value = camera.projectionMatrixInverse
+        material.uniforms['resolution'].value = scope.resolution
 
-      material.uniforms['virtualCameraNear'].value = camera.near
-      material.uniforms['virtualCameraFar'].value = camera.far
-      material.uniforms['virtualCameraMatrixWorld'].value = virtualCamera.matrixWorld
-      material.uniforms['virtualCameraProjectionMatrix'].value = camera.projectionMatrix
-      material.uniforms['virtualCameraProjectionMatrixInverse'].value = camera.projectionMatrixInverse
-      material.uniforms['resolution'].value = scope.resolution
+        // Update the texture matrix
+        textureMatrix.set(0.5, 0.0, 0.0, 0.5, 0.0, 0.5, 0.0, 0.5, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.0, 1.0)
+        textureMatrix.multiply(virtualCamera.projectionMatrix)
+        textureMatrix.multiply(virtualCamera.matrixWorldInverse)
+        textureMatrix.multiply(scope.matrixWorld)
 
-      // Update the texture matrix
-      textureMatrix.set(0.5, 0.0, 0.0, 0.5, 0.0, 0.5, 0.0, 0.5, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.0, 1.0)
-      textureMatrix.multiply(virtualCamera.projectionMatrix)
-      textureMatrix.multiply(virtualCamera.matrixWorldInverse)
-      textureMatrix.multiply(scope.matrixWorld)
+        // scope.visible = false;
 
-      // scope.visible = false;
+        const currentRenderTarget = renderer.getRenderTarget()
 
-      const currentRenderTarget = renderer.getRenderTarget()
+        const currentXrEnabled = renderer.xr.enabled
+        const currentShadowAutoUpdate = renderer.shadowMap.autoUpdate
+        const currentClippingPlanes = renderer.clippingPlanes
 
-      const currentXrEnabled = renderer.xr.enabled
-      const currentShadowAutoUpdate = renderer.shadowMap.autoUpdate
-      const currentClippingPlanes = renderer.clippingPlanes
+        renderer.xr.enabled = false // Avoid camera modification
+        renderer.shadowMap.autoUpdate = false // Avoid re-computing shadows
+        renderer.clippingPlanes = globalPlanes
 
-      renderer.xr.enabled = false // Avoid camera modification
-      renderer.shadowMap.autoUpdate = false // Avoid re-computing shadows
-      renderer.clippingPlanes = globalPlanes
+        renderer.setRenderTarget(renderTarget)
 
-      renderer.setRenderTarget(renderTarget)
+        renderer.state.buffers.depth.setMask(true) // make sure the depth buffer is writable so it can be properly cleared, see #18897
 
-      renderer.state.buffers.depth.setMask(true) // make sure the depth buffer is writable so it can be properly cleared, see #18897
+        if (renderer.autoClear === false) renderer.clear()
+        renderer.render(scene, virtualCamera)
 
-      if (renderer.autoClear === false) renderer.clear()
-      renderer.render(scene, virtualCamera)
+        renderer.xr.enabled = currentXrEnabled
+        renderer.shadowMap.autoUpdate = currentShadowAutoUpdate
+        renderer.clippingPlanes = currentClippingPlanes
 
-      renderer.xr.enabled = currentXrEnabled
-      renderer.shadowMap.autoUpdate = currentShadowAutoUpdate
-      renderer.clippingPlanes = currentClippingPlanes
+        renderer.setRenderTarget(currentRenderTarget)
 
-      renderer.setRenderTarget(currentRenderTarget)
+        // Restore viewport
 
-      // Restore viewport
+        const viewport = camera.viewport
 
-      const viewport = camera.viewport
+        if (viewport !== undefined) {
+          renderer.state.viewport(viewport)
+        }
 
-      if (viewport !== undefined) {
-        renderer.state.viewport(viewport)
+        // scope.visible = true;
       }
 
-      // scope.visible = true;
-    }
-
-    this.getRenderTarget = function () {
-      return renderTarget
+      this.getRenderTarget = function () {
+        return renderTarget
+      }
     }
   }
-}
+
+  return ReflectorForSSRPass
+})()
 
 export { ReflectorForSSRPass }
diff --git a/src/objects/Refractor.js b/src/objects/Refractor.js
index 09dda320..e5978f65 100644
--- a/src/objects/Refractor.js
+++ b/src/objects/Refractor.js
@@ -15,23 +15,24 @@ import {
 } from 'three'
 import { version } from '../_polyfill/constants'
 
-class Refractor extends Mesh {
-  static RefractorShader = {
-    uniforms: {
-      color: {
-        value: null,
+const Refractor = /* @__PURE__ */ (() => {
+  class Refractor extends Mesh {
+    static RefractorShader = {
+      uniforms: {
+        color: {
+          value: null,
+        },
+
+        tDiffuse: {
+          value: null,
+        },
+
+        textureMatrix: {
+          value: null,
+        },
       },
 
-      tDiffuse: {
-        value: null,
-      },
-
-      textureMatrix: {
-        value: null,
-      },
-    },
-
-    vertexShader: /* glsl */ `
+      vertexShader: /* glsl */ `
 
 		uniform mat4 textureMatrix;
 
@@ -44,7 +45,7 @@ class Refractor extends Mesh {
 
 		}`,
 
-    fragmentShader: /* glsl */ `
+      fragmentShader: /* glsl */ `
 
 		uniform vec3 color;
 		uniform sampler2D tDiffuse;
@@ -72,233 +73,236 @@ class Refractor extends Mesh {
 			#include <${version >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>
 
 		}`,
-  }
+    }
 
-  constructor(geometry, options = {}) {
-    super(geometry)
+    constructor(geometry, options = {}) {
+      super(geometry)
 
-    this.isRefractor = true
+      this.isRefractor = true
 
-    this.type = 'Refractor'
-    this.camera = new PerspectiveCamera()
+      this.type = 'Refractor'
+      this.camera = new PerspectiveCamera()
 
-    const scope = this
+      const scope = this
 
-    const color = options.color !== undefined ? new Color(options.color) : new Color(0x7f7f7f)
-    const textureWidth = options.textureWidth || 512
-    const textureHeight = options.textureHeight || 512
-    const clipBias = options.clipBias || 0
-    const shader = options.shader || Refractor.RefractorShader
-    const multisample = options.multisample !== undefined ? options.multisample : 4
+      const color = options.color !== undefined ? new Color(options.color) : new Color(0x7f7f7f)
+      const textureWidth = options.textureWidth || 512
+      const textureHeight = options.textureHeight || 512
+      const clipBias = options.clipBias || 0
+      const shader = options.shader || Refractor.RefractorShader
+      const multisample = options.multisample !== undefined ? options.multisample : 4
 
-    //
+      //
 
-    const virtualCamera = this.camera
-    virtualCamera.matrixAutoUpdate = false
-    virtualCamera.userData.refractor = true
+      const virtualCamera = this.camera
+      virtualCamera.matrixAutoUpdate = false
+      virtualCamera.userData.refractor = true
 
-    //
+      //
 
-    const refractorPlane = new Plane()
-    const textureMatrix = new Matrix4()
+      const refractorPlane = new Plane()
+      const textureMatrix = new Matrix4()
 
-    // render target
+      // render target
 
-    const renderTarget = new WebGLRenderTarget(textureWidth, textureHeight, {
-      samples: multisample,
-      type: HalfFloatType,
-    })
+      const renderTarget = new WebGLRenderTarget(textureWidth, textureHeight, {
+        samples: multisample,
+        type: HalfFloatType,
+      })
 
-    // material
+      // material
 
-    this.material = new ShaderMaterial({
-      uniforms: UniformsUtils.clone(shader.uniforms),
-      vertexShader: shader.vertexShader,
-      fragmentShader: shader.fragmentShader,
-      transparent: true, // ensures, refractors are drawn from farthest to closest
-    })
+      this.material = new ShaderMaterial({
+        uniforms: UniformsUtils.clone(shader.uniforms),
+        vertexShader: shader.vertexShader,
+        fragmentShader: shader.fragmentShader,
+        transparent: true, // ensures, refractors are drawn from farthest to closest
+      })
 
-    this.material.uniforms['color'].value = color
-    this.material.uniforms['tDiffuse'].value = renderTarget.texture
-    this.material.uniforms['textureMatrix'].value = textureMatrix
+      this.material.uniforms['color'].value = color
+      this.material.uniforms['tDiffuse'].value = renderTarget.texture
+      this.material.uniforms['textureMatrix'].value = textureMatrix
 
-    // functions
+      // functions
 
-    const visible = (function () {
-      const refractorWorldPosition = new Vector3()
-      const cameraWorldPosition = new Vector3()
-      const rotationMatrix = new Matrix4()
+      const visible = (function () {
+        const refractorWorldPosition = new Vector3()
+        const cameraWorldPosition = new Vector3()
+        const rotationMatrix = new Matrix4()
 
-      const view = new Vector3()
-      const normal = new Vector3()
+        const view = new Vector3()
+        const normal = new Vector3()
 
-      return function visible(camera) {
-        refractorWorldPosition.setFromMatrixPosition(scope.matrixWorld)
-        cameraWorldPosition.setFromMatrixPosition(camera.matrixWorld)
+        return function visible(camera) {
+          refractorWorldPosition.setFromMatrixPosition(scope.matrixWorld)
+          cameraWorldPosition.setFromMatrixPosition(camera.matrixWorld)
 
-        view.subVectors(refractorWorldPosition, cameraWorldPosition)
+          view.subVectors(refractorWorldPosition, cameraWorldPosition)
 
-        rotationMatrix.extractRotation(scope.matrixWorld)
+          rotationMatrix.extractRotation(scope.matrixWorld)
 
-        normal.set(0, 0, 1)
-        normal.applyMatrix4(rotationMatrix)
+          normal.set(0, 0, 1)
+          normal.applyMatrix4(rotationMatrix)
 
-        return view.dot(normal) < 0
-      }
-    })()
+          return view.dot(normal) < 0
+        }
+      })()
 
-    const updateRefractorPlane = (function () {
-      const normal = new Vector3()
-      const position = new Vector3()
-      const quaternion = new Quaternion()
-      const scale = new Vector3()
+      const updateRefractorPlane = (function () {
+        const normal = new Vector3()
+        const position = new Vector3()
+        const quaternion = new Quaternion()
+        const scale = new Vector3()
 
-      return function updateRefractorPlane() {
-        scope.matrixWorld.decompose(position, quaternion, scale)
-        normal.set(0, 0, 1).applyQuaternion(quaternion).normalize()
+        return function updateRefractorPlane() {
+          scope.matrixWorld.decompose(position, quaternion, scale)
+          normal.set(0, 0, 1).applyQuaternion(quaternion).normalize()
 
-        // flip the normal because we want to cull everything above the plane
+          // flip the normal because we want to cull everything above the plane
 
-        normal.negate()
+          normal.negate()
 
-        refractorPlane.setFromNormalAndCoplanarPoint(normal, position)
-      }
-    })()
+          refractorPlane.setFromNormalAndCoplanarPoint(normal, position)
+        }
+      })()
 
-    const updateVirtualCamera = (function () {
-      const clipPlane = new Plane()
-      const clipVector = new Vector4()
-      const q = new Vector4()
+      const updateVirtualCamera = (function () {
+        const clipPlane = new Plane()
+        const clipVector = new Vector4()
+        const q = new Vector4()
 
-      return function updateVirtualCamera(camera) {
-        virtualCamera.matrixWorld.copy(camera.matrixWorld)
-        virtualCamera.matrixWorldInverse.copy(virtualCamera.matrixWorld).invert()
-        virtualCamera.projectionMatrix.copy(camera.projectionMatrix)
-        virtualCamera.far = camera.far // used in WebGLBackground
+        return function updateVirtualCamera(camera) {
+          virtualCamera.matrixWorld.copy(camera.matrixWorld)
+          virtualCamera.matrixWorldInverse.copy(virtualCamera.matrixWorld).invert()
+          virtualCamera.projectionMatrix.copy(camera.projectionMatrix)
+          virtualCamera.far = camera.far // used in WebGLBackground
 
-        // The following code creates an oblique view frustum for clipping.
-        // see: Lengyel, Eric. “Oblique View Frustum Depth Projection and Clipping”.
-        // Journal of Game Development, Vol. 1, No. 2 (2005), Charles River Media, pp. 5–16
+          // The following code creates an oblique view frustum for clipping.
+          // see: Lengyel, Eric. “Oblique View Frustum Depth Projection and Clipping”.
+          // Journal of Game Development, Vol. 1, No. 2 (2005), Charles River Media, pp. 5–16
 
-        clipPlane.copy(refractorPlane)
-        clipPlane.applyMatrix4(virtualCamera.matrixWorldInverse)
+          clipPlane.copy(refractorPlane)
+          clipPlane.applyMatrix4(virtualCamera.matrixWorldInverse)
 
-        clipVector.set(clipPlane.normal.x, clipPlane.normal.y, clipPlane.normal.z, clipPlane.constant)
+          clipVector.set(clipPlane.normal.x, clipPlane.normal.y, clipPlane.normal.z, clipPlane.constant)
 
-        // calculate the clip-space corner point opposite the clipping plane and
-        // transform it into camera space by multiplying it by the inverse of the projection matrix
+          // calculate the clip-space corner point opposite the clipping plane and
+          // transform it into camera space by multiplying it by the inverse of the projection matrix
 
-        const projectionMatrix = virtualCamera.projectionMatrix
+          const projectionMatrix = virtualCamera.projectionMatrix
 
-        q.x = (Math.sign(clipVector.x) + projectionMatrix.elements[8]) / projectionMatrix.elements[0]
-        q.y = (Math.sign(clipVector.y) + projectionMatrix.elements[9]) / projectionMatrix.elements[5]
-        q.z = -1.0
-        q.w = (1.0 + projectionMatrix.elements[10]) / projectionMatrix.elements[14]
+          q.x = (Math.sign(clipVector.x) + projectionMatrix.elements[8]) / projectionMatrix.elements[0]
+          q.y = (Math.sign(clipVector.y) + projectionMatrix.elements[9]) / projectionMatrix.elements[5]
+          q.z = -1.0
+          q.w = (1.0 + projectionMatrix.elements[10]) / projectionMatrix.elements[14]
 
-        // calculate the scaled plane vector
+          // calculate the scaled plane vector
 
-        clipVector.multiplyScalar(2.0 / clipVector.dot(q))
+          clipVector.multiplyScalar(2.0 / clipVector.dot(q))
 
-        // replacing the third row of the projection matrix
+          // replacing the third row of the projection matrix
 
-        projectionMatrix.elements[2] = clipVector.x
-        projectionMatrix.elements[6] = clipVector.y
-        projectionMatrix.elements[10] = clipVector.z + 1.0 - clipBias
-        projectionMatrix.elements[14] = clipVector.w
-      }
-    })()
+          projectionMatrix.elements[2] = clipVector.x
+          projectionMatrix.elements[6] = clipVector.y
+          projectionMatrix.elements[10] = clipVector.z + 1.0 - clipBias
+          projectionMatrix.elements[14] = clipVector.w
+        }
+      })()
 
-    // This will update the texture matrix that is used for projective texture mapping in the shader.
-    // see: http://developer.download.nvidia.com/assets/gamedev/docs/projective_texture_mapping.pdf
+      // This will update the texture matrix that is used for projective texture mapping in the shader.
+      // see: http://developer.download.nvidia.com/assets/gamedev/docs/projective_texture_mapping.pdf
 
-    function updateTextureMatrix(camera) {
-      // this matrix does range mapping to [ 0, 1 ]
+      function updateTextureMatrix(camera) {
+        // this matrix does range mapping to [ 0, 1 ]
 
-      textureMatrix.set(0.5, 0.0, 0.0, 0.5, 0.0, 0.5, 0.0, 0.5, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.0, 1.0)
+        textureMatrix.set(0.5, 0.0, 0.0, 0.5, 0.0, 0.5, 0.0, 0.5, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.0, 1.0)
 
-      // we use "Object Linear Texgen", so we need to multiply the texture matrix T
-      // (matrix above) with the projection and view matrix of the virtual camera
-      // and the model matrix of the refractor
+        // we use "Object Linear Texgen", so we need to multiply the texture matrix T
+        // (matrix above) with the projection and view matrix of the virtual camera
+        // and the model matrix of the refractor
 
-      textureMatrix.multiply(camera.projectionMatrix)
-      textureMatrix.multiply(camera.matrixWorldInverse)
-      textureMatrix.multiply(scope.matrixWorld)
-    }
+        textureMatrix.multiply(camera.projectionMatrix)
+        textureMatrix.multiply(camera.matrixWorldInverse)
+        textureMatrix.multiply(scope.matrixWorld)
+      }
 
-    //
+      //
 
-    function render(renderer, scene, camera) {
-      scope.visible = false
+      function render(renderer, scene, camera) {
+        scope.visible = false
 
-      const currentRenderTarget = renderer.getRenderTarget()
-      const currentXrEnabled = renderer.xr.enabled
-      const currentShadowAutoUpdate = renderer.shadowMap.autoUpdate
-      const currentToneMapping = renderer.toneMapping
+        const currentRenderTarget = renderer.getRenderTarget()
+        const currentXrEnabled = renderer.xr.enabled
+        const currentShadowAutoUpdate = renderer.shadowMap.autoUpdate
+        const currentToneMapping = renderer.toneMapping
 
-      let isSRGB = false
-      if ('outputColorSpace' in renderer) isSRGB = renderer.outputColorSpace === 'srgb'
-      else isSRGB = renderer.outputEncoding === 3001 // sRGBEncoding
+        let isSRGB = false
+        if ('outputColorSpace' in renderer) isSRGB = renderer.outputColorSpace === 'srgb'
+        else isSRGB = renderer.outputEncoding === 3001 // sRGBEncoding
 
-      renderer.xr.enabled = false // avoid camera modification
-      renderer.shadowMap.autoUpdate = false // avoid re-computing shadows
-      if ('outputColorSpace' in renderer) renderer.outputColorSpace = 'srgb-linear'
-      else renderer.outputEncoding = 3000 // LinearEncoding
-      renderer.toneMapping = NoToneMapping
+        renderer.xr.enabled = false // avoid camera modification
+        renderer.shadowMap.autoUpdate = false // avoid re-computing shadows
+        if ('outputColorSpace' in renderer) renderer.outputColorSpace = 'srgb-linear'
+        else renderer.outputEncoding = 3000 // LinearEncoding
+        renderer.toneMapping = NoToneMapping
 
-      renderer.setRenderTarget(renderTarget)
-      if (renderer.autoClear === false) renderer.clear()
-      renderer.render(scene, virtualCamera)
+        renderer.setRenderTarget(renderTarget)
+        if (renderer.autoClear === false) renderer.clear()
+        renderer.render(scene, virtualCamera)
 
-      renderer.xr.enabled = currentXrEnabled
-      renderer.shadowMap.autoUpdate = currentShadowAutoUpdate
-      renderer.toneMapping = currentToneMapping
-      renderer.setRenderTarget(currentRenderTarget)
+        renderer.xr.enabled = currentXrEnabled
+        renderer.shadowMap.autoUpdate = currentShadowAutoUpdate
+        renderer.toneMapping = currentToneMapping
+        renderer.setRenderTarget(currentRenderTarget)
 
-      if ('outputColorSpace' in renderer) renderer.outputColorSpace = isSRGB ? 'srgb' : 'srgb-linear'
-      else renderer.outputEncoding = isSRGB ? 3001 : 3000
+        if ('outputColorSpace' in renderer) renderer.outputColorSpace = isSRGB ? 'srgb' : 'srgb-linear'
+        else renderer.outputEncoding = isSRGB ? 3001 : 3000
 
-      // restore viewport
+        // restore viewport
 
-      const viewport = camera.viewport
+        const viewport = camera.viewport
 
-      if (viewport !== undefined) {
-        renderer.state.viewport(viewport)
-      }
+        if (viewport !== undefined) {
+          renderer.state.viewport(viewport)
+        }
 
-      scope.visible = true
-    }
+        scope.visible = true
+      }
 
-    //
+      //
 
-    this.onBeforeRender = function (renderer, scene, camera) {
-      // ensure refractors are rendered only once per frame
+      this.onBeforeRender = function (renderer, scene, camera) {
+        // ensure refractors are rendered only once per frame
 
-      if (camera.userData.refractor === true) return
+        if (camera.userData.refractor === true) return
 
-      // avoid rendering when the refractor is viewed from behind
+        // avoid rendering when the refractor is viewed from behind
 
-      if (!visible(camera) === true) return
+        if (!visible(camera) === true) return
 
-      // update
+        // update
 
-      updateRefractorPlane()
+        updateRefractorPlane()
 
-      updateTextureMatrix(camera)
+        updateTextureMatrix(camera)
 
-      updateVirtualCamera(camera)
+        updateVirtualCamera(camera)
 
-      render(renderer, scene, camera)
-    }
+        render(renderer, scene, camera)
+      }
 
-    this.getRenderTarget = function () {
-      return renderTarget
-    }
+      this.getRenderTarget = function () {
+        return renderTarget
+      }
 
-    this.dispose = function () {
-      renderTarget.dispose()
-      scope.material.dispose()
+      this.dispose = function () {
+        renderTarget.dispose()
+        scope.material.dispose()
+      }
     }
   }
-}
+
+  return Refractor
+})()
 
 export { Refractor }
diff --git a/src/objects/ShadowMesh.js b/src/objects/ShadowMesh.js
index 41075b36..38f91193 100644
--- a/src/objects/ShadowMesh.js
+++ b/src/objects/ShadowMesh.js
@@ -4,7 +4,7 @@ import { Matrix4, Mesh, MeshBasicMaterial, EqualStencilFunc, IncrementStencilOp
  * A shadow Mesh that follows a shadow-casting Mesh in the scene, but is confined to a single plane.
  */
 
-const _shadowMatrix = new Matrix4()
+const _shadowMatrix = /* @__PURE__ */ new Matrix4()
 
 class ShadowMesh extends Mesh {
   constructor(mesh) {
diff --git a/src/objects/Sky.ts b/src/objects/Sky.ts
index 80c206a2..db7cd269 100644
--- a/src/objects/Sky.ts
+++ b/src/objects/Sky.ts
@@ -1,17 +1,31 @@
 import { BackSide, BoxGeometry, Mesh, ShaderMaterial, UniformsUtils, Vector3 } from 'three'
 import { version } from '../_polyfill/constants'
 
-const SkyShader = {
-  uniforms: {
-    turbidity: { value: 2 },
-    rayleigh: { value: 1 },
-    mieCoefficient: { value: 0.005 },
-    mieDirectionalG: { value: 0.8 },
-    sunPosition: { value: new Vector3() },
-    up: { value: new Vector3(0, 1, 0) },
-  },
-
-  vertexShader: /* glsl */ `
+/**
+ * Based on "A Practical Analytic Model for Daylight"
+ * aka The Preetham Model, the de facto standard analytic skydome model
+ * https://www.researchgate.net/publication/220720443_A_Practical_Analytic_Model_for_Daylight
+ *
+ * First implemented by Simon Wallner
+ * http://www.simonwallner.at/projects/atmospheric-scattering
+ *
+ * Improved by Martin Upitis
+ * http://blenderartists.org/forum/showthread.php?245954-preethams-sky-impementation-HDR
+ *
+ * Three.js integration by zz85 http://twitter.com/blurspline
+ */
+const Sky = /* @__PURE__ */ (() => {
+  const SkyShader = {
+    uniforms: {
+      turbidity: { value: 2 },
+      rayleigh: { value: 1 },
+      mieCoefficient: { value: 0.005 },
+      mieDirectionalG: { value: 0.8 },
+      sunPosition: { value: new Vector3() },
+      up: { value: new Vector3(0, 1, 0) },
+    },
+
+    vertexShader: /* glsl */ `
       uniform vec3 sunPosition;
       uniform float rayleigh;
       uniform float turbidity;
@@ -84,7 +98,7 @@ const SkyShader = {
       }
     `,
 
-  fragmentShader: /* glsl */ `
+    fragmentShader: /* glsl */ `
       varying vec3 vWorldPosition;
       varying vec3 vSunDirection;
       varying float vSunfade;
@@ -171,37 +185,27 @@ const SkyShader = {
 
       }
     `,
-}
-
-const material = new ShaderMaterial({
-  name: 'SkyShader',
-  fragmentShader: SkyShader.fragmentShader,
-  vertexShader: SkyShader.vertexShader,
-  uniforms: UniformsUtils.clone(SkyShader.uniforms),
-  side: BackSide,
-  depthWrite: false,
-})
+  }
 
-/**
- * Based on "A Practical Analytic Model for Daylight"
- * aka The Preetham Model, the de facto standard analytic skydome model
- * https://www.researchgate.net/publication/220720443_A_Practical_Analytic_Model_for_Daylight
- *
- * First implemented by Simon Wallner
- * http://www.simonwallner.at/projects/atmospheric-scattering
- *
- * Improved by Martin Upitis
- * http://blenderartists.org/forum/showthread.php?245954-preethams-sky-impementation-HDR
- *
- * Three.js integration by zz85 http://twitter.com/blurspline
- */
-class Sky extends Mesh {
-  constructor() {
-    super(new BoxGeometry(1, 1, 1), material)
+  const material = new ShaderMaterial({
+    name: 'SkyShader',
+    fragmentShader: SkyShader.fragmentShader,
+    vertexShader: SkyShader.vertexShader,
+    uniforms: UniformsUtils.clone(SkyShader.uniforms),
+    side: BackSide,
+    depthWrite: false,
+  })
+
+  class Sky extends Mesh {
+    constructor() {
+      super(new BoxGeometry(1, 1, 1), material)
+    }
+
+    static SkyShader = SkyShader
+    public static material = material
   }
 
-  static SkyShader = SkyShader
-  public static material = material
-}
+  return Sky
+})()
 
 export { Sky }
diff --git a/src/objects/Water.js b/src/objects/Water.js
index 540647af..33dd0f94 100644
--- a/src/objects/Water.js
+++ b/src/objects/Water.js
@@ -11,8 +11,8 @@ import {
   Vector3,
   Vector4,
   WebGLRenderTarget,
-  REVISION,
 } from 'three'
+import { version } from '../_polyfill/constants'
 
 /**
  * Work based on :
@@ -179,7 +179,7 @@ class Water extends Mesh {
 					gl_FragColor = vec4( outgoingLight, alpha );
 
 					#include <tonemapping_fragment>
-					#include <${parseInt(REVISION.replace(/\D+/g, '')) >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>
+					#include <${version >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>
 					#include <fog_fragment>	
 				}`,
     }
diff --git a/src/objects/Water2.js b/src/objects/Water2.js
index 4b73e8f2..4eed788e 100644
--- a/src/objects/Water2.js
+++ b/src/objects/Water2.js
@@ -21,43 +21,44 @@ import { version } from '../_polyfill/constants'
  *
  */
 
-class Water2 extends Mesh {
-  static WaterShader = {
-    uniforms: {
-      color: {
-        value: null,
+const Water2 = /* @__PURE__ */ (() => {
+  class Water2 extends Mesh {
+    static WaterShader = {
+      uniforms: {
+        color: {
+          value: null,
+        },
+
+        reflectivity: {
+          value: 0,
+        },
+
+        tReflectionMap: {
+          value: null,
+        },
+
+        tRefractionMap: {
+          value: null,
+        },
+
+        tNormalMap0: {
+          value: null,
+        },
+
+        tNormalMap1: {
+          value: null,
+        },
+
+        textureMatrix: {
+          value: null,
+        },
+
+        config: {
+          value: /* @__PURE__ */ new Vector4(),
+        },
       },
 
-      reflectivity: {
-        value: 0,
-      },
-
-      tReflectionMap: {
-        value: null,
-      },
-
-      tRefractionMap: {
-        value: null,
-      },
-
-      tNormalMap0: {
-        value: null,
-      },
-
-      tNormalMap1: {
-        value: null,
-      },
-
-      textureMatrix: {
-        value: null,
-      },
-
-      config: {
-        value: new Vector4(),
-      },
-    },
-
-    vertexShader: /* glsl */ `
+      vertexShader: /* glsl */ `
 
 		#include <common>
 		#include <fog_pars_vertex>
@@ -85,7 +86,7 @@ class Water2 extends Mesh {
 
 		}`,
 
-    fragmentShader: /* glsl */ `
+      fragmentShader: /* glsl */ `
 
 		#include <common>
 		#include <fog_pars_fragment>
@@ -160,158 +161,161 @@ class Water2 extends Mesh {
 			#include <fog_fragment>
 
 		}`,
-  }
-
-  constructor(geometry, options = {}) {
-    super(geometry)
+    }
 
-    this.isWater = true
+    constructor(geometry, options = {}) {
+      super(geometry)
 
-    this.type = 'Water'
+      this.isWater = true
 
-    const scope = this
+      this.type = 'Water'
 
-    const color = options.color !== undefined ? new Color(options.color) : new Color(0xffffff)
-    const textureWidth = options.textureWidth || 512
-    const textureHeight = options.textureHeight || 512
-    const clipBias = options.clipBias || 0
-    const flowDirection = options.flowDirection || new Vector2(1, 0)
-    const flowSpeed = options.flowSpeed || 0.03
-    const reflectivity = options.reflectivity || 0.02
-    const scale = options.scale || 1
-    const shader = options.shader || Water2.WaterShader
-    const encoding = options.encoding !== undefined ? options.encoding : 3000
+      const scope = this
 
-    const flowMap = options.flowMap || undefined
-    const normalMap0 = options.normalMap0
-    const normalMap1 = options.normalMap1
+      const color = options.color !== undefined ? new Color(options.color) : new Color(0xffffff)
+      const textureWidth = options.textureWidth || 512
+      const textureHeight = options.textureHeight || 512
+      const clipBias = options.clipBias || 0
+      const flowDirection = options.flowDirection || new Vector2(1, 0)
+      const flowSpeed = options.flowSpeed || 0.03
+      const reflectivity = options.reflectivity || 0.02
+      const scale = options.scale || 1
+      const shader = options.shader || Water2.WaterShader
+      const encoding = options.encoding !== undefined ? options.encoding : 3000
 
-    const cycle = 0.15 // a cycle of a flow map phase
-    const halfCycle = cycle * 0.5
-    const textureMatrix = new Matrix4()
-    const clock = new Clock()
+      const flowMap = options.flowMap || undefined
+      const normalMap0 = options.normalMap0
+      const normalMap1 = options.normalMap1
 
-    // internal components
+      const cycle = 0.15 // a cycle of a flow map phase
+      const halfCycle = cycle * 0.5
+      const textureMatrix = new Matrix4()
+      const clock = new Clock()
 
-    if (Reflector === undefined) {
-      console.error('THREE.Water: Required component Reflector not found.')
-      return
-    }
+      // internal components
 
-    if (Refractor === undefined) {
-      console.error('THREE.Water: Required component Refractor not found.')
-      return
-    }
+      if (Reflector === undefined) {
+        console.error('THREE.Water: Required component Reflector not found.')
+        return
+      }
 
-    const reflector = new Reflector(geometry, {
-      textureWidth: textureWidth,
-      textureHeight: textureHeight,
-      clipBias: clipBias,
-      encoding: encoding,
-    })
-
-    const refractor = new Refractor(geometry, {
-      textureWidth: textureWidth,
-      textureHeight: textureHeight,
-      clipBias: clipBias,
-      encoding: encoding,
-    })
-
-    reflector.matrixAutoUpdate = false
-    refractor.matrixAutoUpdate = false
-
-    // material
-
-    this.material = new ShaderMaterial({
-      uniforms: UniformsUtils.merge([UniformsLib['fog'], shader.uniforms]),
-      vertexShader: shader.vertexShader,
-      fragmentShader: shader.fragmentShader,
-      transparent: true,
-      fog: true,
-    })
-
-    if (flowMap !== undefined) {
-      this.material.defines.USE_FLOWMAP = ''
-      this.material.uniforms['tFlowMap'] = {
-        type: 't',
-        value: flowMap,
+      if (Refractor === undefined) {
+        console.error('THREE.Water: Required component Refractor not found.')
+        return
       }
-    } else {
-      this.material.uniforms['flowDirection'] = {
-        type: 'v2',
-        value: flowDirection,
+
+      const reflector = new Reflector(geometry, {
+        textureWidth: textureWidth,
+        textureHeight: textureHeight,
+        clipBias: clipBias,
+        encoding: encoding,
+      })
+
+      const refractor = new Refractor(geometry, {
+        textureWidth: textureWidth,
+        textureHeight: textureHeight,
+        clipBias: clipBias,
+        encoding: encoding,
+      })
+
+      reflector.matrixAutoUpdate = false
+      refractor.matrixAutoUpdate = false
+
+      // material
+
+      this.material = new ShaderMaterial({
+        uniforms: UniformsUtils.merge([UniformsLib['fog'], shader.uniforms]),
+        vertexShader: shader.vertexShader,
+        fragmentShader: shader.fragmentShader,
+        transparent: true,
+        fog: true,
+      })
+
+      if (flowMap !== undefined) {
+        this.material.defines.USE_FLOWMAP = ''
+        this.material.uniforms['tFlowMap'] = {
+          type: 't',
+          value: flowMap,
+        }
+      } else {
+        this.material.uniforms['flowDirection'] = {
+          type: 'v2',
+          value: flowDirection,
+        }
       }
-    }
 
-    // maps
+      // maps
 
-    normalMap0.wrapS = normalMap0.wrapT = RepeatWrapping
-    normalMap1.wrapS = normalMap1.wrapT = RepeatWrapping
+      normalMap0.wrapS = normalMap0.wrapT = RepeatWrapping
+      normalMap1.wrapS = normalMap1.wrapT = RepeatWrapping
 
-    this.material.uniforms['tReflectionMap'].value = reflector.getRenderTarget().texture
-    this.material.uniforms['tRefractionMap'].value = refractor.getRenderTarget().texture
-    this.material.uniforms['tNormalMap0'].value = normalMap0
-    this.material.uniforms['tNormalMap1'].value = normalMap1
+      this.material.uniforms['tReflectionMap'].value = reflector.getRenderTarget().texture
+      this.material.uniforms['tRefractionMap'].value = refractor.getRenderTarget().texture
+      this.material.uniforms['tNormalMap0'].value = normalMap0
+      this.material.uniforms['tNormalMap1'].value = normalMap1
 
-    // water
+      // water
 
-    this.material.uniforms['color'].value = color
-    this.material.uniforms['reflectivity'].value = reflectivity
-    this.material.uniforms['textureMatrix'].value = textureMatrix
+      this.material.uniforms['color'].value = color
+      this.material.uniforms['reflectivity'].value = reflectivity
+      this.material.uniforms['textureMatrix'].value = textureMatrix
 
-    // inital values
+      // inital values
 
-    this.material.uniforms['config'].value.x = 0 // flowMapOffset0
-    this.material.uniforms['config'].value.y = halfCycle // flowMapOffset1
-    this.material.uniforms['config'].value.z = halfCycle // halfCycle
-    this.material.uniforms['config'].value.w = scale // scale
+      this.material.uniforms['config'].value.x = 0 // flowMapOffset0
+      this.material.uniforms['config'].value.y = halfCycle // flowMapOffset1
+      this.material.uniforms['config'].value.z = halfCycle // halfCycle
+      this.material.uniforms['config'].value.w = scale // scale
 
-    // functions
+      // functions
 
-    function updateTextureMatrix(camera) {
-      textureMatrix.set(0.5, 0.0, 0.0, 0.5, 0.0, 0.5, 0.0, 0.5, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.0, 1.0)
+      function updateTextureMatrix(camera) {
+        textureMatrix.set(0.5, 0.0, 0.0, 0.5, 0.0, 0.5, 0.0, 0.5, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.0, 1.0)
 
-      textureMatrix.multiply(camera.projectionMatrix)
-      textureMatrix.multiply(camera.matrixWorldInverse)
-      textureMatrix.multiply(scope.matrixWorld)
-    }
+        textureMatrix.multiply(camera.projectionMatrix)
+        textureMatrix.multiply(camera.matrixWorldInverse)
+        textureMatrix.multiply(scope.matrixWorld)
+      }
 
-    function updateFlow() {
-      const delta = clock.getDelta()
-      const config = scope.material.uniforms['config']
+      function updateFlow() {
+        const delta = clock.getDelta()
+        const config = scope.material.uniforms['config']
 
-      config.value.x += flowSpeed * delta // flowMapOffset0
-      config.value.y = config.value.x + halfCycle // flowMapOffset1
+        config.value.x += flowSpeed * delta // flowMapOffset0
+        config.value.y = config.value.x + halfCycle // flowMapOffset1
 
-      // Important: The distance between offsets should be always the value of "halfCycle".
-      // Moreover, both offsets should be in the range of [ 0, cycle ].
-      // This approach ensures a smooth water flow and avoids "reset" effects.
+        // Important: The distance between offsets should be always the value of "halfCycle".
+        // Moreover, both offsets should be in the range of [ 0, cycle ].
+        // This approach ensures a smooth water flow and avoids "reset" effects.
 
-      if (config.value.x >= cycle) {
-        config.value.x = 0
-        config.value.y = halfCycle
-      } else if (config.value.y >= cycle) {
-        config.value.y = config.value.y - cycle
+        if (config.value.x >= cycle) {
+          config.value.x = 0
+          config.value.y = halfCycle
+        } else if (config.value.y >= cycle) {
+          config.value.y = config.value.y - cycle
+        }
       }
-    }
 
-    //
+      //
 
-    this.onBeforeRender = function (renderer, scene, camera) {
-      updateTextureMatrix(camera)
-      updateFlow()
+      this.onBeforeRender = function (renderer, scene, camera) {
+        updateTextureMatrix(camera)
+        updateFlow()
 
-      scope.visible = false
+        scope.visible = false
 
-      reflector.matrixWorld.copy(scope.matrixWorld)
-      refractor.matrixWorld.copy(scope.matrixWorld)
+        reflector.matrixWorld.copy(scope.matrixWorld)
+        refractor.matrixWorld.copy(scope.matrixWorld)
 
-      reflector.onBeforeRender(renderer, scene, camera)
-      refractor.onBeforeRender(renderer, scene, camera)
+        reflector.onBeforeRender(renderer, scene, camera)
+        refractor.onBeforeRender(renderer, scene, camera)
 
-      scope.visible = true
+        scope.visible = true
+      }
     }
   }
-}
+
+  return Water2
+})()
 
 export { Water2 }
diff --git a/src/postprocessing/SAOPass.js b/src/postprocessing/SAOPass.js
index 6125d3b8..caa026dc 100644
--- a/src/postprocessing/SAOPass.js
+++ b/src/postprocessing/SAOPass.js
@@ -28,353 +28,357 @@ import { UnpackDepthRGBAShader } from '../shaders/UnpackDepthRGBAShader'
 /**
  * SAO implementation inspired from bhouston previous SAO work
  */
-class SAOPass extends Pass {
-  static OUTPUT = {
-    Beauty: 1,
-    Default: 0,
-    SAO: 2,
-    Depth: 3,
-    Normal: 4,
-  }
-
-  constructor(scene, camera, useDepthTexture = false, useNormals = false, resolution = new Vector2(256, 256)) {
-    super()
-
-    this.scene = scene
-    this.camera = camera
-
-    this.clear = true
-    this.needsSwap = false
-
-    this.supportsDepthTextureExtension = useDepthTexture
-    this.supportsNormalTexture = useNormals
-
-    this.originalClearColor = new Color()
-    this._oldClearColor = new Color()
-    this.oldClearAlpha = 1
-
-    this.params = {
-      output: 0,
-      saoBias: 0.5,
-      saoIntensity: 0.18,
-      saoScale: 1,
-      saoKernelRadius: 100,
-      saoMinResolution: 0,
-      saoBlur: true,
-      saoBlurRadius: 8,
-      saoBlurStdDev: 4,
-      saoBlurDepthCutoff: 0.01,
+const SAOPass = /* @__PURE__ */ (() => {
+  class SAOPass extends Pass {
+    static OUTPUT = {
+      Beauty: 1,
+      Default: 0,
+      SAO: 2,
+      Depth: 3,
+      Normal: 4,
     }
 
-    this.resolution = new Vector2(resolution.x, resolution.y)
+    constructor(scene, camera, useDepthTexture = false, useNormals = false, resolution = new Vector2(256, 256)) {
+      super()
+
+      this.scene = scene
+      this.camera = camera
+
+      this.clear = true
+      this.needsSwap = false
+
+      this.supportsDepthTextureExtension = useDepthTexture
+      this.supportsNormalTexture = useNormals
+
+      this.originalClearColor = new Color()
+      this._oldClearColor = new Color()
+      this.oldClearAlpha = 1
+
+      this.params = {
+        output: 0,
+        saoBias: 0.5,
+        saoIntensity: 0.18,
+        saoScale: 1,
+        saoKernelRadius: 100,
+        saoMinResolution: 0,
+        saoBlur: true,
+        saoBlurRadius: 8,
+        saoBlurStdDev: 4,
+        saoBlurDepthCutoff: 0.01,
+      }
 
-    this.saoRenderTarget = new WebGLRenderTarget(this.resolution.x, this.resolution.y, { type: HalfFloatType })
-    this.blurIntermediateRenderTarget = this.saoRenderTarget.clone()
-    this.beautyRenderTarget = this.saoRenderTarget.clone()
+      this.resolution = new Vector2(resolution.x, resolution.y)
 
-    this.normalRenderTarget = new WebGLRenderTarget(this.resolution.x, this.resolution.y, {
-      minFilter: NearestFilter,
-      magFilter: NearestFilter,
-      type: HalfFloatType,
-    })
-    this.depthRenderTarget = this.normalRenderTarget.clone()
+      this.saoRenderTarget = new WebGLRenderTarget(this.resolution.x, this.resolution.y, { type: HalfFloatType })
+      this.blurIntermediateRenderTarget = this.saoRenderTarget.clone()
+      this.beautyRenderTarget = this.saoRenderTarget.clone()
 
-    let depthTexture
+      this.normalRenderTarget = new WebGLRenderTarget(this.resolution.x, this.resolution.y, {
+        minFilter: NearestFilter,
+        magFilter: NearestFilter,
+        type: HalfFloatType,
+      })
+      this.depthRenderTarget = this.normalRenderTarget.clone()
 
-    if (this.supportsDepthTextureExtension) {
-      depthTexture = new DepthTexture()
-      depthTexture.type = UnsignedShortType
+      let depthTexture
 
-      this.beautyRenderTarget.depthTexture = depthTexture
-      this.beautyRenderTarget.depthBuffer = true
-    }
+      if (this.supportsDepthTextureExtension) {
+        depthTexture = new DepthTexture()
+        depthTexture.type = UnsignedShortType
 
-    this.depthMaterial = new MeshDepthMaterial()
-    this.depthMaterial.depthPacking = RGBADepthPacking
-    this.depthMaterial.blending = NoBlending
-
-    this.normalMaterial = new MeshNormalMaterial()
-    this.normalMaterial.blending = NoBlending
-
-    this.saoMaterial = new ShaderMaterial({
-      defines: Object.assign({}, SAOShader.defines),
-      fragmentShader: SAOShader.fragmentShader,
-      vertexShader: SAOShader.vertexShader,
-      uniforms: UniformsUtils.clone(SAOShader.uniforms),
-    })
-    this.saoMaterial.extensions.derivatives = true
-    this.saoMaterial.defines['DEPTH_PACKING'] = this.supportsDepthTextureExtension ? 0 : 1
-    this.saoMaterial.defines['NORMAL_TEXTURE'] = this.supportsNormalTexture ? 1 : 0
-    this.saoMaterial.defines['PERSPECTIVE_CAMERA'] = this.camera.isPerspectiveCamera ? 1 : 0
-    this.saoMaterial.uniforms['tDepth'].value = this.supportsDepthTextureExtension
-      ? depthTexture
-      : this.depthRenderTarget.texture
-    this.saoMaterial.uniforms['tNormal'].value = this.normalRenderTarget.texture
-    this.saoMaterial.uniforms['size'].value.set(this.resolution.x, this.resolution.y)
-    this.saoMaterial.uniforms['cameraInverseProjectionMatrix'].value.copy(this.camera.projectionMatrixInverse)
-    this.saoMaterial.uniforms['cameraProjectionMatrix'].value = this.camera.projectionMatrix
-    this.saoMaterial.blending = NoBlending
-
-    this.vBlurMaterial = new ShaderMaterial({
-      uniforms: UniformsUtils.clone(DepthLimitedBlurShader.uniforms),
-      defines: Object.assign({}, DepthLimitedBlurShader.defines),
-      vertexShader: DepthLimitedBlurShader.vertexShader,
-      fragmentShader: DepthLimitedBlurShader.fragmentShader,
-    })
-    this.vBlurMaterial.defines['DEPTH_PACKING'] = this.supportsDepthTextureExtension ? 0 : 1
-    this.vBlurMaterial.defines['PERSPECTIVE_CAMERA'] = this.camera.isPerspectiveCamera ? 1 : 0
-    this.vBlurMaterial.uniforms['tDiffuse'].value = this.saoRenderTarget.texture
-    this.vBlurMaterial.uniforms['tDepth'].value = this.supportsDepthTextureExtension
-      ? depthTexture
-      : this.depthRenderTarget.texture
-    this.vBlurMaterial.uniforms['size'].value.set(this.resolution.x, this.resolution.y)
-    this.vBlurMaterial.blending = NoBlending
-
-    this.hBlurMaterial = new ShaderMaterial({
-      uniforms: UniformsUtils.clone(DepthLimitedBlurShader.uniforms),
-      defines: Object.assign({}, DepthLimitedBlurShader.defines),
-      vertexShader: DepthLimitedBlurShader.vertexShader,
-      fragmentShader: DepthLimitedBlurShader.fragmentShader,
-    })
-    this.hBlurMaterial.defines['DEPTH_PACKING'] = this.supportsDepthTextureExtension ? 0 : 1
-    this.hBlurMaterial.defines['PERSPECTIVE_CAMERA'] = this.camera.isPerspectiveCamera ? 1 : 0
-    this.hBlurMaterial.uniforms['tDiffuse'].value = this.blurIntermediateRenderTarget.texture
-    this.hBlurMaterial.uniforms['tDepth'].value = this.supportsDepthTextureExtension
-      ? depthTexture
-      : this.depthRenderTarget.texture
-    this.hBlurMaterial.uniforms['size'].value.set(this.resolution.x, this.resolution.y)
-    this.hBlurMaterial.blending = NoBlending
-
-    this.materialCopy = new ShaderMaterial({
-      uniforms: UniformsUtils.clone(CopyShader.uniforms),
-      vertexShader: CopyShader.vertexShader,
-      fragmentShader: CopyShader.fragmentShader,
-      blending: NoBlending,
-    })
-    this.materialCopy.transparent = true
-    this.materialCopy.depthTest = false
-    this.materialCopy.depthWrite = false
-    this.materialCopy.blending = CustomBlending
-    this.materialCopy.blendSrc = DstColorFactor
-    this.materialCopy.blendDst = ZeroFactor
-    this.materialCopy.blendEquation = AddEquation
-    this.materialCopy.blendSrcAlpha = DstAlphaFactor
-    this.materialCopy.blendDstAlpha = ZeroFactor
-    this.materialCopy.blendEquationAlpha = AddEquation
-
-    this.depthCopy = new ShaderMaterial({
-      uniforms: UniformsUtils.clone(UnpackDepthRGBAShader.uniforms),
-      vertexShader: UnpackDepthRGBAShader.vertexShader,
-      fragmentShader: UnpackDepthRGBAShader.fragmentShader,
-      blending: NoBlending,
-    })
-
-    this.fsQuad = new FullScreenQuad(null)
-  }
+        this.beautyRenderTarget.depthTexture = depthTexture
+        this.beautyRenderTarget.depthBuffer = true
+      }
 
-  render(renderer, writeBuffer, readBuffer /*, deltaTime, maskActive*/) {
-    // Rendering readBuffer first when rendering to screen
-    if (this.renderToScreen) {
-      this.materialCopy.blending = NoBlending
-      this.materialCopy.uniforms['tDiffuse'].value = readBuffer.texture
-      this.materialCopy.needsUpdate = true
-      this.renderPass(renderer, this.materialCopy, null)
+      this.depthMaterial = new MeshDepthMaterial()
+      this.depthMaterial.depthPacking = RGBADepthPacking
+      this.depthMaterial.blending = NoBlending
+
+      this.normalMaterial = new MeshNormalMaterial()
+      this.normalMaterial.blending = NoBlending
+
+      this.saoMaterial = new ShaderMaterial({
+        defines: Object.assign({}, SAOShader.defines),
+        fragmentShader: SAOShader.fragmentShader,
+        vertexShader: SAOShader.vertexShader,
+        uniforms: UniformsUtils.clone(SAOShader.uniforms),
+      })
+      this.saoMaterial.extensions.derivatives = true
+      this.saoMaterial.defines['DEPTH_PACKING'] = this.supportsDepthTextureExtension ? 0 : 1
+      this.saoMaterial.defines['NORMAL_TEXTURE'] = this.supportsNormalTexture ? 1 : 0
+      this.saoMaterial.defines['PERSPECTIVE_CAMERA'] = this.camera.isPerspectiveCamera ? 1 : 0
+      this.saoMaterial.uniforms['tDepth'].value = this.supportsDepthTextureExtension
+        ? depthTexture
+        : this.depthRenderTarget.texture
+      this.saoMaterial.uniforms['tNormal'].value = this.normalRenderTarget.texture
+      this.saoMaterial.uniforms['size'].value.set(this.resolution.x, this.resolution.y)
+      this.saoMaterial.uniforms['cameraInverseProjectionMatrix'].value.copy(this.camera.projectionMatrixInverse)
+      this.saoMaterial.uniforms['cameraProjectionMatrix'].value = this.camera.projectionMatrix
+      this.saoMaterial.blending = NoBlending
+
+      this.vBlurMaterial = new ShaderMaterial({
+        uniforms: UniformsUtils.clone(DepthLimitedBlurShader.uniforms),
+        defines: Object.assign({}, DepthLimitedBlurShader.defines),
+        vertexShader: DepthLimitedBlurShader.vertexShader,
+        fragmentShader: DepthLimitedBlurShader.fragmentShader,
+      })
+      this.vBlurMaterial.defines['DEPTH_PACKING'] = this.supportsDepthTextureExtension ? 0 : 1
+      this.vBlurMaterial.defines['PERSPECTIVE_CAMERA'] = this.camera.isPerspectiveCamera ? 1 : 0
+      this.vBlurMaterial.uniforms['tDiffuse'].value = this.saoRenderTarget.texture
+      this.vBlurMaterial.uniforms['tDepth'].value = this.supportsDepthTextureExtension
+        ? depthTexture
+        : this.depthRenderTarget.texture
+      this.vBlurMaterial.uniforms['size'].value.set(this.resolution.x, this.resolution.y)
+      this.vBlurMaterial.blending = NoBlending
+
+      this.hBlurMaterial = new ShaderMaterial({
+        uniforms: UniformsUtils.clone(DepthLimitedBlurShader.uniforms),
+        defines: Object.assign({}, DepthLimitedBlurShader.defines),
+        vertexShader: DepthLimitedBlurShader.vertexShader,
+        fragmentShader: DepthLimitedBlurShader.fragmentShader,
+      })
+      this.hBlurMaterial.defines['DEPTH_PACKING'] = this.supportsDepthTextureExtension ? 0 : 1
+      this.hBlurMaterial.defines['PERSPECTIVE_CAMERA'] = this.camera.isPerspectiveCamera ? 1 : 0
+      this.hBlurMaterial.uniforms['tDiffuse'].value = this.blurIntermediateRenderTarget.texture
+      this.hBlurMaterial.uniforms['tDepth'].value = this.supportsDepthTextureExtension
+        ? depthTexture
+        : this.depthRenderTarget.texture
+      this.hBlurMaterial.uniforms['size'].value.set(this.resolution.x, this.resolution.y)
+      this.hBlurMaterial.blending = NoBlending
+
+      this.materialCopy = new ShaderMaterial({
+        uniforms: UniformsUtils.clone(CopyShader.uniforms),
+        vertexShader: CopyShader.vertexShader,
+        fragmentShader: CopyShader.fragmentShader,
+        blending: NoBlending,
+      })
+      this.materialCopy.transparent = true
+      this.materialCopy.depthTest = false
+      this.materialCopy.depthWrite = false
+      this.materialCopy.blending = CustomBlending
+      this.materialCopy.blendSrc = DstColorFactor
+      this.materialCopy.blendDst = ZeroFactor
+      this.materialCopy.blendEquation = AddEquation
+      this.materialCopy.blendSrcAlpha = DstAlphaFactor
+      this.materialCopy.blendDstAlpha = ZeroFactor
+      this.materialCopy.blendEquationAlpha = AddEquation
+
+      this.depthCopy = new ShaderMaterial({
+        uniforms: UniformsUtils.clone(UnpackDepthRGBAShader.uniforms),
+        vertexShader: UnpackDepthRGBAShader.vertexShader,
+        fragmentShader: UnpackDepthRGBAShader.fragmentShader,
+        blending: NoBlending,
+      })
+
+      this.fsQuad = new FullScreenQuad(null)
     }
 
-    if (this.params.output === 1) {
-      return
-    }
+    render(renderer, writeBuffer, readBuffer /*, deltaTime, maskActive*/) {
+      // Rendering readBuffer first when rendering to screen
+      if (this.renderToScreen) {
+        this.materialCopy.blending = NoBlending
+        this.materialCopy.uniforms['tDiffuse'].value = readBuffer.texture
+        this.materialCopy.needsUpdate = true
+        this.renderPass(renderer, this.materialCopy, null)
+      }
 
-    renderer.getClearColor(this._oldClearColor)
-    this.oldClearAlpha = renderer.getClearAlpha()
-    const oldAutoClear = renderer.autoClear
-    renderer.autoClear = false
-
-    renderer.setRenderTarget(this.depthRenderTarget)
-    renderer.clear()
-
-    this.saoMaterial.uniforms['bias'].value = this.params.saoBias
-    this.saoMaterial.uniforms['intensity'].value = this.params.saoIntensity
-    this.saoMaterial.uniforms['scale'].value = this.params.saoScale
-    this.saoMaterial.uniforms['kernelRadius'].value = this.params.saoKernelRadius
-    this.saoMaterial.uniforms['minResolution'].value = this.params.saoMinResolution
-    this.saoMaterial.uniforms['cameraNear'].value = this.camera.near
-    this.saoMaterial.uniforms['cameraFar'].value = this.camera.far
-    // this.saoMaterial.uniforms['randomSeed'].value = Math.random();
-
-    const depthCutoff = this.params.saoBlurDepthCutoff * (this.camera.far - this.camera.near)
-    this.vBlurMaterial.uniforms['depthCutoff'].value = depthCutoff
-    this.hBlurMaterial.uniforms['depthCutoff'].value = depthCutoff
-
-    this.vBlurMaterial.uniforms['cameraNear'].value = this.camera.near
-    this.vBlurMaterial.uniforms['cameraFar'].value = this.camera.far
-    this.hBlurMaterial.uniforms['cameraNear'].value = this.camera.near
-    this.hBlurMaterial.uniforms['cameraFar'].value = this.camera.far
-
-    this.params.saoBlurRadius = Math.floor(this.params.saoBlurRadius)
-    if (this.prevStdDev !== this.params.saoBlurStdDev || this.prevNumSamples !== this.params.saoBlurRadius) {
-      BlurShaderUtils.configure(
-        this.vBlurMaterial,
-        this.params.saoBlurRadius,
-        this.params.saoBlurStdDev,
-        new Vector2(0, 1),
-      )
-      BlurShaderUtils.configure(
-        this.hBlurMaterial,
-        this.params.saoBlurRadius,
-        this.params.saoBlurStdDev,
-        new Vector2(1, 0),
-      )
-      this.prevStdDev = this.params.saoBlurStdDev
-      this.prevNumSamples = this.params.saoBlurRadius
-    }
+      if (this.params.output === 1) {
+        return
+      }
 
-    // Rendering scene to depth texture
-    renderer.setClearColor(0x000000)
-    renderer.setRenderTarget(this.beautyRenderTarget)
-    renderer.clear()
-    renderer.render(this.scene, this.camera)
+      renderer.getClearColor(this._oldClearColor)
+      this.oldClearAlpha = renderer.getClearAlpha()
+      const oldAutoClear = renderer.autoClear
+      renderer.autoClear = false
 
-    // Re-render scene if depth texture extension is not supported
-    if (!this.supportsDepthTextureExtension) {
-      // Clear rule : far clipping plane in both RGBA and Basic encoding
-      this.renderOverride(renderer, this.depthMaterial, this.depthRenderTarget, 0x000000, 1.0)
-    }
+      renderer.setRenderTarget(this.depthRenderTarget)
+      renderer.clear()
 
-    if (this.supportsNormalTexture) {
-      // Clear rule : default normal is facing the camera
-      this.renderOverride(renderer, this.normalMaterial, this.normalRenderTarget, 0x7777ff, 1.0)
-    }
+      this.saoMaterial.uniforms['bias'].value = this.params.saoBias
+      this.saoMaterial.uniforms['intensity'].value = this.params.saoIntensity
+      this.saoMaterial.uniforms['scale'].value = this.params.saoScale
+      this.saoMaterial.uniforms['kernelRadius'].value = this.params.saoKernelRadius
+      this.saoMaterial.uniforms['minResolution'].value = this.params.saoMinResolution
+      this.saoMaterial.uniforms['cameraNear'].value = this.camera.near
+      this.saoMaterial.uniforms['cameraFar'].value = this.camera.far
+      // this.saoMaterial.uniforms['randomSeed'].value = Math.random();
+
+      const depthCutoff = this.params.saoBlurDepthCutoff * (this.camera.far - this.camera.near)
+      this.vBlurMaterial.uniforms['depthCutoff'].value = depthCutoff
+      this.hBlurMaterial.uniforms['depthCutoff'].value = depthCutoff
+
+      this.vBlurMaterial.uniforms['cameraNear'].value = this.camera.near
+      this.vBlurMaterial.uniforms['cameraFar'].value = this.camera.far
+      this.hBlurMaterial.uniforms['cameraNear'].value = this.camera.near
+      this.hBlurMaterial.uniforms['cameraFar'].value = this.camera.far
+
+      this.params.saoBlurRadius = Math.floor(this.params.saoBlurRadius)
+      if (this.prevStdDev !== this.params.saoBlurStdDev || this.prevNumSamples !== this.params.saoBlurRadius) {
+        BlurShaderUtils.configure(
+          this.vBlurMaterial,
+          this.params.saoBlurRadius,
+          this.params.saoBlurStdDev,
+          new Vector2(0, 1),
+        )
+        BlurShaderUtils.configure(
+          this.hBlurMaterial,
+          this.params.saoBlurRadius,
+          this.params.saoBlurStdDev,
+          new Vector2(1, 0),
+        )
+        this.prevStdDev = this.params.saoBlurStdDev
+        this.prevNumSamples = this.params.saoBlurRadius
+      }
 
-    // Rendering SAO texture
-    this.renderPass(renderer, this.saoMaterial, this.saoRenderTarget, 0xffffff, 1.0)
+      // Rendering scene to depth texture
+      renderer.setClearColor(0x000000)
+      renderer.setRenderTarget(this.beautyRenderTarget)
+      renderer.clear()
+      renderer.render(this.scene, this.camera)
 
-    // Blurring SAO texture
-    if (this.params.saoBlur) {
-      this.renderPass(renderer, this.vBlurMaterial, this.blurIntermediateRenderTarget, 0xffffff, 1.0)
-      this.renderPass(renderer, this.hBlurMaterial, this.saoRenderTarget, 0xffffff, 1.0)
-    }
+      // Re-render scene if depth texture extension is not supported
+      if (!this.supportsDepthTextureExtension) {
+        // Clear rule : far clipping plane in both RGBA and Basic encoding
+        this.renderOverride(renderer, this.depthMaterial, this.depthRenderTarget, 0x000000, 1.0)
+      }
 
-    let outputMaterial = this.materialCopy
-    // Setting up SAO rendering
-    if (this.params.output === 3) {
-      if (this.supportsDepthTextureExtension) {
-        this.materialCopy.uniforms['tDiffuse'].value = this.beautyRenderTarget.depthTexture
+      if (this.supportsNormalTexture) {
+        // Clear rule : default normal is facing the camera
+        this.renderOverride(renderer, this.normalMaterial, this.normalRenderTarget, 0x7777ff, 1.0)
+      }
+
+      // Rendering SAO texture
+      this.renderPass(renderer, this.saoMaterial, this.saoRenderTarget, 0xffffff, 1.0)
+
+      // Blurring SAO texture
+      if (this.params.saoBlur) {
+        this.renderPass(renderer, this.vBlurMaterial, this.blurIntermediateRenderTarget, 0xffffff, 1.0)
+        this.renderPass(renderer, this.hBlurMaterial, this.saoRenderTarget, 0xffffff, 1.0)
+      }
+
+      let outputMaterial = this.materialCopy
+      // Setting up SAO rendering
+      if (this.params.output === 3) {
+        if (this.supportsDepthTextureExtension) {
+          this.materialCopy.uniforms['tDiffuse'].value = this.beautyRenderTarget.depthTexture
+          this.materialCopy.needsUpdate = true
+        } else {
+          this.depthCopy.uniforms['tDiffuse'].value = this.depthRenderTarget.texture
+          this.depthCopy.needsUpdate = true
+          outputMaterial = this.depthCopy
+        }
+      } else if (this.params.output === 4) {
+        this.materialCopy.uniforms['tDiffuse'].value = this.normalRenderTarget.texture
         this.materialCopy.needsUpdate = true
       } else {
-        this.depthCopy.uniforms['tDiffuse'].value = this.depthRenderTarget.texture
-        this.depthCopy.needsUpdate = true
-        outputMaterial = this.depthCopy
+        this.materialCopy.uniforms['tDiffuse'].value = this.saoRenderTarget.texture
+        this.materialCopy.needsUpdate = true
       }
-    } else if (this.params.output === 4) {
-      this.materialCopy.uniforms['tDiffuse'].value = this.normalRenderTarget.texture
-      this.materialCopy.needsUpdate = true
-    } else {
-      this.materialCopy.uniforms['tDiffuse'].value = this.saoRenderTarget.texture
-      this.materialCopy.needsUpdate = true
-    }
 
-    // Blending depends on output, only want a CustomBlending when showing SAO
-    if (this.params.output === 0) {
-      outputMaterial.blending = CustomBlending
-    } else {
-      outputMaterial.blending = NoBlending
+      // Blending depends on output, only want a CustomBlending when showing SAO
+      if (this.params.output === 0) {
+        outputMaterial.blending = CustomBlending
+      } else {
+        outputMaterial.blending = NoBlending
+      }
+
+      // Rendering SAOPass result on top of previous pass
+      this.renderPass(renderer, outputMaterial, this.renderToScreen ? null : readBuffer)
+
+      renderer.setClearColor(this._oldClearColor, this.oldClearAlpha)
+      renderer.autoClear = oldAutoClear
     }
 
-    // Rendering SAOPass result on top of previous pass
-    this.renderPass(renderer, outputMaterial, this.renderToScreen ? null : readBuffer)
+    renderPass(renderer, passMaterial, renderTarget, clearColor, clearAlpha) {
+      // save original state
+      renderer.getClearColor(this.originalClearColor)
+      const originalClearAlpha = renderer.getClearAlpha()
+      const originalAutoClear = renderer.autoClear
 
-    renderer.setClearColor(this._oldClearColor, this.oldClearAlpha)
-    renderer.autoClear = oldAutoClear
-  }
+      renderer.setRenderTarget(renderTarget)
 
-  renderPass(renderer, passMaterial, renderTarget, clearColor, clearAlpha) {
-    // save original state
-    renderer.getClearColor(this.originalClearColor)
-    const originalClearAlpha = renderer.getClearAlpha()
-    const originalAutoClear = renderer.autoClear
+      // setup pass state
+      renderer.autoClear = false
+      if (clearColor !== undefined && clearColor !== null) {
+        renderer.setClearColor(clearColor)
+        renderer.setClearAlpha(clearAlpha || 0.0)
+        renderer.clear()
+      }
 
-    renderer.setRenderTarget(renderTarget)
+      this.fsQuad.material = passMaterial
+      this.fsQuad.render(renderer)
 
-    // setup pass state
-    renderer.autoClear = false
-    if (clearColor !== undefined && clearColor !== null) {
-      renderer.setClearColor(clearColor)
-      renderer.setClearAlpha(clearAlpha || 0.0)
-      renderer.clear()
+      // restore original state
+      renderer.autoClear = originalAutoClear
+      renderer.setClearColor(this.originalClearColor)
+      renderer.setClearAlpha(originalClearAlpha)
     }
 
-    this.fsQuad.material = passMaterial
-    this.fsQuad.render(renderer)
+    renderOverride(renderer, overrideMaterial, renderTarget, clearColor, clearAlpha) {
+      renderer.getClearColor(this.originalClearColor)
+      const originalClearAlpha = renderer.getClearAlpha()
+      const originalAutoClear = renderer.autoClear
 
-    // restore original state
-    renderer.autoClear = originalAutoClear
-    renderer.setClearColor(this.originalClearColor)
-    renderer.setClearAlpha(originalClearAlpha)
-  }
+      renderer.setRenderTarget(renderTarget)
+      renderer.autoClear = false
 
-  renderOverride(renderer, overrideMaterial, renderTarget, clearColor, clearAlpha) {
-    renderer.getClearColor(this.originalClearColor)
-    const originalClearAlpha = renderer.getClearAlpha()
-    const originalAutoClear = renderer.autoClear
+      clearColor = overrideMaterial.clearColor || clearColor
+      clearAlpha = overrideMaterial.clearAlpha || clearAlpha
+      if (clearColor !== undefined && clearColor !== null) {
+        renderer.setClearColor(clearColor)
+        renderer.setClearAlpha(clearAlpha || 0.0)
+        renderer.clear()
+      }
 
-    renderer.setRenderTarget(renderTarget)
-    renderer.autoClear = false
+      this.scene.overrideMaterial = overrideMaterial
+      renderer.render(this.scene, this.camera)
+      this.scene.overrideMaterial = null
 
-    clearColor = overrideMaterial.clearColor || clearColor
-    clearAlpha = overrideMaterial.clearAlpha || clearAlpha
-    if (clearColor !== undefined && clearColor !== null) {
-      renderer.setClearColor(clearColor)
-      renderer.setClearAlpha(clearAlpha || 0.0)
-      renderer.clear()
+      // restore original state
+      renderer.autoClear = originalAutoClear
+      renderer.setClearColor(this.originalClearColor)
+      renderer.setClearAlpha(originalClearAlpha)
     }
 
-    this.scene.overrideMaterial = overrideMaterial
-    renderer.render(this.scene, this.camera)
-    this.scene.overrideMaterial = null
+    setSize(width, height) {
+      this.beautyRenderTarget.setSize(width, height)
+      this.saoRenderTarget.setSize(width, height)
+      this.blurIntermediateRenderTarget.setSize(width, height)
+      this.normalRenderTarget.setSize(width, height)
+      this.depthRenderTarget.setSize(width, height)
 
-    // restore original state
-    renderer.autoClear = originalAutoClear
-    renderer.setClearColor(this.originalClearColor)
-    renderer.setClearAlpha(originalClearAlpha)
-  }
-
-  setSize(width, height) {
-    this.beautyRenderTarget.setSize(width, height)
-    this.saoRenderTarget.setSize(width, height)
-    this.blurIntermediateRenderTarget.setSize(width, height)
-    this.normalRenderTarget.setSize(width, height)
-    this.depthRenderTarget.setSize(width, height)
+      this.saoMaterial.uniforms['size'].value.set(width, height)
+      this.saoMaterial.uniforms['cameraInverseProjectionMatrix'].value.copy(this.camera.projectionMatrixInverse)
+      this.saoMaterial.uniforms['cameraProjectionMatrix'].value = this.camera.projectionMatrix
+      this.saoMaterial.needsUpdate = true
 
-    this.saoMaterial.uniforms['size'].value.set(width, height)
-    this.saoMaterial.uniforms['cameraInverseProjectionMatrix'].value.copy(this.camera.projectionMatrixInverse)
-    this.saoMaterial.uniforms['cameraProjectionMatrix'].value = this.camera.projectionMatrix
-    this.saoMaterial.needsUpdate = true
+      this.vBlurMaterial.uniforms['size'].value.set(width, height)
+      this.vBlurMaterial.needsUpdate = true
 
-    this.vBlurMaterial.uniforms['size'].value.set(width, height)
-    this.vBlurMaterial.needsUpdate = true
+      this.hBlurMaterial.uniforms['size'].value.set(width, height)
+      this.hBlurMaterial.needsUpdate = true
+    }
 
-    this.hBlurMaterial.uniforms['size'].value.set(width, height)
-    this.hBlurMaterial.needsUpdate = true
+    dispose() {
+      this.saoRenderTarget.dispose()
+      this.blurIntermediateRenderTarget.dispose()
+      this.beautyRenderTarget.dispose()
+      this.normalRenderTarget.dispose()
+      this.depthRenderTarget.dispose()
+
+      this.depthMaterial.dispose()
+      this.normalMaterial.dispose()
+      this.saoMaterial.dispose()
+      this.vBlurMaterial.dispose()
+      this.hBlurMaterial.dispose()
+      this.materialCopy.dispose()
+      this.depthCopy.dispose()
+
+      this.fsQuad.dispose()
+    }
   }
 
-  dispose() {
-    this.saoRenderTarget.dispose()
-    this.blurIntermediateRenderTarget.dispose()
-    this.beautyRenderTarget.dispose()
-    this.normalRenderTarget.dispose()
-    this.depthRenderTarget.dispose()
-
-    this.depthMaterial.dispose()
-    this.normalMaterial.dispose()
-    this.saoMaterial.dispose()
-    this.vBlurMaterial.dispose()
-    this.hBlurMaterial.dispose()
-    this.materialCopy.dispose()
-    this.depthCopy.dispose()
-
-    this.fsQuad.dispose()
-  }
-}
+  return SAOPass
+})()
 
 export { SAOPass }
diff --git a/src/postprocessing/SSAOPass.js b/src/postprocessing/SSAOPass.js
index 52a5d0ed..1af8f82b 100644
--- a/src/postprocessing/SSAOPass.js
+++ b/src/postprocessing/SSAOPass.js
@@ -28,377 +28,381 @@ import { SSAOShader, SSAOBlurShader, SSAODepthShader } from '../shaders/SSAOShad
 
 import { CopyShader } from '../shaders/CopyShader'
 
-class SSAOPass extends Pass {
-  static OUTPUT = {
-    Default: 0,
-    SSAO: 1,
-    Blur: 2,
-    Beauty: 3,
-    Depth: 4,
-    Normal: 5,
-  }
+const SSAOPass = /* @__PURE__ */ (() => {
+  class SSAOPass extends Pass {
+    static OUTPUT = {
+      Default: 0,
+      SSAO: 1,
+      Blur: 2,
+      Beauty: 3,
+      Depth: 4,
+      Normal: 5,
+    }
 
-  constructor(scene, camera, width, height) {
-    super()
+    constructor(scene, camera, width, height) {
+      super()
 
-    this.width = width !== undefined ? width : 512
-    this.height = height !== undefined ? height : 512
+      this.width = width !== undefined ? width : 512
+      this.height = height !== undefined ? height : 512
 
-    this.clear = true
+      this.clear = true
 
-    this.camera = camera
-    this.scene = scene
+      this.camera = camera
+      this.scene = scene
 
-    this.kernelRadius = 8
-    this.kernelSize = 32
-    this.kernel = []
-    this.noiseTexture = null
-    this.output = 0
+      this.kernelRadius = 8
+      this.kernelSize = 32
+      this.kernel = []
+      this.noiseTexture = null
+      this.output = 0
 
-    this.minDistance = 0.005
-    this.maxDistance = 0.1
+      this.minDistance = 0.005
+      this.maxDistance = 0.1
 
-    this._visibilityCache = new Map()
+      this._visibilityCache = new Map()
 
-    //
+      //
 
-    this.generateSampleKernel()
-    this.generateRandomKernelRotations()
+      this.generateSampleKernel()
+      this.generateRandomKernelRotations()
 
-    // beauty render target
+      // beauty render target
 
-    const depthTexture = new DepthTexture()
-    depthTexture.format = DepthStencilFormat
-    depthTexture.type = UnsignedInt248Type
+      const depthTexture = new DepthTexture()
+      depthTexture.format = DepthStencilFormat
+      depthTexture.type = UnsignedInt248Type
 
-    this.beautyRenderTarget = new WebGLRenderTarget(this.width, this.height)
+      this.beautyRenderTarget = new WebGLRenderTarget(this.width, this.height)
 
-    // normal render target with depth buffer
+      // normal render target with depth buffer
 
-    this.normalRenderTarget = new WebGLRenderTarget(this.width, this.height, {
-      minFilter: NearestFilter,
-      magFilter: NearestFilter,
-      depthTexture: depthTexture,
-    })
+      this.normalRenderTarget = new WebGLRenderTarget(this.width, this.height, {
+        minFilter: NearestFilter,
+        magFilter: NearestFilter,
+        depthTexture: depthTexture,
+      })
 
-    // ssao render target
+      // ssao render target
 
-    this.ssaoRenderTarget = new WebGLRenderTarget(this.width, this.height)
+      this.ssaoRenderTarget = new WebGLRenderTarget(this.width, this.height)
 
-    this.blurRenderTarget = this.ssaoRenderTarget.clone()
+      this.blurRenderTarget = this.ssaoRenderTarget.clone()
 
-    // ssao material
+      // ssao material
 
-    if (SSAOShader === undefined) {
-      console.error('THREE.SSAOPass: The pass relies on SSAOShader.')
-    }
+      if (SSAOShader === undefined) {
+        console.error('THREE.SSAOPass: The pass relies on SSAOShader.')
+      }
 
-    this.ssaoMaterial = new ShaderMaterial({
-      defines: Object.assign({}, SSAOShader.defines),
-      uniforms: UniformsUtils.clone(SSAOShader.uniforms),
-      vertexShader: SSAOShader.vertexShader,
-      fragmentShader: SSAOShader.fragmentShader,
-      blending: NoBlending,
-    })
-
-    this.ssaoMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
-    this.ssaoMaterial.uniforms['tNormal'].value = this.normalRenderTarget.texture
-    this.ssaoMaterial.uniforms['tDepth'].value = this.normalRenderTarget.depthTexture
-    this.ssaoMaterial.uniforms['tNoise'].value = this.noiseTexture
-    this.ssaoMaterial.uniforms['kernel'].value = this.kernel
-    this.ssaoMaterial.uniforms['cameraNear'].value = this.camera.near
-    this.ssaoMaterial.uniforms['cameraFar'].value = this.camera.far
-    this.ssaoMaterial.uniforms['resolution'].value.set(this.width, this.height)
-    this.ssaoMaterial.uniforms['cameraProjectionMatrix'].value.copy(this.camera.projectionMatrix)
-    this.ssaoMaterial.uniforms['cameraInverseProjectionMatrix'].value.copy(this.camera.projectionMatrixInverse)
-
-    // normal material
-
-    this.normalMaterial = new MeshNormalMaterial()
-    this.normalMaterial.blending = NoBlending
-
-    // blur material
-
-    this.blurMaterial = new ShaderMaterial({
-      defines: Object.assign({}, SSAOBlurShader.defines),
-      uniforms: UniformsUtils.clone(SSAOBlurShader.uniforms),
-      vertexShader: SSAOBlurShader.vertexShader,
-      fragmentShader: SSAOBlurShader.fragmentShader,
-    })
-    this.blurMaterial.uniforms['tDiffuse'].value = this.ssaoRenderTarget.texture
-    this.blurMaterial.uniforms['resolution'].value.set(this.width, this.height)
-
-    // material for rendering the depth
-
-    this.depthRenderMaterial = new ShaderMaterial({
-      defines: Object.assign({}, SSAODepthShader.defines),
-      uniforms: UniformsUtils.clone(SSAODepthShader.uniforms),
-      vertexShader: SSAODepthShader.vertexShader,
-      fragmentShader: SSAODepthShader.fragmentShader,
-      blending: NoBlending,
-    })
-    this.depthRenderMaterial.uniforms['tDepth'].value = this.normalRenderTarget.depthTexture
-    this.depthRenderMaterial.uniforms['cameraNear'].value = this.camera.near
-    this.depthRenderMaterial.uniforms['cameraFar'].value = this.camera.far
-
-    // material for rendering the content of a render target
-
-    this.copyMaterial = new ShaderMaterial({
-      uniforms: UniformsUtils.clone(CopyShader.uniforms),
-      vertexShader: CopyShader.vertexShader,
-      fragmentShader: CopyShader.fragmentShader,
-      transparent: true,
-      depthTest: false,
-      depthWrite: false,
-      blendSrc: DstColorFactor,
-      blendDst: ZeroFactor,
-      blendEquation: AddEquation,
-      blendSrcAlpha: DstAlphaFactor,
-      blendDstAlpha: ZeroFactor,
-      blendEquationAlpha: AddEquation,
-    })
-
-    this.fsQuad = new FullScreenQuad(null)
-
-    this.originalClearColor = new Color()
-  }
+      this.ssaoMaterial = new ShaderMaterial({
+        defines: Object.assign({}, SSAOShader.defines),
+        uniforms: UniformsUtils.clone(SSAOShader.uniforms),
+        vertexShader: SSAOShader.vertexShader,
+        fragmentShader: SSAOShader.fragmentShader,
+        blending: NoBlending,
+      })
 
-  dispose() {
-    // dispose render targets
+      this.ssaoMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
+      this.ssaoMaterial.uniforms['tNormal'].value = this.normalRenderTarget.texture
+      this.ssaoMaterial.uniforms['tDepth'].value = this.normalRenderTarget.depthTexture
+      this.ssaoMaterial.uniforms['tNoise'].value = this.noiseTexture
+      this.ssaoMaterial.uniforms['kernel'].value = this.kernel
+      this.ssaoMaterial.uniforms['cameraNear'].value = this.camera.near
+      this.ssaoMaterial.uniforms['cameraFar'].value = this.camera.far
+      this.ssaoMaterial.uniforms['resolution'].value.set(this.width, this.height)
+      this.ssaoMaterial.uniforms['cameraProjectionMatrix'].value.copy(this.camera.projectionMatrix)
+      this.ssaoMaterial.uniforms['cameraInverseProjectionMatrix'].value.copy(this.camera.projectionMatrixInverse)
 
-    this.beautyRenderTarget.dispose()
-    this.normalRenderTarget.dispose()
-    this.ssaoRenderTarget.dispose()
-    this.blurRenderTarget.dispose()
+      // normal material
 
-    // dispose materials
+      this.normalMaterial = new MeshNormalMaterial()
+      this.normalMaterial.blending = NoBlending
 
-    this.normalMaterial.dispose()
-    this.blurMaterial.dispose()
-    this.copyMaterial.dispose()
-    this.depthRenderMaterial.dispose()
+      // blur material
 
-    // dipsose full screen quad
+      this.blurMaterial = new ShaderMaterial({
+        defines: Object.assign({}, SSAOBlurShader.defines),
+        uniforms: UniformsUtils.clone(SSAOBlurShader.uniforms),
+        vertexShader: SSAOBlurShader.vertexShader,
+        fragmentShader: SSAOBlurShader.fragmentShader,
+      })
+      this.blurMaterial.uniforms['tDiffuse'].value = this.ssaoRenderTarget.texture
+      this.blurMaterial.uniforms['resolution'].value.set(this.width, this.height)
 
-    this.fsQuad.dispose()
-  }
+      // material for rendering the depth
 
-  render(renderer, writeBuffer /*, readBuffer, deltaTime, maskActive */) {
-    if (renderer.capabilities.isWebGL2 === false) this.noiseTexture.format = LuminanceFormat
+      this.depthRenderMaterial = new ShaderMaterial({
+        defines: Object.assign({}, SSAODepthShader.defines),
+        uniforms: UniformsUtils.clone(SSAODepthShader.uniforms),
+        vertexShader: SSAODepthShader.vertexShader,
+        fragmentShader: SSAODepthShader.fragmentShader,
+        blending: NoBlending,
+      })
+      this.depthRenderMaterial.uniforms['tDepth'].value = this.normalRenderTarget.depthTexture
+      this.depthRenderMaterial.uniforms['cameraNear'].value = this.camera.near
+      this.depthRenderMaterial.uniforms['cameraFar'].value = this.camera.far
 
-    // render beauty
+      // material for rendering the content of a render target
 
-    renderer.setRenderTarget(this.beautyRenderTarget)
-    renderer.clear()
-    renderer.render(this.scene, this.camera)
+      this.copyMaterial = new ShaderMaterial({
+        uniforms: UniformsUtils.clone(CopyShader.uniforms),
+        vertexShader: CopyShader.vertexShader,
+        fragmentShader: CopyShader.fragmentShader,
+        transparent: true,
+        depthTest: false,
+        depthWrite: false,
+        blendSrc: DstColorFactor,
+        blendDst: ZeroFactor,
+        blendEquation: AddEquation,
+        blendSrcAlpha: DstAlphaFactor,
+        blendDstAlpha: ZeroFactor,
+        blendEquationAlpha: AddEquation,
+      })
+
+      this.fsQuad = new FullScreenQuad(null)
+
+      this.originalClearColor = new Color()
+    }
 
-    // render normals and depth (honor only meshes, points and lines do not contribute to SSAO)
+    dispose() {
+      // dispose render targets
 
-    this.overrideVisibility()
-    this.renderOverride(renderer, this.normalMaterial, this.normalRenderTarget, 0x7777ff, 1.0)
-    this.restoreVisibility()
+      this.beautyRenderTarget.dispose()
+      this.normalRenderTarget.dispose()
+      this.ssaoRenderTarget.dispose()
+      this.blurRenderTarget.dispose()
 
-    // render SSAO
+      // dispose materials
 
-    this.ssaoMaterial.uniforms['kernelRadius'].value = this.kernelRadius
-    this.ssaoMaterial.uniforms['minDistance'].value = this.minDistance
-    this.ssaoMaterial.uniforms['maxDistance'].value = this.maxDistance
-    this.renderPass(renderer, this.ssaoMaterial, this.ssaoRenderTarget)
+      this.normalMaterial.dispose()
+      this.blurMaterial.dispose()
+      this.copyMaterial.dispose()
+      this.depthRenderMaterial.dispose()
 
-    // render blur
+      // dipsose full screen quad
 
-    this.renderPass(renderer, this.blurMaterial, this.blurRenderTarget)
+      this.fsQuad.dispose()
+    }
 
-    // output result to screen
+    render(renderer, writeBuffer /*, readBuffer, deltaTime, maskActive */) {
+      if (renderer.capabilities.isWebGL2 === false) this.noiseTexture.format = LuminanceFormat
 
-    switch (this.output) {
-      case SSAOPass.OUTPUT.SSAO:
-        this.copyMaterial.uniforms['tDiffuse'].value = this.ssaoRenderTarget.texture
-        this.copyMaterial.blending = NoBlending
-        this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
+      // render beauty
 
-        break
+      renderer.setRenderTarget(this.beautyRenderTarget)
+      renderer.clear()
+      renderer.render(this.scene, this.camera)
 
-      case SSAOPass.OUTPUT.Blur:
-        this.copyMaterial.uniforms['tDiffuse'].value = this.blurRenderTarget.texture
-        this.copyMaterial.blending = NoBlending
-        this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
+      // render normals and depth (honor only meshes, points and lines do not contribute to SSAO)
 
-        break
+      this.overrideVisibility()
+      this.renderOverride(renderer, this.normalMaterial, this.normalRenderTarget, 0x7777ff, 1.0)
+      this.restoreVisibility()
 
-      case SSAOPass.OUTPUT.Beauty:
-        this.copyMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
-        this.copyMaterial.blending = NoBlending
-        this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
+      // render SSAO
 
-        break
+      this.ssaoMaterial.uniforms['kernelRadius'].value = this.kernelRadius
+      this.ssaoMaterial.uniforms['minDistance'].value = this.minDistance
+      this.ssaoMaterial.uniforms['maxDistance'].value = this.maxDistance
+      this.renderPass(renderer, this.ssaoMaterial, this.ssaoRenderTarget)
 
-      case SSAOPass.OUTPUT.Depth:
-        this.renderPass(renderer, this.depthRenderMaterial, this.renderToScreen ? null : writeBuffer)
+      // render blur
 
-        break
+      this.renderPass(renderer, this.blurMaterial, this.blurRenderTarget)
 
-      case SSAOPass.OUTPUT.Normal:
-        this.copyMaterial.uniforms['tDiffuse'].value = this.normalRenderTarget.texture
-        this.copyMaterial.blending = NoBlending
-        this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
+      // output result to screen
 
-        break
+      switch (this.output) {
+        case SSAOPass.OUTPUT.SSAO:
+          this.copyMaterial.uniforms['tDiffuse'].value = this.ssaoRenderTarget.texture
+          this.copyMaterial.blending = NoBlending
+          this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
 
-      case SSAOPass.OUTPUT.Default:
-        this.copyMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
-        this.copyMaterial.blending = NoBlending
-        this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
+          break
 
-        this.copyMaterial.uniforms['tDiffuse'].value = this.blurRenderTarget.texture
-        this.copyMaterial.blending = CustomBlending
-        this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
+        case SSAOPass.OUTPUT.Blur:
+          this.copyMaterial.uniforms['tDiffuse'].value = this.blurRenderTarget.texture
+          this.copyMaterial.blending = NoBlending
+          this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
 
-        break
+          break
 
-      default:
-        console.warn('THREE.SSAOPass: Unknown output type.')
-    }
-  }
+        case SSAOPass.OUTPUT.Beauty:
+          this.copyMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
+          this.copyMaterial.blending = NoBlending
+          this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
 
-  renderPass(renderer, passMaterial, renderTarget, clearColor, clearAlpha) {
-    // save original state
-    renderer.getClearColor(this.originalClearColor)
-    const originalClearAlpha = renderer.getClearAlpha()
-    const originalAutoClear = renderer.autoClear
+          break
 
-    renderer.setRenderTarget(renderTarget)
+        case SSAOPass.OUTPUT.Depth:
+          this.renderPass(renderer, this.depthRenderMaterial, this.renderToScreen ? null : writeBuffer)
 
-    // setup pass state
-    renderer.autoClear = false
-    if (clearColor !== undefined && clearColor !== null) {
-      renderer.setClearColor(clearColor)
-      renderer.setClearAlpha(clearAlpha || 0.0)
-      renderer.clear()
-    }
+          break
 
-    this.fsQuad.material = passMaterial
-    this.fsQuad.render(renderer)
+        case SSAOPass.OUTPUT.Normal:
+          this.copyMaterial.uniforms['tDiffuse'].value = this.normalRenderTarget.texture
+          this.copyMaterial.blending = NoBlending
+          this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
 
-    // restore original state
-    renderer.autoClear = originalAutoClear
-    renderer.setClearColor(this.originalClearColor)
-    renderer.setClearAlpha(originalClearAlpha)
-  }
+          break
 
-  renderOverride(renderer, overrideMaterial, renderTarget, clearColor, clearAlpha) {
-    renderer.getClearColor(this.originalClearColor)
-    const originalClearAlpha = renderer.getClearAlpha()
-    const originalAutoClear = renderer.autoClear
+        case SSAOPass.OUTPUT.Default:
+          this.copyMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
+          this.copyMaterial.blending = NoBlending
+          this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
 
-    renderer.setRenderTarget(renderTarget)
-    renderer.autoClear = false
+          this.copyMaterial.uniforms['tDiffuse'].value = this.blurRenderTarget.texture
+          this.copyMaterial.blending = CustomBlending
+          this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
 
-    clearColor = overrideMaterial.clearColor || clearColor
-    clearAlpha = overrideMaterial.clearAlpha || clearAlpha
+          break
 
-    if (clearColor !== undefined && clearColor !== null) {
-      renderer.setClearColor(clearColor)
-      renderer.setClearAlpha(clearAlpha || 0.0)
-      renderer.clear()
+        default:
+          console.warn('THREE.SSAOPass: Unknown output type.')
+      }
     }
 
-    this.scene.overrideMaterial = overrideMaterial
-    renderer.render(this.scene, this.camera)
-    this.scene.overrideMaterial = null
+    renderPass(renderer, passMaterial, renderTarget, clearColor, clearAlpha) {
+      // save original state
+      renderer.getClearColor(this.originalClearColor)
+      const originalClearAlpha = renderer.getClearAlpha()
+      const originalAutoClear = renderer.autoClear
+
+      renderer.setRenderTarget(renderTarget)
+
+      // setup pass state
+      renderer.autoClear = false
+      if (clearColor !== undefined && clearColor !== null) {
+        renderer.setClearColor(clearColor)
+        renderer.setClearAlpha(clearAlpha || 0.0)
+        renderer.clear()
+      }
+
+      this.fsQuad.material = passMaterial
+      this.fsQuad.render(renderer)
+
+      // restore original state
+      renderer.autoClear = originalAutoClear
+      renderer.setClearColor(this.originalClearColor)
+      renderer.setClearAlpha(originalClearAlpha)
+    }
 
-    // restore original state
+    renderOverride(renderer, overrideMaterial, renderTarget, clearColor, clearAlpha) {
+      renderer.getClearColor(this.originalClearColor)
+      const originalClearAlpha = renderer.getClearAlpha()
+      const originalAutoClear = renderer.autoClear
 
-    renderer.autoClear = originalAutoClear
-    renderer.setClearColor(this.originalClearColor)
-    renderer.setClearAlpha(originalClearAlpha)
-  }
+      renderer.setRenderTarget(renderTarget)
+      renderer.autoClear = false
 
-  setSize(width, height) {
-    this.width = width
-    this.height = height
+      clearColor = overrideMaterial.clearColor || clearColor
+      clearAlpha = overrideMaterial.clearAlpha || clearAlpha
 
-    this.beautyRenderTarget.setSize(width, height)
-    this.ssaoRenderTarget.setSize(width, height)
-    this.normalRenderTarget.setSize(width, height)
-    this.blurRenderTarget.setSize(width, height)
+      if (clearColor !== undefined && clearColor !== null) {
+        renderer.setClearColor(clearColor)
+        renderer.setClearAlpha(clearAlpha || 0.0)
+        renderer.clear()
+      }
 
-    this.ssaoMaterial.uniforms['resolution'].value.set(width, height)
-    this.ssaoMaterial.uniforms['cameraProjectionMatrix'].value.copy(this.camera.projectionMatrix)
-    this.ssaoMaterial.uniforms['cameraInverseProjectionMatrix'].value.copy(this.camera.projectionMatrixInverse)
+      this.scene.overrideMaterial = overrideMaterial
+      renderer.render(this.scene, this.camera)
+      this.scene.overrideMaterial = null
 
-    this.blurMaterial.uniforms['resolution'].value.set(width, height)
-  }
+      // restore original state
 
-  generateSampleKernel() {
-    const kernelSize = this.kernelSize
-    const kernel = this.kernel
+      renderer.autoClear = originalAutoClear
+      renderer.setClearColor(this.originalClearColor)
+      renderer.setClearAlpha(originalClearAlpha)
+    }
 
-    for (let i = 0; i < kernelSize; i++) {
-      const sample = new Vector3()
-      sample.x = Math.random() * 2 - 1
-      sample.y = Math.random() * 2 - 1
-      sample.z = Math.random()
+    setSize(width, height) {
+      this.width = width
+      this.height = height
 
-      sample.normalize()
+      this.beautyRenderTarget.setSize(width, height)
+      this.ssaoRenderTarget.setSize(width, height)
+      this.normalRenderTarget.setSize(width, height)
+      this.blurRenderTarget.setSize(width, height)
 
-      let scale = i / kernelSize
-      scale = MathUtils.lerp(0.1, 1, scale * scale)
-      sample.multiplyScalar(scale)
+      this.ssaoMaterial.uniforms['resolution'].value.set(width, height)
+      this.ssaoMaterial.uniforms['cameraProjectionMatrix'].value.copy(this.camera.projectionMatrix)
+      this.ssaoMaterial.uniforms['cameraInverseProjectionMatrix'].value.copy(this.camera.projectionMatrixInverse)
 
-      kernel.push(sample)
+      this.blurMaterial.uniforms['resolution'].value.set(width, height)
     }
-  }
 
-  generateRandomKernelRotations() {
-    const width = 4,
-      height = 4
+    generateSampleKernel() {
+      const kernelSize = this.kernelSize
+      const kernel = this.kernel
+
+      for (let i = 0; i < kernelSize; i++) {
+        const sample = new Vector3()
+        sample.x = Math.random() * 2 - 1
+        sample.y = Math.random() * 2 - 1
+        sample.z = Math.random()
 
-    if (SimplexNoise === undefined) {
-      console.error('THREE.SSAOPass: The pass relies on SimplexNoise.')
+        sample.normalize()
+
+        let scale = i / kernelSize
+        scale = MathUtils.lerp(0.1, 1, scale * scale)
+        sample.multiplyScalar(scale)
+
+        kernel.push(sample)
+      }
     }
 
-    const simplex = new SimplexNoise()
+    generateRandomKernelRotations() {
+      const width = 4,
+        height = 4
 
-    const size = width * height
-    const data = new Float32Array(size)
+      if (SimplexNoise === undefined) {
+        console.error('THREE.SSAOPass: The pass relies on SimplexNoise.')
+      }
 
-    for (let i = 0; i < size; i++) {
-      const x = Math.random() * 2 - 1
-      const y = Math.random() * 2 - 1
-      const z = 0
+      const simplex = new SimplexNoise()
 
-      data[i] = simplex.noise3d(x, y, z)
-    }
+      const size = width * height
+      const data = new Float32Array(size)
 
-    this.noiseTexture = new DataTexture(data, width, height, RedFormat, FloatType)
-    this.noiseTexture.wrapS = RepeatWrapping
-    this.noiseTexture.wrapT = RepeatWrapping
-    this.noiseTexture.needsUpdate = true
-  }
+      for (let i = 0; i < size; i++) {
+        const x = Math.random() * 2 - 1
+        const y = Math.random() * 2 - 1
+        const z = 0
 
-  overrideVisibility() {
-    const scene = this.scene
-    const cache = this._visibilityCache
+        data[i] = simplex.noise3d(x, y, z)
+      }
 
-    scene.traverse(function (object) {
-      cache.set(object, object.visible)
+      this.noiseTexture = new DataTexture(data, width, height, RedFormat, FloatType)
+      this.noiseTexture.wrapS = RepeatWrapping
+      this.noiseTexture.wrapT = RepeatWrapping
+      this.noiseTexture.needsUpdate = true
+    }
 
-      if (object.isPoints || object.isLine) object.visible = false
-    })
-  }
+    overrideVisibility() {
+      const scene = this.scene
+      const cache = this._visibilityCache
 
-  restoreVisibility() {
-    const scene = this.scene
-    const cache = this._visibilityCache
+      scene.traverse(function (object) {
+        cache.set(object, object.visible)
+
+        if (object.isPoints || object.isLine) object.visible = false
+      })
+    }
 
-    scene.traverse(function (object) {
-      const visible = cache.get(object)
-      object.visible = visible
-    })
+    restoreVisibility() {
+      const scene = this.scene
+      const cache = this._visibilityCache
 
-    cache.clear()
+      scene.traverse(function (object) {
+        const visible = cache.get(object)
+        object.visible = visible
+      })
+
+      cache.clear()
+    }
   }
-}
+
+  return SSAOPass
+})()
 
 export { SSAOPass }
diff --git a/src/postprocessing/SSRPass.js b/src/postprocessing/SSRPass.js
index c46038c5..b4e54852 100644
--- a/src/postprocessing/SSRPass.js
+++ b/src/postprocessing/SSRPass.js
@@ -21,530 +21,534 @@ import { SSRBlurShader } from '../shaders/SSRShader'
 import { SSRDepthShader } from '../shaders/SSRShader'
 import { CopyShader } from '../shaders/CopyShader'
 
-class SSRPass extends Pass {
-  static OUTPUT = {
-    Default: 0,
-    SSR: 1,
-    Beauty: 3,
-    Depth: 4,
-    Normal: 5,
-    Metalness: 7,
-  }
-  constructor({ renderer, scene, camera, width, height, selects, bouncing = false, groundReflector }) {
-    super()
-
-    this.width = width !== undefined ? width : 512
-    this.height = height !== undefined ? height : 512
-
-    this.clear = true
-
-    this.renderer = renderer
-    this.scene = scene
-    this.camera = camera
-    this.groundReflector = groundReflector
-
-    this.opacity = SSRShader.uniforms.opacity.value
-    this.output = 0
-
-    this.maxDistance = SSRShader.uniforms.maxDistance.value
-    this.thickness = SSRShader.uniforms.thickness.value
-
-    this.tempColor = new Color()
-
-    this._selects = selects
-    this.selective = Array.isArray(this._selects)
-    Object.defineProperty(this, 'selects', {
-      get() {
-        return this._selects
-      },
-      set(val) {
-        if (this._selects === val) return
-        this._selects = val
-        if (Array.isArray(val)) {
-          this.selective = true
-          this.ssrMaterial.defines.SELECTIVE = true
+const SSRPass = /* @__PURE__ */ (() => {
+  class SSRPass extends Pass {
+    static OUTPUT = {
+      Default: 0,
+      SSR: 1,
+      Beauty: 3,
+      Depth: 4,
+      Normal: 5,
+      Metalness: 7,
+    }
+    constructor({ renderer, scene, camera, width, height, selects, bouncing = false, groundReflector }) {
+      super()
+
+      this.width = width !== undefined ? width : 512
+      this.height = height !== undefined ? height : 512
+
+      this.clear = true
+
+      this.renderer = renderer
+      this.scene = scene
+      this.camera = camera
+      this.groundReflector = groundReflector
+
+      this.opacity = SSRShader.uniforms.opacity.value
+      this.output = 0
+
+      this.maxDistance = SSRShader.uniforms.maxDistance.value
+      this.thickness = SSRShader.uniforms.thickness.value
+
+      this.tempColor = new Color()
+
+      this._selects = selects
+      this.selective = Array.isArray(this._selects)
+      Object.defineProperty(this, 'selects', {
+        get() {
+          return this._selects
+        },
+        set(val) {
+          if (this._selects === val) return
+          this._selects = val
+          if (Array.isArray(val)) {
+            this.selective = true
+            this.ssrMaterial.defines.SELECTIVE = true
+            this.ssrMaterial.needsUpdate = true
+          } else {
+            this.selective = false
+            this.ssrMaterial.defines.SELECTIVE = false
+            this.ssrMaterial.needsUpdate = true
+          }
+        },
+      })
+
+      this._bouncing = bouncing
+      Object.defineProperty(this, 'bouncing', {
+        get() {
+          return this._bouncing
+        },
+        set(val) {
+          if (this._bouncing === val) return
+          this._bouncing = val
+          if (val) {
+            this.ssrMaterial.uniforms['tDiffuse'].value = this.prevRenderTarget.texture
+          } else {
+            this.ssrMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
+          }
+        },
+      })
+
+      this.blur = true
+
+      this._distanceAttenuation = SSRShader.defines.DISTANCE_ATTENUATION
+      Object.defineProperty(this, 'distanceAttenuation', {
+        get() {
+          return this._distanceAttenuation
+        },
+        set(val) {
+          if (this._distanceAttenuation === val) return
+          this._distanceAttenuation = val
+          this.ssrMaterial.defines.DISTANCE_ATTENUATION = val
           this.ssrMaterial.needsUpdate = true
-        } else {
-          this.selective = false
-          this.ssrMaterial.defines.SELECTIVE = false
+        },
+      })
+
+      this._fresnel = SSRShader.defines.FRESNEL
+      Object.defineProperty(this, 'fresnel', {
+        get() {
+          return this._fresnel
+        },
+        set(val) {
+          if (this._fresnel === val) return
+          this._fresnel = val
+          this.ssrMaterial.defines.FRESNEL = val
           this.ssrMaterial.needsUpdate = true
-        }
-      },
-    })
-
-    this._bouncing = bouncing
-    Object.defineProperty(this, 'bouncing', {
-      get() {
-        return this._bouncing
-      },
-      set(val) {
-        if (this._bouncing === val) return
-        this._bouncing = val
-        if (val) {
-          this.ssrMaterial.uniforms['tDiffuse'].value = this.prevRenderTarget.texture
-        } else {
-          this.ssrMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
-        }
-      },
-    })
-
-    this.blur = true
-
-    this._distanceAttenuation = SSRShader.defines.DISTANCE_ATTENUATION
-    Object.defineProperty(this, 'distanceAttenuation', {
-      get() {
-        return this._distanceAttenuation
-      },
-      set(val) {
-        if (this._distanceAttenuation === val) return
-        this._distanceAttenuation = val
-        this.ssrMaterial.defines.DISTANCE_ATTENUATION = val
-        this.ssrMaterial.needsUpdate = true
-      },
-    })
-
-    this._fresnel = SSRShader.defines.FRESNEL
-    Object.defineProperty(this, 'fresnel', {
-      get() {
-        return this._fresnel
-      },
-      set(val) {
-        if (this._fresnel === val) return
-        this._fresnel = val
-        this.ssrMaterial.defines.FRESNEL = val
-        this.ssrMaterial.needsUpdate = true
-      },
-    })
-
-    this._infiniteThick = SSRShader.defines.INFINITE_THICK
-    Object.defineProperty(this, 'infiniteThick', {
-      get() {
-        return this._infiniteThick
-      },
-      set(val) {
-        if (this._infiniteThick === val) return
-        this._infiniteThick = val
-        this.ssrMaterial.defines.INFINITE_THICK = val
-        this.ssrMaterial.needsUpdate = true
-      },
-    })
-
-    // beauty render target with depth buffer
-
-    const depthTexture = new DepthTexture()
-    depthTexture.type = UnsignedShortType
-    depthTexture.minFilter = NearestFilter
-    depthTexture.magFilter = NearestFilter
-
-    this.beautyRenderTarget = new WebGLRenderTarget(this.width, this.height, {
-      minFilter: NearestFilter,
-      magFilter: NearestFilter,
-      type: HalfFloatType,
-      depthTexture: depthTexture,
-      depthBuffer: true,
-    })
-
-    //for bouncing
-    this.prevRenderTarget = new WebGLRenderTarget(this.width, this.height, {
-      minFilter: NearestFilter,
-      magFilter: NearestFilter,
-    })
-
-    // normal render target
-
-    this.normalRenderTarget = new WebGLRenderTarget(this.width, this.height, {
-      minFilter: NearestFilter,
-      magFilter: NearestFilter,
-      type: HalfFloatType,
-    })
-
-    // metalness render target
-
-    this.metalnessRenderTarget = new WebGLRenderTarget(this.width, this.height, {
-      minFilter: NearestFilter,
-      magFilter: NearestFilter,
-      type: HalfFloatType,
-    })
-
-    // ssr render target
-
-    this.ssrRenderTarget = new WebGLRenderTarget(this.width, this.height, {
-      minFilter: NearestFilter,
-      magFilter: NearestFilter,
-    })
-
-    this.blurRenderTarget = this.ssrRenderTarget.clone()
-    this.blurRenderTarget2 = this.ssrRenderTarget.clone()
-    // this.blurRenderTarget3 = this.ssrRenderTarget.clone();
-
-    // ssr material
-
-    this.ssrMaterial = new ShaderMaterial({
-      defines: Object.assign({}, SSRShader.defines, {
-        MAX_STEP: Math.sqrt(this.width * this.width + this.height * this.height),
-      }),
-      uniforms: UniformsUtils.clone(SSRShader.uniforms),
-      vertexShader: SSRShader.vertexShader,
-      fragmentShader: SSRShader.fragmentShader,
-      blending: NoBlending,
-    })
-
-    this.ssrMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
-    this.ssrMaterial.uniforms['tNormal'].value = this.normalRenderTarget.texture
-    this.ssrMaterial.defines.SELECTIVE = this.selective
-    this.ssrMaterial.needsUpdate = true
-    this.ssrMaterial.uniforms['tMetalness'].value = this.metalnessRenderTarget.texture
-    this.ssrMaterial.uniforms['tDepth'].value = this.beautyRenderTarget.depthTexture
-    this.ssrMaterial.uniforms['cameraNear'].value = this.camera.near
-    this.ssrMaterial.uniforms['cameraFar'].value = this.camera.far
-    this.ssrMaterial.uniforms['thickness'].value = this.thickness
-    this.ssrMaterial.uniforms['resolution'].value.set(this.width, this.height)
-    this.ssrMaterial.uniforms['cameraProjectionMatrix'].value.copy(this.camera.projectionMatrix)
-    this.ssrMaterial.uniforms['cameraInverseProjectionMatrix'].value.copy(this.camera.projectionMatrixInverse)
-
-    // normal material
-
-    this.normalMaterial = new MeshNormalMaterial()
-    this.normalMaterial.blending = NoBlending
-
-    // metalnessOn material
-
-    this.metalnessOnMaterial = new MeshBasicMaterial({
-      color: 'white',
-    })
-
-    // metalnessOff material
-
-    this.metalnessOffMaterial = new MeshBasicMaterial({
-      color: 'black',
-    })
-
-    // blur material
-
-    this.blurMaterial = new ShaderMaterial({
-      defines: Object.assign({}, SSRBlurShader.defines),
-      uniforms: UniformsUtils.clone(SSRBlurShader.uniforms),
-      vertexShader: SSRBlurShader.vertexShader,
-      fragmentShader: SSRBlurShader.fragmentShader,
-    })
-    this.blurMaterial.uniforms['tDiffuse'].value = this.ssrRenderTarget.texture
-    this.blurMaterial.uniforms['resolution'].value.set(this.width, this.height)
-
-    // blur material 2
-
-    this.blurMaterial2 = new ShaderMaterial({
-      defines: Object.assign({}, SSRBlurShader.defines),
-      uniforms: UniformsUtils.clone(SSRBlurShader.uniforms),
-      vertexShader: SSRBlurShader.vertexShader,
-      fragmentShader: SSRBlurShader.fragmentShader,
-    })
-    this.blurMaterial2.uniforms['tDiffuse'].value = this.blurRenderTarget.texture
-    this.blurMaterial2.uniforms['resolution'].value.set(this.width, this.height)
-
-    // // blur material 3
-
-    // this.blurMaterial3 = new ShaderMaterial({
-    //   defines: Object.assign({}, SSRBlurShader.defines),
-    //   uniforms: UniformsUtils.clone(SSRBlurShader.uniforms),
-    //   vertexShader: SSRBlurShader.vertexShader,
-    //   fragmentShader: SSRBlurShader.fragmentShader
-    // });
-    // this.blurMaterial3.uniforms['tDiffuse'].value = this.blurRenderTarget2.texture;
-    // this.blurMaterial3.uniforms['resolution'].value.set(this.width, this.height);
-
-    // material for rendering the depth
-
-    this.depthRenderMaterial = new ShaderMaterial({
-      defines: Object.assign({}, SSRDepthShader.defines),
-      uniforms: UniformsUtils.clone(SSRDepthShader.uniforms),
-      vertexShader: SSRDepthShader.vertexShader,
-      fragmentShader: SSRDepthShader.fragmentShader,
-      blending: NoBlending,
-    })
-    this.depthRenderMaterial.uniforms['tDepth'].value = this.beautyRenderTarget.depthTexture
-    this.depthRenderMaterial.uniforms['cameraNear'].value = this.camera.near
-    this.depthRenderMaterial.uniforms['cameraFar'].value = this.camera.far
-
-    // material for rendering the content of a render target
-
-    this.copyMaterial = new ShaderMaterial({
-      uniforms: UniformsUtils.clone(CopyShader.uniforms),
-      vertexShader: CopyShader.vertexShader,
-      fragmentShader: CopyShader.fragmentShader,
-      transparent: true,
-      depthTest: false,
-      depthWrite: false,
-      blendSrc: SrcAlphaFactor,
-      blendDst: OneMinusSrcAlphaFactor,
-      blendEquation: AddEquation,
-      blendSrcAlpha: SrcAlphaFactor,
-      blendDstAlpha: OneMinusSrcAlphaFactor,
-      blendEquationAlpha: AddEquation,
-      // premultipliedAlpha:true,
-    })
-
-    this.fsQuad = new FullScreenQuad(null)
-
-    this.originalClearColor = new Color()
-  }
-
-  dispose() {
-    // dispose render targets
-
-    this.beautyRenderTarget.dispose()
-    this.prevRenderTarget.dispose()
-    this.normalRenderTarget.dispose()
-    this.metalnessRenderTarget.dispose()
-    this.ssrRenderTarget.dispose()
-    this.blurRenderTarget.dispose()
-    this.blurRenderTarget2.dispose()
-    // this.blurRenderTarget3.dispose();
+        },
+      })
+
+      this._infiniteThick = SSRShader.defines.INFINITE_THICK
+      Object.defineProperty(this, 'infiniteThick', {
+        get() {
+          return this._infiniteThick
+        },
+        set(val) {
+          if (this._infiniteThick === val) return
+          this._infiniteThick = val
+          this.ssrMaterial.defines.INFINITE_THICK = val
+          this.ssrMaterial.needsUpdate = true
+        },
+      })
+
+      // beauty render target with depth buffer
+
+      const depthTexture = new DepthTexture()
+      depthTexture.type = UnsignedShortType
+      depthTexture.minFilter = NearestFilter
+      depthTexture.magFilter = NearestFilter
+
+      this.beautyRenderTarget = new WebGLRenderTarget(this.width, this.height, {
+        minFilter: NearestFilter,
+        magFilter: NearestFilter,
+        type: HalfFloatType,
+        depthTexture: depthTexture,
+        depthBuffer: true,
+      })
+
+      //for bouncing
+      this.prevRenderTarget = new WebGLRenderTarget(this.width, this.height, {
+        minFilter: NearestFilter,
+        magFilter: NearestFilter,
+      })
+
+      // normal render target
+
+      this.normalRenderTarget = new WebGLRenderTarget(this.width, this.height, {
+        minFilter: NearestFilter,
+        magFilter: NearestFilter,
+        type: HalfFloatType,
+      })
+
+      // metalness render target
+
+      this.metalnessRenderTarget = new WebGLRenderTarget(this.width, this.height, {
+        minFilter: NearestFilter,
+        magFilter: NearestFilter,
+        type: HalfFloatType,
+      })
+
+      // ssr render target
+
+      this.ssrRenderTarget = new WebGLRenderTarget(this.width, this.height, {
+        minFilter: NearestFilter,
+        magFilter: NearestFilter,
+      })
+
+      this.blurRenderTarget = this.ssrRenderTarget.clone()
+      this.blurRenderTarget2 = this.ssrRenderTarget.clone()
+      // this.blurRenderTarget3 = this.ssrRenderTarget.clone();
+
+      // ssr material
+
+      this.ssrMaterial = new ShaderMaterial({
+        defines: Object.assign({}, SSRShader.defines, {
+          MAX_STEP: Math.sqrt(this.width * this.width + this.height * this.height),
+        }),
+        uniforms: UniformsUtils.clone(SSRShader.uniforms),
+        vertexShader: SSRShader.vertexShader,
+        fragmentShader: SSRShader.fragmentShader,
+        blending: NoBlending,
+      })
+
+      this.ssrMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
+      this.ssrMaterial.uniforms['tNormal'].value = this.normalRenderTarget.texture
+      this.ssrMaterial.defines.SELECTIVE = this.selective
+      this.ssrMaterial.needsUpdate = true
+      this.ssrMaterial.uniforms['tMetalness'].value = this.metalnessRenderTarget.texture
+      this.ssrMaterial.uniforms['tDepth'].value = this.beautyRenderTarget.depthTexture
+      this.ssrMaterial.uniforms['cameraNear'].value = this.camera.near
+      this.ssrMaterial.uniforms['cameraFar'].value = this.camera.far
+      this.ssrMaterial.uniforms['thickness'].value = this.thickness
+      this.ssrMaterial.uniforms['resolution'].value.set(this.width, this.height)
+      this.ssrMaterial.uniforms['cameraProjectionMatrix'].value.copy(this.camera.projectionMatrix)
+      this.ssrMaterial.uniforms['cameraInverseProjectionMatrix'].value.copy(this.camera.projectionMatrixInverse)
+
+      // normal material
+
+      this.normalMaterial = new MeshNormalMaterial()
+      this.normalMaterial.blending = NoBlending
+
+      // metalnessOn material
+
+      this.metalnessOnMaterial = new MeshBasicMaterial({
+        color: 'white',
+      })
+
+      // metalnessOff material
+
+      this.metalnessOffMaterial = new MeshBasicMaterial({
+        color: 'black',
+      })
+
+      // blur material
+
+      this.blurMaterial = new ShaderMaterial({
+        defines: Object.assign({}, SSRBlurShader.defines),
+        uniforms: UniformsUtils.clone(SSRBlurShader.uniforms),
+        vertexShader: SSRBlurShader.vertexShader,
+        fragmentShader: SSRBlurShader.fragmentShader,
+      })
+      this.blurMaterial.uniforms['tDiffuse'].value = this.ssrRenderTarget.texture
+      this.blurMaterial.uniforms['resolution'].value.set(this.width, this.height)
+
+      // blur material 2
+
+      this.blurMaterial2 = new ShaderMaterial({
+        defines: Object.assign({}, SSRBlurShader.defines),
+        uniforms: UniformsUtils.clone(SSRBlurShader.uniforms),
+        vertexShader: SSRBlurShader.vertexShader,
+        fragmentShader: SSRBlurShader.fragmentShader,
+      })
+      this.blurMaterial2.uniforms['tDiffuse'].value = this.blurRenderTarget.texture
+      this.blurMaterial2.uniforms['resolution'].value.set(this.width, this.height)
+
+      // // blur material 3
+
+      // this.blurMaterial3 = new ShaderMaterial({
+      //   defines: Object.assign({}, SSRBlurShader.defines),
+      //   uniforms: UniformsUtils.clone(SSRBlurShader.uniforms),
+      //   vertexShader: SSRBlurShader.vertexShader,
+      //   fragmentShader: SSRBlurShader.fragmentShader
+      // });
+      // this.blurMaterial3.uniforms['tDiffuse'].value = this.blurRenderTarget2.texture;
+      // this.blurMaterial3.uniforms['resolution'].value.set(this.width, this.height);
+
+      // material for rendering the depth
+
+      this.depthRenderMaterial = new ShaderMaterial({
+        defines: Object.assign({}, SSRDepthShader.defines),
+        uniforms: UniformsUtils.clone(SSRDepthShader.uniforms),
+        vertexShader: SSRDepthShader.vertexShader,
+        fragmentShader: SSRDepthShader.fragmentShader,
+        blending: NoBlending,
+      })
+      this.depthRenderMaterial.uniforms['tDepth'].value = this.beautyRenderTarget.depthTexture
+      this.depthRenderMaterial.uniforms['cameraNear'].value = this.camera.near
+      this.depthRenderMaterial.uniforms['cameraFar'].value = this.camera.far
+
+      // material for rendering the content of a render target
+
+      this.copyMaterial = new ShaderMaterial({
+        uniforms: UniformsUtils.clone(CopyShader.uniforms),
+        vertexShader: CopyShader.vertexShader,
+        fragmentShader: CopyShader.fragmentShader,
+        transparent: true,
+        depthTest: false,
+        depthWrite: false,
+        blendSrc: SrcAlphaFactor,
+        blendDst: OneMinusSrcAlphaFactor,
+        blendEquation: AddEquation,
+        blendSrcAlpha: SrcAlphaFactor,
+        blendDstAlpha: OneMinusSrcAlphaFactor,
+        blendEquationAlpha: AddEquation,
+        // premultipliedAlpha:true,
+      })
+
+      this.fsQuad = new FullScreenQuad(null)
+
+      this.originalClearColor = new Color()
+    }
 
-    // dispose materials
+    dispose() {
+      // dispose render targets
 
-    this.normalMaterial.dispose()
-    this.metalnessOnMaterial.dispose()
-    this.metalnessOffMaterial.dispose()
-    this.blurMaterial.dispose()
-    this.blurMaterial2.dispose()
-    this.copyMaterial.dispose()
-    this.depthRenderMaterial.dispose()
+      this.beautyRenderTarget.dispose()
+      this.prevRenderTarget.dispose()
+      this.normalRenderTarget.dispose()
+      this.metalnessRenderTarget.dispose()
+      this.ssrRenderTarget.dispose()
+      this.blurRenderTarget.dispose()
+      this.blurRenderTarget2.dispose()
+      // this.blurRenderTarget3.dispose();
 
-    // dipsose full screen quad
+      // dispose materials
 
-    this.fsQuad.dispose()
-  }
+      this.normalMaterial.dispose()
+      this.metalnessOnMaterial.dispose()
+      this.metalnessOffMaterial.dispose()
+      this.blurMaterial.dispose()
+      this.blurMaterial2.dispose()
+      this.copyMaterial.dispose()
+      this.depthRenderMaterial.dispose()
 
-  render(renderer, writeBuffer /*, readBuffer, deltaTime, maskActive */) {
-    // render beauty and depth
+      // dipsose full screen quad
 
-    renderer.setRenderTarget(this.beautyRenderTarget)
-    renderer.clear()
-    if (this.groundReflector) {
-      this.groundReflector.visible = false
-      this.groundReflector.doRender(this.renderer, this.scene, this.camera)
-      this.groundReflector.visible = true
+      this.fsQuad.dispose()
     }
 
-    renderer.render(this.scene, this.camera)
-    if (this.groundReflector) this.groundReflector.visible = false
+    render(renderer, writeBuffer /*, readBuffer, deltaTime, maskActive */) {
+      // render beauty and depth
 
-    // render normals
+      renderer.setRenderTarget(this.beautyRenderTarget)
+      renderer.clear()
+      if (this.groundReflector) {
+        this.groundReflector.visible = false
+        this.groundReflector.doRender(this.renderer, this.scene, this.camera)
+        this.groundReflector.visible = true
+      }
 
-    this.renderOverride(renderer, this.normalMaterial, this.normalRenderTarget, 0, 0)
+      renderer.render(this.scene, this.camera)
+      if (this.groundReflector) this.groundReflector.visible = false
 
-    // render metalnesses
+      // render normals
 
-    if (this.selective) {
-      this.renderMetalness(renderer, this.metalnessOnMaterial, this.metalnessRenderTarget, 0, 0)
-    }
+      this.renderOverride(renderer, this.normalMaterial, this.normalRenderTarget, 0, 0)
 
-    // render SSR
+      // render metalnesses
 
-    this.ssrMaterial.uniforms['opacity'].value = this.opacity
-    this.ssrMaterial.uniforms['maxDistance'].value = this.maxDistance
-    this.ssrMaterial.uniforms['thickness'].value = this.thickness
-    this.renderPass(renderer, this.ssrMaterial, this.ssrRenderTarget)
+      if (this.selective) {
+        this.renderMetalness(renderer, this.metalnessOnMaterial, this.metalnessRenderTarget, 0, 0)
+      }
 
-    // render blur
+      // render SSR
 
-    if (this.blur) {
-      this.renderPass(renderer, this.blurMaterial, this.blurRenderTarget)
-      this.renderPass(renderer, this.blurMaterial2, this.blurRenderTarget2)
-      // this.renderPass(renderer, this.blurMaterial3, this.blurRenderTarget3);
-    }
+      this.ssrMaterial.uniforms['opacity'].value = this.opacity
+      this.ssrMaterial.uniforms['maxDistance'].value = this.maxDistance
+      this.ssrMaterial.uniforms['thickness'].value = this.thickness
+      this.renderPass(renderer, this.ssrMaterial, this.ssrRenderTarget)
 
-    // output result to screen
+      // render blur
 
-    switch (this.output) {
-      case SSRPass.OUTPUT.Default:
-        if (this.bouncing) {
-          this.copyMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
-          this.copyMaterial.blending = NoBlending
-          this.renderPass(renderer, this.copyMaterial, this.prevRenderTarget)
+      if (this.blur) {
+        this.renderPass(renderer, this.blurMaterial, this.blurRenderTarget)
+        this.renderPass(renderer, this.blurMaterial2, this.blurRenderTarget2)
+        // this.renderPass(renderer, this.blurMaterial3, this.blurRenderTarget3);
+      }
 
+      // output result to screen
+
+      switch (this.output) {
+        case SSRPass.OUTPUT.Default:
+          if (this.bouncing) {
+            this.copyMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
+            this.copyMaterial.blending = NoBlending
+            this.renderPass(renderer, this.copyMaterial, this.prevRenderTarget)
+
+            if (this.blur) this.copyMaterial.uniforms['tDiffuse'].value = this.blurRenderTarget2.texture
+            else this.copyMaterial.uniforms['tDiffuse'].value = this.ssrRenderTarget.texture
+            this.copyMaterial.blending = NormalBlending
+            this.renderPass(renderer, this.copyMaterial, this.prevRenderTarget)
+
+            this.copyMaterial.uniforms['tDiffuse'].value = this.prevRenderTarget.texture
+            this.copyMaterial.blending = NoBlending
+            this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
+          } else {
+            this.copyMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
+            this.copyMaterial.blending = NoBlending
+            this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
+
+            if (this.blur) this.copyMaterial.uniforms['tDiffuse'].value = this.blurRenderTarget2.texture
+            else this.copyMaterial.uniforms['tDiffuse'].value = this.ssrRenderTarget.texture
+            this.copyMaterial.blending = NormalBlending
+            this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
+          }
+
+          break
+        case SSRPass.OUTPUT.SSR:
           if (this.blur) this.copyMaterial.uniforms['tDiffuse'].value = this.blurRenderTarget2.texture
           else this.copyMaterial.uniforms['tDiffuse'].value = this.ssrRenderTarget.texture
-          this.copyMaterial.blending = NormalBlending
-          this.renderPass(renderer, this.copyMaterial, this.prevRenderTarget)
-
-          this.copyMaterial.uniforms['tDiffuse'].value = this.prevRenderTarget.texture
-          this.copyMaterial.blending = NoBlending
-          this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
-        } else {
-          this.copyMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
           this.copyMaterial.blending = NoBlending
           this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
 
-          if (this.blur) this.copyMaterial.uniforms['tDiffuse'].value = this.blurRenderTarget2.texture
-          else this.copyMaterial.uniforms['tDiffuse'].value = this.ssrRenderTarget.texture
-          this.copyMaterial.blending = NormalBlending
-          this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
-        }
+          if (this.bouncing) {
+            if (this.blur) this.copyMaterial.uniforms['tDiffuse'].value = this.blurRenderTarget2.texture
+            else this.copyMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
+            this.copyMaterial.blending = NoBlending
+            this.renderPass(renderer, this.copyMaterial, this.prevRenderTarget)
 
-        break
-      case SSRPass.OUTPUT.SSR:
-        if (this.blur) this.copyMaterial.uniforms['tDiffuse'].value = this.blurRenderTarget2.texture
-        else this.copyMaterial.uniforms['tDiffuse'].value = this.ssrRenderTarget.texture
-        this.copyMaterial.blending = NoBlending
-        this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
+            this.copyMaterial.uniforms['tDiffuse'].value = this.ssrRenderTarget.texture
+            this.copyMaterial.blending = NormalBlending
+            this.renderPass(renderer, this.copyMaterial, this.prevRenderTarget)
+          }
 
-        if (this.bouncing) {
-          if (this.blur) this.copyMaterial.uniforms['tDiffuse'].value = this.blurRenderTarget2.texture
-          else this.copyMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
-          this.copyMaterial.blending = NoBlending
-          this.renderPass(renderer, this.copyMaterial, this.prevRenderTarget)
+          break
 
-          this.copyMaterial.uniforms['tDiffuse'].value = this.ssrRenderTarget.texture
-          this.copyMaterial.blending = NormalBlending
-          this.renderPass(renderer, this.copyMaterial, this.prevRenderTarget)
-        }
+        case SSRPass.OUTPUT.Beauty:
+          this.copyMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
+          this.copyMaterial.blending = NoBlending
+          this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
 
-        break
+          break
 
-      case SSRPass.OUTPUT.Beauty:
-        this.copyMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
-        this.copyMaterial.blending = NoBlending
-        this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
+        case SSRPass.OUTPUT.Depth:
+          this.renderPass(renderer, this.depthRenderMaterial, this.renderToScreen ? null : writeBuffer)
 
-        break
+          break
 
-      case SSRPass.OUTPUT.Depth:
-        this.renderPass(renderer, this.depthRenderMaterial, this.renderToScreen ? null : writeBuffer)
+        case SSRPass.OUTPUT.Normal:
+          this.copyMaterial.uniforms['tDiffuse'].value = this.normalRenderTarget.texture
+          this.copyMaterial.blending = NoBlending
+          this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
 
-        break
+          break
 
-      case SSRPass.OUTPUT.Normal:
-        this.copyMaterial.uniforms['tDiffuse'].value = this.normalRenderTarget.texture
-        this.copyMaterial.blending = NoBlending
-        this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
+        case SSRPass.OUTPUT.Metalness:
+          this.copyMaterial.uniforms['tDiffuse'].value = this.metalnessRenderTarget.texture
+          this.copyMaterial.blending = NoBlending
+          this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
 
-        break
+          break
 
-      case SSRPass.OUTPUT.Metalness:
-        this.copyMaterial.uniforms['tDiffuse'].value = this.metalnessRenderTarget.texture
-        this.copyMaterial.blending = NoBlending
-        this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
+        default:
+          console.warn('THREE.SSRPass: Unknown output type.')
+      }
+    }
 
-        break
+    renderPass(renderer, passMaterial, renderTarget, clearColor, clearAlpha) {
+      // save original state
+      this.originalClearColor.copy(renderer.getClearColor(this.tempColor))
+      const originalClearAlpha = renderer.getClearAlpha(this.tempColor)
+      const originalAutoClear = renderer.autoClear
 
-      default:
-        console.warn('THREE.SSRPass: Unknown output type.')
-    }
-  }
+      renderer.setRenderTarget(renderTarget)
 
-  renderPass(renderer, passMaterial, renderTarget, clearColor, clearAlpha) {
-    // save original state
-    this.originalClearColor.copy(renderer.getClearColor(this.tempColor))
-    const originalClearAlpha = renderer.getClearAlpha(this.tempColor)
-    const originalAutoClear = renderer.autoClear
+      // setup pass state
+      renderer.autoClear = false
+      if (clearColor !== undefined && clearColor !== null) {
+        renderer.setClearColor(clearColor)
+        renderer.setClearAlpha(clearAlpha || 0.0)
+        renderer.clear()
+      }
 
-    renderer.setRenderTarget(renderTarget)
+      this.fsQuad.material = passMaterial
+      this.fsQuad.render(renderer)
 
-    // setup pass state
-    renderer.autoClear = false
-    if (clearColor !== undefined && clearColor !== null) {
-      renderer.setClearColor(clearColor)
-      renderer.setClearAlpha(clearAlpha || 0.0)
-      renderer.clear()
+      // restore original state
+      renderer.autoClear = originalAutoClear
+      renderer.setClearColor(this.originalClearColor)
+      renderer.setClearAlpha(originalClearAlpha)
     }
 
-    this.fsQuad.material = passMaterial
-    this.fsQuad.render(renderer)
+    renderOverride(renderer, overrideMaterial, renderTarget, clearColor, clearAlpha) {
+      this.originalClearColor.copy(renderer.getClearColor(this.tempColor))
+      const originalClearAlpha = renderer.getClearAlpha(this.tempColor)
+      const originalAutoClear = renderer.autoClear
 
-    // restore original state
-    renderer.autoClear = originalAutoClear
-    renderer.setClearColor(this.originalClearColor)
-    renderer.setClearAlpha(originalClearAlpha)
-  }
+      renderer.setRenderTarget(renderTarget)
+      renderer.autoClear = false
+
+      clearColor = overrideMaterial.clearColor || clearColor
+      clearAlpha = overrideMaterial.clearAlpha || clearAlpha
 
-  renderOverride(renderer, overrideMaterial, renderTarget, clearColor, clearAlpha) {
-    this.originalClearColor.copy(renderer.getClearColor(this.tempColor))
-    const originalClearAlpha = renderer.getClearAlpha(this.tempColor)
-    const originalAutoClear = renderer.autoClear
+      if (clearColor !== undefined && clearColor !== null) {
+        renderer.setClearColor(clearColor)
+        renderer.setClearAlpha(clearAlpha || 0.0)
+        renderer.clear()
+      }
 
-    renderer.setRenderTarget(renderTarget)
-    renderer.autoClear = false
+      this.scene.overrideMaterial = overrideMaterial
+      renderer.render(this.scene, this.camera)
+      this.scene.overrideMaterial = null
 
-    clearColor = overrideMaterial.clearColor || clearColor
-    clearAlpha = overrideMaterial.clearAlpha || clearAlpha
+      // restore original state
 
-    if (clearColor !== undefined && clearColor !== null) {
-      renderer.setClearColor(clearColor)
-      renderer.setClearAlpha(clearAlpha || 0.0)
-      renderer.clear()
+      renderer.autoClear = originalAutoClear
+      renderer.setClearColor(this.originalClearColor)
+      renderer.setClearAlpha(originalClearAlpha)
     }
 
-    this.scene.overrideMaterial = overrideMaterial
-    renderer.render(this.scene, this.camera)
-    this.scene.overrideMaterial = null
+    renderMetalness(renderer, overrideMaterial, renderTarget, clearColor, clearAlpha) {
+      this.originalClearColor.copy(renderer.getClearColor(this.tempColor))
+      const originalClearAlpha = renderer.getClearAlpha(this.tempColor)
+      const originalAutoClear = renderer.autoClear
 
-    // restore original state
+      renderer.setRenderTarget(renderTarget)
+      renderer.autoClear = false
 
-    renderer.autoClear = originalAutoClear
-    renderer.setClearColor(this.originalClearColor)
-    renderer.setClearAlpha(originalClearAlpha)
-  }
+      clearColor = overrideMaterial.clearColor || clearColor
+      clearAlpha = overrideMaterial.clearAlpha || clearAlpha
 
-  renderMetalness(renderer, overrideMaterial, renderTarget, clearColor, clearAlpha) {
-    this.originalClearColor.copy(renderer.getClearColor(this.tempColor))
-    const originalClearAlpha = renderer.getClearAlpha(this.tempColor)
-    const originalAutoClear = renderer.autoClear
+      if (clearColor !== undefined && clearColor !== null) {
+        renderer.setClearColor(clearColor)
+        renderer.setClearAlpha(clearAlpha || 0.0)
+        renderer.clear()
+      }
 
-    renderer.setRenderTarget(renderTarget)
-    renderer.autoClear = false
+      this.scene.traverseVisible((child) => {
+        child._SSRPassBackupMaterial = child.material
+        if (this._selects.includes(child)) {
+          child.material = this.metalnessOnMaterial
+        } else {
+          child.material = this.metalnessOffMaterial
+        }
+      })
+      renderer.render(this.scene, this.camera)
+      this.scene.traverseVisible((child) => {
+        child.material = child._SSRPassBackupMaterial
+      })
 
-    clearColor = overrideMaterial.clearColor || clearColor
-    clearAlpha = overrideMaterial.clearAlpha || clearAlpha
+      // restore original state
 
-    if (clearColor !== undefined && clearColor !== null) {
-      renderer.setClearColor(clearColor)
-      renderer.setClearAlpha(clearAlpha || 0.0)
-      renderer.clear()
+      renderer.autoClear = originalAutoClear
+      renderer.setClearColor(this.originalClearColor)
+      renderer.setClearAlpha(originalClearAlpha)
     }
 
-    this.scene.traverseVisible((child) => {
-      child._SSRPassBackupMaterial = child.material
-      if (this._selects.includes(child)) {
-        child.material = this.metalnessOnMaterial
-      } else {
-        child.material = this.metalnessOffMaterial
-      }
-    })
-    renderer.render(this.scene, this.camera)
-    this.scene.traverseVisible((child) => {
-      child.material = child._SSRPassBackupMaterial
-    })
-
-    // restore original state
-
-    renderer.autoClear = originalAutoClear
-    renderer.setClearColor(this.originalClearColor)
-    renderer.setClearAlpha(originalClearAlpha)
+    setSize(width, height) {
+      this.width = width
+      this.height = height
+
+      this.ssrMaterial.defines.MAX_STEP = Math.sqrt(width * width + height * height)
+      this.ssrMaterial.needsUpdate = true
+      this.beautyRenderTarget.setSize(width, height)
+      this.prevRenderTarget.setSize(width, height)
+      this.ssrRenderTarget.setSize(width, height)
+      this.normalRenderTarget.setSize(width, height)
+      this.metalnessRenderTarget.setSize(width, height)
+      this.blurRenderTarget.setSize(width, height)
+      this.blurRenderTarget2.setSize(width, height)
+      // this.blurRenderTarget3.setSize(width, height);
+
+      this.ssrMaterial.uniforms['resolution'].value.set(width, height)
+      this.ssrMaterial.uniforms['cameraProjectionMatrix'].value.copy(this.camera.projectionMatrix)
+      this.ssrMaterial.uniforms['cameraInverseProjectionMatrix'].value.copy(this.camera.projectionMatrixInverse)
+
+      this.blurMaterial.uniforms['resolution'].value.set(width, height)
+      this.blurMaterial2.uniforms['resolution'].value.set(width, height)
+    }
   }
 
-  setSize(width, height) {
-    this.width = width
-    this.height = height
-
-    this.ssrMaterial.defines.MAX_STEP = Math.sqrt(width * width + height * height)
-    this.ssrMaterial.needsUpdate = true
-    this.beautyRenderTarget.setSize(width, height)
-    this.prevRenderTarget.setSize(width, height)
-    this.ssrRenderTarget.setSize(width, height)
-    this.normalRenderTarget.setSize(width, height)
-    this.metalnessRenderTarget.setSize(width, height)
-    this.blurRenderTarget.setSize(width, height)
-    this.blurRenderTarget2.setSize(width, height)
-    // this.blurRenderTarget3.setSize(width, height);
-
-    this.ssrMaterial.uniforms['resolution'].value.set(width, height)
-    this.ssrMaterial.uniforms['cameraProjectionMatrix'].value.copy(this.camera.projectionMatrix)
-    this.ssrMaterial.uniforms['cameraInverseProjectionMatrix'].value.copy(this.camera.projectionMatrixInverse)
-
-    this.blurMaterial.uniforms['resolution'].value.set(width, height)
-    this.blurMaterial2.uniforms['resolution'].value.set(width, height)
-  }
-}
+  return SSRPass
+})()
 
 export { SSRPass }
diff --git a/src/postprocessing/UnrealBloomPass.js b/src/postprocessing/UnrealBloomPass.js
index 25e854c6..e0d1123c 100644
--- a/src/postprocessing/UnrealBloomPass.js
+++ b/src/postprocessing/UnrealBloomPass.js
@@ -22,281 +22,282 @@ import { LuminosityHighPassShader } from '../shaders/LuminosityHighPassShader'
  * Reference:
  * - https://docs.unrealengine.com/latest/INT/Engine/Rendering/PostProcessEffects/Bloom/
  */
-class UnrealBloomPass extends Pass {
-  static BlurDirectionX = new Vector2(1.0, 0.0)
-  static BlurDirectionY = new Vector2(0.0, 1.0)
+const UnrealBloomPass = /* @__PURE__ */ (() => {
+  class UnrealBloomPass extends Pass {
+    static BlurDirectionX = new Vector2(1.0, 0.0)
+    static BlurDirectionY = new Vector2(0.0, 1.0)
 
-  constructor(resolution, strength, radius, threshold) {
-    super()
+    constructor(resolution, strength, radius, threshold) {
+      super()
 
-    this.strength = strength !== undefined ? strength : 1
-    this.radius = radius
-    this.threshold = threshold
-    this.resolution = resolution !== undefined ? new Vector2(resolution.x, resolution.y) : new Vector2(256, 256)
+      this.strength = strength !== undefined ? strength : 1
+      this.radius = radius
+      this.threshold = threshold
+      this.resolution = resolution !== undefined ? new Vector2(resolution.x, resolution.y) : new Vector2(256, 256)
 
-    // create color only once here, reuse it later inside the render function
-    this.clearColor = new Color(0, 0, 0)
+      // create color only once here, reuse it later inside the render function
+      this.clearColor = new Color(0, 0, 0)
+
+      // render targets
+      this.renderTargetsHorizontal = []
+      this.renderTargetsVertical = []
+      this.nMips = 5
+      let resx = Math.round(this.resolution.x / 2)
+      let resy = Math.round(this.resolution.y / 2)
 
-    // render targets
-    this.renderTargetsHorizontal = []
-    this.renderTargetsVertical = []
-    this.nMips = 5
-    let resx = Math.round(this.resolution.x / 2)
-    let resy = Math.round(this.resolution.y / 2)
+      this.renderTargetBright = new WebGLRenderTarget(resx, resy, { type: HalfFloatType })
+      this.renderTargetBright.texture.name = 'UnrealBloomPass.bright'
+      this.renderTargetBright.texture.generateMipmaps = false
 
-    this.renderTargetBright = new WebGLRenderTarget(resx, resy, { type: HalfFloatType })
-    this.renderTargetBright.texture.name = 'UnrealBloomPass.bright'
-    this.renderTargetBright.texture.generateMipmaps = false
+      for (let i = 0; i < this.nMips; i++) {
+        const renderTargetHorizonal = new WebGLRenderTarget(resx, resy, { type: HalfFloatType })
 
-    for (let i = 0; i < this.nMips; i++) {
-      const renderTargetHorizonal = new WebGLRenderTarget(resx, resy, { type: HalfFloatType })
+        renderTargetHorizonal.texture.name = 'UnrealBloomPass.h' + i
+        renderTargetHorizonal.texture.generateMipmaps = false
 
-      renderTargetHorizonal.texture.name = 'UnrealBloomPass.h' + i
-      renderTargetHorizonal.texture.generateMipmaps = false
+        this.renderTargetsHorizontal.push(renderTargetHorizonal)
 
-      this.renderTargetsHorizontal.push(renderTargetHorizonal)
+        const renderTargetVertical = new WebGLRenderTarget(resx, resy, { type: HalfFloatType })
 
-      const renderTargetVertical = new WebGLRenderTarget(resx, resy, { type: HalfFloatType })
+        renderTargetVertical.texture.name = 'UnrealBloomPass.v' + i
+        renderTargetVertical.texture.generateMipmaps = false
 
-      renderTargetVertical.texture.name = 'UnrealBloomPass.v' + i
-      renderTargetVertical.texture.generateMipmaps = false
+        this.renderTargetsVertical.push(renderTargetVertical)
 
-      this.renderTargetsVertical.push(renderTargetVertical)
+        resx = Math.round(resx / 2)
 
-      resx = Math.round(resx / 2)
+        resy = Math.round(resy / 2)
+      }
 
-      resy = Math.round(resy / 2)
-    }
+      // luminosity high pass material
 
-    // luminosity high pass material
+      const highPassShader = LuminosityHighPassShader
+      this.highPassUniforms = UniformsUtils.clone(highPassShader.uniforms)
 
-    const highPassShader = LuminosityHighPassShader
-    this.highPassUniforms = UniformsUtils.clone(highPassShader.uniforms)
+      this.highPassUniforms['luminosityThreshold'].value = threshold
+      this.highPassUniforms['smoothWidth'].value = 0.01
 
-    this.highPassUniforms['luminosityThreshold'].value = threshold
-    this.highPassUniforms['smoothWidth'].value = 0.01
+      this.materialHighPassFilter = new ShaderMaterial({
+        uniforms: this.highPassUniforms,
+        vertexShader: highPassShader.vertexShader,
+        fragmentShader: highPassShader.fragmentShader,
+        defines: {},
+      })
 
-    this.materialHighPassFilter = new ShaderMaterial({
-      uniforms: this.highPassUniforms,
-      vertexShader: highPassShader.vertexShader,
-      fragmentShader: highPassShader.fragmentShader,
-      defines: {},
-    })
+      // Gaussian Blur Materials
+      this.separableBlurMaterials = []
+      const kernelSizeArray = [3, 5, 7, 9, 11]
+      resx = Math.round(this.resolution.x / 2)
+      resy = Math.round(this.resolution.y / 2)
 
-    // Gaussian Blur Materials
-    this.separableBlurMaterials = []
-    const kernelSizeArray = [3, 5, 7, 9, 11]
-    resx = Math.round(this.resolution.x / 2)
-    resy = Math.round(this.resolution.y / 2)
+      for (let i = 0; i < this.nMips; i++) {
+        this.separableBlurMaterials.push(this.getSeperableBlurMaterial(kernelSizeArray[i]))
 
-    for (let i = 0; i < this.nMips; i++) {
-      this.separableBlurMaterials.push(this.getSeperableBlurMaterial(kernelSizeArray[i]))
+        this.separableBlurMaterials[i].uniforms['texSize'].value = new Vector2(resx, resy)
 
-      this.separableBlurMaterials[i].uniforms['texSize'].value = new Vector2(resx, resy)
+        resx = Math.round(resx / 2)
 
-      resx = Math.round(resx / 2)
+        resy = Math.round(resy / 2)
+      }
 
-      resy = Math.round(resy / 2)
-    }
+      // Composite material
+      this.compositeMaterial = this.getCompositeMaterial(this.nMips)
+      this.compositeMaterial.uniforms['blurTexture1'].value = this.renderTargetsVertical[0].texture
+      this.compositeMaterial.uniforms['blurTexture2'].value = this.renderTargetsVertical[1].texture
+      this.compositeMaterial.uniforms['blurTexture3'].value = this.renderTargetsVertical[2].texture
+      this.compositeMaterial.uniforms['blurTexture4'].value = this.renderTargetsVertical[3].texture
+      this.compositeMaterial.uniforms['blurTexture5'].value = this.renderTargetsVertical[4].texture
+      this.compositeMaterial.uniforms['bloomStrength'].value = strength
+      this.compositeMaterial.uniforms['bloomRadius'].value = 0.1
+      this.compositeMaterial.needsUpdate = true
 
-    // Composite material
-    this.compositeMaterial = this.getCompositeMaterial(this.nMips)
-    this.compositeMaterial.uniforms['blurTexture1'].value = this.renderTargetsVertical[0].texture
-    this.compositeMaterial.uniforms['blurTexture2'].value = this.renderTargetsVertical[1].texture
-    this.compositeMaterial.uniforms['blurTexture3'].value = this.renderTargetsVertical[2].texture
-    this.compositeMaterial.uniforms['blurTexture4'].value = this.renderTargetsVertical[3].texture
-    this.compositeMaterial.uniforms['blurTexture5'].value = this.renderTargetsVertical[4].texture
-    this.compositeMaterial.uniforms['bloomStrength'].value = strength
-    this.compositeMaterial.uniforms['bloomRadius'].value = 0.1
-    this.compositeMaterial.needsUpdate = true
-
-    const bloomFactors = [1.0, 0.8, 0.6, 0.4, 0.2]
-    this.compositeMaterial.uniforms['bloomFactors'].value = bloomFactors
-    this.bloomTintColors = [
-      new Vector3(1, 1, 1),
-      new Vector3(1, 1, 1),
-      new Vector3(1, 1, 1),
-      new Vector3(1, 1, 1),
-      new Vector3(1, 1, 1),
-    ]
-    this.compositeMaterial.uniforms['bloomTintColors'].value = this.bloomTintColors
-
-    // copy material
-
-    const copyShader = CopyShader
-
-    this.copyUniforms = UniformsUtils.clone(copyShader.uniforms)
-    this.copyUniforms['opacity'].value = 1.0
-
-    this.materialCopy = new ShaderMaterial({
-      uniforms: this.copyUniforms,
-      vertexShader: copyShader.vertexShader,
-      fragmentShader: copyShader.fragmentShader,
-      blending: AdditiveBlending,
-      depthTest: false,
-      depthWrite: false,
-      transparent: true,
-    })
-
-    this.enabled = true
-    this.needsSwap = false
-
-    this._oldClearColor = new Color()
-    this.oldClearAlpha = 1
-
-    this.basic = new MeshBasicMaterial()
-
-    this.fsQuad = new FullScreenQuad(null)
-  }
+      const bloomFactors = [1.0, 0.8, 0.6, 0.4, 0.2]
+      this.compositeMaterial.uniforms['bloomFactors'].value = bloomFactors
+      this.bloomTintColors = [
+        new Vector3(1, 1, 1),
+        new Vector3(1, 1, 1),
+        new Vector3(1, 1, 1),
+        new Vector3(1, 1, 1),
+        new Vector3(1, 1, 1),
+      ]
+      this.compositeMaterial.uniforms['bloomTintColors'].value = this.bloomTintColors
 
-  dispose() {
-    for (let i = 0; i < this.renderTargetsHorizontal.length; i++) {
-      this.renderTargetsHorizontal[i].dispose()
-    }
+      // copy material
 
-    for (let i = 0; i < this.renderTargetsVertical.length; i++) {
-      this.renderTargetsVertical[i].dispose()
-    }
+      const copyShader = CopyShader
+
+      this.copyUniforms = UniformsUtils.clone(copyShader.uniforms)
+      this.copyUniforms['opacity'].value = 1.0
+
+      this.materialCopy = new ShaderMaterial({
+        uniforms: this.copyUniforms,
+        vertexShader: copyShader.vertexShader,
+        fragmentShader: copyShader.fragmentShader,
+        blending: AdditiveBlending,
+        depthTest: false,
+        depthWrite: false,
+        transparent: true,
+      })
+
+      this.enabled = true
+      this.needsSwap = false
 
-    this.renderTargetBright.dispose()
+      this._oldClearColor = new Color()
+      this.oldClearAlpha = 1
 
-    //
+      this.basic = new MeshBasicMaterial()
 
-    for (let i = 0; i < this.separableBlurMaterials.length; i++) {
-      this.separableBlurMaterials[i].dispose()
+      this.fsQuad = new FullScreenQuad(null)
     }
 
-    this.compositeMaterial.dispose()
-    this.materialCopy.dispose()
-    this.basic.dispose()
+    dispose() {
+      for (let i = 0; i < this.renderTargetsHorizontal.length; i++) {
+        this.renderTargetsHorizontal[i].dispose()
+      }
 
-    //
+      for (let i = 0; i < this.renderTargetsVertical.length; i++) {
+        this.renderTargetsVertical[i].dispose()
+      }
 
-    this.fsQuad.dispose()
-  }
+      this.renderTargetBright.dispose()
 
-  setSize(width, height) {
-    let resx = Math.round(width / 2)
-    let resy = Math.round(height / 2)
+      //
 
-    this.renderTargetBright.setSize(resx, resy)
+      for (let i = 0; i < this.separableBlurMaterials.length; i++) {
+        this.separableBlurMaterials[i].dispose()
+      }
 
-    for (let i = 0; i < this.nMips; i++) {
-      this.renderTargetsHorizontal[i].setSize(resx, resy)
-      this.renderTargetsVertical[i].setSize(resx, resy)
+      this.compositeMaterial.dispose()
+      this.materialCopy.dispose()
+      this.basic.dispose()
 
-      this.separableBlurMaterials[i].uniforms['texSize'].value = new Vector2(resx, resy)
+      //
 
-      resx = Math.round(resx / 2)
-      resy = Math.round(resy / 2)
+      this.fsQuad.dispose()
     }
-  }
 
-  render(renderer, writeBuffer, readBuffer, deltaTime, maskActive) {
-    renderer.getClearColor(this._oldClearColor)
-    this.oldClearAlpha = renderer.getClearAlpha()
-    const oldAutoClear = renderer.autoClear
-    renderer.autoClear = false
+    setSize(width, height) {
+      let resx = Math.round(width / 2)
+      let resy = Math.round(height / 2)
 
-    renderer.setClearColor(this.clearColor, 0)
+      this.renderTargetBright.setSize(resx, resy)
 
-    if (maskActive) renderer.state.buffers.stencil.setTest(false)
+      for (let i = 0; i < this.nMips; i++) {
+        this.renderTargetsHorizontal[i].setSize(resx, resy)
+        this.renderTargetsVertical[i].setSize(resx, resy)
 
-    // Render input to screen
+        this.separableBlurMaterials[i].uniforms['texSize'].value = new Vector2(resx, resy)
 
-    if (this.renderToScreen) {
-      this.fsQuad.material = this.basic
-      this.basic.map = readBuffer.texture
-
-      renderer.setRenderTarget(null)
-      renderer.clear()
-      this.fsQuad.render(renderer)
+        resx = Math.round(resx / 2)
+        resy = Math.round(resy / 2)
+      }
     }
 
-    // 1. Extract Bright Areas
+    render(renderer, writeBuffer, readBuffer, deltaTime, maskActive) {
+      renderer.getClearColor(this._oldClearColor)
+      this.oldClearAlpha = renderer.getClearAlpha()
+      const oldAutoClear = renderer.autoClear
+      renderer.autoClear = false
 
-    this.highPassUniforms['tDiffuse'].value = readBuffer.texture
-    this.highPassUniforms['luminosityThreshold'].value = this.threshold
-    this.fsQuad.material = this.materialHighPassFilter
+      renderer.setClearColor(this.clearColor, 0)
 
-    renderer.setRenderTarget(this.renderTargetBright)
-    renderer.clear()
-    this.fsQuad.render(renderer)
+      if (maskActive) renderer.state.buffers.stencil.setTest(false)
 
-    // 2. Blur All the mips progressively
+      // Render input to screen
 
-    let inputRenderTarget = this.renderTargetBright
+      if (this.renderToScreen) {
+        this.fsQuad.material = this.basic
+        this.basic.map = readBuffer.texture
 
-    for (let i = 0; i < this.nMips; i++) {
-      this.fsQuad.material = this.separableBlurMaterials[i]
+        renderer.setRenderTarget(null)
+        renderer.clear()
+        this.fsQuad.render(renderer)
+      }
 
-      this.separableBlurMaterials[i].uniforms['colorTexture'].value = inputRenderTarget.texture
-      this.separableBlurMaterials[i].uniforms['direction'].value = UnrealBloomPass.BlurDirectionX
-      renderer.setRenderTarget(this.renderTargetsHorizontal[i])
-      renderer.clear()
-      this.fsQuad.render(renderer)
+      // 1. Extract Bright Areas
+
+      this.highPassUniforms['tDiffuse'].value = readBuffer.texture
+      this.highPassUniforms['luminosityThreshold'].value = this.threshold
+      this.fsQuad.material = this.materialHighPassFilter
 
-      this.separableBlurMaterials[i].uniforms['colorTexture'].value = this.renderTargetsHorizontal[i].texture
-      this.separableBlurMaterials[i].uniforms['direction'].value = UnrealBloomPass.BlurDirectionY
-      renderer.setRenderTarget(this.renderTargetsVertical[i])
+      renderer.setRenderTarget(this.renderTargetBright)
       renderer.clear()
       this.fsQuad.render(renderer)
 
-      inputRenderTarget = this.renderTargetsVertical[i]
-    }
+      // 2. Blur All the mips progressively
 
-    // Composite All the mips
+      let inputRenderTarget = this.renderTargetBright
 
-    this.fsQuad.material = this.compositeMaterial
-    this.compositeMaterial.uniforms['bloomStrength'].value = this.strength
-    this.compositeMaterial.uniforms['bloomRadius'].value = this.radius
-    this.compositeMaterial.uniforms['bloomTintColors'].value = this.bloomTintColors
+      for (let i = 0; i < this.nMips; i++) {
+        this.fsQuad.material = this.separableBlurMaterials[i]
 
-    renderer.setRenderTarget(this.renderTargetsHorizontal[0])
-    renderer.clear()
-    this.fsQuad.render(renderer)
+        this.separableBlurMaterials[i].uniforms['colorTexture'].value = inputRenderTarget.texture
+        this.separableBlurMaterials[i].uniforms['direction'].value = UnrealBloomPass.BlurDirectionX
+        renderer.setRenderTarget(this.renderTargetsHorizontal[i])
+        renderer.clear()
+        this.fsQuad.render(renderer)
 
-    // Blend it additively over the input texture
+        this.separableBlurMaterials[i].uniforms['colorTexture'].value = this.renderTargetsHorizontal[i].texture
+        this.separableBlurMaterials[i].uniforms['direction'].value = UnrealBloomPass.BlurDirectionY
+        renderer.setRenderTarget(this.renderTargetsVertical[i])
+        renderer.clear()
+        this.fsQuad.render(renderer)
 
-    this.fsQuad.material = this.materialCopy
-    this.copyUniforms['tDiffuse'].value = this.renderTargetsHorizontal[0].texture
+        inputRenderTarget = this.renderTargetsVertical[i]
+      }
 
-    if (maskActive) renderer.state.buffers.stencil.setTest(true)
+      // Composite All the mips
 
-    if (this.renderToScreen) {
-      renderer.setRenderTarget(null)
-      this.fsQuad.render(renderer)
-    } else {
-      renderer.setRenderTarget(readBuffer)
+      this.fsQuad.material = this.compositeMaterial
+      this.compositeMaterial.uniforms['bloomStrength'].value = this.strength
+      this.compositeMaterial.uniforms['bloomRadius'].value = this.radius
+      this.compositeMaterial.uniforms['bloomTintColors'].value = this.bloomTintColors
+
+      renderer.setRenderTarget(this.renderTargetsHorizontal[0])
+      renderer.clear()
       this.fsQuad.render(renderer)
-    }
 
-    // Restore renderer settings
+      // Blend it additively over the input texture
 
-    renderer.setClearColor(this._oldClearColor, this.oldClearAlpha)
-    renderer.autoClear = oldAutoClear
-  }
+      this.fsQuad.material = this.materialCopy
+      this.copyUniforms['tDiffuse'].value = this.renderTargetsHorizontal[0].texture
 
-  getSeperableBlurMaterial(kernelRadius) {
-    return new ShaderMaterial({
-      defines: {
-        KERNEL_RADIUS: kernelRadius,
-        SIGMA: kernelRadius,
-      },
+      if (maskActive) renderer.state.buffers.stencil.setTest(true)
 
-      uniforms: {
-        colorTexture: { value: null },
-        texSize: { value: new Vector2(0.5, 0.5) },
-        direction: { value: new Vector2(0.5, 0.5) },
-      },
+      if (this.renderToScreen) {
+        renderer.setRenderTarget(null)
+        this.fsQuad.render(renderer)
+      } else {
+        renderer.setRenderTarget(readBuffer)
+        this.fsQuad.render(renderer)
+      }
 
-      vertexShader: `varying vec2 vUv;
+      // Restore renderer settings
+
+      renderer.setClearColor(this._oldClearColor, this.oldClearAlpha)
+      renderer.autoClear = oldAutoClear
+    }
+
+    getSeperableBlurMaterial(kernelRadius) {
+      return new ShaderMaterial({
+        defines: {
+          KERNEL_RADIUS: kernelRadius,
+          SIGMA: kernelRadius,
+        },
+
+        uniforms: {
+          colorTexture: { value: null },
+          texSize: { value: new Vector2(0.5, 0.5) },
+          direction: { value: new Vector2(0.5, 0.5) },
+        },
+
+        vertexShader: `varying vec2 vUv;
 				void main() {
 					vUv = uv;
 					gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 				}`,
 
-      fragmentShader: `#include <common>
+        fragmentShader: `#include <common>
 				varying vec2 vUv;
 				uniform sampler2D colorTexture;
 				uniform vec2 texSize;
@@ -321,34 +322,34 @@ class UnrealBloomPass extends Pass {
 					}
 					gl_FragColor = vec4(diffuseSum/weightSum, 1.0);
 				}`,
-    })
-  }
+      })
+    }
 
-  getCompositeMaterial(nMips) {
-    return new ShaderMaterial({
-      defines: {
-        NUM_MIPS: nMips,
-      },
-
-      uniforms: {
-        blurTexture1: { value: null },
-        blurTexture2: { value: null },
-        blurTexture3: { value: null },
-        blurTexture4: { value: null },
-        blurTexture5: { value: null },
-        bloomStrength: { value: 1.0 },
-        bloomFactors: { value: null },
-        bloomTintColors: { value: null },
-        bloomRadius: { value: 0.0 },
-      },
-
-      vertexShader: `varying vec2 vUv;
+    getCompositeMaterial(nMips) {
+      return new ShaderMaterial({
+        defines: {
+          NUM_MIPS: nMips,
+        },
+
+        uniforms: {
+          blurTexture1: { value: null },
+          blurTexture2: { value: null },
+          blurTexture3: { value: null },
+          blurTexture4: { value: null },
+          blurTexture5: { value: null },
+          bloomStrength: { value: 1.0 },
+          bloomFactors: { value: null },
+          bloomTintColors: { value: null },
+          bloomRadius: { value: 0.0 },
+        },
+
+        vertexShader: `varying vec2 vUv;
 				void main() {
 					vUv = uv;
 					gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 				}`,
 
-      fragmentShader: `varying vec2 vUv;
+        fragmentShader: `varying vec2 vUv;
 				uniform sampler2D blurTexture1;
 				uniform sampler2D blurTexture2;
 				uniform sampler2D blurTexture3;
@@ -371,8 +372,11 @@ class UnrealBloomPass extends Pass {
 						lerpBloomFactor(bloomFactors[3]) * vec4(bloomTintColors[3], 1.0) * texture2D(blurTexture4, vUv) +
 						lerpBloomFactor(bloomFactors[4]) * vec4(bloomTintColors[4], 1.0) * texture2D(blurTexture5, vUv) );
 				}`,
-    })
+      })
+    }
   }
-}
+
+  return UnrealBloomPass
+})()
 
 export { UnrealBloomPass }
diff --git a/src/renderers/CSS2DRenderer.js b/src/renderers/CSS2DRenderer.js
index 7caf2532..f0aa059e 100644
--- a/src/renderers/CSS2DRenderer.js
+++ b/src/renderers/CSS2DRenderer.js
@@ -35,11 +35,11 @@ class CSS2DObject extends Object3D {
   }
 }
 
-const _vector = new Vector3()
-const _viewMatrix = new Matrix4()
-const _viewProjectionMatrix = new Matrix4()
-const _a = new Vector3()
-const _b = new Vector3()
+const _vector = /* @__PURE__ */ new Vector3()
+const _viewMatrix = /* @__PURE__ */ new Matrix4()
+const _viewProjectionMatrix = /* @__PURE__ */ new Matrix4()
+const _a = /* @__PURE__ */ new Vector3()
+const _b = /* @__PURE__ */ new Vector3()
 
 class CSS2DRenderer {
   constructor(parameters = {}) {
diff --git a/src/renderers/CSS3DRenderer.js b/src/renderers/CSS3DRenderer.js
index cdeb32e8..292a0ba5 100644
--- a/src/renderers/CSS3DRenderer.js
+++ b/src/renderers/CSS3DRenderer.js
@@ -4,9 +4,9 @@ import { Matrix4, Object3D, Quaternion, Vector3 } from 'three'
  * Based on http://www.emagix.net/academic/mscs-project/item/camera-sync-with-css3-and-webgl-threejs
  */
 
-const _position = new Vector3()
-const _quaternion = new Quaternion()
-const _scale = new Vector3()
+const _position = /* @__PURE__ */ new Vector3()
+const _quaternion = /* @__PURE__ */ new Quaternion()
+const _scale = /* @__PURE__ */ new Vector3()
 
 class CSS3DObject extends Object3D {
   constructor(element = document.createElement('div')) {
@@ -59,8 +59,8 @@ class CSS3DSprite extends CSS3DObject {
 
 //
 
-const _matrix = new Matrix4()
-const _matrix2 = new Matrix4()
+const _matrix = /* @__PURE__ */ new Matrix4()
+const _matrix2 = /* @__PURE__ */ new Matrix4()
 
 class CSS3DRenderer {
   constructor(parameters = {}) {
diff --git a/src/shaders/ACESFilmicToneMappingShader.ts b/src/shaders/ACESFilmicToneMappingShader.ts
index e80700dc..db221340 100644
--- a/src/shaders/ACESFilmicToneMappingShader.ts
+++ b/src/shaders/ACESFilmicToneMappingShader.ts
@@ -22,70 +22,69 @@ export const ACESFilmicToneMappingShader: IACESFilmicToneMappingShader = {
     exposure: { value: 1.0 },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;,
 
-    'void main() {',
+    void main() {,
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;,
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );,
 
-    '}',
-  ].join('\n'),
+    },
+  `,
+  fragmentShader: /* glsl */ `
+    #define saturate(a) clamp( a, 0.0, 1.0 ),
 
-  fragmentShader: [
-    '#define saturate(a) clamp( a, 0.0, 1.0 )',
+    uniform sampler2D tDiffuse;,
 
-    'uniform sampler2D tDiffuse;',
+    uniform float exposure;,
 
-    'uniform float exposure;',
+    varying vec2 vUv;,
 
-    'varying vec2 vUv;',
+    vec3 RRTAndODTFit( vec3 v ) {,
 
-    'vec3 RRTAndODTFit( vec3 v ) {',
+    	vec3 a = v * ( v + 0.0245786 ) - 0.000090537;,
+    	vec3 b = v * ( 0.983729 * v + 0.4329510 ) + 0.238081;,
+    	return a / b;,
 
-    '	vec3 a = v * ( v + 0.0245786 ) - 0.000090537;',
-    '	vec3 b = v * ( 0.983729 * v + 0.4329510 ) + 0.238081;',
-    '	return a / b;',
+    },
 
-    '}',
+    vec3 ACESFilmicToneMapping( vec3 color ) {,
 
-    'vec3 ACESFilmicToneMapping( vec3 color ) {',
+      // sRGB => XYZ => D65_2_D60 => AP1 => RRT_SAT
+    	const mat3 ACESInputMat = mat3(,
+    		vec3( 0.59719, 0.07600, 0.02840 ),, // transposed from source
+    		vec3( 0.35458, 0.90834, 0.13383 ),,
+    		vec3( 0.04823, 0.01566, 0.83777 ),
+    	);,
 
-    // sRGB => XYZ => D65_2_D60 => AP1 => RRT_SAT
-    '	const mat3 ACESInputMat = mat3(',
-    '		vec3( 0.59719, 0.07600, 0.02840 ),', // transposed from source
-    '		vec3( 0.35458, 0.90834, 0.13383 ),',
-    '		vec3( 0.04823, 0.01566, 0.83777 )',
-    '	);',
+      // ODT_SAT => XYZ => D60_2_D65 => sRGB
+    	const mat3 ACESOutputMat = mat3(,
+    		vec3(  1.60475, -0.10208, -0.00327 ),, // transposed from source
+    		vec3( -0.53108,  1.10813, -0.07276 ),,
+    		vec3( -0.07367, -0.00605,  1.07602 ),
+    	);,
 
-    // ODT_SAT => XYZ => D60_2_D65 => sRGB
-    '	const mat3 ACESOutputMat = mat3(',
-    '		vec3(  1.60475, -0.10208, -0.00327 ),', // transposed from source
-    '		vec3( -0.53108,  1.10813, -0.07276 ),',
-    '		vec3( -0.07367, -0.00605,  1.07602 )',
-    '	);',
+    	color = ACESInputMat * color;,
 
-    '	color = ACESInputMat * color;',
+      // Apply RRT and ODT
+    	color = RRTAndODTFit( color );,
 
-    // Apply RRT and ODT
-    '	color = RRTAndODTFit( color );',
+    	color = ACESOutputMat * color;,
 
-    '	color = ACESOutputMat * color;',
+      // Clamp to [0, 1]
+    	return saturate( color );,
 
-    // Clamp to [0, 1]
-    '	return saturate( color );',
+    },
 
-    '}',
+    void main() {,
 
-    'void main() {',
+    	vec4 tex = texture2D( tDiffuse, vUv );,
 
-    '	vec4 tex = texture2D( tDiffuse, vUv );',
+    	tex.rgb *= exposure / 0.6;, // pre-exposed, outside of the tone mapping function
 
-    '	tex.rgb *= exposure / 0.6;', // pre-exposed, outside of the tone mapping function
+    	gl_FragColor = vec4( ACESFilmicToneMapping( tex.rgb ), tex.a );,
 
-    '	gl_FragColor = vec4( ACESFilmicToneMapping( tex.rgb ), tex.a );',
-
-    '}',
-  ].join('\n'),
+    },
+  `,
 }
diff --git a/src/shaders/AfterimageShader.ts b/src/shaders/AfterimageShader.ts
index a5214494..990c93b8 100644
--- a/src/shaders/AfterimageShader.ts
+++ b/src/shaders/AfterimageShader.ts
@@ -22,40 +22,40 @@ export const AfterimageShader: IAfterimageShader = {
     tNew: { value: null },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform float damp;',
+  fragmentShader: /* glsl */ `
+    uniform float damp;
 
-    'uniform sampler2D tOld;',
-    'uniform sampler2D tNew;',
+    uniform sampler2D tOld;
+    uniform sampler2D tNew;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'vec4 when_gt( vec4 x, float y ) {',
+    vec4 when_gt( vec4 x, float y ) {
 
-    '	return max( sign( x - y ), 0.0 );',
+    	return max( sign( x - y ), 0.0 );
 
-    '}',
+    }
 
-    'void main() {',
+    void main() {
 
-    '	vec4 texelOld = texture2D( tOld, vUv );',
-    '	vec4 texelNew = texture2D( tNew, vUv );',
+    	vec4 texelOld = texture2D( tOld, vUv );
+    	vec4 texelNew = texture2D( tNew, vUv );
 
-    '	texelOld *= damp * when_gt( texelOld, 0.1 );',
+    	texelOld *= damp * when_gt( texelOld, 0.1 );
 
-    '	gl_FragColor = max(texelNew, texelOld);',
+    	gl_FragColor = max(texelNew, texelOld);
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/BasicShader.ts b/src/shaders/BasicShader.ts
index 9226a3e0..36d0369b 100644
--- a/src/shaders/BasicShader.ts
+++ b/src/shaders/BasicShader.ts
@@ -11,13 +11,19 @@ export interface IBasicShader extends IShader<BasicShaderUniforms> {}
 export const BasicShader: IBasicShader = {
   uniforms: {},
 
-  vertexShader: [
-    'void main() {',
+  vertexShader: /* glsl */ `
+    void main() {
 
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: ['void main() {', '	gl_FragColor = vec4( 1.0, 0.0, 0.0, 0.5 );', '}'].join('\n'),
+  fragmentShader: /* glsl */ `
+    void main() {
+
+      gl_FragColor = vec4( 1.0, 0.0, 0.0, 0.5 );
+
+    }
+  `,
 }
diff --git a/src/shaders/BleachBypassShader.ts b/src/shaders/BleachBypassShader.ts
index 03d967d2..bed9ada9 100644
--- a/src/shaders/BleachBypassShader.ts
+++ b/src/shaders/BleachBypassShader.ts
@@ -20,45 +20,45 @@ export const BleachBypassShader: IBleachBypassShader = {
     opacity: { value: 1.0 },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform float opacity;',
+  fragmentShader: /* glsl */ `
+    uniform float opacity;
 
-    'uniform sampler2D tDiffuse;',
+    uniform sampler2D tDiffuse;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vec4 base = texture2D( tDiffuse, vUv );',
+    	vec4 base = texture2D( tDiffuse, vUv );
 
-    '	vec3 lumCoeff = vec3( 0.25, 0.65, 0.1 );',
-    '	float lum = dot( lumCoeff, base.rgb );',
-    '	vec3 blend = vec3( lum );',
+    	vec3 lumCoeff = vec3( 0.25, 0.65, 0.1 );
+    	float lum = dot( lumCoeff, base.rgb );
+    	vec3 blend = vec3( lum );
 
-    '	float L = min( 1.0, max( 0.0, 10.0 * ( lum - 0.45 ) ) );',
+    	float L = min( 1.0, max( 0.0, 10.0 * ( lum - 0.45 ) ) );
 
-    '	vec3 result1 = 2.0 * base.rgb * blend;',
-    '	vec3 result2 = 1.0 - 2.0 * ( 1.0 - blend ) * ( 1.0 - base.rgb );',
+    	vec3 result1 = 2.0 * base.rgb * blend;
+    	vec3 result2 = 1.0 - 2.0 * ( 1.0 - blend ) * ( 1.0 - base.rgb );
 
-    '	vec3 newColor = mix( result1, result2, L );',
+    	vec3 newColor = mix( result1, result2, L );
 
-    '	float A2 = opacity * base.a;',
-    '	vec3 mixRGB = A2 * newColor.rgb;',
-    '	mixRGB += ( ( 1.0 - A2 ) * base.rgb );',
+    	float A2 = opacity * base.a;
+    	vec3 mixRGB = A2 * newColor.rgb;
+    	mixRGB += ( ( 1.0 - A2 ) * base.rgb );
 
-    '	gl_FragColor = vec4( mixRGB, base.a );',
+    	gl_FragColor = vec4( mixRGB, base.a );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/BlendShader.ts b/src/shaders/BlendShader.ts
index d626c3a9..086160ef 100644
--- a/src/shaders/BlendShader.ts
+++ b/src/shaders/BlendShader.ts
@@ -10,32 +10,32 @@ export const BlendShader = {
     opacity: { value: 1.0 },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform float opacity;',
-    'uniform float mixRatio;',
+  fragmentShader: /* glsl */ `
+    uniform float opacity;
+    uniform float mixRatio;
 
-    'uniform sampler2D tDiffuse1;',
-    'uniform sampler2D tDiffuse2;',
+    uniform sampler2D tDiffuse1;
+    uniform sampler2D tDiffuse2;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vec4 texel1 = texture2D( tDiffuse1, vUv );',
-    '	vec4 texel2 = texture2D( tDiffuse2, vUv );',
-    '	gl_FragColor = opacity * mix( texel1, texel2, mixRatio );',
+    	vec4 texel1 = texture2D( tDiffuse1, vUv );
+    	vec4 texel2 = texture2D( tDiffuse2, vUv );
+    	gl_FragColor = opacity * mix( texel1, texel2, mixRatio );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/BokehShader.ts b/src/shaders/BokehShader.ts
index 6c80cf5f..f248cf4b 100644
--- a/src/shaders/BokehShader.ts
+++ b/src/shaders/BokehShader.ts
@@ -42,116 +42,116 @@ export const BokehShader: IBokehShader = {
     farClip: { value: 1000.0 },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
-
-    'void main() {',
-
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
-
-    '}',
-  ].join('\n'),
-
-  fragmentShader: [
-    '#include <common>',
-
-    'varying vec2 vUv;',
-
-    'uniform sampler2D tColor;',
-    'uniform sampler2D tDepth;',
-
-    'uniform float maxblur;', // max blur amount
-    'uniform float aperture;', // aperture - bigger values for shallower depth of field
-
-    'uniform float nearClip;',
-    'uniform float farClip;',
-
-    'uniform float focus;',
-    'uniform float aspect;',
-
-    '#include <packing>',
-
-    'float getDepth( const in vec2 screenPosition ) {',
-    '	#if DEPTH_PACKING == 1',
-    '	return unpackRGBAToDepth( texture2D( tDepth, screenPosition ) );',
-    '	#else',
-    '	return texture2D( tDepth, screenPosition ).x;',
-    '	#endif',
-    '}',
-
-    'float getViewZ( const in float depth ) {',
-    '	#if PERSPECTIVE_CAMERA == 1',
-    '	return perspectiveDepthToViewZ( depth, nearClip, farClip );',
-    '	#else',
-    '	return orthographicDepthToViewZ( depth, nearClip, farClip );',
-    '	#endif',
-    '}',
-
-    'void main() {',
-
-    '	vec2 aspectcorrect = vec2( 1.0, aspect );',
-
-    '	float viewZ = getViewZ( getDepth( vUv ) );',
-
-    '	float factor = ( focus + viewZ );', // viewZ is <= 0, so this is a difference equation
-
-    '	vec2 dofblur = vec2 ( clamp( factor * aperture, -maxblur, maxblur ) );',
-
-    '	vec2 dofblur9 = dofblur * 0.9;',
-    '	vec2 dofblur7 = dofblur * 0.7;',
-    '	vec2 dofblur4 = dofblur * 0.4;',
-
-    '	vec4 col = vec4( 0.0 );',
-
-    '	col += texture2D( tColor, vUv.xy );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.0,   0.4  ) * aspectcorrect ) * dofblur );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.15,  0.37 ) * aspectcorrect ) * dofblur );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.29,  0.29 ) * aspectcorrect ) * dofblur );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2( -0.37,  0.15 ) * aspectcorrect ) * dofblur );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.40,  0.0  ) * aspectcorrect ) * dofblur );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.37, -0.15 ) * aspectcorrect ) * dofblur );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.29, -0.29 ) * aspectcorrect ) * dofblur );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2( -0.15, -0.37 ) * aspectcorrect ) * dofblur );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.0,  -0.4  ) * aspectcorrect ) * dofblur );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2( -0.15,  0.37 ) * aspectcorrect ) * dofblur );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2( -0.29,  0.29 ) * aspectcorrect ) * dofblur );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.37,  0.15 ) * aspectcorrect ) * dofblur );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2( -0.4,   0.0  ) * aspectcorrect ) * dofblur );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2( -0.37, -0.15 ) * aspectcorrect ) * dofblur );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2( -0.29, -0.29 ) * aspectcorrect ) * dofblur );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.15, -0.37 ) * aspectcorrect ) * dofblur );',
-
-    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.15,  0.37 ) * aspectcorrect ) * dofblur9 );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2( -0.37,  0.15 ) * aspectcorrect ) * dofblur9 );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.37, -0.15 ) * aspectcorrect ) * dofblur9 );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2( -0.15, -0.37 ) * aspectcorrect ) * dofblur9 );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2( -0.15,  0.37 ) * aspectcorrect ) * dofblur9 );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.37,  0.15 ) * aspectcorrect ) * dofblur9 );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2( -0.37, -0.15 ) * aspectcorrect ) * dofblur9 );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.15, -0.37 ) * aspectcorrect ) * dofblur9 );',
-
-    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.29,  0.29 ) * aspectcorrect ) * dofblur7 );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.40,  0.0  ) * aspectcorrect ) * dofblur7 );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.29, -0.29 ) * aspectcorrect ) * dofblur7 );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.0,  -0.4  ) * aspectcorrect ) * dofblur7 );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2( -0.29,  0.29 ) * aspectcorrect ) * dofblur7 );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2( -0.4,   0.0  ) * aspectcorrect ) * dofblur7 );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2( -0.29, -0.29 ) * aspectcorrect ) * dofblur7 );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.0,   0.4  ) * aspectcorrect ) * dofblur7 );',
-
-    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.29,  0.29 ) * aspectcorrect ) * dofblur4 );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.4,   0.0  ) * aspectcorrect ) * dofblur4 );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.29, -0.29 ) * aspectcorrect ) * dofblur4 );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.0,  -0.4  ) * aspectcorrect ) * dofblur4 );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2( -0.29,  0.29 ) * aspectcorrect ) * dofblur4 );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2( -0.4,   0.0  ) * aspectcorrect ) * dofblur4 );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2( -0.29, -0.29 ) * aspectcorrect ) * dofblur4 );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.0,   0.4  ) * aspectcorrect ) * dofblur4 );',
-
-    '	gl_FragColor = col / 41.0;',
-    '	gl_FragColor.a = 1.0;',
-
-    '}',
-  ].join('\n'),
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
+
+    void main() {
+
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+
+    }
+  `,
+
+  fragmentShader: /* glsl */ `
+    #include <common>
+
+    varying vec2 vUv;
+
+    uniform sampler2D tColor;
+    uniform sampler2D tDepth;
+
+    uniform float maxblur; // max blur amount
+    uniform float aperture; // aperture - bigger values for shallower depth of field
+
+    uniform float nearClip;
+    uniform float farClip;
+
+    uniform float focus;
+    uniform float aspect;
+
+    #include <packing>
+
+    float getDepth( const in vec2 screenPosition ) {
+    	#if DEPTH_PACKING == 1
+    	return unpackRGBAToDepth( texture2D( tDepth, screenPosition ) );
+    	#else
+    	return texture2D( tDepth, screenPosition ).x;
+    	#endif
+    }
+
+    float getViewZ( const in float depth ) {
+    	#if PERSPECTIVE_CAMERA == 1
+    	return perspectiveDepthToViewZ( depth, nearClip, farClip );
+    	#else
+    	return orthographicDepthToViewZ( depth, nearClip, farClip );
+    	#endif
+    }
+
+    void main() {
+
+    	vec2 aspectcorrect = vec2( 1.0, aspect );
+
+    	float viewZ = getViewZ( getDepth( vUv ) );
+
+    	float factor = ( focus + viewZ ); // viewZ is <= 0, so this is a difference equation
+
+    	vec2 dofblur = vec2 ( clamp( factor * aperture, -maxblur, maxblur ) );
+
+    	vec2 dofblur9 = dofblur * 0.9;
+    	vec2 dofblur7 = dofblur * 0.7;
+    	vec2 dofblur4 = dofblur * 0.4;
+
+    	vec4 col = vec4( 0.0 );
+
+    	col += texture2D( tColor, vUv.xy );
+    	col += texture2D( tColor, vUv.xy + ( vec2(  0.0,   0.4  ) * aspectcorrect ) * dofblur );
+    	col += texture2D( tColor, vUv.xy + ( vec2(  0.15,  0.37 ) * aspectcorrect ) * dofblur );
+    	col += texture2D( tColor, vUv.xy + ( vec2(  0.29,  0.29 ) * aspectcorrect ) * dofblur );
+    	col += texture2D( tColor, vUv.xy + ( vec2( -0.37,  0.15 ) * aspectcorrect ) * dofblur );
+    	col += texture2D( tColor, vUv.xy + ( vec2(  0.40,  0.0  ) * aspectcorrect ) * dofblur );
+    	col += texture2D( tColor, vUv.xy + ( vec2(  0.37, -0.15 ) * aspectcorrect ) * dofblur );
+    	col += texture2D( tColor, vUv.xy + ( vec2(  0.29, -0.29 ) * aspectcorrect ) * dofblur );
+    	col += texture2D( tColor, vUv.xy + ( vec2( -0.15, -0.37 ) * aspectcorrect ) * dofblur );
+    	col += texture2D( tColor, vUv.xy + ( vec2(  0.0,  -0.4  ) * aspectcorrect ) * dofblur );
+    	col += texture2D( tColor, vUv.xy + ( vec2( -0.15,  0.37 ) * aspectcorrect ) * dofblur );
+    	col += texture2D( tColor, vUv.xy + ( vec2( -0.29,  0.29 ) * aspectcorrect ) * dofblur );
+    	col += texture2D( tColor, vUv.xy + ( vec2(  0.37,  0.15 ) * aspectcorrect ) * dofblur );
+    	col += texture2D( tColor, vUv.xy + ( vec2( -0.4,   0.0  ) * aspectcorrect ) * dofblur );
+    	col += texture2D( tColor, vUv.xy + ( vec2( -0.37, -0.15 ) * aspectcorrect ) * dofblur );
+    	col += texture2D( tColor, vUv.xy + ( vec2( -0.29, -0.29 ) * aspectcorrect ) * dofblur );
+    	col += texture2D( tColor, vUv.xy + ( vec2(  0.15, -0.37 ) * aspectcorrect ) * dofblur );
+
+    	col += texture2D( tColor, vUv.xy + ( vec2(  0.15,  0.37 ) * aspectcorrect ) * dofblur9 );
+    	col += texture2D( tColor, vUv.xy + ( vec2( -0.37,  0.15 ) * aspectcorrect ) * dofblur9 );
+    	col += texture2D( tColor, vUv.xy + ( vec2(  0.37, -0.15 ) * aspectcorrect ) * dofblur9 );
+    	col += texture2D( tColor, vUv.xy + ( vec2( -0.15, -0.37 ) * aspectcorrect ) * dofblur9 );
+    	col += texture2D( tColor, vUv.xy + ( vec2( -0.15,  0.37 ) * aspectcorrect ) * dofblur9 );
+    	col += texture2D( tColor, vUv.xy + ( vec2(  0.37,  0.15 ) * aspectcorrect ) * dofblur9 );
+    	col += texture2D( tColor, vUv.xy + ( vec2( -0.37, -0.15 ) * aspectcorrect ) * dofblur9 );
+    	col += texture2D( tColor, vUv.xy + ( vec2(  0.15, -0.37 ) * aspectcorrect ) * dofblur9 );
+
+    	col += texture2D( tColor, vUv.xy + ( vec2(  0.29,  0.29 ) * aspectcorrect ) * dofblur7 );
+    	col += texture2D( tColor, vUv.xy + ( vec2(  0.40,  0.0  ) * aspectcorrect ) * dofblur7 );
+    	col += texture2D( tColor, vUv.xy + ( vec2(  0.29, -0.29 ) * aspectcorrect ) * dofblur7 );
+    	col += texture2D( tColor, vUv.xy + ( vec2(  0.0,  -0.4  ) * aspectcorrect ) * dofblur7 );
+    	col += texture2D( tColor, vUv.xy + ( vec2( -0.29,  0.29 ) * aspectcorrect ) * dofblur7 );
+    	col += texture2D( tColor, vUv.xy + ( vec2( -0.4,   0.0  ) * aspectcorrect ) * dofblur7 );
+    	col += texture2D( tColor, vUv.xy + ( vec2( -0.29, -0.29 ) * aspectcorrect ) * dofblur7 );
+    	col += texture2D( tColor, vUv.xy + ( vec2(  0.0,   0.4  ) * aspectcorrect ) * dofblur7 );
+
+    	col += texture2D( tColor, vUv.xy + ( vec2(  0.29,  0.29 ) * aspectcorrect ) * dofblur4 );
+    	col += texture2D( tColor, vUv.xy + ( vec2(  0.4,   0.0  ) * aspectcorrect ) * dofblur4 );
+    	col += texture2D( tColor, vUv.xy + ( vec2(  0.29, -0.29 ) * aspectcorrect ) * dofblur4 );
+    	col += texture2D( tColor, vUv.xy + ( vec2(  0.0,  -0.4  ) * aspectcorrect ) * dofblur4 );
+    	col += texture2D( tColor, vUv.xy + ( vec2( -0.29,  0.29 ) * aspectcorrect ) * dofblur4 );
+    	col += texture2D( tColor, vUv.xy + ( vec2( -0.4,   0.0  ) * aspectcorrect ) * dofblur4 );
+    	col += texture2D( tColor, vUv.xy + ( vec2( -0.29, -0.29 ) * aspectcorrect ) * dofblur4 );
+    	col += texture2D( tColor, vUv.xy + ( vec2(  0.0,   0.4  ) * aspectcorrect ) * dofblur4 );
+
+    	gl_FragColor = col / 41.0;
+    	gl_FragColor.a = 1.0;
+
+    }
+  `,
 }
diff --git a/src/shaders/BokehShader2.ts b/src/shaders/BokehShader2.ts
index f9734ebe..28f6bca6 100644
--- a/src/shaders/BokehShader2.ts
+++ b/src/shaders/BokehShader2.ts
@@ -78,305 +78,305 @@ export const BokehShader2: {
     pentagon: { value: 0 },
 
     shaderFocus: { value: 1 },
-    focusCoords: { value: new Vector2() },
+    focusCoords: { value: /* @__PURE__ */ new Vector2() },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    '#include <common>',
+  fragmentShader: /* glsl */ `
+    #include <common>
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'uniform sampler2D tColor;',
-    'uniform sampler2D tDepth;',
-    'uniform float textureWidth;',
-    'uniform float textureHeight;',
+    uniform sampler2D tColor;
+    uniform sampler2D tDepth;
+    uniform float textureWidth;
+    uniform float textureHeight;
 
-    'uniform float focalDepth;  //focal distance value in meters, but you may use autofocus option below',
-    'uniform float focalLength; //focal length in mm',
-    'uniform float fstop; //f-stop value',
-    'uniform bool showFocus; //show debug focus point and focal range (red = focal point, green = focal range)',
+    uniform float focalDepth;  //focal distance value in meters, but you may use autofocus option below
+    uniform float focalLength; //focal length in mm
+    uniform float fstop; //f-stop value
+    uniform bool showFocus; //show debug focus point and focal range (red = focal point, green = focal range)
 
-    '/*',
-    'make sure that these two values are the same for your camera, otherwise distances will be wrong.',
-    '*/',
+    /*
+    make sure that these two values are the same for your camera, otherwise distances will be wrong.
+    */
 
-    'uniform float znear; // camera clipping start',
-    'uniform float zfar; // camera clipping end',
+    uniform float znear; // camera clipping start
+    uniform float zfar; // camera clipping end
 
-    '//------------------------------------------',
-    '//user variables',
+    //------------------------------------------
+    //user variables
 
-    'const int samples = SAMPLES; //samples on the first ring',
-    'const int rings = RINGS; //ring count',
+    const int samples = SAMPLES; //samples on the first ring
+    const int rings = RINGS; //ring count
 
-    'const int maxringsamples = rings * samples;',
+    const int maxringsamples = rings * samples;
 
-    'uniform bool manualdof; // manual dof calculation',
-    'float ndofstart = 1.0; // near dof blur start',
-    'float ndofdist = 2.0; // near dof blur falloff distance',
-    'float fdofstart = 1.0; // far dof blur start',
-    'float fdofdist = 3.0; // far dof blur falloff distance',
+    uniform bool manualdof; // manual dof calculation
+    float ndofstart = 1.0; // near dof blur start
+    float ndofdist = 2.0; // near dof blur falloff distance
+    float fdofstart = 1.0; // far dof blur start
+    float fdofdist = 3.0; // far dof blur falloff distance
 
-    'float CoC = 0.03; //circle of confusion size in mm (35mm film = 0.03mm)',
+    float CoC = 0.03; //circle of confusion size in mm (35mm film = 0.03mm)
 
-    'uniform bool vignetting; // use optical lens vignetting',
+    uniform bool vignetting; // use optical lens vignetting
 
-    'float vignout = 1.3; // vignetting outer border',
-    'float vignin = 0.0; // vignetting inner border',
-    'float vignfade = 22.0; // f-stops till vignete fades',
+    float vignout = 1.3; // vignetting outer border
+    float vignin = 0.0; // vignetting inner border
+    float vignfade = 22.0; // f-stops till vignete fades
 
-    'uniform bool shaderFocus;',
-    '// disable if you use external focalDepth value',
+    uniform bool shaderFocus;
+    // disable if you use external focalDepth value
 
-    'uniform vec2 focusCoords;',
-    '// autofocus point on screen (0.0,0.0 - left lower corner, 1.0,1.0 - upper right)',
-    '// if center of screen use vec2(0.5, 0.5);',
+    uniform vec2 focusCoords;
+    // autofocus point on screen (0.0,0.0 - left lower corner, 1.0,1.0 - upper right)
+    // if center of screen use vec2(0.5, 0.5);
 
-    'uniform float maxblur;',
-    '//clamp value of max blur (0.0 = no blur, 1.0 default)',
+    uniform float maxblur;
+    //clamp value of max blur (0.0 = no blur, 1.0 default)
 
-    'uniform float threshold; // highlight threshold;',
-    'uniform float gain; // highlight gain;',
+    uniform float threshold; // highlight threshold;
+    uniform float gain; // highlight gain;
 
-    'uniform float bias; // bokeh edge bias',
-    'uniform float fringe; // bokeh chromatic aberration / fringing',
+    uniform float bias; // bokeh edge bias
+    uniform float fringe; // bokeh chromatic aberration / fringing
 
-    'uniform bool noise; //use noise instead of pattern for sample dithering',
+    uniform bool noise; //use noise instead of pattern for sample dithering
 
-    'uniform float dithering;',
+    uniform float dithering;
 
-    'uniform bool depthblur; // blur the depth buffer',
-    'float dbsize = 1.25; // depth blur size',
+    uniform bool depthblur; // blur the depth buffer
+    float dbsize = 1.25; // depth blur size
 
-    '/*',
-    'next part is experimental',
-    'not looking good with small sample and ring count',
-    'looks okay starting from samples = 4, rings = 4',
-    '*/',
+    /*
+    next part is experimental
+    not looking good with small sample and ring count
+    looks okay starting from samples = 4, rings = 4
+    */
 
-    'uniform bool pentagon; //use pentagon as bokeh shape?',
-    'float feather = 0.4; //pentagon shape feather',
+    uniform bool pentagon; //use pentagon as bokeh shape?
+    float feather = 0.4; //pentagon shape feather
 
-    '//------------------------------------------',
+    //------------------------------------------
 
-    'float penta(vec2 coords) {',
-    '	//pentagonal shape',
-    '	float scale = float(rings) - 1.3;',
-    '	vec4  HS0 = vec4( 1.0,         0.0,         0.0,  1.0);',
-    '	vec4  HS1 = vec4( 0.309016994, 0.951056516, 0.0,  1.0);',
-    '	vec4  HS2 = vec4(-0.809016994, 0.587785252, 0.0,  1.0);',
-    '	vec4  HS3 = vec4(-0.809016994,-0.587785252, 0.0,  1.0);',
-    '	vec4  HS4 = vec4( 0.309016994,-0.951056516, 0.0,  1.0);',
-    '	vec4  HS5 = vec4( 0.0        ,0.0         , 1.0,  1.0);',
+    float penta(vec2 coords) {
+    	//pentagonal shape
+    	float scale = float(rings) - 1.3;
+    	vec4  HS0 = vec4( 1.0,         0.0,         0.0,  1.0);
+    	vec4  HS1 = vec4( 0.309016994, 0.951056516, 0.0,  1.0);
+    	vec4  HS2 = vec4(-0.809016994, 0.587785252, 0.0,  1.0);
+    	vec4  HS3 = vec4(-0.809016994,-0.587785252, 0.0,  1.0);
+    	vec4  HS4 = vec4( 0.309016994,-0.951056516, 0.0,  1.0);
+    	vec4  HS5 = vec4( 0.0        ,0.0         , 1.0,  1.0);
 
-    '	vec4  one = vec4( 1.0 );',
+    	vec4  one = vec4( 1.0 );
 
-    '	vec4 P = vec4((coords),vec2(scale, scale));',
+    	vec4 P = vec4((coords),vec2(scale, scale));
 
-    '	vec4 dist = vec4(0.0);',
-    '	float inorout = -4.0;',
+    	vec4 dist = vec4(0.0);
+    	float inorout = -4.0;
 
-    '	dist.x = dot( P, HS0 );',
-    '	dist.y = dot( P, HS1 );',
-    '	dist.z = dot( P, HS2 );',
-    '	dist.w = dot( P, HS3 );',
+    	dist.x = dot( P, HS0 );
+    	dist.y = dot( P, HS1 );
+    	dist.z = dot( P, HS2 );
+    	dist.w = dot( P, HS3 );
 
-    '	dist = smoothstep( -feather, feather, dist );',
+    	dist = smoothstep( -feather, feather, dist );
 
-    '	inorout += dot( dist, one );',
+    	inorout += dot( dist, one );
 
-    '	dist.x = dot( P, HS4 );',
-    '	dist.y = HS5.w - abs( P.z );',
+    	dist.x = dot( P, HS4 );
+    	dist.y = HS5.w - abs( P.z );
 
-    '	dist = smoothstep( -feather, feather, dist );',
-    '	inorout += dist.x;',
+    	dist = smoothstep( -feather, feather, dist );
+    	inorout += dist.x;
 
-    '	return clamp( inorout, 0.0, 1.0 );',
-    '}',
+    	return clamp( inorout, 0.0, 1.0 );
+    }
 
-    'float bdepth(vec2 coords) {',
-    '	// Depth buffer blur',
-    '	float d = 0.0;',
-    '	float kernel[9];',
-    '	vec2 offset[9];',
+    float bdepth(vec2 coords) {
+    	// Depth buffer blur
+    	float d = 0.0;
+    	float kernel[9];
+    	vec2 offset[9];
 
-    '	vec2 wh = vec2(1.0/textureWidth,1.0/textureHeight) * dbsize;',
+    	vec2 wh = vec2(1.0/textureWidth,1.0/textureHeight) * dbsize;
 
-    '	offset[0] = vec2(-wh.x,-wh.y);',
-    '	offset[1] = vec2( 0.0, -wh.y);',
-    '	offset[2] = vec2( wh.x -wh.y);',
+    	offset[0] = vec2(-wh.x,-wh.y);
+    	offset[1] = vec2( 0.0, -wh.y);
+    	offset[2] = vec2( wh.x -wh.y);
 
-    '	offset[3] = vec2(-wh.x,  0.0);',
-    '	offset[4] = vec2( 0.0,   0.0);',
-    '	offset[5] = vec2( wh.x,  0.0);',
+    	offset[3] = vec2(-wh.x,  0.0);
+    	offset[4] = vec2( 0.0,   0.0);
+    	offset[5] = vec2( wh.x,  0.0);
 
-    '	offset[6] = vec2(-wh.x, wh.y);',
-    '	offset[7] = vec2( 0.0,  wh.y);',
-    '	offset[8] = vec2( wh.x, wh.y);',
+    	offset[6] = vec2(-wh.x, wh.y);
+    	offset[7] = vec2( 0.0,  wh.y);
+    	offset[8] = vec2( wh.x, wh.y);
 
-    '	kernel[0] = 1.0/16.0;   kernel[1] = 2.0/16.0;   kernel[2] = 1.0/16.0;',
-    '	kernel[3] = 2.0/16.0;   kernel[4] = 4.0/16.0;   kernel[5] = 2.0/16.0;',
-    '	kernel[6] = 1.0/16.0;   kernel[7] = 2.0/16.0;   kernel[8] = 1.0/16.0;',
+    	kernel[0] = 1.0/16.0;   kernel[1] = 2.0/16.0;   kernel[2] = 1.0/16.0;
+    	kernel[3] = 2.0/16.0;   kernel[4] = 4.0/16.0;   kernel[5] = 2.0/16.0;
+    	kernel[6] = 1.0/16.0;   kernel[7] = 2.0/16.0;   kernel[8] = 1.0/16.0;
 
-    '	for( int i=0; i<9; i++ ) {',
-    '		float tmp = texture2D(tDepth, coords + offset[i]).r;',
-    '		d += tmp * kernel[i];',
-    '	}',
+    	for( int i=0; i<9; i++ ) {
+    		float tmp = texture2D(tDepth, coords + offset[i]).r;
+    		d += tmp * kernel[i];
+    	}
 
-    '	return d;',
-    '}',
+    	return d;
+    }
 
-    'vec3 color(vec2 coords,float blur) {',
-    '	//processing the sample',
+    vec3 color(vec2 coords,float blur) {
+    	//processing the sample
 
-    '	vec3 col = vec3(0.0);',
-    '	vec2 texel = vec2(1.0/textureWidth,1.0/textureHeight);',
+    	vec3 col = vec3(0.0);
+    	vec2 texel = vec2(1.0/textureWidth,1.0/textureHeight);
 
-    '	col.r = texture2D(tColor,coords + vec2(0.0,1.0)*texel*fringe*blur).r;',
-    '	col.g = texture2D(tColor,coords + vec2(-0.866,-0.5)*texel*fringe*blur).g;',
-    '	col.b = texture2D(tColor,coords + vec2(0.866,-0.5)*texel*fringe*blur).b;',
+    	col.r = texture2D(tColor,coords + vec2(0.0,1.0)*texel*fringe*blur).r;
+    	col.g = texture2D(tColor,coords + vec2(-0.866,-0.5)*texel*fringe*blur).g;
+    	col.b = texture2D(tColor,coords + vec2(0.866,-0.5)*texel*fringe*blur).b;
 
-    '	vec3 lumcoeff = vec3(0.299,0.587,0.114);',
-    '	float lum = dot(col.rgb, lumcoeff);',
-    '	float thresh = max((lum-threshold)*gain, 0.0);',
-    '	return col+mix(vec3(0.0),col,thresh*blur);',
-    '}',
+    	vec3 lumcoeff = vec3(0.299,0.587,0.114);
+    	float lum = dot(col.rgb, lumcoeff);
+    	float thresh = max((lum-threshold)*gain, 0.0);
+    	return col+mix(vec3(0.0),col,thresh*blur);
+    }
 
-    'vec3 debugFocus(vec3 col, float blur, float depth) {',
-    '	float edge = 0.002*depth; //distance based edge smoothing',
-    '	float m = clamp(smoothstep(0.0,edge,blur),0.0,1.0);',
-    '	float e = clamp(smoothstep(1.0-edge,1.0,blur),0.0,1.0);',
+    vec3 debugFocus(vec3 col, float blur, float depth) {
+    	float edge = 0.002*depth; //distance based edge smoothing
+    	float m = clamp(smoothstep(0.0,edge,blur),0.0,1.0);
+    	float e = clamp(smoothstep(1.0-edge,1.0,blur),0.0,1.0);
 
-    '	col = mix(col,vec3(1.0,0.5,0.0),(1.0-m)*0.6);',
-    '	col = mix(col,vec3(0.0,0.5,1.0),((1.0-e)-(1.0-m))*0.2);',
+    	col = mix(col,vec3(1.0,0.5,0.0),(1.0-m)*0.6);
+    	col = mix(col,vec3(0.0,0.5,1.0),((1.0-e)-(1.0-m))*0.2);
 
-    '	return col;',
-    '}',
+    	return col;
+    }
 
-    'float linearize(float depth) {',
-    '	return -zfar * znear / (depth * (zfar - znear) - zfar);',
-    '}',
+    float linearize(float depth) {
+    	return -zfar * znear / (depth * (zfar - znear) - zfar);
+    }
 
-    'float vignette() {',
-    '	float dist = distance(vUv.xy, vec2(0.5,0.5));',
-    '	dist = smoothstep(vignout+(fstop/vignfade), vignin+(fstop/vignfade), dist);',
-    '	return clamp(dist,0.0,1.0);',
-    '}',
+    float vignette() {
+    	float dist = distance(vUv.xy, vec2(0.5,0.5));
+    	dist = smoothstep(vignout+(fstop/vignfade), vignin+(fstop/vignfade), dist);
+    	return clamp(dist,0.0,1.0);
+    }
 
-    'float gather(float i, float j, int ringsamples, inout vec3 col, float w, float h, float blur) {',
-    '	float rings2 = float(rings);',
-    '	float step = PI*2.0 / float(ringsamples);',
-    '	float pw = cos(j*step)*i;',
-    '	float ph = sin(j*step)*i;',
-    '	float p = 1.0;',
-    '	if (pentagon) {',
-    '		p = penta(vec2(pw,ph));',
-    '	}',
-    '	col += color(vUv.xy + vec2(pw*w,ph*h), blur) * mix(1.0, i/rings2, bias) * p;',
-    '	return 1.0 * mix(1.0, i /rings2, bias) * p;',
-    '}',
+    float gather(float i, float j, int ringsamples, inout vec3 col, float w, float h, float blur) {
+    	float rings2 = float(rings);
+    	float step = PI*2.0 / float(ringsamples);
+    	float pw = cos(j*step)*i;
+    	float ph = sin(j*step)*i;
+    	float p = 1.0;
+    	if (pentagon) {
+    		p = penta(vec2(pw,ph));
+    	}
+    	col += color(vUv.xy + vec2(pw*w,ph*h), blur) * mix(1.0, i/rings2, bias) * p;
+    	return 1.0 * mix(1.0, i /rings2, bias) * p;
+    }
 
-    'void main() {',
-    '	//scene depth calculation',
+    void main() {
+    	//scene depth calculation
 
-    '	float depth = linearize(texture2D(tDepth,vUv.xy).x);',
+    	float depth = linearize(texture2D(tDepth,vUv.xy).x);
 
-    '	// Blur depth?',
-    '	if ( depthblur ) {',
-    '		depth = linearize(bdepth(vUv.xy));',
-    '	}',
+    	// Blur depth?
+    	if ( depthblur ) {
+    		depth = linearize(bdepth(vUv.xy));
+    	}
 
-    '	//focal plane calculation',
+    	//focal plane calculation
 
-    '	float fDepth = focalDepth;',
+    	float fDepth = focalDepth;
 
-    '	if (shaderFocus) {',
+    	if (shaderFocus) {
 
-    '		fDepth = linearize(texture2D(tDepth,focusCoords).x);',
+    		fDepth = linearize(texture2D(tDepth,focusCoords).x);
 
-    '	}',
+    	}
 
-    '	// dof blur factor calculation',
+    	// dof blur factor calculation
 
-    '	float blur = 0.0;',
+    	float blur = 0.0;
 
-    '	if (manualdof) {',
-    '		float a = depth-fDepth; // Focal plane',
-    '		float b = (a-fdofstart)/fdofdist; // Far DoF',
-    '		float c = (-a-ndofstart)/ndofdist; // Near Dof',
-    '		blur = (a>0.0) ? b : c;',
-    '	} else {',
-    '		float f = focalLength; // focal length in mm',
-    '		float d = fDepth*1000.0; // focal plane in mm',
-    '		float o = depth*1000.0; // depth in mm',
+    	if (manualdof) {
+    		float a = depth-fDepth; // Focal plane
+    		float b = (a-fdofstart)/fdofdist; // Far DoF
+    		float c = (-a-ndofstart)/ndofdist; // Near Dof
+    		blur = (a>0.0) ? b : c;
+    	} else {
+    		float f = focalLength; // focal length in mm
+    		float d = fDepth*1000.0; // focal plane in mm
+    		float o = depth*1000.0; // depth in mm
 
-    '		float a = (o*f)/(o-f);',
-    '		float b = (d*f)/(d-f);',
-    '		float c = (d-f)/(d*fstop*CoC);',
+    		float a = (o*f)/(o-f);
+    		float b = (d*f)/(d-f);
+    		float c = (d-f)/(d*fstop*CoC);
 
-    '		blur = abs(a-b)*c;',
-    '	}',
+    		blur = abs(a-b)*c;
+    	}
 
-    '	blur = clamp(blur,0.0,1.0);',
+    	blur = clamp(blur,0.0,1.0);
 
-    '	// calculation of pattern for dithering',
+    	// calculation of pattern for dithering
 
-    '	vec2 noise = vec2(rand(vUv.xy), rand( vUv.xy + vec2( 0.4, 0.6 ) ) )*dithering*blur;',
+    	vec2 noise = vec2(rand(vUv.xy), rand( vUv.xy + vec2( 0.4, 0.6 ) ) )*dithering*blur;
 
-    '	// getting blur x and y step factor',
+    	// getting blur x and y step factor
 
-    '	float w = (1.0/textureWidth)*blur*maxblur+noise.x;',
-    '	float h = (1.0/textureHeight)*blur*maxblur+noise.y;',
+    	float w = (1.0/textureWidth)*blur*maxblur+noise.x;
+    	float h = (1.0/textureHeight)*blur*maxblur+noise.y;
 
-    '	// calculation of final color',
+    	// calculation of final color
 
-    '	vec3 col = vec3(0.0);',
+    	vec3 col = vec3(0.0);
 
-    '	if(blur < 0.05) {',
-    '		//some optimization thingy',
-    '		col = texture2D(tColor, vUv.xy).rgb;',
-    '	} else {',
-    '		col = texture2D(tColor, vUv.xy).rgb;',
-    '		float s = 1.0;',
-    '		int ringsamples;',
+    	if(blur < 0.05) {
+    		//some optimization thingy
+    		col = texture2D(tColor, vUv.xy).rgb;
+    	} else {
+    		col = texture2D(tColor, vUv.xy).rgb;
+    		float s = 1.0;
+    		int ringsamples;
 
-    '		for (int i = 1; i <= rings; i++) {',
-    '			/*unboxstart*/',
-    '			ringsamples = i * samples;',
+    		for (int i = 1; i <= rings; i++) {
+    			/*unboxstart*/
+    			ringsamples = i * samples;
 
-    '			for (int j = 0 ; j < maxringsamples ; j++) {',
-    '				if (j >= ringsamples) break;',
-    '				s += gather(float(i), float(j), ringsamples, col, w, h, blur);',
-    '			}',
-    '			/*unboxend*/',
-    '		}',
+    			for (int j = 0 ; j < maxringsamples ; j++) {
+    				if (j >= ringsamples) break;
+    				s += gather(float(i), float(j), ringsamples, col, w, h, blur);
+    			}
+    			/*unboxend*/
+    		}
 
-    '		col /= s; //divide by sample count',
-    '	}',
+    		col /= s; //divide by sample count
+    	}
 
-    '	if (showFocus) {',
-    '		col = debugFocus(col, blur, depth);',
-    '	}',
+    	if (showFocus) {
+    		col = debugFocus(col, blur, depth);
+    	}
 
-    '	if (vignetting) {',
-    '		col *= vignette();',
-    '	}',
+    	if (vignetting) {
+    		col *= vignette();
+    	}
 
-    '	gl_FragColor.rgb = col;',
-    '	gl_FragColor.a = 1.0;',
-    '} ',
-  ].join('\n'),
+    	gl_FragColor.rgb = col;
+    	gl_FragColor.a = 1.0;
+    } 
+  `,
 }
 
 export const BokehDepthShader = {
@@ -385,30 +385,30 @@ export const BokehDepthShader = {
     mFar: { value: 1000.0 },
   },
 
-  vertexShader: [
-    'varying float vViewZDepth;',
+  vertexShader: /* glsl */ `
+    varying float vViewZDepth;
 
-    'void main() {',
+    void main() {
 
-    '	#include <begin_vertex>',
-    '	#include <project_vertex>',
+    	#include <begin_vertex>
+    	#include <project_vertex>
 
-    '	vViewZDepth = - mvPosition.z;',
+    	vViewZDepth = - mvPosition.z;
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform float mNear;',
-    'uniform float mFar;',
+  fragmentShader: /* glsl */ `
+    uniform float mNear;
+    uniform float mFar;
 
-    'varying float vViewZDepth;',
+    varying float vViewZDepth;
 
-    'void main() {',
+    void main() {
 
-    '	float color = 1.0 - smoothstep( mNear, mFar, vViewZDepth );',
-    '	gl_FragColor = vec4( vec3( color ), 1.0 );',
+    	float color = 1.0 - smoothstep( mNear, mFar, vViewZDepth );
+    	gl_FragColor = vec4( vec3( color ), 1.0 );
 
-    '} ',
-  ].join('\n'),
+    } 
+  `,
 }
diff --git a/src/shaders/BrightnessContrastShader.ts b/src/shaders/BrightnessContrastShader.ts
index 56c15b3a..c2d77b3a 100644
--- a/src/shaders/BrightnessContrastShader.ts
+++ b/src/shaders/BrightnessContrastShader.ts
@@ -12,37 +12,37 @@ export const BrightnessContrastShader = {
     contrast: { value: 0 },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
+    	vUv = uv;
 
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform sampler2D tDiffuse;',
-    'uniform float brightness;',
-    'uniform float contrast;',
+  fragmentShader: /* glsl */ `
+    uniform sampler2D tDiffuse;
+    uniform float brightness;
+    uniform float contrast;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	gl_FragColor = texture2D( tDiffuse, vUv );',
+    	gl_FragColor = texture2D( tDiffuse, vUv );
 
-    '	gl_FragColor.rgb += brightness;',
+    	gl_FragColor.rgb += brightness;
 
-    '	if (contrast > 0.0) {',
-    '		gl_FragColor.rgb = (gl_FragColor.rgb - 0.5) / (1.0 - contrast) + 0.5;',
-    '	} else {',
-    '		gl_FragColor.rgb = (gl_FragColor.rgb - 0.5) * (1.0 + contrast) + 0.5;',
-    '	}',
+    	if (contrast > 0.0) {
+    		gl_FragColor.rgb = (gl_FragColor.rgb - 0.5) / (1.0 - contrast) + 0.5;
+    	} else {
+    		gl_FragColor.rgb = (gl_FragColor.rgb - 0.5) * (1.0 + contrast) + 0.5;
+    	}
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/ColorCorrectionShader.ts b/src/shaders/ColorCorrectionShader.ts
index 2e63a4b3..29e77305 100644
--- a/src/shaders/ColorCorrectionShader.ts
+++ b/src/shaders/ColorCorrectionShader.ts
@@ -7,36 +7,36 @@ import { Vector3 } from 'three'
 export const ColorCorrectionShader = {
   uniforms: {
     tDiffuse: { value: null },
-    powRGB: { value: new Vector3(2, 2, 2) },
-    mulRGB: { value: new Vector3(1, 1, 1) },
-    addRGB: { value: new Vector3(0, 0, 0) },
+    powRGB: { value: /* @__PURE__ */ new Vector3(2, 2, 2) },
+    mulRGB: { value: /* @__PURE__ */ new Vector3(1, 1, 1) },
+    addRGB: { value: /* @__PURE__ */ new Vector3(0, 0, 0) },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
+    	vUv = uv;
 
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform sampler2D tDiffuse;',
-    'uniform vec3 powRGB;',
-    'uniform vec3 mulRGB;',
-    'uniform vec3 addRGB;',
+  fragmentShader: /* glsl */ `
+    uniform sampler2D tDiffuse;
+    uniform vec3 powRGB;
+    uniform vec3 mulRGB;
+    uniform vec3 addRGB;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	gl_FragColor = texture2D( tDiffuse, vUv );',
-    '	gl_FragColor.rgb = mulRGB * pow( ( gl_FragColor.rgb + addRGB ), powRGB );',
+    	gl_FragColor = texture2D( tDiffuse, vUv );
+    	gl_FragColor.rgb = mulRGB * pow( ( gl_FragColor.rgb + addRGB ), powRGB );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/ColorifyShader.ts b/src/shaders/ColorifyShader.ts
index 68f74c5f..0554126b 100644
--- a/src/shaders/ColorifyShader.ts
+++ b/src/shaders/ColorifyShader.ts
@@ -7,35 +7,35 @@ import { Color } from 'three'
 export const ColorifyShader = {
   uniforms: {
     tDiffuse: { value: null },
-    color: { value: new Color(0xffffff) },
+    color: { value: /* @__PURE__ */ new Color(0xffffff) },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform vec3 color;',
-    'uniform sampler2D tDiffuse;',
+  fragmentShader: /* glsl */ `
+    uniform vec3 color;
+    uniform sampler2D tDiffuse;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vec4 texel = texture2D( tDiffuse, vUv );',
+    	vec4 texel = texture2D( tDiffuse, vUv );
 
-    '	vec3 luma = vec3( 0.299, 0.587, 0.114 );',
-    '	float v = dot( texel.xyz, luma );',
+    	vec3 luma = vec3( 0.299, 0.587, 0.114 );
+    	float v = dot( texel.xyz, luma );
 
-    '	gl_FragColor = vec4( v * color, texel.w );',
+    	gl_FragColor = vec4( v * color, texel.w );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/ConvolutionShader.ts b/src/shaders/ConvolutionShader.ts
index 3d1c5126..5a18083e 100644
--- a/src/shaders/ConvolutionShader.ts
+++ b/src/shaders/ConvolutionShader.ts
@@ -32,47 +32,47 @@ export const ConvolutionShader: IConvolutionShader = {
 
   uniforms: {
     tDiffuse: { value: null },
-    uImageIncrement: { value: new Vector2(0.001953125, 0.0) },
+    uImageIncrement: { value: /* @__PURE__ */ new Vector2(0.001953125, 0.0) },
     cKernel: { value: [] },
   },
 
-  vertexShader: [
-    'uniform vec2 uImageIncrement;',
+  vertexShader: /* glsl */ `
+    uniform vec2 uImageIncrement;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv - ( ( KERNEL_SIZE_FLOAT - 1.0 ) / 2.0 ) * uImageIncrement;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv - ( ( KERNEL_SIZE_FLOAT - 1.0 ) / 2.0 ) * uImageIncrement;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform float cKernel[ KERNEL_SIZE_INT ];',
+  fragmentShader: /* glsl */ `
+    uniform float cKernel[ KERNEL_SIZE_INT ];
 
-    'uniform sampler2D tDiffuse;',
-    'uniform vec2 uImageIncrement;',
+    uniform sampler2D tDiffuse;
+    uniform vec2 uImageIncrement;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vec2 imageCoord = vUv;',
-    '	vec4 sum = vec4( 0.0, 0.0, 0.0, 0.0 );',
+    	vec2 imageCoord = vUv;
+    	vec4 sum = vec4( 0.0, 0.0, 0.0, 0.0 );
 
-    '	for( int i = 0; i < KERNEL_SIZE_INT; i ++ ) {',
+    	for( int i = 0; i < KERNEL_SIZE_INT; i ++ ) {
 
-    '		sum += texture2D( tDiffuse, imageCoord ) * cKernel[ i ];',
-    '		imageCoord += uImageIncrement;',
+    		sum += texture2D( tDiffuse, imageCoord ) * cKernel[ i ];
+    		imageCoord += uImageIncrement;
 
-    '	}',
+    	}
 
-    '	gl_FragColor = sum;',
+    	gl_FragColor = sum;
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
   buildKernel: function (sigma) {
     // We lop off the sqrt(2 * pi) * sigma term, since we're going to normalize anyway.
diff --git a/src/shaders/CopyShader.ts b/src/shaders/CopyShader.ts
index ad38d817..3bae6f68 100644
--- a/src/shaders/CopyShader.ts
+++ b/src/shaders/CopyShader.ts
@@ -18,29 +18,29 @@ export const CopyShader: ICopyShader = {
     opacity: { value: 1.0 },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform float opacity;',
+  fragmentShader: /* glsl */ `
+    uniform float opacity;
 
-    'uniform sampler2D tDiffuse;',
+    uniform sampler2D tDiffuse;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vec4 texel = texture2D( tDiffuse, vUv );',
-    '	gl_FragColor = opacity * texel;',
+    	vec4 texel = texture2D( tDiffuse, vUv );
+    	gl_FragColor = opacity * texel;
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/DOFMipMapShader.ts b/src/shaders/DOFMipMapShader.ts
index 00c38c52..6b068ea3 100644
--- a/src/shaders/DOFMipMapShader.ts
+++ b/src/shaders/DOFMipMapShader.ts
@@ -12,37 +12,37 @@ export const DOFMipMapShader = {
     maxblur: { value: 1.0 },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform float focus;',
-    'uniform float maxblur;',
+  fragmentShader: /* glsl */ `
+    uniform float focus;
+    uniform float maxblur;
 
-    'uniform sampler2D tColor;',
-    'uniform sampler2D tDepth;',
+    uniform sampler2D tColor;
+    uniform sampler2D tDepth;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vec4 depth = texture2D( tDepth, vUv );',
+    	vec4 depth = texture2D( tDepth, vUv );
 
-    '	float factor = depth.x - focus;',
+    	float factor = depth.x - focus;
 
-    '	vec4 col = texture2D( tColor, vUv, 2.0 * maxblur * abs( focus - depth.x ) );',
+    	vec4 col = texture2D( tColor, vUv, 2.0 * maxblur * abs( focus - depth.x ) );
 
-    '	gl_FragColor = col;',
-    '	gl_FragColor.a = 1.0;',
+    	gl_FragColor = col;
+    	gl_FragColor.a = 1.0;
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/DepthLimitedBlurShader.ts b/src/shaders/DepthLimitedBlurShader.ts
index 2e962893..ddff62ec 100644
--- a/src/shaders/DepthLimitedBlurShader.ts
+++ b/src/shaders/DepthLimitedBlurShader.ts
@@ -33,104 +33,104 @@ export const DepthLimitedBlurShader: IDepthLimitedBlurShader = {
   },
   uniforms: {
     tDiffuse: { value: null },
-    size: { value: new Vector2(512, 512) },
-    sampleUvOffsets: { value: [new Vector2(0, 0)] },
+    size: { value: /* @__PURE__ */ new Vector2(512, 512) },
+    sampleUvOffsets: { value: [/* @__PURE__ */ new Vector2(0, 0)] },
     sampleWeights: { value: [1.0] },
     tDepth: { value: null },
     cameraNear: { value: 10 },
     cameraFar: { value: 1000 },
     depthCutoff: { value: 10 },
   },
-  vertexShader: [
-    '#include <common>',
+  vertexShader: /* glsl */ `
+    #include <common>
 
-    'uniform vec2 size;',
+    uniform vec2 size;
 
-    'varying vec2 vUv;',
-    'varying vec2 vInvSize;',
+    varying vec2 vUv;
+    varying vec2 vInvSize;
 
-    'void main() {',
-    '	vUv = uv;',
-    '	vInvSize = 1.0 / size;',
+    void main() {
+    	vUv = uv;
+    	vInvSize = 1.0 / size;
 
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
-    '}',
-  ].join('\n'),
-  fragmentShader: [
-    '#include <common>',
-    '#include <packing>',
-
-    'uniform sampler2D tDiffuse;',
-    'uniform sampler2D tDepth;',
-
-    'uniform float cameraNear;',
-    'uniform float cameraFar;',
-    'uniform float depthCutoff;',
-
-    'uniform vec2 sampleUvOffsets[ KERNEL_RADIUS + 1 ];',
-    'uniform float sampleWeights[ KERNEL_RADIUS + 1 ];',
-
-    'varying vec2 vUv;',
-    'varying vec2 vInvSize;',
-
-    'float getDepth( const in vec2 screenPosition ) {',
-    '	#if DEPTH_PACKING == 1',
-    '	return unpackRGBAToDepth( texture2D( tDepth, screenPosition ) );',
-    '	#else',
-    '	return texture2D( tDepth, screenPosition ).x;',
-    '	#endif',
-    '}',
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    }
+  `,
+  fragmentShader: /* glsl */ `
+    #include <common>
+    #include <packing>
+
+    uniform sampler2D tDiffuse;
+    uniform sampler2D tDepth;
+
+    uniform float cameraNear;
+    uniform float cameraFar;
+    uniform float depthCutoff;
+
+    uniform vec2 sampleUvOffsets[ KERNEL_RADIUS + 1 ];
+    uniform float sampleWeights[ KERNEL_RADIUS + 1 ];
+
+    varying vec2 vUv;
+    varying vec2 vInvSize;
+
+    float getDepth( const in vec2 screenPosition ) {
+    	#if DEPTH_PACKING == 1
+    	return unpackRGBAToDepth( texture2D( tDepth, screenPosition ) );
+    	#else
+    	return texture2D( tDepth, screenPosition ).x;
+    	#endif
+    }
 
-    'float getViewZ( const in float depth ) {',
-    '	#if PERSPECTIVE_CAMERA == 1',
-    '	return perspectiveDepthToViewZ( depth, cameraNear, cameraFar );',
-    '	#else',
-    '	return orthographicDepthToViewZ( depth, cameraNear, cameraFar );',
-    '	#endif',
-    '}',
+    float getViewZ( const in float depth ) {
+    	#if PERSPECTIVE_CAMERA == 1
+    	return perspectiveDepthToViewZ( depth, cameraNear, cameraFar );
+    	#else
+    	return orthographicDepthToViewZ( depth, cameraNear, cameraFar );
+    	#endif
+    }
 
-    'void main() {',
-    '	float depth = getDepth( vUv );',
-    '	if( depth >= ( 1.0 - EPSILON ) ) {',
-    '		discard;',
-    '	}',
+    void main() {
+    	float depth = getDepth( vUv );
+    	if( depth >= ( 1.0 - EPSILON ) ) {
+    		discard;
+    	}
 
-    '	float centerViewZ = -getViewZ( depth );',
-    '	bool rBreak = false, lBreak = false;',
+    	float centerViewZ = -getViewZ( depth );
+    	bool rBreak = false, lBreak = false;
 
-    '	float weightSum = sampleWeights[0];',
-    '	vec4 diffuseSum = texture2D( tDiffuse, vUv ) * weightSum;',
+    	float weightSum = sampleWeights[0];
+    	vec4 diffuseSum = texture2D( tDiffuse, vUv ) * weightSum;
 
-    '	for( int i = 1; i <= KERNEL_RADIUS; i ++ ) {',
+    	for( int i = 1; i <= KERNEL_RADIUS; i ++ ) {
 
-    '		float sampleWeight = sampleWeights[i];',
-    '		vec2 sampleUvOffset = sampleUvOffsets[i] * vInvSize;',
+    		float sampleWeight = sampleWeights[i];
+    		vec2 sampleUvOffset = sampleUvOffsets[i] * vInvSize;
 
-    '		vec2 sampleUv = vUv + sampleUvOffset;',
-    '		float viewZ = -getViewZ( getDepth( sampleUv ) );',
+    		vec2 sampleUv = vUv + sampleUvOffset;
+    		float viewZ = -getViewZ( getDepth( sampleUv ) );
 
-    '		if( abs( viewZ - centerViewZ ) > depthCutoff ) rBreak = true;',
+    		if( abs( viewZ - centerViewZ ) > depthCutoff ) rBreak = true;
 
-    '		if( ! rBreak ) {',
-    '			diffuseSum += texture2D( tDiffuse, sampleUv ) * sampleWeight;',
-    '			weightSum += sampleWeight;',
-    '		}',
+    		if( ! rBreak ) {
+    			diffuseSum += texture2D( tDiffuse, sampleUv ) * sampleWeight;
+    			weightSum += sampleWeight;
+    		}
 
-    '		sampleUv = vUv - sampleUvOffset;',
-    '		viewZ = -getViewZ( getDepth( sampleUv ) );',
+    		sampleUv = vUv - sampleUvOffset;
+    		viewZ = -getViewZ( getDepth( sampleUv ) );
 
-    '		if( abs( viewZ - centerViewZ ) > depthCutoff ) lBreak = true;',
+    		if( abs( viewZ - centerViewZ ) > depthCutoff ) lBreak = true;
 
-    '		if( ! lBreak ) {',
-    '			diffuseSum += texture2D( tDiffuse, sampleUv ) * sampleWeight;',
-    '			weightSum += sampleWeight;',
-    '		}',
+    		if( ! lBreak ) {
+    			diffuseSum += texture2D( tDiffuse, sampleUv ) * sampleWeight;
+    			weightSum += sampleWeight;
+    		}
 
-    '	}',
+    	}
 
-    '	gl_FragColor = diffuseSum / weightSum;',
-    '}',
-  ].join('\n'),
+    	gl_FragColor = diffuseSum / weightSum;
+    }
+  `,
 }
 
 export const BlurShaderUtils = {
diff --git a/src/shaders/DigitalGlitch.ts b/src/shaders/DigitalGlitch.ts
index 1a3ff844..c2244cf7 100644
--- a/src/shaders/DigitalGlitch.ts
+++ b/src/shaders/DigitalGlitch.ts
@@ -13,67 +13,72 @@ export const DigitalGlitch = {
     col_s: { value: 0.05 },
   },
 
-  vertexShader: `varying vec2 vUv;
-     void main() {
-     	 vUv = uv;
-     	 gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
-     }`,
+  vertexShader: /* glsl */ `
+		varying vec2 vUv;
 
-  fragmentShader: `uniform int byp; //should we apply the glitch ?
-     uniform sampler2D tDiffuse;
-     uniform sampler2D tDisp;
-     uniform float amount;
-     uniform float angle;
-     uniform float seed;
-     uniform float seed_x;
-     uniform float seed_y;
-     uniform float distortion_x;
-     uniform float distortion_y;
-     uniform float col_s;
+		void main() {
+			vUv = uv;
+			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+		}
+	`,
 
-     varying vec2 vUv;
+  fragmentShader: /* glsl */ `
+		uniform int byp; //should we apply the glitch ?
+		uniform sampler2D tDiffuse;
+		uniform sampler2D tDisp;
+		uniform float amount;
+		uniform float angle;
+		uniform float seed;
+		uniform float seed_x;
+		uniform float seed_y;
+		uniform float distortion_x;
+		uniform float distortion_y;
+		uniform float col_s;
 
-     float rand(vec2 co){
-     	 return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
-     }
+		varying vec2 vUv;
 
-     void main() {
-     	if(byp<1) {
-     		vec2 p = vUv;
-     		float xs = floor(gl_FragCoord.x / 0.5);
-     		float ys = floor(gl_FragCoord.y / 0.5);
-    //based on staffantans glitch shader for unity https://github.com/staffantan/unityglitch
-     		vec4 normal = texture2D (tDisp, p*seed*seed);
-     		if(p.y<distortion_x+col_s && p.y>distortion_x-col_s*seed) {
-     			if(seed_x>0.){
-     				p.y = 1. - (p.y + distortion_y);
-     			}
-     			else {
-     				p.y = distortion_y;
-     			}
-     		}
-     		if(p.x<distortion_y+col_s && p.x>distortion_y-col_s*seed) {
-     			if(seed_y>0.){
-     				p.x=distortion_x;
-     			}
-     			else {
-     				p.x = 1. - (p.x + distortion_x);
-     			}
-     		}
-     		p.x+=normal.x*seed_x*(seed/5.);
-     		p.y+=normal.y*seed_y*(seed/5.);
-    //base from RGB shift shader
-     		vec2 offset = amount * vec2( cos(angle), sin(angle));
-     		vec4 cr = texture2D(tDiffuse, p + offset);
-     		vec4 cga = texture2D(tDiffuse, p);
-     		vec4 cb = texture2D(tDiffuse, p - offset);
-     		gl_FragColor = vec4(cr.r, cga.g, cb.b, cga.a);
-    //add noise
-     		vec4 snow = 200.*amount*vec4(rand(vec2(xs * seed,ys * seed*50.))*0.2);
-     		gl_FragColor = gl_FragColor+ snow;
-     	}
-     	else {
-     		gl_FragColor=texture2D (tDiffuse, vUv);
-     	}
-    }`,
+		float rand(vec2 co){
+			return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
+		}
+
+		void main() {
+			if(byp<1) {
+				vec2 p = vUv;
+				float xs = floor(gl_FragCoord.x / 0.5);
+				float ys = floor(gl_FragCoord.y / 0.5);
+		//based on staffantans glitch shader for unity https://github.com/staffantan/unityglitch
+				vec4 normal = texture2D (tDisp, p*seed*seed);
+				if(p.y<distortion_x+col_s && p.y>distortion_x-col_s*seed) {
+					if(seed_x>0.){
+						p.y = 1. - (p.y + distortion_y);
+					}
+					else {
+						p.y = distortion_y;
+					}
+				}
+				if(p.x<distortion_y+col_s && p.x>distortion_y-col_s*seed) {
+					if(seed_y>0.){
+						p.x=distortion_x;
+					}
+					else {
+						p.x = 1. - (p.x + distortion_x);
+					}
+				}
+				p.x+=normal.x*seed_x*(seed/5.);
+				p.y+=normal.y*seed_y*(seed/5.);
+		//base from RGB shift shader
+				vec2 offset = amount * vec2( cos(angle), sin(angle));
+				vec4 cr = texture2D(tDiffuse, p + offset);
+				vec4 cga = texture2D(tDiffuse, p);
+				vec4 cb = texture2D(tDiffuse, p - offset);
+				gl_FragColor = vec4(cr.r, cga.g, cb.b, cga.a);
+		//add noise
+				vec4 snow = 200.*amount*vec4(rand(vec2(xs * seed,ys * seed*50.))*0.2);
+				gl_FragColor = gl_FragColor+ snow;
+			}
+			else {
+				gl_FragColor=texture2D (tDiffuse, vUv);
+			}
+		}
+`,
 }
diff --git a/src/shaders/DotScreenShader.ts b/src/shaders/DotScreenShader.ts
index aa01e7b1..83a205a8 100644
--- a/src/shaders/DotScreenShader.ts
+++ b/src/shaders/DotScreenShader.ts
@@ -9,52 +9,52 @@ import { Vector2 } from 'three'
 export const DotScreenShader = {
   uniforms: {
     tDiffuse: { value: null },
-    tSize: { value: new Vector2(256, 256) },
-    center: { value: new Vector2(0.5, 0.5) },
+    tSize: { value: /* @__PURE__ */ new Vector2(256, 256) },
+    center: { value: /* @__PURE__ */ new Vector2(0.5, 0.5) },
     angle: { value: 1.57 },
     scale: { value: 1.0 },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform vec2 center;',
-    'uniform float angle;',
-    'uniform float scale;',
-    'uniform vec2 tSize;',
+  fragmentShader: /* glsl */ `
+    uniform vec2 center;
+    uniform float angle;
+    uniform float scale;
+    uniform vec2 tSize;
 
-    'uniform sampler2D tDiffuse;',
+    uniform sampler2D tDiffuse;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'float pattern() {',
+    float pattern() {
 
-    '	float s = sin( angle ), c = cos( angle );',
+    	float s = sin( angle ), c = cos( angle );
 
-    '	vec2 tex = vUv * tSize - center;',
-    '	vec2 point = vec2( c * tex.x - s * tex.y, s * tex.x + c * tex.y ) * scale;',
+    	vec2 tex = vUv * tSize - center;
+    	vec2 point = vec2( c * tex.x - s * tex.y, s * tex.x + c * tex.y ) * scale;
 
-    '	return ( sin( point.x ) * sin( point.y ) ) * 4.0;',
+    	return ( sin( point.x ) * sin( point.y ) ) * 4.0;
 
-    '}',
+    }
 
-    'void main() {',
+    void main() {
 
-    '	vec4 color = texture2D( tDiffuse, vUv );',
+    	vec4 color = texture2D( tDiffuse, vUv );
 
-    '	float average = ( color.r + color.g + color.b ) / 3.0;',
+    	float average = ( color.r + color.g + color.b ) / 3.0;
 
-    '	gl_FragColor = vec4( vec3( average * 10.0 - 5.0 + pattern() ), color.a );',
+    	gl_FragColor = vec4( vec3( average * 10.0 - 5.0 + pattern() ), color.a );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/FXAAShader.ts b/src/shaders/FXAAShader.ts
index 795b5677..dbb313db 100644
--- a/src/shaders/FXAAShader.ts
+++ b/src/shaders/FXAAShader.ts
@@ -10,1099 +10,1099 @@ import { Vector2 } from 'three'
 export const FXAAShader = {
   uniforms: {
     tDiffuse: { value: null },
-    resolution: { value: new Vector2(1 / 1024, 1 / 512) },
+    resolution: { value: /* @__PURE__ */ new Vector2(1 / 1024, 1 / 512) },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'precision highp float;',
-    '',
-    'uniform sampler2D tDiffuse;',
-    '',
-    'uniform vec2 resolution;',
-    '',
-    'varying vec2 vUv;',
-    '',
-    '// FXAA 3.11 implementation by NVIDIA, ported to WebGL by Agost Biro (biro@archilogic.com)',
-    '',
-    '//----------------------------------------------------------------------------------',
-    '// File:        es3-keplerFXAAassetsshaders/FXAA_DefaultES.frag',
-    '// SDK Version: v3.00',
-    '// Email:       gameworks@nvidia.com',
-    '// Site:        http://developer.nvidia.com/',
-    '//',
-    '// Copyright (c) 2014-2015, NVIDIA CORPORATION. All rights reserved.',
-    '//',
-    '// Redistribution and use in source and binary forms, with or without',
-    '// modification, are permitted provided that the following conditions',
-    '// are met:',
-    '//  * Redistributions of source code must retain the above copyright',
-    '//    notice, this list of conditions and the following disclaimer.',
-    '//  * Redistributions in binary form must reproduce the above copyright',
-    '//    notice, this list of conditions and the following disclaimer in the',
-    '//    documentation and/or other materials provided with the distribution.',
-    '//  * Neither the name of NVIDIA CORPORATION nor the names of its',
-    '//    contributors may be used to endorse or promote products derived',
-    '//    from this software without specific prior written permission.',
-    '//',
-    "// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY",
-    '// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE',
-    '// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR',
-    '// PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR',
-    '// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,',
-    '// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,',
-    '// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR',
-    '// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY',
-    '// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT',
-    '// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE',
-    '// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.',
-    '//',
-    '//----------------------------------------------------------------------------------',
-    '',
-    '#define FXAA_PC 1',
-    '#define FXAA_GLSL_100 1',
-    '#define FXAA_QUALITY_PRESET 12',
-    '',
-    '#define FXAA_GREEN_AS_LUMA 1',
-    '',
-    '/*--------------------------------------------------------------------------*/',
-    '#ifndef FXAA_PC_CONSOLE',
-    '    //',
-    '    // The console algorithm for PC is included',
-    '    // for developers targeting really low spec machines.',
-    '    // Likely better to just run FXAA_PC, and use a really low preset.',
-    '    //',
-    '    #define FXAA_PC_CONSOLE 0',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#ifndef FXAA_GLSL_120',
-    '    #define FXAA_GLSL_120 0',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#ifndef FXAA_GLSL_130',
-    '    #define FXAA_GLSL_130 0',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#ifndef FXAA_HLSL_3',
-    '    #define FXAA_HLSL_3 0',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#ifndef FXAA_HLSL_4',
-    '    #define FXAA_HLSL_4 0',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#ifndef FXAA_HLSL_5',
-    '    #define FXAA_HLSL_5 0',
-    '#endif',
-    '/*==========================================================================*/',
-    '#ifndef FXAA_GREEN_AS_LUMA',
-    '    //',
-    '    // For those using non-linear color,',
-    '    // and either not able to get luma in alpha, or not wanting to,',
-    '    // this enables FXAA to run using green as a proxy for luma.',
-    '    // So with this enabled, no need to pack luma in alpha.',
-    '    //',
-    '    // This will turn off AA on anything which lacks some amount of green.',
-    '    // Pure red and blue or combination of only R and B, will get no AA.',
-    '    //',
-    '    // Might want to lower the settings for both,',
-    '    //    fxaaConsoleEdgeThresholdMin',
-    '    //    fxaaQualityEdgeThresholdMin',
-    '    // In order to insure AA does not get turned off on colors',
-    '    // which contain a minor amount of green.',
-    '    //',
-    '    // 1 = On.',
-    '    // 0 = Off.',
-    '    //',
-    '    #define FXAA_GREEN_AS_LUMA 0',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#ifndef FXAA_EARLY_EXIT',
-    '    //',
-    "    // Controls algorithm's early exit path.",
-    '    // On PS3 turning this ON adds 2 cycles to the shader.',
-    '    // On 360 turning this OFF adds 10ths of a millisecond to the shader.',
-    '    // Turning this off on console will result in a more blurry image.',
-    '    // So this defaults to on.',
-    '    //',
-    '    // 1 = On.',
-    '    // 0 = Off.',
-    '    //',
-    '    #define FXAA_EARLY_EXIT 1',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#ifndef FXAA_DISCARD',
-    '    //',
-    '    // Only valid for PC OpenGL currently.',
-    '    // Probably will not work when FXAA_GREEN_AS_LUMA = 1.',
-    '    //',
-    "    // 1 = Use discard on pixels which don't need AA.",
-    '    //     For APIs which enable concurrent TEX+ROP from same surface.',
-    "    // 0 = Return unchanged color on pixels which don't need AA.",
-    '    //',
-    '    #define FXAA_DISCARD 0',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#ifndef FXAA_FAST_PIXEL_OFFSET',
-    '    //',
-    '    // Used for GLSL 120 only.',
-    '    //',
-    '    // 1 = GL API supports fast pixel offsets',
-    '    // 0 = do not use fast pixel offsets',
-    '    //',
-    '    #ifdef GL_EXT_gpu_shader4',
-    '        #define FXAA_FAST_PIXEL_OFFSET 1',
-    '    #endif',
-    '    #ifdef GL_NV_gpu_shader5',
-    '        #define FXAA_FAST_PIXEL_OFFSET 1',
-    '    #endif',
-    '    #ifdef GL_ARB_gpu_shader5',
-    '        #define FXAA_FAST_PIXEL_OFFSET 1',
-    '    #endif',
-    '    #ifndef FXAA_FAST_PIXEL_OFFSET',
-    '        #define FXAA_FAST_PIXEL_OFFSET 0',
-    '    #endif',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#ifndef FXAA_GATHER4_ALPHA',
-    '    //',
-    '    // 1 = API supports gather4 on alpha channel.',
-    '    // 0 = API does not support gather4 on alpha channel.',
-    '    //',
-    '    #if (FXAA_HLSL_5 == 1)',
-    '        #define FXAA_GATHER4_ALPHA 1',
-    '    #endif',
-    '    #ifdef GL_ARB_gpu_shader5',
-    '        #define FXAA_GATHER4_ALPHA 1',
-    '    #endif',
-    '    #ifdef GL_NV_gpu_shader5',
-    '        #define FXAA_GATHER4_ALPHA 1',
-    '    #endif',
-    '    #ifndef FXAA_GATHER4_ALPHA',
-    '        #define FXAA_GATHER4_ALPHA 0',
-    '    #endif',
-    '#endif',
-    '',
-    '',
-    '/*============================================================================',
-    '                        FXAA QUALITY - TUNING KNOBS',
-    '------------------------------------------------------------------------------',
-    'NOTE the other tuning knobs are now in the shader function inputs!',
-    '============================================================================*/',
-    '#ifndef FXAA_QUALITY_PRESET',
-    '    //',
-    '    // Choose the quality preset.',
-    '    // This needs to be compiled into the shader as it effects code.',
-    '    // Best option to include multiple presets is to',
-    '    // in each shader define the preset, then include this file.',
-    '    //',
-    '    // OPTIONS',
-    '    // -----------------------------------------------------------------------',
-    '    // 10 to 15 - default medium dither (10=fastest, 15=highest quality)',
-    '    // 20 to 29 - less dither, more expensive (20=fastest, 29=highest quality)',
-    '    // 39       - no dither, very expensive',
-    '    //',
-    '    // NOTES',
-    '    // -----------------------------------------------------------------------',
-    '    // 12 = slightly faster then FXAA 3.9 and higher edge quality (default)',
-    '    // 13 = about same speed as FXAA 3.9 and better than 12',
-    '    // 23 = closest to FXAA 3.9 visually and performance wise',
-    '    //  _ = the lowest digit is directly related to performance',
-    '    // _  = the highest digit is directly related to style',
-    '    //',
-    '    #define FXAA_QUALITY_PRESET 12',
-    '#endif',
-    '',
-    '',
-    '/*============================================================================',
-    '',
-    '                           FXAA QUALITY - PRESETS',
-    '',
-    '============================================================================*/',
-    '',
-    '/*============================================================================',
-    '                     FXAA QUALITY - MEDIUM DITHER PRESETS',
-    '============================================================================*/',
-    '#if (FXAA_QUALITY_PRESET == 10)',
-    '    #define FXAA_QUALITY_PS 3',
-    '    #define FXAA_QUALITY_P0 1.5',
-    '    #define FXAA_QUALITY_P1 3.0',
-    '    #define FXAA_QUALITY_P2 12.0',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#if (FXAA_QUALITY_PRESET == 11)',
-    '    #define FXAA_QUALITY_PS 4',
-    '    #define FXAA_QUALITY_P0 1.0',
-    '    #define FXAA_QUALITY_P1 1.5',
-    '    #define FXAA_QUALITY_P2 3.0',
-    '    #define FXAA_QUALITY_P3 12.0',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#if (FXAA_QUALITY_PRESET == 12)',
-    '    #define FXAA_QUALITY_PS 5',
-    '    #define FXAA_QUALITY_P0 1.0',
-    '    #define FXAA_QUALITY_P1 1.5',
-    '    #define FXAA_QUALITY_P2 2.0',
-    '    #define FXAA_QUALITY_P3 4.0',
-    '    #define FXAA_QUALITY_P4 12.0',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#if (FXAA_QUALITY_PRESET == 13)',
-    '    #define FXAA_QUALITY_PS 6',
-    '    #define FXAA_QUALITY_P0 1.0',
-    '    #define FXAA_QUALITY_P1 1.5',
-    '    #define FXAA_QUALITY_P2 2.0',
-    '    #define FXAA_QUALITY_P3 2.0',
-    '    #define FXAA_QUALITY_P4 4.0',
-    '    #define FXAA_QUALITY_P5 12.0',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#if (FXAA_QUALITY_PRESET == 14)',
-    '    #define FXAA_QUALITY_PS 7',
-    '    #define FXAA_QUALITY_P0 1.0',
-    '    #define FXAA_QUALITY_P1 1.5',
-    '    #define FXAA_QUALITY_P2 2.0',
-    '    #define FXAA_QUALITY_P3 2.0',
-    '    #define FXAA_QUALITY_P4 2.0',
-    '    #define FXAA_QUALITY_P5 4.0',
-    '    #define FXAA_QUALITY_P6 12.0',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#if (FXAA_QUALITY_PRESET == 15)',
-    '    #define FXAA_QUALITY_PS 8',
-    '    #define FXAA_QUALITY_P0 1.0',
-    '    #define FXAA_QUALITY_P1 1.5',
-    '    #define FXAA_QUALITY_P2 2.0',
-    '    #define FXAA_QUALITY_P3 2.0',
-    '    #define FXAA_QUALITY_P4 2.0',
-    '    #define FXAA_QUALITY_P5 2.0',
-    '    #define FXAA_QUALITY_P6 4.0',
-    '    #define FXAA_QUALITY_P7 12.0',
-    '#endif',
-    '',
-    '/*============================================================================',
-    '                     FXAA QUALITY - LOW DITHER PRESETS',
-    '============================================================================*/',
-    '#if (FXAA_QUALITY_PRESET == 20)',
-    '    #define FXAA_QUALITY_PS 3',
-    '    #define FXAA_QUALITY_P0 1.5',
-    '    #define FXAA_QUALITY_P1 2.0',
-    '    #define FXAA_QUALITY_P2 8.0',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#if (FXAA_QUALITY_PRESET == 21)',
-    '    #define FXAA_QUALITY_PS 4',
-    '    #define FXAA_QUALITY_P0 1.0',
-    '    #define FXAA_QUALITY_P1 1.5',
-    '    #define FXAA_QUALITY_P2 2.0',
-    '    #define FXAA_QUALITY_P3 8.0',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#if (FXAA_QUALITY_PRESET == 22)',
-    '    #define FXAA_QUALITY_PS 5',
-    '    #define FXAA_QUALITY_P0 1.0',
-    '    #define FXAA_QUALITY_P1 1.5',
-    '    #define FXAA_QUALITY_P2 2.0',
-    '    #define FXAA_QUALITY_P3 2.0',
-    '    #define FXAA_QUALITY_P4 8.0',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#if (FXAA_QUALITY_PRESET == 23)',
-    '    #define FXAA_QUALITY_PS 6',
-    '    #define FXAA_QUALITY_P0 1.0',
-    '    #define FXAA_QUALITY_P1 1.5',
-    '    #define FXAA_QUALITY_P2 2.0',
-    '    #define FXAA_QUALITY_P3 2.0',
-    '    #define FXAA_QUALITY_P4 2.0',
-    '    #define FXAA_QUALITY_P5 8.0',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#if (FXAA_QUALITY_PRESET == 24)',
-    '    #define FXAA_QUALITY_PS 7',
-    '    #define FXAA_QUALITY_P0 1.0',
-    '    #define FXAA_QUALITY_P1 1.5',
-    '    #define FXAA_QUALITY_P2 2.0',
-    '    #define FXAA_QUALITY_P3 2.0',
-    '    #define FXAA_QUALITY_P4 2.0',
-    '    #define FXAA_QUALITY_P5 3.0',
-    '    #define FXAA_QUALITY_P6 8.0',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#if (FXAA_QUALITY_PRESET == 25)',
-    '    #define FXAA_QUALITY_PS 8',
-    '    #define FXAA_QUALITY_P0 1.0',
-    '    #define FXAA_QUALITY_P1 1.5',
-    '    #define FXAA_QUALITY_P2 2.0',
-    '    #define FXAA_QUALITY_P3 2.0',
-    '    #define FXAA_QUALITY_P4 2.0',
-    '    #define FXAA_QUALITY_P5 2.0',
-    '    #define FXAA_QUALITY_P6 4.0',
-    '    #define FXAA_QUALITY_P7 8.0',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#if (FXAA_QUALITY_PRESET == 26)',
-    '    #define FXAA_QUALITY_PS 9',
-    '    #define FXAA_QUALITY_P0 1.0',
-    '    #define FXAA_QUALITY_P1 1.5',
-    '    #define FXAA_QUALITY_P2 2.0',
-    '    #define FXAA_QUALITY_P3 2.0',
-    '    #define FXAA_QUALITY_P4 2.0',
-    '    #define FXAA_QUALITY_P5 2.0',
-    '    #define FXAA_QUALITY_P6 2.0',
-    '    #define FXAA_QUALITY_P7 4.0',
-    '    #define FXAA_QUALITY_P8 8.0',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#if (FXAA_QUALITY_PRESET == 27)',
-    '    #define FXAA_QUALITY_PS 10',
-    '    #define FXAA_QUALITY_P0 1.0',
-    '    #define FXAA_QUALITY_P1 1.5',
-    '    #define FXAA_QUALITY_P2 2.0',
-    '    #define FXAA_QUALITY_P3 2.0',
-    '    #define FXAA_QUALITY_P4 2.0',
-    '    #define FXAA_QUALITY_P5 2.0',
-    '    #define FXAA_QUALITY_P6 2.0',
-    '    #define FXAA_QUALITY_P7 2.0',
-    '    #define FXAA_QUALITY_P8 4.0',
-    '    #define FXAA_QUALITY_P9 8.0',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#if (FXAA_QUALITY_PRESET == 28)',
-    '    #define FXAA_QUALITY_PS 11',
-    '    #define FXAA_QUALITY_P0 1.0',
-    '    #define FXAA_QUALITY_P1 1.5',
-    '    #define FXAA_QUALITY_P2 2.0',
-    '    #define FXAA_QUALITY_P3 2.0',
-    '    #define FXAA_QUALITY_P4 2.0',
-    '    #define FXAA_QUALITY_P5 2.0',
-    '    #define FXAA_QUALITY_P6 2.0',
-    '    #define FXAA_QUALITY_P7 2.0',
-    '    #define FXAA_QUALITY_P8 2.0',
-    '    #define FXAA_QUALITY_P9 4.0',
-    '    #define FXAA_QUALITY_P10 8.0',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#if (FXAA_QUALITY_PRESET == 29)',
-    '    #define FXAA_QUALITY_PS 12',
-    '    #define FXAA_QUALITY_P0 1.0',
-    '    #define FXAA_QUALITY_P1 1.5',
-    '    #define FXAA_QUALITY_P2 2.0',
-    '    #define FXAA_QUALITY_P3 2.0',
-    '    #define FXAA_QUALITY_P4 2.0',
-    '    #define FXAA_QUALITY_P5 2.0',
-    '    #define FXAA_QUALITY_P6 2.0',
-    '    #define FXAA_QUALITY_P7 2.0',
-    '    #define FXAA_QUALITY_P8 2.0',
-    '    #define FXAA_QUALITY_P9 2.0',
-    '    #define FXAA_QUALITY_P10 4.0',
-    '    #define FXAA_QUALITY_P11 8.0',
-    '#endif',
-    '',
-    '/*============================================================================',
-    '                     FXAA QUALITY - EXTREME QUALITY',
-    '============================================================================*/',
-    '#if (FXAA_QUALITY_PRESET == 39)',
-    '    #define FXAA_QUALITY_PS 12',
-    '    #define FXAA_QUALITY_P0 1.0',
-    '    #define FXAA_QUALITY_P1 1.0',
-    '    #define FXAA_QUALITY_P2 1.0',
-    '    #define FXAA_QUALITY_P3 1.0',
-    '    #define FXAA_QUALITY_P4 1.0',
-    '    #define FXAA_QUALITY_P5 1.5',
-    '    #define FXAA_QUALITY_P6 2.0',
-    '    #define FXAA_QUALITY_P7 2.0',
-    '    #define FXAA_QUALITY_P8 2.0',
-    '    #define FXAA_QUALITY_P9 2.0',
-    '    #define FXAA_QUALITY_P10 4.0',
-    '    #define FXAA_QUALITY_P11 8.0',
-    '#endif',
-    '',
-    '',
-    '',
-    '/*============================================================================',
-    '',
-    '                                API PORTING',
-    '',
-    '============================================================================*/',
-    '#if (FXAA_GLSL_100 == 1) || (FXAA_GLSL_120 == 1) || (FXAA_GLSL_130 == 1)',
-    '    #define FxaaBool bool',
-    '    #define FxaaDiscard discard',
-    '    #define FxaaFloat float',
-    '    #define FxaaFloat2 vec2',
-    '    #define FxaaFloat3 vec3',
-    '    #define FxaaFloat4 vec4',
-    '    #define FxaaHalf float',
-    '    #define FxaaHalf2 vec2',
-    '    #define FxaaHalf3 vec3',
-    '    #define FxaaHalf4 vec4',
-    '    #define FxaaInt2 ivec2',
-    '    #define FxaaSat(x) clamp(x, 0.0, 1.0)',
-    '    #define FxaaTex sampler2D',
-    '#else',
-    '    #define FxaaBool bool',
-    '    #define FxaaDiscard clip(-1)',
-    '    #define FxaaFloat float',
-    '    #define FxaaFloat2 float2',
-    '    #define FxaaFloat3 float3',
-    '    #define FxaaFloat4 float4',
-    '    #define FxaaHalf half',
-    '    #define FxaaHalf2 half2',
-    '    #define FxaaHalf3 half3',
-    '    #define FxaaHalf4 half4',
-    '    #define FxaaSat(x) saturate(x)',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#if (FXAA_GLSL_100 == 1)',
-    '  #define FxaaTexTop(t, p) texture2D(t, p, 0.0)',
-    '  #define FxaaTexOff(t, p, o, r) texture2D(t, p + (o * r), 0.0)',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#if (FXAA_GLSL_120 == 1)',
-    '    // Requires,',
-    '    //  #version 120',
-    '    // And at least,',
-    '    //  #extension GL_EXT_gpu_shader4 : enable',
-    '    //  (or set FXAA_FAST_PIXEL_OFFSET 1 to work like DX9)',
-    '    #define FxaaTexTop(t, p) texture2DLod(t, p, 0.0)',
-    '    #if (FXAA_FAST_PIXEL_OFFSET == 1)',
-    '        #define FxaaTexOff(t, p, o, r) texture2DLodOffset(t, p, 0.0, o)',
-    '    #else',
-    '        #define FxaaTexOff(t, p, o, r) texture2DLod(t, p + (o * r), 0.0)',
-    '    #endif',
-    '    #if (FXAA_GATHER4_ALPHA == 1)',
-    '        // use #extension GL_ARB_gpu_shader5 : enable',
-    '        #define FxaaTexAlpha4(t, p) textureGather(t, p, 3)',
-    '        #define FxaaTexOffAlpha4(t, p, o) textureGatherOffset(t, p, o, 3)',
-    '        #define FxaaTexGreen4(t, p) textureGather(t, p, 1)',
-    '        #define FxaaTexOffGreen4(t, p, o) textureGatherOffset(t, p, o, 1)',
-    '    #endif',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#if (FXAA_GLSL_130 == 1)',
-    '    // Requires "#version 130" or better',
-    '    #define FxaaTexTop(t, p) textureLod(t, p, 0.0)',
-    '    #define FxaaTexOff(t, p, o, r) textureLodOffset(t, p, 0.0, o)',
-    '    #if (FXAA_GATHER4_ALPHA == 1)',
-    '        // use #extension GL_ARB_gpu_shader5 : enable',
-    '        #define FxaaTexAlpha4(t, p) textureGather(t, p, 3)',
-    '        #define FxaaTexOffAlpha4(t, p, o) textureGatherOffset(t, p, o, 3)',
-    '        #define FxaaTexGreen4(t, p) textureGather(t, p, 1)',
-    '        #define FxaaTexOffGreen4(t, p, o) textureGatherOffset(t, p, o, 1)',
-    '    #endif',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#if (FXAA_HLSL_3 == 1)',
-    '    #define FxaaInt2 float2',
-    '    #define FxaaTex sampler2D',
-    '    #define FxaaTexTop(t, p) tex2Dlod(t, float4(p, 0.0, 0.0))',
-    '    #define FxaaTexOff(t, p, o, r) tex2Dlod(t, float4(p + (o * r), 0, 0))',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#if (FXAA_HLSL_4 == 1)',
-    '    #define FxaaInt2 int2',
-    '    struct FxaaTex { SamplerState smpl; Texture2D tex; };',
-    '    #define FxaaTexTop(t, p) t.tex.SampleLevel(t.smpl, p, 0.0)',
-    '    #define FxaaTexOff(t, p, o, r) t.tex.SampleLevel(t.smpl, p, 0.0, o)',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#if (FXAA_HLSL_5 == 1)',
-    '    #define FxaaInt2 int2',
-    '    struct FxaaTex { SamplerState smpl; Texture2D tex; };',
-    '    #define FxaaTexTop(t, p) t.tex.SampleLevel(t.smpl, p, 0.0)',
-    '    #define FxaaTexOff(t, p, o, r) t.tex.SampleLevel(t.smpl, p, 0.0, o)',
-    '    #define FxaaTexAlpha4(t, p) t.tex.GatherAlpha(t.smpl, p)',
-    '    #define FxaaTexOffAlpha4(t, p, o) t.tex.GatherAlpha(t.smpl, p, o)',
-    '    #define FxaaTexGreen4(t, p) t.tex.GatherGreen(t.smpl, p)',
-    '    #define FxaaTexOffGreen4(t, p, o) t.tex.GatherGreen(t.smpl, p, o)',
-    '#endif',
-    '',
-    '',
-    '/*============================================================================',
-    '                   GREEN AS LUMA OPTION SUPPORT FUNCTION',
-    '============================================================================*/',
-    '#if (FXAA_GREEN_AS_LUMA == 0)',
-    '    FxaaFloat FxaaLuma(FxaaFloat4 rgba) { return rgba.w; }',
-    '#else',
-    '    FxaaFloat FxaaLuma(FxaaFloat4 rgba) { return rgba.y; }',
-    '#endif',
-    '',
-    '',
-    '',
-    '',
-    '/*============================================================================',
-    '',
-    '                             FXAA3 QUALITY - PC',
-    '',
-    '============================================================================*/',
-    '#if (FXAA_PC == 1)',
-    '/*--------------------------------------------------------------------------*/',
-    'FxaaFloat4 FxaaPixelShader(',
-    '    //',
-    '    // Use noperspective interpolation here (turn off perspective interpolation).',
-    '    // {xy} = center of pixel',
-    '    FxaaFloat2 pos,',
-    '    //',
-    '    // Used only for FXAA Console, and not used on the 360 version.',
-    '    // Use noperspective interpolation here (turn off perspective interpolation).',
-    '    // {xy_} = upper left of pixel',
-    '    // {_zw} = lower right of pixel',
-    '    FxaaFloat4 fxaaConsolePosPos,',
-    '    //',
-    '    // Input color texture.',
-    '    // {rgb_} = color in linear or perceptual color space',
-    '    // if (FXAA_GREEN_AS_LUMA == 0)',
-    '    //     {__a} = luma in perceptual color space (not linear)',
-    '    FxaaTex tex,',
-    '    //',
-    '    // Only used on the optimized 360 version of FXAA Console.',
-    '    // For everything but 360, just use the same input here as for "tex".',
-    '    // For 360, same texture, just alias with a 2nd sampler.',
-    '    // This sampler needs to have an exponent bias of -1.',
-    '    FxaaTex fxaaConsole360TexExpBiasNegOne,',
-    '    //',
-    '    // Only used on the optimized 360 version of FXAA Console.',
-    '    // For everything but 360, just use the same input here as for "tex".',
-    '    // For 360, same texture, just alias with a 3nd sampler.',
-    '    // This sampler needs to have an exponent bias of -2.',
-    '    FxaaTex fxaaConsole360TexExpBiasNegTwo,',
-    '    //',
-    '    // Only used on FXAA Quality.',
-    '    // This must be from a constant/uniform.',
-    '    // {x_} = 1.0/screenWidthInPixels',
-    '    // {_y} = 1.0/screenHeightInPixels',
-    '    FxaaFloat2 fxaaQualityRcpFrame,',
-    '    //',
-    '    // Only used on FXAA Console.',
-    '    // This must be from a constant/uniform.',
-    '    // This effects sub-pixel AA quality and inversely sharpness.',
-    '    //   Where N ranges between,',
-    '    //     N = 0.50 (default)',
-    '    //     N = 0.33 (sharper)',
-    '    // {x__} = -N/screenWidthInPixels',
-    '    // {_y_} = -N/screenHeightInPixels',
-    '    // {_z_} =  N/screenWidthInPixels',
-    '    // {__w} =  N/screenHeightInPixels',
-    '    FxaaFloat4 fxaaConsoleRcpFrameOpt,',
-    '    //',
-    '    // Only used on FXAA Console.',
-    '    // Not used on 360, but used on PS3 and PC.',
-    '    // This must be from a constant/uniform.',
-    '    // {x__} = -2.0/screenWidthInPixels',
-    '    // {_y_} = -2.0/screenHeightInPixels',
-    '    // {_z_} =  2.0/screenWidthInPixels',
-    '    // {__w} =  2.0/screenHeightInPixels',
-    '    FxaaFloat4 fxaaConsoleRcpFrameOpt2,',
-    '    //',
-    '    // Only used on FXAA Console.',
-    '    // Only used on 360 in place of fxaaConsoleRcpFrameOpt2.',
-    '    // This must be from a constant/uniform.',
-    '    // {x__} =  8.0/screenWidthInPixels',
-    '    // {_y_} =  8.0/screenHeightInPixels',
-    '    // {_z_} = -4.0/screenWidthInPixels',
-    '    // {__w} = -4.0/screenHeightInPixels',
-    '    FxaaFloat4 fxaaConsole360RcpFrameOpt2,',
-    '    //',
-    '    // Only used on FXAA Quality.',
-    '    // This used to be the FXAA_QUALITY_SUBPIX define.',
-    '    // It is here now to allow easier tuning.',
-    '    // Choose the amount of sub-pixel aliasing removal.',
-    '    // This can effect sharpness.',
-    '    //   1.00 - upper limit (softer)',
-    '    //   0.75 - default amount of filtering',
-    '    //   0.50 - lower limit (sharper, less sub-pixel aliasing removal)',
-    '    //   0.25 - almost off',
-    '    //   0.00 - completely off',
-    '    FxaaFloat fxaaQualitySubpix,',
-    '    //',
-    '    // Only used on FXAA Quality.',
-    '    // This used to be the FXAA_QUALITY_EDGE_THRESHOLD define.',
-    '    // It is here now to allow easier tuning.',
-    '    // The minimum amount of local contrast required to apply algorithm.',
-    '    //   0.333 - too little (faster)',
-    '    //   0.250 - low quality',
-    '    //   0.166 - default',
-    '    //   0.125 - high quality',
-    '    //   0.063 - overkill (slower)',
-    '    FxaaFloat fxaaQualityEdgeThreshold,',
-    '    //',
-    '    // Only used on FXAA Quality.',
-    '    // This used to be the FXAA_QUALITY_EDGE_THRESHOLD_MIN define.',
-    '    // It is here now to allow easier tuning.',
-    '    // Trims the algorithm from processing darks.',
-    '    //   0.0833 - upper limit (default, the start of visible unfiltered edges)',
-    '    //   0.0625 - high quality (faster)',
-    '    //   0.0312 - visible limit (slower)',
-    '    // Special notes when using FXAA_GREEN_AS_LUMA,',
-    '    //   Likely want to set this to zero.',
-    '    //   As colors that are mostly not-green',
-    '    //   will appear very dark in the green channel!',
-    '    //   Tune by looking at mostly non-green content,',
-    '    //   then start at zero and increase until aliasing is a problem.',
-    '    FxaaFloat fxaaQualityEdgeThresholdMin,',
-    '    //',
-    '    // Only used on FXAA Console.',
-    '    // This used to be the FXAA_CONSOLE_EDGE_SHARPNESS define.',
-    '    // It is here now to allow easier tuning.',
-    '    // This does not effect PS3, as this needs to be compiled in.',
-    '    //   Use FXAA_CONSOLE_PS3_EDGE_SHARPNESS for PS3.',
-    '    //   Due to the PS3 being ALU bound,',
-    '    //   there are only three safe values here: 2 and 4 and 8.',
-    '    //   These options use the shaders ability to a free *|/ by 2|4|8.',
-    '    // For all other platforms can be a non-power of two.',
-    '    //   8.0 is sharper (default!!!)',
-    '    //   4.0 is softer',
-    '    //   2.0 is really soft (good only for vector graphics inputs)',
-    '    FxaaFloat fxaaConsoleEdgeSharpness,',
-    '    //',
-    '    // Only used on FXAA Console.',
-    '    // This used to be the FXAA_CONSOLE_EDGE_THRESHOLD define.',
-    '    // It is here now to allow easier tuning.',
-    '    // This does not effect PS3, as this needs to be compiled in.',
-    '    //   Use FXAA_CONSOLE_PS3_EDGE_THRESHOLD for PS3.',
-    '    //   Due to the PS3 being ALU bound,',
-    '    //   there are only two safe values here: 1/4 and 1/8.',
-    '    //   These options use the shaders ability to a free *|/ by 2|4|8.',
-    '    // The console setting has a different mapping than the quality setting.',
-    '    // Other platforms can use other values.',
-    '    //   0.125 leaves less aliasing, but is softer (default!!!)',
-    '    //   0.25 leaves more aliasing, and is sharper',
-    '    FxaaFloat fxaaConsoleEdgeThreshold,',
-    '    //',
-    '    // Only used on FXAA Console.',
-    '    // This used to be the FXAA_CONSOLE_EDGE_THRESHOLD_MIN define.',
-    '    // It is here now to allow easier tuning.',
-    '    // Trims the algorithm from processing darks.',
-    '    // The console setting has a different mapping than the quality setting.',
-    '    // This only applies when FXAA_EARLY_EXIT is 1.',
-    '    // This does not apply to PS3,',
-    '    // PS3 was simplified to avoid more shader instructions.',
-    '    //   0.06 - faster but more aliasing in darks',
-    '    //   0.05 - default',
-    '    //   0.04 - slower and less aliasing in darks',
-    '    // Special notes when using FXAA_GREEN_AS_LUMA,',
-    '    //   Likely want to set this to zero.',
-    '    //   As colors that are mostly not-green',
-    '    //   will appear very dark in the green channel!',
-    '    //   Tune by looking at mostly non-green content,',
-    '    //   then start at zero and increase until aliasing is a problem.',
-    '    FxaaFloat fxaaConsoleEdgeThresholdMin,',
-    '    //',
-    '    // Extra constants for 360 FXAA Console only.',
-    '    // Use zeros or anything else for other platforms.',
-    '    // These must be in physical constant registers and NOT immediates.',
-    '    // Immediates will result in compiler un-optimizing.',
-    '    // {xyzw} = float4(1.0, -1.0, 0.25, -0.25)',
-    '    FxaaFloat4 fxaaConsole360ConstDir',
-    ') {',
-    '/*--------------------------------------------------------------------------*/',
-    '    FxaaFloat2 posM;',
-    '    posM.x = pos.x;',
-    '    posM.y = pos.y;',
-    '    #if (FXAA_GATHER4_ALPHA == 1)',
-    '        #if (FXAA_DISCARD == 0)',
-    '            FxaaFloat4 rgbyM = FxaaTexTop(tex, posM);',
-    '            #if (FXAA_GREEN_AS_LUMA == 0)',
-    '                #define lumaM rgbyM.w',
-    '            #else',
-    '                #define lumaM rgbyM.y',
-    '            #endif',
-    '        #endif',
-    '        #if (FXAA_GREEN_AS_LUMA == 0)',
-    '            FxaaFloat4 luma4A = FxaaTexAlpha4(tex, posM);',
-    '            FxaaFloat4 luma4B = FxaaTexOffAlpha4(tex, posM, FxaaInt2(-1, -1));',
-    '        #else',
-    '            FxaaFloat4 luma4A = FxaaTexGreen4(tex, posM);',
-    '            FxaaFloat4 luma4B = FxaaTexOffGreen4(tex, posM, FxaaInt2(-1, -1));',
-    '        #endif',
-    '        #if (FXAA_DISCARD == 1)',
-    '            #define lumaM luma4A.w',
-    '        #endif',
-    '        #define lumaE luma4A.z',
-    '        #define lumaS luma4A.x',
-    '        #define lumaSE luma4A.y',
-    '        #define lumaNW luma4B.w',
-    '        #define lumaN luma4B.z',
-    '        #define lumaW luma4B.x',
-    '    #else',
-    '        FxaaFloat4 rgbyM = FxaaTexTop(tex, posM);',
-    '        #if (FXAA_GREEN_AS_LUMA == 0)',
-    '            #define lumaM rgbyM.w',
-    '        #else',
-    '            #define lumaM rgbyM.y',
-    '        #endif',
-    '        #if (FXAA_GLSL_100 == 1)',
-    '          FxaaFloat lumaS = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2( 0.0, 1.0), fxaaQualityRcpFrame.xy));',
-    '          FxaaFloat lumaE = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2( 1.0, 0.0), fxaaQualityRcpFrame.xy));',
-    '          FxaaFloat lumaN = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2( 0.0,-1.0), fxaaQualityRcpFrame.xy));',
-    '          FxaaFloat lumaW = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2(-1.0, 0.0), fxaaQualityRcpFrame.xy));',
-    '        #else',
-    '          FxaaFloat lumaS = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 0, 1), fxaaQualityRcpFrame.xy));',
-    '          FxaaFloat lumaE = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 1, 0), fxaaQualityRcpFrame.xy));',
-    '          FxaaFloat lumaN = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 0,-1), fxaaQualityRcpFrame.xy));',
-    '          FxaaFloat lumaW = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(-1, 0), fxaaQualityRcpFrame.xy));',
-    '        #endif',
-    '    #endif',
-    '/*--------------------------------------------------------------------------*/',
-    '    FxaaFloat maxSM = max(lumaS, lumaM);',
-    '    FxaaFloat minSM = min(lumaS, lumaM);',
-    '    FxaaFloat maxESM = max(lumaE, maxSM);',
-    '    FxaaFloat minESM = min(lumaE, minSM);',
-    '    FxaaFloat maxWN = max(lumaN, lumaW);',
-    '    FxaaFloat minWN = min(lumaN, lumaW);',
-    '    FxaaFloat rangeMax = max(maxWN, maxESM);',
-    '    FxaaFloat rangeMin = min(minWN, minESM);',
-    '    FxaaFloat rangeMaxScaled = rangeMax * fxaaQualityEdgeThreshold;',
-    '    FxaaFloat range = rangeMax - rangeMin;',
-    '    FxaaFloat rangeMaxClamped = max(fxaaQualityEdgeThresholdMin, rangeMaxScaled);',
-    '    FxaaBool earlyExit = range < rangeMaxClamped;',
-    '/*--------------------------------------------------------------------------*/',
-    '    if(earlyExit)',
-    '        #if (FXAA_DISCARD == 1)',
-    '            FxaaDiscard;',
-    '        #else',
-    '            return rgbyM;',
-    '        #endif',
-    '/*--------------------------------------------------------------------------*/',
-    '    #if (FXAA_GATHER4_ALPHA == 0)',
-    '        #if (FXAA_GLSL_100 == 1)',
-    '          FxaaFloat lumaNW = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2(-1.0,-1.0), fxaaQualityRcpFrame.xy));',
-    '          FxaaFloat lumaSE = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2( 1.0, 1.0), fxaaQualityRcpFrame.xy));',
-    '          FxaaFloat lumaNE = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2( 1.0,-1.0), fxaaQualityRcpFrame.xy));',
-    '          FxaaFloat lumaSW = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2(-1.0, 1.0), fxaaQualityRcpFrame.xy));',
-    '        #else',
-    '          FxaaFloat lumaNW = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(-1,-1), fxaaQualityRcpFrame.xy));',
-    '          FxaaFloat lumaSE = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 1, 1), fxaaQualityRcpFrame.xy));',
-    '          FxaaFloat lumaNE = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 1,-1), fxaaQualityRcpFrame.xy));',
-    '          FxaaFloat lumaSW = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(-1, 1), fxaaQualityRcpFrame.xy));',
-    '        #endif',
-    '    #else',
-    '        FxaaFloat lumaNE = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(1, -1), fxaaQualityRcpFrame.xy));',
-    '        FxaaFloat lumaSW = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(-1, 1), fxaaQualityRcpFrame.xy));',
-    '    #endif',
-    '/*--------------------------------------------------------------------------*/',
-    '    FxaaFloat lumaNS = lumaN + lumaS;',
-    '    FxaaFloat lumaWE = lumaW + lumaE;',
-    '    FxaaFloat subpixRcpRange = 1.0/range;',
-    '    FxaaFloat subpixNSWE = lumaNS + lumaWE;',
-    '    FxaaFloat edgeHorz1 = (-2.0 * lumaM) + lumaNS;',
-    '    FxaaFloat edgeVert1 = (-2.0 * lumaM) + lumaWE;',
-    '/*--------------------------------------------------------------------------*/',
-    '    FxaaFloat lumaNESE = lumaNE + lumaSE;',
-    '    FxaaFloat lumaNWNE = lumaNW + lumaNE;',
-    '    FxaaFloat edgeHorz2 = (-2.0 * lumaE) + lumaNESE;',
-    '    FxaaFloat edgeVert2 = (-2.0 * lumaN) + lumaNWNE;',
-    '/*--------------------------------------------------------------------------*/',
-    '    FxaaFloat lumaNWSW = lumaNW + lumaSW;',
-    '    FxaaFloat lumaSWSE = lumaSW + lumaSE;',
-    '    FxaaFloat edgeHorz4 = (abs(edgeHorz1) * 2.0) + abs(edgeHorz2);',
-    '    FxaaFloat edgeVert4 = (abs(edgeVert1) * 2.0) + abs(edgeVert2);',
-    '    FxaaFloat edgeHorz3 = (-2.0 * lumaW) + lumaNWSW;',
-    '    FxaaFloat edgeVert3 = (-2.0 * lumaS) + lumaSWSE;',
-    '    FxaaFloat edgeHorz = abs(edgeHorz3) + edgeHorz4;',
-    '    FxaaFloat edgeVert = abs(edgeVert3) + edgeVert4;',
-    '/*--------------------------------------------------------------------------*/',
-    '    FxaaFloat subpixNWSWNESE = lumaNWSW + lumaNESE;',
-    '    FxaaFloat lengthSign = fxaaQualityRcpFrame.x;',
-    '    FxaaBool horzSpan = edgeHorz >= edgeVert;',
-    '    FxaaFloat subpixA = subpixNSWE * 2.0 + subpixNWSWNESE;',
-    '/*--------------------------------------------------------------------------*/',
-    '    if(!horzSpan) lumaN = lumaW;',
-    '    if(!horzSpan) lumaS = lumaE;',
-    '    if(horzSpan) lengthSign = fxaaQualityRcpFrame.y;',
-    '    FxaaFloat subpixB = (subpixA * (1.0/12.0)) - lumaM;',
-    '/*--------------------------------------------------------------------------*/',
-    '    FxaaFloat gradientN = lumaN - lumaM;',
-    '    FxaaFloat gradientS = lumaS - lumaM;',
-    '    FxaaFloat lumaNN = lumaN + lumaM;',
-    '    FxaaFloat lumaSS = lumaS + lumaM;',
-    '    FxaaBool pairN = abs(gradientN) >= abs(gradientS);',
-    '    FxaaFloat gradient = max(abs(gradientN), abs(gradientS));',
-    '    if(pairN) lengthSign = -lengthSign;',
-    '    FxaaFloat subpixC = FxaaSat(abs(subpixB) * subpixRcpRange);',
-    '/*--------------------------------------------------------------------------*/',
-    '    FxaaFloat2 posB;',
-    '    posB.x = posM.x;',
-    '    posB.y = posM.y;',
-    '    FxaaFloat2 offNP;',
-    '    offNP.x = (!horzSpan) ? 0.0 : fxaaQualityRcpFrame.x;',
-    '    offNP.y = ( horzSpan) ? 0.0 : fxaaQualityRcpFrame.y;',
-    '    if(!horzSpan) posB.x += lengthSign * 0.5;',
-    '    if( horzSpan) posB.y += lengthSign * 0.5;',
-    '/*--------------------------------------------------------------------------*/',
-    '    FxaaFloat2 posN;',
-    '    posN.x = posB.x - offNP.x * FXAA_QUALITY_P0;',
-    '    posN.y = posB.y - offNP.y * FXAA_QUALITY_P0;',
-    '    FxaaFloat2 posP;',
-    '    posP.x = posB.x + offNP.x * FXAA_QUALITY_P0;',
-    '    posP.y = posB.y + offNP.y * FXAA_QUALITY_P0;',
-    '    FxaaFloat subpixD = ((-2.0)*subpixC) + 3.0;',
-    '    FxaaFloat lumaEndN = FxaaLuma(FxaaTexTop(tex, posN));',
-    '    FxaaFloat subpixE = subpixC * subpixC;',
-    '    FxaaFloat lumaEndP = FxaaLuma(FxaaTexTop(tex, posP));',
-    '/*--------------------------------------------------------------------------*/',
-    '    if(!pairN) lumaNN = lumaSS;',
-    '    FxaaFloat gradientScaled = gradient * 1.0/4.0;',
-    '    FxaaFloat lumaMM = lumaM - lumaNN * 0.5;',
-    '    FxaaFloat subpixF = subpixD * subpixE;',
-    '    FxaaBool lumaMLTZero = lumaMM < 0.0;',
-    '/*--------------------------------------------------------------------------*/',
-    '    lumaEndN -= lumaNN * 0.5;',
-    '    lumaEndP -= lumaNN * 0.5;',
-    '    FxaaBool doneN = abs(lumaEndN) >= gradientScaled;',
-    '    FxaaBool doneP = abs(lumaEndP) >= gradientScaled;',
-    '    if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P1;',
-    '    if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P1;',
-    '    FxaaBool doneNP = (!doneN) || (!doneP);',
-    '    if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P1;',
-    '    if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P1;',
-    '/*--------------------------------------------------------------------------*/',
-    '    if(doneNP) {',
-    '        if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));',
-    '        if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));',
-    '        if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;',
-    '        if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;',
-    '        doneN = abs(lumaEndN) >= gradientScaled;',
-    '        doneP = abs(lumaEndP) >= gradientScaled;',
-    '        if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P2;',
-    '        if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P2;',
-    '        doneNP = (!doneN) || (!doneP);',
-    '        if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P2;',
-    '        if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P2;',
-    '/*--------------------------------------------------------------------------*/',
-    '        #if (FXAA_QUALITY_PS > 3)',
-    '        if(doneNP) {',
-    '            if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));',
-    '            if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));',
-    '            if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;',
-    '            if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;',
-    '            doneN = abs(lumaEndN) >= gradientScaled;',
-    '            doneP = abs(lumaEndP) >= gradientScaled;',
-    '            if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P3;',
-    '            if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P3;',
-    '            doneNP = (!doneN) || (!doneP);',
-    '            if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P3;',
-    '            if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P3;',
-    '/*--------------------------------------------------------------------------*/',
-    '            #if (FXAA_QUALITY_PS > 4)',
-    '            if(doneNP) {',
-    '                if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));',
-    '                if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));',
-    '                if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;',
-    '                if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;',
-    '                doneN = abs(lumaEndN) >= gradientScaled;',
-    '                doneP = abs(lumaEndP) >= gradientScaled;',
-    '                if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P4;',
-    '                if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P4;',
-    '                doneNP = (!doneN) || (!doneP);',
-    '                if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P4;',
-    '                if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P4;',
-    '/*--------------------------------------------------------------------------*/',
-    '                #if (FXAA_QUALITY_PS > 5)',
-    '                if(doneNP) {',
-    '                    if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));',
-    '                    if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));',
-    '                    if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;',
-    '                    if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;',
-    '                    doneN = abs(lumaEndN) >= gradientScaled;',
-    '                    doneP = abs(lumaEndP) >= gradientScaled;',
-    '                    if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P5;',
-    '                    if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P5;',
-    '                    doneNP = (!doneN) || (!doneP);',
-    '                    if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P5;',
-    '                    if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P5;',
-    '/*--------------------------------------------------------------------------*/',
-    '                    #if (FXAA_QUALITY_PS > 6)',
-    '                    if(doneNP) {',
-    '                        if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));',
-    '                        if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));',
-    '                        if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;',
-    '                        if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;',
-    '                        doneN = abs(lumaEndN) >= gradientScaled;',
-    '                        doneP = abs(lumaEndP) >= gradientScaled;',
-    '                        if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P6;',
-    '                        if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P6;',
-    '                        doneNP = (!doneN) || (!doneP);',
-    '                        if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P6;',
-    '                        if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P6;',
-    '/*--------------------------------------------------------------------------*/',
-    '                        #if (FXAA_QUALITY_PS > 7)',
-    '                        if(doneNP) {',
-    '                            if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));',
-    '                            if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));',
-    '                            if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;',
-    '                            if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;',
-    '                            doneN = abs(lumaEndN) >= gradientScaled;',
-    '                            doneP = abs(lumaEndP) >= gradientScaled;',
-    '                            if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P7;',
-    '                            if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P7;',
-    '                            doneNP = (!doneN) || (!doneP);',
-    '                            if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P7;',
-    '                            if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P7;',
-    '/*--------------------------------------------------------------------------*/',
-    '    #if (FXAA_QUALITY_PS > 8)',
-    '    if(doneNP) {',
-    '        if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));',
-    '        if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));',
-    '        if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;',
-    '        if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;',
-    '        doneN = abs(lumaEndN) >= gradientScaled;',
-    '        doneP = abs(lumaEndP) >= gradientScaled;',
-    '        if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P8;',
-    '        if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P8;',
-    '        doneNP = (!doneN) || (!doneP);',
-    '        if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P8;',
-    '        if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P8;',
-    '/*--------------------------------------------------------------------------*/',
-    '        #if (FXAA_QUALITY_PS > 9)',
-    '        if(doneNP) {',
-    '            if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));',
-    '            if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));',
-    '            if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;',
-    '            if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;',
-    '            doneN = abs(lumaEndN) >= gradientScaled;',
-    '            doneP = abs(lumaEndP) >= gradientScaled;',
-    '            if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P9;',
-    '            if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P9;',
-    '            doneNP = (!doneN) || (!doneP);',
-    '            if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P9;',
-    '            if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P9;',
-    '/*--------------------------------------------------------------------------*/',
-    '            #if (FXAA_QUALITY_PS > 10)',
-    '            if(doneNP) {',
-    '                if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));',
-    '                if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));',
-    '                if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;',
-    '                if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;',
-    '                doneN = abs(lumaEndN) >= gradientScaled;',
-    '                doneP = abs(lumaEndP) >= gradientScaled;',
-    '                if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P10;',
-    '                if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P10;',
-    '                doneNP = (!doneN) || (!doneP);',
-    '                if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P10;',
-    '                if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P10;',
-    '/*--------------------------------------------------------------------------*/',
-    '                #if (FXAA_QUALITY_PS > 11)',
-    '                if(doneNP) {',
-    '                    if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));',
-    '                    if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));',
-    '                    if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;',
-    '                    if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;',
-    '                    doneN = abs(lumaEndN) >= gradientScaled;',
-    '                    doneP = abs(lumaEndP) >= gradientScaled;',
-    '                    if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P11;',
-    '                    if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P11;',
-    '                    doneNP = (!doneN) || (!doneP);',
-    '                    if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P11;',
-    '                    if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P11;',
-    '/*--------------------------------------------------------------------------*/',
-    '                    #if (FXAA_QUALITY_PS > 12)',
-    '                    if(doneNP) {',
-    '                        if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));',
-    '                        if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));',
-    '                        if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;',
-    '                        if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;',
-    '                        doneN = abs(lumaEndN) >= gradientScaled;',
-    '                        doneP = abs(lumaEndP) >= gradientScaled;',
-    '                        if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P12;',
-    '                        if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P12;',
-    '                        doneNP = (!doneN) || (!doneP);',
-    '                        if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P12;',
-    '                        if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P12;',
-    '/*--------------------------------------------------------------------------*/',
-    '                    }',
-    '                    #endif',
-    '/*--------------------------------------------------------------------------*/',
-    '                }',
-    '                #endif',
-    '/*--------------------------------------------------------------------------*/',
-    '            }',
-    '            #endif',
-    '/*--------------------------------------------------------------------------*/',
-    '        }',
-    '        #endif',
-    '/*--------------------------------------------------------------------------*/',
-    '    }',
-    '    #endif',
-    '/*--------------------------------------------------------------------------*/',
-    '                        }',
-    '                        #endif',
-    '/*--------------------------------------------------------------------------*/',
-    '                    }',
-    '                    #endif',
-    '/*--------------------------------------------------------------------------*/',
-    '                }',
-    '                #endif',
-    '/*--------------------------------------------------------------------------*/',
-    '            }',
-    '            #endif',
-    '/*--------------------------------------------------------------------------*/',
-    '        }',
-    '        #endif',
-    '/*--------------------------------------------------------------------------*/',
-    '    }',
-    '/*--------------------------------------------------------------------------*/',
-    '    FxaaFloat dstN = posM.x - posN.x;',
-    '    FxaaFloat dstP = posP.x - posM.x;',
-    '    if(!horzSpan) dstN = posM.y - posN.y;',
-    '    if(!horzSpan) dstP = posP.y - posM.y;',
-    '/*--------------------------------------------------------------------------*/',
-    '    FxaaBool goodSpanN = (lumaEndN < 0.0) != lumaMLTZero;',
-    '    FxaaFloat spanLength = (dstP + dstN);',
-    '    FxaaBool goodSpanP = (lumaEndP < 0.0) != lumaMLTZero;',
-    '    FxaaFloat spanLengthRcp = 1.0/spanLength;',
-    '/*--------------------------------------------------------------------------*/',
-    '    FxaaBool directionN = dstN < dstP;',
-    '    FxaaFloat dst = min(dstN, dstP);',
-    '    FxaaBool goodSpan = directionN ? goodSpanN : goodSpanP;',
-    '    FxaaFloat subpixG = subpixF * subpixF;',
-    '    FxaaFloat pixelOffset = (dst * (-spanLengthRcp)) + 0.5;',
-    '    FxaaFloat subpixH = subpixG * fxaaQualitySubpix;',
-    '/*--------------------------------------------------------------------------*/',
-    '    FxaaFloat pixelOffsetGood = goodSpan ? pixelOffset : 0.0;',
-    '    FxaaFloat pixelOffsetSubpix = max(pixelOffsetGood, subpixH);',
-    '    if(!horzSpan) posM.x += pixelOffsetSubpix * lengthSign;',
-    '    if( horzSpan) posM.y += pixelOffsetSubpix * lengthSign;',
-    '    #if (FXAA_DISCARD == 1)',
-    '        return FxaaTexTop(tex, posM);',
-    '    #else',
-    '        return FxaaFloat4(FxaaTexTop(tex, posM).xyz, lumaM);',
-    '    #endif',
-    '}',
-    '/*==========================================================================*/',
-    '#endif',
-    '',
-    'void main() {',
-    '  gl_FragColor = FxaaPixelShader(',
-    '    vUv,',
-    '    vec4(0.0),',
-    '    tDiffuse,',
-    '    tDiffuse,',
-    '    tDiffuse,',
-    '    resolution,',
-    '    vec4(0.0),',
-    '    vec4(0.0),',
-    '    vec4(0.0),',
-    '    0.75,',
-    '    0.166,',
-    '    0.0833,',
-    '    0.0,',
-    '    0.0,',
-    '    0.0,',
-    '    vec4(0.0)',
-    '  );',
-    '',
-    '  // TODO avoid querying texture twice for same texel',
-    '  gl_FragColor.a = texture2D(tDiffuse, vUv).a;',
-    '}',
-  ].join('\n'),
+  fragmentShader: /* glsl */ `
+    precision highp float;
+    
+    uniform sampler2D tDiffuse;
+    
+    uniform vec2 resolution;
+    
+    varying vec2 vUv;
+    
+    // FXAA 3.11 implementation by NVIDIA, ported to WebGL by Agost Biro (biro@archilogic.com)
+    
+    //----------------------------------------------------------------------------------
+    // File:        es3-keplerFXAAassetsshaders/FXAA_DefaultES.frag
+    // SDK Version: v3.00
+    // Email:       gameworks@nvidia.com
+    // Site:        http://developer.nvidia.com/
+    //
+    // Copyright (c) 2014-2015, NVIDIA CORPORATION. All rights reserved.
+    //
+    // Redistribution and use in source and binary forms, with or without
+    // modification, are permitted provided that the following conditions
+    // are met:
+    //  * Redistributions of source code must retain the above copyright
+    //    notice, this list of conditions and the following disclaimer.
+    //  * Redistributions in binary form must reproduce the above copyright
+    //    notice, this list of conditions and the following disclaimer in the
+    //    documentation and/or other materials provided with the distribution.
+    //  * Neither the name of NVIDIA CORPORATION nor the names of its
+    //    contributors may be used to endorse or promote products derived
+    //    from this software without specific prior written permission.
+    //
+    "// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AS IS AND ANY",
+    // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+    // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+    // PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+    // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+    // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+    // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+    // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+    // OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+    // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+    // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+    //
+    //----------------------------------------------------------------------------------
+    
+    #define FXAA_PC 1
+    #define FXAA_GLSL_100 1
+    #define FXAA_QUALITY_PRESET 12
+    
+    #define FXAA_GREEN_AS_LUMA 1
+    
+    /*--------------------------------------------------------------------------*/
+    #ifndef FXAA_PC_CONSOLE
+        //
+        // The console algorithm for PC is included
+        // for developers targeting really low spec machines.
+        // Likely better to just run FXAA_PC, and use a really low preset.
+        //
+        #define FXAA_PC_CONSOLE 0
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #ifndef FXAA_GLSL_120
+        #define FXAA_GLSL_120 0
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #ifndef FXAA_GLSL_130
+        #define FXAA_GLSL_130 0
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #ifndef FXAA_HLSL_3
+        #define FXAA_HLSL_3 0
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #ifndef FXAA_HLSL_4
+        #define FXAA_HLSL_4 0
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #ifndef FXAA_HLSL_5
+        #define FXAA_HLSL_5 0
+    #endif
+    /*==========================================================================*/
+    #ifndef FXAA_GREEN_AS_LUMA
+        //
+        // For those using non-linear color,
+        // and either not able to get luma in alpha, or not wanting to,
+        // this enables FXAA to run using green as a proxy for luma.
+        // So with this enabled, no need to pack luma in alpha.
+        //
+        // This will turn off AA on anything which lacks some amount of green.
+        // Pure red and blue or combination of only R and B, will get no AA.
+        //
+        // Might want to lower the settings for both,
+        //    fxaaConsoleEdgeThresholdMin
+        //    fxaaQualityEdgeThresholdMin
+        // In order to insure AA does not get turned off on colors
+        // which contain a minor amount of green.
+        //
+        // 1 = On.
+        // 0 = Off.
+        //
+        #define FXAA_GREEN_AS_LUMA 0
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #ifndef FXAA_EARLY_EXIT
+        //
+    "    // Controls algorithms early exit path.",
+        // On PS3 turning this ON adds 2 cycles to the shader.
+        // On 360 turning this OFF adds 10ths of a millisecond to the shader.
+        // Turning this off on console will result in a more blurry image.
+        // So this defaults to on.
+        //
+        // 1 = On.
+        // 0 = Off.
+        //
+        #define FXAA_EARLY_EXIT 1
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #ifndef FXAA_DISCARD
+        //
+        // Only valid for PC OpenGL currently.
+        // Probably will not work when FXAA_GREEN_AS_LUMA = 1.
+        //
+    "    // 1 = Use discard on pixels which dont need AA.",
+        //     For APIs which enable concurrent TEX+ROP from same surface.
+    "    // 0 = Return unchanged color on pixels which dont need AA.",
+        //
+        #define FXAA_DISCARD 0
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #ifndef FXAA_FAST_PIXEL_OFFSET
+        //
+        // Used for GLSL 120 only.
+        //
+        // 1 = GL API supports fast pixel offsets
+        // 0 = do not use fast pixel offsets
+        //
+        #ifdef GL_EXT_gpu_shader4
+            #define FXAA_FAST_PIXEL_OFFSET 1
+        #endif
+        #ifdef GL_NV_gpu_shader5
+            #define FXAA_FAST_PIXEL_OFFSET 1
+        #endif
+        #ifdef GL_ARB_gpu_shader5
+            #define FXAA_FAST_PIXEL_OFFSET 1
+        #endif
+        #ifndef FXAA_FAST_PIXEL_OFFSET
+            #define FXAA_FAST_PIXEL_OFFSET 0
+        #endif
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #ifndef FXAA_GATHER4_ALPHA
+        //
+        // 1 = API supports gather4 on alpha channel.
+        // 0 = API does not support gather4 on alpha channel.
+        //
+        #if (FXAA_HLSL_5 == 1)
+            #define FXAA_GATHER4_ALPHA 1
+        #endif
+        #ifdef GL_ARB_gpu_shader5
+            #define FXAA_GATHER4_ALPHA 1
+        #endif
+        #ifdef GL_NV_gpu_shader5
+            #define FXAA_GATHER4_ALPHA 1
+        #endif
+        #ifndef FXAA_GATHER4_ALPHA
+            #define FXAA_GATHER4_ALPHA 0
+        #endif
+    #endif
+    
+    
+    /*============================================================================
+                            FXAA QUALITY - TUNING KNOBS
+    ------------------------------------------------------------------------------
+    NOTE the other tuning knobs are now in the shader function inputs!
+    ============================================================================*/
+    #ifndef FXAA_QUALITY_PRESET
+        //
+        // Choose the quality preset.
+        // This needs to be compiled into the shader as it effects code.
+        // Best option to include multiple presets is to
+        // in each shader define the preset, then include this file.
+        //
+        // OPTIONS
+        // -----------------------------------------------------------------------
+        // 10 to 15 - default medium dither (10=fastest, 15=highest quality)
+        // 20 to 29 - less dither, more expensive (20=fastest, 29=highest quality)
+        // 39       - no dither, very expensive
+        //
+        // NOTES
+        // -----------------------------------------------------------------------
+        // 12 = slightly faster then FXAA 3.9 and higher edge quality (default)
+        // 13 = about same speed as FXAA 3.9 and better than 12
+        // 23 = closest to FXAA 3.9 visually and performance wise
+        //  _ = the lowest digit is directly related to performance
+        // _  = the highest digit is directly related to style
+        //
+        #define FXAA_QUALITY_PRESET 12
+    #endif
+    
+    
+    /*============================================================================
+    
+                               FXAA QUALITY - PRESETS
+    
+    ============================================================================*/
+    
+    /*============================================================================
+                         FXAA QUALITY - MEDIUM DITHER PRESETS
+    ============================================================================*/
+    #if (FXAA_QUALITY_PRESET == 10)
+        #define FXAA_QUALITY_PS 3
+        #define FXAA_QUALITY_P0 1.5
+        #define FXAA_QUALITY_P1 3.0
+        #define FXAA_QUALITY_P2 12.0
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #if (FXAA_QUALITY_PRESET == 11)
+        #define FXAA_QUALITY_PS 4
+        #define FXAA_QUALITY_P0 1.0
+        #define FXAA_QUALITY_P1 1.5
+        #define FXAA_QUALITY_P2 3.0
+        #define FXAA_QUALITY_P3 12.0
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #if (FXAA_QUALITY_PRESET == 12)
+        #define FXAA_QUALITY_PS 5
+        #define FXAA_QUALITY_P0 1.0
+        #define FXAA_QUALITY_P1 1.5
+        #define FXAA_QUALITY_P2 2.0
+        #define FXAA_QUALITY_P3 4.0
+        #define FXAA_QUALITY_P4 12.0
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #if (FXAA_QUALITY_PRESET == 13)
+        #define FXAA_QUALITY_PS 6
+        #define FXAA_QUALITY_P0 1.0
+        #define FXAA_QUALITY_P1 1.5
+        #define FXAA_QUALITY_P2 2.0
+        #define FXAA_QUALITY_P3 2.0
+        #define FXAA_QUALITY_P4 4.0
+        #define FXAA_QUALITY_P5 12.0
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #if (FXAA_QUALITY_PRESET == 14)
+        #define FXAA_QUALITY_PS 7
+        #define FXAA_QUALITY_P0 1.0
+        #define FXAA_QUALITY_P1 1.5
+        #define FXAA_QUALITY_P2 2.0
+        #define FXAA_QUALITY_P3 2.0
+        #define FXAA_QUALITY_P4 2.0
+        #define FXAA_QUALITY_P5 4.0
+        #define FXAA_QUALITY_P6 12.0
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #if (FXAA_QUALITY_PRESET == 15)
+        #define FXAA_QUALITY_PS 8
+        #define FXAA_QUALITY_P0 1.0
+        #define FXAA_QUALITY_P1 1.5
+        #define FXAA_QUALITY_P2 2.0
+        #define FXAA_QUALITY_P3 2.0
+        #define FXAA_QUALITY_P4 2.0
+        #define FXAA_QUALITY_P5 2.0
+        #define FXAA_QUALITY_P6 4.0
+        #define FXAA_QUALITY_P7 12.0
+    #endif
+    
+    /*============================================================================
+                         FXAA QUALITY - LOW DITHER PRESETS
+    ============================================================================*/
+    #if (FXAA_QUALITY_PRESET == 20)
+        #define FXAA_QUALITY_PS 3
+        #define FXAA_QUALITY_P0 1.5
+        #define FXAA_QUALITY_P1 2.0
+        #define FXAA_QUALITY_P2 8.0
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #if (FXAA_QUALITY_PRESET == 21)
+        #define FXAA_QUALITY_PS 4
+        #define FXAA_QUALITY_P0 1.0
+        #define FXAA_QUALITY_P1 1.5
+        #define FXAA_QUALITY_P2 2.0
+        #define FXAA_QUALITY_P3 8.0
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #if (FXAA_QUALITY_PRESET == 22)
+        #define FXAA_QUALITY_PS 5
+        #define FXAA_QUALITY_P0 1.0
+        #define FXAA_QUALITY_P1 1.5
+        #define FXAA_QUALITY_P2 2.0
+        #define FXAA_QUALITY_P3 2.0
+        #define FXAA_QUALITY_P4 8.0
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #if (FXAA_QUALITY_PRESET == 23)
+        #define FXAA_QUALITY_PS 6
+        #define FXAA_QUALITY_P0 1.0
+        #define FXAA_QUALITY_P1 1.5
+        #define FXAA_QUALITY_P2 2.0
+        #define FXAA_QUALITY_P3 2.0
+        #define FXAA_QUALITY_P4 2.0
+        #define FXAA_QUALITY_P5 8.0
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #if (FXAA_QUALITY_PRESET == 24)
+        #define FXAA_QUALITY_PS 7
+        #define FXAA_QUALITY_P0 1.0
+        #define FXAA_QUALITY_P1 1.5
+        #define FXAA_QUALITY_P2 2.0
+        #define FXAA_QUALITY_P3 2.0
+        #define FXAA_QUALITY_P4 2.0
+        #define FXAA_QUALITY_P5 3.0
+        #define FXAA_QUALITY_P6 8.0
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #if (FXAA_QUALITY_PRESET == 25)
+        #define FXAA_QUALITY_PS 8
+        #define FXAA_QUALITY_P0 1.0
+        #define FXAA_QUALITY_P1 1.5
+        #define FXAA_QUALITY_P2 2.0
+        #define FXAA_QUALITY_P3 2.0
+        #define FXAA_QUALITY_P4 2.0
+        #define FXAA_QUALITY_P5 2.0
+        #define FXAA_QUALITY_P6 4.0
+        #define FXAA_QUALITY_P7 8.0
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #if (FXAA_QUALITY_PRESET == 26)
+        #define FXAA_QUALITY_PS 9
+        #define FXAA_QUALITY_P0 1.0
+        #define FXAA_QUALITY_P1 1.5
+        #define FXAA_QUALITY_P2 2.0
+        #define FXAA_QUALITY_P3 2.0
+        #define FXAA_QUALITY_P4 2.0
+        #define FXAA_QUALITY_P5 2.0
+        #define FXAA_QUALITY_P6 2.0
+        #define FXAA_QUALITY_P7 4.0
+        #define FXAA_QUALITY_P8 8.0
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #if (FXAA_QUALITY_PRESET == 27)
+        #define FXAA_QUALITY_PS 10
+        #define FXAA_QUALITY_P0 1.0
+        #define FXAA_QUALITY_P1 1.5
+        #define FXAA_QUALITY_P2 2.0
+        #define FXAA_QUALITY_P3 2.0
+        #define FXAA_QUALITY_P4 2.0
+        #define FXAA_QUALITY_P5 2.0
+        #define FXAA_QUALITY_P6 2.0
+        #define FXAA_QUALITY_P7 2.0
+        #define FXAA_QUALITY_P8 4.0
+        #define FXAA_QUALITY_P9 8.0
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #if (FXAA_QUALITY_PRESET == 28)
+        #define FXAA_QUALITY_PS 11
+        #define FXAA_QUALITY_P0 1.0
+        #define FXAA_QUALITY_P1 1.5
+        #define FXAA_QUALITY_P2 2.0
+        #define FXAA_QUALITY_P3 2.0
+        #define FXAA_QUALITY_P4 2.0
+        #define FXAA_QUALITY_P5 2.0
+        #define FXAA_QUALITY_P6 2.0
+        #define FXAA_QUALITY_P7 2.0
+        #define FXAA_QUALITY_P8 2.0
+        #define FXAA_QUALITY_P9 4.0
+        #define FXAA_QUALITY_P10 8.0
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #if (FXAA_QUALITY_PRESET == 29)
+        #define FXAA_QUALITY_PS 12
+        #define FXAA_QUALITY_P0 1.0
+        #define FXAA_QUALITY_P1 1.5
+        #define FXAA_QUALITY_P2 2.0
+        #define FXAA_QUALITY_P3 2.0
+        #define FXAA_QUALITY_P4 2.0
+        #define FXAA_QUALITY_P5 2.0
+        #define FXAA_QUALITY_P6 2.0
+        #define FXAA_QUALITY_P7 2.0
+        #define FXAA_QUALITY_P8 2.0
+        #define FXAA_QUALITY_P9 2.0
+        #define FXAA_QUALITY_P10 4.0
+        #define FXAA_QUALITY_P11 8.0
+    #endif
+    
+    /*============================================================================
+                         FXAA QUALITY - EXTREME QUALITY
+    ============================================================================*/
+    #if (FXAA_QUALITY_PRESET == 39)
+        #define FXAA_QUALITY_PS 12
+        #define FXAA_QUALITY_P0 1.0
+        #define FXAA_QUALITY_P1 1.0
+        #define FXAA_QUALITY_P2 1.0
+        #define FXAA_QUALITY_P3 1.0
+        #define FXAA_QUALITY_P4 1.0
+        #define FXAA_QUALITY_P5 1.5
+        #define FXAA_QUALITY_P6 2.0
+        #define FXAA_QUALITY_P7 2.0
+        #define FXAA_QUALITY_P8 2.0
+        #define FXAA_QUALITY_P9 2.0
+        #define FXAA_QUALITY_P10 4.0
+        #define FXAA_QUALITY_P11 8.0
+    #endif
+    
+    
+    
+    /*============================================================================
+    
+                                    API PORTING
+    
+    ============================================================================*/
+    #if (FXAA_GLSL_100 == 1) || (FXAA_GLSL_120 == 1) || (FXAA_GLSL_130 == 1)
+        #define FxaaBool bool
+        #define FxaaDiscard discard
+        #define FxaaFloat float
+        #define FxaaFloat2 vec2
+        #define FxaaFloat3 vec3
+        #define FxaaFloat4 vec4
+        #define FxaaHalf float
+        #define FxaaHalf2 vec2
+        #define FxaaHalf3 vec3
+        #define FxaaHalf4 vec4
+        #define FxaaInt2 ivec2
+        #define FxaaSat(x) clamp(x, 0.0, 1.0)
+        #define FxaaTex sampler2D
+    #else
+        #define FxaaBool bool
+        #define FxaaDiscard clip(-1)
+        #define FxaaFloat float
+        #define FxaaFloat2 float2
+        #define FxaaFloat3 float3
+        #define FxaaFloat4 float4
+        #define FxaaHalf half
+        #define FxaaHalf2 half2
+        #define FxaaHalf3 half3
+        #define FxaaHalf4 half4
+        #define FxaaSat(x) saturate(x)
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #if (FXAA_GLSL_100 == 1)
+      #define FxaaTexTop(t, p) texture2D(t, p, 0.0)
+      #define FxaaTexOff(t, p, o, r) texture2D(t, p + (o * r), 0.0)
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #if (FXAA_GLSL_120 == 1)
+        // Requires,
+        //  #version 120
+        // And at least,
+        //  #extension GL_EXT_gpu_shader4 : enable
+        //  (or set FXAA_FAST_PIXEL_OFFSET 1 to work like DX9)
+        #define FxaaTexTop(t, p) texture2DLod(t, p, 0.0)
+        #if (FXAA_FAST_PIXEL_OFFSET == 1)
+            #define FxaaTexOff(t, p, o, r) texture2DLodOffset(t, p, 0.0, o)
+        #else
+            #define FxaaTexOff(t, p, o, r) texture2DLod(t, p + (o * r), 0.0)
+        #endif
+        #if (FXAA_GATHER4_ALPHA == 1)
+            // use #extension GL_ARB_gpu_shader5 : enable
+            #define FxaaTexAlpha4(t, p) textureGather(t, p, 3)
+            #define FxaaTexOffAlpha4(t, p, o) textureGatherOffset(t, p, o, 3)
+            #define FxaaTexGreen4(t, p) textureGather(t, p, 1)
+            #define FxaaTexOffGreen4(t, p, o) textureGatherOffset(t, p, o, 1)
+        #endif
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #if (FXAA_GLSL_130 == 1)
+        // Requires "#version 130" or better
+        #define FxaaTexTop(t, p) textureLod(t, p, 0.0)
+        #define FxaaTexOff(t, p, o, r) textureLodOffset(t, p, 0.0, o)
+        #if (FXAA_GATHER4_ALPHA == 1)
+            // use #extension GL_ARB_gpu_shader5 : enable
+            #define FxaaTexAlpha4(t, p) textureGather(t, p, 3)
+            #define FxaaTexOffAlpha4(t, p, o) textureGatherOffset(t, p, o, 3)
+            #define FxaaTexGreen4(t, p) textureGather(t, p, 1)
+            #define FxaaTexOffGreen4(t, p, o) textureGatherOffset(t, p, o, 1)
+        #endif
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #if (FXAA_HLSL_3 == 1)
+        #define FxaaInt2 float2
+        #define FxaaTex sampler2D
+        #define FxaaTexTop(t, p) tex2Dlod(t, float4(p, 0.0, 0.0))
+        #define FxaaTexOff(t, p, o, r) tex2Dlod(t, float4(p + (o * r), 0, 0))
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #if (FXAA_HLSL_4 == 1)
+        #define FxaaInt2 int2
+        struct FxaaTex { SamplerState smpl; Texture2D tex; };
+        #define FxaaTexTop(t, p) t.tex.SampleLevel(t.smpl, p, 0.0)
+        #define FxaaTexOff(t, p, o, r) t.tex.SampleLevel(t.smpl, p, 0.0, o)
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #if (FXAA_HLSL_5 == 1)
+        #define FxaaInt2 int2
+        struct FxaaTex { SamplerState smpl; Texture2D tex; };
+        #define FxaaTexTop(t, p) t.tex.SampleLevel(t.smpl, p, 0.0)
+        #define FxaaTexOff(t, p, o, r) t.tex.SampleLevel(t.smpl, p, 0.0, o)
+        #define FxaaTexAlpha4(t, p) t.tex.GatherAlpha(t.smpl, p)
+        #define FxaaTexOffAlpha4(t, p, o) t.tex.GatherAlpha(t.smpl, p, o)
+        #define FxaaTexGreen4(t, p) t.tex.GatherGreen(t.smpl, p)
+        #define FxaaTexOffGreen4(t, p, o) t.tex.GatherGreen(t.smpl, p, o)
+    #endif
+    
+    
+    /*============================================================================
+                       GREEN AS LUMA OPTION SUPPORT FUNCTION
+    ============================================================================*/
+    #if (FXAA_GREEN_AS_LUMA == 0)
+        FxaaFloat FxaaLuma(FxaaFloat4 rgba) { return rgba.w; }
+    #else
+        FxaaFloat FxaaLuma(FxaaFloat4 rgba) { return rgba.y; }
+    #endif
+    
+    
+    
+    
+    /*============================================================================
+    
+                                 FXAA3 QUALITY - PC
+    
+    ============================================================================*/
+    #if (FXAA_PC == 1)
+    /*--------------------------------------------------------------------------*/
+    FxaaFloat4 FxaaPixelShader(
+        //
+        // Use noperspective interpolation here (turn off perspective interpolation).
+        // {xy} = center of pixel
+        FxaaFloat2 pos,
+        //
+        // Used only for FXAA Console, and not used on the 360 version.
+        // Use noperspective interpolation here (turn off perspective interpolation).
+        // {xy_} = upper left of pixel
+        // {_zw} = lower right of pixel
+        FxaaFloat4 fxaaConsolePosPos,
+        //
+        // Input color texture.
+        // {rgb_} = color in linear or perceptual color space
+        // if (FXAA_GREEN_AS_LUMA == 0)
+        //     {__a} = luma in perceptual color space (not linear)
+        FxaaTex tex,
+        //
+        // Only used on the optimized 360 version of FXAA Console.
+        // For everything but 360, just use the same input here as for "tex".
+        // For 360, same texture, just alias with a 2nd sampler.
+        // This sampler needs to have an exponent bias of -1.
+        FxaaTex fxaaConsole360TexExpBiasNegOne,
+        //
+        // Only used on the optimized 360 version of FXAA Console.
+        // For everything but 360, just use the same input here as for "tex".
+        // For 360, same texture, just alias with a 3nd sampler.
+        // This sampler needs to have an exponent bias of -2.
+        FxaaTex fxaaConsole360TexExpBiasNegTwo,
+        //
+        // Only used on FXAA Quality.
+        // This must be from a constant/uniform.
+        // {x_} = 1.0/screenWidthInPixels
+        // {_y} = 1.0/screenHeightInPixels
+        FxaaFloat2 fxaaQualityRcpFrame,
+        //
+        // Only used on FXAA Console.
+        // This must be from a constant/uniform.
+        // This effects sub-pixel AA quality and inversely sharpness.
+        //   Where N ranges between,
+        //     N = 0.50 (default)
+        //     N = 0.33 (sharper)
+        // {x__} = -N/screenWidthInPixels
+        // {_y_} = -N/screenHeightInPixels
+        // {_z_} =  N/screenWidthInPixels
+        // {__w} =  N/screenHeightInPixels
+        FxaaFloat4 fxaaConsoleRcpFrameOpt,
+        //
+        // Only used on FXAA Console.
+        // Not used on 360, but used on PS3 and PC.
+        // This must be from a constant/uniform.
+        // {x__} = -2.0/screenWidthInPixels
+        // {_y_} = -2.0/screenHeightInPixels
+        // {_z_} =  2.0/screenWidthInPixels
+        // {__w} =  2.0/screenHeightInPixels
+        FxaaFloat4 fxaaConsoleRcpFrameOpt2,
+        //
+        // Only used on FXAA Console.
+        // Only used on 360 in place of fxaaConsoleRcpFrameOpt2.
+        // This must be from a constant/uniform.
+        // {x__} =  8.0/screenWidthInPixels
+        // {_y_} =  8.0/screenHeightInPixels
+        // {_z_} = -4.0/screenWidthInPixels
+        // {__w} = -4.0/screenHeightInPixels
+        FxaaFloat4 fxaaConsole360RcpFrameOpt2,
+        //
+        // Only used on FXAA Quality.
+        // This used to be the FXAA_QUALITY_SUBPIX define.
+        // It is here now to allow easier tuning.
+        // Choose the amount of sub-pixel aliasing removal.
+        // This can effect sharpness.
+        //   1.00 - upper limit (softer)
+        //   0.75 - default amount of filtering
+        //   0.50 - lower limit (sharper, less sub-pixel aliasing removal)
+        //   0.25 - almost off
+        //   0.00 - completely off
+        FxaaFloat fxaaQualitySubpix,
+        //
+        // Only used on FXAA Quality.
+        // This used to be the FXAA_QUALITY_EDGE_THRESHOLD define.
+        // It is here now to allow easier tuning.
+        // The minimum amount of local contrast required to apply algorithm.
+        //   0.333 - too little (faster)
+        //   0.250 - low quality
+        //   0.166 - default
+        //   0.125 - high quality
+        //   0.063 - overkill (slower)
+        FxaaFloat fxaaQualityEdgeThreshold,
+        //
+        // Only used on FXAA Quality.
+        // This used to be the FXAA_QUALITY_EDGE_THRESHOLD_MIN define.
+        // It is here now to allow easier tuning.
+        // Trims the algorithm from processing darks.
+        //   0.0833 - upper limit (default, the start of visible unfiltered edges)
+        //   0.0625 - high quality (faster)
+        //   0.0312 - visible limit (slower)
+        // Special notes when using FXAA_GREEN_AS_LUMA,
+        //   Likely want to set this to zero.
+        //   As colors that are mostly not-green
+        //   will appear very dark in the green channel!
+        //   Tune by looking at mostly non-green content,
+        //   then start at zero and increase until aliasing is a problem.
+        FxaaFloat fxaaQualityEdgeThresholdMin,
+        //
+        // Only used on FXAA Console.
+        // This used to be the FXAA_CONSOLE_EDGE_SHARPNESS define.
+        // It is here now to allow easier tuning.
+        // This does not effect PS3, as this needs to be compiled in.
+        //   Use FXAA_CONSOLE_PS3_EDGE_SHARPNESS for PS3.
+        //   Due to the PS3 being ALU bound,
+        //   there are only three safe values here: 2 and 4 and 8.
+        //   These options use the shaders ability to a free *|/ by 2|4|8.
+        // For all other platforms can be a non-power of two.
+        //   8.0 is sharper (default!!!)
+        //   4.0 is softer
+        //   2.0 is really soft (good only for vector graphics inputs)
+        FxaaFloat fxaaConsoleEdgeSharpness,
+        //
+        // Only used on FXAA Console.
+        // This used to be the FXAA_CONSOLE_EDGE_THRESHOLD define.
+        // It is here now to allow easier tuning.
+        // This does not effect PS3, as this needs to be compiled in.
+        //   Use FXAA_CONSOLE_PS3_EDGE_THRESHOLD for PS3.
+        //   Due to the PS3 being ALU bound,
+        //   there are only two safe values here: 1/4 and 1/8.
+        //   These options use the shaders ability to a free *|/ by 2|4|8.
+        // The console setting has a different mapping than the quality setting.
+        // Other platforms can use other values.
+        //   0.125 leaves less aliasing, but is softer (default!!!)
+        //   0.25 leaves more aliasing, and is sharper
+        FxaaFloat fxaaConsoleEdgeThreshold,
+        //
+        // Only used on FXAA Console.
+        // This used to be the FXAA_CONSOLE_EDGE_THRESHOLD_MIN define.
+        // It is here now to allow easier tuning.
+        // Trims the algorithm from processing darks.
+        // The console setting has a different mapping than the quality setting.
+        // This only applies when FXAA_EARLY_EXIT is 1.
+        // This does not apply to PS3,
+        // PS3 was simplified to avoid more shader instructions.
+        //   0.06 - faster but more aliasing in darks
+        //   0.05 - default
+        //   0.04 - slower and less aliasing in darks
+        // Special notes when using FXAA_GREEN_AS_LUMA,
+        //   Likely want to set this to zero.
+        //   As colors that are mostly not-green
+        //   will appear very dark in the green channel!
+        //   Tune by looking at mostly non-green content,
+        //   then start at zero and increase until aliasing is a problem.
+        FxaaFloat fxaaConsoleEdgeThresholdMin,
+        //
+        // Extra constants for 360 FXAA Console only.
+        // Use zeros or anything else for other platforms.
+        // These must be in physical constant registers and NOT immediates.
+        // Immediates will result in compiler un-optimizing.
+        // {xyzw} = float4(1.0, -1.0, 0.25, -0.25)
+        FxaaFloat4 fxaaConsole360ConstDir
+    ) {
+    /*--------------------------------------------------------------------------*/
+        FxaaFloat2 posM;
+        posM.x = pos.x;
+        posM.y = pos.y;
+        #if (FXAA_GATHER4_ALPHA == 1)
+            #if (FXAA_DISCARD == 0)
+                FxaaFloat4 rgbyM = FxaaTexTop(tex, posM);
+                #if (FXAA_GREEN_AS_LUMA == 0)
+                    #define lumaM rgbyM.w
+                #else
+                    #define lumaM rgbyM.y
+                #endif
+            #endif
+            #if (FXAA_GREEN_AS_LUMA == 0)
+                FxaaFloat4 luma4A = FxaaTexAlpha4(tex, posM);
+                FxaaFloat4 luma4B = FxaaTexOffAlpha4(tex, posM, FxaaInt2(-1, -1));
+            #else
+                FxaaFloat4 luma4A = FxaaTexGreen4(tex, posM);
+                FxaaFloat4 luma4B = FxaaTexOffGreen4(tex, posM, FxaaInt2(-1, -1));
+            #endif
+            #if (FXAA_DISCARD == 1)
+                #define lumaM luma4A.w
+            #endif
+            #define lumaE luma4A.z
+            #define lumaS luma4A.x
+            #define lumaSE luma4A.y
+            #define lumaNW luma4B.w
+            #define lumaN luma4B.z
+            #define lumaW luma4B.x
+        #else
+            FxaaFloat4 rgbyM = FxaaTexTop(tex, posM);
+            #if (FXAA_GREEN_AS_LUMA == 0)
+                #define lumaM rgbyM.w
+            #else
+                #define lumaM rgbyM.y
+            #endif
+            #if (FXAA_GLSL_100 == 1)
+              FxaaFloat lumaS = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2( 0.0, 1.0), fxaaQualityRcpFrame.xy));
+              FxaaFloat lumaE = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2( 1.0, 0.0), fxaaQualityRcpFrame.xy));
+              FxaaFloat lumaN = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2( 0.0,-1.0), fxaaQualityRcpFrame.xy));
+              FxaaFloat lumaW = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2(-1.0, 0.0), fxaaQualityRcpFrame.xy));
+            #else
+              FxaaFloat lumaS = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 0, 1), fxaaQualityRcpFrame.xy));
+              FxaaFloat lumaE = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 1, 0), fxaaQualityRcpFrame.xy));
+              FxaaFloat lumaN = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 0,-1), fxaaQualityRcpFrame.xy));
+              FxaaFloat lumaW = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(-1, 0), fxaaQualityRcpFrame.xy));
+            #endif
+        #endif
+    /*--------------------------------------------------------------------------*/
+        FxaaFloat maxSM = max(lumaS, lumaM);
+        FxaaFloat minSM = min(lumaS, lumaM);
+        FxaaFloat maxESM = max(lumaE, maxSM);
+        FxaaFloat minESM = min(lumaE, minSM);
+        FxaaFloat maxWN = max(lumaN, lumaW);
+        FxaaFloat minWN = min(lumaN, lumaW);
+        FxaaFloat rangeMax = max(maxWN, maxESM);
+        FxaaFloat rangeMin = min(minWN, minESM);
+        FxaaFloat rangeMaxScaled = rangeMax * fxaaQualityEdgeThreshold;
+        FxaaFloat range = rangeMax - rangeMin;
+        FxaaFloat rangeMaxClamped = max(fxaaQualityEdgeThresholdMin, rangeMaxScaled);
+        FxaaBool earlyExit = range < rangeMaxClamped;
+    /*--------------------------------------------------------------------------*/
+        if(earlyExit)
+            #if (FXAA_DISCARD == 1)
+                FxaaDiscard;
+            #else
+                return rgbyM;
+            #endif
+    /*--------------------------------------------------------------------------*/
+        #if (FXAA_GATHER4_ALPHA == 0)
+            #if (FXAA_GLSL_100 == 1)
+              FxaaFloat lumaNW = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2(-1.0,-1.0), fxaaQualityRcpFrame.xy));
+              FxaaFloat lumaSE = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2( 1.0, 1.0), fxaaQualityRcpFrame.xy));
+              FxaaFloat lumaNE = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2( 1.0,-1.0), fxaaQualityRcpFrame.xy));
+              FxaaFloat lumaSW = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2(-1.0, 1.0), fxaaQualityRcpFrame.xy));
+            #else
+              FxaaFloat lumaNW = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(-1,-1), fxaaQualityRcpFrame.xy));
+              FxaaFloat lumaSE = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 1, 1), fxaaQualityRcpFrame.xy));
+              FxaaFloat lumaNE = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 1,-1), fxaaQualityRcpFrame.xy));
+              FxaaFloat lumaSW = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(-1, 1), fxaaQualityRcpFrame.xy));
+            #endif
+        #else
+            FxaaFloat lumaNE = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(1, -1), fxaaQualityRcpFrame.xy));
+            FxaaFloat lumaSW = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(-1, 1), fxaaQualityRcpFrame.xy));
+        #endif
+    /*--------------------------------------------------------------------------*/
+        FxaaFloat lumaNS = lumaN + lumaS;
+        FxaaFloat lumaWE = lumaW + lumaE;
+        FxaaFloat subpixRcpRange = 1.0/range;
+        FxaaFloat subpixNSWE = lumaNS + lumaWE;
+        FxaaFloat edgeHorz1 = (-2.0 * lumaM) + lumaNS;
+        FxaaFloat edgeVert1 = (-2.0 * lumaM) + lumaWE;
+    /*--------------------------------------------------------------------------*/
+        FxaaFloat lumaNESE = lumaNE + lumaSE;
+        FxaaFloat lumaNWNE = lumaNW + lumaNE;
+        FxaaFloat edgeHorz2 = (-2.0 * lumaE) + lumaNESE;
+        FxaaFloat edgeVert2 = (-2.0 * lumaN) + lumaNWNE;
+    /*--------------------------------------------------------------------------*/
+        FxaaFloat lumaNWSW = lumaNW + lumaSW;
+        FxaaFloat lumaSWSE = lumaSW + lumaSE;
+        FxaaFloat edgeHorz4 = (abs(edgeHorz1) * 2.0) + abs(edgeHorz2);
+        FxaaFloat edgeVert4 = (abs(edgeVert1) * 2.0) + abs(edgeVert2);
+        FxaaFloat edgeHorz3 = (-2.0 * lumaW) + lumaNWSW;
+        FxaaFloat edgeVert3 = (-2.0 * lumaS) + lumaSWSE;
+        FxaaFloat edgeHorz = abs(edgeHorz3) + edgeHorz4;
+        FxaaFloat edgeVert = abs(edgeVert3) + edgeVert4;
+    /*--------------------------------------------------------------------------*/
+        FxaaFloat subpixNWSWNESE = lumaNWSW + lumaNESE;
+        FxaaFloat lengthSign = fxaaQualityRcpFrame.x;
+        FxaaBool horzSpan = edgeHorz >= edgeVert;
+        FxaaFloat subpixA = subpixNSWE * 2.0 + subpixNWSWNESE;
+    /*--------------------------------------------------------------------------*/
+        if(!horzSpan) lumaN = lumaW;
+        if(!horzSpan) lumaS = lumaE;
+        if(horzSpan) lengthSign = fxaaQualityRcpFrame.y;
+        FxaaFloat subpixB = (subpixA * (1.0/12.0)) - lumaM;
+    /*--------------------------------------------------------------------------*/
+        FxaaFloat gradientN = lumaN - lumaM;
+        FxaaFloat gradientS = lumaS - lumaM;
+        FxaaFloat lumaNN = lumaN + lumaM;
+        FxaaFloat lumaSS = lumaS + lumaM;
+        FxaaBool pairN = abs(gradientN) >= abs(gradientS);
+        FxaaFloat gradient = max(abs(gradientN), abs(gradientS));
+        if(pairN) lengthSign = -lengthSign;
+        FxaaFloat subpixC = FxaaSat(abs(subpixB) * subpixRcpRange);
+    /*--------------------------------------------------------------------------*/
+        FxaaFloat2 posB;
+        posB.x = posM.x;
+        posB.y = posM.y;
+        FxaaFloat2 offNP;
+        offNP.x = (!horzSpan) ? 0.0 : fxaaQualityRcpFrame.x;
+        offNP.y = ( horzSpan) ? 0.0 : fxaaQualityRcpFrame.y;
+        if(!horzSpan) posB.x += lengthSign * 0.5;
+        if( horzSpan) posB.y += lengthSign * 0.5;
+    /*--------------------------------------------------------------------------*/
+        FxaaFloat2 posN;
+        posN.x = posB.x - offNP.x * FXAA_QUALITY_P0;
+        posN.y = posB.y - offNP.y * FXAA_QUALITY_P0;
+        FxaaFloat2 posP;
+        posP.x = posB.x + offNP.x * FXAA_QUALITY_P0;
+        posP.y = posB.y + offNP.y * FXAA_QUALITY_P0;
+        FxaaFloat subpixD = ((-2.0)*subpixC) + 3.0;
+        FxaaFloat lumaEndN = FxaaLuma(FxaaTexTop(tex, posN));
+        FxaaFloat subpixE = subpixC * subpixC;
+        FxaaFloat lumaEndP = FxaaLuma(FxaaTexTop(tex, posP));
+    /*--------------------------------------------------------------------------*/
+        if(!pairN) lumaNN = lumaSS;
+        FxaaFloat gradientScaled = gradient * 1.0/4.0;
+        FxaaFloat lumaMM = lumaM - lumaNN * 0.5;
+        FxaaFloat subpixF = subpixD * subpixE;
+        FxaaBool lumaMLTZero = lumaMM < 0.0;
+    /*--------------------------------------------------------------------------*/
+        lumaEndN -= lumaNN * 0.5;
+        lumaEndP -= lumaNN * 0.5;
+        FxaaBool doneN = abs(lumaEndN) >= gradientScaled;
+        FxaaBool doneP = abs(lumaEndP) >= gradientScaled;
+        if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P1;
+        if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P1;
+        FxaaBool doneNP = (!doneN) || (!doneP);
+        if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P1;
+        if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P1;
+    /*--------------------------------------------------------------------------*/
+        if(doneNP) {
+            if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
+            if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
+            if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
+            if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
+            doneN = abs(lumaEndN) >= gradientScaled;
+            doneP = abs(lumaEndP) >= gradientScaled;
+            if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P2;
+            if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P2;
+            doneNP = (!doneN) || (!doneP);
+            if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P2;
+            if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P2;
+    /*--------------------------------------------------------------------------*/
+            #if (FXAA_QUALITY_PS > 3)
+            if(doneNP) {
+                if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
+                if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
+                if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
+                if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
+                doneN = abs(lumaEndN) >= gradientScaled;
+                doneP = abs(lumaEndP) >= gradientScaled;
+                if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P3;
+                if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P3;
+                doneNP = (!doneN) || (!doneP);
+                if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P3;
+                if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P3;
+    /*--------------------------------------------------------------------------*/
+                #if (FXAA_QUALITY_PS > 4)
+                if(doneNP) {
+                    if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
+                    if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
+                    if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
+                    if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
+                    doneN = abs(lumaEndN) >= gradientScaled;
+                    doneP = abs(lumaEndP) >= gradientScaled;
+                    if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P4;
+                    if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P4;
+                    doneNP = (!doneN) || (!doneP);
+                    if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P4;
+                    if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P4;
+    /*--------------------------------------------------------------------------*/
+                    #if (FXAA_QUALITY_PS > 5)
+                    if(doneNP) {
+                        if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
+                        if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
+                        if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
+                        if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
+                        doneN = abs(lumaEndN) >= gradientScaled;
+                        doneP = abs(lumaEndP) >= gradientScaled;
+                        if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P5;
+                        if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P5;
+                        doneNP = (!doneN) || (!doneP);
+                        if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P5;
+                        if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P5;
+    /*--------------------------------------------------------------------------*/
+                        #if (FXAA_QUALITY_PS > 6)
+                        if(doneNP) {
+                            if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
+                            if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
+                            if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
+                            if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
+                            doneN = abs(lumaEndN) >= gradientScaled;
+                            doneP = abs(lumaEndP) >= gradientScaled;
+                            if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P6;
+                            if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P6;
+                            doneNP = (!doneN) || (!doneP);
+                            if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P6;
+                            if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P6;
+    /*--------------------------------------------------------------------------*/
+                            #if (FXAA_QUALITY_PS > 7)
+                            if(doneNP) {
+                                if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
+                                if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
+                                if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
+                                if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
+                                doneN = abs(lumaEndN) >= gradientScaled;
+                                doneP = abs(lumaEndP) >= gradientScaled;
+                                if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P7;
+                                if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P7;
+                                doneNP = (!doneN) || (!doneP);
+                                if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P7;
+                                if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P7;
+    /*--------------------------------------------------------------------------*/
+        #if (FXAA_QUALITY_PS > 8)
+        if(doneNP) {
+            if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
+            if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
+            if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
+            if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
+            doneN = abs(lumaEndN) >= gradientScaled;
+            doneP = abs(lumaEndP) >= gradientScaled;
+            if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P8;
+            if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P8;
+            doneNP = (!doneN) || (!doneP);
+            if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P8;
+            if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P8;
+    /*--------------------------------------------------------------------------*/
+            #if (FXAA_QUALITY_PS > 9)
+            if(doneNP) {
+                if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
+                if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
+                if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
+                if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
+                doneN = abs(lumaEndN) >= gradientScaled;
+                doneP = abs(lumaEndP) >= gradientScaled;
+                if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P9;
+                if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P9;
+                doneNP = (!doneN) || (!doneP);
+                if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P9;
+                if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P9;
+    /*--------------------------------------------------------------------------*/
+                #if (FXAA_QUALITY_PS > 10)
+                if(doneNP) {
+                    if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
+                    if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
+                    if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
+                    if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
+                    doneN = abs(lumaEndN) >= gradientScaled;
+                    doneP = abs(lumaEndP) >= gradientScaled;
+                    if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P10;
+                    if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P10;
+                    doneNP = (!doneN) || (!doneP);
+                    if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P10;
+                    if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P10;
+    /*--------------------------------------------------------------------------*/
+                    #if (FXAA_QUALITY_PS > 11)
+                    if(doneNP) {
+                        if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
+                        if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
+                        if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
+                        if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
+                        doneN = abs(lumaEndN) >= gradientScaled;
+                        doneP = abs(lumaEndP) >= gradientScaled;
+                        if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P11;
+                        if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P11;
+                        doneNP = (!doneN) || (!doneP);
+                        if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P11;
+                        if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P11;
+    /*--------------------------------------------------------------------------*/
+                        #if (FXAA_QUALITY_PS > 12)
+                        if(doneNP) {
+                            if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
+                            if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
+                            if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
+                            if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
+                            doneN = abs(lumaEndN) >= gradientScaled;
+                            doneP = abs(lumaEndP) >= gradientScaled;
+                            if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P12;
+                            if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P12;
+                            doneNP = (!doneN) || (!doneP);
+                            if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P12;
+                            if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P12;
+    /*--------------------------------------------------------------------------*/
+                        }
+                        #endif
+    /*--------------------------------------------------------------------------*/
+                    }
+                    #endif
+    /*--------------------------------------------------------------------------*/
+                }
+                #endif
+    /*--------------------------------------------------------------------------*/
+            }
+            #endif
+    /*--------------------------------------------------------------------------*/
+        }
+        #endif
+    /*--------------------------------------------------------------------------*/
+                            }
+                            #endif
+    /*--------------------------------------------------------------------------*/
+                        }
+                        #endif
+    /*--------------------------------------------------------------------------*/
+                    }
+                    #endif
+    /*--------------------------------------------------------------------------*/
+                }
+                #endif
+    /*--------------------------------------------------------------------------*/
+            }
+            #endif
+    /*--------------------------------------------------------------------------*/
+        }
+    /*--------------------------------------------------------------------------*/
+        FxaaFloat dstN = posM.x - posN.x;
+        FxaaFloat dstP = posP.x - posM.x;
+        if(!horzSpan) dstN = posM.y - posN.y;
+        if(!horzSpan) dstP = posP.y - posM.y;
+    /*--------------------------------------------------------------------------*/
+        FxaaBool goodSpanN = (lumaEndN < 0.0) != lumaMLTZero;
+        FxaaFloat spanLength = (dstP + dstN);
+        FxaaBool goodSpanP = (lumaEndP < 0.0) != lumaMLTZero;
+        FxaaFloat spanLengthRcp = 1.0/spanLength;
+    /*--------------------------------------------------------------------------*/
+        FxaaBool directionN = dstN < dstP;
+        FxaaFloat dst = min(dstN, dstP);
+        FxaaBool goodSpan = directionN ? goodSpanN : goodSpanP;
+        FxaaFloat subpixG = subpixF * subpixF;
+        FxaaFloat pixelOffset = (dst * (-spanLengthRcp)) + 0.5;
+        FxaaFloat subpixH = subpixG * fxaaQualitySubpix;
+    /*--------------------------------------------------------------------------*/
+        FxaaFloat pixelOffsetGood = goodSpan ? pixelOffset : 0.0;
+        FxaaFloat pixelOffsetSubpix = max(pixelOffsetGood, subpixH);
+        if(!horzSpan) posM.x += pixelOffsetSubpix * lengthSign;
+        if( horzSpan) posM.y += pixelOffsetSubpix * lengthSign;
+        #if (FXAA_DISCARD == 1)
+            return FxaaTexTop(tex, posM);
+        #else
+            return FxaaFloat4(FxaaTexTop(tex, posM).xyz, lumaM);
+        #endif
+    }
+    /*==========================================================================*/
+    #endif
+    
+    void main() {
+      gl_FragColor = FxaaPixelShader(
+        vUv,
+        vec4(0.0),
+        tDiffuse,
+        tDiffuse,
+        tDiffuse,
+        resolution,
+        vec4(0.0),
+        vec4(0.0),
+        vec4(0.0),
+        0.75,
+        0.166,
+        0.0833,
+        0.0,
+        0.0,
+        0.0,
+        vec4(0.0)
+      );
+    
+      // TODO avoid querying texture twice for same texel
+      gl_FragColor.a = texture2D(tDiffuse, vUv).a;
+    }
+  `,
 }
diff --git a/src/shaders/FilmShader.ts b/src/shaders/FilmShader.ts
index bc98b542..e05b9c7e 100644
--- a/src/shaders/FilmShader.ts
+++ b/src/shaders/FilmShader.ts
@@ -28,67 +28,67 @@ export const FilmShader = {
     grayscale: { value: 1 },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    '#include <common>',
+  fragmentShader: /* glsl */ `
+    #include <common>
 
     // control parameter
-    'uniform float time;',
+    uniform float time;
 
-    'uniform bool grayscale;',
+    uniform bool grayscale;
 
     // noise effect intensity value (0 = no effect, 1 = full effect)
-    'uniform float nIntensity;',
+    uniform float nIntensity;
 
     // scanlines effect intensity value (0 = no effect, 1 = full effect)
-    'uniform float sIntensity;',
+    uniform float sIntensity;
 
     // scanlines effect count value (0 = no effect, 4096 = full effect)
-    'uniform float sCount;',
+    uniform float sCount;
 
-    'uniform sampler2D tDiffuse;',
+    uniform sampler2D tDiffuse;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
     // sample the source
-    '	vec4 cTextureScreen = texture2D( tDiffuse, vUv );',
+    	vec4 cTextureScreen = texture2D( tDiffuse, vUv );
 
     // make some noise
-    '	float dx = rand( vUv + time );',
+    	float dx = rand( vUv + time );
 
     // add noise
-    '	vec3 cResult = cTextureScreen.rgb + cTextureScreen.rgb * clamp( 0.1 + dx, 0.0, 1.0 );',
+    	vec3 cResult = cTextureScreen.rgb + cTextureScreen.rgb * clamp( 0.1 + dx, 0.0, 1.0 );
 
     // get us a sine and cosine
-    '	vec2 sc = vec2( sin( vUv.y * sCount ), cos( vUv.y * sCount ) );',
+    	vec2 sc = vec2( sin( vUv.y * sCount ), cos( vUv.y * sCount ) );
 
     // add scanlines
-    '	cResult += cTextureScreen.rgb * vec3( sc.x, sc.y, sc.x ) * sIntensity;',
+    	cResult += cTextureScreen.rgb * vec3( sc.x, sc.y, sc.x ) * sIntensity;
 
     // interpolate between source and result by intensity
-    '	cResult = cTextureScreen.rgb + clamp( nIntensity, 0.0,1.0 ) * ( cResult - cTextureScreen.rgb );',
+    	cResult = cTextureScreen.rgb + clamp( nIntensity, 0.0,1.0 ) * ( cResult - cTextureScreen.rgb );
 
     // convert to grayscale if desired
-    '	if( grayscale ) {',
+    	if( grayscale ) {
 
-    '		cResult = vec3( cResult.r * 0.3 + cResult.g * 0.59 + cResult.b * 0.11 );',
+    		cResult = vec3( cResult.r * 0.3 + cResult.g * 0.59 + cResult.b * 0.11 );
 
-    '	}',
+    	}
 
-    '	gl_FragColor =  vec4( cResult, cTextureScreen.a );',
+    	gl_FragColor =  vec4( cResult, cTextureScreen.a );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/FocusShader.ts b/src/shaders/FocusShader.ts
index 8e49a8ba..68261a59 100644
--- a/src/shaders/FocusShader.ts
+++ b/src/shaders/FocusShader.ts
@@ -13,69 +13,69 @@ export const FocusShader = {
     waveFactor: { value: 0.00125 },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform float screenWidth;',
-    'uniform float screenHeight;',
-    'uniform float sampleDistance;',
-    'uniform float waveFactor;',
+  fragmentShader: /* glsl */ `
+    uniform float screenWidth;
+    uniform float screenHeight;
+    uniform float sampleDistance;
+    uniform float waveFactor;
 
-    'uniform sampler2D tDiffuse;',
+    uniform sampler2D tDiffuse;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vec4 color, org, tmp, add;',
-    '	float sample_dist, f;',
-    '	vec2 vin;',
-    '	vec2 uv = vUv;',
+    	vec4 color, org, tmp, add;
+    	float sample_dist, f;
+    	vec2 vin;
+    	vec2 uv = vUv;
 
-    '	add = color = org = texture2D( tDiffuse, uv );',
+    	add = color = org = texture2D( tDiffuse, uv );
 
-    '	vin = ( uv - vec2( 0.5 ) ) * vec2( 1.4 );',
-    '	sample_dist = dot( vin, vin ) * 2.0;',
+    	vin = ( uv - vec2( 0.5 ) ) * vec2( 1.4 );
+    	sample_dist = dot( vin, vin ) * 2.0;
 
-    '	f = ( waveFactor * 100.0 + sample_dist ) * sampleDistance * 4.0;',
+    	f = ( waveFactor * 100.0 + sample_dist ) * sampleDistance * 4.0;
 
-    '	vec2 sampleSize = vec2(  1.0 / screenWidth, 1.0 / screenHeight ) * vec2( f );',
+    	vec2 sampleSize = vec2(  1.0 / screenWidth, 1.0 / screenHeight ) * vec2( f );
 
-    '	add += tmp = texture2D( tDiffuse, uv + vec2( 0.111964, 0.993712 ) * sampleSize );',
-    '	if( tmp.b < color.b ) color = tmp;',
+    	add += tmp = texture2D( tDiffuse, uv + vec2( 0.111964, 0.993712 ) * sampleSize );
+    	if( tmp.b < color.b ) color = tmp;
 
-    '	add += tmp = texture2D( tDiffuse, uv + vec2( 0.846724, 0.532032 ) * sampleSize );',
-    '	if( tmp.b < color.b ) color = tmp;',
+    	add += tmp = texture2D( tDiffuse, uv + vec2( 0.846724, 0.532032 ) * sampleSize );
+    	if( tmp.b < color.b ) color = tmp;
 
-    '	add += tmp = texture2D( tDiffuse, uv + vec2( 0.943883, -0.330279 ) * sampleSize );',
-    '	if( tmp.b < color.b ) color = tmp;',
+    	add += tmp = texture2D( tDiffuse, uv + vec2( 0.943883, -0.330279 ) * sampleSize );
+    	if( tmp.b < color.b ) color = tmp;
 
-    '	add += tmp = texture2D( tDiffuse, uv + vec2( 0.330279, -0.943883 ) * sampleSize );',
-    '	if( tmp.b < color.b ) color = tmp;',
+    	add += tmp = texture2D( tDiffuse, uv + vec2( 0.330279, -0.943883 ) * sampleSize );
+    	if( tmp.b < color.b ) color = tmp;
 
-    '	add += tmp = texture2D( tDiffuse, uv + vec2( -0.532032, -0.846724 ) * sampleSize );',
-    '	if( tmp.b < color.b ) color = tmp;',
+    	add += tmp = texture2D( tDiffuse, uv + vec2( -0.532032, -0.846724 ) * sampleSize );
+    	if( tmp.b < color.b ) color = tmp;
 
-    '	add += tmp = texture2D( tDiffuse, uv + vec2( -0.993712, -0.111964 ) * sampleSize );',
-    '	if( tmp.b < color.b ) color = tmp;',
+    	add += tmp = texture2D( tDiffuse, uv + vec2( -0.993712, -0.111964 ) * sampleSize );
+    	if( tmp.b < color.b ) color = tmp;
 
-    '	add += tmp = texture2D( tDiffuse, uv + vec2( -0.707107, 0.707107 ) * sampleSize );',
-    '	if( tmp.b < color.b ) color = tmp;',
+    	add += tmp = texture2D( tDiffuse, uv + vec2( -0.707107, 0.707107 ) * sampleSize );
+    	if( tmp.b < color.b ) color = tmp;
 
-    '	color = color * vec4( 2.0 ) - ( add / vec4( 8.0 ) );',
-    '	color = color + ( add / vec4( 8.0 ) - color ) * ( vec4( 1.0 ) - vec4( sample_dist * 0.5 ) );',
+    	color = color * vec4( 2.0 ) - ( add / vec4( 8.0 ) );
+    	color = color + ( add / vec4( 8.0 ) - color ) * ( vec4( 1.0 ) - vec4( sample_dist * 0.5 ) );
 
-    '	gl_FragColor = vec4( color.rgb * color.rgb * vec3( 0.95 ) + color.rgb, 1.0 );',
+    	gl_FragColor = vec4( color.rgb * color.rgb * vec3( 0.95 ) + color.rgb, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/FreiChenShader.ts b/src/shaders/FreiChenShader.ts
index 4a0e2ea7..9778f4f1 100644
--- a/src/shaders/FreiChenShader.ts
+++ b/src/shaders/FreiChenShader.ts
@@ -10,77 +10,77 @@ import { Vector2 } from 'three'
 export const FreiChenShader = {
   uniforms: {
     tDiffuse: { value: null },
-    aspect: { value: new Vector2(512, 512) },
+    aspect: { value: /* @__PURE__ */ new Vector2(512, 512) },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform sampler2D tDiffuse;',
-    'varying vec2 vUv;',
+  fragmentShader: /* glsl */ `
+    uniform sampler2D tDiffuse;
+    varying vec2 vUv;
 
-    'uniform vec2 aspect;',
+    uniform vec2 aspect;
 
-    'vec2 texel = vec2(1.0 / aspect.x, 1.0 / aspect.y);',
+    vec2 texel = vec2(1.0 / aspect.x, 1.0 / aspect.y);
 
-    'mat3 G[9];',
+    mat3 G[9];
 
     // hard coded matrix values!!!! as suggested in https://github.com/neilmendoza/ofxPostProcessing/blob/master/src/EdgePass.cpp#L45
 
-    'const mat3 g0 = mat3( 0.3535533845424652, 0, -0.3535533845424652, 0.5, 0, -0.5, 0.3535533845424652, 0, -0.3535533845424652 );',
-    'const mat3 g1 = mat3( 0.3535533845424652, 0.5, 0.3535533845424652, 0, 0, 0, -0.3535533845424652, -0.5, -0.3535533845424652 );',
-    'const mat3 g2 = mat3( 0, 0.3535533845424652, -0.5, -0.3535533845424652, 0, 0.3535533845424652, 0.5, -0.3535533845424652, 0 );',
-    'const mat3 g3 = mat3( 0.5, -0.3535533845424652, 0, -0.3535533845424652, 0, 0.3535533845424652, 0, 0.3535533845424652, -0.5 );',
-    'const mat3 g4 = mat3( 0, -0.5, 0, 0.5, 0, 0.5, 0, -0.5, 0 );',
-    'const mat3 g5 = mat3( -0.5, 0, 0.5, 0, 0, 0, 0.5, 0, -0.5 );',
-    'const mat3 g6 = mat3( 0.1666666716337204, -0.3333333432674408, 0.1666666716337204, -0.3333333432674408, 0.6666666865348816, -0.3333333432674408, 0.1666666716337204, -0.3333333432674408, 0.1666666716337204 );',
-    'const mat3 g7 = mat3( -0.3333333432674408, 0.1666666716337204, -0.3333333432674408, 0.1666666716337204, 0.6666666865348816, 0.1666666716337204, -0.3333333432674408, 0.1666666716337204, -0.3333333432674408 );',
-    'const mat3 g8 = mat3( 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408 );',
-
-    'void main(void)',
-    '{',
-
-    '	G[0] = g0,',
-    '	G[1] = g1,',
-    '	G[2] = g2,',
-    '	G[3] = g3,',
-    '	G[4] = g4,',
-    '	G[5] = g5,',
-    '	G[6] = g6,',
-    '	G[7] = g7,',
-    '	G[8] = g8;',
-
-    '	mat3 I;',
-    '	float cnv[9];',
-    '	vec3 sample;',
-
-    /* fetch the 3x3 neighbourhood and use the RGB vector's length as intensity value */
-    '	for (float i=0.0; i<3.0; i++) {',
-    '		for (float j=0.0; j<3.0; j++) {',
-    '			sample = texture2D(tDiffuse, vUv + texel * vec2(i-1.0,j-1.0) ).rgb;',
-    '			I[int(i)][int(j)] = length(sample);',
-    '		}',
-    '	}',
+    const mat3 g0 = mat3( 0.3535533845424652, 0, -0.3535533845424652, 0.5, 0, -0.5, 0.3535533845424652, 0, -0.3535533845424652 );
+    const mat3 g1 = mat3( 0.3535533845424652, 0.5, 0.3535533845424652, 0, 0, 0, -0.3535533845424652, -0.5, -0.3535533845424652 );
+    const mat3 g2 = mat3( 0, 0.3535533845424652, -0.5, -0.3535533845424652, 0, 0.3535533845424652, 0.5, -0.3535533845424652, 0 );
+    const mat3 g3 = mat3( 0.5, -0.3535533845424652, 0, -0.3535533845424652, 0, 0.3535533845424652, 0, 0.3535533845424652, -0.5 );
+    const mat3 g4 = mat3( 0, -0.5, 0, 0.5, 0, 0.5, 0, -0.5, 0 );
+    const mat3 g5 = mat3( -0.5, 0, 0.5, 0, 0, 0, 0.5, 0, -0.5 );
+    const mat3 g6 = mat3( 0.1666666716337204, -0.3333333432674408, 0.1666666716337204, -0.3333333432674408, 0.6666666865348816, -0.3333333432674408, 0.1666666716337204, -0.3333333432674408, 0.1666666716337204 );
+    const mat3 g7 = mat3( -0.3333333432674408, 0.1666666716337204, -0.3333333432674408, 0.1666666716337204, 0.6666666865348816, 0.1666666716337204, -0.3333333432674408, 0.1666666716337204, -0.3333333432674408 );
+    const mat3 g8 = mat3( 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408 );
+
+    void main(void)
+    {
+
+    	G[0] = g0,
+    	G[1] = g1,
+    	G[2] = g2,
+    	G[3] = g3,
+    	G[4] = g4,
+    	G[5] = g5,
+    	G[6] = g6,
+    	G[7] = g7,
+    	G[8] = g8;
+
+    	mat3 I;
+    	float cnv[9];
+    	vec3 sample;
+
+    /* fetch the 3x3 neighbourhood and use the RGB vectors length as intensity value */
+    	for (float i=0.0; i<3.0; i++) {
+    		for (float j=0.0; j<3.0; j++) {
+    			sample = texture2D(tDiffuse, vUv + texel * vec2(i-1.0,j-1.0) ).rgb;
+    			I[int(i)][int(j)] = length(sample);
+    		}
+    	}
 
     /* calculate the convolution values for all the masks */
-    '	for (int i=0; i<9; i++) {',
-    '		float dp3 = dot(G[i][0], I[0]) + dot(G[i][1], I[1]) + dot(G[i][2], I[2]);',
-    '		cnv[i] = dp3 * dp3;',
-    '	}',
+    	for (int i=0; i<9; i++) {
+    		float dp3 = dot(G[i][0], I[0]) + dot(G[i][1], I[1]) + dot(G[i][2], I[2]);
+    		cnv[i] = dp3 * dp3;
+    	}
 
-    '	float M = (cnv[0] + cnv[1]) + (cnv[2] + cnv[3]);',
-    '	float S = (cnv[4] + cnv[5]) + (cnv[6] + cnv[7]) + (cnv[8] + M);',
+    	float M = (cnv[0] + cnv[1]) + (cnv[2] + cnv[3]);
+    	float S = (cnv[4] + cnv[5]) + (cnv[6] + cnv[7]) + (cnv[8] + M);
 
-    '	gl_FragColor = vec4(vec3(sqrt(M/S)), 1.0);',
-    '}',
-  ].join('\n'),
+    	gl_FragColor = vec4(vec3(sqrt(M/S)), 1.0);
+    }
+  `,
 }
diff --git a/src/shaders/FresnelShader.ts b/src/shaders/FresnelShader.ts
index c016ed90..d11c4424 100644
--- a/src/shaders/FresnelShader.ts
+++ b/src/shaders/FresnelShader.ts
@@ -11,54 +11,54 @@ export const FresnelShader = {
     tCube: { value: null },
   },
 
-  vertexShader: [
-    'uniform float mRefractionRatio;',
-    'uniform float mFresnelBias;',
-    'uniform float mFresnelScale;',
-    'uniform float mFresnelPower;',
+  vertexShader: /* glsl */ `
+    uniform float mRefractionRatio;
+    uniform float mFresnelBias;
+    uniform float mFresnelScale;
+    uniform float mFresnelPower;
 
-    'varying vec3 vReflect;',
-    'varying vec3 vRefract[3];',
-    'varying float vReflectionFactor;',
+    varying vec3 vReflect;
+    varying vec3 vRefract[3];
+    varying float vReflectionFactor;
 
-    'void main() {',
+    void main() {
 
-    '	vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );',
-    '	vec4 worldPosition = modelMatrix * vec4( position, 1.0 );',
+    	vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );
+    	vec4 worldPosition = modelMatrix * vec4( position, 1.0 );
 
-    '	vec3 worldNormal = normalize( mat3( modelMatrix[0].xyz, modelMatrix[1].xyz, modelMatrix[2].xyz ) * normal );',
+    	vec3 worldNormal = normalize( mat3( modelMatrix[0].xyz, modelMatrix[1].xyz, modelMatrix[2].xyz ) * normal );
 
-    '	vec3 I = worldPosition.xyz - cameraPosition;',
+    	vec3 I = worldPosition.xyz - cameraPosition;
 
-    '	vReflect = reflect( I, worldNormal );',
-    '	vRefract[0] = refract( normalize( I ), worldNormal, mRefractionRatio );',
-    '	vRefract[1] = refract( normalize( I ), worldNormal, mRefractionRatio * 0.99 );',
-    '	vRefract[2] = refract( normalize( I ), worldNormal, mRefractionRatio * 0.98 );',
-    '	vReflectionFactor = mFresnelBias + mFresnelScale * pow( 1.0 + dot( normalize( I ), worldNormal ), mFresnelPower );',
+    	vReflect = reflect( I, worldNormal );
+    	vRefract[0] = refract( normalize( I ), worldNormal, mRefractionRatio );
+    	vRefract[1] = refract( normalize( I ), worldNormal, mRefractionRatio * 0.99 );
+    	vRefract[2] = refract( normalize( I ), worldNormal, mRefractionRatio * 0.98 );
+    	vReflectionFactor = mFresnelBias + mFresnelScale * pow( 1.0 + dot( normalize( I ), worldNormal ), mFresnelPower );
 
-    '	gl_Position = projectionMatrix * mvPosition;',
+    	gl_Position = projectionMatrix * mvPosition;
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform samplerCube tCube;',
+  fragmentShader: /* glsl */ `
+    uniform samplerCube tCube;
 
-    'varying vec3 vReflect;',
-    'varying vec3 vRefract[3];',
-    'varying float vReflectionFactor;',
+    varying vec3 vReflect;
+    varying vec3 vRefract[3];
+    varying float vReflectionFactor;
 
-    'void main() {',
+    void main() {
 
-    '	vec4 reflectedColor = textureCube( tCube, vec3( -vReflect.x, vReflect.yz ) );',
-    '	vec4 refractedColor = vec4( 1.0 );',
+    	vec4 reflectedColor = textureCube( tCube, vec3( -vReflect.x, vReflect.yz ) );
+    	vec4 refractedColor = vec4( 1.0 );
 
-    '	refractedColor.r = textureCube( tCube, vec3( -vRefract[0].x, vRefract[0].yz ) ).r;',
-    '	refractedColor.g = textureCube( tCube, vec3( -vRefract[1].x, vRefract[1].yz ) ).g;',
-    '	refractedColor.b = textureCube( tCube, vec3( -vRefract[2].x, vRefract[2].yz ) ).b;',
+    	refractedColor.r = textureCube( tCube, vec3( -vRefract[0].x, vRefract[0].yz ) ).r;
+    	refractedColor.g = textureCube( tCube, vec3( -vRefract[1].x, vRefract[1].yz ) ).g;
+    	refractedColor.b = textureCube( tCube, vec3( -vRefract[2].x, vRefract[2].yz ) ).b;
 
-    '	gl_FragColor = mix( refractedColor, reflectedColor, clamp( vReflectionFactor, 0.0, 1.0 ) );',
+    	gl_FragColor = mix( refractedColor, reflectedColor, clamp( vReflectionFactor, 0.0, 1.0 ) );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/GammaCorrectionShader.ts b/src/shaders/GammaCorrectionShader.ts
index 00f0425d..0b5173c0 100644
--- a/src/shaders/GammaCorrectionShader.ts
+++ b/src/shaders/GammaCorrectionShader.ts
@@ -17,32 +17,32 @@ export const GammaCorrectionShader: IGammaCorrectionShader = {
     tDiffuse: { value: null },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform sampler2D tDiffuse;',
+  fragmentShader: /* glsl */ `
+    uniform sampler2D tDiffuse;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vec4 tex = texture2D( tDiffuse, vUv );',
+    	vec4 tex = texture2D( tDiffuse, vUv );
 
-    '	#ifdef LinearTosRGB',
-    '		gl_FragColor = LinearTosRGB( tex );',
-    '	#else',
-    '		gl_FragColor = sRGBTransferOETF( tex );',
-    '	#endif',
+    	#ifdef LinearTosRGB
+    		gl_FragColor = LinearTosRGB( tex );
+    	#else
+    		gl_FragColor = sRGBTransferOETF( tex );
+    	#endif
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/GodRaysShader.ts b/src/shaders/GodRaysShader.ts
index 6cfa2629..c3c0f1fa 100644
--- a/src/shaders/GodRaysShader.ts
+++ b/src/shaders/GodRaysShader.ts
@@ -25,28 +25,28 @@ export const GodRaysDepthMaskShader = {
     },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    ' vUv = uv;',
-    ' gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+     vUv = uv;
+     gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'varying vec2 vUv;',
+  fragmentShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'uniform sampler2D tInput;',
+    uniform sampler2D tInput;
 
-    'void main() {',
+    void main() {
 
-    '	gl_FragColor = vec4( 1.0 ) - texture2D( tInput, vUv );',
+    	gl_FragColor = vec4( 1.0 ) - texture2D( tInput, vUv );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
 
 /**
@@ -73,62 +73,62 @@ export const GodRaysGenerateShader = {
       value: 1.0,
     },
     vSunPositionScreenSpace: {
-      value: new Vector3(),
+      value: /* @__PURE__ */ new Vector3(),
     },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    ' vUv = uv;',
-    ' gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+     vUv = uv;
+     gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    '#define TAPS_PER_PASS 6.0',
+  fragmentShader: /* glsl */ `
+    #define TAPS_PER_PASS 6.0
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'uniform sampler2D tInput;',
+    uniform sampler2D tInput;
 
-    'uniform vec3 vSunPositionScreenSpace;',
-    'uniform float fStepSize;', // filter step size
+    uniform vec3 vSunPositionScreenSpace;
+    uniform float fStepSize; // filter step size
 
-    'void main() {',
+    void main() {
 
     // delta from current pixel to "sun" position
 
-    '	vec2 delta = vSunPositionScreenSpace.xy - vUv;',
-    '	float dist = length( delta );',
+    	vec2 delta = vSunPositionScreenSpace.xy - vUv;
+    	float dist = length( delta );
 
     // Step vector (uv space)
 
-    '	vec2 stepv = fStepSize * delta / dist;',
+    	vec2 stepv = fStepSize * delta / dist;
 
     // Number of iterations between pixel and sun
 
-    '	float iters = dist/fStepSize;',
+    	float iters = dist/fStepSize;
 
-    '	vec2 uv = vUv.xy;',
-    '	float col = 0.0;',
+    	vec2 uv = vUv.xy;
+    	float col = 0.0;
 
     // This breaks ANGLE in Chrome 22
     //	- see http://code.google.com/p/chromium/issues/detail?id=153105
 
     /*
 		// Unrolling didnt do much on my hardware (ATI Mobility Radeon 3450),
-		// so i've just left the loop
+		// so ive just left the loop
 
 		"for ( float i = 0.0; i < TAPS_PER_PASS; i += 1.0 ) {",
 
 		// Accumulate samples, making sure we dont walk past the light source.
 
 		// The check for uv.y < 1 would not be necessary with "border" UV wrap
-		// mode, with a black border color. I don't think this is currently
+		// mode, with a black border color. I dont think this is currently
 		// exposed by three.js. As a result there might be artifacts when the
 		// sun is to the left, right or bottom of screen as these cases are
 		// not specifically handled.
@@ -141,38 +141,38 @@ export const GodRaysGenerateShader = {
 
     // Unrolling loop manually makes it work in ANGLE
 
-    '	float f = min( 1.0, max( vSunPositionScreenSpace.z / 1000.0, 0.0 ) );', // used to fade out godrays
+    	float f = min( 1.0, max( vSunPositionScreenSpace.z / 1000.0, 0.0 ) ); // used to fade out godrays
 
-    '	if ( 0.0 <= iters && uv.y < 1.0 ) col += texture2D( tInput, uv ).r * f;',
-    '	uv += stepv;',
+    	if ( 0.0 <= iters && uv.y < 1.0 ) col += texture2D( tInput, uv ).r * f;
+    	uv += stepv;
 
-    '	if ( 1.0 <= iters && uv.y < 1.0 ) col += texture2D( tInput, uv ).r * f;',
-    '	uv += stepv;',
+    	if ( 1.0 <= iters && uv.y < 1.0 ) col += texture2D( tInput, uv ).r * f;
+    	uv += stepv;
 
-    '	if ( 2.0 <= iters && uv.y < 1.0 ) col += texture2D( tInput, uv ).r * f;',
-    '	uv += stepv;',
+    	if ( 2.0 <= iters && uv.y < 1.0 ) col += texture2D( tInput, uv ).r * f;
+    	uv += stepv;
 
-    '	if ( 3.0 <= iters && uv.y < 1.0 ) col += texture2D( tInput, uv ).r * f;',
-    '	uv += stepv;',
+    	if ( 3.0 <= iters && uv.y < 1.0 ) col += texture2D( tInput, uv ).r * f;
+    	uv += stepv;
 
-    '	if ( 4.0 <= iters && uv.y < 1.0 ) col += texture2D( tInput, uv ).r * f;',
-    '	uv += stepv;',
+    	if ( 4.0 <= iters && uv.y < 1.0 ) col += texture2D( tInput, uv ).r * f;
+    	uv += stepv;
 
-    '	if ( 5.0 <= iters && uv.y < 1.0 ) col += texture2D( tInput, uv ).r * f;',
-    '	uv += stepv;',
+    	if ( 5.0 <= iters && uv.y < 1.0 ) col += texture2D( tInput, uv ).r * f;
+    	uv += stepv;
 
-    // Should technically be dividing by 'iters', but 'TAPS_PER_PASS' smooths out
+    // Should technically be dividing by iters but TAPS_PER_PASS smooths out
     // objectionable artifacts, in particular near the sun position. The side
     // effect is that the result is darker than it should be around the sun, as
     // TAPS_PER_PASS is greater than the number of samples actually accumulated.
-    // When the result is inverted (in the shader 'godrays_combine', this produces
+    // When the result is inverted (in the shader godrays_combine this produces
     // a slight bright spot at the position of the sun, even when it is occluded.
 
-    '	gl_FragColor = vec4( col/TAPS_PER_PASS );',
-    '	gl_FragColor.a = 1.0;',
+    	gl_FragColor = vec4( col/TAPS_PER_PASS );
+    	gl_FragColor.a = 1.0;
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
 
 /**
@@ -195,36 +195,36 @@ export const GodRaysCombineShader = {
     },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'varying vec2 vUv;',
+  fragmentShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'uniform sampler2D tColors;',
-    'uniform sampler2D tGodRays;',
+    uniform sampler2D tColors;
+    uniform sampler2D tGodRays;
 
-    'uniform float fGodRayIntensity;',
+    uniform float fGodRayIntensity;
 
-    'void main() {',
+    void main() {
 
     // Since THREE.MeshDepthMaterial renders foreground objects white and background
     // objects black, the god-rays will be white streaks. Therefore value is inverted
     // before being combined with tColors
 
-    '	gl_FragColor = texture2D( tColors, vUv ) + fGodRayIntensity * vec4( 1.0 - texture2D( tGodRays, vUv ).r );',
-    '	gl_FragColor.a = 1.0;',
+    	gl_FragColor = texture2D( tColors, vUv ) + fGodRayIntensity * vec4( 1.0 - texture2D( tGodRays, vUv ).r );
+    	gl_FragColor.a = 1.0;
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
 
 /**
@@ -235,7 +235,7 @@ export const GodRaysCombineShader = {
 export const GodRaysFakeSunShader = {
   uniforms: {
     vSunPositionScreenSpace: {
-      value: new Vector3(),
+      value: /* @__PURE__ */ new Vector3(),
     },
 
     fAspect: {
@@ -243,48 +243,48 @@ export const GodRaysFakeSunShader = {
     },
 
     sunColor: {
-      value: new Color(0xffee00),
+      value: /* @__PURE__ */ new Color(0xffee00),
     },
 
     bgColor: {
-      value: new Color(0x000000),
+      value: /* @__PURE__ */ new Color(0x000000),
     },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'varying vec2 vUv;',
+  fragmentShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'uniform vec3 vSunPositionScreenSpace;',
-    'uniform float fAspect;',
+    uniform vec3 vSunPositionScreenSpace;
+    uniform float fAspect;
 
-    'uniform vec3 sunColor;',
-    'uniform vec3 bgColor;',
+    uniform vec3 sunColor;
+    uniform vec3 bgColor;
 
-    'void main() {',
+    void main() {
 
-    '	vec2 diff = vUv - vSunPositionScreenSpace.xy;',
+    	vec2 diff = vUv - vSunPositionScreenSpace.xy;
 
     // Correct for aspect ratio
 
-    '	diff.x *= fAspect;',
+    	diff.x *= fAspect;
 
-    '	float prop = clamp( length( diff ) / 0.5, 0.0, 1.0 );',
-    '	prop = 0.35 * pow( 1.0 - prop, 3.0 );',
+    	float prop = clamp( length( diff ) / 0.5, 0.0, 1.0 );
+    	prop = 0.35 * pow( 1.0 - prop, 3.0 );
 
-    '	gl_FragColor.xyz = ( vSunPositionScreenSpace.z > 0.0 ) ? mix( sunColor, bgColor, 1.0 - prop ) : bgColor;',
-    '	gl_FragColor.w = 1.0;',
+    	gl_FragColor.xyz = ( vSunPositionScreenSpace.z > 0.0 ) ? mix( sunColor, bgColor, 1.0 - prop ) : bgColor;
+    	gl_FragColor.w = 1.0;
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/HalftoneShader.ts b/src/shaders/HalftoneShader.ts
index 47eed4a8..2bbf5104 100644
--- a/src/shaders/HalftoneShader.ts
+++ b/src/shaders/HalftoneShader.ts
@@ -22,285 +22,285 @@ export const HalftoneShader = {
     disable: { value: false },
   },
 
-  vertexShader: [
-    'varying vec2 vUV;',
-
-    'void main() {',
-
-    '	vUV = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);',
-
-    '}',
-  ].join('\n'),
-
-  fragmentShader: [
-    '#define SQRT2_MINUS_ONE 0.41421356',
-    '#define SQRT2_HALF_MINUS_ONE 0.20710678',
-    '#define PI2 6.28318531',
-    '#define SHAPE_DOT 1',
-    '#define SHAPE_ELLIPSE 2',
-    '#define SHAPE_LINE 3',
-    '#define SHAPE_SQUARE 4',
-    '#define BLENDING_LINEAR 1',
-    '#define BLENDING_MULTIPLY 2',
-    '#define BLENDING_ADD 3',
-    '#define BLENDING_LIGHTER 4',
-    '#define BLENDING_DARKER 5',
-    'uniform sampler2D tDiffuse;',
-    'uniform float radius;',
-    'uniform float rotateR;',
-    'uniform float rotateG;',
-    'uniform float rotateB;',
-    'uniform float scatter;',
-    'uniform float width;',
-    'uniform float height;',
-    'uniform int shape;',
-    'uniform bool disable;',
-    'uniform float blending;',
-    'uniform int blendingMode;',
-    'varying vec2 vUV;',
-    'uniform bool greyscale;',
-    'const int samples = 8;',
-
-    'float blend( float a, float b, float t ) {',
+  vertexShader: /* glsl */ `
+    varying vec2 vUV;
+
+    void main() {
+
+    	vUV = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+
+    }
+  `,
+
+  fragmentShader: /* glsl */ `
+    #define SQRT2_MINUS_ONE 0.41421356
+    #define SQRT2_HALF_MINUS_ONE 0.20710678
+    #define PI2 6.28318531
+    #define SHAPE_DOT 1
+    #define SHAPE_ELLIPSE 2
+    #define SHAPE_LINE 3
+    #define SHAPE_SQUARE 4
+    #define BLENDING_LINEAR 1
+    #define BLENDING_MULTIPLY 2
+    #define BLENDING_ADD 3
+    #define BLENDING_LIGHTER 4
+    #define BLENDING_DARKER 5
+    uniform sampler2D tDiffuse;
+    uniform float radius;
+    uniform float rotateR;
+    uniform float rotateG;
+    uniform float rotateB;
+    uniform float scatter;
+    uniform float width;
+    uniform float height;
+    uniform int shape;
+    uniform bool disable;
+    uniform float blending;
+    uniform int blendingMode;
+    varying vec2 vUV;
+    uniform bool greyscale;
+    const int samples = 8;
+
+    float blend( float a, float b, float t ) {
 
     // linear blend
-    '	return a * ( 1.0 - t ) + b * t;',
+    	return a * ( 1.0 - t ) + b * t;
 
-    '}',
+    }
 
-    'float hypot( float x, float y ) {',
+    float hypot( float x, float y ) {
 
     // vector magnitude
-    '	return sqrt( x * x + y * y );',
+    	return sqrt( x * x + y * y );
 
-    '}',
+    }
 
-    'float rand( vec2 seed ){',
+    float rand( vec2 seed ){
 
     // get pseudo-random number
-    'return fract( sin( dot( seed.xy, vec2( 12.9898, 78.233 ) ) ) * 43758.5453 );',
+    return fract( sin( dot( seed.xy, vec2( 12.9898, 78.233 ) ) ) * 43758.5453 );
 
-    '}',
+    }
 
-    'float distanceToDotRadius( float channel, vec2 coord, vec2 normal, vec2 p, float angle, float rad_max ) {',
+    float distanceToDotRadius( float channel, vec2 coord, vec2 normal, vec2 p, float angle, float rad_max ) {
 
     // apply shape-specific transforms
-    '	float dist = hypot( coord.x - p.x, coord.y - p.y );',
-    '	float rad = channel;',
+    	float dist = hypot( coord.x - p.x, coord.y - p.y );
+    	float rad = channel;
 
-    '	if ( shape == SHAPE_DOT ) {',
+    	if ( shape == SHAPE_DOT ) {
 
-    '		rad = pow( abs( rad ), 1.125 ) * rad_max;',
+    		rad = pow( abs( rad ), 1.125 ) * rad_max;
 
-    '	} else if ( shape == SHAPE_ELLIPSE ) {',
+    	} else if ( shape == SHAPE_ELLIPSE ) {
 
-    '		rad = pow( abs( rad ), 1.125 ) * rad_max;',
+    		rad = pow( abs( rad ), 1.125 ) * rad_max;
 
-    '		if ( dist != 0.0 ) {',
-    '			float dot_p = abs( ( p.x - coord.x ) / dist * normal.x + ( p.y - coord.y ) / dist * normal.y );',
-    '			dist = ( dist * ( 1.0 - SQRT2_HALF_MINUS_ONE ) ) + dot_p * dist * SQRT2_MINUS_ONE;',
-    '		}',
+    		if ( dist != 0.0 ) {
+    			float dot_p = abs( ( p.x - coord.x ) / dist * normal.x + ( p.y - coord.y ) / dist * normal.y );
+    			dist = ( dist * ( 1.0 - SQRT2_HALF_MINUS_ONE ) ) + dot_p * dist * SQRT2_MINUS_ONE;
+    		}
 
-    '	} else if ( shape == SHAPE_LINE ) {',
+    	} else if ( shape == SHAPE_LINE ) {
 
-    '		rad = pow( abs( rad ), 1.5) * rad_max;',
-    '		float dot_p = ( p.x - coord.x ) * normal.x + ( p.y - coord.y ) * normal.y;',
-    '		dist = hypot( normal.x * dot_p, normal.y * dot_p );',
+    		rad = pow( abs( rad ), 1.5) * rad_max;
+    		float dot_p = ( p.x - coord.x ) * normal.x + ( p.y - coord.y ) * normal.y;
+    		dist = hypot( normal.x * dot_p, normal.y * dot_p );
 
-    '	} else if ( shape == SHAPE_SQUARE ) {',
+    	} else if ( shape == SHAPE_SQUARE ) {
 
-    '		float theta = atan( p.y - coord.y, p.x - coord.x ) - angle;',
-    '		float sin_t = abs( sin( theta ) );',
-    '		float cos_t = abs( cos( theta ) );',
-    '		rad = pow( abs( rad ), 1.4 );',
-    '		rad = rad_max * ( rad + ( ( sin_t > cos_t ) ? rad - sin_t * rad : rad - cos_t * rad ) );',
+    		float theta = atan( p.y - coord.y, p.x - coord.x ) - angle;
+    		float sin_t = abs( sin( theta ) );
+    		float cos_t = abs( cos( theta ) );
+    		rad = pow( abs( rad ), 1.4 );
+    		rad = rad_max * ( rad + ( ( sin_t > cos_t ) ? rad - sin_t * rad : rad - cos_t * rad ) );
 
-    '	}',
+    	}
 
-    '	return rad - dist;',
+    	return rad - dist;
 
-    '}',
+    }
 
-    'struct Cell {',
+    struct Cell {
 
     // grid sample positions
-    '	vec2 normal;',
-    '	vec2 p1;',
-    '	vec2 p2;',
-    '	vec2 p3;',
-    '	vec2 p4;',
-    '	float samp2;',
-    '	float samp1;',
-    '	float samp3;',
-    '	float samp4;',
+    	vec2 normal;
+    	vec2 p1;
+    	vec2 p2;
+    	vec2 p3;
+    	vec2 p4;
+    	float samp2;
+    	float samp1;
+    	float samp3;
+    	float samp4;
 
-    '};',
+    };
 
-    'vec4 getSample( vec2 point ) {',
+    vec4 getSample( vec2 point ) {
 
     // multi-sampled point
-    '	vec4 tex = texture2D( tDiffuse, vec2( point.x / width, point.y / height ) );',
-    '	float base = rand( vec2( floor( point.x ), floor( point.y ) ) ) * PI2;',
-    '	float step = PI2 / float( samples );',
-    '	float dist = radius * 0.66;',
+    	vec4 tex = texture2D( tDiffuse, vec2( point.x / width, point.y / height ) );
+    	float base = rand( vec2( floor( point.x ), floor( point.y ) ) ) * PI2;
+    	float step = PI2 / float( samples );
+    	float dist = radius * 0.66;
 
-    '	for ( int i = 0; i < samples; ++i ) {',
+    	for ( int i = 0; i < samples; ++i ) {
 
-    '		float r = base + step * float( i );',
-    '		vec2 coord = point + vec2( cos( r ) * dist, sin( r ) * dist );',
-    '		tex += texture2D( tDiffuse, vec2( coord.x / width, coord.y / height ) );',
+    		float r = base + step * float( i );
+    		vec2 coord = point + vec2( cos( r ) * dist, sin( r ) * dist );
+    		tex += texture2D( tDiffuse, vec2( coord.x / width, coord.y / height ) );
 
-    '	}',
+    	}
 
-    '	tex /= float( samples ) + 1.0;',
-    '	return tex;',
+    	tex /= float( samples ) + 1.0;
+    	return tex;
 
-    '}',
+    }
 
-    'float getDotColour( Cell c, vec2 p, int channel, float angle, float aa ) {',
+    float getDotColour( Cell c, vec2 p, int channel, float angle, float aa ) {
 
     // get colour for given point
-    '	float dist_c_1, dist_c_2, dist_c_3, dist_c_4, res;',
+    	float dist_c_1, dist_c_2, dist_c_3, dist_c_4, res;
 
-    '	if ( channel == 0 ) {',
+    	if ( channel == 0 ) {
 
-    '		c.samp1 = getSample( c.p1 ).r;',
-    '		c.samp2 = getSample( c.p2 ).r;',
-    '		c.samp3 = getSample( c.p3 ).r;',
-    '		c.samp4 = getSample( c.p4 ).r;',
+    		c.samp1 = getSample( c.p1 ).r;
+    		c.samp2 = getSample( c.p2 ).r;
+    		c.samp3 = getSample( c.p3 ).r;
+    		c.samp4 = getSample( c.p4 ).r;
 
-    '	} else if (channel == 1) {',
+    	} else if (channel == 1) {
 
-    '		c.samp1 = getSample( c.p1 ).g;',
-    '		c.samp2 = getSample( c.p2 ).g;',
-    '		c.samp3 = getSample( c.p3 ).g;',
-    '		c.samp4 = getSample( c.p4 ).g;',
+    		c.samp1 = getSample( c.p1 ).g;
+    		c.samp2 = getSample( c.p2 ).g;
+    		c.samp3 = getSample( c.p3 ).g;
+    		c.samp4 = getSample( c.p4 ).g;
 
-    '	} else {',
+    	} else {
 
-    '		c.samp1 = getSample( c.p1 ).b;',
-    '		c.samp3 = getSample( c.p3 ).b;',
-    '		c.samp2 = getSample( c.p2 ).b;',
-    '		c.samp4 = getSample( c.p4 ).b;',
+    		c.samp1 = getSample( c.p1 ).b;
+    		c.samp3 = getSample( c.p3 ).b;
+    		c.samp2 = getSample( c.p2 ).b;
+    		c.samp4 = getSample( c.p4 ).b;
 
-    '	}',
+    	}
 
-    '	dist_c_1 = distanceToDotRadius( c.samp1, c.p1, c.normal, p, angle, radius );',
-    '	dist_c_2 = distanceToDotRadius( c.samp2, c.p2, c.normal, p, angle, radius );',
-    '	dist_c_3 = distanceToDotRadius( c.samp3, c.p3, c.normal, p, angle, radius );',
-    '	dist_c_4 = distanceToDotRadius( c.samp4, c.p4, c.normal, p, angle, radius );',
-    '	res = ( dist_c_1 > 0.0 ) ? clamp( dist_c_1 / aa, 0.0, 1.0 ) : 0.0;',
-    '	res += ( dist_c_2 > 0.0 ) ? clamp( dist_c_2 / aa, 0.0, 1.0 ) : 0.0;',
-    '	res += ( dist_c_3 > 0.0 ) ? clamp( dist_c_3 / aa, 0.0, 1.0 ) : 0.0;',
-    '	res += ( dist_c_4 > 0.0 ) ? clamp( dist_c_4 / aa, 0.0, 1.0 ) : 0.0;',
-    '	res = clamp( res, 0.0, 1.0 );',
+    	dist_c_1 = distanceToDotRadius( c.samp1, c.p1, c.normal, p, angle, radius );
+    	dist_c_2 = distanceToDotRadius( c.samp2, c.p2, c.normal, p, angle, radius );
+    	dist_c_3 = distanceToDotRadius( c.samp3, c.p3, c.normal, p, angle, radius );
+    	dist_c_4 = distanceToDotRadius( c.samp4, c.p4, c.normal, p, angle, radius );
+    	res = ( dist_c_1 > 0.0 ) ? clamp( dist_c_1 / aa, 0.0, 1.0 ) : 0.0;
+    	res += ( dist_c_2 > 0.0 ) ? clamp( dist_c_2 / aa, 0.0, 1.0 ) : 0.0;
+    	res += ( dist_c_3 > 0.0 ) ? clamp( dist_c_3 / aa, 0.0, 1.0 ) : 0.0;
+    	res += ( dist_c_4 > 0.0 ) ? clamp( dist_c_4 / aa, 0.0, 1.0 ) : 0.0;
+    	res = clamp( res, 0.0, 1.0 );
 
-    '	return res;',
+    	return res;
 
-    '}',
+    }
 
-    'Cell getReferenceCell( vec2 p, vec2 origin, float grid_angle, float step ) {',
+    Cell getReferenceCell( vec2 p, vec2 origin, float grid_angle, float step ) {
 
     // get containing cell
-    '	Cell c;',
+    	Cell c;
 
     // calc grid
-    '	vec2 n = vec2( cos( grid_angle ), sin( grid_angle ) );',
-    '	float threshold = step * 0.5;',
-    '	float dot_normal = n.x * ( p.x - origin.x ) + n.y * ( p.y - origin.y );',
-    '	float dot_line = -n.y * ( p.x - origin.x ) + n.x * ( p.y - origin.y );',
-    '	vec2 offset = vec2( n.x * dot_normal, n.y * dot_normal );',
-    '	float offset_normal = mod( hypot( offset.x, offset.y ), step );',
-    '	float normal_dir = ( dot_normal < 0.0 ) ? 1.0 : -1.0;',
-    '	float normal_scale = ( ( offset_normal < threshold ) ? -offset_normal : step - offset_normal ) * normal_dir;',
-    '	float offset_line = mod( hypot( ( p.x - offset.x ) - origin.x, ( p.y - offset.y ) - origin.y ), step );',
-    '	float line_dir = ( dot_line < 0.0 ) ? 1.0 : -1.0;',
-    '	float line_scale = ( ( offset_line < threshold ) ? -offset_line : step - offset_line ) * line_dir;',
+    	vec2 n = vec2( cos( grid_angle ), sin( grid_angle ) );
+    	float threshold = step * 0.5;
+    	float dot_normal = n.x * ( p.x - origin.x ) + n.y * ( p.y - origin.y );
+    	float dot_line = -n.y * ( p.x - origin.x ) + n.x * ( p.y - origin.y );
+    	vec2 offset = vec2( n.x * dot_normal, n.y * dot_normal );
+    	float offset_normal = mod( hypot( offset.x, offset.y ), step );
+    	float normal_dir = ( dot_normal < 0.0 ) ? 1.0 : -1.0;
+    	float normal_scale = ( ( offset_normal < threshold ) ? -offset_normal : step - offset_normal ) * normal_dir;
+    	float offset_line = mod( hypot( ( p.x - offset.x ) - origin.x, ( p.y - offset.y ) - origin.y ), step );
+    	float line_dir = ( dot_line < 0.0 ) ? 1.0 : -1.0;
+    	float line_scale = ( ( offset_line < threshold ) ? -offset_line : step - offset_line ) * line_dir;
 
     // get closest corner
-    '	c.normal = n;',
-    '	c.p1.x = p.x - n.x * normal_scale + n.y * line_scale;',
-    '	c.p1.y = p.y - n.y * normal_scale - n.x * line_scale;',
+    	c.normal = n;
+    	c.p1.x = p.x - n.x * normal_scale + n.y * line_scale;
+    	c.p1.y = p.y - n.y * normal_scale - n.x * line_scale;
 
     // scatter
-    '	if ( scatter != 0.0 ) {',
+    	if ( scatter != 0.0 ) {
 
-    '		float off_mag = scatter * threshold * 0.5;',
-    '		float off_angle = rand( vec2( floor( c.p1.x ), floor( c.p1.y ) ) ) * PI2;',
-    '		c.p1.x += cos( off_angle ) * off_mag;',
-    '		c.p1.y += sin( off_angle ) * off_mag;',
+    		float off_mag = scatter * threshold * 0.5;
+    		float off_angle = rand( vec2( floor( c.p1.x ), floor( c.p1.y ) ) ) * PI2;
+    		c.p1.x += cos( off_angle ) * off_mag;
+    		c.p1.y += sin( off_angle ) * off_mag;
 
-    '	}',
+    	}
 
     // find corners
-    '	float normal_step = normal_dir * ( ( offset_normal < threshold ) ? step : -step );',
-    '	float line_step = line_dir * ( ( offset_line < threshold ) ? step : -step );',
-    '	c.p2.x = c.p1.x - n.x * normal_step;',
-    '	c.p2.y = c.p1.y - n.y * normal_step;',
-    '	c.p3.x = c.p1.x + n.y * line_step;',
-    '	c.p3.y = c.p1.y - n.x * line_step;',
-    '	c.p4.x = c.p1.x - n.x * normal_step + n.y * line_step;',
-    '	c.p4.y = c.p1.y - n.y * normal_step - n.x * line_step;',
+    	float normal_step = normal_dir * ( ( offset_normal < threshold ) ? step : -step );
+    	float line_step = line_dir * ( ( offset_line < threshold ) ? step : -step );
+    	c.p2.x = c.p1.x - n.x * normal_step;
+    	c.p2.y = c.p1.y - n.y * normal_step;
+    	c.p3.x = c.p1.x + n.y * line_step;
+    	c.p3.y = c.p1.y - n.x * line_step;
+    	c.p4.x = c.p1.x - n.x * normal_step + n.y * line_step;
+    	c.p4.y = c.p1.y - n.y * normal_step - n.x * line_step;
 
-    '	return c;',
+    	return c;
 
-    '}',
+    }
 
-    'float blendColour( float a, float b, float t ) {',
+    float blendColour( float a, float b, float t ) {
 
     // blend colours
-    '	if ( blendingMode == BLENDING_LINEAR ) {',
-    '		return blend( a, b, 1.0 - t );',
-    '	} else if ( blendingMode == BLENDING_ADD ) {',
-    '		return blend( a, min( 1.0, a + b ), t );',
-    '	} else if ( blendingMode == BLENDING_MULTIPLY ) {',
-    '		return blend( a, max( 0.0, a * b ), t );',
-    '	} else if ( blendingMode == BLENDING_LIGHTER ) {',
-    '		return blend( a, max( a, b ), t );',
-    '	} else if ( blendingMode == BLENDING_DARKER ) {',
-    '		return blend( a, min( a, b ), t );',
-    '	} else {',
-    '		return blend( a, b, 1.0 - t );',
-    '	}',
-
-    '}',
-
-    'void main() {',
-
-    '	if ( ! disable ) {',
+    	if ( blendingMode == BLENDING_LINEAR ) {
+    		return blend( a, b, 1.0 - t );
+    	} else if ( blendingMode == BLENDING_ADD ) {
+    		return blend( a, min( 1.0, a + b ), t );
+    	} else if ( blendingMode == BLENDING_MULTIPLY ) {
+    		return blend( a, max( 0.0, a * b ), t );
+    	} else if ( blendingMode == BLENDING_LIGHTER ) {
+    		return blend( a, max( a, b ), t );
+    	} else if ( blendingMode == BLENDING_DARKER ) {
+    		return blend( a, min( a, b ), t );
+    	} else {
+    		return blend( a, b, 1.0 - t );
+    	}
+
+    }
+
+    void main() {
+
+    	if ( ! disable ) {
 
     // setup
-    '		vec2 p = vec2( vUV.x * width, vUV.y * height );',
-    '		vec2 origin = vec2( 0, 0 );',
-    '		float aa = ( radius < 2.5 ) ? radius * 0.5 : 1.25;',
+    		vec2 p = vec2( vUV.x * width, vUV.y * height );
+    		vec2 origin = vec2( 0, 0 );
+    		float aa = ( radius < 2.5 ) ? radius * 0.5 : 1.25;
 
     // get channel samples
-    '		Cell cell_r = getReferenceCell( p, origin, rotateR, radius );',
-    '		Cell cell_g = getReferenceCell( p, origin, rotateG, radius );',
-    '		Cell cell_b = getReferenceCell( p, origin, rotateB, radius );',
-    '		float r = getDotColour( cell_r, p, 0, rotateR, aa );',
-    '		float g = getDotColour( cell_g, p, 1, rotateG, aa );',
-    '		float b = getDotColour( cell_b, p, 2, rotateB, aa );',
+    		Cell cell_r = getReferenceCell( p, origin, rotateR, radius );
+    		Cell cell_g = getReferenceCell( p, origin, rotateG, radius );
+    		Cell cell_b = getReferenceCell( p, origin, rotateB, radius );
+    		float r = getDotColour( cell_r, p, 0, rotateR, aa );
+    		float g = getDotColour( cell_g, p, 1, rotateG, aa );
+    		float b = getDotColour( cell_b, p, 2, rotateB, aa );
 
     // blend with original
-    '		vec4 colour = texture2D( tDiffuse, vUV );',
-    '		r = blendColour( r, colour.r, blending );',
-    '		g = blendColour( g, colour.g, blending );',
-    '		b = blendColour( b, colour.b, blending );',
+    		vec4 colour = texture2D( tDiffuse, vUV );
+    		r = blendColour( r, colour.r, blending );
+    		g = blendColour( g, colour.g, blending );
+    		b = blendColour( b, colour.b, blending );
 
-    '		if ( greyscale ) {',
-    '			r = g = b = (r + b + g) / 3.0;',
-    '		}',
+    		if ( greyscale ) {
+    			r = g = b = (r + b + g) / 3.0;
+    		}
 
-    '		gl_FragColor = vec4( r, g, b, 1.0 );',
+    		gl_FragColor = vec4( r, g, b, 1.0 );
 
-    '	} else {',
+    	} else {
 
-    '		gl_FragColor = texture2D( tDiffuse, vUV );',
+    		gl_FragColor = texture2D( tDiffuse, vUV );
 
-    '	}',
+    	}
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/HorizontalTiltShiftShader.ts b/src/shaders/HorizontalTiltShiftShader.ts
index 62fe7f14..ab395017 100644
--- a/src/shaders/HorizontalTiltShiftShader.ts
+++ b/src/shaders/HorizontalTiltShiftShader.ts
@@ -14,42 +14,42 @@ export const HorizontalTiltShiftShader = {
     r: { value: 0.35 },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform sampler2D tDiffuse;',
-    'uniform float h;',
-    'uniform float r;',
+  fragmentShader: /* glsl */ `
+    uniform sampler2D tDiffuse;
+    uniform float h;
+    uniform float r;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vec4 sum = vec4( 0.0 );',
+    	vec4 sum = vec4( 0.0 );
 
-    '	float hh = h * abs( r - vUv.y );',
+    	float hh = h * abs( r - vUv.y );
 
-    '	sum += texture2D( tDiffuse, vec2( vUv.x - 4.0 * hh, vUv.y ) ) * 0.051;',
-    '	sum += texture2D( tDiffuse, vec2( vUv.x - 3.0 * hh, vUv.y ) ) * 0.0918;',
-    '	sum += texture2D( tDiffuse, vec2( vUv.x - 2.0 * hh, vUv.y ) ) * 0.12245;',
-    '	sum += texture2D( tDiffuse, vec2( vUv.x - 1.0 * hh, vUv.y ) ) * 0.1531;',
-    '	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y ) ) * 0.1633;',
-    '	sum += texture2D( tDiffuse, vec2( vUv.x + 1.0 * hh, vUv.y ) ) * 0.1531;',
-    '	sum += texture2D( tDiffuse, vec2( vUv.x + 2.0 * hh, vUv.y ) ) * 0.12245;',
-    '	sum += texture2D( tDiffuse, vec2( vUv.x + 3.0 * hh, vUv.y ) ) * 0.0918;',
-    '	sum += texture2D( tDiffuse, vec2( vUv.x + 4.0 * hh, vUv.y ) ) * 0.051;',
+    	sum += texture2D( tDiffuse, vec2( vUv.x - 4.0 * hh, vUv.y ) ) * 0.051;
+    	sum += texture2D( tDiffuse, vec2( vUv.x - 3.0 * hh, vUv.y ) ) * 0.0918;
+    	sum += texture2D( tDiffuse, vec2( vUv.x - 2.0 * hh, vUv.y ) ) * 0.12245;
+    	sum += texture2D( tDiffuse, vec2( vUv.x - 1.0 * hh, vUv.y ) ) * 0.1531;
+    	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y ) ) * 0.1633;
+    	sum += texture2D( tDiffuse, vec2( vUv.x + 1.0 * hh, vUv.y ) ) * 0.1531;
+    	sum += texture2D( tDiffuse, vec2( vUv.x + 2.0 * hh, vUv.y ) ) * 0.12245;
+    	sum += texture2D( tDiffuse, vec2( vUv.x + 3.0 * hh, vUv.y ) ) * 0.0918;
+    	sum += texture2D( tDiffuse, vec2( vUv.x + 4.0 * hh, vUv.y ) ) * 0.051;
 
-    '	gl_FragColor = sum;',
+    	gl_FragColor = sum;
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/HueSaturationShader.ts b/src/shaders/HueSaturationShader.ts
index 0fe823b9..6dbf9464 100644
--- a/src/shaders/HueSaturationShader.ts
+++ b/src/shaders/HueSaturationShader.ts
@@ -12,48 +12,48 @@ export const HueSaturationShader = {
     saturation: { value: 0 },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
+    	vUv = uv;
 
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform sampler2D tDiffuse;',
-    'uniform float hue;',
-    'uniform float saturation;',
+  fragmentShader: /* glsl */ `
+    uniform sampler2D tDiffuse;
+    uniform float hue;
+    uniform float saturation;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	gl_FragColor = texture2D( tDiffuse, vUv );',
+    	gl_FragColor = texture2D( tDiffuse, vUv );
 
     // hue
-    '	float angle = hue * 3.14159265;',
-    '	float s = sin(angle), c = cos(angle);',
-    '	vec3 weights = (vec3(2.0 * c, -sqrt(3.0) * s - c, sqrt(3.0) * s - c) + 1.0) / 3.0;',
-    '	float len = length(gl_FragColor.rgb);',
-    '	gl_FragColor.rgb = vec3(',
-    '		dot(gl_FragColor.rgb, weights.xyz),',
-    '		dot(gl_FragColor.rgb, weights.zxy),',
-    '		dot(gl_FragColor.rgb, weights.yzx)',
-    '	);',
+    	float angle = hue * 3.14159265;
+    	float s = sin(angle), c = cos(angle);
+    	vec3 weights = (vec3(2.0 * c, -sqrt(3.0) * s - c, sqrt(3.0) * s - c) + 1.0) / 3.0;
+    	float len = length(gl_FragColor.rgb);
+    	gl_FragColor.rgb = vec3(
+    		dot(gl_FragColor.rgb, weights.xyz),
+    		dot(gl_FragColor.rgb, weights.zxy),
+    		dot(gl_FragColor.rgb, weights.yzx)
+    	);
 
     // saturation
-    '	float average = (gl_FragColor.r + gl_FragColor.g + gl_FragColor.b) / 3.0;',
-    '	if (saturation > 0.0) {',
-    '		gl_FragColor.rgb += (average - gl_FragColor.rgb) * (1.0 - 1.0 / (1.001 - saturation));',
-    '	} else {',
-    '		gl_FragColor.rgb += (average - gl_FragColor.rgb) * (-saturation);',
-    '	}',
-
-    '}',
-  ].join('\n'),
+    	float average = (gl_FragColor.r + gl_FragColor.g + gl_FragColor.b) / 3.0;
+    	if (saturation > 0.0) {
+    		gl_FragColor.rgb += (average - gl_FragColor.rgb) * (1.0 - 1.0 / (1.001 - saturation));
+    	} else {
+    		gl_FragColor.rgb += (average - gl_FragColor.rgb) * (-saturation);
+    	}
+
+    }
+  `,
 }
diff --git a/src/shaders/KaleidoShader.ts b/src/shaders/KaleidoShader.ts
index a879be43..0c269141 100644
--- a/src/shaders/KaleidoShader.ts
+++ b/src/shaders/KaleidoShader.ts
@@ -15,36 +15,36 @@ export const KaleidoShader = {
     angle: { value: 0.0 },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform sampler2D tDiffuse;',
-    'uniform float sides;',
-    'uniform float angle;',
+  fragmentShader: /* glsl */ `
+    uniform sampler2D tDiffuse;
+    uniform float sides;
+    uniform float angle;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vec2 p = vUv - 0.5;',
-    '	float r = length(p);',
-    '	float a = atan(p.y, p.x) + angle;',
-    '	float tau = 2. * 3.1416 ;',
-    '	a = mod(a, tau/sides);',
-    '	a = abs(a - tau/sides/2.) ;',
-    '	p = r * vec2(cos(a), sin(a));',
-    '	vec4 color = texture2D(tDiffuse, p + 0.5);',
-    '	gl_FragColor = color;',
+    	vec2 p = vUv - 0.5;
+    	float r = length(p);
+    	float a = atan(p.y, p.x) + angle;
+    	float tau = 2. * 3.1416 ;
+    	a = mod(a, tau/sides);
+    	a = abs(a - tau/sides/2.) ;
+    	p = r * vec2(cos(a), sin(a));
+    	vec4 color = texture2D(tDiffuse, p + 0.5);
+    	gl_FragColor = color;
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/LuminosityHighPassShader.ts b/src/shaders/LuminosityHighPassShader.ts
index 88709b49..7e08295f 100644
--- a/src/shaders/LuminosityHighPassShader.ts
+++ b/src/shaders/LuminosityHighPassShader.ts
@@ -12,45 +12,45 @@ export const LuminosityHighPassShader = {
     tDiffuse: { value: null },
     luminosityThreshold: { value: 1.0 },
     smoothWidth: { value: 1.0 },
-    defaultColor: { value: new Color(0x000000) },
+    defaultColor: { value: /* @__PURE__ */ new Color(0x000000) },
     defaultOpacity: { value: 0.0 },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
+    	vUv = uv;
 
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform sampler2D tDiffuse;',
-    'uniform vec3 defaultColor;',
-    'uniform float defaultOpacity;',
-    'uniform float luminosityThreshold;',
-    'uniform float smoothWidth;',
+  fragmentShader: /* glsl */ `
+    uniform sampler2D tDiffuse;
+    uniform vec3 defaultColor;
+    uniform float defaultOpacity;
+    uniform float luminosityThreshold;
+    uniform float smoothWidth;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vec4 texel = texture2D( tDiffuse, vUv );',
+    	vec4 texel = texture2D( tDiffuse, vUv );
 
-    '	vec3 luma = vec3( 0.299, 0.587, 0.114 );',
+    	vec3 luma = vec3( 0.299, 0.587, 0.114 );
 
-    '	float v = dot( texel.xyz, luma );',
+    	float v = dot( texel.xyz, luma );
 
-    '	vec4 outputColor = vec4( defaultColor.rgb, defaultOpacity );',
+    	vec4 outputColor = vec4( defaultColor.rgb, defaultOpacity );
 
-    '	float alpha = smoothstep( luminosityThreshold, luminosityThreshold + smoothWidth, v );',
+    	float alpha = smoothstep( luminosityThreshold, luminosityThreshold + smoothWidth, v );
 
-    '	gl_FragColor = mix( outputColor, texel, alpha );',
+    	gl_FragColor = mix( outputColor, texel, alpha );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/LuminosityShader.ts b/src/shaders/LuminosityShader.ts
index 149f7990..73053c53 100644
--- a/src/shaders/LuminosityShader.ts
+++ b/src/shaders/LuminosityShader.ts
@@ -8,33 +8,33 @@ export const LuminosityShader = {
     tDiffuse: { value: null },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
+    	vUv = uv;
 
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    '#include <common>',
+  fragmentShader: /* glsl */ `
+    #include <common>
 
-    'uniform sampler2D tDiffuse;',
+    uniform sampler2D tDiffuse;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vec4 texel = texture2D( tDiffuse, vUv );',
+    	vec4 texel = texture2D( tDiffuse, vUv );
 
-    '	float l = linearToRelativeLuminance( texel.rgb );',
+    	float l = linearToRelativeLuminance( texel.rgb );
 
-    '	gl_FragColor = vec4( l, l, l, texel.w );',
+    	gl_FragColor = vec4( l, l, l, texel.w );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/MirrorShader.ts b/src/shaders/MirrorShader.ts
index bcfade64..1c8f147d 100644
--- a/src/shaders/MirrorShader.ts
+++ b/src/shaders/MirrorShader.ts
@@ -11,38 +11,38 @@ export const MirrorShader = {
     side: { value: 1 },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform sampler2D tDiffuse;',
-    'uniform int side;',
+  fragmentShader: /* glsl */ `
+    uniform sampler2D tDiffuse;
+    uniform int side;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vec2 p = vUv;',
-    '	if (side == 0){',
-    '		if (p.x > 0.5) p.x = 1.0 - p.x;',
-    '	}else if (side == 1){',
-    '		if (p.x < 0.5) p.x = 1.0 - p.x;',
-    '	}else if (side == 2){',
-    '		if (p.y < 0.5) p.y = 1.0 - p.y;',
-    '	}else if (side == 3){',
-    '		if (p.y > 0.5) p.y = 1.0 - p.y;',
-    '	} ',
-    '	vec4 color = texture2D(tDiffuse, p);',
-    '	gl_FragColor = color;',
+    	vec2 p = vUv;
+    	if (side == 0){
+    		if (p.x > 0.5) p.x = 1.0 - p.x;
+    	}else if (side == 1){
+    		if (p.x < 0.5) p.x = 1.0 - p.x;
+    	}else if (side == 2){
+    		if (p.y < 0.5) p.y = 1.0 - p.y;
+    	}else if (side == 3){
+    		if (p.y > 0.5) p.y = 1.0 - p.y;
+    	} 
+    	vec4 color = texture2D(tDiffuse, p);
+    	gl_FragColor = color;
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/NormalMapShader.ts b/src/shaders/NormalMapShader.ts
index 56258ad7..a6813519 100644
--- a/src/shaders/NormalMapShader.ts
+++ b/src/shaders/NormalMapShader.ts
@@ -8,38 +8,38 @@ import { Vector2 } from 'three'
 export const NormalMapShader = {
   uniforms: {
     heightMap: { value: null },
-    resolution: { value: new Vector2(512, 512) },
-    scale: { value: new Vector2(1, 1) },
+    resolution: { value: /* @__PURE__ */ new Vector2(512, 512) },
+    scale: { value: /* @__PURE__ */ new Vector2(1, 1) },
     height: { value: 0.05 },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform float height;',
-    'uniform vec2 resolution;',
-    'uniform sampler2D heightMap;',
+  fragmentShader: /* glsl */ `
+    uniform float height;
+    uniform vec2 resolution;
+    uniform sampler2D heightMap;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	float val = texture2D( heightMap, vUv ).x;',
+    	float val = texture2D( heightMap, vUv ).x;
 
-    '	float valU = texture2D( heightMap, vUv + vec2( 1.0 / resolution.x, 0.0 ) ).x;',
-    '	float valV = texture2D( heightMap, vUv + vec2( 0.0, 1.0 / resolution.y ) ).x;',
+    	float valU = texture2D( heightMap, vUv + vec2( 1.0 / resolution.x, 0.0 ) ).x;
+    	float valV = texture2D( heightMap, vUv + vec2( 0.0, 1.0 / resolution.y ) ).x;
 
-    '	gl_FragColor = vec4( ( 0.5 * normalize( vec3( val - valU, val - valV, height  ) ) + 0.5 ), 1.0 );',
+    	gl_FragColor = vec4( ( 0.5 * normalize( vec3( val - valU, val - valV, height  ) ) + 0.5 ), 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/ParallaxShader.ts b/src/shaders/ParallaxShader.ts
index adc2f921..ddb998d4 100644
--- a/src/shaders/ParallaxShader.ts
+++ b/src/shaders/ParallaxShader.ts
@@ -21,161 +21,161 @@ export const ParallaxShader = {
     parallaxMaxLayers: { value: null },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
-    'varying vec3 vViewPosition;',
-    'varying vec3 vNormal;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
+    varying vec3 vViewPosition;
+    varying vec3 vNormal;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );',
-    '	vViewPosition = -mvPosition.xyz;',
-    '	vNormal = normalize( normalMatrix * normal );',
-    '	gl_Position = projectionMatrix * mvPosition;',
+    	vUv = uv;
+    	vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );
+    	vViewPosition = -mvPosition.xyz;
+    	vNormal = normalize( normalMatrix * normal );
+    	gl_Position = projectionMatrix * mvPosition;
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform sampler2D bumpMap;',
-    'uniform sampler2D map;',
+  fragmentShader: /* glsl */ `
+    uniform sampler2D bumpMap;
+    uniform sampler2D map;
 
-    'uniform float parallaxScale;',
-    'uniform float parallaxMinLayers;',
-    'uniform float parallaxMaxLayers;',
+    uniform float parallaxScale;
+    uniform float parallaxMinLayers;
+    uniform float parallaxMaxLayers;
 
-    'varying vec2 vUv;',
-    'varying vec3 vViewPosition;',
-    'varying vec3 vNormal;',
+    varying vec2 vUv;
+    varying vec3 vViewPosition;
+    varying vec3 vNormal;
 
-    '#ifdef USE_BASIC_PARALLAX',
+    #ifdef USE_BASIC_PARALLAX
 
-    '	vec2 parallaxMap( in vec3 V ) {',
+    	vec2 parallaxMap( in vec3 V ) {
 
-    '		float initialHeight = texture2D( bumpMap, vUv ).r;',
+    		float initialHeight = texture2D( bumpMap, vUv ).r;
 
     // No Offset Limitting: messy, floating output at grazing angles.
     //"vec2 texCoordOffset = parallaxScale * V.xy / V.z * initialHeight;",
 
     // Offset Limiting
-    '		vec2 texCoordOffset = parallaxScale * V.xy * initialHeight;',
-    '		return vUv - texCoordOffset;',
+    		vec2 texCoordOffset = parallaxScale * V.xy * initialHeight;
+    		return vUv - texCoordOffset;
 
-    '	}',
+    	}
 
-    '#else',
+    #else
 
-    '	vec2 parallaxMap( in vec3 V ) {',
+    	vec2 parallaxMap( in vec3 V ) {
 
     // Determine number of layers from angle between V and N
-    '		float numLayers = mix( parallaxMaxLayers, parallaxMinLayers, abs( dot( vec3( 0.0, 0.0, 1.0 ), V ) ) );',
+    		float numLayers = mix( parallaxMaxLayers, parallaxMinLayers, abs( dot( vec3( 0.0, 0.0, 1.0 ), V ) ) );
 
-    '		float layerHeight = 1.0 / numLayers;',
-    '		float currentLayerHeight = 0.0;',
+    		float layerHeight = 1.0 / numLayers;
+    		float currentLayerHeight = 0.0;
     // Shift of texture coordinates for each iteration
-    '		vec2 dtex = parallaxScale * V.xy / V.z / numLayers;',
+    		vec2 dtex = parallaxScale * V.xy / V.z / numLayers;
 
-    '		vec2 currentTextureCoords = vUv;',
+    		vec2 currentTextureCoords = vUv;
 
-    '		float heightFromTexture = texture2D( bumpMap, currentTextureCoords ).r;',
+    		float heightFromTexture = texture2D( bumpMap, currentTextureCoords ).r;
 
     // while ( heightFromTexture > currentLayerHeight )
     // Infinite loops are not well supported. Do a "large" finite
     // loop, but not too large, as it slows down some compilers.
-    '		for ( int i = 0; i < 30; i += 1 ) {',
-    '			if ( heightFromTexture <= currentLayerHeight ) {',
-    '				break;',
-    '			}',
-    '			currentLayerHeight += layerHeight;',
+    		for ( int i = 0; i < 30; i += 1 ) {
+    			if ( heightFromTexture <= currentLayerHeight ) {
+    				break;
+    			}
+    			currentLayerHeight += layerHeight;
     // Shift texture coordinates along vector V
-    '			currentTextureCoords -= dtex;',
-    '			heightFromTexture = texture2D( bumpMap, currentTextureCoords ).r;',
-    '		}',
+    			currentTextureCoords -= dtex;
+    			heightFromTexture = texture2D( bumpMap, currentTextureCoords ).r;
+    		}
 
-    '		#ifdef USE_STEEP_PARALLAX',
+    		#ifdef USE_STEEP_PARALLAX
 
-    '			return currentTextureCoords;',
+    			return currentTextureCoords;
 
-    '		#elif defined( USE_RELIEF_PARALLAX )',
+    		#elif defined( USE_RELIEF_PARALLAX )
 
-    '			vec2 deltaTexCoord = dtex / 2.0;',
-    '			float deltaHeight = layerHeight / 2.0;',
+    			vec2 deltaTexCoord = dtex / 2.0;
+    			float deltaHeight = layerHeight / 2.0;
 
     // Return to the mid point of previous layer
-    '			currentTextureCoords += deltaTexCoord;',
-    '			currentLayerHeight -= deltaHeight;',
+    			currentTextureCoords += deltaTexCoord;
+    			currentLayerHeight -= deltaHeight;
 
     // Binary search to increase precision of Steep Parallax Mapping
-    '			const int numSearches = 5;',
-    '			for ( int i = 0; i < numSearches; i += 1 ) {',
+    			const int numSearches = 5;
+    			for ( int i = 0; i < numSearches; i += 1 ) {
 
-    '				deltaTexCoord /= 2.0;',
-    '				deltaHeight /= 2.0;',
-    '				heightFromTexture = texture2D( bumpMap, currentTextureCoords ).r;',
+    				deltaTexCoord /= 2.0;
+    				deltaHeight /= 2.0;
+    				heightFromTexture = texture2D( bumpMap, currentTextureCoords ).r;
     // Shift along or against vector V
-    '				if( heightFromTexture > currentLayerHeight ) {', // Below the surface
+    				if( heightFromTexture > currentLayerHeight ) { // Below the surface
 
-    '					currentTextureCoords -= deltaTexCoord;',
-    '					currentLayerHeight += deltaHeight;',
+    					currentTextureCoords -= deltaTexCoord;
+    					currentLayerHeight += deltaHeight;
 
-    '				} else {', // above the surface
+    				} else { // above the surface
 
-    '					currentTextureCoords += deltaTexCoord;',
-    '					currentLayerHeight -= deltaHeight;',
+    					currentTextureCoords += deltaTexCoord;
+    					currentLayerHeight -= deltaHeight;
 
-    '				}',
+    				}
 
-    '			}',
-    '			return currentTextureCoords;',
+    			}
+    			return currentTextureCoords;
 
-    '		#elif defined( USE_OCLUSION_PARALLAX )',
+    		#elif defined( USE_OCLUSION_PARALLAX )
 
-    '			vec2 prevTCoords = currentTextureCoords + dtex;',
+    			vec2 prevTCoords = currentTextureCoords + dtex;
 
     // Heights for linear interpolation
-    '			float nextH = heightFromTexture - currentLayerHeight;',
-    '			float prevH = texture2D( bumpMap, prevTCoords ).r - currentLayerHeight + layerHeight;',
+    			float nextH = heightFromTexture - currentLayerHeight;
+    			float prevH = texture2D( bumpMap, prevTCoords ).r - currentLayerHeight + layerHeight;
 
     // Proportions for linear interpolation
-    '			float weight = nextH / ( nextH - prevH );',
+    			float weight = nextH / ( nextH - prevH );
 
     // Interpolation of texture coordinates
-    '			return prevTCoords * weight + currentTextureCoords * ( 1.0 - weight );',
+    			return prevTCoords * weight + currentTextureCoords * ( 1.0 - weight );
 
-    '		#else', // NO_PARALLAX
+    		#else // NO_PARALLAX
 
-    '			return vUv;',
+    			return vUv;
 
-    '		#endif',
+    		#endif
 
-    '	}',
-    '#endif',
+    	}
+    #endif
 
-    'vec2 perturbUv( vec3 surfPosition, vec3 surfNormal, vec3 viewPosition ) {',
+    vec2 perturbUv( vec3 surfPosition, vec3 surfNormal, vec3 viewPosition ) {
 
-    '	vec2 texDx = dFdx( vUv );',
-    '	vec2 texDy = dFdy( vUv );',
+    	vec2 texDx = dFdx( vUv );
+    	vec2 texDy = dFdy( vUv );
 
-    '	vec3 vSigmaX = dFdx( surfPosition );',
-    '	vec3 vSigmaY = dFdy( surfPosition );',
-    '	vec3 vR1 = cross( vSigmaY, surfNormal );',
-    '	vec3 vR2 = cross( surfNormal, vSigmaX );',
-    '	float fDet = dot( vSigmaX, vR1 );',
+    	vec3 vSigmaX = dFdx( surfPosition );
+    	vec3 vSigmaY = dFdy( surfPosition );
+    	vec3 vR1 = cross( vSigmaY, surfNormal );
+    	vec3 vR2 = cross( surfNormal, vSigmaX );
+    	float fDet = dot( vSigmaX, vR1 );
 
-    '	vec2 vProjVscr = ( 1.0 / fDet ) * vec2( dot( vR1, viewPosition ), dot( vR2, viewPosition ) );',
-    '	vec3 vProjVtex;',
-    '	vProjVtex.xy = texDx * vProjVscr.x + texDy * vProjVscr.y;',
-    '	vProjVtex.z = dot( surfNormal, viewPosition );',
+    	vec2 vProjVscr = ( 1.0 / fDet ) * vec2( dot( vR1, viewPosition ), dot( vR2, viewPosition ) );
+    	vec3 vProjVtex;
+    	vProjVtex.xy = texDx * vProjVscr.x + texDy * vProjVscr.y;
+    	vProjVtex.z = dot( surfNormal, viewPosition );
 
-    '	return parallaxMap( vProjVtex );',
-    '}',
+    	return parallaxMap( vProjVtex );
+    }
 
-    'void main() {',
+    void main() {
 
-    '	vec2 mapUv = perturbUv( -vViewPosition, normalize( vNormal ), normalize( vViewPosition ) );',
-    '	gl_FragColor = texture2D( map, mapUv );',
+    	vec2 mapUv = perturbUv( -vViewPosition, normalize( vNormal ), normalize( vViewPosition ) );
+    	gl_FragColor = texture2D( map, mapUv );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/PixelShader.ts b/src/shaders/PixelShader.ts
index f9594f59..3408aed2 100644
--- a/src/shaders/PixelShader.ts
+++ b/src/shaders/PixelShader.ts
@@ -9,30 +9,30 @@ export const PixelShader = {
     pixelSize: { value: 1 },
   },
 
-  vertexShader: [
-    'varying highp vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying highp vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    'vUv = uv;',
-    'gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+      vUv = uv;
+      gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform sampler2D tDiffuse;',
-    'uniform float pixelSize;',
-    'uniform vec2 resolution;',
+  fragmentShader: /* glsl */ `
+    uniform sampler2D tDiffuse;
+    uniform float pixelSize;
+    uniform vec2 resolution;
 
-    'varying highp vec2 vUv;',
+    varying highp vec2 vUv;
 
-    'void main(){',
+    void main(){
 
-    'vec2 dxy = pixelSize / resolution;',
-    'vec2 coord = dxy * floor( vUv / dxy );',
-    'gl_FragColor = texture2D(tDiffuse, coord);',
+      vec2 dxy = pixelSize / resolution;
+      vec2 coord = dxy * floor( vUv / dxy );
+      gl_FragColor = texture2D(tDiffuse, coord);
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/RGBShiftShader.ts b/src/shaders/RGBShiftShader.ts
index b545112f..abfc5640 100644
--- a/src/shaders/RGBShiftShader.ts
+++ b/src/shaders/RGBShiftShader.ts
@@ -15,32 +15,32 @@ export const RGBShiftShader = {
     angle: { value: 0.0 },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform sampler2D tDiffuse;',
-    'uniform float amount;',
-    'uniform float angle;',
+  fragmentShader: /* glsl */ `
+    uniform sampler2D tDiffuse;
+    uniform float amount;
+    uniform float angle;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vec2 offset = amount * vec2( cos(angle), sin(angle));',
-    '	vec4 cr = texture2D(tDiffuse, vUv + offset);',
-    '	vec4 cga = texture2D(tDiffuse, vUv);',
-    '	vec4 cb = texture2D(tDiffuse, vUv - offset);',
-    '	gl_FragColor = vec4(cr.r, cga.g, cb.b, cga.a);',
+    	vec2 offset = amount * vec2( cos(angle), sin(angle));
+    	vec4 cr = texture2D(tDiffuse, vUv + offset);
+    	vec4 cga = texture2D(tDiffuse, vUv);
+    	vec4 cb = texture2D(tDiffuse, vUv - offset);
+    	gl_FragColor = vec4(cr.r, cga.g, cb.b, cga.a);
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/SAOShader.ts b/src/shaders/SAOShader.ts
index 69b1546c..0843688b 100644
--- a/src/shaders/SAOShader.ts
+++ b/src/shaders/SAOShader.ts
@@ -43,12 +43,12 @@ export const SAOShader: ISAOShader = {
     tDepth: { value: null },
     tDiffuse: { value: null },
     tNormal: { value: null },
-    size: { value: new Vector2(512, 512) },
+    size: { value: /* @__PURE__ */ new Vector2(512, 512) },
 
     cameraNear: { value: 1 },
     cameraFar: { value: 100 },
-    cameraProjectionMatrix: { value: new Matrix4() },
-    cameraInverseProjectionMatrix: { value: new Matrix4() },
+    cameraProjectionMatrix: { value: /* @__PURE__ */ new Matrix4() },
+    cameraInverseProjectionMatrix: { value: /* @__PURE__ */ new Matrix4() },
 
     scale: { value: 1.0 },
     intensity: { value: 0.1 },
@@ -58,149 +58,149 @@ export const SAOShader: ISAOShader = {
     kernelRadius: { value: 100.0 },
     randomSeed: { value: 0.0 },
   },
-  vertexShader: [
-    'varying vec2 vUv;',
-
-    'void main() {',
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
-    '}',
-  ].join('\n'),
-  fragmentShader: [
-    '#include <common>',
-
-    'varying vec2 vUv;',
-
-    '#if DIFFUSE_TEXTURE == 1',
-    'uniform sampler2D tDiffuse;',
-    '#endif',
-
-    'uniform sampler2D tDepth;',
-
-    '#if NORMAL_TEXTURE == 1',
-    'uniform sampler2D tNormal;',
-    '#endif',
-
-    'uniform float cameraNear;',
-    'uniform float cameraFar;',
-    'uniform mat4 cameraProjectionMatrix;',
-    'uniform mat4 cameraInverseProjectionMatrix;',
-
-    'uniform float scale;',
-    'uniform float intensity;',
-    'uniform float bias;',
-    'uniform float kernelRadius;',
-    'uniform float minResolution;',
-    'uniform vec2 size;',
-    'uniform float randomSeed;',
-
-    '// RGBA depth',
-
-    '#include <packing>',
-
-    'vec4 getDefaultColor( const in vec2 screenPosition ) {',
-    '	#if DIFFUSE_TEXTURE == 1',
-    '	return texture2D( tDiffuse, vUv );',
-    '	#else',
-    '	return vec4( 1.0 );',
-    '	#endif',
-    '}',
-
-    'float getDepth( const in vec2 screenPosition ) {',
-    '	#if DEPTH_PACKING == 1',
-    '	return unpackRGBAToDepth( texture2D( tDepth, screenPosition ) );',
-    '	#else',
-    '	return texture2D( tDepth, screenPosition ).x;',
-    '	#endif',
-    '}',
-
-    'float getViewZ( const in float depth ) {',
-    '	#if PERSPECTIVE_CAMERA == 1',
-    '	return perspectiveDepthToViewZ( depth, cameraNear, cameraFar );',
-    '	#else',
-    '	return orthographicDepthToViewZ( depth, cameraNear, cameraFar );',
-    '	#endif',
-    '}',
-
-    'vec3 getViewPosition( const in vec2 screenPosition, const in float depth, const in float viewZ ) {',
-    '	float clipW = cameraProjectionMatrix[2][3] * viewZ + cameraProjectionMatrix[3][3];',
-    '	vec4 clipPosition = vec4( ( vec3( screenPosition, depth ) - 0.5 ) * 2.0, 1.0 );',
-    '	clipPosition *= clipW; // unprojection.',
-
-    '	return ( cameraInverseProjectionMatrix * clipPosition ).xyz;',
-    '}',
-
-    'vec3 getViewNormal( const in vec3 viewPosition, const in vec2 screenPosition ) {',
-    '	#if NORMAL_TEXTURE == 1',
-    '	return unpackRGBToNormal( texture2D( tNormal, screenPosition ).xyz );',
-    '	#else',
-    '	return normalize( cross( dFdx( viewPosition ), dFdy( viewPosition ) ) );',
-    '	#endif',
-    '}',
-
-    'float scaleDividedByCameraFar;',
-    'float minResolutionMultipliedByCameraFar;',
-
-    'float getOcclusion( const in vec3 centerViewPosition, const in vec3 centerViewNormal, const in vec3 sampleViewPosition ) {',
-    '	vec3 viewDelta = sampleViewPosition - centerViewPosition;',
-    '	float viewDistance = length( viewDelta );',
-    '	float scaledScreenDistance = scaleDividedByCameraFar * viewDistance;',
-
-    '	return max(0.0, (dot(centerViewNormal, viewDelta) - minResolutionMultipliedByCameraFar) / scaledScreenDistance - bias) / (1.0 + pow2( scaledScreenDistance ) );',
-    '}',
-
-    '// moving costly divides into consts',
-    'const float ANGLE_STEP = PI2 * float( NUM_RINGS ) / float( NUM_SAMPLES );',
-    'const float INV_NUM_SAMPLES = 1.0 / float( NUM_SAMPLES );',
-
-    'float getAmbientOcclusion( const in vec3 centerViewPosition ) {',
-    '	// precompute some variables require in getOcclusion.',
-    '	scaleDividedByCameraFar = scale / cameraFar;',
-    '	minResolutionMultipliedByCameraFar = minResolution * cameraFar;',
-    '	vec3 centerViewNormal = getViewNormal( centerViewPosition, vUv );',
-
-    '	// jsfiddle that shows sample pattern: https://jsfiddle.net/a16ff1p7/',
-    '	float angle = rand( vUv + randomSeed ) * PI2;',
-    '	vec2 radius = vec2( kernelRadius * INV_NUM_SAMPLES ) / size;',
-    '	vec2 radiusStep = radius;',
-
-    '	float occlusionSum = 0.0;',
-    '	float weightSum = 0.0;',
-
-    '	for( int i = 0; i < NUM_SAMPLES; i ++ ) {',
-    '		vec2 sampleUv = vUv + vec2( cos( angle ), sin( angle ) ) * radius;',
-    '		radius += radiusStep;',
-    '		angle += ANGLE_STEP;',
-
-    '		float sampleDepth = getDepth( sampleUv );',
-    '		if( sampleDepth >= ( 1.0 - EPSILON ) ) {',
-    '			continue;',
-    '		}',
-
-    '		float sampleViewZ = getViewZ( sampleDepth );',
-    '		vec3 sampleViewPosition = getViewPosition( sampleUv, sampleDepth, sampleViewZ );',
-    '		occlusionSum += getOcclusion( centerViewPosition, centerViewNormal, sampleViewPosition );',
-    '		weightSum += 1.0;',
-    '	}',
-
-    '	if( weightSum == 0.0 ) discard;',
-
-    '	return occlusionSum * ( intensity / weightSum );',
-    '}',
-
-    'void main() {',
-    '	float centerDepth = getDepth( vUv );',
-    '	if( centerDepth >= ( 1.0 - EPSILON ) ) {',
-    '		discard;',
-    '	}',
-
-    '	float centerViewZ = getViewZ( centerDepth );',
-    '	vec3 viewPosition = getViewPosition( vUv, centerDepth, centerViewZ );',
-
-    '	float ambientOcclusion = getAmbientOcclusion( viewPosition );',
-
-    '	gl_FragColor = getDefaultColor( vUv );',
-    '	gl_FragColor.xyz *=  1.0 - ambientOcclusion;',
-    '}',
-  ].join('\n'),
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
+
+    void main() {
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    }
+  `,
+  fragmentShader: /* glsl */ `
+    #include <common>
+
+    varying vec2 vUv;
+
+    #if DIFFUSE_TEXTURE == 1
+    uniform sampler2D tDiffuse;
+    #endif
+
+    uniform sampler2D tDepth;
+
+    #if NORMAL_TEXTURE == 1
+    uniform sampler2D tNormal;
+    #endif
+
+    uniform float cameraNear;
+    uniform float cameraFar;
+    uniform mat4 cameraProjectionMatrix;
+    uniform mat4 cameraInverseProjectionMatrix;
+
+    uniform float scale;
+    uniform float intensity;
+    uniform float bias;
+    uniform float kernelRadius;
+    uniform float minResolution;
+    uniform vec2 size;
+    uniform float randomSeed;
+
+    // RGBA depth
+
+    #include <packing>
+
+    vec4 getDefaultColor( const in vec2 screenPosition ) {
+    	#if DIFFUSE_TEXTURE == 1
+    	return texture2D( tDiffuse, vUv );
+    	#else
+    	return vec4( 1.0 );
+    	#endif
+    }
+
+    float getDepth( const in vec2 screenPosition ) {
+    	#if DEPTH_PACKING == 1
+    	return unpackRGBAToDepth( texture2D( tDepth, screenPosition ) );
+    	#else
+    	return texture2D( tDepth, screenPosition ).x;
+    	#endif
+    }
+
+    float getViewZ( const in float depth ) {
+    	#if PERSPECTIVE_CAMERA == 1
+    	return perspectiveDepthToViewZ( depth, cameraNear, cameraFar );
+    	#else
+    	return orthographicDepthToViewZ( depth, cameraNear, cameraFar );
+    	#endif
+    }
+
+    vec3 getViewPosition( const in vec2 screenPosition, const in float depth, const in float viewZ ) {
+    	float clipW = cameraProjectionMatrix[2][3] * viewZ + cameraProjectionMatrix[3][3];
+    	vec4 clipPosition = vec4( ( vec3( screenPosition, depth ) - 0.5 ) * 2.0, 1.0 );
+    	clipPosition *= clipW; // unprojection.
+
+    	return ( cameraInverseProjectionMatrix * clipPosition ).xyz;
+    }
+
+    vec3 getViewNormal( const in vec3 viewPosition, const in vec2 screenPosition ) {
+    	#if NORMAL_TEXTURE == 1
+    	return unpackRGBToNormal( texture2D( tNormal, screenPosition ).xyz );
+    	#else
+    	return normalize( cross( dFdx( viewPosition ), dFdy( viewPosition ) ) );
+    	#endif
+    }
+
+    float scaleDividedByCameraFar;
+    float minResolutionMultipliedByCameraFar;
+
+    float getOcclusion( const in vec3 centerViewPosition, const in vec3 centerViewNormal, const in vec3 sampleViewPosition ) {
+    	vec3 viewDelta = sampleViewPosition - centerViewPosition;
+    	float viewDistance = length( viewDelta );
+    	float scaledScreenDistance = scaleDividedByCameraFar * viewDistance;
+
+    	return max(0.0, (dot(centerViewNormal, viewDelta) - minResolutionMultipliedByCameraFar) / scaledScreenDistance - bias) / (1.0 + pow2( scaledScreenDistance ) );
+    }
+
+    // moving costly divides into consts
+    const float ANGLE_STEP = PI2 * float( NUM_RINGS ) / float( NUM_SAMPLES );
+    const float INV_NUM_SAMPLES = 1.0 / float( NUM_SAMPLES );
+
+    float getAmbientOcclusion( const in vec3 centerViewPosition ) {
+    	// precompute some variables require in getOcclusion.
+    	scaleDividedByCameraFar = scale / cameraFar;
+    	minResolutionMultipliedByCameraFar = minResolution * cameraFar;
+    	vec3 centerViewNormal = getViewNormal( centerViewPosition, vUv );
+
+    	// jsfiddle that shows sample pattern: https://jsfiddle.net/a16ff1p7/
+    	float angle = rand( vUv + randomSeed ) * PI2;
+    	vec2 radius = vec2( kernelRadius * INV_NUM_SAMPLES ) / size;
+    	vec2 radiusStep = radius;
+
+    	float occlusionSum = 0.0;
+    	float weightSum = 0.0;
+
+    	for( int i = 0; i < NUM_SAMPLES; i ++ ) {
+    		vec2 sampleUv = vUv + vec2( cos( angle ), sin( angle ) ) * radius;
+    		radius += radiusStep;
+    		angle += ANGLE_STEP;
+
+    		float sampleDepth = getDepth( sampleUv );
+    		if( sampleDepth >= ( 1.0 - EPSILON ) ) {
+    			continue;
+    		}
+
+    		float sampleViewZ = getViewZ( sampleDepth );
+    		vec3 sampleViewPosition = getViewPosition( sampleUv, sampleDepth, sampleViewZ );
+    		occlusionSum += getOcclusion( centerViewPosition, centerViewNormal, sampleViewPosition );
+    		weightSum += 1.0;
+    	}
+
+    	if( weightSum == 0.0 ) discard;
+
+    	return occlusionSum * ( intensity / weightSum );
+    }
+
+    void main() {
+    	float centerDepth = getDepth( vUv );
+    	if( centerDepth >= ( 1.0 - EPSILON ) ) {
+    		discard;
+    	}
+
+    	float centerViewZ = getViewZ( centerDepth );
+    	vec3 viewPosition = getViewPosition( vUv, centerDepth, centerViewZ );
+
+    	float ambientOcclusion = getAmbientOcclusion( viewPosition );
+
+    	gl_FragColor = getDefaultColor( vUv );
+    	gl_FragColor.xyz *=  1.0 - ambientOcclusion;
+    }
+  `,
 }
diff --git a/src/shaders/SMAAShader.ts b/src/shaders/SMAAShader.ts
index 95813a82..17cde98c 100644
--- a/src/shaders/SMAAShader.ts
+++ b/src/shaders/SMAAShader.ts
@@ -13,96 +13,96 @@ export const SMAAEdgesShader = {
 
   uniforms: {
     tDiffuse: { value: null },
-    resolution: { value: new Vector2(1 / 1024, 1 / 512) },
+    resolution: { value: /* @__PURE__ */ new Vector2(1 / 1024, 1 / 512) },
   },
 
-  vertexShader: [
-    'uniform vec2 resolution;',
+  vertexShader: /* glsl */ `
+    uniform vec2 resolution;
 
-    'varying vec2 vUv;',
-    'varying vec4 vOffset[ 3 ];',
+    varying vec2 vUv;
+    varying vec4 vOffset[ 3 ];
 
-    'void SMAAEdgeDetectionVS( vec2 texcoord ) {',
-    '	vOffset[ 0 ] = texcoord.xyxy + resolution.xyxy * vec4( -1.0, 0.0, 0.0,  1.0 );', // WebGL port note: Changed sign in W component
-    '	vOffset[ 1 ] = texcoord.xyxy + resolution.xyxy * vec4(  1.0, 0.0, 0.0, -1.0 );', // WebGL port note: Changed sign in W component
-    '	vOffset[ 2 ] = texcoord.xyxy + resolution.xyxy * vec4( -2.0, 0.0, 0.0,  2.0 );', // WebGL port note: Changed sign in W component
-    '}',
+    void SMAAEdgeDetectionVS( vec2 texcoord ) {
+    	vOffset[ 0 ] = texcoord.xyxy + resolution.xyxy * vec4( -1.0, 0.0, 0.0,  1.0 ); // WebGL port note: Changed sign in W component
+    	vOffset[ 1 ] = texcoord.xyxy + resolution.xyxy * vec4(  1.0, 0.0, 0.0, -1.0 ); // WebGL port note: Changed sign in W component
+    	vOffset[ 2 ] = texcoord.xyxy + resolution.xyxy * vec4( -2.0, 0.0, 0.0,  2.0 ); // WebGL port note: Changed sign in W component
+    }
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
+    	vUv = uv;
 
-    '	SMAAEdgeDetectionVS( vUv );',
+    	SMAAEdgeDetectionVS( vUv );
 
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform sampler2D tDiffuse;',
+  fragmentShader: /* glsl */ `
+    uniform sampler2D tDiffuse;
 
-    'varying vec2 vUv;',
-    'varying vec4 vOffset[ 3 ];',
+    varying vec2 vUv;
+    varying vec4 vOffset[ 3 ];
 
-    'vec4 SMAAColorEdgeDetectionPS( vec2 texcoord, vec4 offset[3], sampler2D colorTex ) {',
-    '	vec2 threshold = vec2( SMAA_THRESHOLD, SMAA_THRESHOLD );',
+    vec4 SMAAColorEdgeDetectionPS( vec2 texcoord, vec4 offset[3], sampler2D colorTex ) {
+    	vec2 threshold = vec2( SMAA_THRESHOLD, SMAA_THRESHOLD );
 
     // Calculate color deltas:
-    '	vec4 delta;',
-    '	vec3 C = texture2D( colorTex, texcoord ).rgb;',
+    	vec4 delta;
+    	vec3 C = texture2D( colorTex, texcoord ).rgb;
 
-    '	vec3 Cleft = texture2D( colorTex, offset[0].xy ).rgb;',
-    '	vec3 t = abs( C - Cleft );',
-    '	delta.x = max( max( t.r, t.g ), t.b );',
+    	vec3 Cleft = texture2D( colorTex, offset[0].xy ).rgb;
+    	vec3 t = abs( C - Cleft );
+    	delta.x = max( max( t.r, t.g ), t.b );
 
-    '	vec3 Ctop = texture2D( colorTex, offset[0].zw ).rgb;',
-    '	t = abs( C - Ctop );',
-    '	delta.y = max( max( t.r, t.g ), t.b );',
+    	vec3 Ctop = texture2D( colorTex, offset[0].zw ).rgb;
+    	t = abs( C - Ctop );
+    	delta.y = max( max( t.r, t.g ), t.b );
 
     // We do the usual threshold:
-    '	vec2 edges = step( threshold, delta.xy );',
+    	vec2 edges = step( threshold, delta.xy );
 
     // Then discard if there is no edge:
-    '	if ( dot( edges, vec2( 1.0, 1.0 ) ) == 0.0 )',
-    '		discard;',
+    	if ( dot( edges, vec2( 1.0, 1.0 ) ) == 0.0 )
+    		discard;
 
     // Calculate right and bottom deltas:
-    '	vec3 Cright = texture2D( colorTex, offset[1].xy ).rgb;',
-    '	t = abs( C - Cright );',
-    '	delta.z = max( max( t.r, t.g ), t.b );',
+    	vec3 Cright = texture2D( colorTex, offset[1].xy ).rgb;
+    	t = abs( C - Cright );
+    	delta.z = max( max( t.r, t.g ), t.b );
 
-    '	vec3 Cbottom  = texture2D( colorTex, offset[1].zw ).rgb;',
-    '	t = abs( C - Cbottom );',
-    '	delta.w = max( max( t.r, t.g ), t.b );',
+    	vec3 Cbottom  = texture2D( colorTex, offset[1].zw ).rgb;
+    	t = abs( C - Cbottom );
+    	delta.w = max( max( t.r, t.g ), t.b );
 
     // Calculate the maximum delta in the direct neighborhood:
-    '	float maxDelta = max( max( max( delta.x, delta.y ), delta.z ), delta.w );',
+    	float maxDelta = max( max( max( delta.x, delta.y ), delta.z ), delta.w );
 
     // Calculate left-left and top-top deltas:
-    '	vec3 Cleftleft  = texture2D( colorTex, offset[2].xy ).rgb;',
-    '	t = abs( C - Cleftleft );',
-    '	delta.z = max( max( t.r, t.g ), t.b );',
+    	vec3 Cleftleft  = texture2D( colorTex, offset[2].xy ).rgb;
+    	t = abs( C - Cleftleft );
+    	delta.z = max( max( t.r, t.g ), t.b );
 
-    '	vec3 Ctoptop = texture2D( colorTex, offset[2].zw ).rgb;',
-    '	t = abs( C - Ctoptop );',
-    '	delta.w = max( max( t.r, t.g ), t.b );',
+    	vec3 Ctoptop = texture2D( colorTex, offset[2].zw ).rgb;
+    	t = abs( C - Ctoptop );
+    	delta.w = max( max( t.r, t.g ), t.b );
 
     // Calculate the final maximum delta:
-    '	maxDelta = max( max( maxDelta, delta.z ), delta.w );',
+    	maxDelta = max( max( maxDelta, delta.z ), delta.w );
 
     // Local contrast adaptation in action:
-    '	edges.xy *= step( 0.5 * maxDelta, delta.xy );',
+    	edges.xy *= step( 0.5 * maxDelta, delta.xy );
 
-    '	return vec4( edges, 0.0, 0.0 );',
-    '}',
+    	return vec4( edges, 0.0, 0.0 );
+    }
 
-    'void main() {',
+    void main() {
 
-    '	gl_FragColor = SMAAColorEdgeDetectionPS( vUv, vOffset, tDiffuse );',
+    	gl_FragColor = SMAAColorEdgeDetectionPS( vUv, vOffset, tDiffuse );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
 
 export const SMAAWeightsShader = {
@@ -117,67 +117,67 @@ export const SMAAWeightsShader = {
     tDiffuse: { value: null },
     tArea: { value: null },
     tSearch: { value: null },
-    resolution: { value: new Vector2(1 / 1024, 1 / 512) },
+    resolution: { value: /* @__PURE__ */ new Vector2(1 / 1024, 1 / 512) },
   },
 
-  vertexShader: [
-    'uniform vec2 resolution;',
+  vertexShader: /* glsl */ `
+    uniform vec2 resolution;
 
-    'varying vec2 vUv;',
-    'varying vec4 vOffset[ 3 ];',
-    'varying vec2 vPixcoord;',
+    varying vec2 vUv;
+    varying vec4 vOffset[ 3 ];
+    varying vec2 vPixcoord;
 
-    'void SMAABlendingWeightCalculationVS( vec2 texcoord ) {',
-    '	vPixcoord = texcoord / resolution;',
+    void SMAABlendingWeightCalculationVS( vec2 texcoord ) {
+    	vPixcoord = texcoord / resolution;
 
     // We will use these offsets for the searches later on (see @PSEUDO_GATHER4):
-    '	vOffset[ 0 ] = texcoord.xyxy + resolution.xyxy * vec4( -0.25, 0.125, 1.25, 0.125 );', // WebGL port note: Changed sign in Y and W components
-    '	vOffset[ 1 ] = texcoord.xyxy + resolution.xyxy * vec4( -0.125, 0.25, -0.125, -1.25 );', // WebGL port note: Changed sign in Y and W components
+    	vOffset[ 0 ] = texcoord.xyxy + resolution.xyxy * vec4( -0.25, 0.125, 1.25, 0.125 ); // WebGL port note: Changed sign in Y and W components
+    	vOffset[ 1 ] = texcoord.xyxy + resolution.xyxy * vec4( -0.125, 0.25, -0.125, -1.25 ); // WebGL port note: Changed sign in Y and W components
 
     // And these for the searches, they indicate the ends of the loops:
-    '	vOffset[ 2 ] = vec4( vOffset[ 0 ].xz, vOffset[ 1 ].yw ) + vec4( -2.0, 2.0, -2.0, 2.0 ) * resolution.xxyy * float( SMAA_MAX_SEARCH_STEPS );',
+    	vOffset[ 2 ] = vec4( vOffset[ 0 ].xz, vOffset[ 1 ].yw ) + vec4( -2.0, 2.0, -2.0, 2.0 ) * resolution.xxyy * float( SMAA_MAX_SEARCH_STEPS );
 
-    '}',
+    }
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
+    	vUv = uv;
 
-    '	SMAABlendingWeightCalculationVS( vUv );',
+    	SMAABlendingWeightCalculationVS( vUv );
 
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    '#define SMAASampleLevelZeroOffset( tex, coord, offset ) texture2D( tex, coord + float( offset ) * resolution, 0.0 )',
+  fragmentShader: /* glsl */ `
+    #define SMAASampleLevelZeroOffset( tex, coord, offset ) texture2D( tex, coord + float( offset ) * resolution, 0.0 )
 
-    'uniform sampler2D tDiffuse;',
-    'uniform sampler2D tArea;',
-    'uniform sampler2D tSearch;',
-    'uniform vec2 resolution;',
+    uniform sampler2D tDiffuse;
+    uniform sampler2D tArea;
+    uniform sampler2D tSearch;
+    uniform vec2 resolution;
 
-    'varying vec2 vUv;',
-    'varying vec4 vOffset[3];',
-    'varying vec2 vPixcoord;',
+    varying vec2 vUv;
+    varying vec4 vOffset[3];
+    varying vec2 vPixcoord;
 
-    '#if __VERSION__ == 100',
-    'vec2 round( vec2 x ) {',
-    '	return sign( x ) * floor( abs( x ) + 0.5 );',
-    '}',
-    '#endif',
+    #if __VERSION__ == 100
+    vec2 round( vec2 x ) {
+    	return sign( x ) * floor( abs( x ) + 0.5 );
+    }
+    #endif
 
-    'float SMAASearchLength( sampler2D searchTex, vec2 e, float bias, float scale ) {',
+    float SMAASearchLength( sampler2D searchTex, vec2 e, float bias, float scale ) {
     // Not required if searchTex accesses are set to point:
     // float2 SEARCH_TEX_PIXEL_SIZE = 1.0 / float2(66.0, 33.0);
     // e = float2(bias, 0.0) + 0.5 * SEARCH_TEX_PIXEL_SIZE +
     //     e * float2(scale, 1.0) * float2(64.0, 32.0) * SEARCH_TEX_PIXEL_SIZE;
-    '	e.r = bias + e.r * scale;',
-    '	return 255.0 * texture2D( searchTex, e, 0.0 ).r;',
-    '}',
+    	e.r = bias + e.r * scale;
+    	return 255.0 * texture2D( searchTex, e, 0.0 ).r;
+    }
 
-    'float SMAASearchXLeft( sampler2D edgesTex, sampler2D searchTex, vec2 texcoord, float end ) {',
+    float SMAASearchXLeft( sampler2D edgesTex, sampler2D searchTex, vec2 texcoord, float end ) {
     /**
      * @PSEUDO_GATHER4
      * This texcoord has been offset by (-0.25, -0.125) in the vertex shader to
@@ -185,256 +185,256 @@ export const SMAAWeightsShader = {
      * Sampling with different offsets in each direction allows to disambiguate
      * which edges are active from the four fetched ones.
      */
-    '	vec2 e = vec2( 0.0, 1.0 );',
+    	vec2 e = vec2( 0.0, 1.0 );
 
-    '	for ( int i = 0; i < SMAA_MAX_SEARCH_STEPS; i ++ ) {', // WebGL port note: Changed while to for
-    '		e = texture2D( edgesTex, texcoord, 0.0 ).rg;',
-    '		texcoord -= vec2( 2.0, 0.0 ) * resolution;',
-    '		if ( ! ( texcoord.x > end && e.g > 0.8281 && e.r == 0.0 ) ) break;',
-    '	}',
+    	for ( int i = 0; i < SMAA_MAX_SEARCH_STEPS; i ++ ) { // WebGL port note: Changed while to for
+    		e = texture2D( edgesTex, texcoord, 0.0 ).rg;
+    		texcoord -= vec2( 2.0, 0.0 ) * resolution;
+    		if ( ! ( texcoord.x > end && e.g > 0.8281 && e.r == 0.0 ) ) break;
+    	}
 
     // We correct the previous (-0.25, -0.125) offset we applied:
-    '	texcoord.x += 0.25 * resolution.x;',
+    	texcoord.x += 0.25 * resolution.x;
 
     // The searches are bias by 1, so adjust the coords accordingly:
-    '	texcoord.x += resolution.x;',
+    	texcoord.x += resolution.x;
 
     // Disambiguate the length added by the last step:
-    '	texcoord.x += 2.0 * resolution.x;', // Undo last step
-    '	texcoord.x -= resolution.x * SMAASearchLength(searchTex, e, 0.0, 0.5);',
+    	texcoord.x += 2.0 * resolution.x; // Undo last step
+    	texcoord.x -= resolution.x * SMAASearchLength(searchTex, e, 0.0, 0.5);
 
-    '	return texcoord.x;',
-    '}',
+    	return texcoord.x;
+    }
 
-    'float SMAASearchXRight( sampler2D edgesTex, sampler2D searchTex, vec2 texcoord, float end ) {',
-    '	vec2 e = vec2( 0.0, 1.0 );',
+    float SMAASearchXRight( sampler2D edgesTex, sampler2D searchTex, vec2 texcoord, float end ) {
+    	vec2 e = vec2( 0.0, 1.0 );
 
-    '	for ( int i = 0; i < SMAA_MAX_SEARCH_STEPS; i ++ ) {', // WebGL port note: Changed while to for
-    '		e = texture2D( edgesTex, texcoord, 0.0 ).rg;',
-    '		texcoord += vec2( 2.0, 0.0 ) * resolution;',
-    '		if ( ! ( texcoord.x < end && e.g > 0.8281 && e.r == 0.0 ) ) break;',
-    '	}',
+    	for ( int i = 0; i < SMAA_MAX_SEARCH_STEPS; i ++ ) { // WebGL port note: Changed while to for
+    		e = texture2D( edgesTex, texcoord, 0.0 ).rg;
+    		texcoord += vec2( 2.0, 0.0 ) * resolution;
+    		if ( ! ( texcoord.x < end && e.g > 0.8281 && e.r == 0.0 ) ) break;
+    	}
 
-    '	texcoord.x -= 0.25 * resolution.x;',
-    '	texcoord.x -= resolution.x;',
-    '	texcoord.x -= 2.0 * resolution.x;',
-    '	texcoord.x += resolution.x * SMAASearchLength( searchTex, e, 0.5, 0.5 );',
+    	texcoord.x -= 0.25 * resolution.x;
+    	texcoord.x -= resolution.x;
+    	texcoord.x -= 2.0 * resolution.x;
+    	texcoord.x += resolution.x * SMAASearchLength( searchTex, e, 0.5, 0.5 );
 
-    '	return texcoord.x;',
-    '}',
+    	return texcoord.x;
+    }
 
-    'float SMAASearchYUp( sampler2D edgesTex, sampler2D searchTex, vec2 texcoord, float end ) {',
-    '	vec2 e = vec2( 1.0, 0.0 );',
+    float SMAASearchYUp( sampler2D edgesTex, sampler2D searchTex, vec2 texcoord, float end ) {
+    	vec2 e = vec2( 1.0, 0.0 );
 
-    '	for ( int i = 0; i < SMAA_MAX_SEARCH_STEPS; i ++ ) {', // WebGL port note: Changed while to for
-    '		e = texture2D( edgesTex, texcoord, 0.0 ).rg;',
-    '		texcoord += vec2( 0.0, 2.0 ) * resolution;', // WebGL port note: Changed sign
-    '		if ( ! ( texcoord.y > end && e.r > 0.8281 && e.g == 0.0 ) ) break;',
-    '	}',
+    	for ( int i = 0; i < SMAA_MAX_SEARCH_STEPS; i ++ ) { // WebGL port note: Changed while to for
+    		e = texture2D( edgesTex, texcoord, 0.0 ).rg;
+    		texcoord += vec2( 0.0, 2.0 ) * resolution; // WebGL port note: Changed sign
+    		if ( ! ( texcoord.y > end && e.r > 0.8281 && e.g == 0.0 ) ) break;
+    	}
 
-    '	texcoord.y -= 0.25 * resolution.y;', // WebGL port note: Changed sign
-    '	texcoord.y -= resolution.y;', // WebGL port note: Changed sign
-    '	texcoord.y -= 2.0 * resolution.y;', // WebGL port note: Changed sign
-    '	texcoord.y += resolution.y * SMAASearchLength( searchTex, e.gr, 0.0, 0.5 );', // WebGL port note: Changed sign
+    	texcoord.y -= 0.25 * resolution.y; // WebGL port note: Changed sign
+    	texcoord.y -= resolution.y; // WebGL port note: Changed sign
+    	texcoord.y -= 2.0 * resolution.y; // WebGL port note: Changed sign
+    	texcoord.y += resolution.y * SMAASearchLength( searchTex, e.gr, 0.0, 0.5 ); // WebGL port note: Changed sign
 
-    '	return texcoord.y;',
-    '}',
+    	return texcoord.y;
+    }
 
-    'float SMAASearchYDown( sampler2D edgesTex, sampler2D searchTex, vec2 texcoord, float end ) {',
-    '	vec2 e = vec2( 1.0, 0.0 );',
+    float SMAASearchYDown( sampler2D edgesTex, sampler2D searchTex, vec2 texcoord, float end ) {
+    	vec2 e = vec2( 1.0, 0.0 );
 
-    '	for ( int i = 0; i < SMAA_MAX_SEARCH_STEPS; i ++ ) {', // WebGL port note: Changed while to for
-    '		e = texture2D( edgesTex, texcoord, 0.0 ).rg;',
-    '		texcoord -= vec2( 0.0, 2.0 ) * resolution;', // WebGL port note: Changed sign
-    '		if ( ! ( texcoord.y < end && e.r > 0.8281 && e.g == 0.0 ) ) break;',
-    '	}',
+    	for ( int i = 0; i < SMAA_MAX_SEARCH_STEPS; i ++ ) { // WebGL port note: Changed while to for
+    		e = texture2D( edgesTex, texcoord, 0.0 ).rg;
+    		texcoord -= vec2( 0.0, 2.0 ) * resolution; // WebGL port note: Changed sign
+    		if ( ! ( texcoord.y < end && e.r > 0.8281 && e.g == 0.0 ) ) break;
+    	}
 
-    '	texcoord.y += 0.25 * resolution.y;', // WebGL port note: Changed sign
-    '	texcoord.y += resolution.y;', // WebGL port note: Changed sign
-    '	texcoord.y += 2.0 * resolution.y;', // WebGL port note: Changed sign
-    '	texcoord.y -= resolution.y * SMAASearchLength( searchTex, e.gr, 0.5, 0.5 );', // WebGL port note: Changed sign
+    	texcoord.y += 0.25 * resolution.y; // WebGL port note: Changed sign
+    	texcoord.y += resolution.y; // WebGL port note: Changed sign
+    	texcoord.y += 2.0 * resolution.y; // WebGL port note: Changed sign
+    	texcoord.y -= resolution.y * SMAASearchLength( searchTex, e.gr, 0.5, 0.5 ); // WebGL port note: Changed sign
 
-    '	return texcoord.y;',
-    '}',
+    	return texcoord.y;
+    }
 
-    'vec2 SMAAArea( sampler2D areaTex, vec2 dist, float e1, float e2, float offset ) {',
+    vec2 SMAAArea( sampler2D areaTex, vec2 dist, float e1, float e2, float offset ) {
     // Rounding prevents precision errors of bilinear filtering:
-    '	vec2 texcoord = float( SMAA_AREATEX_MAX_DISTANCE ) * round( 4.0 * vec2( e1, e2 ) ) + dist;',
+    	vec2 texcoord = float( SMAA_AREATEX_MAX_DISTANCE ) * round( 4.0 * vec2( e1, e2 ) ) + dist;
 
     // We do a scale and bias for mapping to texel space:
-    '	texcoord = SMAA_AREATEX_PIXEL_SIZE * texcoord + ( 0.5 * SMAA_AREATEX_PIXEL_SIZE );',
+    	texcoord = SMAA_AREATEX_PIXEL_SIZE * texcoord + ( 0.5 * SMAA_AREATEX_PIXEL_SIZE );
 
     // Move to proper place, according to the subpixel offset:
-    '	texcoord.y += SMAA_AREATEX_SUBTEX_SIZE * offset;',
+    	texcoord.y += SMAA_AREATEX_SUBTEX_SIZE * offset;
 
-    '	return texture2D( areaTex, texcoord, 0.0 ).rg;',
-    '}',
+    	return texture2D( areaTex, texcoord, 0.0 ).rg;
+    }
 
-    'vec4 SMAABlendingWeightCalculationPS( vec2 texcoord, vec2 pixcoord, vec4 offset[ 3 ], sampler2D edgesTex, sampler2D areaTex, sampler2D searchTex, ivec4 subsampleIndices ) {',
-    '	vec4 weights = vec4( 0.0, 0.0, 0.0, 0.0 );',
+    vec4 SMAABlendingWeightCalculationPS( vec2 texcoord, vec2 pixcoord, vec4 offset[ 3 ], sampler2D edgesTex, sampler2D areaTex, sampler2D searchTex, ivec4 subsampleIndices ) {
+    	vec4 weights = vec4( 0.0, 0.0, 0.0, 0.0 );
 
-    '	vec2 e = texture2D( edgesTex, texcoord ).rg;',
+    	vec2 e = texture2D( edgesTex, texcoord ).rg;
 
-    '	if ( e.g > 0.0 ) {', // Edge at north
-    '		vec2 d;',
+    	if ( e.g > 0.0 ) { // Edge at north
+    		vec2 d;
 
     // Find the distance to the left:
-    '		vec2 coords;',
-    '		coords.x = SMAASearchXLeft( edgesTex, searchTex, offset[ 0 ].xy, offset[ 2 ].x );',
-    '		coords.y = offset[ 1 ].y;', // offset[1].y = texcoord.y - 0.25 * resolution.y (@CROSSING_OFFSET)
-    '		d.x = coords.x;',
+    		vec2 coords;
+    		coords.x = SMAASearchXLeft( edgesTex, searchTex, offset[ 0 ].xy, offset[ 2 ].x );
+    		coords.y = offset[ 1 ].y; // offset[1].y = texcoord.y - 0.25 * resolution.y (@CROSSING_OFFSET)
+    		d.x = coords.x;
 
     // Now fetch the left crossing edges, two at a time using bilinear
     // filtering. Sampling at -0.25 (see @CROSSING_OFFSET) enables to
     // discern what value each edge has:
-    '		float e1 = texture2D( edgesTex, coords, 0.0 ).r;',
+    		float e1 = texture2D( edgesTex, coords, 0.0 ).r;
 
     // Find the distance to the right:
-    '		coords.x = SMAASearchXRight( edgesTex, searchTex, offset[ 0 ].zw, offset[ 2 ].y );',
-    '		d.y = coords.x;',
+    		coords.x = SMAASearchXRight( edgesTex, searchTex, offset[ 0 ].zw, offset[ 2 ].y );
+    		d.y = coords.x;
 
     // We want the distances to be in pixel units (doing this here allow to
     // better interleave arithmetic and memory accesses):
-    '		d = d / resolution.x - pixcoord.x;',
+    		d = d / resolution.x - pixcoord.x;
 
     // SMAAArea below needs a sqrt, as the areas texture is compressed
     // quadratically:
-    '		vec2 sqrt_d = sqrt( abs( d ) );',
+    		vec2 sqrt_d = sqrt( abs( d ) );
 
     // Fetch the right crossing edges:
-    '		coords.y -= 1.0 * resolution.y;', // WebGL port note: Added
-    '		float e2 = SMAASampleLevelZeroOffset( edgesTex, coords, ivec2( 1, 0 ) ).r;',
+    		coords.y -= 1.0 * resolution.y; // WebGL port note: Added
+    		float e2 = SMAASampleLevelZeroOffset( edgesTex, coords, ivec2( 1, 0 ) ).r;
 
     // Ok, we know how this pattern looks like, now it is time for getting
     // the actual area:
-    '		weights.rg = SMAAArea( areaTex, sqrt_d, e1, e2, float( subsampleIndices.y ) );',
-    '	}',
+    		weights.rg = SMAAArea( areaTex, sqrt_d, e1, e2, float( subsampleIndices.y ) );
+    	}
 
-    '	if ( e.r > 0.0 ) {', // Edge at west
-    '		vec2 d;',
+    	if ( e.r > 0.0 ) { // Edge at west
+    		vec2 d;
 
     // Find the distance to the top:
-    '		vec2 coords;',
+    		vec2 coords;
 
-    '		coords.y = SMAASearchYUp( edgesTex, searchTex, offset[ 1 ].xy, offset[ 2 ].z );',
-    '		coords.x = offset[ 0 ].x;', // offset[1].x = texcoord.x - 0.25 * resolution.x;
-    '		d.x = coords.y;',
+    		coords.y = SMAASearchYUp( edgesTex, searchTex, offset[ 1 ].xy, offset[ 2 ].z );
+    		coords.x = offset[ 0 ].x; // offset[1].x = texcoord.x - 0.25 * resolution.x;
+    		d.x = coords.y;
 
     // Fetch the top crossing edges:
-    '		float e1 = texture2D( edgesTex, coords, 0.0 ).g;',
+    		float e1 = texture2D( edgesTex, coords, 0.0 ).g;
 
     // Find the distance to the bottom:
-    '		coords.y = SMAASearchYDown( edgesTex, searchTex, offset[ 1 ].zw, offset[ 2 ].w );',
-    '		d.y = coords.y;',
+    		coords.y = SMAASearchYDown( edgesTex, searchTex, offset[ 1 ].zw, offset[ 2 ].w );
+    		d.y = coords.y;
 
     // We want the distances to be in pixel units:
-    '		d = d / resolution.y - pixcoord.y;',
+    		d = d / resolution.y - pixcoord.y;
 
     // SMAAArea below needs a sqrt, as the areas texture is compressed
     // quadratically:
-    '		vec2 sqrt_d = sqrt( abs( d ) );',
+    		vec2 sqrt_d = sqrt( abs( d ) );
 
     // Fetch the bottom crossing edges:
-    '		coords.y -= 1.0 * resolution.y;', // WebGL port note: Added
-    '		float e2 = SMAASampleLevelZeroOffset( edgesTex, coords, ivec2( 0, 1 ) ).g;',
+    		coords.y -= 1.0 * resolution.y; // WebGL port note: Added
+    		float e2 = SMAASampleLevelZeroOffset( edgesTex, coords, ivec2( 0, 1 ) ).g;
 
     // Get the area for this direction:
-    '		weights.ba = SMAAArea( areaTex, sqrt_d, e1, e2, float( subsampleIndices.x ) );',
-    '	}',
+    		weights.ba = SMAAArea( areaTex, sqrt_d, e1, e2, float( subsampleIndices.x ) );
+    	}
 
-    '	return weights;',
-    '}',
+    	return weights;
+    }
 
-    'void main() {',
+    void main() {
 
-    '	gl_FragColor = SMAABlendingWeightCalculationPS( vUv, vPixcoord, vOffset, tDiffuse, tArea, tSearch, ivec4( 0.0 ) );',
+    	gl_FragColor = SMAABlendingWeightCalculationPS( vUv, vPixcoord, vOffset, tDiffuse, tArea, tSearch, ivec4( 0.0 ) );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
 
 export const SMAABlendShader = {
   uniforms: {
     tDiffuse: { value: null },
     tColor: { value: null },
-    resolution: { value: new Vector2(1 / 1024, 1 / 512) },
+    resolution: { value: /* @__PURE__ */ new Vector2(1 / 1024, 1 / 512) },
   },
 
-  vertexShader: [
-    'uniform vec2 resolution;',
+  vertexShader: /* glsl */ `
+    uniform vec2 resolution;
 
-    'varying vec2 vUv;',
-    'varying vec4 vOffset[ 2 ];',
+    varying vec2 vUv;
+    varying vec4 vOffset[ 2 ];
 
-    'void SMAANeighborhoodBlendingVS( vec2 texcoord ) {',
-    '	vOffset[ 0 ] = texcoord.xyxy + resolution.xyxy * vec4( -1.0, 0.0, 0.0, 1.0 );', // WebGL port note: Changed sign in W component
-    '	vOffset[ 1 ] = texcoord.xyxy + resolution.xyxy * vec4( 1.0, 0.0, 0.0, -1.0 );', // WebGL port note: Changed sign in W component
-    '}',
+    void SMAANeighborhoodBlendingVS( vec2 texcoord ) {
+    	vOffset[ 0 ] = texcoord.xyxy + resolution.xyxy * vec4( -1.0, 0.0, 0.0, 1.0 ); // WebGL port note: Changed sign in W component
+    	vOffset[ 1 ] = texcoord.xyxy + resolution.xyxy * vec4( 1.0, 0.0, 0.0, -1.0 ); // WebGL port note: Changed sign in W component
+    }
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
+    	vUv = uv;
 
-    '	SMAANeighborhoodBlendingVS( vUv );',
+    	SMAANeighborhoodBlendingVS( vUv );
 
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform sampler2D tDiffuse;',
-    'uniform sampler2D tColor;',
-    'uniform vec2 resolution;',
+  fragmentShader: /* glsl */ `
+    uniform sampler2D tDiffuse;
+    uniform sampler2D tColor;
+    uniform vec2 resolution;
 
-    'varying vec2 vUv;',
-    'varying vec4 vOffset[ 2 ];',
+    varying vec2 vUv;
+    varying vec4 vOffset[ 2 ];
 
-    'vec4 SMAANeighborhoodBlendingPS( vec2 texcoord, vec4 offset[ 2 ], sampler2D colorTex, sampler2D blendTex ) {',
+    vec4 SMAANeighborhoodBlendingPS( vec2 texcoord, vec4 offset[ 2 ], sampler2D colorTex, sampler2D blendTex ) {
     // Fetch the blending weights for current pixel:
-    '	vec4 a;',
-    '	a.xz = texture2D( blendTex, texcoord ).xz;',
-    '	a.y = texture2D( blendTex, offset[ 1 ].zw ).g;',
-    '	a.w = texture2D( blendTex, offset[ 1 ].xy ).a;',
+    	vec4 a;
+    	a.xz = texture2D( blendTex, texcoord ).xz;
+    	a.y = texture2D( blendTex, offset[ 1 ].zw ).g;
+    	a.w = texture2D( blendTex, offset[ 1 ].xy ).a;
 
     // Is there any blending weight with a value greater than 0.0?
-    '	if ( dot(a, vec4( 1.0, 1.0, 1.0, 1.0 )) < 1e-5 ) {',
-    '		return texture2D( colorTex, texcoord, 0.0 );',
-    '	} else {',
+    	if ( dot(a, vec4( 1.0, 1.0, 1.0, 1.0 )) < 1e-5 ) {
+    		return texture2D( colorTex, texcoord, 0.0 );
+    	} else {
     // Up to 4 lines can be crossing a pixel (one through each edge). We
     // favor blending by choosing the line with the maximum weight for each
     // direction:
-    '		vec2 offset;',
-    '		offset.x = a.a > a.b ? a.a : -a.b;', // left vs. right
-    '		offset.y = a.g > a.r ? -a.g : a.r;', // top vs. bottom // WebGL port note: Changed signs
+    		vec2 offset;
+    		offset.x = a.a > a.b ? a.a : -a.b; // left vs. right
+    		offset.y = a.g > a.r ? -a.g : a.r; // top vs. bottom // WebGL port note: Changed signs
 
     // Then we go in the direction that has the maximum weight:
-    '		if ( abs( offset.x ) > abs( offset.y )) {', // horizontal vs. vertical
-    '			offset.y = 0.0;',
-    '		} else {',
-    '			offset.x = 0.0;',
-    '		}',
+    		if ( abs( offset.x ) > abs( offset.y )) { // horizontal vs. vertical
+    			offset.y = 0.0;
+    		} else {
+    			offset.x = 0.0;
+    		}
 
     // Fetch the opposite color and lerp by hand:
-    '		vec4 C = texture2D( colorTex, texcoord, 0.0 );',
-    '		texcoord += sign( offset ) * resolution;',
-    '		vec4 Cop = texture2D( colorTex, texcoord, 0.0 );',
-    '		float s = abs( offset.x ) > abs( offset.y ) ? abs( offset.x ) : abs( offset.y );',
+    		vec4 C = texture2D( colorTex, texcoord, 0.0 );
+    		texcoord += sign( offset ) * resolution;
+    		vec4 Cop = texture2D( colorTex, texcoord, 0.0 );
+    		float s = abs( offset.x ) > abs( offset.y ) ? abs( offset.x ) : abs( offset.y );
 
     // WebGL port note: Added gamma correction
-    '		C.xyz = pow(C.xyz, vec3(2.2));',
-    '		Cop.xyz = pow(Cop.xyz, vec3(2.2));',
-    '		vec4 mixed = mix(C, Cop, s);',
-    '		mixed.xyz = pow(mixed.xyz, vec3(1.0 / 2.2));',
+    		C.xyz = pow(C.xyz, vec3(2.2));
+    		Cop.xyz = pow(Cop.xyz, vec3(2.2));
+    		vec4 mixed = mix(C, Cop, s);
+    		mixed.xyz = pow(mixed.xyz, vec3(1.0 / 2.2));
 
-    '		return mixed;',
-    '	}',
-    '}',
+    		return mixed;
+    	}
+    }
 
-    'void main() {',
+    void main() {
 
-    '	gl_FragColor = SMAANeighborhoodBlendingPS( vUv, vOffset, tColor, tDiffuse );',
+    	gl_FragColor = SMAANeighborhoodBlendingPS( vUv, vOffset, tColor, tDiffuse );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/SSAOShader.ts b/src/shaders/SSAOShader.ts
index 98475a18..e5d17aef 100644
--- a/src/shaders/SSAOShader.ts
+++ b/src/shaders/SSAOShader.ts
@@ -21,150 +21,150 @@ export const SSAOShader = {
     kernel: { value: null },
     cameraNear: { value: null },
     cameraFar: { value: null },
-    resolution: { value: new Vector2() },
-    cameraProjectionMatrix: { value: new Matrix4() },
-    cameraInverseProjectionMatrix: { value: new Matrix4() },
+    resolution: { value: /* @__PURE__ */ new Vector2() },
+    cameraProjectionMatrix: { value: /* @__PURE__ */ new Matrix4() },
+    cameraInverseProjectionMatrix: { value: /* @__PURE__ */ new Matrix4() },
     kernelRadius: { value: 8 },
     minDistance: { value: 0.005 },
     maxDistance: { value: 0.05 },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
+    	vUv = uv;
 
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform sampler2D tDiffuse;',
-    'uniform sampler2D tNormal;',
-    'uniform sampler2D tDepth;',
-    'uniform sampler2D tNoise;',
+  fragmentShader: /* glsl */ `
+    uniform sampler2D tDiffuse;
+    uniform sampler2D tNormal;
+    uniform sampler2D tDepth;
+    uniform sampler2D tNoise;
 
-    'uniform vec3 kernel[ KERNEL_SIZE ];',
+    uniform vec3 kernel[ KERNEL_SIZE ];
 
-    'uniform vec2 resolution;',
+    uniform vec2 resolution;
 
-    'uniform float cameraNear;',
-    'uniform float cameraFar;',
-    'uniform mat4 cameraProjectionMatrix;',
-    'uniform mat4 cameraInverseProjectionMatrix;',
+    uniform float cameraNear;
+    uniform float cameraFar;
+    uniform mat4 cameraProjectionMatrix;
+    uniform mat4 cameraInverseProjectionMatrix;
 
-    'uniform float kernelRadius;',
-    'uniform float minDistance;', // avoid artifacts caused by neighbour fragments with minimal depth difference
-    'uniform float maxDistance;', // avoid the influence of fragments which are too far away
+    uniform float kernelRadius;
+    uniform float minDistance; // avoid artifacts caused by neighbour fragments with minimal depth difference
+    uniform float maxDistance; // avoid the influence of fragments which are too far away
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    '#include <packing>',
+    #include <packing>
 
-    'float getDepth( const in vec2 screenPosition ) {',
+    float getDepth( const in vec2 screenPosition ) {
 
-    '	return texture2D( tDepth, screenPosition ).x;',
+    	return texture2D( tDepth, screenPosition ).x;
 
-    '}',
+    }
 
-    'float getLinearDepth( const in vec2 screenPosition ) {',
+    float getLinearDepth( const in vec2 screenPosition ) {
 
-    '	#if PERSPECTIVE_CAMERA == 1',
+    	#if PERSPECTIVE_CAMERA == 1
 
-    '		float fragCoordZ = texture2D( tDepth, screenPosition ).x;',
-    '		float viewZ = perspectiveDepthToViewZ( fragCoordZ, cameraNear, cameraFar );',
-    '		return viewZToOrthographicDepth( viewZ, cameraNear, cameraFar );',
+    		float fragCoordZ = texture2D( tDepth, screenPosition ).x;
+    		float viewZ = perspectiveDepthToViewZ( fragCoordZ, cameraNear, cameraFar );
+    		return viewZToOrthographicDepth( viewZ, cameraNear, cameraFar );
 
-    '	#else',
+    	#else
 
-    '		return texture2D( tDepth, screenPosition ).x;',
+    		return texture2D( tDepth, screenPosition ).x;
 
-    '	#endif',
+    	#endif
 
-    '}',
+    }
 
-    'float getViewZ( const in float depth ) {',
+    float getViewZ( const in float depth ) {
 
-    '	#if PERSPECTIVE_CAMERA == 1',
+    	#if PERSPECTIVE_CAMERA == 1
 
-    '		return perspectiveDepthToViewZ( depth, cameraNear, cameraFar );',
+    		return perspectiveDepthToViewZ( depth, cameraNear, cameraFar );
 
-    '	#else',
+    	#else
 
-    '		return orthographicDepthToViewZ( depth, cameraNear, cameraFar );',
+    		return orthographicDepthToViewZ( depth, cameraNear, cameraFar );
 
-    '	#endif',
+    	#endif
 
-    '}',
+    }
 
-    'vec3 getViewPosition( const in vec2 screenPosition, const in float depth, const in float viewZ ) {',
+    vec3 getViewPosition( const in vec2 screenPosition, const in float depth, const in float viewZ ) {
 
-    '	float clipW = cameraProjectionMatrix[2][3] * viewZ + cameraProjectionMatrix[3][3];',
+    	float clipW = cameraProjectionMatrix[2][3] * viewZ + cameraProjectionMatrix[3][3];
 
-    '	vec4 clipPosition = vec4( ( vec3( screenPosition, depth ) - 0.5 ) * 2.0, 1.0 );',
+    	vec4 clipPosition = vec4( ( vec3( screenPosition, depth ) - 0.5 ) * 2.0, 1.0 );
 
-    '	clipPosition *= clipW; // unprojection.',
+    	clipPosition *= clipW; // unprojection.
 
-    '	return ( cameraInverseProjectionMatrix * clipPosition ).xyz;',
+    	return ( cameraInverseProjectionMatrix * clipPosition ).xyz;
 
-    '}',
+    }
 
-    'vec3 getViewNormal( const in vec2 screenPosition ) {',
+    vec3 getViewNormal( const in vec2 screenPosition ) {
 
-    '	return unpackRGBToNormal( texture2D( tNormal, screenPosition ).xyz );',
+    	return unpackRGBToNormal( texture2D( tNormal, screenPosition ).xyz );
 
-    '}',
+    }
 
-    'void main() {',
+    void main() {
 
-    '	float depth = getDepth( vUv );',
-    '	float viewZ = getViewZ( depth );',
+    	float depth = getDepth( vUv );
+    	float viewZ = getViewZ( depth );
 
-    '	vec3 viewPosition = getViewPosition( vUv, depth, viewZ );',
-    '	vec3 viewNormal = getViewNormal( vUv );',
+    	vec3 viewPosition = getViewPosition( vUv, depth, viewZ );
+    	vec3 viewNormal = getViewNormal( vUv );
 
-    ' vec2 noiseScale = vec2( resolution.x / 4.0, resolution.y / 4.0 );',
-    '	vec3 random = texture2D( tNoise, vUv * noiseScale ).xyz;',
+     vec2 noiseScale = vec2( resolution.x / 4.0, resolution.y / 4.0 );
+    	vec3 random = texture2D( tNoise, vUv * noiseScale ).xyz;
 
     // compute matrix used to reorient a kernel vector
 
-    '	vec3 tangent = normalize( random - viewNormal * dot( random, viewNormal ) );',
-    '	vec3 bitangent = cross( viewNormal, tangent );',
-    '	mat3 kernelMatrix = mat3( tangent, bitangent, viewNormal );',
+    	vec3 tangent = normalize( random - viewNormal * dot( random, viewNormal ) );
+    	vec3 bitangent = cross( viewNormal, tangent );
+    	mat3 kernelMatrix = mat3( tangent, bitangent, viewNormal );
 
-    ' float occlusion = 0.0;',
+     float occlusion = 0.0;
 
-    ' for ( int i = 0; i < KERNEL_SIZE; i ++ ) {',
+     for ( int i = 0; i < KERNEL_SIZE; i ++ ) {
 
-    '		vec3 sampleVector = kernelMatrix * kernel[ i ];', // reorient sample vector in view space
-    '		vec3 samplePoint = viewPosition + ( sampleVector * kernelRadius );', // calculate sample point
+    		vec3 sampleVector = kernelMatrix * kernel[ i ]; // reorient sample vector in view space
+    		vec3 samplePoint = viewPosition + ( sampleVector * kernelRadius ); // calculate sample point
 
-    '		vec4 samplePointNDC = cameraProjectionMatrix * vec4( samplePoint, 1.0 );', // project point and calculate NDC
-    '		samplePointNDC /= samplePointNDC.w;',
+    		vec4 samplePointNDC = cameraProjectionMatrix * vec4( samplePoint, 1.0 ); // project point and calculate NDC
+    		samplePointNDC /= samplePointNDC.w;
 
-    '		vec2 samplePointUv = samplePointNDC.xy * 0.5 + 0.5;', // compute uv coordinates
+    		vec2 samplePointUv = samplePointNDC.xy * 0.5 + 0.5; // compute uv coordinates
 
-    '		float realDepth = getLinearDepth( samplePointUv );', // get linear depth from depth texture
-    '		float sampleDepth = viewZToOrthographicDepth( samplePoint.z, cameraNear, cameraFar );', // compute linear depth of the sample view Z value
-    '		float delta = sampleDepth - realDepth;',
+    		float realDepth = getLinearDepth( samplePointUv ); // get linear depth from depth texture
+    		float sampleDepth = viewZToOrthographicDepth( samplePoint.z, cameraNear, cameraFar ); // compute linear depth of the sample view Z value
+    		float delta = sampleDepth - realDepth;
 
-    '		if ( delta > minDistance && delta < maxDistance ) {', // if fragment is before sample point, increase occlusion
+    		if ( delta > minDistance && delta < maxDistance ) { // if fragment is before sample point, increase occlusion
 
-    '			occlusion += 1.0;',
+    			occlusion += 1.0;
 
-    '		}',
+    		}
 
-    '	}',
+    	}
 
-    '	occlusion = clamp( occlusion / float( KERNEL_SIZE ), 0.0, 1.0 );',
+    	occlusion = clamp( occlusion / float( KERNEL_SIZE ), 0.0, 1.0 );
 
-    '	gl_FragColor = vec4( vec3( 1.0 - occlusion ), 1.0 );',
+    	gl_FragColor = vec4( vec3( 1.0 - occlusion ), 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
 
 export const SSAODepthShader = {
@@ -178,94 +178,94 @@ export const SSAODepthShader = {
     cameraFar: { value: null },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform sampler2D tDepth;',
+  fragmentShader: /* glsl */ `
+    uniform sampler2D tDepth;
 
-    'uniform float cameraNear;',
-    'uniform float cameraFar;',
+    uniform float cameraNear;
+    uniform float cameraFar;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    '#include <packing>',
+    #include <packing>
 
-    'float getLinearDepth( const in vec2 screenPosition ) {',
+    float getLinearDepth( const in vec2 screenPosition ) {
 
-    '	#if PERSPECTIVE_CAMERA == 1',
+    	#if PERSPECTIVE_CAMERA == 1
 
-    '		float fragCoordZ = texture2D( tDepth, screenPosition ).x;',
-    '		float viewZ = perspectiveDepthToViewZ( fragCoordZ, cameraNear, cameraFar );',
-    '		return viewZToOrthographicDepth( viewZ, cameraNear, cameraFar );',
+    		float fragCoordZ = texture2D( tDepth, screenPosition ).x;
+    		float viewZ = perspectiveDepthToViewZ( fragCoordZ, cameraNear, cameraFar );
+    		return viewZToOrthographicDepth( viewZ, cameraNear, cameraFar );
 
-    '	#else',
+    	#else
 
-    '		return texture2D( tDepth, screenPosition ).x;',
+    		return texture2D( tDepth, screenPosition ).x;
 
-    '	#endif',
+    	#endif
 
-    '}',
+    }
 
-    'void main() {',
+    void main() {
 
-    '	float depth = getLinearDepth( vUv );',
-    '	gl_FragColor = vec4( vec3( 1.0 - depth ), 1.0 );',
+    	float depth = getLinearDepth( vUv );
+    	gl_FragColor = vec4( vec3( 1.0 - depth ), 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
 
 export const SSAOBlurShader = {
   uniforms: {
     tDiffuse: { value: null },
-    resolution: { value: new Vector2() },
+    resolution: { value: /* @__PURE__ */ new Vector2() },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform sampler2D tDiffuse;',
+  fragmentShader: /* glsl */ `
+    uniform sampler2D tDiffuse;
 
-    'uniform vec2 resolution;',
+    uniform vec2 resolution;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vec2 texelSize = ( 1.0 / resolution );',
-    '	float result = 0.0;',
+    	vec2 texelSize = ( 1.0 / resolution );
+    	float result = 0.0;
 
-    '	for ( int i = - 2; i <= 2; i ++ ) {',
+    	for ( int i = - 2; i <= 2; i ++ ) {
 
-    '		for ( int j = - 2; j <= 2; j ++ ) {',
+    		for ( int j = - 2; j <= 2; j ++ ) {
 
-    '			vec2 offset = ( vec2( float( i ), float( j ) ) ) * texelSize;',
-    '			result += texture2D( tDiffuse, vUv + offset ).r;',
+    			vec2 offset = ( vec2( float( i ), float( j ) ) ) * texelSize;
+    			result += texture2D( tDiffuse, vUv + offset ).r;
 
-    '		}',
+    		}
 
-    '	}',
+    	}
 
-    '	gl_FragColor = vec4( vec3( result / ( 5.0 * 5.0 ) ), 1.0 );',
+    	gl_FragColor = vec4( vec3( result / ( 5.0 * 5.0 ) ), 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/SSRShader.ts b/src/shaders/SSRShader.ts
index a212b977..fe073f1f 100644
--- a/src/shaders/SSRShader.ts
+++ b/src/shaders/SSRShader.ts
@@ -21,9 +21,9 @@ export const SSRShader = {
     tDepth: { value: null },
     cameraNear: { value: null },
     cameraFar: { value: null },
-    resolution: { value: new Vector2() },
-    cameraProjectionMatrix: { value: new Matrix4() },
-    cameraInverseProjectionMatrix: { value: new Matrix4() },
+    resolution: { value: /* @__PURE__ */ new Vector2() },
+    cameraProjectionMatrix: { value: /* @__PURE__ */ new Matrix4() },
+    cameraInverseProjectionMatrix: { value: /* @__PURE__ */ new Matrix4() },
     opacity: { value: 0.5 },
     maxDistance: { value: 180 },
     cameraRange: { value: 0 },
@@ -278,7 +278,7 @@ export const SSRDepthShader = {
 export const SSRBlurShader = {
   uniforms: {
     tDiffuse: { value: null },
-    resolution: { value: new Vector2() },
+    resolution: { value: /* @__PURE__ */ new Vector2() },
     opacity: { value: 0.5 },
   },
 
diff --git a/src/shaders/SepiaShader.ts b/src/shaders/SepiaShader.ts
index fdd9f8d1..3048d490 100644
--- a/src/shaders/SepiaShader.ts
+++ b/src/shaders/SepiaShader.ts
@@ -10,35 +10,35 @@ export const SepiaShader = {
     amount: { value: 1.0 },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform float amount;',
+  fragmentShader: /* glsl */ `
+    uniform float amount;
 
-    'uniform sampler2D tDiffuse;',
+    uniform sampler2D tDiffuse;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vec4 color = texture2D( tDiffuse, vUv );',
-    '	vec3 c = color.rgb;',
+    	vec4 color = texture2D( tDiffuse, vUv );
+    	vec3 c = color.rgb;
 
-    '	color.r = dot( c, vec3( 1.0 - 0.607 * amount, 0.769 * amount, 0.189 * amount ) );',
-    '	color.g = dot( c, vec3( 0.349 * amount, 1.0 - 0.314 * amount, 0.168 * amount ) );',
-    '	color.b = dot( c, vec3( 0.272 * amount, 0.534 * amount, 1.0 - 0.869 * amount ) );',
+    	color.r = dot( c, vec3( 1.0 - 0.607 * amount, 0.769 * amount, 0.189 * amount ) );
+    	color.g = dot( c, vec3( 0.349 * amount, 1.0 - 0.314 * amount, 0.168 * amount ) );
+    	color.b = dot( c, vec3( 0.272 * amount, 0.534 * amount, 1.0 - 0.869 * amount ) );
 
-    '	gl_FragColor = vec4( min( vec3( 1.0 ), color.rgb ), color.a );',
+    	gl_FragColor = vec4( min( vec3( 1.0 ), color.rgb ), color.a );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/SobelOperatorShader.ts b/src/shaders/SobelOperatorShader.ts
index 2401781f..f88f3601 100644
--- a/src/shaders/SobelOperatorShader.ts
+++ b/src/shaders/SobelOperatorShader.ts
@@ -10,73 +10,73 @@ import { Vector2 } from 'three'
 export const SobelOperatorShader = {
   uniforms: {
     tDiffuse: { value: null },
-    resolution: { value: new Vector2() },
+    resolution: { value: /* @__PURE__ */ new Vector2() },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
+    	vUv = uv;
 
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform sampler2D tDiffuse;',
-    'uniform vec2 resolution;',
-    'varying vec2 vUv;',
+  fragmentShader: /* glsl */ `
+    uniform sampler2D tDiffuse;
+    uniform vec2 resolution;
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vec2 texel = vec2( 1.0 / resolution.x, 1.0 / resolution.y );',
+    	vec2 texel = vec2( 1.0 / resolution.x, 1.0 / resolution.y );
 
     // kernel definition (in glsl matrices are filled in column-major order)
 
-    '	const mat3 Gx = mat3( -1, -2, -1, 0, 0, 0, 1, 2, 1 );', // x direction kernel
-    '	const mat3 Gy = mat3( -1, 0, 1, -2, 0, 2, -1, 0, 1 );', // y direction kernel
+    	const mat3 Gx = mat3( -1, -2, -1, 0, 0, 0, 1, 2, 1 ); // x direction kernel
+    	const mat3 Gy = mat3( -1, 0, 1, -2, 0, 2, -1, 0, 1 ); // y direction kernel
 
     // fetch the 3x3 neighbourhood of a fragment
 
     // first column
 
-    '	float tx0y0 = texture2D( tDiffuse, vUv + texel * vec2( -1, -1 ) ).r;',
-    '	float tx0y1 = texture2D( tDiffuse, vUv + texel * vec2( -1,  0 ) ).r;',
-    '	float tx0y2 = texture2D( tDiffuse, vUv + texel * vec2( -1,  1 ) ).r;',
+    	float tx0y0 = texture2D( tDiffuse, vUv + texel * vec2( -1, -1 ) ).r;
+    	float tx0y1 = texture2D( tDiffuse, vUv + texel * vec2( -1,  0 ) ).r;
+    	float tx0y2 = texture2D( tDiffuse, vUv + texel * vec2( -1,  1 ) ).r;
 
     // second column
 
-    '	float tx1y0 = texture2D( tDiffuse, vUv + texel * vec2(  0, -1 ) ).r;',
-    '	float tx1y1 = texture2D( tDiffuse, vUv + texel * vec2(  0,  0 ) ).r;',
-    '	float tx1y2 = texture2D( tDiffuse, vUv + texel * vec2(  0,  1 ) ).r;',
+    	float tx1y0 = texture2D( tDiffuse, vUv + texel * vec2(  0, -1 ) ).r;
+    	float tx1y1 = texture2D( tDiffuse, vUv + texel * vec2(  0,  0 ) ).r;
+    	float tx1y2 = texture2D( tDiffuse, vUv + texel * vec2(  0,  1 ) ).r;
 
     // third column
 
-    '	float tx2y0 = texture2D( tDiffuse, vUv + texel * vec2(  1, -1 ) ).r;',
-    '	float tx2y1 = texture2D( tDiffuse, vUv + texel * vec2(  1,  0 ) ).r;',
-    '	float tx2y2 = texture2D( tDiffuse, vUv + texel * vec2(  1,  1 ) ).r;',
+    	float tx2y0 = texture2D( tDiffuse, vUv + texel * vec2(  1, -1 ) ).r;
+    	float tx2y1 = texture2D( tDiffuse, vUv + texel * vec2(  1,  0 ) ).r;
+    	float tx2y2 = texture2D( tDiffuse, vUv + texel * vec2(  1,  1 ) ).r;
 
     // gradient value in x direction
 
-    '	float valueGx = Gx[0][0] * tx0y0 + Gx[1][0] * tx1y0 + Gx[2][0] * tx2y0 + ',
-    '		Gx[0][1] * tx0y1 + Gx[1][1] * tx1y1 + Gx[2][1] * tx2y1 + ',
-    '		Gx[0][2] * tx0y2 + Gx[1][2] * tx1y2 + Gx[2][2] * tx2y2; ',
+    	float valueGx = Gx[0][0] * tx0y0 + Gx[1][0] * tx1y0 + Gx[2][0] * tx2y0 + 
+    		Gx[0][1] * tx0y1 + Gx[1][1] * tx1y1 + Gx[2][1] * tx2y1 + 
+    		Gx[0][2] * tx0y2 + Gx[1][2] * tx1y2 + Gx[2][2] * tx2y2; 
 
     // gradient value in y direction
 
-    '	float valueGy = Gy[0][0] * tx0y0 + Gy[1][0] * tx1y0 + Gy[2][0] * tx2y0 + ',
-    '		Gy[0][1] * tx0y1 + Gy[1][1] * tx1y1 + Gy[2][1] * tx2y1 + ',
-    '		Gy[0][2] * tx0y2 + Gy[1][2] * tx1y2 + Gy[2][2] * tx2y2; ',
+    	float valueGy = Gy[0][0] * tx0y0 + Gy[1][0] * tx1y0 + Gy[2][0] * tx2y0 + 
+    		Gy[0][1] * tx0y1 + Gy[1][1] * tx1y1 + Gy[2][1] * tx2y1 + 
+    		Gy[0][2] * tx0y2 + Gy[1][2] * tx1y2 + Gy[2][2] * tx2y2; 
 
     // magnitute of the total gradient
 
-    '	float G = sqrt( ( valueGx * valueGx ) + ( valueGy * valueGy ) );',
+    	float G = sqrt( ( valueGx * valueGx ) + ( valueGy * valueGy ) );
 
-    '	gl_FragColor = vec4( vec3( G ), 1 );',
+    	gl_FragColor = vec4( vec3( G ), 1 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/TechnicolorShader.ts b/src/shaders/TechnicolorShader.ts
index 91799c01..076bb5d0 100644
--- a/src/shaders/TechnicolorShader.ts
+++ b/src/shaders/TechnicolorShader.ts
@@ -10,28 +10,28 @@ export const TechnicolorShader = {
     tDiffuse: { value: null },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform sampler2D tDiffuse;',
-    'varying vec2 vUv;',
+  fragmentShader: /* glsl */ `
+    uniform sampler2D tDiffuse;
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vec4 tex = texture2D( tDiffuse, vec2( vUv.x, vUv.y ) );',
-    '	vec4 newTex = vec4(tex.r, (tex.g + tex.b) * .5, (tex.g + tex.b) * .5, 1.0);',
+    	vec4 tex = texture2D( tDiffuse, vec2( vUv.x, vUv.y ) );
+    	vec4 newTex = vec4(tex.r, (tex.g + tex.b) * .5, (tex.g + tex.b) * .5, 1.0);
 
-    '	gl_FragColor = newTex;',
+    	gl_FragColor = newTex;
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/ToneMapShader.ts b/src/shaders/ToneMapShader.ts
index d0c52936..c167f980 100644
--- a/src/shaders/ToneMapShader.ts
+++ b/src/shaders/ToneMapShader.ts
@@ -12,57 +12,57 @@ export const ToneMapShader = {
     middleGrey: { value: 0.6 },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    '#include <common>',
+  fragmentShader: /* glsl */ `
+    #include <common>
 
-    'uniform sampler2D tDiffuse;',
+    uniform sampler2D tDiffuse;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'uniform float middleGrey;',
-    'uniform float minLuminance;',
-    'uniform float maxLuminance;',
-    '#ifdef ADAPTED_LUMINANCE',
-    '	uniform sampler2D luminanceMap;',
-    '#else',
-    '	uniform float averageLuminance;',
-    '#endif',
+    uniform float middleGrey;
+    uniform float minLuminance;
+    uniform float maxLuminance;
+    #ifdef ADAPTED_LUMINANCE
+    	uniform sampler2D luminanceMap;
+    #else
+    	uniform float averageLuminance;
+    #endif
 
-    'vec3 ToneMap( vec3 vColor ) {',
-    '	#ifdef ADAPTED_LUMINANCE',
+    vec3 ToneMap( vec3 vColor ) {
+    	#ifdef ADAPTED_LUMINANCE
     // Get the calculated average luminance
-    '		float fLumAvg = texture2D(luminanceMap, vec2(0.5, 0.5)).r;',
-    '	#else',
-    '		float fLumAvg = averageLuminance;',
-    '	#endif',
+    		float fLumAvg = texture2D(luminanceMap, vec2(0.5, 0.5)).r;
+    	#else
+    		float fLumAvg = averageLuminance;
+    	#endif
 
     // Calculate the luminance of the current pixel
-    '	float fLumPixel = linearToRelativeLuminance( vColor );',
+    	float fLumPixel = linearToRelativeLuminance( vColor );
 
     // Apply the modified operator (Eq. 4)
-    '	float fLumScaled = (fLumPixel * middleGrey) / max( minLuminance, fLumAvg );',
+    	float fLumScaled = (fLumPixel * middleGrey) / max( minLuminance, fLumAvg );
 
-    '	float fLumCompressed = (fLumScaled * (1.0 + (fLumScaled / (maxLuminance * maxLuminance)))) / (1.0 + fLumScaled);',
-    '	return fLumCompressed * vColor;',
-    '}',
+    	float fLumCompressed = (fLumScaled * (1.0 + (fLumScaled / (maxLuminance * maxLuminance)))) / (1.0 + fLumScaled);
+    	return fLumCompressed * vColor;
+    }
 
-    'void main() {',
+    void main() {
 
-    '	vec4 texel = texture2D( tDiffuse, vUv );',
+    	vec4 texel = texture2D( tDiffuse, vUv );
 
-    '	gl_FragColor = vec4( ToneMap( texel.xyz ), texel.w );',
+    	gl_FragColor = vec4( ToneMap( texel.xyz ), texel.w );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/ToonShader.ts b/src/shaders/ToonShader.ts
index d541f81c..7909c631 100644
--- a/src/shaders/ToonShader.ts
+++ b/src/shaders/ToonShader.ts
@@ -11,287 +11,287 @@ import { Color, Vector3 } from 'three'
 
 export const ToonShader1 = {
   uniforms: {
-    uDirLightPos: { value: new Vector3() },
-    uDirLightColor: { value: new Color(0xeeeeee) },
+    uDirLightPos: { value: /* @__PURE__ */ new Vector3() },
+    uDirLightColor: { value: /* @__PURE__ */ new Color(0xeeeeee) },
 
-    uAmbientLightColor: { value: new Color(0x050505) },
+    uAmbientLightColor: { value: /* @__PURE__ */ new Color(0x050505) },
 
-    uBaseColor: { value: new Color(0xffffff) },
+    uBaseColor: { value: /* @__PURE__ */ new Color(0xffffff) },
   },
 
-  vertexShader: [
-    'varying vec3 vNormal;',
-    'varying vec3 vRefract;',
+  vertexShader: /* glsl */ `
+    varying vec3 vNormal;
+    varying vec3 vRefract;
 
-    'void main() {',
+    void main() {
 
-    '	vec4 worldPosition = modelMatrix * vec4( position, 1.0 );',
-    '	vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );',
-    '	vec3 worldNormal = normalize ( mat3( modelMatrix[0].xyz, modelMatrix[1].xyz, modelMatrix[2].xyz ) * normal );',
+    	vec4 worldPosition = modelMatrix * vec4( position, 1.0 );
+    	vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );
+    	vec3 worldNormal = normalize ( mat3( modelMatrix[0].xyz, modelMatrix[1].xyz, modelMatrix[2].xyz ) * normal );
 
-    '	vNormal = normalize( normalMatrix * normal );',
+    	vNormal = normalize( normalMatrix * normal );
 
-    '	vec3 I = worldPosition.xyz - cameraPosition;',
-    '	vRefract = refract( normalize( I ), worldNormal, 1.02 );',
+    	vec3 I = worldPosition.xyz - cameraPosition;
+    	vRefract = refract( normalize( I ), worldNormal, 1.02 );
 
-    '	gl_Position = projectionMatrix * mvPosition;',
+    	gl_Position = projectionMatrix * mvPosition;
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform vec3 uBaseColor;',
+  fragmentShader: /* glsl */ `
+    uniform vec3 uBaseColor;
 
-    'uniform vec3 uDirLightPos;',
-    'uniform vec3 uDirLightColor;',
+    uniform vec3 uDirLightPos;
+    uniform vec3 uDirLightColor;
 
-    'uniform vec3 uAmbientLightColor;',
+    uniform vec3 uAmbientLightColor;
 
-    'varying vec3 vNormal;',
+    varying vec3 vNormal;
 
-    'varying vec3 vRefract;',
+    varying vec3 vRefract;
 
-    'void main() {',
+    void main() {
 
-    '	float directionalLightWeighting = max( dot( normalize( vNormal ), uDirLightPos ), 0.0);',
-    '	vec3 lightWeighting = uAmbientLightColor + uDirLightColor * directionalLightWeighting;',
+    	float directionalLightWeighting = max( dot( normalize( vNormal ), uDirLightPos ), 0.0);
+    	vec3 lightWeighting = uAmbientLightColor + uDirLightColor * directionalLightWeighting;
 
-    '	float intensity = smoothstep( - 0.5, 1.0, pow( length(lightWeighting), 20.0 ) );',
-    '	intensity += length(lightWeighting) * 0.2;',
+    	float intensity = smoothstep( - 0.5, 1.0, pow( length(lightWeighting), 20.0 ) );
+    	intensity += length(lightWeighting) * 0.2;
 
-    '	float cameraWeighting = dot( normalize( vNormal ), vRefract );',
-    '	intensity += pow( 1.0 - length( cameraWeighting ), 6.0 );',
-    '	intensity = intensity * 0.2 + 0.3;',
+    	float cameraWeighting = dot( normalize( vNormal ), vRefract );
+    	intensity += pow( 1.0 - length( cameraWeighting ), 6.0 );
+    	intensity = intensity * 0.2 + 0.3;
 
-    '	if ( intensity < 0.50 ) {',
+    	if ( intensity < 0.50 ) {
 
-    '		gl_FragColor = vec4( 2.0 * intensity * uBaseColor, 1.0 );',
+    		gl_FragColor = vec4( 2.0 * intensity * uBaseColor, 1.0 );
 
-    '	} else {',
+    	} else {
 
-    '		gl_FragColor = vec4( 1.0 - 2.0 * ( 1.0 - intensity ) * ( 1.0 - uBaseColor ), 1.0 );',
+    		gl_FragColor = vec4( 1.0 - 2.0 * ( 1.0 - intensity ) * ( 1.0 - uBaseColor ), 1.0 );
 
-    '}',
+    }
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
 
 export const ToonShader2 = {
   uniforms: {
-    uDirLightPos: { value: new Vector3() },
-    uDirLightColor: { value: new Color(0xeeeeee) },
+    uDirLightPos: { value: /* @__PURE__ */ new Vector3() },
+    uDirLightColor: { value: /* @__PURE__ */ new Color(0xeeeeee) },
 
-    uAmbientLightColor: { value: new Color(0x050505) },
+    uAmbientLightColor: { value: /* @__PURE__ */ new Color(0x050505) },
 
-    uBaseColor: { value: new Color(0xeeeeee) },
-    uLineColor1: { value: new Color(0x808080) },
-    uLineColor2: { value: new Color(0x000000) },
-    uLineColor3: { value: new Color(0x000000) },
-    uLineColor4: { value: new Color(0x000000) },
+    uBaseColor: { value: /* @__PURE__ */ new Color(0xeeeeee) },
+    uLineColor1: { value: /* @__PURE__ */ new Color(0x808080) },
+    uLineColor2: { value: /* @__PURE__ */ new Color(0x000000) },
+    uLineColor3: { value: /* @__PURE__ */ new Color(0x000000) },
+    uLineColor4: { value: /* @__PURE__ */ new Color(0x000000) },
   },
 
-  vertexShader: [
-    'varying vec3 vNormal;',
+  vertexShader: /* glsl */ `
+    varying vec3 vNormal;
 
-    'void main() {',
+    void main() {
 
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
-    '	vNormal = normalize( normalMatrix * normal );',
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    	vNormal = normalize( normalMatrix * normal );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform vec3 uBaseColor;',
-    'uniform vec3 uLineColor1;',
-    'uniform vec3 uLineColor2;',
-    'uniform vec3 uLineColor3;',
-    'uniform vec3 uLineColor4;',
+  fragmentShader: /* glsl */ `
+    uniform vec3 uBaseColor;
+    uniform vec3 uLineColor1;
+    uniform vec3 uLineColor2;
+    uniform vec3 uLineColor3;
+    uniform vec3 uLineColor4;
 
-    'uniform vec3 uDirLightPos;',
-    'uniform vec3 uDirLightColor;',
+    uniform vec3 uDirLightPos;
+    uniform vec3 uDirLightColor;
 
-    'uniform vec3 uAmbientLightColor;',
+    uniform vec3 uAmbientLightColor;
 
-    'varying vec3 vNormal;',
+    varying vec3 vNormal;
 
-    'void main() {',
+    void main() {
 
-    '	float camera = max( dot( normalize( vNormal ), vec3( 0.0, 0.0, 1.0 ) ), 0.4);',
-    '	float light = max( dot( normalize( vNormal ), uDirLightPos ), 0.0);',
+    	float camera = max( dot( normalize( vNormal ), vec3( 0.0, 0.0, 1.0 ) ), 0.4);
+    	float light = max( dot( normalize( vNormal ), uDirLightPos ), 0.0);
 
-    '	gl_FragColor = vec4( uBaseColor, 1.0 );',
+    	gl_FragColor = vec4( uBaseColor, 1.0 );
 
-    '	if ( length(uAmbientLightColor + uDirLightColor * light) < 1.00 ) {',
+    	if ( length(uAmbientLightColor + uDirLightColor * light) < 1.00 ) {
 
-    '		gl_FragColor *= vec4( uLineColor1, 1.0 );',
+    		gl_FragColor *= vec4( uLineColor1, 1.0 );
 
-    '	}',
+    	}
 
-    '	if ( length(uAmbientLightColor + uDirLightColor * camera) < 0.50 ) {',
+    	if ( length(uAmbientLightColor + uDirLightColor * camera) < 0.50 ) {
 
-    '		gl_FragColor *= vec4( uLineColor2, 1.0 );',
+    		gl_FragColor *= vec4( uLineColor2, 1.0 );
 
-    '	}',
+    	}
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
 
 export const ToonShaderHatching = {
   uniforms: {
-    uDirLightPos: { value: new Vector3() },
-    uDirLightColor: { value: new Color(0xeeeeee) },
+    uDirLightPos: { value: /* @__PURE__ */ new Vector3() },
+    uDirLightColor: { value: /* @__PURE__ */ new Color(0xeeeeee) },
 
-    uAmbientLightColor: { value: new Color(0x050505) },
+    uAmbientLightColor: { value: /* @__PURE__ */ new Color(0x050505) },
 
-    uBaseColor: { value: new Color(0xffffff) },
-    uLineColor1: { value: new Color(0x000000) },
-    uLineColor2: { value: new Color(0x000000) },
-    uLineColor3: { value: new Color(0x000000) },
-    uLineColor4: { value: new Color(0x000000) },
+    uBaseColor: { value: /* @__PURE__ */ new Color(0xffffff) },
+    uLineColor1: { value: /* @__PURE__ */ new Color(0x000000) },
+    uLineColor2: { value: /* @__PURE__ */ new Color(0x000000) },
+    uLineColor3: { value: /* @__PURE__ */ new Color(0x000000) },
+    uLineColor4: { value: /* @__PURE__ */ new Color(0x000000) },
   },
 
-  vertexShader: [
-    'varying vec3 vNormal;',
+  vertexShader: /* glsl */ `
+    varying vec3 vNormal;
 
-    'void main() {',
+    void main() {
 
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
-    '	vNormal = normalize( normalMatrix * normal );',
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    	vNormal = normalize( normalMatrix * normal );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform vec3 uBaseColor;',
-    'uniform vec3 uLineColor1;',
-    'uniform vec3 uLineColor2;',
-    'uniform vec3 uLineColor3;',
-    'uniform vec3 uLineColor4;',
+  fragmentShader: /* glsl */ `
+    uniform vec3 uBaseColor;
+    uniform vec3 uLineColor1;
+    uniform vec3 uLineColor2;
+    uniform vec3 uLineColor3;
+    uniform vec3 uLineColor4;
 
-    'uniform vec3 uDirLightPos;',
-    'uniform vec3 uDirLightColor;',
+    uniform vec3 uDirLightPos;
+    uniform vec3 uDirLightColor;
 
-    'uniform vec3 uAmbientLightColor;',
+    uniform vec3 uAmbientLightColor;
 
-    'varying vec3 vNormal;',
+    varying vec3 vNormal;
 
-    'void main() {',
+    void main() {
 
-    '	float directionalLightWeighting = max( dot( normalize(vNormal), uDirLightPos ), 0.0);',
-    '	vec3 lightWeighting = uAmbientLightColor + uDirLightColor * directionalLightWeighting;',
+    	float directionalLightWeighting = max( dot( normalize(vNormal), uDirLightPos ), 0.0);
+    	vec3 lightWeighting = uAmbientLightColor + uDirLightColor * directionalLightWeighting;
 
-    '	gl_FragColor = vec4( uBaseColor, 1.0 );',
+    	gl_FragColor = vec4( uBaseColor, 1.0 );
 
-    '	if ( length(lightWeighting) < 1.00 ) {',
+    	if ( length(lightWeighting) < 1.00 ) {
 
-    '		if ( mod(gl_FragCoord.x + gl_FragCoord.y, 10.0) == 0.0) {',
+    		if ( mod(gl_FragCoord.x + gl_FragCoord.y, 10.0) == 0.0) {
 
-    '			gl_FragColor = vec4( uLineColor1, 1.0 );',
+    			gl_FragColor = vec4( uLineColor1, 1.0 );
 
-    '		}',
+    		}
 
-    '	}',
+    	}
 
-    '	if ( length(lightWeighting) < 0.75 ) {',
+    	if ( length(lightWeighting) < 0.75 ) {
 
-    '		if (mod(gl_FragCoord.x - gl_FragCoord.y, 10.0) == 0.0) {',
+    		if (mod(gl_FragCoord.x - gl_FragCoord.y, 10.0) == 0.0) {
 
-    '			gl_FragColor = vec4( uLineColor2, 1.0 );',
+    			gl_FragColor = vec4( uLineColor2, 1.0 );
 
-    '		}',
+    		}
 
-    '	}',
+    	}
 
-    '	if ( length(lightWeighting) < 0.50 ) {',
+    	if ( length(lightWeighting) < 0.50 ) {
 
-    '		if (mod(gl_FragCoord.x + gl_FragCoord.y - 5.0, 10.0) == 0.0) {',
+    		if (mod(gl_FragCoord.x + gl_FragCoord.y - 5.0, 10.0) == 0.0) {
 
-    '			gl_FragColor = vec4( uLineColor3, 1.0 );',
+    			gl_FragColor = vec4( uLineColor3, 1.0 );
 
-    '		}',
+    		}
 
-    '	}',
+    	}
 
-    '	if ( length(lightWeighting) < 0.3465 ) {',
+    	if ( length(lightWeighting) < 0.3465 ) {
 
-    '		if (mod(gl_FragCoord.x - gl_FragCoord.y - 5.0, 10.0) == 0.0) {',
+    		if (mod(gl_FragCoord.x - gl_FragCoord.y - 5.0, 10.0) == 0.0) {
 
-    '			gl_FragColor = vec4( uLineColor4, 1.0 );',
+    			gl_FragColor = vec4( uLineColor4, 1.0 );
 
-    '	}',
+    	}
 
-    '	}',
+    	}
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
 
 export const ToonShaderDotted = {
   uniforms: {
-    uDirLightPos: { value: new Vector3() },
-    uDirLightColor: { value: new Color(0xeeeeee) },
+    uDirLightPos: { value: /* @__PURE__ */ new Vector3() },
+    uDirLightColor: { value: /* @__PURE__ */ new Color(0xeeeeee) },
 
-    uAmbientLightColor: { value: new Color(0x050505) },
+    uAmbientLightColor: { value: /* @__PURE__ */ new Color(0x050505) },
 
-    uBaseColor: { value: new Color(0xffffff) },
-    uLineColor1: { value: new Color(0x000000) },
+    uBaseColor: { value: /* @__PURE__ */ new Color(0xffffff) },
+    uLineColor1: { value: /* @__PURE__ */ new Color(0x000000) },
   },
 
-  vertexShader: [
-    'varying vec3 vNormal;',
+  vertexShader: /* glsl */ `
+    varying vec3 vNormal;
 
-    'void main() {',
+    void main() {
 
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
-    '	vNormal = normalize( normalMatrix * normal );',
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    	vNormal = normalize( normalMatrix * normal );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform vec3 uBaseColor;',
-    'uniform vec3 uLineColor1;',
-    'uniform vec3 uLineColor2;',
-    'uniform vec3 uLineColor3;',
-    'uniform vec3 uLineColor4;',
+  fragmentShader: /* glsl */ `
+    uniform vec3 uBaseColor;
+    uniform vec3 uLineColor1;
+    uniform vec3 uLineColor2;
+    uniform vec3 uLineColor3;
+    uniform vec3 uLineColor4;
 
-    'uniform vec3 uDirLightPos;',
-    'uniform vec3 uDirLightColor;',
+    uniform vec3 uDirLightPos;
+    uniform vec3 uDirLightColor;
 
-    'uniform vec3 uAmbientLightColor;',
+    uniform vec3 uAmbientLightColor;
 
-    'varying vec3 vNormal;',
+    varying vec3 vNormal;
 
-    'void main() {',
+    void main() {
 
-    'float directionalLightWeighting = max( dot( normalize(vNormal), uDirLightPos ), 0.0);',
-    'vec3 lightWeighting = uAmbientLightColor + uDirLightColor * directionalLightWeighting;',
+    float directionalLightWeighting = max( dot( normalize(vNormal), uDirLightPos ), 0.0);
+    vec3 lightWeighting = uAmbientLightColor + uDirLightColor * directionalLightWeighting;
 
-    'gl_FragColor = vec4( uBaseColor, 1.0 );',
+    gl_FragColor = vec4( uBaseColor, 1.0 );
 
-    'if ( length(lightWeighting) < 1.00 ) {',
+    if ( length(lightWeighting) < 1.00 ) {
 
-    '		if ( ( mod(gl_FragCoord.x, 4.001) + mod(gl_FragCoord.y, 4.0) ) > 6.00 ) {',
+    		if ( ( mod(gl_FragCoord.x, 4.001) + mod(gl_FragCoord.y, 4.0) ) > 6.00 ) {
 
-    '			gl_FragColor = vec4( uLineColor1, 1.0 );',
+    			gl_FragColor = vec4( uLineColor1, 1.0 );
 
-    '		}',
+    		}
 
-    '	}',
+    	}
 
-    '	if ( length(lightWeighting) < 0.50 ) {',
+    	if ( length(lightWeighting) < 0.50 ) {
 
-    '		if ( ( mod(gl_FragCoord.x + 2.0, 4.001) + mod(gl_FragCoord.y + 2.0, 4.0) ) > 6.00 ) {',
+    		if ( ( mod(gl_FragCoord.x + 2.0, 4.001) + mod(gl_FragCoord.y + 2.0, 4.0) ) > 6.00 ) {
 
-    '			gl_FragColor = vec4( uLineColor1, 1.0 );',
+    			gl_FragColor = vec4( uLineColor1, 1.0 );
 
-    '		}',
+    		}
 
-    '	}',
+    	}
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/TriangleBlurShader.ts b/src/shaders/TriangleBlurShader.ts
index e24c0838..da98a712 100644
--- a/src/shaders/TriangleBlurShader.ts
+++ b/src/shaders/TriangleBlurShader.ts
@@ -13,52 +13,52 @@ import { Vector2 } from 'three'
 export const TriangleBlurShader = {
   uniforms: {
     texture: { value: null },
-    delta: { value: new Vector2(1, 1) },
+    delta: { value: /* @__PURE__ */ new Vector2(1, 1) },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    '#include <common>',
+  fragmentShader: /* glsl */ `
+    #include <common>
 
-    '#define ITERATIONS 10.0',
+    #define ITERATIONS 10.0
 
-    'uniform sampler2D texture;',
-    'uniform vec2 delta;',
+    uniform sampler2D texture;
+    uniform vec2 delta;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vec4 color = vec4( 0.0 );',
+    	vec4 color = vec4( 0.0 );
 
-    '	float total = 0.0;',
+    	float total = 0.0;
 
     // randomize the lookup values to hide the fixed number of samples
 
-    '	float offset = rand( vUv );',
+    	float offset = rand( vUv );
 
-    '	for ( float t = -ITERATIONS; t <= ITERATIONS; t ++ ) {',
+    	for ( float t = -ITERATIONS; t <= ITERATIONS; t ++ ) {
 
-    '		float percent = ( t + offset - 0.5 ) / ITERATIONS;',
-    '		float weight = 1.0 - abs( percent );',
+    		float percent = ( t + offset - 0.5 ) / ITERATIONS;
+    		float weight = 1.0 - abs( percent );
 
-    '		color += texture2D( texture, vUv + delta * percent ) * weight;',
-    '		total += weight;',
+    		color += texture2D( texture, vUv + delta * percent ) * weight;
+    		total += weight;
 
-    '	}',
+    	}
 
-    '	gl_FragColor = color / total;',
+    	gl_FragColor = color / total;
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/UnpackDepthRGBAShader.ts b/src/shaders/UnpackDepthRGBAShader.ts
index 28a43b09..dcc16d4e 100644
--- a/src/shaders/UnpackDepthRGBAShader.ts
+++ b/src/shaders/UnpackDepthRGBAShader.ts
@@ -9,31 +9,31 @@ export const UnpackDepthRGBAShader = {
     opacity: { value: 1.0 },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform float opacity;',
+  fragmentShader: /* glsl */ `
+    uniform float opacity;
 
-    'uniform sampler2D tDiffuse;',
+    uniform sampler2D tDiffuse;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    '#include <packing>',
+    #include <packing>
 
-    'void main() {',
+    void main() {
 
-    '	float depth = 1.0 - unpackRGBAToDepth( texture2D( tDiffuse, vUv ) );',
-    '	gl_FragColor = vec4( vec3( depth ), opacity );',
+    	float depth = 1.0 - unpackRGBAToDepth( texture2D( tDiffuse, vUv ) );
+    	gl_FragColor = vec4( vec3( depth ), opacity );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/VerticalTiltShiftShader.ts b/src/shaders/VerticalTiltShiftShader.ts
index bb237b0d..47fd6a0d 100644
--- a/src/shaders/VerticalTiltShiftShader.ts
+++ b/src/shaders/VerticalTiltShiftShader.ts
@@ -14,42 +14,42 @@ export const VerticalTiltShiftShader = {
     r: { value: 0.35 },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform sampler2D tDiffuse;',
-    'uniform float v;',
-    'uniform float r;',
+  fragmentShader: /* glsl */ `
+    uniform sampler2D tDiffuse;
+    uniform float v;
+    uniform float r;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vec4 sum = vec4( 0.0 );',
+    	vec4 sum = vec4( 0.0 );
 
-    '	float vv = v * abs( r - vUv.y );',
+    	float vv = v * abs( r - vUv.y );
 
-    '	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 4.0 * vv ) ) * 0.051;',
-    '	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 3.0 * vv ) ) * 0.0918;',
-    '	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 2.0 * vv ) ) * 0.12245;',
-    '	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 1.0 * vv ) ) * 0.1531;',
-    '	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y ) ) * 0.1633;',
-    '	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 1.0 * vv ) ) * 0.1531;',
-    '	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 2.0 * vv ) ) * 0.12245;',
-    '	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 3.0 * vv ) ) * 0.0918;',
-    '	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 4.0 * vv ) ) * 0.051;',
+    	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 4.0 * vv ) ) * 0.051;
+    	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 3.0 * vv ) ) * 0.0918;
+    	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 2.0 * vv ) ) * 0.12245;
+    	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 1.0 * vv ) ) * 0.1531;
+    	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y ) ) * 0.1633;
+    	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 1.0 * vv ) ) * 0.1531;
+    	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 2.0 * vv ) ) * 0.12245;
+    	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 3.0 * vv ) ) * 0.0918;
+    	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 4.0 * vv ) ) * 0.051;
 
-    '	gl_FragColor = sum;',
+    	gl_FragColor = sum;
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/VignetteShader.ts b/src/shaders/VignetteShader.ts
index 756478e2..e3e9b30f 100644
--- a/src/shaders/VignetteShader.ts
+++ b/src/shaders/VignetteShader.ts
@@ -11,32 +11,32 @@ export const VignetteShader = {
     darkness: { value: 1.0 },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform float offset;',
-    'uniform float darkness;',
+  fragmentShader: /* glsl */ `
+    uniform float offset;
+    uniform float darkness;
 
-    'uniform sampler2D tDiffuse;',
+    uniform sampler2D tDiffuse;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    // Eskil's vignette
+    // Eskils vignette
 
-    '	vec4 texel = texture2D( tDiffuse, vUv );',
-    '	vec2 uv = ( vUv - vec2( 0.5 ) ) * vec2( offset );',
-    '	gl_FragColor = vec4( mix( texel.rgb, vec3( 1.0 - darkness ), dot( uv, uv ) ), texel.a );',
+    	vec4 texel = texture2D( tDiffuse, vUv );
+    	vec2 uv = ( vUv - vec2( 0.5 ) ) * vec2( offset );
+    	gl_FragColor = vec4( mix( texel.rgb, vec3( 1.0 - darkness ), dot( uv, uv ) ), texel.a );
 
     /*
 		// alternative version from glfx.js
@@ -48,6 +48,6 @@ export const VignetteShader = {
 		"	gl_FragColor = color;",
 		*/
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/VolumeShader.ts b/src/shaders/VolumeShader.ts
index eb321679..7abcb6a0 100644
--- a/src/shaders/VolumeShader.ts
+++ b/src/shaders/VolumeShader.ts
@@ -8,267 +8,267 @@ import { Vector2, Vector3 } from 'three'
 
 export const VolumeRenderShader1 = {
   uniforms: {
-    u_size: { value: new Vector3(1, 1, 1) },
+    u_size: { value: /* @__PURE__ */ new Vector3(1, 1, 1) },
     u_renderstyle: { value: 0 },
     u_renderthreshold: { value: 0.5 },
-    u_clim: { value: new Vector2(1, 1) },
+    u_clim: { value: /* @__PURE__ */ new Vector2(1, 1) },
     u_data: { value: null },
     u_cmdata: { value: null },
   },
-  vertexShader: [
-    '		varying vec4 v_nearpos;',
-    '		varying vec4 v_farpos;',
-    '		varying vec3 v_position;',
-
-    '		void main() {',
-    // Prepare transforms to map to "camera view". See also:
-    // https://threejs.org/docs/#api/renderers/webgl/WebGLProgram
-    '				mat4 viewtransformf = modelViewMatrix;',
-    '				mat4 viewtransformi = inverse(modelViewMatrix);',
-
-    // Project local vertex coordinate to camera position. Then do a step
-    // backward (in cam coords) to the near clipping plane, and project back. Do
-    // the same for the far clipping plane. This gives us all the information we
-    // need to calculate the ray and truncate it to the viewing cone.
-    '				vec4 position4 = vec4(position, 1.0);',
-    '				vec4 pos_in_cam = viewtransformf * position4;',
-
-    // Intersection of ray and near clipping plane (z = -1 in clip coords)
-    '				pos_in_cam.z = -pos_in_cam.w;',
-    '				v_nearpos = viewtransformi * pos_in_cam;',
-
-    // Intersection of ray and far clipping plane (z = +1 in clip coords)
-    '				pos_in_cam.z = pos_in_cam.w;',
-    '				v_farpos = viewtransformi * pos_in_cam;',
-
-    // Set varyings and output pos
-    '				v_position = position;',
-    '				gl_Position = projectionMatrix * viewMatrix * modelMatrix * position4;',
-    '		}',
-  ].join('\n'),
-  fragmentShader: [
-    '		precision highp float;',
-    '		precision mediump sampler3D;',
-
-    '		uniform vec3 u_size;',
-    '		uniform int u_renderstyle;',
-    '		uniform float u_renderthreshold;',
-    '		uniform vec2 u_clim;',
-
-    '		uniform sampler3D u_data;',
-    '		uniform sampler2D u_cmdata;',
-
-    '		varying vec3 v_position;',
-    '		varying vec4 v_nearpos;',
-    '		varying vec4 v_farpos;',
-
-    // The maximum distance through our rendering volume is sqrt(3).
-    '		const int MAX_STEPS = 887;	// 887 for 512^3, 1774 for 1024^3',
-    '		const int REFINEMENT_STEPS = 4;',
-    '		const float relative_step_size = 1.0;',
-    '		const vec4 ambient_color = vec4(0.2, 0.4, 0.2, 1.0);',
-    '		const vec4 diffuse_color = vec4(0.8, 0.2, 0.2, 1.0);',
-    '		const vec4 specular_color = vec4(1.0, 1.0, 1.0, 1.0);',
-    '		const float shininess = 40.0;',
-
-    '		void cast_mip(vec3 start_loc, vec3 step, int nsteps, vec3 view_ray);',
-    '		void cast_iso(vec3 start_loc, vec3 step, int nsteps, vec3 view_ray);',
-
-    '		float sample1(vec3 texcoords);',
-    '		vec4 apply_colormap(float val);',
-    '		vec4 add_lighting(float val, vec3 loc, vec3 step, vec3 view_ray);',
-
-    '		void main() {',
-    // Normalize clipping plane info
-    '				vec3 farpos = v_farpos.xyz / v_farpos.w;',
-    '				vec3 nearpos = v_nearpos.xyz / v_nearpos.w;',
-
-    // Calculate unit vector pointing in the view direction through this fragment.
-    '				vec3 view_ray = normalize(nearpos.xyz - farpos.xyz);',
-
-    // Compute the (negative) distance to the front surface or near clipping plane.
-    // v_position is the back face of the cuboid, so the initial distance calculated in the dot
-    // product below is the distance from near clip plane to the back of the cuboid
-    '				float distance = dot(nearpos - v_position, view_ray);',
-    '				distance = max(distance, min((-0.5 - v_position.x) / view_ray.x,',
-    '																		(u_size.x - 0.5 - v_position.x) / view_ray.x));',
-    '				distance = max(distance, min((-0.5 - v_position.y) / view_ray.y,',
-    '																		(u_size.y - 0.5 - v_position.y) / view_ray.y));',
-    '				distance = max(distance, min((-0.5 - v_position.z) / view_ray.z,',
-    '																		(u_size.z - 0.5 - v_position.z) / view_ray.z));',
-
-    // Now we have the starting position on the front surface
-    '				vec3 front = v_position + view_ray * distance;',
-
-    // Decide how many steps to take
-    '				int nsteps = int(-distance / relative_step_size + 0.5);',
-    '				if ( nsteps < 1 )',
-    '						discard;',
-
-    // Get starting location and step vector in texture coordinates
-    '				vec3 step = ((v_position - front) / u_size) / float(nsteps);',
-    '				vec3 start_loc = front / u_size;',
-
-    // For testing: show the number of steps. This helps to establish
-    // whether the rays are correctly oriented
-    //'gl_FragColor = vec4(0.0, float(nsteps) / 1.0 / u_size.x, 1.0, 1.0);',
-    //'return;',
-
-    '				if (u_renderstyle == 0)',
-    '						cast_mip(start_loc, step, nsteps, view_ray);',
-    '				else if (u_renderstyle == 1)',
-    '						cast_iso(start_loc, step, nsteps, view_ray);',
-
-    '				if (gl_FragColor.a < 0.05)',
-    '						discard;',
-    '		}',
-
-    '		float sample1(vec3 texcoords) {',
-    '				/* Sample float value from a 3D texture. Assumes intensity data. */',
-    '				return texture(u_data, texcoords.xyz).r;',
-    '		}',
-
-    '		vec4 apply_colormap(float val) {',
-    '				val = (val - u_clim[0]) / (u_clim[1] - u_clim[0]);',
-    '				return texture2D(u_cmdata, vec2(val, 0.5));',
-    '		}',
-
-    '		void cast_mip(vec3 start_loc, vec3 step, int nsteps, vec3 view_ray) {',
-
-    '				float max_val = -1e6;',
-    '				int max_i = 100;',
-    '				vec3 loc = start_loc;',
-
-    // Enter the raycasting loop. In WebGL 1 the loop index cannot be compared with
-    // non-constant expression. So we use a hard-coded max, and an additional condition
-    // inside the loop.
-    '				for (int iter=0; iter<MAX_STEPS; iter++) {',
-    '						if (iter >= nsteps)',
-    '								break;',
-    // Sample from the 3D texture
-    '						float val = sample1(loc);',
-    // Apply MIP operation
-    '						if (val > max_val) {',
-    '								max_val = val;',
-    '								max_i = iter;',
-    '						}',
-    // Advance location deeper into the volume
-    '						loc += step;',
-    '				}',
-
-    // Refine location, gives crispier images
-    '				vec3 iloc = start_loc + step * (float(max_i) - 0.5);',
-    '				vec3 istep = step / float(REFINEMENT_STEPS);',
-    '				for (int i=0; i<REFINEMENT_STEPS; i++) {',
-    '						max_val = max(max_val, sample1(iloc));',
-    '						iloc += istep;',
-    '				}',
-
-    // Resolve final color
-    '				gl_FragColor = apply_colormap(max_val);',
-    '		}',
-
-    '		void cast_iso(vec3 start_loc, vec3 step, int nsteps, vec3 view_ray) {',
-
-    '				gl_FragColor = vec4(0.0);	// init transparent',
-    '				vec4 color3 = vec4(0.0);	// final color',
-    '				vec3 dstep = 1.5 / u_size;	// step to sample derivative',
-    '				vec3 loc = start_loc;',
-
-    '				float low_threshold = u_renderthreshold - 0.02 * (u_clim[1] - u_clim[0]);',
-
-    // Enter the raycasting loop. In WebGL 1 the loop index cannot be compared with
-    // non-constant expression. So we use a hard-coded max, and an additional condition
-    // inside the loop.
-    '				for (int iter=0; iter<MAX_STEPS; iter++) {',
-    '						if (iter >= nsteps)',
-    '								break;',
-
-    // Sample from the 3D texture
-    '						float val = sample1(loc);',
-
-    '						if (val > low_threshold) {',
-    // Take the last interval in smaller steps
-    '								vec3 iloc = loc - 0.5 * step;',
-    '								vec3 istep = step / float(REFINEMENT_STEPS);',
-    '								for (int i=0; i<REFINEMENT_STEPS; i++) {',
-    '										val = sample1(iloc);',
-    '										if (val > u_renderthreshold) {',
-    '												gl_FragColor = add_lighting(val, iloc, dstep, view_ray);',
-    '												return;',
-    '										}',
-    '										iloc += istep;',
-    '								}',
-    '						}',
-
-    // Advance location deeper into the volume
-    '						loc += step;',
-    '				}',
-    '		}',
-
-    '		vec4 add_lighting(float val, vec3 loc, vec3 step, vec3 view_ray)',
-    '		{',
-    // Calculate color by incorporating lighting
-
-    // View direction
-    '				vec3 V = normalize(view_ray);',
-
-    // calculate normal vector from gradient
-    '				vec3 N;',
-    '				float val1, val2;',
-    '				val1 = sample1(loc + vec3(-step[0], 0.0, 0.0));',
-    '				val2 = sample1(loc + vec3(+step[0], 0.0, 0.0));',
-    '				N[0] = val1 - val2;',
-    '				val = max(max(val1, val2), val);',
-    '				val1 = sample1(loc + vec3(0.0, -step[1], 0.0));',
-    '				val2 = sample1(loc + vec3(0.0, +step[1], 0.0));',
-    '				N[1] = val1 - val2;',
-    '				val = max(max(val1, val2), val);',
-    '				val1 = sample1(loc + vec3(0.0, 0.0, -step[2]));',
-    '				val2 = sample1(loc + vec3(0.0, 0.0, +step[2]));',
-    '				N[2] = val1 - val2;',
-    '				val = max(max(val1, val2), val);',
-
-    '				float gm = length(N); // gradient magnitude',
-    '				N = normalize(N);',
-
-    // Flip normal so it points towards viewer
-    '				float Nselect = float(dot(N, V) > 0.0);',
-    '				N = (2.0 * Nselect - 1.0) * N;	// ==	Nselect * N - (1.0-Nselect)*N;',
-
-    // Init colors
-    '				vec4 ambient_color = vec4(0.0, 0.0, 0.0, 0.0);',
-    '				vec4 diffuse_color = vec4(0.0, 0.0, 0.0, 0.0);',
-    '				vec4 specular_color = vec4(0.0, 0.0, 0.0, 0.0);',
-
-    // note: could allow multiple lights
-    '				for (int i=0; i<1; i++)',
-    '				{',
-    // Get light direction (make sure to prevent zero devision)
-    '						vec3 L = normalize(view_ray);	//lightDirs[i];',
-    '						float lightEnabled = float( length(L) > 0.0 );',
-    '						L = normalize(L + (1.0 - lightEnabled));',
-
-    // Calculate lighting properties
-    '						float lambertTerm = clamp(dot(N, L), 0.0, 1.0);',
-    '						vec3 H = normalize(L+V); // Halfway vector',
-    '						float specularTerm = pow(max(dot(H, N), 0.0), shininess);',
-
-    // Calculate mask
-    '						float mask1 = lightEnabled;',
-
-    // Calculate colors
-    '						ambient_color +=	mask1 * ambient_color;	// * gl_LightSource[i].ambient;',
-    '						diffuse_color +=	mask1 * lambertTerm;',
-    '						specular_color += mask1 * specularTerm * specular_color;',
-    '				}',
-
-    // Calculate final color by componing different components
-    '				vec4 final_color;',
-    '				vec4 color = apply_colormap(val);',
-    '				final_color = color * (ambient_color + diffuse_color) + specular_color;',
-    '				final_color.a = color.a;',
-    '				return final_color;',
-    '		}',
-  ].join('\n'),
+  vertexShader: /* glsl */ `
+		varying vec4 v_nearpos;
+		varying vec4 v_farpos;
+		varying vec3 v_position;
+
+		void main() {
+			// Prepare transforms to map to "camera view". See also:
+			// https://threejs.org/docs/#api/renderers/webgl/WebGLProgram
+			mat4 viewtransformf = modelViewMatrix;
+			mat4 viewtransformi = inverse(modelViewMatrix);
+
+			// Project local vertex coordinate to camera position. Then do a step
+			// backward (in cam coords) to the near clipping plane, and project back. Do
+			// the same for the far clipping plane. This gives us all the information we
+			// need to calculate the ray and truncate it to the viewing cone.
+			vec4 position4 = vec4(position, 1.0);
+			vec4 pos_in_cam = viewtransformf * position4;
+
+			// Intersection of ray and near clipping plane (z = -1 in clip coords)
+			pos_in_cam.z = -pos_in_cam.w;
+			v_nearpos = viewtransformi * pos_in_cam;
+
+			// Intersection of ray and far clipping plane (z = +1 in clip coords)
+			pos_in_cam.z = pos_in_cam.w;
+			v_farpos = viewtransformi * pos_in_cam;
+
+			// Set varyings and output pos
+			v_position = position;
+			gl_Position = projectionMatrix * viewMatrix * modelMatrix * position4;
+		}
+  `,
+  fragmentShader: /* glsl */ `
+		precision highp float;
+		precision mediump sampler3D;
+
+		uniform vec3 u_size;
+		uniform int u_renderstyle;
+		uniform float u_renderthreshold;
+		uniform vec2 u_clim;
+
+		uniform sampler3D u_data;
+		uniform sampler2D u_cmdata;
+
+		varying vec3 v_position;
+		varying vec4 v_nearpos;
+		varying vec4 v_farpos;
+
+	// The maximum distance through our rendering volume is sqrt(3).
+		const int MAX_STEPS = 887;	// 887 for 512^3, 1774 for 1024^3
+		const int REFINEMENT_STEPS = 4;
+		const float relative_step_size = 1.0;
+		const vec4 ambient_color = vec4(0.2, 0.4, 0.2, 1.0);
+		const vec4 diffuse_color = vec4(0.8, 0.2, 0.2, 1.0);
+		const vec4 specular_color = vec4(1.0, 1.0, 1.0, 1.0);
+		const float shininess = 40.0;
+
+		void cast_mip(vec3 start_loc, vec3 step, int nsteps, vec3 view_ray);
+		void cast_iso(vec3 start_loc, vec3 step, int nsteps, vec3 view_ray);
+
+		float sample1(vec3 texcoords);
+		vec4 apply_colormap(float val);
+		vec4 add_lighting(float val, vec3 loc, vec3 step, vec3 view_ray);
+
+		void main() {
+	// Normalize clipping plane info
+			vec3 farpos = v_farpos.xyz / v_farpos.w;
+			vec3 nearpos = v_nearpos.xyz / v_nearpos.w;
+
+	// Calculate unit vector pointing in the view direction through this fragment.
+			vec3 view_ray = normalize(nearpos.xyz - farpos.xyz);
+
+	// Compute the (negative) distance to the front surface or near clipping plane.
+	// v_position is the back face of the cuboid, so the initial distance calculated in the dot
+	// product below is the distance from near clip plane to the back of the cuboid
+			float distance = dot(nearpos - v_position, view_ray);
+			distance = max(distance, min((-0.5 - v_position.x) / view_ray.x,
+										(u_size.x - 0.5 - v_position.x) / view_ray.x));
+			distance = max(distance, min((-0.5 - v_position.y) / view_ray.y,
+										(u_size.y - 0.5 - v_position.y) / view_ray.y));
+			distance = max(distance, min((-0.5 - v_position.z) / view_ray.z,
+										(u_size.z - 0.5 - v_position.z) / view_ray.z));
+
+	// Now we have the starting position on the front surface
+			vec3 front = v_position + view_ray * distance;
+
+	// Decide how many steps to take
+			int nsteps = int(-distance / relative_step_size + 0.5);
+			if ( nsteps < 1 )
+				discard;
+
+	// Get starting location and step vector in texture coordinates
+			vec3 step = ((v_position - front) / u_size) / float(nsteps);
+			vec3 start_loc = front / u_size;
+
+	// For testing: show the number of steps. This helps to establish
+	// whether the rays are correctly oriented
+	//gl_FragColor = vec4(0.0, float(nsteps) / 1.0 / u_size.x, 1.0, 1.0);
+	//return;
+
+			if (u_renderstyle == 0)
+				cast_mip(start_loc, step, nsteps, view_ray);
+			else if (u_renderstyle == 1)
+				cast_iso(start_loc, step, nsteps, view_ray);
+
+			if (gl_FragColor.a < 0.05)
+				discard;
+		}
+
+		float sample1(vec3 texcoords) {
+			/* Sample float value from a 3D texture. Assumes intensity data. */
+			return texture(u_data, texcoords.xyz).r;
+		}
+
+		vec4 apply_colormap(float val) {
+			val = (val - u_clim[0]) / (u_clim[1] - u_clim[0]);
+			return texture2D(u_cmdata, vec2(val, 0.5));
+		}
+
+		void cast_mip(vec3 start_loc, vec3 step, int nsteps, vec3 view_ray) {
+
+			float max_val = -1e6;
+			int max_i = 100;
+			vec3 loc = start_loc;
+
+	// Enter the raycasting loop. In WebGL 1 the loop index cannot be compared with
+	// non-constant expression. So we use a hard-coded max, and an additional condition
+	// inside the loop.
+			for (int iter=0; iter<MAX_STEPS; iter++) {
+				if (iter >= nsteps)
+					break;
+	// Sample from the 3D texture
+				float val = sample1(loc);
+	// Apply MIP operation
+				if (val > max_val) {
+					max_val = val;
+					max_i = iter;
+				}
+	// Advance location deeper into the volume
+				loc += step;
+			}
+
+	// Refine location, gives crispier images
+			vec3 iloc = start_loc + step * (float(max_i) - 0.5);
+			vec3 istep = step / float(REFINEMENT_STEPS);
+			for (int i=0; i<REFINEMENT_STEPS; i++) {
+				max_val = max(max_val, sample1(iloc));
+				iloc += istep;
+			}
+
+	// Resolve final color
+			gl_FragColor = apply_colormap(max_val);
+		}
+
+		void cast_iso(vec3 start_loc, vec3 step, int nsteps, vec3 view_ray) {
+
+			gl_FragColor = vec4(0.0);	// init transparent
+			vec4 color3 = vec4(0.0);	// final color
+			vec3 dstep = 1.5 / u_size;	// step to sample derivative
+			vec3 loc = start_loc;
+
+			float low_threshold = u_renderthreshold - 0.02 * (u_clim[1] - u_clim[0]);
+
+	// Enter the raycasting loop. In WebGL 1 the loop index cannot be compared with
+	// non-constant expression. So we use a hard-coded max, and an additional condition
+	// inside the loop.
+			for (int iter=0; iter<MAX_STEPS; iter++) {
+				if (iter >= nsteps)
+					break;
+
+	// Sample from the 3D texture
+				float val = sample1(loc);
+
+				if (val > low_threshold) {
+	// Take the last interval in smaller steps
+					vec3 iloc = loc - 0.5 * step;
+					vec3 istep = step / float(REFINEMENT_STEPS);
+					for (int i=0; i<REFINEMENT_STEPS; i++) {
+						val = sample1(iloc);
+						if (val > u_renderthreshold) {
+							gl_FragColor = add_lighting(val, iloc, dstep, view_ray);
+							return;
+						}
+						iloc += istep;
+					}
+				}
+
+	// Advance location deeper into the volume
+				loc += step;
+			}
+		}
+
+		vec4 add_lighting(float val, vec3 loc, vec3 step, vec3 view_ray)
+		{
+	// Calculate color by incorporating lighting
+
+	// View direction
+			vec3 V = normalize(view_ray);
+
+	// calculate normal vector from gradient
+			vec3 N;
+			float val1, val2;
+			val1 = sample1(loc + vec3(-step[0], 0.0, 0.0));
+			val2 = sample1(loc + vec3(+step[0], 0.0, 0.0));
+			N[0] = val1 - val2;
+			val = max(max(val1, val2), val);
+			val1 = sample1(loc + vec3(0.0, -step[1], 0.0));
+			val2 = sample1(loc + vec3(0.0, +step[1], 0.0));
+			N[1] = val1 - val2;
+			val = max(max(val1, val2), val);
+			val1 = sample1(loc + vec3(0.0, 0.0, -step[2]));
+			val2 = sample1(loc + vec3(0.0, 0.0, +step[2]));
+			N[2] = val1 - val2;
+			val = max(max(val1, val2), val);
+
+			float gm = length(N); // gradient magnitude
+			N = normalize(N);
+
+	// Flip normal so it points towards viewer
+			float Nselect = float(dot(N, V) > 0.0);
+			N = (2.0 * Nselect - 1.0) * N;	// ==	Nselect * N - (1.0-Nselect)*N;
+
+	// Init colors
+			vec4 ambient_color = vec4(0.0, 0.0, 0.0, 0.0);
+			vec4 diffuse_color = vec4(0.0, 0.0, 0.0, 0.0);
+			vec4 specular_color = vec4(0.0, 0.0, 0.0, 0.0);
+
+	// note: could allow multiple lights
+			for (int i=0; i<1; i++)
+			{
+	// Get light direction (make sure to prevent zero devision)
+				vec3 L = normalize(view_ray);	//lightDirs[i];
+				float lightEnabled = float( length(L) > 0.0 );
+				L = normalize(L + (1.0 - lightEnabled));
+
+	// Calculate lighting properties
+				float lambertTerm = clamp(dot(N, L), 0.0, 1.0);
+				vec3 H = normalize(L+V); // Halfway vector
+				float specularTerm = pow(max(dot(H, N), 0.0), shininess);
+
+	// Calculate mask
+				float mask1 = lightEnabled;
+
+	// Calculate colors
+				ambient_color +=	mask1 * ambient_color;	// * gl_LightSource[i].ambient;
+				diffuse_color +=	mask1 * lambertTerm;
+				specular_color += mask1 * specularTerm * specular_color;
+			}
+
+	// Calculate final color by componing different components
+			vec4 final_color;
+			vec4 color = apply_colormap(val);
+			final_color = color * (ambient_color + diffuse_color) + specular_color;
+			final_color.a = color.a;
+			return final_color;
+		}
+  `,
 }
diff --git a/src/shaders/WaterRefractionShader.ts b/src/shaders/WaterRefractionShader.ts
index 32f2cb7b..7f14e079 100644
--- a/src/shaders/WaterRefractionShader.ts
+++ b/src/shaders/WaterRefractionShader.ts
@@ -21,64 +21,64 @@ export const WaterRefractionShader = {
     },
   },
 
-  vertexShader: [
-    'uniform mat4 textureMatrix;',
+  vertexShader: /* glsl */ `
+    uniform mat4 textureMatrix;
 
-    'varying vec2 vUv;',
-    'varying vec4 vUvRefraction;',
+    varying vec2 vUv;
+    varying vec4 vUvRefraction;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
+    	vUv = uv;
 
-    '	vUvRefraction = textureMatrix * vec4( position, 1.0 );',
+    	vUvRefraction = textureMatrix * vec4( position, 1.0 );
 
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform vec3 color;',
-    'uniform float time;',
-    'uniform sampler2D tDiffuse;',
-    'uniform sampler2D tDudv;',
+  fragmentShader: /* glsl */ `
+    uniform vec3 color;
+    uniform float time;
+    uniform sampler2D tDiffuse;
+    uniform sampler2D tDudv;
 
-    'varying vec2 vUv;',
-    'varying vec4 vUvRefraction;',
+    varying vec2 vUv;
+    varying vec4 vUvRefraction;
 
-    'float blendOverlay( float base, float blend ) {',
+    float blendOverlay( float base, float blend ) {
 
-    '	return( base < 0.5 ? ( 2.0 * base * blend ) : ( 1.0 - 2.0 * ( 1.0 - base ) * ( 1.0 - blend ) ) );',
+    	return( base < 0.5 ? ( 2.0 * base * blend ) : ( 1.0 - 2.0 * ( 1.0 - base ) * ( 1.0 - blend ) ) );
 
-    '}',
+    }
 
-    'vec3 blendOverlay( vec3 base, vec3 blend ) {',
+    vec3 blendOverlay( vec3 base, vec3 blend ) {
 
-    '	return vec3( blendOverlay( base.r, blend.r ), blendOverlay( base.g, blend.g ),blendOverlay( base.b, blend.b ) );',
+    	return vec3( blendOverlay( base.r, blend.r ), blendOverlay( base.g, blend.g ),blendOverlay( base.b, blend.b ) );
 
-    '}',
+    }
 
-    'void main() {',
+    void main() {
 
-    ' float waveStrength = 0.1;',
-    ' float waveSpeed = 0.03;',
+     float waveStrength = 0.1;
+     float waveSpeed = 0.03;
 
     // simple distortion (ripple) via dudv map (see https://www.youtube.com/watch?v=6B7IF6GOu7s)
 
-    '	vec2 distortedUv = texture2D( tDudv, vec2( vUv.x + time * waveSpeed, vUv.y ) ).rg * waveStrength;',
-    '	distortedUv = vUv.xy + vec2( distortedUv.x, distortedUv.y + time * waveSpeed );',
-    '	vec2 distortion = ( texture2D( tDudv, distortedUv ).rg * 2.0 - 1.0 ) * waveStrength;',
+    	vec2 distortedUv = texture2D( tDudv, vec2( vUv.x + time * waveSpeed, vUv.y ) ).rg * waveStrength;
+    	distortedUv = vUv.xy + vec2( distortedUv.x, distortedUv.y + time * waveSpeed );
+    	vec2 distortion = ( texture2D( tDudv, distortedUv ).rg * 2.0 - 1.0 ) * waveStrength;
 
     // new uv coords
 
-    ' vec4 uv = vec4( vUvRefraction );',
-    ' uv.xy += distortion;',
+     vec4 uv = vec4( vUvRefraction );
+     uv.xy += distortion;
 
-    '	vec4 base = texture2DProj( tDiffuse, uv );',
+    	vec4 base = texture2DProj( tDiffuse, uv );
 
-    '	gl_FragColor = vec4( blendOverlay( base.rgb, color ), 1.0 );',
+    	gl_FragColor = vec4( blendOverlay( base.rgb, color ), 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/utils/GeometryCompressionUtils.js b/src/utils/GeometryCompressionUtils.js
index dec6b46e..7bee13fe 100644
--- a/src/utils/GeometryCompressionUtils.js
+++ b/src/utils/GeometryCompressionUtils.js
@@ -14,8 +14,8 @@ import {
   ShaderLib,
   UniformsUtils,
   Vector3,
-  REVISION,
 } from 'three'
+import { version } from '../_polyfill/constants'
 
 var GeometryCompressionUtils = {
   /**
@@ -732,7 +732,7 @@ class PackedPhongMaterial extends MeshPhongMaterial {
       'gl_FragColor = vec4( outgoingLight, diffuseColor.a );',
 
       ShaderChunk.tonemapping_fragment,
-      parseInt(REVISION.replace(/\D+/g, '')) >= 154 ? ShaderChunk.colorspace_fragment : ShaderChunk.encodings_fragment,
+      version >= 154 ? ShaderChunk.colorspace_fragment : ShaderChunk.encodings_fragment,
       ShaderChunk.fog_fragment,
       ShaderChunk.premultiplied_alpha_fragment,
       ShaderChunk.dithering_fragment,
diff --git a/src/utils/LDrawUtils.js b/src/utils/LDrawUtils.js
index 1329807f..de7ab99c 100644
--- a/src/utils/LDrawUtils.js
+++ b/src/utils/LDrawUtils.js
@@ -1,8 +1,8 @@
 import { BufferAttribute, BufferGeometry, Group, LineSegments, Matrix3, Mesh } from 'three'
 import { mergeBufferGeometries } from './BufferGeometryUtils'
 
-class LDrawUtils {
-  static mergeObject(object) {
+const LDrawUtils = {
+  mergeObject(object) {
     // Merges geometries in object by materials and returns new object. Use on not indexed geometries.
     // The object buffers reference the old object ones.
     // Special treatment is done to the conditional lines generated by LDrawLoader.
@@ -150,7 +150,7 @@ class LDrawUtils {
     mergedObject.userData.numConstructionSteps = 1
 
     return mergedObject
-  }
+  },
 }
 
 export { LDrawUtils }
diff --git a/src/utils/RoughnessMipmapper.js b/src/utils/RoughnessMipmapper.js
index 46e58c7c..6b58a42b 100644
--- a/src/utils/RoughnessMipmapper.js
+++ b/src/utils/RoughnessMipmapper.js
@@ -17,11 +17,11 @@ import {
   WebGLRenderTarget,
 } from 'three'
 
-var _mipmapMaterial = _getMipmapMaterial()
+var _mipmapMaterial = /* @__PURE__ */ _getMipmapMaterial()
 
-var _mesh = new Mesh(new PlaneGeometry(2, 2), _mipmapMaterial)
+var _mesh = /* @__PURE__ */ new Mesh(/* @__PURE__ */ new PlaneGeometry(2, 2), _mipmapMaterial)
 
-var _flatCamera = new OrthographicCamera(0, 1, 0, 1, 0, 1)
+var _flatCamera = /* @__PURE__ */ new OrthographicCamera(0, 1, 0, 1, 0, 1)
 
 var _tempTarget = null
 
diff --git a/src/webxr/ARButton.ts b/src/webxr/ARButton.ts
index d29b80dc..ba806fea 100644
--- a/src/webxr/ARButton.ts
+++ b/src/webxr/ARButton.ts
@@ -1,162 +1,169 @@
 import { WebGLRenderer } from 'three'
 
-class ARButton {
-  static createButton(renderer: WebGLRenderer, sessionInit: XRSessionInit = {}): HTMLButtonElement | HTMLAnchorElement {
-    const button = document.createElement('button')
-
-    function showStartAR(/*device*/): void {
-      if ((sessionInit as any).domOverlay === undefined) {
-        const overlay = document.createElement('div')
-        overlay.style.display = 'none'
-        document.body.appendChild(overlay)
-
-        const svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg')
-        svg.setAttribute('width', '38px')
-        svg.setAttribute('height', '38px')
-        svg.style.position = 'absolute'
-        svg.style.right = '20px'
-        svg.style.top = '20px'
-        svg.addEventListener('click', function () {
-          currentSession?.end()
-        })
-        overlay.appendChild(svg)
-
-        const path = document.createElementNS('http://www.w3.org/2000/svg', 'path')
-        path.setAttribute('d', 'M 12,12 L 28,28 M 28,12 12,28')
-        path.setAttribute('stroke', '#fff')
-        path.setAttribute('stroke-width', '2px')
-        svg.appendChild(path)
-
-        if (sessionInit.optionalFeatures === undefined) {
-          sessionInit.optionalFeatures = []
+const ARButton = /* @__PURE__ */ (() => {
+  class ARButton {
+    static createButton(
+      renderer: WebGLRenderer,
+      sessionInit: XRSessionInit = {},
+    ): HTMLButtonElement | HTMLAnchorElement {
+      const button = document.createElement('button')
+
+      function showStartAR(/*device*/): void {
+        if ((sessionInit as any).domOverlay === undefined) {
+          const overlay = document.createElement('div')
+          overlay.style.display = 'none'
+          document.body.appendChild(overlay)
+
+          const svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg')
+          svg.setAttribute('width', '38px')
+          svg.setAttribute('height', '38px')
+          svg.style.position = 'absolute'
+          svg.style.right = '20px'
+          svg.style.top = '20px'
+          svg.addEventListener('click', function () {
+            currentSession?.end()
+          })
+          overlay.appendChild(svg)
+
+          const path = document.createElementNS('http://www.w3.org/2000/svg', 'path')
+          path.setAttribute('d', 'M 12,12 L 28,28 M 28,12 12,28')
+          path.setAttribute('stroke', '#fff')
+          path.setAttribute('stroke-width', '2px')
+          svg.appendChild(path)
+
+          if (sessionInit.optionalFeatures === undefined) {
+            sessionInit.optionalFeatures = []
+          }
+
+          sessionInit.optionalFeatures.push('dom-overlay')
+          ;(sessionInit as any).domOverlay = { root: overlay }
         }
 
-        sessionInit.optionalFeatures.push('dom-overlay')
-        ;(sessionInit as any).domOverlay = { root: overlay }
-      }
+        //
 
-      //
+        let currentSession: XRSession | null = null
 
-      let currentSession: XRSession | null = null
+        async function onSessionStarted(session: XRSession): Promise<void> {
+          session.addEventListener('end', onSessionEnded)
 
-      async function onSessionStarted(session: XRSession): Promise<void> {
-        session.addEventListener('end', onSessionEnded)
+          renderer.xr.setReferenceSpaceType('local')
 
-        renderer.xr.setReferenceSpaceType('local')
+          await renderer.xr.setSession(session as any)
 
-        await renderer.xr.setSession(session as any)
+          button.textContent = 'STOP AR'
+          ;(sessionInit as any).domOverlay!.root.style.display = ''
 
-        button.textContent = 'STOP AR'
-        ;(sessionInit as any).domOverlay!.root.style.display = ''
+          currentSession = session
+        }
 
-        currentSession = session
-      }
+        function onSessionEnded(/*event*/): void {
+          currentSession!.removeEventListener('end', onSessionEnded)
 
-      function onSessionEnded(/*event*/): void {
-        currentSession!.removeEventListener('end', onSessionEnded)
+          button.textContent = 'START AR'
+          ;(sessionInit as any).domOverlay!.root.style.display = 'none'
 
-        button.textContent = 'START AR'
-        ;(sessionInit as any).domOverlay!.root.style.display = 'none'
-
-        currentSession = null
-      }
+          currentSession = null
+        }
 
-      //
+        //
 
-      button.style.display = ''
+        button.style.display = ''
 
-      button.style.cursor = 'pointer'
-      button.style.left = 'calc(50% - 50px)'
-      button.style.width = '100px'
+        button.style.cursor = 'pointer'
+        button.style.left = 'calc(50% - 50px)'
+        button.style.width = '100px'
 
-      button.textContent = 'START AR'
+        button.textContent = 'START AR'
 
-      button.onmouseenter = (): void => {
-        button.style.opacity = '1.0'
-      }
+        button.onmouseenter = (): void => {
+          button.style.opacity = '1.0'
+        }
 
-      button.onmouseleave = (): void => {
-        button.style.opacity = '0.5'
-      }
+        button.onmouseleave = (): void => {
+          button.style.opacity = '0.5'
+        }
 
-      button.onclick = (): void => {
-        if (currentSession === null) {
-          ;(navigator as Navigator).xr!.requestSession('immersive-ar', sessionInit).then(onSessionStarted)
-        } else {
-          currentSession.end()
+        button.onclick = (): void => {
+          if (currentSession === null) {
+            ;(navigator as Navigator).xr!.requestSession('immersive-ar', sessionInit).then(onSessionStarted)
+          } else {
+            currentSession.end()
+          }
         }
       }
-    }
 
-    function disableButton(): void {
-      button.style.display = ''
+      function disableButton(): void {
+        button.style.display = ''
 
-      button.style.cursor = 'auto'
-      button.style.left = 'calc(50% - 75px)'
-      button.style.width = '150px'
+        button.style.cursor = 'auto'
+        button.style.left = 'calc(50% - 75px)'
+        button.style.width = '150px'
 
-      button.onmouseenter = null
-      button.onmouseleave = null
+        button.onmouseenter = null
+        button.onmouseleave = null
 
-      button.onclick = null
-    }
-
-    function showARNotSupported(): void {
-      disableButton()
+        button.onclick = null
+      }
 
-      button.textContent = 'AR NOT SUPPORTED'
-    }
+      function showARNotSupported(): void {
+        disableButton()
 
-    function stylizeElement(element: HTMLElement): void {
-      element.style.position = 'absolute'
-      element.style.bottom = '20px'
-      element.style.padding = '12px 6px'
-      element.style.border = '1px solid #fff'
-      element.style.borderRadius = '4px'
-      element.style.background = 'rgba(0,0,0,0.1)'
-      element.style.color = '#fff'
-      element.style.font = 'normal 13px sans-serif'
-      element.style.textAlign = 'center'
-      element.style.opacity = '0.5'
-      element.style.outline = 'none'
-      element.style.zIndex = '999'
-    }
+        button.textContent = 'AR NOT SUPPORTED'
+      }
 
-    if ('xr' in navigator) {
-      button.id = 'ARButton'
-      button.style.display = 'none'
+      function stylizeElement(element: HTMLElement): void {
+        element.style.position = 'absolute'
+        element.style.bottom = '20px'
+        element.style.padding = '12px 6px'
+        element.style.border = '1px solid #fff'
+        element.style.borderRadius = '4px'
+        element.style.background = 'rgba(0,0,0,0.1)'
+        element.style.color = '#fff'
+        element.style.font = 'normal 13px sans-serif'
+        element.style.textAlign = 'center'
+        element.style.opacity = '0.5'
+        element.style.outline = 'none'
+        element.style.zIndex = '999'
+      }
 
-      stylizeElement(button)
+      if ('xr' in navigator) {
+        button.id = 'ARButton'
+        button.style.display = 'none'
 
-      // Query for session mode
-      ;(navigator as Navigator)
-        .xr!.isSessionSupported('immersive-ar')
-        .then(function (supported: boolean) {
-          supported ? showStartAR() : showARNotSupported()
-        })
-        .catch(showARNotSupported)
+        stylizeElement(button)
 
-      return button
-    } else {
-      const message = document.createElement('a')
+        // Query for session mode
+        ;(navigator as Navigator)
+          .xr!.isSessionSupported('immersive-ar')
+          .then(function (supported: boolean) {
+            supported ? showStartAR() : showARNotSupported()
+          })
+          .catch(showARNotSupported)
 
-      if (window.isSecureContext === false) {
-        message.href = document.location.href.replace(/^http:/, 'https:')
-        message.innerHTML = 'WEBXR NEEDS HTTPS' // TODO Improve message
+        return button
       } else {
-        message.href = 'https://immersiveweb.dev/'
-        message.innerHTML = 'WEBXR NOT AVAILABLE'
-      }
+        const message = document.createElement('a')
+
+        if (window.isSecureContext === false) {
+          message.href = document.location.href.replace(/^http:/, 'https:')
+          message.innerHTML = 'WEBXR NEEDS HTTPS' // TODO Improve message
+        } else {
+          message.href = 'https://immersiveweb.dev/'
+          message.innerHTML = 'WEBXR NOT AVAILABLE'
+        }
 
-      message.style.left = 'calc(50% - 90px)'
-      message.style.width = '180px'
-      message.style.textDecoration = 'none'
+        message.style.left = 'calc(50% - 90px)'
+        message.style.width = '180px'
+        message.style.textDecoration = 'none'
 
-      stylizeElement(message)
+        stylizeElement(message)
 
-      return message
+        return message
+      }
     }
   }
-}
+
+  return ARButton
+})()
 
 export { ARButton }
diff --git a/src/webxr/OculusHandPointerModel.js b/src/webxr/OculusHandPointerModel.js
index 4881455c..00e044a5 100644
--- a/src/webxr/OculusHandPointerModel.js
+++ b/src/webxr/OculusHandPointerModel.js
@@ -13,8 +13,8 @@ const POINTER_LENGTH = 0.035
 const POINTER_SEGMENTS = 16
 const POINTER_RINGS = 12
 const POINTER_HEMISPHERE_ANGLE = 110
-const YAXIS = new THREE.Vector3(0, 1, 0)
-const ZAXIS = new THREE.Vector3(0, 0, 1)
+const YAXIS = /* @__PURE__ */ new THREE.Vector3(0, 1, 0)
+const ZAXIS = /* @__PURE__ */ new THREE.Vector3(0, 0, 1)
 
 const CURSOR_RADIUS = 0.02
 const CURSOR_MAX_DISTANCE = 1.5
diff --git a/src/webxr/VRButton.ts b/src/webxr/VRButton.ts
index 1ec7a521..c83ef9a5 100644
--- a/src/webxr/VRButton.ts
+++ b/src/webxr/VRButton.ts
@@ -1,150 +1,157 @@
 import { WebGLRenderer } from 'three'
 
-class VRButton {
-  static createButton(renderer: WebGLRenderer, sessionInit: XRSessionInit = {}): HTMLButtonElement | HTMLAnchorElement {
-    const button = document.createElement('button')
+const VRButton = /* @__PURE__ */ (() => {
+  class VRButton {
+    static createButton(
+      renderer: WebGLRenderer,
+      sessionInit: XRSessionInit = {},
+    ): HTMLButtonElement | HTMLAnchorElement {
+      const button = document.createElement('button')
 
-    function showEnterVR(/*device*/): void {
-      let currentSession: XRSession | null = null
+      function showEnterVR(/*device*/): void {
+        let currentSession: XRSession | null = null
 
-      async function onSessionStarted(session: XRSession): Promise<void> {
-        session.addEventListener('end', onSessionEnded)
+        async function onSessionStarted(session: XRSession): Promise<void> {
+          session.addEventListener('end', onSessionEnded)
 
-        await renderer.xr.setSession(session as any)
-        button.textContent = 'EXIT VR'
+          await renderer.xr.setSession(session as any)
+          button.textContent = 'EXIT VR'
 
-        currentSession = session
-      }
+          currentSession = session
+        }
 
-      function onSessionEnded(/*event*/): void {
-        currentSession!.removeEventListener('end', onSessionEnded)
+        function onSessionEnded(/*event*/): void {
+          currentSession!.removeEventListener('end', onSessionEnded)
 
-        button.textContent = 'ENTER VR'
+          button.textContent = 'ENTER VR'
 
-        currentSession = null
-      }
+          currentSession = null
+        }
 
-      //
+        //
 
-      button.style.display = ''
+        button.style.display = ''
 
-      button.style.cursor = 'pointer'
-      button.style.left = 'calc(50% - 50px)'
-      button.style.width = '100px'
+        button.style.cursor = 'pointer'
+        button.style.left = 'calc(50% - 50px)'
+        button.style.width = '100px'
 
-      button.textContent = 'ENTER VR'
+        button.textContent = 'ENTER VR'
 
-      button.onmouseenter = (): void => {
-        button.style.opacity = '1.0'
-      }
+        button.onmouseenter = (): void => {
+          button.style.opacity = '1.0'
+        }
 
-      button.onmouseleave = (): void => {
-        button.style.opacity = '0.5'
-      }
+        button.onmouseleave = (): void => {
+          button.style.opacity = '0.5'
+        }
 
-      button.onclick = (): void => {
-        if (currentSession === null) {
-          // WebXR's requestReferenceSpace only works if the corresponding feature
-          // was requested at session creation time. For simplicity, just ask for
-          // the interesting ones as optional features, but be aware that the
-          // requestReferenceSpace call will fail if it turns out to be unavailable.
-          // ('local' is always available for immersive sessions and doesn't need to
-          // be requested separately.)
-
-          const optionalFeatures = [sessionInit.optionalFeatures, 'local-floor', 'bounded-floor', 'hand-tracking']
-            .flat()
-            .filter(Boolean) as string[]
-
-          ;(navigator as Navigator).xr
-            ?.requestSession('immersive-vr', { ...sessionInit, optionalFeatures })
-            .then(onSessionStarted)
-        } else {
-          currentSession.end()
+        button.onclick = (): void => {
+          if (currentSession === null) {
+            // WebXR's requestReferenceSpace only works if the corresponding feature
+            // was requested at session creation time. For simplicity, just ask for
+            // the interesting ones as optional features, but be aware that the
+            // requestReferenceSpace call will fail if it turns out to be unavailable.
+            // ('local' is always available for immersive sessions and doesn't need to
+            // be requested separately.)
+
+            const optionalFeatures = [sessionInit.optionalFeatures, 'local-floor', 'bounded-floor', 'hand-tracking']
+              .flat()
+              .filter(Boolean) as string[]
+
+            ;(navigator as Navigator).xr
+              ?.requestSession('immersive-vr', { ...sessionInit, optionalFeatures })
+              .then(onSessionStarted)
+          } else {
+            currentSession.end()
+          }
         }
       }
-    }
-
-    function disableButton(): void {
-      button.style.display = ''
 
-      button.style.cursor = 'auto'
-      button.style.left = 'calc(50% - 75px)'
-      button.style.width = '150px'
+      function disableButton(): void {
+        button.style.display = ''
 
-      button.onmouseenter = null
-      button.onmouseleave = null
+        button.style.cursor = 'auto'
+        button.style.left = 'calc(50% - 75px)'
+        button.style.width = '150px'
 
-      button.onclick = null
-    }
+        button.onmouseenter = null
+        button.onmouseleave = null
 
-    function showWebXRNotFound(): void {
-      disableButton()
+        button.onclick = null
+      }
 
-      button.textContent = 'VR NOT SUPPORTED'
-    }
+      function showWebXRNotFound(): void {
+        disableButton()
 
-    function stylizeElement(element: HTMLElement): void {
-      element.style.position = 'absolute'
-      element.style.bottom = '20px'
-      element.style.padding = '12px 6px'
-      element.style.border = '1px solid #fff'
-      element.style.borderRadius = '4px'
-      element.style.background = 'rgba(0,0,0,0.1)'
-      element.style.color = '#fff'
-      element.style.font = 'normal 13px sans-serif'
-      element.style.textAlign = 'center'
-      element.style.opacity = '0.5'
-      element.style.outline = 'none'
-      element.style.zIndex = '999'
-    }
+        button.textContent = 'VR NOT SUPPORTED'
+      }
 
-    if ('xr' in navigator) {
-      stylizeElement(button)
-      button.id = 'VRButton'
-      button.style.display = 'none'
+      function stylizeElement(element: HTMLElement): void {
+        element.style.position = 'absolute'
+        element.style.bottom = '20px'
+        element.style.padding = '12px 6px'
+        element.style.border = '1px solid #fff'
+        element.style.borderRadius = '4px'
+        element.style.background = 'rgba(0,0,0,0.1)'
+        element.style.color = '#fff'
+        element.style.font = 'normal 13px sans-serif'
+        element.style.textAlign = 'center'
+        element.style.opacity = '0.5'
+        element.style.outline = 'none'
+        element.style.zIndex = '999'
+      }
 
-      // Query for session mode
-      navigator.xr!.isSessionSupported('immersive-vr').then((supported) => {
-        supported ? showEnterVR() : showWebXRNotFound()
+      if ('xr' in navigator) {
+        stylizeElement(button)
+        button.id = 'VRButton'
+        button.style.display = 'none'
 
-        if (supported && VRButton.xrSessionIsGranted) {
-          button.click()
-        }
-      })
+        // Query for session mode
+        navigator.xr!.isSessionSupported('immersive-vr').then((supported) => {
+          supported ? showEnterVR() : showWebXRNotFound()
 
-      return button
-    } else {
-      const message = document.createElement('a')
+          if (supported && VRButton.xrSessionIsGranted) {
+            button.click()
+          }
+        })
 
-      if (window.isSecureContext === false) {
-        message.href = document.location.href.replace(/^http:/, 'https:')
-        message.innerHTML = 'WEBXR NEEDS HTTPS' // TODO Improve message
+        return button
       } else {
-        message.href = 'https://immersiveweb.dev/'
-        message.innerHTML = 'WEBXR NOT AVAILABLE'
-      }
+        const message = document.createElement('a')
 
-      message.style.left = 'calc(50% - 90px)'
-      message.style.width = '180px'
-      message.style.textDecoration = 'none'
+        if (window.isSecureContext === false) {
+          message.href = document.location.href.replace(/^http:/, 'https:')
+          message.innerHTML = 'WEBXR NEEDS HTTPS' // TODO Improve message
+        } else {
+          message.href = 'https://immersiveweb.dev/'
+          message.innerHTML = 'WEBXR NOT AVAILABLE'
+        }
 
-      stylizeElement(message)
+        message.style.left = 'calc(50% - 90px)'
+        message.style.width = '180px'
+        message.style.textDecoration = 'none'
 
-      return message
+        stylizeElement(message)
+
+        return message
+      }
     }
-  }
 
-  static xrSessionIsGranted = false
+    static xrSessionIsGranted = false
 
-  static registerSessionGrantedListener(): void {
-    if (typeof navigator !== 'undefined' && 'xr' in navigator) {
-      ;(navigator as Navigator).xr!.addEventListener('sessiongranted', () => {
-        VRButton.xrSessionIsGranted = true
-      })
+    static registerSessionGrantedListener(): void {
+      if (typeof navigator !== 'undefined' && 'xr' in navigator) {
+        ;(navigator as Navigator).xr!.addEventListener('sessiongranted', () => {
+          VRButton.xrSessionIsGranted = true
+        })
+      }
     }
   }
-}
 
-VRButton.registerSessionGrantedListener()
+  VRButton.registerSessionGrantedListener()
+
+  return VRButton
+})()
 
 export { VRButton }
diff --git a/src/webxr/XRHandPrimitiveModel.js b/src/webxr/XRHandPrimitiveModel.js
index 9e98456a..a967f563 100644
--- a/src/webxr/XRHandPrimitiveModel.js
+++ b/src/webxr/XRHandPrimitiveModel.js
@@ -8,8 +8,8 @@ import {
   Vector3,
 } from 'three'
 
-const _matrix = new Matrix4()
-const _vector = new Vector3()
+const _matrix = /* @__PURE__ */ new Matrix4()
+const _vector = /* @__PURE__ */ new Vector3()
 
 class XRHandPrimitiveModel {
   constructor(handModel, controller, path, handedness, options) {

From bc97e0812f99a79e18d4149882552bdcd497dc72 Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Wed, 8 Jan 2025 13:37:36 -0600
Subject: [PATCH 34/36] fix: revert tree-shaking around use of classes

TypeScript cannot see that the result is the same whether an IIFE or a class using modern static keywords.
---
 src/_polyfill/CapsuleGeometry.js           |   36 +-
 src/_polyfill/constants.ts                 |    2 +-
 src/animation/AnimationClipCreator.js      |   26 +-
 src/animation/CCDIKSolver.js               |   22 +-
 src/animation/MMDAnimationHelper.js        |    2 +-
 src/animation/MMDPhysics.js                |    8 +-
 src/controls/ArcballControls.ts            |    4 +-
 src/controls/FirstPersonControls.ts        |    2 +-
 src/controls/OrbitControls.ts              |   17 +-
 src/controls/PointerLockControls.ts        |   10 +-
 src/csm/CSM.js                             |    8 +-
 src/csm/CSMFrustum.js                      |    2 +-
 src/deprecated/Geometry.js                 | 1614 ++++----
 src/effects/AnaglyphEffect.js              |    4 +-
 src/effects/OutlineEffect.js               |    5 +-
 src/effects/ParallaxBarrierEffect.js       |    4 +-
 src/exporters/DRACOExporter.ts             |  302 +-
 src/exporters/GLTFExporter.js              |  392 +-
 src/geometries/LightningStrike.js          | 1314 ++++---
 src/geometries/RoundedBoxGeometry.js       |    2 +-
 src/helpers/RaycasterHelper.ts             |    4 +-
 src/helpers/VertexNormalsHelper.js         |    6 +-
 src/helpers/VertexTangentsHelper.js        |    4 +-
 src/interactive/InteractiveGroup.js        |    2 +-
 src/interactive/SelectionBox.js            |   30 +-
 src/libs/chevrotain.js                     |    2 +-
 src/libs/lottie.js                         |    2 +-
 src/libs/opentype.js                       |    2 +-
 src/lights/LightProbeGenerator.js          |   10 +-
 src/lights/RectAreaLightUniformsLib.js     |    6 +-
 src/lines/LineMaterial.js                  |    5 +-
 src/lines/LineSegments2.js                 |   51 +-
 src/lines/LineSegmentsGeometry.js          |    4 +-
 src/lines/Wireframe.js                     |   16 +-
 src/loaders/BasisTextureLoader.js          |  963 +++--
 src/loaders/EXRLoader.js                   |    4 +-
 src/loaders/FBXLoader.js                   |    8 +-
 src/loaders/FontLoader.ts                  |    4 +-
 src/loaders/GLTFLoader.js                  |    4 +-
 src/loaders/KTX2Loader.js                  |  876 +++--
 src/loaders/LDrawLoader.js                 |   10 +-
 src/loaders/OBJLoader.js                   |   10 +-
 src/loaders/PRWMLoader.js                  |  104 +-
 src/loaders/SVGLoader.js                   | 3953 ++++++++++----------
 src/loaders/XLoader.js                     |    2 +-
 src/math/Capsule.js                        |    6 +-
 src/math/ColorConverter.js                 |   18 +-
 src/math/ConvexHull.js                     |  110 +-
 src/math/ImprovedNoise.js                  |    2 +-
 src/math/MeshSurfaceSampler.js             |    4 +-
 src/math/OBB.js                            |   28 +-
 src/math/Octree.js                         |   14 +-
 src/misc/ConvexObjectBreaker.js            |  658 ++--
 src/misc/Gyroscope.js                      |   12 +-
 src/modifiers/CurveModifier.ts             |    2 +-
 src/modifiers/SimplifyModifier.ts          |    4 +-
 src/objects/BatchedMesh.ts                 |    4 +-
 src/objects/GroundProjectedEnv.ts          |   14 +-
 src/objects/Lensflare.js                   |  390 +-
 src/objects/Reflector.js                   |  291 +-
 src/objects/ReflectorForSSRPass.js         |  384 +-
 src/objects/Refractor.js                   |  352 +-
 src/objects/ShadowMesh.js                  |    2 +-
 src/objects/Sky.ts                         |   86 +-
 src/objects/Water.js                       |    4 +-
 src/objects/Water2.js                      |  312 +-
 src/postprocessing/SAOPass.js              |  616 ++-
 src/postprocessing/SSAOPass.js             |  572 ++-
 src/postprocessing/SSRPass.js              |  932 +++--
 src/postprocessing/UnrealBloomPass.js      |  456 ++-
 src/renderers/CSS2DRenderer.js             |   10 +-
 src/renderers/CSS3DRenderer.js             |   10 +-
 src/shaders/ACESFilmicToneMappingShader.ts |   87 +-
 src/shaders/AfterimageShader.ts            |   44 +-
 src/shaders/BasicShader.ts                 |   18 +-
 src/shaders/BleachBypassShader.ts          |   52 +-
 src/shaders/BlendShader.ts                 |   38 +-
 src/shaders/BokehShader.ts                 |  224 +-
 src/shaders/BokehShader2.ts                |  464 +--
 src/shaders/BrightnessContrastShader.ts    |   44 +-
 src/shaders/ColorCorrectionShader.ts       |   42 +-
 src/shaders/ColorifyShader.ts              |   38 +-
 src/shaders/ConvolutionShader.ts           |   48 +-
 src/shaders/CopyShader.ts                  |   32 +-
 src/shaders/DOFMipMapShader.ts             |   42 +-
 src/shaders/DepthLimitedBlurShader.ts      |  148 +-
 src/shaders/DigitalGlitch.ts               |  123 +-
 src/shaders/DotScreenShader.ts             |   56 +-
 src/shaders/FXAAShader.ts                  | 2178 +++++------
 src/shaders/FilmShader.ts                  |   58 +-
 src/shaders/FocusShader.ts                 |   86 +-
 src/shaders/FreiChenShader.ts              |  114 +-
 src/shaders/FresnelShader.ts               |   70 +-
 src/shaders/GammaCorrectionShader.ts       |   38 +-
 src/shaders/GodRaysShader.ts               |  196 +-
 src/shaders/HalftoneShader.ts              |  400 +-
 src/shaders/HorizontalTiltShiftShader.ts   |   54 +-
 src/shaders/HueSaturationShader.ts         |   64 +-
 src/shaders/KaleidoShader.ts               |   48 +-
 src/shaders/LuminosityHighPassShader.ts    |   48 +-
 src/shaders/LuminosityShader.ts            |   34 +-
 src/shaders/MirrorShader.ts                |   52 +-
 src/shaders/NormalMapShader.ts             |   42 +-
 src/shaders/ParallaxShader.ts              |  188 +-
 src/shaders/PixelShader.ts                 |   36 +-
 src/shaders/RGBShiftShader.ts              |   40 +-
 src/shaders/SAOShader.ts                   |  296 +-
 src/shaders/SMAAShader.ts                  |  478 +--
 src/shaders/SSAOShader.ts                  |  266 +-
 src/shaders/SSRShader.ts                   |    8 +-
 src/shaders/SepiaShader.ts                 |   40 +-
 src/shaders/SobelOperatorShader.ts         |   70 +-
 src/shaders/TechnicolorShader.ts           |   32 +-
 src/shaders/ToneMapShader.ts               |   70 +-
 src/shaders/ToonShader.ts                  |  330 +-
 src/shaders/TriangleBlurShader.ts          |   54 +-
 src/shaders/UnpackDepthRGBAShader.ts       |   34 +-
 src/shaders/VerticalTiltShiftShader.ts     |   54 +-
 src/shaders/VignetteShader.ts              |   38 +-
 src/shaders/VolumeShader.ts                |  516 +--
 src/shaders/WaterRefractionShader.ts       |   70 +-
 src/utils/GeometryCompressionUtils.js      |    4 +-
 src/utils/LDrawUtils.js                    |    6 +-
 src/utils/RoughnessMipmapper.js            |    6 +-
 src/webxr/ARButton.ts                      |  249 +-
 src/webxr/OculusHandPointerModel.js        |    4 +-
 src/webxr/VRButton.ts                      |  225 +-
 src/webxr/XRHandPrimitiveModel.js          |    4 +-
 128 files changed, 11559 insertions(+), 11692 deletions(-)

diff --git a/src/_polyfill/CapsuleGeometry.js b/src/_polyfill/CapsuleGeometry.js
index 8a5fc0ff..c2e655a5 100644
--- a/src/_polyfill/CapsuleGeometry.js
+++ b/src/_polyfill/CapsuleGeometry.js
@@ -1,30 +1,26 @@
 import { Path, LatheGeometry } from 'three'
 
-const CapsuleGeometry = /* @__PURE__ */ (() => {
-  class CapsuleGeometry extends LatheGeometry {
-    constructor(radius = 1, length = 1, capSegments = 4, radialSegments = 8) {
-      const path = new Path()
-      path.absarc(0, -length / 2, radius, Math.PI * 1.5, 0)
-      path.absarc(0, length / 2, radius, 0, Math.PI * 0.5)
+class CapsuleGeometry extends LatheGeometry {
+  constructor(radius = 1, length = 1, capSegments = 4, radialSegments = 8) {
+    const path = new Path()
+    path.absarc(0, -length / 2, radius, Math.PI * 1.5, 0)
+    path.absarc(0, length / 2, radius, 0, Math.PI * 0.5)
 
-      super(path.getPoints(capSegments), radialSegments)
+    super(path.getPoints(capSegments), radialSegments)
 
-      this.type = 'CapsuleGeometry'
+    this.type = 'CapsuleGeometry'
 
-      this.parameters = {
-        radius: radius,
-        height: length,
-        capSegments: capSegments,
-        radialSegments: radialSegments,
-      }
-    }
-
-    static fromJSON(data) {
-      return new CapsuleGeometry(data.radius, data.length, data.capSegments, data.radialSegments)
+    this.parameters = {
+      radius: radius,
+      height: length,
+      capSegments: capSegments,
+      radialSegments: radialSegments,
     }
   }
 
-  return CapsuleGeometry
-})()
+  static fromJSON(data) {
+    return new CapsuleGeometry(data.radius, data.length, data.capSegments, data.radialSegments)
+  }
+}
 
 export { CapsuleGeometry }
diff --git a/src/_polyfill/constants.ts b/src/_polyfill/constants.ts
index aabfc441..1237ca1f 100644
--- a/src/_polyfill/constants.ts
+++ b/src/_polyfill/constants.ts
@@ -1,3 +1,3 @@
 import { REVISION } from 'three'
 
-export const version = /* @__PURE__ */ (() => parseInt(REVISION.replace(/\D+/g, '')))()
+export const version = parseInt(REVISION.replace(/\D+/g, ''))
diff --git a/src/animation/AnimationClipCreator.js b/src/animation/AnimationClipCreator.js
index 23ea4050..2befa398 100644
--- a/src/animation/AnimationClipCreator.js
+++ b/src/animation/AnimationClipCreator.js
@@ -7,8 +7,8 @@ import {
   VectorKeyframeTrack,
 } from 'three'
 
-const AnimationClipCreator = {
-  CreateRotationAnimation(period, axis = 'x') {
+class AnimationClipCreator {
+  static CreateRotationAnimation(period, axis = 'x') {
     const times = [0, period],
       values = [0, 360]
 
@@ -17,9 +17,9 @@ const AnimationClipCreator = {
     const track = new NumberKeyframeTrack(trackName, times, values)
 
     return new AnimationClip(null, period, [track])
-  },
+  }
 
-  CreateScaleAxisAnimation(period, axis = 'x') {
+  static CreateScaleAxisAnimation(period, axis = 'x') {
     const times = [0, period],
       values = [0, 1]
 
@@ -28,9 +28,9 @@ const AnimationClipCreator = {
     const track = new NumberKeyframeTrack(trackName, times, values)
 
     return new AnimationClip(null, period, [track])
-  },
+  }
 
-  CreateShakeAnimation(duration, shakeScale) {
+  static CreateShakeAnimation(duration, shakeScale) {
     const times = [],
       values = [],
       tmp = new Vector3()
@@ -49,9 +49,9 @@ const AnimationClipCreator = {
     const track = new VectorKeyframeTrack(trackName, times, values)
 
     return new AnimationClip(null, duration, [track])
-  },
+  }
 
-  CreatePulsationAnimation(duration, pulseScale) {
+  static CreatePulsationAnimation(duration, pulseScale) {
     const times = [],
       values = [],
       tmp = new Vector3()
@@ -68,9 +68,9 @@ const AnimationClipCreator = {
     const track = new VectorKeyframeTrack(trackName, times, values)
 
     return new AnimationClip(null, duration, [track])
-  },
+  }
 
-  CreateVisibilityAnimation(duration) {
+  static CreateVisibilityAnimation(duration) {
     const times = [0, duration / 2, duration],
       values = [true, false, true]
 
@@ -79,9 +79,9 @@ const AnimationClipCreator = {
     const track = new BooleanKeyframeTrack(trackName, times, values)
 
     return new AnimationClip(null, duration, [track])
-  },
+  }
 
-  CreateMaterialColorAnimation(duration, colors) {
+  static CreateMaterialColorAnimation(duration, colors) {
     const times = [],
       values = [],
       timeStep = duration / colors.length
@@ -98,7 +98,7 @@ const AnimationClipCreator = {
     const track = new ColorKeyframeTrack(trackName, times, values)
 
     return new AnimationClip(null, duration, [track])
-  },
+  }
 }
 
 export { AnimationClipCreator }
diff --git a/src/animation/CCDIKSolver.js b/src/animation/CCDIKSolver.js
index 75fff7e4..0e5650a0 100644
--- a/src/animation/CCDIKSolver.js
+++ b/src/animation/CCDIKSolver.js
@@ -13,17 +13,17 @@ import {
   Vector3,
 } from 'three'
 
-const _q = /* @__PURE__ */ new Quaternion()
-const _targetPos = /* @__PURE__ */ new Vector3()
-const _targetVec = /* @__PURE__ */ new Vector3()
-const _effectorPos = /* @__PURE__ */ new Vector3()
-const _effectorVec = /* @__PURE__ */ new Vector3()
-const _linkPos = /* @__PURE__ */ new Vector3()
-const _invLinkQ = /* @__PURE__ */ new Quaternion()
-const _linkScale = /* @__PURE__ */ new Vector3()
-const _axis = /* @__PURE__ */ new Vector3()
-const _vector = /* @__PURE__ */ new Vector3()
-const _matrix = /* @__PURE__ */ new Matrix4()
+const _q = new Quaternion()
+const _targetPos = new Vector3()
+const _targetVec = new Vector3()
+const _effectorPos = new Vector3()
+const _effectorVec = new Vector3()
+const _linkPos = new Vector3()
+const _invLinkQ = new Quaternion()
+const _linkScale = new Vector3()
+const _axis = new Vector3()
+const _vector = new Vector3()
+const _matrix = new Matrix4()
 
 /**
  * CCD Algorithm
diff --git a/src/animation/MMDAnimationHelper.js b/src/animation/MMDAnimationHelper.js
index 396c7424..8ec13284 100644
--- a/src/animation/MMDAnimationHelper.js
+++ b/src/animation/MMDAnimationHelper.js
@@ -861,7 +861,7 @@ class AudioManager {
   }
 }
 
-const _q = /* @__PURE__ */ new Quaternion()
+const _q = new Quaternion()
 
 /**
  * Solver for Grant (Fuyo in Japanese. I just google translated because
diff --git a/src/animation/MMDPhysics.js b/src/animation/MMDPhysics.js
index 22ea4ea2..c11992cc 100644
--- a/src/animation/MMDPhysics.js
+++ b/src/animation/MMDPhysics.js
@@ -1001,10 +1001,10 @@ class Constraint {
   }
 }
 
-const _position = /* @__PURE__ */ new Vector3()
-const _quaternion = /* @__PURE__ */ new Quaternion()
-const _scale = /* @__PURE__ */ new Vector3()
-const _matrixWorldInv = /* @__PURE__ */ new Matrix4()
+const _position = new Vector3()
+const _quaternion = new Quaternion()
+const _scale = new Vector3()
+const _matrixWorldInv = new Matrix4()
 
 class MMDPhysicsHelper extends Object3D {
   /**
diff --git a/src/controls/ArcballControls.ts b/src/controls/ArcballControls.ts
index c048168f..9a64a49c 100644
--- a/src/controls/ArcballControls.ts
+++ b/src/controls/ArcballControls.ts
@@ -68,8 +68,8 @@ const _center = {
 
 //transformation matrices for gizmos and camera
 const _transformation: Transformation = {
-  camera: /* @__PURE__ */ new Matrix4(),
-  gizmos: /* @__PURE__ */ new Matrix4(),
+  camera: new Matrix4(),
+  gizmos: new Matrix4(),
 }
 
 //events
diff --git a/src/controls/FirstPersonControls.ts b/src/controls/FirstPersonControls.ts
index bc40ae9b..b69983f6 100644
--- a/src/controls/FirstPersonControls.ts
+++ b/src/controls/FirstPersonControls.ts
@@ -2,7 +2,7 @@ import { MathUtils, Spherical, Vector3, Camera } from 'three'
 import { EventDispatcher } from './EventDispatcher'
 import { StandardControlsEventMap } from './StandardControlsEventMap'
 
-const targetPosition = /* @__PURE__ */ new Vector3()
+const targetPosition = new Vector3()
 
 export class FirstPersonControls extends EventDispatcher<{}> {
   public object: Camera
diff --git a/src/controls/OrbitControls.ts b/src/controls/OrbitControls.ts
index cad6a154..93d8a764 100644
--- a/src/controls/OrbitControls.ts
+++ b/src/controls/OrbitControls.ts
@@ -14,8 +14,8 @@ import {
 import { EventDispatcher } from './EventDispatcher'
 import { StandardControlsEventMap } from './StandardControlsEventMap'
 
-const _ray = /* @__PURE__ */ new Ray()
-const _plane = /* @__PURE__ */ new Plane()
+const _ray = new Ray()
+const _plane = new Plane()
 const TILT_LIMIT = Math.cos(70 * (Math.PI / 180))
 
 // This set of controls performs orbiting, dollying (zooming), and panning.
@@ -119,6 +119,7 @@ class OrbitControls extends EventDispatcher<StandardControlsEventMap> {
   getScale: () => number
   // Set the current scale (these are not used in most scenarios, however they can be useful for specific use cases)
   setScale: (newScale: number) => void
+  
 
   constructor(object: PerspectiveCamera | OrthographicCamera, domElement?: HTMLElement) {
     super()
@@ -1095,21 +1096,21 @@ class OrbitControls extends EventDispatcher<StandardControlsEventMap> {
     }
 
     this.dollyOut = (dollyScale = getZoomScale()) => {
-      dollyOut(dollyScale)
-      scope.update()
+        dollyOut(dollyScale)
+        scope.update()
     }
 
     this.getScale = () => {
-      return scale
+        return scale;
     }
 
     this.setScale = (newScale) => {
-      setScale(newScale)
-      scope.update()
+        setScale(newScale)
+        scope.update()
     }
 
     this.getZoomScale = () => {
-      return getZoomScale()
+        return getZoomScale();
     }
 
     // connect events
diff --git a/src/controls/PointerLockControls.ts b/src/controls/PointerLockControls.ts
index 19d6fd0f..ee93891e 100644
--- a/src/controls/PointerLockControls.ts
+++ b/src/controls/PointerLockControls.ts
@@ -1,8 +1,8 @@
 import { Euler, Camera, Vector3 } from 'three'
 import { EventDispatcher } from './EventDispatcher'
 
-const _euler = /* @__PURE__ */ new Euler(0, 0, 0, 'YXZ')
-const _vector = /* @__PURE__ */ new Vector3()
+const _euler = new Euler(0, 0, 0, 'YXZ')
+const _vector = new Vector3()
 const _changeEvent = { type: 'change' }
 const _lockEvent = { type: 'lock' }
 const _unlockEvent = { type: 'unlock' }
@@ -12,17 +12,17 @@ export interface PointerLockControlsEventMap {
   /**
    * Fires when the user moves the mouse.
    */
-  change: {}
+  change: {};
 
   /**
    * Fires when the pointer lock status is "locked" (in other words: the mouse is captured).
    */
-  lock: {}
+  lock: {};
 
   /**
    * Fires when the pointer lock status is "unlocked" (in other words: the mouse is not captured anymore).
    */
-  unlock: {}
+  unlock: {};
 }
 
 class PointerLockControls extends EventDispatcher<PointerLockControlsEventMap> {
diff --git a/src/csm/CSM.js b/src/csm/CSM.js
index ce5359af..afa6cdee 100644
--- a/src/csm/CSM.js
+++ b/src/csm/CSM.js
@@ -2,10 +2,10 @@ import { Vector2, Vector3, DirectionalLight, MathUtils, ShaderChunk, Matrix4, Bo
 import { CSMFrustum } from './CSMFrustum'
 import { CSMShader } from './CSMShader'
 
-const _cameraToLightMatrix = /* @__PURE__ */ new Matrix4()
-const _lightSpaceFrustum = /* @__PURE__ */ new CSMFrustum()
-const _center = /* @__PURE__ */ new Vector3()
-const _bbox = /* @__PURE__ */ new Box3()
+const _cameraToLightMatrix = new Matrix4()
+const _lightSpaceFrustum = new CSMFrustum()
+const _center = new Vector3()
+const _bbox = new Box3()
 const _uniformArray = []
 const _logArray = []
 
diff --git a/src/csm/CSMFrustum.js b/src/csm/CSMFrustum.js
index 3e375417..ab8f7d15 100644
--- a/src/csm/CSMFrustum.js
+++ b/src/csm/CSMFrustum.js
@@ -1,6 +1,6 @@
 import { Vector3, Matrix4 } from 'three'
 
-const inverseProjectionMatrix = /* @__PURE__ */ new Matrix4()
+const inverseProjectionMatrix = new Matrix4()
 
 class CSMFrustum {
   constructor(data) {
diff --git a/src/deprecated/Geometry.js b/src/deprecated/Geometry.js
index c720b2a2..d4d5afc2 100644
--- a/src/deprecated/Geometry.js
+++ b/src/deprecated/Geometry.js
@@ -14,300 +14,330 @@ import {
   Vector3,
 } from 'three'
 
-const _m1 = /* @__PURE__ */ new Matrix4()
-const _obj = /* @__PURE__ */ new Object3D()
-const _offset = /* @__PURE__ */ new Vector3()
+const _m1 = new Matrix4()
+const _obj = new Object3D()
+const _offset = new Vector3()
 
-const Geometry = /* @__PURE__ */ (() => {
-  class Geometry extends EventDispatcher {
-    static createBufferGeometryFromObject(object) {
-      let buffergeometry = new BufferGeometry()
+class Geometry extends EventDispatcher {
+  static createBufferGeometryFromObject(object) {
+    let buffergeometry = new BufferGeometry()
 
-      const geometry = object.geometry
+    const geometry = object.geometry
 
-      if (object.isPoints || object.isLine) {
-        const positions = new Float32BufferAttribute(geometry.vertices.length * 3, 3)
-        const colors = new Float32BufferAttribute(geometry.colors.length * 3, 3)
+    if (object.isPoints || object.isLine) {
+      const positions = new Float32BufferAttribute(geometry.vertices.length * 3, 3)
+      const colors = new Float32BufferAttribute(geometry.colors.length * 3, 3)
 
-        buffergeometry.setAttribute('position', positions.copyVector3sArray(geometry.vertices))
-        buffergeometry.setAttribute('color', colors.copyColorsArray(geometry.colors))
+      buffergeometry.setAttribute('position', positions.copyVector3sArray(geometry.vertices))
+      buffergeometry.setAttribute('color', colors.copyColorsArray(geometry.colors))
 
-        if (geometry.lineDistances && geometry.lineDistances.length === geometry.vertices.length) {
-          const lineDistances = new Float32BufferAttribute(geometry.lineDistances.length, 1)
+      if (geometry.lineDistances && geometry.lineDistances.length === geometry.vertices.length) {
+        const lineDistances = new Float32BufferAttribute(geometry.lineDistances.length, 1)
 
-          buffergeometry.setAttribute('lineDistance', lineDistances.copyArray(geometry.lineDistances))
-        }
-
-        if (geometry.boundingSphere !== null) {
-          buffergeometry.boundingSphere = geometry.boundingSphere.clone()
-        }
+        buffergeometry.setAttribute('lineDistance', lineDistances.copyArray(geometry.lineDistances))
+      }
 
-        if (geometry.boundingBox !== null) {
-          buffergeometry.boundingBox = geometry.boundingBox.clone()
-        }
-      } else if (object.isMesh) {
-        buffergeometry = geometry.toBufferGeometry()
+      if (geometry.boundingSphere !== null) {
+        buffergeometry.boundingSphere = geometry.boundingSphere.clone()
       }
 
-      return buffergeometry
+      if (geometry.boundingBox !== null) {
+        buffergeometry.boundingBox = geometry.boundingBox.clone()
+      }
+    } else if (object.isMesh) {
+      buffergeometry = geometry.toBufferGeometry()
     }
 
-    constructor() {
-      super()
-      this.isGeometry = true
-      this.uuid = MathUtils.generateUUID()
+    return buffergeometry
+  }
 
-      this.name = ''
-      this.type = 'Geometry'
+  constructor() {
+    super()
+    this.isGeometry = true
+    this.uuid = MathUtils.generateUUID()
 
-      this.vertices = []
-      this.colors = []
-      this.faces = []
-      this.faceVertexUvs = [[]]
+    this.name = ''
+    this.type = 'Geometry'
 
-      this.morphTargets = []
-      this.morphNormals = []
+    this.vertices = []
+    this.colors = []
+    this.faces = []
+    this.faceVertexUvs = [[]]
 
-      this.skinWeights = []
-      this.skinIndices = []
+    this.morphTargets = []
+    this.morphNormals = []
 
-      this.lineDistances = []
+    this.skinWeights = []
+    this.skinIndices = []
 
-      this.boundingBox = null
-      this.boundingSphere = null
+    this.lineDistances = []
 
-      // update flags
+    this.boundingBox = null
+    this.boundingSphere = null
 
-      this.elementsNeedUpdate = false
-      this.verticesNeedUpdate = false
-      this.uvsNeedUpdate = false
-      this.normalsNeedUpdate = false
-      this.colorsNeedUpdate = false
-      this.lineDistancesNeedUpdate = false
-      this.groupsNeedUpdate = false
+    // update flags
+
+    this.elementsNeedUpdate = false
+    this.verticesNeedUpdate = false
+    this.uvsNeedUpdate = false
+    this.normalsNeedUpdate = false
+    this.colorsNeedUpdate = false
+    this.lineDistancesNeedUpdate = false
+    this.groupsNeedUpdate = false
+  }
+
+  applyMatrix4(matrix) {
+    const normalMatrix = new Matrix3().getNormalMatrix(matrix)
+
+    for (let i = 0, il = this.vertices.length; i < il; i++) {
+      const vertex = this.vertices[i]
+      vertex.applyMatrix4(matrix)
     }
 
-    applyMatrix4(matrix) {
-      const normalMatrix = new Matrix3().getNormalMatrix(matrix)
+    for (let i = 0, il = this.faces.length; i < il; i++) {
+      const face = this.faces[i]
+      face.normal.applyMatrix3(normalMatrix).normalize()
 
-      for (let i = 0, il = this.vertices.length; i < il; i++) {
-        const vertex = this.vertices[i]
-        vertex.applyMatrix4(matrix)
+      for (let j = 0, jl = face.vertexNormals.length; j < jl; j++) {
+        face.vertexNormals[j].applyMatrix3(normalMatrix).normalize()
       }
+    }
 
-      for (let i = 0, il = this.faces.length; i < il; i++) {
-        const face = this.faces[i]
-        face.normal.applyMatrix3(normalMatrix).normalize()
+    if (this.boundingBox !== null) {
+      this.computeBoundingBox()
+    }
 
-        for (let j = 0, jl = face.vertexNormals.length; j < jl; j++) {
-          face.vertexNormals[j].applyMatrix3(normalMatrix).normalize()
-        }
-      }
+    if (this.boundingSphere !== null) {
+      this.computeBoundingSphere()
+    }
 
-      if (this.boundingBox !== null) {
-        this.computeBoundingBox()
-      }
+    this.verticesNeedUpdate = true
+    this.normalsNeedUpdate = true
 
-      if (this.boundingSphere !== null) {
-        this.computeBoundingSphere()
-      }
+    return this
+  }
 
-      this.verticesNeedUpdate = true
-      this.normalsNeedUpdate = true
+  rotateX(angle) {
+    // rotate geometry around world x-axis
 
-      return this
-    }
+    _m1.makeRotationX(angle)
 
-    rotateX(angle) {
-      // rotate geometry around world x-axis
+    this.applyMatrix4(_m1)
 
-      _m1.makeRotationX(angle)
+    return this
+  }
 
-      this.applyMatrix4(_m1)
+  rotateY(angle) {
+    // rotate geometry around world y-axis
 
-      return this
-    }
+    _m1.makeRotationY(angle)
 
-    rotateY(angle) {
-      // rotate geometry around world y-axis
+    this.applyMatrix4(_m1)
 
-      _m1.makeRotationY(angle)
+    return this
+  }
 
-      this.applyMatrix4(_m1)
+  rotateZ(angle) {
+    // rotate geometry around world z-axis
 
-      return this
-    }
+    _m1.makeRotationZ(angle)
 
-    rotateZ(angle) {
-      // rotate geometry around world z-axis
+    this.applyMatrix4(_m1)
 
-      _m1.makeRotationZ(angle)
+    return this
+  }
 
-      this.applyMatrix4(_m1)
+  translate(x, y, z) {
+    // translate geometry
 
-      return this
-    }
+    _m1.makeTranslation(x, y, z)
 
-    translate(x, y, z) {
-      // translate geometry
+    this.applyMatrix4(_m1)
 
-      _m1.makeTranslation(x, y, z)
+    return this
+  }
 
-      this.applyMatrix4(_m1)
+  scale(x, y, z) {
+    // scale geometry
 
-      return this
-    }
+    _m1.makeScale(x, y, z)
 
-    scale(x, y, z) {
-      // scale geometry
+    this.applyMatrix4(_m1)
 
-      _m1.makeScale(x, y, z)
+    return this
+  }
 
-      this.applyMatrix4(_m1)
+  lookAt(vector) {
+    _obj.lookAt(vector)
 
-      return this
-    }
+    _obj.updateMatrix()
 
-    lookAt(vector) {
-      _obj.lookAt(vector)
+    this.applyMatrix4(_obj.matrix)
 
-      _obj.updateMatrix()
+    return this
+  }
+
+  fromBufferGeometry(geometry) {
+    const scope = this
 
-      this.applyMatrix4(_obj.matrix)
+    const index = geometry.index !== null ? geometry.index : undefined
+    const attributes = geometry.attributes
 
+    if (attributes.position === undefined) {
+      console.error('THREE.Geometry.fromBufferGeometry(): Position attribute required for conversion.')
       return this
     }
 
-    fromBufferGeometry(geometry) {
-      const scope = this
+    const position = attributes.position
+    const normal = attributes.normal
+    const color = attributes.color
+    const uv = attributes.uv
+    const uv2 = attributes.uv2
+
+    if (uv2 !== undefined) this.faceVertexUvs[1] = []
 
-      const index = geometry.index !== null ? geometry.index : undefined
-      const attributes = geometry.attributes
+    for (let i = 0; i < position.count; i++) {
+      scope.vertices.push(new Vector3().fromBufferAttribute(position, i))
 
-      if (attributes.position === undefined) {
-        console.error('THREE.Geometry.fromBufferGeometry(): Position attribute required for conversion.')
-        return this
+      if (color !== undefined) {
+        scope.colors.push(new Color().fromBufferAttribute(color, i))
       }
+    }
 
-      const position = attributes.position
-      const normal = attributes.normal
-      const color = attributes.color
-      const uv = attributes.uv
-      const uv2 = attributes.uv2
+    function addFace(a, b, c, materialIndex) {
+      const vertexColors =
+        color === undefined ? [] : [scope.colors[a].clone(), scope.colors[b].clone(), scope.colors[c].clone()]
 
-      if (uv2 !== undefined) this.faceVertexUvs[1] = []
+      const vertexNormals =
+        normal === undefined
+          ? []
+          : [
+              new Vector3().fromBufferAttribute(normal, a),
+              new Vector3().fromBufferAttribute(normal, b),
+              new Vector3().fromBufferAttribute(normal, c),
+            ]
 
-      for (let i = 0; i < position.count; i++) {
-        scope.vertices.push(new Vector3().fromBufferAttribute(position, i))
+      const face = new Face3(a, b, c, vertexNormals, vertexColors, materialIndex)
 
-        if (color !== undefined) {
-          scope.colors.push(new Color().fromBufferAttribute(color, i))
-        }
-      }
+      scope.faces.push(face)
 
-      function addFace(a, b, c, materialIndex) {
-        const vertexColors =
-          color === undefined ? [] : [scope.colors[a].clone(), scope.colors[b].clone(), scope.colors[c].clone()]
-
-        const vertexNormals =
-          normal === undefined
-            ? []
-            : [
-                new Vector3().fromBufferAttribute(normal, a),
-                new Vector3().fromBufferAttribute(normal, b),
-                new Vector3().fromBufferAttribute(normal, c),
-              ]
-
-        const face = new Face3(a, b, c, vertexNormals, vertexColors, materialIndex)
-
-        scope.faces.push(face)
-
-        if (uv !== undefined) {
-          scope.faceVertexUvs[0].push([
-            new Vector2().fromBufferAttribute(uv, a),
-            new Vector2().fromBufferAttribute(uv, b),
-            new Vector2().fromBufferAttribute(uv, c),
-          ])
-        }
+      if (uv !== undefined) {
+        scope.faceVertexUvs[0].push([
+          new Vector2().fromBufferAttribute(uv, a),
+          new Vector2().fromBufferAttribute(uv, b),
+          new Vector2().fromBufferAttribute(uv, c),
+        ])
+      }
 
-        if (uv2 !== undefined) {
-          scope.faceVertexUvs[1].push([
-            new Vector2().fromBufferAttribute(uv2, a),
-            new Vector2().fromBufferAttribute(uv2, b),
-            new Vector2().fromBufferAttribute(uv2, c),
-          ])
-        }
+      if (uv2 !== undefined) {
+        scope.faceVertexUvs[1].push([
+          new Vector2().fromBufferAttribute(uv2, a),
+          new Vector2().fromBufferAttribute(uv2, b),
+          new Vector2().fromBufferAttribute(uv2, c),
+        ])
       }
+    }
 
-      const groups = geometry.groups
+    const groups = geometry.groups
 
-      if (groups.length > 0) {
-        for (let i = 0; i < groups.length; i++) {
-          const group = groups[i]
+    if (groups.length > 0) {
+      for (let i = 0; i < groups.length; i++) {
+        const group = groups[i]
 
-          const start = group.start
-          const count = group.count
+        const start = group.start
+        const count = group.count
 
-          for (let j = start, jl = start + count; j < jl; j += 3) {
-            if (index !== undefined) {
-              addFace(index.getX(j), index.getX(j + 1), index.getX(j + 2), group.materialIndex)
-            } else {
-              addFace(j, j + 1, j + 2, group.materialIndex)
-            }
+        for (let j = start, jl = start + count; j < jl; j += 3) {
+          if (index !== undefined) {
+            addFace(index.getX(j), index.getX(j + 1), index.getX(j + 2), group.materialIndex)
+          } else {
+            addFace(j, j + 1, j + 2, group.materialIndex)
           }
         }
+      }
+    } else {
+      if (index !== undefined) {
+        for (let i = 0; i < index.count; i += 3) {
+          addFace(index.getX(i), index.getX(i + 1), index.getX(i + 2))
+        }
       } else {
-        if (index !== undefined) {
-          for (let i = 0; i < index.count; i += 3) {
-            addFace(index.getX(i), index.getX(i + 1), index.getX(i + 2))
-          }
-        } else {
-          for (let i = 0; i < position.count; i += 3) {
-            addFace(i, i + 1, i + 2)
-          }
+        for (let i = 0; i < position.count; i += 3) {
+          addFace(i, i + 1, i + 2)
         }
       }
+    }
 
-      this.computeFaceNormals()
-
-      if (geometry.boundingBox !== null) {
-        this.boundingBox = geometry.boundingBox.clone()
-      }
+    this.computeFaceNormals()
 
-      if (geometry.boundingSphere !== null) {
-        this.boundingSphere = geometry.boundingSphere.clone()
-      }
+    if (geometry.boundingBox !== null) {
+      this.boundingBox = geometry.boundingBox.clone()
+    }
 
-      return this
+    if (geometry.boundingSphere !== null) {
+      this.boundingSphere = geometry.boundingSphere.clone()
     }
 
-    center() {
-      this.computeBoundingBox()
+    return this
+  }
 
-      this.boundingBox.getCenter(_offset).negate()
+  center() {
+    this.computeBoundingBox()
 
-      this.translate(_offset.x, _offset.y, _offset.z)
+    this.boundingBox.getCenter(_offset).negate()
 
-      return this
-    }
+    this.translate(_offset.x, _offset.y, _offset.z)
 
-    normalize() {
-      this.computeBoundingSphere()
+    return this
+  }
 
-      const center = this.boundingSphere.center
-      const radius = this.boundingSphere.radius
+  normalize() {
+    this.computeBoundingSphere()
 
-      const s = radius === 0 ? 1 : 1.0 / radius
+    const center = this.boundingSphere.center
+    const radius = this.boundingSphere.radius
 
-      const matrix = new Matrix4()
-      matrix.set(s, 0, 0, -s * center.x, 0, s, 0, -s * center.y, 0, 0, s, -s * center.z, 0, 0, 0, 1)
+    const s = radius === 0 ? 1 : 1.0 / radius
 
-      this.applyMatrix4(matrix)
+    const matrix = new Matrix4()
+    matrix.set(s, 0, 0, -s * center.x, 0, s, 0, -s * center.y, 0, 0, s, -s * center.z, 0, 0, 0, 1)
 
-      return this
+    this.applyMatrix4(matrix)
+
+    return this
+  }
+
+  computeFaceNormals() {
+    const cb = new Vector3(),
+      ab = new Vector3()
+
+    for (let f = 0, fl = this.faces.length; f < fl; f++) {
+      const face = this.faces[f]
+
+      const vA = this.vertices[face.a]
+      const vB = this.vertices[face.b]
+      const vC = this.vertices[face.c]
+
+      cb.subVectors(vC, vB)
+      ab.subVectors(vA, vB)
+      cb.cross(ab)
+
+      cb.normalize()
+
+      face.normal.copy(cb)
     }
+  }
+
+  computeVertexNormals(areaWeighted = true) {
+    const vertices = new Array(this.vertices.length)
+
+    for (let v = 0, vl = this.vertices.length; v < vl; v++) {
+      vertices[v] = new Vector3()
+    }
+
+    if (areaWeighted) {
+      // vertex normals weighted by triangle areas
+      // http://www.iquilezles.org/www/articles/normals/normals.htm
 
-    computeFaceNormals() {
       const cb = new Vector3(),
         ab = new Vector3()
 
@@ -322,584 +352,549 @@ const Geometry = /* @__PURE__ */ (() => {
         ab.subVectors(vA, vB)
         cb.cross(ab)
 
-        cb.normalize()
-
-        face.normal.copy(cb)
+        vertices[face.a].add(cb)
+        vertices[face.b].add(cb)
+        vertices[face.c].add(cb)
       }
-    }
+    } else {
+      this.computeFaceNormals()
 
-    computeVertexNormals(areaWeighted = true) {
-      const vertices = new Array(this.vertices.length)
+      for (let f = 0, fl = this.faces.length; f < fl; f++) {
+        const face = this.faces[f]
 
-      for (let v = 0, vl = this.vertices.length; v < vl; v++) {
-        vertices[v] = new Vector3()
+        vertices[face.a].add(face.normal)
+        vertices[face.b].add(face.normal)
+        vertices[face.c].add(face.normal)
       }
+    }
 
-      if (areaWeighted) {
-        // vertex normals weighted by triangle areas
-        // http://www.iquilezles.org/www/articles/normals/normals.htm
-
-        const cb = new Vector3(),
-          ab = new Vector3()
-
-        for (let f = 0, fl = this.faces.length; f < fl; f++) {
-          const face = this.faces[f]
+    for (let v = 0, vl = this.vertices.length; v < vl; v++) {
+      vertices[v].normalize()
+    }
 
-          const vA = this.vertices[face.a]
-          const vB = this.vertices[face.b]
-          const vC = this.vertices[face.c]
+    for (let f = 0, fl = this.faces.length; f < fl; f++) {
+      const face = this.faces[f]
 
-          cb.subVectors(vC, vB)
-          ab.subVectors(vA, vB)
-          cb.cross(ab)
+      const vertexNormals = face.vertexNormals
 
-          vertices[face.a].add(cb)
-          vertices[face.b].add(cb)
-          vertices[face.c].add(cb)
-        }
+      if (vertexNormals.length === 3) {
+        vertexNormals[0].copy(vertices[face.a])
+        vertexNormals[1].copy(vertices[face.b])
+        vertexNormals[2].copy(vertices[face.c])
       } else {
-        this.computeFaceNormals()
-
-        for (let f = 0, fl = this.faces.length; f < fl; f++) {
-          const face = this.faces[f]
-
-          vertices[face.a].add(face.normal)
-          vertices[face.b].add(face.normal)
-          vertices[face.c].add(face.normal)
-        }
+        vertexNormals[0] = vertices[face.a].clone()
+        vertexNormals[1] = vertices[face.b].clone()
+        vertexNormals[2] = vertices[face.c].clone()
       }
+    }
 
-      for (let v = 0, vl = this.vertices.length; v < vl; v++) {
-        vertices[v].normalize()
-      }
+    if (this.faces.length > 0) {
+      this.normalsNeedUpdate = true
+    }
+  }
 
-      for (let f = 0, fl = this.faces.length; f < fl; f++) {
-        const face = this.faces[f]
+  computeFlatVertexNormals() {
+    this.computeFaceNormals()
 
-        const vertexNormals = face.vertexNormals
+    for (let f = 0, fl = this.faces.length; f < fl; f++) {
+      const face = this.faces[f]
 
-        if (vertexNormals.length === 3) {
-          vertexNormals[0].copy(vertices[face.a])
-          vertexNormals[1].copy(vertices[face.b])
-          vertexNormals[2].copy(vertices[face.c])
-        } else {
-          vertexNormals[0] = vertices[face.a].clone()
-          vertexNormals[1] = vertices[face.b].clone()
-          vertexNormals[2] = vertices[face.c].clone()
-        }
-      }
+      const vertexNormals = face.vertexNormals
 
-      if (this.faces.length > 0) {
-        this.normalsNeedUpdate = true
+      if (vertexNormals.length === 3) {
+        vertexNormals[0].copy(face.normal)
+        vertexNormals[1].copy(face.normal)
+        vertexNormals[2].copy(face.normal)
+      } else {
+        vertexNormals[0] = face.normal.clone()
+        vertexNormals[1] = face.normal.clone()
+        vertexNormals[2] = face.normal.clone()
       }
     }
 
-    computeFlatVertexNormals() {
-      this.computeFaceNormals()
-
-      for (let f = 0, fl = this.faces.length; f < fl; f++) {
-        const face = this.faces[f]
+    if (this.faces.length > 0) {
+      this.normalsNeedUpdate = true
+    }
+  }
 
-        const vertexNormals = face.vertexNormals
+  computeMorphNormals() {
+    // save original normals
+    // - create temp variables on first access
+    //   otherwise just copy (for faster repeated calls)
 
-        if (vertexNormals.length === 3) {
-          vertexNormals[0].copy(face.normal)
-          vertexNormals[1].copy(face.normal)
-          vertexNormals[2].copy(face.normal)
-        } else {
-          vertexNormals[0] = face.normal.clone()
-          vertexNormals[1] = face.normal.clone()
-          vertexNormals[2] = face.normal.clone()
-        }
-      }
+    for (let f = 0, fl = this.faces.length; f < fl; f++) {
+      const face = this.faces[f]
 
-      if (this.faces.length > 0) {
-        this.normalsNeedUpdate = true
+      if (!face.__originalFaceNormal) {
+        face.__originalFaceNormal = face.normal.clone()
+      } else {
+        face.__originalFaceNormal.copy(face.normal)
       }
-    }
-
-    computeMorphNormals() {
-      // save original normals
-      // - create temp variables on first access
-      //   otherwise just copy (for faster repeated calls)
 
-      for (let f = 0, fl = this.faces.length; f < fl; f++) {
-        const face = this.faces[f]
+      if (!face.__originalVertexNormals) face.__originalVertexNormals = []
 
-        if (!face.__originalFaceNormal) {
-          face.__originalFaceNormal = face.normal.clone()
+      for (let i = 0, il = face.vertexNormals.length; i < il; i++) {
+        if (!face.__originalVertexNormals[i]) {
+          face.__originalVertexNormals[i] = face.vertexNormals[i].clone()
         } else {
-          face.__originalFaceNormal.copy(face.normal)
-        }
-
-        if (!face.__originalVertexNormals) face.__originalVertexNormals = []
-
-        for (let i = 0, il = face.vertexNormals.length; i < il; i++) {
-          if (!face.__originalVertexNormals[i]) {
-            face.__originalVertexNormals[i] = face.vertexNormals[i].clone()
-          } else {
-            face.__originalVertexNormals[i].copy(face.vertexNormals[i])
-          }
+          face.__originalVertexNormals[i].copy(face.vertexNormals[i])
         }
       }
+    }
 
-      // use temp geometry to compute face and vertex normals for each morph
-
-      const tmpGeo = new Geometry()
-      tmpGeo.faces = this.faces
+    // use temp geometry to compute face and vertex normals for each morph
 
-      for (let i = 0, il = this.morphTargets.length; i < il; i++) {
-        // create on first access
+    const tmpGeo = new Geometry()
+    tmpGeo.faces = this.faces
 
-        if (!this.morphNormals[i]) {
-          this.morphNormals[i] = {}
-          this.morphNormals[i].faceNormals = []
-          this.morphNormals[i].vertexNormals = []
+    for (let i = 0, il = this.morphTargets.length; i < il; i++) {
+      // create on first access
 
-          const dstNormalsFace = this.morphNormals[i].faceNormals
-          const dstNormalsVertex = this.morphNormals[i].vertexNormals
+      if (!this.morphNormals[i]) {
+        this.morphNormals[i] = {}
+        this.morphNormals[i].faceNormals = []
+        this.morphNormals[i].vertexNormals = []
 
-          for (let f = 0, fl = this.faces.length; f < fl; f++) {
-            const faceNormal = new Vector3()
-            const vertexNormals = {
-              a: new Vector3(),
-              b: new Vector3(),
-              c: new Vector3(),
-            }
+        const dstNormalsFace = this.morphNormals[i].faceNormals
+        const dstNormalsVertex = this.morphNormals[i].vertexNormals
 
-            dstNormalsFace.push(faceNormal)
-            dstNormalsVertex.push(vertexNormals)
+        for (let f = 0, fl = this.faces.length; f < fl; f++) {
+          const faceNormal = new Vector3()
+          const vertexNormals = {
+            a: new Vector3(),
+            b: new Vector3(),
+            c: new Vector3(),
           }
+
+          dstNormalsFace.push(faceNormal)
+          dstNormalsVertex.push(vertexNormals)
         }
+      }
 
-        const morphNormals = this.morphNormals[i]
+      const morphNormals = this.morphNormals[i]
 
-        // set vertices to morph target
+      // set vertices to morph target
 
-        tmpGeo.vertices = this.morphTargets[i].vertices
+      tmpGeo.vertices = this.morphTargets[i].vertices
 
-        // compute morph normals
+      // compute morph normals
 
-        tmpGeo.computeFaceNormals()
-        tmpGeo.computeVertexNormals()
+      tmpGeo.computeFaceNormals()
+      tmpGeo.computeVertexNormals()
 
-        // store morph normals
+      // store morph normals
 
-        for (let f = 0, fl = this.faces.length; f < fl; f++) {
-          const face = this.faces[f]
+      for (let f = 0, fl = this.faces.length; f < fl; f++) {
+        const face = this.faces[f]
 
-          const faceNormal = morphNormals.faceNormals[f]
-          const vertexNormals = morphNormals.vertexNormals[f]
+        const faceNormal = morphNormals.faceNormals[f]
+        const vertexNormals = morphNormals.vertexNormals[f]
 
-          faceNormal.copy(face.normal)
+        faceNormal.copy(face.normal)
 
-          vertexNormals.a.copy(face.vertexNormals[0])
-          vertexNormals.b.copy(face.vertexNormals[1])
-          vertexNormals.c.copy(face.vertexNormals[2])
-        }
+        vertexNormals.a.copy(face.vertexNormals[0])
+        vertexNormals.b.copy(face.vertexNormals[1])
+        vertexNormals.c.copy(face.vertexNormals[2])
       }
+    }
 
-      // restore original normals
+    // restore original normals
 
-      for (let f = 0, fl = this.faces.length; f < fl; f++) {
-        const face = this.faces[f]
+    for (let f = 0, fl = this.faces.length; f < fl; f++) {
+      const face = this.faces[f]
 
-        face.normal = face.__originalFaceNormal
-        face.vertexNormals = face.__originalVertexNormals
-      }
+      face.normal = face.__originalFaceNormal
+      face.vertexNormals = face.__originalVertexNormals
     }
+  }
 
-    computeBoundingBox() {
-      if (this.boundingBox === null) {
-        this.boundingBox = new Box3()
-      }
-
-      this.boundingBox.setFromPoints(this.vertices)
+  computeBoundingBox() {
+    if (this.boundingBox === null) {
+      this.boundingBox = new Box3()
     }
 
-    computeBoundingSphere() {
-      if (this.boundingSphere === null) {
-        this.boundingSphere = new Sphere()
-      }
+    this.boundingBox.setFromPoints(this.vertices)
+  }
 
-      this.boundingSphere.setFromPoints(this.vertices)
+  computeBoundingSphere() {
+    if (this.boundingSphere === null) {
+      this.boundingSphere = new Sphere()
     }
 
-    merge(geometry, matrix, materialIndexOffset = 0) {
-      if (!(geometry && geometry.isGeometry)) {
-        console.error('THREE.Geometry.merge(): geometry not an instance of THREE.Geometry.', geometry)
-        return
-      }
+    this.boundingSphere.setFromPoints(this.vertices)
+  }
 
-      let normalMatrix
-      const vertexOffset = this.vertices.length,
-        vertices1 = this.vertices,
-        vertices2 = geometry.vertices,
-        faces1 = this.faces,
-        faces2 = geometry.faces,
-        colors1 = this.colors,
-        colors2 = geometry.colors
-
-      if (matrix !== undefined) {
-        normalMatrix = new Matrix3().getNormalMatrix(matrix)
-      }
+  merge(geometry, matrix, materialIndexOffset = 0) {
+    if (!(geometry && geometry.isGeometry)) {
+      console.error('THREE.Geometry.merge(): geometry not an instance of THREE.Geometry.', geometry)
+      return
+    }
 
-      // vertices
+    let normalMatrix
+    const vertexOffset = this.vertices.length,
+      vertices1 = this.vertices,
+      vertices2 = geometry.vertices,
+      faces1 = this.faces,
+      faces2 = geometry.faces,
+      colors1 = this.colors,
+      colors2 = geometry.colors
+
+    if (matrix !== undefined) {
+      normalMatrix = new Matrix3().getNormalMatrix(matrix)
+    }
 
-      for (let i = 0, il = vertices2.length; i < il; i++) {
-        const vertex = vertices2[i]
+    // vertices
 
-        const vertexCopy = vertex.clone()
+    for (let i = 0, il = vertices2.length; i < il; i++) {
+      const vertex = vertices2[i]
 
-        if (matrix !== undefined) vertexCopy.applyMatrix4(matrix)
+      const vertexCopy = vertex.clone()
 
-        vertices1.push(vertexCopy)
-      }
+      if (matrix !== undefined) vertexCopy.applyMatrix4(matrix)
 
-      // colors
+      vertices1.push(vertexCopy)
+    }
 
-      for (let i = 0, il = colors2.length; i < il; i++) {
-        colors1.push(colors2[i].clone())
-      }
+    // colors
 
-      // faces
+    for (let i = 0, il = colors2.length; i < il; i++) {
+      colors1.push(colors2[i].clone())
+    }
 
-      for (let i = 0, il = faces2.length; i < il; i++) {
-        const face = faces2[i]
-        let normal, color
-        const faceVertexNormals = face.vertexNormals,
-          faceVertexColors = face.vertexColors
+    // faces
 
-        const faceCopy = new Face3(face.a + vertexOffset, face.b + vertexOffset, face.c + vertexOffset)
-        faceCopy.normal.copy(face.normal)
+    for (let i = 0, il = faces2.length; i < il; i++) {
+      const face = faces2[i]
+      let normal, color
+      const faceVertexNormals = face.vertexNormals,
+        faceVertexColors = face.vertexColors
 
-        if (normalMatrix !== undefined) {
-          faceCopy.normal.applyMatrix3(normalMatrix).normalize()
-        }
+      const faceCopy = new Face3(face.a + vertexOffset, face.b + vertexOffset, face.c + vertexOffset)
+      faceCopy.normal.copy(face.normal)
 
-        for (let j = 0, jl = faceVertexNormals.length; j < jl; j++) {
-          normal = faceVertexNormals[j].clone()
+      if (normalMatrix !== undefined) {
+        faceCopy.normal.applyMatrix3(normalMatrix).normalize()
+      }
 
-          if (normalMatrix !== undefined) {
-            normal.applyMatrix3(normalMatrix).normalize()
-          }
+      for (let j = 0, jl = faceVertexNormals.length; j < jl; j++) {
+        normal = faceVertexNormals[j].clone()
 
-          faceCopy.vertexNormals.push(normal)
+        if (normalMatrix !== undefined) {
+          normal.applyMatrix3(normalMatrix).normalize()
         }
 
-        faceCopy.color.copy(face.color)
-
-        for (let j = 0, jl = faceVertexColors.length; j < jl; j++) {
-          color = faceVertexColors[j]
-          faceCopy.vertexColors.push(color.clone())
-        }
+        faceCopy.vertexNormals.push(normal)
+      }
 
-        faceCopy.materialIndex = face.materialIndex + materialIndexOffset
+      faceCopy.color.copy(face.color)
 
-        faces1.push(faceCopy)
+      for (let j = 0, jl = faceVertexColors.length; j < jl; j++) {
+        color = faceVertexColors[j]
+        faceCopy.vertexColors.push(color.clone())
       }
 
-      // uvs
+      faceCopy.materialIndex = face.materialIndex + materialIndexOffset
 
-      for (let i = 0, il = geometry.faceVertexUvs.length; i < il; i++) {
-        const faceVertexUvs2 = geometry.faceVertexUvs[i]
+      faces1.push(faceCopy)
+    }
 
-        if (this.faceVertexUvs[i] === undefined) this.faceVertexUvs[i] = []
+    // uvs
 
-        for (let j = 0, jl = faceVertexUvs2.length; j < jl; j++) {
-          const uvs2 = faceVertexUvs2[j],
-            uvsCopy = []
+    for (let i = 0, il = geometry.faceVertexUvs.length; i < il; i++) {
+      const faceVertexUvs2 = geometry.faceVertexUvs[i]
 
-          for (let k = 0, kl = uvs2.length; k < kl; k++) {
-            uvsCopy.push(uvs2[k].clone())
-          }
+      if (this.faceVertexUvs[i] === undefined) this.faceVertexUvs[i] = []
 
-          this.faceVertexUvs[i].push(uvsCopy)
+      for (let j = 0, jl = faceVertexUvs2.length; j < jl; j++) {
+        const uvs2 = faceVertexUvs2[j],
+          uvsCopy = []
+
+        for (let k = 0, kl = uvs2.length; k < kl; k++) {
+          uvsCopy.push(uvs2[k].clone())
         }
+
+        this.faceVertexUvs[i].push(uvsCopy)
       }
     }
+  }
 
-    mergeMesh(mesh) {
-      if (!(mesh && mesh.isMesh)) {
-        console.error('THREE.Geometry.mergeMesh(): mesh not an instance of THREE.Mesh.', mesh)
-        return
-      }
+  mergeMesh(mesh) {
+    if (!(mesh && mesh.isMesh)) {
+      console.error('THREE.Geometry.mergeMesh(): mesh not an instance of THREE.Mesh.', mesh)
+      return
+    }
 
-      if (mesh.matrixAutoUpdate) mesh.updateMatrix()
+    if (mesh.matrixAutoUpdate) mesh.updateMatrix()
 
-      this.merge(mesh.geometry, mesh.matrix)
-    }
+    this.merge(mesh.geometry, mesh.matrix)
+  }
 
-    /*
-     * Checks for duplicate vertices with hashmap.
-     * Duplicated vertices are removed
-     * and faces' vertices are updated.
-     */
-
-    mergeVertices(precisionPoints = 4) {
-      const verticesMap = {} // Hashmap for looking up vertices by position coordinates (and making sure they are unique)
-      const unique = [],
-        changes = []
-
-      const precision = Math.pow(10, precisionPoints)
-
-      for (let i = 0, il = this.vertices.length; i < il; i++) {
-        const v = this.vertices[i]
-        const key = `${Math.round(v.x * precision)}_${Math.round(v.y * precision)}_${Math.round(v.z * precision)}`
-
-        if (verticesMap[key] === undefined) {
-          verticesMap[key] = i
-          unique.push(this.vertices[i])
-          changes[i] = unique.length - 1
-        } else {
-          //console.log('Duplicate vertex found. ', i, ' could be using ', verticesMap[key]);
-          changes[i] = changes[verticesMap[key]]
-        }
+  /*
+   * Checks for duplicate vertices with hashmap.
+   * Duplicated vertices are removed
+   * and faces' vertices are updated.
+   */
+
+  mergeVertices(precisionPoints = 4) {
+    const verticesMap = {} // Hashmap for looking up vertices by position coordinates (and making sure they are unique)
+    const unique = [],
+      changes = []
+
+    const precision = Math.pow(10, precisionPoints)
+
+    for (let i = 0, il = this.vertices.length; i < il; i++) {
+      const v = this.vertices[i]
+      const key = `${Math.round(v.x * precision)}_${Math.round(v.y * precision)}_${Math.round(v.z * precision)}`
+
+      if (verticesMap[key] === undefined) {
+        verticesMap[key] = i
+        unique.push(this.vertices[i])
+        changes[i] = unique.length - 1
+      } else {
+        //console.log('Duplicate vertex found. ', i, ' could be using ', verticesMap[key]);
+        changes[i] = changes[verticesMap[key]]
       }
+    }
 
-      // if faces are completely degenerate after merging vertices, we
-      // have to remove them from the geometry.
-      const faceIndicesToRemove = []
+    // if faces are completely degenerate after merging vertices, we
+    // have to remove them from the geometry.
+    const faceIndicesToRemove = []
 
-      for (let i = 0, il = this.faces.length; i < il; i++) {
-        const face = this.faces[i]
+    for (let i = 0, il = this.faces.length; i < il; i++) {
+      const face = this.faces[i]
 
-        face.a = changes[face.a]
-        face.b = changes[face.b]
-        face.c = changes[face.c]
+      face.a = changes[face.a]
+      face.b = changes[face.b]
+      face.c = changes[face.c]
 
-        const indices = [face.a, face.b, face.c]
+      const indices = [face.a, face.b, face.c]
 
-        // if any duplicate vertices are found in a Face3
-        // we have to remove the face as nothing can be saved
-        for (let n = 0; n < 3; n++) {
-          if (indices[n] === indices[(n + 1) % 3]) {
-            faceIndicesToRemove.push(i)
-            break
-          }
+      // if any duplicate vertices are found in a Face3
+      // we have to remove the face as nothing can be saved
+      for (let n = 0; n < 3; n++) {
+        if (indices[n] === indices[(n + 1) % 3]) {
+          faceIndicesToRemove.push(i)
+          break
         }
       }
+    }
 
-      for (let i = faceIndicesToRemove.length - 1; i >= 0; i--) {
-        const idx = faceIndicesToRemove[i]
+    for (let i = faceIndicesToRemove.length - 1; i >= 0; i--) {
+      const idx = faceIndicesToRemove[i]
 
-        this.faces.splice(idx, 1)
+      this.faces.splice(idx, 1)
 
-        for (let j = 0, jl = this.faceVertexUvs.length; j < jl; j++) {
-          this.faceVertexUvs[j].splice(idx, 1)
-        }
+      for (let j = 0, jl = this.faceVertexUvs.length; j < jl; j++) {
+        this.faceVertexUvs[j].splice(idx, 1)
       }
+    }
+
+    // Use unique set of vertices
+
+    const diff = this.vertices.length - unique.length
+    this.vertices = unique
+    return diff
+  }
 
-      // Use unique set of vertices
+  setFromPoints(points) {
+    this.vertices = []
 
-      const diff = this.vertices.length - unique.length
-      this.vertices = unique
-      return diff
+    for (let i = 0, l = points.length; i < l; i++) {
+      const point = points[i]
+      this.vertices.push(new Vector3(point.x, point.y, point.z || 0))
     }
 
-    setFromPoints(points) {
-      this.vertices = []
+    return this
+  }
+
+  sortFacesByMaterialIndex() {
+    const faces = this.faces
+    const length = faces.length
 
-      for (let i = 0, l = points.length; i < l; i++) {
-        const point = points[i]
-        this.vertices.push(new Vector3(point.x, point.y, point.z || 0))
-      }
+    // tag faces
 
-      return this
+    for (let i = 0; i < length; i++) {
+      faces[i]._id = i
     }
 
-    sortFacesByMaterialIndex() {
-      const faces = this.faces
-      const length = faces.length
+    // sort faces
 
-      // tag faces
+    function materialIndexSort(a, b) {
+      return a.materialIndex - b.materialIndex
+    }
 
-      for (let i = 0; i < length; i++) {
-        faces[i]._id = i
-      }
+    faces.sort(materialIndexSort)
 
-      // sort faces
+    // sort uvs
 
-      function materialIndexSort(a, b) {
-        return a.materialIndex - b.materialIndex
-      }
+    const uvs1 = this.faceVertexUvs[0]
+    const uvs2 = this.faceVertexUvs[1]
 
-      faces.sort(materialIndexSort)
+    let newUvs1, newUvs2
 
-      // sort uvs
+    if (uvs1 && uvs1.length === length) newUvs1 = []
+    if (uvs2 && uvs2.length === length) newUvs2 = []
 
-      const uvs1 = this.faceVertexUvs[0]
-      const uvs2 = this.faceVertexUvs[1]
+    for (let i = 0; i < length; i++) {
+      const id = faces[i]._id
 
-      let newUvs1, newUvs2
+      if (newUvs1) newUvs1.push(uvs1[id])
+      if (newUvs2) newUvs2.push(uvs2[id])
+    }
 
-      if (uvs1 && uvs1.length === length) newUvs1 = []
-      if (uvs2 && uvs2.length === length) newUvs2 = []
+    if (newUvs1) this.faceVertexUvs[0] = newUvs1
+    if (newUvs2) this.faceVertexUvs[1] = newUvs2
+  }
 
-      for (let i = 0; i < length; i++) {
-        const id = faces[i]._id
+  toJSON() {
+    const data = {
+      metadata: {
+        version: 4.5,
+        type: 'Geometry',
+        generator: 'Geometry.toJSON',
+      },
+    }
 
-        if (newUvs1) newUvs1.push(uvs1[id])
-        if (newUvs2) newUvs2.push(uvs2[id])
-      }
+    // standard Geometry serialization
 
-      if (newUvs1) this.faceVertexUvs[0] = newUvs1
-      if (newUvs2) this.faceVertexUvs[1] = newUvs2
-    }
+    data.uuid = this.uuid
+    data.type = this.type
+    if (this.name !== '') data.name = this.name
 
-    toJSON() {
-      const data = {
-        metadata: {
-          version: 4.5,
-          type: 'Geometry',
-          generator: 'Geometry.toJSON',
-        },
+    if (this.parameters !== undefined) {
+      const parameters = this.parameters
+
+      for (let key in parameters) {
+        if (parameters[key] !== undefined) data[key] = parameters[key]
       }
 
-      // standard Geometry serialization
+      return data
+    }
 
-      data.uuid = this.uuid
-      data.type = this.type
-      if (this.name !== '') data.name = this.name
+    const vertices = []
 
-      if (this.parameters !== undefined) {
-        const parameters = this.parameters
+    for (let i = 0; i < this.vertices.length; i++) {
+      const vertex = this.vertices[i]
+      vertices.push(vertex.x, vertex.y, vertex.z)
+    }
 
-        for (let key in parameters) {
-          if (parameters[key] !== undefined) data[key] = parameters[key]
-        }
+    const faces = []
+    const normals = []
+    const normalsHash = {}
+    const colors = []
+    const colorsHash = {}
+    const uvs = []
+    const uvsHash = {}
 
-        return data
-      }
+    for (let i = 0; i < this.faces.length; i++) {
+      const face = this.faces[i]
 
-      const vertices = []
+      const hasMaterial = true
+      const hasFaceUv = false // deprecated
+      const hasFaceVertexUv = this.faceVertexUvs[0][i] !== undefined
+      const hasFaceNormal = face.normal.length() > 0
+      const hasFaceVertexNormal = face.vertexNormals.length > 0
+      const hasFaceColor = face.color.r !== 1 || face.color.g !== 1 || face.color.b !== 1
+      const hasFaceVertexColor = face.vertexColors.length > 0
 
-      for (let i = 0; i < this.vertices.length; i++) {
-        const vertex = this.vertices[i]
-        vertices.push(vertex.x, vertex.y, vertex.z)
-      }
+      let faceType = 0
 
-      const faces = []
-      const normals = []
-      const normalsHash = {}
-      const colors = []
-      const colorsHash = {}
-      const uvs = []
-      const uvsHash = {}
-
-      for (let i = 0; i < this.faces.length; i++) {
-        const face = this.faces[i]
-
-        const hasMaterial = true
-        const hasFaceUv = false // deprecated
-        const hasFaceVertexUv = this.faceVertexUvs[0][i] !== undefined
-        const hasFaceNormal = face.normal.length() > 0
-        const hasFaceVertexNormal = face.vertexNormals.length > 0
-        const hasFaceColor = face.color.r !== 1 || face.color.g !== 1 || face.color.b !== 1
-        const hasFaceVertexColor = face.vertexColors.length > 0
-
-        let faceType = 0
-
-        faceType = setBit(faceType, 0, 0) // isQuad
-        faceType = setBit(faceType, 1, hasMaterial)
-        faceType = setBit(faceType, 2, hasFaceUv)
-        faceType = setBit(faceType, 3, hasFaceVertexUv)
-        faceType = setBit(faceType, 4, hasFaceNormal)
-        faceType = setBit(faceType, 5, hasFaceVertexNormal)
-        faceType = setBit(faceType, 6, hasFaceColor)
-        faceType = setBit(faceType, 7, hasFaceVertexColor)
-
-        faces.push(faceType)
-        faces.push(face.a, face.b, face.c)
-        faces.push(face.materialIndex)
-
-        if (hasFaceVertexUv) {
-          const faceVertexUvs = this.faceVertexUvs[0][i]
-
-          faces.push(getUvIndex(faceVertexUvs[0]), getUvIndex(faceVertexUvs[1]), getUvIndex(faceVertexUvs[2]))
-        }
+      faceType = setBit(faceType, 0, 0) // isQuad
+      faceType = setBit(faceType, 1, hasMaterial)
+      faceType = setBit(faceType, 2, hasFaceUv)
+      faceType = setBit(faceType, 3, hasFaceVertexUv)
+      faceType = setBit(faceType, 4, hasFaceNormal)
+      faceType = setBit(faceType, 5, hasFaceVertexNormal)
+      faceType = setBit(faceType, 6, hasFaceColor)
+      faceType = setBit(faceType, 7, hasFaceVertexColor)
 
-        if (hasFaceNormal) {
-          faces.push(getNormalIndex(face.normal))
-        }
+      faces.push(faceType)
+      faces.push(face.a, face.b, face.c)
+      faces.push(face.materialIndex)
 
-        if (hasFaceVertexNormal) {
-          const vertexNormals = face.vertexNormals
+      if (hasFaceVertexUv) {
+        const faceVertexUvs = this.faceVertexUvs[0][i]
 
-          faces.push(
-            getNormalIndex(vertexNormals[0]),
-            getNormalIndex(vertexNormals[1]),
-            getNormalIndex(vertexNormals[2]),
-          )
-        }
+        faces.push(getUvIndex(faceVertexUvs[0]), getUvIndex(faceVertexUvs[1]), getUvIndex(faceVertexUvs[2]))
+      }
 
-        if (hasFaceColor) {
-          faces.push(getColorIndex(face.color))
-        }
+      if (hasFaceNormal) {
+        faces.push(getNormalIndex(face.normal))
+      }
 
-        if (hasFaceVertexColor) {
-          const vertexColors = face.vertexColors
+      if (hasFaceVertexNormal) {
+        const vertexNormals = face.vertexNormals
 
-          faces.push(getColorIndex(vertexColors[0]), getColorIndex(vertexColors[1]), getColorIndex(vertexColors[2]))
-        }
+        faces.push(getNormalIndex(vertexNormals[0]), getNormalIndex(vertexNormals[1]), getNormalIndex(vertexNormals[2]))
       }
 
-      function setBit(value, position, enabled) {
-        return enabled ? value | (1 << position) : value & ~(1 << position)
+      if (hasFaceColor) {
+        faces.push(getColorIndex(face.color))
       }
 
-      function getNormalIndex(normal) {
-        const hash = normal.x.toString() + normal.y.toString() + normal.z.toString()
+      if (hasFaceVertexColor) {
+        const vertexColors = face.vertexColors
 
-        if (normalsHash[hash] !== undefined) {
-          return normalsHash[hash]
-        }
+        faces.push(getColorIndex(vertexColors[0]), getColorIndex(vertexColors[1]), getColorIndex(vertexColors[2]))
+      }
+    }
+
+    function setBit(value, position, enabled) {
+      return enabled ? value | (1 << position) : value & ~(1 << position)
+    }
 
-        normalsHash[hash] = normals.length / 3
-        normals.push(normal.x, normal.y, normal.z)
+    function getNormalIndex(normal) {
+      const hash = normal.x.toString() + normal.y.toString() + normal.z.toString()
 
+      if (normalsHash[hash] !== undefined) {
         return normalsHash[hash]
       }
 
-      function getColorIndex(color) {
-        const hash = color.r.toString() + color.g.toString() + color.b.toString()
+      normalsHash[hash] = normals.length / 3
+      normals.push(normal.x, normal.y, normal.z)
 
-        if (colorsHash[hash] !== undefined) {
-          return colorsHash[hash]
-        }
+      return normalsHash[hash]
+    }
 
-        colorsHash[hash] = colors.length
-        colors.push(color.getHex())
+    function getColorIndex(color) {
+      const hash = color.r.toString() + color.g.toString() + color.b.toString()
 
+      if (colorsHash[hash] !== undefined) {
         return colorsHash[hash]
       }
 
-      function getUvIndex(uv) {
-        const hash = uv.x.toString() + uv.y.toString()
+      colorsHash[hash] = colors.length
+      colors.push(color.getHex())
 
-        if (uvsHash[hash] !== undefined) {
-          return uvsHash[hash]
-        }
+      return colorsHash[hash]
+    }
 
-        uvsHash[hash] = uvs.length / 2
-        uvs.push(uv.x, uv.y)
+    function getUvIndex(uv) {
+      const hash = uv.x.toString() + uv.y.toString()
 
+      if (uvsHash[hash] !== undefined) {
         return uvsHash[hash]
       }
 
-      data.data = {}
-
-      data.data.vertices = vertices
-      data.data.normals = normals
-      if (colors.length > 0) data.data.colors = colors
-      if (uvs.length > 0) data.data.uvs = [uvs] // temporal backward compatibility
-      data.data.faces = faces
+      uvsHash[hash] = uvs.length / 2
+      uvs.push(uv.x, uv.y)
 
-      return data
+      return uvsHash[hash]
     }
 
-    clone() {
-      /*
+    data.data = {}
+
+    data.data.vertices = vertices
+    data.data.normals = normals
+    if (colors.length > 0) data.data.colors = colors
+    if (uvs.length > 0) data.data.uvs = [uvs] // temporal backward compatibility
+    data.data.faces = faces
+
+    return data
+  }
+
+  clone() {
+    /*
 		 // Handle primitives
 
 		 const parameters = this.parameters;
@@ -923,293 +918,290 @@ const Geometry = /* @__PURE__ */ (() => {
 		 return new this.constructor().copy( this );
 		 */
 
-      return new Geometry().copy(this)
-    }
-
-    copy(source) {
-      // reset
+    return new Geometry().copy(this)
+  }
 
-      this.vertices = []
-      this.colors = []
-      this.faces = []
-      this.faceVertexUvs = [[]]
-      this.morphTargets = []
-      this.morphNormals = []
-      this.skinWeights = []
-      this.skinIndices = []
-      this.lineDistances = []
-      this.boundingBox = null
-      this.boundingSphere = null
+  copy(source) {
+    // reset
 
-      // name
+    this.vertices = []
+    this.colors = []
+    this.faces = []
+    this.faceVertexUvs = [[]]
+    this.morphTargets = []
+    this.morphNormals = []
+    this.skinWeights = []
+    this.skinIndices = []
+    this.lineDistances = []
+    this.boundingBox = null
+    this.boundingSphere = null
 
-      this.name = source.name
+    // name
 
-      // vertices
+    this.name = source.name
 
-      const vertices = source.vertices
+    // vertices
 
-      for (let i = 0, il = vertices.length; i < il; i++) {
-        this.vertices.push(vertices[i].clone())
-      }
+    const vertices = source.vertices
 
-      // colors
+    for (let i = 0, il = vertices.length; i < il; i++) {
+      this.vertices.push(vertices[i].clone())
+    }
 
-      const colors = source.colors
+    // colors
 
-      for (let i = 0, il = colors.length; i < il; i++) {
-        this.colors.push(colors[i].clone())
-      }
+    const colors = source.colors
 
-      // faces
+    for (let i = 0, il = colors.length; i < il; i++) {
+      this.colors.push(colors[i].clone())
+    }
 
-      const faces = source.faces
+    // faces
 
-      for (let i = 0, il = faces.length; i < il; i++) {
-        this.faces.push(faces[i].clone())
-      }
+    const faces = source.faces
 
-      // face vertex uvs
+    for (let i = 0, il = faces.length; i < il; i++) {
+      this.faces.push(faces[i].clone())
+    }
 
-      for (let i = 0, il = source.faceVertexUvs.length; i < il; i++) {
-        const faceVertexUvs = source.faceVertexUvs[i]
+    // face vertex uvs
 
-        if (this.faceVertexUvs[i] === undefined) {
-          this.faceVertexUvs[i] = []
-        }
+    for (let i = 0, il = source.faceVertexUvs.length; i < il; i++) {
+      const faceVertexUvs = source.faceVertexUvs[i]
 
-        for (let j = 0, jl = faceVertexUvs.length; j < jl; j++) {
-          const uvs = faceVertexUvs[j],
-            uvsCopy = []
+      if (this.faceVertexUvs[i] === undefined) {
+        this.faceVertexUvs[i] = []
+      }
 
-          for (let k = 0, kl = uvs.length; k < kl; k++) {
-            const uv = uvs[k]
+      for (let j = 0, jl = faceVertexUvs.length; j < jl; j++) {
+        const uvs = faceVertexUvs[j],
+          uvsCopy = []
 
-            uvsCopy.push(uv.clone())
-          }
+        for (let k = 0, kl = uvs.length; k < kl; k++) {
+          const uv = uvs[k]
 
-          this.faceVertexUvs[i].push(uvsCopy)
+          uvsCopy.push(uv.clone())
         }
+
+        this.faceVertexUvs[i].push(uvsCopy)
       }
+    }
 
-      // morph targets
+    // morph targets
 
-      const morphTargets = source.morphTargets
+    const morphTargets = source.morphTargets
 
-      for (let i = 0, il = morphTargets.length; i < il; i++) {
-        const morphTarget = {}
-        morphTarget.name = morphTargets[i].name
+    for (let i = 0, il = morphTargets.length; i < il; i++) {
+      const morphTarget = {}
+      morphTarget.name = morphTargets[i].name
 
-        // vertices
+      // vertices
 
-        if (morphTargets[i].vertices !== undefined) {
-          morphTarget.vertices = []
+      if (morphTargets[i].vertices !== undefined) {
+        morphTarget.vertices = []
 
-          for (let j = 0, jl = morphTargets[i].vertices.length; j < jl; j++) {
-            morphTarget.vertices.push(morphTargets[i].vertices[j].clone())
-          }
+        for (let j = 0, jl = morphTargets[i].vertices.length; j < jl; j++) {
+          morphTarget.vertices.push(morphTargets[i].vertices[j].clone())
         }
+      }
 
-        // normals
+      // normals
 
-        if (morphTargets[i].normals !== undefined) {
-          morphTarget.normals = []
+      if (morphTargets[i].normals !== undefined) {
+        morphTarget.normals = []
 
-          for (let j = 0, jl = morphTargets[i].normals.length; j < jl; j++) {
-            morphTarget.normals.push(morphTargets[i].normals[j].clone())
-          }
+        for (let j = 0, jl = morphTargets[i].normals.length; j < jl; j++) {
+          morphTarget.normals.push(morphTargets[i].normals[j].clone())
         }
-
-        this.morphTargets.push(morphTarget)
       }
 
-      // morph normals
-
-      const morphNormals = source.morphNormals
-
-      for (let i = 0, il = morphNormals.length; i < il; i++) {
-        const morphNormal = {}
+      this.morphTargets.push(morphTarget)
+    }
 
-        // vertex normals
+    // morph normals
 
-        if (morphNormals[i].vertexNormals !== undefined) {
-          morphNormal.vertexNormals = []
+    const morphNormals = source.morphNormals
 
-          for (let j = 0, jl = morphNormals[i].vertexNormals.length; j < jl; j++) {
-            const srcVertexNormal = morphNormals[i].vertexNormals[j]
-            const destVertexNormal = {}
+    for (let i = 0, il = morphNormals.length; i < il; i++) {
+      const morphNormal = {}
 
-            destVertexNormal.a = srcVertexNormal.a.clone()
-            destVertexNormal.b = srcVertexNormal.b.clone()
-            destVertexNormal.c = srcVertexNormal.c.clone()
+      // vertex normals
 
-            morphNormal.vertexNormals.push(destVertexNormal)
-          }
-        }
+      if (morphNormals[i].vertexNormals !== undefined) {
+        morphNormal.vertexNormals = []
 
-        // face normals
+        for (let j = 0, jl = morphNormals[i].vertexNormals.length; j < jl; j++) {
+          const srcVertexNormal = morphNormals[i].vertexNormals[j]
+          const destVertexNormal = {}
 
-        if (morphNormals[i].faceNormals !== undefined) {
-          morphNormal.faceNormals = []
+          destVertexNormal.a = srcVertexNormal.a.clone()
+          destVertexNormal.b = srcVertexNormal.b.clone()
+          destVertexNormal.c = srcVertexNormal.c.clone()
 
-          for (let j = 0, jl = morphNormals[i].faceNormals.length; j < jl; j++) {
-            morphNormal.faceNormals.push(morphNormals[i].faceNormals[j].clone())
-          }
+          morphNormal.vertexNormals.push(destVertexNormal)
         }
-
-        this.morphNormals.push(morphNormal)
       }
 
-      // skin weights
+      // face normals
 
-      const skinWeights = source.skinWeights
+      if (morphNormals[i].faceNormals !== undefined) {
+        morphNormal.faceNormals = []
 
-      for (let i = 0, il = skinWeights.length; i < il; i++) {
-        this.skinWeights.push(skinWeights[i].clone())
+        for (let j = 0, jl = morphNormals[i].faceNormals.length; j < jl; j++) {
+          morphNormal.faceNormals.push(morphNormals[i].faceNormals[j].clone())
+        }
       }
 
-      // skin indices
-
-      const skinIndices = source.skinIndices
-
-      for (let i = 0, il = skinIndices.length; i < il; i++) {
-        this.skinIndices.push(skinIndices[i].clone())
-      }
+      this.morphNormals.push(morphNormal)
+    }
 
-      // line distances
+    // skin weights
 
-      const lineDistances = source.lineDistances
+    const skinWeights = source.skinWeights
 
-      for (let i = 0, il = lineDistances.length; i < il; i++) {
-        this.lineDistances.push(lineDistances[i])
-      }
+    for (let i = 0, il = skinWeights.length; i < il; i++) {
+      this.skinWeights.push(skinWeights[i].clone())
+    }
 
-      // bounding box
+    // skin indices
 
-      const boundingBox = source.boundingBox
+    const skinIndices = source.skinIndices
 
-      if (boundingBox !== null) {
-        this.boundingBox = boundingBox.clone()
-      }
+    for (let i = 0, il = skinIndices.length; i < il; i++) {
+      this.skinIndices.push(skinIndices[i].clone())
+    }
 
-      // bounding sphere
+    // line distances
 
-      const boundingSphere = source.boundingSphere
+    const lineDistances = source.lineDistances
 
-      if (boundingSphere !== null) {
-        this.boundingSphere = boundingSphere.clone()
-      }
+    for (let i = 0, il = lineDistances.length; i < il; i++) {
+      this.lineDistances.push(lineDistances[i])
+    }
 
-      // update flags
+    // bounding box
 
-      this.elementsNeedUpdate = source.elementsNeedUpdate
-      this.verticesNeedUpdate = source.verticesNeedUpdate
-      this.uvsNeedUpdate = source.uvsNeedUpdate
-      this.normalsNeedUpdate = source.normalsNeedUpdate
-      this.colorsNeedUpdate = source.colorsNeedUpdate
-      this.lineDistancesNeedUpdate = source.lineDistancesNeedUpdate
-      this.groupsNeedUpdate = source.groupsNeedUpdate
+    const boundingBox = source.boundingBox
 
-      return this
+    if (boundingBox !== null) {
+      this.boundingBox = boundingBox.clone()
     }
 
-    toBufferGeometry() {
-      const geometry = new DirectGeometry().fromGeometry(this)
+    // bounding sphere
 
-      const buffergeometry = new BufferGeometry()
+    const boundingSphere = source.boundingSphere
 
-      const positions = new Float32Array(geometry.vertices.length * 3)
-      buffergeometry.setAttribute('position', new BufferAttribute(positions, 3).copyVector3sArray(geometry.vertices))
-
-      if (geometry.normals.length > 0) {
-        const normals = new Float32Array(geometry.normals.length * 3)
-        buffergeometry.setAttribute('normal', new BufferAttribute(normals, 3).copyVector3sArray(geometry.normals))
-      }
+    if (boundingSphere !== null) {
+      this.boundingSphere = boundingSphere.clone()
+    }
 
-      if (geometry.colors.length > 0) {
-        const colors = new Float32Array(geometry.colors.length * 3)
-        buffergeometry.setAttribute('color', new BufferAttribute(colors, 3).copyColorsArray(geometry.colors))
-      }
+    // update flags
 
-      if (geometry.uvs.length > 0) {
-        const uvs = new Float32Array(geometry.uvs.length * 2)
-        buffergeometry.setAttribute('uv', new BufferAttribute(uvs, 2).copyVector2sArray(geometry.uvs))
-      }
+    this.elementsNeedUpdate = source.elementsNeedUpdate
+    this.verticesNeedUpdate = source.verticesNeedUpdate
+    this.uvsNeedUpdate = source.uvsNeedUpdate
+    this.normalsNeedUpdate = source.normalsNeedUpdate
+    this.colorsNeedUpdate = source.colorsNeedUpdate
+    this.lineDistancesNeedUpdate = source.lineDistancesNeedUpdate
+    this.groupsNeedUpdate = source.groupsNeedUpdate
 
-      if (geometry.uvs2.length > 0) {
-        const uvs2 = new Float32Array(geometry.uvs2.length * 2)
-        buffergeometry.setAttribute('uv2', new BufferAttribute(uvs2, 2).copyVector2sArray(geometry.uvs2))
-      }
+    return this
+  }
 
-      // groups
+  toBufferGeometry() {
+    const geometry = new DirectGeometry().fromGeometry(this)
 
-      buffergeometry.groups = geometry.groups
+    const buffergeometry = new BufferGeometry()
 
-      // morphs
+    const positions = new Float32Array(geometry.vertices.length * 3)
+    buffergeometry.setAttribute('position', new BufferAttribute(positions, 3).copyVector3sArray(geometry.vertices))
 
-      for (let name in geometry.morphTargets) {
-        const array = []
-        const morphTargets = geometry.morphTargets[name]
+    if (geometry.normals.length > 0) {
+      const normals = new Float32Array(geometry.normals.length * 3)
+      buffergeometry.setAttribute('normal', new BufferAttribute(normals, 3).copyVector3sArray(geometry.normals))
+    }
 
-        for (let i = 0, l = morphTargets.length; i < l; i++) {
-          const morphTarget = morphTargets[i]
+    if (geometry.colors.length > 0) {
+      const colors = new Float32Array(geometry.colors.length * 3)
+      buffergeometry.setAttribute('color', new BufferAttribute(colors, 3).copyColorsArray(geometry.colors))
+    }
 
-          const attribute = new Float32BufferAttribute(morphTarget.data.length * 3, 3)
-          attribute.name = morphTarget.name
+    if (geometry.uvs.length > 0) {
+      const uvs = new Float32Array(geometry.uvs.length * 2)
+      buffergeometry.setAttribute('uv', new BufferAttribute(uvs, 2).copyVector2sArray(geometry.uvs))
+    }
 
-          array.push(attribute.copyVector3sArray(morphTarget.data))
-        }
+    if (geometry.uvs2.length > 0) {
+      const uvs2 = new Float32Array(geometry.uvs2.length * 2)
+      buffergeometry.setAttribute('uv2', new BufferAttribute(uvs2, 2).copyVector2sArray(geometry.uvs2))
+    }
 
-        buffergeometry.morphAttributes[name] = array
-      }
+    // groups
 
-      // skinning
+    buffergeometry.groups = geometry.groups
 
-      if (geometry.skinIndices.length > 0) {
-        const skinIndices = new Float32BufferAttribute(geometry.skinIndices.length * 4, 4)
-        buffergeometry.setAttribute('skinIndex', skinIndices.copyVector4sArray(geometry.skinIndices))
-      }
+    // morphs
 
-      if (geometry.skinWeights.length > 0) {
-        const skinWeights = new Float32BufferAttribute(geometry.skinWeights.length * 4, 4)
-        buffergeometry.setAttribute('skinWeight', skinWeights.copyVector4sArray(geometry.skinWeights))
-      }
+    for (let name in geometry.morphTargets) {
+      const array = []
+      const morphTargets = geometry.morphTargets[name]
 
-      //
+      for (let i = 0, l = morphTargets.length; i < l; i++) {
+        const morphTarget = morphTargets[i]
 
-      if (geometry.boundingSphere !== null) {
-        buffergeometry.boundingSphere = geometry.boundingSphere.clone()
-      }
+        const attribute = new Float32BufferAttribute(morphTarget.data.length * 3, 3)
+        attribute.name = morphTarget.name
 
-      if (geometry.boundingBox !== null) {
-        buffergeometry.boundingBox = geometry.boundingBox.clone()
+        array.push(attribute.copyVector3sArray(morphTarget.data))
       }
 
-      return buffergeometry
+      buffergeometry.morphAttributes[name] = array
     }
 
-    computeTangents() {
-      console.error('THREE.Geometry: .computeTangents() has been removed.')
+    // skinning
+
+    if (geometry.skinIndices.length > 0) {
+      const skinIndices = new Float32BufferAttribute(geometry.skinIndices.length * 4, 4)
+      buffergeometry.setAttribute('skinIndex', skinIndices.copyVector4sArray(geometry.skinIndices))
     }
 
-    computeLineDistances() {
-      console.error(
-        'THREE.Geometry: .computeLineDistances() has been removed. Use THREE.Line.computeLineDistances() instead.',
-      )
+    if (geometry.skinWeights.length > 0) {
+      const skinWeights = new Float32BufferAttribute(geometry.skinWeights.length * 4, 4)
+      buffergeometry.setAttribute('skinWeight', skinWeights.copyVector4sArray(geometry.skinWeights))
     }
 
-    applyMatrix(matrix) {
-      console.warn('THREE.Geometry: .applyMatrix() has been renamed to .applyMatrix4().')
-      return this.applyMatrix4(matrix)
+    //
+
+    if (geometry.boundingSphere !== null) {
+      buffergeometry.boundingSphere = geometry.boundingSphere.clone()
     }
 
-    dispose() {
-      this.dispatchEvent({ type: 'dispose' })
+    if (geometry.boundingBox !== null) {
+      buffergeometry.boundingBox = geometry.boundingBox.clone()
     }
+
+    return buffergeometry
   }
 
-  return Geometry
-})()
+  computeTangents() {
+    console.error('THREE.Geometry: .computeTangents() has been removed.')
+  }
+
+  computeLineDistances() {
+    console.error(
+      'THREE.Geometry: .computeLineDistances() has been removed. Use THREE.Line.computeLineDistances() instead.',
+    )
+  }
+
+  applyMatrix(matrix) {
+    console.warn('THREE.Geometry: .applyMatrix() has been renamed to .applyMatrix4().')
+    return this.applyMatrix4(matrix)
+  }
+
+  dispose() {
+    this.dispatchEvent({ type: 'dispose' })
+  }
+}
 
 class DirectGeometry {
   constructor() {
diff --git a/src/effects/AnaglyphEffect.js b/src/effects/AnaglyphEffect.js
index 7713e65e..fdbdc8c3 100644
--- a/src/effects/AnaglyphEffect.js
+++ b/src/effects/AnaglyphEffect.js
@@ -10,8 +10,8 @@ import {
   ShaderMaterial,
   StereoCamera,
   WebGLRenderTarget,
+  REVISION,
 } from 'three'
-import { version } from '../_polyfill/constants'
 
 class AnaglyphEffect {
   constructor(renderer, width = 512, height = 512) {
@@ -96,7 +96,7 @@ class AnaglyphEffect {
         '			max( colorL.a, colorR.a ) );',
 
         '	#include <tonemapping_fragment>',
-        `	#include <${version >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>`,
+        `	#include <${parseInt(REVISION.replace(/\D+/g, '')) >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>`,
 
         '}',
       ].join('\n'),
diff --git a/src/effects/OutlineEffect.js b/src/effects/OutlineEffect.js
index 581b2349..2999048c 100644
--- a/src/effects/OutlineEffect.js
+++ b/src/effects/OutlineEffect.js
@@ -1,5 +1,4 @@
-import { BackSide, Color, ShaderMaterial, UniformsLib, UniformsUtils } from 'three'
-import { version } from '../_polyfill/constants'
+import { BackSide, Color, ShaderMaterial, UniformsLib, UniformsUtils, REVISION } from 'three'
 
 /**
  * Reference: https://en.wikipedia.org/wiki/Cel_shading
@@ -158,7 +157,7 @@ class OutlineEffect {
       '	gl_FragColor = vec4( outlineColor, outlineAlpha );',
 
       '	#include <tonemapping_fragment>',
-      `	#include <${version >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>`,
+      `	#include <${parseInt(REVISION.replace(/\D+/g, '')) >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>`,
       '	#include <fog_fragment>',
       '	#include <premultiplied_alpha_fragment>',
 
diff --git a/src/effects/ParallaxBarrierEffect.js b/src/effects/ParallaxBarrierEffect.js
index 8cee4954..00ae33f4 100644
--- a/src/effects/ParallaxBarrierEffect.js
+++ b/src/effects/ParallaxBarrierEffect.js
@@ -9,8 +9,8 @@ import {
   ShaderMaterial,
   StereoCamera,
   WebGLRenderTarget,
+  REVISION,
 } from 'three'
-import { version } from '../_polyfill/constants'
 
 class ParallaxBarrierEffect {
   constructor(renderer) {
@@ -62,7 +62,7 @@ class ParallaxBarrierEffect {
         '	}',
 
         '	#include <tonemapping_fragment>',
-        `	#include <${version >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>`,
+        `	#include <${parseInt(REVISION.replace(/\D+/g, '')) >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>`,
 
         '}',
       ].join('\n'),
diff --git a/src/exporters/DRACOExporter.ts b/src/exporters/DRACOExporter.ts
index 8f15354b..474d6097 100644
--- a/src/exporters/DRACOExporter.ts
+++ b/src/exporters/DRACOExporter.ts
@@ -17,203 +17,191 @@ import { BufferGeometry, Mesh, Points } from 'three'
 
 declare const DracoEncoderModule: () => EncoderModule
 
-const DRACOExporter = /* @__PURE__ */ (() => {
-  class DRACOExporter {
-    // Encoder methods
-
-    public static MESH_EDGEBREAKER_ENCODING = 1
-    public static MESH_SEQUENTIAL_ENCODING = 0
-
-    // Geometry type
-
-    public static POINT_CLOUD = 0
-    public static TRIANGULAR_MESH = 1
-
-    // Attribute type
-    public static INVALID = -1
-    public static POSITION = 0
-    public static NORMAL = 1
-    public static COLOR = 2
-    public static TEX_COORD = 3
-    public static GENERIC = 4
-
-    public parse(
-      object: Mesh | Points,
-      options = {
-        decodeSpeed: 5,
-        encodeSpeed: 5,
-        encoderMethod: DRACOExporter.MESH_EDGEBREAKER_ENCODING,
-        quantization: [16, 8, 8, 8, 8],
-        exportUvs: true,
-        exportNormals: true,
-        exportColor: false,
-      },
-    ): Int8Array {
-      if (object instanceof BufferGeometry && object.isBufferGeometry) {
-        throw new Error('DRACOExporter: The first parameter of parse() is now an instance of Mesh or Points.')
-      }
-
-      if (DracoEncoderModule === undefined) {
-        throw new Error('THREE.DRACOExporter: required the draco_encoder to work.')
-      }
+class DRACOExporter {
+  // Encoder methods
+
+  public static MESH_EDGEBREAKER_ENCODING = 1
+  public static MESH_SEQUENTIAL_ENCODING = 0
+
+  // Geometry type
+
+  public static POINT_CLOUD = 0
+  public static TRIANGULAR_MESH = 1
+
+  // Attribute type
+  public static INVALID = -1
+  public static POSITION = 0
+  public static NORMAL = 1
+  public static COLOR = 2
+  public static TEX_COORD = 3
+  public static GENERIC = 4
+
+  public parse(
+    object: Mesh | Points,
+    options = {
+      decodeSpeed: 5,
+      encodeSpeed: 5,
+      encoderMethod: DRACOExporter.MESH_EDGEBREAKER_ENCODING,
+      quantization: [16, 8, 8, 8, 8],
+      exportUvs: true,
+      exportNormals: true,
+      exportColor: false,
+    },
+  ): Int8Array {
+    if (object instanceof BufferGeometry && object.isBufferGeometry) {
+      throw new Error('DRACOExporter: The first parameter of parse() is now an instance of Mesh or Points.')
+    }
 
-      const geometry = object.geometry
+    if (DracoEncoderModule === undefined) {
+      throw new Error('THREE.DRACOExporter: required the draco_encoder to work.')
+    }
 
-      const dracoEncoder = DracoEncoderModule()
-      const encoder = new dracoEncoder.Encoder()
-      let builder
-      let dracoObject
+    const geometry = object.geometry
 
-      if (!geometry.isBufferGeometry) {
-        throw new Error(
-          'THREE.DRACOExporter.parse(geometry, options): geometry is not a THREE.BufferGeometry instance.',
-        )
-      }
+    const dracoEncoder = DracoEncoderModule()
+    const encoder = new dracoEncoder.Encoder()
+    let builder
+    let dracoObject
 
-      if (object instanceof Mesh && object.isMesh) {
-        builder = new dracoEncoder.MeshBuilder()
-        dracoObject = new dracoEncoder.Mesh()
+    if (!geometry.isBufferGeometry) {
+      throw new Error('THREE.DRACOExporter.parse(geometry, options): geometry is not a THREE.BufferGeometry instance.')
+    }
 
-        const vertices = geometry.getAttribute('position')
-        // @ts-ignore
-        builder.AddFloatAttributeToMesh(
-          dracoObject,
-          dracoEncoder.POSITION,
-          vertices.count,
-          vertices.itemSize,
-          vertices.array,
-        )
+    if (object instanceof Mesh && object.isMesh) {
+      builder = new dracoEncoder.MeshBuilder()
+      dracoObject = new dracoEncoder.Mesh()
 
-        const faces = geometry.getIndex()
+      const vertices = geometry.getAttribute('position')
+      // @ts-ignore
+      builder.AddFloatAttributeToMesh(
+        dracoObject,
+        dracoEncoder.POSITION,
+        vertices.count,
+        vertices.itemSize,
+        vertices.array,
+      )
 
-        if (faces !== null) {
-          builder.AddFacesToMesh(dracoObject, faces.count / 3, faces.array as Uint16Array | Uint32Array)
-        } else {
-          const faces = new (vertices.count > 65535 ? Uint32Array : Uint16Array)(vertices.count)
+      const faces = geometry.getIndex()
 
-          for (let i = 0; i < faces.length; i++) {
-            faces[i] = i
-          }
+      if (faces !== null) {
+        builder.AddFacesToMesh(dracoObject, faces.count / 3, faces.array as Uint16Array | Uint32Array)
+      } else {
+        const faces = new (vertices.count > 65535 ? Uint32Array : Uint16Array)(vertices.count)
 
-          builder.AddFacesToMesh(dracoObject, vertices.count, faces)
+        for (let i = 0; i < faces.length; i++) {
+          faces[i] = i
         }
 
-        if (options.exportNormals) {
-          const normals = geometry.getAttribute('normal')
-
-          if (normals !== undefined) {
-            // @ts-ignore
-            builder.AddFloatAttributeToMesh(
-              dracoObject,
-              dracoEncoder.NORMAL,
-              normals.count,
-              normals.itemSize,
-              normals.array,
-            )
-          }
+        builder.AddFacesToMesh(dracoObject, vertices.count, faces)
+      }
+
+      if (options.exportNormals) {
+        const normals = geometry.getAttribute('normal')
+
+        if (normals !== undefined) {
+          // @ts-ignore
+          builder.AddFloatAttributeToMesh(
+            dracoObject,
+            dracoEncoder.NORMAL,
+            normals.count,
+            normals.itemSize,
+            normals.array,
+          )
         }
+      }
 
-        if (options.exportUvs) {
-          const uvs = geometry.getAttribute('uv')
+      if (options.exportUvs) {
+        const uvs = geometry.getAttribute('uv')
 
-          if (uvs !== undefined) {
-            // @ts-ignore
-            builder.AddFloatAttributeToMesh(dracoObject, dracoEncoder.TEX_COORD, uvs.count, uvs.itemSize, uvs.array)
-          }
+        if (uvs !== undefined) {
+          // @ts-ignore
+          builder.AddFloatAttributeToMesh(dracoObject, dracoEncoder.TEX_COORD, uvs.count, uvs.itemSize, uvs.array)
         }
+      }
+
+      if (options.exportColor) {
+        const colors = geometry.getAttribute('color')
 
-        if (options.exportColor) {
-          const colors = geometry.getAttribute('color')
-
-          if (colors !== undefined) {
-            // @ts-ignore
-            builder.AddFloatAttributeToMesh(
-              dracoObject,
-              dracoEncoder.COLOR,
-              colors.count,
-              colors.itemSize,
-              colors.array,
-            )
-          }
+        if (colors !== undefined) {
+          // @ts-ignore
+          builder.AddFloatAttributeToMesh(dracoObject, dracoEncoder.COLOR, colors.count, colors.itemSize, colors.array)
         }
-      } else if (object instanceof Points && object.isPoints) {
-        // @ts-ignore
-        builder = new dracoEncoder.PointCloudBuilder()
-        // @ts-ignore
-        dracoObject = new dracoEncoder.PointCloud()
+      }
+    } else if (object instanceof Points && object.isPoints) {
+      // @ts-ignore
+      builder = new dracoEncoder.PointCloudBuilder()
+      // @ts-ignore
+      dracoObject = new dracoEncoder.PointCloud()
 
-        const vertices = geometry.getAttribute('position')
-        builder.AddFloatAttribute(dracoObject, dracoEncoder.POSITION, vertices.count, vertices.itemSize, vertices.array)
+      const vertices = geometry.getAttribute('position')
+      builder.AddFloatAttribute(dracoObject, dracoEncoder.POSITION, vertices.count, vertices.itemSize, vertices.array)
 
-        if (options.exportColor) {
-          const colors = geometry.getAttribute('color')
+      if (options.exportColor) {
+        const colors = geometry.getAttribute('color')
 
-          if (colors !== undefined) {
-            builder.AddFloatAttribute(dracoObject, dracoEncoder.COLOR, colors.count, colors.itemSize, colors.array)
-          }
+        if (colors !== undefined) {
+          builder.AddFloatAttribute(dracoObject, dracoEncoder.COLOR, colors.count, colors.itemSize, colors.array)
         }
-      } else {
-        throw new Error('DRACOExporter: Unsupported object type.')
       }
+    } else {
+      throw new Error('DRACOExporter: Unsupported object type.')
+    }
 
-      //Compress using draco encoder
+    //Compress using draco encoder
 
-      const encodedData = new dracoEncoder.DracoInt8Array()
+    const encodedData = new dracoEncoder.DracoInt8Array()
 
-      //Sets the desired encoding and decoding speed for the given options from 0 (slowest speed, but the best compression) to 10 (fastest, but the worst compression).
+    //Sets the desired encoding and decoding speed for the given options from 0 (slowest speed, but the best compression) to 10 (fastest, but the worst compression).
 
-      const encodeSpeed = options.encodeSpeed !== undefined ? options.encodeSpeed : 5
-      const decodeSpeed = options.decodeSpeed !== undefined ? options.decodeSpeed : 5
+    const encodeSpeed = options.encodeSpeed !== undefined ? options.encodeSpeed : 5
+    const decodeSpeed = options.decodeSpeed !== undefined ? options.decodeSpeed : 5
 
-      encoder.SetSpeedOptions(encodeSpeed, decodeSpeed)
+    encoder.SetSpeedOptions(encodeSpeed, decodeSpeed)
 
-      // Sets the desired encoding method for a given geometry.
+    // Sets the desired encoding method for a given geometry.
 
-      if (options.encoderMethod !== undefined) {
-        encoder.SetEncodingMethod(options.encoderMethod)
-      }
+    if (options.encoderMethod !== undefined) {
+      encoder.SetEncodingMethod(options.encoderMethod)
+    }
 
-      // Sets the quantization (number of bits used to represent) compression options for a named attribute.
-      // The attribute values will be quantized in a box defined by the maximum extent of the attribute values.
-      if (options.quantization !== undefined) {
-        for (let i = 0; i < 5; i++) {
-          if (options.quantization[i] !== undefined) {
-            encoder.SetAttributeQuantization(i, options.quantization[i])
-          }
+    // Sets the quantization (number of bits used to represent) compression options for a named attribute.
+    // The attribute values will be quantized in a box defined by the maximum extent of the attribute values.
+    if (options.quantization !== undefined) {
+      for (let i = 0; i < 5; i++) {
+        if (options.quantization[i] !== undefined) {
+          encoder.SetAttributeQuantization(i, options.quantization[i])
         }
       }
+    }
 
-      let length
+    let length
 
-      if (object instanceof Mesh && object.isMesh) {
-        length = encoder.EncodeMeshToDracoBuffer(dracoObject, encodedData)
-      } else {
-        // @ts-ignore
-        length = encoder.EncodePointCloudToDracoBuffer(dracoObject, true, encodedData)
-      }
+    if (object instanceof Mesh && object.isMesh) {
+      length = encoder.EncodeMeshToDracoBuffer(dracoObject, encodedData)
+    } else {
+      // @ts-ignore
+      length = encoder.EncodePointCloudToDracoBuffer(dracoObject, true, encodedData)
+    }
 
-      dracoEncoder.destroy(dracoObject)
+    dracoEncoder.destroy(dracoObject)
 
-      if (length === 0) {
-        throw new Error('THREE.DRACOExporter: Draco encoding failed.')
-      }
+    if (length === 0) {
+      throw new Error('THREE.DRACOExporter: Draco encoding failed.')
+    }
 
-      //Copy encoded data to buffer.
-      const outputData = new Int8Array(new ArrayBuffer(length))
+    //Copy encoded data to buffer.
+    const outputData = new Int8Array(new ArrayBuffer(length))
 
-      for (let i = 0; i < length; i++) {
-        outputData[i] = encodedData.GetValue(i)
-      }
+    for (let i = 0; i < length; i++) {
+      outputData[i] = encodedData.GetValue(i)
+    }
 
-      dracoEncoder.destroy(encodedData)
-      dracoEncoder.destroy(encoder)
-      dracoEncoder.destroy(builder)
+    dracoEncoder.destroy(encodedData)
+    dracoEncoder.destroy(encoder)
+    dracoEncoder.destroy(builder)
 
-      return outputData
-    }
+    return outputData
   }
-
-  return DRACOExporter
-})()
+}
 
 export { DRACOExporter }
diff --git a/src/exporters/GLTFExporter.js b/src/exporters/GLTFExporter.js
index b2c9736b..143a42d5 100644
--- a/src/exporters/GLTFExporter.js
+++ b/src/exporters/GLTFExporter.js
@@ -129,263 +129,259 @@ const KHR_mesh_quantization_ExtraAttrTypes = {
   TEXCOORD: ['byte', 'byte normalized', 'unsigned byte', 'short', 'short normalized', 'unsigned short'],
 }
 
-const GLTFExporter = /* @__PURE__ */ (() => {
-  class GLTFExporter {
-    /**
-     * Static utility functions
-     */
-    static Utils = {
-      insertKeyframe: function (track, time) {
-        const tolerance = 0.001 // 1ms
-        const valueSize = track.getValueSize()
-
-        const times = new track.TimeBufferType(track.times.length + 1)
-        const values = new track.ValueBufferType(track.values.length + valueSize)
-        const interpolant = track.createInterpolant(new track.ValueBufferType(valueSize))
-
-        let index
-
-        if (track.times.length === 0) {
-          times[0] = time
-
-          for (let i = 0; i < valueSize; i++) {
-            values[i] = 0
-          }
+class GLTFExporter {
+  /**
+   * Static utility functions
+   */
+  static Utils = {
+    insertKeyframe: function (track, time) {
+      const tolerance = 0.001 // 1ms
+      const valueSize = track.getValueSize()
 
-          index = 0
-        } else if (time < track.times[0]) {
-          if (Math.abs(track.times[0] - time) < tolerance) return 0
+      const times = new track.TimeBufferType(track.times.length + 1)
+      const values = new track.ValueBufferType(track.values.length + valueSize)
+      const interpolant = track.createInterpolant(new track.ValueBufferType(valueSize))
 
-          times[0] = time
-          times.set(track.times, 1)
+      let index
 
-          values.set(interpolant.evaluate(time), 0)
-          values.set(track.values, valueSize)
+      if (track.times.length === 0) {
+        times[0] = time
 
-          index = 0
-        } else if (time > track.times[track.times.length - 1]) {
-          if (Math.abs(track.times[track.times.length - 1] - time) < tolerance) {
-            return track.times.length - 1
-          }
+        for (let i = 0; i < valueSize; i++) {
+          values[i] = 0
+        }
 
-          times[times.length - 1] = time
-          times.set(track.times, 0)
+        index = 0
+      } else if (time < track.times[0]) {
+        if (Math.abs(track.times[0] - time) < tolerance) return 0
 
-          values.set(track.values, 0)
-          values.set(interpolant.evaluate(time), track.values.length)
+        times[0] = time
+        times.set(track.times, 1)
 
-          index = times.length - 1
-        } else {
-          for (let i = 0; i < track.times.length; i++) {
-            if (Math.abs(track.times[i] - time) < tolerance) return i
+        values.set(interpolant.evaluate(time), 0)
+        values.set(track.values, valueSize)
 
-            if (track.times[i] < time && track.times[i + 1] > time) {
-              times.set(track.times.slice(0, i + 1), 0)
-              times[i + 1] = time
-              times.set(track.times.slice(i + 1), i + 2)
+        index = 0
+      } else if (time > track.times[track.times.length - 1]) {
+        if (Math.abs(track.times[track.times.length - 1] - time) < tolerance) {
+          return track.times.length - 1
+        }
 
-              values.set(track.values.slice(0, (i + 1) * valueSize), 0)
-              values.set(interpolant.evaluate(time), (i + 1) * valueSize)
-              values.set(track.values.slice((i + 1) * valueSize), (i + 2) * valueSize)
+        times[times.length - 1] = time
+        times.set(track.times, 0)
 
-              index = i + 1
+        values.set(track.values, 0)
+        values.set(interpolant.evaluate(time), track.values.length)
 
-              break
-            }
-          }
-        }
+        index = times.length - 1
+      } else {
+        for (let i = 0; i < track.times.length; i++) {
+          if (Math.abs(track.times[i] - time) < tolerance) return i
 
-        track.times = times
-        track.values = values
+          if (track.times[i] < time && track.times[i + 1] > time) {
+            times.set(track.times.slice(0, i + 1), 0)
+            times[i + 1] = time
+            times.set(track.times.slice(i + 1), i + 2)
 
-        return index
-      },
+            values.set(track.values.slice(0, (i + 1) * valueSize), 0)
+            values.set(interpolant.evaluate(time), (i + 1) * valueSize)
+            values.set(track.values.slice((i + 1) * valueSize), (i + 2) * valueSize)
 
-      mergeMorphTargetTracks: function (clip, root) {
-        const tracks = []
-        const mergedTracks = {}
-        const sourceTracks = clip.tracks
-
-        for (let i = 0; i < sourceTracks.length; ++i) {
-          let sourceTrack = sourceTracks[i]
-          const sourceTrackBinding = PropertyBinding.parseTrackName(sourceTrack.name)
-          const sourceTrackNode = PropertyBinding.findNode(root, sourceTrackBinding.nodeName)
-
-          if (
-            sourceTrackBinding.propertyName !== 'morphTargetInfluences' ||
-            sourceTrackBinding.propertyIndex === undefined
-          ) {
-            // Tracks that don't affect morph targets, or that affect all morph targets together, can be left as-is.
-            tracks.push(sourceTrack)
-            continue
+            index = i + 1
+
+            break
           }
+        }
+      }
 
-          if (
-            sourceTrack.createInterpolant !== sourceTrack.InterpolantFactoryMethodDiscrete &&
-            sourceTrack.createInterpolant !== sourceTrack.InterpolantFactoryMethodLinear
-          ) {
-            if (sourceTrack.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline) {
-              // This should never happen, because glTF morph target animations
-              // affect all targets already.
-              throw new Error('THREE.GLTFExporter: Cannot merge tracks with glTF CUBICSPLINE interpolation.')
-            }
+      track.times = times
+      track.values = values
 
-            console.warn('THREE.GLTFExporter: Morph target interpolation mode not yet supported. Using LINEAR instead.')
+      return index
+    },
+
+    mergeMorphTargetTracks: function (clip, root) {
+      const tracks = []
+      const mergedTracks = {}
+      const sourceTracks = clip.tracks
+
+      for (let i = 0; i < sourceTracks.length; ++i) {
+        let sourceTrack = sourceTracks[i]
+        const sourceTrackBinding = PropertyBinding.parseTrackName(sourceTrack.name)
+        const sourceTrackNode = PropertyBinding.findNode(root, sourceTrackBinding.nodeName)
+
+        if (
+          sourceTrackBinding.propertyName !== 'morphTargetInfluences' ||
+          sourceTrackBinding.propertyIndex === undefined
+        ) {
+          // Tracks that don't affect morph targets, or that affect all morph targets together, can be left as-is.
+          tracks.push(sourceTrack)
+          continue
+        }
 
-            sourceTrack = sourceTrack.clone()
-            sourceTrack.setInterpolation(InterpolateLinear)
+        if (
+          sourceTrack.createInterpolant !== sourceTrack.InterpolantFactoryMethodDiscrete &&
+          sourceTrack.createInterpolant !== sourceTrack.InterpolantFactoryMethodLinear
+        ) {
+          if (sourceTrack.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline) {
+            // This should never happen, because glTF morph target animations
+            // affect all targets already.
+            throw new Error('THREE.GLTFExporter: Cannot merge tracks with glTF CUBICSPLINE interpolation.')
           }
 
-          const targetCount = sourceTrackNode.morphTargetInfluences.length
-          const targetIndex = sourceTrackNode.morphTargetDictionary[sourceTrackBinding.propertyIndex]
-
-          if (targetIndex === undefined) {
-            throw new Error('THREE.GLTFExporter: Morph target name not found: ' + sourceTrackBinding.propertyIndex)
-          }
+          console.warn('THREE.GLTFExporter: Morph target interpolation mode not yet supported. Using LINEAR instead.')
 
-          let mergedTrack
+          sourceTrack = sourceTrack.clone()
+          sourceTrack.setInterpolation(InterpolateLinear)
+        }
 
-          // If this is the first time we've seen this object, create a new
-          // track to store merged keyframe data for each morph target.
-          if (mergedTracks[sourceTrackNode.uuid] === undefined) {
-            mergedTrack = sourceTrack.clone()
+        const targetCount = sourceTrackNode.morphTargetInfluences.length
+        const targetIndex = sourceTrackNode.morphTargetDictionary[sourceTrackBinding.propertyIndex]
 
-            const values = new mergedTrack.ValueBufferType(targetCount * mergedTrack.times.length)
+        if (targetIndex === undefined) {
+          throw new Error('THREE.GLTFExporter: Morph target name not found: ' + sourceTrackBinding.propertyIndex)
+        }
 
-            for (let j = 0; j < mergedTrack.times.length; j++) {
-              values[j * targetCount + targetIndex] = mergedTrack.values[j]
-            }
+        let mergedTrack
 
-            // We need to take into consideration the intended target node
-            // of our original un-merged morphTarget animation.
-            mergedTrack.name = (sourceTrackBinding.nodeName || '') + '.morphTargetInfluences'
-            mergedTrack.values = values
+        // If this is the first time we've seen this object, create a new
+        // track to store merged keyframe data for each morph target.
+        if (mergedTracks[sourceTrackNode.uuid] === undefined) {
+          mergedTrack = sourceTrack.clone()
 
-            mergedTracks[sourceTrackNode.uuid] = mergedTrack
-            tracks.push(mergedTrack)
+          const values = new mergedTrack.ValueBufferType(targetCount * mergedTrack.times.length)
 
-            continue
+          for (let j = 0; j < mergedTrack.times.length; j++) {
+            values[j * targetCount + targetIndex] = mergedTrack.values[j]
           }
 
-          const sourceInterpolant = sourceTrack.createInterpolant(new sourceTrack.ValueBufferType(1))
+          // We need to take into consideration the intended target node
+          // of our original un-merged morphTarget animation.
+          mergedTrack.name = (sourceTrackBinding.nodeName || '') + '.morphTargetInfluences'
+          mergedTrack.values = values
 
-          mergedTrack = mergedTracks[sourceTrackNode.uuid]
+          mergedTracks[sourceTrackNode.uuid] = mergedTrack
+          tracks.push(mergedTrack)
 
-          // For every existing keyframe of the merged track, write a (possibly
-          // interpolated) value from the source track.
-          for (let j = 0; j < mergedTrack.times.length; j++) {
-            mergedTrack.values[j * targetCount + targetIndex] = sourceInterpolant.evaluate(mergedTrack.times[j])
-          }
+          continue
+        }
 
-          // For every existing keyframe of the source track, write a (possibly
-          // new) keyframe to the merged track. Values from the previous loop may
-          // be written again, but keyframes are de-duplicated.
-          for (let j = 0; j < sourceTrack.times.length; j++) {
-            const keyframeIndex = this.insertKeyframe(mergedTrack, sourceTrack.times[j])
-            mergedTrack.values[keyframeIndex * targetCount + targetIndex] = sourceTrack.values[j]
-          }
+        const sourceInterpolant = sourceTrack.createInterpolant(new sourceTrack.ValueBufferType(1))
+
+        mergedTrack = mergedTracks[sourceTrackNode.uuid]
+
+        // For every existing keyframe of the merged track, write a (possibly
+        // interpolated) value from the source track.
+        for (let j = 0; j < mergedTrack.times.length; j++) {
+          mergedTrack.values[j * targetCount + targetIndex] = sourceInterpolant.evaluate(mergedTrack.times[j])
         }
 
-        clip.tracks = tracks
+        // For every existing keyframe of the source track, write a (possibly
+        // new) keyframe to the merged track. Values from the previous loop may
+        // be written again, but keyframes are de-duplicated.
+        for (let j = 0; j < sourceTrack.times.length; j++) {
+          const keyframeIndex = this.insertKeyframe(mergedTrack, sourceTrack.times[j])
+          mergedTrack.values[keyframeIndex * targetCount + targetIndex] = sourceTrack.values[j]
+        }
+      }
 
-        return clip
-      },
-    }
+      clip.tracks = tracks
 
-    constructor() {
-      this.pluginCallbacks = []
+      return clip
+    },
+  }
 
-      this.register(function (writer) {
-        return new GLTFLightExtension(writer)
-      })
+  constructor() {
+    this.pluginCallbacks = []
 
-      this.register(function (writer) {
-        return new GLTFMaterialsUnlitExtension(writer)
-      })
+    this.register(function (writer) {
+      return new GLTFLightExtension(writer)
+    })
 
-      this.register(function (writer) {
-        return new GLTFMaterialsTransmissionExtension(writer)
-      })
+    this.register(function (writer) {
+      return new GLTFMaterialsUnlitExtension(writer)
+    })
 
-      this.register(function (writer) {
-        return new GLTFMaterialsVolumeExtension(writer)
-      })
+    this.register(function (writer) {
+      return new GLTFMaterialsTransmissionExtension(writer)
+    })
 
-      this.register(function (writer) {
-        return new GLTFMaterialsIorExtension(writer)
-      })
+    this.register(function (writer) {
+      return new GLTFMaterialsVolumeExtension(writer)
+    })
 
-      this.register(function (writer) {
-        return new GLTFMaterialsSpecularExtension(writer)
-      })
+    this.register(function (writer) {
+      return new GLTFMaterialsIorExtension(writer)
+    })
 
-      this.register(function (writer) {
-        return new GLTFMaterialsClearcoatExtension(writer)
-      })
+    this.register(function (writer) {
+      return new GLTFMaterialsSpecularExtension(writer)
+    })
 
-      this.register(function (writer) {
-        return new GLTFMaterialsIridescenceExtension(writer)
-      })
+    this.register(function (writer) {
+      return new GLTFMaterialsClearcoatExtension(writer)
+    })
 
-      this.register(function (writer) {
-        return new GLTFMaterialsSheenExtension(writer)
-      })
+    this.register(function (writer) {
+      return new GLTFMaterialsIridescenceExtension(writer)
+    })
 
-      this.register(function (writer) {
-        return new GLTFMaterialsAnisotropyExtension(writer)
-      })
+    this.register(function (writer) {
+      return new GLTFMaterialsSheenExtension(writer)
+    })
 
-      this.register(function (writer) {
-        return new GLTFMaterialsEmissiveStrengthExtension(writer)
-      })
-    }
+    this.register(function (writer) {
+      return new GLTFMaterialsAnisotropyExtension(writer)
+    })
 
-    register(callback) {
-      if (this.pluginCallbacks.indexOf(callback) === -1) {
-        this.pluginCallbacks.push(callback)
-      }
+    this.register(function (writer) {
+      return new GLTFMaterialsEmissiveStrengthExtension(writer)
+    })
+  }
 
-      return this
+  register(callback) {
+    if (this.pluginCallbacks.indexOf(callback) === -1) {
+      this.pluginCallbacks.push(callback)
     }
 
-    unregister(callback) {
-      if (this.pluginCallbacks.indexOf(callback) !== -1) {
-        this.pluginCallbacks.splice(this.pluginCallbacks.indexOf(callback), 1)
-      }
+    return this
+  }
 
-      return this
+  unregister(callback) {
+    if (this.pluginCallbacks.indexOf(callback) !== -1) {
+      this.pluginCallbacks.splice(this.pluginCallbacks.indexOf(callback), 1)
     }
 
-    /**
-     * Parse scenes and generate GLTF output
-     * @param  {Scene or [THREE.Scenes]} input   Scene or Array of THREE.Scenes
-     * @param  {Function} onDone  Callback on completed
-     * @param  {Function} onError  Callback on errors
-     * @param  {Object} options options
-     */
-    parse(input, onDone, onError, options) {
-      const writer = new GLTFWriter()
-      const plugins = []
+    return this
+  }
 
-      for (let i = 0, il = this.pluginCallbacks.length; i < il; i++) {
-        plugins.push(this.pluginCallbacks[i](writer))
-      }
+  /**
+   * Parse scenes and generate GLTF output
+   * @param  {Scene or [THREE.Scenes]} input   Scene or Array of THREE.Scenes
+   * @param  {Function} onDone  Callback on completed
+   * @param  {Function} onError  Callback on errors
+   * @param  {Object} options options
+   */
+  parse(input, onDone, onError, options) {
+    const writer = new GLTFWriter()
+    const plugins = []
 
-      writer.setPlugins(plugins)
-      writer.write(input, onDone, options).catch(onError)
+    for (let i = 0, il = this.pluginCallbacks.length; i < il; i++) {
+      plugins.push(this.pluginCallbacks[i](writer))
     }
 
-    parseAsync(input, options) {
-      const scope = this
-
-      return new Promise(function (resolve, reject) {
-        scope.parse(input, resolve, reject, options)
-      })
-    }
+    writer.setPlugins(plugins)
+    writer.write(input, onDone, options).catch(onError)
   }
 
-  return GLTFExporter
-})()
+  parseAsync(input, options) {
+    const scope = this
+
+    return new Promise(function (resolve, reject) {
+      scope.parse(input, resolve, reject, options)
+    })
+  }
+}
 
 //------------------------------------------------------------------------------
 // Constants
@@ -445,7 +441,7 @@ const PATH_PROPERTIES = {
   morphTargetInfluences: 'weights',
 }
 
-const DEFAULT_SPECULAR_COLOR = /* @__PURE__ */ new Color()
+const DEFAULT_SPECULAR_COLOR = new Color()
 
 // GLB constants
 // https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#glb-file-format-specification
diff --git a/src/geometries/LightningStrike.js b/src/geometries/LightningStrike.js
index fe434a24..36cb6bc0 100644
--- a/src/geometries/LightningStrike.js
+++ b/src/geometries/LightningStrike.js
@@ -109,821 +109,811 @@ import { SimplexNoise } from '../math/SimplexNoise'
  *
  */
 
-const LightningStrike = /* @__PURE__ */ (() => {
-  class LightningStrike extends BufferGeometry {
-    // Ray states
-    static RAY_INITIALIZED = 0
-    static RAY_UNBORN = 1
-    static RAY_PROPAGATING = 2
-    static RAY_STEADY = 3
-    static RAY_VANISHING = 4
-    static RAY_EXTINGUISHED = 5
+class LightningStrike extends BufferGeometry {
+  // Ray states
+  static RAY_INITIALIZED = 0
+  static RAY_UNBORN = 1
+  static RAY_PROPAGATING = 2
+  static RAY_STEADY = 3
+  static RAY_VANISHING = 4
+  static RAY_EXTINGUISHED = 5
 
-    static COS30DEG = Math.cos((30 * Math.PI) / 180)
-    static SIN30DEG = Math.sin((30 * Math.PI) / 180)
+  static COS30DEG = Math.cos((30 * Math.PI) / 180)
+  static SIN30DEG = Math.sin((30 * Math.PI) / 180)
 
-    constructor(rayParameters = {}) {
-      super()
+  constructor(rayParameters = {}) {
+    super()
 
-      this.isLightningStrike = true
+    this.isLightningStrike = true
 
-      this.type = 'LightningStrike'
+    this.type = 'LightningStrike'
 
-      // Set parameters, and set undefined parameters to default values
-      this.init(LightningStrike.copyParameters(rayParameters, rayParameters))
+    // Set parameters, and set undefined parameters to default values
+    this.init(LightningStrike.copyParameters(rayParameters, rayParameters))
 
-      // Creates and populates the mesh
-      this.createMesh()
-    }
-
-    static createRandomGenerator() {
-      const numSeeds = 2053
-      const seeds = []
+    // Creates and populates the mesh
+    this.createMesh()
+  }
 
-      for (let i = 0; i < numSeeds; i++) {
-        seeds.push(Math.random())
-      }
+  static createRandomGenerator() {
+    const numSeeds = 2053
+    const seeds = []
 
-      const generator = {
-        currentSeed: 0,
+    for (let i = 0; i < numSeeds; i++) {
+      seeds.push(Math.random())
+    }
 
-        random: function () {
-          const value = seeds[generator.currentSeed]
+    const generator = {
+      currentSeed: 0,
 
-          generator.currentSeed = (generator.currentSeed + 1) % numSeeds
+      random: function () {
+        const value = seeds[generator.currentSeed]
 
-          return value
-        },
+        generator.currentSeed = (generator.currentSeed + 1) % numSeeds
 
-        getSeed: function () {
-          return generator.currentSeed / numSeeds
-        },
+        return value
+      },
 
-        setSeed: function (seed) {
-          generator.currentSeed = Math.floor(seed * numSeeds) % numSeeds
-        },
-      }
+      getSeed: function () {
+        return generator.currentSeed / numSeeds
+      },
 
-      return generator
+      setSeed: function (seed) {
+        generator.currentSeed = Math.floor(seed * numSeeds) % numSeeds
+      },
     }
 
-    static copyParameters(dest = {}, source = {}) {
-      const vecCopy = function (v) {
-        if (source === dest) {
-          return v
-        } else {
-          return v.clone()
-        }
-      }
+    return generator
+  }
 
-      ;(dest.sourceOffset = source.sourceOffset !== undefined ? vecCopy(source.sourceOffset) : new Vector3(0, 100, 0)),
-        (dest.destOffset = source.destOffset !== undefined ? vecCopy(source.destOffset) : new Vector3(0, 0, 0)),
-        (dest.timeScale = source.timeScale !== undefined ? source.timeScale : 1),
-        (dest.roughness = source.roughness !== undefined ? source.roughness : 0.9),
-        (dest.straightness = source.straightness !== undefined ? source.straightness : 0.7),
-        (dest.up0 = source.up0 !== undefined ? vecCopy(source.up0) : new Vector3(0, 0, 1))
-      ;(dest.up1 = source.up1 !== undefined ? vecCopy(source.up1) : new Vector3(0, 0, 1)),
-        (dest.radius0 = source.radius0 !== undefined ? source.radius0 : 1),
-        (dest.radius1 = source.radius1 !== undefined ? source.radius1 : 1),
-        (dest.radius0Factor = source.radius0Factor !== undefined ? source.radius0Factor : 0.5),
-        (dest.radius1Factor = source.radius1Factor !== undefined ? source.radius1Factor : 0.2),
-        (dest.minRadius = source.minRadius !== undefined ? source.minRadius : 0.2),
-        // These parameters should not be changed after lightning creation. They can be changed but the ray will change its form abruptly:
-
-        (dest.isEternal =
-          source.isEternal !== undefined
-            ? source.isEternal
-            : source.birthTime === undefined || source.deathTime === undefined),
-        (dest.birthTime = source.birthTime),
-        (dest.deathTime = source.deathTime),
-        (dest.propagationTimeFactor = source.propagationTimeFactor !== undefined ? source.propagationTimeFactor : 0.1),
-        (dest.vanishingTimeFactor = source.vanishingTimeFactor !== undefined ? source.vanishingTimeFactor : 0.9),
-        (dest.subrayPeriod = source.subrayPeriod !== undefined ? source.subrayPeriod : 4),
-        (dest.subrayDutyCycle = source.subrayDutyCycle !== undefined ? source.subrayDutyCycle : 0.6)
-
-      // These parameters cannot change after lightning creation:
-
-      dest.maxIterations = source.maxIterations !== undefined ? source.maxIterations : 9
-      dest.isStatic = source.isStatic !== undefined ? source.isStatic : false
-      dest.ramification = source.ramification !== undefined ? source.ramification : 5
-      dest.maxSubrayRecursion = source.maxSubrayRecursion !== undefined ? source.maxSubrayRecursion : 3
-      dest.recursionProbability = source.recursionProbability !== undefined ? source.recursionProbability : 0.6
-      dest.generateUVs = source.generateUVs !== undefined ? source.generateUVs : false
-      ;(dest.randomGenerator = source.randomGenerator),
-        (dest.noiseSeed = source.noiseSeed),
-        (dest.onDecideSubrayCreation = source.onDecideSubrayCreation),
-        (dest.onSubrayCreation = source.onSubrayCreation)
-
-      return dest
+  static copyParameters(dest = {}, source = {}) {
+    const vecCopy = function (v) {
+      if (source === dest) {
+        return v
+      } else {
+        return v.clone()
+      }
     }
 
-    update(time) {
-      if (this.isStatic) return
+    ;(dest.sourceOffset = source.sourceOffset !== undefined ? vecCopy(source.sourceOffset) : new Vector3(0, 100, 0)),
+      (dest.destOffset = source.destOffset !== undefined ? vecCopy(source.destOffset) : new Vector3(0, 0, 0)),
+      (dest.timeScale = source.timeScale !== undefined ? source.timeScale : 1),
+      (dest.roughness = source.roughness !== undefined ? source.roughness : 0.9),
+      (dest.straightness = source.straightness !== undefined ? source.straightness : 0.7),
+      (dest.up0 = source.up0 !== undefined ? vecCopy(source.up0) : new Vector3(0, 0, 1))
+    ;(dest.up1 = source.up1 !== undefined ? vecCopy(source.up1) : new Vector3(0, 0, 1)),
+      (dest.radius0 = source.radius0 !== undefined ? source.radius0 : 1),
+      (dest.radius1 = source.radius1 !== undefined ? source.radius1 : 1),
+      (dest.radius0Factor = source.radius0Factor !== undefined ? source.radius0Factor : 0.5),
+      (dest.radius1Factor = source.radius1Factor !== undefined ? source.radius1Factor : 0.2),
+      (dest.minRadius = source.minRadius !== undefined ? source.minRadius : 0.2),
+      // These parameters should not be changed after lightning creation. They can be changed but the ray will change its form abruptly:
+
+      (dest.isEternal =
+        source.isEternal !== undefined
+          ? source.isEternal
+          : source.birthTime === undefined || source.deathTime === undefined),
+      (dest.birthTime = source.birthTime),
+      (dest.deathTime = source.deathTime),
+      (dest.propagationTimeFactor = source.propagationTimeFactor !== undefined ? source.propagationTimeFactor : 0.1),
+      (dest.vanishingTimeFactor = source.vanishingTimeFactor !== undefined ? source.vanishingTimeFactor : 0.9),
+      (dest.subrayPeriod = source.subrayPeriod !== undefined ? source.subrayPeriod : 4),
+      (dest.subrayDutyCycle = source.subrayDutyCycle !== undefined ? source.subrayDutyCycle : 0.6)
+
+    // These parameters cannot change after lightning creation:
+
+    dest.maxIterations = source.maxIterations !== undefined ? source.maxIterations : 9
+    dest.isStatic = source.isStatic !== undefined ? source.isStatic : false
+    dest.ramification = source.ramification !== undefined ? source.ramification : 5
+    dest.maxSubrayRecursion = source.maxSubrayRecursion !== undefined ? source.maxSubrayRecursion : 3
+    dest.recursionProbability = source.recursionProbability !== undefined ? source.recursionProbability : 0.6
+    dest.generateUVs = source.generateUVs !== undefined ? source.generateUVs : false
+    ;(dest.randomGenerator = source.randomGenerator),
+      (dest.noiseSeed = source.noiseSeed),
+      (dest.onDecideSubrayCreation = source.onDecideSubrayCreation),
+      (dest.onSubrayCreation = source.onSubrayCreation)
+
+    return dest
+  }
 
-      if (
-        this.rayParameters.isEternal ||
-        (this.rayParameters.birthTime <= time && time <= this.rayParameters.deathTime)
-      ) {
-        this.updateMesh(time)
-
-        if (time < this.subrays[0].endPropagationTime) {
-          this.state = LightningStrike.RAY_PROPAGATING
-        } else if (time > this.subrays[0].beginVanishingTime) {
-          this.state = LightningStrike.RAY_VANISHING
-        } else {
-          this.state = LightningStrike.RAY_STEADY
-        }
+  update(time) {
+    if (this.isStatic) return
+
+    if (
+      this.rayParameters.isEternal ||
+      (this.rayParameters.birthTime <= time && time <= this.rayParameters.deathTime)
+    ) {
+      this.updateMesh(time)
 
-        this.visible = true
+      if (time < this.subrays[0].endPropagationTime) {
+        this.state = LightningStrike.RAY_PROPAGATING
+      } else if (time > this.subrays[0].beginVanishingTime) {
+        this.state = LightningStrike.RAY_VANISHING
       } else {
-        this.visible = false
+        this.state = LightningStrike.RAY_STEADY
+      }
 
-        if (time < this.rayParameters.birthTime) {
-          this.state = LightningStrike.RAY_UNBORN
-        } else {
-          this.state = LightningStrike.RAY_EXTINGUISHED
-        }
+      this.visible = true
+    } else {
+      this.visible = false
+
+      if (time < this.rayParameters.birthTime) {
+        this.state = LightningStrike.RAY_UNBORN
+      } else {
+        this.state = LightningStrike.RAY_EXTINGUISHED
       }
     }
+  }
 
-    init(rayParameters) {
-      // Init all the state from the parameters
-
-      this.rayParameters = rayParameters
-
-      // These parameters cannot change after lightning creation:
-
-      this.maxIterations = rayParameters.maxIterations !== undefined ? Math.floor(rayParameters.maxIterations) : 9
-      rayParameters.maxIterations = this.maxIterations
-      this.isStatic = rayParameters.isStatic !== undefined ? rayParameters.isStatic : false
-      rayParameters.isStatic = this.isStatic
-      this.ramification = rayParameters.ramification !== undefined ? Math.floor(rayParameters.ramification) : 5
-      rayParameters.ramification = this.ramification
-      this.maxSubrayRecursion =
-        rayParameters.maxSubrayRecursion !== undefined ? Math.floor(rayParameters.maxSubrayRecursion) : 3
-      rayParameters.maxSubrayRecursion = this.maxSubrayRecursion
-      this.recursionProbability =
-        rayParameters.recursionProbability !== undefined ? rayParameters.recursionProbability : 0.6
-      rayParameters.recursionProbability = this.recursionProbability
-      this.generateUVs = rayParameters.generateUVs !== undefined ? rayParameters.generateUVs : false
-      rayParameters.generateUVs = this.generateUVs
-
-      // Random generator
-      if (rayParameters.randomGenerator !== undefined) {
-        this.randomGenerator = rayParameters.randomGenerator
-        this.seedGenerator = rayParameters.randomGenerator
-
-        if (rayParameters.noiseSeed !== undefined) {
-          this.seedGenerator.setSeed(rayParameters.noiseSeed)
-        }
-      } else {
-        this.randomGenerator = LightningStrike.createRandomGenerator()
-        this.seedGenerator = Math
+  init(rayParameters) {
+    // Init all the state from the parameters
+
+    this.rayParameters = rayParameters
+
+    // These parameters cannot change after lightning creation:
+
+    this.maxIterations = rayParameters.maxIterations !== undefined ? Math.floor(rayParameters.maxIterations) : 9
+    rayParameters.maxIterations = this.maxIterations
+    this.isStatic = rayParameters.isStatic !== undefined ? rayParameters.isStatic : false
+    rayParameters.isStatic = this.isStatic
+    this.ramification = rayParameters.ramification !== undefined ? Math.floor(rayParameters.ramification) : 5
+    rayParameters.ramification = this.ramification
+    this.maxSubrayRecursion =
+      rayParameters.maxSubrayRecursion !== undefined ? Math.floor(rayParameters.maxSubrayRecursion) : 3
+    rayParameters.maxSubrayRecursion = this.maxSubrayRecursion
+    this.recursionProbability =
+      rayParameters.recursionProbability !== undefined ? rayParameters.recursionProbability : 0.6
+    rayParameters.recursionProbability = this.recursionProbability
+    this.generateUVs = rayParameters.generateUVs !== undefined ? rayParameters.generateUVs : false
+    rayParameters.generateUVs = this.generateUVs
+
+    // Random generator
+    if (rayParameters.randomGenerator !== undefined) {
+      this.randomGenerator = rayParameters.randomGenerator
+      this.seedGenerator = rayParameters.randomGenerator
+
+      if (rayParameters.noiseSeed !== undefined) {
+        this.seedGenerator.setSeed(rayParameters.noiseSeed)
       }
+    } else {
+      this.randomGenerator = LightningStrike.createRandomGenerator()
+      this.seedGenerator = Math
+    }
 
-      // Ray creation callbacks
-      if (rayParameters.onDecideSubrayCreation !== undefined) {
-        this.onDecideSubrayCreation = rayParameters.onDecideSubrayCreation
-      } else {
-        this.createDefaultSubrayCreationCallbacks()
+    // Ray creation callbacks
+    if (rayParameters.onDecideSubrayCreation !== undefined) {
+      this.onDecideSubrayCreation = rayParameters.onDecideSubrayCreation
+    } else {
+      this.createDefaultSubrayCreationCallbacks()
 
-        if (rayParameters.onSubrayCreation !== undefined) {
-          this.onSubrayCreation = rayParameters.onSubrayCreation
-        }
+      if (rayParameters.onSubrayCreation !== undefined) {
+        this.onSubrayCreation = rayParameters.onSubrayCreation
       }
+    }
 
-      // Internal state
+    // Internal state
 
-      this.state = LightningStrike.RAY_INITIALIZED
+    this.state = LightningStrike.RAY_INITIALIZED
 
-      this.maxSubrays = Math.ceil(1 + Math.pow(this.ramification, Math.max(0, this.maxSubrayRecursion - 1)))
-      rayParameters.maxSubrays = this.maxSubrays
+    this.maxSubrays = Math.ceil(1 + Math.pow(this.ramification, Math.max(0, this.maxSubrayRecursion - 1)))
+    rayParameters.maxSubrays = this.maxSubrays
 
-      this.maxRaySegments = 2 * (1 << this.maxIterations)
+    this.maxRaySegments = 2 * (1 << this.maxIterations)
 
-      this.subrays = []
+    this.subrays = []
 
-      for (let i = 0; i < this.maxSubrays; i++) {
-        this.subrays.push(this.createSubray())
-      }
-
-      this.raySegments = []
+    for (let i = 0; i < this.maxSubrays; i++) {
+      this.subrays.push(this.createSubray())
+    }
 
-      for (let i = 0; i < this.maxRaySegments; i++) {
-        this.raySegments.push(this.createSegment())
-      }
+    this.raySegments = []
 
-      this.time = 0
-      this.timeFraction = 0
-      this.currentSegmentCallback = null
-      this.currentCreateTriangleVertices = this.generateUVs
-        ? this.createTriangleVerticesWithUVs
-        : this.createTriangleVerticesWithoutUVs
-      this.numSubrays = 0
-      this.currentSubray = null
-      this.currentSegmentIndex = 0
-      this.isInitialSegment = false
-      this.subrayProbability = 0
-
-      this.currentVertex = 0
-      this.currentIndex = 0
-      this.currentCoordinate = 0
-      this.currentUVCoordinate = 0
-      this.vertices = null
-      this.uvs = null
-      this.indices = null
-      this.positionAttribute = null
-      this.uvsAttribute = null
-
-      this.simplexX = new SimplexNoise(this.seedGenerator)
-      this.simplexY = new SimplexNoise(this.seedGenerator)
-      this.simplexZ = new SimplexNoise(this.seedGenerator)
-
-      // Temp vectors
-      this.forwards = new Vector3()
-      this.forwardsFill = new Vector3()
-      this.side = new Vector3()
-      this.down = new Vector3()
-      this.middlePos = new Vector3()
-      this.middleLinPos = new Vector3()
-      this.newPos = new Vector3()
-      this.vPos = new Vector3()
-      this.cross1 = new Vector3()
+    for (let i = 0; i < this.maxRaySegments; i++) {
+      this.raySegments.push(this.createSegment())
     }
 
-    createMesh() {
-      const maxDrawableSegmentsPerSubRay = 1 << this.maxIterations
-
-      const maxVerts = 3 * (maxDrawableSegmentsPerSubRay + 1) * this.maxSubrays
-      const maxIndices = 18 * maxDrawableSegmentsPerSubRay * this.maxSubrays
+    this.time = 0
+    this.timeFraction = 0
+    this.currentSegmentCallback = null
+    this.currentCreateTriangleVertices = this.generateUVs
+      ? this.createTriangleVerticesWithUVs
+      : this.createTriangleVerticesWithoutUVs
+    this.numSubrays = 0
+    this.currentSubray = null
+    this.currentSegmentIndex = 0
+    this.isInitialSegment = false
+    this.subrayProbability = 0
+
+    this.currentVertex = 0
+    this.currentIndex = 0
+    this.currentCoordinate = 0
+    this.currentUVCoordinate = 0
+    this.vertices = null
+    this.uvs = null
+    this.indices = null
+    this.positionAttribute = null
+    this.uvsAttribute = null
+
+    this.simplexX = new SimplexNoise(this.seedGenerator)
+    this.simplexY = new SimplexNoise(this.seedGenerator)
+    this.simplexZ = new SimplexNoise(this.seedGenerator)
+
+    // Temp vectors
+    this.forwards = new Vector3()
+    this.forwardsFill = new Vector3()
+    this.side = new Vector3()
+    this.down = new Vector3()
+    this.middlePos = new Vector3()
+    this.middleLinPos = new Vector3()
+    this.newPos = new Vector3()
+    this.vPos = new Vector3()
+    this.cross1 = new Vector3()
+  }
 
-      this.vertices = new Float32Array(maxVerts * 3)
-      this.indices = new Uint32Array(maxIndices)
+  createMesh() {
+    const maxDrawableSegmentsPerSubRay = 1 << this.maxIterations
 
-      if (this.generateUVs) {
-        this.uvs = new Float32Array(maxVerts * 2)
-      }
+    const maxVerts = 3 * (maxDrawableSegmentsPerSubRay + 1) * this.maxSubrays
+    const maxIndices = 18 * maxDrawableSegmentsPerSubRay * this.maxSubrays
 
-      // Populate the mesh
-      this.fillMesh(0)
+    this.vertices = new Float32Array(maxVerts * 3)
+    this.indices = new Uint32Array(maxIndices)
 
-      this.setIndex(new Uint32BufferAttribute(this.indices, 1))
+    if (this.generateUVs) {
+      this.uvs = new Float32Array(maxVerts * 2)
+    }
 
-      this.positionAttribute = new Float32BufferAttribute(this.vertices, 3)
-      this.setAttribute('position', this.positionAttribute)
+    // Populate the mesh
+    this.fillMesh(0)
 
-      if (this.generateUVs) {
-        this.uvsAttribute = new Float32BufferAttribute(new Float32Array(this.uvs), 2)
-        this.setAttribute('uv', this.uvsAttribute)
-      }
+    this.setIndex(new Uint32BufferAttribute(this.indices, 1))
 
-      if (!this.isStatic) {
-        this.index.usage = DynamicDrawUsage
-        this.positionAttribute.usage = DynamicDrawUsage
+    this.positionAttribute = new Float32BufferAttribute(this.vertices, 3)
+    this.setAttribute('position', this.positionAttribute)
 
-        if (this.generateUVs) {
-          this.uvsAttribute.usage = DynamicDrawUsage
-        }
-      }
+    if (this.generateUVs) {
+      this.uvsAttribute = new Float32BufferAttribute(new Float32Array(this.uvs), 2)
+      this.setAttribute('uv', this.uvsAttribute)
+    }
 
-      // Store buffers for later modification
-      this.vertices = this.positionAttribute.array
-      this.indices = this.index.array
+    if (!this.isStatic) {
+      this.index.usage = DynamicDrawUsage
+      this.positionAttribute.usage = DynamicDrawUsage
 
       if (this.generateUVs) {
-        this.uvs = this.uvsAttribute.array
+        this.uvsAttribute.usage = DynamicDrawUsage
       }
     }
 
-    updateMesh(time) {
-      this.fillMesh(time)
+    // Store buffers for later modification
+    this.vertices = this.positionAttribute.array
+    this.indices = this.index.array
 
-      this.drawRange.count = this.currentIndex
+    if (this.generateUVs) {
+      this.uvs = this.uvsAttribute.array
+    }
+  }
 
-      this.index.needsUpdate = true
+  updateMesh(time) {
+    this.fillMesh(time)
 
-      this.positionAttribute.needsUpdate = true
+    this.drawRange.count = this.currentIndex
 
-      if (this.generateUVs) {
-        this.uvsAttribute.needsUpdate = true
-      }
-    }
+    this.index.needsUpdate = true
 
-    fillMesh(time) {
-      const scope = this
+    this.positionAttribute.needsUpdate = true
 
-      this.currentVertex = 0
-      this.currentIndex = 0
-      this.currentCoordinate = 0
-      this.currentUVCoordinate = 0
+    if (this.generateUVs) {
+      this.uvsAttribute.needsUpdate = true
+    }
+  }
 
-      this.fractalRay(time, function fillVertices(segment) {
-        const subray = scope.currentSubray
+  fillMesh(time) {
+    const scope = this
 
-        if (time < subray.birthTime) {
-          //&& ( ! this.rayParameters.isEternal || scope.currentSubray.recursion > 0 ) ) {
+    this.currentVertex = 0
+    this.currentIndex = 0
+    this.currentCoordinate = 0
+    this.currentUVCoordinate = 0
 
-          return
-        } else if (this.rayParameters.isEternal && scope.currentSubray.recursion == 0) {
-          // Eternal rays don't propagate nor vanish, but its subrays do
+    this.fractalRay(time, function fillVertices(segment) {
+      const subray = scope.currentSubray
 
-          scope.createPrism(segment)
+      if (time < subray.birthTime) {
+        //&& ( ! this.rayParameters.isEternal || scope.currentSubray.recursion > 0 ) ) {
 
-          scope.onDecideSubrayCreation(segment, scope)
-        } else if (time < subray.endPropagationTime) {
-          if (scope.timeFraction >= segment.fraction0 * subray.propagationTimeFactor) {
-            // Ray propagation has arrived to this segment
+        return
+      } else if (this.rayParameters.isEternal && scope.currentSubray.recursion == 0) {
+        // Eternal rays don't propagate nor vanish, but its subrays do
 
-            scope.createPrism(segment)
+        scope.createPrism(segment)
 
-            scope.onDecideSubrayCreation(segment, scope)
-          }
-        } else if (time < subray.beginVanishingTime) {
-          // Ray is steady (nor propagating nor vanishing)
+        scope.onDecideSubrayCreation(segment, scope)
+      } else if (time < subray.endPropagationTime) {
+        if (scope.timeFraction >= segment.fraction0 * subray.propagationTimeFactor) {
+          // Ray propagation has arrived to this segment
 
           scope.createPrism(segment)
 
-          scope.onDecideSubrayCreation(segment, scope)
-        } else {
-          if (scope.timeFraction <= subray.vanishingTimeFactor + segment.fraction1 * (1 - subray.vanishingTimeFactor)) {
-            // Segment has not yet vanished
-
-            scope.createPrism(segment)
-          }
-
           scope.onDecideSubrayCreation(segment, scope)
         }
-      })
-    }
+      } else if (time < subray.beginVanishingTime) {
+        // Ray is steady (nor propagating nor vanishing)
 
-    addNewSubray(/*rayParameters*/) {
-      return this.subrays[this.numSubrays++]
-    }
+        scope.createPrism(segment)
 
-    initSubray(subray, rayParameters) {
-      subray.pos0.copy(rayParameters.sourceOffset)
-      subray.pos1.copy(rayParameters.destOffset)
-      subray.up0.copy(rayParameters.up0)
-      subray.up1.copy(rayParameters.up1)
-      subray.radius0 = rayParameters.radius0
-      subray.radius1 = rayParameters.radius1
-      subray.birthTime = rayParameters.birthTime
-      subray.deathTime = rayParameters.deathTime
-      subray.timeScale = rayParameters.timeScale
-      subray.roughness = rayParameters.roughness
-      subray.straightness = rayParameters.straightness
-      subray.propagationTimeFactor = rayParameters.propagationTimeFactor
-      subray.vanishingTimeFactor = rayParameters.vanishingTimeFactor
-
-      subray.maxIterations = this.maxIterations
-      subray.seed = rayParameters.noiseSeed !== undefined ? rayParameters.noiseSeed : 0
-      subray.recursion = 0
-    }
+        scope.onDecideSubrayCreation(segment, scope)
+      } else {
+        if (scope.timeFraction <= subray.vanishingTimeFactor + segment.fraction1 * (1 - subray.vanishingTimeFactor)) {
+          // Segment has not yet vanished
 
-    fractalRay(time, segmentCallback) {
-      this.time = time
-      this.currentSegmentCallback = segmentCallback
-      this.numSubrays = 0
+          scope.createPrism(segment)
+        }
 
-      // Add the top level subray
-      this.initSubray(this.addNewSubray(), this.rayParameters)
+        scope.onDecideSubrayCreation(segment, scope)
+      }
+    })
+  }
 
-      // Process all subrays that are being generated until consuming all of them
-      for (let subrayIndex = 0; subrayIndex < this.numSubrays; subrayIndex++) {
-        const subray = this.subrays[subrayIndex]
-        this.currentSubray = subray
+  addNewSubray(/*rayParameters*/) {
+    return this.subrays[this.numSubrays++]
+  }
 
-        this.randomGenerator.setSeed(subray.seed)
+  initSubray(subray, rayParameters) {
+    subray.pos0.copy(rayParameters.sourceOffset)
+    subray.pos1.copy(rayParameters.destOffset)
+    subray.up0.copy(rayParameters.up0)
+    subray.up1.copy(rayParameters.up1)
+    subray.radius0 = rayParameters.radius0
+    subray.radius1 = rayParameters.radius1
+    subray.birthTime = rayParameters.birthTime
+    subray.deathTime = rayParameters.deathTime
+    subray.timeScale = rayParameters.timeScale
+    subray.roughness = rayParameters.roughness
+    subray.straightness = rayParameters.straightness
+    subray.propagationTimeFactor = rayParameters.propagationTimeFactor
+    subray.vanishingTimeFactor = rayParameters.vanishingTimeFactor
+
+    subray.maxIterations = this.maxIterations
+    subray.seed = rayParameters.noiseSeed !== undefined ? rayParameters.noiseSeed : 0
+    subray.recursion = 0
+  }
 
-        subray.endPropagationTime = MathUtils.lerp(subray.birthTime, subray.deathTime, subray.propagationTimeFactor)
-        subray.beginVanishingTime = MathUtils.lerp(subray.deathTime, subray.birthTime, 1 - subray.vanishingTimeFactor)
+  fractalRay(time, segmentCallback) {
+    this.time = time
+    this.currentSegmentCallback = segmentCallback
+    this.numSubrays = 0
 
-        const random1 = this.randomGenerator.random
-        subray.linPos0.set(random1(), random1(), random1()).multiplyScalar(1000)
-        subray.linPos1.set(random1(), random1(), random1()).multiplyScalar(1000)
+    // Add the top level subray
+    this.initSubray(this.addNewSubray(), this.rayParameters)
 
-        this.timeFraction = (time - subray.birthTime) / (subray.deathTime - subray.birthTime)
+    // Process all subrays that are being generated until consuming all of them
+    for (let subrayIndex = 0; subrayIndex < this.numSubrays; subrayIndex++) {
+      const subray = this.subrays[subrayIndex]
+      this.currentSubray = subray
 
-        this.currentSegmentIndex = 0
-        this.isInitialSegment = true
+      this.randomGenerator.setSeed(subray.seed)
 
-        const segment = this.getNewSegment()
-        segment.iteration = 0
-        segment.pos0.copy(subray.pos0)
-        segment.pos1.copy(subray.pos1)
-        segment.linPos0.copy(subray.linPos0)
-        segment.linPos1.copy(subray.linPos1)
-        segment.up0.copy(subray.up0)
-        segment.up1.copy(subray.up1)
-        segment.radius0 = subray.radius0
-        segment.radius1 = subray.radius1
-        segment.fraction0 = 0
-        segment.fraction1 = 1
-        segment.positionVariationFactor = 1 - subray.straightness
+      subray.endPropagationTime = MathUtils.lerp(subray.birthTime, subray.deathTime, subray.propagationTimeFactor)
+      subray.beginVanishingTime = MathUtils.lerp(subray.deathTime, subray.birthTime, 1 - subray.vanishingTimeFactor)
 
-        this.subrayProbability =
-          (this.ramification * Math.pow(this.recursionProbability, subray.recursion)) / (1 << subray.maxIterations)
+      const random1 = this.randomGenerator.random
+      subray.linPos0.set(random1(), random1(), random1()).multiplyScalar(1000)
+      subray.linPos1.set(random1(), random1(), random1()).multiplyScalar(1000)
 
-        this.fractalRayRecursive(segment)
-      }
+      this.timeFraction = (time - subray.birthTime) / (subray.deathTime - subray.birthTime)
 
-      this.currentSegmentCallback = null
-      this.currentSubray = null
+      this.currentSegmentIndex = 0
+      this.isInitialSegment = true
+
+      const segment = this.getNewSegment()
+      segment.iteration = 0
+      segment.pos0.copy(subray.pos0)
+      segment.pos1.copy(subray.pos1)
+      segment.linPos0.copy(subray.linPos0)
+      segment.linPos1.copy(subray.linPos1)
+      segment.up0.copy(subray.up0)
+      segment.up1.copy(subray.up1)
+      segment.radius0 = subray.radius0
+      segment.radius1 = subray.radius1
+      segment.fraction0 = 0
+      segment.fraction1 = 1
+      segment.positionVariationFactor = 1 - subray.straightness
+
+      this.subrayProbability =
+        (this.ramification * Math.pow(this.recursionProbability, subray.recursion)) / (1 << subray.maxIterations)
+
+      this.fractalRayRecursive(segment)
     }
 
-    fractalRayRecursive(segment) {
-      // Leave recursion condition
-      if (segment.iteration >= this.currentSubray.maxIterations) {
-        this.currentSegmentCallback(segment)
+    this.currentSegmentCallback = null
+    this.currentSubray = null
+  }
 
-        return
-      }
+  fractalRayRecursive(segment) {
+    // Leave recursion condition
+    if (segment.iteration >= this.currentSubray.maxIterations) {
+      this.currentSegmentCallback(segment)
 
-      // Interpolation
-      this.forwards.subVectors(segment.pos1, segment.pos0)
-      let lForwards = this.forwards.length()
+      return
+    }
 
-      if (lForwards < 0.000001) {
-        this.forwards.set(0, 0, 0.01)
-        lForwards = this.forwards.length()
-      }
+    // Interpolation
+    this.forwards.subVectors(segment.pos1, segment.pos0)
+    let lForwards = this.forwards.length()
 
-      const middleRadius = (segment.radius0 + segment.radius1) * 0.5
-      const middleFraction = (segment.fraction0 + segment.fraction1) * 0.5
-
-      const timeDimension = this.time * this.currentSubray.timeScale * Math.pow(2, segment.iteration)
-
-      this.middlePos.lerpVectors(segment.pos0, segment.pos1, 0.5)
-      this.middleLinPos.lerpVectors(segment.linPos0, segment.linPos1, 0.5)
-      const p = this.middleLinPos
-
-      // Noise
-      this.newPos.set(
-        this.simplexX.noise4d(p.x, p.y, p.z, timeDimension),
-        this.simplexY.noise4d(p.x, p.y, p.z, timeDimension),
-        this.simplexZ.noise4d(p.x, p.y, p.z, timeDimension),
-      )
-
-      this.newPos.multiplyScalar(segment.positionVariationFactor * lForwards)
-      this.newPos.add(this.middlePos)
-
-      // Recursion
-
-      const newSegment1 = this.getNewSegment()
-      newSegment1.pos0.copy(segment.pos0)
-      newSegment1.pos1.copy(this.newPos)
-      newSegment1.linPos0.copy(segment.linPos0)
-      newSegment1.linPos1.copy(this.middleLinPos)
-      newSegment1.up0.copy(segment.up0)
-      newSegment1.up1.copy(segment.up1)
-      newSegment1.radius0 = segment.radius0
-      newSegment1.radius1 = middleRadius
-      newSegment1.fraction0 = segment.fraction0
-      newSegment1.fraction1 = middleFraction
-      newSegment1.positionVariationFactor = segment.positionVariationFactor * this.currentSubray.roughness
-      newSegment1.iteration = segment.iteration + 1
-
-      const newSegment2 = this.getNewSegment()
-      newSegment2.pos0.copy(this.newPos)
-      newSegment2.pos1.copy(segment.pos1)
-      newSegment2.linPos0.copy(this.middleLinPos)
-      newSegment2.linPos1.copy(segment.linPos1)
-      this.cross1.crossVectors(segment.up0, this.forwards.normalize())
-      newSegment2.up0.crossVectors(this.forwards, this.cross1).normalize()
-      newSegment2.up1.copy(segment.up1)
-      newSegment2.radius0 = middleRadius
-      newSegment2.radius1 = segment.radius1
-      newSegment2.fraction0 = middleFraction
-      newSegment2.fraction1 = segment.fraction1
-      newSegment2.positionVariationFactor = segment.positionVariationFactor * this.currentSubray.roughness
-      newSegment2.iteration = segment.iteration + 1
-
-      this.fractalRayRecursive(newSegment1)
-
-      this.fractalRayRecursive(newSegment2)
+    if (lForwards < 0.000001) {
+      this.forwards.set(0, 0, 0.01)
+      lForwards = this.forwards.length()
     }
 
-    createPrism(segment) {
-      // Creates one triangular prism and its vertices at the segment
-
-      this.forwardsFill.subVectors(segment.pos1, segment.pos0).normalize()
+    const middleRadius = (segment.radius0 + segment.radius1) * 0.5
+    const middleFraction = (segment.fraction0 + segment.fraction1) * 0.5
+
+    const timeDimension = this.time * this.currentSubray.timeScale * Math.pow(2, segment.iteration)
+
+    this.middlePos.lerpVectors(segment.pos0, segment.pos1, 0.5)
+    this.middleLinPos.lerpVectors(segment.linPos0, segment.linPos1, 0.5)
+    const p = this.middleLinPos
+
+    // Noise
+    this.newPos.set(
+      this.simplexX.noise4d(p.x, p.y, p.z, timeDimension),
+      this.simplexY.noise4d(p.x, p.y, p.z, timeDimension),
+      this.simplexZ.noise4d(p.x, p.y, p.z, timeDimension),
+    )
+
+    this.newPos.multiplyScalar(segment.positionVariationFactor * lForwards)
+    this.newPos.add(this.middlePos)
+
+    // Recursion
+
+    const newSegment1 = this.getNewSegment()
+    newSegment1.pos0.copy(segment.pos0)
+    newSegment1.pos1.copy(this.newPos)
+    newSegment1.linPos0.copy(segment.linPos0)
+    newSegment1.linPos1.copy(this.middleLinPos)
+    newSegment1.up0.copy(segment.up0)
+    newSegment1.up1.copy(segment.up1)
+    newSegment1.radius0 = segment.radius0
+    newSegment1.radius1 = middleRadius
+    newSegment1.fraction0 = segment.fraction0
+    newSegment1.fraction1 = middleFraction
+    newSegment1.positionVariationFactor = segment.positionVariationFactor * this.currentSubray.roughness
+    newSegment1.iteration = segment.iteration + 1
+
+    const newSegment2 = this.getNewSegment()
+    newSegment2.pos0.copy(this.newPos)
+    newSegment2.pos1.copy(segment.pos1)
+    newSegment2.linPos0.copy(this.middleLinPos)
+    newSegment2.linPos1.copy(segment.linPos1)
+    this.cross1.crossVectors(segment.up0, this.forwards.normalize())
+    newSegment2.up0.crossVectors(this.forwards, this.cross1).normalize()
+    newSegment2.up1.copy(segment.up1)
+    newSegment2.radius0 = middleRadius
+    newSegment2.radius1 = segment.radius1
+    newSegment2.fraction0 = middleFraction
+    newSegment2.fraction1 = segment.fraction1
+    newSegment2.positionVariationFactor = segment.positionVariationFactor * this.currentSubray.roughness
+    newSegment2.iteration = segment.iteration + 1
+
+    this.fractalRayRecursive(newSegment1)
+
+    this.fractalRayRecursive(newSegment2)
+  }
 
-      if (this.isInitialSegment) {
-        this.currentCreateTriangleVertices(segment.pos0, segment.up0, this.forwardsFill, segment.radius0, 0)
+  createPrism(segment) {
+    // Creates one triangular prism and its vertices at the segment
 
-        this.isInitialSegment = false
-      }
+    this.forwardsFill.subVectors(segment.pos1, segment.pos0).normalize()
 
-      this.currentCreateTriangleVertices(
-        segment.pos1,
-        segment.up0,
-        this.forwardsFill,
-        segment.radius1,
-        segment.fraction1,
-      )
+    if (this.isInitialSegment) {
+      this.currentCreateTriangleVertices(segment.pos0, segment.up0, this.forwardsFill, segment.radius0, 0)
 
-      this.createPrismFaces()
+      this.isInitialSegment = false
     }
 
-    createTriangleVerticesWithoutUVs(pos, up, forwards, radius) {
-      // Create an equilateral triangle (only vertices)
+    this.currentCreateTriangleVertices(segment.pos1, segment.up0, this.forwardsFill, segment.radius1, segment.fraction1)
 
-      this.side.crossVectors(up, forwards).multiplyScalar(radius * LightningStrike.COS30DEG)
-      this.down.copy(up).multiplyScalar(-radius * LightningStrike.SIN30DEG)
+    this.createPrismFaces()
+  }
 
-      const p = this.vPos
-      const v = this.vertices
+  createTriangleVerticesWithoutUVs(pos, up, forwards, radius) {
+    // Create an equilateral triangle (only vertices)
 
-      p.copy(pos).sub(this.side).add(this.down)
+    this.side.crossVectors(up, forwards).multiplyScalar(radius * LightningStrike.COS30DEG)
+    this.down.copy(up).multiplyScalar(-radius * LightningStrike.SIN30DEG)
 
-      v[this.currentCoordinate++] = p.x
-      v[this.currentCoordinate++] = p.y
-      v[this.currentCoordinate++] = p.z
+    const p = this.vPos
+    const v = this.vertices
 
-      p.copy(pos).add(this.side).add(this.down)
+    p.copy(pos).sub(this.side).add(this.down)
 
-      v[this.currentCoordinate++] = p.x
-      v[this.currentCoordinate++] = p.y
-      v[this.currentCoordinate++] = p.z
+    v[this.currentCoordinate++] = p.x
+    v[this.currentCoordinate++] = p.y
+    v[this.currentCoordinate++] = p.z
 
-      p.copy(up).multiplyScalar(radius).add(pos)
+    p.copy(pos).add(this.side).add(this.down)
 
-      v[this.currentCoordinate++] = p.x
-      v[this.currentCoordinate++] = p.y
-      v[this.currentCoordinate++] = p.z
+    v[this.currentCoordinate++] = p.x
+    v[this.currentCoordinate++] = p.y
+    v[this.currentCoordinate++] = p.z
 
-      this.currentVertex += 3
-    }
+    p.copy(up).multiplyScalar(radius).add(pos)
 
-    createTriangleVerticesWithUVs(pos, up, forwards, radius, u) {
-      // Create an equilateral triangle (only vertices)
+    v[this.currentCoordinate++] = p.x
+    v[this.currentCoordinate++] = p.y
+    v[this.currentCoordinate++] = p.z
 
-      this.side.crossVectors(up, forwards).multiplyScalar(radius * LightningStrike.COS30DEG)
-      this.down.copy(up).multiplyScalar(-radius * LightningStrike.SIN30DEG)
+    this.currentVertex += 3
+  }
 
-      const p = this.vPos
-      const v = this.vertices
-      const uv = this.uvs
+  createTriangleVerticesWithUVs(pos, up, forwards, radius, u) {
+    // Create an equilateral triangle (only vertices)
 
-      p.copy(pos).sub(this.side).add(this.down)
+    this.side.crossVectors(up, forwards).multiplyScalar(radius * LightningStrike.COS30DEG)
+    this.down.copy(up).multiplyScalar(-radius * LightningStrike.SIN30DEG)
 
-      v[this.currentCoordinate++] = p.x
-      v[this.currentCoordinate++] = p.y
-      v[this.currentCoordinate++] = p.z
+    const p = this.vPos
+    const v = this.vertices
+    const uv = this.uvs
 
-      uv[this.currentUVCoordinate++] = u
-      uv[this.currentUVCoordinate++] = 0
+    p.copy(pos).sub(this.side).add(this.down)
 
-      p.copy(pos).add(this.side).add(this.down)
+    v[this.currentCoordinate++] = p.x
+    v[this.currentCoordinate++] = p.y
+    v[this.currentCoordinate++] = p.z
 
-      v[this.currentCoordinate++] = p.x
-      v[this.currentCoordinate++] = p.y
-      v[this.currentCoordinate++] = p.z
+    uv[this.currentUVCoordinate++] = u
+    uv[this.currentUVCoordinate++] = 0
 
-      uv[this.currentUVCoordinate++] = u
-      uv[this.currentUVCoordinate++] = 0.5
+    p.copy(pos).add(this.side).add(this.down)
 
-      p.copy(up).multiplyScalar(radius).add(pos)
+    v[this.currentCoordinate++] = p.x
+    v[this.currentCoordinate++] = p.y
+    v[this.currentCoordinate++] = p.z
 
-      v[this.currentCoordinate++] = p.x
-      v[this.currentCoordinate++] = p.y
-      v[this.currentCoordinate++] = p.z
+    uv[this.currentUVCoordinate++] = u
+    uv[this.currentUVCoordinate++] = 0.5
 
-      uv[this.currentUVCoordinate++] = u
-      uv[this.currentUVCoordinate++] = 1
+    p.copy(up).multiplyScalar(radius).add(pos)
 
-      this.currentVertex += 3
-    }
+    v[this.currentCoordinate++] = p.x
+    v[this.currentCoordinate++] = p.y
+    v[this.currentCoordinate++] = p.z
 
-    createPrismFaces(vertex /*, index*/) {
-      const indices = this.indices
-      vertex = this.currentVertex - 6
-
-      indices[this.currentIndex++] = vertex + 1
-      indices[this.currentIndex++] = vertex + 2
-      indices[this.currentIndex++] = vertex + 5
-      indices[this.currentIndex++] = vertex + 1
-      indices[this.currentIndex++] = vertex + 5
-      indices[this.currentIndex++] = vertex + 4
-      indices[this.currentIndex++] = vertex + 0
-      indices[this.currentIndex++] = vertex + 1
-      indices[this.currentIndex++] = vertex + 4
-      indices[this.currentIndex++] = vertex + 0
-      indices[this.currentIndex++] = vertex + 4
-      indices[this.currentIndex++] = vertex + 3
-      indices[this.currentIndex++] = vertex + 2
-      indices[this.currentIndex++] = vertex + 0
-      indices[this.currentIndex++] = vertex + 3
-      indices[this.currentIndex++] = vertex + 2
-      indices[this.currentIndex++] = vertex + 3
-      indices[this.currentIndex++] = vertex + 5
-    }
+    uv[this.currentUVCoordinate++] = u
+    uv[this.currentUVCoordinate++] = 1
 
-    createDefaultSubrayCreationCallbacks() {
-      const random1 = this.randomGenerator.random
+    this.currentVertex += 3
+  }
 
-      this.onDecideSubrayCreation = function (segment, lightningStrike) {
-        // Decide subrays creation at parent (sub)ray segment
+  createPrismFaces(vertex /*, index*/) {
+    const indices = this.indices
+    vertex = this.currentVertex - 6
+
+    indices[this.currentIndex++] = vertex + 1
+    indices[this.currentIndex++] = vertex + 2
+    indices[this.currentIndex++] = vertex + 5
+    indices[this.currentIndex++] = vertex + 1
+    indices[this.currentIndex++] = vertex + 5
+    indices[this.currentIndex++] = vertex + 4
+    indices[this.currentIndex++] = vertex + 0
+    indices[this.currentIndex++] = vertex + 1
+    indices[this.currentIndex++] = vertex + 4
+    indices[this.currentIndex++] = vertex + 0
+    indices[this.currentIndex++] = vertex + 4
+    indices[this.currentIndex++] = vertex + 3
+    indices[this.currentIndex++] = vertex + 2
+    indices[this.currentIndex++] = vertex + 0
+    indices[this.currentIndex++] = vertex + 3
+    indices[this.currentIndex++] = vertex + 2
+    indices[this.currentIndex++] = vertex + 3
+    indices[this.currentIndex++] = vertex + 5
+  }
 
-        const subray = lightningStrike.currentSubray
+  createDefaultSubrayCreationCallbacks() {
+    const random1 = this.randomGenerator.random
 
-        const period = lightningStrike.rayParameters.subrayPeriod
-        const dutyCycle = lightningStrike.rayParameters.subrayDutyCycle
+    this.onDecideSubrayCreation = function (segment, lightningStrike) {
+      // Decide subrays creation at parent (sub)ray segment
 
-        const phase0 =
-          lightningStrike.rayParameters.isEternal && subray.recursion == 0
-            ? -random1() * period
-            : MathUtils.lerp(subray.birthTime, subray.endPropagationTime, segment.fraction0) - random1() * period
+      const subray = lightningStrike.currentSubray
 
-        const phase = lightningStrike.time - phase0
-        const currentCycle = Math.floor(phase / period)
+      const period = lightningStrike.rayParameters.subrayPeriod
+      const dutyCycle = lightningStrike.rayParameters.subrayDutyCycle
 
-        const childSubraySeed = random1() * (currentCycle + 1)
+      const phase0 =
+        lightningStrike.rayParameters.isEternal && subray.recursion == 0
+          ? -random1() * period
+          : MathUtils.lerp(subray.birthTime, subray.endPropagationTime, segment.fraction0) - random1() * period
 
-        const isActive = phase % period <= dutyCycle * period
+      const phase = lightningStrike.time - phase0
+      const currentCycle = Math.floor(phase / period)
 
-        let probability = 0
+      const childSubraySeed = random1() * (currentCycle + 1)
 
-        if (isActive) {
-          probability = lightningStrike.subrayProbability
-          // Distribution test: probability *= segment.fraction0 > 0.5 && segment.fraction0 < 0.9 ? 1 / 0.4 : 0;
-        }
+      const isActive = phase % period <= dutyCycle * period
 
-        if (
-          subray.recursion < lightningStrike.maxSubrayRecursion &&
-          lightningStrike.numSubrays < lightningStrike.maxSubrays &&
-          random1() < probability
-        ) {
-          const childSubray = lightningStrike.addNewSubray()
-
-          const parentSeed = lightningStrike.randomGenerator.getSeed()
-          childSubray.seed = childSubraySeed
-          lightningStrike.randomGenerator.setSeed(childSubraySeed)
-
-          childSubray.recursion = subray.recursion + 1
-          childSubray.maxIterations = Math.max(1, subray.maxIterations - 1)
-
-          childSubray.linPos0.set(random1(), random1(), random1()).multiplyScalar(1000)
-          childSubray.linPos1.set(random1(), random1(), random1()).multiplyScalar(1000)
-          childSubray.up0.copy(subray.up0)
-          childSubray.up1.copy(subray.up1)
-          childSubray.radius0 = segment.radius0 * lightningStrike.rayParameters.radius0Factor
-          childSubray.radius1 = Math.min(
-            lightningStrike.rayParameters.minRadius,
-            segment.radius1 * lightningStrike.rayParameters.radius1Factor,
-          )
-
-          childSubray.birthTime = phase0 + currentCycle * period
-          childSubray.deathTime = childSubray.birthTime + period * dutyCycle
-
-          if (!lightningStrike.rayParameters.isEternal && subray.recursion == 0) {
-            childSubray.birthTime = Math.max(childSubray.birthTime, subray.birthTime)
-            childSubray.deathTime = Math.min(childSubray.deathTime, subray.deathTime)
-          }
-
-          childSubray.timeScale = subray.timeScale * 2
-          childSubray.roughness = subray.roughness
-          childSubray.straightness = subray.straightness
-          childSubray.propagationTimeFactor = subray.propagationTimeFactor
-          childSubray.vanishingTimeFactor = subray.vanishingTimeFactor
-
-          lightningStrike.onSubrayCreation(segment, subray, childSubray, lightningStrike)
-
-          lightningStrike.randomGenerator.setSeed(parentSeed)
-        }
+      let probability = 0
+
+      if (isActive) {
+        probability = lightningStrike.subrayProbability
+        // Distribution test: probability *= segment.fraction0 > 0.5 && segment.fraction0 < 0.9 ? 1 / 0.4 : 0;
       }
 
-      const vec1Pos = new Vector3()
-      const vec2Forward = new Vector3()
-      const vec3Side = new Vector3()
-      const vec4Up = new Vector3()
+      if (
+        subray.recursion < lightningStrike.maxSubrayRecursion &&
+        lightningStrike.numSubrays < lightningStrike.maxSubrays &&
+        random1() < probability
+      ) {
+        const childSubray = lightningStrike.addNewSubray()
+
+        const parentSeed = lightningStrike.randomGenerator.getSeed()
+        childSubray.seed = childSubraySeed
+        lightningStrike.randomGenerator.setSeed(childSubraySeed)
+
+        childSubray.recursion = subray.recursion + 1
+        childSubray.maxIterations = Math.max(1, subray.maxIterations - 1)
+
+        childSubray.linPos0.set(random1(), random1(), random1()).multiplyScalar(1000)
+        childSubray.linPos1.set(random1(), random1(), random1()).multiplyScalar(1000)
+        childSubray.up0.copy(subray.up0)
+        childSubray.up1.copy(subray.up1)
+        childSubray.radius0 = segment.radius0 * lightningStrike.rayParameters.radius0Factor
+        childSubray.radius1 = Math.min(
+          lightningStrike.rayParameters.minRadius,
+          segment.radius1 * lightningStrike.rayParameters.radius1Factor,
+        )
+
+        childSubray.birthTime = phase0 + currentCycle * period
+        childSubray.deathTime = childSubray.birthTime + period * dutyCycle
+
+        if (!lightningStrike.rayParameters.isEternal && subray.recursion == 0) {
+          childSubray.birthTime = Math.max(childSubray.birthTime, subray.birthTime)
+          childSubray.deathTime = Math.min(childSubray.deathTime, subray.deathTime)
+        }
 
-      this.onSubrayCreation = function (segment, parentSubray, childSubray, lightningStrike) {
-        // Decide childSubray origin and destination positions (pos0 and pos1) and possibly other properties of childSubray
+        childSubray.timeScale = subray.timeScale * 2
+        childSubray.roughness = subray.roughness
+        childSubray.straightness = subray.straightness
+        childSubray.propagationTimeFactor = subray.propagationTimeFactor
+        childSubray.vanishingTimeFactor = subray.vanishingTimeFactor
 
-        // Just use the default cone position generator
-        lightningStrike.subrayCylinderPosition(segment, parentSubray, childSubray, 0.5, 0.6, 0.2)
-      }
+        lightningStrike.onSubrayCreation(segment, subray, childSubray, lightningStrike)
 
-      this.subrayConePosition = function (
-        segment,
-        parentSubray,
-        childSubray,
-        heightFactor,
-        sideWidthFactor,
-        minSideWidthFactor,
-      ) {
-        // Sets childSubray pos0 and pos1 in a cone
-
-        childSubray.pos0.copy(segment.pos0)
-
-        vec1Pos.subVectors(parentSubray.pos1, parentSubray.pos0)
-        vec2Forward.copy(vec1Pos).normalize()
-        vec1Pos.multiplyScalar(segment.fraction0 + (1 - segment.fraction0) * (random1() * heightFactor))
-        const length = vec1Pos.length()
-        vec3Side.crossVectors(parentSubray.up0, vec2Forward)
-        const angle = 2 * Math.PI * random1()
-        vec3Side.multiplyScalar(Math.cos(angle))
-        vec4Up.copy(parentSubray.up0).multiplyScalar(Math.sin(angle))
-
-        childSubray.pos1
-          .copy(vec3Side)
-          .add(vec4Up)
-          .multiplyScalar(length * sideWidthFactor * (minSideWidthFactor + random1() * (1 - minSideWidthFactor)))
-          .add(vec1Pos)
-          .add(parentSubray.pos0)
+        lightningStrike.randomGenerator.setSeed(parentSeed)
       }
+    }
 
-      this.subrayCylinderPosition = function (
-        segment,
-        parentSubray,
-        childSubray,
-        heightFactor,
-        sideWidthFactor,
-        minSideWidthFactor,
-      ) {
-        // Sets childSubray pos0 and pos1 in a cylinder
-
-        childSubray.pos0.copy(segment.pos0)
-
-        vec1Pos.subVectors(parentSubray.pos1, parentSubray.pos0)
-        vec2Forward.copy(vec1Pos).normalize()
-        vec1Pos.multiplyScalar(segment.fraction0 + (1 - segment.fraction0) * ((2 * random1() - 1) * heightFactor))
-        const length = vec1Pos.length()
-        vec3Side.crossVectors(parentSubray.up0, vec2Forward)
-        const angle = 2 * Math.PI * random1()
-        vec3Side.multiplyScalar(Math.cos(angle))
-        vec4Up.copy(parentSubray.up0).multiplyScalar(Math.sin(angle))
-
-        childSubray.pos1
-          .copy(vec3Side)
-          .add(vec4Up)
-          .multiplyScalar(length * sideWidthFactor * (minSideWidthFactor + random1() * (1 - minSideWidthFactor)))
-          .add(vec1Pos)
-          .add(parentSubray.pos0)
-      }
+    const vec1Pos = new Vector3()
+    const vec2Forward = new Vector3()
+    const vec3Side = new Vector3()
+    const vec4Up = new Vector3()
+
+    this.onSubrayCreation = function (segment, parentSubray, childSubray, lightningStrike) {
+      // Decide childSubray origin and destination positions (pos0 and pos1) and possibly other properties of childSubray
+
+      // Just use the default cone position generator
+      lightningStrike.subrayCylinderPosition(segment, parentSubray, childSubray, 0.5, 0.6, 0.2)
     }
 
-    createSubray() {
-      return {
-        seed: 0,
-        maxIterations: 0,
-        recursion: 0,
-        pos0: new Vector3(),
-        pos1: new Vector3(),
-        linPos0: new Vector3(),
-        linPos1: new Vector3(),
-        up0: new Vector3(),
-        up1: new Vector3(),
-        radius0: 0,
-        radius1: 0,
-        birthTime: 0,
-        deathTime: 0,
-        timeScale: 0,
-        roughness: 0,
-        straightness: 0,
-        propagationTimeFactor: 0,
-        vanishingTimeFactor: 0,
-        endPropagationTime: 0,
-        beginVanishingTime: 0,
-      }
+    this.subrayConePosition = function (
+      segment,
+      parentSubray,
+      childSubray,
+      heightFactor,
+      sideWidthFactor,
+      minSideWidthFactor,
+    ) {
+      // Sets childSubray pos0 and pos1 in a cone
+
+      childSubray.pos0.copy(segment.pos0)
+
+      vec1Pos.subVectors(parentSubray.pos1, parentSubray.pos0)
+      vec2Forward.copy(vec1Pos).normalize()
+      vec1Pos.multiplyScalar(segment.fraction0 + (1 - segment.fraction0) * (random1() * heightFactor))
+      const length = vec1Pos.length()
+      vec3Side.crossVectors(parentSubray.up0, vec2Forward)
+      const angle = 2 * Math.PI * random1()
+      vec3Side.multiplyScalar(Math.cos(angle))
+      vec4Up.copy(parentSubray.up0).multiplyScalar(Math.sin(angle))
+
+      childSubray.pos1
+        .copy(vec3Side)
+        .add(vec4Up)
+        .multiplyScalar(length * sideWidthFactor * (minSideWidthFactor + random1() * (1 - minSideWidthFactor)))
+        .add(vec1Pos)
+        .add(parentSubray.pos0)
     }
 
-    createSegment() {
-      return {
-        iteration: 0,
-        pos0: new Vector3(),
-        pos1: new Vector3(),
-        linPos0: new Vector3(),
-        linPos1: new Vector3(),
-        up0: new Vector3(),
-        up1: new Vector3(),
-        radius0: 0,
-        radius1: 0,
-        fraction0: 0,
-        fraction1: 0,
-        positionVariationFactor: 0,
-      }
+    this.subrayCylinderPosition = function (
+      segment,
+      parentSubray,
+      childSubray,
+      heightFactor,
+      sideWidthFactor,
+      minSideWidthFactor,
+    ) {
+      // Sets childSubray pos0 and pos1 in a cylinder
+
+      childSubray.pos0.copy(segment.pos0)
+
+      vec1Pos.subVectors(parentSubray.pos1, parentSubray.pos0)
+      vec2Forward.copy(vec1Pos).normalize()
+      vec1Pos.multiplyScalar(segment.fraction0 + (1 - segment.fraction0) * ((2 * random1() - 1) * heightFactor))
+      const length = vec1Pos.length()
+      vec3Side.crossVectors(parentSubray.up0, vec2Forward)
+      const angle = 2 * Math.PI * random1()
+      vec3Side.multiplyScalar(Math.cos(angle))
+      vec4Up.copy(parentSubray.up0).multiplyScalar(Math.sin(angle))
+
+      childSubray.pos1
+        .copy(vec3Side)
+        .add(vec4Up)
+        .multiplyScalar(length * sideWidthFactor * (minSideWidthFactor + random1() * (1 - minSideWidthFactor)))
+        .add(vec1Pos)
+        .add(parentSubray.pos0)
     }
+  }
 
-    getNewSegment() {
-      return this.raySegments[this.currentSegmentIndex++]
+  createSubray() {
+    return {
+      seed: 0,
+      maxIterations: 0,
+      recursion: 0,
+      pos0: new Vector3(),
+      pos1: new Vector3(),
+      linPos0: new Vector3(),
+      linPos1: new Vector3(),
+      up0: new Vector3(),
+      up1: new Vector3(),
+      radius0: 0,
+      radius1: 0,
+      birthTime: 0,
+      deathTime: 0,
+      timeScale: 0,
+      roughness: 0,
+      straightness: 0,
+      propagationTimeFactor: 0,
+      vanishingTimeFactor: 0,
+      endPropagationTime: 0,
+      beginVanishingTime: 0,
     }
+  }
 
-    copy(source) {
-      super.copy(source)
+  createSegment() {
+    return {
+      iteration: 0,
+      pos0: new Vector3(),
+      pos1: new Vector3(),
+      linPos0: new Vector3(),
+      linPos1: new Vector3(),
+      up0: new Vector3(),
+      up1: new Vector3(),
+      radius0: 0,
+      radius1: 0,
+      fraction0: 0,
+      fraction1: 0,
+      positionVariationFactor: 0,
+    }
+  }
 
-      this.init(LightningStrike.copyParameters({}, source.rayParameters))
+  getNewSegment() {
+    return this.raySegments[this.currentSegmentIndex++]
+  }
 
-      return this
-    }
+  copy(source) {
+    super.copy(source)
 
-    clone() {
-      return new this.constructor(LightningStrike.copyParameters({}, this.rayParameters))
-    }
+    this.init(LightningStrike.copyParameters({}, source.rayParameters))
+
+    return this
   }
 
-  return LightningStrike
-})()
+  clone() {
+    return new this.constructor(LightningStrike.copyParameters({}, this.rayParameters))
+  }
+}
 
 export { LightningStrike }
diff --git a/src/geometries/RoundedBoxGeometry.js b/src/geometries/RoundedBoxGeometry.js
index 3a10f247..80c5f35b 100644
--- a/src/geometries/RoundedBoxGeometry.js
+++ b/src/geometries/RoundedBoxGeometry.js
@@ -1,6 +1,6 @@
 import { BoxGeometry, Vector3 } from 'three'
 
-const tempNormal = /* @__PURE__ */ new Vector3()
+const tempNormal = new Vector3()
 
 function getUv(faceDirVector, normal, uvAxis, projectionAxis, radius, sideLength) {
   const totArcLength = (2 * Math.PI * radius) / 4
diff --git a/src/helpers/RaycasterHelper.ts b/src/helpers/RaycasterHelper.ts
index ed093375..f5f57644 100644
--- a/src/helpers/RaycasterHelper.ts
+++ b/src/helpers/RaycasterHelper.ts
@@ -18,8 +18,8 @@ import {
   Vector3,
 } from 'three'
 
-const _o = /* @__PURE__ */ new Object3D()
-const _v = /* @__PURE__ */ new Vector3()
+const _o = new Object3D()
+const _v = new Vector3()
 
 class RaycasterHelper extends Object3D {
   raycaster: Raycaster
diff --git a/src/helpers/VertexNormalsHelper.js b/src/helpers/VertexNormalsHelper.js
index b586a130..18e8addb 100644
--- a/src/helpers/VertexNormalsHelper.js
+++ b/src/helpers/VertexNormalsHelper.js
@@ -1,8 +1,8 @@
 import { BufferGeometry, Float32BufferAttribute, LineSegments, LineBasicMaterial, Matrix3, Vector3 } from 'three'
 
-const _v1 = /* @__PURE__ */ new Vector3()
-const _v2 = /* @__PURE__ */ new Vector3()
-const _normalMatrix = /* @__PURE__ */ new Matrix3()
+const _v1 = new Vector3()
+const _v2 = new Vector3()
+const _normalMatrix = new Matrix3()
 
 class VertexNormalsHelper extends LineSegments {
   constructor(object, size = 1, color = 0xff0000) {
diff --git a/src/helpers/VertexTangentsHelper.js b/src/helpers/VertexTangentsHelper.js
index a9af184a..42d50ee5 100644
--- a/src/helpers/VertexTangentsHelper.js
+++ b/src/helpers/VertexTangentsHelper.js
@@ -1,7 +1,7 @@
 import { BufferGeometry, Float32BufferAttribute, LineSegments, LineBasicMaterial, Vector3 } from 'three'
 
-const _v1 = /* @__PURE__ */ new Vector3()
-const _v2 = /* @__PURE__ */ new Vector3()
+const _v1 = new Vector3()
+const _v2 = new Vector3()
 
 class VertexTangentsHelper extends LineSegments {
   constructor(object, size = 1, color = 0x00ffff) {
diff --git a/src/interactive/InteractiveGroup.js b/src/interactive/InteractiveGroup.js
index 263e979b..704f4ffb 100644
--- a/src/interactive/InteractiveGroup.js
+++ b/src/interactive/InteractiveGroup.js
@@ -1,6 +1,6 @@
 import { Group, Matrix4, Raycaster, Vector2 } from 'three'
 
-const _pointer = /* @__PURE__ */ new Vector2()
+const _pointer = new Vector2()
 const _event = { type: '', data: _pointer }
 
 class InteractiveGroup extends Group {
diff --git a/src/interactive/SelectionBox.js b/src/interactive/SelectionBox.js
index dda5dd6e..4db0205e 100644
--- a/src/interactive/SelectionBox.js
+++ b/src/interactive/SelectionBox.js
@@ -1,24 +1,24 @@
 import { Frustum, Vector3 } from 'three'
 
-const frustum = /* @__PURE__ */ new Frustum()
-const center = /* @__PURE__ */ new Vector3()
+const frustum = new Frustum()
+const center = new Vector3()
 
-const tmpPoint = /* @__PURE__ */ new Vector3()
+const tmpPoint = new Vector3()
 
-const vecNear = /* @__PURE__ */ new Vector3()
-const vecTopLeft = /* @__PURE__ */ new Vector3()
-const vecTopRight = /* @__PURE__ */ new Vector3()
-const vecDownRight = /* @__PURE__ */ new Vector3()
-const vecDownLeft = /* @__PURE__ */ new Vector3()
+const vecNear = new Vector3()
+const vecTopLeft = new Vector3()
+const vecTopRight = new Vector3()
+const vecDownRight = new Vector3()
+const vecDownLeft = new Vector3()
 
-const vecFarTopLeft = /* @__PURE__ */ new Vector3()
-const vecFarTopRight = /* @__PURE__ */ new Vector3()
-const vecFarDownRight = /* @__PURE__ */ new Vector3()
-const vecFarDownLeft = /* @__PURE__ */ new Vector3()
+const vecFarTopLeft = new Vector3()
+const vecFarTopRight = new Vector3()
+const vecFarDownRight = new Vector3()
+const vecFarDownLeft = new Vector3()
 
-const vectemp1 = /* @__PURE__ */ new Vector3()
-const vectemp2 = /* @__PURE__ */ new Vector3()
-const vectemp3 = /* @__PURE__ */ new Vector3()
+const vectemp1 = new Vector3()
+const vectemp2 = new Vector3()
+const vectemp3 = new Vector3()
 
 class SelectionBox {
   constructor(camera, scene, deep) {
diff --git a/src/libs/chevrotain.js b/src/libs/chevrotain.js
index 4d8c0e48..8e23804d 100644
--- a/src/libs/chevrotain.js
+++ b/src/libs/chevrotain.js
@@ -1,4 +1,4 @@
-const { CstParser, Lexer, createToken } = /* @__PURE__ */ (() => {
+const { CstParser, Lexer, createToken } = (() => {
   /** Detect free variable `global` from Node.js. */
   var freeGlobal = typeof global == 'object' && global && global.Object === Object && global
 
diff --git a/src/libs/lottie.js b/src/libs/lottie.js
index e6e503df..2c2d699d 100644
--- a/src/libs/lottie.js
+++ b/src/libs/lottie.js
@@ -1,4 +1,4 @@
-const lottie = /* @__PURE__ */ (() => {
+const lottie = (() => {
   if (typeof navigator === 'undefined' || typeof document === 'undefined') return {}
 
   const svgNS = 'http://www.w3.org/2000/svg'
diff --git a/src/libs/opentype.js b/src/libs/opentype.js
index d8aa0d04..ecb8c687 100644
--- a/src/libs/opentype.js
+++ b/src/libs/opentype.js
@@ -1,4 +1,4 @@
-const { parseBuffer } = /* @__PURE__ */ (() => {
+const { parseBuffer } = (() => {
   /**
    * https://opentype.js.org v1.3.4 | (c) Frederik De Bleser and other contributors | MIT License | Uses tiny-inflate by Devon Govett and string.prototype.codepointat polyfill by Mathias Bynens
    */
diff --git a/src/lights/LightProbeGenerator.js b/src/lights/LightProbeGenerator.js
index bd38bf06..216438e4 100644
--- a/src/lights/LightProbeGenerator.js
+++ b/src/lights/LightProbeGenerator.js
@@ -1,8 +1,8 @@
 import { Color, LightProbe, SphericalHarmonics3, Vector3 } from 'three'
 
-const LightProbeGenerator = {
+class LightProbeGenerator {
   // https://www.ppsloan.org/publications/StupidSH36.pdf
-  fromCubeTexture(cubeTexture) {
+  static fromCubeTexture(cubeTexture) {
     let totalWeight = 0
 
     const coord = new Vector3()
@@ -122,9 +122,9 @@ const LightProbeGenerator = {
     }
 
     return new LightProbe(sh)
-  },
+  }
 
-  fromCubeRenderTarget(renderer, cubeRenderTarget) {
+  static fromCubeRenderTarget(renderer, cubeRenderTarget) {
     // The renderTarget must be set to RGBA in order to make readRenderTargetPixels works
     let totalWeight = 0
 
@@ -229,7 +229,7 @@ const LightProbeGenerator = {
     }
 
     return new LightProbe(sh)
-  },
+  }
 }
 
 export { LightProbeGenerator }
diff --git a/src/lights/RectAreaLightUniformsLib.js b/src/lights/RectAreaLightUniformsLib.js
index 3f495939..c14634f1 100644
--- a/src/lights/RectAreaLightUniformsLib.js
+++ b/src/lights/RectAreaLightUniformsLib.js
@@ -28,8 +28,8 @@ import {
 // by Eric Heitz, Jonathan Dupuy, Stephen Hill and David Neubelt
 // code: https://github.com/selfshadow/ltc_code/
 
-const RectAreaLightUniformsLib = {
-  init() {
+class RectAreaLightUniformsLib {
+  static init() {
     // source: https://github.com/selfshadow/ltc_code/tree/master/fit/results/ltc.js
 
     const LTC_MAT_1 = [
@@ -32882,7 +32882,7 @@ const RectAreaLightUniformsLib = {
 
     UniformsLib.LTC_HALF_1.needsUpdate = true
     UniformsLib.LTC_HALF_2.needsUpdate = true
-  },
+  }
 }
 
 export { RectAreaLightUniformsLib }
diff --git a/src/lines/LineMaterial.js b/src/lines/LineMaterial.js
index 8e54c9e8..3c4959de 100644
--- a/src/lines/LineMaterial.js
+++ b/src/lines/LineMaterial.js
@@ -10,8 +10,7 @@
  * }
  */
 
-import { ShaderMaterial, UniformsLib, UniformsUtils, Vector2 } from 'three'
-import { version } from '../_polyfill/constants'
+import { ShaderMaterial, UniformsLib, UniformsUtils, Vector2, REVISION } from 'three'
 
 class LineMaterial extends ShaderMaterial {
   constructor(parameters) {
@@ -438,7 +437,7 @@ class LineMaterial extends ShaderMaterial {
 					gl_FragColor = diffuseColor;
 
 					#include <tonemapping_fragment>
-					#include <${version >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>
+					#include <${parseInt(REVISION.replace(/\D+/g, '')) >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>
 					#include <fog_fragment>
 					#include <premultiplied_alpha_fragment>
 
diff --git a/src/lines/LineSegments2.js b/src/lines/LineSegments2.js
index 461e240a..b514fe81 100644
--- a/src/lines/LineSegments2.js
+++ b/src/lines/LineSegments2.js
@@ -14,23 +14,23 @@ import { LineSegmentsGeometry } from '../lines/LineSegmentsGeometry'
 import { LineMaterial } from '../lines/LineMaterial'
 import { UV1 } from '../_polyfill/uv1'
 
-const _viewport = /* @__PURE__ */ new Vector4()
+const _viewport = new Vector4();
 
-const _start = /* @__PURE__ */ new Vector3()
-const _end = /* @__PURE__ */ new Vector3()
+const _start = new Vector3()
+const _end = new Vector3()
 
-const _start4 = /* @__PURE__ */ new Vector4()
-const _end4 = /* @__PURE__ */ new Vector4()
+const _start4 = new Vector4()
+const _end4 = new Vector4()
 
-const _ssOrigin = /* @__PURE__ */ new Vector4()
-const _ssOrigin3 = /* @__PURE__ */ new Vector3()
-const _mvMatrix = /* @__PURE__ */ new Matrix4()
-const _line = /* @__PURE__ */ new Line3()
-const _closestPoint = /* @__PURE__ */ new Vector3()
+const _ssOrigin = new Vector4()
+const _ssOrigin3 = new Vector3()
+const _mvMatrix = new Matrix4()
+const _line = new Line3()
+const _closestPoint = new Vector3()
 
-const _box = /* @__PURE__ */ new Box3()
-const _sphere = /* @__PURE__ */ new Sphere()
-const _clipToWorldVector = /* @__PURE__ */ new Vector4()
+const _box = new Box3()
+const _sphere = new Sphere()
+const _clipToWorldVector = new Vector4()
 
 let _ray, _lineWidth
 
@@ -51,17 +51,18 @@ function getWorldSpaceHalfWidth(camera, distance, resolution) {
 }
 
 function raycastWorldUnits(lineSegments, intersects) {
-  const matrixWorld = lineSegments.matrixWorld
-  const geometry = lineSegments.geometry
-  const instanceStart = geometry.attributes.instanceStart
-  const instanceEnd = geometry.attributes.instanceEnd
-  const segmentCount = Math.min(geometry.instanceCount, instanceStart.count)
+
+  const matrixWorld = lineSegments.matrixWorld;
+  const geometry = lineSegments.geometry;
+  const instanceStart = geometry.attributes.instanceStart;
+  const instanceEnd = geometry.attributes.instanceEnd;
+  const segmentCount = Math.min(geometry.instanceCount, instanceStart.count);
 
   for (let i = 0, l = segmentCount; i < l; i++) {
     _line.start.fromBufferAttribute(instanceStart, i)
     _line.end.fromBufferAttribute(instanceEnd, i)
 
-    _line.applyMatrix4(matrixWorld)
+    _line.applyMatrix4(matrixWorld);
 
     const pointOnLine = new Vector3()
     const point = new Vector3()
@@ -93,7 +94,7 @@ function raycastScreenSpace(lineSegments, camera, intersects) {
   const geometry = lineSegments.geometry
   const instanceStart = geometry.attributes.instanceStart
   const instanceEnd = geometry.attributes.instanceEnd
-  const segmentCount = Math.min(geometry.instanceCount, instanceStart.count)
+  const segmentCount = Math.min(geometry.instanceCount, instanceStart.count);
 
   const near = -camera.near
 
@@ -311,12 +312,16 @@ class LineSegments2 extends Mesh {
   }
 
   onBeforeRender(renderer) {
-    const uniforms = this.material.uniforms
+
+    const uniforms = this.material.uniforms;
 
     if (uniforms && uniforms.resolution) {
-      renderer.getViewport(_viewport)
-      this.material.uniforms.resolution.value.set(_viewport.z, _viewport.w)
+
+      renderer.getViewport(_viewport);
+      this.material.uniforms.resolution.value.set(_viewport.z, _viewport.w);
+
     }
+
   }
 }
 
diff --git a/src/lines/LineSegmentsGeometry.js b/src/lines/LineSegmentsGeometry.js
index 5b1fb7bb..967b2fcb 100644
--- a/src/lines/LineSegmentsGeometry.js
+++ b/src/lines/LineSegmentsGeometry.js
@@ -9,8 +9,8 @@ import {
   WireframeGeometry,
 } from 'three'
 
-const _box = /* @__PURE__ */ new Box3()
-const _vector = /* @__PURE__ */ new Vector3()
+const _box = new Box3()
+const _vector = new Vector3()
 
 class LineSegmentsGeometry extends InstancedBufferGeometry {
   constructor() {
diff --git a/src/lines/Wireframe.js b/src/lines/Wireframe.js
index 5d97668b..5c3bfe87 100644
--- a/src/lines/Wireframe.js
+++ b/src/lines/Wireframe.js
@@ -2,9 +2,9 @@ import { InstancedInterleavedBuffer, InterleavedBufferAttribute, Mesh, Vector3,
 import { LineSegmentsGeometry } from '../lines/LineSegmentsGeometry'
 import { LineMaterial } from '../lines/LineMaterial'
 
-const _start = /* @__PURE__ */ new Vector3()
-const _end = /* @__PURE__ */ new Vector3()
-const _viewport = /* @__PURE__ */ new Vector4()
+const _start = new Vector3()
+const _end = new Vector3()
+const _viewport = new Vector4();
 
 class Wireframe extends Mesh {
   constructor(geometry = new LineSegmentsGeometry(), material = new LineMaterial({ color: Math.random() * 0xffffff })) {
@@ -41,12 +41,16 @@ class Wireframe extends Mesh {
   }
 
   onBeforeRender(renderer) {
-    const uniforms = this.material.uniforms
+
+    const uniforms = this.material.uniforms;
 
     if (uniforms && uniforms.resolution) {
-      renderer.getViewport(_viewport)
-      this.material.uniforms.resolution.value.set(_viewport.z, _viewport.w)
+
+      renderer.getViewport(_viewport);
+      this.material.uniforms.resolution.value.set(_viewport.z, _viewport.w);
+
     }
+
   }
 }
 
diff --git a/src/loaders/BasisTextureLoader.js b/src/loaders/BasisTextureLoader.js
index 6d2babf6..f568464c 100644
--- a/src/loaders/BasisTextureLoader.js
+++ b/src/loaders/BasisTextureLoader.js
@@ -32,174 +32,135 @@ import {
 
 const _taskCache = new WeakMap()
 
-const BasisTextureLoader = /* @__PURE__ */ (() => {
-  class BasisTextureLoader extends Loader {
-    /* CONSTANTS */
+class BasisTextureLoader extends Loader {
+  /* CONSTANTS */
 
-    static BasisFormat = {
-      ETC1S: 0,
-      UASTC_4x4: 1,
-    }
-
-    static TranscoderFormat = {
-      ETC1: 0,
-      ETC2: 1,
-      BC1: 2,
-      BC3: 3,
-      BC4: 4,
-      BC5: 5,
-      BC7_M6_OPAQUE_ONLY: 6,
-      BC7_M5: 7,
-      PVRTC1_4_RGB: 8,
-      PVRTC1_4_RGBA: 9,
-      ASTC_4x4: 10,
-      ATC_RGB: 11,
-      ATC_RGBA_INTERPOLATED_ALPHA: 12,
-      RGBA32: 13,
-      RGB565: 14,
-      BGR565: 15,
-      RGBA4444: 16,
-    }
-
-    static EngineFormat = {
-      RGBAFormat: RGBAFormat,
-      RGBA_ASTC_4x4_Format: RGBA_ASTC_4x4_Format,
-      RGBA_BPTC_Format: RGBA_BPTC_Format,
-      RGBA_ETC2_EAC_Format: RGBA_ETC2_EAC_Format,
-      RGBA_PVRTC_4BPPV1_Format: RGBA_PVRTC_4BPPV1_Format,
-      RGBA_S3TC_DXT5_Format: RGBA_S3TC_DXT5_Format,
-      RGB_ETC1_Format: RGB_ETC1_Format,
-      RGB_ETC2_Format: RGB_ETC2_Format,
-      RGB_PVRTC_4BPPV1_Format: RGB_PVRTC_4BPPV1_Format,
-      RGB_S3TC_DXT1_Format: RGB_S3TC_DXT1_Format,
-    }
+  static BasisFormat = {
+    ETC1S: 0,
+    UASTC_4x4: 1,
+  }
 
-    /* WEB WORKER */
+  static TranscoderFormat = {
+    ETC1: 0,
+    ETC2: 1,
+    BC1: 2,
+    BC3: 3,
+    BC4: 4,
+    BC5: 5,
+    BC7_M6_OPAQUE_ONLY: 6,
+    BC7_M5: 7,
+    PVRTC1_4_RGB: 8,
+    PVRTC1_4_RGBA: 9,
+    ASTC_4x4: 10,
+    ATC_RGB: 11,
+    ATC_RGBA_INTERPOLATED_ALPHA: 12,
+    RGBA32: 13,
+    RGB565: 14,
+    BGR565: 15,
+    RGBA4444: 16,
+  }
 
-    static BasisWorker = function () {
-      let config
-      let transcoderPending
-      let BasisModule
+  static EngineFormat = {
+    RGBAFormat: RGBAFormat,
+    RGBA_ASTC_4x4_Format: RGBA_ASTC_4x4_Format,
+    RGBA_BPTC_Format: RGBA_BPTC_Format,
+    RGBA_ETC2_EAC_Format: RGBA_ETC2_EAC_Format,
+    RGBA_PVRTC_4BPPV1_Format: RGBA_PVRTC_4BPPV1_Format,
+    RGBA_S3TC_DXT5_Format: RGBA_S3TC_DXT5_Format,
+    RGB_ETC1_Format: RGB_ETC1_Format,
+    RGB_ETC2_Format: RGB_ETC2_Format,
+    RGB_PVRTC_4BPPV1_Format: RGB_PVRTC_4BPPV1_Format,
+    RGB_S3TC_DXT1_Format: RGB_S3TC_DXT1_Format,
+  }
 
-      const EngineFormat = _EngineFormat
-      const TranscoderFormat = _TranscoderFormat
-      const BasisFormat = _BasisFormat
+  /* WEB WORKER */
 
-      onmessage = function (e) {
-        const message = e.data
+  static BasisWorker = function () {
+    let config
+    let transcoderPending
+    let BasisModule
 
-        switch (message.type) {
-          case 'init':
-            config = message.config
-            init(message.transcoderBinary)
-            break
+    const EngineFormat = _EngineFormat
+    const TranscoderFormat = _TranscoderFormat
+    const BasisFormat = _BasisFormat
 
-          case 'transcode':
-            transcoderPending.then(() => {
-              try {
-                const { width, height, hasAlpha, mipmaps, format } = message.taskConfig.lowLevel
-                  ? transcodeLowLevel(message.taskConfig)
-                  : transcode(message.buffers[0])
+    onmessage = function (e) {
+      const message = e.data
 
-                const buffers = []
+      switch (message.type) {
+        case 'init':
+          config = message.config
+          init(message.transcoderBinary)
+          break
 
-                for (let i = 0; i < mipmaps.length; ++i) {
-                  buffers.push(mipmaps[i].data.buffer)
-                }
+        case 'transcode':
+          transcoderPending.then(() => {
+            try {
+              const { width, height, hasAlpha, mipmaps, format } = message.taskConfig.lowLevel
+                ? transcodeLowLevel(message.taskConfig)
+                : transcode(message.buffers[0])
 
-                self.postMessage(
-                  { type: 'transcode', id: message.id, width, height, hasAlpha, mipmaps, format },
-                  buffers,
-                )
-              } catch (error) {
-                console.error(error)
+              const buffers = []
 
-                self.postMessage({ type: 'error', id: message.id, error: error.message })
+              for (let i = 0; i < mipmaps.length; ++i) {
+                buffers.push(mipmaps[i].data.buffer)
               }
-            })
-            break
-        }
-      }
 
-      function init(wasmBinary) {
-        transcoderPending = new Promise((resolve) => {
-          BasisModule = { wasmBinary, onRuntimeInitialized: resolve }
-          BASIS(BasisModule)
-        }).then(() => {
-          BasisModule.initializeBasis()
-        })
-      }
+              self.postMessage({ type: 'transcode', id: message.id, width, height, hasAlpha, mipmaps, format }, buffers)
+            } catch (error) {
+              console.error(error)
 
-      function transcodeLowLevel(taskConfig) {
-        const { basisFormat, width, height, hasAlpha } = taskConfig
-
-        const { transcoderFormat, engineFormat } = getTranscoderFormat(basisFormat, width, height, hasAlpha)
-
-        const blockByteLength = BasisModule.getBytesPerBlockOrPixel(transcoderFormat)
+              self.postMessage({ type: 'error', id: message.id, error: error.message })
+            }
+          })
+          break
+      }
+    }
 
-        assert(BasisModule.isFormatSupported(transcoderFormat), 'THREE.BasisTextureLoader: Unsupported format.')
+    function init(wasmBinary) {
+      transcoderPending = new Promise((resolve) => {
+        BasisModule = { wasmBinary, onRuntimeInitialized: resolve }
+        BASIS(BasisModule)
+      }).then(() => {
+        BasisModule.initializeBasis()
+      })
+    }
 
-        const mipmaps = []
+    function transcodeLowLevel(taskConfig) {
+      const { basisFormat, width, height, hasAlpha } = taskConfig
 
-        if (basisFormat === BasisFormat.ETC1S) {
-          const transcoder = new BasisModule.LowLevelETC1SImageTranscoder()
+      const { transcoderFormat, engineFormat } = getTranscoderFormat(basisFormat, width, height, hasAlpha)
 
-          const { endpointCount, endpointsData, selectorCount, selectorsData, tablesData } = taskConfig.globalData
+      const blockByteLength = BasisModule.getBytesPerBlockOrPixel(transcoderFormat)
 
-          try {
-            let ok
+      assert(BasisModule.isFormatSupported(transcoderFormat), 'THREE.BasisTextureLoader: Unsupported format.')
 
-            ok = transcoder.decodePalettes(endpointCount, endpointsData, selectorCount, selectorsData)
+      const mipmaps = []
 
-            assert(ok, 'THREE.BasisTextureLoader: decodePalettes() failed.')
+      if (basisFormat === BasisFormat.ETC1S) {
+        const transcoder = new BasisModule.LowLevelETC1SImageTranscoder()
 
-            ok = transcoder.decodeTables(tablesData)
+        const { endpointCount, endpointsData, selectorCount, selectorsData, tablesData } = taskConfig.globalData
 
-            assert(ok, 'THREE.BasisTextureLoader: decodeTables() failed.')
+        try {
+          let ok
 
-            for (let i = 0; i < taskConfig.levels.length; i++) {
-              const level = taskConfig.levels[i]
-              const imageDesc = taskConfig.globalData.imageDescs[i]
+          ok = transcoder.decodePalettes(endpointCount, endpointsData, selectorCount, selectorsData)
 
-              const dstByteLength = getTranscodedImageByteLength(transcoderFormat, level.width, level.height)
-              const dst = new Uint8Array(dstByteLength)
+          assert(ok, 'THREE.BasisTextureLoader: decodePalettes() failed.')
 
-              ok = transcoder.transcodeImage(
-                transcoderFormat,
-                dst,
-                dstByteLength / blockByteLength,
-                level.data,
-                getWidthInBlocks(transcoderFormat, level.width),
-                getHeightInBlocks(transcoderFormat, level.height),
-                level.width,
-                level.height,
-                level.index,
-                imageDesc.rgbSliceByteOffset,
-                imageDesc.rgbSliceByteLength,
-                imageDesc.alphaSliceByteOffset,
-                imageDesc.alphaSliceByteLength,
-                imageDesc.imageFlags,
-                hasAlpha,
-                false,
-                0,
-                0,
-              )
+          ok = transcoder.decodeTables(tablesData)
 
-              assert(ok, 'THREE.BasisTextureLoader: transcodeImage() failed for level ' + level.index + '.')
+          assert(ok, 'THREE.BasisTextureLoader: decodeTables() failed.')
 
-              mipmaps.push({ data: dst, width: level.width, height: level.height })
-            }
-          } finally {
-            transcoder.delete()
-          }
-        } else {
           for (let i = 0; i < taskConfig.levels.length; i++) {
             const level = taskConfig.levels[i]
+            const imageDesc = taskConfig.globalData.imageDescs[i]
 
             const dstByteLength = getTranscodedImageByteLength(transcoderFormat, level.width, level.height)
             const dst = new Uint8Array(dstByteLength)
 
-            const ok = BasisModule.transcodeUASTCImage(
+            ok = transcoder.transcodeImage(
               transcoderFormat,
               dst,
               dstByteLength / blockByteLength,
@@ -209,455 +170,487 @@ const BasisTextureLoader = /* @__PURE__ */ (() => {
               level.width,
               level.height,
               level.index,
-              0,
-              level.data.byteLength,
-              0,
+              imageDesc.rgbSliceByteOffset,
+              imageDesc.rgbSliceByteLength,
+              imageDesc.alphaSliceByteOffset,
+              imageDesc.alphaSliceByteLength,
+              imageDesc.imageFlags,
               hasAlpha,
               false,
               0,
               0,
-              -1,
-              -1,
             )
 
-            assert(ok, 'THREE.BasisTextureLoader: transcodeUASTCImage() failed for level ' + level.index + '.')
+            assert(ok, 'THREE.BasisTextureLoader: transcodeImage() failed for level ' + level.index + '.')
 
             mipmaps.push({ data: dst, width: level.width, height: level.height })
           }
+        } finally {
+          transcoder.delete()
         }
-
-        return { width, height, hasAlpha, mipmaps, format: engineFormat }
-      }
-
-      function transcode(buffer) {
-        const basisFile = new BasisModule.BasisFile(new Uint8Array(buffer))
-
-        const basisFormat = basisFile.isUASTC() ? BasisFormat.UASTC_4x4 : BasisFormat.ETC1S
-        const width = basisFile.getImageWidth(0, 0)
-        const height = basisFile.getImageHeight(0, 0)
-        const levels = basisFile.getNumLevels(0)
-        const hasAlpha = basisFile.getHasAlpha()
-
-        function cleanup() {
-          basisFile.close()
-          basisFile.delete()
-        }
-
-        const { transcoderFormat, engineFormat } = getTranscoderFormat(basisFormat, width, height, hasAlpha)
-
-        if (!width || !height || !levels) {
-          cleanup()
-          throw new Error('THREE.BasisTextureLoader:	Invalid texture')
-        }
-
-        if (!basisFile.startTranscoding()) {
-          cleanup()
-          throw new Error('THREE.BasisTextureLoader: .startTranscoding failed')
+      } else {
+        for (let i = 0; i < taskConfig.levels.length; i++) {
+          const level = taskConfig.levels[i]
+
+          const dstByteLength = getTranscodedImageByteLength(transcoderFormat, level.width, level.height)
+          const dst = new Uint8Array(dstByteLength)
+
+          const ok = BasisModule.transcodeUASTCImage(
+            transcoderFormat,
+            dst,
+            dstByteLength / blockByteLength,
+            level.data,
+            getWidthInBlocks(transcoderFormat, level.width),
+            getHeightInBlocks(transcoderFormat, level.height),
+            level.width,
+            level.height,
+            level.index,
+            0,
+            level.data.byteLength,
+            0,
+            hasAlpha,
+            false,
+            0,
+            0,
+            -1,
+            -1,
+          )
+
+          assert(ok, 'THREE.BasisTextureLoader: transcodeUASTCImage() failed for level ' + level.index + '.')
+
+          mipmaps.push({ data: dst, width: level.width, height: level.height })
         }
+      }
 
-        const mipmaps = []
+      return { width, height, hasAlpha, mipmaps, format: engineFormat }
+    }
 
-        for (let mip = 0; mip < levels; mip++) {
-          const mipWidth = basisFile.getImageWidth(0, mip)
-          const mipHeight = basisFile.getImageHeight(0, mip)
-          const dst = new Uint8Array(basisFile.getImageTranscodedSizeInBytes(0, mip, transcoderFormat))
+    function transcode(buffer) {
+      const basisFile = new BasisModule.BasisFile(new Uint8Array(buffer))
 
-          const status = basisFile.transcodeImage(dst, 0, mip, transcoderFormat, 0, hasAlpha)
+      const basisFormat = basisFile.isUASTC() ? BasisFormat.UASTC_4x4 : BasisFormat.ETC1S
+      const width = basisFile.getImageWidth(0, 0)
+      const height = basisFile.getImageHeight(0, 0)
+      const levels = basisFile.getNumLevels(0)
+      const hasAlpha = basisFile.getHasAlpha()
 
-          if (!status) {
-            cleanup()
-            throw new Error('THREE.BasisTextureLoader: .transcodeImage failed.')
-          }
+      function cleanup() {
+        basisFile.close()
+        basisFile.delete()
+      }
 
-          mipmaps.push({ data: dst, width: mipWidth, height: mipHeight })
-        }
+      const { transcoderFormat, engineFormat } = getTranscoderFormat(basisFormat, width, height, hasAlpha)
 
+      if (!width || !height || !levels) {
         cleanup()
-
-        return { width, height, hasAlpha, mipmaps, format: engineFormat }
+        throw new Error('THREE.BasisTextureLoader:	Invalid texture')
       }
 
-      //
-
-      // Optimal choice of a transcoder target format depends on the Basis format (ETC1S or UASTC),
-      // device capabilities, and texture dimensions. The list below ranks the formats separately
-      // for ETC1S and UASTC.
-      //
-      // In some cases, transcoding UASTC to RGBA32 might be preferred for higher quality (at
-      // significant memory cost) compared to ETC1/2, BC1/3, and PVRTC. The transcoder currently
-      // chooses RGBA32 only as a last resort and does not expose that option to the caller.
-      const FORMAT_OPTIONS = [
-        {
-          if: 'astcSupported',
-          basisFormat: [BasisFormat.UASTC_4x4],
-          transcoderFormat: [TranscoderFormat.ASTC_4x4, TranscoderFormat.ASTC_4x4],
-          engineFormat: [EngineFormat.RGBA_ASTC_4x4_Format, EngineFormat.RGBA_ASTC_4x4_Format],
-          priorityETC1S: Infinity,
-          priorityUASTC: 1,
-          needsPowerOfTwo: false,
-        },
-        {
-          if: 'bptcSupported',
-          basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
-          transcoderFormat: [TranscoderFormat.BC7_M5, TranscoderFormat.BC7_M5],
-          engineFormat: [EngineFormat.RGBA_BPTC_Format, EngineFormat.RGBA_BPTC_Format],
-          priorityETC1S: 3,
-          priorityUASTC: 2,
-          needsPowerOfTwo: false,
-        },
-        {
-          if: 'dxtSupported',
-          basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
-          transcoderFormat: [TranscoderFormat.BC1, TranscoderFormat.BC3],
-          engineFormat: [EngineFormat.RGB_S3TC_DXT1_Format, EngineFormat.RGBA_S3TC_DXT5_Format],
-          priorityETC1S: 4,
-          priorityUASTC: 5,
-          needsPowerOfTwo: false,
-        },
-        {
-          if: 'etc2Supported',
-          basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
-          transcoderFormat: [TranscoderFormat.ETC1, TranscoderFormat.ETC2],
-          engineFormat: [EngineFormat.RGB_ETC2_Format, EngineFormat.RGBA_ETC2_EAC_Format],
-          priorityETC1S: 1,
-          priorityUASTC: 3,
-          needsPowerOfTwo: false,
-        },
-        {
-          if: 'etc1Supported',
-          basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
-          transcoderFormat: [TranscoderFormat.ETC1, TranscoderFormat.ETC1],
-          engineFormat: [EngineFormat.RGB_ETC1_Format, EngineFormat.RGB_ETC1_Format],
-          priorityETC1S: 2,
-          priorityUASTC: 4,
-          needsPowerOfTwo: false,
-        },
-        {
-          if: 'pvrtcSupported',
-          basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
-          transcoderFormat: [TranscoderFormat.PVRTC1_4_RGB, TranscoderFormat.PVRTC1_4_RGBA],
-          engineFormat: [EngineFormat.RGB_PVRTC_4BPPV1_Format, EngineFormat.RGBA_PVRTC_4BPPV1_Format],
-          priorityETC1S: 5,
-          priorityUASTC: 6,
-          needsPowerOfTwo: true,
-        },
-      ]
-
-      const ETC1S_OPTIONS = FORMAT_OPTIONS.sort(function (a, b) {
-        return a.priorityETC1S - b.priorityETC1S
-      })
-      const UASTC_OPTIONS = FORMAT_OPTIONS.sort(function (a, b) {
-        return a.priorityUASTC - b.priorityUASTC
-      })
+      if (!basisFile.startTranscoding()) {
+        cleanup()
+        throw new Error('THREE.BasisTextureLoader: .startTranscoding failed')
+      }
 
-      function getTranscoderFormat(basisFormat, width, height, hasAlpha) {
-        let transcoderFormat
-        let engineFormat
+      const mipmaps = []
 
-        const options = basisFormat === BasisFormat.ETC1S ? ETC1S_OPTIONS : UASTC_OPTIONS
+      for (let mip = 0; mip < levels; mip++) {
+        const mipWidth = basisFile.getImageWidth(0, mip)
+        const mipHeight = basisFile.getImageHeight(0, mip)
+        const dst = new Uint8Array(basisFile.getImageTranscodedSizeInBytes(0, mip, transcoderFormat))
 
-        for (let i = 0; i < options.length; i++) {
-          const opt = options[i]
+        const status = basisFile.transcodeImage(dst, 0, mip, transcoderFormat, 0, hasAlpha)
 
-          if (!config[opt.if]) continue
-          if (!opt.basisFormat.includes(basisFormat)) continue
-          if (opt.needsPowerOfTwo && !(isPowerOfTwo(width) && isPowerOfTwo(height))) continue
+        if (!status) {
+          cleanup()
+          throw new Error('THREE.BasisTextureLoader: .transcodeImage failed.')
+        }
 
-          transcoderFormat = opt.transcoderFormat[hasAlpha ? 1 : 0]
-          engineFormat = opt.engineFormat[hasAlpha ? 1 : 0]
+        mipmaps.push({ data: dst, width: mipWidth, height: mipHeight })
+      }
 
-          return { transcoderFormat, engineFormat }
-        }
+      cleanup()
 
-        console.warn('THREE.BasisTextureLoader: No suitable compressed texture format found. Decoding to RGBA32.')
+      return { width, height, hasAlpha, mipmaps, format: engineFormat }
+    }
 
-        transcoderFormat = TranscoderFormat.RGBA32
-        engineFormat = EngineFormat.RGBAFormat
+    //
+
+    // Optimal choice of a transcoder target format depends on the Basis format (ETC1S or UASTC),
+    // device capabilities, and texture dimensions. The list below ranks the formats separately
+    // for ETC1S and UASTC.
+    //
+    // In some cases, transcoding UASTC to RGBA32 might be preferred for higher quality (at
+    // significant memory cost) compared to ETC1/2, BC1/3, and PVRTC. The transcoder currently
+    // chooses RGBA32 only as a last resort and does not expose that option to the caller.
+    const FORMAT_OPTIONS = [
+      {
+        if: 'astcSupported',
+        basisFormat: [BasisFormat.UASTC_4x4],
+        transcoderFormat: [TranscoderFormat.ASTC_4x4, TranscoderFormat.ASTC_4x4],
+        engineFormat: [EngineFormat.RGBA_ASTC_4x4_Format, EngineFormat.RGBA_ASTC_4x4_Format],
+        priorityETC1S: Infinity,
+        priorityUASTC: 1,
+        needsPowerOfTwo: false,
+      },
+      {
+        if: 'bptcSupported',
+        basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
+        transcoderFormat: [TranscoderFormat.BC7_M5, TranscoderFormat.BC7_M5],
+        engineFormat: [EngineFormat.RGBA_BPTC_Format, EngineFormat.RGBA_BPTC_Format],
+        priorityETC1S: 3,
+        priorityUASTC: 2,
+        needsPowerOfTwo: false,
+      },
+      {
+        if: 'dxtSupported',
+        basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
+        transcoderFormat: [TranscoderFormat.BC1, TranscoderFormat.BC3],
+        engineFormat: [EngineFormat.RGB_S3TC_DXT1_Format, EngineFormat.RGBA_S3TC_DXT5_Format],
+        priorityETC1S: 4,
+        priorityUASTC: 5,
+        needsPowerOfTwo: false,
+      },
+      {
+        if: 'etc2Supported',
+        basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
+        transcoderFormat: [TranscoderFormat.ETC1, TranscoderFormat.ETC2],
+        engineFormat: [EngineFormat.RGB_ETC2_Format, EngineFormat.RGBA_ETC2_EAC_Format],
+        priorityETC1S: 1,
+        priorityUASTC: 3,
+        needsPowerOfTwo: false,
+      },
+      {
+        if: 'etc1Supported',
+        basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
+        transcoderFormat: [TranscoderFormat.ETC1, TranscoderFormat.ETC1],
+        engineFormat: [EngineFormat.RGB_ETC1_Format, EngineFormat.RGB_ETC1_Format],
+        priorityETC1S: 2,
+        priorityUASTC: 4,
+        needsPowerOfTwo: false,
+      },
+      {
+        if: 'pvrtcSupported',
+        basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
+        transcoderFormat: [TranscoderFormat.PVRTC1_4_RGB, TranscoderFormat.PVRTC1_4_RGBA],
+        engineFormat: [EngineFormat.RGB_PVRTC_4BPPV1_Format, EngineFormat.RGBA_PVRTC_4BPPV1_Format],
+        priorityETC1S: 5,
+        priorityUASTC: 6,
+        needsPowerOfTwo: true,
+      },
+    ]
+
+    const ETC1S_OPTIONS = FORMAT_OPTIONS.sort(function (a, b) {
+      return a.priorityETC1S - b.priorityETC1S
+    })
+    const UASTC_OPTIONS = FORMAT_OPTIONS.sort(function (a, b) {
+      return a.priorityUASTC - b.priorityUASTC
+    })
+
+    function getTranscoderFormat(basisFormat, width, height, hasAlpha) {
+      let transcoderFormat
+      let engineFormat
+
+      const options = basisFormat === BasisFormat.ETC1S ? ETC1S_OPTIONS : UASTC_OPTIONS
+
+      for (let i = 0; i < options.length; i++) {
+        const opt = options[i]
+
+        if (!config[opt.if]) continue
+        if (!opt.basisFormat.includes(basisFormat)) continue
+        if (opt.needsPowerOfTwo && !(isPowerOfTwo(width) && isPowerOfTwo(height))) continue
+
+        transcoderFormat = opt.transcoderFormat[hasAlpha ? 1 : 0]
+        engineFormat = opt.engineFormat[hasAlpha ? 1 : 0]
 
         return { transcoderFormat, engineFormat }
       }
 
-      function assert(ok, message) {
-        if (!ok) throw new Error(message)
-      }
+      console.warn('THREE.BasisTextureLoader: No suitable compressed texture format found. Decoding to RGBA32.')
 
-      function getWidthInBlocks(transcoderFormat, width) {
-        return Math.ceil(width / BasisModule.getFormatBlockWidth(transcoderFormat))
-      }
+      transcoderFormat = TranscoderFormat.RGBA32
+      engineFormat = EngineFormat.RGBAFormat
 
-      function getHeightInBlocks(transcoderFormat, height) {
-        return Math.ceil(height / BasisModule.getFormatBlockHeight(transcoderFormat))
-      }
+      return { transcoderFormat, engineFormat }
+    }
 
-      function getTranscodedImageByteLength(transcoderFormat, width, height) {
-        const blockByteLength = BasisModule.getBytesPerBlockOrPixel(transcoderFormat)
+    function assert(ok, message) {
+      if (!ok) throw new Error(message)
+    }
 
-        if (BasisModule.formatIsUncompressed(transcoderFormat)) {
-          return width * height * blockByteLength
-        }
+    function getWidthInBlocks(transcoderFormat, width) {
+      return Math.ceil(width / BasisModule.getFormatBlockWidth(transcoderFormat))
+    }
 
-        if (transcoderFormat === TranscoderFormat.PVRTC1_4_RGB || transcoderFormat === TranscoderFormat.PVRTC1_4_RGBA) {
-          // GL requires extra padding for very small textures:
-          // https://www.khronos.org/registry/OpenGL/extensions/IMG/IMG_texture_compression_pvrtc.txt
-          const paddedWidth = (width + 3) & ~3
-          const paddedHeight = (height + 3) & ~3
+    function getHeightInBlocks(transcoderFormat, height) {
+      return Math.ceil(height / BasisModule.getFormatBlockHeight(transcoderFormat))
+    }
 
-          return (Math.max(8, paddedWidth) * Math.max(8, paddedHeight) * 4 + 7) / 8
-        }
+    function getTranscodedImageByteLength(transcoderFormat, width, height) {
+      const blockByteLength = BasisModule.getBytesPerBlockOrPixel(transcoderFormat)
 
-        return getWidthInBlocks(transcoderFormat, width) * getHeightInBlocks(transcoderFormat, height) * blockByteLength
+      if (BasisModule.formatIsUncompressed(transcoderFormat)) {
+        return width * height * blockByteLength
       }
 
-      function isPowerOfTwo(value) {
-        if (value <= 2) return true
+      if (transcoderFormat === TranscoderFormat.PVRTC1_4_RGB || transcoderFormat === TranscoderFormat.PVRTC1_4_RGBA) {
+        // GL requires extra padding for very small textures:
+        // https://www.khronos.org/registry/OpenGL/extensions/IMG/IMG_texture_compression_pvrtc.txt
+        const paddedWidth = (width + 3) & ~3
+        const paddedHeight = (height + 3) & ~3
 
-        return (value & (value - 1)) === 0 && value !== 0
+        return (Math.max(8, paddedWidth) * Math.max(8, paddedHeight) * 4 + 7) / 8
       }
-    }
 
-    constructor(manager) {
-      super(manager)
+      return getWidthInBlocks(transcoderFormat, width) * getHeightInBlocks(transcoderFormat, height) * blockByteLength
+    }
 
-      this.transcoderPath = ''
-      this.transcoderBinary = null
-      this.transcoderPending = null
+    function isPowerOfTwo(value) {
+      if (value <= 2) return true
 
-      this.workerLimit = 4
-      this.workerPool = []
-      this.workerNextTaskID = 1
-      this.workerSourceURL = ''
-      this.workerConfig = null
+      return (value & (value - 1)) === 0 && value !== 0
     }
+  }
 
-    setTranscoderPath(path) {
-      this.transcoderPath = path
+  constructor(manager) {
+    super(manager)
 
-      return this
-    }
+    this.transcoderPath = ''
+    this.transcoderBinary = null
+    this.transcoderPending = null
 
-    setWorkerLimit(workerLimit) {
-      this.workerLimit = workerLimit
+    this.workerLimit = 4
+    this.workerPool = []
+    this.workerNextTaskID = 1
+    this.workerSourceURL = ''
+    this.workerConfig = null
+  }
 
-      return this
-    }
+  setTranscoderPath(path) {
+    this.transcoderPath = path
 
-    detectSupport(renderer) {
-      this.workerConfig = {
-        astcSupported: renderer.extensions.has('WEBGL_compressed_texture_astc'),
-        etc1Supported: renderer.extensions.has('WEBGL_compressed_texture_etc1'),
-        etc2Supported: renderer.extensions.has('WEBGL_compressed_texture_etc'),
-        dxtSupported: renderer.extensions.has('WEBGL_compressed_texture_s3tc'),
-        bptcSupported: renderer.extensions.has('EXT_texture_compression_bptc'),
-        pvrtcSupported:
-          renderer.extensions.has('WEBGL_compressed_texture_pvrtc') ||
-          renderer.extensions.has('WEBKIT_WEBGL_compressed_texture_pvrtc'),
-      }
+    return this
+  }
+
+  setWorkerLimit(workerLimit) {
+    this.workerLimit = workerLimit
+
+    return this
+  }
 
-      return this
+  detectSupport(renderer) {
+    this.workerConfig = {
+      astcSupported: renderer.extensions.has('WEBGL_compressed_texture_astc'),
+      etc1Supported: renderer.extensions.has('WEBGL_compressed_texture_etc1'),
+      etc2Supported: renderer.extensions.has('WEBGL_compressed_texture_etc'),
+      dxtSupported: renderer.extensions.has('WEBGL_compressed_texture_s3tc'),
+      bptcSupported: renderer.extensions.has('EXT_texture_compression_bptc'),
+      pvrtcSupported:
+        renderer.extensions.has('WEBGL_compressed_texture_pvrtc') ||
+        renderer.extensions.has('WEBKIT_WEBGL_compressed_texture_pvrtc'),
     }
 
-    load(url, onLoad, onProgress, onError) {
-      const loader = new FileLoader(this.manager)
+    return this
+  }
 
-      loader.setResponseType('arraybuffer')
-      loader.setWithCredentials(this.withCredentials)
+  load(url, onLoad, onProgress, onError) {
+    const loader = new FileLoader(this.manager)
 
-      const texture = new CompressedTexture()
+    loader.setResponseType('arraybuffer')
+    loader.setWithCredentials(this.withCredentials)
 
-      loader.load(
-        url,
-        (buffer) => {
-          // Check for an existing task using this buffer. A transferred buffer cannot be transferred
-          // again from this thread.
-          if (_taskCache.has(buffer)) {
-            const cachedTask = _taskCache.get(buffer)
+    const texture = new CompressedTexture()
 
-            return cachedTask.promise.then(onLoad).catch(onError)
-          }
+    loader.load(
+      url,
+      (buffer) => {
+        // Check for an existing task using this buffer. A transferred buffer cannot be transferred
+        // again from this thread.
+        if (_taskCache.has(buffer)) {
+          const cachedTask = _taskCache.get(buffer)
 
-          this._createTexture([buffer])
-            .then(function (_texture) {
-              texture.copy(_texture)
-              texture.needsUpdate = true
+          return cachedTask.promise.then(onLoad).catch(onError)
+        }
 
-              if (onLoad) onLoad(texture)
-            })
-            .catch(onError)
-        },
-        onProgress,
-        onError,
-      )
+        this._createTexture([buffer])
+          .then(function (_texture) {
+            texture.copy(_texture)
+            texture.needsUpdate = true
 
-      return texture
-    }
+            if (onLoad) onLoad(texture)
+          })
+          .catch(onError)
+      },
+      onProgress,
+      onError,
+    )
 
-    /** Low-level transcoding API, exposed for use by KTX2Loader. */
-    parseInternalAsync(options) {
-      const { levels } = options
+    return texture
+  }
 
-      const buffers = new Set()
+  /** Low-level transcoding API, exposed for use by KTX2Loader. */
+  parseInternalAsync(options) {
+    const { levels } = options
 
-      for (let i = 0; i < levels.length; i++) {
-        buffers.add(levels[i].data.buffer)
-      }
+    const buffers = new Set()
 
-      return this._createTexture(Array.from(buffers), { ...options, lowLevel: true })
+    for (let i = 0; i < levels.length; i++) {
+      buffers.add(levels[i].data.buffer)
     }
 
-    /**
-     * @param {ArrayBuffer[]} buffers
-     * @param {object?} config
-     * @return {Promise<CompressedTexture>}
-     */
-    _createTexture(buffers, config = {}) {
-      let worker
-      let taskID
-
-      const taskConfig = config
-      let taskCost = 0
+    return this._createTexture(Array.from(buffers), { ...options, lowLevel: true })
+  }
 
-      for (let i = 0; i < buffers.length; i++) {
-        taskCost += buffers[i].byteLength
-      }
+  /**
+   * @param {ArrayBuffer[]} buffers
+   * @param {object?} config
+   * @return {Promise<CompressedTexture>}
+   */
+  _createTexture(buffers, config = {}) {
+    let worker
+    let taskID
 
-      const texturePending = this._allocateWorker(taskCost)
-        .then((_worker) => {
-          worker = _worker
-          taskID = this.workerNextTaskID++
+    const taskConfig = config
+    let taskCost = 0
 
-          return new Promise((resolve, reject) => {
-            worker._callbacks[taskID] = { resolve, reject }
+    for (let i = 0; i < buffers.length; i++) {
+      taskCost += buffers[i].byteLength
+    }
 
-            worker.postMessage({ type: 'transcode', id: taskID, buffers: buffers, taskConfig: taskConfig }, buffers)
-          })
-        })
-        .then((message) => {
-          const { mipmaps, width, height, format } = message
+    const texturePending = this._allocateWorker(taskCost)
+      .then((_worker) => {
+        worker = _worker
+        taskID = this.workerNextTaskID++
 
-          const texture = new CompressedTexture(mipmaps, width, height, format, UnsignedByteType)
-          texture.minFilter = mipmaps.length === 1 ? LinearFilter : LinearMipmapLinearFilter
-          texture.magFilter = LinearFilter
-          texture.generateMipmaps = false
-          texture.needsUpdate = true
+        return new Promise((resolve, reject) => {
+          worker._callbacks[taskID] = { resolve, reject }
 
-          return texture
+          worker.postMessage({ type: 'transcode', id: taskID, buffers: buffers, taskConfig: taskConfig }, buffers)
         })
+      })
+      .then((message) => {
+        const { mipmaps, width, height, format } = message
 
-      // Note: replaced '.finally()' with '.catch().then()' block - iOS 11 support (#19416)
-      texturePending
-        .catch(() => true)
-        .then(() => {
-          if (worker && taskID) {
-            worker._taskLoad -= taskCost
-            delete worker._callbacks[taskID]
-          }
-        })
+        const texture = new CompressedTexture(mipmaps, width, height, format, UnsignedByteType)
+        texture.minFilter = mipmaps.length === 1 ? LinearFilter : LinearMipmapLinearFilter
+        texture.magFilter = LinearFilter
+        texture.generateMipmaps = false
+        texture.needsUpdate = true
+
+        return texture
+      })
 
-      // Cache the task result.
-      _taskCache.set(buffers[0], { promise: texturePending })
+    // Note: replaced '.finally()' with '.catch().then()' block - iOS 11 support (#19416)
+    texturePending
+      .catch(() => true)
+      .then(() => {
+        if (worker && taskID) {
+          worker._taskLoad -= taskCost
+          delete worker._callbacks[taskID]
+        }
+      })
 
-      return texturePending
-    }
+    // Cache the task result.
+    _taskCache.set(buffers[0], { promise: texturePending })
 
-    _initTranscoder() {
-      if (!this.transcoderPending) {
-        // Load transcoder wrapper.
-        const jsLoader = new FileLoader(this.manager)
-        jsLoader.setPath(this.transcoderPath)
-        jsLoader.setWithCredentials(this.withCredentials)
-        const jsContent = new Promise((resolve, reject) => {
-          jsLoader.load('basis_transcoder.js', resolve, undefined, reject)
-        })
+    return texturePending
+  }
 
-        // Load transcoder WASM binary.
-        const binaryLoader = new FileLoader(this.manager)
-        binaryLoader.setPath(this.transcoderPath)
-        binaryLoader.setResponseType('arraybuffer')
-        binaryLoader.setWithCredentials(this.withCredentials)
-        const binaryContent = new Promise((resolve, reject) => {
-          binaryLoader.load('basis_transcoder.wasm', resolve, undefined, reject)
-        })
+  _initTranscoder() {
+    if (!this.transcoderPending) {
+      // Load transcoder wrapper.
+      const jsLoader = new FileLoader(this.manager)
+      jsLoader.setPath(this.transcoderPath)
+      jsLoader.setWithCredentials(this.withCredentials)
+      const jsContent = new Promise((resolve, reject) => {
+        jsLoader.load('basis_transcoder.js', resolve, undefined, reject)
+      })
 
-        this.transcoderPending = Promise.all([jsContent, binaryContent]).then(([jsContent, binaryContent]) => {
-          const fn = BasisTextureLoader.BasisWorker.toString()
-
-          const body = [
-            '/* constants */',
-            'let _EngineFormat = ' + JSON.stringify(BasisTextureLoader.EngineFormat),
-            'let _TranscoderFormat = ' + JSON.stringify(BasisTextureLoader.TranscoderFormat),
-            'let _BasisFormat = ' + JSON.stringify(BasisTextureLoader.BasisFormat),
-            '/* basis_transcoder.js */',
-            jsContent,
-            '/* worker */',
-            fn.substring(fn.indexOf('{') + 1, fn.lastIndexOf('}')),
-          ].join('\n')
-
-          this.workerSourceURL = URL.createObjectURL(new Blob([body]))
-          this.transcoderBinary = binaryContent
-        })
-      }
+      // Load transcoder WASM binary.
+      const binaryLoader = new FileLoader(this.manager)
+      binaryLoader.setPath(this.transcoderPath)
+      binaryLoader.setResponseType('arraybuffer')
+      binaryLoader.setWithCredentials(this.withCredentials)
+      const binaryContent = new Promise((resolve, reject) => {
+        binaryLoader.load('basis_transcoder.wasm', resolve, undefined, reject)
+      })
 
-      return this.transcoderPending
+      this.transcoderPending = Promise.all([jsContent, binaryContent]).then(([jsContent, binaryContent]) => {
+        const fn = BasisTextureLoader.BasisWorker.toString()
+
+        const body = [
+          '/* constants */',
+          'let _EngineFormat = ' + JSON.stringify(BasisTextureLoader.EngineFormat),
+          'let _TranscoderFormat = ' + JSON.stringify(BasisTextureLoader.TranscoderFormat),
+          'let _BasisFormat = ' + JSON.stringify(BasisTextureLoader.BasisFormat),
+          '/* basis_transcoder.js */',
+          jsContent,
+          '/* worker */',
+          fn.substring(fn.indexOf('{') + 1, fn.lastIndexOf('}')),
+        ].join('\n')
+
+        this.workerSourceURL = URL.createObjectURL(new Blob([body]))
+        this.transcoderBinary = binaryContent
+      })
     }
 
-    _allocateWorker(taskCost) {
-      return this._initTranscoder().then(() => {
-        if (this.workerPool.length < this.workerLimit) {
-          const worker = new Worker(this.workerSourceURL)
+    return this.transcoderPending
+  }
 
-          worker._callbacks = {}
-          worker._taskLoad = 0
+  _allocateWorker(taskCost) {
+    return this._initTranscoder().then(() => {
+      if (this.workerPool.length < this.workerLimit) {
+        const worker = new Worker(this.workerSourceURL)
 
-          worker.postMessage({
-            type: 'init',
-            config: this.workerConfig,
-            transcoderBinary: this.transcoderBinary,
-          })
+        worker._callbacks = {}
+        worker._taskLoad = 0
 
-          worker.onmessage = function (e) {
-            const message = e.data
+        worker.postMessage({
+          type: 'init',
+          config: this.workerConfig,
+          transcoderBinary: this.transcoderBinary,
+        })
 
-            switch (message.type) {
-              case 'transcode':
-                worker._callbacks[message.id].resolve(message)
-                break
+        worker.onmessage = function (e) {
+          const message = e.data
 
-              case 'error':
-                worker._callbacks[message.id].reject(message)
-                break
+          switch (message.type) {
+            case 'transcode':
+              worker._callbacks[message.id].resolve(message)
+              break
 
-              default:
-                console.error('THREE.BasisTextureLoader: Unexpected message, "' + message.type + '"')
-            }
-          }
+            case 'error':
+              worker._callbacks[message.id].reject(message)
+              break
 
-          this.workerPool.push(worker)
-        } else {
-          this.workerPool.sort(function (a, b) {
-            return a._taskLoad > b._taskLoad ? -1 : 1
-          })
+            default:
+              console.error('THREE.BasisTextureLoader: Unexpected message, "' + message.type + '"')
+          }
         }
 
-        const worker = this.workerPool[this.workerPool.length - 1]
-
-        worker._taskLoad += taskCost
+        this.workerPool.push(worker)
+      } else {
+        this.workerPool.sort(function (a, b) {
+          return a._taskLoad > b._taskLoad ? -1 : 1
+        })
+      }
 
-        return worker
-      })
-    }
+      const worker = this.workerPool[this.workerPool.length - 1]
 
-    dispose() {
-      for (let i = 0; i < this.workerPool.length; i++) {
-        this.workerPool[i].terminate()
-      }
+      worker._taskLoad += taskCost
 
-      this.workerPool.length = 0
+      return worker
+    })
+  }
 
-      return this
+  dispose() {
+    for (let i = 0; i < this.workerPool.length; i++) {
+      this.workerPool[i].terminate()
     }
-  }
 
-  return BasisTextureLoader
-})()
+    this.workerPool.length = 0
+
+    return this
+  }
+}
 
 export { BasisTextureLoader }
diff --git a/src/loaders/EXRLoader.js b/src/loaders/EXRLoader.js
index 002bfefd..fd311038 100644
--- a/src/loaders/EXRLoader.js
+++ b/src/loaders/EXRLoader.js
@@ -9,7 +9,6 @@ import {
   RGBAFormat,
 } from 'three'
 import { unzlibSync } from 'fflate'
-import { version } from '../_polyfill/constants'
 
 /**
  * OpenEXR loader currently supports uncompressed, ZIP(S), RLE, PIZ and DWA/B compression.
@@ -84,8 +83,7 @@ import { version } from '../_polyfill/constants'
 
 // // End of OpenEXR license -------------------------------------------------
 
-// https://github.com/mrdoob/three.js/pull/25771
-const hasColorSpace = version >= 152
+const hasColorSpace = 'colorSpace' in new Texture()
 
 class EXRLoader extends DataTextureLoader {
   constructor(manager) {
diff --git a/src/loaders/FBXLoader.js b/src/loaders/FBXLoader.js
index 034e4bb3..e171ec87 100644
--- a/src/loaders/FBXLoader.js
+++ b/src/loaders/FBXLoader.js
@@ -1275,8 +1275,8 @@ class GeometryParser {
     }
 
     buffers.uvs.forEach(function (uvBuffer, i) {
-      if (UV1 === 'uv2') i++
-      const name = i === 0 ? 'uv' : `uv${i}`
+      if (UV1 === 'uv2') i++;
+      const name = i === 0 ? 'uv' : `uv${i}`;
 
       geo.setAttribute(name, new Float32BufferAttribute(buffers.uvs[i], 2))
     })
@@ -3113,8 +3113,8 @@ function getData(polygonVertexIndex, polygonIndex, vertexIndex, infoObject) {
   return slice(dataArray, infoObject.buffer, from, to)
 }
 
-const tempEuler = /* @__PURE__ */ new Euler()
-const tempVec = /* @__PURE__ */ new Vector3()
+const tempEuler = new Euler()
+const tempVec = new Vector3()
 
 // generate transformation from FBX transform data
 // ref: https://help.autodesk.com/view/FBX/2017/ENU/?guid=__files_GUID_10CDD63C_79C1_4F2D_BB28_AD2BE65A02ED_htm
diff --git a/src/loaders/FontLoader.ts b/src/loaders/FontLoader.ts
index 00aa0643..cb0e4ee4 100644
--- a/src/loaders/FontLoader.ts
+++ b/src/loaders/FontLoader.ts
@@ -66,8 +66,8 @@ type FontData = {
 
 export class Font {
   public data: FontData
-  public isFont = true
-  public type = 'Font'
+  public static isFont: true
+  public static type: 'Font'
 
   constructor(data: FontData) {
     this.data = data
diff --git a/src/loaders/GLTFLoader.js b/src/loaders/GLTFLoader.js
index dd037655..c4b7d01c 100644
--- a/src/loaders/GLTFLoader.js
+++ b/src/loaders/GLTFLoader.js
@@ -1676,7 +1676,7 @@ class GLTFCubicSplineInterpolant extends Interpolant {
   }
 }
 
-const _q = /* @__PURE__ */ new Quaternion()
+const _q = new Quaternion()
 
 class GLTFCubicSplineQuaternionInterpolant extends GLTFCubicSplineInterpolant {
   interpolate_(i1, t0, t, t1) {
@@ -2006,7 +2006,7 @@ function getImageURIMimeType(uri) {
   return 'image/png'
 }
 
-const _identityMatrix = /* @__PURE__ */ new Matrix4()
+const _identityMatrix = new Matrix4()
 
 /* GLTF PARSER */
 
diff --git a/src/loaders/KTX2Loader.js b/src/loaders/KTX2Loader.js
index ae2758c7..f2b25571 100644
--- a/src/loaders/KTX2Loader.js
+++ b/src/loaders/KTX2Loader.js
@@ -81,538 +81,534 @@ let _activeLoaders = 0
 
 let _zstd
 
-const KTX2Loader = /* @__PURE__ */ (() => {
-  class KTX2Loader extends Loader {
-    /* CONSTANTS */
+class KTX2Loader extends Loader {
+  /* CONSTANTS */
 
-    static BasisFormat = {
-      ETC1S: 0,
-      UASTC_4x4: 1,
-    }
+  static BasisFormat = {
+    ETC1S: 0,
+    UASTC_4x4: 1,
+  }
 
-    static TranscoderFormat = {
-      ETC1: 0,
-      ETC2: 1,
-      BC1: 2,
-      BC3: 3,
-      BC4: 4,
-      BC5: 5,
-      BC7_M6_OPAQUE_ONLY: 6,
-      BC7_M5: 7,
-      PVRTC1_4_RGB: 8,
-      PVRTC1_4_RGBA: 9,
-      ASTC_4x4: 10,
-      ATC_RGB: 11,
-      ATC_RGBA_INTERPOLATED_ALPHA: 12,
-      RGBA32: 13,
-      RGB565: 14,
-      BGR565: 15,
-      RGBA4444: 16,
-    }
+  static TranscoderFormat = {
+    ETC1: 0,
+    ETC2: 1,
+    BC1: 2,
+    BC3: 3,
+    BC4: 4,
+    BC5: 5,
+    BC7_M6_OPAQUE_ONLY: 6,
+    BC7_M5: 7,
+    PVRTC1_4_RGB: 8,
+    PVRTC1_4_RGBA: 9,
+    ASTC_4x4: 10,
+    ATC_RGB: 11,
+    ATC_RGBA_INTERPOLATED_ALPHA: 12,
+    RGBA32: 13,
+    RGB565: 14,
+    BGR565: 15,
+    RGBA4444: 16,
+  }
 
-    static EngineFormat = {
-      RGBAFormat: RGBAFormat,
-      RGBA_ASTC_4x4_Format: RGBA_ASTC_4x4_Format,
-      RGBA_BPTC_Format: RGBA_BPTC_Format,
-      RGBA_ETC2_EAC_Format: RGBA_ETC2_EAC_Format,
-      RGBA_PVRTC_4BPPV1_Format: RGBA_PVRTC_4BPPV1_Format,
-      RGBA_S3TC_DXT5_Format: RGBA_S3TC_DXT5_Format,
-      RGB_ETC1_Format: RGB_ETC1_Format,
-      RGB_ETC2_Format: RGB_ETC2_Format,
-      RGB_PVRTC_4BPPV1_Format: RGB_PVRTC_4BPPV1_Format,
-      RGB_S3TC_DXT1_Format: RGB_S3TC_DXT1_Format,
-    }
+  static EngineFormat = {
+    RGBAFormat: RGBAFormat,
+    RGBA_ASTC_4x4_Format: RGBA_ASTC_4x4_Format,
+    RGBA_BPTC_Format: RGBA_BPTC_Format,
+    RGBA_ETC2_EAC_Format: RGBA_ETC2_EAC_Format,
+    RGBA_PVRTC_4BPPV1_Format: RGBA_PVRTC_4BPPV1_Format,
+    RGBA_S3TC_DXT5_Format: RGBA_S3TC_DXT5_Format,
+    RGB_ETC1_Format: RGB_ETC1_Format,
+    RGB_ETC2_Format: RGB_ETC2_Format,
+    RGB_PVRTC_4BPPV1_Format: RGB_PVRTC_4BPPV1_Format,
+    RGB_S3TC_DXT1_Format: RGB_S3TC_DXT1_Format,
+  }
+
+  /* WEB WORKER */
+
+  static BasisWorker = function () {
+    let config
+    let transcoderPending
+    let BasisModule
+
+    /** @type KTX2Loader.EngineFormat */
+    const EngineFormat = _EngineFormat
+    /** @type KTX2Loader.TranscoderFormat */
+    const TranscoderFormat = _TranscoderFormat
+    /** @type KTX2Loader.BasisFormat */
+    const BasisFormat = _BasisFormat
+
+    self.addEventListener('message', function (e) {
+      const message = e.data
+
+      switch (message.type) {
+        case 'init':
+          config = message.config
+          init(message.transcoderBinary)
+          break
+
+        case 'transcode':
+          transcoderPending.then(() => {
+            try {
+              const { faces, buffers, width, height, hasAlpha, format, dfdFlags } = transcode(message.buffer)
+
+              self.postMessage(
+                { type: 'transcode', id: message.id, faces, width, height, hasAlpha, format, dfdFlags },
+                buffers,
+              )
+            } catch (error) {
+              console.error(error)
+
+              self.postMessage({ type: 'error', id: message.id, error: error.message })
+            }
+          })
+          break
+      }
+    })
+
+    function init(wasmBinary) {
+      transcoderPending = new Promise((resolve) => {
+        BasisModule = { wasmBinary, onRuntimeInitialized: resolve }
+        BASIS(BasisModule)
+      }).then(() => {
+        BasisModule.initializeBasis()
 
-    /* WEB WORKER */
-
-    static BasisWorker = function () {
-      let config
-      let transcoderPending
-      let BasisModule
-
-      /** @type KTX2Loader.EngineFormat */
-      const EngineFormat = _EngineFormat
-      /** @type KTX2Loader.TranscoderFormat */
-      const TranscoderFormat = _TranscoderFormat
-      /** @type KTX2Loader.BasisFormat */
-      const BasisFormat = _BasisFormat
-
-      self.addEventListener('message', function (e) {
-        const message = e.data
-
-        switch (message.type) {
-          case 'init':
-            config = message.config
-            init(message.transcoderBinary)
-            break
-
-          case 'transcode':
-            transcoderPending.then(() => {
-              try {
-                const { faces, buffers, width, height, hasAlpha, format, dfdFlags } = transcode(message.buffer)
-
-                self.postMessage(
-                  { type: 'transcode', id: message.id, faces, width, height, hasAlpha, format, dfdFlags },
-                  buffers,
-                )
-              } catch (error) {
-                console.error(error)
-
-                self.postMessage({ type: 'error', id: message.id, error: error.message })
-              }
-            })
-            break
+        if (BasisModule.KTX2File === undefined) {
+          console.warn('THREE.KTX2Loader: Please update Basis Universal transcoder.')
         }
       })
+    }
 
-      function init(wasmBinary) {
-        transcoderPending = new Promise((resolve) => {
-          BasisModule = { wasmBinary, onRuntimeInitialized: resolve }
-          BASIS(BasisModule)
-        }).then(() => {
-          BasisModule.initializeBasis()
+    function transcode(buffer) {
+      const ktx2File = new BasisModule.KTX2File(new Uint8Array(buffer))
 
-          if (BasisModule.KTX2File === undefined) {
-            console.warn('THREE.KTX2Loader: Please update Basis Universal transcoder.')
-          }
-        })
+      function cleanup() {
+        ktx2File.close()
+        ktx2File.delete()
       }
 
-      function transcode(buffer) {
-        const ktx2File = new BasisModule.KTX2File(new Uint8Array(buffer))
+      if (!ktx2File.isValid()) {
+        cleanup()
+        throw new Error('THREE.KTX2Loader:	Invalid or unsupported .ktx2 file')
+      }
 
-        function cleanup() {
-          ktx2File.close()
-          ktx2File.delete()
-        }
+      const basisFormat = ktx2File.isUASTC() ? BasisFormat.UASTC_4x4 : BasisFormat.ETC1S
+      const width = ktx2File.getWidth()
+      const height = ktx2File.getHeight()
+      const layerCount = ktx2File.getLayers() || 1
+      const levelCount = ktx2File.getLevels()
+      const faceCount = ktx2File.getFaces()
+      const hasAlpha = ktx2File.getHasAlpha()
+      const dfdFlags = ktx2File.getDFDFlags()
 
-        if (!ktx2File.isValid()) {
-          cleanup()
-          throw new Error('THREE.KTX2Loader:	Invalid or unsupported .ktx2 file')
-        }
+      const { transcoderFormat, engineFormat } = getTranscoderFormat(basisFormat, width, height, hasAlpha)
 
-        const basisFormat = ktx2File.isUASTC() ? BasisFormat.UASTC_4x4 : BasisFormat.ETC1S
-        const width = ktx2File.getWidth()
-        const height = ktx2File.getHeight()
-        const layerCount = ktx2File.getLayers() || 1
-        const levelCount = ktx2File.getLevels()
-        const faceCount = ktx2File.getFaces()
-        const hasAlpha = ktx2File.getHasAlpha()
-        const dfdFlags = ktx2File.getDFDFlags()
+      if (!width || !height || !levelCount) {
+        cleanup()
+        throw new Error('THREE.KTX2Loader:	Invalid texture')
+      }
 
-        const { transcoderFormat, engineFormat } = getTranscoderFormat(basisFormat, width, height, hasAlpha)
+      if (!ktx2File.startTranscoding()) {
+        cleanup()
+        throw new Error('THREE.KTX2Loader: .startTranscoding failed')
+      }
 
-        if (!width || !height || !levelCount) {
-          cleanup()
-          throw new Error('THREE.KTX2Loader:	Invalid texture')
-        }
+      const faces = []
+      const buffers = []
 
-        if (!ktx2File.startTranscoding()) {
-          cleanup()
-          throw new Error('THREE.KTX2Loader: .startTranscoding failed')
-        }
+      for (let face = 0; face < faceCount; face++) {
+        const mipmaps = []
+
+        for (let mip = 0; mip < levelCount; mip++) {
+          const layerMips = []
+
+          let mipWidth, mipHeight
+
+          for (let layer = 0; layer < layerCount; layer++) {
+            const levelInfo = ktx2File.getImageLevelInfo(mip, layer, face)
+
+            if (
+              face === 0 &&
+              mip === 0 &&
+              layer === 0 &&
+              (levelInfo.origWidth % 4 !== 0 || levelInfo.origHeight % 4 !== 0)
+            ) {
+              console.warn('THREE.KTX2Loader: ETC1S and UASTC textures should use multiple-of-four dimensions.')
+            }
 
-        const faces = []
-        const buffers = []
-
-        for (let face = 0; face < faceCount; face++) {
-          const mipmaps = []
-
-          for (let mip = 0; mip < levelCount; mip++) {
-            const layerMips = []
-
-            let mipWidth, mipHeight
-
-            for (let layer = 0; layer < layerCount; layer++) {
-              const levelInfo = ktx2File.getImageLevelInfo(mip, layer, face)
-
-              if (
-                face === 0 &&
-                mip === 0 &&
-                layer === 0 &&
-                (levelInfo.origWidth % 4 !== 0 || levelInfo.origHeight % 4 !== 0)
-              ) {
-                console.warn('THREE.KTX2Loader: ETC1S and UASTC textures should use multiple-of-four dimensions.')
-              }
-
-              if (levelCount > 1) {
-                mipWidth = levelInfo.origWidth
-                mipHeight = levelInfo.origHeight
-              } else {
-                // Handles non-multiple-of-four dimensions in textures without mipmaps. Textures with
-                // mipmaps must use multiple-of-four dimensions, for some texture formats and APIs.
-                // See mrdoob/three.js#25908.
-                mipWidth = levelInfo.width
-                mipHeight = levelInfo.height
-              }
-
-              const dst = new Uint8Array(ktx2File.getImageTranscodedSizeInBytes(mip, layer, 0, transcoderFormat))
-              const status = ktx2File.transcodeImage(dst, mip, layer, face, transcoderFormat, 0, -1, -1)
-
-              if (!status) {
-                cleanup()
-                throw new Error('THREE.KTX2Loader: .transcodeImage failed.')
-              }
-
-              layerMips.push(dst)
+            if (levelCount > 1) {
+              mipWidth = levelInfo.origWidth
+              mipHeight = levelInfo.origHeight
+            } else {
+              // Handles non-multiple-of-four dimensions in textures without mipmaps. Textures with
+              // mipmaps must use multiple-of-four dimensions, for some texture formats and APIs.
+              // See mrdoob/three.js#25908.
+              mipWidth = levelInfo.width
+              mipHeight = levelInfo.height
             }
 
-            const mipData = concat(layerMips)
+            const dst = new Uint8Array(ktx2File.getImageTranscodedSizeInBytes(mip, layer, 0, transcoderFormat))
+            const status = ktx2File.transcodeImage(dst, mip, layer, face, transcoderFormat, 0, -1, -1)
 
-            mipmaps.push({ data: mipData, width: mipWidth, height: mipHeight })
-            buffers.push(mipData.buffer)
+            if (!status) {
+              cleanup()
+              throw new Error('THREE.KTX2Loader: .transcodeImage failed.')
+            }
+
+            layerMips.push(dst)
           }
 
-          faces.push({ mipmaps, width, height, format: engineFormat })
-        }
+          const mipData = concat(layerMips)
 
-        cleanup()
+          mipmaps.push({ data: mipData, width: mipWidth, height: mipHeight })
+          buffers.push(mipData.buffer)
+        }
 
-        return { faces, buffers, width, height, hasAlpha, format: engineFormat, dfdFlags }
+        faces.push({ mipmaps, width, height, format: engineFormat })
       }
 
-      //
-
-      // Optimal choice of a transcoder target format depends on the Basis format (ETC1S or UASTC),
-      // device capabilities, and texture dimensions. The list below ranks the formats separately
-      // for ETC1S and UASTC.
-      //
-      // In some cases, transcoding UASTC to RGBA32 might be preferred for higher quality (at
-      // significant memory cost) compared to ETC1/2, BC1/3, and PVRTC. The transcoder currently
-      // chooses RGBA32 only as a last resort and does not expose that option to the caller.
-      const FORMAT_OPTIONS = [
-        {
-          if: 'astcSupported',
-          basisFormat: [BasisFormat.UASTC_4x4],
-          transcoderFormat: [TranscoderFormat.ASTC_4x4, TranscoderFormat.ASTC_4x4],
-          engineFormat: [EngineFormat.RGBA_ASTC_4x4_Format, EngineFormat.RGBA_ASTC_4x4_Format],
-          priorityETC1S: Infinity,
-          priorityUASTC: 1,
-          needsPowerOfTwo: false,
-        },
-        {
-          if: 'bptcSupported',
-          basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
-          transcoderFormat: [TranscoderFormat.BC7_M5, TranscoderFormat.BC7_M5],
-          engineFormat: [EngineFormat.RGBA_BPTC_Format, EngineFormat.RGBA_BPTC_Format],
-          priorityETC1S: 3,
-          priorityUASTC: 2,
-          needsPowerOfTwo: false,
-        },
-        {
-          if: 'dxtSupported',
-          basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
-          transcoderFormat: [TranscoderFormat.BC1, TranscoderFormat.BC3],
-          engineFormat: [EngineFormat.RGB_S3TC_DXT1_Format, EngineFormat.RGBA_S3TC_DXT5_Format],
-          priorityETC1S: 4,
-          priorityUASTC: 5,
-          needsPowerOfTwo: false,
-        },
-        {
-          if: 'etc2Supported',
-          basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
-          transcoderFormat: [TranscoderFormat.ETC1, TranscoderFormat.ETC2],
-          engineFormat: [EngineFormat.RGB_ETC2_Format, EngineFormat.RGBA_ETC2_EAC_Format],
-          priorityETC1S: 1,
-          priorityUASTC: 3,
-          needsPowerOfTwo: false,
-        },
-        {
-          if: 'etc1Supported',
-          basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
-          transcoderFormat: [TranscoderFormat.ETC1],
-          engineFormat: [EngineFormat.RGB_ETC1_Format],
-          priorityETC1S: 2,
-          priorityUASTC: 4,
-          needsPowerOfTwo: false,
-        },
-        {
-          if: 'pvrtcSupported',
-          basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
-          transcoderFormat: [TranscoderFormat.PVRTC1_4_RGB, TranscoderFormat.PVRTC1_4_RGBA],
-          engineFormat: [EngineFormat.RGB_PVRTC_4BPPV1_Format, EngineFormat.RGBA_PVRTC_4BPPV1_Format],
-          priorityETC1S: 5,
-          priorityUASTC: 6,
-          needsPowerOfTwo: true,
-        },
-      ]
-
-      const ETC1S_OPTIONS = FORMAT_OPTIONS.sort(function (a, b) {
-        return a.priorityETC1S - b.priorityETC1S
-      })
-      const UASTC_OPTIONS = FORMAT_OPTIONS.sort(function (a, b) {
-        return a.priorityUASTC - b.priorityUASTC
-      })
-
-      function getTranscoderFormat(basisFormat, width, height, hasAlpha) {
-        let transcoderFormat
-        let engineFormat
+      cleanup()
 
-        const options = basisFormat === BasisFormat.ETC1S ? ETC1S_OPTIONS : UASTC_OPTIONS
+      return { faces, buffers, width, height, hasAlpha, format: engineFormat, dfdFlags }
+    }
 
-        for (let i = 0; i < options.length; i++) {
-          const opt = options[i]
+    //
+
+    // Optimal choice of a transcoder target format depends on the Basis format (ETC1S or UASTC),
+    // device capabilities, and texture dimensions. The list below ranks the formats separately
+    // for ETC1S and UASTC.
+    //
+    // In some cases, transcoding UASTC to RGBA32 might be preferred for higher quality (at
+    // significant memory cost) compared to ETC1/2, BC1/3, and PVRTC. The transcoder currently
+    // chooses RGBA32 only as a last resort and does not expose that option to the caller.
+    const FORMAT_OPTIONS = [
+      {
+        if: 'astcSupported',
+        basisFormat: [BasisFormat.UASTC_4x4],
+        transcoderFormat: [TranscoderFormat.ASTC_4x4, TranscoderFormat.ASTC_4x4],
+        engineFormat: [EngineFormat.RGBA_ASTC_4x4_Format, EngineFormat.RGBA_ASTC_4x4_Format],
+        priorityETC1S: Infinity,
+        priorityUASTC: 1,
+        needsPowerOfTwo: false,
+      },
+      {
+        if: 'bptcSupported',
+        basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
+        transcoderFormat: [TranscoderFormat.BC7_M5, TranscoderFormat.BC7_M5],
+        engineFormat: [EngineFormat.RGBA_BPTC_Format, EngineFormat.RGBA_BPTC_Format],
+        priorityETC1S: 3,
+        priorityUASTC: 2,
+        needsPowerOfTwo: false,
+      },
+      {
+        if: 'dxtSupported',
+        basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
+        transcoderFormat: [TranscoderFormat.BC1, TranscoderFormat.BC3],
+        engineFormat: [EngineFormat.RGB_S3TC_DXT1_Format, EngineFormat.RGBA_S3TC_DXT5_Format],
+        priorityETC1S: 4,
+        priorityUASTC: 5,
+        needsPowerOfTwo: false,
+      },
+      {
+        if: 'etc2Supported',
+        basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
+        transcoderFormat: [TranscoderFormat.ETC1, TranscoderFormat.ETC2],
+        engineFormat: [EngineFormat.RGB_ETC2_Format, EngineFormat.RGBA_ETC2_EAC_Format],
+        priorityETC1S: 1,
+        priorityUASTC: 3,
+        needsPowerOfTwo: false,
+      },
+      {
+        if: 'etc1Supported',
+        basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
+        transcoderFormat: [TranscoderFormat.ETC1],
+        engineFormat: [EngineFormat.RGB_ETC1_Format],
+        priorityETC1S: 2,
+        priorityUASTC: 4,
+        needsPowerOfTwo: false,
+      },
+      {
+        if: 'pvrtcSupported',
+        basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
+        transcoderFormat: [TranscoderFormat.PVRTC1_4_RGB, TranscoderFormat.PVRTC1_4_RGBA],
+        engineFormat: [EngineFormat.RGB_PVRTC_4BPPV1_Format, EngineFormat.RGBA_PVRTC_4BPPV1_Format],
+        priorityETC1S: 5,
+        priorityUASTC: 6,
+        needsPowerOfTwo: true,
+      },
+    ]
+
+    const ETC1S_OPTIONS = FORMAT_OPTIONS.sort(function (a, b) {
+      return a.priorityETC1S - b.priorityETC1S
+    })
+    const UASTC_OPTIONS = FORMAT_OPTIONS.sort(function (a, b) {
+      return a.priorityUASTC - b.priorityUASTC
+    })
 
-          if (!config[opt.if]) continue
-          if (!opt.basisFormat.includes(basisFormat)) continue
-          if (hasAlpha && opt.transcoderFormat.length < 2) continue
-          if (opt.needsPowerOfTwo && !(isPowerOfTwo(width) && isPowerOfTwo(height))) continue
+    function getTranscoderFormat(basisFormat, width, height, hasAlpha) {
+      let transcoderFormat
+      let engineFormat
 
-          transcoderFormat = opt.transcoderFormat[hasAlpha ? 1 : 0]
-          engineFormat = opt.engineFormat[hasAlpha ? 1 : 0]
+      const options = basisFormat === BasisFormat.ETC1S ? ETC1S_OPTIONS : UASTC_OPTIONS
 
-          return { transcoderFormat, engineFormat }
-        }
+      for (let i = 0; i < options.length; i++) {
+        const opt = options[i]
 
-        console.warn('THREE.KTX2Loader: No suitable compressed texture format found. Decoding to RGBA32.')
+        if (!config[opt.if]) continue
+        if (!opt.basisFormat.includes(basisFormat)) continue
+        if (hasAlpha && opt.transcoderFormat.length < 2) continue
+        if (opt.needsPowerOfTwo && !(isPowerOfTwo(width) && isPowerOfTwo(height))) continue
 
-        transcoderFormat = TranscoderFormat.RGBA32
-        engineFormat = EngineFormat.RGBAFormat
+        transcoderFormat = opt.transcoderFormat[hasAlpha ? 1 : 0]
+        engineFormat = opt.engineFormat[hasAlpha ? 1 : 0]
 
         return { transcoderFormat, engineFormat }
       }
 
-      function isPowerOfTwo(value) {
-        if (value <= 2) return true
+      console.warn('THREE.KTX2Loader: No suitable compressed texture format found. Decoding to RGBA32.')
 
-        return (value & (value - 1)) === 0 && value !== 0
-      }
-
-      /** Concatenates N byte arrays. */
-      function concat(arrays) {
-        if (arrays.length === 1) return arrays[0]
-
-        let totalByteLength = 0
+      transcoderFormat = TranscoderFormat.RGBA32
+      engineFormat = EngineFormat.RGBAFormat
 
-        for (let i = 0; i < arrays.length; i++) {
-          const array = arrays[i]
-          totalByteLength += array.byteLength
-        }
+      return { transcoderFormat, engineFormat }
+    }
 
-        const result = new Uint8Array(totalByteLength)
+    function isPowerOfTwo(value) {
+      if (value <= 2) return true
 
-        let byteOffset = 0
+      return (value & (value - 1)) === 0 && value !== 0
+    }
 
-        for (let i = 0; i < arrays.length; i++) {
-          const array = arrays[i]
-          result.set(array, byteOffset)
+    /** Concatenates N byte arrays. */
+    function concat(arrays) {
+      if (arrays.length === 1) return arrays[0]
 
-          byteOffset += array.byteLength
-        }
+      let totalByteLength = 0
 
-        return result
+      for (let i = 0; i < arrays.length; i++) {
+        const array = arrays[i]
+        totalByteLength += array.byteLength
       }
-    }
 
-    constructor(manager) {
-      super(manager)
+      const result = new Uint8Array(totalByteLength)
 
-      this.transcoderPath = ''
-      this.transcoderBinary = null
-      this.transcoderPending = null
+      let byteOffset = 0
 
-      this.workerPool = new WorkerPool()
-      this.workerSourceURL = ''
-      this.workerConfig = null
+      for (let i = 0; i < arrays.length; i++) {
+        const array = arrays[i]
+        result.set(array, byteOffset)
 
-      if (typeof MSC_TRANSCODER !== 'undefined') {
-        console.warn(
-          'THREE.KTX2Loader: Please update to latest "basis_transcoder".' +
-            ' "msc_basis_transcoder" is no longer supported in three.js r125+.',
-        )
+        byteOffset += array.byteLength
       }
-    }
-
-    setTranscoderPath(path) {
-      this.transcoderPath = path
 
-      return this
+      return result
     }
+  }
 
-    setWorkerLimit(num) {
-      this.workerPool.setWorkerLimit(num)
-
-      return this
-    }
+  constructor(manager) {
+    super(manager)
 
-    detectSupport(renderer) {
-      this.workerConfig = {
-        astcSupported: renderer.extensions.has('WEBGL_compressed_texture_astc'),
-        etc1Supported: renderer.extensions.has('WEBGL_compressed_texture_etc1'),
-        etc2Supported: renderer.extensions.has('WEBGL_compressed_texture_etc'),
-        dxtSupported: renderer.extensions.has('WEBGL_compressed_texture_s3tc'),
-        bptcSupported: renderer.extensions.has('EXT_texture_compression_bptc'),
-        pvrtcSupported:
-          renderer.extensions.has('WEBGL_compressed_texture_pvrtc') ||
-          renderer.extensions.has('WEBKIT_WEBGL_compressed_texture_pvrtc'),
-      }
+    this.transcoderPath = ''
+    this.transcoderBinary = null
+    this.transcoderPending = null
 
-      if (renderer.capabilities.isWebGL2) {
-        // https://github.com/mrdoob/three.js/pull/22928
-        this.workerConfig.etc1Supported = false
-      }
+    this.workerPool = new WorkerPool()
+    this.workerSourceURL = ''
+    this.workerConfig = null
 
-      return this
+    if (typeof MSC_TRANSCODER !== 'undefined') {
+      console.warn(
+        'THREE.KTX2Loader: Please update to latest "basis_transcoder".' +
+          ' "msc_basis_transcoder" is no longer supported in three.js r125+.',
+      )
     }
+  }
 
-    init() {
-      if (!this.transcoderPending) {
-        // Load transcoder wrapper.
-        const jsLoader = new FileLoader(this.manager)
-        jsLoader.setPath(this.transcoderPath)
-        jsLoader.setWithCredentials(this.withCredentials)
-        const jsContent = jsLoader.loadAsync('basis_transcoder.js')
-
-        // Load transcoder WASM binary.
-        const binaryLoader = new FileLoader(this.manager)
-        binaryLoader.setPath(this.transcoderPath)
-        binaryLoader.setResponseType('arraybuffer')
-        binaryLoader.setWithCredentials(this.withCredentials)
-        const binaryContent = binaryLoader.loadAsync('basis_transcoder.wasm')
-
-        this.transcoderPending = Promise.all([jsContent, binaryContent]).then(([jsContent, binaryContent]) => {
-          const fn = KTX2Loader.BasisWorker.toString()
-
-          const body = [
-            '/* constants */',
-            'let _EngineFormat = ' + JSON.stringify(KTX2Loader.EngineFormat),
-            'let _TranscoderFormat = ' + JSON.stringify(KTX2Loader.TranscoderFormat),
-            'let _BasisFormat = ' + JSON.stringify(KTX2Loader.BasisFormat),
-            '/* basis_transcoder.js */',
-            jsContent,
-            '/* worker */',
-            fn.substring(fn.indexOf('{') + 1, fn.lastIndexOf('}')),
-          ].join('\n')
-
-          this.workerSourceURL = URL.createObjectURL(new Blob([body]))
-          this.transcoderBinary = binaryContent
-
-          this.workerPool.setWorkerCreator(() => {
-            const worker = new Worker(this.workerSourceURL)
-            const transcoderBinary = this.transcoderBinary.slice(0)
-
-            worker.postMessage({ type: 'init', config: this.workerConfig, transcoderBinary }, [transcoderBinary])
-
-            return worker
-          })
-        })
+  setTranscoderPath(path) {
+    this.transcoderPath = path
 
-        if (_activeLoaders > 0) {
-          // Each instance loads a transcoder and allocates workers, increasing network and memory cost.
+    return this
+  }
 
-          console.warn(
-            'THREE.KTX2Loader: Multiple active KTX2 loaders may cause performance issues.' +
-              ' Use a single KTX2Loader instance, or call .dispose() on old instances.',
-          )
-        }
+  setWorkerLimit(num) {
+    this.workerPool.setWorkerLimit(num)
 
-        _activeLoaders++
-      }
+    return this
+  }
 
-      return this.transcoderPending
+  detectSupport(renderer) {
+    this.workerConfig = {
+      astcSupported: renderer.extensions.has('WEBGL_compressed_texture_astc'),
+      etc1Supported: renderer.extensions.has('WEBGL_compressed_texture_etc1'),
+      etc2Supported: renderer.extensions.has('WEBGL_compressed_texture_etc'),
+      dxtSupported: renderer.extensions.has('WEBGL_compressed_texture_s3tc'),
+      bptcSupported: renderer.extensions.has('EXT_texture_compression_bptc'),
+      pvrtcSupported:
+        renderer.extensions.has('WEBGL_compressed_texture_pvrtc') ||
+        renderer.extensions.has('WEBKIT_WEBGL_compressed_texture_pvrtc'),
     }
 
-    load(url, onLoad, onProgress, onError) {
-      if (this.workerConfig === null) {
-        throw new Error('THREE.KTX2Loader: Missing initialization with `.detectSupport( renderer )`.')
-      }
+    if (renderer.capabilities.isWebGL2) {
+      // https://github.com/mrdoob/three.js/pull/22928
+      this.workerConfig.etc1Supported = false
+    }
+
+    return this
+  }
+
+  init() {
+    if (!this.transcoderPending) {
+      // Load transcoder wrapper.
+      const jsLoader = new FileLoader(this.manager)
+      jsLoader.setPath(this.transcoderPath)
+      jsLoader.setWithCredentials(this.withCredentials)
+      const jsContent = jsLoader.loadAsync('basis_transcoder.js')
+
+      // Load transcoder WASM binary.
+      const binaryLoader = new FileLoader(this.manager)
+      binaryLoader.setPath(this.transcoderPath)
+      binaryLoader.setResponseType('arraybuffer')
+      binaryLoader.setWithCredentials(this.withCredentials)
+      const binaryContent = binaryLoader.loadAsync('basis_transcoder.wasm')
+
+      this.transcoderPending = Promise.all([jsContent, binaryContent]).then(([jsContent, binaryContent]) => {
+        const fn = KTX2Loader.BasisWorker.toString()
+
+        const body = [
+          '/* constants */',
+          'let _EngineFormat = ' + JSON.stringify(KTX2Loader.EngineFormat),
+          'let _TranscoderFormat = ' + JSON.stringify(KTX2Loader.TranscoderFormat),
+          'let _BasisFormat = ' + JSON.stringify(KTX2Loader.BasisFormat),
+          '/* basis_transcoder.js */',
+          jsContent,
+          '/* worker */',
+          fn.substring(fn.indexOf('{') + 1, fn.lastIndexOf('}')),
+        ].join('\n')
+
+        this.workerSourceURL = URL.createObjectURL(new Blob([body]))
+        this.transcoderBinary = binaryContent
+
+        this.workerPool.setWorkerCreator(() => {
+          const worker = new Worker(this.workerSourceURL)
+          const transcoderBinary = this.transcoderBinary.slice(0)
+
+          worker.postMessage({ type: 'init', config: this.workerConfig, transcoderBinary }, [transcoderBinary])
+
+          return worker
+        })
+      })
 
-      const loader = new FileLoader(this.manager)
+      if (_activeLoaders > 0) {
+        // Each instance loads a transcoder and allocates workers, increasing network and memory cost.
 
-      loader.setResponseType('arraybuffer')
-      loader.setWithCredentials(this.withCredentials)
+        console.warn(
+          'THREE.KTX2Loader: Multiple active KTX2 loaders may cause performance issues.' +
+            ' Use a single KTX2Loader instance, or call .dispose() on old instances.',
+        )
+      }
 
-      loader.load(
-        url,
-        (buffer) => {
-          // Check for an existing task using this buffer. A transferred buffer cannot be transferred
-          // again from this thread.
-          if (_taskCache.has(buffer)) {
-            const cachedTask = _taskCache.get(buffer)
+      _activeLoaders++
+    }
 
-            return cachedTask.promise.then(onLoad).catch(onError)
-          }
+    return this.transcoderPending
+  }
 
-          this._createTexture(buffer)
-            .then((texture) => (onLoad ? onLoad(texture) : null))
-            .catch(onError)
-        },
-        onProgress,
-        onError,
-      )
+  load(url, onLoad, onProgress, onError) {
+    if (this.workerConfig === null) {
+      throw new Error('THREE.KTX2Loader: Missing initialization with `.detectSupport( renderer )`.')
     }
 
-    _createTextureFrom(transcodeResult, container) {
-      const { faces, width, height, format, type, error, dfdFlags } = transcodeResult
+    const loader = new FileLoader(this.manager)
 
-      if (type === 'error') return Promise.reject(error)
+    loader.setResponseType('arraybuffer')
+    loader.setWithCredentials(this.withCredentials)
 
-      let texture
+    loader.load(
+      url,
+      (buffer) => {
+        // Check for an existing task using this buffer. A transferred buffer cannot be transferred
+        // again from this thread.
+        if (_taskCache.has(buffer)) {
+          const cachedTask = _taskCache.get(buffer)
 
-      if (container.faceCount === 6) {
-        texture = new CompressedCubeTexture(faces, format, UnsignedByteType)
-      } else {
-        const mipmaps = faces[0].mipmaps
+          return cachedTask.promise.then(onLoad).catch(onError)
+        }
 
-        texture =
-          container.layerCount > 1
-            ? new CompressedArrayTexture(mipmaps, width, height, container.layerCount, format, UnsignedByteType)
-            : new CompressedTexture(mipmaps, width, height, format, UnsignedByteType)
-      }
+        this._createTexture(buffer)
+          .then((texture) => (onLoad ? onLoad(texture) : null))
+          .catch(onError)
+      },
+      onProgress,
+      onError,
+    )
+  }
 
-      texture.minFilter = faces[0].mipmaps.length === 1 ? LinearFilter : LinearMipmapLinearFilter
-      texture.magFilter = LinearFilter
-      texture.generateMipmaps = false
-      texture.needsUpdate = true
+  _createTextureFrom(transcodeResult, container) {
+    const { faces, width, height, format, type, error, dfdFlags } = transcodeResult
 
-      const colorSpace = parseColorSpace(container)
-      if ('colorSpace' in texture) texture.colorSpace = colorSpace
-      else texture.encoding = colorSpace === SRGBColorSpace ? sRGBEncoding : LinearEncoding
+    if (type === 'error') return Promise.reject(error)
 
-      texture.premultiplyAlpha = !!(dfdFlags & KHR_DF_FLAG_ALPHA_PREMULTIPLIED)
+    let texture
 
-      return texture
+    if (container.faceCount === 6) {
+      texture = new CompressedCubeTexture(faces, format, UnsignedByteType)
+    } else {
+      const mipmaps = faces[0].mipmaps
+
+      texture =
+        container.layerCount > 1
+          ? new CompressedArrayTexture(mipmaps, width, height, container.layerCount, format, UnsignedByteType)
+          : new CompressedTexture(mipmaps, width, height, format, UnsignedByteType)
     }
 
-    /**
-     * @param {ArrayBuffer} buffer
-     * @param {object?} config
-     * @return {Promise<CompressedTexture|CompressedArrayTexture|DataTexture|Data3DTexture>}
-     */
-    async _createTexture(buffer, config = {}) {
-      const container = read(new Uint8Array(buffer))
+    texture.minFilter = faces[0].mipmaps.length === 1 ? LinearFilter : LinearMipmapLinearFilter
+    texture.magFilter = LinearFilter
+    texture.generateMipmaps = false
+    texture.needsUpdate = true
 
-      if (container.vkFormat !== VK_FORMAT_UNDEFINED) {
-        return createRawTexture(container)
-      }
+    const colorSpace = parseColorSpace(container)
+    if ('colorSpace' in texture) texture.colorSpace = colorSpace
+    else texture.encoding = colorSpace === SRGBColorSpace ? sRGBEncoding : LinearEncoding
 
-      //
+    texture.premultiplyAlpha = !!(dfdFlags & KHR_DF_FLAG_ALPHA_PREMULTIPLIED)
 
-      const taskConfig = config
-      const texturePending = this.init()
-        .then(() => {
-          return this.workerPool.postMessage({ type: 'transcode', buffer, taskConfig: taskConfig }, [buffer])
-        })
-        .then((e) => this._createTextureFrom(e.data, container))
+    return texture
+  }
 
-      // Cache the task result.
-      _taskCache.set(buffer, { promise: texturePending })
+  /**
+   * @param {ArrayBuffer} buffer
+   * @param {object?} config
+   * @return {Promise<CompressedTexture|CompressedArrayTexture|DataTexture|Data3DTexture>}
+   */
+  async _createTexture(buffer, config = {}) {
+    const container = read(new Uint8Array(buffer))
 
-      return texturePending
+    if (container.vkFormat !== VK_FORMAT_UNDEFINED) {
+      return createRawTexture(container)
     }
 
-    dispose() {
-      this.workerPool.dispose()
-      if (this.workerSourceURL) URL.revokeObjectURL(this.workerSourceURL)
+    //
+
+    const taskConfig = config
+    const texturePending = this.init()
+      .then(() => {
+        return this.workerPool.postMessage({ type: 'transcode', buffer, taskConfig: taskConfig }, [buffer])
+      })
+      .then((e) => this._createTextureFrom(e.data, container))
 
-      _activeLoaders--
+    // Cache the task result.
+    _taskCache.set(buffer, { promise: texturePending })
 
-      return this
-    }
+    return texturePending
   }
 
-  return KTX2Loader
-})()
+  dispose() {
+    this.workerPool.dispose()
+    if (this.workerSourceURL) URL.revokeObjectURL(this.workerSourceURL)
+
+    _activeLoaders--
+
+    return this
+  }
+}
 
 //
 // Parsing for non-Basis textures. These textures are may have supercompression
diff --git a/src/loaders/LDrawLoader.js b/src/loaders/LDrawLoader.js
index ea6323a6..41c39c67 100644
--- a/src/loaders/LDrawLoader.js
+++ b/src/loaders/LDrawLoader.js
@@ -15,8 +15,8 @@ import {
   UniformsUtils,
   Vector3,
   Ray,
+  REVISION,
 } from 'three'
-import { version } from '../_polyfill/constants'
 
 // Special surface finish tag types.
 // Note: "MATERIAL" tag (e.g. GLITTER, SPECKLE) is not implemented
@@ -40,8 +40,8 @@ const FILE_LOCATION_NOT_FOUND = 6
 const MAIN_COLOUR_CODE = '16'
 const MAIN_EDGE_COLOUR_CODE = '24'
 
-const _tempVec0 = /* @__PURE__ */ new Vector3()
-const _tempVec1 = /* @__PURE__ */ new Vector3()
+const _tempVec0 = new Vector3()
+const _tempVec1 = new Vector3()
 
 class LDrawConditionalLineMaterial extends ShaderMaterial {
   constructor(parameters) {
@@ -129,7 +129,7 @@ class LDrawConditionalLineMaterial extends ShaderMaterial {
           outgoingLight = diffuseColor.rgb; // simple shader
           gl_FragColor = vec4(outgoingLight, diffuseColor.a);
           #include <tonemapping_fragment>
-          #include <${version >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>
+          #include <${parseInt(REVISION.replace(/\D+/g, '')) >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>
           #include <fog_fragment>
           #include <premultiplied_alpha_fragment>
         }
@@ -180,7 +180,7 @@ function generateFaceNormals(faces) {
   }
 }
 
-const _ray = /* @__PURE__ */ new Ray()
+const _ray = new Ray()
 function smoothNormals(faces, lineSegments, checkSubSegments = false) {
   // NOTE: 1e2 is pretty coarse but was chosen to quantize the resulting value because
   // it allows edges to be smoothed as expected (see minifig arms).
diff --git a/src/loaders/OBJLoader.js b/src/loaders/OBJLoader.js
index 82ffde04..f5a5ffce 100644
--- a/src/loaders/OBJLoader.js
+++ b/src/loaders/OBJLoader.js
@@ -23,12 +23,12 @@ const _material_use_pattern = /^usemtl /
 // usemap map_name
 const _map_use_pattern = /^usemap /
 
-const _vA = /* @__PURE__ */ new Vector3()
-const _vB = /* @__PURE__ */ new Vector3()
-const _vC = /* @__PURE__ */ new Vector3()
+const _vA = new Vector3()
+const _vB = new Vector3()
+const _vC = new Vector3()
 
-const _ab = /* @__PURE__ */ new Vector3()
-const _cb = /* @__PURE__ */ new Vector3()
+const _ab = new Vector3()
+const _cb = new Vector3()
 
 function ParserState() {
   const state = {
diff --git a/src/loaders/PRWMLoader.js b/src/loaders/PRWMLoader.js
index a2604cc8..b839b1bf 100644
--- a/src/loaders/PRWMLoader.js
+++ b/src/loaders/PRWMLoader.js
@@ -168,69 +168,65 @@ function decodePrwm(buffer) {
 
 // Define the public interface
 
-const PRWMLoader = /* @__PURE__ */ (() => {
-  class PRWMLoader extends Loader {
-    constructor(manager) {
-      super(manager)
-    }
+class PRWMLoader extends Loader {
+  constructor(manager) {
+    super(manager)
+  }
 
-    load(url, onLoad, onProgress, onError) {
-      const scope = this
-
-      const loader = new FileLoader(scope.manager)
-      loader.setPath(scope.path)
-      loader.setResponseType('arraybuffer')
-      loader.setRequestHeader(scope.requestHeader)
-      loader.setWithCredentials(scope.withCredentials)
-
-      url = url.replace(/\*/g, isBigEndianPlatform() ? 'be' : 'le')
-
-      loader.load(
-        url,
-        function (arrayBuffer) {
-          try {
-            onLoad(scope.parse(arrayBuffer))
-          } catch (e) {
-            if (onError) {
-              onError(e)
-            } else {
-              console.error(e)
-            }
-
-            scope.manager.itemError(url)
+  load(url, onLoad, onProgress, onError) {
+    const scope = this
+
+    const loader = new FileLoader(scope.manager)
+    loader.setPath(scope.path)
+    loader.setResponseType('arraybuffer')
+    loader.setRequestHeader(scope.requestHeader)
+    loader.setWithCredentials(scope.withCredentials)
+
+    url = url.replace(/\*/g, isBigEndianPlatform() ? 'be' : 'le')
+
+    loader.load(
+      url,
+      function (arrayBuffer) {
+        try {
+          onLoad(scope.parse(arrayBuffer))
+        } catch (e) {
+          if (onError) {
+            onError(e)
+          } else {
+            console.error(e)
           }
-        },
-        onProgress,
-        onError,
-      )
-    }
 
-    parse(arrayBuffer) {
-      const data = decodePrwm(arrayBuffer),
-        attributesKey = Object.keys(data.attributes),
-        bufferGeometry = new BufferGeometry()
-
-      for (let i = 0; i < attributesKey.length; i++) {
-        const attribute = data.attributes[attributesKey[i]]
-        bufferGeometry.setAttribute(
-          attributesKey[i],
-          new BufferAttribute(attribute.values, attribute.cardinality, attribute.normalized),
-        )
-      }
+          scope.manager.itemError(url)
+        }
+      },
+      onProgress,
+      onError,
+    )
+  }
 
-      if (data.indices !== null) {
-        bufferGeometry.setIndex(new BufferAttribute(data.indices, 1))
-      }
+  parse(arrayBuffer) {
+    const data = decodePrwm(arrayBuffer),
+      attributesKey = Object.keys(data.attributes),
+      bufferGeometry = new BufferGeometry()
 
-      return bufferGeometry
+    for (let i = 0; i < attributesKey.length; i++) {
+      const attribute = data.attributes[attributesKey[i]]
+      bufferGeometry.setAttribute(
+        attributesKey[i],
+        new BufferAttribute(attribute.values, attribute.cardinality, attribute.normalized),
+      )
     }
 
-    static isBigEndianPlatform() {
-      return isBigEndianPlatform()
+    if (data.indices !== null) {
+      bufferGeometry.setIndex(new BufferAttribute(data.indices, 1))
     }
+
+    return bufferGeometry
   }
 
-  return PRWMLoader
-})()
+  static isBigEndianPlatform() {
+    return isBigEndianPlatform()
+  }
+}
 
 export { PRWMLoader }
diff --git a/src/loaders/SVGLoader.js b/src/loaders/SVGLoader.js
index 8bbb51c2..b8879e62 100644
--- a/src/loaders/SVGLoader.js
+++ b/src/loaders/SVGLoader.js
@@ -15,2520 +15,2513 @@ import {
 
 const COLOR_SPACE_SVG = 'srgb'
 
-const SVGLoader = /* @__PURE__ */ (() => {
-  class SVGLoader extends Loader {
-    constructor(manager) {
-      super(manager)
+class SVGLoader extends Loader {
+  constructor(manager) {
+    super(manager)
 
-      // Default dots per inch
-      this.defaultDPI = 90
+    // Default dots per inch
+    this.defaultDPI = 90
 
-      // Accepted units: 'mm', 'cm', 'in', 'pt', 'pc', 'px'
-      this.defaultUnit = 'px'
-    }
-
-    load(url, onLoad, onProgress, onError) {
-      const scope = this
-
-      const loader = new FileLoader(scope.manager)
-      loader.setPath(scope.path)
-      loader.setRequestHeader(scope.requestHeader)
-      loader.setWithCredentials(scope.withCredentials)
-      loader.load(
-        url,
-        function (text) {
-          try {
-            onLoad(scope.parse(text))
-          } catch (e) {
-            if (onError) {
-              onError(e)
-            } else {
-              console.error(e)
-            }
+    // Accepted units: 'mm', 'cm', 'in', 'pt', 'pc', 'px'
+    this.defaultUnit = 'px'
+  }
 
-            scope.manager.itemError(url)
+  load(url, onLoad, onProgress, onError) {
+    const scope = this
+
+    const loader = new FileLoader(scope.manager)
+    loader.setPath(scope.path)
+    loader.setRequestHeader(scope.requestHeader)
+    loader.setWithCredentials(scope.withCredentials)
+    loader.load(
+      url,
+      function (text) {
+        try {
+          onLoad(scope.parse(text))
+        } catch (e) {
+          if (onError) {
+            onError(e)
+          } else {
+            console.error(e)
           }
-        },
-        onProgress,
-        onError,
-      )
-    }
 
-    parse(text) {
-      const scope = this
+          scope.manager.itemError(url)
+        }
+      },
+      onProgress,
+      onError,
+    )
+  }
 
-      function parseNode(node, style) {
-        if (node.nodeType !== 1) return
+  parse(text) {
+    const scope = this
 
-        const transform = getNodeTransform(node)
+    function parseNode(node, style) {
+      if (node.nodeType !== 1) return
 
-        let isDefsNode = false
+      const transform = getNodeTransform(node)
 
-        let path = null
+      let isDefsNode = false
 
-        switch (node.nodeName) {
-          case 'svg':
-            style = parseStyle(node, style)
-            break
+      let path = null
 
-          case 'style':
-            parseCSSStylesheet(node)
-            break
+      switch (node.nodeName) {
+        case 'svg':
+          style = parseStyle(node, style)
+          break
 
-          case 'g':
-            style = parseStyle(node, style)
-            break
+        case 'style':
+          parseCSSStylesheet(node)
+          break
 
-          case 'path':
-            style = parseStyle(node, style)
-            if (node.hasAttribute('d')) path = parsePathNode(node)
-            break
+        case 'g':
+          style = parseStyle(node, style)
+          break
 
-          case 'rect':
-            style = parseStyle(node, style)
-            path = parseRectNode(node)
-            break
+        case 'path':
+          style = parseStyle(node, style)
+          if (node.hasAttribute('d')) path = parsePathNode(node)
+          break
 
-          case 'polygon':
-            style = parseStyle(node, style)
-            path = parsePolygonNode(node)
-            break
+        case 'rect':
+          style = parseStyle(node, style)
+          path = parseRectNode(node)
+          break
 
-          case 'polyline':
-            style = parseStyle(node, style)
-            path = parsePolylineNode(node)
-            break
+        case 'polygon':
+          style = parseStyle(node, style)
+          path = parsePolygonNode(node)
+          break
 
-          case 'circle':
-            style = parseStyle(node, style)
-            path = parseCircleNode(node)
-            break
+        case 'polyline':
+          style = parseStyle(node, style)
+          path = parsePolylineNode(node)
+          break
 
-          case 'ellipse':
-            style = parseStyle(node, style)
-            path = parseEllipseNode(node)
-            break
+        case 'circle':
+          style = parseStyle(node, style)
+          path = parseCircleNode(node)
+          break
 
-          case 'line':
-            style = parseStyle(node, style)
-            path = parseLineNode(node)
-            break
+        case 'ellipse':
+          style = parseStyle(node, style)
+          path = parseEllipseNode(node)
+          break
 
-          case 'defs':
-            isDefsNode = true
-            break
+        case 'line':
+          style = parseStyle(node, style)
+          path = parseLineNode(node)
+          break
 
-          case 'use':
-            style = parseStyle(node, style)
+        case 'defs':
+          isDefsNode = true
+          break
 
-            const href = node.getAttributeNS('http://www.w3.org/1999/xlink', 'href') || ''
-            const usedNodeId = href.substring(1)
-            const usedNode = node.viewportElement.getElementById(usedNodeId)
-            if (usedNode) {
-              parseNode(usedNode, style)
-            } else {
-              console.warn("SVGLoader: 'use node' references non-existent node id: " + usedNodeId)
-            }
-
-            break
-
-          default:
-          // console.log( node );
-        }
+        case 'use':
+          style = parseStyle(node, style)
 
-        if (path) {
-          if (style.fill !== undefined && style.fill !== 'none') {
-            path.color.setStyle(style.fill, COLOR_SPACE_SVG)
+          const href = node.getAttributeNS('http://www.w3.org/1999/xlink', 'href') || ''
+          const usedNodeId = href.substring(1)
+          const usedNode = node.viewportElement.getElementById(usedNodeId)
+          if (usedNode) {
+            parseNode(usedNode, style)
+          } else {
+            console.warn("SVGLoader: 'use node' references non-existent node id: " + usedNodeId)
           }
 
-          transformPath(path, currentTransform)
+          break
 
-          paths.push(path)
+        default:
+        // console.log( node );
+      }
 
-          path.userData = { node: node, style: style }
+      if (path) {
+        if (style.fill !== undefined && style.fill !== 'none') {
+          path.color.setStyle(style.fill, COLOR_SPACE_SVG)
         }
 
-        const childNodes = node.childNodes
+        transformPath(path, currentTransform)
 
-        for (let i = 0; i < childNodes.length; i++) {
-          const node = childNodes[i]
+        paths.push(path)
 
-          if (isDefsNode && node.nodeName !== 'style' && node.nodeName !== 'defs') {
-            // Ignore everything in defs except CSS style definitions
-            // and nested defs, because it is OK by the standard to have
-            // <style/> there.
-            continue
-          }
+        path.userData = { node: node, style: style }
+      }
 
-          parseNode(node, style)
-        }
+      const childNodes = node.childNodes
 
-        if (transform) {
-          transformStack.pop()
+      for (let i = 0; i < childNodes.length; i++) {
+        const node = childNodes[i]
 
-          if (transformStack.length > 0) {
-            currentTransform.copy(transformStack[transformStack.length - 1])
-          } else {
-            currentTransform.identity()
-          }
+        if (isDefsNode && node.nodeName !== 'style' && node.nodeName !== 'defs') {
+          // Ignore everything in defs except CSS style definitions
+          // and nested defs, because it is OK by the standard to have
+          // <style/> there.
+          continue
         }
+
+        parseNode(node, style)
       }
 
-      function parsePathNode(node) {
-        const path = new ShapePath()
+      if (transform) {
+        transformStack.pop()
+
+        if (transformStack.length > 0) {
+          currentTransform.copy(transformStack[transformStack.length - 1])
+        } else {
+          currentTransform.identity()
+        }
+      }
+    }
 
-        const point = new Vector2()
-        const control = new Vector2()
+    function parsePathNode(node) {
+      const path = new ShapePath()
 
-        const firstPoint = new Vector2()
-        let isFirstPoint = true
-        let doSetFirstPoint = false
+      const point = new Vector2()
+      const control = new Vector2()
 
-        const d = node.getAttribute('d')
+      const firstPoint = new Vector2()
+      let isFirstPoint = true
+      let doSetFirstPoint = false
 
-        if (d === '' || d === 'none') return null
+      const d = node.getAttribute('d')
 
-        // console.log( d );
+      if (d === '' || d === 'none') return null
 
-        const commands = d.match(/[a-df-z][^a-df-z]*/gi)
+      // console.log( d );
 
-        for (let i = 0, l = commands.length; i < l; i++) {
-          const command = commands[i]
+      const commands = d.match(/[a-df-z][^a-df-z]*/gi)
 
-          const type = command.charAt(0)
-          const data = command.slice(1).trim()
+      for (let i = 0, l = commands.length; i < l; i++) {
+        const command = commands[i]
 
-          if (isFirstPoint === true) {
-            doSetFirstPoint = true
-            isFirstPoint = false
-          }
+        const type = command.charAt(0)
+        const data = command.slice(1).trim()
 
-          let numbers
+        if (isFirstPoint === true) {
+          doSetFirstPoint = true
+          isFirstPoint = false
+        }
 
-          switch (type) {
-            case 'M':
-              numbers = parseFloats(data)
-              for (let j = 0, jl = numbers.length; j < jl; j += 2) {
-                point.x = numbers[j + 0]
-                point.y = numbers[j + 1]
-                control.x = point.x
-                control.y = point.y
+        let numbers
 
-                if (j === 0) {
-                  path.moveTo(point.x, point.y)
-                } else {
-                  path.lineTo(point.x, point.y)
-                }
+        switch (type) {
+          case 'M':
+            numbers = parseFloats(data)
+            for (let j = 0, jl = numbers.length; j < jl; j += 2) {
+              point.x = numbers[j + 0]
+              point.y = numbers[j + 1]
+              control.x = point.x
+              control.y = point.y
 
-                if (j === 0) firstPoint.copy(point)
+              if (j === 0) {
+                path.moveTo(point.x, point.y)
+              } else {
+                path.lineTo(point.x, point.y)
               }
 
-              break
+              if (j === 0) firstPoint.copy(point)
+            }
 
-            case 'H':
-              numbers = parseFloats(data)
+            break
 
-              for (let j = 0, jl = numbers.length; j < jl; j++) {
-                point.x = numbers[j]
-                control.x = point.x
-                control.y = point.y
-                path.lineTo(point.x, point.y)
+          case 'H':
+            numbers = parseFloats(data)
 
-                if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
-              }
+            for (let j = 0, jl = numbers.length; j < jl; j++) {
+              point.x = numbers[j]
+              control.x = point.x
+              control.y = point.y
+              path.lineTo(point.x, point.y)
 
-              break
+              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
+            }
 
-            case 'V':
-              numbers = parseFloats(data)
+            break
 
-              for (let j = 0, jl = numbers.length; j < jl; j++) {
-                point.y = numbers[j]
-                control.x = point.x
-                control.y = point.y
-                path.lineTo(point.x, point.y)
+          case 'V':
+            numbers = parseFloats(data)
 
-                if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
-              }
+            for (let j = 0, jl = numbers.length; j < jl; j++) {
+              point.y = numbers[j]
+              control.x = point.x
+              control.y = point.y
+              path.lineTo(point.x, point.y)
 
-              break
+              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
+            }
 
-            case 'L':
-              numbers = parseFloats(data)
+            break
 
-              for (let j = 0, jl = numbers.length; j < jl; j += 2) {
-                point.x = numbers[j + 0]
-                point.y = numbers[j + 1]
-                control.x = point.x
-                control.y = point.y
-                path.lineTo(point.x, point.y)
+          case 'L':
+            numbers = parseFloats(data)
 
-                if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
-              }
+            for (let j = 0, jl = numbers.length; j < jl; j += 2) {
+              point.x = numbers[j + 0]
+              point.y = numbers[j + 1]
+              control.x = point.x
+              control.y = point.y
+              path.lineTo(point.x, point.y)
 
-              break
+              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
+            }
 
-            case 'C':
-              numbers = parseFloats(data)
-
-              for (let j = 0, jl = numbers.length; j < jl; j += 6) {
-                path.bezierCurveTo(
-                  numbers[j + 0],
-                  numbers[j + 1],
-                  numbers[j + 2],
-                  numbers[j + 3],
-                  numbers[j + 4],
-                  numbers[j + 5],
-                )
-                control.x = numbers[j + 2]
-                control.y = numbers[j + 3]
-                point.x = numbers[j + 4]
-                point.y = numbers[j + 5]
-
-                if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
-              }
+            break
 
-              break
+          case 'C':
+            numbers = parseFloats(data)
+
+            for (let j = 0, jl = numbers.length; j < jl; j += 6) {
+              path.bezierCurveTo(
+                numbers[j + 0],
+                numbers[j + 1],
+                numbers[j + 2],
+                numbers[j + 3],
+                numbers[j + 4],
+                numbers[j + 5],
+              )
+              control.x = numbers[j + 2]
+              control.y = numbers[j + 3]
+              point.x = numbers[j + 4]
+              point.y = numbers[j + 5]
+
+              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
+            }
 
-            case 'S':
-              numbers = parseFloats(data)
-
-              for (let j = 0, jl = numbers.length; j < jl; j += 4) {
-                path.bezierCurveTo(
-                  getReflection(point.x, control.x),
-                  getReflection(point.y, control.y),
-                  numbers[j + 0],
-                  numbers[j + 1],
-                  numbers[j + 2],
-                  numbers[j + 3],
-                )
-                control.x = numbers[j + 0]
-                control.y = numbers[j + 1]
-                point.x = numbers[j + 2]
-                point.y = numbers[j + 3]
-
-                if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
-              }
+            break
 
-              break
+          case 'S':
+            numbers = parseFloats(data)
+
+            for (let j = 0, jl = numbers.length; j < jl; j += 4) {
+              path.bezierCurveTo(
+                getReflection(point.x, control.x),
+                getReflection(point.y, control.y),
+                numbers[j + 0],
+                numbers[j + 1],
+                numbers[j + 2],
+                numbers[j + 3],
+              )
+              control.x = numbers[j + 0]
+              control.y = numbers[j + 1]
+              point.x = numbers[j + 2]
+              point.y = numbers[j + 3]
+
+              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
+            }
 
-            case 'Q':
-              numbers = parseFloats(data)
+            break
 
-              for (let j = 0, jl = numbers.length; j < jl; j += 4) {
-                path.quadraticCurveTo(numbers[j + 0], numbers[j + 1], numbers[j + 2], numbers[j + 3])
-                control.x = numbers[j + 0]
-                control.y = numbers[j + 1]
-                point.x = numbers[j + 2]
-                point.y = numbers[j + 3]
+          case 'Q':
+            numbers = parseFloats(data)
 
-                if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
-              }
+            for (let j = 0, jl = numbers.length; j < jl; j += 4) {
+              path.quadraticCurveTo(numbers[j + 0], numbers[j + 1], numbers[j + 2], numbers[j + 3])
+              control.x = numbers[j + 0]
+              control.y = numbers[j + 1]
+              point.x = numbers[j + 2]
+              point.y = numbers[j + 3]
 
-              break
+              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
+            }
 
-            case 'T':
-              numbers = parseFloats(data)
+            break
 
-              for (let j = 0, jl = numbers.length; j < jl; j += 2) {
-                const rx = getReflection(point.x, control.x)
-                const ry = getReflection(point.y, control.y)
-                path.quadraticCurveTo(rx, ry, numbers[j + 0], numbers[j + 1])
-                control.x = rx
-                control.y = ry
-                point.x = numbers[j + 0]
-                point.y = numbers[j + 1]
+          case 'T':
+            numbers = parseFloats(data)
 
-                if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
-              }
+            for (let j = 0, jl = numbers.length; j < jl; j += 2) {
+              const rx = getReflection(point.x, control.x)
+              const ry = getReflection(point.y, control.y)
+              path.quadraticCurveTo(rx, ry, numbers[j + 0], numbers[j + 1])
+              control.x = rx
+              control.y = ry
+              point.x = numbers[j + 0]
+              point.y = numbers[j + 1]
 
-              break
+              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
+            }
 
-            case 'A':
-              numbers = parseFloats(data, [3, 4], 7)
-
-              for (let j = 0, jl = numbers.length; j < jl; j += 7) {
-                // skip command if start point == end point
-                if (numbers[j + 5] == point.x && numbers[j + 6] == point.y) continue
-
-                const start = point.clone()
-                point.x = numbers[j + 5]
-                point.y = numbers[j + 6]
-                control.x = point.x
-                control.y = point.y
-                parseArcCommand(
-                  path,
-                  numbers[j],
-                  numbers[j + 1],
-                  numbers[j + 2],
-                  numbers[j + 3],
-                  numbers[j + 4],
-                  start,
-                  point,
-                )
-
-                if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
-              }
+            break
 
-              break
+          case 'A':
+            numbers = parseFloats(data, [3, 4], 7)
+
+            for (let j = 0, jl = numbers.length; j < jl; j += 7) {
+              // skip command if start point == end point
+              if (numbers[j + 5] == point.x && numbers[j + 6] == point.y) continue
+
+              const start = point.clone()
+              point.x = numbers[j + 5]
+              point.y = numbers[j + 6]
+              control.x = point.x
+              control.y = point.y
+              parseArcCommand(
+                path,
+                numbers[j],
+                numbers[j + 1],
+                numbers[j + 2],
+                numbers[j + 3],
+                numbers[j + 4],
+                start,
+                point,
+              )
+
+              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
+            }
 
-            case 'm':
-              numbers = parseFloats(data)
+            break
 
-              for (let j = 0, jl = numbers.length; j < jl; j += 2) {
-                point.x += numbers[j + 0]
-                point.y += numbers[j + 1]
-                control.x = point.x
-                control.y = point.y
+          case 'm':
+            numbers = parseFloats(data)
 
-                if (j === 0) {
-                  path.moveTo(point.x, point.y)
-                } else {
-                  path.lineTo(point.x, point.y)
-                }
+            for (let j = 0, jl = numbers.length; j < jl; j += 2) {
+              point.x += numbers[j + 0]
+              point.y += numbers[j + 1]
+              control.x = point.x
+              control.y = point.y
 
-                if (j === 0) firstPoint.copy(point)
+              if (j === 0) {
+                path.moveTo(point.x, point.y)
+              } else {
+                path.lineTo(point.x, point.y)
               }
 
-              break
-
-            case 'h':
-              numbers = parseFloats(data)
+              if (j === 0) firstPoint.copy(point)
+            }
 
-              for (let j = 0, jl = numbers.length; j < jl; j++) {
-                point.x += numbers[j]
-                control.x = point.x
-                control.y = point.y
-                path.lineTo(point.x, point.y)
+            break
 
-                if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
-              }
+          case 'h':
+            numbers = parseFloats(data)
 
-              break
+            for (let j = 0, jl = numbers.length; j < jl; j++) {
+              point.x += numbers[j]
+              control.x = point.x
+              control.y = point.y
+              path.lineTo(point.x, point.y)
 
-            case 'v':
-              numbers = parseFloats(data)
+              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
+            }
 
-              for (let j = 0, jl = numbers.length; j < jl; j++) {
-                point.y += numbers[j]
-                control.x = point.x
-                control.y = point.y
-                path.lineTo(point.x, point.y)
+            break
 
-                if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
-              }
+          case 'v':
+            numbers = parseFloats(data)
 
-              break
+            for (let j = 0, jl = numbers.length; j < jl; j++) {
+              point.y += numbers[j]
+              control.x = point.x
+              control.y = point.y
+              path.lineTo(point.x, point.y)
 
-            case 'l':
-              numbers = parseFloats(data)
+              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
+            }
 
-              for (let j = 0, jl = numbers.length; j < jl; j += 2) {
-                point.x += numbers[j + 0]
-                point.y += numbers[j + 1]
-                control.x = point.x
-                control.y = point.y
-                path.lineTo(point.x, point.y)
+            break
 
-                if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
-              }
+          case 'l':
+            numbers = parseFloats(data)
 
-              break
+            for (let j = 0, jl = numbers.length; j < jl; j += 2) {
+              point.x += numbers[j + 0]
+              point.y += numbers[j + 1]
+              control.x = point.x
+              control.y = point.y
+              path.lineTo(point.x, point.y)
 
-            case 'c':
-              numbers = parseFloats(data)
-
-              for (let j = 0, jl = numbers.length; j < jl; j += 6) {
-                path.bezierCurveTo(
-                  point.x + numbers[j + 0],
-                  point.y + numbers[j + 1],
-                  point.x + numbers[j + 2],
-                  point.y + numbers[j + 3],
-                  point.x + numbers[j + 4],
-                  point.y + numbers[j + 5],
-                )
-                control.x = point.x + numbers[j + 2]
-                control.y = point.y + numbers[j + 3]
-                point.x += numbers[j + 4]
-                point.y += numbers[j + 5]
-
-                if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
-              }
+              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
+            }
 
-              break
+            break
 
-            case 's':
-              numbers = parseFloats(data)
-
-              for (let j = 0, jl = numbers.length; j < jl; j += 4) {
-                path.bezierCurveTo(
-                  getReflection(point.x, control.x),
-                  getReflection(point.y, control.y),
-                  point.x + numbers[j + 0],
-                  point.y + numbers[j + 1],
-                  point.x + numbers[j + 2],
-                  point.y + numbers[j + 3],
-                )
-                control.x = point.x + numbers[j + 0]
-                control.y = point.y + numbers[j + 1]
-                point.x += numbers[j + 2]
-                point.y += numbers[j + 3]
-
-                if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
-              }
+          case 'c':
+            numbers = parseFloats(data)
+
+            for (let j = 0, jl = numbers.length; j < jl; j += 6) {
+              path.bezierCurveTo(
+                point.x + numbers[j + 0],
+                point.y + numbers[j + 1],
+                point.x + numbers[j + 2],
+                point.y + numbers[j + 3],
+                point.x + numbers[j + 4],
+                point.y + numbers[j + 5],
+              )
+              control.x = point.x + numbers[j + 2]
+              control.y = point.y + numbers[j + 3]
+              point.x += numbers[j + 4]
+              point.y += numbers[j + 5]
+
+              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
+            }
 
-              break
+            break
 
-            case 'q':
-              numbers = parseFloats(data)
-
-              for (let j = 0, jl = numbers.length; j < jl; j += 4) {
-                path.quadraticCurveTo(
-                  point.x + numbers[j + 0],
-                  point.y + numbers[j + 1],
-                  point.x + numbers[j + 2],
-                  point.y + numbers[j + 3],
-                )
-                control.x = point.x + numbers[j + 0]
-                control.y = point.y + numbers[j + 1]
-                point.x += numbers[j + 2]
-                point.y += numbers[j + 3]
-
-                if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
-              }
+          case 's':
+            numbers = parseFloats(data)
+
+            for (let j = 0, jl = numbers.length; j < jl; j += 4) {
+              path.bezierCurveTo(
+                getReflection(point.x, control.x),
+                getReflection(point.y, control.y),
+                point.x + numbers[j + 0],
+                point.y + numbers[j + 1],
+                point.x + numbers[j + 2],
+                point.y + numbers[j + 3],
+              )
+              control.x = point.x + numbers[j + 0]
+              control.y = point.y + numbers[j + 1]
+              point.x += numbers[j + 2]
+              point.y += numbers[j + 3]
+
+              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
+            }
 
-              break
+            break
 
-            case 't':
-              numbers = parseFloats(data)
+          case 'q':
+            numbers = parseFloats(data)
+
+            for (let j = 0, jl = numbers.length; j < jl; j += 4) {
+              path.quadraticCurveTo(
+                point.x + numbers[j + 0],
+                point.y + numbers[j + 1],
+                point.x + numbers[j + 2],
+                point.y + numbers[j + 3],
+              )
+              control.x = point.x + numbers[j + 0]
+              control.y = point.y + numbers[j + 1]
+              point.x += numbers[j + 2]
+              point.y += numbers[j + 3]
+
+              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
+            }
 
-              for (let j = 0, jl = numbers.length; j < jl; j += 2) {
-                const rx = getReflection(point.x, control.x)
-                const ry = getReflection(point.y, control.y)
-                path.quadraticCurveTo(rx, ry, point.x + numbers[j + 0], point.y + numbers[j + 1])
-                control.x = rx
-                control.y = ry
-                point.x = point.x + numbers[j + 0]
-                point.y = point.y + numbers[j + 1]
+            break
 
-                if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
-              }
+          case 't':
+            numbers = parseFloats(data)
 
-              break
+            for (let j = 0, jl = numbers.length; j < jl; j += 2) {
+              const rx = getReflection(point.x, control.x)
+              const ry = getReflection(point.y, control.y)
+              path.quadraticCurveTo(rx, ry, point.x + numbers[j + 0], point.y + numbers[j + 1])
+              control.x = rx
+              control.y = ry
+              point.x = point.x + numbers[j + 0]
+              point.y = point.y + numbers[j + 1]
 
-            case 'a':
-              numbers = parseFloats(data, [3, 4], 7)
-
-              for (let j = 0, jl = numbers.length; j < jl; j += 7) {
-                // skip command if no displacement
-                if (numbers[j + 5] == 0 && numbers[j + 6] == 0) continue
-
-                const start = point.clone()
-                point.x += numbers[j + 5]
-                point.y += numbers[j + 6]
-                control.x = point.x
-                control.y = point.y
-                parseArcCommand(
-                  path,
-                  numbers[j],
-                  numbers[j + 1],
-                  numbers[j + 2],
-                  numbers[j + 3],
-                  numbers[j + 4],
-                  start,
-                  point,
-                )
-
-                if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
-              }
+              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
+            }
 
-              break
+            break
 
-            case 'Z':
-            case 'z':
-              path.currentPath.autoClose = true
+          case 'a':
+            numbers = parseFloats(data, [3, 4], 7)
+
+            for (let j = 0, jl = numbers.length; j < jl; j += 7) {
+              // skip command if no displacement
+              if (numbers[j + 5] == 0 && numbers[j + 6] == 0) continue
+
+              const start = point.clone()
+              point.x += numbers[j + 5]
+              point.y += numbers[j + 6]
+              control.x = point.x
+              control.y = point.y
+              parseArcCommand(
+                path,
+                numbers[j],
+                numbers[j + 1],
+                numbers[j + 2],
+                numbers[j + 3],
+                numbers[j + 4],
+                start,
+                point,
+              )
+
+              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
+            }
 
-              if (path.currentPath.curves.length > 0) {
-                // Reset point to beginning of Path
-                point.copy(firstPoint)
-                path.currentPath.currentPoint.copy(point)
-                isFirstPoint = true
-              }
+            break
 
-              break
+          case 'Z':
+          case 'z':
+            path.currentPath.autoClose = true
 
-            default:
-              console.warn(command)
-          }
+            if (path.currentPath.curves.length > 0) {
+              // Reset point to beginning of Path
+              point.copy(firstPoint)
+              path.currentPath.currentPoint.copy(point)
+              isFirstPoint = true
+            }
 
-          // console.log( type, parseFloats( data ), parseFloats( data ).length  )
+            break
 
-          doSetFirstPoint = false
+          default:
+            console.warn(command)
         }
 
-        return path
+        // console.log( type, parseFloats( data ), parseFloats( data ).length  )
+
+        doSetFirstPoint = false
       }
 
-      function parseCSSStylesheet(node) {
-        if (!node.sheet || !node.sheet.cssRules || !node.sheet.cssRules.length) return
+      return path
+    }
 
-        for (let i = 0; i < node.sheet.cssRules.length; i++) {
-          const stylesheet = node.sheet.cssRules[i]
+    function parseCSSStylesheet(node) {
+      if (!node.sheet || !node.sheet.cssRules || !node.sheet.cssRules.length) return
 
-          if (stylesheet.type !== 1) continue
+      for (let i = 0; i < node.sheet.cssRules.length; i++) {
+        const stylesheet = node.sheet.cssRules[i]
 
-          const selectorList = stylesheet.selectorText
-            .split(/,/gm)
-            .filter(Boolean)
-            .map((i) => i.trim())
+        if (stylesheet.type !== 1) continue
 
-          for (let j = 0; j < selectorList.length; j++) {
-            // Remove empty rules
-            const definitions = Object.fromEntries(Object.entries(stylesheet.style).filter(([, v]) => v !== ''))
+        const selectorList = stylesheet.selectorText
+          .split(/,/gm)
+          .filter(Boolean)
+          .map((i) => i.trim())
 
-            stylesheets[selectorList[j]] = Object.assign(stylesheets[selectorList[j]] || {}, definitions)
-          }
+        for (let j = 0; j < selectorList.length; j++) {
+          // Remove empty rules
+          const definitions = Object.fromEntries(Object.entries(stylesheet.style).filter(([, v]) => v !== ''))
+
+          stylesheets[selectorList[j]] = Object.assign(stylesheets[selectorList[j]] || {}, definitions)
         }
       }
+    }
 
-      /**
-       * https://www.w3.org/TR/SVG/implnote.html#ArcImplementationNotes
-       * https://mortoray.com/2017/02/16/rendering-an-svg-elliptical-arc-as-bezier-curves/ Appendix: Endpoint to center arc conversion
-       * From
-       * rx ry x-axis-rotation large-arc-flag sweep-flag x y
-       * To
-       * aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation
-       */
-
-      function parseArcCommand(path, rx, ry, x_axis_rotation, large_arc_flag, sweep_flag, start, end) {
-        if (rx == 0 || ry == 0) {
-          // draw a line if either of the radii == 0
-          path.lineTo(end.x, end.y)
-          return
-        }
+    /**
+     * https://www.w3.org/TR/SVG/implnote.html#ArcImplementationNotes
+     * https://mortoray.com/2017/02/16/rendering-an-svg-elliptical-arc-as-bezier-curves/ Appendix: Endpoint to center arc conversion
+     * From
+     * rx ry x-axis-rotation large-arc-flag sweep-flag x y
+     * To
+     * aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation
+     */
+
+    function parseArcCommand(path, rx, ry, x_axis_rotation, large_arc_flag, sweep_flag, start, end) {
+      if (rx == 0 || ry == 0) {
+        // draw a line if either of the radii == 0
+        path.lineTo(end.x, end.y)
+        return
+      }
 
-        x_axis_rotation = (x_axis_rotation * Math.PI) / 180
-
-        // Ensure radii are positive
-        rx = Math.abs(rx)
-        ry = Math.abs(ry)
-
-        // Compute (x1', y1')
-        const dx2 = (start.x - end.x) / 2.0
-        const dy2 = (start.y - end.y) / 2.0
-        const x1p = Math.cos(x_axis_rotation) * dx2 + Math.sin(x_axis_rotation) * dy2
-        const y1p = -Math.sin(x_axis_rotation) * dx2 + Math.cos(x_axis_rotation) * dy2
-
-        // Compute (cx', cy')
-        let rxs = rx * rx
-        let rys = ry * ry
-        const x1ps = x1p * x1p
-        const y1ps = y1p * y1p
-
-        // Ensure radii are large enough
-        const cr = x1ps / rxs + y1ps / rys
-
-        if (cr > 1) {
-          // scale up rx,ry equally so cr == 1
-          const s = Math.sqrt(cr)
-          rx = s * rx
-          ry = s * ry
-          rxs = rx * rx
-          rys = ry * ry
-        }
+      x_axis_rotation = (x_axis_rotation * Math.PI) / 180
+
+      // Ensure radii are positive
+      rx = Math.abs(rx)
+      ry = Math.abs(ry)
+
+      // Compute (x1', y1')
+      const dx2 = (start.x - end.x) / 2.0
+      const dy2 = (start.y - end.y) / 2.0
+      const x1p = Math.cos(x_axis_rotation) * dx2 + Math.sin(x_axis_rotation) * dy2
+      const y1p = -Math.sin(x_axis_rotation) * dx2 + Math.cos(x_axis_rotation) * dy2
+
+      // Compute (cx', cy')
+      let rxs = rx * rx
+      let rys = ry * ry
+      const x1ps = x1p * x1p
+      const y1ps = y1p * y1p
+
+      // Ensure radii are large enough
+      const cr = x1ps / rxs + y1ps / rys
+
+      if (cr > 1) {
+        // scale up rx,ry equally so cr == 1
+        const s = Math.sqrt(cr)
+        rx = s * rx
+        ry = s * ry
+        rxs = rx * rx
+        rys = ry * ry
+      }
 
-        const dq = rxs * y1ps + rys * x1ps
-        const pq = (rxs * rys - dq) / dq
-        let q = Math.sqrt(Math.max(0, pq))
-        if (large_arc_flag === sweep_flag) q = -q
-        const cxp = (q * rx * y1p) / ry
-        const cyp = (-q * ry * x1p) / rx
-
-        // Step 3: Compute (cx, cy) from (cx', cy')
-        const cx = Math.cos(x_axis_rotation) * cxp - Math.sin(x_axis_rotation) * cyp + (start.x + end.x) / 2
-        const cy = Math.sin(x_axis_rotation) * cxp + Math.cos(x_axis_rotation) * cyp + (start.y + end.y) / 2
-
-        // Step 4: Compute θ1 and Δθ
-        const theta = svgAngle(1, 0, (x1p - cxp) / rx, (y1p - cyp) / ry)
-        const delta = svgAngle((x1p - cxp) / rx, (y1p - cyp) / ry, (-x1p - cxp) / rx, (-y1p - cyp) / ry) % (Math.PI * 2)
-
-        path.currentPath.absellipse(cx, cy, rx, ry, theta, theta + delta, sweep_flag === 0, x_axis_rotation)
-      }
-
-      function svgAngle(ux, uy, vx, vy) {
-        const dot = ux * vx + uy * vy
-        const len = Math.sqrt(ux * ux + uy * uy) * Math.sqrt(vx * vx + vy * vy)
-        let ang = Math.acos(Math.max(-1, Math.min(1, dot / len))) // floating point precision, slightly over values appear
-        if (ux * vy - uy * vx < 0) ang = -ang
-        return ang
-      }
-
-      /*
-       * According to https://www.w3.org/TR/SVG/shapes.html#RectElementRXAttribute
-       * rounded corner should be rendered to elliptical arc, but bezier curve does the job well enough
-       */
-      function parseRectNode(node) {
-        const x = parseFloatWithUnits(node.getAttribute('x') || 0)
-        const y = parseFloatWithUnits(node.getAttribute('y') || 0)
-        const rx = parseFloatWithUnits(node.getAttribute('rx') || node.getAttribute('ry') || 0)
-        const ry = parseFloatWithUnits(node.getAttribute('ry') || node.getAttribute('rx') || 0)
-        const w = parseFloatWithUnits(node.getAttribute('width'))
-        const h = parseFloatWithUnits(node.getAttribute('height'))
-
-        // Ellipse arc to Bezier approximation Coefficient (Inversed). See:
-        // https://spencermortensen.com/articles/bezier-circle/
-        const bci = 1 - 0.551915024494
-
-        const path = new ShapePath()
-
-        // top left
-        path.moveTo(x + rx, y)
-
-        // top right
-        path.lineTo(x + w - rx, y)
-        if (rx !== 0 || ry !== 0) {
-          path.bezierCurveTo(x + w - rx * bci, y, x + w, y + ry * bci, x + w, y + ry)
-        }
+      const dq = rxs * y1ps + rys * x1ps
+      const pq = (rxs * rys - dq) / dq
+      let q = Math.sqrt(Math.max(0, pq))
+      if (large_arc_flag === sweep_flag) q = -q
+      const cxp = (q * rx * y1p) / ry
+      const cyp = (-q * ry * x1p) / rx
 
-        // bottom right
-        path.lineTo(x + w, y + h - ry)
-        if (rx !== 0 || ry !== 0) {
-          path.bezierCurveTo(x + w, y + h - ry * bci, x + w - rx * bci, y + h, x + w - rx, y + h)
-        }
+      // Step 3: Compute (cx, cy) from (cx', cy')
+      const cx = Math.cos(x_axis_rotation) * cxp - Math.sin(x_axis_rotation) * cyp + (start.x + end.x) / 2
+      const cy = Math.sin(x_axis_rotation) * cxp + Math.cos(x_axis_rotation) * cyp + (start.y + end.y) / 2
 
-        // bottom left
-        path.lineTo(x + rx, y + h)
-        if (rx !== 0 || ry !== 0) {
-          path.bezierCurveTo(x + rx * bci, y + h, x, y + h - ry * bci, x, y + h - ry)
-        }
+      // Step 4: Compute θ1 and Δθ
+      const theta = svgAngle(1, 0, (x1p - cxp) / rx, (y1p - cyp) / ry)
+      const delta = svgAngle((x1p - cxp) / rx, (y1p - cyp) / ry, (-x1p - cxp) / rx, (-y1p - cyp) / ry) % (Math.PI * 2)
 
-        // back to top left
-        path.lineTo(x, y + ry)
-        if (rx !== 0 || ry !== 0) {
-          path.bezierCurveTo(x, y + ry * bci, x + rx * bci, y, x + rx, y)
-        }
+      path.currentPath.absellipse(cx, cy, rx, ry, theta, theta + delta, sweep_flag === 0, x_axis_rotation)
+    }
 
-        return path
+    function svgAngle(ux, uy, vx, vy) {
+      const dot = ux * vx + uy * vy
+      const len = Math.sqrt(ux * ux + uy * uy) * Math.sqrt(vx * vx + vy * vy)
+      let ang = Math.acos(Math.max(-1, Math.min(1, dot / len))) // floating point precision, slightly over values appear
+      if (ux * vy - uy * vx < 0) ang = -ang
+      return ang
+    }
+
+    /*
+     * According to https://www.w3.org/TR/SVG/shapes.html#RectElementRXAttribute
+     * rounded corner should be rendered to elliptical arc, but bezier curve does the job well enough
+     */
+    function parseRectNode(node) {
+      const x = parseFloatWithUnits(node.getAttribute('x') || 0)
+      const y = parseFloatWithUnits(node.getAttribute('y') || 0)
+      const rx = parseFloatWithUnits(node.getAttribute('rx') || node.getAttribute('ry') || 0)
+      const ry = parseFloatWithUnits(node.getAttribute('ry') || node.getAttribute('rx') || 0)
+      const w = parseFloatWithUnits(node.getAttribute('width'))
+      const h = parseFloatWithUnits(node.getAttribute('height'))
+
+      // Ellipse arc to Bezier approximation Coefficient (Inversed). See:
+      // https://spencermortensen.com/articles/bezier-circle/
+      const bci = 1 - 0.551915024494
+
+      const path = new ShapePath()
+
+      // top left
+      path.moveTo(x + rx, y)
+
+      // top right
+      path.lineTo(x + w - rx, y)
+      if (rx !== 0 || ry !== 0) {
+        path.bezierCurveTo(x + w - rx * bci, y, x + w, y + ry * bci, x + w, y + ry)
       }
 
-      function parsePolygonNode(node) {
-        function iterator(match, a, b) {
-          const x = parseFloatWithUnits(a)
-          const y = parseFloatWithUnits(b)
+      // bottom right
+      path.lineTo(x + w, y + h - ry)
+      if (rx !== 0 || ry !== 0) {
+        path.bezierCurveTo(x + w, y + h - ry * bci, x + w - rx * bci, y + h, x + w - rx, y + h)
+      }
 
-          if (index === 0) {
-            path.moveTo(x, y)
-          } else {
-            path.lineTo(x, y)
-          }
+      // bottom left
+      path.lineTo(x + rx, y + h)
+      if (rx !== 0 || ry !== 0) {
+        path.bezierCurveTo(x + rx * bci, y + h, x, y + h - ry * bci, x, y + h - ry)
+      }
+
+      // back to top left
+      path.lineTo(x, y + ry)
+      if (rx !== 0 || ry !== 0) {
+        path.bezierCurveTo(x, y + ry * bci, x + rx * bci, y, x + rx, y)
+      }
+
+      return path
+    }
 
-          index++
+    function parsePolygonNode(node) {
+      function iterator(match, a, b) {
+        const x = parseFloatWithUnits(a)
+        const y = parseFloatWithUnits(b)
+
+        if (index === 0) {
+          path.moveTo(x, y)
+        } else {
+          path.lineTo(x, y)
         }
 
-        const regex = /([+-]?\d*\.?\d+(?:e[+-]?\d+)?)(?:,|\s)([+-]?\d*\.?\d+(?:e[+-]?\d+)?)/g
+        index++
+      }
 
-        const path = new ShapePath()
+      const regex = /([+-]?\d*\.?\d+(?:e[+-]?\d+)?)(?:,|\s)([+-]?\d*\.?\d+(?:e[+-]?\d+)?)/g
 
-        let index = 0
+      const path = new ShapePath()
 
-        node.getAttribute('points').replace(regex, iterator)
+      let index = 0
 
-        path.currentPath.autoClose = true
+      node.getAttribute('points').replace(regex, iterator)
 
-        return path
-      }
+      path.currentPath.autoClose = true
 
-      function parsePolylineNode(node) {
-        function iterator(match, a, b) {
-          const x = parseFloatWithUnits(a)
-          const y = parseFloatWithUnits(b)
+      return path
+    }
 
-          if (index === 0) {
-            path.moveTo(x, y)
-          } else {
-            path.lineTo(x, y)
-          }
+    function parsePolylineNode(node) {
+      function iterator(match, a, b) {
+        const x = parseFloatWithUnits(a)
+        const y = parseFloatWithUnits(b)
 
-          index++
+        if (index === 0) {
+          path.moveTo(x, y)
+        } else {
+          path.lineTo(x, y)
         }
 
-        const regex = /([+-]?\d*\.?\d+(?:e[+-]?\d+)?)(?:,|\s)([+-]?\d*\.?\d+(?:e[+-]?\d+)?)/g
+        index++
+      }
 
-        const path = new ShapePath()
+      const regex = /([+-]?\d*\.?\d+(?:e[+-]?\d+)?)(?:,|\s)([+-]?\d*\.?\d+(?:e[+-]?\d+)?)/g
 
-        let index = 0
+      const path = new ShapePath()
 
-        node.getAttribute('points').replace(regex, iterator)
+      let index = 0
 
-        path.currentPath.autoClose = false
+      node.getAttribute('points').replace(regex, iterator)
 
-        return path
-      }
+      path.currentPath.autoClose = false
 
-      function parseCircleNode(node) {
-        const x = parseFloatWithUnits(node.getAttribute('cx') || 0)
-        const y = parseFloatWithUnits(node.getAttribute('cy') || 0)
-        const r = parseFloatWithUnits(node.getAttribute('r') || 0)
+      return path
+    }
 
-        const subpath = new Path()
-        subpath.absarc(x, y, r, 0, Math.PI * 2)
+    function parseCircleNode(node) {
+      const x = parseFloatWithUnits(node.getAttribute('cx') || 0)
+      const y = parseFloatWithUnits(node.getAttribute('cy') || 0)
+      const r = parseFloatWithUnits(node.getAttribute('r') || 0)
 
-        const path = new ShapePath()
-        path.subPaths.push(subpath)
+      const subpath = new Path()
+      subpath.absarc(x, y, r, 0, Math.PI * 2)
 
-        return path
-      }
+      const path = new ShapePath()
+      path.subPaths.push(subpath)
 
-      function parseEllipseNode(node) {
-        const x = parseFloatWithUnits(node.getAttribute('cx') || 0)
-        const y = parseFloatWithUnits(node.getAttribute('cy') || 0)
-        const rx = parseFloatWithUnits(node.getAttribute('rx') || 0)
-        const ry = parseFloatWithUnits(node.getAttribute('ry') || 0)
+      return path
+    }
 
-        const subpath = new Path()
-        subpath.absellipse(x, y, rx, ry, 0, Math.PI * 2)
+    function parseEllipseNode(node) {
+      const x = parseFloatWithUnits(node.getAttribute('cx') || 0)
+      const y = parseFloatWithUnits(node.getAttribute('cy') || 0)
+      const rx = parseFloatWithUnits(node.getAttribute('rx') || 0)
+      const ry = parseFloatWithUnits(node.getAttribute('ry') || 0)
 
-        const path = new ShapePath()
-        path.subPaths.push(subpath)
+      const subpath = new Path()
+      subpath.absellipse(x, y, rx, ry, 0, Math.PI * 2)
 
-        return path
-      }
+      const path = new ShapePath()
+      path.subPaths.push(subpath)
 
-      function parseLineNode(node) {
-        const x1 = parseFloatWithUnits(node.getAttribute('x1') || 0)
-        const y1 = parseFloatWithUnits(node.getAttribute('y1') || 0)
-        const x2 = parseFloatWithUnits(node.getAttribute('x2') || 0)
-        const y2 = parseFloatWithUnits(node.getAttribute('y2') || 0)
+      return path
+    }
 
-        const path = new ShapePath()
-        path.moveTo(x1, y1)
-        path.lineTo(x2, y2)
-        path.currentPath.autoClose = false
+    function parseLineNode(node) {
+      const x1 = parseFloatWithUnits(node.getAttribute('x1') || 0)
+      const y1 = parseFloatWithUnits(node.getAttribute('y1') || 0)
+      const x2 = parseFloatWithUnits(node.getAttribute('x2') || 0)
+      const y2 = parseFloatWithUnits(node.getAttribute('y2') || 0)
 
-        return path
-      }
+      const path = new ShapePath()
+      path.moveTo(x1, y1)
+      path.lineTo(x2, y2)
+      path.currentPath.autoClose = false
 
-      //
+      return path
+    }
 
-      function parseStyle(node, style) {
-        style = Object.assign({}, style) // clone style
+    //
 
-        let stylesheetStyles = {}
+    function parseStyle(node, style) {
+      style = Object.assign({}, style) // clone style
 
-        if (node.hasAttribute('class')) {
-          const classSelectors = node
-            .getAttribute('class')
-            .split(/\s/)
-            .filter(Boolean)
-            .map((i) => i.trim())
+      let stylesheetStyles = {}
 
-          for (let i = 0; i < classSelectors.length; i++) {
-            stylesheetStyles = Object.assign(stylesheetStyles, stylesheets['.' + classSelectors[i]])
-          }
-        }
+      if (node.hasAttribute('class')) {
+        const classSelectors = node
+          .getAttribute('class')
+          .split(/\s/)
+          .filter(Boolean)
+          .map((i) => i.trim())
 
-        if (node.hasAttribute('id')) {
-          stylesheetStyles = Object.assign(stylesheetStyles, stylesheets['#' + node.getAttribute('id')])
+        for (let i = 0; i < classSelectors.length; i++) {
+          stylesheetStyles = Object.assign(stylesheetStyles, stylesheets['.' + classSelectors[i]])
         }
+      }
 
-        function addStyle(svgName, jsName, adjustFunction) {
-          if (adjustFunction === undefined)
-            adjustFunction = function copy(v) {
-              if (v.startsWith('url')) console.warn('SVGLoader: url access in attributes is not implemented.')
-
-              return v
-            }
+      if (node.hasAttribute('id')) {
+        stylesheetStyles = Object.assign(stylesheetStyles, stylesheets['#' + node.getAttribute('id')])
+      }
 
-          if (node.hasAttribute(svgName)) style[jsName] = adjustFunction(node.getAttribute(svgName))
-          if (stylesheetStyles[svgName]) style[jsName] = adjustFunction(stylesheetStyles[svgName])
-          if (node.style && node.style[svgName] !== '') style[jsName] = adjustFunction(node.style[svgName])
-        }
+      function addStyle(svgName, jsName, adjustFunction) {
+        if (adjustFunction === undefined)
+          adjustFunction = function copy(v) {
+            if (v.startsWith('url')) console.warn('SVGLoader: url access in attributes is not implemented.')
 
-        function clamp(v) {
-          return Math.max(0, Math.min(1, parseFloatWithUnits(v)))
-        }
+            return v
+          }
 
-        function positive(v) {
-          return Math.max(0, parseFloatWithUnits(v))
-        }
+        if (node.hasAttribute(svgName)) style[jsName] = adjustFunction(node.getAttribute(svgName))
+        if (stylesheetStyles[svgName]) style[jsName] = adjustFunction(stylesheetStyles[svgName])
+        if (node.style && node.style[svgName] !== '') style[jsName] = adjustFunction(node.style[svgName])
+      }
 
-        addStyle('fill', 'fill')
-        addStyle('fill-opacity', 'fillOpacity', clamp)
-        addStyle('fill-rule', 'fillRule')
-        addStyle('opacity', 'opacity', clamp)
-        addStyle('stroke', 'stroke')
-        addStyle('stroke-opacity', 'strokeOpacity', clamp)
-        addStyle('stroke-width', 'strokeWidth', positive)
-        addStyle('stroke-linejoin', 'strokeLineJoin')
-        addStyle('stroke-linecap', 'strokeLineCap')
-        addStyle('stroke-miterlimit', 'strokeMiterLimit', positive)
-        addStyle('visibility', 'visibility')
+      function clamp(v) {
+        return Math.max(0, Math.min(1, parseFloatWithUnits(v)))
+      }
 
-        return style
+      function positive(v) {
+        return Math.max(0, parseFloatWithUnits(v))
       }
 
-      // http://www.w3.org/TR/SVG11/implnote.html#PathElementImplementationNotes
+      addStyle('fill', 'fill')
+      addStyle('fill-opacity', 'fillOpacity', clamp)
+      addStyle('fill-rule', 'fillRule')
+      addStyle('opacity', 'opacity', clamp)
+      addStyle('stroke', 'stroke')
+      addStyle('stroke-opacity', 'strokeOpacity', clamp)
+      addStyle('stroke-width', 'strokeWidth', positive)
+      addStyle('stroke-linejoin', 'strokeLineJoin')
+      addStyle('stroke-linecap', 'strokeLineCap')
+      addStyle('stroke-miterlimit', 'strokeMiterLimit', positive)
+      addStyle('visibility', 'visibility')
+
+      return style
+    }
+
+    // http://www.w3.org/TR/SVG11/implnote.html#PathElementImplementationNotes
+
+    function getReflection(a, b) {
+      return a - (b - a)
+    }
+
+    // from https://github.com/ppvg/svg-numbers (MIT License)
 
-      function getReflection(a, b) {
-        return a - (b - a)
+    function parseFloats(input, flags, stride) {
+      if (typeof input !== 'string') {
+        throw new TypeError('Invalid input: ' + typeof input)
       }
 
-      // from https://github.com/ppvg/svg-numbers (MIT License)
+      // Character groups
+      const RE = {
+        SEPARATOR: /[ \t\r\n\,.\-+]/,
+        WHITESPACE: /[ \t\r\n]/,
+        DIGIT: /[\d]/,
+        SIGN: /[-+]/,
+        POINT: /\./,
+        COMMA: /,/,
+        EXP: /e/i,
+        FLAGS: /[01]/,
+      }
 
-      function parseFloats(input, flags, stride) {
-        if (typeof input !== 'string') {
-          throw new TypeError('Invalid input: ' + typeof input)
-        }
+      // States
+      const SEP = 0
+      const INT = 1
+      const FLOAT = 2
+      const EXP = 3
+
+      let state = SEP
+      let seenComma = true
+      let number = '',
+        exponent = ''
+      const result = []
+
+      function throwSyntaxError(current, i, partial) {
+        const error = new SyntaxError('Unexpected character "' + current + '" at index ' + i + '.')
+        error.partial = partial
+        throw error
+      }
 
-        // Character groups
-        const RE = {
-          SEPARATOR: /[ \t\r\n\,.\-+]/,
-          WHITESPACE: /[ \t\r\n]/,
-          DIGIT: /[\d]/,
-          SIGN: /[-+]/,
-          POINT: /\./,
-          COMMA: /,/,
-          EXP: /e/i,
-          FLAGS: /[01]/,
+      function newNumber() {
+        if (number !== '') {
+          if (exponent === '') result.push(Number(number))
+          else result.push(Number(number) * Math.pow(10, Number(exponent)))
         }
 
-        // States
-        const SEP = 0
-        const INT = 1
-        const FLOAT = 2
-        const EXP = 3
-
-        let state = SEP
-        let seenComma = true
-        let number = '',
-          exponent = ''
-        const result = []
-
-        function throwSyntaxError(current, i, partial) {
-          const error = new SyntaxError('Unexpected character "' + current + '" at index ' + i + '.')
-          error.partial = partial
-          throw error
-        }
+        number = ''
+        exponent = ''
+      }
 
-        function newNumber() {
-          if (number !== '') {
-            if (exponent === '') result.push(Number(number))
-            else result.push(Number(number) * Math.pow(10, Number(exponent)))
-          }
+      let current
+      const length = input.length
 
-          number = ''
-          exponent = ''
-        }
+      for (let i = 0; i < length; i++) {
+        current = input[i]
 
-        let current
-        const length = input.length
+        // check for flags
+        if (Array.isArray(flags) && flags.includes(result.length % stride) && RE.FLAGS.test(current)) {
+          state = INT
+          number = current
+          newNumber()
+          continue
+        }
 
-        for (let i = 0; i < length; i++) {
-          current = input[i]
+        // parse until next number
+        if (state === SEP) {
+          // eat whitespace
+          if (RE.WHITESPACE.test(current)) {
+            continue
+          }
 
-          // check for flags
-          if (Array.isArray(flags) && flags.includes(result.length % stride) && RE.FLAGS.test(current)) {
+          // start new number
+          if (RE.DIGIT.test(current) || RE.SIGN.test(current)) {
             state = INT
             number = current
-            newNumber()
             continue
           }
 
-          // parse until next number
-          if (state === SEP) {
-            // eat whitespace
-            if (RE.WHITESPACE.test(current)) {
-              continue
-            }
-
-            // start new number
-            if (RE.DIGIT.test(current) || RE.SIGN.test(current)) {
-              state = INT
-              number = current
-              continue
-            }
+          if (RE.POINT.test(current)) {
+            state = FLOAT
+            number = current
+            continue
+          }
 
-            if (RE.POINT.test(current)) {
-              state = FLOAT
-              number = current
-              continue
+          // throw on double commas (e.g. "1, , 2")
+          if (RE.COMMA.test(current)) {
+            if (seenComma) {
+              throwSyntaxError(current, i, result)
             }
 
-            // throw on double commas (e.g. "1, , 2")
-            if (RE.COMMA.test(current)) {
-              if (seenComma) {
-                throwSyntaxError(current, i, result)
-              }
+            seenComma = true
+          }
+        }
 
-              seenComma = true
-            }
+        // parse integer part
+        if (state === INT) {
+          if (RE.DIGIT.test(current)) {
+            number += current
+            continue
           }
 
-          // parse integer part
-          if (state === INT) {
-            if (RE.DIGIT.test(current)) {
-              number += current
-              continue
-            }
+          if (RE.POINT.test(current)) {
+            number += current
+            state = FLOAT
+            continue
+          }
 
-            if (RE.POINT.test(current)) {
-              number += current
-              state = FLOAT
-              continue
-            }
+          if (RE.EXP.test(current)) {
+            state = EXP
+            continue
+          }
 
-            if (RE.EXP.test(current)) {
-              state = EXP
-              continue
-            }
+          // throw on double signs ("-+1"), but not on sign as separator ("-1-2")
+          if (RE.SIGN.test(current) && number.length === 1 && RE.SIGN.test(number[0])) {
+            throwSyntaxError(current, i, result)
+          }
+        }
 
-            // throw on double signs ("-+1"), but not on sign as separator ("-1-2")
-            if (RE.SIGN.test(current) && number.length === 1 && RE.SIGN.test(number[0])) {
-              throwSyntaxError(current, i, result)
-            }
+        // parse decimal part
+        if (state === FLOAT) {
+          if (RE.DIGIT.test(current)) {
+            number += current
+            continue
           }
 
-          // parse decimal part
-          if (state === FLOAT) {
-            if (RE.DIGIT.test(current)) {
-              number += current
-              continue
-            }
+          if (RE.EXP.test(current)) {
+            state = EXP
+            continue
+          }
 
-            if (RE.EXP.test(current)) {
-              state = EXP
-              continue
-            }
+          // throw on double decimal points (e.g. "1..2")
+          if (RE.POINT.test(current) && number[number.length - 1] === '.') {
+            throwSyntaxError(current, i, result)
+          }
+        }
 
-            // throw on double decimal points (e.g. "1..2")
-            if (RE.POINT.test(current) && number[number.length - 1] === '.') {
-              throwSyntaxError(current, i, result)
-            }
+        // parse exponent part
+        if (state === EXP) {
+          if (RE.DIGIT.test(current)) {
+            exponent += current
+            continue
           }
 
-          // parse exponent part
-          if (state === EXP) {
-            if (RE.DIGIT.test(current)) {
+          if (RE.SIGN.test(current)) {
+            if (exponent === '') {
               exponent += current
               continue
             }
 
-            if (RE.SIGN.test(current)) {
-              if (exponent === '') {
-                exponent += current
-                continue
-              }
-
-              if (exponent.length === 1 && RE.SIGN.test(exponent)) {
-                throwSyntaxError(current, i, result)
-              }
+            if (exponent.length === 1 && RE.SIGN.test(exponent)) {
+              throwSyntaxError(current, i, result)
             }
           }
-
-          // end of number
-          if (RE.WHITESPACE.test(current)) {
-            newNumber()
-            state = SEP
-            seenComma = false
-          } else if (RE.COMMA.test(current)) {
-            newNumber()
-            state = SEP
-            seenComma = true
-          } else if (RE.SIGN.test(current)) {
-            newNumber()
-            state = INT
-            number = current
-          } else if (RE.POINT.test(current)) {
-            newNumber()
-            state = FLOAT
-            number = current
-          } else {
-            throwSyntaxError(current, i, result)
-          }
         }
 
-        // add the last number found (if any)
-        newNumber()
-
-        return result
-      }
-
-      // Units
-
-      const units = ['mm', 'cm', 'in', 'pt', 'pc', 'px']
-
-      // Conversion: [ fromUnit ][ toUnit ] (-1 means dpi dependent)
-      const unitConversion = {
-        mm: {
-          mm: 1,
-          cm: 0.1,
-          in: 1 / 25.4,
-          pt: 72 / 25.4,
-          pc: 6 / 25.4,
-          px: -1,
-        },
-        cm: {
-          mm: 10,
-          cm: 1,
-          in: 1 / 2.54,
-          pt: 72 / 2.54,
-          pc: 6 / 2.54,
-          px: -1,
-        },
-        in: {
-          mm: 25.4,
-          cm: 2.54,
-          in: 1,
-          pt: 72,
-          pc: 6,
-          px: -1,
-        },
-        pt: {
-          mm: 25.4 / 72,
-          cm: 2.54 / 72,
-          in: 1 / 72,
-          pt: 1,
-          pc: 6 / 72,
-          px: -1,
-        },
-        pc: {
-          mm: 25.4 / 6,
-          cm: 2.54 / 6,
-          in: 1 / 6,
-          pt: 72 / 6,
-          pc: 1,
-          px: -1,
-        },
-        px: {
-          px: 1,
-        },
-      }
-
-      function parseFloatWithUnits(string) {
-        let theUnit = 'px'
-
-        if (typeof string === 'string' || string instanceof String) {
-          for (let i = 0, n = units.length; i < n; i++) {
-            const u = units[i]
-
-            if (string.endsWith(u)) {
-              theUnit = u
-              string = string.substring(0, string.length - u.length)
-              break
-            }
-          }
+        // end of number
+        if (RE.WHITESPACE.test(current)) {
+          newNumber()
+          state = SEP
+          seenComma = false
+        } else if (RE.COMMA.test(current)) {
+          newNumber()
+          state = SEP
+          seenComma = true
+        } else if (RE.SIGN.test(current)) {
+          newNumber()
+          state = INT
+          number = current
+        } else if (RE.POINT.test(current)) {
+          newNumber()
+          state = FLOAT
+          number = current
+        } else {
+          throwSyntaxError(current, i, result)
         }
+      }
+
+      // add the last number found (if any)
+      newNumber()
 
-        let scale = undefined
+      return result
+    }
 
-        if (theUnit === 'px' && scope.defaultUnit !== 'px') {
-          // Conversion scale from  pixels to inches, then to default units
+    // Units
+
+    const units = ['mm', 'cm', 'in', 'pt', 'pc', 'px']
+
+    // Conversion: [ fromUnit ][ toUnit ] (-1 means dpi dependent)
+    const unitConversion = {
+      mm: {
+        mm: 1,
+        cm: 0.1,
+        in: 1 / 25.4,
+        pt: 72 / 25.4,
+        pc: 6 / 25.4,
+        px: -1,
+      },
+      cm: {
+        mm: 10,
+        cm: 1,
+        in: 1 / 2.54,
+        pt: 72 / 2.54,
+        pc: 6 / 2.54,
+        px: -1,
+      },
+      in: {
+        mm: 25.4,
+        cm: 2.54,
+        in: 1,
+        pt: 72,
+        pc: 6,
+        px: -1,
+      },
+      pt: {
+        mm: 25.4 / 72,
+        cm: 2.54 / 72,
+        in: 1 / 72,
+        pt: 1,
+        pc: 6 / 72,
+        px: -1,
+      },
+      pc: {
+        mm: 25.4 / 6,
+        cm: 2.54 / 6,
+        in: 1 / 6,
+        pt: 72 / 6,
+        pc: 1,
+        px: -1,
+      },
+      px: {
+        px: 1,
+      },
+    }
 
-          scale = unitConversion['in'][scope.defaultUnit] / scope.defaultDPI
-        } else {
-          scale = unitConversion[theUnit][scope.defaultUnit]
+    function parseFloatWithUnits(string) {
+      let theUnit = 'px'
 
-          if (scale < 0) {
-            // Conversion scale to pixels
+      if (typeof string === 'string' || string instanceof String) {
+        for (let i = 0, n = units.length; i < n; i++) {
+          const u = units[i]
 
-            scale = unitConversion[theUnit]['in'] * scope.defaultDPI
+          if (string.endsWith(u)) {
+            theUnit = u
+            string = string.substring(0, string.length - u.length)
+            break
           }
         }
-
-        return scale * parseFloat(string)
       }
 
-      // Transforms
+      let scale = undefined
 
-      function getNodeTransform(node) {
-        if (
-          !(
-            node.hasAttribute('transform') ||
-            (node.nodeName === 'use' && (node.hasAttribute('x') || node.hasAttribute('y')))
-          )
-        ) {
-          return null
-        }
+      if (theUnit === 'px' && scope.defaultUnit !== 'px') {
+        // Conversion scale from  pixels to inches, then to default units
 
-        const transform = parseNodeTransform(node)
+        scale = unitConversion['in'][scope.defaultUnit] / scope.defaultDPI
+      } else {
+        scale = unitConversion[theUnit][scope.defaultUnit]
 
-        if (transformStack.length > 0) {
-          transform.premultiply(transformStack[transformStack.length - 1])
+        if (scale < 0) {
+          // Conversion scale to pixels
+
+          scale = unitConversion[theUnit]['in'] * scope.defaultDPI
         }
+      }
+
+      return scale * parseFloat(string)
+    }
 
-        currentTransform.copy(transform)
-        transformStack.push(transform)
+    // Transforms
 
-        return transform
+    function getNodeTransform(node) {
+      if (
+        !(
+          node.hasAttribute('transform') ||
+          (node.nodeName === 'use' && (node.hasAttribute('x') || node.hasAttribute('y')))
+        )
+      ) {
+        return null
       }
 
-      function parseNodeTransform(node) {
-        const transform = new Matrix3()
-        const currentTransform = tempTransform0
+      const transform = parseNodeTransform(node)
 
-        if (node.nodeName === 'use' && (node.hasAttribute('x') || node.hasAttribute('y'))) {
-          const tx = parseFloatWithUnits(node.getAttribute('x'))
-          const ty = parseFloatWithUnits(node.getAttribute('y'))
+      if (transformStack.length > 0) {
+        transform.premultiply(transformStack[transformStack.length - 1])
+      }
 
-          transform.translate(tx, ty)
-        }
+      currentTransform.copy(transform)
+      transformStack.push(transform)
+
+      return transform
+    }
 
-        if (node.hasAttribute('transform')) {
-          const transformsTexts = node.getAttribute('transform').split(')')
+    function parseNodeTransform(node) {
+      const transform = new Matrix3()
+      const currentTransform = tempTransform0
 
-          for (let tIndex = transformsTexts.length - 1; tIndex >= 0; tIndex--) {
-            const transformText = transformsTexts[tIndex].trim()
+      if (node.nodeName === 'use' && (node.hasAttribute('x') || node.hasAttribute('y'))) {
+        const tx = parseFloatWithUnits(node.getAttribute('x'))
+        const ty = parseFloatWithUnits(node.getAttribute('y'))
 
-            if (transformText === '') continue
+        transform.translate(tx, ty)
+      }
 
-            const openParPos = transformText.indexOf('(')
-            const closeParPos = transformText.length
+      if (node.hasAttribute('transform')) {
+        const transformsTexts = node.getAttribute('transform').split(')')
 
-            if (openParPos > 0 && openParPos < closeParPos) {
-              const transformType = transformText.slice(0, openParPos)
+        for (let tIndex = transformsTexts.length - 1; tIndex >= 0; tIndex--) {
+          const transformText = transformsTexts[tIndex].trim()
 
-              const array = parseFloats(transformText.slice(openParPos + 1))
+          if (transformText === '') continue
 
-              currentTransform.identity()
+          const openParPos = transformText.indexOf('(')
+          const closeParPos = transformText.length
 
-              switch (transformType) {
-                case 'translate':
-                  if (array.length >= 1) {
-                    const tx = array[0]
-                    let ty = 0
+          if (openParPos > 0 && openParPos < closeParPos) {
+            const transformType = transformText.slice(0, openParPos)
 
-                    if (array.length >= 2) {
-                      ty = array[1]
-                    }
+            const array = parseFloats(transformText.slice(openParPos + 1))
 
-                    currentTransform.translate(tx, ty)
-                  }
+            currentTransform.identity()
 
-                  break
+            switch (transformType) {
+              case 'translate':
+                if (array.length >= 1) {
+                  const tx = array[0]
+                  let ty = 0
 
-                case 'rotate':
-                  if (array.length >= 1) {
-                    let angle = 0
-                    let cx = 0
-                    let cy = 0
-
-                    // Angle
-                    angle = (array[0] * Math.PI) / 180
-
-                    if (array.length >= 3) {
-                      // Center x, y
-                      cx = array[1]
-                      cy = array[2]
-                    }
-
-                    // Rotate around center (cx, cy)
-                    tempTransform1.makeTranslation(-cx, -cy)
-                    tempTransform2.makeRotation(angle)
-                    tempTransform3.multiplyMatrices(tempTransform2, tempTransform1)
-                    tempTransform1.makeTranslation(cx, cy)
-                    currentTransform.multiplyMatrices(tempTransform1, tempTransform3)
+                  if (array.length >= 2) {
+                    ty = array[1]
                   }
 
-                  break
+                  currentTransform.translate(tx, ty)
+                }
 
-                case 'scale':
-                  if (array.length >= 1) {
-                    const scaleX = array[0]
-                    let scaleY = scaleX
+                break
 
-                    if (array.length >= 2) {
-                      scaleY = array[1]
-                    }
+              case 'rotate':
+                if (array.length >= 1) {
+                  let angle = 0
+                  let cx = 0
+                  let cy = 0
 
-                    currentTransform.scale(scaleX, scaleY)
+                  // Angle
+                  angle = (array[0] * Math.PI) / 180
+
+                  if (array.length >= 3) {
+                    // Center x, y
+                    cx = array[1]
+                    cy = array[2]
                   }
 
-                  break
+                  // Rotate around center (cx, cy)
+                  tempTransform1.makeTranslation(-cx, -cy)
+                  tempTransform2.makeRotation(angle)
+                  tempTransform3.multiplyMatrices(tempTransform2, tempTransform1)
+                  tempTransform1.makeTranslation(cx, cy)
+                  currentTransform.multiplyMatrices(tempTransform1, tempTransform3)
+                }
 
-                case 'skewX':
-                  if (array.length === 1) {
-                    currentTransform.set(1, Math.tan((array[0] * Math.PI) / 180), 0, 0, 1, 0, 0, 0, 1)
-                  }
+                break
 
-                  break
+              case 'scale':
+                if (array.length >= 1) {
+                  const scaleX = array[0]
+                  let scaleY = scaleX
 
-                case 'skewY':
-                  if (array.length === 1) {
-                    currentTransform.set(1, 0, 0, Math.tan((array[0] * Math.PI) / 180), 1, 0, 0, 0, 1)
+                  if (array.length >= 2) {
+                    scaleY = array[1]
                   }
 
-                  break
+                  currentTransform.scale(scaleX, scaleY)
+                }
+
+                break
+
+              case 'skewX':
+                if (array.length === 1) {
+                  currentTransform.set(1, Math.tan((array[0] * Math.PI) / 180), 0, 0, 1, 0, 0, 0, 1)
+                }
+
+                break
+
+              case 'skewY':
+                if (array.length === 1) {
+                  currentTransform.set(1, 0, 0, Math.tan((array[0] * Math.PI) / 180), 1, 0, 0, 0, 1)
+                }
+
+                break
 
-                case 'matrix':
-                  if (array.length === 6) {
-                    currentTransform.set(array[0], array[2], array[4], array[1], array[3], array[5], 0, 0, 1)
-                  }
+              case 'matrix':
+                if (array.length === 6) {
+                  currentTransform.set(array[0], array[2], array[4], array[1], array[3], array[5], 0, 0, 1)
+                }
 
-                  break
-              }
+                break
             }
-
-            transform.premultiply(currentTransform)
           }
-        }
 
-        return transform
+          transform.premultiply(currentTransform)
+        }
       }
 
-      function transformPath(path, m) {
-        function transfVec2(v2) {
-          tempV3.set(v2.x, v2.y, 1).applyMatrix3(m)
+      return transform
+    }
 
-          v2.set(tempV3.x, tempV3.y)
-        }
+    function transformPath(path, m) {
+      function transfVec2(v2) {
+        tempV3.set(v2.x, v2.y, 1).applyMatrix3(m)
 
-        function transfEllipseGeneric(curve) {
-          // For math description see:
-          // https://math.stackexchange.com/questions/4544164
+        v2.set(tempV3.x, tempV3.y)
+      }
 
-          const a = curve.xRadius
-          const b = curve.yRadius
+      function transfEllipseGeneric(curve) {
+        // For math description see:
+        // https://math.stackexchange.com/questions/4544164
 
-          const cosTheta = Math.cos(curve.aRotation)
-          const sinTheta = Math.sin(curve.aRotation)
+        const a = curve.xRadius
+        const b = curve.yRadius
 
-          const v1 = new Vector3(a * cosTheta, a * sinTheta, 0)
-          const v2 = new Vector3(-b * sinTheta, b * cosTheta, 0)
+        const cosTheta = Math.cos(curve.aRotation)
+        const sinTheta = Math.sin(curve.aRotation)
 
-          const f1 = v1.applyMatrix3(m)
-          const f2 = v2.applyMatrix3(m)
+        const v1 = new Vector3(a * cosTheta, a * sinTheta, 0)
+        const v2 = new Vector3(-b * sinTheta, b * cosTheta, 0)
 
-          const mF = tempTransform0.set(f1.x, f2.x, 0, f1.y, f2.y, 0, 0, 0, 1)
+        const f1 = v1.applyMatrix3(m)
+        const f2 = v2.applyMatrix3(m)
 
-          const mFInv = tempTransform1.copy(mF).invert()
-          const mFInvT = tempTransform2.copy(mFInv).transpose()
-          const mQ = mFInvT.multiply(mFInv)
-          const mQe = mQ.elements
+        const mF = tempTransform0.set(f1.x, f2.x, 0, f1.y, f2.y, 0, 0, 0, 1)
 
-          const ed = eigenDecomposition(mQe[0], mQe[1], mQe[4])
-          const rt1sqrt = Math.sqrt(ed.rt1)
-          const rt2sqrt = Math.sqrt(ed.rt2)
+        const mFInv = tempTransform1.copy(mF).invert()
+        const mFInvT = tempTransform2.copy(mFInv).transpose()
+        const mQ = mFInvT.multiply(mFInv)
+        const mQe = mQ.elements
 
-          curve.xRadius = 1 / rt1sqrt
-          curve.yRadius = 1 / rt2sqrt
-          curve.aRotation = Math.atan2(ed.sn, ed.cs)
+        const ed = eigenDecomposition(mQe[0], mQe[1], mQe[4])
+        const rt1sqrt = Math.sqrt(ed.rt1)
+        const rt2sqrt = Math.sqrt(ed.rt2)
 
-          const isFullEllipse = (curve.aEndAngle - curve.aStartAngle) % (2 * Math.PI) < Number.EPSILON
+        curve.xRadius = 1 / rt1sqrt
+        curve.yRadius = 1 / rt2sqrt
+        curve.aRotation = Math.atan2(ed.sn, ed.cs)
 
-          // Do not touch angles of a full ellipse because after transformation they
-          // would converge to a sinle value effectively removing the whole curve
+        const isFullEllipse = (curve.aEndAngle - curve.aStartAngle) % (2 * Math.PI) < Number.EPSILON
 
-          if (!isFullEllipse) {
-            const mDsqrt = tempTransform1.set(rt1sqrt, 0, 0, 0, rt2sqrt, 0, 0, 0, 1)
+        // Do not touch angles of a full ellipse because after transformation they
+        // would converge to a sinle value effectively removing the whole curve
 
-            const mRT = tempTransform2.set(ed.cs, ed.sn, 0, -ed.sn, ed.cs, 0, 0, 0, 1)
+        if (!isFullEllipse) {
+          const mDsqrt = tempTransform1.set(rt1sqrt, 0, 0, 0, rt2sqrt, 0, 0, 0, 1)
 
-            const mDRF = mDsqrt.multiply(mRT).multiply(mF)
+          const mRT = tempTransform2.set(ed.cs, ed.sn, 0, -ed.sn, ed.cs, 0, 0, 0, 1)
 
-            const transformAngle = (phi) => {
-              const { x: cosR, y: sinR } = new Vector3(Math.cos(phi), Math.sin(phi), 0).applyMatrix3(mDRF)
+          const mDRF = mDsqrt.multiply(mRT).multiply(mF)
 
-              return Math.atan2(sinR, cosR)
-            }
+          const transformAngle = (phi) => {
+            const { x: cosR, y: sinR } = new Vector3(Math.cos(phi), Math.sin(phi), 0).applyMatrix3(mDRF)
 
-            curve.aStartAngle = transformAngle(curve.aStartAngle)
-            curve.aEndAngle = transformAngle(curve.aEndAngle)
+            return Math.atan2(sinR, cosR)
+          }
 
-            if (isTransformFlipped(m)) {
-              curve.aClockwise = !curve.aClockwise
-            }
+          curve.aStartAngle = transformAngle(curve.aStartAngle)
+          curve.aEndAngle = transformAngle(curve.aEndAngle)
+
+          if (isTransformFlipped(m)) {
+            curve.aClockwise = !curve.aClockwise
           }
         }
+      }
 
-        function transfEllipseNoSkew(curve) {
-          // Faster shortcut if no skew is applied
-          // (e.g, a euclidean transform of a group containing the ellipse)
+      function transfEllipseNoSkew(curve) {
+        // Faster shortcut if no skew is applied
+        // (e.g, a euclidean transform of a group containing the ellipse)
 
-          const sx = getTransformScaleX(m)
-          const sy = getTransformScaleY(m)
+        const sx = getTransformScaleX(m)
+        const sy = getTransformScaleY(m)
 
-          curve.xRadius *= sx
-          curve.yRadius *= sy
+        curve.xRadius *= sx
+        curve.yRadius *= sy
 
-          // Extract rotation angle from the matrix of form:
-          //
-          //  | cosθ sx   -sinθ sy |
-          //  | sinθ sx    cosθ sy |
-          //
-          // Remembering that tanθ = sinθ / cosθ; and that
-          // `sx`, `sy`, or both might be zero.
-          const theta =
-            sx > Number.EPSILON ? Math.atan2(m.elements[1], m.elements[0]) : Math.atan2(-m.elements[3], m.elements[4])
+        // Extract rotation angle from the matrix of form:
+        //
+        //  | cosθ sx   -sinθ sy |
+        //  | sinθ sx    cosθ sy |
+        //
+        // Remembering that tanθ = sinθ / cosθ; and that
+        // `sx`, `sy`, or both might be zero.
+        const theta =
+          sx > Number.EPSILON ? Math.atan2(m.elements[1], m.elements[0]) : Math.atan2(-m.elements[3], m.elements[4])
 
-          curve.aRotation += theta
+        curve.aRotation += theta
 
-          if (isTransformFlipped(m)) {
-            curve.aStartAngle *= -1
-            curve.aEndAngle *= -1
-            curve.aClockwise = !curve.aClockwise
-          }
+        if (isTransformFlipped(m)) {
+          curve.aStartAngle *= -1
+          curve.aEndAngle *= -1
+          curve.aClockwise = !curve.aClockwise
         }
+      }
 
-        const subPaths = path.subPaths
-
-        for (let i = 0, n = subPaths.length; i < n; i++) {
-          const subPath = subPaths[i]
-          const curves = subPath.curves
-
-          for (let j = 0; j < curves.length; j++) {
-            const curve = curves[j]
-
-            if (curve.isLineCurve) {
-              transfVec2(curve.v1)
-              transfVec2(curve.v2)
-            } else if (curve.isCubicBezierCurve) {
-              transfVec2(curve.v0)
-              transfVec2(curve.v1)
-              transfVec2(curve.v2)
-              transfVec2(curve.v3)
-            } else if (curve.isQuadraticBezierCurve) {
-              transfVec2(curve.v0)
-              transfVec2(curve.v1)
-              transfVec2(curve.v2)
-            } else if (curve.isEllipseCurve) {
-              // Transform ellipse center point
-
-              tempV2.set(curve.aX, curve.aY)
-              transfVec2(tempV2)
-              curve.aX = tempV2.x
-              curve.aY = tempV2.y
-
-              // Transform ellipse shape parameters
-
-              if (isTransformSkewed(m)) {
-                transfEllipseGeneric(curve)
-              } else {
-                transfEllipseNoSkew(curve)
-              }
+      const subPaths = path.subPaths
+
+      for (let i = 0, n = subPaths.length; i < n; i++) {
+        const subPath = subPaths[i]
+        const curves = subPath.curves
+
+        for (let j = 0; j < curves.length; j++) {
+          const curve = curves[j]
+
+          if (curve.isLineCurve) {
+            transfVec2(curve.v1)
+            transfVec2(curve.v2)
+          } else if (curve.isCubicBezierCurve) {
+            transfVec2(curve.v0)
+            transfVec2(curve.v1)
+            transfVec2(curve.v2)
+            transfVec2(curve.v3)
+          } else if (curve.isQuadraticBezierCurve) {
+            transfVec2(curve.v0)
+            transfVec2(curve.v1)
+            transfVec2(curve.v2)
+          } else if (curve.isEllipseCurve) {
+            // Transform ellipse center point
+
+            tempV2.set(curve.aX, curve.aY)
+            transfVec2(tempV2)
+            curve.aX = tempV2.x
+            curve.aY = tempV2.y
+
+            // Transform ellipse shape parameters
+
+            if (isTransformSkewed(m)) {
+              transfEllipseGeneric(curve)
+            } else {
+              transfEllipseNoSkew(curve)
             }
           }
         }
       }
+    }
 
-      function isTransformFlipped(m) {
-        const te = m.elements
-        return te[0] * te[4] - te[1] * te[3] < 0
-      }
+    function isTransformFlipped(m) {
+      const te = m.elements
+      return te[0] * te[4] - te[1] * te[3] < 0
+    }
 
-      function isTransformSkewed(m) {
-        const te = m.elements
-        const basisDot = te[0] * te[3] + te[1] * te[4]
+    function isTransformSkewed(m) {
+      const te = m.elements
+      const basisDot = te[0] * te[3] + te[1] * te[4]
 
-        // Shortcut for trivial rotations and transformations
-        if (basisDot === 0) return false
+      // Shortcut for trivial rotations and transformations
+      if (basisDot === 0) return false
 
-        const sx = getTransformScaleX(m)
-        const sy = getTransformScaleY(m)
+      const sx = getTransformScaleX(m)
+      const sy = getTransformScaleY(m)
 
-        return Math.abs(basisDot / (sx * sy)) > Number.EPSILON
-      }
+      return Math.abs(basisDot / (sx * sy)) > Number.EPSILON
+    }
+
+    function getTransformScaleX(m) {
+      const te = m.elements
+      return Math.sqrt(te[0] * te[0] + te[1] * te[1])
+    }
 
-      function getTransformScaleX(m) {
-        const te = m.elements
-        return Math.sqrt(te[0] * te[0] + te[1] * te[1])
+    function getTransformScaleY(m) {
+      const te = m.elements
+      return Math.sqrt(te[3] * te[3] + te[4] * te[4])
+    }
+
+    // Calculates the eigensystem of a real symmetric 2x2 matrix
+    //    [ A  B ]
+    //    [ B  C ]
+    // in the form
+    //    [ A  B ]  =  [ cs  -sn ] [ rt1   0  ] [  cs  sn ]
+    //    [ B  C ]     [ sn   cs ] [  0   rt2 ] [ -sn  cs ]
+    // where rt1 >= rt2.
+    //
+    // Adapted from: https://www.mpi-hd.mpg.de/personalhomes/globes/3x3/index.html
+    // -> Algorithms for real symmetric matrices -> Analytical (2x2 symmetric)
+    function eigenDecomposition(A, B, C) {
+      let rt1, rt2, cs, sn, t
+      const sm = A + C
+      const df = A - C
+      const rt = Math.sqrt(df * df + 4 * B * B)
+
+      if (sm > 0) {
+        rt1 = 0.5 * (sm + rt)
+        t = 1 / rt1
+        rt2 = A * t * C - B * t * B
+      } else if (sm < 0) {
+        rt2 = 0.5 * (sm - rt)
+      } else {
+        // This case needs to be treated separately to avoid div by 0
+
+        rt1 = 0.5 * rt
+        rt2 = -0.5 * rt
       }
 
-      function getTransformScaleY(m) {
-        const te = m.elements
-        return Math.sqrt(te[3] * te[3] + te[4] * te[4])
+      // Calculate eigenvectors
+
+      if (df > 0) {
+        cs = df + rt
+      } else {
+        cs = df - rt
       }
 
-      // Calculates the eigensystem of a real symmetric 2x2 matrix
-      //    [ A  B ]
-      //    [ B  C ]
-      // in the form
-      //    [ A  B ]  =  [ cs  -sn ] [ rt1   0  ] [  cs  sn ]
-      //    [ B  C ]     [ sn   cs ] [  0   rt2 ] [ -sn  cs ]
-      // where rt1 >= rt2.
-      //
-      // Adapted from: https://www.mpi-hd.mpg.de/personalhomes/globes/3x3/index.html
-      // -> Algorithms for real symmetric matrices -> Analytical (2x2 symmetric)
-      function eigenDecomposition(A, B, C) {
-        let rt1, rt2, cs, sn, t
-        const sm = A + C
-        const df = A - C
-        const rt = Math.sqrt(df * df + 4 * B * B)
-
-        if (sm > 0) {
-          rt1 = 0.5 * (sm + rt)
-          t = 1 / rt1
-          rt2 = A * t * C - B * t * B
-        } else if (sm < 0) {
-          rt2 = 0.5 * (sm - rt)
-        } else {
-          // This case needs to be treated separately to avoid div by 0
+      if (Math.abs(cs) > 2 * Math.abs(B)) {
+        t = (-2 * B) / cs
+        sn = 1 / Math.sqrt(1 + t * t)
+        cs = t * sn
+      } else if (Math.abs(B) === 0) {
+        cs = 1
+        sn = 0
+      } else {
+        t = (-0.5 * cs) / B
+        cs = 1 / Math.sqrt(1 + t * t)
+        sn = t * cs
+      }
 
-          rt1 = 0.5 * rt
-          rt2 = -0.5 * rt
-        }
+      if (df > 0) {
+        t = cs
+        cs = -sn
+        sn = t
+      }
 
-        // Calculate eigenvectors
+      return { rt1, rt2, cs, sn }
+    }
 
-        if (df > 0) {
-          cs = df + rt
-        } else {
-          cs = df - rt
-        }
+    //
 
-        if (Math.abs(cs) > 2 * Math.abs(B)) {
-          t = (-2 * B) / cs
-          sn = 1 / Math.sqrt(1 + t * t)
-          cs = t * sn
-        } else if (Math.abs(B) === 0) {
-          cs = 1
-          sn = 0
-        } else {
-          t = (-0.5 * cs) / B
-          cs = 1 / Math.sqrt(1 + t * t)
-          sn = t * cs
-        }
+    const paths = []
+    const stylesheets = {}
 
-        if (df > 0) {
-          t = cs
-          cs = -sn
-          sn = t
-        }
+    const transformStack = []
 
-        return { rt1, rt2, cs, sn }
-      }
+    const tempTransform0 = new Matrix3()
+    const tempTransform1 = new Matrix3()
+    const tempTransform2 = new Matrix3()
+    const tempTransform3 = new Matrix3()
+    const tempV2 = new Vector2()
+    const tempV3 = new Vector3()
 
-      //
+    const currentTransform = new Matrix3()
 
-      const paths = []
-      const stylesheets = {}
+    const xml = new DOMParser().parseFromString(text, 'image/svg+xml') // application/xml
 
-      const transformStack = []
+    parseNode(xml.documentElement, {
+      fill: '#000',
+      fillOpacity: 1,
+      strokeOpacity: 1,
+      strokeWidth: 1,
+      strokeLineJoin: 'miter',
+      strokeLineCap: 'butt',
+      strokeMiterLimit: 4,
+    })
 
-      const tempTransform0 = new Matrix3()
-      const tempTransform1 = new Matrix3()
-      const tempTransform2 = new Matrix3()
-      const tempTransform3 = new Matrix3()
-      const tempV2 = new Vector2()
-      const tempV3 = new Vector3()
+    const data = { paths: paths, xml: xml.documentElement }
 
-      const currentTransform = new Matrix3()
+    // console.log( paths );
+    return data
+  }
 
-      const xml = new DOMParser().parseFromString(text, 'image/svg+xml') // application/xml
+  static createShapes(shapePath) {
+    // Param shapePath: a shapepath as returned by the parse function of this class
+    // Returns Shape object
 
-      parseNode(xml.documentElement, {
-        fill: '#000',
-        fillOpacity: 1,
-        strokeOpacity: 1,
-        strokeWidth: 1,
-        strokeLineJoin: 'miter',
-        strokeLineCap: 'butt',
-        strokeMiterLimit: 4,
-      })
+    const BIGNUMBER = 999999999
 
-      const data = { paths: paths, xml: xml.documentElement }
+    const IntersectionLocationType = {
+      ORIGIN: 0,
+      DESTINATION: 1,
+      BETWEEN: 2,
+      LEFT: 3,
+      RIGHT: 4,
+      BEHIND: 5,
+      BEYOND: 6,
+    }
 
-      // console.log( paths );
-      return data
+    const classifyResult = {
+      loc: IntersectionLocationType.ORIGIN,
+      t: 0,
     }
 
-    static createShapes(shapePath) {
-      // Param shapePath: a shapepath as returned by the parse function of this class
-      // Returns Shape object
-
-      const BIGNUMBER = 999999999
-
-      const IntersectionLocationType = {
-        ORIGIN: 0,
-        DESTINATION: 1,
-        BETWEEN: 2,
-        LEFT: 3,
-        RIGHT: 4,
-        BEHIND: 5,
-        BEYOND: 6,
-      }
-
-      const classifyResult = {
-        loc: IntersectionLocationType.ORIGIN,
-        t: 0,
-      }
-
-      function findEdgeIntersection(a0, a1, b0, b1) {
-        const x1 = a0.x
-        const x2 = a1.x
-        const x3 = b0.x
-        const x4 = b1.x
-        const y1 = a0.y
-        const y2 = a1.y
-        const y3 = b0.y
-        const y4 = b1.y
-        const nom1 = (x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3)
-        const nom2 = (x2 - x1) * (y1 - y3) - (y2 - y1) * (x1 - x3)
-        const denom = (y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1)
-        const t1 = nom1 / denom
-        const t2 = nom2 / denom
-
-        if ((denom === 0 && nom1 !== 0) || t1 <= 0 || t1 >= 1 || t2 < 0 || t2 > 1) {
-          //1. lines are parallel or edges don't intersect
-
-          return null
-        } else if (nom1 === 0 && denom === 0) {
-          //2. lines are colinear
-
-          //check if endpoints of edge2 (b0-b1) lies on edge1 (a0-a1)
-          for (let i = 0; i < 2; i++) {
-            classifyPoint(i === 0 ? b0 : b1, a0, a1)
-            //find position of this endpoints relatively to edge1
-            if (classifyResult.loc == IntersectionLocationType.ORIGIN) {
-              const point = i === 0 ? b0 : b1
-              return { x: point.x, y: point.y, t: classifyResult.t }
-            } else if (classifyResult.loc == IntersectionLocationType.BETWEEN) {
-              const x = +(x1 + classifyResult.t * (x2 - x1)).toPrecision(10)
-              const y = +(y1 + classifyResult.t * (y2 - y1)).toPrecision(10)
-              return { x: x, y: y, t: classifyResult.t }
-            }
+    function findEdgeIntersection(a0, a1, b0, b1) {
+      const x1 = a0.x
+      const x2 = a1.x
+      const x3 = b0.x
+      const x4 = b1.x
+      const y1 = a0.y
+      const y2 = a1.y
+      const y3 = b0.y
+      const y4 = b1.y
+      const nom1 = (x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3)
+      const nom2 = (x2 - x1) * (y1 - y3) - (y2 - y1) * (x1 - x3)
+      const denom = (y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1)
+      const t1 = nom1 / denom
+      const t2 = nom2 / denom
+
+      if ((denom === 0 && nom1 !== 0) || t1 <= 0 || t1 >= 1 || t2 < 0 || t2 > 1) {
+        //1. lines are parallel or edges don't intersect
+
+        return null
+      } else if (nom1 === 0 && denom === 0) {
+        //2. lines are colinear
+
+        //check if endpoints of edge2 (b0-b1) lies on edge1 (a0-a1)
+        for (let i = 0; i < 2; i++) {
+          classifyPoint(i === 0 ? b0 : b1, a0, a1)
+          //find position of this endpoints relatively to edge1
+          if (classifyResult.loc == IntersectionLocationType.ORIGIN) {
+            const point = i === 0 ? b0 : b1
+            return { x: point.x, y: point.y, t: classifyResult.t }
+          } else if (classifyResult.loc == IntersectionLocationType.BETWEEN) {
+            const x = +(x1 + classifyResult.t * (x2 - x1)).toPrecision(10)
+            const y = +(y1 + classifyResult.t * (y2 - y1)).toPrecision(10)
+            return { x: x, y: y, t: classifyResult.t }
           }
+        }
 
-          return null
-        } else {
-          //3. edges intersect
+        return null
+      } else {
+        //3. edges intersect
 
-          for (let i = 0; i < 2; i++) {
-            classifyPoint(i === 0 ? b0 : b1, a0, a1)
+        for (let i = 0; i < 2; i++) {
+          classifyPoint(i === 0 ? b0 : b1, a0, a1)
 
-            if (classifyResult.loc == IntersectionLocationType.ORIGIN) {
-              const point = i === 0 ? b0 : b1
-              return { x: point.x, y: point.y, t: classifyResult.t }
-            }
+          if (classifyResult.loc == IntersectionLocationType.ORIGIN) {
+            const point = i === 0 ? b0 : b1
+            return { x: point.x, y: point.y, t: classifyResult.t }
           }
-
-          const x = +(x1 + t1 * (x2 - x1)).toPrecision(10)
-          const y = +(y1 + t1 * (y2 - y1)).toPrecision(10)
-          return { x: x, y: y, t: t1 }
         }
-      }
 
-      function classifyPoint(p, edgeStart, edgeEnd) {
-        const ax = edgeEnd.x - edgeStart.x
-        const ay = edgeEnd.y - edgeStart.y
-        const bx = p.x - edgeStart.x
-        const by = p.y - edgeStart.y
-        const sa = ax * by - bx * ay
-
-        if (p.x === edgeStart.x && p.y === edgeStart.y) {
-          classifyResult.loc = IntersectionLocationType.ORIGIN
-          classifyResult.t = 0
-          return
-        }
+        const x = +(x1 + t1 * (x2 - x1)).toPrecision(10)
+        const y = +(y1 + t1 * (y2 - y1)).toPrecision(10)
+        return { x: x, y: y, t: t1 }
+      }
+    }
 
-        if (p.x === edgeEnd.x && p.y === edgeEnd.y) {
-          classifyResult.loc = IntersectionLocationType.DESTINATION
-          classifyResult.t = 1
-          return
-        }
+    function classifyPoint(p, edgeStart, edgeEnd) {
+      const ax = edgeEnd.x - edgeStart.x
+      const ay = edgeEnd.y - edgeStart.y
+      const bx = p.x - edgeStart.x
+      const by = p.y - edgeStart.y
+      const sa = ax * by - bx * ay
+
+      if (p.x === edgeStart.x && p.y === edgeStart.y) {
+        classifyResult.loc = IntersectionLocationType.ORIGIN
+        classifyResult.t = 0
+        return
+      }
 
-        if (sa < -Number.EPSILON) {
-          classifyResult.loc = IntersectionLocationType.LEFT
-          return
-        }
+      if (p.x === edgeEnd.x && p.y === edgeEnd.y) {
+        classifyResult.loc = IntersectionLocationType.DESTINATION
+        classifyResult.t = 1
+        return
+      }
 
-        if (sa > Number.EPSILON) {
-          classifyResult.loc = IntersectionLocationType.RIGHT
-          return
-        }
+      if (sa < -Number.EPSILON) {
+        classifyResult.loc = IntersectionLocationType.LEFT
+        return
+      }
 
-        if (ax * bx < 0 || ay * by < 0) {
-          classifyResult.loc = IntersectionLocationType.BEHIND
-          return
-        }
+      if (sa > Number.EPSILON) {
+        classifyResult.loc = IntersectionLocationType.RIGHT
+        return
+      }
 
-        if (Math.sqrt(ax * ax + ay * ay) < Math.sqrt(bx * bx + by * by)) {
-          classifyResult.loc = IntersectionLocationType.BEYOND
-          return
-        }
+      if (ax * bx < 0 || ay * by < 0) {
+        classifyResult.loc = IntersectionLocationType.BEHIND
+        return
+      }
 
-        let t
+      if (Math.sqrt(ax * ax + ay * ay) < Math.sqrt(bx * bx + by * by)) {
+        classifyResult.loc = IntersectionLocationType.BEYOND
+        return
+      }
 
-        if (ax !== 0) {
-          t = bx / ax
-        } else {
-          t = by / ay
-        }
+      let t
 
-        classifyResult.loc = IntersectionLocationType.BETWEEN
-        classifyResult.t = t
+      if (ax !== 0) {
+        t = bx / ax
+      } else {
+        t = by / ay
       }
 
-      function getIntersections(path1, path2) {
-        const intersectionsRaw = []
-        const intersections = []
+      classifyResult.loc = IntersectionLocationType.BETWEEN
+      classifyResult.t = t
+    }
+
+    function getIntersections(path1, path2) {
+      const intersectionsRaw = []
+      const intersections = []
 
-        for (let index = 1; index < path1.length; index++) {
-          const path1EdgeStart = path1[index - 1]
-          const path1EdgeEnd = path1[index]
+      for (let index = 1; index < path1.length; index++) {
+        const path1EdgeStart = path1[index - 1]
+        const path1EdgeEnd = path1[index]
 
-          for (let index2 = 1; index2 < path2.length; index2++) {
-            const path2EdgeStart = path2[index2 - 1]
-            const path2EdgeEnd = path2[index2]
+        for (let index2 = 1; index2 < path2.length; index2++) {
+          const path2EdgeStart = path2[index2 - 1]
+          const path2EdgeEnd = path2[index2]
 
-            const intersection = findEdgeIntersection(path1EdgeStart, path1EdgeEnd, path2EdgeStart, path2EdgeEnd)
+          const intersection = findEdgeIntersection(path1EdgeStart, path1EdgeEnd, path2EdgeStart, path2EdgeEnd)
 
-            if (
-              intersection !== null &&
-              intersectionsRaw.find(
-                (i) => i.t <= intersection.t + Number.EPSILON && i.t >= intersection.t - Number.EPSILON,
-              ) === undefined
-            ) {
-              intersectionsRaw.push(intersection)
-              intersections.push(new Vector2(intersection.x, intersection.y))
-            }
+          if (
+            intersection !== null &&
+            intersectionsRaw.find(
+              (i) => i.t <= intersection.t + Number.EPSILON && i.t >= intersection.t - Number.EPSILON,
+            ) === undefined
+          ) {
+            intersectionsRaw.push(intersection)
+            intersections.push(new Vector2(intersection.x, intersection.y))
           }
         }
-
-        return intersections
       }
 
-      function getScanlineIntersections(scanline, boundingBox, paths) {
-        const center = new Vector2()
-        boundingBox.getCenter(center)
-
-        const allIntersections = []
-
-        paths.forEach((path) => {
-          // check if the center of the bounding box is in the bounding box of the paths.
-          // this is a pruning method to limit the search of intersections in paths that can't envelop of the current path.
-          // if a path envelops another path. The center of that oter path, has to be inside the bounding box of the enveloping path.
-          if (path.boundingBox.containsPoint(center)) {
-            const intersections = getIntersections(scanline, path.points)
+      return intersections
+    }
 
-            intersections.forEach((p) => {
-              allIntersections.push({ identifier: path.identifier, isCW: path.isCW, point: p })
-            })
-          }
-        })
+    function getScanlineIntersections(scanline, boundingBox, paths) {
+      const center = new Vector2()
+      boundingBox.getCenter(center)
 
-        allIntersections.sort((i1, i2) => {
-          return i1.point.x - i2.point.x
-        })
+      const allIntersections = []
 
-        return allIntersections
-      }
+      paths.forEach((path) => {
+        // check if the center of the bounding box is in the bounding box of the paths.
+        // this is a pruning method to limit the search of intersections in paths that can't envelop of the current path.
+        // if a path envelops another path. The center of that oter path, has to be inside the bounding box of the enveloping path.
+        if (path.boundingBox.containsPoint(center)) {
+          const intersections = getIntersections(scanline, path.points)
 
-      function isHoleTo(simplePath, allPaths, scanlineMinX, scanlineMaxX, _fillRule) {
-        if (_fillRule === null || _fillRule === undefined || _fillRule === '') {
-          _fillRule = 'nonzero'
+          intersections.forEach((p) => {
+            allIntersections.push({ identifier: path.identifier, isCW: path.isCW, point: p })
+          })
         }
+      })
 
-        const centerBoundingBox = new Vector2()
-        simplePath.boundingBox.getCenter(centerBoundingBox)
-
-        const scanline = [
-          new Vector2(scanlineMinX, centerBoundingBox.y),
-          new Vector2(scanlineMaxX, centerBoundingBox.y),
-        ]
+      allIntersections.sort((i1, i2) => {
+        return i1.point.x - i2.point.x
+      })
 
-        const scanlineIntersections = getScanlineIntersections(scanline, simplePath.boundingBox, allPaths)
+      return allIntersections
+    }
 
-        scanlineIntersections.sort((i1, i2) => {
-          return i1.point.x - i2.point.x
-        })
+    function isHoleTo(simplePath, allPaths, scanlineMinX, scanlineMaxX, _fillRule) {
+      if (_fillRule === null || _fillRule === undefined || _fillRule === '') {
+        _fillRule = 'nonzero'
+      }
 
-        const baseIntersections = []
-        const otherIntersections = []
+      const centerBoundingBox = new Vector2()
+      simplePath.boundingBox.getCenter(centerBoundingBox)
 
-        scanlineIntersections.forEach((i) => {
-          if (i.identifier === simplePath.identifier) {
-            baseIntersections.push(i)
-          } else {
-            otherIntersections.push(i)
-          }
-        })
+      const scanline = [new Vector2(scanlineMinX, centerBoundingBox.y), new Vector2(scanlineMaxX, centerBoundingBox.y)]
 
-        const firstXOfPath = baseIntersections[0].point.x
+      const scanlineIntersections = getScanlineIntersections(scanline, simplePath.boundingBox, allPaths)
 
-        // build up the path hierarchy
-        const stack = []
-        let i = 0
+      scanlineIntersections.sort((i1, i2) => {
+        return i1.point.x - i2.point.x
+      })
 
-        while (i < otherIntersections.length && otherIntersections[i].point.x < firstXOfPath) {
-          if (stack.length > 0 && stack[stack.length - 1] === otherIntersections[i].identifier) {
-            stack.pop()
-          } else {
-            stack.push(otherIntersections[i].identifier)
-          }
+      const baseIntersections = []
+      const otherIntersections = []
 
-          i++
+      scanlineIntersections.forEach((i) => {
+        if (i.identifier === simplePath.identifier) {
+          baseIntersections.push(i)
+        } else {
+          otherIntersections.push(i)
         }
+      })
 
-        stack.push(simplePath.identifier)
-
-        if (_fillRule === 'evenodd') {
-          const isHole = stack.length % 2 === 0 ? true : false
-          const isHoleFor = stack[stack.length - 2]
-
-          return { identifier: simplePath.identifier, isHole: isHole, for: isHoleFor }
-        } else if (_fillRule === 'nonzero') {
-          // check if path is a hole by counting the amount of paths with alternating rotations it has to cross.
-          let isHole = true
-          let isHoleFor = null
-          let lastCWValue = null
-
-          for (let i = 0; i < stack.length; i++) {
-            const identifier = stack[i]
-            if (isHole) {
-              lastCWValue = allPaths[identifier].isCW
-              isHole = false
-              isHoleFor = identifier
-            } else if (lastCWValue !== allPaths[identifier].isCW) {
-              lastCWValue = allPaths[identifier].isCW
-              isHole = true
-            }
-          }
+      const firstXOfPath = baseIntersections[0].point.x
+
+      // build up the path hierarchy
+      const stack = []
+      let i = 0
 
-          return { identifier: simplePath.identifier, isHole: isHole, for: isHoleFor }
+      while (i < otherIntersections.length && otherIntersections[i].point.x < firstXOfPath) {
+        if (stack.length > 0 && stack[stack.length - 1] === otherIntersections[i].identifier) {
+          stack.pop()
         } else {
-          console.warn('fill-rule: "' + _fillRule + '" is currently not implemented.')
+          stack.push(otherIntersections[i].identifier)
         }
-      }
-
-      // check for self intersecting paths
-      // TODO
 
-      // check intersecting paths
-      // TODO
+        i++
+      }
 
-      // prepare paths for hole detection
-      let scanlineMinX = BIGNUMBER
-      let scanlineMaxX = -BIGNUMBER
+      stack.push(simplePath.identifier)
+
+      if (_fillRule === 'evenodd') {
+        const isHole = stack.length % 2 === 0 ? true : false
+        const isHoleFor = stack[stack.length - 2]
+
+        return { identifier: simplePath.identifier, isHole: isHole, for: isHoleFor }
+      } else if (_fillRule === 'nonzero') {
+        // check if path is a hole by counting the amount of paths with alternating rotations it has to cross.
+        let isHole = true
+        let isHoleFor = null
+        let lastCWValue = null
+
+        for (let i = 0; i < stack.length; i++) {
+          const identifier = stack[i]
+          if (isHole) {
+            lastCWValue = allPaths[identifier].isCW
+            isHole = false
+            isHoleFor = identifier
+          } else if (lastCWValue !== allPaths[identifier].isCW) {
+            lastCWValue = allPaths[identifier].isCW
+            isHole = true
+          }
+        }
 
-      let simplePaths = shapePath.subPaths.map((p) => {
-        const points = p.getPoints()
-        let maxY = -BIGNUMBER
-        let minY = BIGNUMBER
-        let maxX = -BIGNUMBER
-        let minX = BIGNUMBER
+        return { identifier: simplePath.identifier, isHole: isHole, for: isHoleFor }
+      } else {
+        console.warn('fill-rule: "' + _fillRule + '" is currently not implemented.')
+      }
+    }
 
-        //points.forEach(p => p.y *= -1);
+    // check for self intersecting paths
+    // TODO
 
-        for (let i = 0; i < points.length; i++) {
-          const p = points[i]
+    // check intersecting paths
+    // TODO
 
-          if (p.y > maxY) {
-            maxY = p.y
-          }
+    // prepare paths for hole detection
+    let scanlineMinX = BIGNUMBER
+    let scanlineMaxX = -BIGNUMBER
 
-          if (p.y < minY) {
-            minY = p.y
-          }
+    let simplePaths = shapePath.subPaths.map((p) => {
+      const points = p.getPoints()
+      let maxY = -BIGNUMBER
+      let minY = BIGNUMBER
+      let maxX = -BIGNUMBER
+      let minX = BIGNUMBER
 
-          if (p.x > maxX) {
-            maxX = p.x
-          }
+      //points.forEach(p => p.y *= -1);
 
-          if (p.x < minX) {
-            minX = p.x
-          }
-        }
+      for (let i = 0; i < points.length; i++) {
+        const p = points[i]
 
-        //
-        if (scanlineMaxX <= maxX) {
-          scanlineMaxX = maxX + 1
+        if (p.y > maxY) {
+          maxY = p.y
         }
 
-        if (scanlineMinX >= minX) {
-          scanlineMinX = minX - 1
+        if (p.y < minY) {
+          minY = p.y
         }
 
-        return {
-          curves: p.curves,
-          points: points,
-          isCW: ShapeUtils.isClockWise(points),
-          identifier: -1,
-          boundingBox: new Box2(new Vector2(minX, minY), new Vector2(maxX, maxY)),
+        if (p.x > maxX) {
+          maxX = p.x
         }
-      })
 
-      simplePaths = simplePaths.filter((sp) => sp.points.length > 1)
-
-      for (let identifier = 0; identifier < simplePaths.length; identifier++) {
-        simplePaths[identifier].identifier = identifier
-      }
-
-      // check if path is solid or a hole
-      const isAHole = simplePaths.map((p) =>
-        isHoleTo(
-          p,
-          simplePaths,
-          scanlineMinX,
-          scanlineMaxX,
-          shapePath.userData ? shapePath.userData.style.fillRule : undefined,
-        ),
-      )
-
-      const shapesToReturn = []
-      simplePaths.forEach((p) => {
-        const amIAHole = isAHole[p.identifier]
-
-        if (!amIAHole.isHole) {
-          const shape = new Shape()
-          shape.curves = p.curves
-          const holes = isAHole.filter((h) => h.isHole && h.for === p.identifier)
-          holes.forEach((h) => {
-            const hole = simplePaths[h.identifier]
-            const path = new Path()
-            path.curves = hole.curves
-            shape.holes.push(path)
-          })
-          shapesToReturn.push(shape)
+        if (p.x < minX) {
+          minX = p.x
         }
-      })
-
-      return shapesToReturn
-    }
+      }
 
-    static getStrokeStyle(width, color, lineJoin, lineCap, miterLimit) {
-      // Param width: Stroke width
-      // Param color: As returned by THREE.Color.getStyle()
-      // Param lineJoin: One of "round", "bevel", "miter" or "miter-limit"
-      // Param lineCap: One of "round", "square" or "butt"
-      // Param miterLimit: Maximum join length, in multiples of the "width" parameter (join is truncated if it exceeds that distance)
-      // Returns style object
+      //
+      if (scanlineMaxX <= maxX) {
+        scanlineMaxX = maxX + 1
+      }
 
-      width = width !== undefined ? width : 1
-      color = color !== undefined ? color : '#000'
-      lineJoin = lineJoin !== undefined ? lineJoin : 'miter'
-      lineCap = lineCap !== undefined ? lineCap : 'butt'
-      miterLimit = miterLimit !== undefined ? miterLimit : 4
+      if (scanlineMinX >= minX) {
+        scanlineMinX = minX - 1
+      }
 
       return {
-        strokeColor: color,
-        strokeWidth: width,
-        strokeLineJoin: lineJoin,
-        strokeLineCap: lineCap,
-        strokeMiterLimit: miterLimit,
+        curves: p.curves,
+        points: points,
+        isCW: ShapeUtils.isClockWise(points),
+        identifier: -1,
+        boundingBox: new Box2(new Vector2(minX, minY), new Vector2(maxX, maxY)),
       }
-    }
+    })
 
-    static pointsToStroke(points, style, arcDivisions, minDistance) {
-      // Generates a stroke with some width around the given path.
-      // The path can be open or closed (last point equals to first point)
-      // Param points: Array of Vector2D (the path). Minimum 2 points.
-      // Param style: Object with SVG properties as returned by SVGLoader.getStrokeStyle(), or SVGLoader.parse() in the path.userData.style object
-      // Params arcDivisions: Arc divisions for round joins and endcaps. (Optional)
-      // Param minDistance: Points closer to this distance will be merged. (Optional)
-      // Returns BufferGeometry with stroke triangles (In plane z = 0). UV coordinates are generated ('u' along path. 'v' across it, from left to right)
+    simplePaths = simplePaths.filter((sp) => sp.points.length > 1)
 
-      const vertices = []
-      const normals = []
-      const uvs = []
+    for (let identifier = 0; identifier < simplePaths.length; identifier++) {
+      simplePaths[identifier].identifier = identifier
+    }
 
-      if (SVGLoader.pointsToStrokeWithBuffers(points, style, arcDivisions, minDistance, vertices, normals, uvs) === 0) {
-        return null
+    // check if path is solid or a hole
+    const isAHole = simplePaths.map((p) =>
+      isHoleTo(
+        p,
+        simplePaths,
+        scanlineMinX,
+        scanlineMaxX,
+        shapePath.userData ? shapePath.userData.style.fillRule : undefined,
+      ),
+    )
+
+    const shapesToReturn = []
+    simplePaths.forEach((p) => {
+      const amIAHole = isAHole[p.identifier]
+
+      if (!amIAHole.isHole) {
+        const shape = new Shape()
+        shape.curves = p.curves
+        const holes = isAHole.filter((h) => h.isHole && h.for === p.identifier)
+        holes.forEach((h) => {
+          const hole = simplePaths[h.identifier]
+          const path = new Path()
+          path.curves = hole.curves
+          shape.holes.push(path)
+        })
+        shapesToReturn.push(shape)
       }
+    })
 
-      const geometry = new BufferGeometry()
-      geometry.setAttribute('position', new Float32BufferAttribute(vertices, 3))
-      geometry.setAttribute('normal', new Float32BufferAttribute(normals, 3))
-      geometry.setAttribute('uv', new Float32BufferAttribute(uvs, 2))
+    return shapesToReturn
+  }
 
-      return geometry
+  static getStrokeStyle(width, color, lineJoin, lineCap, miterLimit) {
+    // Param width: Stroke width
+    // Param color: As returned by THREE.Color.getStyle()
+    // Param lineJoin: One of "round", "bevel", "miter" or "miter-limit"
+    // Param lineCap: One of "round", "square" or "butt"
+    // Param miterLimit: Maximum join length, in multiples of the "width" parameter (join is truncated if it exceeds that distance)
+    // Returns style object
+
+    width = width !== undefined ? width : 1
+    color = color !== undefined ? color : '#000'
+    lineJoin = lineJoin !== undefined ? lineJoin : 'miter'
+    lineCap = lineCap !== undefined ? lineCap : 'butt'
+    miterLimit = miterLimit !== undefined ? miterLimit : 4
+
+    return {
+      strokeColor: color,
+      strokeWidth: width,
+      strokeLineJoin: lineJoin,
+      strokeLineCap: lineCap,
+      strokeMiterLimit: miterLimit,
     }
+  }
 
-    static pointsToStrokeWithBuffers(points, style, arcDivisions, minDistance, vertices, normals, uvs, vertexOffset) {
-      // This function can be called to update existing arrays or buffers.
-      // Accepts same parameters as pointsToStroke, plus the buffers and optional offset.
-      // Param vertexOffset: Offset vertices to start writing in the buffers (3 elements/vertex for vertices and normals, and 2 elements/vertex for uvs)
-      // Returns number of written vertices / normals / uvs pairs
-      // if 'vertices' parameter is undefined no triangles will be generated, but the returned vertices count will still be valid (useful to preallocate the buffers)
-      // 'normals' and 'uvs' buffers are optional
-
-      const tempV2_1 = new Vector2()
-      const tempV2_2 = new Vector2()
-      const tempV2_3 = new Vector2()
-      const tempV2_4 = new Vector2()
-      const tempV2_5 = new Vector2()
-      const tempV2_6 = new Vector2()
-      const tempV2_7 = new Vector2()
-      const lastPointL = new Vector2()
-      const lastPointR = new Vector2()
-      const point0L = new Vector2()
-      const point0R = new Vector2()
-      const currentPointL = new Vector2()
-      const currentPointR = new Vector2()
-      const nextPointL = new Vector2()
-      const nextPointR = new Vector2()
-      const innerPoint = new Vector2()
-      const outerPoint = new Vector2()
-
-      arcDivisions = arcDivisions !== undefined ? arcDivisions : 12
-      minDistance = minDistance !== undefined ? minDistance : 0.001
-      vertexOffset = vertexOffset !== undefined ? vertexOffset : 0
-
-      // First ensure there are no duplicated points
-      points = removeDuplicatedPoints(points)
-
-      const numPoints = points.length
-
-      if (numPoints < 2) return 0
-
-      const isClosed = points[0].equals(points[numPoints - 1])
-
-      let currentPoint
-      let previousPoint = points[0]
-      let nextPoint
-
-      const strokeWidth2 = style.strokeWidth / 2
-
-      const deltaU = 1 / (numPoints - 1)
-      let u0 = 0,
-        u1
-
-      let innerSideModified
-      let joinIsOnLeftSide
-      let isMiter
-      let initialJoinIsOnLeftSide = false
-
-      let numVertices = 0
-      let currentCoordinate = vertexOffset * 3
-      let currentCoordinateUV = vertexOffset * 2
-
-      // Get initial left and right stroke points
-      getNormal(points[0], points[1], tempV2_1).multiplyScalar(strokeWidth2)
-      lastPointL.copy(points[0]).sub(tempV2_1)
-      lastPointR.copy(points[0]).add(tempV2_1)
-      point0L.copy(lastPointL)
-      point0R.copy(lastPointR)
-
-      for (let iPoint = 1; iPoint < numPoints; iPoint++) {
-        currentPoint = points[iPoint]
-
-        // Get next point
-        if (iPoint === numPoints - 1) {
-          if (isClosed) {
-            // Skip duplicated initial point
-            nextPoint = points[1]
-          } else nextPoint = undefined
-        } else {
-          nextPoint = points[iPoint + 1]
-        }
+  static pointsToStroke(points, style, arcDivisions, minDistance) {
+    // Generates a stroke with some width around the given path.
+    // The path can be open or closed (last point equals to first point)
+    // Param points: Array of Vector2D (the path). Minimum 2 points.
+    // Param style: Object with SVG properties as returned by SVGLoader.getStrokeStyle(), or SVGLoader.parse() in the path.userData.style object
+    // Params arcDivisions: Arc divisions for round joins and endcaps. (Optional)
+    // Param minDistance: Points closer to this distance will be merged. (Optional)
+    // Returns BufferGeometry with stroke triangles (In plane z = 0). UV coordinates are generated ('u' along path. 'v' across it, from left to right)
+
+    const vertices = []
+    const normals = []
+    const uvs = []
+
+    if (SVGLoader.pointsToStrokeWithBuffers(points, style, arcDivisions, minDistance, vertices, normals, uvs) === 0) {
+      return null
+    }
+
+    const geometry = new BufferGeometry()
+    geometry.setAttribute('position', new Float32BufferAttribute(vertices, 3))
+    geometry.setAttribute('normal', new Float32BufferAttribute(normals, 3))
+    geometry.setAttribute('uv', new Float32BufferAttribute(uvs, 2))
 
-        // Normal of previous segment in tempV2_1
-        const normal1 = tempV2_1
-        getNormal(previousPoint, currentPoint, normal1)
+    return geometry
+  }
 
-        tempV2_3.copy(normal1).multiplyScalar(strokeWidth2)
-        currentPointL.copy(currentPoint).sub(tempV2_3)
-        currentPointR.copy(currentPoint).add(tempV2_3)
+  static pointsToStrokeWithBuffers(points, style, arcDivisions, minDistance, vertices, normals, uvs, vertexOffset) {
+    // This function can be called to update existing arrays or buffers.
+    // Accepts same parameters as pointsToStroke, plus the buffers and optional offset.
+    // Param vertexOffset: Offset vertices to start writing in the buffers (3 elements/vertex for vertices and normals, and 2 elements/vertex for uvs)
+    // Returns number of written vertices / normals / uvs pairs
+    // if 'vertices' parameter is undefined no triangles will be generated, but the returned vertices count will still be valid (useful to preallocate the buffers)
+    // 'normals' and 'uvs' buffers are optional
+
+    const tempV2_1 = new Vector2()
+    const tempV2_2 = new Vector2()
+    const tempV2_3 = new Vector2()
+    const tempV2_4 = new Vector2()
+    const tempV2_5 = new Vector2()
+    const tempV2_6 = new Vector2()
+    const tempV2_7 = new Vector2()
+    const lastPointL = new Vector2()
+    const lastPointR = new Vector2()
+    const point0L = new Vector2()
+    const point0R = new Vector2()
+    const currentPointL = new Vector2()
+    const currentPointR = new Vector2()
+    const nextPointL = new Vector2()
+    const nextPointR = new Vector2()
+    const innerPoint = new Vector2()
+    const outerPoint = new Vector2()
+
+    arcDivisions = arcDivisions !== undefined ? arcDivisions : 12
+    minDistance = minDistance !== undefined ? minDistance : 0.001
+    vertexOffset = vertexOffset !== undefined ? vertexOffset : 0
+
+    // First ensure there are no duplicated points
+    points = removeDuplicatedPoints(points)
+
+    const numPoints = points.length
+
+    if (numPoints < 2) return 0
+
+    const isClosed = points[0].equals(points[numPoints - 1])
+
+    let currentPoint
+    let previousPoint = points[0]
+    let nextPoint
+
+    const strokeWidth2 = style.strokeWidth / 2
+
+    const deltaU = 1 / (numPoints - 1)
+    let u0 = 0,
+      u1
+
+    let innerSideModified
+    let joinIsOnLeftSide
+    let isMiter
+    let initialJoinIsOnLeftSide = false
+
+    let numVertices = 0
+    let currentCoordinate = vertexOffset * 3
+    let currentCoordinateUV = vertexOffset * 2
+
+    // Get initial left and right stroke points
+    getNormal(points[0], points[1], tempV2_1).multiplyScalar(strokeWidth2)
+    lastPointL.copy(points[0]).sub(tempV2_1)
+    lastPointR.copy(points[0]).add(tempV2_1)
+    point0L.copy(lastPointL)
+    point0R.copy(lastPointR)
+
+    for (let iPoint = 1; iPoint < numPoints; iPoint++) {
+      currentPoint = points[iPoint]
+
+      // Get next point
+      if (iPoint === numPoints - 1) {
+        if (isClosed) {
+          // Skip duplicated initial point
+          nextPoint = points[1]
+        } else nextPoint = undefined
+      } else {
+        nextPoint = points[iPoint + 1]
+      }
 
-        u1 = u0 + deltaU
+      // Normal of previous segment in tempV2_1
+      const normal1 = tempV2_1
+      getNormal(previousPoint, currentPoint, normal1)
+
+      tempV2_3.copy(normal1).multiplyScalar(strokeWidth2)
+      currentPointL.copy(currentPoint).sub(tempV2_3)
+      currentPointR.copy(currentPoint).add(tempV2_3)
+
+      u1 = u0 + deltaU
+
+      innerSideModified = false
+
+      if (nextPoint !== undefined) {
+        // Normal of next segment in tempV2_2
+        getNormal(currentPoint, nextPoint, tempV2_2)
+
+        tempV2_3.copy(tempV2_2).multiplyScalar(strokeWidth2)
+        nextPointL.copy(currentPoint).sub(tempV2_3)
+        nextPointR.copy(currentPoint).add(tempV2_3)
+
+        joinIsOnLeftSide = true
+        tempV2_3.subVectors(nextPoint, previousPoint)
+        if (normal1.dot(tempV2_3) < 0) {
+          joinIsOnLeftSide = false
+        }
+
+        if (iPoint === 1) initialJoinIsOnLeftSide = joinIsOnLeftSide
+
+        tempV2_3.subVectors(nextPoint, currentPoint)
+        tempV2_3.normalize()
+        const dot = Math.abs(normal1.dot(tempV2_3))
+
+        // If path is straight, don't create join
+        if (dot > Number.EPSILON) {
+          // Compute inner and outer segment intersections
+          const miterSide = strokeWidth2 / dot
+          tempV2_3.multiplyScalar(-miterSide)
+          tempV2_4.subVectors(currentPoint, previousPoint)
+          tempV2_5.copy(tempV2_4).setLength(miterSide).add(tempV2_3)
+          innerPoint.copy(tempV2_5).negate()
+          const miterLength2 = tempV2_5.length()
+          const segmentLengthPrev = tempV2_4.length()
+          tempV2_4.divideScalar(segmentLengthPrev)
+          tempV2_6.subVectors(nextPoint, currentPoint)
+          const segmentLengthNext = tempV2_6.length()
+          tempV2_6.divideScalar(segmentLengthNext)
+          // Check that previous and next segments doesn't overlap with the innerPoint of intersection
+          if (tempV2_4.dot(innerPoint) < segmentLengthPrev && tempV2_6.dot(innerPoint) < segmentLengthNext) {
+            innerSideModified = true
+          }
 
-        innerSideModified = false
+          outerPoint.copy(tempV2_5).add(currentPoint)
+          innerPoint.add(currentPoint)
 
-        if (nextPoint !== undefined) {
-          // Normal of next segment in tempV2_2
-          getNormal(currentPoint, nextPoint, tempV2_2)
+          isMiter = false
 
-          tempV2_3.copy(tempV2_2).multiplyScalar(strokeWidth2)
-          nextPointL.copy(currentPoint).sub(tempV2_3)
-          nextPointR.copy(currentPoint).add(tempV2_3)
+          if (innerSideModified) {
+            if (joinIsOnLeftSide) {
+              nextPointR.copy(innerPoint)
+              currentPointR.copy(innerPoint)
+            } else {
+              nextPointL.copy(innerPoint)
+              currentPointL.copy(innerPoint)
+            }
+          } else {
+            // The segment triangles are generated here if there was overlapping
 
-          joinIsOnLeftSide = true
-          tempV2_3.subVectors(nextPoint, previousPoint)
-          if (normal1.dot(tempV2_3) < 0) {
-            joinIsOnLeftSide = false
+            makeSegmentTriangles()
           }
 
-          if (iPoint === 1) initialJoinIsOnLeftSide = joinIsOnLeftSide
-
-          tempV2_3.subVectors(nextPoint, currentPoint)
-          tempV2_3.normalize()
-          const dot = Math.abs(normal1.dot(tempV2_3))
-
-          // If path is straight, don't create join
-          if (dot > Number.EPSILON) {
-            // Compute inner and outer segment intersections
-            const miterSide = strokeWidth2 / dot
-            tempV2_3.multiplyScalar(-miterSide)
-            tempV2_4.subVectors(currentPoint, previousPoint)
-            tempV2_5.copy(tempV2_4).setLength(miterSide).add(tempV2_3)
-            innerPoint.copy(tempV2_5).negate()
-            const miterLength2 = tempV2_5.length()
-            const segmentLengthPrev = tempV2_4.length()
-            tempV2_4.divideScalar(segmentLengthPrev)
-            tempV2_6.subVectors(nextPoint, currentPoint)
-            const segmentLengthNext = tempV2_6.length()
-            tempV2_6.divideScalar(segmentLengthNext)
-            // Check that previous and next segments doesn't overlap with the innerPoint of intersection
-            if (tempV2_4.dot(innerPoint) < segmentLengthPrev && tempV2_6.dot(innerPoint) < segmentLengthNext) {
-              innerSideModified = true
-            }
+          switch (style.strokeLineJoin) {
+            case 'bevel':
+              makeSegmentWithBevelJoin(joinIsOnLeftSide, innerSideModified, u1)
+
+              break
 
-            outerPoint.copy(tempV2_5).add(currentPoint)
-            innerPoint.add(currentPoint)
+            case 'round':
+              // Segment triangles
 
-            isMiter = false
+              createSegmentTrianglesWithMiddleSection(joinIsOnLeftSide, innerSideModified)
+
+              // Join triangles
 
-            if (innerSideModified) {
               if (joinIsOnLeftSide) {
-                nextPointR.copy(innerPoint)
-                currentPointR.copy(innerPoint)
+                makeCircularSector(currentPoint, currentPointL, nextPointL, u1, 0)
               } else {
-                nextPointL.copy(innerPoint)
-                currentPointL.copy(innerPoint)
+                makeCircularSector(currentPoint, nextPointR, currentPointR, u1, 1)
               }
-            } else {
-              // The segment triangles are generated here if there was overlapping
-
-              makeSegmentTriangles()
-            }
 
-            switch (style.strokeLineJoin) {
-              case 'bevel':
-                makeSegmentWithBevelJoin(joinIsOnLeftSide, innerSideModified, u1)
+              break
 
-                break
+            case 'miter':
+            case 'miter-clip':
+            default:
+              const miterFraction = (strokeWidth2 * style.strokeMiterLimit) / miterLength2
 
-              case 'round':
-                // Segment triangles
+              if (miterFraction < 1) {
+                // The join miter length exceeds the miter limit
 
-                createSegmentTrianglesWithMiddleSection(joinIsOnLeftSide, innerSideModified)
+                if (style.strokeLineJoin !== 'miter-clip') {
+                  makeSegmentWithBevelJoin(joinIsOnLeftSide, innerSideModified, u1)
+                  break
+                } else {
+                  // Segment triangles
 
-                // Join triangles
+                  createSegmentTrianglesWithMiddleSection(joinIsOnLeftSide, innerSideModified)
 
-                if (joinIsOnLeftSide) {
-                  makeCircularSector(currentPoint, currentPointL, nextPointL, u1, 0)
-                } else {
-                  makeCircularSector(currentPoint, nextPointR, currentPointR, u1, 1)
-                }
+                  // Miter-clip join triangles
 
-                break
+                  if (joinIsOnLeftSide) {
+                    tempV2_6.subVectors(outerPoint, currentPointL).multiplyScalar(miterFraction).add(currentPointL)
+                    tempV2_7.subVectors(outerPoint, nextPointL).multiplyScalar(miterFraction).add(nextPointL)
 
-              case 'miter':
-              case 'miter-clip':
-              default:
-                const miterFraction = (strokeWidth2 * style.strokeMiterLimit) / miterLength2
+                    addVertex(currentPointL, u1, 0)
+                    addVertex(tempV2_6, u1, 0)
+                    addVertex(currentPoint, u1, 0.5)
 
-                if (miterFraction < 1) {
-                  // The join miter length exceeds the miter limit
+                    addVertex(currentPoint, u1, 0.5)
+                    addVertex(tempV2_6, u1, 0)
+                    addVertex(tempV2_7, u1, 0)
 
-                  if (style.strokeLineJoin !== 'miter-clip') {
-                    makeSegmentWithBevelJoin(joinIsOnLeftSide, innerSideModified, u1)
-                    break
+                    addVertex(currentPoint, u1, 0.5)
+                    addVertex(tempV2_7, u1, 0)
+                    addVertex(nextPointL, u1, 0)
                   } else {
-                    // Segment triangles
+                    tempV2_6.subVectors(outerPoint, currentPointR).multiplyScalar(miterFraction).add(currentPointR)
+                    tempV2_7.subVectors(outerPoint, nextPointR).multiplyScalar(miterFraction).add(nextPointR)
 
-                    createSegmentTrianglesWithMiddleSection(joinIsOnLeftSide, innerSideModified)
+                    addVertex(currentPointR, u1, 1)
+                    addVertex(tempV2_6, u1, 1)
+                    addVertex(currentPoint, u1, 0.5)
 
-                    // Miter-clip join triangles
+                    addVertex(currentPoint, u1, 0.5)
+                    addVertex(tempV2_6, u1, 1)
+                    addVertex(tempV2_7, u1, 1)
 
-                    if (joinIsOnLeftSide) {
-                      tempV2_6.subVectors(outerPoint, currentPointL).multiplyScalar(miterFraction).add(currentPointL)
-                      tempV2_7.subVectors(outerPoint, nextPointL).multiplyScalar(miterFraction).add(nextPointL)
-
-                      addVertex(currentPointL, u1, 0)
-                      addVertex(tempV2_6, u1, 0)
-                      addVertex(currentPoint, u1, 0.5)
+                    addVertex(currentPoint, u1, 0.5)
+                    addVertex(tempV2_7, u1, 1)
+                    addVertex(nextPointR, u1, 1)
+                  }
+                }
+              } else {
+                // Miter join segment triangles
 
-                      addVertex(currentPoint, u1, 0.5)
-                      addVertex(tempV2_6, u1, 0)
-                      addVertex(tempV2_7, u1, 0)
+                if (innerSideModified) {
+                  // Optimized segment + join triangles
 
-                      addVertex(currentPoint, u1, 0.5)
-                      addVertex(tempV2_7, u1, 0)
-                      addVertex(nextPointL, u1, 0)
-                    } else {
-                      tempV2_6.subVectors(outerPoint, currentPointR).multiplyScalar(miterFraction).add(currentPointR)
-                      tempV2_7.subVectors(outerPoint, nextPointR).multiplyScalar(miterFraction).add(nextPointR)
+                  if (joinIsOnLeftSide) {
+                    addVertex(lastPointR, u0, 1)
+                    addVertex(lastPointL, u0, 0)
+                    addVertex(outerPoint, u1, 0)
 
-                      addVertex(currentPointR, u1, 1)
-                      addVertex(tempV2_6, u1, 1)
-                      addVertex(currentPoint, u1, 0.5)
+                    addVertex(lastPointR, u0, 1)
+                    addVertex(outerPoint, u1, 0)
+                    addVertex(innerPoint, u1, 1)
+                  } else {
+                    addVertex(lastPointR, u0, 1)
+                    addVertex(lastPointL, u0, 0)
+                    addVertex(outerPoint, u1, 1)
 
-                      addVertex(currentPoint, u1, 0.5)
-                      addVertex(tempV2_6, u1, 1)
-                      addVertex(tempV2_7, u1, 1)
+                    addVertex(lastPointL, u0, 0)
+                    addVertex(innerPoint, u1, 0)
+                    addVertex(outerPoint, u1, 1)
+                  }
 
-                      addVertex(currentPoint, u1, 0.5)
-                      addVertex(tempV2_7, u1, 1)
-                      addVertex(nextPointR, u1, 1)
-                    }
+                  if (joinIsOnLeftSide) {
+                    nextPointL.copy(outerPoint)
+                  } else {
+                    nextPointR.copy(outerPoint)
                   }
                 } else {
-                  // Miter join segment triangles
-
-                  if (innerSideModified) {
-                    // Optimized segment + join triangles
-
-                    if (joinIsOnLeftSide) {
-                      addVertex(lastPointR, u0, 1)
-                      addVertex(lastPointL, u0, 0)
-                      addVertex(outerPoint, u1, 0)
-
-                      addVertex(lastPointR, u0, 1)
-                      addVertex(outerPoint, u1, 0)
-                      addVertex(innerPoint, u1, 1)
-                    } else {
-                      addVertex(lastPointR, u0, 1)
-                      addVertex(lastPointL, u0, 0)
-                      addVertex(outerPoint, u1, 1)
-
-                      addVertex(lastPointL, u0, 0)
-                      addVertex(innerPoint, u1, 0)
-                      addVertex(outerPoint, u1, 1)
-                    }
-
-                    if (joinIsOnLeftSide) {
-                      nextPointL.copy(outerPoint)
-                    } else {
-                      nextPointR.copy(outerPoint)
-                    }
+                  // Add extra miter join triangles
+
+                  if (joinIsOnLeftSide) {
+                    addVertex(currentPointL, u1, 0)
+                    addVertex(outerPoint, u1, 0)
+                    addVertex(currentPoint, u1, 0.5)
+
+                    addVertex(currentPoint, u1, 0.5)
+                    addVertex(outerPoint, u1, 0)
+                    addVertex(nextPointL, u1, 0)
                   } else {
-                    // Add extra miter join triangles
-
-                    if (joinIsOnLeftSide) {
-                      addVertex(currentPointL, u1, 0)
-                      addVertex(outerPoint, u1, 0)
-                      addVertex(currentPoint, u1, 0.5)
-
-                      addVertex(currentPoint, u1, 0.5)
-                      addVertex(outerPoint, u1, 0)
-                      addVertex(nextPointL, u1, 0)
-                    } else {
-                      addVertex(currentPointR, u1, 1)
-                      addVertex(outerPoint, u1, 1)
-                      addVertex(currentPoint, u1, 0.5)
-
-                      addVertex(currentPoint, u1, 0.5)
-                      addVertex(outerPoint, u1, 1)
-                      addVertex(nextPointR, u1, 1)
-                    }
-                  }
+                    addVertex(currentPointR, u1, 1)
+                    addVertex(outerPoint, u1, 1)
+                    addVertex(currentPoint, u1, 0.5)
 
-                  isMiter = true
+                    addVertex(currentPoint, u1, 0.5)
+                    addVertex(outerPoint, u1, 1)
+                    addVertex(nextPointR, u1, 1)
+                  }
                 }
 
-                break
-            }
-          } else {
-            // The segment triangles are generated here when two consecutive points are collinear
+                isMiter = true
+              }
 
-            makeSegmentTriangles()
+              break
           }
         } else {
-          // The segment triangles are generated here if it is the ending segment
+          // The segment triangles are generated here when two consecutive points are collinear
 
           makeSegmentTriangles()
         }
+      } else {
+        // The segment triangles are generated here if it is the ending segment
 
-        if (!isClosed && iPoint === numPoints - 1) {
-          // Start line endcap
-          addCapGeometry(points[0], point0L, point0R, joinIsOnLeftSide, true, u0)
-        }
+        makeSegmentTriangles()
+      }
 
-        // Increment loop variables
+      if (!isClosed && iPoint === numPoints - 1) {
+        // Start line endcap
+        addCapGeometry(points[0], point0L, point0R, joinIsOnLeftSide, true, u0)
+      }
 
-        u0 = u1
+      // Increment loop variables
 
-        previousPoint = currentPoint
+      u0 = u1
 
-        lastPointL.copy(nextPointL)
-        lastPointR.copy(nextPointR)
-      }
+      previousPoint = currentPoint
 
-      if (!isClosed) {
-        // Ending line endcap
-        addCapGeometry(currentPoint, currentPointL, currentPointR, joinIsOnLeftSide, false, u1)
-      } else if (innerSideModified && vertices) {
-        // Modify path first segment vertices to adjust to the segments inner and outer intersections
+      lastPointL.copy(nextPointL)
+      lastPointR.copy(nextPointR)
+    }
 
-        let lastOuter = outerPoint
-        let lastInner = innerPoint
+    if (!isClosed) {
+      // Ending line endcap
+      addCapGeometry(currentPoint, currentPointL, currentPointR, joinIsOnLeftSide, false, u1)
+    } else if (innerSideModified && vertices) {
+      // Modify path first segment vertices to adjust to the segments inner and outer intersections
 
-        if (initialJoinIsOnLeftSide !== joinIsOnLeftSide) {
-          lastOuter = innerPoint
-          lastInner = outerPoint
-        }
+      let lastOuter = outerPoint
+      let lastInner = innerPoint
 
-        if (joinIsOnLeftSide) {
-          if (isMiter || initialJoinIsOnLeftSide) {
-            lastInner.toArray(vertices, 0 * 3)
-            lastInner.toArray(vertices, 3 * 3)
+      if (initialJoinIsOnLeftSide !== joinIsOnLeftSide) {
+        lastOuter = innerPoint
+        lastInner = outerPoint
+      }
 
-            if (isMiter) {
-              lastOuter.toArray(vertices, 1 * 3)
-            }
+      if (joinIsOnLeftSide) {
+        if (isMiter || initialJoinIsOnLeftSide) {
+          lastInner.toArray(vertices, 0 * 3)
+          lastInner.toArray(vertices, 3 * 3)
+
+          if (isMiter) {
+            lastOuter.toArray(vertices, 1 * 3)
           }
-        } else {
-          if (isMiter || !initialJoinIsOnLeftSide) {
-            lastInner.toArray(vertices, 1 * 3)
-            lastInner.toArray(vertices, 3 * 3)
+        }
+      } else {
+        if (isMiter || !initialJoinIsOnLeftSide) {
+          lastInner.toArray(vertices, 1 * 3)
+          lastInner.toArray(vertices, 3 * 3)
 
-            if (isMiter) {
-              lastOuter.toArray(vertices, 0 * 3)
-            }
+          if (isMiter) {
+            lastOuter.toArray(vertices, 0 * 3)
           }
         }
       }
+    }
 
-      return numVertices
+    return numVertices
 
-      // -- End of algorithm
+    // -- End of algorithm
 
-      // -- Functions
+    // -- Functions
 
-      function getNormal(p1, p2, result) {
-        result.subVectors(p2, p1)
-        return result.set(-result.y, result.x).normalize()
-      }
+    function getNormal(p1, p2, result) {
+      result.subVectors(p2, p1)
+      return result.set(-result.y, result.x).normalize()
+    }
 
-      function addVertex(position, u, v) {
-        if (vertices) {
-          vertices[currentCoordinate] = position.x
-          vertices[currentCoordinate + 1] = position.y
-          vertices[currentCoordinate + 2] = 0
+    function addVertex(position, u, v) {
+      if (vertices) {
+        vertices[currentCoordinate] = position.x
+        vertices[currentCoordinate + 1] = position.y
+        vertices[currentCoordinate + 2] = 0
 
-          if (normals) {
-            normals[currentCoordinate] = 0
-            normals[currentCoordinate + 1] = 0
-            normals[currentCoordinate + 2] = 1
-          }
+        if (normals) {
+          normals[currentCoordinate] = 0
+          normals[currentCoordinate + 1] = 0
+          normals[currentCoordinate + 2] = 1
+        }
 
-          currentCoordinate += 3
+        currentCoordinate += 3
 
-          if (uvs) {
-            uvs[currentCoordinateUV] = u
-            uvs[currentCoordinateUV + 1] = v
+        if (uvs) {
+          uvs[currentCoordinateUV] = u
+          uvs[currentCoordinateUV + 1] = v
 
-            currentCoordinateUV += 2
-          }
+          currentCoordinateUV += 2
         }
-
-        numVertices += 3
       }
 
-      function makeCircularSector(center, p1, p2, u, v) {
-        // param p1, p2: Points in the circle arc.
-        // p1 and p2 are in clockwise direction.
-
-        tempV2_1.copy(p1).sub(center).normalize()
-        tempV2_2.copy(p2).sub(center).normalize()
+      numVertices += 3
+    }
 
-        let angle = Math.PI
-        const dot = tempV2_1.dot(tempV2_2)
-        if (Math.abs(dot) < 1) angle = Math.abs(Math.acos(dot))
+    function makeCircularSector(center, p1, p2, u, v) {
+      // param p1, p2: Points in the circle arc.
+      // p1 and p2 are in clockwise direction.
 
-        angle /= arcDivisions
+      tempV2_1.copy(p1).sub(center).normalize()
+      tempV2_2.copy(p2).sub(center).normalize()
 
-        tempV2_3.copy(p1)
+      let angle = Math.PI
+      const dot = tempV2_1.dot(tempV2_2)
+      if (Math.abs(dot) < 1) angle = Math.abs(Math.acos(dot))
 
-        for (let i = 0, il = arcDivisions - 1; i < il; i++) {
-          tempV2_4.copy(tempV2_3).rotateAround(center, angle)
+      angle /= arcDivisions
 
-          addVertex(tempV2_3, u, v)
-          addVertex(tempV2_4, u, v)
-          addVertex(center, u, 0.5)
+      tempV2_3.copy(p1)
 
-          tempV2_3.copy(tempV2_4)
-        }
+      for (let i = 0, il = arcDivisions - 1; i < il; i++) {
+        tempV2_4.copy(tempV2_3).rotateAround(center, angle)
 
+        addVertex(tempV2_3, u, v)
         addVertex(tempV2_4, u, v)
-        addVertex(p2, u, v)
         addVertex(center, u, 0.5)
+
+        tempV2_3.copy(tempV2_4)
       }
 
-      function makeSegmentTriangles() {
-        addVertex(lastPointR, u0, 1)
-        addVertex(lastPointL, u0, 0)
-        addVertex(currentPointL, u1, 0)
+      addVertex(tempV2_4, u, v)
+      addVertex(p2, u, v)
+      addVertex(center, u, 0.5)
+    }
 
-        addVertex(lastPointR, u0, 1)
-        addVertex(currentPointL, u1, 0)
-        addVertex(currentPointR, u1, 1)
-      }
+    function makeSegmentTriangles() {
+      addVertex(lastPointR, u0, 1)
+      addVertex(lastPointL, u0, 0)
+      addVertex(currentPointL, u1, 0)
 
-      function makeSegmentWithBevelJoin(joinIsOnLeftSide, innerSideModified, u) {
-        if (innerSideModified) {
-          // Optimized segment + bevel triangles
+      addVertex(lastPointR, u0, 1)
+      addVertex(currentPointL, u1, 0)
+      addVertex(currentPointR, u1, 1)
+    }
 
-          if (joinIsOnLeftSide) {
-            // Path segments triangles
+    function makeSegmentWithBevelJoin(joinIsOnLeftSide, innerSideModified, u) {
+      if (innerSideModified) {
+        // Optimized segment + bevel triangles
 
-            addVertex(lastPointR, u0, 1)
-            addVertex(lastPointL, u0, 0)
-            addVertex(currentPointL, u1, 0)
+        if (joinIsOnLeftSide) {
+          // Path segments triangles
 
-            addVertex(lastPointR, u0, 1)
-            addVertex(currentPointL, u1, 0)
-            addVertex(innerPoint, u1, 1)
+          addVertex(lastPointR, u0, 1)
+          addVertex(lastPointL, u0, 0)
+          addVertex(currentPointL, u1, 0)
 
-            // Bevel join triangle
+          addVertex(lastPointR, u0, 1)
+          addVertex(currentPointL, u1, 0)
+          addVertex(innerPoint, u1, 1)
 
-            addVertex(currentPointL, u, 0)
-            addVertex(nextPointL, u, 0)
-            addVertex(innerPoint, u, 0.5)
-          } else {
-            // Path segments triangles
+          // Bevel join triangle
 
-            addVertex(lastPointR, u0, 1)
-            addVertex(lastPointL, u0, 0)
-            addVertex(currentPointR, u1, 1)
+          addVertex(currentPointL, u, 0)
+          addVertex(nextPointL, u, 0)
+          addVertex(innerPoint, u, 0.5)
+        } else {
+          // Path segments triangles
 
-            addVertex(lastPointL, u0, 0)
-            addVertex(innerPoint, u1, 0)
-            addVertex(currentPointR, u1, 1)
+          addVertex(lastPointR, u0, 1)
+          addVertex(lastPointL, u0, 0)
+          addVertex(currentPointR, u1, 1)
 
-            // Bevel join triangle
+          addVertex(lastPointL, u0, 0)
+          addVertex(innerPoint, u1, 0)
+          addVertex(currentPointR, u1, 1)
 
-            addVertex(currentPointR, u, 1)
-            addVertex(innerPoint, u, 0)
-            addVertex(nextPointR, u, 1)
-          }
-        } else {
-          // Bevel join triangle. The segment triangles are done in the main loop
+          // Bevel join triangle
 
-          if (joinIsOnLeftSide) {
-            addVertex(currentPointL, u, 0)
-            addVertex(nextPointL, u, 0)
-            addVertex(currentPoint, u, 0.5)
-          } else {
-            addVertex(currentPointR, u, 1)
-            addVertex(nextPointR, u, 0)
-            addVertex(currentPoint, u, 0.5)
-          }
+          addVertex(currentPointR, u, 1)
+          addVertex(innerPoint, u, 0)
+          addVertex(nextPointR, u, 1)
+        }
+      } else {
+        // Bevel join triangle. The segment triangles are done in the main loop
+
+        if (joinIsOnLeftSide) {
+          addVertex(currentPointL, u, 0)
+          addVertex(nextPointL, u, 0)
+          addVertex(currentPoint, u, 0.5)
+        } else {
+          addVertex(currentPointR, u, 1)
+          addVertex(nextPointR, u, 0)
+          addVertex(currentPoint, u, 0.5)
         }
       }
+    }
 
-      function createSegmentTrianglesWithMiddleSection(joinIsOnLeftSide, innerSideModified) {
-        if (innerSideModified) {
-          if (joinIsOnLeftSide) {
-            addVertex(lastPointR, u0, 1)
-            addVertex(lastPointL, u0, 0)
-            addVertex(currentPointL, u1, 0)
+    function createSegmentTrianglesWithMiddleSection(joinIsOnLeftSide, innerSideModified) {
+      if (innerSideModified) {
+        if (joinIsOnLeftSide) {
+          addVertex(lastPointR, u0, 1)
+          addVertex(lastPointL, u0, 0)
+          addVertex(currentPointL, u1, 0)
 
-            addVertex(lastPointR, u0, 1)
-            addVertex(currentPointL, u1, 0)
-            addVertex(innerPoint, u1, 1)
+          addVertex(lastPointR, u0, 1)
+          addVertex(currentPointL, u1, 0)
+          addVertex(innerPoint, u1, 1)
 
-            addVertex(currentPointL, u0, 0)
-            addVertex(currentPoint, u1, 0.5)
-            addVertex(innerPoint, u1, 1)
+          addVertex(currentPointL, u0, 0)
+          addVertex(currentPoint, u1, 0.5)
+          addVertex(innerPoint, u1, 1)
 
-            addVertex(currentPoint, u1, 0.5)
-            addVertex(nextPointL, u0, 0)
-            addVertex(innerPoint, u1, 1)
-          } else {
-            addVertex(lastPointR, u0, 1)
-            addVertex(lastPointL, u0, 0)
-            addVertex(currentPointR, u1, 1)
+          addVertex(currentPoint, u1, 0.5)
+          addVertex(nextPointL, u0, 0)
+          addVertex(innerPoint, u1, 1)
+        } else {
+          addVertex(lastPointR, u0, 1)
+          addVertex(lastPointL, u0, 0)
+          addVertex(currentPointR, u1, 1)
 
-            addVertex(lastPointL, u0, 0)
-            addVertex(innerPoint, u1, 0)
-            addVertex(currentPointR, u1, 1)
+          addVertex(lastPointL, u0, 0)
+          addVertex(innerPoint, u1, 0)
+          addVertex(currentPointR, u1, 1)
 
-            addVertex(currentPointR, u0, 1)
-            addVertex(innerPoint, u1, 0)
-            addVertex(currentPoint, u1, 0.5)
+          addVertex(currentPointR, u0, 1)
+          addVertex(innerPoint, u1, 0)
+          addVertex(currentPoint, u1, 0.5)
 
-            addVertex(currentPoint, u1, 0.5)
-            addVertex(innerPoint, u1, 0)
-            addVertex(nextPointR, u0, 1)
-          }
+          addVertex(currentPoint, u1, 0.5)
+          addVertex(innerPoint, u1, 0)
+          addVertex(nextPointR, u0, 1)
         }
       }
+    }
 
-      function addCapGeometry(center, p1, p2, joinIsOnLeftSide, start, u) {
-        // param center: End point of the path
-        // param p1, p2: Left and right cap points
+    function addCapGeometry(center, p1, p2, joinIsOnLeftSide, start, u) {
+      // param center: End point of the path
+      // param p1, p2: Left and right cap points
 
-        switch (style.strokeLineCap) {
-          case 'round':
-            if (start) {
-              makeCircularSector(center, p2, p1, u, 0.5)
-            } else {
-              makeCircularSector(center, p1, p2, u, 0.5)
-            }
+      switch (style.strokeLineCap) {
+        case 'round':
+          if (start) {
+            makeCircularSector(center, p2, p1, u, 0.5)
+          } else {
+            makeCircularSector(center, p1, p2, u, 0.5)
+          }
 
-            break
+          break
 
-          case 'square':
-            if (start) {
-              tempV2_1.subVectors(p1, center)
-              tempV2_2.set(tempV2_1.y, -tempV2_1.x)
+        case 'square':
+          if (start) {
+            tempV2_1.subVectors(p1, center)
+            tempV2_2.set(tempV2_1.y, -tempV2_1.x)
 
-              tempV2_3.addVectors(tempV2_1, tempV2_2).add(center)
-              tempV2_4.subVectors(tempV2_2, tempV2_1).add(center)
+            tempV2_3.addVectors(tempV2_1, tempV2_2).add(center)
+            tempV2_4.subVectors(tempV2_2, tempV2_1).add(center)
 
-              // Modify already existing vertices
-              if (joinIsOnLeftSide) {
-                tempV2_3.toArray(vertices, 1 * 3)
-                tempV2_4.toArray(vertices, 0 * 3)
-                tempV2_4.toArray(vertices, 3 * 3)
-              } else {
-                tempV2_3.toArray(vertices, 1 * 3)
-                // using tempV2_4 to update 3rd vertex if the uv.y of 3rd vertex is 1
-                uvs[3 * 2 + 1] === 1 ? tempV2_4.toArray(vertices, 3 * 3) : tempV2_3.toArray(vertices, 3 * 3)
-                tempV2_4.toArray(vertices, 0 * 3)
-              }
+            // Modify already existing vertices
+            if (joinIsOnLeftSide) {
+              tempV2_3.toArray(vertices, 1 * 3)
+              tempV2_4.toArray(vertices, 0 * 3)
+              tempV2_4.toArray(vertices, 3 * 3)
             } else {
-              tempV2_1.subVectors(p2, center)
-              tempV2_2.set(tempV2_1.y, -tempV2_1.x)
+              tempV2_3.toArray(vertices, 1 * 3)
+              // using tempV2_4 to update 3rd vertex if the uv.y of 3rd vertex is 1
+              uvs[3 * 2 + 1] === 1 ? tempV2_4.toArray(vertices, 3 * 3) : tempV2_3.toArray(vertices, 3 * 3)
+              tempV2_4.toArray(vertices, 0 * 3)
+            }
+          } else {
+            tempV2_1.subVectors(p2, center)
+            tempV2_2.set(tempV2_1.y, -tempV2_1.x)
 
-              tempV2_3.addVectors(tempV2_1, tempV2_2).add(center)
-              tempV2_4.subVectors(tempV2_2, tempV2_1).add(center)
+            tempV2_3.addVectors(tempV2_1, tempV2_2).add(center)
+            tempV2_4.subVectors(tempV2_2, tempV2_1).add(center)
 
-              const vl = vertices.length
+            const vl = vertices.length
 
-              // Modify already existing vertices
-              if (joinIsOnLeftSide) {
-                tempV2_3.toArray(vertices, vl - 1 * 3)
-                tempV2_4.toArray(vertices, vl - 2 * 3)
-                tempV2_4.toArray(vertices, vl - 4 * 3)
-              } else {
-                tempV2_4.toArray(vertices, vl - 2 * 3)
-                tempV2_3.toArray(vertices, vl - 1 * 3)
-                tempV2_4.toArray(vertices, vl - 4 * 3)
-              }
+            // Modify already existing vertices
+            if (joinIsOnLeftSide) {
+              tempV2_3.toArray(vertices, vl - 1 * 3)
+              tempV2_4.toArray(vertices, vl - 2 * 3)
+              tempV2_4.toArray(vertices, vl - 4 * 3)
+            } else {
+              tempV2_4.toArray(vertices, vl - 2 * 3)
+              tempV2_3.toArray(vertices, vl - 1 * 3)
+              tempV2_4.toArray(vertices, vl - 4 * 3)
             }
+          }
 
-            break
+          break
 
-          case 'butt':
-          default:
-            // Nothing to do here
-            break
-        }
+        case 'butt':
+        default:
+          // Nothing to do here
+          break
       }
+    }
 
-      function removeDuplicatedPoints(points) {
-        // Creates a new array if necessary with duplicated points removed.
-        // This does not remove duplicated initial and ending points of a closed path.
+    function removeDuplicatedPoints(points) {
+      // Creates a new array if necessary with duplicated points removed.
+      // This does not remove duplicated initial and ending points of a closed path.
 
-        let dupPoints = false
-        for (let i = 1, n = points.length - 1; i < n; i++) {
-          if (points[i].distanceTo(points[i + 1]) < minDistance) {
-            dupPoints = true
-            break
-          }
+      let dupPoints = false
+      for (let i = 1, n = points.length - 1; i < n; i++) {
+        if (points[i].distanceTo(points[i + 1]) < minDistance) {
+          dupPoints = true
+          break
         }
+      }
 
-        if (!dupPoints) return points
+      if (!dupPoints) return points
 
-        const newPoints = []
-        newPoints.push(points[0])
+      const newPoints = []
+      newPoints.push(points[0])
 
-        for (let i = 1, n = points.length - 1; i < n; i++) {
-          if (points[i].distanceTo(points[i + 1]) >= minDistance) {
-            newPoints.push(points[i])
-          }
+      for (let i = 1, n = points.length - 1; i < n; i++) {
+        if (points[i].distanceTo(points[i + 1]) >= minDistance) {
+          newPoints.push(points[i])
         }
+      }
 
-        newPoints.push(points[points.length - 1])
+      newPoints.push(points[points.length - 1])
 
-        return newPoints
-      }
+      return newPoints
     }
   }
-
-  return SVGLoader
-})()
+}
 
 export { SVGLoader }
diff --git a/src/loaders/XLoader.js b/src/loaders/XLoader.js
index 073382b5..60cba98b 100644
--- a/src/loaders/XLoader.js
+++ b/src/loaders/XLoader.js
@@ -21,7 +21,7 @@ import {
 } from 'three'
 import { decodeText } from '../_polyfill/LoaderUtils'
 
-var XLoader = /* @__PURE__ */ (function () {
+var XLoader = (function () {
   var classCallCheck = function (instance, Constructor) {
     if (!(instance instanceof Constructor)) {
       throw new TypeError('Cannot call a class as a function')
diff --git a/src/math/Capsule.js b/src/math/Capsule.js
index 63a0c956..bf2d12e1 100644
--- a/src/math/Capsule.js
+++ b/src/math/Capsule.js
@@ -1,8 +1,8 @@
 import { Vector3 } from 'three'
 
-const _v1 = /* @__PURE__ */ new Vector3()
-const _v2 = /* @__PURE__ */ new Vector3()
-const _v3 = /* @__PURE__ */ new Vector3()
+const _v1 = new Vector3()
+const _v2 = new Vector3()
+const _v3 = new Vector3()
 
 const EPS = 1e-10
 
diff --git a/src/math/ColorConverter.js b/src/math/ColorConverter.js
index 1fdd400b..714a2c98 100644
--- a/src/math/ColorConverter.js
+++ b/src/math/ColorConverter.js
@@ -2,8 +2,8 @@ import { MathUtils } from 'three'
 
 const _hsl = {}
 
-const ColorConverter = {
-  setHSV(color, h, s, v) {
+class ColorConverter {
+  static setHSV(color, h, s, v) {
     // https://gist.github.com/xpansive/1337890#file-index-js
 
     h = MathUtils.euclideanModulo(h, 1)
@@ -11,9 +11,9 @@ const ColorConverter = {
     v = MathUtils.clamp(v, 0, 1)
 
     return color.setHSL(h, (s * v) / ((h = (2 - s) * v) < 1 ? h : 2 - h), h * 0.5)
-  },
+  }
 
-  getHSV(color, target) {
+  static getHSV(color, target) {
     color.getHSL(_hsl)
 
     // based on https://gist.github.com/xpansive/1337890#file-index-js
@@ -24,19 +24,19 @@ const ColorConverter = {
     target.v = _hsl.l + _hsl.s
 
     return target
-  },
+  }
 
   // where c, m, y, k is between 0 and 1
 
-  setCMYK(color, c, m, y, k) {
+  static setCMYK(color, c, m, y, k) {
     const r = (1 - c) * (1 - k)
     const g = (1 - m) * (1 - k)
     const b = (1 - y) * (1 - k)
 
     return color.setRGB(r, g, b)
-  },
+  }
 
-  getCMYK(color, target) {
+  static getCMYK(color, target) {
     const r = color.r
     const g = color.g
     const b = color.b
@@ -52,7 +52,7 @@ const ColorConverter = {
     target.k = k
 
     return target
-  },
+  }
 }
 
 export { ColorConverter }
diff --git a/src/math/ConvexHull.js b/src/math/ConvexHull.js
index 55633bc1..bc345894 100644
--- a/src/math/ConvexHull.js
+++ b/src/math/ConvexHull.js
@@ -7,11 +7,11 @@ import { Line3, Plane, Triangle, Vector3 } from 'three'
 const Visible = 0
 const Deleted = 1
 
-const _v1 = /* @__PURE__ */ new Vector3()
-const _line3 = /* @__PURE__ */ new Line3()
-const _plane = /* @__PURE__ */ new Plane()
-const _closestPoint = /* @__PURE__ */ new Vector3()
-const _triangle = /* @__PURE__ */ new Triangle()
+const _v1 = new Vector3()
+const _line3 = new Line3()
+const _plane = new Plane()
+const _closestPoint = new Vector3()
+const _triangle = new Triangle()
 
 class ConvexHull {
   constructor() {
@@ -703,78 +703,74 @@ class ConvexHull {
 
 //
 
-const Face = /* @__PURE__ */ (() => {
-  class Face {
-    constructor() {
-      this.normal = new Vector3()
-      this.midpoint = new Vector3()
-      this.area = 0
-
-      this.constant = 0 // signed distance from face to the origin
-      this.outside = null // reference to a vertex in a vertex list this face can see
-      this.mark = Visible
-      this.edge = null
-    }
+class Face {
+  constructor() {
+    this.normal = new Vector3()
+    this.midpoint = new Vector3()
+    this.area = 0
 
-    static create(a, b, c) {
-      const face = new Face()
+    this.constant = 0 // signed distance from face to the origin
+    this.outside = null // reference to a vertex in a vertex list this face can see
+    this.mark = Visible
+    this.edge = null
+  }
 
-      const e0 = new HalfEdge(a, face)
-      const e1 = new HalfEdge(b, face)
-      const e2 = new HalfEdge(c, face)
+  static create(a, b, c) {
+    const face = new Face()
 
-      // join edges
+    const e0 = new HalfEdge(a, face)
+    const e1 = new HalfEdge(b, face)
+    const e2 = new HalfEdge(c, face)
 
-      e0.next = e2.prev = e1
-      e1.next = e0.prev = e2
-      e2.next = e1.prev = e0
+    // join edges
 
-      // main half edge reference
+    e0.next = e2.prev = e1
+    e1.next = e0.prev = e2
+    e2.next = e1.prev = e0
 
-      face.edge = e0
+    // main half edge reference
 
-      return face.compute()
-    }
+    face.edge = e0
 
-    getEdge(i) {
-      let edge = this.edge
+    return face.compute()
+  }
 
-      while (i > 0) {
-        edge = edge.next
-        i--
-      }
+  getEdge(i) {
+    let edge = this.edge
 
-      while (i < 0) {
-        edge = edge.prev
-        i++
-      }
+    while (i > 0) {
+      edge = edge.next
+      i--
+    }
 
-      return edge
+    while (i < 0) {
+      edge = edge.prev
+      i++
     }
 
-    compute() {
-      const a = this.edge.tail()
-      const b = this.edge.head()
-      const c = this.edge.next.head()
+    return edge
+  }
 
-      _triangle.set(a.point, b.point, c.point)
+  compute() {
+    const a = this.edge.tail()
+    const b = this.edge.head()
+    const c = this.edge.next.head()
 
-      _triangle.getNormal(this.normal)
-      _triangle.getMidpoint(this.midpoint)
-      this.area = _triangle.getArea()
+    _triangle.set(a.point, b.point, c.point)
 
-      this.constant = this.normal.dot(this.midpoint)
+    _triangle.getNormal(this.normal)
+    _triangle.getMidpoint(this.midpoint)
+    this.area = _triangle.getArea()
 
-      return this
-    }
+    this.constant = this.normal.dot(this.midpoint)
 
-    distanceToPoint(point) {
-      return this.normal.dot(point) - this.constant
-    }
+    return this
   }
 
-  return Face
-})()
+  distanceToPoint(point) {
+    return this.normal.dot(point) - this.constant
+  }
+}
 
 // Entity for a Doubly-Connected Edge List (DCEL).
 
diff --git a/src/math/ImprovedNoise.js b/src/math/ImprovedNoise.js
index f0d6981a..d48fa581 100644
--- a/src/math/ImprovedNoise.js
+++ b/src/math/ImprovedNoise.js
@@ -20,7 +20,7 @@ function init() {
   return _p
 }
 
-const _p = /* @__PURE__ */ init()
+const _p = init()
 
 function fade(t) {
   return t * t * t * (t * (t * 6 - 15) + 10)
diff --git a/src/math/MeshSurfaceSampler.js b/src/math/MeshSurfaceSampler.js
index 51778207..274736c4 100644
--- a/src/math/MeshSurfaceSampler.js
+++ b/src/math/MeshSurfaceSampler.js
@@ -11,8 +11,8 @@ import { Triangle, Vector3 } from 'three'
  * - https://stackoverflow.com/a/4322940/1314762
  */
 
-const _face = /* @__PURE__ */ new Triangle()
-const _color = /* @__PURE__ */ new Vector3()
+const _face = new Triangle()
+const _color = new Vector3()
 
 class MeshSurfaceSampler {
   constructor(mesh) {
diff --git a/src/math/OBB.js b/src/math/OBB.js
index b82b7514..c50b8032 100644
--- a/src/math/OBB.js
+++ b/src/math/OBB.js
@@ -4,13 +4,13 @@ import { Box3, MathUtils, Matrix4, Matrix3, Ray, Vector3 } from 'three'
 
 const a = {
   c: null, // center
-  u: [/* @__PURE__ */ new Vector3(), /* @__PURE__ */ new Vector3(), /* @__PURE__ */ new Vector3()], // basis vectors
+  u: [new Vector3(), new Vector3(), new Vector3()], // basis vectors
   e: [], // half width
 }
 
 const b = {
   c: null, // center
-  u: [/* @__PURE__ */ new Vector3(), /* @__PURE__ */ new Vector3(), /* @__PURE__ */ new Vector3()], // basis vectors
+  u: [new Vector3(), new Vector3(), new Vector3()], // basis vectors
   e: [], // half width
 }
 
@@ -18,17 +18,17 @@ const R = [[], [], []]
 const AbsR = [[], [], []]
 const t = []
 
-const xAxis = /* @__PURE__ */ new Vector3()
-const yAxis = /* @__PURE__ */ new Vector3()
-const zAxis = /* @__PURE__ */ new Vector3()
-const v1 = /* @__PURE__ */ new Vector3()
-const size = /* @__PURE__ */ new Vector3()
-const closestPoint = /* @__PURE__ */ new Vector3()
-const rotationMatrix = /* @__PURE__ */ new Matrix3()
-const aabb = /* @__PURE__ */ new Box3()
-const matrix = /* @__PURE__ */ new Matrix4()
-const inverse = /* @__PURE__ */ new Matrix4()
-const localRay = /* @__PURE__ */ new Ray()
+const xAxis = new Vector3()
+const yAxis = new Vector3()
+const zAxis = new Vector3()
+const v1 = new Vector3()
+const size = new Vector3()
+const closestPoint = new Vector3()
+const rotationMatrix = new Matrix3()
+const aabb = new Box3()
+const matrix = new Matrix4()
+const inverse = new Matrix4()
+const localRay = new Ray()
 
 // OBB
 
@@ -361,6 +361,6 @@ class OBB {
   }
 }
 
-const obb = /* @__PURE__ */ new OBB()
+const obb = new OBB()
 
 export { OBB }
diff --git a/src/math/Octree.js b/src/math/Octree.js
index 9882264b..1a332e59 100644
--- a/src/math/Octree.js
+++ b/src/math/Octree.js
@@ -1,13 +1,13 @@
 import { Box3, Line3, Plane, Sphere, Triangle, Vector3 } from 'three'
 import { Capsule } from '../math/Capsule'
 
-const _v1 = /* @__PURE__ */ new Vector3()
-const _v2 = /* @__PURE__ */ new Vector3()
-const _plane = /* @__PURE__ */ new Plane()
-const _line1 = /* @__PURE__ */ new Line3()
-const _line2 = /* @__PURE__ */ new Line3()
-const _sphere = /* @__PURE__ */ new Sphere()
-const _capsule = /* @__PURE__ */ new Capsule()
+const _v1 = new Vector3()
+const _v2 = new Vector3()
+const _plane = new Plane()
+const _line1 = new Line3()
+const _line2 = new Line3()
+const _sphere = new Sphere()
+const _capsule = new Capsule()
 
 class Octree {
   constructor(box) {
diff --git a/src/misc/ConvexObjectBreaker.js b/src/misc/ConvexObjectBreaker.js
index 891a2e57..76d72c63 100644
--- a/src/misc/ConvexObjectBreaker.js
+++ b/src/misc/ConvexObjectBreaker.js
@@ -30,431 +30,423 @@ import { ConvexGeometry } from '../geometries/ConvexGeometry'
  *
  */
 
-const _v1 = /* @__PURE__ */ new Vector3()
-
-const ConvexObjectBreaker = /* @__PURE__ */ (() => {
-  class ConvexObjectBreaker {
-    constructor(minSizeForBreak = 1.4, smallDelta = 0.0001) {
-      this.minSizeForBreak = minSizeForBreak
-      this.smallDelta = smallDelta
-
-      this.tempLine1 = new Line3()
-      this.tempPlane1 = new Plane()
-      this.tempPlane2 = new Plane()
-      this.tempPlane_Cut = new Plane()
-      this.tempCM1 = new Vector3()
-      this.tempCM2 = new Vector3()
-      this.tempVector3 = new Vector3()
-      this.tempVector3_2 = new Vector3()
-      this.tempVector3_3 = new Vector3()
-      this.tempVector3_P0 = new Vector3()
-      this.tempVector3_P1 = new Vector3()
-      this.tempVector3_P2 = new Vector3()
-      this.tempVector3_N0 = new Vector3()
-      this.tempVector3_N1 = new Vector3()
-      this.tempVector3_AB = new Vector3()
-      this.tempVector3_CB = new Vector3()
-      this.tempResultObjects = { object1: null, object2: null }
-
-      this.segments = []
-      const n = 30 * 30
-      for (let i = 0; i < n; i++) this.segments[i] = false
-    }
+const _v1 = new Vector3()
+
+class ConvexObjectBreaker {
+  constructor(minSizeForBreak = 1.4, smallDelta = 0.0001) {
+    this.minSizeForBreak = minSizeForBreak
+    this.smallDelta = smallDelta
+
+    this.tempLine1 = new Line3()
+    this.tempPlane1 = new Plane()
+    this.tempPlane2 = new Plane()
+    this.tempPlane_Cut = new Plane()
+    this.tempCM1 = new Vector3()
+    this.tempCM2 = new Vector3()
+    this.tempVector3 = new Vector3()
+    this.tempVector3_2 = new Vector3()
+    this.tempVector3_3 = new Vector3()
+    this.tempVector3_P0 = new Vector3()
+    this.tempVector3_P1 = new Vector3()
+    this.tempVector3_P2 = new Vector3()
+    this.tempVector3_N0 = new Vector3()
+    this.tempVector3_N1 = new Vector3()
+    this.tempVector3_AB = new Vector3()
+    this.tempVector3_CB = new Vector3()
+    this.tempResultObjects = { object1: null, object2: null }
+
+    this.segments = []
+    const n = 30 * 30
+    for (let i = 0; i < n; i++) this.segments[i] = false
+  }
 
-    prepareBreakableObject(object, mass, velocity, angularVelocity, breakable) {
-      // object is a Object3d (normally a Mesh), must have a buffer geometry, and it must be convex.
-      // Its material property is propagated to its children (sub-pieces)
-      // mass must be > 0
+  prepareBreakableObject(object, mass, velocity, angularVelocity, breakable) {
+    // object is a Object3d (normally a Mesh), must have a buffer geometry, and it must be convex.
+    // Its material property is propagated to its children (sub-pieces)
+    // mass must be > 0
 
-      const userData = object.userData
-      userData.mass = mass
-      userData.velocity = velocity.clone()
-      userData.angularVelocity = angularVelocity.clone()
-      userData.breakable = breakable
-    }
+    const userData = object.userData
+    userData.mass = mass
+    userData.velocity = velocity.clone()
+    userData.angularVelocity = angularVelocity.clone()
+    userData.breakable = breakable
+  }
 
-    /*
-     * @param {int} maxRadialIterations Iterations for radial cuts.
-     * @param {int} maxRandomIterations Max random iterations for not-radial cuts
-     *
-     * Returns the array of pieces
-     */
-    subdivideByImpact(object, pointOfImpact, normal, maxRadialIterations, maxRandomIterations) {
-      const debris = []
+  /*
+   * @param {int} maxRadialIterations Iterations for radial cuts.
+   * @param {int} maxRandomIterations Max random iterations for not-radial cuts
+   *
+   * Returns the array of pieces
+   */
+  subdivideByImpact(object, pointOfImpact, normal, maxRadialIterations, maxRandomIterations) {
+    const debris = []
 
-      const tempPlane1 = this.tempPlane1
-      const tempPlane2 = this.tempPlane2
+    const tempPlane1 = this.tempPlane1
+    const tempPlane2 = this.tempPlane2
 
-      this.tempVector3.addVectors(pointOfImpact, normal)
-      tempPlane1.setFromCoplanarPoints(pointOfImpact, object.position, this.tempVector3)
+    this.tempVector3.addVectors(pointOfImpact, normal)
+    tempPlane1.setFromCoplanarPoints(pointOfImpact, object.position, this.tempVector3)
 
-      const maxTotalIterations = maxRandomIterations + maxRadialIterations
+    const maxTotalIterations = maxRandomIterations + maxRadialIterations
 
-      const scope = this
+    const scope = this
 
-      function subdivideRadial(subObject, startAngle, endAngle, numIterations) {
-        if (Math.random() < numIterations * 0.05 || numIterations > maxTotalIterations) {
-          debris.push(subObject)
+    function subdivideRadial(subObject, startAngle, endAngle, numIterations) {
+      if (Math.random() < numIterations * 0.05 || numIterations > maxTotalIterations) {
+        debris.push(subObject)
 
-          return
-        }
+        return
+      }
+
+      let angle = Math.PI
 
-        let angle = Math.PI
+      if (numIterations === 0) {
+        tempPlane2.normal.copy(tempPlane1.normal)
+        tempPlane2.constant = tempPlane1.constant
+      } else {
+        if (numIterations <= maxRadialIterations) {
+          angle = (endAngle - startAngle) * (0.2 + 0.6 * Math.random()) + startAngle
 
-        if (numIterations === 0) {
-          tempPlane2.normal.copy(tempPlane1.normal)
-          tempPlane2.constant = tempPlane1.constant
+          // Rotate tempPlane2 at impact point around normal axis and the angle
+          scope.tempVector3_2.copy(object.position).sub(pointOfImpact).applyAxisAngle(normal, angle).add(pointOfImpact)
+          tempPlane2.setFromCoplanarPoints(pointOfImpact, scope.tempVector3, scope.tempVector3_2)
         } else {
-          if (numIterations <= maxRadialIterations) {
-            angle = (endAngle - startAngle) * (0.2 + 0.6 * Math.random()) + startAngle
-
-            // Rotate tempPlane2 at impact point around normal axis and the angle
-            scope.tempVector3_2
-              .copy(object.position)
-              .sub(pointOfImpact)
-              .applyAxisAngle(normal, angle)
-              .add(pointOfImpact)
-            tempPlane2.setFromCoplanarPoints(pointOfImpact, scope.tempVector3, scope.tempVector3_2)
-          } else {
-            angle = (0.5 * (numIterations & 1) + 0.2 * (2 - Math.random())) * Math.PI
-
-            // Rotate tempPlane2 at object position around normal axis and the angle
-            scope.tempVector3_2
-              .copy(pointOfImpact)
-              .sub(subObject.position)
-              .applyAxisAngle(normal, angle)
-              .add(subObject.position)
-            scope.tempVector3_3.copy(normal).add(subObject.position)
-            tempPlane2.setFromCoplanarPoints(subObject.position, scope.tempVector3_3, scope.tempVector3_2)
-          }
+          angle = (0.5 * (numIterations & 1) + 0.2 * (2 - Math.random())) * Math.PI
+
+          // Rotate tempPlane2 at object position around normal axis and the angle
+          scope.tempVector3_2
+            .copy(pointOfImpact)
+            .sub(subObject.position)
+            .applyAxisAngle(normal, angle)
+            .add(subObject.position)
+          scope.tempVector3_3.copy(normal).add(subObject.position)
+          tempPlane2.setFromCoplanarPoints(subObject.position, scope.tempVector3_3, scope.tempVector3_2)
         }
+      }
 
-        // Perform the cut
-        scope.cutByPlane(subObject, tempPlane2, scope.tempResultObjects)
+      // Perform the cut
+      scope.cutByPlane(subObject, tempPlane2, scope.tempResultObjects)
 
-        const obj1 = scope.tempResultObjects.object1
-        const obj2 = scope.tempResultObjects.object2
+      const obj1 = scope.tempResultObjects.object1
+      const obj2 = scope.tempResultObjects.object2
 
-        if (obj1) {
-          subdivideRadial(obj1, startAngle, angle, numIterations + 1)
-        }
+      if (obj1) {
+        subdivideRadial(obj1, startAngle, angle, numIterations + 1)
+      }
 
-        if (obj2) {
-          subdivideRadial(obj2, angle, endAngle, numIterations + 1)
-        }
+      if (obj2) {
+        subdivideRadial(obj2, angle, endAngle, numIterations + 1)
       }
+    }
 
-      subdivideRadial(object, 0, 2 * Math.PI, 0)
+    subdivideRadial(object, 0, 2 * Math.PI, 0)
 
-      return debris
-    }
+    return debris
+  }
 
-    cutByPlane(object, plane, output) {
-      // Returns breakable objects in output.object1 and output.object2 members, the resulting 2 pieces of the cut.
-      // object2 can be null if the plane doesn't cut the object.
-      // object1 can be null only in case of internal error
-      // Returned value is number of pieces, 0 for error.
+  cutByPlane(object, plane, output) {
+    // Returns breakable objects in output.object1 and output.object2 members, the resulting 2 pieces of the cut.
+    // object2 can be null if the plane doesn't cut the object.
+    // object1 can be null only in case of internal error
+    // Returned value is number of pieces, 0 for error.
 
-      const geometry = object.geometry
-      const coords = geometry.attributes.position.array
-      const normals = geometry.attributes.normal.array
+    const geometry = object.geometry
+    const coords = geometry.attributes.position.array
+    const normals = geometry.attributes.normal.array
 
-      const numPoints = coords.length / 3
-      let numFaces = numPoints / 3
+    const numPoints = coords.length / 3
+    let numFaces = numPoints / 3
 
-      let indices = geometry.getIndex()
+    let indices = geometry.getIndex()
 
-      if (indices) {
-        indices = indices.array
-        numFaces = indices.length / 3
-      }
+    if (indices) {
+      indices = indices.array
+      numFaces = indices.length / 3
+    }
 
-      function getVertexIndex(faceIdx, vert) {
-        // vert = 0, 1 or 2.
+    function getVertexIndex(faceIdx, vert) {
+      // vert = 0, 1 or 2.
 
-        const idx = faceIdx * 3 + vert
+      const idx = faceIdx * 3 + vert
 
-        return indices ? indices[idx] : idx
-      }
+      return indices ? indices[idx] : idx
+    }
+
+    const points1 = []
+    const points2 = []
 
-      const points1 = []
-      const points2 = []
+    const delta = this.smallDelta
 
-      const delta = this.smallDelta
+    // Reset segments mark
+    const numPointPairs = numPoints * numPoints
+    for (let i = 0; i < numPointPairs; i++) this.segments[i] = false
 
-      // Reset segments mark
-      const numPointPairs = numPoints * numPoints
-      for (let i = 0; i < numPointPairs; i++) this.segments[i] = false
+    const p0 = this.tempVector3_P0
+    const p1 = this.tempVector3_P1
+    const n0 = this.tempVector3_N0
+    const n1 = this.tempVector3_N1
 
-      const p0 = this.tempVector3_P0
-      const p1 = this.tempVector3_P1
-      const n0 = this.tempVector3_N0
-      const n1 = this.tempVector3_N1
+    // Iterate through the faces to mark edges shared by coplanar faces
+    for (let i = 0; i < numFaces - 1; i++) {
+      const a1 = getVertexIndex(i, 0)
+      const b1 = getVertexIndex(i, 1)
+      const c1 = getVertexIndex(i, 2)
 
-      // Iterate through the faces to mark edges shared by coplanar faces
-      for (let i = 0; i < numFaces - 1; i++) {
-        const a1 = getVertexIndex(i, 0)
-        const b1 = getVertexIndex(i, 1)
-        const c1 = getVertexIndex(i, 2)
+      // Assuming all 3 vertices have the same normal
+      n0.set(normals[a1], normals[a1] + 1, normals[a1] + 2)
+
+      for (let j = i + 1; j < numFaces; j++) {
+        const a2 = getVertexIndex(j, 0)
+        const b2 = getVertexIndex(j, 1)
+        const c2 = getVertexIndex(j, 2)
 
         // Assuming all 3 vertices have the same normal
-        n0.set(normals[a1], normals[a1] + 1, normals[a1] + 2)
-
-        for (let j = i + 1; j < numFaces; j++) {
-          const a2 = getVertexIndex(j, 0)
-          const b2 = getVertexIndex(j, 1)
-          const c2 = getVertexIndex(j, 2)
-
-          // Assuming all 3 vertices have the same normal
-          n1.set(normals[a2], normals[a2] + 1, normals[a2] + 2)
-
-          const coplanar = 1 - n0.dot(n1) < delta
-
-          if (coplanar) {
-            if (a1 === a2 || a1 === b2 || a1 === c2) {
-              if (b1 === a2 || b1 === b2 || b1 === c2) {
-                this.segments[a1 * numPoints + b1] = true
-                this.segments[b1 * numPoints + a1] = true
-              } else {
-                this.segments[c1 * numPoints + a1] = true
-                this.segments[a1 * numPoints + c1] = true
-              }
-            } else if (b1 === a2 || b1 === b2 || b1 === c2) {
-              this.segments[c1 * numPoints + b1] = true
-              this.segments[b1 * numPoints + c1] = true
+        n1.set(normals[a2], normals[a2] + 1, normals[a2] + 2)
+
+        const coplanar = 1 - n0.dot(n1) < delta
+
+        if (coplanar) {
+          if (a1 === a2 || a1 === b2 || a1 === c2) {
+            if (b1 === a2 || b1 === b2 || b1 === c2) {
+              this.segments[a1 * numPoints + b1] = true
+              this.segments[b1 * numPoints + a1] = true
+            } else {
+              this.segments[c1 * numPoints + a1] = true
+              this.segments[a1 * numPoints + c1] = true
             }
+          } else if (b1 === a2 || b1 === b2 || b1 === c2) {
+            this.segments[c1 * numPoints + b1] = true
+            this.segments[b1 * numPoints + c1] = true
           }
         }
       }
+    }
 
-      // Transform the plane to object local space
-      const localPlane = this.tempPlane_Cut
-      object.updateMatrix()
-      ConvexObjectBreaker.transformPlaneToLocalSpace(plane, object.matrix, localPlane)
+    // Transform the plane to object local space
+    const localPlane = this.tempPlane_Cut
+    object.updateMatrix()
+    ConvexObjectBreaker.transformPlaneToLocalSpace(plane, object.matrix, localPlane)
 
-      // Iterate through the faces adding points to both pieces
-      for (let i = 0; i < numFaces; i++) {
-        const va = getVertexIndex(i, 0)
-        const vb = getVertexIndex(i, 1)
-        const vc = getVertexIndex(i, 2)
+    // Iterate through the faces adding points to both pieces
+    for (let i = 0; i < numFaces; i++) {
+      const va = getVertexIndex(i, 0)
+      const vb = getVertexIndex(i, 1)
+      const vc = getVertexIndex(i, 2)
 
-        for (let segment = 0; segment < 3; segment++) {
-          const i0 = segment === 0 ? va : segment === 1 ? vb : vc
-          const i1 = segment === 0 ? vb : segment === 1 ? vc : va
+      for (let segment = 0; segment < 3; segment++) {
+        const i0 = segment === 0 ? va : segment === 1 ? vb : vc
+        const i1 = segment === 0 ? vb : segment === 1 ? vc : va
 
-          const segmentState = this.segments[i0 * numPoints + i1]
+        const segmentState = this.segments[i0 * numPoints + i1]
 
-          if (segmentState) continue // The segment already has been processed in another face
+        if (segmentState) continue // The segment already has been processed in another face
 
-          // Mark segment as processed (also inverted segment)
-          this.segments[i0 * numPoints + i1] = true
-          this.segments[i1 * numPoints + i0] = true
+        // Mark segment as processed (also inverted segment)
+        this.segments[i0 * numPoints + i1] = true
+        this.segments[i1 * numPoints + i0] = true
 
-          p0.set(coords[3 * i0], coords[3 * i0 + 1], coords[3 * i0 + 2])
-          p1.set(coords[3 * i1], coords[3 * i1 + 1], coords[3 * i1 + 2])
+        p0.set(coords[3 * i0], coords[3 * i0 + 1], coords[3 * i0 + 2])
+        p1.set(coords[3 * i1], coords[3 * i1 + 1], coords[3 * i1 + 2])
 
-          // mark: 1 for negative side, 2 for positive side, 3 for coplanar point
-          let mark0 = 0
+        // mark: 1 for negative side, 2 for positive side, 3 for coplanar point
+        let mark0 = 0
 
-          let d = localPlane.distanceToPoint(p0)
+        let d = localPlane.distanceToPoint(p0)
 
-          if (d > delta) {
-            mark0 = 2
-            points2.push(p0.clone())
-          } else if (d < -delta) {
-            mark0 = 1
-            points1.push(p0.clone())
-          } else {
-            mark0 = 3
-            points1.push(p0.clone())
-            points2.push(p0.clone())
-          }
+        if (d > delta) {
+          mark0 = 2
+          points2.push(p0.clone())
+        } else if (d < -delta) {
+          mark0 = 1
+          points1.push(p0.clone())
+        } else {
+          mark0 = 3
+          points1.push(p0.clone())
+          points2.push(p0.clone())
+        }
 
-          // mark: 1 for negative side, 2 for positive side, 3 for coplanar point
-          let mark1 = 0
-
-          d = localPlane.distanceToPoint(p1)
-
-          if (d > delta) {
-            mark1 = 2
-            points2.push(p1.clone())
-          } else if (d < -delta) {
-            mark1 = 1
-            points1.push(p1.clone())
-          } else {
-            mark1 = 3
-            points1.push(p1.clone())
-            points2.push(p1.clone())
-          }
+        // mark: 1 for negative side, 2 for positive side, 3 for coplanar point
+        let mark1 = 0
 
-          if ((mark0 === 1 && mark1 === 2) || (mark0 === 2 && mark1 === 1)) {
-            // Intersection of segment with the plane
+        d = localPlane.distanceToPoint(p1)
 
-            this.tempLine1.start.copy(p0)
-            this.tempLine1.end.copy(p1)
+        if (d > delta) {
+          mark1 = 2
+          points2.push(p1.clone())
+        } else if (d < -delta) {
+          mark1 = 1
+          points1.push(p1.clone())
+        } else {
+          mark1 = 3
+          points1.push(p1.clone())
+          points2.push(p1.clone())
+        }
 
-            let intersection = new Vector3()
-            intersection = localPlane.intersectLine(this.tempLine1, intersection)
+        if ((mark0 === 1 && mark1 === 2) || (mark0 === 2 && mark1 === 1)) {
+          // Intersection of segment with the plane
 
-            if (intersection === null) {
-              // Shouldn't happen
-              console.error('Internal error: segment does not intersect plane.')
-              output.segmentedObject1 = null
-              output.segmentedObject2 = null
-              return 0
-            }
+          this.tempLine1.start.copy(p0)
+          this.tempLine1.end.copy(p1)
+
+          let intersection = new Vector3()
+          intersection = localPlane.intersectLine(this.tempLine1, intersection)
 
-            points1.push(intersection)
-            points2.push(intersection.clone())
+          if (intersection === null) {
+            // Shouldn't happen
+            console.error('Internal error: segment does not intersect plane.')
+            output.segmentedObject1 = null
+            output.segmentedObject2 = null
+            return 0
           }
+
+          points1.push(intersection)
+          points2.push(intersection.clone())
         }
       }
+    }
 
-      // Calculate debris mass (very fast and imprecise):
-      const newMass = object.userData.mass * 0.5
+    // Calculate debris mass (very fast and imprecise):
+    const newMass = object.userData.mass * 0.5
 
-      // Calculate debris Center of Mass (again fast and imprecise)
-      this.tempCM1.set(0, 0, 0)
-      let radius1 = 0
-      const numPoints1 = points1.length
+    // Calculate debris Center of Mass (again fast and imprecise)
+    this.tempCM1.set(0, 0, 0)
+    let radius1 = 0
+    const numPoints1 = points1.length
 
-      if (numPoints1 > 0) {
-        for (let i = 0; i < numPoints1; i++) this.tempCM1.add(points1[i])
+    if (numPoints1 > 0) {
+      for (let i = 0; i < numPoints1; i++) this.tempCM1.add(points1[i])
 
-        this.tempCM1.divideScalar(numPoints1)
-        for (let i = 0; i < numPoints1; i++) {
-          const p = points1[i]
-          p.sub(this.tempCM1)
-          radius1 = Math.max(radius1, p.x, p.y, p.z)
-        }
-
-        this.tempCM1.add(object.position)
+      this.tempCM1.divideScalar(numPoints1)
+      for (let i = 0; i < numPoints1; i++) {
+        const p = points1[i]
+        p.sub(this.tempCM1)
+        radius1 = Math.max(radius1, p.x, p.y, p.z)
       }
 
-      this.tempCM2.set(0, 0, 0)
-      let radius2 = 0
-      const numPoints2 = points2.length
-      if (numPoints2 > 0) {
-        for (let i = 0; i < numPoints2; i++) this.tempCM2.add(points2[i])
-
-        this.tempCM2.divideScalar(numPoints2)
-        for (let i = 0; i < numPoints2; i++) {
-          const p = points2[i]
-          p.sub(this.tempCM2)
-          radius2 = Math.max(radius2, p.x, p.y, p.z)
-        }
+      this.tempCM1.add(object.position)
+    }
 
-        this.tempCM2.add(object.position)
+    this.tempCM2.set(0, 0, 0)
+    let radius2 = 0
+    const numPoints2 = points2.length
+    if (numPoints2 > 0) {
+      for (let i = 0; i < numPoints2; i++) this.tempCM2.add(points2[i])
+
+      this.tempCM2.divideScalar(numPoints2)
+      for (let i = 0; i < numPoints2; i++) {
+        const p = points2[i]
+        p.sub(this.tempCM2)
+        radius2 = Math.max(radius2, p.x, p.y, p.z)
       }
 
-      let object1 = null
-      let object2 = null
-
-      let numObjects = 0
+      this.tempCM2.add(object.position)
+    }
 
-      if (numPoints1 > 4) {
-        object1 = new Mesh(new ConvexGeometry(points1), object.material)
-        object1.position.copy(this.tempCM1)
-        object1.quaternion.copy(object.quaternion)
+    let object1 = null
+    let object2 = null
 
-        this.prepareBreakableObject(
-          object1,
-          newMass,
-          object.userData.velocity,
-          object.userData.angularVelocity,
-          2 * radius1 > this.minSizeForBreak,
-        )
+    let numObjects = 0
 
-        numObjects++
-      }
+    if (numPoints1 > 4) {
+      object1 = new Mesh(new ConvexGeometry(points1), object.material)
+      object1.position.copy(this.tempCM1)
+      object1.quaternion.copy(object.quaternion)
 
-      if (numPoints2 > 4) {
-        object2 = new Mesh(new ConvexGeometry(points2), object.material)
-        object2.position.copy(this.tempCM2)
-        object2.quaternion.copy(object.quaternion)
+      this.prepareBreakableObject(
+        object1,
+        newMass,
+        object.userData.velocity,
+        object.userData.angularVelocity,
+        2 * radius1 > this.minSizeForBreak,
+      )
 
-        this.prepareBreakableObject(
-          object2,
-          newMass,
-          object.userData.velocity,
-          object.userData.angularVelocity,
-          2 * radius2 > this.minSizeForBreak,
-        )
+      numObjects++
+    }
 
-        numObjects++
-      }
+    if (numPoints2 > 4) {
+      object2 = new Mesh(new ConvexGeometry(points2), object.material)
+      object2.position.copy(this.tempCM2)
+      object2.quaternion.copy(object.quaternion)
 
-      output.object1 = object1
-      output.object2 = object2
+      this.prepareBreakableObject(
+        object2,
+        newMass,
+        object.userData.velocity,
+        object.userData.angularVelocity,
+        2 * radius2 > this.minSizeForBreak,
+      )
 
-      return numObjects
+      numObjects++
     }
 
-    static transformFreeVector(v, m) {
-      // input:
-      // vector interpreted as a free vector
-      // THREE.Matrix4 orthogonal matrix (matrix without scale)
+    output.object1 = object1
+    output.object2 = object2
 
-      const x = v.x,
-        y = v.y,
-        z = v.z
-      const e = m.elements
+    return numObjects
+  }
 
-      v.x = e[0] * x + e[4] * y + e[8] * z
-      v.y = e[1] * x + e[5] * y + e[9] * z
-      v.z = e[2] * x + e[6] * y + e[10] * z
+  static transformFreeVector(v, m) {
+    // input:
+    // vector interpreted as a free vector
+    // THREE.Matrix4 orthogonal matrix (matrix without scale)
 
-      return v
-    }
+    const x = v.x,
+      y = v.y,
+      z = v.z
+    const e = m.elements
 
-    static transformFreeVectorInverse(v, m) {
-      // input:
-      // vector interpreted as a free vector
-      // THREE.Matrix4 orthogonal matrix (matrix without scale)
+    v.x = e[0] * x + e[4] * y + e[8] * z
+    v.y = e[1] * x + e[5] * y + e[9] * z
+    v.z = e[2] * x + e[6] * y + e[10] * z
 
-      const x = v.x,
-        y = v.y,
-        z = v.z
-      const e = m.elements
+    return v
+  }
 
-      v.x = e[0] * x + e[1] * y + e[2] * z
-      v.y = e[4] * x + e[5] * y + e[6] * z
-      v.z = e[8] * x + e[9] * y + e[10] * z
+  static transformFreeVectorInverse(v, m) {
+    // input:
+    // vector interpreted as a free vector
+    // THREE.Matrix4 orthogonal matrix (matrix without scale)
 
-      return v
-    }
+    const x = v.x,
+      y = v.y,
+      z = v.z
+    const e = m.elements
 
-    static transformTiedVectorInverse(v, m) {
-      // input:
-      // vector interpreted as a tied (ordinary) vector
-      // THREE.Matrix4 orthogonal matrix (matrix without scale)
+    v.x = e[0] * x + e[1] * y + e[2] * z
+    v.y = e[4] * x + e[5] * y + e[6] * z
+    v.z = e[8] * x + e[9] * y + e[10] * z
 
-      const x = v.x,
-        y = v.y,
-        z = v.z
-      const e = m.elements
+    return v
+  }
 
-      v.x = e[0] * x + e[1] * y + e[2] * z - e[12]
-      v.y = e[4] * x + e[5] * y + e[6] * z - e[13]
-      v.z = e[8] * x + e[9] * y + e[10] * z - e[14]
+  static transformTiedVectorInverse(v, m) {
+    // input:
+    // vector interpreted as a tied (ordinary) vector
+    // THREE.Matrix4 orthogonal matrix (matrix without scale)
 
-      return v
-    }
+    const x = v.x,
+      y = v.y,
+      z = v.z
+    const e = m.elements
 
-    static transformPlaneToLocalSpace(plane, m, resultPlane) {
-      resultPlane.normal.copy(plane.normal)
-      resultPlane.constant = plane.constant
+    v.x = e[0] * x + e[1] * y + e[2] * z - e[12]
+    v.y = e[4] * x + e[5] * y + e[6] * z - e[13]
+    v.z = e[8] * x + e[9] * y + e[10] * z - e[14]
 
-      const referencePoint = ConvexObjectBreaker.transformTiedVectorInverse(plane.coplanarPoint(_v1), m)
+    return v
+  }
 
-      ConvexObjectBreaker.transformFreeVectorInverse(resultPlane.normal, m)
+  static transformPlaneToLocalSpace(plane, m, resultPlane) {
+    resultPlane.normal.copy(plane.normal)
+    resultPlane.constant = plane.constant
 
-      // recalculate constant (like in setFromNormalAndCoplanarPoint)
-      resultPlane.constant = -referencePoint.dot(resultPlane.normal)
-    }
-  }
+    const referencePoint = ConvexObjectBreaker.transformTiedVectorInverse(plane.coplanarPoint(_v1), m)
+
+    ConvexObjectBreaker.transformFreeVectorInverse(resultPlane.normal, m)
 
-  return ConvexObjectBreaker
-})()
+    // recalculate constant (like in setFromNormalAndCoplanarPoint)
+    resultPlane.constant = -referencePoint.dot(resultPlane.normal)
+  }
+}
 
 export { ConvexObjectBreaker }
diff --git a/src/misc/Gyroscope.js b/src/misc/Gyroscope.js
index 570f40d3..0ab3fb72 100644
--- a/src/misc/Gyroscope.js
+++ b/src/misc/Gyroscope.js
@@ -1,12 +1,12 @@
 import { Object3D, Quaternion, Vector3 } from 'three'
 
-const _translationObject = /* @__PURE__ */ new Vector3()
-const _quaternionObject = /* @__PURE__ */ new Quaternion()
-const _scaleObject = /* @__PURE__ */ new Vector3()
+const _translationObject = new Vector3()
+const _quaternionObject = new Quaternion()
+const _scaleObject = new Vector3()
 
-const _translationWorld = /* @__PURE__ */ new Vector3()
-const _quaternionWorld = /* @__PURE__ */ new Quaternion()
-const _scaleWorld = /* @__PURE__ */ new Vector3()
+const _translationWorld = new Vector3()
+const _quaternionWorld = new Quaternion()
+const _scaleWorld = new Vector3()
 
 class Gyroscope extends Object3D {
   constructor() {
diff --git a/src/modifiers/CurveModifier.ts b/src/modifiers/CurveModifier.ts
index 588a5865..2097a471 100644
--- a/src/modifiers/CurveModifier.ts
+++ b/src/modifiers/CurveModifier.ts
@@ -250,7 +250,7 @@ export class Flow<TMesh extends Mesh = Mesh> {
     this.uniforms.pathOffset.value += amount
   }
 }
-const matrix = /* @__PURE__ */ new Matrix4()
+const matrix = new Matrix4()
 
 /**
  * A helper class for creating instanced versions of flow, where the instances are placed on the curve.
diff --git a/src/modifiers/SimplifyModifier.ts b/src/modifiers/SimplifyModifier.ts
index d9d0348d..f5ae4779 100644
--- a/src/modifiers/SimplifyModifier.ts
+++ b/src/modifiers/SimplifyModifier.ts
@@ -1,8 +1,8 @@
 import { BufferGeometry, Float32BufferAttribute, Vector3 } from 'three'
 import * as BufferGeometryUtils from '../utils/BufferGeometryUtils'
 
-const cb = /* @__PURE__ */ new Vector3()
-const ab = /* @__PURE__ */ new Vector3()
+const cb = new Vector3()
+const ab = new Vector3()
 
 function pushIfUnique<TItem>(array: TItem[], object: TItem): void {
   if (array.indexOf(object) === -1) array.push(object)
diff --git a/src/objects/BatchedMesh.ts b/src/objects/BatchedMesh.ts
index 5c95ccb4..8c2f7635 100644
--- a/src/objects/BatchedMesh.ts
+++ b/src/objects/BatchedMesh.ts
@@ -13,8 +13,8 @@ import {
 } from 'three'
 
 const ID_ATTR_NAME = '_batch_id_'
-const _identityMatrix = /* @__PURE__ */ new Matrix4()
-const _zeroScaleMatrix = /* @__PURE__ */ (() => new Matrix4().set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1))()
+const _identityMatrix = new Matrix4()
+const _zeroScaleMatrix = new Matrix4().set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1)
 
 // Custom shaders
 const batchingParsVertex = /* glsl */ `
diff --git a/src/objects/GroundProjectedEnv.ts b/src/objects/GroundProjectedEnv.ts
index 8787ae95..9012ec79 100644
--- a/src/objects/GroundProjectedEnv.ts
+++ b/src/objects/GroundProjectedEnv.ts
@@ -1,5 +1,13 @@
-import { Mesh, IcosahedronGeometry, ShaderMaterial, DoubleSide, Texture, CubeTexture, BufferGeometry } from 'three'
-import { version } from '../_polyfill/constants'
+import {
+  Mesh,
+  IcosahedronGeometry,
+  ShaderMaterial,
+  DoubleSide,
+  Texture,
+  CubeTexture,
+  BufferGeometry,
+  REVISION,
+} from 'three'
 
 export interface GroundProjectedEnvParameters {
   height?: number
@@ -106,7 +114,7 @@ export class GroundProjectedEnv extends Mesh<BufferGeometry, ShaderMaterial> {
             #endif
             gl_FragColor = vec4( outcolor, 1.0 );
             #include <tonemapping_fragment>
-            #include <${version >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>
+            #include <${parseInt(REVISION.replace(/\D+/g, '')) >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>
         }
         `
 
diff --git a/src/objects/Lensflare.js b/src/objects/Lensflare.js
index 736287ee..70a698b1 100644
--- a/src/objects/Lensflare.js
+++ b/src/objects/Lensflare.js
@@ -17,45 +17,56 @@ import {
   Vector4,
 } from 'three'
 
-const Lensflare = /* @__PURE__ */ (() => {
-  class Lensflare extends Mesh {
-    constructor() {
-      super(Lensflare.Geometry, new MeshBasicMaterial({ opacity: 0, transparent: true }))
+const geometry = new BufferGeometry()
 
-      this.isLensflare = true
+const float32Array = new Float32Array([-1, -1, 0, 0, 0, 1, -1, 0, 1, 0, 1, 1, 0, 1, 1, -1, 1, 0, 0, 1])
 
-      this.type = 'Lensflare'
-      this.frustumCulled = false
-      this.renderOrder = Infinity
+const interleavedBuffer = new InterleavedBuffer(float32Array, 5)
 
-      //
+geometry.setIndex([0, 1, 2, 0, 2, 3])
+geometry.setAttribute('position', new InterleavedBufferAttribute(interleavedBuffer, 3, 0, false))
+geometry.setAttribute('uv', new InterleavedBufferAttribute(interleavedBuffer, 2, 3, false))
 
-      const positionScreen = new Vector3()
-      const positionView = new Vector3()
+class Lensflare extends Mesh {
+  static Geometry = geometry
 
-      // textures
-      const tempMap = new DataTexture(new Uint8Array(16 * 16 * 3), 16, 16, RGBAFormat)
-      tempMap.minFilter = NearestFilter
-      tempMap.magFilter = NearestFilter
-      tempMap.wrapS = ClampToEdgeWrapping
-      tempMap.wrapT = ClampToEdgeWrapping
+  constructor() {
+    super(Lensflare.Geometry, new MeshBasicMaterial({ opacity: 0, transparent: true }))
 
-      const occlusionMap = new DataTexture(new Uint8Array(16 * 16 * 3), 16, 16, RGBAFormat)
-      occlusionMap.minFilter = NearestFilter
-      occlusionMap.magFilter = NearestFilter
-      occlusionMap.wrapS = ClampToEdgeWrapping
-      occlusionMap.wrapT = ClampToEdgeWrapping
+    this.isLensflare = true
 
-      // material
+    this.type = 'Lensflare'
+    this.frustumCulled = false
+    this.renderOrder = Infinity
 
-      const geometry = Lensflare.Geometry
+    //
 
-      const material1a = new RawShaderMaterial({
-        uniforms: {
-          scale: { value: null },
-          screenPosition: { value: null },
-        },
-        vertexShader: /* glsl */ `
+    const positionScreen = new Vector3()
+    const positionView = new Vector3()
+
+    // textures
+    const tempMap = new DataTexture(new Uint8Array(16 * 16 * 3), 16, 16, RGBAFormat)
+    tempMap.minFilter = NearestFilter
+    tempMap.magFilter = NearestFilter
+    tempMap.wrapS = ClampToEdgeWrapping
+    tempMap.wrapT = ClampToEdgeWrapping
+
+    const occlusionMap = new DataTexture(new Uint8Array(16 * 16 * 3), 16, 16, RGBAFormat)
+    occlusionMap.minFilter = NearestFilter
+    occlusionMap.magFilter = NearestFilter
+    occlusionMap.wrapS = ClampToEdgeWrapping
+    occlusionMap.wrapT = ClampToEdgeWrapping
+
+    // material
+
+    const geometry = Lensflare.Geometry
+
+    const material1a = new RawShaderMaterial({
+      uniforms: {
+        scale: { value: null },
+        screenPosition: { value: null },
+      },
+      vertexShader: /* glsl */ `
 
 				precision highp float;
 
@@ -70,7 +81,7 @@ const Lensflare = /* @__PURE__ */ (() => {
 
 				}`,
 
-        fragmentShader: /* glsl */ `
+      fragmentShader: /* glsl */ `
 
 				precision highp float;
 
@@ -79,18 +90,18 @@ const Lensflare = /* @__PURE__ */ (() => {
 					gl_FragColor = vec4( 1.0, 0.0, 1.0, 1.0 );
 
 				}`,
-        depthTest: true,
-        depthWrite: false,
-        transparent: false,
-      })
-
-      const material1b = new RawShaderMaterial({
-        uniforms: {
-          map: { value: tempMap },
-          scale: { value: null },
-          screenPosition: { value: null },
-        },
-        vertexShader: /* glsl */ `
+      depthTest: true,
+      depthWrite: false,
+      transparent: false,
+    })
+
+    const material1b = new RawShaderMaterial({
+      uniforms: {
+        map: { value: tempMap },
+        scale: { value: null },
+        screenPosition: { value: null },
+      },
+      vertexShader: /* glsl */ `
 
 				precision highp float;
 
@@ -110,7 +121,7 @@ const Lensflare = /* @__PURE__ */ (() => {
 
 				}`,
 
-        fragmentShader: /* glsl */ `
+      fragmentShader: /* glsl */ `
 
 				precision highp float;
 
@@ -123,173 +134,149 @@ const Lensflare = /* @__PURE__ */ (() => {
 					gl_FragColor = texture2D( map, vUV );
 
 				}`,
-        depthTest: false,
-        depthWrite: false,
-        transparent: false,
-      })
+      depthTest: false,
+      depthWrite: false,
+      transparent: false,
+    })
 
-      // the following object is used for occlusionMap generation
+    // the following object is used for occlusionMap generation
 
-      const mesh1 = new Mesh(geometry, material1a)
+    const mesh1 = new Mesh(geometry, material1a)
 
-      //
+    //
 
-      const elements = []
+    const elements = []
 
-      const shader = LensflareElement.Shader
+    const shader = LensflareElement.Shader
 
-      const material2 = new RawShaderMaterial({
-        uniforms: {
-          map: { value: null },
-          occlusionMap: { value: occlusionMap },
-          color: { value: new Color(0xffffff) },
-          scale: { value: new Vector2() },
-          screenPosition: { value: new Vector3() },
-        },
-        vertexShader: shader.vertexShader,
-        fragmentShader: shader.fragmentShader,
-        blending: AdditiveBlending,
-        transparent: true,
-        depthWrite: false,
-      })
+    const material2 = new RawShaderMaterial({
+      uniforms: {
+        map: { value: null },
+        occlusionMap: { value: occlusionMap },
+        color: { value: new Color(0xffffff) },
+        scale: { value: new Vector2() },
+        screenPosition: { value: new Vector3() },
+      },
+      vertexShader: shader.vertexShader,
+      fragmentShader: shader.fragmentShader,
+      blending: AdditiveBlending,
+      transparent: true,
+      depthWrite: false,
+    })
 
-      const mesh2 = new Mesh(geometry, material2)
+    const mesh2 = new Mesh(geometry, material2)
 
-      this.addElement = function (element) {
-        elements.push(element)
-      }
+    this.addElement = function (element) {
+      elements.push(element)
+    }
 
-      //
+    //
 
-      const scale = new Vector2()
-      const screenPositionPixels = new Vector2()
-      const validArea = new Box2()
-      const viewport = new Vector4()
+    const scale = new Vector2()
+    const screenPositionPixels = new Vector2()
+    const validArea = new Box2()
+    const viewport = new Vector4()
 
-      this.onBeforeRender = function (renderer, scene, camera) {
-        renderer.getCurrentViewport(viewport)
+    this.onBeforeRender = function (renderer, scene, camera) {
+      renderer.getCurrentViewport(viewport)
 
-        const invAspect = viewport.w / viewport.z
-        const halfViewportWidth = viewport.z / 2.0
-        const halfViewportHeight = viewport.w / 2.0
+      const invAspect = viewport.w / viewport.z
+      const halfViewportWidth = viewport.z / 2.0
+      const halfViewportHeight = viewport.w / 2.0
 
-        let size = 16 / viewport.w
-        scale.set(size * invAspect, size)
+      let size = 16 / viewport.w
+      scale.set(size * invAspect, size)
 
-        validArea.min.set(viewport.x, viewport.y)
-        validArea.max.set(viewport.x + (viewport.z - 16), viewport.y + (viewport.w - 16))
+      validArea.min.set(viewport.x, viewport.y)
+      validArea.max.set(viewport.x + (viewport.z - 16), viewport.y + (viewport.w - 16))
 
-        // calculate position in screen space
+      // calculate position in screen space
 
-        positionView.setFromMatrixPosition(this.matrixWorld)
-        positionView.applyMatrix4(camera.matrixWorldInverse)
+      positionView.setFromMatrixPosition(this.matrixWorld)
+      positionView.applyMatrix4(camera.matrixWorldInverse)
 
-        if (positionView.z > 0) return // lensflare is behind the camera
+      if (positionView.z > 0) return // lensflare is behind the camera
 
-        positionScreen.copy(positionView).applyMatrix4(camera.projectionMatrix)
+      positionScreen.copy(positionView).applyMatrix4(camera.projectionMatrix)
 
-        // horizontal and vertical coordinate of the lower left corner of the pixels to copy
+      // horizontal and vertical coordinate of the lower left corner of the pixels to copy
 
-        screenPositionPixels.x = viewport.x + positionScreen.x * halfViewportWidth + halfViewportWidth - 8
-        screenPositionPixels.y = viewport.y + positionScreen.y * halfViewportHeight + halfViewportHeight - 8
+      screenPositionPixels.x = viewport.x + positionScreen.x * halfViewportWidth + halfViewportWidth - 8
+      screenPositionPixels.y = viewport.y + positionScreen.y * halfViewportHeight + halfViewportHeight - 8
 
-        // screen cull
+      // screen cull
 
-        if (validArea.containsPoint(screenPositionPixels)) {
-          // save current RGB to temp texture
+      if (validArea.containsPoint(screenPositionPixels)) {
+        // save current RGB to temp texture
 
-          renderer.copyFramebufferToTexture(screenPositionPixels, tempMap)
+        renderer.copyFramebufferToTexture(screenPositionPixels, tempMap)
 
-          // render pink quad
+        // render pink quad
 
-          let uniforms = material1a.uniforms
-          uniforms['scale'].value = scale
-          uniforms['screenPosition'].value = positionScreen
+        let uniforms = material1a.uniforms
+        uniforms['scale'].value = scale
+        uniforms['screenPosition'].value = positionScreen
 
-          renderer.renderBufferDirect(camera, null, geometry, material1a, mesh1, null)
+        renderer.renderBufferDirect(camera, null, geometry, material1a, mesh1, null)
 
-          // copy result to occlusionMap
+        // copy result to occlusionMap
 
-          renderer.copyFramebufferToTexture(screenPositionPixels, occlusionMap)
+        renderer.copyFramebufferToTexture(screenPositionPixels, occlusionMap)
 
-          // restore graphics
+        // restore graphics
 
-          uniforms = material1b.uniforms
-          uniforms['scale'].value = scale
-          uniforms['screenPosition'].value = positionScreen
+        uniforms = material1b.uniforms
+        uniforms['scale'].value = scale
+        uniforms['screenPosition'].value = positionScreen
 
-          renderer.renderBufferDirect(camera, null, geometry, material1b, mesh1, null)
+        renderer.renderBufferDirect(camera, null, geometry, material1b, mesh1, null)
 
-          // render elements
+        // render elements
 
-          const vecX = -positionScreen.x * 2
-          const vecY = -positionScreen.y * 2
+        const vecX = -positionScreen.x * 2
+        const vecY = -positionScreen.y * 2
 
-          for (let i = 0, l = elements.length; i < l; i++) {
-            const element = elements[i]
+        for (let i = 0, l = elements.length; i < l; i++) {
+          const element = elements[i]
 
-            const uniforms = material2.uniforms
+          const uniforms = material2.uniforms
 
-            uniforms['color'].value.copy(element.color)
-            uniforms['map'].value = element.texture
-            uniforms['screenPosition'].value.x = positionScreen.x + vecX * element.distance
-            uniforms['screenPosition'].value.y = positionScreen.y + vecY * element.distance
+          uniforms['color'].value.copy(element.color)
+          uniforms['map'].value = element.texture
+          uniforms['screenPosition'].value.x = positionScreen.x + vecX * element.distance
+          uniforms['screenPosition'].value.y = positionScreen.y + vecY * element.distance
 
-            size = element.size / viewport.w
-            const invAspect = viewport.w / viewport.z
+          size = element.size / viewport.w
+          const invAspect = viewport.w / viewport.z
 
-            uniforms['scale'].value.set(size * invAspect, size)
+          uniforms['scale'].value.set(size * invAspect, size)
 
-            material2.uniformsNeedUpdate = true
+          material2.uniformsNeedUpdate = true
 
-            renderer.renderBufferDirect(camera, null, geometry, material2, mesh2, null)
-          }
+          renderer.renderBufferDirect(camera, null, geometry, material2, mesh2, null)
         }
       }
+    }
 
-      this.dispose = function () {
-        material1a.dispose()
-        material1b.dispose()
-        material2.dispose()
+    this.dispose = function () {
+      material1a.dispose()
+      material1b.dispose()
+      material2.dispose()
 
-        tempMap.dispose()
-        occlusionMap.dispose()
+      tempMap.dispose()
+      occlusionMap.dispose()
 
-        for (let i = 0, l = elements.length; i < l; i++) {
-          elements[i].texture.dispose()
-        }
+      for (let i = 0, l = elements.length; i < l; i++) {
+        elements[i].texture.dispose()
       }
     }
   }
-
-  const _geometry = new BufferGeometry()
-  const interleavedBuffer = new InterleavedBuffer(
-    new Float32Array([-1, -1, 0, 0, 0, 1, -1, 0, 1, 0, 1, 1, 0, 1, 1, -1, 1, 0, 0, 1]),
-    5,
-  )
-
-  _geometry.setIndex([0, 1, 2, 0, 2, 3])
-  _geometry.setAttribute('position', new InterleavedBufferAttribute(interleavedBuffer, 3, 0, false))
-  _geometry.setAttribute('uv', new InterleavedBufferAttribute(interleavedBuffer, 2, 3, false))
-
-  Lensflare.Geometry = _geometry
-
-  return Lensflare
-})()
+}
 
 //
 
-const LensflareElement = /* @__PURE__ */ (() => {
-  class LensflareElement {
-    constructor(texture, size = 1, distance = 0, color = new Color(0xffffff)) {
-      this.texture = texture
-      this.size = size
-      this.distance = distance
-      this.color = color
-    }
-  }
-
-  LensflareElement.Shader = {
+class LensflareElement {
+  static Shader = {
     uniforms: {
       map: { value: null },
       occlusionMap: { value: null },
@@ -300,66 +287,69 @@ const LensflareElement = /* @__PURE__ */ (() => {
 
     vertexShader: /* glsl */ `
 
-      precision highp float;
+		precision highp float;
 
-      uniform vec3 screenPosition;
-      uniform vec2 scale;
+		uniform vec3 screenPosition;
+		uniform vec2 scale;
 
-      uniform sampler2D occlusionMap;
+		uniform sampler2D occlusionMap;
 
-      attribute vec3 position;
-      attribute vec2 uv;
+		attribute vec3 position;
+		attribute vec2 uv;
 
-      varying vec2 vUV;
-      varying float vVisibility;
+		varying vec2 vUV;
+		varying float vVisibility;
 
-      void main() {
+		void main() {
 
-        vUV = uv;
+			vUV = uv;
 
-        vec2 pos = position.xy;
+			vec2 pos = position.xy;
 
-        vec4 visibility = texture2D( occlusionMap, vec2( 0.1, 0.1 ) );
-        visibility += texture2D( occlusionMap, vec2( 0.5, 0.1 ) );
-        visibility += texture2D( occlusionMap, vec2( 0.9, 0.1 ) );
-        visibility += texture2D( occlusionMap, vec2( 0.9, 0.5 ) );
-        visibility += texture2D( occlusionMap, vec2( 0.9, 0.9 ) );
-        visibility += texture2D( occlusionMap, vec2( 0.5, 0.9 ) );
-        visibility += texture2D( occlusionMap, vec2( 0.1, 0.9 ) );
-        visibility += texture2D( occlusionMap, vec2( 0.1, 0.5 ) );
-        visibility += texture2D( occlusionMap, vec2( 0.5, 0.5 ) );
+			vec4 visibility = texture2D( occlusionMap, vec2( 0.1, 0.1 ) );
+			visibility += texture2D( occlusionMap, vec2( 0.5, 0.1 ) );
+			visibility += texture2D( occlusionMap, vec2( 0.9, 0.1 ) );
+			visibility += texture2D( occlusionMap, vec2( 0.9, 0.5 ) );
+			visibility += texture2D( occlusionMap, vec2( 0.9, 0.9 ) );
+			visibility += texture2D( occlusionMap, vec2( 0.5, 0.9 ) );
+			visibility += texture2D( occlusionMap, vec2( 0.1, 0.9 ) );
+			visibility += texture2D( occlusionMap, vec2( 0.1, 0.5 ) );
+			visibility += texture2D( occlusionMap, vec2( 0.5, 0.5 ) );
 
-        vVisibility =        visibility.r / 9.0;
-        vVisibility *= 1.0 - visibility.g / 9.0;
-        vVisibility *=       visibility.b / 9.0;
+			vVisibility =        visibility.r / 9.0;
+			vVisibility *= 1.0 - visibility.g / 9.0;
+			vVisibility *=       visibility.b / 9.0;
 
-        gl_Position = vec4( ( pos * scale + screenPosition.xy ).xy, screenPosition.z, 1.0 );
+			gl_Position = vec4( ( pos * scale + screenPosition.xy ).xy, screenPosition.z, 1.0 );
 
-      }
-    `,
+		}`,
 
     fragmentShader: /* glsl */ `
 
-      precision highp float;
+		precision highp float;
 
-      uniform sampler2D map;
-      uniform vec3 color;
+		uniform sampler2D map;
+		uniform vec3 color;
 
-      varying vec2 vUV;
-      varying float vVisibility;
+		varying vec2 vUV;
+		varying float vVisibility;
 
-      void main() {
+		void main() {
 
-        vec4 texture = texture2D( map, vUV );
-        texture.a *= vVisibility;
-        gl_FragColor = texture;
-        gl_FragColor.rgb *= color;
+			vec4 texture = texture2D( map, vUV );
+			texture.a *= vVisibility;
+			gl_FragColor = texture;
+			gl_FragColor.rgb *= color;
 
-      }
-    `,
+		}`,
   }
 
-  return LensflareElement
-})()
+  constructor(texture, size = 1, distance = 0, color = new Color(0xffffff)) {
+    this.texture = texture
+    this.size = size
+    this.distance = distance
+    this.color = color
+  }
+}
 
 export { Lensflare, LensflareElement }
diff --git a/src/objects/Reflector.js b/src/objects/Reflector.js
index d1fdd776..5d326eb6 100644
--- a/src/objects/Reflector.js
+++ b/src/objects/Reflector.js
@@ -14,24 +14,23 @@ import {
 } from 'three'
 import { version } from '../_polyfill/constants'
 
-const Reflector = /* @__PURE__ */ (() => {
-  class Reflector extends Mesh {
-    static ReflectorShader = {
-      uniforms: {
-        color: {
-          value: null,
-        },
-
-        tDiffuse: {
-          value: null,
-        },
-
-        textureMatrix: {
-          value: null,
-        },
+class Reflector extends Mesh {
+  static ReflectorShader = {
+    uniforms: {
+      color: {
+        value: null,
       },
 
-      vertexShader: /* glsl */ `
+      tDiffuse: {
+        value: null,
+      },
+
+      textureMatrix: {
+        value: null,
+      },
+    },
+
+    vertexShader: /* glsl */ `
 		uniform mat4 textureMatrix;
 		varying vec4 vUv;
 
@@ -48,7 +47,7 @@ const Reflector = /* @__PURE__ */ (() => {
 
 		}`,
 
-      fragmentShader: /* glsl */ `
+    fragmentShader: /* glsl */ `
 		uniform vec3 color;
 		uniform sampler2D tDiffuse;
 		varying vec4 vUv;
@@ -78,190 +77,182 @@ const Reflector = /* @__PURE__ */ (() => {
 			#include <${version >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>
 
 		}`,
-    }
-
-    constructor(geometry, options = {}) {
-      super(geometry)
+  }
 
-      this.isReflector = true
+  constructor(geometry, options = {}) {
+    super(geometry)
 
-      this.type = 'Reflector'
-      this.camera = new PerspectiveCamera()
+    this.isReflector = true
 
-      const scope = this
+    this.type = 'Reflector'
+    this.camera = new PerspectiveCamera()
 
-      const color = options.color !== undefined ? new Color(options.color) : new Color(0x7f7f7f)
-      const textureWidth = options.textureWidth || 512
-      const textureHeight = options.textureHeight || 512
-      const clipBias = options.clipBias || 0
-      const shader = options.shader || Reflector.ReflectorShader
-      const multisample = options.multisample !== undefined ? options.multisample : 4
+    const scope = this
 
-      //
+    const color = options.color !== undefined ? new Color(options.color) : new Color(0x7f7f7f)
+    const textureWidth = options.textureWidth || 512
+    const textureHeight = options.textureHeight || 512
+    const clipBias = options.clipBias || 0
+    const shader = options.shader || Reflector.ReflectorShader
+    const multisample = options.multisample !== undefined ? options.multisample : 4
 
-      const reflectorPlane = new Plane()
-      const normal = new Vector3()
-      const reflectorWorldPosition = new Vector3()
-      const cameraWorldPosition = new Vector3()
-      const rotationMatrix = new Matrix4()
-      const lookAtPosition = new Vector3(0, 0, -1)
-      const clipPlane = new Vector4()
+    //
 
-      const view = new Vector3()
-      const target = new Vector3()
-      const q = new Vector4()
+    const reflectorPlane = new Plane()
+    const normal = new Vector3()
+    const reflectorWorldPosition = new Vector3()
+    const cameraWorldPosition = new Vector3()
+    const rotationMatrix = new Matrix4()
+    const lookAtPosition = new Vector3(0, 0, -1)
+    const clipPlane = new Vector4()
 
-      const textureMatrix = new Matrix4()
-      const virtualCamera = this.camera
+    const view = new Vector3()
+    const target = new Vector3()
+    const q = new Vector4()
 
-      const renderTarget = new WebGLRenderTarget(textureWidth, textureHeight, {
-        samples: multisample,
-        type: HalfFloatType,
-      })
+    const textureMatrix = new Matrix4()
+    const virtualCamera = this.camera
 
-      const material = new ShaderMaterial({
-        uniforms: UniformsUtils.clone(shader.uniforms),
-        fragmentShader: shader.fragmentShader,
-        vertexShader: shader.vertexShader,
-      })
+    const renderTarget = new WebGLRenderTarget(textureWidth, textureHeight, {
+      samples: multisample,
+      type: HalfFloatType,
+    })
 
-      material.uniforms['tDiffuse'].value = renderTarget.texture
-      material.uniforms['color'].value = color
-      material.uniforms['textureMatrix'].value = textureMatrix
+    const material = new ShaderMaterial({
+      uniforms: UniformsUtils.clone(shader.uniforms),
+      fragmentShader: shader.fragmentShader,
+      vertexShader: shader.vertexShader,
+    })
 
-      this.material = material
+    material.uniforms['tDiffuse'].value = renderTarget.texture
+    material.uniforms['color'].value = color
+    material.uniforms['textureMatrix'].value = textureMatrix
 
-      this.onBeforeRender = function (renderer, scene, camera) {
-        reflectorWorldPosition.setFromMatrixPosition(scope.matrixWorld)
-        cameraWorldPosition.setFromMatrixPosition(camera.matrixWorld)
+    this.material = material
 
-        rotationMatrix.extractRotation(scope.matrixWorld)
+    this.onBeforeRender = function (renderer, scene, camera) {
+      reflectorWorldPosition.setFromMatrixPosition(scope.matrixWorld)
+      cameraWorldPosition.setFromMatrixPosition(camera.matrixWorld)
 
-        normal.set(0, 0, 1)
-        normal.applyMatrix4(rotationMatrix)
+      rotationMatrix.extractRotation(scope.matrixWorld)
 
-        view.subVectors(reflectorWorldPosition, cameraWorldPosition)
+      normal.set(0, 0, 1)
+      normal.applyMatrix4(rotationMatrix)
 
-        // Avoid rendering when reflector is facing away
+      view.subVectors(reflectorWorldPosition, cameraWorldPosition)
 
-        if (view.dot(normal) > 0) return
+      // Avoid rendering when reflector is facing away
 
-        view.reflect(normal).negate()
-        view.add(reflectorWorldPosition)
+      if (view.dot(normal) > 0) return
 
-        rotationMatrix.extractRotation(camera.matrixWorld)
+      view.reflect(normal).negate()
+      view.add(reflectorWorldPosition)
 
-        lookAtPosition.set(0, 0, -1)
-        lookAtPosition.applyMatrix4(rotationMatrix)
-        lookAtPosition.add(cameraWorldPosition)
+      rotationMatrix.extractRotation(camera.matrixWorld)
 
-        target.subVectors(reflectorWorldPosition, lookAtPosition)
-        target.reflect(normal).negate()
-        target.add(reflectorWorldPosition)
+      lookAtPosition.set(0, 0, -1)
+      lookAtPosition.applyMatrix4(rotationMatrix)
+      lookAtPosition.add(cameraWorldPosition)
 
-        virtualCamera.position.copy(view)
-        virtualCamera.up.set(0, 1, 0)
-        virtualCamera.up.applyMatrix4(rotationMatrix)
-        virtualCamera.up.reflect(normal)
-        virtualCamera.lookAt(target)
+      target.subVectors(reflectorWorldPosition, lookAtPosition)
+      target.reflect(normal).negate()
+      target.add(reflectorWorldPosition)
 
-        virtualCamera.far = camera.far // Used in WebGLBackground
+      virtualCamera.position.copy(view)
+      virtualCamera.up.set(0, 1, 0)
+      virtualCamera.up.applyMatrix4(rotationMatrix)
+      virtualCamera.up.reflect(normal)
+      virtualCamera.lookAt(target)
 
-        virtualCamera.updateMatrixWorld()
-        virtualCamera.projectionMatrix.copy(camera.projectionMatrix)
+      virtualCamera.far = camera.far // Used in WebGLBackground
 
-        // Update the texture matrix
-        textureMatrix.set(0.5, 0.0, 0.0, 0.5, 0.0, 0.5, 0.0, 0.5, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.0, 1.0)
-        textureMatrix.multiply(virtualCamera.projectionMatrix)
-        textureMatrix.multiply(virtualCamera.matrixWorldInverse)
-        textureMatrix.multiply(scope.matrixWorld)
+      virtualCamera.updateMatrixWorld()
+      virtualCamera.projectionMatrix.copy(camera.projectionMatrix)
 
-        // Now update projection matrix with new clip plane, implementing code from: http://www.terathon.com/code/oblique.html
-        // Paper explaining this technique: http://www.terathon.com/lengyel/Lengyel-Oblique.pdf
-        reflectorPlane.setFromNormalAndCoplanarPoint(normal, reflectorWorldPosition)
-        reflectorPlane.applyMatrix4(virtualCamera.matrixWorldInverse)
+      // Update the texture matrix
+      textureMatrix.set(0.5, 0.0, 0.0, 0.5, 0.0, 0.5, 0.0, 0.5, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.0, 1.0)
+      textureMatrix.multiply(virtualCamera.projectionMatrix)
+      textureMatrix.multiply(virtualCamera.matrixWorldInverse)
+      textureMatrix.multiply(scope.matrixWorld)
 
-        clipPlane.set(
-          reflectorPlane.normal.x,
-          reflectorPlane.normal.y,
-          reflectorPlane.normal.z,
-          reflectorPlane.constant,
-        )
+      // Now update projection matrix with new clip plane, implementing code from: http://www.terathon.com/code/oblique.html
+      // Paper explaining this technique: http://www.terathon.com/lengyel/Lengyel-Oblique.pdf
+      reflectorPlane.setFromNormalAndCoplanarPoint(normal, reflectorWorldPosition)
+      reflectorPlane.applyMatrix4(virtualCamera.matrixWorldInverse)
 
-        const projectionMatrix = virtualCamera.projectionMatrix
+      clipPlane.set(reflectorPlane.normal.x, reflectorPlane.normal.y, reflectorPlane.normal.z, reflectorPlane.constant)
 
-        q.x = (Math.sign(clipPlane.x) + projectionMatrix.elements[8]) / projectionMatrix.elements[0]
-        q.y = (Math.sign(clipPlane.y) + projectionMatrix.elements[9]) / projectionMatrix.elements[5]
-        q.z = -1.0
-        q.w = (1.0 + projectionMatrix.elements[10]) / projectionMatrix.elements[14]
+      const projectionMatrix = virtualCamera.projectionMatrix
 
-        // Calculate the scaled plane vector
-        clipPlane.multiplyScalar(2.0 / clipPlane.dot(q))
+      q.x = (Math.sign(clipPlane.x) + projectionMatrix.elements[8]) / projectionMatrix.elements[0]
+      q.y = (Math.sign(clipPlane.y) + projectionMatrix.elements[9]) / projectionMatrix.elements[5]
+      q.z = -1.0
+      q.w = (1.0 + projectionMatrix.elements[10]) / projectionMatrix.elements[14]
 
-        // Replacing the third row of the projection matrix
-        projectionMatrix.elements[2] = clipPlane.x
-        projectionMatrix.elements[6] = clipPlane.y
-        projectionMatrix.elements[10] = clipPlane.z + 1.0 - clipBias
-        projectionMatrix.elements[14] = clipPlane.w
+      // Calculate the scaled plane vector
+      clipPlane.multiplyScalar(2.0 / clipPlane.dot(q))
 
-        // Render
-        scope.visible = false
+      // Replacing the third row of the projection matrix
+      projectionMatrix.elements[2] = clipPlane.x
+      projectionMatrix.elements[6] = clipPlane.y
+      projectionMatrix.elements[10] = clipPlane.z + 1.0 - clipBias
+      projectionMatrix.elements[14] = clipPlane.w
 
-        const currentRenderTarget = renderer.getRenderTarget()
+      // Render
+      scope.visible = false
 
-        const currentXrEnabled = renderer.xr.enabled
-        const currentShadowAutoUpdate = renderer.shadowMap.autoUpdate
-        const currentToneMapping = renderer.toneMapping
+      const currentRenderTarget = renderer.getRenderTarget()
 
-        let isSRGB = false
-        if ('outputColorSpace' in renderer) isSRGB = renderer.outputColorSpace === 'srgb'
-        else isSRGB = renderer.outputEncoding === 3001 // sRGBEncoding
+      const currentXrEnabled = renderer.xr.enabled
+      const currentShadowAutoUpdate = renderer.shadowMap.autoUpdate
+      const currentToneMapping = renderer.toneMapping
 
-        renderer.xr.enabled = false // Avoid camera modification
-        renderer.shadowMap.autoUpdate = false // Avoid re-computing shadows
-        if ('outputColorSpace' in renderer) renderer.outputColorSpace = 'srgb-linear'
-        else renderer.outputEncoding = 3000 // LinearEncoding
-        renderer.toneMapping = NoToneMapping
+      let isSRGB = false
+      if ('outputColorSpace' in renderer) isSRGB = renderer.outputColorSpace === 'srgb'
+      else isSRGB = renderer.outputEncoding === 3001 // sRGBEncoding
 
-        renderer.setRenderTarget(renderTarget)
+      renderer.xr.enabled = false // Avoid camera modification
+      renderer.shadowMap.autoUpdate = false // Avoid re-computing shadows
+      if ('outputColorSpace' in renderer) renderer.outputColorSpace = 'srgb-linear'
+      else renderer.outputEncoding = 3000 // LinearEncoding
+      renderer.toneMapping = NoToneMapping
 
-        renderer.state.buffers.depth.setMask(true) // make sure the depth buffer is writable so it can be properly cleared, see #18897
+      renderer.setRenderTarget(renderTarget)
 
-        if (renderer.autoClear === false) renderer.clear()
-        renderer.render(scene, virtualCamera)
+      renderer.state.buffers.depth.setMask(true) // make sure the depth buffer is writable so it can be properly cleared, see #18897
 
-        renderer.xr.enabled = currentXrEnabled
-        renderer.shadowMap.autoUpdate = currentShadowAutoUpdate
-        renderer.toneMapping = currentToneMapping
+      if (renderer.autoClear === false) renderer.clear()
+      renderer.render(scene, virtualCamera)
 
-        if ('outputColorSpace' in renderer) renderer.outputColorSpace = isSRGB ? 'srgb' : 'srgb-linear'
-        else renderer.outputEncoding = isSRGB ? 3001 : 3000
+      renderer.xr.enabled = currentXrEnabled
+      renderer.shadowMap.autoUpdate = currentShadowAutoUpdate
+      renderer.toneMapping = currentToneMapping
 
-        renderer.setRenderTarget(currentRenderTarget)
+      if ('outputColorSpace' in renderer) renderer.outputColorSpace = isSRGB ? 'srgb' : 'srgb-linear'
+      else renderer.outputEncoding = isSRGB ? 3001 : 3000
 
-        // Restore viewport
+      renderer.setRenderTarget(currentRenderTarget)
 
-        const viewport = camera.viewport
+      // Restore viewport
 
-        if (viewport !== undefined) {
-          renderer.state.viewport(viewport)
-        }
+      const viewport = camera.viewport
 
-        scope.visible = true
+      if (viewport !== undefined) {
+        renderer.state.viewport(viewport)
       }
 
-      this.getRenderTarget = function () {
-        return renderTarget
-      }
+      scope.visible = true
+    }
 
-      this.dispose = function () {
-        renderTarget.dispose()
-        scope.material.dispose()
-      }
+    this.getRenderTarget = function () {
+      return renderTarget
     }
-  }
 
-  return Reflector
-})()
+    this.dispose = function () {
+      renderTarget.dispose()
+      scope.material.dispose()
+    }
+  }
+}
 
 export { Reflector }
diff --git a/src/objects/ReflectorForSSRPass.js b/src/objects/ReflectorForSSRPass.js
index 4b8cde38..a03e7a82 100644
--- a/src/objects/ReflectorForSSRPass.js
+++ b/src/objects/ReflectorForSSRPass.js
@@ -15,31 +15,30 @@ import {
   HalfFloatType,
 } from 'three'
 
-const ReflectorForSSRPass = /* @__PURE__ */ (() => {
-  class ReflectorForSSRPass extends Mesh {
-    static ReflectorShader = {
-      defines: {
-        DISTANCE_ATTENUATION: true,
-        FRESNEL: true,
-      },
-
-      uniforms: {
-        color: { value: null },
-        tDiffuse: { value: null },
-        tDepth: { value: null },
-        textureMatrix: { value: new Matrix4() },
-        maxDistance: { value: 180 },
-        opacity: { value: 0.5 },
-        fresnelCoe: { value: null },
-        virtualCameraNear: { value: null },
-        virtualCameraFar: { value: null },
-        virtualCameraProjectionMatrix: { value: new Matrix4() },
-        virtualCameraMatrixWorld: { value: new Matrix4() },
-        virtualCameraProjectionMatrixInverse: { value: new Matrix4() },
-        resolution: { value: new Vector2() },
-      },
-
-      vertexShader: /* glsl */ `
+class ReflectorForSSRPass extends Mesh {
+  static ReflectorShader = {
+    defines: {
+      DISTANCE_ATTENUATION: true,
+      FRESNEL: true,
+    },
+
+    uniforms: {
+      color: { value: null },
+      tDiffuse: { value: null },
+      tDepth: { value: null },
+      textureMatrix: { value: new Matrix4() },
+      maxDistance: { value: 180 },
+      opacity: { value: 0.5 },
+      fresnelCoe: { value: null },
+      virtualCameraNear: { value: null },
+      virtualCameraFar: { value: null },
+      virtualCameraProjectionMatrix: { value: new Matrix4() },
+      virtualCameraMatrixWorld: { value: new Matrix4() },
+      virtualCameraProjectionMatrixInverse: { value: new Matrix4() },
+      resolution: { value: new Vector2() },
+    },
+
+    vertexShader: /* glsl */ `
 		uniform mat4 textureMatrix;
 		varying vec4 vUv;
 
@@ -51,7 +50,7 @@ const ReflectorForSSRPass = /* @__PURE__ */ (() => {
 
 		}`,
 
-      fragmentShader: /* glsl */ `
+    fragmentShader: /* glsl */ `
 		uniform vec3 color;
 		uniform sampler2D tDiffuse;
 		uniform sampler2D tDepth;
@@ -109,214 +108,211 @@ const ReflectorForSSRPass = /* @__PURE__ */ (() => {
 			#endif
 		}
 	`,
-    }
+  }
 
-    constructor(geometry, options = {}) {
-      super(geometry)
-
-      this.isReflectorForSSRPass = true
-
-      this.type = 'ReflectorForSSRPass'
-
-      const scope = this
-
-      const color = options.color !== undefined ? new Color(options.color) : new Color(0x7f7f7f)
-      const textureWidth = options.textureWidth || 512
-      const textureHeight = options.textureHeight || 512
-      const clipBias = options.clipBias || 0
-      const shader = options.shader || ReflectorForSSRPass.ReflectorShader
-      const useDepthTexture = options.useDepthTexture === true
-      const yAxis = new Vector3(0, 1, 0)
-      const vecTemp0 = new Vector3()
-      const vecTemp1 = new Vector3()
-
-      //
-
-      scope.needsUpdate = false
-      scope.maxDistance = ReflectorForSSRPass.ReflectorShader.uniforms.maxDistance.value
-      scope.opacity = ReflectorForSSRPass.ReflectorShader.uniforms.opacity.value
-      scope.color = color
-      scope.resolution = options.resolution || new Vector2(window.innerWidth, window.innerHeight)
-
-      scope._distanceAttenuation = ReflectorForSSRPass.ReflectorShader.defines.DISTANCE_ATTENUATION
-      Object.defineProperty(scope, 'distanceAttenuation', {
-        get() {
-          return scope._distanceAttenuation
-        },
-        set(val) {
-          if (scope._distanceAttenuation === val) return
-          scope._distanceAttenuation = val
-          scope.material.defines.DISTANCE_ATTENUATION = val
-          scope.material.needsUpdate = true
-        },
-      })
-
-      scope._fresnel = ReflectorForSSRPass.ReflectorShader.defines.FRESNEL
-      Object.defineProperty(scope, 'fresnel', {
-        get() {
-          return scope._fresnel
-        },
-        set(val) {
-          if (scope._fresnel === val) return
-          scope._fresnel = val
-          scope.material.defines.FRESNEL = val
-          scope.material.needsUpdate = true
-        },
-      })
-
-      const normal = new Vector3()
-      const reflectorWorldPosition = new Vector3()
-      const cameraWorldPosition = new Vector3()
-      const rotationMatrix = new Matrix4()
-      const lookAtPosition = new Vector3(0, 0, -1)
-
-      const view = new Vector3()
-      const target = new Vector3()
-
-      const textureMatrix = new Matrix4()
-      const virtualCamera = new PerspectiveCamera()
-
-      let depthTexture
-
-      if (useDepthTexture) {
-        depthTexture = new DepthTexture()
-        depthTexture.type = UnsignedShortType
-        depthTexture.minFilter = NearestFilter
-        depthTexture.magFilter = NearestFilter
-      }
+  constructor(geometry, options = {}) {
+    super(geometry)
 
-      const parameters = {
-        depthTexture: useDepthTexture ? depthTexture : null,
-        type: HalfFloatType,
-      }
+    this.isReflectorForSSRPass = true
 
-      const renderTarget = new WebGLRenderTarget(textureWidth, textureHeight, parameters)
+    this.type = 'ReflectorForSSRPass'
 
-      const material = new ShaderMaterial({
-        transparent: useDepthTexture,
-        defines: Object.assign({}, ReflectorForSSRPass.ReflectorShader.defines, {
-          useDepthTexture,
-        }),
-        uniforms: UniformsUtils.clone(shader.uniforms),
-        fragmentShader: shader.fragmentShader,
-        vertexShader: shader.vertexShader,
-      })
+    const scope = this
 
-      material.uniforms['tDiffuse'].value = renderTarget.texture
-      material.uniforms['color'].value = scope.color
-      material.uniforms['textureMatrix'].value = textureMatrix
-      if (useDepthTexture) {
-        material.uniforms['tDepth'].value = renderTarget.depthTexture
-      }
+    const color = options.color !== undefined ? new Color(options.color) : new Color(0x7f7f7f)
+    const textureWidth = options.textureWidth || 512
+    const textureHeight = options.textureHeight || 512
+    const clipBias = options.clipBias || 0
+    const shader = options.shader || ReflectorForSSRPass.ReflectorShader
+    const useDepthTexture = options.useDepthTexture === true
+    const yAxis = new Vector3(0, 1, 0)
+    const vecTemp0 = new Vector3()
+    const vecTemp1 = new Vector3()
+
+    //
+
+    scope.needsUpdate = false
+    scope.maxDistance = ReflectorForSSRPass.ReflectorShader.uniforms.maxDistance.value
+    scope.opacity = ReflectorForSSRPass.ReflectorShader.uniforms.opacity.value
+    scope.color = color
+    scope.resolution = options.resolution || new Vector2(window.innerWidth, window.innerHeight)
+
+    scope._distanceAttenuation = ReflectorForSSRPass.ReflectorShader.defines.DISTANCE_ATTENUATION
+    Object.defineProperty(scope, 'distanceAttenuation', {
+      get() {
+        return scope._distanceAttenuation
+      },
+      set(val) {
+        if (scope._distanceAttenuation === val) return
+        scope._distanceAttenuation = val
+        scope.material.defines.DISTANCE_ATTENUATION = val
+        scope.material.needsUpdate = true
+      },
+    })
+
+    scope._fresnel = ReflectorForSSRPass.ReflectorShader.defines.FRESNEL
+    Object.defineProperty(scope, 'fresnel', {
+      get() {
+        return scope._fresnel
+      },
+      set(val) {
+        if (scope._fresnel === val) return
+        scope._fresnel = val
+        scope.material.defines.FRESNEL = val
+        scope.material.needsUpdate = true
+      },
+    })
 
-      this.material = material
+    const normal = new Vector3()
+    const reflectorWorldPosition = new Vector3()
+    const cameraWorldPosition = new Vector3()
+    const rotationMatrix = new Matrix4()
+    const lookAtPosition = new Vector3(0, 0, -1)
 
-      const globalPlane = new Plane(new Vector3(0, 1, 0), clipBias)
-      const globalPlanes = [globalPlane]
+    const view = new Vector3()
+    const target = new Vector3()
 
-      this.doRender = function (renderer, scene, camera) {
-        material.uniforms['maxDistance'].value = scope.maxDistance
-        material.uniforms['color'].value = scope.color
-        material.uniforms['opacity'].value = scope.opacity
+    const textureMatrix = new Matrix4()
+    const virtualCamera = new PerspectiveCamera()
 
-        vecTemp0.copy(camera.position).normalize()
-        vecTemp1.copy(vecTemp0).reflect(yAxis)
-        material.uniforms['fresnelCoe'].value = (vecTemp0.dot(vecTemp1) + 1) / 2 // TODO: Also need to use glsl viewPosition and viewNormal per pixel.
+    let depthTexture
+
+    if (useDepthTexture) {
+      depthTexture = new DepthTexture()
+      depthTexture.type = UnsignedShortType
+      depthTexture.minFilter = NearestFilter
+      depthTexture.magFilter = NearestFilter
+    }
 
-        reflectorWorldPosition.setFromMatrixPosition(scope.matrixWorld)
-        cameraWorldPosition.setFromMatrixPosition(camera.matrixWorld)
+    const parameters = {
+      depthTexture: useDepthTexture ? depthTexture : null,
+      type: HalfFloatType,
+    }
 
-        rotationMatrix.extractRotation(scope.matrixWorld)
+    const renderTarget = new WebGLRenderTarget(textureWidth, textureHeight, parameters)
+
+    const material = new ShaderMaterial({
+      transparent: useDepthTexture,
+      defines: Object.assign({}, ReflectorForSSRPass.ReflectorShader.defines, {
+        useDepthTexture,
+      }),
+      uniforms: UniformsUtils.clone(shader.uniforms),
+      fragmentShader: shader.fragmentShader,
+      vertexShader: shader.vertexShader,
+    })
+
+    material.uniforms['tDiffuse'].value = renderTarget.texture
+    material.uniforms['color'].value = scope.color
+    material.uniforms['textureMatrix'].value = textureMatrix
+    if (useDepthTexture) {
+      material.uniforms['tDepth'].value = renderTarget.depthTexture
+    }
 
-        normal.set(0, 0, 1)
-        normal.applyMatrix4(rotationMatrix)
+    this.material = material
 
-        view.subVectors(reflectorWorldPosition, cameraWorldPosition)
+    const globalPlane = new Plane(new Vector3(0, 1, 0), clipBias)
+    const globalPlanes = [globalPlane]
 
-        // Avoid rendering when reflector is facing away
+    this.doRender = function (renderer, scene, camera) {
+      material.uniforms['maxDistance'].value = scope.maxDistance
+      material.uniforms['color'].value = scope.color
+      material.uniforms['opacity'].value = scope.opacity
 
-        if (view.dot(normal) > 0) return
+      vecTemp0.copy(camera.position).normalize()
+      vecTemp1.copy(vecTemp0).reflect(yAxis)
+      material.uniforms['fresnelCoe'].value = (vecTemp0.dot(vecTemp1) + 1) / 2 // TODO: Also need to use glsl viewPosition and viewNormal per pixel.
 
-        view.reflect(normal).negate()
-        view.add(reflectorWorldPosition)
+      reflectorWorldPosition.setFromMatrixPosition(scope.matrixWorld)
+      cameraWorldPosition.setFromMatrixPosition(camera.matrixWorld)
 
-        rotationMatrix.extractRotation(camera.matrixWorld)
+      rotationMatrix.extractRotation(scope.matrixWorld)
 
-        lookAtPosition.set(0, 0, -1)
-        lookAtPosition.applyMatrix4(rotationMatrix)
-        lookAtPosition.add(cameraWorldPosition)
+      normal.set(0, 0, 1)
+      normal.applyMatrix4(rotationMatrix)
 
-        target.subVectors(reflectorWorldPosition, lookAtPosition)
-        target.reflect(normal).negate()
-        target.add(reflectorWorldPosition)
+      view.subVectors(reflectorWorldPosition, cameraWorldPosition)
 
-        virtualCamera.position.copy(view)
-        virtualCamera.up.set(0, 1, 0)
-        virtualCamera.up.applyMatrix4(rotationMatrix)
-        virtualCamera.up.reflect(normal)
-        virtualCamera.lookAt(target)
+      // Avoid rendering when reflector is facing away
 
-        virtualCamera.far = camera.far // Used in WebGLBackground
+      if (view.dot(normal) > 0) return
 
-        virtualCamera.updateMatrixWorld()
-        virtualCamera.projectionMatrix.copy(camera.projectionMatrix)
+      view.reflect(normal).negate()
+      view.add(reflectorWorldPosition)
 
-        material.uniforms['virtualCameraNear'].value = camera.near
-        material.uniforms['virtualCameraFar'].value = camera.far
-        material.uniforms['virtualCameraMatrixWorld'].value = virtualCamera.matrixWorld
-        material.uniforms['virtualCameraProjectionMatrix'].value = camera.projectionMatrix
-        material.uniforms['virtualCameraProjectionMatrixInverse'].value = camera.projectionMatrixInverse
-        material.uniforms['resolution'].value = scope.resolution
+      rotationMatrix.extractRotation(camera.matrixWorld)
 
-        // Update the texture matrix
-        textureMatrix.set(0.5, 0.0, 0.0, 0.5, 0.0, 0.5, 0.0, 0.5, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.0, 1.0)
-        textureMatrix.multiply(virtualCamera.projectionMatrix)
-        textureMatrix.multiply(virtualCamera.matrixWorldInverse)
-        textureMatrix.multiply(scope.matrixWorld)
+      lookAtPosition.set(0, 0, -1)
+      lookAtPosition.applyMatrix4(rotationMatrix)
+      lookAtPosition.add(cameraWorldPosition)
 
-        // scope.visible = false;
+      target.subVectors(reflectorWorldPosition, lookAtPosition)
+      target.reflect(normal).negate()
+      target.add(reflectorWorldPosition)
 
-        const currentRenderTarget = renderer.getRenderTarget()
+      virtualCamera.position.copy(view)
+      virtualCamera.up.set(0, 1, 0)
+      virtualCamera.up.applyMatrix4(rotationMatrix)
+      virtualCamera.up.reflect(normal)
+      virtualCamera.lookAt(target)
 
-        const currentXrEnabled = renderer.xr.enabled
-        const currentShadowAutoUpdate = renderer.shadowMap.autoUpdate
-        const currentClippingPlanes = renderer.clippingPlanes
+      virtualCamera.far = camera.far // Used in WebGLBackground
 
-        renderer.xr.enabled = false // Avoid camera modification
-        renderer.shadowMap.autoUpdate = false // Avoid re-computing shadows
-        renderer.clippingPlanes = globalPlanes
+      virtualCamera.updateMatrixWorld()
+      virtualCamera.projectionMatrix.copy(camera.projectionMatrix)
 
-        renderer.setRenderTarget(renderTarget)
+      material.uniforms['virtualCameraNear'].value = camera.near
+      material.uniforms['virtualCameraFar'].value = camera.far
+      material.uniforms['virtualCameraMatrixWorld'].value = virtualCamera.matrixWorld
+      material.uniforms['virtualCameraProjectionMatrix'].value = camera.projectionMatrix
+      material.uniforms['virtualCameraProjectionMatrixInverse'].value = camera.projectionMatrixInverse
+      material.uniforms['resolution'].value = scope.resolution
 
-        renderer.state.buffers.depth.setMask(true) // make sure the depth buffer is writable so it can be properly cleared, see #18897
+      // Update the texture matrix
+      textureMatrix.set(0.5, 0.0, 0.0, 0.5, 0.0, 0.5, 0.0, 0.5, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.0, 1.0)
+      textureMatrix.multiply(virtualCamera.projectionMatrix)
+      textureMatrix.multiply(virtualCamera.matrixWorldInverse)
+      textureMatrix.multiply(scope.matrixWorld)
 
-        if (renderer.autoClear === false) renderer.clear()
-        renderer.render(scene, virtualCamera)
+      // scope.visible = false;
 
-        renderer.xr.enabled = currentXrEnabled
-        renderer.shadowMap.autoUpdate = currentShadowAutoUpdate
-        renderer.clippingPlanes = currentClippingPlanes
+      const currentRenderTarget = renderer.getRenderTarget()
 
-        renderer.setRenderTarget(currentRenderTarget)
+      const currentXrEnabled = renderer.xr.enabled
+      const currentShadowAutoUpdate = renderer.shadowMap.autoUpdate
+      const currentClippingPlanes = renderer.clippingPlanes
 
-        // Restore viewport
+      renderer.xr.enabled = false // Avoid camera modification
+      renderer.shadowMap.autoUpdate = false // Avoid re-computing shadows
+      renderer.clippingPlanes = globalPlanes
 
-        const viewport = camera.viewport
+      renderer.setRenderTarget(renderTarget)
 
-        if (viewport !== undefined) {
-          renderer.state.viewport(viewport)
-        }
+      renderer.state.buffers.depth.setMask(true) // make sure the depth buffer is writable so it can be properly cleared, see #18897
 
-        // scope.visible = true;
-      }
+      if (renderer.autoClear === false) renderer.clear()
+      renderer.render(scene, virtualCamera)
 
-      this.getRenderTarget = function () {
-        return renderTarget
+      renderer.xr.enabled = currentXrEnabled
+      renderer.shadowMap.autoUpdate = currentShadowAutoUpdate
+      renderer.clippingPlanes = currentClippingPlanes
+
+      renderer.setRenderTarget(currentRenderTarget)
+
+      // Restore viewport
+
+      const viewport = camera.viewport
+
+      if (viewport !== undefined) {
+        renderer.state.viewport(viewport)
       }
+
+      // scope.visible = true;
     }
-  }
 
-  return ReflectorForSSRPass
-})()
+    this.getRenderTarget = function () {
+      return renderTarget
+    }
+  }
+}
 
 export { ReflectorForSSRPass }
diff --git a/src/objects/Refractor.js b/src/objects/Refractor.js
index e5978f65..09dda320 100644
--- a/src/objects/Refractor.js
+++ b/src/objects/Refractor.js
@@ -15,24 +15,23 @@ import {
 } from 'three'
 import { version } from '../_polyfill/constants'
 
-const Refractor = /* @__PURE__ */ (() => {
-  class Refractor extends Mesh {
-    static RefractorShader = {
-      uniforms: {
-        color: {
-          value: null,
-        },
-
-        tDiffuse: {
-          value: null,
-        },
-
-        textureMatrix: {
-          value: null,
-        },
+class Refractor extends Mesh {
+  static RefractorShader = {
+    uniforms: {
+      color: {
+        value: null,
       },
 
-      vertexShader: /* glsl */ `
+      tDiffuse: {
+        value: null,
+      },
+
+      textureMatrix: {
+        value: null,
+      },
+    },
+
+    vertexShader: /* glsl */ `
 
 		uniform mat4 textureMatrix;
 
@@ -45,7 +44,7 @@ const Refractor = /* @__PURE__ */ (() => {
 
 		}`,
 
-      fragmentShader: /* glsl */ `
+    fragmentShader: /* glsl */ `
 
 		uniform vec3 color;
 		uniform sampler2D tDiffuse;
@@ -73,236 +72,233 @@ const Refractor = /* @__PURE__ */ (() => {
 			#include <${version >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>
 
 		}`,
-    }
-
-    constructor(geometry, options = {}) {
-      super(geometry)
+  }
 
-      this.isRefractor = true
+  constructor(geometry, options = {}) {
+    super(geometry)
 
-      this.type = 'Refractor'
-      this.camera = new PerspectiveCamera()
+    this.isRefractor = true
 
-      const scope = this
+    this.type = 'Refractor'
+    this.camera = new PerspectiveCamera()
 
-      const color = options.color !== undefined ? new Color(options.color) : new Color(0x7f7f7f)
-      const textureWidth = options.textureWidth || 512
-      const textureHeight = options.textureHeight || 512
-      const clipBias = options.clipBias || 0
-      const shader = options.shader || Refractor.RefractorShader
-      const multisample = options.multisample !== undefined ? options.multisample : 4
+    const scope = this
 
-      //
+    const color = options.color !== undefined ? new Color(options.color) : new Color(0x7f7f7f)
+    const textureWidth = options.textureWidth || 512
+    const textureHeight = options.textureHeight || 512
+    const clipBias = options.clipBias || 0
+    const shader = options.shader || Refractor.RefractorShader
+    const multisample = options.multisample !== undefined ? options.multisample : 4
 
-      const virtualCamera = this.camera
-      virtualCamera.matrixAutoUpdate = false
-      virtualCamera.userData.refractor = true
+    //
 
-      //
+    const virtualCamera = this.camera
+    virtualCamera.matrixAutoUpdate = false
+    virtualCamera.userData.refractor = true
 
-      const refractorPlane = new Plane()
-      const textureMatrix = new Matrix4()
+    //
 
-      // render target
+    const refractorPlane = new Plane()
+    const textureMatrix = new Matrix4()
 
-      const renderTarget = new WebGLRenderTarget(textureWidth, textureHeight, {
-        samples: multisample,
-        type: HalfFloatType,
-      })
+    // render target
 
-      // material
+    const renderTarget = new WebGLRenderTarget(textureWidth, textureHeight, {
+      samples: multisample,
+      type: HalfFloatType,
+    })
 
-      this.material = new ShaderMaterial({
-        uniforms: UniformsUtils.clone(shader.uniforms),
-        vertexShader: shader.vertexShader,
-        fragmentShader: shader.fragmentShader,
-        transparent: true, // ensures, refractors are drawn from farthest to closest
-      })
+    // material
 
-      this.material.uniforms['color'].value = color
-      this.material.uniforms['tDiffuse'].value = renderTarget.texture
-      this.material.uniforms['textureMatrix'].value = textureMatrix
+    this.material = new ShaderMaterial({
+      uniforms: UniformsUtils.clone(shader.uniforms),
+      vertexShader: shader.vertexShader,
+      fragmentShader: shader.fragmentShader,
+      transparent: true, // ensures, refractors are drawn from farthest to closest
+    })
 
-      // functions
+    this.material.uniforms['color'].value = color
+    this.material.uniforms['tDiffuse'].value = renderTarget.texture
+    this.material.uniforms['textureMatrix'].value = textureMatrix
 
-      const visible = (function () {
-        const refractorWorldPosition = new Vector3()
-        const cameraWorldPosition = new Vector3()
-        const rotationMatrix = new Matrix4()
+    // functions
 
-        const view = new Vector3()
-        const normal = new Vector3()
+    const visible = (function () {
+      const refractorWorldPosition = new Vector3()
+      const cameraWorldPosition = new Vector3()
+      const rotationMatrix = new Matrix4()
 
-        return function visible(camera) {
-          refractorWorldPosition.setFromMatrixPosition(scope.matrixWorld)
-          cameraWorldPosition.setFromMatrixPosition(camera.matrixWorld)
+      const view = new Vector3()
+      const normal = new Vector3()
 
-          view.subVectors(refractorWorldPosition, cameraWorldPosition)
+      return function visible(camera) {
+        refractorWorldPosition.setFromMatrixPosition(scope.matrixWorld)
+        cameraWorldPosition.setFromMatrixPosition(camera.matrixWorld)
 
-          rotationMatrix.extractRotation(scope.matrixWorld)
+        view.subVectors(refractorWorldPosition, cameraWorldPosition)
 
-          normal.set(0, 0, 1)
-          normal.applyMatrix4(rotationMatrix)
+        rotationMatrix.extractRotation(scope.matrixWorld)
 
-          return view.dot(normal) < 0
-        }
-      })()
+        normal.set(0, 0, 1)
+        normal.applyMatrix4(rotationMatrix)
 
-      const updateRefractorPlane = (function () {
-        const normal = new Vector3()
-        const position = new Vector3()
-        const quaternion = new Quaternion()
-        const scale = new Vector3()
+        return view.dot(normal) < 0
+      }
+    })()
 
-        return function updateRefractorPlane() {
-          scope.matrixWorld.decompose(position, quaternion, scale)
-          normal.set(0, 0, 1).applyQuaternion(quaternion).normalize()
+    const updateRefractorPlane = (function () {
+      const normal = new Vector3()
+      const position = new Vector3()
+      const quaternion = new Quaternion()
+      const scale = new Vector3()
 
-          // flip the normal because we want to cull everything above the plane
+      return function updateRefractorPlane() {
+        scope.matrixWorld.decompose(position, quaternion, scale)
+        normal.set(0, 0, 1).applyQuaternion(quaternion).normalize()
 
-          normal.negate()
+        // flip the normal because we want to cull everything above the plane
 
-          refractorPlane.setFromNormalAndCoplanarPoint(normal, position)
-        }
-      })()
+        normal.negate()
 
-      const updateVirtualCamera = (function () {
-        const clipPlane = new Plane()
-        const clipVector = new Vector4()
-        const q = new Vector4()
+        refractorPlane.setFromNormalAndCoplanarPoint(normal, position)
+      }
+    })()
 
-        return function updateVirtualCamera(camera) {
-          virtualCamera.matrixWorld.copy(camera.matrixWorld)
-          virtualCamera.matrixWorldInverse.copy(virtualCamera.matrixWorld).invert()
-          virtualCamera.projectionMatrix.copy(camera.projectionMatrix)
-          virtualCamera.far = camera.far // used in WebGLBackground
+    const updateVirtualCamera = (function () {
+      const clipPlane = new Plane()
+      const clipVector = new Vector4()
+      const q = new Vector4()
 
-          // The following code creates an oblique view frustum for clipping.
-          // see: Lengyel, Eric. “Oblique View Frustum Depth Projection and Clipping”.
-          // Journal of Game Development, Vol. 1, No. 2 (2005), Charles River Media, pp. 5–16
+      return function updateVirtualCamera(camera) {
+        virtualCamera.matrixWorld.copy(camera.matrixWorld)
+        virtualCamera.matrixWorldInverse.copy(virtualCamera.matrixWorld).invert()
+        virtualCamera.projectionMatrix.copy(camera.projectionMatrix)
+        virtualCamera.far = camera.far // used in WebGLBackground
 
-          clipPlane.copy(refractorPlane)
-          clipPlane.applyMatrix4(virtualCamera.matrixWorldInverse)
+        // The following code creates an oblique view frustum for clipping.
+        // see: Lengyel, Eric. “Oblique View Frustum Depth Projection and Clipping”.
+        // Journal of Game Development, Vol. 1, No. 2 (2005), Charles River Media, pp. 5–16
 
-          clipVector.set(clipPlane.normal.x, clipPlane.normal.y, clipPlane.normal.z, clipPlane.constant)
+        clipPlane.copy(refractorPlane)
+        clipPlane.applyMatrix4(virtualCamera.matrixWorldInverse)
 
-          // calculate the clip-space corner point opposite the clipping plane and
-          // transform it into camera space by multiplying it by the inverse of the projection matrix
+        clipVector.set(clipPlane.normal.x, clipPlane.normal.y, clipPlane.normal.z, clipPlane.constant)
 
-          const projectionMatrix = virtualCamera.projectionMatrix
+        // calculate the clip-space corner point opposite the clipping plane and
+        // transform it into camera space by multiplying it by the inverse of the projection matrix
 
-          q.x = (Math.sign(clipVector.x) + projectionMatrix.elements[8]) / projectionMatrix.elements[0]
-          q.y = (Math.sign(clipVector.y) + projectionMatrix.elements[9]) / projectionMatrix.elements[5]
-          q.z = -1.0
-          q.w = (1.0 + projectionMatrix.elements[10]) / projectionMatrix.elements[14]
+        const projectionMatrix = virtualCamera.projectionMatrix
 
-          // calculate the scaled plane vector
+        q.x = (Math.sign(clipVector.x) + projectionMatrix.elements[8]) / projectionMatrix.elements[0]
+        q.y = (Math.sign(clipVector.y) + projectionMatrix.elements[9]) / projectionMatrix.elements[5]
+        q.z = -1.0
+        q.w = (1.0 + projectionMatrix.elements[10]) / projectionMatrix.elements[14]
 
-          clipVector.multiplyScalar(2.0 / clipVector.dot(q))
+        // calculate the scaled plane vector
 
-          // replacing the third row of the projection matrix
+        clipVector.multiplyScalar(2.0 / clipVector.dot(q))
 
-          projectionMatrix.elements[2] = clipVector.x
-          projectionMatrix.elements[6] = clipVector.y
-          projectionMatrix.elements[10] = clipVector.z + 1.0 - clipBias
-          projectionMatrix.elements[14] = clipVector.w
-        }
-      })()
+        // replacing the third row of the projection matrix
 
-      // This will update the texture matrix that is used for projective texture mapping in the shader.
-      // see: http://developer.download.nvidia.com/assets/gamedev/docs/projective_texture_mapping.pdf
+        projectionMatrix.elements[2] = clipVector.x
+        projectionMatrix.elements[6] = clipVector.y
+        projectionMatrix.elements[10] = clipVector.z + 1.0 - clipBias
+        projectionMatrix.elements[14] = clipVector.w
+      }
+    })()
 
-      function updateTextureMatrix(camera) {
-        // this matrix does range mapping to [ 0, 1 ]
+    // This will update the texture matrix that is used for projective texture mapping in the shader.
+    // see: http://developer.download.nvidia.com/assets/gamedev/docs/projective_texture_mapping.pdf
 
-        textureMatrix.set(0.5, 0.0, 0.0, 0.5, 0.0, 0.5, 0.0, 0.5, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.0, 1.0)
+    function updateTextureMatrix(camera) {
+      // this matrix does range mapping to [ 0, 1 ]
 
-        // we use "Object Linear Texgen", so we need to multiply the texture matrix T
-        // (matrix above) with the projection and view matrix of the virtual camera
-        // and the model matrix of the refractor
+      textureMatrix.set(0.5, 0.0, 0.0, 0.5, 0.0, 0.5, 0.0, 0.5, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.0, 1.0)
 
-        textureMatrix.multiply(camera.projectionMatrix)
-        textureMatrix.multiply(camera.matrixWorldInverse)
-        textureMatrix.multiply(scope.matrixWorld)
-      }
+      // we use "Object Linear Texgen", so we need to multiply the texture matrix T
+      // (matrix above) with the projection and view matrix of the virtual camera
+      // and the model matrix of the refractor
 
-      //
+      textureMatrix.multiply(camera.projectionMatrix)
+      textureMatrix.multiply(camera.matrixWorldInverse)
+      textureMatrix.multiply(scope.matrixWorld)
+    }
 
-      function render(renderer, scene, camera) {
-        scope.visible = false
+    //
 
-        const currentRenderTarget = renderer.getRenderTarget()
-        const currentXrEnabled = renderer.xr.enabled
-        const currentShadowAutoUpdate = renderer.shadowMap.autoUpdate
-        const currentToneMapping = renderer.toneMapping
+    function render(renderer, scene, camera) {
+      scope.visible = false
 
-        let isSRGB = false
-        if ('outputColorSpace' in renderer) isSRGB = renderer.outputColorSpace === 'srgb'
-        else isSRGB = renderer.outputEncoding === 3001 // sRGBEncoding
+      const currentRenderTarget = renderer.getRenderTarget()
+      const currentXrEnabled = renderer.xr.enabled
+      const currentShadowAutoUpdate = renderer.shadowMap.autoUpdate
+      const currentToneMapping = renderer.toneMapping
 
-        renderer.xr.enabled = false // avoid camera modification
-        renderer.shadowMap.autoUpdate = false // avoid re-computing shadows
-        if ('outputColorSpace' in renderer) renderer.outputColorSpace = 'srgb-linear'
-        else renderer.outputEncoding = 3000 // LinearEncoding
-        renderer.toneMapping = NoToneMapping
+      let isSRGB = false
+      if ('outputColorSpace' in renderer) isSRGB = renderer.outputColorSpace === 'srgb'
+      else isSRGB = renderer.outputEncoding === 3001 // sRGBEncoding
 
-        renderer.setRenderTarget(renderTarget)
-        if (renderer.autoClear === false) renderer.clear()
-        renderer.render(scene, virtualCamera)
+      renderer.xr.enabled = false // avoid camera modification
+      renderer.shadowMap.autoUpdate = false // avoid re-computing shadows
+      if ('outputColorSpace' in renderer) renderer.outputColorSpace = 'srgb-linear'
+      else renderer.outputEncoding = 3000 // LinearEncoding
+      renderer.toneMapping = NoToneMapping
 
-        renderer.xr.enabled = currentXrEnabled
-        renderer.shadowMap.autoUpdate = currentShadowAutoUpdate
-        renderer.toneMapping = currentToneMapping
-        renderer.setRenderTarget(currentRenderTarget)
+      renderer.setRenderTarget(renderTarget)
+      if (renderer.autoClear === false) renderer.clear()
+      renderer.render(scene, virtualCamera)
 
-        if ('outputColorSpace' in renderer) renderer.outputColorSpace = isSRGB ? 'srgb' : 'srgb-linear'
-        else renderer.outputEncoding = isSRGB ? 3001 : 3000
+      renderer.xr.enabled = currentXrEnabled
+      renderer.shadowMap.autoUpdate = currentShadowAutoUpdate
+      renderer.toneMapping = currentToneMapping
+      renderer.setRenderTarget(currentRenderTarget)
 
-        // restore viewport
+      if ('outputColorSpace' in renderer) renderer.outputColorSpace = isSRGB ? 'srgb' : 'srgb-linear'
+      else renderer.outputEncoding = isSRGB ? 3001 : 3000
 
-        const viewport = camera.viewport
+      // restore viewport
 
-        if (viewport !== undefined) {
-          renderer.state.viewport(viewport)
-        }
+      const viewport = camera.viewport
 
-        scope.visible = true
+      if (viewport !== undefined) {
+        renderer.state.viewport(viewport)
       }
 
-      //
+      scope.visible = true
+    }
 
-      this.onBeforeRender = function (renderer, scene, camera) {
-        // ensure refractors are rendered only once per frame
+    //
 
-        if (camera.userData.refractor === true) return
+    this.onBeforeRender = function (renderer, scene, camera) {
+      // ensure refractors are rendered only once per frame
 
-        // avoid rendering when the refractor is viewed from behind
+      if (camera.userData.refractor === true) return
 
-        if (!visible(camera) === true) return
+      // avoid rendering when the refractor is viewed from behind
 
-        // update
+      if (!visible(camera) === true) return
 
-        updateRefractorPlane()
+      // update
 
-        updateTextureMatrix(camera)
+      updateRefractorPlane()
 
-        updateVirtualCamera(camera)
+      updateTextureMatrix(camera)
 
-        render(renderer, scene, camera)
-      }
+      updateVirtualCamera(camera)
 
-      this.getRenderTarget = function () {
-        return renderTarget
-      }
+      render(renderer, scene, camera)
+    }
 
-      this.dispose = function () {
-        renderTarget.dispose()
-        scope.material.dispose()
-      }
+    this.getRenderTarget = function () {
+      return renderTarget
     }
-  }
 
-  return Refractor
-})()
+    this.dispose = function () {
+      renderTarget.dispose()
+      scope.material.dispose()
+    }
+  }
+}
 
 export { Refractor }
diff --git a/src/objects/ShadowMesh.js b/src/objects/ShadowMesh.js
index 38f91193..41075b36 100644
--- a/src/objects/ShadowMesh.js
+++ b/src/objects/ShadowMesh.js
@@ -4,7 +4,7 @@ import { Matrix4, Mesh, MeshBasicMaterial, EqualStencilFunc, IncrementStencilOp
  * A shadow Mesh that follows a shadow-casting Mesh in the scene, but is confined to a single plane.
  */
 
-const _shadowMatrix = /* @__PURE__ */ new Matrix4()
+const _shadowMatrix = new Matrix4()
 
 class ShadowMesh extends Mesh {
   constructor(mesh) {
diff --git a/src/objects/Sky.ts b/src/objects/Sky.ts
index db7cd269..80c206a2 100644
--- a/src/objects/Sky.ts
+++ b/src/objects/Sky.ts
@@ -1,31 +1,17 @@
 import { BackSide, BoxGeometry, Mesh, ShaderMaterial, UniformsUtils, Vector3 } from 'three'
 import { version } from '../_polyfill/constants'
 
-/**
- * Based on "A Practical Analytic Model for Daylight"
- * aka The Preetham Model, the de facto standard analytic skydome model
- * https://www.researchgate.net/publication/220720443_A_Practical_Analytic_Model_for_Daylight
- *
- * First implemented by Simon Wallner
- * http://www.simonwallner.at/projects/atmospheric-scattering
- *
- * Improved by Martin Upitis
- * http://blenderartists.org/forum/showthread.php?245954-preethams-sky-impementation-HDR
- *
- * Three.js integration by zz85 http://twitter.com/blurspline
- */
-const Sky = /* @__PURE__ */ (() => {
-  const SkyShader = {
-    uniforms: {
-      turbidity: { value: 2 },
-      rayleigh: { value: 1 },
-      mieCoefficient: { value: 0.005 },
-      mieDirectionalG: { value: 0.8 },
-      sunPosition: { value: new Vector3() },
-      up: { value: new Vector3(0, 1, 0) },
-    },
-
-    vertexShader: /* glsl */ `
+const SkyShader = {
+  uniforms: {
+    turbidity: { value: 2 },
+    rayleigh: { value: 1 },
+    mieCoefficient: { value: 0.005 },
+    mieDirectionalG: { value: 0.8 },
+    sunPosition: { value: new Vector3() },
+    up: { value: new Vector3(0, 1, 0) },
+  },
+
+  vertexShader: /* glsl */ `
       uniform vec3 sunPosition;
       uniform float rayleigh;
       uniform float turbidity;
@@ -98,7 +84,7 @@ const Sky = /* @__PURE__ */ (() => {
       }
     `,
 
-    fragmentShader: /* glsl */ `
+  fragmentShader: /* glsl */ `
       varying vec3 vWorldPosition;
       varying vec3 vSunDirection;
       varying float vSunfade;
@@ -185,27 +171,37 @@ const Sky = /* @__PURE__ */ (() => {
 
       }
     `,
-  }
+}
 
-  const material = new ShaderMaterial({
-    name: 'SkyShader',
-    fragmentShader: SkyShader.fragmentShader,
-    vertexShader: SkyShader.vertexShader,
-    uniforms: UniformsUtils.clone(SkyShader.uniforms),
-    side: BackSide,
-    depthWrite: false,
-  })
-
-  class Sky extends Mesh {
-    constructor() {
-      super(new BoxGeometry(1, 1, 1), material)
-    }
-
-    static SkyShader = SkyShader
-    public static material = material
+const material = new ShaderMaterial({
+  name: 'SkyShader',
+  fragmentShader: SkyShader.fragmentShader,
+  vertexShader: SkyShader.vertexShader,
+  uniforms: UniformsUtils.clone(SkyShader.uniforms),
+  side: BackSide,
+  depthWrite: false,
+})
+
+/**
+ * Based on "A Practical Analytic Model for Daylight"
+ * aka The Preetham Model, the de facto standard analytic skydome model
+ * https://www.researchgate.net/publication/220720443_A_Practical_Analytic_Model_for_Daylight
+ *
+ * First implemented by Simon Wallner
+ * http://www.simonwallner.at/projects/atmospheric-scattering
+ *
+ * Improved by Martin Upitis
+ * http://blenderartists.org/forum/showthread.php?245954-preethams-sky-impementation-HDR
+ *
+ * Three.js integration by zz85 http://twitter.com/blurspline
+ */
+class Sky extends Mesh {
+  constructor() {
+    super(new BoxGeometry(1, 1, 1), material)
   }
 
-  return Sky
-})()
+  static SkyShader = SkyShader
+  public static material = material
+}
 
 export { Sky }
diff --git a/src/objects/Water.js b/src/objects/Water.js
index 33dd0f94..540647af 100644
--- a/src/objects/Water.js
+++ b/src/objects/Water.js
@@ -11,8 +11,8 @@ import {
   Vector3,
   Vector4,
   WebGLRenderTarget,
+  REVISION,
 } from 'three'
-import { version } from '../_polyfill/constants'
 
 /**
  * Work based on :
@@ -179,7 +179,7 @@ class Water extends Mesh {
 					gl_FragColor = vec4( outgoingLight, alpha );
 
 					#include <tonemapping_fragment>
-					#include <${version >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>
+					#include <${parseInt(REVISION.replace(/\D+/g, '')) >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>
 					#include <fog_fragment>	
 				}`,
     }
diff --git a/src/objects/Water2.js b/src/objects/Water2.js
index 4eed788e..4b73e8f2 100644
--- a/src/objects/Water2.js
+++ b/src/objects/Water2.js
@@ -21,44 +21,43 @@ import { version } from '../_polyfill/constants'
  *
  */
 
-const Water2 = /* @__PURE__ */ (() => {
-  class Water2 extends Mesh {
-    static WaterShader = {
-      uniforms: {
-        color: {
-          value: null,
-        },
-
-        reflectivity: {
-          value: 0,
-        },
-
-        tReflectionMap: {
-          value: null,
-        },
-
-        tRefractionMap: {
-          value: null,
-        },
-
-        tNormalMap0: {
-          value: null,
-        },
-
-        tNormalMap1: {
-          value: null,
-        },
-
-        textureMatrix: {
-          value: null,
-        },
-
-        config: {
-          value: /* @__PURE__ */ new Vector4(),
-        },
+class Water2 extends Mesh {
+  static WaterShader = {
+    uniforms: {
+      color: {
+        value: null,
       },
 
-      vertexShader: /* glsl */ `
+      reflectivity: {
+        value: 0,
+      },
+
+      tReflectionMap: {
+        value: null,
+      },
+
+      tRefractionMap: {
+        value: null,
+      },
+
+      tNormalMap0: {
+        value: null,
+      },
+
+      tNormalMap1: {
+        value: null,
+      },
+
+      textureMatrix: {
+        value: null,
+      },
+
+      config: {
+        value: new Vector4(),
+      },
+    },
+
+    vertexShader: /* glsl */ `
 
 		#include <common>
 		#include <fog_pars_vertex>
@@ -86,7 +85,7 @@ const Water2 = /* @__PURE__ */ (() => {
 
 		}`,
 
-      fragmentShader: /* glsl */ `
+    fragmentShader: /* glsl */ `
 
 		#include <common>
 		#include <fog_pars_fragment>
@@ -161,161 +160,158 @@ const Water2 = /* @__PURE__ */ (() => {
 			#include <fog_fragment>
 
 		}`,
-    }
+  }
 
-    constructor(geometry, options = {}) {
-      super(geometry)
+  constructor(geometry, options = {}) {
+    super(geometry)
 
-      this.isWater = true
+    this.isWater = true
 
-      this.type = 'Water'
+    this.type = 'Water'
 
-      const scope = this
+    const scope = this
 
-      const color = options.color !== undefined ? new Color(options.color) : new Color(0xffffff)
-      const textureWidth = options.textureWidth || 512
-      const textureHeight = options.textureHeight || 512
-      const clipBias = options.clipBias || 0
-      const flowDirection = options.flowDirection || new Vector2(1, 0)
-      const flowSpeed = options.flowSpeed || 0.03
-      const reflectivity = options.reflectivity || 0.02
-      const scale = options.scale || 1
-      const shader = options.shader || Water2.WaterShader
-      const encoding = options.encoding !== undefined ? options.encoding : 3000
+    const color = options.color !== undefined ? new Color(options.color) : new Color(0xffffff)
+    const textureWidth = options.textureWidth || 512
+    const textureHeight = options.textureHeight || 512
+    const clipBias = options.clipBias || 0
+    const flowDirection = options.flowDirection || new Vector2(1, 0)
+    const flowSpeed = options.flowSpeed || 0.03
+    const reflectivity = options.reflectivity || 0.02
+    const scale = options.scale || 1
+    const shader = options.shader || Water2.WaterShader
+    const encoding = options.encoding !== undefined ? options.encoding : 3000
 
-      const flowMap = options.flowMap || undefined
-      const normalMap0 = options.normalMap0
-      const normalMap1 = options.normalMap1
+    const flowMap = options.flowMap || undefined
+    const normalMap0 = options.normalMap0
+    const normalMap1 = options.normalMap1
 
-      const cycle = 0.15 // a cycle of a flow map phase
-      const halfCycle = cycle * 0.5
-      const textureMatrix = new Matrix4()
-      const clock = new Clock()
+    const cycle = 0.15 // a cycle of a flow map phase
+    const halfCycle = cycle * 0.5
+    const textureMatrix = new Matrix4()
+    const clock = new Clock()
 
-      // internal components
+    // internal components
 
-      if (Reflector === undefined) {
-        console.error('THREE.Water: Required component Reflector not found.')
-        return
-      }
+    if (Reflector === undefined) {
+      console.error('THREE.Water: Required component Reflector not found.')
+      return
+    }
 
-      if (Refractor === undefined) {
-        console.error('THREE.Water: Required component Refractor not found.')
-        return
-      }
+    if (Refractor === undefined) {
+      console.error('THREE.Water: Required component Refractor not found.')
+      return
+    }
 
-      const reflector = new Reflector(geometry, {
-        textureWidth: textureWidth,
-        textureHeight: textureHeight,
-        clipBias: clipBias,
-        encoding: encoding,
-      })
-
-      const refractor = new Refractor(geometry, {
-        textureWidth: textureWidth,
-        textureHeight: textureHeight,
-        clipBias: clipBias,
-        encoding: encoding,
-      })
-
-      reflector.matrixAutoUpdate = false
-      refractor.matrixAutoUpdate = false
-
-      // material
-
-      this.material = new ShaderMaterial({
-        uniforms: UniformsUtils.merge([UniformsLib['fog'], shader.uniforms]),
-        vertexShader: shader.vertexShader,
-        fragmentShader: shader.fragmentShader,
-        transparent: true,
-        fog: true,
-      })
-
-      if (flowMap !== undefined) {
-        this.material.defines.USE_FLOWMAP = ''
-        this.material.uniforms['tFlowMap'] = {
-          type: 't',
-          value: flowMap,
-        }
-      } else {
-        this.material.uniforms['flowDirection'] = {
-          type: 'v2',
-          value: flowDirection,
-        }
+    const reflector = new Reflector(geometry, {
+      textureWidth: textureWidth,
+      textureHeight: textureHeight,
+      clipBias: clipBias,
+      encoding: encoding,
+    })
+
+    const refractor = new Refractor(geometry, {
+      textureWidth: textureWidth,
+      textureHeight: textureHeight,
+      clipBias: clipBias,
+      encoding: encoding,
+    })
+
+    reflector.matrixAutoUpdate = false
+    refractor.matrixAutoUpdate = false
+
+    // material
+
+    this.material = new ShaderMaterial({
+      uniforms: UniformsUtils.merge([UniformsLib['fog'], shader.uniforms]),
+      vertexShader: shader.vertexShader,
+      fragmentShader: shader.fragmentShader,
+      transparent: true,
+      fog: true,
+    })
+
+    if (flowMap !== undefined) {
+      this.material.defines.USE_FLOWMAP = ''
+      this.material.uniforms['tFlowMap'] = {
+        type: 't',
+        value: flowMap,
+      }
+    } else {
+      this.material.uniforms['flowDirection'] = {
+        type: 'v2',
+        value: flowDirection,
       }
+    }
 
-      // maps
+    // maps
 
-      normalMap0.wrapS = normalMap0.wrapT = RepeatWrapping
-      normalMap1.wrapS = normalMap1.wrapT = RepeatWrapping
+    normalMap0.wrapS = normalMap0.wrapT = RepeatWrapping
+    normalMap1.wrapS = normalMap1.wrapT = RepeatWrapping
 
-      this.material.uniforms['tReflectionMap'].value = reflector.getRenderTarget().texture
-      this.material.uniforms['tRefractionMap'].value = refractor.getRenderTarget().texture
-      this.material.uniforms['tNormalMap0'].value = normalMap0
-      this.material.uniforms['tNormalMap1'].value = normalMap1
+    this.material.uniforms['tReflectionMap'].value = reflector.getRenderTarget().texture
+    this.material.uniforms['tRefractionMap'].value = refractor.getRenderTarget().texture
+    this.material.uniforms['tNormalMap0'].value = normalMap0
+    this.material.uniforms['tNormalMap1'].value = normalMap1
 
-      // water
+    // water
 
-      this.material.uniforms['color'].value = color
-      this.material.uniforms['reflectivity'].value = reflectivity
-      this.material.uniforms['textureMatrix'].value = textureMatrix
+    this.material.uniforms['color'].value = color
+    this.material.uniforms['reflectivity'].value = reflectivity
+    this.material.uniforms['textureMatrix'].value = textureMatrix
 
-      // inital values
+    // inital values
 
-      this.material.uniforms['config'].value.x = 0 // flowMapOffset0
-      this.material.uniforms['config'].value.y = halfCycle // flowMapOffset1
-      this.material.uniforms['config'].value.z = halfCycle // halfCycle
-      this.material.uniforms['config'].value.w = scale // scale
+    this.material.uniforms['config'].value.x = 0 // flowMapOffset0
+    this.material.uniforms['config'].value.y = halfCycle // flowMapOffset1
+    this.material.uniforms['config'].value.z = halfCycle // halfCycle
+    this.material.uniforms['config'].value.w = scale // scale
 
-      // functions
+    // functions
 
-      function updateTextureMatrix(camera) {
-        textureMatrix.set(0.5, 0.0, 0.0, 0.5, 0.0, 0.5, 0.0, 0.5, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.0, 1.0)
+    function updateTextureMatrix(camera) {
+      textureMatrix.set(0.5, 0.0, 0.0, 0.5, 0.0, 0.5, 0.0, 0.5, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.0, 1.0)
 
-        textureMatrix.multiply(camera.projectionMatrix)
-        textureMatrix.multiply(camera.matrixWorldInverse)
-        textureMatrix.multiply(scope.matrixWorld)
-      }
+      textureMatrix.multiply(camera.projectionMatrix)
+      textureMatrix.multiply(camera.matrixWorldInverse)
+      textureMatrix.multiply(scope.matrixWorld)
+    }
 
-      function updateFlow() {
-        const delta = clock.getDelta()
-        const config = scope.material.uniforms['config']
+    function updateFlow() {
+      const delta = clock.getDelta()
+      const config = scope.material.uniforms['config']
 
-        config.value.x += flowSpeed * delta // flowMapOffset0
-        config.value.y = config.value.x + halfCycle // flowMapOffset1
+      config.value.x += flowSpeed * delta // flowMapOffset0
+      config.value.y = config.value.x + halfCycle // flowMapOffset1
 
-        // Important: The distance between offsets should be always the value of "halfCycle".
-        // Moreover, both offsets should be in the range of [ 0, cycle ].
-        // This approach ensures a smooth water flow and avoids "reset" effects.
+      // Important: The distance between offsets should be always the value of "halfCycle".
+      // Moreover, both offsets should be in the range of [ 0, cycle ].
+      // This approach ensures a smooth water flow and avoids "reset" effects.
 
-        if (config.value.x >= cycle) {
-          config.value.x = 0
-          config.value.y = halfCycle
-        } else if (config.value.y >= cycle) {
-          config.value.y = config.value.y - cycle
-        }
+      if (config.value.x >= cycle) {
+        config.value.x = 0
+        config.value.y = halfCycle
+      } else if (config.value.y >= cycle) {
+        config.value.y = config.value.y - cycle
       }
+    }
 
-      //
+    //
 
-      this.onBeforeRender = function (renderer, scene, camera) {
-        updateTextureMatrix(camera)
-        updateFlow()
+    this.onBeforeRender = function (renderer, scene, camera) {
+      updateTextureMatrix(camera)
+      updateFlow()
 
-        scope.visible = false
+      scope.visible = false
 
-        reflector.matrixWorld.copy(scope.matrixWorld)
-        refractor.matrixWorld.copy(scope.matrixWorld)
+      reflector.matrixWorld.copy(scope.matrixWorld)
+      refractor.matrixWorld.copy(scope.matrixWorld)
 
-        reflector.onBeforeRender(renderer, scene, camera)
-        refractor.onBeforeRender(renderer, scene, camera)
+      reflector.onBeforeRender(renderer, scene, camera)
+      refractor.onBeforeRender(renderer, scene, camera)
 
-        scope.visible = true
-      }
+      scope.visible = true
     }
   }
-
-  return Water2
-})()
+}
 
 export { Water2 }
diff --git a/src/postprocessing/SAOPass.js b/src/postprocessing/SAOPass.js
index caa026dc..6125d3b8 100644
--- a/src/postprocessing/SAOPass.js
+++ b/src/postprocessing/SAOPass.js
@@ -28,357 +28,353 @@ import { UnpackDepthRGBAShader } from '../shaders/UnpackDepthRGBAShader'
 /**
  * SAO implementation inspired from bhouston previous SAO work
  */
-const SAOPass = /* @__PURE__ */ (() => {
-  class SAOPass extends Pass {
-    static OUTPUT = {
-      Beauty: 1,
-      Default: 0,
-      SAO: 2,
-      Depth: 3,
-      Normal: 4,
-    }
+class SAOPass extends Pass {
+  static OUTPUT = {
+    Beauty: 1,
+    Default: 0,
+    SAO: 2,
+    Depth: 3,
+    Normal: 4,
+  }
 
-    constructor(scene, camera, useDepthTexture = false, useNormals = false, resolution = new Vector2(256, 256)) {
-      super()
-
-      this.scene = scene
-      this.camera = camera
-
-      this.clear = true
-      this.needsSwap = false
-
-      this.supportsDepthTextureExtension = useDepthTexture
-      this.supportsNormalTexture = useNormals
-
-      this.originalClearColor = new Color()
-      this._oldClearColor = new Color()
-      this.oldClearAlpha = 1
-
-      this.params = {
-        output: 0,
-        saoBias: 0.5,
-        saoIntensity: 0.18,
-        saoScale: 1,
-        saoKernelRadius: 100,
-        saoMinResolution: 0,
-        saoBlur: true,
-        saoBlurRadius: 8,
-        saoBlurStdDev: 4,
-        saoBlurDepthCutoff: 0.01,
-      }
+  constructor(scene, camera, useDepthTexture = false, useNormals = false, resolution = new Vector2(256, 256)) {
+    super()
+
+    this.scene = scene
+    this.camera = camera
+
+    this.clear = true
+    this.needsSwap = false
+
+    this.supportsDepthTextureExtension = useDepthTexture
+    this.supportsNormalTexture = useNormals
+
+    this.originalClearColor = new Color()
+    this._oldClearColor = new Color()
+    this.oldClearAlpha = 1
+
+    this.params = {
+      output: 0,
+      saoBias: 0.5,
+      saoIntensity: 0.18,
+      saoScale: 1,
+      saoKernelRadius: 100,
+      saoMinResolution: 0,
+      saoBlur: true,
+      saoBlurRadius: 8,
+      saoBlurStdDev: 4,
+      saoBlurDepthCutoff: 0.01,
+    }
 
-      this.resolution = new Vector2(resolution.x, resolution.y)
+    this.resolution = new Vector2(resolution.x, resolution.y)
 
-      this.saoRenderTarget = new WebGLRenderTarget(this.resolution.x, this.resolution.y, { type: HalfFloatType })
-      this.blurIntermediateRenderTarget = this.saoRenderTarget.clone()
-      this.beautyRenderTarget = this.saoRenderTarget.clone()
+    this.saoRenderTarget = new WebGLRenderTarget(this.resolution.x, this.resolution.y, { type: HalfFloatType })
+    this.blurIntermediateRenderTarget = this.saoRenderTarget.clone()
+    this.beautyRenderTarget = this.saoRenderTarget.clone()
 
-      this.normalRenderTarget = new WebGLRenderTarget(this.resolution.x, this.resolution.y, {
-        minFilter: NearestFilter,
-        magFilter: NearestFilter,
-        type: HalfFloatType,
-      })
-      this.depthRenderTarget = this.normalRenderTarget.clone()
+    this.normalRenderTarget = new WebGLRenderTarget(this.resolution.x, this.resolution.y, {
+      minFilter: NearestFilter,
+      magFilter: NearestFilter,
+      type: HalfFloatType,
+    })
+    this.depthRenderTarget = this.normalRenderTarget.clone()
 
-      let depthTexture
+    let depthTexture
 
-      if (this.supportsDepthTextureExtension) {
-        depthTexture = new DepthTexture()
-        depthTexture.type = UnsignedShortType
+    if (this.supportsDepthTextureExtension) {
+      depthTexture = new DepthTexture()
+      depthTexture.type = UnsignedShortType
 
-        this.beautyRenderTarget.depthTexture = depthTexture
-        this.beautyRenderTarget.depthBuffer = true
-      }
-
-      this.depthMaterial = new MeshDepthMaterial()
-      this.depthMaterial.depthPacking = RGBADepthPacking
-      this.depthMaterial.blending = NoBlending
-
-      this.normalMaterial = new MeshNormalMaterial()
-      this.normalMaterial.blending = NoBlending
-
-      this.saoMaterial = new ShaderMaterial({
-        defines: Object.assign({}, SAOShader.defines),
-        fragmentShader: SAOShader.fragmentShader,
-        vertexShader: SAOShader.vertexShader,
-        uniforms: UniformsUtils.clone(SAOShader.uniforms),
-      })
-      this.saoMaterial.extensions.derivatives = true
-      this.saoMaterial.defines['DEPTH_PACKING'] = this.supportsDepthTextureExtension ? 0 : 1
-      this.saoMaterial.defines['NORMAL_TEXTURE'] = this.supportsNormalTexture ? 1 : 0
-      this.saoMaterial.defines['PERSPECTIVE_CAMERA'] = this.camera.isPerspectiveCamera ? 1 : 0
-      this.saoMaterial.uniforms['tDepth'].value = this.supportsDepthTextureExtension
-        ? depthTexture
-        : this.depthRenderTarget.texture
-      this.saoMaterial.uniforms['tNormal'].value = this.normalRenderTarget.texture
-      this.saoMaterial.uniforms['size'].value.set(this.resolution.x, this.resolution.y)
-      this.saoMaterial.uniforms['cameraInverseProjectionMatrix'].value.copy(this.camera.projectionMatrixInverse)
-      this.saoMaterial.uniforms['cameraProjectionMatrix'].value = this.camera.projectionMatrix
-      this.saoMaterial.blending = NoBlending
-
-      this.vBlurMaterial = new ShaderMaterial({
-        uniforms: UniformsUtils.clone(DepthLimitedBlurShader.uniforms),
-        defines: Object.assign({}, DepthLimitedBlurShader.defines),
-        vertexShader: DepthLimitedBlurShader.vertexShader,
-        fragmentShader: DepthLimitedBlurShader.fragmentShader,
-      })
-      this.vBlurMaterial.defines['DEPTH_PACKING'] = this.supportsDepthTextureExtension ? 0 : 1
-      this.vBlurMaterial.defines['PERSPECTIVE_CAMERA'] = this.camera.isPerspectiveCamera ? 1 : 0
-      this.vBlurMaterial.uniforms['tDiffuse'].value = this.saoRenderTarget.texture
-      this.vBlurMaterial.uniforms['tDepth'].value = this.supportsDepthTextureExtension
-        ? depthTexture
-        : this.depthRenderTarget.texture
-      this.vBlurMaterial.uniforms['size'].value.set(this.resolution.x, this.resolution.y)
-      this.vBlurMaterial.blending = NoBlending
-
-      this.hBlurMaterial = new ShaderMaterial({
-        uniforms: UniformsUtils.clone(DepthLimitedBlurShader.uniforms),
-        defines: Object.assign({}, DepthLimitedBlurShader.defines),
-        vertexShader: DepthLimitedBlurShader.vertexShader,
-        fragmentShader: DepthLimitedBlurShader.fragmentShader,
-      })
-      this.hBlurMaterial.defines['DEPTH_PACKING'] = this.supportsDepthTextureExtension ? 0 : 1
-      this.hBlurMaterial.defines['PERSPECTIVE_CAMERA'] = this.camera.isPerspectiveCamera ? 1 : 0
-      this.hBlurMaterial.uniforms['tDiffuse'].value = this.blurIntermediateRenderTarget.texture
-      this.hBlurMaterial.uniforms['tDepth'].value = this.supportsDepthTextureExtension
-        ? depthTexture
-        : this.depthRenderTarget.texture
-      this.hBlurMaterial.uniforms['size'].value.set(this.resolution.x, this.resolution.y)
-      this.hBlurMaterial.blending = NoBlending
-
-      this.materialCopy = new ShaderMaterial({
-        uniforms: UniformsUtils.clone(CopyShader.uniforms),
-        vertexShader: CopyShader.vertexShader,
-        fragmentShader: CopyShader.fragmentShader,
-        blending: NoBlending,
-      })
-      this.materialCopy.transparent = true
-      this.materialCopy.depthTest = false
-      this.materialCopy.depthWrite = false
-      this.materialCopy.blending = CustomBlending
-      this.materialCopy.blendSrc = DstColorFactor
-      this.materialCopy.blendDst = ZeroFactor
-      this.materialCopy.blendEquation = AddEquation
-      this.materialCopy.blendSrcAlpha = DstAlphaFactor
-      this.materialCopy.blendDstAlpha = ZeroFactor
-      this.materialCopy.blendEquationAlpha = AddEquation
-
-      this.depthCopy = new ShaderMaterial({
-        uniforms: UniformsUtils.clone(UnpackDepthRGBAShader.uniforms),
-        vertexShader: UnpackDepthRGBAShader.vertexShader,
-        fragmentShader: UnpackDepthRGBAShader.fragmentShader,
-        blending: NoBlending,
-      })
-
-      this.fsQuad = new FullScreenQuad(null)
+      this.beautyRenderTarget.depthTexture = depthTexture
+      this.beautyRenderTarget.depthBuffer = true
     }
 
-    render(renderer, writeBuffer, readBuffer /*, deltaTime, maskActive*/) {
-      // Rendering readBuffer first when rendering to screen
-      if (this.renderToScreen) {
-        this.materialCopy.blending = NoBlending
-        this.materialCopy.uniforms['tDiffuse'].value = readBuffer.texture
-        this.materialCopy.needsUpdate = true
-        this.renderPass(renderer, this.materialCopy, null)
-      }
-
-      if (this.params.output === 1) {
-        return
-      }
+    this.depthMaterial = new MeshDepthMaterial()
+    this.depthMaterial.depthPacking = RGBADepthPacking
+    this.depthMaterial.blending = NoBlending
+
+    this.normalMaterial = new MeshNormalMaterial()
+    this.normalMaterial.blending = NoBlending
+
+    this.saoMaterial = new ShaderMaterial({
+      defines: Object.assign({}, SAOShader.defines),
+      fragmentShader: SAOShader.fragmentShader,
+      vertexShader: SAOShader.vertexShader,
+      uniforms: UniformsUtils.clone(SAOShader.uniforms),
+    })
+    this.saoMaterial.extensions.derivatives = true
+    this.saoMaterial.defines['DEPTH_PACKING'] = this.supportsDepthTextureExtension ? 0 : 1
+    this.saoMaterial.defines['NORMAL_TEXTURE'] = this.supportsNormalTexture ? 1 : 0
+    this.saoMaterial.defines['PERSPECTIVE_CAMERA'] = this.camera.isPerspectiveCamera ? 1 : 0
+    this.saoMaterial.uniforms['tDepth'].value = this.supportsDepthTextureExtension
+      ? depthTexture
+      : this.depthRenderTarget.texture
+    this.saoMaterial.uniforms['tNormal'].value = this.normalRenderTarget.texture
+    this.saoMaterial.uniforms['size'].value.set(this.resolution.x, this.resolution.y)
+    this.saoMaterial.uniforms['cameraInverseProjectionMatrix'].value.copy(this.camera.projectionMatrixInverse)
+    this.saoMaterial.uniforms['cameraProjectionMatrix'].value = this.camera.projectionMatrix
+    this.saoMaterial.blending = NoBlending
+
+    this.vBlurMaterial = new ShaderMaterial({
+      uniforms: UniformsUtils.clone(DepthLimitedBlurShader.uniforms),
+      defines: Object.assign({}, DepthLimitedBlurShader.defines),
+      vertexShader: DepthLimitedBlurShader.vertexShader,
+      fragmentShader: DepthLimitedBlurShader.fragmentShader,
+    })
+    this.vBlurMaterial.defines['DEPTH_PACKING'] = this.supportsDepthTextureExtension ? 0 : 1
+    this.vBlurMaterial.defines['PERSPECTIVE_CAMERA'] = this.camera.isPerspectiveCamera ? 1 : 0
+    this.vBlurMaterial.uniforms['tDiffuse'].value = this.saoRenderTarget.texture
+    this.vBlurMaterial.uniforms['tDepth'].value = this.supportsDepthTextureExtension
+      ? depthTexture
+      : this.depthRenderTarget.texture
+    this.vBlurMaterial.uniforms['size'].value.set(this.resolution.x, this.resolution.y)
+    this.vBlurMaterial.blending = NoBlending
+
+    this.hBlurMaterial = new ShaderMaterial({
+      uniforms: UniformsUtils.clone(DepthLimitedBlurShader.uniforms),
+      defines: Object.assign({}, DepthLimitedBlurShader.defines),
+      vertexShader: DepthLimitedBlurShader.vertexShader,
+      fragmentShader: DepthLimitedBlurShader.fragmentShader,
+    })
+    this.hBlurMaterial.defines['DEPTH_PACKING'] = this.supportsDepthTextureExtension ? 0 : 1
+    this.hBlurMaterial.defines['PERSPECTIVE_CAMERA'] = this.camera.isPerspectiveCamera ? 1 : 0
+    this.hBlurMaterial.uniforms['tDiffuse'].value = this.blurIntermediateRenderTarget.texture
+    this.hBlurMaterial.uniforms['tDepth'].value = this.supportsDepthTextureExtension
+      ? depthTexture
+      : this.depthRenderTarget.texture
+    this.hBlurMaterial.uniforms['size'].value.set(this.resolution.x, this.resolution.y)
+    this.hBlurMaterial.blending = NoBlending
+
+    this.materialCopy = new ShaderMaterial({
+      uniforms: UniformsUtils.clone(CopyShader.uniforms),
+      vertexShader: CopyShader.vertexShader,
+      fragmentShader: CopyShader.fragmentShader,
+      blending: NoBlending,
+    })
+    this.materialCopy.transparent = true
+    this.materialCopy.depthTest = false
+    this.materialCopy.depthWrite = false
+    this.materialCopy.blending = CustomBlending
+    this.materialCopy.blendSrc = DstColorFactor
+    this.materialCopy.blendDst = ZeroFactor
+    this.materialCopy.blendEquation = AddEquation
+    this.materialCopy.blendSrcAlpha = DstAlphaFactor
+    this.materialCopy.blendDstAlpha = ZeroFactor
+    this.materialCopy.blendEquationAlpha = AddEquation
+
+    this.depthCopy = new ShaderMaterial({
+      uniforms: UniformsUtils.clone(UnpackDepthRGBAShader.uniforms),
+      vertexShader: UnpackDepthRGBAShader.vertexShader,
+      fragmentShader: UnpackDepthRGBAShader.fragmentShader,
+      blending: NoBlending,
+    })
+
+    this.fsQuad = new FullScreenQuad(null)
+  }
 
-      renderer.getClearColor(this._oldClearColor)
-      this.oldClearAlpha = renderer.getClearAlpha()
-      const oldAutoClear = renderer.autoClear
-      renderer.autoClear = false
+  render(renderer, writeBuffer, readBuffer /*, deltaTime, maskActive*/) {
+    // Rendering readBuffer first when rendering to screen
+    if (this.renderToScreen) {
+      this.materialCopy.blending = NoBlending
+      this.materialCopy.uniforms['tDiffuse'].value = readBuffer.texture
+      this.materialCopy.needsUpdate = true
+      this.renderPass(renderer, this.materialCopy, null)
+    }
 
-      renderer.setRenderTarget(this.depthRenderTarget)
-      renderer.clear()
+    if (this.params.output === 1) {
+      return
+    }
 
-      this.saoMaterial.uniforms['bias'].value = this.params.saoBias
-      this.saoMaterial.uniforms['intensity'].value = this.params.saoIntensity
-      this.saoMaterial.uniforms['scale'].value = this.params.saoScale
-      this.saoMaterial.uniforms['kernelRadius'].value = this.params.saoKernelRadius
-      this.saoMaterial.uniforms['minResolution'].value = this.params.saoMinResolution
-      this.saoMaterial.uniforms['cameraNear'].value = this.camera.near
-      this.saoMaterial.uniforms['cameraFar'].value = this.camera.far
-      // this.saoMaterial.uniforms['randomSeed'].value = Math.random();
-
-      const depthCutoff = this.params.saoBlurDepthCutoff * (this.camera.far - this.camera.near)
-      this.vBlurMaterial.uniforms['depthCutoff'].value = depthCutoff
-      this.hBlurMaterial.uniforms['depthCutoff'].value = depthCutoff
-
-      this.vBlurMaterial.uniforms['cameraNear'].value = this.camera.near
-      this.vBlurMaterial.uniforms['cameraFar'].value = this.camera.far
-      this.hBlurMaterial.uniforms['cameraNear'].value = this.camera.near
-      this.hBlurMaterial.uniforms['cameraFar'].value = this.camera.far
-
-      this.params.saoBlurRadius = Math.floor(this.params.saoBlurRadius)
-      if (this.prevStdDev !== this.params.saoBlurStdDev || this.prevNumSamples !== this.params.saoBlurRadius) {
-        BlurShaderUtils.configure(
-          this.vBlurMaterial,
-          this.params.saoBlurRadius,
-          this.params.saoBlurStdDev,
-          new Vector2(0, 1),
-        )
-        BlurShaderUtils.configure(
-          this.hBlurMaterial,
-          this.params.saoBlurRadius,
-          this.params.saoBlurStdDev,
-          new Vector2(1, 0),
-        )
-        this.prevStdDev = this.params.saoBlurStdDev
-        this.prevNumSamples = this.params.saoBlurRadius
-      }
+    renderer.getClearColor(this._oldClearColor)
+    this.oldClearAlpha = renderer.getClearAlpha()
+    const oldAutoClear = renderer.autoClear
+    renderer.autoClear = false
+
+    renderer.setRenderTarget(this.depthRenderTarget)
+    renderer.clear()
+
+    this.saoMaterial.uniforms['bias'].value = this.params.saoBias
+    this.saoMaterial.uniforms['intensity'].value = this.params.saoIntensity
+    this.saoMaterial.uniforms['scale'].value = this.params.saoScale
+    this.saoMaterial.uniforms['kernelRadius'].value = this.params.saoKernelRadius
+    this.saoMaterial.uniforms['minResolution'].value = this.params.saoMinResolution
+    this.saoMaterial.uniforms['cameraNear'].value = this.camera.near
+    this.saoMaterial.uniforms['cameraFar'].value = this.camera.far
+    // this.saoMaterial.uniforms['randomSeed'].value = Math.random();
+
+    const depthCutoff = this.params.saoBlurDepthCutoff * (this.camera.far - this.camera.near)
+    this.vBlurMaterial.uniforms['depthCutoff'].value = depthCutoff
+    this.hBlurMaterial.uniforms['depthCutoff'].value = depthCutoff
+
+    this.vBlurMaterial.uniforms['cameraNear'].value = this.camera.near
+    this.vBlurMaterial.uniforms['cameraFar'].value = this.camera.far
+    this.hBlurMaterial.uniforms['cameraNear'].value = this.camera.near
+    this.hBlurMaterial.uniforms['cameraFar'].value = this.camera.far
+
+    this.params.saoBlurRadius = Math.floor(this.params.saoBlurRadius)
+    if (this.prevStdDev !== this.params.saoBlurStdDev || this.prevNumSamples !== this.params.saoBlurRadius) {
+      BlurShaderUtils.configure(
+        this.vBlurMaterial,
+        this.params.saoBlurRadius,
+        this.params.saoBlurStdDev,
+        new Vector2(0, 1),
+      )
+      BlurShaderUtils.configure(
+        this.hBlurMaterial,
+        this.params.saoBlurRadius,
+        this.params.saoBlurStdDev,
+        new Vector2(1, 0),
+      )
+      this.prevStdDev = this.params.saoBlurStdDev
+      this.prevNumSamples = this.params.saoBlurRadius
+    }
 
-      // Rendering scene to depth texture
-      renderer.setClearColor(0x000000)
-      renderer.setRenderTarget(this.beautyRenderTarget)
-      renderer.clear()
-      renderer.render(this.scene, this.camera)
+    // Rendering scene to depth texture
+    renderer.setClearColor(0x000000)
+    renderer.setRenderTarget(this.beautyRenderTarget)
+    renderer.clear()
+    renderer.render(this.scene, this.camera)
 
-      // Re-render scene if depth texture extension is not supported
-      if (!this.supportsDepthTextureExtension) {
-        // Clear rule : far clipping plane in both RGBA and Basic encoding
-        this.renderOverride(renderer, this.depthMaterial, this.depthRenderTarget, 0x000000, 1.0)
-      }
+    // Re-render scene if depth texture extension is not supported
+    if (!this.supportsDepthTextureExtension) {
+      // Clear rule : far clipping plane in both RGBA and Basic encoding
+      this.renderOverride(renderer, this.depthMaterial, this.depthRenderTarget, 0x000000, 1.0)
+    }
 
-      if (this.supportsNormalTexture) {
-        // Clear rule : default normal is facing the camera
-        this.renderOverride(renderer, this.normalMaterial, this.normalRenderTarget, 0x7777ff, 1.0)
-      }
+    if (this.supportsNormalTexture) {
+      // Clear rule : default normal is facing the camera
+      this.renderOverride(renderer, this.normalMaterial, this.normalRenderTarget, 0x7777ff, 1.0)
+    }
 
-      // Rendering SAO texture
-      this.renderPass(renderer, this.saoMaterial, this.saoRenderTarget, 0xffffff, 1.0)
+    // Rendering SAO texture
+    this.renderPass(renderer, this.saoMaterial, this.saoRenderTarget, 0xffffff, 1.0)
 
-      // Blurring SAO texture
-      if (this.params.saoBlur) {
-        this.renderPass(renderer, this.vBlurMaterial, this.blurIntermediateRenderTarget, 0xffffff, 1.0)
-        this.renderPass(renderer, this.hBlurMaterial, this.saoRenderTarget, 0xffffff, 1.0)
-      }
+    // Blurring SAO texture
+    if (this.params.saoBlur) {
+      this.renderPass(renderer, this.vBlurMaterial, this.blurIntermediateRenderTarget, 0xffffff, 1.0)
+      this.renderPass(renderer, this.hBlurMaterial, this.saoRenderTarget, 0xffffff, 1.0)
+    }
 
-      let outputMaterial = this.materialCopy
-      // Setting up SAO rendering
-      if (this.params.output === 3) {
-        if (this.supportsDepthTextureExtension) {
-          this.materialCopy.uniforms['tDiffuse'].value = this.beautyRenderTarget.depthTexture
-          this.materialCopy.needsUpdate = true
-        } else {
-          this.depthCopy.uniforms['tDiffuse'].value = this.depthRenderTarget.texture
-          this.depthCopy.needsUpdate = true
-          outputMaterial = this.depthCopy
-        }
-      } else if (this.params.output === 4) {
-        this.materialCopy.uniforms['tDiffuse'].value = this.normalRenderTarget.texture
+    let outputMaterial = this.materialCopy
+    // Setting up SAO rendering
+    if (this.params.output === 3) {
+      if (this.supportsDepthTextureExtension) {
+        this.materialCopy.uniforms['tDiffuse'].value = this.beautyRenderTarget.depthTexture
         this.materialCopy.needsUpdate = true
       } else {
-        this.materialCopy.uniforms['tDiffuse'].value = this.saoRenderTarget.texture
-        this.materialCopy.needsUpdate = true
+        this.depthCopy.uniforms['tDiffuse'].value = this.depthRenderTarget.texture
+        this.depthCopy.needsUpdate = true
+        outputMaterial = this.depthCopy
       }
+    } else if (this.params.output === 4) {
+      this.materialCopy.uniforms['tDiffuse'].value = this.normalRenderTarget.texture
+      this.materialCopy.needsUpdate = true
+    } else {
+      this.materialCopy.uniforms['tDiffuse'].value = this.saoRenderTarget.texture
+      this.materialCopy.needsUpdate = true
+    }
 
-      // Blending depends on output, only want a CustomBlending when showing SAO
-      if (this.params.output === 0) {
-        outputMaterial.blending = CustomBlending
-      } else {
-        outputMaterial.blending = NoBlending
-      }
-
-      // Rendering SAOPass result on top of previous pass
-      this.renderPass(renderer, outputMaterial, this.renderToScreen ? null : readBuffer)
-
-      renderer.setClearColor(this._oldClearColor, this.oldClearAlpha)
-      renderer.autoClear = oldAutoClear
+    // Blending depends on output, only want a CustomBlending when showing SAO
+    if (this.params.output === 0) {
+      outputMaterial.blending = CustomBlending
+    } else {
+      outputMaterial.blending = NoBlending
     }
 
-    renderPass(renderer, passMaterial, renderTarget, clearColor, clearAlpha) {
-      // save original state
-      renderer.getClearColor(this.originalClearColor)
-      const originalClearAlpha = renderer.getClearAlpha()
-      const originalAutoClear = renderer.autoClear
+    // Rendering SAOPass result on top of previous pass
+    this.renderPass(renderer, outputMaterial, this.renderToScreen ? null : readBuffer)
 
-      renderer.setRenderTarget(renderTarget)
+    renderer.setClearColor(this._oldClearColor, this.oldClearAlpha)
+    renderer.autoClear = oldAutoClear
+  }
 
-      // setup pass state
-      renderer.autoClear = false
-      if (clearColor !== undefined && clearColor !== null) {
-        renderer.setClearColor(clearColor)
-        renderer.setClearAlpha(clearAlpha || 0.0)
-        renderer.clear()
-      }
+  renderPass(renderer, passMaterial, renderTarget, clearColor, clearAlpha) {
+    // save original state
+    renderer.getClearColor(this.originalClearColor)
+    const originalClearAlpha = renderer.getClearAlpha()
+    const originalAutoClear = renderer.autoClear
 
-      this.fsQuad.material = passMaterial
-      this.fsQuad.render(renderer)
+    renderer.setRenderTarget(renderTarget)
 
-      // restore original state
-      renderer.autoClear = originalAutoClear
-      renderer.setClearColor(this.originalClearColor)
-      renderer.setClearAlpha(originalClearAlpha)
+    // setup pass state
+    renderer.autoClear = false
+    if (clearColor !== undefined && clearColor !== null) {
+      renderer.setClearColor(clearColor)
+      renderer.setClearAlpha(clearAlpha || 0.0)
+      renderer.clear()
     }
 
-    renderOverride(renderer, overrideMaterial, renderTarget, clearColor, clearAlpha) {
-      renderer.getClearColor(this.originalClearColor)
-      const originalClearAlpha = renderer.getClearAlpha()
-      const originalAutoClear = renderer.autoClear
+    this.fsQuad.material = passMaterial
+    this.fsQuad.render(renderer)
 
-      renderer.setRenderTarget(renderTarget)
-      renderer.autoClear = false
+    // restore original state
+    renderer.autoClear = originalAutoClear
+    renderer.setClearColor(this.originalClearColor)
+    renderer.setClearAlpha(originalClearAlpha)
+  }
 
-      clearColor = overrideMaterial.clearColor || clearColor
-      clearAlpha = overrideMaterial.clearAlpha || clearAlpha
-      if (clearColor !== undefined && clearColor !== null) {
-        renderer.setClearColor(clearColor)
-        renderer.setClearAlpha(clearAlpha || 0.0)
-        renderer.clear()
-      }
+  renderOverride(renderer, overrideMaterial, renderTarget, clearColor, clearAlpha) {
+    renderer.getClearColor(this.originalClearColor)
+    const originalClearAlpha = renderer.getClearAlpha()
+    const originalAutoClear = renderer.autoClear
 
-      this.scene.overrideMaterial = overrideMaterial
-      renderer.render(this.scene, this.camera)
-      this.scene.overrideMaterial = null
+    renderer.setRenderTarget(renderTarget)
+    renderer.autoClear = false
 
-      // restore original state
-      renderer.autoClear = originalAutoClear
-      renderer.setClearColor(this.originalClearColor)
-      renderer.setClearAlpha(originalClearAlpha)
+    clearColor = overrideMaterial.clearColor || clearColor
+    clearAlpha = overrideMaterial.clearAlpha || clearAlpha
+    if (clearColor !== undefined && clearColor !== null) {
+      renderer.setClearColor(clearColor)
+      renderer.setClearAlpha(clearAlpha || 0.0)
+      renderer.clear()
     }
 
-    setSize(width, height) {
-      this.beautyRenderTarget.setSize(width, height)
-      this.saoRenderTarget.setSize(width, height)
-      this.blurIntermediateRenderTarget.setSize(width, height)
-      this.normalRenderTarget.setSize(width, height)
-      this.depthRenderTarget.setSize(width, height)
+    this.scene.overrideMaterial = overrideMaterial
+    renderer.render(this.scene, this.camera)
+    this.scene.overrideMaterial = null
 
-      this.saoMaterial.uniforms['size'].value.set(width, height)
-      this.saoMaterial.uniforms['cameraInverseProjectionMatrix'].value.copy(this.camera.projectionMatrixInverse)
-      this.saoMaterial.uniforms['cameraProjectionMatrix'].value = this.camera.projectionMatrix
-      this.saoMaterial.needsUpdate = true
+    // restore original state
+    renderer.autoClear = originalAutoClear
+    renderer.setClearColor(this.originalClearColor)
+    renderer.setClearAlpha(originalClearAlpha)
+  }
 
-      this.vBlurMaterial.uniforms['size'].value.set(width, height)
-      this.vBlurMaterial.needsUpdate = true
+  setSize(width, height) {
+    this.beautyRenderTarget.setSize(width, height)
+    this.saoRenderTarget.setSize(width, height)
+    this.blurIntermediateRenderTarget.setSize(width, height)
+    this.normalRenderTarget.setSize(width, height)
+    this.depthRenderTarget.setSize(width, height)
 
-      this.hBlurMaterial.uniforms['size'].value.set(width, height)
-      this.hBlurMaterial.needsUpdate = true
-    }
+    this.saoMaterial.uniforms['size'].value.set(width, height)
+    this.saoMaterial.uniforms['cameraInverseProjectionMatrix'].value.copy(this.camera.projectionMatrixInverse)
+    this.saoMaterial.uniforms['cameraProjectionMatrix'].value = this.camera.projectionMatrix
+    this.saoMaterial.needsUpdate = true
 
-    dispose() {
-      this.saoRenderTarget.dispose()
-      this.blurIntermediateRenderTarget.dispose()
-      this.beautyRenderTarget.dispose()
-      this.normalRenderTarget.dispose()
-      this.depthRenderTarget.dispose()
-
-      this.depthMaterial.dispose()
-      this.normalMaterial.dispose()
-      this.saoMaterial.dispose()
-      this.vBlurMaterial.dispose()
-      this.hBlurMaterial.dispose()
-      this.materialCopy.dispose()
-      this.depthCopy.dispose()
-
-      this.fsQuad.dispose()
-    }
+    this.vBlurMaterial.uniforms['size'].value.set(width, height)
+    this.vBlurMaterial.needsUpdate = true
+
+    this.hBlurMaterial.uniforms['size'].value.set(width, height)
+    this.hBlurMaterial.needsUpdate = true
   }
 
-  return SAOPass
-})()
+  dispose() {
+    this.saoRenderTarget.dispose()
+    this.blurIntermediateRenderTarget.dispose()
+    this.beautyRenderTarget.dispose()
+    this.normalRenderTarget.dispose()
+    this.depthRenderTarget.dispose()
+
+    this.depthMaterial.dispose()
+    this.normalMaterial.dispose()
+    this.saoMaterial.dispose()
+    this.vBlurMaterial.dispose()
+    this.hBlurMaterial.dispose()
+    this.materialCopy.dispose()
+    this.depthCopy.dispose()
+
+    this.fsQuad.dispose()
+  }
+}
 
 export { SAOPass }
diff --git a/src/postprocessing/SSAOPass.js b/src/postprocessing/SSAOPass.js
index 1af8f82b..52a5d0ed 100644
--- a/src/postprocessing/SSAOPass.js
+++ b/src/postprocessing/SSAOPass.js
@@ -28,381 +28,377 @@ import { SSAOShader, SSAOBlurShader, SSAODepthShader } from '../shaders/SSAOShad
 
 import { CopyShader } from '../shaders/CopyShader'
 
-const SSAOPass = /* @__PURE__ */ (() => {
-  class SSAOPass extends Pass {
-    static OUTPUT = {
-      Default: 0,
-      SSAO: 1,
-      Blur: 2,
-      Beauty: 3,
-      Depth: 4,
-      Normal: 5,
-    }
+class SSAOPass extends Pass {
+  static OUTPUT = {
+    Default: 0,
+    SSAO: 1,
+    Blur: 2,
+    Beauty: 3,
+    Depth: 4,
+    Normal: 5,
+  }
 
-    constructor(scene, camera, width, height) {
-      super()
+  constructor(scene, camera, width, height) {
+    super()
 
-      this.width = width !== undefined ? width : 512
-      this.height = height !== undefined ? height : 512
+    this.width = width !== undefined ? width : 512
+    this.height = height !== undefined ? height : 512
 
-      this.clear = true
+    this.clear = true
 
-      this.camera = camera
-      this.scene = scene
+    this.camera = camera
+    this.scene = scene
 
-      this.kernelRadius = 8
-      this.kernelSize = 32
-      this.kernel = []
-      this.noiseTexture = null
-      this.output = 0
+    this.kernelRadius = 8
+    this.kernelSize = 32
+    this.kernel = []
+    this.noiseTexture = null
+    this.output = 0
 
-      this.minDistance = 0.005
-      this.maxDistance = 0.1
+    this.minDistance = 0.005
+    this.maxDistance = 0.1
 
-      this._visibilityCache = new Map()
+    this._visibilityCache = new Map()
 
-      //
+    //
 
-      this.generateSampleKernel()
-      this.generateRandomKernelRotations()
+    this.generateSampleKernel()
+    this.generateRandomKernelRotations()
 
-      // beauty render target
+    // beauty render target
 
-      const depthTexture = new DepthTexture()
-      depthTexture.format = DepthStencilFormat
-      depthTexture.type = UnsignedInt248Type
+    const depthTexture = new DepthTexture()
+    depthTexture.format = DepthStencilFormat
+    depthTexture.type = UnsignedInt248Type
 
-      this.beautyRenderTarget = new WebGLRenderTarget(this.width, this.height)
+    this.beautyRenderTarget = new WebGLRenderTarget(this.width, this.height)
 
-      // normal render target with depth buffer
+    // normal render target with depth buffer
 
-      this.normalRenderTarget = new WebGLRenderTarget(this.width, this.height, {
-        minFilter: NearestFilter,
-        magFilter: NearestFilter,
-        depthTexture: depthTexture,
-      })
+    this.normalRenderTarget = new WebGLRenderTarget(this.width, this.height, {
+      minFilter: NearestFilter,
+      magFilter: NearestFilter,
+      depthTexture: depthTexture,
+    })
 
-      // ssao render target
+    // ssao render target
 
-      this.ssaoRenderTarget = new WebGLRenderTarget(this.width, this.height)
+    this.ssaoRenderTarget = new WebGLRenderTarget(this.width, this.height)
 
-      this.blurRenderTarget = this.ssaoRenderTarget.clone()
+    this.blurRenderTarget = this.ssaoRenderTarget.clone()
 
-      // ssao material
+    // ssao material
 
-      if (SSAOShader === undefined) {
-        console.error('THREE.SSAOPass: The pass relies on SSAOShader.')
-      }
+    if (SSAOShader === undefined) {
+      console.error('THREE.SSAOPass: The pass relies on SSAOShader.')
+    }
 
-      this.ssaoMaterial = new ShaderMaterial({
-        defines: Object.assign({}, SSAOShader.defines),
-        uniforms: UniformsUtils.clone(SSAOShader.uniforms),
-        vertexShader: SSAOShader.vertexShader,
-        fragmentShader: SSAOShader.fragmentShader,
-        blending: NoBlending,
-      })
+    this.ssaoMaterial = new ShaderMaterial({
+      defines: Object.assign({}, SSAOShader.defines),
+      uniforms: UniformsUtils.clone(SSAOShader.uniforms),
+      vertexShader: SSAOShader.vertexShader,
+      fragmentShader: SSAOShader.fragmentShader,
+      blending: NoBlending,
+    })
+
+    this.ssaoMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
+    this.ssaoMaterial.uniforms['tNormal'].value = this.normalRenderTarget.texture
+    this.ssaoMaterial.uniforms['tDepth'].value = this.normalRenderTarget.depthTexture
+    this.ssaoMaterial.uniforms['tNoise'].value = this.noiseTexture
+    this.ssaoMaterial.uniforms['kernel'].value = this.kernel
+    this.ssaoMaterial.uniforms['cameraNear'].value = this.camera.near
+    this.ssaoMaterial.uniforms['cameraFar'].value = this.camera.far
+    this.ssaoMaterial.uniforms['resolution'].value.set(this.width, this.height)
+    this.ssaoMaterial.uniforms['cameraProjectionMatrix'].value.copy(this.camera.projectionMatrix)
+    this.ssaoMaterial.uniforms['cameraInverseProjectionMatrix'].value.copy(this.camera.projectionMatrixInverse)
+
+    // normal material
+
+    this.normalMaterial = new MeshNormalMaterial()
+    this.normalMaterial.blending = NoBlending
+
+    // blur material
+
+    this.blurMaterial = new ShaderMaterial({
+      defines: Object.assign({}, SSAOBlurShader.defines),
+      uniforms: UniformsUtils.clone(SSAOBlurShader.uniforms),
+      vertexShader: SSAOBlurShader.vertexShader,
+      fragmentShader: SSAOBlurShader.fragmentShader,
+    })
+    this.blurMaterial.uniforms['tDiffuse'].value = this.ssaoRenderTarget.texture
+    this.blurMaterial.uniforms['resolution'].value.set(this.width, this.height)
+
+    // material for rendering the depth
+
+    this.depthRenderMaterial = new ShaderMaterial({
+      defines: Object.assign({}, SSAODepthShader.defines),
+      uniforms: UniformsUtils.clone(SSAODepthShader.uniforms),
+      vertexShader: SSAODepthShader.vertexShader,
+      fragmentShader: SSAODepthShader.fragmentShader,
+      blending: NoBlending,
+    })
+    this.depthRenderMaterial.uniforms['tDepth'].value = this.normalRenderTarget.depthTexture
+    this.depthRenderMaterial.uniforms['cameraNear'].value = this.camera.near
+    this.depthRenderMaterial.uniforms['cameraFar'].value = this.camera.far
+
+    // material for rendering the content of a render target
+
+    this.copyMaterial = new ShaderMaterial({
+      uniforms: UniformsUtils.clone(CopyShader.uniforms),
+      vertexShader: CopyShader.vertexShader,
+      fragmentShader: CopyShader.fragmentShader,
+      transparent: true,
+      depthTest: false,
+      depthWrite: false,
+      blendSrc: DstColorFactor,
+      blendDst: ZeroFactor,
+      blendEquation: AddEquation,
+      blendSrcAlpha: DstAlphaFactor,
+      blendDstAlpha: ZeroFactor,
+      blendEquationAlpha: AddEquation,
+    })
+
+    this.fsQuad = new FullScreenQuad(null)
+
+    this.originalClearColor = new Color()
+  }
 
-      this.ssaoMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
-      this.ssaoMaterial.uniforms['tNormal'].value = this.normalRenderTarget.texture
-      this.ssaoMaterial.uniforms['tDepth'].value = this.normalRenderTarget.depthTexture
-      this.ssaoMaterial.uniforms['tNoise'].value = this.noiseTexture
-      this.ssaoMaterial.uniforms['kernel'].value = this.kernel
-      this.ssaoMaterial.uniforms['cameraNear'].value = this.camera.near
-      this.ssaoMaterial.uniforms['cameraFar'].value = this.camera.far
-      this.ssaoMaterial.uniforms['resolution'].value.set(this.width, this.height)
-      this.ssaoMaterial.uniforms['cameraProjectionMatrix'].value.copy(this.camera.projectionMatrix)
-      this.ssaoMaterial.uniforms['cameraInverseProjectionMatrix'].value.copy(this.camera.projectionMatrixInverse)
+  dispose() {
+    // dispose render targets
 
-      // normal material
+    this.beautyRenderTarget.dispose()
+    this.normalRenderTarget.dispose()
+    this.ssaoRenderTarget.dispose()
+    this.blurRenderTarget.dispose()
 
-      this.normalMaterial = new MeshNormalMaterial()
-      this.normalMaterial.blending = NoBlending
+    // dispose materials
 
-      // blur material
+    this.normalMaterial.dispose()
+    this.blurMaterial.dispose()
+    this.copyMaterial.dispose()
+    this.depthRenderMaterial.dispose()
 
-      this.blurMaterial = new ShaderMaterial({
-        defines: Object.assign({}, SSAOBlurShader.defines),
-        uniforms: UniformsUtils.clone(SSAOBlurShader.uniforms),
-        vertexShader: SSAOBlurShader.vertexShader,
-        fragmentShader: SSAOBlurShader.fragmentShader,
-      })
-      this.blurMaterial.uniforms['tDiffuse'].value = this.ssaoRenderTarget.texture
-      this.blurMaterial.uniforms['resolution'].value.set(this.width, this.height)
+    // dipsose full screen quad
 
-      // material for rendering the depth
+    this.fsQuad.dispose()
+  }
 
-      this.depthRenderMaterial = new ShaderMaterial({
-        defines: Object.assign({}, SSAODepthShader.defines),
-        uniforms: UniformsUtils.clone(SSAODepthShader.uniforms),
-        vertexShader: SSAODepthShader.vertexShader,
-        fragmentShader: SSAODepthShader.fragmentShader,
-        blending: NoBlending,
-      })
-      this.depthRenderMaterial.uniforms['tDepth'].value = this.normalRenderTarget.depthTexture
-      this.depthRenderMaterial.uniforms['cameraNear'].value = this.camera.near
-      this.depthRenderMaterial.uniforms['cameraFar'].value = this.camera.far
+  render(renderer, writeBuffer /*, readBuffer, deltaTime, maskActive */) {
+    if (renderer.capabilities.isWebGL2 === false) this.noiseTexture.format = LuminanceFormat
 
-      // material for rendering the content of a render target
+    // render beauty
 
-      this.copyMaterial = new ShaderMaterial({
-        uniforms: UniformsUtils.clone(CopyShader.uniforms),
-        vertexShader: CopyShader.vertexShader,
-        fragmentShader: CopyShader.fragmentShader,
-        transparent: true,
-        depthTest: false,
-        depthWrite: false,
-        blendSrc: DstColorFactor,
-        blendDst: ZeroFactor,
-        blendEquation: AddEquation,
-        blendSrcAlpha: DstAlphaFactor,
-        blendDstAlpha: ZeroFactor,
-        blendEquationAlpha: AddEquation,
-      })
-
-      this.fsQuad = new FullScreenQuad(null)
-
-      this.originalClearColor = new Color()
-    }
+    renderer.setRenderTarget(this.beautyRenderTarget)
+    renderer.clear()
+    renderer.render(this.scene, this.camera)
 
-    dispose() {
-      // dispose render targets
+    // render normals and depth (honor only meshes, points and lines do not contribute to SSAO)
 
-      this.beautyRenderTarget.dispose()
-      this.normalRenderTarget.dispose()
-      this.ssaoRenderTarget.dispose()
-      this.blurRenderTarget.dispose()
+    this.overrideVisibility()
+    this.renderOverride(renderer, this.normalMaterial, this.normalRenderTarget, 0x7777ff, 1.0)
+    this.restoreVisibility()
 
-      // dispose materials
+    // render SSAO
 
-      this.normalMaterial.dispose()
-      this.blurMaterial.dispose()
-      this.copyMaterial.dispose()
-      this.depthRenderMaterial.dispose()
+    this.ssaoMaterial.uniforms['kernelRadius'].value = this.kernelRadius
+    this.ssaoMaterial.uniforms['minDistance'].value = this.minDistance
+    this.ssaoMaterial.uniforms['maxDistance'].value = this.maxDistance
+    this.renderPass(renderer, this.ssaoMaterial, this.ssaoRenderTarget)
 
-      // dipsose full screen quad
+    // render blur
 
-      this.fsQuad.dispose()
-    }
+    this.renderPass(renderer, this.blurMaterial, this.blurRenderTarget)
 
-    render(renderer, writeBuffer /*, readBuffer, deltaTime, maskActive */) {
-      if (renderer.capabilities.isWebGL2 === false) this.noiseTexture.format = LuminanceFormat
+    // output result to screen
 
-      // render beauty
+    switch (this.output) {
+      case SSAOPass.OUTPUT.SSAO:
+        this.copyMaterial.uniforms['tDiffuse'].value = this.ssaoRenderTarget.texture
+        this.copyMaterial.blending = NoBlending
+        this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
 
-      renderer.setRenderTarget(this.beautyRenderTarget)
-      renderer.clear()
-      renderer.render(this.scene, this.camera)
+        break
 
-      // render normals and depth (honor only meshes, points and lines do not contribute to SSAO)
+      case SSAOPass.OUTPUT.Blur:
+        this.copyMaterial.uniforms['tDiffuse'].value = this.blurRenderTarget.texture
+        this.copyMaterial.blending = NoBlending
+        this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
 
-      this.overrideVisibility()
-      this.renderOverride(renderer, this.normalMaterial, this.normalRenderTarget, 0x7777ff, 1.0)
-      this.restoreVisibility()
+        break
 
-      // render SSAO
+      case SSAOPass.OUTPUT.Beauty:
+        this.copyMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
+        this.copyMaterial.blending = NoBlending
+        this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
 
-      this.ssaoMaterial.uniforms['kernelRadius'].value = this.kernelRadius
-      this.ssaoMaterial.uniforms['minDistance'].value = this.minDistance
-      this.ssaoMaterial.uniforms['maxDistance'].value = this.maxDistance
-      this.renderPass(renderer, this.ssaoMaterial, this.ssaoRenderTarget)
+        break
 
-      // render blur
+      case SSAOPass.OUTPUT.Depth:
+        this.renderPass(renderer, this.depthRenderMaterial, this.renderToScreen ? null : writeBuffer)
 
-      this.renderPass(renderer, this.blurMaterial, this.blurRenderTarget)
+        break
 
-      // output result to screen
+      case SSAOPass.OUTPUT.Normal:
+        this.copyMaterial.uniforms['tDiffuse'].value = this.normalRenderTarget.texture
+        this.copyMaterial.blending = NoBlending
+        this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
 
-      switch (this.output) {
-        case SSAOPass.OUTPUT.SSAO:
-          this.copyMaterial.uniforms['tDiffuse'].value = this.ssaoRenderTarget.texture
-          this.copyMaterial.blending = NoBlending
-          this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
+        break
 
-          break
+      case SSAOPass.OUTPUT.Default:
+        this.copyMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
+        this.copyMaterial.blending = NoBlending
+        this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
 
-        case SSAOPass.OUTPUT.Blur:
-          this.copyMaterial.uniforms['tDiffuse'].value = this.blurRenderTarget.texture
-          this.copyMaterial.blending = NoBlending
-          this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
+        this.copyMaterial.uniforms['tDiffuse'].value = this.blurRenderTarget.texture
+        this.copyMaterial.blending = CustomBlending
+        this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
 
-          break
+        break
 
-        case SSAOPass.OUTPUT.Beauty:
-          this.copyMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
-          this.copyMaterial.blending = NoBlending
-          this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
+      default:
+        console.warn('THREE.SSAOPass: Unknown output type.')
+    }
+  }
 
-          break
+  renderPass(renderer, passMaterial, renderTarget, clearColor, clearAlpha) {
+    // save original state
+    renderer.getClearColor(this.originalClearColor)
+    const originalClearAlpha = renderer.getClearAlpha()
+    const originalAutoClear = renderer.autoClear
 
-        case SSAOPass.OUTPUT.Depth:
-          this.renderPass(renderer, this.depthRenderMaterial, this.renderToScreen ? null : writeBuffer)
+    renderer.setRenderTarget(renderTarget)
 
-          break
+    // setup pass state
+    renderer.autoClear = false
+    if (clearColor !== undefined && clearColor !== null) {
+      renderer.setClearColor(clearColor)
+      renderer.setClearAlpha(clearAlpha || 0.0)
+      renderer.clear()
+    }
 
-        case SSAOPass.OUTPUT.Normal:
-          this.copyMaterial.uniforms['tDiffuse'].value = this.normalRenderTarget.texture
-          this.copyMaterial.blending = NoBlending
-          this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
+    this.fsQuad.material = passMaterial
+    this.fsQuad.render(renderer)
 
-          break
+    // restore original state
+    renderer.autoClear = originalAutoClear
+    renderer.setClearColor(this.originalClearColor)
+    renderer.setClearAlpha(originalClearAlpha)
+  }
 
-        case SSAOPass.OUTPUT.Default:
-          this.copyMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
-          this.copyMaterial.blending = NoBlending
-          this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
+  renderOverride(renderer, overrideMaterial, renderTarget, clearColor, clearAlpha) {
+    renderer.getClearColor(this.originalClearColor)
+    const originalClearAlpha = renderer.getClearAlpha()
+    const originalAutoClear = renderer.autoClear
 
-          this.copyMaterial.uniforms['tDiffuse'].value = this.blurRenderTarget.texture
-          this.copyMaterial.blending = CustomBlending
-          this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
+    renderer.setRenderTarget(renderTarget)
+    renderer.autoClear = false
 
-          break
+    clearColor = overrideMaterial.clearColor || clearColor
+    clearAlpha = overrideMaterial.clearAlpha || clearAlpha
 
-        default:
-          console.warn('THREE.SSAOPass: Unknown output type.')
-      }
+    if (clearColor !== undefined && clearColor !== null) {
+      renderer.setClearColor(clearColor)
+      renderer.setClearAlpha(clearAlpha || 0.0)
+      renderer.clear()
     }
 
-    renderPass(renderer, passMaterial, renderTarget, clearColor, clearAlpha) {
-      // save original state
-      renderer.getClearColor(this.originalClearColor)
-      const originalClearAlpha = renderer.getClearAlpha()
-      const originalAutoClear = renderer.autoClear
-
-      renderer.setRenderTarget(renderTarget)
-
-      // setup pass state
-      renderer.autoClear = false
-      if (clearColor !== undefined && clearColor !== null) {
-        renderer.setClearColor(clearColor)
-        renderer.setClearAlpha(clearAlpha || 0.0)
-        renderer.clear()
-      }
-
-      this.fsQuad.material = passMaterial
-      this.fsQuad.render(renderer)
-
-      // restore original state
-      renderer.autoClear = originalAutoClear
-      renderer.setClearColor(this.originalClearColor)
-      renderer.setClearAlpha(originalClearAlpha)
-    }
+    this.scene.overrideMaterial = overrideMaterial
+    renderer.render(this.scene, this.camera)
+    this.scene.overrideMaterial = null
 
-    renderOverride(renderer, overrideMaterial, renderTarget, clearColor, clearAlpha) {
-      renderer.getClearColor(this.originalClearColor)
-      const originalClearAlpha = renderer.getClearAlpha()
-      const originalAutoClear = renderer.autoClear
+    // restore original state
 
-      renderer.setRenderTarget(renderTarget)
-      renderer.autoClear = false
+    renderer.autoClear = originalAutoClear
+    renderer.setClearColor(this.originalClearColor)
+    renderer.setClearAlpha(originalClearAlpha)
+  }
 
-      clearColor = overrideMaterial.clearColor || clearColor
-      clearAlpha = overrideMaterial.clearAlpha || clearAlpha
+  setSize(width, height) {
+    this.width = width
+    this.height = height
 
-      if (clearColor !== undefined && clearColor !== null) {
-        renderer.setClearColor(clearColor)
-        renderer.setClearAlpha(clearAlpha || 0.0)
-        renderer.clear()
-      }
+    this.beautyRenderTarget.setSize(width, height)
+    this.ssaoRenderTarget.setSize(width, height)
+    this.normalRenderTarget.setSize(width, height)
+    this.blurRenderTarget.setSize(width, height)
 
-      this.scene.overrideMaterial = overrideMaterial
-      renderer.render(this.scene, this.camera)
-      this.scene.overrideMaterial = null
+    this.ssaoMaterial.uniforms['resolution'].value.set(width, height)
+    this.ssaoMaterial.uniforms['cameraProjectionMatrix'].value.copy(this.camera.projectionMatrix)
+    this.ssaoMaterial.uniforms['cameraInverseProjectionMatrix'].value.copy(this.camera.projectionMatrixInverse)
 
-      // restore original state
+    this.blurMaterial.uniforms['resolution'].value.set(width, height)
+  }
 
-      renderer.autoClear = originalAutoClear
-      renderer.setClearColor(this.originalClearColor)
-      renderer.setClearAlpha(originalClearAlpha)
-    }
+  generateSampleKernel() {
+    const kernelSize = this.kernelSize
+    const kernel = this.kernel
 
-    setSize(width, height) {
-      this.width = width
-      this.height = height
+    for (let i = 0; i < kernelSize; i++) {
+      const sample = new Vector3()
+      sample.x = Math.random() * 2 - 1
+      sample.y = Math.random() * 2 - 1
+      sample.z = Math.random()
 
-      this.beautyRenderTarget.setSize(width, height)
-      this.ssaoRenderTarget.setSize(width, height)
-      this.normalRenderTarget.setSize(width, height)
-      this.blurRenderTarget.setSize(width, height)
+      sample.normalize()
 
-      this.ssaoMaterial.uniforms['resolution'].value.set(width, height)
-      this.ssaoMaterial.uniforms['cameraProjectionMatrix'].value.copy(this.camera.projectionMatrix)
-      this.ssaoMaterial.uniforms['cameraInverseProjectionMatrix'].value.copy(this.camera.projectionMatrixInverse)
+      let scale = i / kernelSize
+      scale = MathUtils.lerp(0.1, 1, scale * scale)
+      sample.multiplyScalar(scale)
 
-      this.blurMaterial.uniforms['resolution'].value.set(width, height)
+      kernel.push(sample)
     }
+  }
 
-    generateSampleKernel() {
-      const kernelSize = this.kernelSize
-      const kernel = this.kernel
-
-      for (let i = 0; i < kernelSize; i++) {
-        const sample = new Vector3()
-        sample.x = Math.random() * 2 - 1
-        sample.y = Math.random() * 2 - 1
-        sample.z = Math.random()
-
-        sample.normalize()
-
-        let scale = i / kernelSize
-        scale = MathUtils.lerp(0.1, 1, scale * scale)
-        sample.multiplyScalar(scale)
+  generateRandomKernelRotations() {
+    const width = 4,
+      height = 4
 
-        kernel.push(sample)
-      }
+    if (SimplexNoise === undefined) {
+      console.error('THREE.SSAOPass: The pass relies on SimplexNoise.')
     }
 
-    generateRandomKernelRotations() {
-      const width = 4,
-        height = 4
-
-      if (SimplexNoise === undefined) {
-        console.error('THREE.SSAOPass: The pass relies on SimplexNoise.')
-      }
-
-      const simplex = new SimplexNoise()
+    const simplex = new SimplexNoise()
 
-      const size = width * height
-      const data = new Float32Array(size)
+    const size = width * height
+    const data = new Float32Array(size)
 
-      for (let i = 0; i < size; i++) {
-        const x = Math.random() * 2 - 1
-        const y = Math.random() * 2 - 1
-        const z = 0
+    for (let i = 0; i < size; i++) {
+      const x = Math.random() * 2 - 1
+      const y = Math.random() * 2 - 1
+      const z = 0
 
-        data[i] = simplex.noise3d(x, y, z)
-      }
-
-      this.noiseTexture = new DataTexture(data, width, height, RedFormat, FloatType)
-      this.noiseTexture.wrapS = RepeatWrapping
-      this.noiseTexture.wrapT = RepeatWrapping
-      this.noiseTexture.needsUpdate = true
+      data[i] = simplex.noise3d(x, y, z)
     }
 
-    overrideVisibility() {
-      const scene = this.scene
-      const cache = this._visibilityCache
+    this.noiseTexture = new DataTexture(data, width, height, RedFormat, FloatType)
+    this.noiseTexture.wrapS = RepeatWrapping
+    this.noiseTexture.wrapT = RepeatWrapping
+    this.noiseTexture.needsUpdate = true
+  }
 
-      scene.traverse(function (object) {
-        cache.set(object, object.visible)
+  overrideVisibility() {
+    const scene = this.scene
+    const cache = this._visibilityCache
 
-        if (object.isPoints || object.isLine) object.visible = false
-      })
-    }
+    scene.traverse(function (object) {
+      cache.set(object, object.visible)
 
-    restoreVisibility() {
-      const scene = this.scene
-      const cache = this._visibilityCache
+      if (object.isPoints || object.isLine) object.visible = false
+    })
+  }
 
-      scene.traverse(function (object) {
-        const visible = cache.get(object)
-        object.visible = visible
-      })
+  restoreVisibility() {
+    const scene = this.scene
+    const cache = this._visibilityCache
 
-      cache.clear()
-    }
-  }
+    scene.traverse(function (object) {
+      const visible = cache.get(object)
+      object.visible = visible
+    })
 
-  return SSAOPass
-})()
+    cache.clear()
+  }
+}
 
 export { SSAOPass }
diff --git a/src/postprocessing/SSRPass.js b/src/postprocessing/SSRPass.js
index b4e54852..c46038c5 100644
--- a/src/postprocessing/SSRPass.js
+++ b/src/postprocessing/SSRPass.js
@@ -21,534 +21,530 @@ import { SSRBlurShader } from '../shaders/SSRShader'
 import { SSRDepthShader } from '../shaders/SSRShader'
 import { CopyShader } from '../shaders/CopyShader'
 
-const SSRPass = /* @__PURE__ */ (() => {
-  class SSRPass extends Pass {
-    static OUTPUT = {
-      Default: 0,
-      SSR: 1,
-      Beauty: 3,
-      Depth: 4,
-      Normal: 5,
-      Metalness: 7,
-    }
-    constructor({ renderer, scene, camera, width, height, selects, bouncing = false, groundReflector }) {
-      super()
-
-      this.width = width !== undefined ? width : 512
-      this.height = height !== undefined ? height : 512
-
-      this.clear = true
-
-      this.renderer = renderer
-      this.scene = scene
-      this.camera = camera
-      this.groundReflector = groundReflector
-
-      this.opacity = SSRShader.uniforms.opacity.value
-      this.output = 0
-
-      this.maxDistance = SSRShader.uniforms.maxDistance.value
-      this.thickness = SSRShader.uniforms.thickness.value
-
-      this.tempColor = new Color()
-
-      this._selects = selects
-      this.selective = Array.isArray(this._selects)
-      Object.defineProperty(this, 'selects', {
-        get() {
-          return this._selects
-        },
-        set(val) {
-          if (this._selects === val) return
-          this._selects = val
-          if (Array.isArray(val)) {
-            this.selective = true
-            this.ssrMaterial.defines.SELECTIVE = true
-            this.ssrMaterial.needsUpdate = true
-          } else {
-            this.selective = false
-            this.ssrMaterial.defines.SELECTIVE = false
-            this.ssrMaterial.needsUpdate = true
-          }
-        },
-      })
-
-      this._bouncing = bouncing
-      Object.defineProperty(this, 'bouncing', {
-        get() {
-          return this._bouncing
-        },
-        set(val) {
-          if (this._bouncing === val) return
-          this._bouncing = val
-          if (val) {
-            this.ssrMaterial.uniforms['tDiffuse'].value = this.prevRenderTarget.texture
-          } else {
-            this.ssrMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
-          }
-        },
-      })
-
-      this.blur = true
-
-      this._distanceAttenuation = SSRShader.defines.DISTANCE_ATTENUATION
-      Object.defineProperty(this, 'distanceAttenuation', {
-        get() {
-          return this._distanceAttenuation
-        },
-        set(val) {
-          if (this._distanceAttenuation === val) return
-          this._distanceAttenuation = val
-          this.ssrMaterial.defines.DISTANCE_ATTENUATION = val
-          this.ssrMaterial.needsUpdate = true
-        },
-      })
-
-      this._fresnel = SSRShader.defines.FRESNEL
-      Object.defineProperty(this, 'fresnel', {
-        get() {
-          return this._fresnel
-        },
-        set(val) {
-          if (this._fresnel === val) return
-          this._fresnel = val
-          this.ssrMaterial.defines.FRESNEL = val
+class SSRPass extends Pass {
+  static OUTPUT = {
+    Default: 0,
+    SSR: 1,
+    Beauty: 3,
+    Depth: 4,
+    Normal: 5,
+    Metalness: 7,
+  }
+  constructor({ renderer, scene, camera, width, height, selects, bouncing = false, groundReflector }) {
+    super()
+
+    this.width = width !== undefined ? width : 512
+    this.height = height !== undefined ? height : 512
+
+    this.clear = true
+
+    this.renderer = renderer
+    this.scene = scene
+    this.camera = camera
+    this.groundReflector = groundReflector
+
+    this.opacity = SSRShader.uniforms.opacity.value
+    this.output = 0
+
+    this.maxDistance = SSRShader.uniforms.maxDistance.value
+    this.thickness = SSRShader.uniforms.thickness.value
+
+    this.tempColor = new Color()
+
+    this._selects = selects
+    this.selective = Array.isArray(this._selects)
+    Object.defineProperty(this, 'selects', {
+      get() {
+        return this._selects
+      },
+      set(val) {
+        if (this._selects === val) return
+        this._selects = val
+        if (Array.isArray(val)) {
+          this.selective = true
+          this.ssrMaterial.defines.SELECTIVE = true
           this.ssrMaterial.needsUpdate = true
-        },
-      })
-
-      this._infiniteThick = SSRShader.defines.INFINITE_THICK
-      Object.defineProperty(this, 'infiniteThick', {
-        get() {
-          return this._infiniteThick
-        },
-        set(val) {
-          if (this._infiniteThick === val) return
-          this._infiniteThick = val
-          this.ssrMaterial.defines.INFINITE_THICK = val
+        } else {
+          this.selective = false
+          this.ssrMaterial.defines.SELECTIVE = false
           this.ssrMaterial.needsUpdate = true
-        },
-      })
-
-      // beauty render target with depth buffer
-
-      const depthTexture = new DepthTexture()
-      depthTexture.type = UnsignedShortType
-      depthTexture.minFilter = NearestFilter
-      depthTexture.magFilter = NearestFilter
-
-      this.beautyRenderTarget = new WebGLRenderTarget(this.width, this.height, {
-        minFilter: NearestFilter,
-        magFilter: NearestFilter,
-        type: HalfFloatType,
-        depthTexture: depthTexture,
-        depthBuffer: true,
-      })
-
-      //for bouncing
-      this.prevRenderTarget = new WebGLRenderTarget(this.width, this.height, {
-        minFilter: NearestFilter,
-        magFilter: NearestFilter,
-      })
-
-      // normal render target
-
-      this.normalRenderTarget = new WebGLRenderTarget(this.width, this.height, {
-        minFilter: NearestFilter,
-        magFilter: NearestFilter,
-        type: HalfFloatType,
-      })
-
-      // metalness render target
-
-      this.metalnessRenderTarget = new WebGLRenderTarget(this.width, this.height, {
-        minFilter: NearestFilter,
-        magFilter: NearestFilter,
-        type: HalfFloatType,
-      })
-
-      // ssr render target
-
-      this.ssrRenderTarget = new WebGLRenderTarget(this.width, this.height, {
-        minFilter: NearestFilter,
-        magFilter: NearestFilter,
-      })
-
-      this.blurRenderTarget = this.ssrRenderTarget.clone()
-      this.blurRenderTarget2 = this.ssrRenderTarget.clone()
-      // this.blurRenderTarget3 = this.ssrRenderTarget.clone();
-
-      // ssr material
-
-      this.ssrMaterial = new ShaderMaterial({
-        defines: Object.assign({}, SSRShader.defines, {
-          MAX_STEP: Math.sqrt(this.width * this.width + this.height * this.height),
-        }),
-        uniforms: UniformsUtils.clone(SSRShader.uniforms),
-        vertexShader: SSRShader.vertexShader,
-        fragmentShader: SSRShader.fragmentShader,
-        blending: NoBlending,
-      })
-
-      this.ssrMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
-      this.ssrMaterial.uniforms['tNormal'].value = this.normalRenderTarget.texture
-      this.ssrMaterial.defines.SELECTIVE = this.selective
-      this.ssrMaterial.needsUpdate = true
-      this.ssrMaterial.uniforms['tMetalness'].value = this.metalnessRenderTarget.texture
-      this.ssrMaterial.uniforms['tDepth'].value = this.beautyRenderTarget.depthTexture
-      this.ssrMaterial.uniforms['cameraNear'].value = this.camera.near
-      this.ssrMaterial.uniforms['cameraFar'].value = this.camera.far
-      this.ssrMaterial.uniforms['thickness'].value = this.thickness
-      this.ssrMaterial.uniforms['resolution'].value.set(this.width, this.height)
-      this.ssrMaterial.uniforms['cameraProjectionMatrix'].value.copy(this.camera.projectionMatrix)
-      this.ssrMaterial.uniforms['cameraInverseProjectionMatrix'].value.copy(this.camera.projectionMatrixInverse)
-
-      // normal material
-
-      this.normalMaterial = new MeshNormalMaterial()
-      this.normalMaterial.blending = NoBlending
-
-      // metalnessOn material
-
-      this.metalnessOnMaterial = new MeshBasicMaterial({
-        color: 'white',
-      })
-
-      // metalnessOff material
-
-      this.metalnessOffMaterial = new MeshBasicMaterial({
-        color: 'black',
-      })
-
-      // blur material
-
-      this.blurMaterial = new ShaderMaterial({
-        defines: Object.assign({}, SSRBlurShader.defines),
-        uniforms: UniformsUtils.clone(SSRBlurShader.uniforms),
-        vertexShader: SSRBlurShader.vertexShader,
-        fragmentShader: SSRBlurShader.fragmentShader,
-      })
-      this.blurMaterial.uniforms['tDiffuse'].value = this.ssrRenderTarget.texture
-      this.blurMaterial.uniforms['resolution'].value.set(this.width, this.height)
-
-      // blur material 2
-
-      this.blurMaterial2 = new ShaderMaterial({
-        defines: Object.assign({}, SSRBlurShader.defines),
-        uniforms: UniformsUtils.clone(SSRBlurShader.uniforms),
-        vertexShader: SSRBlurShader.vertexShader,
-        fragmentShader: SSRBlurShader.fragmentShader,
-      })
-      this.blurMaterial2.uniforms['tDiffuse'].value = this.blurRenderTarget.texture
-      this.blurMaterial2.uniforms['resolution'].value.set(this.width, this.height)
-
-      // // blur material 3
-
-      // this.blurMaterial3 = new ShaderMaterial({
-      //   defines: Object.assign({}, SSRBlurShader.defines),
-      //   uniforms: UniformsUtils.clone(SSRBlurShader.uniforms),
-      //   vertexShader: SSRBlurShader.vertexShader,
-      //   fragmentShader: SSRBlurShader.fragmentShader
-      // });
-      // this.blurMaterial3.uniforms['tDiffuse'].value = this.blurRenderTarget2.texture;
-      // this.blurMaterial3.uniforms['resolution'].value.set(this.width, this.height);
-
-      // material for rendering the depth
-
-      this.depthRenderMaterial = new ShaderMaterial({
-        defines: Object.assign({}, SSRDepthShader.defines),
-        uniforms: UniformsUtils.clone(SSRDepthShader.uniforms),
-        vertexShader: SSRDepthShader.vertexShader,
-        fragmentShader: SSRDepthShader.fragmentShader,
-        blending: NoBlending,
-      })
-      this.depthRenderMaterial.uniforms['tDepth'].value = this.beautyRenderTarget.depthTexture
-      this.depthRenderMaterial.uniforms['cameraNear'].value = this.camera.near
-      this.depthRenderMaterial.uniforms['cameraFar'].value = this.camera.far
-
-      // material for rendering the content of a render target
-
-      this.copyMaterial = new ShaderMaterial({
-        uniforms: UniformsUtils.clone(CopyShader.uniforms),
-        vertexShader: CopyShader.vertexShader,
-        fragmentShader: CopyShader.fragmentShader,
-        transparent: true,
-        depthTest: false,
-        depthWrite: false,
-        blendSrc: SrcAlphaFactor,
-        blendDst: OneMinusSrcAlphaFactor,
-        blendEquation: AddEquation,
-        blendSrcAlpha: SrcAlphaFactor,
-        blendDstAlpha: OneMinusSrcAlphaFactor,
-        blendEquationAlpha: AddEquation,
-        // premultipliedAlpha:true,
-      })
-
-      this.fsQuad = new FullScreenQuad(null)
-
-      this.originalClearColor = new Color()
-    }
+        }
+      },
+    })
+
+    this._bouncing = bouncing
+    Object.defineProperty(this, 'bouncing', {
+      get() {
+        return this._bouncing
+      },
+      set(val) {
+        if (this._bouncing === val) return
+        this._bouncing = val
+        if (val) {
+          this.ssrMaterial.uniforms['tDiffuse'].value = this.prevRenderTarget.texture
+        } else {
+          this.ssrMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
+        }
+      },
+    })
+
+    this.blur = true
+
+    this._distanceAttenuation = SSRShader.defines.DISTANCE_ATTENUATION
+    Object.defineProperty(this, 'distanceAttenuation', {
+      get() {
+        return this._distanceAttenuation
+      },
+      set(val) {
+        if (this._distanceAttenuation === val) return
+        this._distanceAttenuation = val
+        this.ssrMaterial.defines.DISTANCE_ATTENUATION = val
+        this.ssrMaterial.needsUpdate = true
+      },
+    })
+
+    this._fresnel = SSRShader.defines.FRESNEL
+    Object.defineProperty(this, 'fresnel', {
+      get() {
+        return this._fresnel
+      },
+      set(val) {
+        if (this._fresnel === val) return
+        this._fresnel = val
+        this.ssrMaterial.defines.FRESNEL = val
+        this.ssrMaterial.needsUpdate = true
+      },
+    })
+
+    this._infiniteThick = SSRShader.defines.INFINITE_THICK
+    Object.defineProperty(this, 'infiniteThick', {
+      get() {
+        return this._infiniteThick
+      },
+      set(val) {
+        if (this._infiniteThick === val) return
+        this._infiniteThick = val
+        this.ssrMaterial.defines.INFINITE_THICK = val
+        this.ssrMaterial.needsUpdate = true
+      },
+    })
+
+    // beauty render target with depth buffer
+
+    const depthTexture = new DepthTexture()
+    depthTexture.type = UnsignedShortType
+    depthTexture.minFilter = NearestFilter
+    depthTexture.magFilter = NearestFilter
+
+    this.beautyRenderTarget = new WebGLRenderTarget(this.width, this.height, {
+      minFilter: NearestFilter,
+      magFilter: NearestFilter,
+      type: HalfFloatType,
+      depthTexture: depthTexture,
+      depthBuffer: true,
+    })
+
+    //for bouncing
+    this.prevRenderTarget = new WebGLRenderTarget(this.width, this.height, {
+      minFilter: NearestFilter,
+      magFilter: NearestFilter,
+    })
+
+    // normal render target
+
+    this.normalRenderTarget = new WebGLRenderTarget(this.width, this.height, {
+      minFilter: NearestFilter,
+      magFilter: NearestFilter,
+      type: HalfFloatType,
+    })
+
+    // metalness render target
+
+    this.metalnessRenderTarget = new WebGLRenderTarget(this.width, this.height, {
+      minFilter: NearestFilter,
+      magFilter: NearestFilter,
+      type: HalfFloatType,
+    })
+
+    // ssr render target
+
+    this.ssrRenderTarget = new WebGLRenderTarget(this.width, this.height, {
+      minFilter: NearestFilter,
+      magFilter: NearestFilter,
+    })
+
+    this.blurRenderTarget = this.ssrRenderTarget.clone()
+    this.blurRenderTarget2 = this.ssrRenderTarget.clone()
+    // this.blurRenderTarget3 = this.ssrRenderTarget.clone();
+
+    // ssr material
+
+    this.ssrMaterial = new ShaderMaterial({
+      defines: Object.assign({}, SSRShader.defines, {
+        MAX_STEP: Math.sqrt(this.width * this.width + this.height * this.height),
+      }),
+      uniforms: UniformsUtils.clone(SSRShader.uniforms),
+      vertexShader: SSRShader.vertexShader,
+      fragmentShader: SSRShader.fragmentShader,
+      blending: NoBlending,
+    })
+
+    this.ssrMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
+    this.ssrMaterial.uniforms['tNormal'].value = this.normalRenderTarget.texture
+    this.ssrMaterial.defines.SELECTIVE = this.selective
+    this.ssrMaterial.needsUpdate = true
+    this.ssrMaterial.uniforms['tMetalness'].value = this.metalnessRenderTarget.texture
+    this.ssrMaterial.uniforms['tDepth'].value = this.beautyRenderTarget.depthTexture
+    this.ssrMaterial.uniforms['cameraNear'].value = this.camera.near
+    this.ssrMaterial.uniforms['cameraFar'].value = this.camera.far
+    this.ssrMaterial.uniforms['thickness'].value = this.thickness
+    this.ssrMaterial.uniforms['resolution'].value.set(this.width, this.height)
+    this.ssrMaterial.uniforms['cameraProjectionMatrix'].value.copy(this.camera.projectionMatrix)
+    this.ssrMaterial.uniforms['cameraInverseProjectionMatrix'].value.copy(this.camera.projectionMatrixInverse)
+
+    // normal material
+
+    this.normalMaterial = new MeshNormalMaterial()
+    this.normalMaterial.blending = NoBlending
+
+    // metalnessOn material
+
+    this.metalnessOnMaterial = new MeshBasicMaterial({
+      color: 'white',
+    })
+
+    // metalnessOff material
+
+    this.metalnessOffMaterial = new MeshBasicMaterial({
+      color: 'black',
+    })
+
+    // blur material
+
+    this.blurMaterial = new ShaderMaterial({
+      defines: Object.assign({}, SSRBlurShader.defines),
+      uniforms: UniformsUtils.clone(SSRBlurShader.uniforms),
+      vertexShader: SSRBlurShader.vertexShader,
+      fragmentShader: SSRBlurShader.fragmentShader,
+    })
+    this.blurMaterial.uniforms['tDiffuse'].value = this.ssrRenderTarget.texture
+    this.blurMaterial.uniforms['resolution'].value.set(this.width, this.height)
+
+    // blur material 2
+
+    this.blurMaterial2 = new ShaderMaterial({
+      defines: Object.assign({}, SSRBlurShader.defines),
+      uniforms: UniformsUtils.clone(SSRBlurShader.uniforms),
+      vertexShader: SSRBlurShader.vertexShader,
+      fragmentShader: SSRBlurShader.fragmentShader,
+    })
+    this.blurMaterial2.uniforms['tDiffuse'].value = this.blurRenderTarget.texture
+    this.blurMaterial2.uniforms['resolution'].value.set(this.width, this.height)
+
+    // // blur material 3
+
+    // this.blurMaterial3 = new ShaderMaterial({
+    //   defines: Object.assign({}, SSRBlurShader.defines),
+    //   uniforms: UniformsUtils.clone(SSRBlurShader.uniforms),
+    //   vertexShader: SSRBlurShader.vertexShader,
+    //   fragmentShader: SSRBlurShader.fragmentShader
+    // });
+    // this.blurMaterial3.uniforms['tDiffuse'].value = this.blurRenderTarget2.texture;
+    // this.blurMaterial3.uniforms['resolution'].value.set(this.width, this.height);
+
+    // material for rendering the depth
+
+    this.depthRenderMaterial = new ShaderMaterial({
+      defines: Object.assign({}, SSRDepthShader.defines),
+      uniforms: UniformsUtils.clone(SSRDepthShader.uniforms),
+      vertexShader: SSRDepthShader.vertexShader,
+      fragmentShader: SSRDepthShader.fragmentShader,
+      blending: NoBlending,
+    })
+    this.depthRenderMaterial.uniforms['tDepth'].value = this.beautyRenderTarget.depthTexture
+    this.depthRenderMaterial.uniforms['cameraNear'].value = this.camera.near
+    this.depthRenderMaterial.uniforms['cameraFar'].value = this.camera.far
+
+    // material for rendering the content of a render target
+
+    this.copyMaterial = new ShaderMaterial({
+      uniforms: UniformsUtils.clone(CopyShader.uniforms),
+      vertexShader: CopyShader.vertexShader,
+      fragmentShader: CopyShader.fragmentShader,
+      transparent: true,
+      depthTest: false,
+      depthWrite: false,
+      blendSrc: SrcAlphaFactor,
+      blendDst: OneMinusSrcAlphaFactor,
+      blendEquation: AddEquation,
+      blendSrcAlpha: SrcAlphaFactor,
+      blendDstAlpha: OneMinusSrcAlphaFactor,
+      blendEquationAlpha: AddEquation,
+      // premultipliedAlpha:true,
+    })
+
+    this.fsQuad = new FullScreenQuad(null)
+
+    this.originalClearColor = new Color()
+  }
+
+  dispose() {
+    // dispose render targets
 
-    dispose() {
-      // dispose render targets
+    this.beautyRenderTarget.dispose()
+    this.prevRenderTarget.dispose()
+    this.normalRenderTarget.dispose()
+    this.metalnessRenderTarget.dispose()
+    this.ssrRenderTarget.dispose()
+    this.blurRenderTarget.dispose()
+    this.blurRenderTarget2.dispose()
+    // this.blurRenderTarget3.dispose();
 
-      this.beautyRenderTarget.dispose()
-      this.prevRenderTarget.dispose()
-      this.normalRenderTarget.dispose()
-      this.metalnessRenderTarget.dispose()
-      this.ssrRenderTarget.dispose()
-      this.blurRenderTarget.dispose()
-      this.blurRenderTarget2.dispose()
-      // this.blurRenderTarget3.dispose();
+    // dispose materials
 
-      // dispose materials
+    this.normalMaterial.dispose()
+    this.metalnessOnMaterial.dispose()
+    this.metalnessOffMaterial.dispose()
+    this.blurMaterial.dispose()
+    this.blurMaterial2.dispose()
+    this.copyMaterial.dispose()
+    this.depthRenderMaterial.dispose()
 
-      this.normalMaterial.dispose()
-      this.metalnessOnMaterial.dispose()
-      this.metalnessOffMaterial.dispose()
-      this.blurMaterial.dispose()
-      this.blurMaterial2.dispose()
-      this.copyMaterial.dispose()
-      this.depthRenderMaterial.dispose()
+    // dipsose full screen quad
+
+    this.fsQuad.dispose()
+  }
 
-      // dipsose full screen quad
+  render(renderer, writeBuffer /*, readBuffer, deltaTime, maskActive */) {
+    // render beauty and depth
 
-      this.fsQuad.dispose()
+    renderer.setRenderTarget(this.beautyRenderTarget)
+    renderer.clear()
+    if (this.groundReflector) {
+      this.groundReflector.visible = false
+      this.groundReflector.doRender(this.renderer, this.scene, this.camera)
+      this.groundReflector.visible = true
     }
 
-    render(renderer, writeBuffer /*, readBuffer, deltaTime, maskActive */) {
-      // render beauty and depth
+    renderer.render(this.scene, this.camera)
+    if (this.groundReflector) this.groundReflector.visible = false
 
-      renderer.setRenderTarget(this.beautyRenderTarget)
-      renderer.clear()
-      if (this.groundReflector) {
-        this.groundReflector.visible = false
-        this.groundReflector.doRender(this.renderer, this.scene, this.camera)
-        this.groundReflector.visible = true
-      }
+    // render normals
 
-      renderer.render(this.scene, this.camera)
-      if (this.groundReflector) this.groundReflector.visible = false
+    this.renderOverride(renderer, this.normalMaterial, this.normalRenderTarget, 0, 0)
 
-      // render normals
+    // render metalnesses
 
-      this.renderOverride(renderer, this.normalMaterial, this.normalRenderTarget, 0, 0)
+    if (this.selective) {
+      this.renderMetalness(renderer, this.metalnessOnMaterial, this.metalnessRenderTarget, 0, 0)
+    }
 
-      // render metalnesses
+    // render SSR
 
-      if (this.selective) {
-        this.renderMetalness(renderer, this.metalnessOnMaterial, this.metalnessRenderTarget, 0, 0)
-      }
+    this.ssrMaterial.uniforms['opacity'].value = this.opacity
+    this.ssrMaterial.uniforms['maxDistance'].value = this.maxDistance
+    this.ssrMaterial.uniforms['thickness'].value = this.thickness
+    this.renderPass(renderer, this.ssrMaterial, this.ssrRenderTarget)
 
-      // render SSR
+    // render blur
 
-      this.ssrMaterial.uniforms['opacity'].value = this.opacity
-      this.ssrMaterial.uniforms['maxDistance'].value = this.maxDistance
-      this.ssrMaterial.uniforms['thickness'].value = this.thickness
-      this.renderPass(renderer, this.ssrMaterial, this.ssrRenderTarget)
+    if (this.blur) {
+      this.renderPass(renderer, this.blurMaterial, this.blurRenderTarget)
+      this.renderPass(renderer, this.blurMaterial2, this.blurRenderTarget2)
+      // this.renderPass(renderer, this.blurMaterial3, this.blurRenderTarget3);
+    }
 
-      // render blur
+    // output result to screen
 
-      if (this.blur) {
-        this.renderPass(renderer, this.blurMaterial, this.blurRenderTarget)
-        this.renderPass(renderer, this.blurMaterial2, this.blurRenderTarget2)
-        // this.renderPass(renderer, this.blurMaterial3, this.blurRenderTarget3);
-      }
+    switch (this.output) {
+      case SSRPass.OUTPUT.Default:
+        if (this.bouncing) {
+          this.copyMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
+          this.copyMaterial.blending = NoBlending
+          this.renderPass(renderer, this.copyMaterial, this.prevRenderTarget)
 
-      // output result to screen
-
-      switch (this.output) {
-        case SSRPass.OUTPUT.Default:
-          if (this.bouncing) {
-            this.copyMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
-            this.copyMaterial.blending = NoBlending
-            this.renderPass(renderer, this.copyMaterial, this.prevRenderTarget)
-
-            if (this.blur) this.copyMaterial.uniforms['tDiffuse'].value = this.blurRenderTarget2.texture
-            else this.copyMaterial.uniforms['tDiffuse'].value = this.ssrRenderTarget.texture
-            this.copyMaterial.blending = NormalBlending
-            this.renderPass(renderer, this.copyMaterial, this.prevRenderTarget)
-
-            this.copyMaterial.uniforms['tDiffuse'].value = this.prevRenderTarget.texture
-            this.copyMaterial.blending = NoBlending
-            this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
-          } else {
-            this.copyMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
-            this.copyMaterial.blending = NoBlending
-            this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
-
-            if (this.blur) this.copyMaterial.uniforms['tDiffuse'].value = this.blurRenderTarget2.texture
-            else this.copyMaterial.uniforms['tDiffuse'].value = this.ssrRenderTarget.texture
-            this.copyMaterial.blending = NormalBlending
-            this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
-          }
-
-          break
-        case SSRPass.OUTPUT.SSR:
           if (this.blur) this.copyMaterial.uniforms['tDiffuse'].value = this.blurRenderTarget2.texture
           else this.copyMaterial.uniforms['tDiffuse'].value = this.ssrRenderTarget.texture
+          this.copyMaterial.blending = NormalBlending
+          this.renderPass(renderer, this.copyMaterial, this.prevRenderTarget)
+
+          this.copyMaterial.uniforms['tDiffuse'].value = this.prevRenderTarget.texture
           this.copyMaterial.blending = NoBlending
           this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
-
-          if (this.bouncing) {
-            if (this.blur) this.copyMaterial.uniforms['tDiffuse'].value = this.blurRenderTarget2.texture
-            else this.copyMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
-            this.copyMaterial.blending = NoBlending
-            this.renderPass(renderer, this.copyMaterial, this.prevRenderTarget)
-
-            this.copyMaterial.uniforms['tDiffuse'].value = this.ssrRenderTarget.texture
-            this.copyMaterial.blending = NormalBlending
-            this.renderPass(renderer, this.copyMaterial, this.prevRenderTarget)
-          }
-
-          break
-
-        case SSRPass.OUTPUT.Beauty:
+        } else {
           this.copyMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
           this.copyMaterial.blending = NoBlending
           this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
 
-          break
-
-        case SSRPass.OUTPUT.Depth:
-          this.renderPass(renderer, this.depthRenderMaterial, this.renderToScreen ? null : writeBuffer)
+          if (this.blur) this.copyMaterial.uniforms['tDiffuse'].value = this.blurRenderTarget2.texture
+          else this.copyMaterial.uniforms['tDiffuse'].value = this.ssrRenderTarget.texture
+          this.copyMaterial.blending = NormalBlending
+          this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
+        }
 
-          break
+        break
+      case SSRPass.OUTPUT.SSR:
+        if (this.blur) this.copyMaterial.uniforms['tDiffuse'].value = this.blurRenderTarget2.texture
+        else this.copyMaterial.uniforms['tDiffuse'].value = this.ssrRenderTarget.texture
+        this.copyMaterial.blending = NoBlending
+        this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
 
-        case SSRPass.OUTPUT.Normal:
-          this.copyMaterial.uniforms['tDiffuse'].value = this.normalRenderTarget.texture
+        if (this.bouncing) {
+          if (this.blur) this.copyMaterial.uniforms['tDiffuse'].value = this.blurRenderTarget2.texture
+          else this.copyMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
           this.copyMaterial.blending = NoBlending
-          this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
+          this.renderPass(renderer, this.copyMaterial, this.prevRenderTarget)
 
-          break
+          this.copyMaterial.uniforms['tDiffuse'].value = this.ssrRenderTarget.texture
+          this.copyMaterial.blending = NormalBlending
+          this.renderPass(renderer, this.copyMaterial, this.prevRenderTarget)
+        }
 
-        case SSRPass.OUTPUT.Metalness:
-          this.copyMaterial.uniforms['tDiffuse'].value = this.metalnessRenderTarget.texture
-          this.copyMaterial.blending = NoBlending
-          this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
+        break
 
-          break
+      case SSRPass.OUTPUT.Beauty:
+        this.copyMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
+        this.copyMaterial.blending = NoBlending
+        this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
 
-        default:
-          console.warn('THREE.SSRPass: Unknown output type.')
-      }
-    }
+        break
 
-    renderPass(renderer, passMaterial, renderTarget, clearColor, clearAlpha) {
-      // save original state
-      this.originalClearColor.copy(renderer.getClearColor(this.tempColor))
-      const originalClearAlpha = renderer.getClearAlpha(this.tempColor)
-      const originalAutoClear = renderer.autoClear
+      case SSRPass.OUTPUT.Depth:
+        this.renderPass(renderer, this.depthRenderMaterial, this.renderToScreen ? null : writeBuffer)
 
-      renderer.setRenderTarget(renderTarget)
+        break
 
-      // setup pass state
-      renderer.autoClear = false
-      if (clearColor !== undefined && clearColor !== null) {
-        renderer.setClearColor(clearColor)
-        renderer.setClearAlpha(clearAlpha || 0.0)
-        renderer.clear()
-      }
+      case SSRPass.OUTPUT.Normal:
+        this.copyMaterial.uniforms['tDiffuse'].value = this.normalRenderTarget.texture
+        this.copyMaterial.blending = NoBlending
+        this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
+
+        break
 
-      this.fsQuad.material = passMaterial
-      this.fsQuad.render(renderer)
+      case SSRPass.OUTPUT.Metalness:
+        this.copyMaterial.uniforms['tDiffuse'].value = this.metalnessRenderTarget.texture
+        this.copyMaterial.blending = NoBlending
+        this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
 
-      // restore original state
-      renderer.autoClear = originalAutoClear
-      renderer.setClearColor(this.originalClearColor)
-      renderer.setClearAlpha(originalClearAlpha)
+        break
+
+      default:
+        console.warn('THREE.SSRPass: Unknown output type.')
     }
+  }
 
-    renderOverride(renderer, overrideMaterial, renderTarget, clearColor, clearAlpha) {
-      this.originalClearColor.copy(renderer.getClearColor(this.tempColor))
-      const originalClearAlpha = renderer.getClearAlpha(this.tempColor)
-      const originalAutoClear = renderer.autoClear
+  renderPass(renderer, passMaterial, renderTarget, clearColor, clearAlpha) {
+    // save original state
+    this.originalClearColor.copy(renderer.getClearColor(this.tempColor))
+    const originalClearAlpha = renderer.getClearAlpha(this.tempColor)
+    const originalAutoClear = renderer.autoClear
 
-      renderer.setRenderTarget(renderTarget)
-      renderer.autoClear = false
+    renderer.setRenderTarget(renderTarget)
 
-      clearColor = overrideMaterial.clearColor || clearColor
-      clearAlpha = overrideMaterial.clearAlpha || clearAlpha
+    // setup pass state
+    renderer.autoClear = false
+    if (clearColor !== undefined && clearColor !== null) {
+      renderer.setClearColor(clearColor)
+      renderer.setClearAlpha(clearAlpha || 0.0)
+      renderer.clear()
+    }
 
-      if (clearColor !== undefined && clearColor !== null) {
-        renderer.setClearColor(clearColor)
-        renderer.setClearAlpha(clearAlpha || 0.0)
-        renderer.clear()
-      }
+    this.fsQuad.material = passMaterial
+    this.fsQuad.render(renderer)
 
-      this.scene.overrideMaterial = overrideMaterial
-      renderer.render(this.scene, this.camera)
-      this.scene.overrideMaterial = null
+    // restore original state
+    renderer.autoClear = originalAutoClear
+    renderer.setClearColor(this.originalClearColor)
+    renderer.setClearAlpha(originalClearAlpha)
+  }
+
+  renderOverride(renderer, overrideMaterial, renderTarget, clearColor, clearAlpha) {
+    this.originalClearColor.copy(renderer.getClearColor(this.tempColor))
+    const originalClearAlpha = renderer.getClearAlpha(this.tempColor)
+    const originalAutoClear = renderer.autoClear
 
-      // restore original state
+    renderer.setRenderTarget(renderTarget)
+    renderer.autoClear = false
 
-      renderer.autoClear = originalAutoClear
-      renderer.setClearColor(this.originalClearColor)
-      renderer.setClearAlpha(originalClearAlpha)
+    clearColor = overrideMaterial.clearColor || clearColor
+    clearAlpha = overrideMaterial.clearAlpha || clearAlpha
+
+    if (clearColor !== undefined && clearColor !== null) {
+      renderer.setClearColor(clearColor)
+      renderer.setClearAlpha(clearAlpha || 0.0)
+      renderer.clear()
     }
 
-    renderMetalness(renderer, overrideMaterial, renderTarget, clearColor, clearAlpha) {
-      this.originalClearColor.copy(renderer.getClearColor(this.tempColor))
-      const originalClearAlpha = renderer.getClearAlpha(this.tempColor)
-      const originalAutoClear = renderer.autoClear
+    this.scene.overrideMaterial = overrideMaterial
+    renderer.render(this.scene, this.camera)
+    this.scene.overrideMaterial = null
 
-      renderer.setRenderTarget(renderTarget)
-      renderer.autoClear = false
+    // restore original state
 
-      clearColor = overrideMaterial.clearColor || clearColor
-      clearAlpha = overrideMaterial.clearAlpha || clearAlpha
+    renderer.autoClear = originalAutoClear
+    renderer.setClearColor(this.originalClearColor)
+    renderer.setClearAlpha(originalClearAlpha)
+  }
 
-      if (clearColor !== undefined && clearColor !== null) {
-        renderer.setClearColor(clearColor)
-        renderer.setClearAlpha(clearAlpha || 0.0)
-        renderer.clear()
-      }
+  renderMetalness(renderer, overrideMaterial, renderTarget, clearColor, clearAlpha) {
+    this.originalClearColor.copy(renderer.getClearColor(this.tempColor))
+    const originalClearAlpha = renderer.getClearAlpha(this.tempColor)
+    const originalAutoClear = renderer.autoClear
 
-      this.scene.traverseVisible((child) => {
-        child._SSRPassBackupMaterial = child.material
-        if (this._selects.includes(child)) {
-          child.material = this.metalnessOnMaterial
-        } else {
-          child.material = this.metalnessOffMaterial
-        }
-      })
-      renderer.render(this.scene, this.camera)
-      this.scene.traverseVisible((child) => {
-        child.material = child._SSRPassBackupMaterial
-      })
+    renderer.setRenderTarget(renderTarget)
+    renderer.autoClear = false
 
-      // restore original state
+    clearColor = overrideMaterial.clearColor || clearColor
+    clearAlpha = overrideMaterial.clearAlpha || clearAlpha
 
-      renderer.autoClear = originalAutoClear
-      renderer.setClearColor(this.originalClearColor)
-      renderer.setClearAlpha(originalClearAlpha)
+    if (clearColor !== undefined && clearColor !== null) {
+      renderer.setClearColor(clearColor)
+      renderer.setClearAlpha(clearAlpha || 0.0)
+      renderer.clear()
     }
 
-    setSize(width, height) {
-      this.width = width
-      this.height = height
-
-      this.ssrMaterial.defines.MAX_STEP = Math.sqrt(width * width + height * height)
-      this.ssrMaterial.needsUpdate = true
-      this.beautyRenderTarget.setSize(width, height)
-      this.prevRenderTarget.setSize(width, height)
-      this.ssrRenderTarget.setSize(width, height)
-      this.normalRenderTarget.setSize(width, height)
-      this.metalnessRenderTarget.setSize(width, height)
-      this.blurRenderTarget.setSize(width, height)
-      this.blurRenderTarget2.setSize(width, height)
-      // this.blurRenderTarget3.setSize(width, height);
-
-      this.ssrMaterial.uniforms['resolution'].value.set(width, height)
-      this.ssrMaterial.uniforms['cameraProjectionMatrix'].value.copy(this.camera.projectionMatrix)
-      this.ssrMaterial.uniforms['cameraInverseProjectionMatrix'].value.copy(this.camera.projectionMatrixInverse)
-
-      this.blurMaterial.uniforms['resolution'].value.set(width, height)
-      this.blurMaterial2.uniforms['resolution'].value.set(width, height)
-    }
+    this.scene.traverseVisible((child) => {
+      child._SSRPassBackupMaterial = child.material
+      if (this._selects.includes(child)) {
+        child.material = this.metalnessOnMaterial
+      } else {
+        child.material = this.metalnessOffMaterial
+      }
+    })
+    renderer.render(this.scene, this.camera)
+    this.scene.traverseVisible((child) => {
+      child.material = child._SSRPassBackupMaterial
+    })
+
+    // restore original state
+
+    renderer.autoClear = originalAutoClear
+    renderer.setClearColor(this.originalClearColor)
+    renderer.setClearAlpha(originalClearAlpha)
   }
 
-  return SSRPass
-})()
+  setSize(width, height) {
+    this.width = width
+    this.height = height
+
+    this.ssrMaterial.defines.MAX_STEP = Math.sqrt(width * width + height * height)
+    this.ssrMaterial.needsUpdate = true
+    this.beautyRenderTarget.setSize(width, height)
+    this.prevRenderTarget.setSize(width, height)
+    this.ssrRenderTarget.setSize(width, height)
+    this.normalRenderTarget.setSize(width, height)
+    this.metalnessRenderTarget.setSize(width, height)
+    this.blurRenderTarget.setSize(width, height)
+    this.blurRenderTarget2.setSize(width, height)
+    // this.blurRenderTarget3.setSize(width, height);
+
+    this.ssrMaterial.uniforms['resolution'].value.set(width, height)
+    this.ssrMaterial.uniforms['cameraProjectionMatrix'].value.copy(this.camera.projectionMatrix)
+    this.ssrMaterial.uniforms['cameraInverseProjectionMatrix'].value.copy(this.camera.projectionMatrixInverse)
+
+    this.blurMaterial.uniforms['resolution'].value.set(width, height)
+    this.blurMaterial2.uniforms['resolution'].value.set(width, height)
+  }
+}
 
 export { SSRPass }
diff --git a/src/postprocessing/UnrealBloomPass.js b/src/postprocessing/UnrealBloomPass.js
index e0d1123c..25e854c6 100644
--- a/src/postprocessing/UnrealBloomPass.js
+++ b/src/postprocessing/UnrealBloomPass.js
@@ -22,282 +22,281 @@ import { LuminosityHighPassShader } from '../shaders/LuminosityHighPassShader'
  * Reference:
  * - https://docs.unrealengine.com/latest/INT/Engine/Rendering/PostProcessEffects/Bloom/
  */
-const UnrealBloomPass = /* @__PURE__ */ (() => {
-  class UnrealBloomPass extends Pass {
-    static BlurDirectionX = new Vector2(1.0, 0.0)
-    static BlurDirectionY = new Vector2(0.0, 1.0)
+class UnrealBloomPass extends Pass {
+  static BlurDirectionX = new Vector2(1.0, 0.0)
+  static BlurDirectionY = new Vector2(0.0, 1.0)
 
-    constructor(resolution, strength, radius, threshold) {
-      super()
+  constructor(resolution, strength, radius, threshold) {
+    super()
 
-      this.strength = strength !== undefined ? strength : 1
-      this.radius = radius
-      this.threshold = threshold
-      this.resolution = resolution !== undefined ? new Vector2(resolution.x, resolution.y) : new Vector2(256, 256)
+    this.strength = strength !== undefined ? strength : 1
+    this.radius = radius
+    this.threshold = threshold
+    this.resolution = resolution !== undefined ? new Vector2(resolution.x, resolution.y) : new Vector2(256, 256)
 
-      // create color only once here, reuse it later inside the render function
-      this.clearColor = new Color(0, 0, 0)
-
-      // render targets
-      this.renderTargetsHorizontal = []
-      this.renderTargetsVertical = []
-      this.nMips = 5
-      let resx = Math.round(this.resolution.x / 2)
-      let resy = Math.round(this.resolution.y / 2)
+    // create color only once here, reuse it later inside the render function
+    this.clearColor = new Color(0, 0, 0)
 
-      this.renderTargetBright = new WebGLRenderTarget(resx, resy, { type: HalfFloatType })
-      this.renderTargetBright.texture.name = 'UnrealBloomPass.bright'
-      this.renderTargetBright.texture.generateMipmaps = false
+    // render targets
+    this.renderTargetsHorizontal = []
+    this.renderTargetsVertical = []
+    this.nMips = 5
+    let resx = Math.round(this.resolution.x / 2)
+    let resy = Math.round(this.resolution.y / 2)
 
-      for (let i = 0; i < this.nMips; i++) {
-        const renderTargetHorizonal = new WebGLRenderTarget(resx, resy, { type: HalfFloatType })
+    this.renderTargetBright = new WebGLRenderTarget(resx, resy, { type: HalfFloatType })
+    this.renderTargetBright.texture.name = 'UnrealBloomPass.bright'
+    this.renderTargetBright.texture.generateMipmaps = false
 
-        renderTargetHorizonal.texture.name = 'UnrealBloomPass.h' + i
-        renderTargetHorizonal.texture.generateMipmaps = false
+    for (let i = 0; i < this.nMips; i++) {
+      const renderTargetHorizonal = new WebGLRenderTarget(resx, resy, { type: HalfFloatType })
 
-        this.renderTargetsHorizontal.push(renderTargetHorizonal)
+      renderTargetHorizonal.texture.name = 'UnrealBloomPass.h' + i
+      renderTargetHorizonal.texture.generateMipmaps = false
 
-        const renderTargetVertical = new WebGLRenderTarget(resx, resy, { type: HalfFloatType })
+      this.renderTargetsHorizontal.push(renderTargetHorizonal)
 
-        renderTargetVertical.texture.name = 'UnrealBloomPass.v' + i
-        renderTargetVertical.texture.generateMipmaps = false
+      const renderTargetVertical = new WebGLRenderTarget(resx, resy, { type: HalfFloatType })
 
-        this.renderTargetsVertical.push(renderTargetVertical)
+      renderTargetVertical.texture.name = 'UnrealBloomPass.v' + i
+      renderTargetVertical.texture.generateMipmaps = false
 
-        resx = Math.round(resx / 2)
+      this.renderTargetsVertical.push(renderTargetVertical)
 
-        resy = Math.round(resy / 2)
-      }
+      resx = Math.round(resx / 2)
 
-      // luminosity high pass material
-
-      const highPassShader = LuminosityHighPassShader
-      this.highPassUniforms = UniformsUtils.clone(highPassShader.uniforms)
-
-      this.highPassUniforms['luminosityThreshold'].value = threshold
-      this.highPassUniforms['smoothWidth'].value = 0.01
-
-      this.materialHighPassFilter = new ShaderMaterial({
-        uniforms: this.highPassUniforms,
-        vertexShader: highPassShader.vertexShader,
-        fragmentShader: highPassShader.fragmentShader,
-        defines: {},
-      })
+      resy = Math.round(resy / 2)
+    }
 
-      // Gaussian Blur Materials
-      this.separableBlurMaterials = []
-      const kernelSizeArray = [3, 5, 7, 9, 11]
-      resx = Math.round(this.resolution.x / 2)
-      resy = Math.round(this.resolution.y / 2)
+    // luminosity high pass material
 
-      for (let i = 0; i < this.nMips; i++) {
-        this.separableBlurMaterials.push(this.getSeperableBlurMaterial(kernelSizeArray[i]))
+    const highPassShader = LuminosityHighPassShader
+    this.highPassUniforms = UniformsUtils.clone(highPassShader.uniforms)
 
-        this.separableBlurMaterials[i].uniforms['texSize'].value = new Vector2(resx, resy)
+    this.highPassUniforms['luminosityThreshold'].value = threshold
+    this.highPassUniforms['smoothWidth'].value = 0.01
 
-        resx = Math.round(resx / 2)
+    this.materialHighPassFilter = new ShaderMaterial({
+      uniforms: this.highPassUniforms,
+      vertexShader: highPassShader.vertexShader,
+      fragmentShader: highPassShader.fragmentShader,
+      defines: {},
+    })
 
-        resy = Math.round(resy / 2)
-      }
+    // Gaussian Blur Materials
+    this.separableBlurMaterials = []
+    const kernelSizeArray = [3, 5, 7, 9, 11]
+    resx = Math.round(this.resolution.x / 2)
+    resy = Math.round(this.resolution.y / 2)
 
-      // Composite material
-      this.compositeMaterial = this.getCompositeMaterial(this.nMips)
-      this.compositeMaterial.uniforms['blurTexture1'].value = this.renderTargetsVertical[0].texture
-      this.compositeMaterial.uniforms['blurTexture2'].value = this.renderTargetsVertical[1].texture
-      this.compositeMaterial.uniforms['blurTexture3'].value = this.renderTargetsVertical[2].texture
-      this.compositeMaterial.uniforms['blurTexture4'].value = this.renderTargetsVertical[3].texture
-      this.compositeMaterial.uniforms['blurTexture5'].value = this.renderTargetsVertical[4].texture
-      this.compositeMaterial.uniforms['bloomStrength'].value = strength
-      this.compositeMaterial.uniforms['bloomRadius'].value = 0.1
-      this.compositeMaterial.needsUpdate = true
+    for (let i = 0; i < this.nMips; i++) {
+      this.separableBlurMaterials.push(this.getSeperableBlurMaterial(kernelSizeArray[i]))
 
-      const bloomFactors = [1.0, 0.8, 0.6, 0.4, 0.2]
-      this.compositeMaterial.uniforms['bloomFactors'].value = bloomFactors
-      this.bloomTintColors = [
-        new Vector3(1, 1, 1),
-        new Vector3(1, 1, 1),
-        new Vector3(1, 1, 1),
-        new Vector3(1, 1, 1),
-        new Vector3(1, 1, 1),
-      ]
-      this.compositeMaterial.uniforms['bloomTintColors'].value = this.bloomTintColors
+      this.separableBlurMaterials[i].uniforms['texSize'].value = new Vector2(resx, resy)
 
-      // copy material
+      resx = Math.round(resx / 2)
 
-      const copyShader = CopyShader
+      resy = Math.round(resy / 2)
+    }
 
-      this.copyUniforms = UniformsUtils.clone(copyShader.uniforms)
-      this.copyUniforms['opacity'].value = 1.0
+    // Composite material
+    this.compositeMaterial = this.getCompositeMaterial(this.nMips)
+    this.compositeMaterial.uniforms['blurTexture1'].value = this.renderTargetsVertical[0].texture
+    this.compositeMaterial.uniforms['blurTexture2'].value = this.renderTargetsVertical[1].texture
+    this.compositeMaterial.uniforms['blurTexture3'].value = this.renderTargetsVertical[2].texture
+    this.compositeMaterial.uniforms['blurTexture4'].value = this.renderTargetsVertical[3].texture
+    this.compositeMaterial.uniforms['blurTexture5'].value = this.renderTargetsVertical[4].texture
+    this.compositeMaterial.uniforms['bloomStrength'].value = strength
+    this.compositeMaterial.uniforms['bloomRadius'].value = 0.1
+    this.compositeMaterial.needsUpdate = true
+
+    const bloomFactors = [1.0, 0.8, 0.6, 0.4, 0.2]
+    this.compositeMaterial.uniforms['bloomFactors'].value = bloomFactors
+    this.bloomTintColors = [
+      new Vector3(1, 1, 1),
+      new Vector3(1, 1, 1),
+      new Vector3(1, 1, 1),
+      new Vector3(1, 1, 1),
+      new Vector3(1, 1, 1),
+    ]
+    this.compositeMaterial.uniforms['bloomTintColors'].value = this.bloomTintColors
+
+    // copy material
+
+    const copyShader = CopyShader
+
+    this.copyUniforms = UniformsUtils.clone(copyShader.uniforms)
+    this.copyUniforms['opacity'].value = 1.0
+
+    this.materialCopy = new ShaderMaterial({
+      uniforms: this.copyUniforms,
+      vertexShader: copyShader.vertexShader,
+      fragmentShader: copyShader.fragmentShader,
+      blending: AdditiveBlending,
+      depthTest: false,
+      depthWrite: false,
+      transparent: true,
+    })
+
+    this.enabled = true
+    this.needsSwap = false
+
+    this._oldClearColor = new Color()
+    this.oldClearAlpha = 1
+
+    this.basic = new MeshBasicMaterial()
+
+    this.fsQuad = new FullScreenQuad(null)
+  }
 
-      this.materialCopy = new ShaderMaterial({
-        uniforms: this.copyUniforms,
-        vertexShader: copyShader.vertexShader,
-        fragmentShader: copyShader.fragmentShader,
-        blending: AdditiveBlending,
-        depthTest: false,
-        depthWrite: false,
-        transparent: true,
-      })
+  dispose() {
+    for (let i = 0; i < this.renderTargetsHorizontal.length; i++) {
+      this.renderTargetsHorizontal[i].dispose()
+    }
 
-      this.enabled = true
-      this.needsSwap = false
+    for (let i = 0; i < this.renderTargetsVertical.length; i++) {
+      this.renderTargetsVertical[i].dispose()
+    }
 
-      this._oldClearColor = new Color()
-      this.oldClearAlpha = 1
+    this.renderTargetBright.dispose()
 
-      this.basic = new MeshBasicMaterial()
+    //
 
-      this.fsQuad = new FullScreenQuad(null)
+    for (let i = 0; i < this.separableBlurMaterials.length; i++) {
+      this.separableBlurMaterials[i].dispose()
     }
 
-    dispose() {
-      for (let i = 0; i < this.renderTargetsHorizontal.length; i++) {
-        this.renderTargetsHorizontal[i].dispose()
-      }
+    this.compositeMaterial.dispose()
+    this.materialCopy.dispose()
+    this.basic.dispose()
 
-      for (let i = 0; i < this.renderTargetsVertical.length; i++) {
-        this.renderTargetsVertical[i].dispose()
-      }
+    //
 
-      this.renderTargetBright.dispose()
+    this.fsQuad.dispose()
+  }
 
-      //
+  setSize(width, height) {
+    let resx = Math.round(width / 2)
+    let resy = Math.round(height / 2)
 
-      for (let i = 0; i < this.separableBlurMaterials.length; i++) {
-        this.separableBlurMaterials[i].dispose()
-      }
+    this.renderTargetBright.setSize(resx, resy)
 
-      this.compositeMaterial.dispose()
-      this.materialCopy.dispose()
-      this.basic.dispose()
+    for (let i = 0; i < this.nMips; i++) {
+      this.renderTargetsHorizontal[i].setSize(resx, resy)
+      this.renderTargetsVertical[i].setSize(resx, resy)
 
-      //
+      this.separableBlurMaterials[i].uniforms['texSize'].value = new Vector2(resx, resy)
 
-      this.fsQuad.dispose()
+      resx = Math.round(resx / 2)
+      resy = Math.round(resy / 2)
     }
+  }
 
-    setSize(width, height) {
-      let resx = Math.round(width / 2)
-      let resy = Math.round(height / 2)
-
-      this.renderTargetBright.setSize(resx, resy)
+  render(renderer, writeBuffer, readBuffer, deltaTime, maskActive) {
+    renderer.getClearColor(this._oldClearColor)
+    this.oldClearAlpha = renderer.getClearAlpha()
+    const oldAutoClear = renderer.autoClear
+    renderer.autoClear = false
 
-      for (let i = 0; i < this.nMips; i++) {
-        this.renderTargetsHorizontal[i].setSize(resx, resy)
-        this.renderTargetsVertical[i].setSize(resx, resy)
+    renderer.setClearColor(this.clearColor, 0)
 
-        this.separableBlurMaterials[i].uniforms['texSize'].value = new Vector2(resx, resy)
+    if (maskActive) renderer.state.buffers.stencil.setTest(false)
 
-        resx = Math.round(resx / 2)
-        resy = Math.round(resy / 2)
-      }
-    }
+    // Render input to screen
 
-    render(renderer, writeBuffer, readBuffer, deltaTime, maskActive) {
-      renderer.getClearColor(this._oldClearColor)
-      this.oldClearAlpha = renderer.getClearAlpha()
-      const oldAutoClear = renderer.autoClear
-      renderer.autoClear = false
+    if (this.renderToScreen) {
+      this.fsQuad.material = this.basic
+      this.basic.map = readBuffer.texture
 
-      renderer.setClearColor(this.clearColor, 0)
+      renderer.setRenderTarget(null)
+      renderer.clear()
+      this.fsQuad.render(renderer)
+    }
 
-      if (maskActive) renderer.state.buffers.stencil.setTest(false)
+    // 1. Extract Bright Areas
 
-      // Render input to screen
+    this.highPassUniforms['tDiffuse'].value = readBuffer.texture
+    this.highPassUniforms['luminosityThreshold'].value = this.threshold
+    this.fsQuad.material = this.materialHighPassFilter
 
-      if (this.renderToScreen) {
-        this.fsQuad.material = this.basic
-        this.basic.map = readBuffer.texture
+    renderer.setRenderTarget(this.renderTargetBright)
+    renderer.clear()
+    this.fsQuad.render(renderer)
 
-        renderer.setRenderTarget(null)
-        renderer.clear()
-        this.fsQuad.render(renderer)
-      }
+    // 2. Blur All the mips progressively
 
-      // 1. Extract Bright Areas
+    let inputRenderTarget = this.renderTargetBright
 
-      this.highPassUniforms['tDiffuse'].value = readBuffer.texture
-      this.highPassUniforms['luminosityThreshold'].value = this.threshold
-      this.fsQuad.material = this.materialHighPassFilter
+    for (let i = 0; i < this.nMips; i++) {
+      this.fsQuad.material = this.separableBlurMaterials[i]
 
-      renderer.setRenderTarget(this.renderTargetBright)
+      this.separableBlurMaterials[i].uniforms['colorTexture'].value = inputRenderTarget.texture
+      this.separableBlurMaterials[i].uniforms['direction'].value = UnrealBloomPass.BlurDirectionX
+      renderer.setRenderTarget(this.renderTargetsHorizontal[i])
       renderer.clear()
       this.fsQuad.render(renderer)
 
-      // 2. Blur All the mips progressively
+      this.separableBlurMaterials[i].uniforms['colorTexture'].value = this.renderTargetsHorizontal[i].texture
+      this.separableBlurMaterials[i].uniforms['direction'].value = UnrealBloomPass.BlurDirectionY
+      renderer.setRenderTarget(this.renderTargetsVertical[i])
+      renderer.clear()
+      this.fsQuad.render(renderer)
 
-      let inputRenderTarget = this.renderTargetBright
+      inputRenderTarget = this.renderTargetsVertical[i]
+    }
 
-      for (let i = 0; i < this.nMips; i++) {
-        this.fsQuad.material = this.separableBlurMaterials[i]
+    // Composite All the mips
 
-        this.separableBlurMaterials[i].uniforms['colorTexture'].value = inputRenderTarget.texture
-        this.separableBlurMaterials[i].uniforms['direction'].value = UnrealBloomPass.BlurDirectionX
-        renderer.setRenderTarget(this.renderTargetsHorizontal[i])
-        renderer.clear()
-        this.fsQuad.render(renderer)
+    this.fsQuad.material = this.compositeMaterial
+    this.compositeMaterial.uniforms['bloomStrength'].value = this.strength
+    this.compositeMaterial.uniforms['bloomRadius'].value = this.radius
+    this.compositeMaterial.uniforms['bloomTintColors'].value = this.bloomTintColors
 
-        this.separableBlurMaterials[i].uniforms['colorTexture'].value = this.renderTargetsHorizontal[i].texture
-        this.separableBlurMaterials[i].uniforms['direction'].value = UnrealBloomPass.BlurDirectionY
-        renderer.setRenderTarget(this.renderTargetsVertical[i])
-        renderer.clear()
-        this.fsQuad.render(renderer)
+    renderer.setRenderTarget(this.renderTargetsHorizontal[0])
+    renderer.clear()
+    this.fsQuad.render(renderer)
 
-        inputRenderTarget = this.renderTargetsVertical[i]
-      }
+    // Blend it additively over the input texture
 
-      // Composite All the mips
+    this.fsQuad.material = this.materialCopy
+    this.copyUniforms['tDiffuse'].value = this.renderTargetsHorizontal[0].texture
 
-      this.fsQuad.material = this.compositeMaterial
-      this.compositeMaterial.uniforms['bloomStrength'].value = this.strength
-      this.compositeMaterial.uniforms['bloomRadius'].value = this.radius
-      this.compositeMaterial.uniforms['bloomTintColors'].value = this.bloomTintColors
+    if (maskActive) renderer.state.buffers.stencil.setTest(true)
 
-      renderer.setRenderTarget(this.renderTargetsHorizontal[0])
-      renderer.clear()
+    if (this.renderToScreen) {
+      renderer.setRenderTarget(null)
       this.fsQuad.render(renderer)
+    } else {
+      renderer.setRenderTarget(readBuffer)
+      this.fsQuad.render(renderer)
+    }
 
-      // Blend it additively over the input texture
-
-      this.fsQuad.material = this.materialCopy
-      this.copyUniforms['tDiffuse'].value = this.renderTargetsHorizontal[0].texture
-
-      if (maskActive) renderer.state.buffers.stencil.setTest(true)
-
-      if (this.renderToScreen) {
-        renderer.setRenderTarget(null)
-        this.fsQuad.render(renderer)
-      } else {
-        renderer.setRenderTarget(readBuffer)
-        this.fsQuad.render(renderer)
-      }
-
-      // Restore renderer settings
+    // Restore renderer settings
 
-      renderer.setClearColor(this._oldClearColor, this.oldClearAlpha)
-      renderer.autoClear = oldAutoClear
-    }
+    renderer.setClearColor(this._oldClearColor, this.oldClearAlpha)
+    renderer.autoClear = oldAutoClear
+  }
 
-    getSeperableBlurMaterial(kernelRadius) {
-      return new ShaderMaterial({
-        defines: {
-          KERNEL_RADIUS: kernelRadius,
-          SIGMA: kernelRadius,
-        },
+  getSeperableBlurMaterial(kernelRadius) {
+    return new ShaderMaterial({
+      defines: {
+        KERNEL_RADIUS: kernelRadius,
+        SIGMA: kernelRadius,
+      },
 
-        uniforms: {
-          colorTexture: { value: null },
-          texSize: { value: new Vector2(0.5, 0.5) },
-          direction: { value: new Vector2(0.5, 0.5) },
-        },
+      uniforms: {
+        colorTexture: { value: null },
+        texSize: { value: new Vector2(0.5, 0.5) },
+        direction: { value: new Vector2(0.5, 0.5) },
+      },
 
-        vertexShader: `varying vec2 vUv;
+      vertexShader: `varying vec2 vUv;
 				void main() {
 					vUv = uv;
 					gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 				}`,
 
-        fragmentShader: `#include <common>
+      fragmentShader: `#include <common>
 				varying vec2 vUv;
 				uniform sampler2D colorTexture;
 				uniform vec2 texSize;
@@ -322,34 +321,34 @@ const UnrealBloomPass = /* @__PURE__ */ (() => {
 					}
 					gl_FragColor = vec4(diffuseSum/weightSum, 1.0);
 				}`,
-      })
-    }
+    })
+  }
 
-    getCompositeMaterial(nMips) {
-      return new ShaderMaterial({
-        defines: {
-          NUM_MIPS: nMips,
-        },
-
-        uniforms: {
-          blurTexture1: { value: null },
-          blurTexture2: { value: null },
-          blurTexture3: { value: null },
-          blurTexture4: { value: null },
-          blurTexture5: { value: null },
-          bloomStrength: { value: 1.0 },
-          bloomFactors: { value: null },
-          bloomTintColors: { value: null },
-          bloomRadius: { value: 0.0 },
-        },
-
-        vertexShader: `varying vec2 vUv;
+  getCompositeMaterial(nMips) {
+    return new ShaderMaterial({
+      defines: {
+        NUM_MIPS: nMips,
+      },
+
+      uniforms: {
+        blurTexture1: { value: null },
+        blurTexture2: { value: null },
+        blurTexture3: { value: null },
+        blurTexture4: { value: null },
+        blurTexture5: { value: null },
+        bloomStrength: { value: 1.0 },
+        bloomFactors: { value: null },
+        bloomTintColors: { value: null },
+        bloomRadius: { value: 0.0 },
+      },
+
+      vertexShader: `varying vec2 vUv;
 				void main() {
 					vUv = uv;
 					gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 				}`,
 
-        fragmentShader: `varying vec2 vUv;
+      fragmentShader: `varying vec2 vUv;
 				uniform sampler2D blurTexture1;
 				uniform sampler2D blurTexture2;
 				uniform sampler2D blurTexture3;
@@ -372,11 +371,8 @@ const UnrealBloomPass = /* @__PURE__ */ (() => {
 						lerpBloomFactor(bloomFactors[3]) * vec4(bloomTintColors[3], 1.0) * texture2D(blurTexture4, vUv) +
 						lerpBloomFactor(bloomFactors[4]) * vec4(bloomTintColors[4], 1.0) * texture2D(blurTexture5, vUv) );
 				}`,
-      })
-    }
+    })
   }
-
-  return UnrealBloomPass
-})()
+}
 
 export { UnrealBloomPass }
diff --git a/src/renderers/CSS2DRenderer.js b/src/renderers/CSS2DRenderer.js
index f0aa059e..7caf2532 100644
--- a/src/renderers/CSS2DRenderer.js
+++ b/src/renderers/CSS2DRenderer.js
@@ -35,11 +35,11 @@ class CSS2DObject extends Object3D {
   }
 }
 
-const _vector = /* @__PURE__ */ new Vector3()
-const _viewMatrix = /* @__PURE__ */ new Matrix4()
-const _viewProjectionMatrix = /* @__PURE__ */ new Matrix4()
-const _a = /* @__PURE__ */ new Vector3()
-const _b = /* @__PURE__ */ new Vector3()
+const _vector = new Vector3()
+const _viewMatrix = new Matrix4()
+const _viewProjectionMatrix = new Matrix4()
+const _a = new Vector3()
+const _b = new Vector3()
 
 class CSS2DRenderer {
   constructor(parameters = {}) {
diff --git a/src/renderers/CSS3DRenderer.js b/src/renderers/CSS3DRenderer.js
index 292a0ba5..cdeb32e8 100644
--- a/src/renderers/CSS3DRenderer.js
+++ b/src/renderers/CSS3DRenderer.js
@@ -4,9 +4,9 @@ import { Matrix4, Object3D, Quaternion, Vector3 } from 'three'
  * Based on http://www.emagix.net/academic/mscs-project/item/camera-sync-with-css3-and-webgl-threejs
  */
 
-const _position = /* @__PURE__ */ new Vector3()
-const _quaternion = /* @__PURE__ */ new Quaternion()
-const _scale = /* @__PURE__ */ new Vector3()
+const _position = new Vector3()
+const _quaternion = new Quaternion()
+const _scale = new Vector3()
 
 class CSS3DObject extends Object3D {
   constructor(element = document.createElement('div')) {
@@ -59,8 +59,8 @@ class CSS3DSprite extends CSS3DObject {
 
 //
 
-const _matrix = /* @__PURE__ */ new Matrix4()
-const _matrix2 = /* @__PURE__ */ new Matrix4()
+const _matrix = new Matrix4()
+const _matrix2 = new Matrix4()
 
 class CSS3DRenderer {
   constructor(parameters = {}) {
diff --git a/src/shaders/ACESFilmicToneMappingShader.ts b/src/shaders/ACESFilmicToneMappingShader.ts
index db221340..e80700dc 100644
--- a/src/shaders/ACESFilmicToneMappingShader.ts
+++ b/src/shaders/ACESFilmicToneMappingShader.ts
@@ -22,69 +22,70 @@ export const ACESFilmicToneMappingShader: IACESFilmicToneMappingShader = {
     exposure: { value: 1.0 },
   },
 
-  vertexShader: /* glsl */ `
-    varying vec2 vUv;,
+  vertexShader: [
+    'varying vec2 vUv;',
 
-    void main() {,
+    'void main() {',
 
-    	vUv = uv;,
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );,
+    '	vUv = uv;',
+    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
 
-    },
-  `,
-  fragmentShader: /* glsl */ `
-    #define saturate(a) clamp( a, 0.0, 1.0 ),
+    '}',
+  ].join('\n'),
 
-    uniform sampler2D tDiffuse;,
+  fragmentShader: [
+    '#define saturate(a) clamp( a, 0.0, 1.0 )',
 
-    uniform float exposure;,
+    'uniform sampler2D tDiffuse;',
 
-    varying vec2 vUv;,
+    'uniform float exposure;',
 
-    vec3 RRTAndODTFit( vec3 v ) {,
+    'varying vec2 vUv;',
 
-    	vec3 a = v * ( v + 0.0245786 ) - 0.000090537;,
-    	vec3 b = v * ( 0.983729 * v + 0.4329510 ) + 0.238081;,
-    	return a / b;,
+    'vec3 RRTAndODTFit( vec3 v ) {',
 
-    },
+    '	vec3 a = v * ( v + 0.0245786 ) - 0.000090537;',
+    '	vec3 b = v * ( 0.983729 * v + 0.4329510 ) + 0.238081;',
+    '	return a / b;',
 
-    vec3 ACESFilmicToneMapping( vec3 color ) {,
+    '}',
 
-      // sRGB => XYZ => D65_2_D60 => AP1 => RRT_SAT
-    	const mat3 ACESInputMat = mat3(,
-    		vec3( 0.59719, 0.07600, 0.02840 ),, // transposed from source
-    		vec3( 0.35458, 0.90834, 0.13383 ),,
-    		vec3( 0.04823, 0.01566, 0.83777 ),
-    	);,
+    'vec3 ACESFilmicToneMapping( vec3 color ) {',
 
-      // ODT_SAT => XYZ => D60_2_D65 => sRGB
-    	const mat3 ACESOutputMat = mat3(,
-    		vec3(  1.60475, -0.10208, -0.00327 ),, // transposed from source
-    		vec3( -0.53108,  1.10813, -0.07276 ),,
-    		vec3( -0.07367, -0.00605,  1.07602 ),
-    	);,
+    // sRGB => XYZ => D65_2_D60 => AP1 => RRT_SAT
+    '	const mat3 ACESInputMat = mat3(',
+    '		vec3( 0.59719, 0.07600, 0.02840 ),', // transposed from source
+    '		vec3( 0.35458, 0.90834, 0.13383 ),',
+    '		vec3( 0.04823, 0.01566, 0.83777 )',
+    '	);',
 
-    	color = ACESInputMat * color;,
+    // ODT_SAT => XYZ => D60_2_D65 => sRGB
+    '	const mat3 ACESOutputMat = mat3(',
+    '		vec3(  1.60475, -0.10208, -0.00327 ),', // transposed from source
+    '		vec3( -0.53108,  1.10813, -0.07276 ),',
+    '		vec3( -0.07367, -0.00605,  1.07602 )',
+    '	);',
 
-      // Apply RRT and ODT
-    	color = RRTAndODTFit( color );,
+    '	color = ACESInputMat * color;',
 
-    	color = ACESOutputMat * color;,
+    // Apply RRT and ODT
+    '	color = RRTAndODTFit( color );',
 
-      // Clamp to [0, 1]
-    	return saturate( color );,
+    '	color = ACESOutputMat * color;',
 
-    },
+    // Clamp to [0, 1]
+    '	return saturate( color );',
 
-    void main() {,
+    '}',
 
-    	vec4 tex = texture2D( tDiffuse, vUv );,
+    'void main() {',
 
-    	tex.rgb *= exposure / 0.6;, // pre-exposed, outside of the tone mapping function
+    '	vec4 tex = texture2D( tDiffuse, vUv );',
 
-    	gl_FragColor = vec4( ACESFilmicToneMapping( tex.rgb ), tex.a );,
+    '	tex.rgb *= exposure / 0.6;', // pre-exposed, outside of the tone mapping function
 
-    },
-  `,
+    '	gl_FragColor = vec4( ACESFilmicToneMapping( tex.rgb ), tex.a );',
+
+    '}',
+  ].join('\n'),
 }
diff --git a/src/shaders/AfterimageShader.ts b/src/shaders/AfterimageShader.ts
index 990c93b8..a5214494 100644
--- a/src/shaders/AfterimageShader.ts
+++ b/src/shaders/AfterimageShader.ts
@@ -22,40 +22,40 @@ export const AfterimageShader: IAfterimageShader = {
     tNew: { value: null },
   },
 
-  vertexShader: /* glsl */ `
-    varying vec2 vUv;
+  vertexShader: [
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vUv = uv;
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    '	vUv = uv;',
+    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    uniform float damp;
+  fragmentShader: [
+    'uniform float damp;',
 
-    uniform sampler2D tOld;
-    uniform sampler2D tNew;
+    'uniform sampler2D tOld;',
+    'uniform sampler2D tNew;',
 
-    varying vec2 vUv;
+    'varying vec2 vUv;',
 
-    vec4 when_gt( vec4 x, float y ) {
+    'vec4 when_gt( vec4 x, float y ) {',
 
-    	return max( sign( x - y ), 0.0 );
+    '	return max( sign( x - y ), 0.0 );',
 
-    }
+    '}',
 
-    void main() {
+    'void main() {',
 
-    	vec4 texelOld = texture2D( tOld, vUv );
-    	vec4 texelNew = texture2D( tNew, vUv );
+    '	vec4 texelOld = texture2D( tOld, vUv );',
+    '	vec4 texelNew = texture2D( tNew, vUv );',
 
-    	texelOld *= damp * when_gt( texelOld, 0.1 );
+    '	texelOld *= damp * when_gt( texelOld, 0.1 );',
 
-    	gl_FragColor = max(texelNew, texelOld);
+    '	gl_FragColor = max(texelNew, texelOld);',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 }
diff --git a/src/shaders/BasicShader.ts b/src/shaders/BasicShader.ts
index 36d0369b..9226a3e0 100644
--- a/src/shaders/BasicShader.ts
+++ b/src/shaders/BasicShader.ts
@@ -11,19 +11,13 @@ export interface IBasicShader extends IShader<BasicShaderUniforms> {}
 export const BasicShader: IBasicShader = {
   uniforms: {},
 
-  vertexShader: /* glsl */ `
-    void main() {
+  vertexShader: [
+    'void main() {',
 
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    void main() {
-
-      gl_FragColor = vec4( 1.0, 0.0, 0.0, 0.5 );
-
-    }
-  `,
+  fragmentShader: ['void main() {', '	gl_FragColor = vec4( 1.0, 0.0, 0.0, 0.5 );', '}'].join('\n'),
 }
diff --git a/src/shaders/BleachBypassShader.ts b/src/shaders/BleachBypassShader.ts
index bed9ada9..03d967d2 100644
--- a/src/shaders/BleachBypassShader.ts
+++ b/src/shaders/BleachBypassShader.ts
@@ -20,45 +20,45 @@ export const BleachBypassShader: IBleachBypassShader = {
     opacity: { value: 1.0 },
   },
 
-  vertexShader: /* glsl */ `
-    varying vec2 vUv;
+  vertexShader: [
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vUv = uv;
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    '	vUv = uv;',
+    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    uniform float opacity;
+  fragmentShader: [
+    'uniform float opacity;',
 
-    uniform sampler2D tDiffuse;
+    'uniform sampler2D tDiffuse;',
 
-    varying vec2 vUv;
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vec4 base = texture2D( tDiffuse, vUv );
+    '	vec4 base = texture2D( tDiffuse, vUv );',
 
-    	vec3 lumCoeff = vec3( 0.25, 0.65, 0.1 );
-    	float lum = dot( lumCoeff, base.rgb );
-    	vec3 blend = vec3( lum );
+    '	vec3 lumCoeff = vec3( 0.25, 0.65, 0.1 );',
+    '	float lum = dot( lumCoeff, base.rgb );',
+    '	vec3 blend = vec3( lum );',
 
-    	float L = min( 1.0, max( 0.0, 10.0 * ( lum - 0.45 ) ) );
+    '	float L = min( 1.0, max( 0.0, 10.0 * ( lum - 0.45 ) ) );',
 
-    	vec3 result1 = 2.0 * base.rgb * blend;
-    	vec3 result2 = 1.0 - 2.0 * ( 1.0 - blend ) * ( 1.0 - base.rgb );
+    '	vec3 result1 = 2.0 * base.rgb * blend;',
+    '	vec3 result2 = 1.0 - 2.0 * ( 1.0 - blend ) * ( 1.0 - base.rgb );',
 
-    	vec3 newColor = mix( result1, result2, L );
+    '	vec3 newColor = mix( result1, result2, L );',
 
-    	float A2 = opacity * base.a;
-    	vec3 mixRGB = A2 * newColor.rgb;
-    	mixRGB += ( ( 1.0 - A2 ) * base.rgb );
+    '	float A2 = opacity * base.a;',
+    '	vec3 mixRGB = A2 * newColor.rgb;',
+    '	mixRGB += ( ( 1.0 - A2 ) * base.rgb );',
 
-    	gl_FragColor = vec4( mixRGB, base.a );
+    '	gl_FragColor = vec4( mixRGB, base.a );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 }
diff --git a/src/shaders/BlendShader.ts b/src/shaders/BlendShader.ts
index 086160ef..d626c3a9 100644
--- a/src/shaders/BlendShader.ts
+++ b/src/shaders/BlendShader.ts
@@ -10,32 +10,32 @@ export const BlendShader = {
     opacity: { value: 1.0 },
   },
 
-  vertexShader: /* glsl */ `
-    varying vec2 vUv;
+  vertexShader: [
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vUv = uv;
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    '	vUv = uv;',
+    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    uniform float opacity;
-    uniform float mixRatio;
+  fragmentShader: [
+    'uniform float opacity;',
+    'uniform float mixRatio;',
 
-    uniform sampler2D tDiffuse1;
-    uniform sampler2D tDiffuse2;
+    'uniform sampler2D tDiffuse1;',
+    'uniform sampler2D tDiffuse2;',
 
-    varying vec2 vUv;
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vec4 texel1 = texture2D( tDiffuse1, vUv );
-    	vec4 texel2 = texture2D( tDiffuse2, vUv );
-    	gl_FragColor = opacity * mix( texel1, texel2, mixRatio );
+    '	vec4 texel1 = texture2D( tDiffuse1, vUv );',
+    '	vec4 texel2 = texture2D( tDiffuse2, vUv );',
+    '	gl_FragColor = opacity * mix( texel1, texel2, mixRatio );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 }
diff --git a/src/shaders/BokehShader.ts b/src/shaders/BokehShader.ts
index f248cf4b..6c80cf5f 100644
--- a/src/shaders/BokehShader.ts
+++ b/src/shaders/BokehShader.ts
@@ -42,116 +42,116 @@ export const BokehShader: IBokehShader = {
     farClip: { value: 1000.0 },
   },
 
-  vertexShader: /* glsl */ `
-    varying vec2 vUv;
-
-    void main() {
-
-    	vUv = uv;
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
-
-    }
-  `,
-
-  fragmentShader: /* glsl */ `
-    #include <common>
-
-    varying vec2 vUv;
-
-    uniform sampler2D tColor;
-    uniform sampler2D tDepth;
-
-    uniform float maxblur; // max blur amount
-    uniform float aperture; // aperture - bigger values for shallower depth of field
-
-    uniform float nearClip;
-    uniform float farClip;
-
-    uniform float focus;
-    uniform float aspect;
-
-    #include <packing>
-
-    float getDepth( const in vec2 screenPosition ) {
-    	#if DEPTH_PACKING == 1
-    	return unpackRGBAToDepth( texture2D( tDepth, screenPosition ) );
-    	#else
-    	return texture2D( tDepth, screenPosition ).x;
-    	#endif
-    }
-
-    float getViewZ( const in float depth ) {
-    	#if PERSPECTIVE_CAMERA == 1
-    	return perspectiveDepthToViewZ( depth, nearClip, farClip );
-    	#else
-    	return orthographicDepthToViewZ( depth, nearClip, farClip );
-    	#endif
-    }
-
-    void main() {
-
-    	vec2 aspectcorrect = vec2( 1.0, aspect );
-
-    	float viewZ = getViewZ( getDepth( vUv ) );
-
-    	float factor = ( focus + viewZ ); // viewZ is <= 0, so this is a difference equation
-
-    	vec2 dofblur = vec2 ( clamp( factor * aperture, -maxblur, maxblur ) );
-
-    	vec2 dofblur9 = dofblur * 0.9;
-    	vec2 dofblur7 = dofblur * 0.7;
-    	vec2 dofblur4 = dofblur * 0.4;
-
-    	vec4 col = vec4( 0.0 );
-
-    	col += texture2D( tColor, vUv.xy );
-    	col += texture2D( tColor, vUv.xy + ( vec2(  0.0,   0.4  ) * aspectcorrect ) * dofblur );
-    	col += texture2D( tColor, vUv.xy + ( vec2(  0.15,  0.37 ) * aspectcorrect ) * dofblur );
-    	col += texture2D( tColor, vUv.xy + ( vec2(  0.29,  0.29 ) * aspectcorrect ) * dofblur );
-    	col += texture2D( tColor, vUv.xy + ( vec2( -0.37,  0.15 ) * aspectcorrect ) * dofblur );
-    	col += texture2D( tColor, vUv.xy + ( vec2(  0.40,  0.0  ) * aspectcorrect ) * dofblur );
-    	col += texture2D( tColor, vUv.xy + ( vec2(  0.37, -0.15 ) * aspectcorrect ) * dofblur );
-    	col += texture2D( tColor, vUv.xy + ( vec2(  0.29, -0.29 ) * aspectcorrect ) * dofblur );
-    	col += texture2D( tColor, vUv.xy + ( vec2( -0.15, -0.37 ) * aspectcorrect ) * dofblur );
-    	col += texture2D( tColor, vUv.xy + ( vec2(  0.0,  -0.4  ) * aspectcorrect ) * dofblur );
-    	col += texture2D( tColor, vUv.xy + ( vec2( -0.15,  0.37 ) * aspectcorrect ) * dofblur );
-    	col += texture2D( tColor, vUv.xy + ( vec2( -0.29,  0.29 ) * aspectcorrect ) * dofblur );
-    	col += texture2D( tColor, vUv.xy + ( vec2(  0.37,  0.15 ) * aspectcorrect ) * dofblur );
-    	col += texture2D( tColor, vUv.xy + ( vec2( -0.4,   0.0  ) * aspectcorrect ) * dofblur );
-    	col += texture2D( tColor, vUv.xy + ( vec2( -0.37, -0.15 ) * aspectcorrect ) * dofblur );
-    	col += texture2D( tColor, vUv.xy + ( vec2( -0.29, -0.29 ) * aspectcorrect ) * dofblur );
-    	col += texture2D( tColor, vUv.xy + ( vec2(  0.15, -0.37 ) * aspectcorrect ) * dofblur );
-
-    	col += texture2D( tColor, vUv.xy + ( vec2(  0.15,  0.37 ) * aspectcorrect ) * dofblur9 );
-    	col += texture2D( tColor, vUv.xy + ( vec2( -0.37,  0.15 ) * aspectcorrect ) * dofblur9 );
-    	col += texture2D( tColor, vUv.xy + ( vec2(  0.37, -0.15 ) * aspectcorrect ) * dofblur9 );
-    	col += texture2D( tColor, vUv.xy + ( vec2( -0.15, -0.37 ) * aspectcorrect ) * dofblur9 );
-    	col += texture2D( tColor, vUv.xy + ( vec2( -0.15,  0.37 ) * aspectcorrect ) * dofblur9 );
-    	col += texture2D( tColor, vUv.xy + ( vec2(  0.37,  0.15 ) * aspectcorrect ) * dofblur9 );
-    	col += texture2D( tColor, vUv.xy + ( vec2( -0.37, -0.15 ) * aspectcorrect ) * dofblur9 );
-    	col += texture2D( tColor, vUv.xy + ( vec2(  0.15, -0.37 ) * aspectcorrect ) * dofblur9 );
-
-    	col += texture2D( tColor, vUv.xy + ( vec2(  0.29,  0.29 ) * aspectcorrect ) * dofblur7 );
-    	col += texture2D( tColor, vUv.xy + ( vec2(  0.40,  0.0  ) * aspectcorrect ) * dofblur7 );
-    	col += texture2D( tColor, vUv.xy + ( vec2(  0.29, -0.29 ) * aspectcorrect ) * dofblur7 );
-    	col += texture2D( tColor, vUv.xy + ( vec2(  0.0,  -0.4  ) * aspectcorrect ) * dofblur7 );
-    	col += texture2D( tColor, vUv.xy + ( vec2( -0.29,  0.29 ) * aspectcorrect ) * dofblur7 );
-    	col += texture2D( tColor, vUv.xy + ( vec2( -0.4,   0.0  ) * aspectcorrect ) * dofblur7 );
-    	col += texture2D( tColor, vUv.xy + ( vec2( -0.29, -0.29 ) * aspectcorrect ) * dofblur7 );
-    	col += texture2D( tColor, vUv.xy + ( vec2(  0.0,   0.4  ) * aspectcorrect ) * dofblur7 );
-
-    	col += texture2D( tColor, vUv.xy + ( vec2(  0.29,  0.29 ) * aspectcorrect ) * dofblur4 );
-    	col += texture2D( tColor, vUv.xy + ( vec2(  0.4,   0.0  ) * aspectcorrect ) * dofblur4 );
-    	col += texture2D( tColor, vUv.xy + ( vec2(  0.29, -0.29 ) * aspectcorrect ) * dofblur4 );
-    	col += texture2D( tColor, vUv.xy + ( vec2(  0.0,  -0.4  ) * aspectcorrect ) * dofblur4 );
-    	col += texture2D( tColor, vUv.xy + ( vec2( -0.29,  0.29 ) * aspectcorrect ) * dofblur4 );
-    	col += texture2D( tColor, vUv.xy + ( vec2( -0.4,   0.0  ) * aspectcorrect ) * dofblur4 );
-    	col += texture2D( tColor, vUv.xy + ( vec2( -0.29, -0.29 ) * aspectcorrect ) * dofblur4 );
-    	col += texture2D( tColor, vUv.xy + ( vec2(  0.0,   0.4  ) * aspectcorrect ) * dofblur4 );
-
-    	gl_FragColor = col / 41.0;
-    	gl_FragColor.a = 1.0;
-
-    }
-  `,
+  vertexShader: [
+    'varying vec2 vUv;',
+
+    'void main() {',
+
+    '	vUv = uv;',
+    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+
+    '}',
+  ].join('\n'),
+
+  fragmentShader: [
+    '#include <common>',
+
+    'varying vec2 vUv;',
+
+    'uniform sampler2D tColor;',
+    'uniform sampler2D tDepth;',
+
+    'uniform float maxblur;', // max blur amount
+    'uniform float aperture;', // aperture - bigger values for shallower depth of field
+
+    'uniform float nearClip;',
+    'uniform float farClip;',
+
+    'uniform float focus;',
+    'uniform float aspect;',
+
+    '#include <packing>',
+
+    'float getDepth( const in vec2 screenPosition ) {',
+    '	#if DEPTH_PACKING == 1',
+    '	return unpackRGBAToDepth( texture2D( tDepth, screenPosition ) );',
+    '	#else',
+    '	return texture2D( tDepth, screenPosition ).x;',
+    '	#endif',
+    '}',
+
+    'float getViewZ( const in float depth ) {',
+    '	#if PERSPECTIVE_CAMERA == 1',
+    '	return perspectiveDepthToViewZ( depth, nearClip, farClip );',
+    '	#else',
+    '	return orthographicDepthToViewZ( depth, nearClip, farClip );',
+    '	#endif',
+    '}',
+
+    'void main() {',
+
+    '	vec2 aspectcorrect = vec2( 1.0, aspect );',
+
+    '	float viewZ = getViewZ( getDepth( vUv ) );',
+
+    '	float factor = ( focus + viewZ );', // viewZ is <= 0, so this is a difference equation
+
+    '	vec2 dofblur = vec2 ( clamp( factor * aperture, -maxblur, maxblur ) );',
+
+    '	vec2 dofblur9 = dofblur * 0.9;',
+    '	vec2 dofblur7 = dofblur * 0.7;',
+    '	vec2 dofblur4 = dofblur * 0.4;',
+
+    '	vec4 col = vec4( 0.0 );',
+
+    '	col += texture2D( tColor, vUv.xy );',
+    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.0,   0.4  ) * aspectcorrect ) * dofblur );',
+    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.15,  0.37 ) * aspectcorrect ) * dofblur );',
+    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.29,  0.29 ) * aspectcorrect ) * dofblur );',
+    '	col += texture2D( tColor, vUv.xy + ( vec2( -0.37,  0.15 ) * aspectcorrect ) * dofblur );',
+    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.40,  0.0  ) * aspectcorrect ) * dofblur );',
+    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.37, -0.15 ) * aspectcorrect ) * dofblur );',
+    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.29, -0.29 ) * aspectcorrect ) * dofblur );',
+    '	col += texture2D( tColor, vUv.xy + ( vec2( -0.15, -0.37 ) * aspectcorrect ) * dofblur );',
+    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.0,  -0.4  ) * aspectcorrect ) * dofblur );',
+    '	col += texture2D( tColor, vUv.xy + ( vec2( -0.15,  0.37 ) * aspectcorrect ) * dofblur );',
+    '	col += texture2D( tColor, vUv.xy + ( vec2( -0.29,  0.29 ) * aspectcorrect ) * dofblur );',
+    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.37,  0.15 ) * aspectcorrect ) * dofblur );',
+    '	col += texture2D( tColor, vUv.xy + ( vec2( -0.4,   0.0  ) * aspectcorrect ) * dofblur );',
+    '	col += texture2D( tColor, vUv.xy + ( vec2( -0.37, -0.15 ) * aspectcorrect ) * dofblur );',
+    '	col += texture2D( tColor, vUv.xy + ( vec2( -0.29, -0.29 ) * aspectcorrect ) * dofblur );',
+    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.15, -0.37 ) * aspectcorrect ) * dofblur );',
+
+    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.15,  0.37 ) * aspectcorrect ) * dofblur9 );',
+    '	col += texture2D( tColor, vUv.xy + ( vec2( -0.37,  0.15 ) * aspectcorrect ) * dofblur9 );',
+    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.37, -0.15 ) * aspectcorrect ) * dofblur9 );',
+    '	col += texture2D( tColor, vUv.xy + ( vec2( -0.15, -0.37 ) * aspectcorrect ) * dofblur9 );',
+    '	col += texture2D( tColor, vUv.xy + ( vec2( -0.15,  0.37 ) * aspectcorrect ) * dofblur9 );',
+    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.37,  0.15 ) * aspectcorrect ) * dofblur9 );',
+    '	col += texture2D( tColor, vUv.xy + ( vec2( -0.37, -0.15 ) * aspectcorrect ) * dofblur9 );',
+    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.15, -0.37 ) * aspectcorrect ) * dofblur9 );',
+
+    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.29,  0.29 ) * aspectcorrect ) * dofblur7 );',
+    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.40,  0.0  ) * aspectcorrect ) * dofblur7 );',
+    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.29, -0.29 ) * aspectcorrect ) * dofblur7 );',
+    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.0,  -0.4  ) * aspectcorrect ) * dofblur7 );',
+    '	col += texture2D( tColor, vUv.xy + ( vec2( -0.29,  0.29 ) * aspectcorrect ) * dofblur7 );',
+    '	col += texture2D( tColor, vUv.xy + ( vec2( -0.4,   0.0  ) * aspectcorrect ) * dofblur7 );',
+    '	col += texture2D( tColor, vUv.xy + ( vec2( -0.29, -0.29 ) * aspectcorrect ) * dofblur7 );',
+    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.0,   0.4  ) * aspectcorrect ) * dofblur7 );',
+
+    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.29,  0.29 ) * aspectcorrect ) * dofblur4 );',
+    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.4,   0.0  ) * aspectcorrect ) * dofblur4 );',
+    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.29, -0.29 ) * aspectcorrect ) * dofblur4 );',
+    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.0,  -0.4  ) * aspectcorrect ) * dofblur4 );',
+    '	col += texture2D( tColor, vUv.xy + ( vec2( -0.29,  0.29 ) * aspectcorrect ) * dofblur4 );',
+    '	col += texture2D( tColor, vUv.xy + ( vec2( -0.4,   0.0  ) * aspectcorrect ) * dofblur4 );',
+    '	col += texture2D( tColor, vUv.xy + ( vec2( -0.29, -0.29 ) * aspectcorrect ) * dofblur4 );',
+    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.0,   0.4  ) * aspectcorrect ) * dofblur4 );',
+
+    '	gl_FragColor = col / 41.0;',
+    '	gl_FragColor.a = 1.0;',
+
+    '}',
+  ].join('\n'),
 }
diff --git a/src/shaders/BokehShader2.ts b/src/shaders/BokehShader2.ts
index 28f6bca6..f9734ebe 100644
--- a/src/shaders/BokehShader2.ts
+++ b/src/shaders/BokehShader2.ts
@@ -78,305 +78,305 @@ export const BokehShader2: {
     pentagon: { value: 0 },
 
     shaderFocus: { value: 1 },
-    focusCoords: { value: /* @__PURE__ */ new Vector2() },
+    focusCoords: { value: new Vector2() },
   },
 
-  vertexShader: /* glsl */ `
-    varying vec2 vUv;
+  vertexShader: [
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vUv = uv;
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    '	vUv = uv;',
+    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    #include <common>
+  fragmentShader: [
+    '#include <common>',
 
-    varying vec2 vUv;
+    'varying vec2 vUv;',
 
-    uniform sampler2D tColor;
-    uniform sampler2D tDepth;
-    uniform float textureWidth;
-    uniform float textureHeight;
+    'uniform sampler2D tColor;',
+    'uniform sampler2D tDepth;',
+    'uniform float textureWidth;',
+    'uniform float textureHeight;',
 
-    uniform float focalDepth;  //focal distance value in meters, but you may use autofocus option below
-    uniform float focalLength; //focal length in mm
-    uniform float fstop; //f-stop value
-    uniform bool showFocus; //show debug focus point and focal range (red = focal point, green = focal range)
+    'uniform float focalDepth;  //focal distance value in meters, but you may use autofocus option below',
+    'uniform float focalLength; //focal length in mm',
+    'uniform float fstop; //f-stop value',
+    'uniform bool showFocus; //show debug focus point and focal range (red = focal point, green = focal range)',
 
-    /*
-    make sure that these two values are the same for your camera, otherwise distances will be wrong.
-    */
+    '/*',
+    'make sure that these two values are the same for your camera, otherwise distances will be wrong.',
+    '*/',
 
-    uniform float znear; // camera clipping start
-    uniform float zfar; // camera clipping end
+    'uniform float znear; // camera clipping start',
+    'uniform float zfar; // camera clipping end',
 
-    //------------------------------------------
-    //user variables
+    '//------------------------------------------',
+    '//user variables',
 
-    const int samples = SAMPLES; //samples on the first ring
-    const int rings = RINGS; //ring count
+    'const int samples = SAMPLES; //samples on the first ring',
+    'const int rings = RINGS; //ring count',
 
-    const int maxringsamples = rings * samples;
+    'const int maxringsamples = rings * samples;',
 
-    uniform bool manualdof; // manual dof calculation
-    float ndofstart = 1.0; // near dof blur start
-    float ndofdist = 2.0; // near dof blur falloff distance
-    float fdofstart = 1.0; // far dof blur start
-    float fdofdist = 3.0; // far dof blur falloff distance
+    'uniform bool manualdof; // manual dof calculation',
+    'float ndofstart = 1.0; // near dof blur start',
+    'float ndofdist = 2.0; // near dof blur falloff distance',
+    'float fdofstart = 1.0; // far dof blur start',
+    'float fdofdist = 3.0; // far dof blur falloff distance',
 
-    float CoC = 0.03; //circle of confusion size in mm (35mm film = 0.03mm)
+    'float CoC = 0.03; //circle of confusion size in mm (35mm film = 0.03mm)',
 
-    uniform bool vignetting; // use optical lens vignetting
+    'uniform bool vignetting; // use optical lens vignetting',
 
-    float vignout = 1.3; // vignetting outer border
-    float vignin = 0.0; // vignetting inner border
-    float vignfade = 22.0; // f-stops till vignete fades
+    'float vignout = 1.3; // vignetting outer border',
+    'float vignin = 0.0; // vignetting inner border',
+    'float vignfade = 22.0; // f-stops till vignete fades',
 
-    uniform bool shaderFocus;
-    // disable if you use external focalDepth value
+    'uniform bool shaderFocus;',
+    '// disable if you use external focalDepth value',
 
-    uniform vec2 focusCoords;
-    // autofocus point on screen (0.0,0.0 - left lower corner, 1.0,1.0 - upper right)
-    // if center of screen use vec2(0.5, 0.5);
+    'uniform vec2 focusCoords;',
+    '// autofocus point on screen (0.0,0.0 - left lower corner, 1.0,1.0 - upper right)',
+    '// if center of screen use vec2(0.5, 0.5);',
 
-    uniform float maxblur;
-    //clamp value of max blur (0.0 = no blur, 1.0 default)
+    'uniform float maxblur;',
+    '//clamp value of max blur (0.0 = no blur, 1.0 default)',
 
-    uniform float threshold; // highlight threshold;
-    uniform float gain; // highlight gain;
+    'uniform float threshold; // highlight threshold;',
+    'uniform float gain; // highlight gain;',
 
-    uniform float bias; // bokeh edge bias
-    uniform float fringe; // bokeh chromatic aberration / fringing
+    'uniform float bias; // bokeh edge bias',
+    'uniform float fringe; // bokeh chromatic aberration / fringing',
 
-    uniform bool noise; //use noise instead of pattern for sample dithering
+    'uniform bool noise; //use noise instead of pattern for sample dithering',
 
-    uniform float dithering;
+    'uniform float dithering;',
 
-    uniform bool depthblur; // blur the depth buffer
-    float dbsize = 1.25; // depth blur size
+    'uniform bool depthblur; // blur the depth buffer',
+    'float dbsize = 1.25; // depth blur size',
 
-    /*
-    next part is experimental
-    not looking good with small sample and ring count
-    looks okay starting from samples = 4, rings = 4
-    */
+    '/*',
+    'next part is experimental',
+    'not looking good with small sample and ring count',
+    'looks okay starting from samples = 4, rings = 4',
+    '*/',
 
-    uniform bool pentagon; //use pentagon as bokeh shape?
-    float feather = 0.4; //pentagon shape feather
+    'uniform bool pentagon; //use pentagon as bokeh shape?',
+    'float feather = 0.4; //pentagon shape feather',
 
-    //------------------------------------------
+    '//------------------------------------------',
 
-    float penta(vec2 coords) {
-    	//pentagonal shape
-    	float scale = float(rings) - 1.3;
-    	vec4  HS0 = vec4( 1.0,         0.0,         0.0,  1.0);
-    	vec4  HS1 = vec4( 0.309016994, 0.951056516, 0.0,  1.0);
-    	vec4  HS2 = vec4(-0.809016994, 0.587785252, 0.0,  1.0);
-    	vec4  HS3 = vec4(-0.809016994,-0.587785252, 0.0,  1.0);
-    	vec4  HS4 = vec4( 0.309016994,-0.951056516, 0.0,  1.0);
-    	vec4  HS5 = vec4( 0.0        ,0.0         , 1.0,  1.0);
+    'float penta(vec2 coords) {',
+    '	//pentagonal shape',
+    '	float scale = float(rings) - 1.3;',
+    '	vec4  HS0 = vec4( 1.0,         0.0,         0.0,  1.0);',
+    '	vec4  HS1 = vec4( 0.309016994, 0.951056516, 0.0,  1.0);',
+    '	vec4  HS2 = vec4(-0.809016994, 0.587785252, 0.0,  1.0);',
+    '	vec4  HS3 = vec4(-0.809016994,-0.587785252, 0.0,  1.0);',
+    '	vec4  HS4 = vec4( 0.309016994,-0.951056516, 0.0,  1.0);',
+    '	vec4  HS5 = vec4( 0.0        ,0.0         , 1.0,  1.0);',
 
-    	vec4  one = vec4( 1.0 );
+    '	vec4  one = vec4( 1.0 );',
 
-    	vec4 P = vec4((coords),vec2(scale, scale));
+    '	vec4 P = vec4((coords),vec2(scale, scale));',
 
-    	vec4 dist = vec4(0.0);
-    	float inorout = -4.0;
+    '	vec4 dist = vec4(0.0);',
+    '	float inorout = -4.0;',
 
-    	dist.x = dot( P, HS0 );
-    	dist.y = dot( P, HS1 );
-    	dist.z = dot( P, HS2 );
-    	dist.w = dot( P, HS3 );
+    '	dist.x = dot( P, HS0 );',
+    '	dist.y = dot( P, HS1 );',
+    '	dist.z = dot( P, HS2 );',
+    '	dist.w = dot( P, HS3 );',
 
-    	dist = smoothstep( -feather, feather, dist );
+    '	dist = smoothstep( -feather, feather, dist );',
 
-    	inorout += dot( dist, one );
+    '	inorout += dot( dist, one );',
 
-    	dist.x = dot( P, HS4 );
-    	dist.y = HS5.w - abs( P.z );
+    '	dist.x = dot( P, HS4 );',
+    '	dist.y = HS5.w - abs( P.z );',
 
-    	dist = smoothstep( -feather, feather, dist );
-    	inorout += dist.x;
+    '	dist = smoothstep( -feather, feather, dist );',
+    '	inorout += dist.x;',
 
-    	return clamp( inorout, 0.0, 1.0 );
-    }
+    '	return clamp( inorout, 0.0, 1.0 );',
+    '}',
 
-    float bdepth(vec2 coords) {
-    	// Depth buffer blur
-    	float d = 0.0;
-    	float kernel[9];
-    	vec2 offset[9];
+    'float bdepth(vec2 coords) {',
+    '	// Depth buffer blur',
+    '	float d = 0.0;',
+    '	float kernel[9];',
+    '	vec2 offset[9];',
 
-    	vec2 wh = vec2(1.0/textureWidth,1.0/textureHeight) * dbsize;
+    '	vec2 wh = vec2(1.0/textureWidth,1.0/textureHeight) * dbsize;',
 
-    	offset[0] = vec2(-wh.x,-wh.y);
-    	offset[1] = vec2( 0.0, -wh.y);
-    	offset[2] = vec2( wh.x -wh.y);
+    '	offset[0] = vec2(-wh.x,-wh.y);',
+    '	offset[1] = vec2( 0.0, -wh.y);',
+    '	offset[2] = vec2( wh.x -wh.y);',
 
-    	offset[3] = vec2(-wh.x,  0.0);
-    	offset[4] = vec2( 0.0,   0.0);
-    	offset[5] = vec2( wh.x,  0.0);
+    '	offset[3] = vec2(-wh.x,  0.0);',
+    '	offset[4] = vec2( 0.0,   0.0);',
+    '	offset[5] = vec2( wh.x,  0.0);',
 
-    	offset[6] = vec2(-wh.x, wh.y);
-    	offset[7] = vec2( 0.0,  wh.y);
-    	offset[8] = vec2( wh.x, wh.y);
+    '	offset[6] = vec2(-wh.x, wh.y);',
+    '	offset[7] = vec2( 0.0,  wh.y);',
+    '	offset[8] = vec2( wh.x, wh.y);',
 
-    	kernel[0] = 1.0/16.0;   kernel[1] = 2.0/16.0;   kernel[2] = 1.0/16.0;
-    	kernel[3] = 2.0/16.0;   kernel[4] = 4.0/16.0;   kernel[5] = 2.0/16.0;
-    	kernel[6] = 1.0/16.0;   kernel[7] = 2.0/16.0;   kernel[8] = 1.0/16.0;
+    '	kernel[0] = 1.0/16.0;   kernel[1] = 2.0/16.0;   kernel[2] = 1.0/16.0;',
+    '	kernel[3] = 2.0/16.0;   kernel[4] = 4.0/16.0;   kernel[5] = 2.0/16.0;',
+    '	kernel[6] = 1.0/16.0;   kernel[7] = 2.0/16.0;   kernel[8] = 1.0/16.0;',
 
-    	for( int i=0; i<9; i++ ) {
-    		float tmp = texture2D(tDepth, coords + offset[i]).r;
-    		d += tmp * kernel[i];
-    	}
+    '	for( int i=0; i<9; i++ ) {',
+    '		float tmp = texture2D(tDepth, coords + offset[i]).r;',
+    '		d += tmp * kernel[i];',
+    '	}',
 
-    	return d;
-    }
+    '	return d;',
+    '}',
 
-    vec3 color(vec2 coords,float blur) {
-    	//processing the sample
+    'vec3 color(vec2 coords,float blur) {',
+    '	//processing the sample',
 
-    	vec3 col = vec3(0.0);
-    	vec2 texel = vec2(1.0/textureWidth,1.0/textureHeight);
+    '	vec3 col = vec3(0.0);',
+    '	vec2 texel = vec2(1.0/textureWidth,1.0/textureHeight);',
 
-    	col.r = texture2D(tColor,coords + vec2(0.0,1.0)*texel*fringe*blur).r;
-    	col.g = texture2D(tColor,coords + vec2(-0.866,-0.5)*texel*fringe*blur).g;
-    	col.b = texture2D(tColor,coords + vec2(0.866,-0.5)*texel*fringe*blur).b;
+    '	col.r = texture2D(tColor,coords + vec2(0.0,1.0)*texel*fringe*blur).r;',
+    '	col.g = texture2D(tColor,coords + vec2(-0.866,-0.5)*texel*fringe*blur).g;',
+    '	col.b = texture2D(tColor,coords + vec2(0.866,-0.5)*texel*fringe*blur).b;',
 
-    	vec3 lumcoeff = vec3(0.299,0.587,0.114);
-    	float lum = dot(col.rgb, lumcoeff);
-    	float thresh = max((lum-threshold)*gain, 0.0);
-    	return col+mix(vec3(0.0),col,thresh*blur);
-    }
+    '	vec3 lumcoeff = vec3(0.299,0.587,0.114);',
+    '	float lum = dot(col.rgb, lumcoeff);',
+    '	float thresh = max((lum-threshold)*gain, 0.0);',
+    '	return col+mix(vec3(0.0),col,thresh*blur);',
+    '}',
 
-    vec3 debugFocus(vec3 col, float blur, float depth) {
-    	float edge = 0.002*depth; //distance based edge smoothing
-    	float m = clamp(smoothstep(0.0,edge,blur),0.0,1.0);
-    	float e = clamp(smoothstep(1.0-edge,1.0,blur),0.0,1.0);
+    'vec3 debugFocus(vec3 col, float blur, float depth) {',
+    '	float edge = 0.002*depth; //distance based edge smoothing',
+    '	float m = clamp(smoothstep(0.0,edge,blur),0.0,1.0);',
+    '	float e = clamp(smoothstep(1.0-edge,1.0,blur),0.0,1.0);',
 
-    	col = mix(col,vec3(1.0,0.5,0.0),(1.0-m)*0.6);
-    	col = mix(col,vec3(0.0,0.5,1.0),((1.0-e)-(1.0-m))*0.2);
+    '	col = mix(col,vec3(1.0,0.5,0.0),(1.0-m)*0.6);',
+    '	col = mix(col,vec3(0.0,0.5,1.0),((1.0-e)-(1.0-m))*0.2);',
 
-    	return col;
-    }
+    '	return col;',
+    '}',
 
-    float linearize(float depth) {
-    	return -zfar * znear / (depth * (zfar - znear) - zfar);
-    }
+    'float linearize(float depth) {',
+    '	return -zfar * znear / (depth * (zfar - znear) - zfar);',
+    '}',
 
-    float vignette() {
-    	float dist = distance(vUv.xy, vec2(0.5,0.5));
-    	dist = smoothstep(vignout+(fstop/vignfade), vignin+(fstop/vignfade), dist);
-    	return clamp(dist,0.0,1.0);
-    }
+    'float vignette() {',
+    '	float dist = distance(vUv.xy, vec2(0.5,0.5));',
+    '	dist = smoothstep(vignout+(fstop/vignfade), vignin+(fstop/vignfade), dist);',
+    '	return clamp(dist,0.0,1.0);',
+    '}',
 
-    float gather(float i, float j, int ringsamples, inout vec3 col, float w, float h, float blur) {
-    	float rings2 = float(rings);
-    	float step = PI*2.0 / float(ringsamples);
-    	float pw = cos(j*step)*i;
-    	float ph = sin(j*step)*i;
-    	float p = 1.0;
-    	if (pentagon) {
-    		p = penta(vec2(pw,ph));
-    	}
-    	col += color(vUv.xy + vec2(pw*w,ph*h), blur) * mix(1.0, i/rings2, bias) * p;
-    	return 1.0 * mix(1.0, i /rings2, bias) * p;
-    }
+    'float gather(float i, float j, int ringsamples, inout vec3 col, float w, float h, float blur) {',
+    '	float rings2 = float(rings);',
+    '	float step = PI*2.0 / float(ringsamples);',
+    '	float pw = cos(j*step)*i;',
+    '	float ph = sin(j*step)*i;',
+    '	float p = 1.0;',
+    '	if (pentagon) {',
+    '		p = penta(vec2(pw,ph));',
+    '	}',
+    '	col += color(vUv.xy + vec2(pw*w,ph*h), blur) * mix(1.0, i/rings2, bias) * p;',
+    '	return 1.0 * mix(1.0, i /rings2, bias) * p;',
+    '}',
 
-    void main() {
-    	//scene depth calculation
+    'void main() {',
+    '	//scene depth calculation',
 
-    	float depth = linearize(texture2D(tDepth,vUv.xy).x);
+    '	float depth = linearize(texture2D(tDepth,vUv.xy).x);',
 
-    	// Blur depth?
-    	if ( depthblur ) {
-    		depth = linearize(bdepth(vUv.xy));
-    	}
+    '	// Blur depth?',
+    '	if ( depthblur ) {',
+    '		depth = linearize(bdepth(vUv.xy));',
+    '	}',
 
-    	//focal plane calculation
+    '	//focal plane calculation',
 
-    	float fDepth = focalDepth;
+    '	float fDepth = focalDepth;',
 
-    	if (shaderFocus) {
+    '	if (shaderFocus) {',
 
-    		fDepth = linearize(texture2D(tDepth,focusCoords).x);
+    '		fDepth = linearize(texture2D(tDepth,focusCoords).x);',
 
-    	}
+    '	}',
 
-    	// dof blur factor calculation
+    '	// dof blur factor calculation',
 
-    	float blur = 0.0;
+    '	float blur = 0.0;',
 
-    	if (manualdof) {
-    		float a = depth-fDepth; // Focal plane
-    		float b = (a-fdofstart)/fdofdist; // Far DoF
-    		float c = (-a-ndofstart)/ndofdist; // Near Dof
-    		blur = (a>0.0) ? b : c;
-    	} else {
-    		float f = focalLength; // focal length in mm
-    		float d = fDepth*1000.0; // focal plane in mm
-    		float o = depth*1000.0; // depth in mm
+    '	if (manualdof) {',
+    '		float a = depth-fDepth; // Focal plane',
+    '		float b = (a-fdofstart)/fdofdist; // Far DoF',
+    '		float c = (-a-ndofstart)/ndofdist; // Near Dof',
+    '		blur = (a>0.0) ? b : c;',
+    '	} else {',
+    '		float f = focalLength; // focal length in mm',
+    '		float d = fDepth*1000.0; // focal plane in mm',
+    '		float o = depth*1000.0; // depth in mm',
 
-    		float a = (o*f)/(o-f);
-    		float b = (d*f)/(d-f);
-    		float c = (d-f)/(d*fstop*CoC);
+    '		float a = (o*f)/(o-f);',
+    '		float b = (d*f)/(d-f);',
+    '		float c = (d-f)/(d*fstop*CoC);',
 
-    		blur = abs(a-b)*c;
-    	}
+    '		blur = abs(a-b)*c;',
+    '	}',
 
-    	blur = clamp(blur,0.0,1.0);
+    '	blur = clamp(blur,0.0,1.0);',
 
-    	// calculation of pattern for dithering
+    '	// calculation of pattern for dithering',
 
-    	vec2 noise = vec2(rand(vUv.xy), rand( vUv.xy + vec2( 0.4, 0.6 ) ) )*dithering*blur;
+    '	vec2 noise = vec2(rand(vUv.xy), rand( vUv.xy + vec2( 0.4, 0.6 ) ) )*dithering*blur;',
 
-    	// getting blur x and y step factor
+    '	// getting blur x and y step factor',
 
-    	float w = (1.0/textureWidth)*blur*maxblur+noise.x;
-    	float h = (1.0/textureHeight)*blur*maxblur+noise.y;
+    '	float w = (1.0/textureWidth)*blur*maxblur+noise.x;',
+    '	float h = (1.0/textureHeight)*blur*maxblur+noise.y;',
 
-    	// calculation of final color
+    '	// calculation of final color',
 
-    	vec3 col = vec3(0.0);
+    '	vec3 col = vec3(0.0);',
 
-    	if(blur < 0.05) {
-    		//some optimization thingy
-    		col = texture2D(tColor, vUv.xy).rgb;
-    	} else {
-    		col = texture2D(tColor, vUv.xy).rgb;
-    		float s = 1.0;
-    		int ringsamples;
+    '	if(blur < 0.05) {',
+    '		//some optimization thingy',
+    '		col = texture2D(tColor, vUv.xy).rgb;',
+    '	} else {',
+    '		col = texture2D(tColor, vUv.xy).rgb;',
+    '		float s = 1.0;',
+    '		int ringsamples;',
 
-    		for (int i = 1; i <= rings; i++) {
-    			/*unboxstart*/
-    			ringsamples = i * samples;
+    '		for (int i = 1; i <= rings; i++) {',
+    '			/*unboxstart*/',
+    '			ringsamples = i * samples;',
 
-    			for (int j = 0 ; j < maxringsamples ; j++) {
-    				if (j >= ringsamples) break;
-    				s += gather(float(i), float(j), ringsamples, col, w, h, blur);
-    			}
-    			/*unboxend*/
-    		}
+    '			for (int j = 0 ; j < maxringsamples ; j++) {',
+    '				if (j >= ringsamples) break;',
+    '				s += gather(float(i), float(j), ringsamples, col, w, h, blur);',
+    '			}',
+    '			/*unboxend*/',
+    '		}',
 
-    		col /= s; //divide by sample count
-    	}
+    '		col /= s; //divide by sample count',
+    '	}',
 
-    	if (showFocus) {
-    		col = debugFocus(col, blur, depth);
-    	}
+    '	if (showFocus) {',
+    '		col = debugFocus(col, blur, depth);',
+    '	}',
 
-    	if (vignetting) {
-    		col *= vignette();
-    	}
+    '	if (vignetting) {',
+    '		col *= vignette();',
+    '	}',
 
-    	gl_FragColor.rgb = col;
-    	gl_FragColor.a = 1.0;
-    } 
-  `,
+    '	gl_FragColor.rgb = col;',
+    '	gl_FragColor.a = 1.0;',
+    '} ',
+  ].join('\n'),
 }
 
 export const BokehDepthShader = {
@@ -385,30 +385,30 @@ export const BokehDepthShader = {
     mFar: { value: 1000.0 },
   },
 
-  vertexShader: /* glsl */ `
-    varying float vViewZDepth;
+  vertexShader: [
+    'varying float vViewZDepth;',
 
-    void main() {
+    'void main() {',
 
-    	#include <begin_vertex>
-    	#include <project_vertex>
+    '	#include <begin_vertex>',
+    '	#include <project_vertex>',
 
-    	vViewZDepth = - mvPosition.z;
+    '	vViewZDepth = - mvPosition.z;',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    uniform float mNear;
-    uniform float mFar;
+  fragmentShader: [
+    'uniform float mNear;',
+    'uniform float mFar;',
 
-    varying float vViewZDepth;
+    'varying float vViewZDepth;',
 
-    void main() {
+    'void main() {',
 
-    	float color = 1.0 - smoothstep( mNear, mFar, vViewZDepth );
-    	gl_FragColor = vec4( vec3( color ), 1.0 );
+    '	float color = 1.0 - smoothstep( mNear, mFar, vViewZDepth );',
+    '	gl_FragColor = vec4( vec3( color ), 1.0 );',
 
-    } 
-  `,
+    '} ',
+  ].join('\n'),
 }
diff --git a/src/shaders/BrightnessContrastShader.ts b/src/shaders/BrightnessContrastShader.ts
index c2d77b3a..56c15b3a 100644
--- a/src/shaders/BrightnessContrastShader.ts
+++ b/src/shaders/BrightnessContrastShader.ts
@@ -12,37 +12,37 @@ export const BrightnessContrastShader = {
     contrast: { value: 0 },
   },
 
-  vertexShader: /* glsl */ `
-    varying vec2 vUv;
+  vertexShader: [
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vUv = uv;
+    '	vUv = uv;',
 
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    uniform sampler2D tDiffuse;
-    uniform float brightness;
-    uniform float contrast;
+  fragmentShader: [
+    'uniform sampler2D tDiffuse;',
+    'uniform float brightness;',
+    'uniform float contrast;',
 
-    varying vec2 vUv;
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	gl_FragColor = texture2D( tDiffuse, vUv );
+    '	gl_FragColor = texture2D( tDiffuse, vUv );',
 
-    	gl_FragColor.rgb += brightness;
+    '	gl_FragColor.rgb += brightness;',
 
-    	if (contrast > 0.0) {
-    		gl_FragColor.rgb = (gl_FragColor.rgb - 0.5) / (1.0 - contrast) + 0.5;
-    	} else {
-    		gl_FragColor.rgb = (gl_FragColor.rgb - 0.5) * (1.0 + contrast) + 0.5;
-    	}
+    '	if (contrast > 0.0) {',
+    '		gl_FragColor.rgb = (gl_FragColor.rgb - 0.5) / (1.0 - contrast) + 0.5;',
+    '	} else {',
+    '		gl_FragColor.rgb = (gl_FragColor.rgb - 0.5) * (1.0 + contrast) + 0.5;',
+    '	}',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 }
diff --git a/src/shaders/ColorCorrectionShader.ts b/src/shaders/ColorCorrectionShader.ts
index 29e77305..2e63a4b3 100644
--- a/src/shaders/ColorCorrectionShader.ts
+++ b/src/shaders/ColorCorrectionShader.ts
@@ -7,36 +7,36 @@ import { Vector3 } from 'three'
 export const ColorCorrectionShader = {
   uniforms: {
     tDiffuse: { value: null },
-    powRGB: { value: /* @__PURE__ */ new Vector3(2, 2, 2) },
-    mulRGB: { value: /* @__PURE__ */ new Vector3(1, 1, 1) },
-    addRGB: { value: /* @__PURE__ */ new Vector3(0, 0, 0) },
+    powRGB: { value: new Vector3(2, 2, 2) },
+    mulRGB: { value: new Vector3(1, 1, 1) },
+    addRGB: { value: new Vector3(0, 0, 0) },
   },
 
-  vertexShader: /* glsl */ `
-    varying vec2 vUv;
+  vertexShader: [
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vUv = uv;
+    '	vUv = uv;',
 
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    uniform sampler2D tDiffuse;
-    uniform vec3 powRGB;
-    uniform vec3 mulRGB;
-    uniform vec3 addRGB;
+  fragmentShader: [
+    'uniform sampler2D tDiffuse;',
+    'uniform vec3 powRGB;',
+    'uniform vec3 mulRGB;',
+    'uniform vec3 addRGB;',
 
-    varying vec2 vUv;
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	gl_FragColor = texture2D( tDiffuse, vUv );
-    	gl_FragColor.rgb = mulRGB * pow( ( gl_FragColor.rgb + addRGB ), powRGB );
+    '	gl_FragColor = texture2D( tDiffuse, vUv );',
+    '	gl_FragColor.rgb = mulRGB * pow( ( gl_FragColor.rgb + addRGB ), powRGB );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 }
diff --git a/src/shaders/ColorifyShader.ts b/src/shaders/ColorifyShader.ts
index 0554126b..68f74c5f 100644
--- a/src/shaders/ColorifyShader.ts
+++ b/src/shaders/ColorifyShader.ts
@@ -7,35 +7,35 @@ import { Color } from 'three'
 export const ColorifyShader = {
   uniforms: {
     tDiffuse: { value: null },
-    color: { value: /* @__PURE__ */ new Color(0xffffff) },
+    color: { value: new Color(0xffffff) },
   },
 
-  vertexShader: /* glsl */ `
-    varying vec2 vUv;
+  vertexShader: [
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vUv = uv;
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    '	vUv = uv;',
+    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    uniform vec3 color;
-    uniform sampler2D tDiffuse;
+  fragmentShader: [
+    'uniform vec3 color;',
+    'uniform sampler2D tDiffuse;',
 
-    varying vec2 vUv;
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vec4 texel = texture2D( tDiffuse, vUv );
+    '	vec4 texel = texture2D( tDiffuse, vUv );',
 
-    	vec3 luma = vec3( 0.299, 0.587, 0.114 );
-    	float v = dot( texel.xyz, luma );
+    '	vec3 luma = vec3( 0.299, 0.587, 0.114 );',
+    '	float v = dot( texel.xyz, luma );',
 
-    	gl_FragColor = vec4( v * color, texel.w );
+    '	gl_FragColor = vec4( v * color, texel.w );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 }
diff --git a/src/shaders/ConvolutionShader.ts b/src/shaders/ConvolutionShader.ts
index 5a18083e..3d1c5126 100644
--- a/src/shaders/ConvolutionShader.ts
+++ b/src/shaders/ConvolutionShader.ts
@@ -32,47 +32,47 @@ export const ConvolutionShader: IConvolutionShader = {
 
   uniforms: {
     tDiffuse: { value: null },
-    uImageIncrement: { value: /* @__PURE__ */ new Vector2(0.001953125, 0.0) },
+    uImageIncrement: { value: new Vector2(0.001953125, 0.0) },
     cKernel: { value: [] },
   },
 
-  vertexShader: /* glsl */ `
-    uniform vec2 uImageIncrement;
+  vertexShader: [
+    'uniform vec2 uImageIncrement;',
 
-    varying vec2 vUv;
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vUv = uv - ( ( KERNEL_SIZE_FLOAT - 1.0 ) / 2.0 ) * uImageIncrement;
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    '	vUv = uv - ( ( KERNEL_SIZE_FLOAT - 1.0 ) / 2.0 ) * uImageIncrement;',
+    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    uniform float cKernel[ KERNEL_SIZE_INT ];
+  fragmentShader: [
+    'uniform float cKernel[ KERNEL_SIZE_INT ];',
 
-    uniform sampler2D tDiffuse;
-    uniform vec2 uImageIncrement;
+    'uniform sampler2D tDiffuse;',
+    'uniform vec2 uImageIncrement;',
 
-    varying vec2 vUv;
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vec2 imageCoord = vUv;
-    	vec4 sum = vec4( 0.0, 0.0, 0.0, 0.0 );
+    '	vec2 imageCoord = vUv;',
+    '	vec4 sum = vec4( 0.0, 0.0, 0.0, 0.0 );',
 
-    	for( int i = 0; i < KERNEL_SIZE_INT; i ++ ) {
+    '	for( int i = 0; i < KERNEL_SIZE_INT; i ++ ) {',
 
-    		sum += texture2D( tDiffuse, imageCoord ) * cKernel[ i ];
-    		imageCoord += uImageIncrement;
+    '		sum += texture2D( tDiffuse, imageCoord ) * cKernel[ i ];',
+    '		imageCoord += uImageIncrement;',
 
-    	}
+    '	}',
 
-    	gl_FragColor = sum;
+    '	gl_FragColor = sum;',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
   buildKernel: function (sigma) {
     // We lop off the sqrt(2 * pi) * sigma term, since we're going to normalize anyway.
diff --git a/src/shaders/CopyShader.ts b/src/shaders/CopyShader.ts
index 3bae6f68..ad38d817 100644
--- a/src/shaders/CopyShader.ts
+++ b/src/shaders/CopyShader.ts
@@ -18,29 +18,29 @@ export const CopyShader: ICopyShader = {
     opacity: { value: 1.0 },
   },
 
-  vertexShader: /* glsl */ `
-    varying vec2 vUv;
+  vertexShader: [
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vUv = uv;
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    '	vUv = uv;',
+    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    uniform float opacity;
+  fragmentShader: [
+    'uniform float opacity;',
 
-    uniform sampler2D tDiffuse;
+    'uniform sampler2D tDiffuse;',
 
-    varying vec2 vUv;
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vec4 texel = texture2D( tDiffuse, vUv );
-    	gl_FragColor = opacity * texel;
+    '	vec4 texel = texture2D( tDiffuse, vUv );',
+    '	gl_FragColor = opacity * texel;',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 }
diff --git a/src/shaders/DOFMipMapShader.ts b/src/shaders/DOFMipMapShader.ts
index 6b068ea3..00c38c52 100644
--- a/src/shaders/DOFMipMapShader.ts
+++ b/src/shaders/DOFMipMapShader.ts
@@ -12,37 +12,37 @@ export const DOFMipMapShader = {
     maxblur: { value: 1.0 },
   },
 
-  vertexShader: /* glsl */ `
-    varying vec2 vUv;
+  vertexShader: [
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vUv = uv;
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    '	vUv = uv;',
+    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    uniform float focus;
-    uniform float maxblur;
+  fragmentShader: [
+    'uniform float focus;',
+    'uniform float maxblur;',
 
-    uniform sampler2D tColor;
-    uniform sampler2D tDepth;
+    'uniform sampler2D tColor;',
+    'uniform sampler2D tDepth;',
 
-    varying vec2 vUv;
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vec4 depth = texture2D( tDepth, vUv );
+    '	vec4 depth = texture2D( tDepth, vUv );',
 
-    	float factor = depth.x - focus;
+    '	float factor = depth.x - focus;',
 
-    	vec4 col = texture2D( tColor, vUv, 2.0 * maxblur * abs( focus - depth.x ) );
+    '	vec4 col = texture2D( tColor, vUv, 2.0 * maxblur * abs( focus - depth.x ) );',
 
-    	gl_FragColor = col;
-    	gl_FragColor.a = 1.0;
+    '	gl_FragColor = col;',
+    '	gl_FragColor.a = 1.0;',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 }
diff --git a/src/shaders/DepthLimitedBlurShader.ts b/src/shaders/DepthLimitedBlurShader.ts
index ddff62ec..2e962893 100644
--- a/src/shaders/DepthLimitedBlurShader.ts
+++ b/src/shaders/DepthLimitedBlurShader.ts
@@ -33,104 +33,104 @@ export const DepthLimitedBlurShader: IDepthLimitedBlurShader = {
   },
   uniforms: {
     tDiffuse: { value: null },
-    size: { value: /* @__PURE__ */ new Vector2(512, 512) },
-    sampleUvOffsets: { value: [/* @__PURE__ */ new Vector2(0, 0)] },
+    size: { value: new Vector2(512, 512) },
+    sampleUvOffsets: { value: [new Vector2(0, 0)] },
     sampleWeights: { value: [1.0] },
     tDepth: { value: null },
     cameraNear: { value: 10 },
     cameraFar: { value: 1000 },
     depthCutoff: { value: 10 },
   },
-  vertexShader: /* glsl */ `
-    #include <common>
+  vertexShader: [
+    '#include <common>',
 
-    uniform vec2 size;
+    'uniform vec2 size;',
 
-    varying vec2 vUv;
-    varying vec2 vInvSize;
+    'varying vec2 vUv;',
+    'varying vec2 vInvSize;',
 
-    void main() {
-    	vUv = uv;
-    	vInvSize = 1.0 / size;
+    'void main() {',
+    '	vUv = uv;',
+    '	vInvSize = 1.0 / size;',
 
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
-    }
-  `,
-  fragmentShader: /* glsl */ `
-    #include <common>
-    #include <packing>
-
-    uniform sampler2D tDiffuse;
-    uniform sampler2D tDepth;
-
-    uniform float cameraNear;
-    uniform float cameraFar;
-    uniform float depthCutoff;
-
-    uniform vec2 sampleUvOffsets[ KERNEL_RADIUS + 1 ];
-    uniform float sampleWeights[ KERNEL_RADIUS + 1 ];
-
-    varying vec2 vUv;
-    varying vec2 vInvSize;
-
-    float getDepth( const in vec2 screenPosition ) {
-    	#if DEPTH_PACKING == 1
-    	return unpackRGBAToDepth( texture2D( tDepth, screenPosition ) );
-    	#else
-    	return texture2D( tDepth, screenPosition ).x;
-    	#endif
-    }
+    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    '}',
+  ].join('\n'),
+  fragmentShader: [
+    '#include <common>',
+    '#include <packing>',
 
-    float getViewZ( const in float depth ) {
-    	#if PERSPECTIVE_CAMERA == 1
-    	return perspectiveDepthToViewZ( depth, cameraNear, cameraFar );
-    	#else
-    	return orthographicDepthToViewZ( depth, cameraNear, cameraFar );
-    	#endif
-    }
+    'uniform sampler2D tDiffuse;',
+    'uniform sampler2D tDepth;',
 
-    void main() {
-    	float depth = getDepth( vUv );
-    	if( depth >= ( 1.0 - EPSILON ) ) {
-    		discard;
-    	}
+    'uniform float cameraNear;',
+    'uniform float cameraFar;',
+    'uniform float depthCutoff;',
 
-    	float centerViewZ = -getViewZ( depth );
-    	bool rBreak = false, lBreak = false;
+    'uniform vec2 sampleUvOffsets[ KERNEL_RADIUS + 1 ];',
+    'uniform float sampleWeights[ KERNEL_RADIUS + 1 ];',
 
-    	float weightSum = sampleWeights[0];
-    	vec4 diffuseSum = texture2D( tDiffuse, vUv ) * weightSum;
+    'varying vec2 vUv;',
+    'varying vec2 vInvSize;',
 
-    	for( int i = 1; i <= KERNEL_RADIUS; i ++ ) {
+    'float getDepth( const in vec2 screenPosition ) {',
+    '	#if DEPTH_PACKING == 1',
+    '	return unpackRGBAToDepth( texture2D( tDepth, screenPosition ) );',
+    '	#else',
+    '	return texture2D( tDepth, screenPosition ).x;',
+    '	#endif',
+    '}',
 
-    		float sampleWeight = sampleWeights[i];
-    		vec2 sampleUvOffset = sampleUvOffsets[i] * vInvSize;
+    'float getViewZ( const in float depth ) {',
+    '	#if PERSPECTIVE_CAMERA == 1',
+    '	return perspectiveDepthToViewZ( depth, cameraNear, cameraFar );',
+    '	#else',
+    '	return orthographicDepthToViewZ( depth, cameraNear, cameraFar );',
+    '	#endif',
+    '}',
 
-    		vec2 sampleUv = vUv + sampleUvOffset;
-    		float viewZ = -getViewZ( getDepth( sampleUv ) );
+    'void main() {',
+    '	float depth = getDepth( vUv );',
+    '	if( depth >= ( 1.0 - EPSILON ) ) {',
+    '		discard;',
+    '	}',
 
-    		if( abs( viewZ - centerViewZ ) > depthCutoff ) rBreak = true;
+    '	float centerViewZ = -getViewZ( depth );',
+    '	bool rBreak = false, lBreak = false;',
 
-    		if( ! rBreak ) {
-    			diffuseSum += texture2D( tDiffuse, sampleUv ) * sampleWeight;
-    			weightSum += sampleWeight;
-    		}
+    '	float weightSum = sampleWeights[0];',
+    '	vec4 diffuseSum = texture2D( tDiffuse, vUv ) * weightSum;',
 
-    		sampleUv = vUv - sampleUvOffset;
-    		viewZ = -getViewZ( getDepth( sampleUv ) );
+    '	for( int i = 1; i <= KERNEL_RADIUS; i ++ ) {',
 
-    		if( abs( viewZ - centerViewZ ) > depthCutoff ) lBreak = true;
+    '		float sampleWeight = sampleWeights[i];',
+    '		vec2 sampleUvOffset = sampleUvOffsets[i] * vInvSize;',
 
-    		if( ! lBreak ) {
-    			diffuseSum += texture2D( tDiffuse, sampleUv ) * sampleWeight;
-    			weightSum += sampleWeight;
-    		}
+    '		vec2 sampleUv = vUv + sampleUvOffset;',
+    '		float viewZ = -getViewZ( getDepth( sampleUv ) );',
 
-    	}
+    '		if( abs( viewZ - centerViewZ ) > depthCutoff ) rBreak = true;',
 
-    	gl_FragColor = diffuseSum / weightSum;
-    }
-  `,
+    '		if( ! rBreak ) {',
+    '			diffuseSum += texture2D( tDiffuse, sampleUv ) * sampleWeight;',
+    '			weightSum += sampleWeight;',
+    '		}',
+
+    '		sampleUv = vUv - sampleUvOffset;',
+    '		viewZ = -getViewZ( getDepth( sampleUv ) );',
+
+    '		if( abs( viewZ - centerViewZ ) > depthCutoff ) lBreak = true;',
+
+    '		if( ! lBreak ) {',
+    '			diffuseSum += texture2D( tDiffuse, sampleUv ) * sampleWeight;',
+    '			weightSum += sampleWeight;',
+    '		}',
+
+    '	}',
+
+    '	gl_FragColor = diffuseSum / weightSum;',
+    '}',
+  ].join('\n'),
 }
 
 export const BlurShaderUtils = {
diff --git a/src/shaders/DigitalGlitch.ts b/src/shaders/DigitalGlitch.ts
index c2244cf7..1a3ff844 100644
--- a/src/shaders/DigitalGlitch.ts
+++ b/src/shaders/DigitalGlitch.ts
@@ -13,72 +13,67 @@ export const DigitalGlitch = {
     col_s: { value: 0.05 },
   },
 
-  vertexShader: /* glsl */ `
-		varying vec2 vUv;
+  vertexShader: `varying vec2 vUv;
+     void main() {
+     	 vUv = uv;
+     	 gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+     }`,
 
-		void main() {
-			vUv = uv;
-			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
-		}
-	`,
+  fragmentShader: `uniform int byp; //should we apply the glitch ?
+     uniform sampler2D tDiffuse;
+     uniform sampler2D tDisp;
+     uniform float amount;
+     uniform float angle;
+     uniform float seed;
+     uniform float seed_x;
+     uniform float seed_y;
+     uniform float distortion_x;
+     uniform float distortion_y;
+     uniform float col_s;
 
-  fragmentShader: /* glsl */ `
-		uniform int byp; //should we apply the glitch ?
-		uniform sampler2D tDiffuse;
-		uniform sampler2D tDisp;
-		uniform float amount;
-		uniform float angle;
-		uniform float seed;
-		uniform float seed_x;
-		uniform float seed_y;
-		uniform float distortion_x;
-		uniform float distortion_y;
-		uniform float col_s;
+     varying vec2 vUv;
 
-		varying vec2 vUv;
+     float rand(vec2 co){
+     	 return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
+     }
 
-		float rand(vec2 co){
-			return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
-		}
-
-		void main() {
-			if(byp<1) {
-				vec2 p = vUv;
-				float xs = floor(gl_FragCoord.x / 0.5);
-				float ys = floor(gl_FragCoord.y / 0.5);
-		//based on staffantans glitch shader for unity https://github.com/staffantan/unityglitch
-				vec4 normal = texture2D (tDisp, p*seed*seed);
-				if(p.y<distortion_x+col_s && p.y>distortion_x-col_s*seed) {
-					if(seed_x>0.){
-						p.y = 1. - (p.y + distortion_y);
-					}
-					else {
-						p.y = distortion_y;
-					}
-				}
-				if(p.x<distortion_y+col_s && p.x>distortion_y-col_s*seed) {
-					if(seed_y>0.){
-						p.x=distortion_x;
-					}
-					else {
-						p.x = 1. - (p.x + distortion_x);
-					}
-				}
-				p.x+=normal.x*seed_x*(seed/5.);
-				p.y+=normal.y*seed_y*(seed/5.);
-		//base from RGB shift shader
-				vec2 offset = amount * vec2( cos(angle), sin(angle));
-				vec4 cr = texture2D(tDiffuse, p + offset);
-				vec4 cga = texture2D(tDiffuse, p);
-				vec4 cb = texture2D(tDiffuse, p - offset);
-				gl_FragColor = vec4(cr.r, cga.g, cb.b, cga.a);
-		//add noise
-				vec4 snow = 200.*amount*vec4(rand(vec2(xs * seed,ys * seed*50.))*0.2);
-				gl_FragColor = gl_FragColor+ snow;
-			}
-			else {
-				gl_FragColor=texture2D (tDiffuse, vUv);
-			}
-		}
-`,
+     void main() {
+     	if(byp<1) {
+     		vec2 p = vUv;
+     		float xs = floor(gl_FragCoord.x / 0.5);
+     		float ys = floor(gl_FragCoord.y / 0.5);
+    //based on staffantans glitch shader for unity https://github.com/staffantan/unityglitch
+     		vec4 normal = texture2D (tDisp, p*seed*seed);
+     		if(p.y<distortion_x+col_s && p.y>distortion_x-col_s*seed) {
+     			if(seed_x>0.){
+     				p.y = 1. - (p.y + distortion_y);
+     			}
+     			else {
+     				p.y = distortion_y;
+     			}
+     		}
+     		if(p.x<distortion_y+col_s && p.x>distortion_y-col_s*seed) {
+     			if(seed_y>0.){
+     				p.x=distortion_x;
+     			}
+     			else {
+     				p.x = 1. - (p.x + distortion_x);
+     			}
+     		}
+     		p.x+=normal.x*seed_x*(seed/5.);
+     		p.y+=normal.y*seed_y*(seed/5.);
+    //base from RGB shift shader
+     		vec2 offset = amount * vec2( cos(angle), sin(angle));
+     		vec4 cr = texture2D(tDiffuse, p + offset);
+     		vec4 cga = texture2D(tDiffuse, p);
+     		vec4 cb = texture2D(tDiffuse, p - offset);
+     		gl_FragColor = vec4(cr.r, cga.g, cb.b, cga.a);
+    //add noise
+     		vec4 snow = 200.*amount*vec4(rand(vec2(xs * seed,ys * seed*50.))*0.2);
+     		gl_FragColor = gl_FragColor+ snow;
+     	}
+     	else {
+     		gl_FragColor=texture2D (tDiffuse, vUv);
+     	}
+    }`,
 }
diff --git a/src/shaders/DotScreenShader.ts b/src/shaders/DotScreenShader.ts
index 83a205a8..aa01e7b1 100644
--- a/src/shaders/DotScreenShader.ts
+++ b/src/shaders/DotScreenShader.ts
@@ -9,52 +9,52 @@ import { Vector2 } from 'three'
 export const DotScreenShader = {
   uniforms: {
     tDiffuse: { value: null },
-    tSize: { value: /* @__PURE__ */ new Vector2(256, 256) },
-    center: { value: /* @__PURE__ */ new Vector2(0.5, 0.5) },
+    tSize: { value: new Vector2(256, 256) },
+    center: { value: new Vector2(0.5, 0.5) },
     angle: { value: 1.57 },
     scale: { value: 1.0 },
   },
 
-  vertexShader: /* glsl */ `
-    varying vec2 vUv;
+  vertexShader: [
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vUv = uv;
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    '	vUv = uv;',
+    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    uniform vec2 center;
-    uniform float angle;
-    uniform float scale;
-    uniform vec2 tSize;
+  fragmentShader: [
+    'uniform vec2 center;',
+    'uniform float angle;',
+    'uniform float scale;',
+    'uniform vec2 tSize;',
 
-    uniform sampler2D tDiffuse;
+    'uniform sampler2D tDiffuse;',
 
-    varying vec2 vUv;
+    'varying vec2 vUv;',
 
-    float pattern() {
+    'float pattern() {',
 
-    	float s = sin( angle ), c = cos( angle );
+    '	float s = sin( angle ), c = cos( angle );',
 
-    	vec2 tex = vUv * tSize - center;
-    	vec2 point = vec2( c * tex.x - s * tex.y, s * tex.x + c * tex.y ) * scale;
+    '	vec2 tex = vUv * tSize - center;',
+    '	vec2 point = vec2( c * tex.x - s * tex.y, s * tex.x + c * tex.y ) * scale;',
 
-    	return ( sin( point.x ) * sin( point.y ) ) * 4.0;
+    '	return ( sin( point.x ) * sin( point.y ) ) * 4.0;',
 
-    }
+    '}',
 
-    void main() {
+    'void main() {',
 
-    	vec4 color = texture2D( tDiffuse, vUv );
+    '	vec4 color = texture2D( tDiffuse, vUv );',
 
-    	float average = ( color.r + color.g + color.b ) / 3.0;
+    '	float average = ( color.r + color.g + color.b ) / 3.0;',
 
-    	gl_FragColor = vec4( vec3( average * 10.0 - 5.0 + pattern() ), color.a );
+    '	gl_FragColor = vec4( vec3( average * 10.0 - 5.0 + pattern() ), color.a );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 }
diff --git a/src/shaders/FXAAShader.ts b/src/shaders/FXAAShader.ts
index dbb313db..795b5677 100644
--- a/src/shaders/FXAAShader.ts
+++ b/src/shaders/FXAAShader.ts
@@ -10,1099 +10,1099 @@ import { Vector2 } from 'three'
 export const FXAAShader = {
   uniforms: {
     tDiffuse: { value: null },
-    resolution: { value: /* @__PURE__ */ new Vector2(1 / 1024, 1 / 512) },
+    resolution: { value: new Vector2(1 / 1024, 1 / 512) },
   },
 
-  vertexShader: /* glsl */ `
-    varying vec2 vUv;
+  vertexShader: [
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vUv = uv;
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    '	vUv = uv;',
+    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    precision highp float;
-    
-    uniform sampler2D tDiffuse;
-    
-    uniform vec2 resolution;
-    
-    varying vec2 vUv;
-    
-    // FXAA 3.11 implementation by NVIDIA, ported to WebGL by Agost Biro (biro@archilogic.com)
-    
-    //----------------------------------------------------------------------------------
-    // File:        es3-keplerFXAAassetsshaders/FXAA_DefaultES.frag
-    // SDK Version: v3.00
-    // Email:       gameworks@nvidia.com
-    // Site:        http://developer.nvidia.com/
-    //
-    // Copyright (c) 2014-2015, NVIDIA CORPORATION. All rights reserved.
-    //
-    // Redistribution and use in source and binary forms, with or without
-    // modification, are permitted provided that the following conditions
-    // are met:
-    //  * Redistributions of source code must retain the above copyright
-    //    notice, this list of conditions and the following disclaimer.
-    //  * Redistributions in binary form must reproduce the above copyright
-    //    notice, this list of conditions and the following disclaimer in the
-    //    documentation and/or other materials provided with the distribution.
-    //  * Neither the name of NVIDIA CORPORATION nor the names of its
-    //    contributors may be used to endorse or promote products derived
-    //    from this software without specific prior written permission.
-    //
-    "// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AS IS AND ANY",
-    // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-    // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-    // PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
-    // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-    // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-    // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-    // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
-    // OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-    // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-    // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-    //
-    //----------------------------------------------------------------------------------
-    
-    #define FXAA_PC 1
-    #define FXAA_GLSL_100 1
-    #define FXAA_QUALITY_PRESET 12
-    
-    #define FXAA_GREEN_AS_LUMA 1
-    
-    /*--------------------------------------------------------------------------*/
-    #ifndef FXAA_PC_CONSOLE
-        //
-        // The console algorithm for PC is included
-        // for developers targeting really low spec machines.
-        // Likely better to just run FXAA_PC, and use a really low preset.
-        //
-        #define FXAA_PC_CONSOLE 0
-    #endif
-    /*--------------------------------------------------------------------------*/
-    #ifndef FXAA_GLSL_120
-        #define FXAA_GLSL_120 0
-    #endif
-    /*--------------------------------------------------------------------------*/
-    #ifndef FXAA_GLSL_130
-        #define FXAA_GLSL_130 0
-    #endif
-    /*--------------------------------------------------------------------------*/
-    #ifndef FXAA_HLSL_3
-        #define FXAA_HLSL_3 0
-    #endif
-    /*--------------------------------------------------------------------------*/
-    #ifndef FXAA_HLSL_4
-        #define FXAA_HLSL_4 0
-    #endif
-    /*--------------------------------------------------------------------------*/
-    #ifndef FXAA_HLSL_5
-        #define FXAA_HLSL_5 0
-    #endif
-    /*==========================================================================*/
-    #ifndef FXAA_GREEN_AS_LUMA
-        //
-        // For those using non-linear color,
-        // and either not able to get luma in alpha, or not wanting to,
-        // this enables FXAA to run using green as a proxy for luma.
-        // So with this enabled, no need to pack luma in alpha.
-        //
-        // This will turn off AA on anything which lacks some amount of green.
-        // Pure red and blue or combination of only R and B, will get no AA.
-        //
-        // Might want to lower the settings for both,
-        //    fxaaConsoleEdgeThresholdMin
-        //    fxaaQualityEdgeThresholdMin
-        // In order to insure AA does not get turned off on colors
-        // which contain a minor amount of green.
-        //
-        // 1 = On.
-        // 0 = Off.
-        //
-        #define FXAA_GREEN_AS_LUMA 0
-    #endif
-    /*--------------------------------------------------------------------------*/
-    #ifndef FXAA_EARLY_EXIT
-        //
-    "    // Controls algorithms early exit path.",
-        // On PS3 turning this ON adds 2 cycles to the shader.
-        // On 360 turning this OFF adds 10ths of a millisecond to the shader.
-        // Turning this off on console will result in a more blurry image.
-        // So this defaults to on.
-        //
-        // 1 = On.
-        // 0 = Off.
-        //
-        #define FXAA_EARLY_EXIT 1
-    #endif
-    /*--------------------------------------------------------------------------*/
-    #ifndef FXAA_DISCARD
-        //
-        // Only valid for PC OpenGL currently.
-        // Probably will not work when FXAA_GREEN_AS_LUMA = 1.
-        //
-    "    // 1 = Use discard on pixels which dont need AA.",
-        //     For APIs which enable concurrent TEX+ROP from same surface.
-    "    // 0 = Return unchanged color on pixels which dont need AA.",
-        //
-        #define FXAA_DISCARD 0
-    #endif
-    /*--------------------------------------------------------------------------*/
-    #ifndef FXAA_FAST_PIXEL_OFFSET
-        //
-        // Used for GLSL 120 only.
-        //
-        // 1 = GL API supports fast pixel offsets
-        // 0 = do not use fast pixel offsets
-        //
-        #ifdef GL_EXT_gpu_shader4
-            #define FXAA_FAST_PIXEL_OFFSET 1
-        #endif
-        #ifdef GL_NV_gpu_shader5
-            #define FXAA_FAST_PIXEL_OFFSET 1
-        #endif
-        #ifdef GL_ARB_gpu_shader5
-            #define FXAA_FAST_PIXEL_OFFSET 1
-        #endif
-        #ifndef FXAA_FAST_PIXEL_OFFSET
-            #define FXAA_FAST_PIXEL_OFFSET 0
-        #endif
-    #endif
-    /*--------------------------------------------------------------------------*/
-    #ifndef FXAA_GATHER4_ALPHA
-        //
-        // 1 = API supports gather4 on alpha channel.
-        // 0 = API does not support gather4 on alpha channel.
-        //
-        #if (FXAA_HLSL_5 == 1)
-            #define FXAA_GATHER4_ALPHA 1
-        #endif
-        #ifdef GL_ARB_gpu_shader5
-            #define FXAA_GATHER4_ALPHA 1
-        #endif
-        #ifdef GL_NV_gpu_shader5
-            #define FXAA_GATHER4_ALPHA 1
-        #endif
-        #ifndef FXAA_GATHER4_ALPHA
-            #define FXAA_GATHER4_ALPHA 0
-        #endif
-    #endif
-    
-    
-    /*============================================================================
-                            FXAA QUALITY - TUNING KNOBS
-    ------------------------------------------------------------------------------
-    NOTE the other tuning knobs are now in the shader function inputs!
-    ============================================================================*/
-    #ifndef FXAA_QUALITY_PRESET
-        //
-        // Choose the quality preset.
-        // This needs to be compiled into the shader as it effects code.
-        // Best option to include multiple presets is to
-        // in each shader define the preset, then include this file.
-        //
-        // OPTIONS
-        // -----------------------------------------------------------------------
-        // 10 to 15 - default medium dither (10=fastest, 15=highest quality)
-        // 20 to 29 - less dither, more expensive (20=fastest, 29=highest quality)
-        // 39       - no dither, very expensive
-        //
-        // NOTES
-        // -----------------------------------------------------------------------
-        // 12 = slightly faster then FXAA 3.9 and higher edge quality (default)
-        // 13 = about same speed as FXAA 3.9 and better than 12
-        // 23 = closest to FXAA 3.9 visually and performance wise
-        //  _ = the lowest digit is directly related to performance
-        // _  = the highest digit is directly related to style
-        //
-        #define FXAA_QUALITY_PRESET 12
-    #endif
-    
-    
-    /*============================================================================
-    
-                               FXAA QUALITY - PRESETS
-    
-    ============================================================================*/
-    
-    /*============================================================================
-                         FXAA QUALITY - MEDIUM DITHER PRESETS
-    ============================================================================*/
-    #if (FXAA_QUALITY_PRESET == 10)
-        #define FXAA_QUALITY_PS 3
-        #define FXAA_QUALITY_P0 1.5
-        #define FXAA_QUALITY_P1 3.0
-        #define FXAA_QUALITY_P2 12.0
-    #endif
-    /*--------------------------------------------------------------------------*/
-    #if (FXAA_QUALITY_PRESET == 11)
-        #define FXAA_QUALITY_PS 4
-        #define FXAA_QUALITY_P0 1.0
-        #define FXAA_QUALITY_P1 1.5
-        #define FXAA_QUALITY_P2 3.0
-        #define FXAA_QUALITY_P3 12.0
-    #endif
-    /*--------------------------------------------------------------------------*/
-    #if (FXAA_QUALITY_PRESET == 12)
-        #define FXAA_QUALITY_PS 5
-        #define FXAA_QUALITY_P0 1.0
-        #define FXAA_QUALITY_P1 1.5
-        #define FXAA_QUALITY_P2 2.0
-        #define FXAA_QUALITY_P3 4.0
-        #define FXAA_QUALITY_P4 12.0
-    #endif
-    /*--------------------------------------------------------------------------*/
-    #if (FXAA_QUALITY_PRESET == 13)
-        #define FXAA_QUALITY_PS 6
-        #define FXAA_QUALITY_P0 1.0
-        #define FXAA_QUALITY_P1 1.5
-        #define FXAA_QUALITY_P2 2.0
-        #define FXAA_QUALITY_P3 2.0
-        #define FXAA_QUALITY_P4 4.0
-        #define FXAA_QUALITY_P5 12.0
-    #endif
-    /*--------------------------------------------------------------------------*/
-    #if (FXAA_QUALITY_PRESET == 14)
-        #define FXAA_QUALITY_PS 7
-        #define FXAA_QUALITY_P0 1.0
-        #define FXAA_QUALITY_P1 1.5
-        #define FXAA_QUALITY_P2 2.0
-        #define FXAA_QUALITY_P3 2.0
-        #define FXAA_QUALITY_P4 2.0
-        #define FXAA_QUALITY_P5 4.0
-        #define FXAA_QUALITY_P6 12.0
-    #endif
-    /*--------------------------------------------------------------------------*/
-    #if (FXAA_QUALITY_PRESET == 15)
-        #define FXAA_QUALITY_PS 8
-        #define FXAA_QUALITY_P0 1.0
-        #define FXAA_QUALITY_P1 1.5
-        #define FXAA_QUALITY_P2 2.0
-        #define FXAA_QUALITY_P3 2.0
-        #define FXAA_QUALITY_P4 2.0
-        #define FXAA_QUALITY_P5 2.0
-        #define FXAA_QUALITY_P6 4.0
-        #define FXAA_QUALITY_P7 12.0
-    #endif
-    
-    /*============================================================================
-                         FXAA QUALITY - LOW DITHER PRESETS
-    ============================================================================*/
-    #if (FXAA_QUALITY_PRESET == 20)
-        #define FXAA_QUALITY_PS 3
-        #define FXAA_QUALITY_P0 1.5
-        #define FXAA_QUALITY_P1 2.0
-        #define FXAA_QUALITY_P2 8.0
-    #endif
-    /*--------------------------------------------------------------------------*/
-    #if (FXAA_QUALITY_PRESET == 21)
-        #define FXAA_QUALITY_PS 4
-        #define FXAA_QUALITY_P0 1.0
-        #define FXAA_QUALITY_P1 1.5
-        #define FXAA_QUALITY_P2 2.0
-        #define FXAA_QUALITY_P3 8.0
-    #endif
-    /*--------------------------------------------------------------------------*/
-    #if (FXAA_QUALITY_PRESET == 22)
-        #define FXAA_QUALITY_PS 5
-        #define FXAA_QUALITY_P0 1.0
-        #define FXAA_QUALITY_P1 1.5
-        #define FXAA_QUALITY_P2 2.0
-        #define FXAA_QUALITY_P3 2.0
-        #define FXAA_QUALITY_P4 8.0
-    #endif
-    /*--------------------------------------------------------------------------*/
-    #if (FXAA_QUALITY_PRESET == 23)
-        #define FXAA_QUALITY_PS 6
-        #define FXAA_QUALITY_P0 1.0
-        #define FXAA_QUALITY_P1 1.5
-        #define FXAA_QUALITY_P2 2.0
-        #define FXAA_QUALITY_P3 2.0
-        #define FXAA_QUALITY_P4 2.0
-        #define FXAA_QUALITY_P5 8.0
-    #endif
-    /*--------------------------------------------------------------------------*/
-    #if (FXAA_QUALITY_PRESET == 24)
-        #define FXAA_QUALITY_PS 7
-        #define FXAA_QUALITY_P0 1.0
-        #define FXAA_QUALITY_P1 1.5
-        #define FXAA_QUALITY_P2 2.0
-        #define FXAA_QUALITY_P3 2.0
-        #define FXAA_QUALITY_P4 2.0
-        #define FXAA_QUALITY_P5 3.0
-        #define FXAA_QUALITY_P6 8.0
-    #endif
-    /*--------------------------------------------------------------------------*/
-    #if (FXAA_QUALITY_PRESET == 25)
-        #define FXAA_QUALITY_PS 8
-        #define FXAA_QUALITY_P0 1.0
-        #define FXAA_QUALITY_P1 1.5
-        #define FXAA_QUALITY_P2 2.0
-        #define FXAA_QUALITY_P3 2.0
-        #define FXAA_QUALITY_P4 2.0
-        #define FXAA_QUALITY_P5 2.0
-        #define FXAA_QUALITY_P6 4.0
-        #define FXAA_QUALITY_P7 8.0
-    #endif
-    /*--------------------------------------------------------------------------*/
-    #if (FXAA_QUALITY_PRESET == 26)
-        #define FXAA_QUALITY_PS 9
-        #define FXAA_QUALITY_P0 1.0
-        #define FXAA_QUALITY_P1 1.5
-        #define FXAA_QUALITY_P2 2.0
-        #define FXAA_QUALITY_P3 2.0
-        #define FXAA_QUALITY_P4 2.0
-        #define FXAA_QUALITY_P5 2.0
-        #define FXAA_QUALITY_P6 2.0
-        #define FXAA_QUALITY_P7 4.0
-        #define FXAA_QUALITY_P8 8.0
-    #endif
-    /*--------------------------------------------------------------------------*/
-    #if (FXAA_QUALITY_PRESET == 27)
-        #define FXAA_QUALITY_PS 10
-        #define FXAA_QUALITY_P0 1.0
-        #define FXAA_QUALITY_P1 1.5
-        #define FXAA_QUALITY_P2 2.0
-        #define FXAA_QUALITY_P3 2.0
-        #define FXAA_QUALITY_P4 2.0
-        #define FXAA_QUALITY_P5 2.0
-        #define FXAA_QUALITY_P6 2.0
-        #define FXAA_QUALITY_P7 2.0
-        #define FXAA_QUALITY_P8 4.0
-        #define FXAA_QUALITY_P9 8.0
-    #endif
-    /*--------------------------------------------------------------------------*/
-    #if (FXAA_QUALITY_PRESET == 28)
-        #define FXAA_QUALITY_PS 11
-        #define FXAA_QUALITY_P0 1.0
-        #define FXAA_QUALITY_P1 1.5
-        #define FXAA_QUALITY_P2 2.0
-        #define FXAA_QUALITY_P3 2.0
-        #define FXAA_QUALITY_P4 2.0
-        #define FXAA_QUALITY_P5 2.0
-        #define FXAA_QUALITY_P6 2.0
-        #define FXAA_QUALITY_P7 2.0
-        #define FXAA_QUALITY_P8 2.0
-        #define FXAA_QUALITY_P9 4.0
-        #define FXAA_QUALITY_P10 8.0
-    #endif
-    /*--------------------------------------------------------------------------*/
-    #if (FXAA_QUALITY_PRESET == 29)
-        #define FXAA_QUALITY_PS 12
-        #define FXAA_QUALITY_P0 1.0
-        #define FXAA_QUALITY_P1 1.5
-        #define FXAA_QUALITY_P2 2.0
-        #define FXAA_QUALITY_P3 2.0
-        #define FXAA_QUALITY_P4 2.0
-        #define FXAA_QUALITY_P5 2.0
-        #define FXAA_QUALITY_P6 2.0
-        #define FXAA_QUALITY_P7 2.0
-        #define FXAA_QUALITY_P8 2.0
-        #define FXAA_QUALITY_P9 2.0
-        #define FXAA_QUALITY_P10 4.0
-        #define FXAA_QUALITY_P11 8.0
-    #endif
-    
-    /*============================================================================
-                         FXAA QUALITY - EXTREME QUALITY
-    ============================================================================*/
-    #if (FXAA_QUALITY_PRESET == 39)
-        #define FXAA_QUALITY_PS 12
-        #define FXAA_QUALITY_P0 1.0
-        #define FXAA_QUALITY_P1 1.0
-        #define FXAA_QUALITY_P2 1.0
-        #define FXAA_QUALITY_P3 1.0
-        #define FXAA_QUALITY_P4 1.0
-        #define FXAA_QUALITY_P5 1.5
-        #define FXAA_QUALITY_P6 2.0
-        #define FXAA_QUALITY_P7 2.0
-        #define FXAA_QUALITY_P8 2.0
-        #define FXAA_QUALITY_P9 2.0
-        #define FXAA_QUALITY_P10 4.0
-        #define FXAA_QUALITY_P11 8.0
-    #endif
-    
-    
-    
-    /*============================================================================
-    
-                                    API PORTING
-    
-    ============================================================================*/
-    #if (FXAA_GLSL_100 == 1) || (FXAA_GLSL_120 == 1) || (FXAA_GLSL_130 == 1)
-        #define FxaaBool bool
-        #define FxaaDiscard discard
-        #define FxaaFloat float
-        #define FxaaFloat2 vec2
-        #define FxaaFloat3 vec3
-        #define FxaaFloat4 vec4
-        #define FxaaHalf float
-        #define FxaaHalf2 vec2
-        #define FxaaHalf3 vec3
-        #define FxaaHalf4 vec4
-        #define FxaaInt2 ivec2
-        #define FxaaSat(x) clamp(x, 0.0, 1.0)
-        #define FxaaTex sampler2D
-    #else
-        #define FxaaBool bool
-        #define FxaaDiscard clip(-1)
-        #define FxaaFloat float
-        #define FxaaFloat2 float2
-        #define FxaaFloat3 float3
-        #define FxaaFloat4 float4
-        #define FxaaHalf half
-        #define FxaaHalf2 half2
-        #define FxaaHalf3 half3
-        #define FxaaHalf4 half4
-        #define FxaaSat(x) saturate(x)
-    #endif
-    /*--------------------------------------------------------------------------*/
-    #if (FXAA_GLSL_100 == 1)
-      #define FxaaTexTop(t, p) texture2D(t, p, 0.0)
-      #define FxaaTexOff(t, p, o, r) texture2D(t, p + (o * r), 0.0)
-    #endif
-    /*--------------------------------------------------------------------------*/
-    #if (FXAA_GLSL_120 == 1)
-        // Requires,
-        //  #version 120
-        // And at least,
-        //  #extension GL_EXT_gpu_shader4 : enable
-        //  (or set FXAA_FAST_PIXEL_OFFSET 1 to work like DX9)
-        #define FxaaTexTop(t, p) texture2DLod(t, p, 0.0)
-        #if (FXAA_FAST_PIXEL_OFFSET == 1)
-            #define FxaaTexOff(t, p, o, r) texture2DLodOffset(t, p, 0.0, o)
-        #else
-            #define FxaaTexOff(t, p, o, r) texture2DLod(t, p + (o * r), 0.0)
-        #endif
-        #if (FXAA_GATHER4_ALPHA == 1)
-            // use #extension GL_ARB_gpu_shader5 : enable
-            #define FxaaTexAlpha4(t, p) textureGather(t, p, 3)
-            #define FxaaTexOffAlpha4(t, p, o) textureGatherOffset(t, p, o, 3)
-            #define FxaaTexGreen4(t, p) textureGather(t, p, 1)
-            #define FxaaTexOffGreen4(t, p, o) textureGatherOffset(t, p, o, 1)
-        #endif
-    #endif
-    /*--------------------------------------------------------------------------*/
-    #if (FXAA_GLSL_130 == 1)
-        // Requires "#version 130" or better
-        #define FxaaTexTop(t, p) textureLod(t, p, 0.0)
-        #define FxaaTexOff(t, p, o, r) textureLodOffset(t, p, 0.0, o)
-        #if (FXAA_GATHER4_ALPHA == 1)
-            // use #extension GL_ARB_gpu_shader5 : enable
-            #define FxaaTexAlpha4(t, p) textureGather(t, p, 3)
-            #define FxaaTexOffAlpha4(t, p, o) textureGatherOffset(t, p, o, 3)
-            #define FxaaTexGreen4(t, p) textureGather(t, p, 1)
-            #define FxaaTexOffGreen4(t, p, o) textureGatherOffset(t, p, o, 1)
-        #endif
-    #endif
-    /*--------------------------------------------------------------------------*/
-    #if (FXAA_HLSL_3 == 1)
-        #define FxaaInt2 float2
-        #define FxaaTex sampler2D
-        #define FxaaTexTop(t, p) tex2Dlod(t, float4(p, 0.0, 0.0))
-        #define FxaaTexOff(t, p, o, r) tex2Dlod(t, float4(p + (o * r), 0, 0))
-    #endif
-    /*--------------------------------------------------------------------------*/
-    #if (FXAA_HLSL_4 == 1)
-        #define FxaaInt2 int2
-        struct FxaaTex { SamplerState smpl; Texture2D tex; };
-        #define FxaaTexTop(t, p) t.tex.SampleLevel(t.smpl, p, 0.0)
-        #define FxaaTexOff(t, p, o, r) t.tex.SampleLevel(t.smpl, p, 0.0, o)
-    #endif
-    /*--------------------------------------------------------------------------*/
-    #if (FXAA_HLSL_5 == 1)
-        #define FxaaInt2 int2
-        struct FxaaTex { SamplerState smpl; Texture2D tex; };
-        #define FxaaTexTop(t, p) t.tex.SampleLevel(t.smpl, p, 0.0)
-        #define FxaaTexOff(t, p, o, r) t.tex.SampleLevel(t.smpl, p, 0.0, o)
-        #define FxaaTexAlpha4(t, p) t.tex.GatherAlpha(t.smpl, p)
-        #define FxaaTexOffAlpha4(t, p, o) t.tex.GatherAlpha(t.smpl, p, o)
-        #define FxaaTexGreen4(t, p) t.tex.GatherGreen(t.smpl, p)
-        #define FxaaTexOffGreen4(t, p, o) t.tex.GatherGreen(t.smpl, p, o)
-    #endif
-    
-    
-    /*============================================================================
-                       GREEN AS LUMA OPTION SUPPORT FUNCTION
-    ============================================================================*/
-    #if (FXAA_GREEN_AS_LUMA == 0)
-        FxaaFloat FxaaLuma(FxaaFloat4 rgba) { return rgba.w; }
-    #else
-        FxaaFloat FxaaLuma(FxaaFloat4 rgba) { return rgba.y; }
-    #endif
-    
-    
-    
-    
-    /*============================================================================
-    
-                                 FXAA3 QUALITY - PC
-    
-    ============================================================================*/
-    #if (FXAA_PC == 1)
-    /*--------------------------------------------------------------------------*/
-    FxaaFloat4 FxaaPixelShader(
-        //
-        // Use noperspective interpolation here (turn off perspective interpolation).
-        // {xy} = center of pixel
-        FxaaFloat2 pos,
-        //
-        // Used only for FXAA Console, and not used on the 360 version.
-        // Use noperspective interpolation here (turn off perspective interpolation).
-        // {xy_} = upper left of pixel
-        // {_zw} = lower right of pixel
-        FxaaFloat4 fxaaConsolePosPos,
-        //
-        // Input color texture.
-        // {rgb_} = color in linear or perceptual color space
-        // if (FXAA_GREEN_AS_LUMA == 0)
-        //     {__a} = luma in perceptual color space (not linear)
-        FxaaTex tex,
-        //
-        // Only used on the optimized 360 version of FXAA Console.
-        // For everything but 360, just use the same input here as for "tex".
-        // For 360, same texture, just alias with a 2nd sampler.
-        // This sampler needs to have an exponent bias of -1.
-        FxaaTex fxaaConsole360TexExpBiasNegOne,
-        //
-        // Only used on the optimized 360 version of FXAA Console.
-        // For everything but 360, just use the same input here as for "tex".
-        // For 360, same texture, just alias with a 3nd sampler.
-        // This sampler needs to have an exponent bias of -2.
-        FxaaTex fxaaConsole360TexExpBiasNegTwo,
-        //
-        // Only used on FXAA Quality.
-        // This must be from a constant/uniform.
-        // {x_} = 1.0/screenWidthInPixels
-        // {_y} = 1.0/screenHeightInPixels
-        FxaaFloat2 fxaaQualityRcpFrame,
-        //
-        // Only used on FXAA Console.
-        // This must be from a constant/uniform.
-        // This effects sub-pixel AA quality and inversely sharpness.
-        //   Where N ranges between,
-        //     N = 0.50 (default)
-        //     N = 0.33 (sharper)
-        // {x__} = -N/screenWidthInPixels
-        // {_y_} = -N/screenHeightInPixels
-        // {_z_} =  N/screenWidthInPixels
-        // {__w} =  N/screenHeightInPixels
-        FxaaFloat4 fxaaConsoleRcpFrameOpt,
-        //
-        // Only used on FXAA Console.
-        // Not used on 360, but used on PS3 and PC.
-        // This must be from a constant/uniform.
-        // {x__} = -2.0/screenWidthInPixels
-        // {_y_} = -2.0/screenHeightInPixels
-        // {_z_} =  2.0/screenWidthInPixels
-        // {__w} =  2.0/screenHeightInPixels
-        FxaaFloat4 fxaaConsoleRcpFrameOpt2,
-        //
-        // Only used on FXAA Console.
-        // Only used on 360 in place of fxaaConsoleRcpFrameOpt2.
-        // This must be from a constant/uniform.
-        // {x__} =  8.0/screenWidthInPixels
-        // {_y_} =  8.0/screenHeightInPixels
-        // {_z_} = -4.0/screenWidthInPixels
-        // {__w} = -4.0/screenHeightInPixels
-        FxaaFloat4 fxaaConsole360RcpFrameOpt2,
-        //
-        // Only used on FXAA Quality.
-        // This used to be the FXAA_QUALITY_SUBPIX define.
-        // It is here now to allow easier tuning.
-        // Choose the amount of sub-pixel aliasing removal.
-        // This can effect sharpness.
-        //   1.00 - upper limit (softer)
-        //   0.75 - default amount of filtering
-        //   0.50 - lower limit (sharper, less sub-pixel aliasing removal)
-        //   0.25 - almost off
-        //   0.00 - completely off
-        FxaaFloat fxaaQualitySubpix,
-        //
-        // Only used on FXAA Quality.
-        // This used to be the FXAA_QUALITY_EDGE_THRESHOLD define.
-        // It is here now to allow easier tuning.
-        // The minimum amount of local contrast required to apply algorithm.
-        //   0.333 - too little (faster)
-        //   0.250 - low quality
-        //   0.166 - default
-        //   0.125 - high quality
-        //   0.063 - overkill (slower)
-        FxaaFloat fxaaQualityEdgeThreshold,
-        //
-        // Only used on FXAA Quality.
-        // This used to be the FXAA_QUALITY_EDGE_THRESHOLD_MIN define.
-        // It is here now to allow easier tuning.
-        // Trims the algorithm from processing darks.
-        //   0.0833 - upper limit (default, the start of visible unfiltered edges)
-        //   0.0625 - high quality (faster)
-        //   0.0312 - visible limit (slower)
-        // Special notes when using FXAA_GREEN_AS_LUMA,
-        //   Likely want to set this to zero.
-        //   As colors that are mostly not-green
-        //   will appear very dark in the green channel!
-        //   Tune by looking at mostly non-green content,
-        //   then start at zero and increase until aliasing is a problem.
-        FxaaFloat fxaaQualityEdgeThresholdMin,
-        //
-        // Only used on FXAA Console.
-        // This used to be the FXAA_CONSOLE_EDGE_SHARPNESS define.
-        // It is here now to allow easier tuning.
-        // This does not effect PS3, as this needs to be compiled in.
-        //   Use FXAA_CONSOLE_PS3_EDGE_SHARPNESS for PS3.
-        //   Due to the PS3 being ALU bound,
-        //   there are only three safe values here: 2 and 4 and 8.
-        //   These options use the shaders ability to a free *|/ by 2|4|8.
-        // For all other platforms can be a non-power of two.
-        //   8.0 is sharper (default!!!)
-        //   4.0 is softer
-        //   2.0 is really soft (good only for vector graphics inputs)
-        FxaaFloat fxaaConsoleEdgeSharpness,
-        //
-        // Only used on FXAA Console.
-        // This used to be the FXAA_CONSOLE_EDGE_THRESHOLD define.
-        // It is here now to allow easier tuning.
-        // This does not effect PS3, as this needs to be compiled in.
-        //   Use FXAA_CONSOLE_PS3_EDGE_THRESHOLD for PS3.
-        //   Due to the PS3 being ALU bound,
-        //   there are only two safe values here: 1/4 and 1/8.
-        //   These options use the shaders ability to a free *|/ by 2|4|8.
-        // The console setting has a different mapping than the quality setting.
-        // Other platforms can use other values.
-        //   0.125 leaves less aliasing, but is softer (default!!!)
-        //   0.25 leaves more aliasing, and is sharper
-        FxaaFloat fxaaConsoleEdgeThreshold,
-        //
-        // Only used on FXAA Console.
-        // This used to be the FXAA_CONSOLE_EDGE_THRESHOLD_MIN define.
-        // It is here now to allow easier tuning.
-        // Trims the algorithm from processing darks.
-        // The console setting has a different mapping than the quality setting.
-        // This only applies when FXAA_EARLY_EXIT is 1.
-        // This does not apply to PS3,
-        // PS3 was simplified to avoid more shader instructions.
-        //   0.06 - faster but more aliasing in darks
-        //   0.05 - default
-        //   0.04 - slower and less aliasing in darks
-        // Special notes when using FXAA_GREEN_AS_LUMA,
-        //   Likely want to set this to zero.
-        //   As colors that are mostly not-green
-        //   will appear very dark in the green channel!
-        //   Tune by looking at mostly non-green content,
-        //   then start at zero and increase until aliasing is a problem.
-        FxaaFloat fxaaConsoleEdgeThresholdMin,
-        //
-        // Extra constants for 360 FXAA Console only.
-        // Use zeros or anything else for other platforms.
-        // These must be in physical constant registers and NOT immediates.
-        // Immediates will result in compiler un-optimizing.
-        // {xyzw} = float4(1.0, -1.0, 0.25, -0.25)
-        FxaaFloat4 fxaaConsole360ConstDir
-    ) {
-    /*--------------------------------------------------------------------------*/
-        FxaaFloat2 posM;
-        posM.x = pos.x;
-        posM.y = pos.y;
-        #if (FXAA_GATHER4_ALPHA == 1)
-            #if (FXAA_DISCARD == 0)
-                FxaaFloat4 rgbyM = FxaaTexTop(tex, posM);
-                #if (FXAA_GREEN_AS_LUMA == 0)
-                    #define lumaM rgbyM.w
-                #else
-                    #define lumaM rgbyM.y
-                #endif
-            #endif
-            #if (FXAA_GREEN_AS_LUMA == 0)
-                FxaaFloat4 luma4A = FxaaTexAlpha4(tex, posM);
-                FxaaFloat4 luma4B = FxaaTexOffAlpha4(tex, posM, FxaaInt2(-1, -1));
-            #else
-                FxaaFloat4 luma4A = FxaaTexGreen4(tex, posM);
-                FxaaFloat4 luma4B = FxaaTexOffGreen4(tex, posM, FxaaInt2(-1, -1));
-            #endif
-            #if (FXAA_DISCARD == 1)
-                #define lumaM luma4A.w
-            #endif
-            #define lumaE luma4A.z
-            #define lumaS luma4A.x
-            #define lumaSE luma4A.y
-            #define lumaNW luma4B.w
-            #define lumaN luma4B.z
-            #define lumaW luma4B.x
-        #else
-            FxaaFloat4 rgbyM = FxaaTexTop(tex, posM);
-            #if (FXAA_GREEN_AS_LUMA == 0)
-                #define lumaM rgbyM.w
-            #else
-                #define lumaM rgbyM.y
-            #endif
-            #if (FXAA_GLSL_100 == 1)
-              FxaaFloat lumaS = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2( 0.0, 1.0), fxaaQualityRcpFrame.xy));
-              FxaaFloat lumaE = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2( 1.0, 0.0), fxaaQualityRcpFrame.xy));
-              FxaaFloat lumaN = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2( 0.0,-1.0), fxaaQualityRcpFrame.xy));
-              FxaaFloat lumaW = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2(-1.0, 0.0), fxaaQualityRcpFrame.xy));
-            #else
-              FxaaFloat lumaS = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 0, 1), fxaaQualityRcpFrame.xy));
-              FxaaFloat lumaE = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 1, 0), fxaaQualityRcpFrame.xy));
-              FxaaFloat lumaN = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 0,-1), fxaaQualityRcpFrame.xy));
-              FxaaFloat lumaW = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(-1, 0), fxaaQualityRcpFrame.xy));
-            #endif
-        #endif
-    /*--------------------------------------------------------------------------*/
-        FxaaFloat maxSM = max(lumaS, lumaM);
-        FxaaFloat minSM = min(lumaS, lumaM);
-        FxaaFloat maxESM = max(lumaE, maxSM);
-        FxaaFloat minESM = min(lumaE, minSM);
-        FxaaFloat maxWN = max(lumaN, lumaW);
-        FxaaFloat minWN = min(lumaN, lumaW);
-        FxaaFloat rangeMax = max(maxWN, maxESM);
-        FxaaFloat rangeMin = min(minWN, minESM);
-        FxaaFloat rangeMaxScaled = rangeMax * fxaaQualityEdgeThreshold;
-        FxaaFloat range = rangeMax - rangeMin;
-        FxaaFloat rangeMaxClamped = max(fxaaQualityEdgeThresholdMin, rangeMaxScaled);
-        FxaaBool earlyExit = range < rangeMaxClamped;
-    /*--------------------------------------------------------------------------*/
-        if(earlyExit)
-            #if (FXAA_DISCARD == 1)
-                FxaaDiscard;
-            #else
-                return rgbyM;
-            #endif
-    /*--------------------------------------------------------------------------*/
-        #if (FXAA_GATHER4_ALPHA == 0)
-            #if (FXAA_GLSL_100 == 1)
-              FxaaFloat lumaNW = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2(-1.0,-1.0), fxaaQualityRcpFrame.xy));
-              FxaaFloat lumaSE = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2( 1.0, 1.0), fxaaQualityRcpFrame.xy));
-              FxaaFloat lumaNE = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2( 1.0,-1.0), fxaaQualityRcpFrame.xy));
-              FxaaFloat lumaSW = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2(-1.0, 1.0), fxaaQualityRcpFrame.xy));
-            #else
-              FxaaFloat lumaNW = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(-1,-1), fxaaQualityRcpFrame.xy));
-              FxaaFloat lumaSE = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 1, 1), fxaaQualityRcpFrame.xy));
-              FxaaFloat lumaNE = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 1,-1), fxaaQualityRcpFrame.xy));
-              FxaaFloat lumaSW = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(-1, 1), fxaaQualityRcpFrame.xy));
-            #endif
-        #else
-            FxaaFloat lumaNE = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(1, -1), fxaaQualityRcpFrame.xy));
-            FxaaFloat lumaSW = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(-1, 1), fxaaQualityRcpFrame.xy));
-        #endif
-    /*--------------------------------------------------------------------------*/
-        FxaaFloat lumaNS = lumaN + lumaS;
-        FxaaFloat lumaWE = lumaW + lumaE;
-        FxaaFloat subpixRcpRange = 1.0/range;
-        FxaaFloat subpixNSWE = lumaNS + lumaWE;
-        FxaaFloat edgeHorz1 = (-2.0 * lumaM) + lumaNS;
-        FxaaFloat edgeVert1 = (-2.0 * lumaM) + lumaWE;
-    /*--------------------------------------------------------------------------*/
-        FxaaFloat lumaNESE = lumaNE + lumaSE;
-        FxaaFloat lumaNWNE = lumaNW + lumaNE;
-        FxaaFloat edgeHorz2 = (-2.0 * lumaE) + lumaNESE;
-        FxaaFloat edgeVert2 = (-2.0 * lumaN) + lumaNWNE;
-    /*--------------------------------------------------------------------------*/
-        FxaaFloat lumaNWSW = lumaNW + lumaSW;
-        FxaaFloat lumaSWSE = lumaSW + lumaSE;
-        FxaaFloat edgeHorz4 = (abs(edgeHorz1) * 2.0) + abs(edgeHorz2);
-        FxaaFloat edgeVert4 = (abs(edgeVert1) * 2.0) + abs(edgeVert2);
-        FxaaFloat edgeHorz3 = (-2.0 * lumaW) + lumaNWSW;
-        FxaaFloat edgeVert3 = (-2.0 * lumaS) + lumaSWSE;
-        FxaaFloat edgeHorz = abs(edgeHorz3) + edgeHorz4;
-        FxaaFloat edgeVert = abs(edgeVert3) + edgeVert4;
-    /*--------------------------------------------------------------------------*/
-        FxaaFloat subpixNWSWNESE = lumaNWSW + lumaNESE;
-        FxaaFloat lengthSign = fxaaQualityRcpFrame.x;
-        FxaaBool horzSpan = edgeHorz >= edgeVert;
-        FxaaFloat subpixA = subpixNSWE * 2.0 + subpixNWSWNESE;
-    /*--------------------------------------------------------------------------*/
-        if(!horzSpan) lumaN = lumaW;
-        if(!horzSpan) lumaS = lumaE;
-        if(horzSpan) lengthSign = fxaaQualityRcpFrame.y;
-        FxaaFloat subpixB = (subpixA * (1.0/12.0)) - lumaM;
-    /*--------------------------------------------------------------------------*/
-        FxaaFloat gradientN = lumaN - lumaM;
-        FxaaFloat gradientS = lumaS - lumaM;
-        FxaaFloat lumaNN = lumaN + lumaM;
-        FxaaFloat lumaSS = lumaS + lumaM;
-        FxaaBool pairN = abs(gradientN) >= abs(gradientS);
-        FxaaFloat gradient = max(abs(gradientN), abs(gradientS));
-        if(pairN) lengthSign = -lengthSign;
-        FxaaFloat subpixC = FxaaSat(abs(subpixB) * subpixRcpRange);
-    /*--------------------------------------------------------------------------*/
-        FxaaFloat2 posB;
-        posB.x = posM.x;
-        posB.y = posM.y;
-        FxaaFloat2 offNP;
-        offNP.x = (!horzSpan) ? 0.0 : fxaaQualityRcpFrame.x;
-        offNP.y = ( horzSpan) ? 0.0 : fxaaQualityRcpFrame.y;
-        if(!horzSpan) posB.x += lengthSign * 0.5;
-        if( horzSpan) posB.y += lengthSign * 0.5;
-    /*--------------------------------------------------------------------------*/
-        FxaaFloat2 posN;
-        posN.x = posB.x - offNP.x * FXAA_QUALITY_P0;
-        posN.y = posB.y - offNP.y * FXAA_QUALITY_P0;
-        FxaaFloat2 posP;
-        posP.x = posB.x + offNP.x * FXAA_QUALITY_P0;
-        posP.y = posB.y + offNP.y * FXAA_QUALITY_P0;
-        FxaaFloat subpixD = ((-2.0)*subpixC) + 3.0;
-        FxaaFloat lumaEndN = FxaaLuma(FxaaTexTop(tex, posN));
-        FxaaFloat subpixE = subpixC * subpixC;
-        FxaaFloat lumaEndP = FxaaLuma(FxaaTexTop(tex, posP));
-    /*--------------------------------------------------------------------------*/
-        if(!pairN) lumaNN = lumaSS;
-        FxaaFloat gradientScaled = gradient * 1.0/4.0;
-        FxaaFloat lumaMM = lumaM - lumaNN * 0.5;
-        FxaaFloat subpixF = subpixD * subpixE;
-        FxaaBool lumaMLTZero = lumaMM < 0.0;
-    /*--------------------------------------------------------------------------*/
-        lumaEndN -= lumaNN * 0.5;
-        lumaEndP -= lumaNN * 0.5;
-        FxaaBool doneN = abs(lumaEndN) >= gradientScaled;
-        FxaaBool doneP = abs(lumaEndP) >= gradientScaled;
-        if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P1;
-        if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P1;
-        FxaaBool doneNP = (!doneN) || (!doneP);
-        if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P1;
-        if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P1;
-    /*--------------------------------------------------------------------------*/
-        if(doneNP) {
-            if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
-            if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
-            if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
-            if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
-            doneN = abs(lumaEndN) >= gradientScaled;
-            doneP = abs(lumaEndP) >= gradientScaled;
-            if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P2;
-            if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P2;
-            doneNP = (!doneN) || (!doneP);
-            if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P2;
-            if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P2;
-    /*--------------------------------------------------------------------------*/
-            #if (FXAA_QUALITY_PS > 3)
-            if(doneNP) {
-                if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
-                if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
-                if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
-                if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
-                doneN = abs(lumaEndN) >= gradientScaled;
-                doneP = abs(lumaEndP) >= gradientScaled;
-                if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P3;
-                if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P3;
-                doneNP = (!doneN) || (!doneP);
-                if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P3;
-                if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P3;
-    /*--------------------------------------------------------------------------*/
-                #if (FXAA_QUALITY_PS > 4)
-                if(doneNP) {
-                    if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
-                    if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
-                    if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
-                    if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
-                    doneN = abs(lumaEndN) >= gradientScaled;
-                    doneP = abs(lumaEndP) >= gradientScaled;
-                    if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P4;
-                    if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P4;
-                    doneNP = (!doneN) || (!doneP);
-                    if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P4;
-                    if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P4;
-    /*--------------------------------------------------------------------------*/
-                    #if (FXAA_QUALITY_PS > 5)
-                    if(doneNP) {
-                        if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
-                        if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
-                        if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
-                        if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
-                        doneN = abs(lumaEndN) >= gradientScaled;
-                        doneP = abs(lumaEndP) >= gradientScaled;
-                        if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P5;
-                        if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P5;
-                        doneNP = (!doneN) || (!doneP);
-                        if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P5;
-                        if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P5;
-    /*--------------------------------------------------------------------------*/
-                        #if (FXAA_QUALITY_PS > 6)
-                        if(doneNP) {
-                            if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
-                            if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
-                            if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
-                            if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
-                            doneN = abs(lumaEndN) >= gradientScaled;
-                            doneP = abs(lumaEndP) >= gradientScaled;
-                            if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P6;
-                            if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P6;
-                            doneNP = (!doneN) || (!doneP);
-                            if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P6;
-                            if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P6;
-    /*--------------------------------------------------------------------------*/
-                            #if (FXAA_QUALITY_PS > 7)
-                            if(doneNP) {
-                                if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
-                                if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
-                                if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
-                                if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
-                                doneN = abs(lumaEndN) >= gradientScaled;
-                                doneP = abs(lumaEndP) >= gradientScaled;
-                                if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P7;
-                                if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P7;
-                                doneNP = (!doneN) || (!doneP);
-                                if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P7;
-                                if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P7;
-    /*--------------------------------------------------------------------------*/
-        #if (FXAA_QUALITY_PS > 8)
-        if(doneNP) {
-            if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
-            if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
-            if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
-            if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
-            doneN = abs(lumaEndN) >= gradientScaled;
-            doneP = abs(lumaEndP) >= gradientScaled;
-            if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P8;
-            if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P8;
-            doneNP = (!doneN) || (!doneP);
-            if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P8;
-            if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P8;
-    /*--------------------------------------------------------------------------*/
-            #if (FXAA_QUALITY_PS > 9)
-            if(doneNP) {
-                if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
-                if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
-                if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
-                if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
-                doneN = abs(lumaEndN) >= gradientScaled;
-                doneP = abs(lumaEndP) >= gradientScaled;
-                if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P9;
-                if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P9;
-                doneNP = (!doneN) || (!doneP);
-                if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P9;
-                if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P9;
-    /*--------------------------------------------------------------------------*/
-                #if (FXAA_QUALITY_PS > 10)
-                if(doneNP) {
-                    if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
-                    if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
-                    if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
-                    if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
-                    doneN = abs(lumaEndN) >= gradientScaled;
-                    doneP = abs(lumaEndP) >= gradientScaled;
-                    if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P10;
-                    if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P10;
-                    doneNP = (!doneN) || (!doneP);
-                    if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P10;
-                    if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P10;
-    /*--------------------------------------------------------------------------*/
-                    #if (FXAA_QUALITY_PS > 11)
-                    if(doneNP) {
-                        if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
-                        if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
-                        if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
-                        if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
-                        doneN = abs(lumaEndN) >= gradientScaled;
-                        doneP = abs(lumaEndP) >= gradientScaled;
-                        if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P11;
-                        if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P11;
-                        doneNP = (!doneN) || (!doneP);
-                        if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P11;
-                        if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P11;
-    /*--------------------------------------------------------------------------*/
-                        #if (FXAA_QUALITY_PS > 12)
-                        if(doneNP) {
-                            if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
-                            if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
-                            if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
-                            if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
-                            doneN = abs(lumaEndN) >= gradientScaled;
-                            doneP = abs(lumaEndP) >= gradientScaled;
-                            if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P12;
-                            if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P12;
-                            doneNP = (!doneN) || (!doneP);
-                            if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P12;
-                            if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P12;
-    /*--------------------------------------------------------------------------*/
-                        }
-                        #endif
-    /*--------------------------------------------------------------------------*/
-                    }
-                    #endif
-    /*--------------------------------------------------------------------------*/
-                }
-                #endif
-    /*--------------------------------------------------------------------------*/
-            }
-            #endif
-    /*--------------------------------------------------------------------------*/
-        }
-        #endif
-    /*--------------------------------------------------------------------------*/
-                            }
-                            #endif
-    /*--------------------------------------------------------------------------*/
-                        }
-                        #endif
-    /*--------------------------------------------------------------------------*/
-                    }
-                    #endif
-    /*--------------------------------------------------------------------------*/
-                }
-                #endif
-    /*--------------------------------------------------------------------------*/
-            }
-            #endif
-    /*--------------------------------------------------------------------------*/
-        }
-    /*--------------------------------------------------------------------------*/
-        FxaaFloat dstN = posM.x - posN.x;
-        FxaaFloat dstP = posP.x - posM.x;
-        if(!horzSpan) dstN = posM.y - posN.y;
-        if(!horzSpan) dstP = posP.y - posM.y;
-    /*--------------------------------------------------------------------------*/
-        FxaaBool goodSpanN = (lumaEndN < 0.0) != lumaMLTZero;
-        FxaaFloat spanLength = (dstP + dstN);
-        FxaaBool goodSpanP = (lumaEndP < 0.0) != lumaMLTZero;
-        FxaaFloat spanLengthRcp = 1.0/spanLength;
-    /*--------------------------------------------------------------------------*/
-        FxaaBool directionN = dstN < dstP;
-        FxaaFloat dst = min(dstN, dstP);
-        FxaaBool goodSpan = directionN ? goodSpanN : goodSpanP;
-        FxaaFloat subpixG = subpixF * subpixF;
-        FxaaFloat pixelOffset = (dst * (-spanLengthRcp)) + 0.5;
-        FxaaFloat subpixH = subpixG * fxaaQualitySubpix;
-    /*--------------------------------------------------------------------------*/
-        FxaaFloat pixelOffsetGood = goodSpan ? pixelOffset : 0.0;
-        FxaaFloat pixelOffsetSubpix = max(pixelOffsetGood, subpixH);
-        if(!horzSpan) posM.x += pixelOffsetSubpix * lengthSign;
-        if( horzSpan) posM.y += pixelOffsetSubpix * lengthSign;
-        #if (FXAA_DISCARD == 1)
-            return FxaaTexTop(tex, posM);
-        #else
-            return FxaaFloat4(FxaaTexTop(tex, posM).xyz, lumaM);
-        #endif
-    }
-    /*==========================================================================*/
-    #endif
-    
-    void main() {
-      gl_FragColor = FxaaPixelShader(
-        vUv,
-        vec4(0.0),
-        tDiffuse,
-        tDiffuse,
-        tDiffuse,
-        resolution,
-        vec4(0.0),
-        vec4(0.0),
-        vec4(0.0),
-        0.75,
-        0.166,
-        0.0833,
-        0.0,
-        0.0,
-        0.0,
-        vec4(0.0)
-      );
-    
-      // TODO avoid querying texture twice for same texel
-      gl_FragColor.a = texture2D(tDiffuse, vUv).a;
-    }
-  `,
+  fragmentShader: [
+    'precision highp float;',
+    '',
+    'uniform sampler2D tDiffuse;',
+    '',
+    'uniform vec2 resolution;',
+    '',
+    'varying vec2 vUv;',
+    '',
+    '// FXAA 3.11 implementation by NVIDIA, ported to WebGL by Agost Biro (biro@archilogic.com)',
+    '',
+    '//----------------------------------------------------------------------------------',
+    '// File:        es3-keplerFXAAassetsshaders/FXAA_DefaultES.frag',
+    '// SDK Version: v3.00',
+    '// Email:       gameworks@nvidia.com',
+    '// Site:        http://developer.nvidia.com/',
+    '//',
+    '// Copyright (c) 2014-2015, NVIDIA CORPORATION. All rights reserved.',
+    '//',
+    '// Redistribution and use in source and binary forms, with or without',
+    '// modification, are permitted provided that the following conditions',
+    '// are met:',
+    '//  * Redistributions of source code must retain the above copyright',
+    '//    notice, this list of conditions and the following disclaimer.',
+    '//  * Redistributions in binary form must reproduce the above copyright',
+    '//    notice, this list of conditions and the following disclaimer in the',
+    '//    documentation and/or other materials provided with the distribution.',
+    '//  * Neither the name of NVIDIA CORPORATION nor the names of its',
+    '//    contributors may be used to endorse or promote products derived',
+    '//    from this software without specific prior written permission.',
+    '//',
+    "// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY",
+    '// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE',
+    '// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR',
+    '// PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR',
+    '// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,',
+    '// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,',
+    '// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR',
+    '// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY',
+    '// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT',
+    '// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE',
+    '// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.',
+    '//',
+    '//----------------------------------------------------------------------------------',
+    '',
+    '#define FXAA_PC 1',
+    '#define FXAA_GLSL_100 1',
+    '#define FXAA_QUALITY_PRESET 12',
+    '',
+    '#define FXAA_GREEN_AS_LUMA 1',
+    '',
+    '/*--------------------------------------------------------------------------*/',
+    '#ifndef FXAA_PC_CONSOLE',
+    '    //',
+    '    // The console algorithm for PC is included',
+    '    // for developers targeting really low spec machines.',
+    '    // Likely better to just run FXAA_PC, and use a really low preset.',
+    '    //',
+    '    #define FXAA_PC_CONSOLE 0',
+    '#endif',
+    '/*--------------------------------------------------------------------------*/',
+    '#ifndef FXAA_GLSL_120',
+    '    #define FXAA_GLSL_120 0',
+    '#endif',
+    '/*--------------------------------------------------------------------------*/',
+    '#ifndef FXAA_GLSL_130',
+    '    #define FXAA_GLSL_130 0',
+    '#endif',
+    '/*--------------------------------------------------------------------------*/',
+    '#ifndef FXAA_HLSL_3',
+    '    #define FXAA_HLSL_3 0',
+    '#endif',
+    '/*--------------------------------------------------------------------------*/',
+    '#ifndef FXAA_HLSL_4',
+    '    #define FXAA_HLSL_4 0',
+    '#endif',
+    '/*--------------------------------------------------------------------------*/',
+    '#ifndef FXAA_HLSL_5',
+    '    #define FXAA_HLSL_5 0',
+    '#endif',
+    '/*==========================================================================*/',
+    '#ifndef FXAA_GREEN_AS_LUMA',
+    '    //',
+    '    // For those using non-linear color,',
+    '    // and either not able to get luma in alpha, or not wanting to,',
+    '    // this enables FXAA to run using green as a proxy for luma.',
+    '    // So with this enabled, no need to pack luma in alpha.',
+    '    //',
+    '    // This will turn off AA on anything which lacks some amount of green.',
+    '    // Pure red and blue or combination of only R and B, will get no AA.',
+    '    //',
+    '    // Might want to lower the settings for both,',
+    '    //    fxaaConsoleEdgeThresholdMin',
+    '    //    fxaaQualityEdgeThresholdMin',
+    '    // In order to insure AA does not get turned off on colors',
+    '    // which contain a minor amount of green.',
+    '    //',
+    '    // 1 = On.',
+    '    // 0 = Off.',
+    '    //',
+    '    #define FXAA_GREEN_AS_LUMA 0',
+    '#endif',
+    '/*--------------------------------------------------------------------------*/',
+    '#ifndef FXAA_EARLY_EXIT',
+    '    //',
+    "    // Controls algorithm's early exit path.",
+    '    // On PS3 turning this ON adds 2 cycles to the shader.',
+    '    // On 360 turning this OFF adds 10ths of a millisecond to the shader.',
+    '    // Turning this off on console will result in a more blurry image.',
+    '    // So this defaults to on.',
+    '    //',
+    '    // 1 = On.',
+    '    // 0 = Off.',
+    '    //',
+    '    #define FXAA_EARLY_EXIT 1',
+    '#endif',
+    '/*--------------------------------------------------------------------------*/',
+    '#ifndef FXAA_DISCARD',
+    '    //',
+    '    // Only valid for PC OpenGL currently.',
+    '    // Probably will not work when FXAA_GREEN_AS_LUMA = 1.',
+    '    //',
+    "    // 1 = Use discard on pixels which don't need AA.",
+    '    //     For APIs which enable concurrent TEX+ROP from same surface.',
+    "    // 0 = Return unchanged color on pixels which don't need AA.",
+    '    //',
+    '    #define FXAA_DISCARD 0',
+    '#endif',
+    '/*--------------------------------------------------------------------------*/',
+    '#ifndef FXAA_FAST_PIXEL_OFFSET',
+    '    //',
+    '    // Used for GLSL 120 only.',
+    '    //',
+    '    // 1 = GL API supports fast pixel offsets',
+    '    // 0 = do not use fast pixel offsets',
+    '    //',
+    '    #ifdef GL_EXT_gpu_shader4',
+    '        #define FXAA_FAST_PIXEL_OFFSET 1',
+    '    #endif',
+    '    #ifdef GL_NV_gpu_shader5',
+    '        #define FXAA_FAST_PIXEL_OFFSET 1',
+    '    #endif',
+    '    #ifdef GL_ARB_gpu_shader5',
+    '        #define FXAA_FAST_PIXEL_OFFSET 1',
+    '    #endif',
+    '    #ifndef FXAA_FAST_PIXEL_OFFSET',
+    '        #define FXAA_FAST_PIXEL_OFFSET 0',
+    '    #endif',
+    '#endif',
+    '/*--------------------------------------------------------------------------*/',
+    '#ifndef FXAA_GATHER4_ALPHA',
+    '    //',
+    '    // 1 = API supports gather4 on alpha channel.',
+    '    // 0 = API does not support gather4 on alpha channel.',
+    '    //',
+    '    #if (FXAA_HLSL_5 == 1)',
+    '        #define FXAA_GATHER4_ALPHA 1',
+    '    #endif',
+    '    #ifdef GL_ARB_gpu_shader5',
+    '        #define FXAA_GATHER4_ALPHA 1',
+    '    #endif',
+    '    #ifdef GL_NV_gpu_shader5',
+    '        #define FXAA_GATHER4_ALPHA 1',
+    '    #endif',
+    '    #ifndef FXAA_GATHER4_ALPHA',
+    '        #define FXAA_GATHER4_ALPHA 0',
+    '    #endif',
+    '#endif',
+    '',
+    '',
+    '/*============================================================================',
+    '                        FXAA QUALITY - TUNING KNOBS',
+    '------------------------------------------------------------------------------',
+    'NOTE the other tuning knobs are now in the shader function inputs!',
+    '============================================================================*/',
+    '#ifndef FXAA_QUALITY_PRESET',
+    '    //',
+    '    // Choose the quality preset.',
+    '    // This needs to be compiled into the shader as it effects code.',
+    '    // Best option to include multiple presets is to',
+    '    // in each shader define the preset, then include this file.',
+    '    //',
+    '    // OPTIONS',
+    '    // -----------------------------------------------------------------------',
+    '    // 10 to 15 - default medium dither (10=fastest, 15=highest quality)',
+    '    // 20 to 29 - less dither, more expensive (20=fastest, 29=highest quality)',
+    '    // 39       - no dither, very expensive',
+    '    //',
+    '    // NOTES',
+    '    // -----------------------------------------------------------------------',
+    '    // 12 = slightly faster then FXAA 3.9 and higher edge quality (default)',
+    '    // 13 = about same speed as FXAA 3.9 and better than 12',
+    '    // 23 = closest to FXAA 3.9 visually and performance wise',
+    '    //  _ = the lowest digit is directly related to performance',
+    '    // _  = the highest digit is directly related to style',
+    '    //',
+    '    #define FXAA_QUALITY_PRESET 12',
+    '#endif',
+    '',
+    '',
+    '/*============================================================================',
+    '',
+    '                           FXAA QUALITY - PRESETS',
+    '',
+    '============================================================================*/',
+    '',
+    '/*============================================================================',
+    '                     FXAA QUALITY - MEDIUM DITHER PRESETS',
+    '============================================================================*/',
+    '#if (FXAA_QUALITY_PRESET == 10)',
+    '    #define FXAA_QUALITY_PS 3',
+    '    #define FXAA_QUALITY_P0 1.5',
+    '    #define FXAA_QUALITY_P1 3.0',
+    '    #define FXAA_QUALITY_P2 12.0',
+    '#endif',
+    '/*--------------------------------------------------------------------------*/',
+    '#if (FXAA_QUALITY_PRESET == 11)',
+    '    #define FXAA_QUALITY_PS 4',
+    '    #define FXAA_QUALITY_P0 1.0',
+    '    #define FXAA_QUALITY_P1 1.5',
+    '    #define FXAA_QUALITY_P2 3.0',
+    '    #define FXAA_QUALITY_P3 12.0',
+    '#endif',
+    '/*--------------------------------------------------------------------------*/',
+    '#if (FXAA_QUALITY_PRESET == 12)',
+    '    #define FXAA_QUALITY_PS 5',
+    '    #define FXAA_QUALITY_P0 1.0',
+    '    #define FXAA_QUALITY_P1 1.5',
+    '    #define FXAA_QUALITY_P2 2.0',
+    '    #define FXAA_QUALITY_P3 4.0',
+    '    #define FXAA_QUALITY_P4 12.0',
+    '#endif',
+    '/*--------------------------------------------------------------------------*/',
+    '#if (FXAA_QUALITY_PRESET == 13)',
+    '    #define FXAA_QUALITY_PS 6',
+    '    #define FXAA_QUALITY_P0 1.0',
+    '    #define FXAA_QUALITY_P1 1.5',
+    '    #define FXAA_QUALITY_P2 2.0',
+    '    #define FXAA_QUALITY_P3 2.0',
+    '    #define FXAA_QUALITY_P4 4.0',
+    '    #define FXAA_QUALITY_P5 12.0',
+    '#endif',
+    '/*--------------------------------------------------------------------------*/',
+    '#if (FXAA_QUALITY_PRESET == 14)',
+    '    #define FXAA_QUALITY_PS 7',
+    '    #define FXAA_QUALITY_P0 1.0',
+    '    #define FXAA_QUALITY_P1 1.5',
+    '    #define FXAA_QUALITY_P2 2.0',
+    '    #define FXAA_QUALITY_P3 2.0',
+    '    #define FXAA_QUALITY_P4 2.0',
+    '    #define FXAA_QUALITY_P5 4.0',
+    '    #define FXAA_QUALITY_P6 12.0',
+    '#endif',
+    '/*--------------------------------------------------------------------------*/',
+    '#if (FXAA_QUALITY_PRESET == 15)',
+    '    #define FXAA_QUALITY_PS 8',
+    '    #define FXAA_QUALITY_P0 1.0',
+    '    #define FXAA_QUALITY_P1 1.5',
+    '    #define FXAA_QUALITY_P2 2.0',
+    '    #define FXAA_QUALITY_P3 2.0',
+    '    #define FXAA_QUALITY_P4 2.0',
+    '    #define FXAA_QUALITY_P5 2.0',
+    '    #define FXAA_QUALITY_P6 4.0',
+    '    #define FXAA_QUALITY_P7 12.0',
+    '#endif',
+    '',
+    '/*============================================================================',
+    '                     FXAA QUALITY - LOW DITHER PRESETS',
+    '============================================================================*/',
+    '#if (FXAA_QUALITY_PRESET == 20)',
+    '    #define FXAA_QUALITY_PS 3',
+    '    #define FXAA_QUALITY_P0 1.5',
+    '    #define FXAA_QUALITY_P1 2.0',
+    '    #define FXAA_QUALITY_P2 8.0',
+    '#endif',
+    '/*--------------------------------------------------------------------------*/',
+    '#if (FXAA_QUALITY_PRESET == 21)',
+    '    #define FXAA_QUALITY_PS 4',
+    '    #define FXAA_QUALITY_P0 1.0',
+    '    #define FXAA_QUALITY_P1 1.5',
+    '    #define FXAA_QUALITY_P2 2.0',
+    '    #define FXAA_QUALITY_P3 8.0',
+    '#endif',
+    '/*--------------------------------------------------------------------------*/',
+    '#if (FXAA_QUALITY_PRESET == 22)',
+    '    #define FXAA_QUALITY_PS 5',
+    '    #define FXAA_QUALITY_P0 1.0',
+    '    #define FXAA_QUALITY_P1 1.5',
+    '    #define FXAA_QUALITY_P2 2.0',
+    '    #define FXAA_QUALITY_P3 2.0',
+    '    #define FXAA_QUALITY_P4 8.0',
+    '#endif',
+    '/*--------------------------------------------------------------------------*/',
+    '#if (FXAA_QUALITY_PRESET == 23)',
+    '    #define FXAA_QUALITY_PS 6',
+    '    #define FXAA_QUALITY_P0 1.0',
+    '    #define FXAA_QUALITY_P1 1.5',
+    '    #define FXAA_QUALITY_P2 2.0',
+    '    #define FXAA_QUALITY_P3 2.0',
+    '    #define FXAA_QUALITY_P4 2.0',
+    '    #define FXAA_QUALITY_P5 8.0',
+    '#endif',
+    '/*--------------------------------------------------------------------------*/',
+    '#if (FXAA_QUALITY_PRESET == 24)',
+    '    #define FXAA_QUALITY_PS 7',
+    '    #define FXAA_QUALITY_P0 1.0',
+    '    #define FXAA_QUALITY_P1 1.5',
+    '    #define FXAA_QUALITY_P2 2.0',
+    '    #define FXAA_QUALITY_P3 2.0',
+    '    #define FXAA_QUALITY_P4 2.0',
+    '    #define FXAA_QUALITY_P5 3.0',
+    '    #define FXAA_QUALITY_P6 8.0',
+    '#endif',
+    '/*--------------------------------------------------------------------------*/',
+    '#if (FXAA_QUALITY_PRESET == 25)',
+    '    #define FXAA_QUALITY_PS 8',
+    '    #define FXAA_QUALITY_P0 1.0',
+    '    #define FXAA_QUALITY_P1 1.5',
+    '    #define FXAA_QUALITY_P2 2.0',
+    '    #define FXAA_QUALITY_P3 2.0',
+    '    #define FXAA_QUALITY_P4 2.0',
+    '    #define FXAA_QUALITY_P5 2.0',
+    '    #define FXAA_QUALITY_P6 4.0',
+    '    #define FXAA_QUALITY_P7 8.0',
+    '#endif',
+    '/*--------------------------------------------------------------------------*/',
+    '#if (FXAA_QUALITY_PRESET == 26)',
+    '    #define FXAA_QUALITY_PS 9',
+    '    #define FXAA_QUALITY_P0 1.0',
+    '    #define FXAA_QUALITY_P1 1.5',
+    '    #define FXAA_QUALITY_P2 2.0',
+    '    #define FXAA_QUALITY_P3 2.0',
+    '    #define FXAA_QUALITY_P4 2.0',
+    '    #define FXAA_QUALITY_P5 2.0',
+    '    #define FXAA_QUALITY_P6 2.0',
+    '    #define FXAA_QUALITY_P7 4.0',
+    '    #define FXAA_QUALITY_P8 8.0',
+    '#endif',
+    '/*--------------------------------------------------------------------------*/',
+    '#if (FXAA_QUALITY_PRESET == 27)',
+    '    #define FXAA_QUALITY_PS 10',
+    '    #define FXAA_QUALITY_P0 1.0',
+    '    #define FXAA_QUALITY_P1 1.5',
+    '    #define FXAA_QUALITY_P2 2.0',
+    '    #define FXAA_QUALITY_P3 2.0',
+    '    #define FXAA_QUALITY_P4 2.0',
+    '    #define FXAA_QUALITY_P5 2.0',
+    '    #define FXAA_QUALITY_P6 2.0',
+    '    #define FXAA_QUALITY_P7 2.0',
+    '    #define FXAA_QUALITY_P8 4.0',
+    '    #define FXAA_QUALITY_P9 8.0',
+    '#endif',
+    '/*--------------------------------------------------------------------------*/',
+    '#if (FXAA_QUALITY_PRESET == 28)',
+    '    #define FXAA_QUALITY_PS 11',
+    '    #define FXAA_QUALITY_P0 1.0',
+    '    #define FXAA_QUALITY_P1 1.5',
+    '    #define FXAA_QUALITY_P2 2.0',
+    '    #define FXAA_QUALITY_P3 2.0',
+    '    #define FXAA_QUALITY_P4 2.0',
+    '    #define FXAA_QUALITY_P5 2.0',
+    '    #define FXAA_QUALITY_P6 2.0',
+    '    #define FXAA_QUALITY_P7 2.0',
+    '    #define FXAA_QUALITY_P8 2.0',
+    '    #define FXAA_QUALITY_P9 4.0',
+    '    #define FXAA_QUALITY_P10 8.0',
+    '#endif',
+    '/*--------------------------------------------------------------------------*/',
+    '#if (FXAA_QUALITY_PRESET == 29)',
+    '    #define FXAA_QUALITY_PS 12',
+    '    #define FXAA_QUALITY_P0 1.0',
+    '    #define FXAA_QUALITY_P1 1.5',
+    '    #define FXAA_QUALITY_P2 2.0',
+    '    #define FXAA_QUALITY_P3 2.0',
+    '    #define FXAA_QUALITY_P4 2.0',
+    '    #define FXAA_QUALITY_P5 2.0',
+    '    #define FXAA_QUALITY_P6 2.0',
+    '    #define FXAA_QUALITY_P7 2.0',
+    '    #define FXAA_QUALITY_P8 2.0',
+    '    #define FXAA_QUALITY_P9 2.0',
+    '    #define FXAA_QUALITY_P10 4.0',
+    '    #define FXAA_QUALITY_P11 8.0',
+    '#endif',
+    '',
+    '/*============================================================================',
+    '                     FXAA QUALITY - EXTREME QUALITY',
+    '============================================================================*/',
+    '#if (FXAA_QUALITY_PRESET == 39)',
+    '    #define FXAA_QUALITY_PS 12',
+    '    #define FXAA_QUALITY_P0 1.0',
+    '    #define FXAA_QUALITY_P1 1.0',
+    '    #define FXAA_QUALITY_P2 1.0',
+    '    #define FXAA_QUALITY_P3 1.0',
+    '    #define FXAA_QUALITY_P4 1.0',
+    '    #define FXAA_QUALITY_P5 1.5',
+    '    #define FXAA_QUALITY_P6 2.0',
+    '    #define FXAA_QUALITY_P7 2.0',
+    '    #define FXAA_QUALITY_P8 2.0',
+    '    #define FXAA_QUALITY_P9 2.0',
+    '    #define FXAA_QUALITY_P10 4.0',
+    '    #define FXAA_QUALITY_P11 8.0',
+    '#endif',
+    '',
+    '',
+    '',
+    '/*============================================================================',
+    '',
+    '                                API PORTING',
+    '',
+    '============================================================================*/',
+    '#if (FXAA_GLSL_100 == 1) || (FXAA_GLSL_120 == 1) || (FXAA_GLSL_130 == 1)',
+    '    #define FxaaBool bool',
+    '    #define FxaaDiscard discard',
+    '    #define FxaaFloat float',
+    '    #define FxaaFloat2 vec2',
+    '    #define FxaaFloat3 vec3',
+    '    #define FxaaFloat4 vec4',
+    '    #define FxaaHalf float',
+    '    #define FxaaHalf2 vec2',
+    '    #define FxaaHalf3 vec3',
+    '    #define FxaaHalf4 vec4',
+    '    #define FxaaInt2 ivec2',
+    '    #define FxaaSat(x) clamp(x, 0.0, 1.0)',
+    '    #define FxaaTex sampler2D',
+    '#else',
+    '    #define FxaaBool bool',
+    '    #define FxaaDiscard clip(-1)',
+    '    #define FxaaFloat float',
+    '    #define FxaaFloat2 float2',
+    '    #define FxaaFloat3 float3',
+    '    #define FxaaFloat4 float4',
+    '    #define FxaaHalf half',
+    '    #define FxaaHalf2 half2',
+    '    #define FxaaHalf3 half3',
+    '    #define FxaaHalf4 half4',
+    '    #define FxaaSat(x) saturate(x)',
+    '#endif',
+    '/*--------------------------------------------------------------------------*/',
+    '#if (FXAA_GLSL_100 == 1)',
+    '  #define FxaaTexTop(t, p) texture2D(t, p, 0.0)',
+    '  #define FxaaTexOff(t, p, o, r) texture2D(t, p + (o * r), 0.0)',
+    '#endif',
+    '/*--------------------------------------------------------------------------*/',
+    '#if (FXAA_GLSL_120 == 1)',
+    '    // Requires,',
+    '    //  #version 120',
+    '    // And at least,',
+    '    //  #extension GL_EXT_gpu_shader4 : enable',
+    '    //  (or set FXAA_FAST_PIXEL_OFFSET 1 to work like DX9)',
+    '    #define FxaaTexTop(t, p) texture2DLod(t, p, 0.0)',
+    '    #if (FXAA_FAST_PIXEL_OFFSET == 1)',
+    '        #define FxaaTexOff(t, p, o, r) texture2DLodOffset(t, p, 0.0, o)',
+    '    #else',
+    '        #define FxaaTexOff(t, p, o, r) texture2DLod(t, p + (o * r), 0.0)',
+    '    #endif',
+    '    #if (FXAA_GATHER4_ALPHA == 1)',
+    '        // use #extension GL_ARB_gpu_shader5 : enable',
+    '        #define FxaaTexAlpha4(t, p) textureGather(t, p, 3)',
+    '        #define FxaaTexOffAlpha4(t, p, o) textureGatherOffset(t, p, o, 3)',
+    '        #define FxaaTexGreen4(t, p) textureGather(t, p, 1)',
+    '        #define FxaaTexOffGreen4(t, p, o) textureGatherOffset(t, p, o, 1)',
+    '    #endif',
+    '#endif',
+    '/*--------------------------------------------------------------------------*/',
+    '#if (FXAA_GLSL_130 == 1)',
+    '    // Requires "#version 130" or better',
+    '    #define FxaaTexTop(t, p) textureLod(t, p, 0.0)',
+    '    #define FxaaTexOff(t, p, o, r) textureLodOffset(t, p, 0.0, o)',
+    '    #if (FXAA_GATHER4_ALPHA == 1)',
+    '        // use #extension GL_ARB_gpu_shader5 : enable',
+    '        #define FxaaTexAlpha4(t, p) textureGather(t, p, 3)',
+    '        #define FxaaTexOffAlpha4(t, p, o) textureGatherOffset(t, p, o, 3)',
+    '        #define FxaaTexGreen4(t, p) textureGather(t, p, 1)',
+    '        #define FxaaTexOffGreen4(t, p, o) textureGatherOffset(t, p, o, 1)',
+    '    #endif',
+    '#endif',
+    '/*--------------------------------------------------------------------------*/',
+    '#if (FXAA_HLSL_3 == 1)',
+    '    #define FxaaInt2 float2',
+    '    #define FxaaTex sampler2D',
+    '    #define FxaaTexTop(t, p) tex2Dlod(t, float4(p, 0.0, 0.0))',
+    '    #define FxaaTexOff(t, p, o, r) tex2Dlod(t, float4(p + (o * r), 0, 0))',
+    '#endif',
+    '/*--------------------------------------------------------------------------*/',
+    '#if (FXAA_HLSL_4 == 1)',
+    '    #define FxaaInt2 int2',
+    '    struct FxaaTex { SamplerState smpl; Texture2D tex; };',
+    '    #define FxaaTexTop(t, p) t.tex.SampleLevel(t.smpl, p, 0.0)',
+    '    #define FxaaTexOff(t, p, o, r) t.tex.SampleLevel(t.smpl, p, 0.0, o)',
+    '#endif',
+    '/*--------------------------------------------------------------------------*/',
+    '#if (FXAA_HLSL_5 == 1)',
+    '    #define FxaaInt2 int2',
+    '    struct FxaaTex { SamplerState smpl; Texture2D tex; };',
+    '    #define FxaaTexTop(t, p) t.tex.SampleLevel(t.smpl, p, 0.0)',
+    '    #define FxaaTexOff(t, p, o, r) t.tex.SampleLevel(t.smpl, p, 0.0, o)',
+    '    #define FxaaTexAlpha4(t, p) t.tex.GatherAlpha(t.smpl, p)',
+    '    #define FxaaTexOffAlpha4(t, p, o) t.tex.GatherAlpha(t.smpl, p, o)',
+    '    #define FxaaTexGreen4(t, p) t.tex.GatherGreen(t.smpl, p)',
+    '    #define FxaaTexOffGreen4(t, p, o) t.tex.GatherGreen(t.smpl, p, o)',
+    '#endif',
+    '',
+    '',
+    '/*============================================================================',
+    '                   GREEN AS LUMA OPTION SUPPORT FUNCTION',
+    '============================================================================*/',
+    '#if (FXAA_GREEN_AS_LUMA == 0)',
+    '    FxaaFloat FxaaLuma(FxaaFloat4 rgba) { return rgba.w; }',
+    '#else',
+    '    FxaaFloat FxaaLuma(FxaaFloat4 rgba) { return rgba.y; }',
+    '#endif',
+    '',
+    '',
+    '',
+    '',
+    '/*============================================================================',
+    '',
+    '                             FXAA3 QUALITY - PC',
+    '',
+    '============================================================================*/',
+    '#if (FXAA_PC == 1)',
+    '/*--------------------------------------------------------------------------*/',
+    'FxaaFloat4 FxaaPixelShader(',
+    '    //',
+    '    // Use noperspective interpolation here (turn off perspective interpolation).',
+    '    // {xy} = center of pixel',
+    '    FxaaFloat2 pos,',
+    '    //',
+    '    // Used only for FXAA Console, and not used on the 360 version.',
+    '    // Use noperspective interpolation here (turn off perspective interpolation).',
+    '    // {xy_} = upper left of pixel',
+    '    // {_zw} = lower right of pixel',
+    '    FxaaFloat4 fxaaConsolePosPos,',
+    '    //',
+    '    // Input color texture.',
+    '    // {rgb_} = color in linear or perceptual color space',
+    '    // if (FXAA_GREEN_AS_LUMA == 0)',
+    '    //     {__a} = luma in perceptual color space (not linear)',
+    '    FxaaTex tex,',
+    '    //',
+    '    // Only used on the optimized 360 version of FXAA Console.',
+    '    // For everything but 360, just use the same input here as for "tex".',
+    '    // For 360, same texture, just alias with a 2nd sampler.',
+    '    // This sampler needs to have an exponent bias of -1.',
+    '    FxaaTex fxaaConsole360TexExpBiasNegOne,',
+    '    //',
+    '    // Only used on the optimized 360 version of FXAA Console.',
+    '    // For everything but 360, just use the same input here as for "tex".',
+    '    // For 360, same texture, just alias with a 3nd sampler.',
+    '    // This sampler needs to have an exponent bias of -2.',
+    '    FxaaTex fxaaConsole360TexExpBiasNegTwo,',
+    '    //',
+    '    // Only used on FXAA Quality.',
+    '    // This must be from a constant/uniform.',
+    '    // {x_} = 1.0/screenWidthInPixels',
+    '    // {_y} = 1.0/screenHeightInPixels',
+    '    FxaaFloat2 fxaaQualityRcpFrame,',
+    '    //',
+    '    // Only used on FXAA Console.',
+    '    // This must be from a constant/uniform.',
+    '    // This effects sub-pixel AA quality and inversely sharpness.',
+    '    //   Where N ranges between,',
+    '    //     N = 0.50 (default)',
+    '    //     N = 0.33 (sharper)',
+    '    // {x__} = -N/screenWidthInPixels',
+    '    // {_y_} = -N/screenHeightInPixels',
+    '    // {_z_} =  N/screenWidthInPixels',
+    '    // {__w} =  N/screenHeightInPixels',
+    '    FxaaFloat4 fxaaConsoleRcpFrameOpt,',
+    '    //',
+    '    // Only used on FXAA Console.',
+    '    // Not used on 360, but used on PS3 and PC.',
+    '    // This must be from a constant/uniform.',
+    '    // {x__} = -2.0/screenWidthInPixels',
+    '    // {_y_} = -2.0/screenHeightInPixels',
+    '    // {_z_} =  2.0/screenWidthInPixels',
+    '    // {__w} =  2.0/screenHeightInPixels',
+    '    FxaaFloat4 fxaaConsoleRcpFrameOpt2,',
+    '    //',
+    '    // Only used on FXAA Console.',
+    '    // Only used on 360 in place of fxaaConsoleRcpFrameOpt2.',
+    '    // This must be from a constant/uniform.',
+    '    // {x__} =  8.0/screenWidthInPixels',
+    '    // {_y_} =  8.0/screenHeightInPixels',
+    '    // {_z_} = -4.0/screenWidthInPixels',
+    '    // {__w} = -4.0/screenHeightInPixels',
+    '    FxaaFloat4 fxaaConsole360RcpFrameOpt2,',
+    '    //',
+    '    // Only used on FXAA Quality.',
+    '    // This used to be the FXAA_QUALITY_SUBPIX define.',
+    '    // It is here now to allow easier tuning.',
+    '    // Choose the amount of sub-pixel aliasing removal.',
+    '    // This can effect sharpness.',
+    '    //   1.00 - upper limit (softer)',
+    '    //   0.75 - default amount of filtering',
+    '    //   0.50 - lower limit (sharper, less sub-pixel aliasing removal)',
+    '    //   0.25 - almost off',
+    '    //   0.00 - completely off',
+    '    FxaaFloat fxaaQualitySubpix,',
+    '    //',
+    '    // Only used on FXAA Quality.',
+    '    // This used to be the FXAA_QUALITY_EDGE_THRESHOLD define.',
+    '    // It is here now to allow easier tuning.',
+    '    // The minimum amount of local contrast required to apply algorithm.',
+    '    //   0.333 - too little (faster)',
+    '    //   0.250 - low quality',
+    '    //   0.166 - default',
+    '    //   0.125 - high quality',
+    '    //   0.063 - overkill (slower)',
+    '    FxaaFloat fxaaQualityEdgeThreshold,',
+    '    //',
+    '    // Only used on FXAA Quality.',
+    '    // This used to be the FXAA_QUALITY_EDGE_THRESHOLD_MIN define.',
+    '    // It is here now to allow easier tuning.',
+    '    // Trims the algorithm from processing darks.',
+    '    //   0.0833 - upper limit (default, the start of visible unfiltered edges)',
+    '    //   0.0625 - high quality (faster)',
+    '    //   0.0312 - visible limit (slower)',
+    '    // Special notes when using FXAA_GREEN_AS_LUMA,',
+    '    //   Likely want to set this to zero.',
+    '    //   As colors that are mostly not-green',
+    '    //   will appear very dark in the green channel!',
+    '    //   Tune by looking at mostly non-green content,',
+    '    //   then start at zero and increase until aliasing is a problem.',
+    '    FxaaFloat fxaaQualityEdgeThresholdMin,',
+    '    //',
+    '    // Only used on FXAA Console.',
+    '    // This used to be the FXAA_CONSOLE_EDGE_SHARPNESS define.',
+    '    // It is here now to allow easier tuning.',
+    '    // This does not effect PS3, as this needs to be compiled in.',
+    '    //   Use FXAA_CONSOLE_PS3_EDGE_SHARPNESS for PS3.',
+    '    //   Due to the PS3 being ALU bound,',
+    '    //   there are only three safe values here: 2 and 4 and 8.',
+    '    //   These options use the shaders ability to a free *|/ by 2|4|8.',
+    '    // For all other platforms can be a non-power of two.',
+    '    //   8.0 is sharper (default!!!)',
+    '    //   4.0 is softer',
+    '    //   2.0 is really soft (good only for vector graphics inputs)',
+    '    FxaaFloat fxaaConsoleEdgeSharpness,',
+    '    //',
+    '    // Only used on FXAA Console.',
+    '    // This used to be the FXAA_CONSOLE_EDGE_THRESHOLD define.',
+    '    // It is here now to allow easier tuning.',
+    '    // This does not effect PS3, as this needs to be compiled in.',
+    '    //   Use FXAA_CONSOLE_PS3_EDGE_THRESHOLD for PS3.',
+    '    //   Due to the PS3 being ALU bound,',
+    '    //   there are only two safe values here: 1/4 and 1/8.',
+    '    //   These options use the shaders ability to a free *|/ by 2|4|8.',
+    '    // The console setting has a different mapping than the quality setting.',
+    '    // Other platforms can use other values.',
+    '    //   0.125 leaves less aliasing, but is softer (default!!!)',
+    '    //   0.25 leaves more aliasing, and is sharper',
+    '    FxaaFloat fxaaConsoleEdgeThreshold,',
+    '    //',
+    '    // Only used on FXAA Console.',
+    '    // This used to be the FXAA_CONSOLE_EDGE_THRESHOLD_MIN define.',
+    '    // It is here now to allow easier tuning.',
+    '    // Trims the algorithm from processing darks.',
+    '    // The console setting has a different mapping than the quality setting.',
+    '    // This only applies when FXAA_EARLY_EXIT is 1.',
+    '    // This does not apply to PS3,',
+    '    // PS3 was simplified to avoid more shader instructions.',
+    '    //   0.06 - faster but more aliasing in darks',
+    '    //   0.05 - default',
+    '    //   0.04 - slower and less aliasing in darks',
+    '    // Special notes when using FXAA_GREEN_AS_LUMA,',
+    '    //   Likely want to set this to zero.',
+    '    //   As colors that are mostly not-green',
+    '    //   will appear very dark in the green channel!',
+    '    //   Tune by looking at mostly non-green content,',
+    '    //   then start at zero and increase until aliasing is a problem.',
+    '    FxaaFloat fxaaConsoleEdgeThresholdMin,',
+    '    //',
+    '    // Extra constants for 360 FXAA Console only.',
+    '    // Use zeros or anything else for other platforms.',
+    '    // These must be in physical constant registers and NOT immediates.',
+    '    // Immediates will result in compiler un-optimizing.',
+    '    // {xyzw} = float4(1.0, -1.0, 0.25, -0.25)',
+    '    FxaaFloat4 fxaaConsole360ConstDir',
+    ') {',
+    '/*--------------------------------------------------------------------------*/',
+    '    FxaaFloat2 posM;',
+    '    posM.x = pos.x;',
+    '    posM.y = pos.y;',
+    '    #if (FXAA_GATHER4_ALPHA == 1)',
+    '        #if (FXAA_DISCARD == 0)',
+    '            FxaaFloat4 rgbyM = FxaaTexTop(tex, posM);',
+    '            #if (FXAA_GREEN_AS_LUMA == 0)',
+    '                #define lumaM rgbyM.w',
+    '            #else',
+    '                #define lumaM rgbyM.y',
+    '            #endif',
+    '        #endif',
+    '        #if (FXAA_GREEN_AS_LUMA == 0)',
+    '            FxaaFloat4 luma4A = FxaaTexAlpha4(tex, posM);',
+    '            FxaaFloat4 luma4B = FxaaTexOffAlpha4(tex, posM, FxaaInt2(-1, -1));',
+    '        #else',
+    '            FxaaFloat4 luma4A = FxaaTexGreen4(tex, posM);',
+    '            FxaaFloat4 luma4B = FxaaTexOffGreen4(tex, posM, FxaaInt2(-1, -1));',
+    '        #endif',
+    '        #if (FXAA_DISCARD == 1)',
+    '            #define lumaM luma4A.w',
+    '        #endif',
+    '        #define lumaE luma4A.z',
+    '        #define lumaS luma4A.x',
+    '        #define lumaSE luma4A.y',
+    '        #define lumaNW luma4B.w',
+    '        #define lumaN luma4B.z',
+    '        #define lumaW luma4B.x',
+    '    #else',
+    '        FxaaFloat4 rgbyM = FxaaTexTop(tex, posM);',
+    '        #if (FXAA_GREEN_AS_LUMA == 0)',
+    '            #define lumaM rgbyM.w',
+    '        #else',
+    '            #define lumaM rgbyM.y',
+    '        #endif',
+    '        #if (FXAA_GLSL_100 == 1)',
+    '          FxaaFloat lumaS = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2( 0.0, 1.0), fxaaQualityRcpFrame.xy));',
+    '          FxaaFloat lumaE = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2( 1.0, 0.0), fxaaQualityRcpFrame.xy));',
+    '          FxaaFloat lumaN = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2( 0.0,-1.0), fxaaQualityRcpFrame.xy));',
+    '          FxaaFloat lumaW = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2(-1.0, 0.0), fxaaQualityRcpFrame.xy));',
+    '        #else',
+    '          FxaaFloat lumaS = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 0, 1), fxaaQualityRcpFrame.xy));',
+    '          FxaaFloat lumaE = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 1, 0), fxaaQualityRcpFrame.xy));',
+    '          FxaaFloat lumaN = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 0,-1), fxaaQualityRcpFrame.xy));',
+    '          FxaaFloat lumaW = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(-1, 0), fxaaQualityRcpFrame.xy));',
+    '        #endif',
+    '    #endif',
+    '/*--------------------------------------------------------------------------*/',
+    '    FxaaFloat maxSM = max(lumaS, lumaM);',
+    '    FxaaFloat minSM = min(lumaS, lumaM);',
+    '    FxaaFloat maxESM = max(lumaE, maxSM);',
+    '    FxaaFloat minESM = min(lumaE, minSM);',
+    '    FxaaFloat maxWN = max(lumaN, lumaW);',
+    '    FxaaFloat minWN = min(lumaN, lumaW);',
+    '    FxaaFloat rangeMax = max(maxWN, maxESM);',
+    '    FxaaFloat rangeMin = min(minWN, minESM);',
+    '    FxaaFloat rangeMaxScaled = rangeMax * fxaaQualityEdgeThreshold;',
+    '    FxaaFloat range = rangeMax - rangeMin;',
+    '    FxaaFloat rangeMaxClamped = max(fxaaQualityEdgeThresholdMin, rangeMaxScaled);',
+    '    FxaaBool earlyExit = range < rangeMaxClamped;',
+    '/*--------------------------------------------------------------------------*/',
+    '    if(earlyExit)',
+    '        #if (FXAA_DISCARD == 1)',
+    '            FxaaDiscard;',
+    '        #else',
+    '            return rgbyM;',
+    '        #endif',
+    '/*--------------------------------------------------------------------------*/',
+    '    #if (FXAA_GATHER4_ALPHA == 0)',
+    '        #if (FXAA_GLSL_100 == 1)',
+    '          FxaaFloat lumaNW = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2(-1.0,-1.0), fxaaQualityRcpFrame.xy));',
+    '          FxaaFloat lumaSE = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2( 1.0, 1.0), fxaaQualityRcpFrame.xy));',
+    '          FxaaFloat lumaNE = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2( 1.0,-1.0), fxaaQualityRcpFrame.xy));',
+    '          FxaaFloat lumaSW = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2(-1.0, 1.0), fxaaQualityRcpFrame.xy));',
+    '        #else',
+    '          FxaaFloat lumaNW = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(-1,-1), fxaaQualityRcpFrame.xy));',
+    '          FxaaFloat lumaSE = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 1, 1), fxaaQualityRcpFrame.xy));',
+    '          FxaaFloat lumaNE = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 1,-1), fxaaQualityRcpFrame.xy));',
+    '          FxaaFloat lumaSW = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(-1, 1), fxaaQualityRcpFrame.xy));',
+    '        #endif',
+    '    #else',
+    '        FxaaFloat lumaNE = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(1, -1), fxaaQualityRcpFrame.xy));',
+    '        FxaaFloat lumaSW = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(-1, 1), fxaaQualityRcpFrame.xy));',
+    '    #endif',
+    '/*--------------------------------------------------------------------------*/',
+    '    FxaaFloat lumaNS = lumaN + lumaS;',
+    '    FxaaFloat lumaWE = lumaW + lumaE;',
+    '    FxaaFloat subpixRcpRange = 1.0/range;',
+    '    FxaaFloat subpixNSWE = lumaNS + lumaWE;',
+    '    FxaaFloat edgeHorz1 = (-2.0 * lumaM) + lumaNS;',
+    '    FxaaFloat edgeVert1 = (-2.0 * lumaM) + lumaWE;',
+    '/*--------------------------------------------------------------------------*/',
+    '    FxaaFloat lumaNESE = lumaNE + lumaSE;',
+    '    FxaaFloat lumaNWNE = lumaNW + lumaNE;',
+    '    FxaaFloat edgeHorz2 = (-2.0 * lumaE) + lumaNESE;',
+    '    FxaaFloat edgeVert2 = (-2.0 * lumaN) + lumaNWNE;',
+    '/*--------------------------------------------------------------------------*/',
+    '    FxaaFloat lumaNWSW = lumaNW + lumaSW;',
+    '    FxaaFloat lumaSWSE = lumaSW + lumaSE;',
+    '    FxaaFloat edgeHorz4 = (abs(edgeHorz1) * 2.0) + abs(edgeHorz2);',
+    '    FxaaFloat edgeVert4 = (abs(edgeVert1) * 2.0) + abs(edgeVert2);',
+    '    FxaaFloat edgeHorz3 = (-2.0 * lumaW) + lumaNWSW;',
+    '    FxaaFloat edgeVert3 = (-2.0 * lumaS) + lumaSWSE;',
+    '    FxaaFloat edgeHorz = abs(edgeHorz3) + edgeHorz4;',
+    '    FxaaFloat edgeVert = abs(edgeVert3) + edgeVert4;',
+    '/*--------------------------------------------------------------------------*/',
+    '    FxaaFloat subpixNWSWNESE = lumaNWSW + lumaNESE;',
+    '    FxaaFloat lengthSign = fxaaQualityRcpFrame.x;',
+    '    FxaaBool horzSpan = edgeHorz >= edgeVert;',
+    '    FxaaFloat subpixA = subpixNSWE * 2.0 + subpixNWSWNESE;',
+    '/*--------------------------------------------------------------------------*/',
+    '    if(!horzSpan) lumaN = lumaW;',
+    '    if(!horzSpan) lumaS = lumaE;',
+    '    if(horzSpan) lengthSign = fxaaQualityRcpFrame.y;',
+    '    FxaaFloat subpixB = (subpixA * (1.0/12.0)) - lumaM;',
+    '/*--------------------------------------------------------------------------*/',
+    '    FxaaFloat gradientN = lumaN - lumaM;',
+    '    FxaaFloat gradientS = lumaS - lumaM;',
+    '    FxaaFloat lumaNN = lumaN + lumaM;',
+    '    FxaaFloat lumaSS = lumaS + lumaM;',
+    '    FxaaBool pairN = abs(gradientN) >= abs(gradientS);',
+    '    FxaaFloat gradient = max(abs(gradientN), abs(gradientS));',
+    '    if(pairN) lengthSign = -lengthSign;',
+    '    FxaaFloat subpixC = FxaaSat(abs(subpixB) * subpixRcpRange);',
+    '/*--------------------------------------------------------------------------*/',
+    '    FxaaFloat2 posB;',
+    '    posB.x = posM.x;',
+    '    posB.y = posM.y;',
+    '    FxaaFloat2 offNP;',
+    '    offNP.x = (!horzSpan) ? 0.0 : fxaaQualityRcpFrame.x;',
+    '    offNP.y = ( horzSpan) ? 0.0 : fxaaQualityRcpFrame.y;',
+    '    if(!horzSpan) posB.x += lengthSign * 0.5;',
+    '    if( horzSpan) posB.y += lengthSign * 0.5;',
+    '/*--------------------------------------------------------------------------*/',
+    '    FxaaFloat2 posN;',
+    '    posN.x = posB.x - offNP.x * FXAA_QUALITY_P0;',
+    '    posN.y = posB.y - offNP.y * FXAA_QUALITY_P0;',
+    '    FxaaFloat2 posP;',
+    '    posP.x = posB.x + offNP.x * FXAA_QUALITY_P0;',
+    '    posP.y = posB.y + offNP.y * FXAA_QUALITY_P0;',
+    '    FxaaFloat subpixD = ((-2.0)*subpixC) + 3.0;',
+    '    FxaaFloat lumaEndN = FxaaLuma(FxaaTexTop(tex, posN));',
+    '    FxaaFloat subpixE = subpixC * subpixC;',
+    '    FxaaFloat lumaEndP = FxaaLuma(FxaaTexTop(tex, posP));',
+    '/*--------------------------------------------------------------------------*/',
+    '    if(!pairN) lumaNN = lumaSS;',
+    '    FxaaFloat gradientScaled = gradient * 1.0/4.0;',
+    '    FxaaFloat lumaMM = lumaM - lumaNN * 0.5;',
+    '    FxaaFloat subpixF = subpixD * subpixE;',
+    '    FxaaBool lumaMLTZero = lumaMM < 0.0;',
+    '/*--------------------------------------------------------------------------*/',
+    '    lumaEndN -= lumaNN * 0.5;',
+    '    lumaEndP -= lumaNN * 0.5;',
+    '    FxaaBool doneN = abs(lumaEndN) >= gradientScaled;',
+    '    FxaaBool doneP = abs(lumaEndP) >= gradientScaled;',
+    '    if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P1;',
+    '    if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P1;',
+    '    FxaaBool doneNP = (!doneN) || (!doneP);',
+    '    if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P1;',
+    '    if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P1;',
+    '/*--------------------------------------------------------------------------*/',
+    '    if(doneNP) {',
+    '        if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));',
+    '        if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));',
+    '        if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;',
+    '        if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;',
+    '        doneN = abs(lumaEndN) >= gradientScaled;',
+    '        doneP = abs(lumaEndP) >= gradientScaled;',
+    '        if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P2;',
+    '        if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P2;',
+    '        doneNP = (!doneN) || (!doneP);',
+    '        if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P2;',
+    '        if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P2;',
+    '/*--------------------------------------------------------------------------*/',
+    '        #if (FXAA_QUALITY_PS > 3)',
+    '        if(doneNP) {',
+    '            if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));',
+    '            if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));',
+    '            if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;',
+    '            if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;',
+    '            doneN = abs(lumaEndN) >= gradientScaled;',
+    '            doneP = abs(lumaEndP) >= gradientScaled;',
+    '            if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P3;',
+    '            if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P3;',
+    '            doneNP = (!doneN) || (!doneP);',
+    '            if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P3;',
+    '            if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P3;',
+    '/*--------------------------------------------------------------------------*/',
+    '            #if (FXAA_QUALITY_PS > 4)',
+    '            if(doneNP) {',
+    '                if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));',
+    '                if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));',
+    '                if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;',
+    '                if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;',
+    '                doneN = abs(lumaEndN) >= gradientScaled;',
+    '                doneP = abs(lumaEndP) >= gradientScaled;',
+    '                if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P4;',
+    '                if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P4;',
+    '                doneNP = (!doneN) || (!doneP);',
+    '                if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P4;',
+    '                if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P4;',
+    '/*--------------------------------------------------------------------------*/',
+    '                #if (FXAA_QUALITY_PS > 5)',
+    '                if(doneNP) {',
+    '                    if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));',
+    '                    if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));',
+    '                    if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;',
+    '                    if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;',
+    '                    doneN = abs(lumaEndN) >= gradientScaled;',
+    '                    doneP = abs(lumaEndP) >= gradientScaled;',
+    '                    if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P5;',
+    '                    if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P5;',
+    '                    doneNP = (!doneN) || (!doneP);',
+    '                    if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P5;',
+    '                    if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P5;',
+    '/*--------------------------------------------------------------------------*/',
+    '                    #if (FXAA_QUALITY_PS > 6)',
+    '                    if(doneNP) {',
+    '                        if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));',
+    '                        if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));',
+    '                        if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;',
+    '                        if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;',
+    '                        doneN = abs(lumaEndN) >= gradientScaled;',
+    '                        doneP = abs(lumaEndP) >= gradientScaled;',
+    '                        if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P6;',
+    '                        if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P6;',
+    '                        doneNP = (!doneN) || (!doneP);',
+    '                        if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P6;',
+    '                        if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P6;',
+    '/*--------------------------------------------------------------------------*/',
+    '                        #if (FXAA_QUALITY_PS > 7)',
+    '                        if(doneNP) {',
+    '                            if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));',
+    '                            if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));',
+    '                            if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;',
+    '                            if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;',
+    '                            doneN = abs(lumaEndN) >= gradientScaled;',
+    '                            doneP = abs(lumaEndP) >= gradientScaled;',
+    '                            if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P7;',
+    '                            if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P7;',
+    '                            doneNP = (!doneN) || (!doneP);',
+    '                            if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P7;',
+    '                            if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P7;',
+    '/*--------------------------------------------------------------------------*/',
+    '    #if (FXAA_QUALITY_PS > 8)',
+    '    if(doneNP) {',
+    '        if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));',
+    '        if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));',
+    '        if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;',
+    '        if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;',
+    '        doneN = abs(lumaEndN) >= gradientScaled;',
+    '        doneP = abs(lumaEndP) >= gradientScaled;',
+    '        if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P8;',
+    '        if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P8;',
+    '        doneNP = (!doneN) || (!doneP);',
+    '        if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P8;',
+    '        if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P8;',
+    '/*--------------------------------------------------------------------------*/',
+    '        #if (FXAA_QUALITY_PS > 9)',
+    '        if(doneNP) {',
+    '            if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));',
+    '            if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));',
+    '            if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;',
+    '            if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;',
+    '            doneN = abs(lumaEndN) >= gradientScaled;',
+    '            doneP = abs(lumaEndP) >= gradientScaled;',
+    '            if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P9;',
+    '            if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P9;',
+    '            doneNP = (!doneN) || (!doneP);',
+    '            if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P9;',
+    '            if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P9;',
+    '/*--------------------------------------------------------------------------*/',
+    '            #if (FXAA_QUALITY_PS > 10)',
+    '            if(doneNP) {',
+    '                if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));',
+    '                if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));',
+    '                if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;',
+    '                if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;',
+    '                doneN = abs(lumaEndN) >= gradientScaled;',
+    '                doneP = abs(lumaEndP) >= gradientScaled;',
+    '                if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P10;',
+    '                if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P10;',
+    '                doneNP = (!doneN) || (!doneP);',
+    '                if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P10;',
+    '                if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P10;',
+    '/*--------------------------------------------------------------------------*/',
+    '                #if (FXAA_QUALITY_PS > 11)',
+    '                if(doneNP) {',
+    '                    if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));',
+    '                    if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));',
+    '                    if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;',
+    '                    if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;',
+    '                    doneN = abs(lumaEndN) >= gradientScaled;',
+    '                    doneP = abs(lumaEndP) >= gradientScaled;',
+    '                    if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P11;',
+    '                    if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P11;',
+    '                    doneNP = (!doneN) || (!doneP);',
+    '                    if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P11;',
+    '                    if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P11;',
+    '/*--------------------------------------------------------------------------*/',
+    '                    #if (FXAA_QUALITY_PS > 12)',
+    '                    if(doneNP) {',
+    '                        if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));',
+    '                        if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));',
+    '                        if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;',
+    '                        if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;',
+    '                        doneN = abs(lumaEndN) >= gradientScaled;',
+    '                        doneP = abs(lumaEndP) >= gradientScaled;',
+    '                        if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P12;',
+    '                        if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P12;',
+    '                        doneNP = (!doneN) || (!doneP);',
+    '                        if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P12;',
+    '                        if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P12;',
+    '/*--------------------------------------------------------------------------*/',
+    '                    }',
+    '                    #endif',
+    '/*--------------------------------------------------------------------------*/',
+    '                }',
+    '                #endif',
+    '/*--------------------------------------------------------------------------*/',
+    '            }',
+    '            #endif',
+    '/*--------------------------------------------------------------------------*/',
+    '        }',
+    '        #endif',
+    '/*--------------------------------------------------------------------------*/',
+    '    }',
+    '    #endif',
+    '/*--------------------------------------------------------------------------*/',
+    '                        }',
+    '                        #endif',
+    '/*--------------------------------------------------------------------------*/',
+    '                    }',
+    '                    #endif',
+    '/*--------------------------------------------------------------------------*/',
+    '                }',
+    '                #endif',
+    '/*--------------------------------------------------------------------------*/',
+    '            }',
+    '            #endif',
+    '/*--------------------------------------------------------------------------*/',
+    '        }',
+    '        #endif',
+    '/*--------------------------------------------------------------------------*/',
+    '    }',
+    '/*--------------------------------------------------------------------------*/',
+    '    FxaaFloat dstN = posM.x - posN.x;',
+    '    FxaaFloat dstP = posP.x - posM.x;',
+    '    if(!horzSpan) dstN = posM.y - posN.y;',
+    '    if(!horzSpan) dstP = posP.y - posM.y;',
+    '/*--------------------------------------------------------------------------*/',
+    '    FxaaBool goodSpanN = (lumaEndN < 0.0) != lumaMLTZero;',
+    '    FxaaFloat spanLength = (dstP + dstN);',
+    '    FxaaBool goodSpanP = (lumaEndP < 0.0) != lumaMLTZero;',
+    '    FxaaFloat spanLengthRcp = 1.0/spanLength;',
+    '/*--------------------------------------------------------------------------*/',
+    '    FxaaBool directionN = dstN < dstP;',
+    '    FxaaFloat dst = min(dstN, dstP);',
+    '    FxaaBool goodSpan = directionN ? goodSpanN : goodSpanP;',
+    '    FxaaFloat subpixG = subpixF * subpixF;',
+    '    FxaaFloat pixelOffset = (dst * (-spanLengthRcp)) + 0.5;',
+    '    FxaaFloat subpixH = subpixG * fxaaQualitySubpix;',
+    '/*--------------------------------------------------------------------------*/',
+    '    FxaaFloat pixelOffsetGood = goodSpan ? pixelOffset : 0.0;',
+    '    FxaaFloat pixelOffsetSubpix = max(pixelOffsetGood, subpixH);',
+    '    if(!horzSpan) posM.x += pixelOffsetSubpix * lengthSign;',
+    '    if( horzSpan) posM.y += pixelOffsetSubpix * lengthSign;',
+    '    #if (FXAA_DISCARD == 1)',
+    '        return FxaaTexTop(tex, posM);',
+    '    #else',
+    '        return FxaaFloat4(FxaaTexTop(tex, posM).xyz, lumaM);',
+    '    #endif',
+    '}',
+    '/*==========================================================================*/',
+    '#endif',
+    '',
+    'void main() {',
+    '  gl_FragColor = FxaaPixelShader(',
+    '    vUv,',
+    '    vec4(0.0),',
+    '    tDiffuse,',
+    '    tDiffuse,',
+    '    tDiffuse,',
+    '    resolution,',
+    '    vec4(0.0),',
+    '    vec4(0.0),',
+    '    vec4(0.0),',
+    '    0.75,',
+    '    0.166,',
+    '    0.0833,',
+    '    0.0,',
+    '    0.0,',
+    '    0.0,',
+    '    vec4(0.0)',
+    '  );',
+    '',
+    '  // TODO avoid querying texture twice for same texel',
+    '  gl_FragColor.a = texture2D(tDiffuse, vUv).a;',
+    '}',
+  ].join('\n'),
 }
diff --git a/src/shaders/FilmShader.ts b/src/shaders/FilmShader.ts
index e05b9c7e..bc98b542 100644
--- a/src/shaders/FilmShader.ts
+++ b/src/shaders/FilmShader.ts
@@ -28,67 +28,67 @@ export const FilmShader = {
     grayscale: { value: 1 },
   },
 
-  vertexShader: /* glsl */ `
-    varying vec2 vUv;
+  vertexShader: [
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vUv = uv;
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    '	vUv = uv;',
+    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    #include <common>
+  fragmentShader: [
+    '#include <common>',
 
     // control parameter
-    uniform float time;
+    'uniform float time;',
 
-    uniform bool grayscale;
+    'uniform bool grayscale;',
 
     // noise effect intensity value (0 = no effect, 1 = full effect)
-    uniform float nIntensity;
+    'uniform float nIntensity;',
 
     // scanlines effect intensity value (0 = no effect, 1 = full effect)
-    uniform float sIntensity;
+    'uniform float sIntensity;',
 
     // scanlines effect count value (0 = no effect, 4096 = full effect)
-    uniform float sCount;
+    'uniform float sCount;',
 
-    uniform sampler2D tDiffuse;
+    'uniform sampler2D tDiffuse;',
 
-    varying vec2 vUv;
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
     // sample the source
-    	vec4 cTextureScreen = texture2D( tDiffuse, vUv );
+    '	vec4 cTextureScreen = texture2D( tDiffuse, vUv );',
 
     // make some noise
-    	float dx = rand( vUv + time );
+    '	float dx = rand( vUv + time );',
 
     // add noise
-    	vec3 cResult = cTextureScreen.rgb + cTextureScreen.rgb * clamp( 0.1 + dx, 0.0, 1.0 );
+    '	vec3 cResult = cTextureScreen.rgb + cTextureScreen.rgb * clamp( 0.1 + dx, 0.0, 1.0 );',
 
     // get us a sine and cosine
-    	vec2 sc = vec2( sin( vUv.y * sCount ), cos( vUv.y * sCount ) );
+    '	vec2 sc = vec2( sin( vUv.y * sCount ), cos( vUv.y * sCount ) );',
 
     // add scanlines
-    	cResult += cTextureScreen.rgb * vec3( sc.x, sc.y, sc.x ) * sIntensity;
+    '	cResult += cTextureScreen.rgb * vec3( sc.x, sc.y, sc.x ) * sIntensity;',
 
     // interpolate between source and result by intensity
-    	cResult = cTextureScreen.rgb + clamp( nIntensity, 0.0,1.0 ) * ( cResult - cTextureScreen.rgb );
+    '	cResult = cTextureScreen.rgb + clamp( nIntensity, 0.0,1.0 ) * ( cResult - cTextureScreen.rgb );',
 
     // convert to grayscale if desired
-    	if( grayscale ) {
+    '	if( grayscale ) {',
 
-    		cResult = vec3( cResult.r * 0.3 + cResult.g * 0.59 + cResult.b * 0.11 );
+    '		cResult = vec3( cResult.r * 0.3 + cResult.g * 0.59 + cResult.b * 0.11 );',
 
-    	}
+    '	}',
 
-    	gl_FragColor =  vec4( cResult, cTextureScreen.a );
+    '	gl_FragColor =  vec4( cResult, cTextureScreen.a );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 }
diff --git a/src/shaders/FocusShader.ts b/src/shaders/FocusShader.ts
index 68261a59..8e49a8ba 100644
--- a/src/shaders/FocusShader.ts
+++ b/src/shaders/FocusShader.ts
@@ -13,69 +13,69 @@ export const FocusShader = {
     waveFactor: { value: 0.00125 },
   },
 
-  vertexShader: /* glsl */ `
-    varying vec2 vUv;
+  vertexShader: [
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vUv = uv;
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    '	vUv = uv;',
+    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    uniform float screenWidth;
-    uniform float screenHeight;
-    uniform float sampleDistance;
-    uniform float waveFactor;
+  fragmentShader: [
+    'uniform float screenWidth;',
+    'uniform float screenHeight;',
+    'uniform float sampleDistance;',
+    'uniform float waveFactor;',
 
-    uniform sampler2D tDiffuse;
+    'uniform sampler2D tDiffuse;',
 
-    varying vec2 vUv;
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vec4 color, org, tmp, add;
-    	float sample_dist, f;
-    	vec2 vin;
-    	vec2 uv = vUv;
+    '	vec4 color, org, tmp, add;',
+    '	float sample_dist, f;',
+    '	vec2 vin;',
+    '	vec2 uv = vUv;',
 
-    	add = color = org = texture2D( tDiffuse, uv );
+    '	add = color = org = texture2D( tDiffuse, uv );',
 
-    	vin = ( uv - vec2( 0.5 ) ) * vec2( 1.4 );
-    	sample_dist = dot( vin, vin ) * 2.0;
+    '	vin = ( uv - vec2( 0.5 ) ) * vec2( 1.4 );',
+    '	sample_dist = dot( vin, vin ) * 2.0;',
 
-    	f = ( waveFactor * 100.0 + sample_dist ) * sampleDistance * 4.0;
+    '	f = ( waveFactor * 100.0 + sample_dist ) * sampleDistance * 4.0;',
 
-    	vec2 sampleSize = vec2(  1.0 / screenWidth, 1.0 / screenHeight ) * vec2( f );
+    '	vec2 sampleSize = vec2(  1.0 / screenWidth, 1.0 / screenHeight ) * vec2( f );',
 
-    	add += tmp = texture2D( tDiffuse, uv + vec2( 0.111964, 0.993712 ) * sampleSize );
-    	if( tmp.b < color.b ) color = tmp;
+    '	add += tmp = texture2D( tDiffuse, uv + vec2( 0.111964, 0.993712 ) * sampleSize );',
+    '	if( tmp.b < color.b ) color = tmp;',
 
-    	add += tmp = texture2D( tDiffuse, uv + vec2( 0.846724, 0.532032 ) * sampleSize );
-    	if( tmp.b < color.b ) color = tmp;
+    '	add += tmp = texture2D( tDiffuse, uv + vec2( 0.846724, 0.532032 ) * sampleSize );',
+    '	if( tmp.b < color.b ) color = tmp;',
 
-    	add += tmp = texture2D( tDiffuse, uv + vec2( 0.943883, -0.330279 ) * sampleSize );
-    	if( tmp.b < color.b ) color = tmp;
+    '	add += tmp = texture2D( tDiffuse, uv + vec2( 0.943883, -0.330279 ) * sampleSize );',
+    '	if( tmp.b < color.b ) color = tmp;',
 
-    	add += tmp = texture2D( tDiffuse, uv + vec2( 0.330279, -0.943883 ) * sampleSize );
-    	if( tmp.b < color.b ) color = tmp;
+    '	add += tmp = texture2D( tDiffuse, uv + vec2( 0.330279, -0.943883 ) * sampleSize );',
+    '	if( tmp.b < color.b ) color = tmp;',
 
-    	add += tmp = texture2D( tDiffuse, uv + vec2( -0.532032, -0.846724 ) * sampleSize );
-    	if( tmp.b < color.b ) color = tmp;
+    '	add += tmp = texture2D( tDiffuse, uv + vec2( -0.532032, -0.846724 ) * sampleSize );',
+    '	if( tmp.b < color.b ) color = tmp;',
 
-    	add += tmp = texture2D( tDiffuse, uv + vec2( -0.993712, -0.111964 ) * sampleSize );
-    	if( tmp.b < color.b ) color = tmp;
+    '	add += tmp = texture2D( tDiffuse, uv + vec2( -0.993712, -0.111964 ) * sampleSize );',
+    '	if( tmp.b < color.b ) color = tmp;',
 
-    	add += tmp = texture2D( tDiffuse, uv + vec2( -0.707107, 0.707107 ) * sampleSize );
-    	if( tmp.b < color.b ) color = tmp;
+    '	add += tmp = texture2D( tDiffuse, uv + vec2( -0.707107, 0.707107 ) * sampleSize );',
+    '	if( tmp.b < color.b ) color = tmp;',
 
-    	color = color * vec4( 2.0 ) - ( add / vec4( 8.0 ) );
-    	color = color + ( add / vec4( 8.0 ) - color ) * ( vec4( 1.0 ) - vec4( sample_dist * 0.5 ) );
+    '	color = color * vec4( 2.0 ) - ( add / vec4( 8.0 ) );',
+    '	color = color + ( add / vec4( 8.0 ) - color ) * ( vec4( 1.0 ) - vec4( sample_dist * 0.5 ) );',
 
-    	gl_FragColor = vec4( color.rgb * color.rgb * vec3( 0.95 ) + color.rgb, 1.0 );
+    '	gl_FragColor = vec4( color.rgb * color.rgb * vec3( 0.95 ) + color.rgb, 1.0 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 }
diff --git a/src/shaders/FreiChenShader.ts b/src/shaders/FreiChenShader.ts
index 9778f4f1..4a0e2ea7 100644
--- a/src/shaders/FreiChenShader.ts
+++ b/src/shaders/FreiChenShader.ts
@@ -10,77 +10,77 @@ import { Vector2 } from 'three'
 export const FreiChenShader = {
   uniforms: {
     tDiffuse: { value: null },
-    aspect: { value: /* @__PURE__ */ new Vector2(512, 512) },
+    aspect: { value: new Vector2(512, 512) },
   },
 
-  vertexShader: /* glsl */ `
-    varying vec2 vUv;
+  vertexShader: [
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vUv = uv;
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    '	vUv = uv;',
+    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    uniform sampler2D tDiffuse;
-    varying vec2 vUv;
+  fragmentShader: [
+    'uniform sampler2D tDiffuse;',
+    'varying vec2 vUv;',
 
-    uniform vec2 aspect;
+    'uniform vec2 aspect;',
 
-    vec2 texel = vec2(1.0 / aspect.x, 1.0 / aspect.y);
+    'vec2 texel = vec2(1.0 / aspect.x, 1.0 / aspect.y);',
 
-    mat3 G[9];
+    'mat3 G[9];',
 
     // hard coded matrix values!!!! as suggested in https://github.com/neilmendoza/ofxPostProcessing/blob/master/src/EdgePass.cpp#L45
 
-    const mat3 g0 = mat3( 0.3535533845424652, 0, -0.3535533845424652, 0.5, 0, -0.5, 0.3535533845424652, 0, -0.3535533845424652 );
-    const mat3 g1 = mat3( 0.3535533845424652, 0.5, 0.3535533845424652, 0, 0, 0, -0.3535533845424652, -0.5, -0.3535533845424652 );
-    const mat3 g2 = mat3( 0, 0.3535533845424652, -0.5, -0.3535533845424652, 0, 0.3535533845424652, 0.5, -0.3535533845424652, 0 );
-    const mat3 g3 = mat3( 0.5, -0.3535533845424652, 0, -0.3535533845424652, 0, 0.3535533845424652, 0, 0.3535533845424652, -0.5 );
-    const mat3 g4 = mat3( 0, -0.5, 0, 0.5, 0, 0.5, 0, -0.5, 0 );
-    const mat3 g5 = mat3( -0.5, 0, 0.5, 0, 0, 0, 0.5, 0, -0.5 );
-    const mat3 g6 = mat3( 0.1666666716337204, -0.3333333432674408, 0.1666666716337204, -0.3333333432674408, 0.6666666865348816, -0.3333333432674408, 0.1666666716337204, -0.3333333432674408, 0.1666666716337204 );
-    const mat3 g7 = mat3( -0.3333333432674408, 0.1666666716337204, -0.3333333432674408, 0.1666666716337204, 0.6666666865348816, 0.1666666716337204, -0.3333333432674408, 0.1666666716337204, -0.3333333432674408 );
-    const mat3 g8 = mat3( 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408 );
-
-    void main(void)
-    {
-
-    	G[0] = g0,
-    	G[1] = g1,
-    	G[2] = g2,
-    	G[3] = g3,
-    	G[4] = g4,
-    	G[5] = g5,
-    	G[6] = g6,
-    	G[7] = g7,
-    	G[8] = g8;
-
-    	mat3 I;
-    	float cnv[9];
-    	vec3 sample;
-
-    /* fetch the 3x3 neighbourhood and use the RGB vectors length as intensity value */
-    	for (float i=0.0; i<3.0; i++) {
-    		for (float j=0.0; j<3.0; j++) {
-    			sample = texture2D(tDiffuse, vUv + texel * vec2(i-1.0,j-1.0) ).rgb;
-    			I[int(i)][int(j)] = length(sample);
-    		}
-    	}
+    'const mat3 g0 = mat3( 0.3535533845424652, 0, -0.3535533845424652, 0.5, 0, -0.5, 0.3535533845424652, 0, -0.3535533845424652 );',
+    'const mat3 g1 = mat3( 0.3535533845424652, 0.5, 0.3535533845424652, 0, 0, 0, -0.3535533845424652, -0.5, -0.3535533845424652 );',
+    'const mat3 g2 = mat3( 0, 0.3535533845424652, -0.5, -0.3535533845424652, 0, 0.3535533845424652, 0.5, -0.3535533845424652, 0 );',
+    'const mat3 g3 = mat3( 0.5, -0.3535533845424652, 0, -0.3535533845424652, 0, 0.3535533845424652, 0, 0.3535533845424652, -0.5 );',
+    'const mat3 g4 = mat3( 0, -0.5, 0, 0.5, 0, 0.5, 0, -0.5, 0 );',
+    'const mat3 g5 = mat3( -0.5, 0, 0.5, 0, 0, 0, 0.5, 0, -0.5 );',
+    'const mat3 g6 = mat3( 0.1666666716337204, -0.3333333432674408, 0.1666666716337204, -0.3333333432674408, 0.6666666865348816, -0.3333333432674408, 0.1666666716337204, -0.3333333432674408, 0.1666666716337204 );',
+    'const mat3 g7 = mat3( -0.3333333432674408, 0.1666666716337204, -0.3333333432674408, 0.1666666716337204, 0.6666666865348816, 0.1666666716337204, -0.3333333432674408, 0.1666666716337204, -0.3333333432674408 );',
+    'const mat3 g8 = mat3( 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408 );',
+
+    'void main(void)',
+    '{',
+
+    '	G[0] = g0,',
+    '	G[1] = g1,',
+    '	G[2] = g2,',
+    '	G[3] = g3,',
+    '	G[4] = g4,',
+    '	G[5] = g5,',
+    '	G[6] = g6,',
+    '	G[7] = g7,',
+    '	G[8] = g8;',
+
+    '	mat3 I;',
+    '	float cnv[9];',
+    '	vec3 sample;',
+
+    /* fetch the 3x3 neighbourhood and use the RGB vector's length as intensity value */
+    '	for (float i=0.0; i<3.0; i++) {',
+    '		for (float j=0.0; j<3.0; j++) {',
+    '			sample = texture2D(tDiffuse, vUv + texel * vec2(i-1.0,j-1.0) ).rgb;',
+    '			I[int(i)][int(j)] = length(sample);',
+    '		}',
+    '	}',
 
     /* calculate the convolution values for all the masks */
-    	for (int i=0; i<9; i++) {
-    		float dp3 = dot(G[i][0], I[0]) + dot(G[i][1], I[1]) + dot(G[i][2], I[2]);
-    		cnv[i] = dp3 * dp3;
-    	}
+    '	for (int i=0; i<9; i++) {',
+    '		float dp3 = dot(G[i][0], I[0]) + dot(G[i][1], I[1]) + dot(G[i][2], I[2]);',
+    '		cnv[i] = dp3 * dp3;',
+    '	}',
 
-    	float M = (cnv[0] + cnv[1]) + (cnv[2] + cnv[3]);
-    	float S = (cnv[4] + cnv[5]) + (cnv[6] + cnv[7]) + (cnv[8] + M);
+    '	float M = (cnv[0] + cnv[1]) + (cnv[2] + cnv[3]);',
+    '	float S = (cnv[4] + cnv[5]) + (cnv[6] + cnv[7]) + (cnv[8] + M);',
 
-    	gl_FragColor = vec4(vec3(sqrt(M/S)), 1.0);
-    }
-  `,
+    '	gl_FragColor = vec4(vec3(sqrt(M/S)), 1.0);',
+    '}',
+  ].join('\n'),
 }
diff --git a/src/shaders/FresnelShader.ts b/src/shaders/FresnelShader.ts
index d11c4424..c016ed90 100644
--- a/src/shaders/FresnelShader.ts
+++ b/src/shaders/FresnelShader.ts
@@ -11,54 +11,54 @@ export const FresnelShader = {
     tCube: { value: null },
   },
 
-  vertexShader: /* glsl */ `
-    uniform float mRefractionRatio;
-    uniform float mFresnelBias;
-    uniform float mFresnelScale;
-    uniform float mFresnelPower;
+  vertexShader: [
+    'uniform float mRefractionRatio;',
+    'uniform float mFresnelBias;',
+    'uniform float mFresnelScale;',
+    'uniform float mFresnelPower;',
 
-    varying vec3 vReflect;
-    varying vec3 vRefract[3];
-    varying float vReflectionFactor;
+    'varying vec3 vReflect;',
+    'varying vec3 vRefract[3];',
+    'varying float vReflectionFactor;',
 
-    void main() {
+    'void main() {',
 
-    	vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );
-    	vec4 worldPosition = modelMatrix * vec4( position, 1.0 );
+    '	vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );',
+    '	vec4 worldPosition = modelMatrix * vec4( position, 1.0 );',
 
-    	vec3 worldNormal = normalize( mat3( modelMatrix[0].xyz, modelMatrix[1].xyz, modelMatrix[2].xyz ) * normal );
+    '	vec3 worldNormal = normalize( mat3( modelMatrix[0].xyz, modelMatrix[1].xyz, modelMatrix[2].xyz ) * normal );',
 
-    	vec3 I = worldPosition.xyz - cameraPosition;
+    '	vec3 I = worldPosition.xyz - cameraPosition;',
 
-    	vReflect = reflect( I, worldNormal );
-    	vRefract[0] = refract( normalize( I ), worldNormal, mRefractionRatio );
-    	vRefract[1] = refract( normalize( I ), worldNormal, mRefractionRatio * 0.99 );
-    	vRefract[2] = refract( normalize( I ), worldNormal, mRefractionRatio * 0.98 );
-    	vReflectionFactor = mFresnelBias + mFresnelScale * pow( 1.0 + dot( normalize( I ), worldNormal ), mFresnelPower );
+    '	vReflect = reflect( I, worldNormal );',
+    '	vRefract[0] = refract( normalize( I ), worldNormal, mRefractionRatio );',
+    '	vRefract[1] = refract( normalize( I ), worldNormal, mRefractionRatio * 0.99 );',
+    '	vRefract[2] = refract( normalize( I ), worldNormal, mRefractionRatio * 0.98 );',
+    '	vReflectionFactor = mFresnelBias + mFresnelScale * pow( 1.0 + dot( normalize( I ), worldNormal ), mFresnelPower );',
 
-    	gl_Position = projectionMatrix * mvPosition;
+    '	gl_Position = projectionMatrix * mvPosition;',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    uniform samplerCube tCube;
+  fragmentShader: [
+    'uniform samplerCube tCube;',
 
-    varying vec3 vReflect;
-    varying vec3 vRefract[3];
-    varying float vReflectionFactor;
+    'varying vec3 vReflect;',
+    'varying vec3 vRefract[3];',
+    'varying float vReflectionFactor;',
 
-    void main() {
+    'void main() {',
 
-    	vec4 reflectedColor = textureCube( tCube, vec3( -vReflect.x, vReflect.yz ) );
-    	vec4 refractedColor = vec4( 1.0 );
+    '	vec4 reflectedColor = textureCube( tCube, vec3( -vReflect.x, vReflect.yz ) );',
+    '	vec4 refractedColor = vec4( 1.0 );',
 
-    	refractedColor.r = textureCube( tCube, vec3( -vRefract[0].x, vRefract[0].yz ) ).r;
-    	refractedColor.g = textureCube( tCube, vec3( -vRefract[1].x, vRefract[1].yz ) ).g;
-    	refractedColor.b = textureCube( tCube, vec3( -vRefract[2].x, vRefract[2].yz ) ).b;
+    '	refractedColor.r = textureCube( tCube, vec3( -vRefract[0].x, vRefract[0].yz ) ).r;',
+    '	refractedColor.g = textureCube( tCube, vec3( -vRefract[1].x, vRefract[1].yz ) ).g;',
+    '	refractedColor.b = textureCube( tCube, vec3( -vRefract[2].x, vRefract[2].yz ) ).b;',
 
-    	gl_FragColor = mix( refractedColor, reflectedColor, clamp( vReflectionFactor, 0.0, 1.0 ) );
+    '	gl_FragColor = mix( refractedColor, reflectedColor, clamp( vReflectionFactor, 0.0, 1.0 ) );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 }
diff --git a/src/shaders/GammaCorrectionShader.ts b/src/shaders/GammaCorrectionShader.ts
index 0b5173c0..00f0425d 100644
--- a/src/shaders/GammaCorrectionShader.ts
+++ b/src/shaders/GammaCorrectionShader.ts
@@ -17,32 +17,32 @@ export const GammaCorrectionShader: IGammaCorrectionShader = {
     tDiffuse: { value: null },
   },
 
-  vertexShader: /* glsl */ `
-    varying vec2 vUv;
+  vertexShader: [
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vUv = uv;
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    '	vUv = uv;',
+    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    uniform sampler2D tDiffuse;
+  fragmentShader: [
+    'uniform sampler2D tDiffuse;',
 
-    varying vec2 vUv;
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vec4 tex = texture2D( tDiffuse, vUv );
+    '	vec4 tex = texture2D( tDiffuse, vUv );',
 
-    	#ifdef LinearTosRGB
-    		gl_FragColor = LinearTosRGB( tex );
-    	#else
-    		gl_FragColor = sRGBTransferOETF( tex );
-    	#endif
+    '	#ifdef LinearTosRGB',
+    '		gl_FragColor = LinearTosRGB( tex );',
+    '	#else',
+    '		gl_FragColor = sRGBTransferOETF( tex );',
+    '	#endif',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 }
diff --git a/src/shaders/GodRaysShader.ts b/src/shaders/GodRaysShader.ts
index c3c0f1fa..6cfa2629 100644
--- a/src/shaders/GodRaysShader.ts
+++ b/src/shaders/GodRaysShader.ts
@@ -25,28 +25,28 @@ export const GodRaysDepthMaskShader = {
     },
   },
 
-  vertexShader: /* glsl */ `
-    varying vec2 vUv;
+  vertexShader: [
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-     vUv = uv;
-     gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    ' vUv = uv;',
+    ' gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    varying vec2 vUv;
+  fragmentShader: [
+    'varying vec2 vUv;',
 
-    uniform sampler2D tInput;
+    'uniform sampler2D tInput;',
 
-    void main() {
+    'void main() {',
 
-    	gl_FragColor = vec4( 1.0 ) - texture2D( tInput, vUv );
+    '	gl_FragColor = vec4( 1.0 ) - texture2D( tInput, vUv );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 }
 
 /**
@@ -73,62 +73,62 @@ export const GodRaysGenerateShader = {
       value: 1.0,
     },
     vSunPositionScreenSpace: {
-      value: /* @__PURE__ */ new Vector3(),
+      value: new Vector3(),
     },
   },
 
-  vertexShader: /* glsl */ `
-    varying vec2 vUv;
+  vertexShader: [
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-     vUv = uv;
-     gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    ' vUv = uv;',
+    ' gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    #define TAPS_PER_PASS 6.0
+  fragmentShader: [
+    '#define TAPS_PER_PASS 6.0',
 
-    varying vec2 vUv;
+    'varying vec2 vUv;',
 
-    uniform sampler2D tInput;
+    'uniform sampler2D tInput;',
 
-    uniform vec3 vSunPositionScreenSpace;
-    uniform float fStepSize; // filter step size
+    'uniform vec3 vSunPositionScreenSpace;',
+    'uniform float fStepSize;', // filter step size
 
-    void main() {
+    'void main() {',
 
     // delta from current pixel to "sun" position
 
-    	vec2 delta = vSunPositionScreenSpace.xy - vUv;
-    	float dist = length( delta );
+    '	vec2 delta = vSunPositionScreenSpace.xy - vUv;',
+    '	float dist = length( delta );',
 
     // Step vector (uv space)
 
-    	vec2 stepv = fStepSize * delta / dist;
+    '	vec2 stepv = fStepSize * delta / dist;',
 
     // Number of iterations between pixel and sun
 
-    	float iters = dist/fStepSize;
+    '	float iters = dist/fStepSize;',
 
-    	vec2 uv = vUv.xy;
-    	float col = 0.0;
+    '	vec2 uv = vUv.xy;',
+    '	float col = 0.0;',
 
     // This breaks ANGLE in Chrome 22
     //	- see http://code.google.com/p/chromium/issues/detail?id=153105
 
     /*
 		// Unrolling didnt do much on my hardware (ATI Mobility Radeon 3450),
-		// so ive just left the loop
+		// so i've just left the loop
 
 		"for ( float i = 0.0; i < TAPS_PER_PASS; i += 1.0 ) {",
 
 		// Accumulate samples, making sure we dont walk past the light source.
 
 		// The check for uv.y < 1 would not be necessary with "border" UV wrap
-		// mode, with a black border color. I dont think this is currently
+		// mode, with a black border color. I don't think this is currently
 		// exposed by three.js. As a result there might be artifacts when the
 		// sun is to the left, right or bottom of screen as these cases are
 		// not specifically handled.
@@ -141,38 +141,38 @@ export const GodRaysGenerateShader = {
 
     // Unrolling loop manually makes it work in ANGLE
 
-    	float f = min( 1.0, max( vSunPositionScreenSpace.z / 1000.0, 0.0 ) ); // used to fade out godrays
+    '	float f = min( 1.0, max( vSunPositionScreenSpace.z / 1000.0, 0.0 ) );', // used to fade out godrays
 
-    	if ( 0.0 <= iters && uv.y < 1.0 ) col += texture2D( tInput, uv ).r * f;
-    	uv += stepv;
+    '	if ( 0.0 <= iters && uv.y < 1.0 ) col += texture2D( tInput, uv ).r * f;',
+    '	uv += stepv;',
 
-    	if ( 1.0 <= iters && uv.y < 1.0 ) col += texture2D( tInput, uv ).r * f;
-    	uv += stepv;
+    '	if ( 1.0 <= iters && uv.y < 1.0 ) col += texture2D( tInput, uv ).r * f;',
+    '	uv += stepv;',
 
-    	if ( 2.0 <= iters && uv.y < 1.0 ) col += texture2D( tInput, uv ).r * f;
-    	uv += stepv;
+    '	if ( 2.0 <= iters && uv.y < 1.0 ) col += texture2D( tInput, uv ).r * f;',
+    '	uv += stepv;',
 
-    	if ( 3.0 <= iters && uv.y < 1.0 ) col += texture2D( tInput, uv ).r * f;
-    	uv += stepv;
+    '	if ( 3.0 <= iters && uv.y < 1.0 ) col += texture2D( tInput, uv ).r * f;',
+    '	uv += stepv;',
 
-    	if ( 4.0 <= iters && uv.y < 1.0 ) col += texture2D( tInput, uv ).r * f;
-    	uv += stepv;
+    '	if ( 4.0 <= iters && uv.y < 1.0 ) col += texture2D( tInput, uv ).r * f;',
+    '	uv += stepv;',
 
-    	if ( 5.0 <= iters && uv.y < 1.0 ) col += texture2D( tInput, uv ).r * f;
-    	uv += stepv;
+    '	if ( 5.0 <= iters && uv.y < 1.0 ) col += texture2D( tInput, uv ).r * f;',
+    '	uv += stepv;',
 
-    // Should technically be dividing by iters but TAPS_PER_PASS smooths out
+    // Should technically be dividing by 'iters', but 'TAPS_PER_PASS' smooths out
     // objectionable artifacts, in particular near the sun position. The side
     // effect is that the result is darker than it should be around the sun, as
     // TAPS_PER_PASS is greater than the number of samples actually accumulated.
-    // When the result is inverted (in the shader godrays_combine this produces
+    // When the result is inverted (in the shader 'godrays_combine', this produces
     // a slight bright spot at the position of the sun, even when it is occluded.
 
-    	gl_FragColor = vec4( col/TAPS_PER_PASS );
-    	gl_FragColor.a = 1.0;
+    '	gl_FragColor = vec4( col/TAPS_PER_PASS );',
+    '	gl_FragColor.a = 1.0;',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 }
 
 /**
@@ -195,36 +195,36 @@ export const GodRaysCombineShader = {
     },
   },
 
-  vertexShader: /* glsl */ `
-    varying vec2 vUv;
+  vertexShader: [
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vUv = uv;
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    '	vUv = uv;',
+    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    varying vec2 vUv;
+  fragmentShader: [
+    'varying vec2 vUv;',
 
-    uniform sampler2D tColors;
-    uniform sampler2D tGodRays;
+    'uniform sampler2D tColors;',
+    'uniform sampler2D tGodRays;',
 
-    uniform float fGodRayIntensity;
+    'uniform float fGodRayIntensity;',
 
-    void main() {
+    'void main() {',
 
     // Since THREE.MeshDepthMaterial renders foreground objects white and background
     // objects black, the god-rays will be white streaks. Therefore value is inverted
     // before being combined with tColors
 
-    	gl_FragColor = texture2D( tColors, vUv ) + fGodRayIntensity * vec4( 1.0 - texture2D( tGodRays, vUv ).r );
-    	gl_FragColor.a = 1.0;
+    '	gl_FragColor = texture2D( tColors, vUv ) + fGodRayIntensity * vec4( 1.0 - texture2D( tGodRays, vUv ).r );',
+    '	gl_FragColor.a = 1.0;',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 }
 
 /**
@@ -235,7 +235,7 @@ export const GodRaysCombineShader = {
 export const GodRaysFakeSunShader = {
   uniforms: {
     vSunPositionScreenSpace: {
-      value: /* @__PURE__ */ new Vector3(),
+      value: new Vector3(),
     },
 
     fAspect: {
@@ -243,48 +243,48 @@ export const GodRaysFakeSunShader = {
     },
 
     sunColor: {
-      value: /* @__PURE__ */ new Color(0xffee00),
+      value: new Color(0xffee00),
     },
 
     bgColor: {
-      value: /* @__PURE__ */ new Color(0x000000),
+      value: new Color(0x000000),
     },
   },
 
-  vertexShader: /* glsl */ `
-    varying vec2 vUv;
+  vertexShader: [
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vUv = uv;
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    '	vUv = uv;',
+    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    varying vec2 vUv;
+  fragmentShader: [
+    'varying vec2 vUv;',
 
-    uniform vec3 vSunPositionScreenSpace;
-    uniform float fAspect;
+    'uniform vec3 vSunPositionScreenSpace;',
+    'uniform float fAspect;',
 
-    uniform vec3 sunColor;
-    uniform vec3 bgColor;
+    'uniform vec3 sunColor;',
+    'uniform vec3 bgColor;',
 
-    void main() {
+    'void main() {',
 
-    	vec2 diff = vUv - vSunPositionScreenSpace.xy;
+    '	vec2 diff = vUv - vSunPositionScreenSpace.xy;',
 
     // Correct for aspect ratio
 
-    	diff.x *= fAspect;
+    '	diff.x *= fAspect;',
 
-    	float prop = clamp( length( diff ) / 0.5, 0.0, 1.0 );
-    	prop = 0.35 * pow( 1.0 - prop, 3.0 );
+    '	float prop = clamp( length( diff ) / 0.5, 0.0, 1.0 );',
+    '	prop = 0.35 * pow( 1.0 - prop, 3.0 );',
 
-    	gl_FragColor.xyz = ( vSunPositionScreenSpace.z > 0.0 ) ? mix( sunColor, bgColor, 1.0 - prop ) : bgColor;
-    	gl_FragColor.w = 1.0;
+    '	gl_FragColor.xyz = ( vSunPositionScreenSpace.z > 0.0 ) ? mix( sunColor, bgColor, 1.0 - prop ) : bgColor;',
+    '	gl_FragColor.w = 1.0;',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 }
diff --git a/src/shaders/HalftoneShader.ts b/src/shaders/HalftoneShader.ts
index 2bbf5104..47eed4a8 100644
--- a/src/shaders/HalftoneShader.ts
+++ b/src/shaders/HalftoneShader.ts
@@ -22,285 +22,285 @@ export const HalftoneShader = {
     disable: { value: false },
   },
 
-  vertexShader: /* glsl */ `
-    varying vec2 vUV;
-
-    void main() {
-
-    	vUV = uv;
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
-
-    }
-  `,
-
-  fragmentShader: /* glsl */ `
-    #define SQRT2_MINUS_ONE 0.41421356
-    #define SQRT2_HALF_MINUS_ONE 0.20710678
-    #define PI2 6.28318531
-    #define SHAPE_DOT 1
-    #define SHAPE_ELLIPSE 2
-    #define SHAPE_LINE 3
-    #define SHAPE_SQUARE 4
-    #define BLENDING_LINEAR 1
-    #define BLENDING_MULTIPLY 2
-    #define BLENDING_ADD 3
-    #define BLENDING_LIGHTER 4
-    #define BLENDING_DARKER 5
-    uniform sampler2D tDiffuse;
-    uniform float radius;
-    uniform float rotateR;
-    uniform float rotateG;
-    uniform float rotateB;
-    uniform float scatter;
-    uniform float width;
-    uniform float height;
-    uniform int shape;
-    uniform bool disable;
-    uniform float blending;
-    uniform int blendingMode;
-    varying vec2 vUV;
-    uniform bool greyscale;
-    const int samples = 8;
-
-    float blend( float a, float b, float t ) {
+  vertexShader: [
+    'varying vec2 vUV;',
+
+    'void main() {',
+
+    '	vUV = uv;',
+    '	gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);',
+
+    '}',
+  ].join('\n'),
+
+  fragmentShader: [
+    '#define SQRT2_MINUS_ONE 0.41421356',
+    '#define SQRT2_HALF_MINUS_ONE 0.20710678',
+    '#define PI2 6.28318531',
+    '#define SHAPE_DOT 1',
+    '#define SHAPE_ELLIPSE 2',
+    '#define SHAPE_LINE 3',
+    '#define SHAPE_SQUARE 4',
+    '#define BLENDING_LINEAR 1',
+    '#define BLENDING_MULTIPLY 2',
+    '#define BLENDING_ADD 3',
+    '#define BLENDING_LIGHTER 4',
+    '#define BLENDING_DARKER 5',
+    'uniform sampler2D tDiffuse;',
+    'uniform float radius;',
+    'uniform float rotateR;',
+    'uniform float rotateG;',
+    'uniform float rotateB;',
+    'uniform float scatter;',
+    'uniform float width;',
+    'uniform float height;',
+    'uniform int shape;',
+    'uniform bool disable;',
+    'uniform float blending;',
+    'uniform int blendingMode;',
+    'varying vec2 vUV;',
+    'uniform bool greyscale;',
+    'const int samples = 8;',
+
+    'float blend( float a, float b, float t ) {',
 
     // linear blend
-    	return a * ( 1.0 - t ) + b * t;
+    '	return a * ( 1.0 - t ) + b * t;',
 
-    }
+    '}',
 
-    float hypot( float x, float y ) {
+    'float hypot( float x, float y ) {',
 
     // vector magnitude
-    	return sqrt( x * x + y * y );
+    '	return sqrt( x * x + y * y );',
 
-    }
+    '}',
 
-    float rand( vec2 seed ){
+    'float rand( vec2 seed ){',
 
     // get pseudo-random number
-    return fract( sin( dot( seed.xy, vec2( 12.9898, 78.233 ) ) ) * 43758.5453 );
+    'return fract( sin( dot( seed.xy, vec2( 12.9898, 78.233 ) ) ) * 43758.5453 );',
 
-    }
+    '}',
 
-    float distanceToDotRadius( float channel, vec2 coord, vec2 normal, vec2 p, float angle, float rad_max ) {
+    'float distanceToDotRadius( float channel, vec2 coord, vec2 normal, vec2 p, float angle, float rad_max ) {',
 
     // apply shape-specific transforms
-    	float dist = hypot( coord.x - p.x, coord.y - p.y );
-    	float rad = channel;
+    '	float dist = hypot( coord.x - p.x, coord.y - p.y );',
+    '	float rad = channel;',
 
-    	if ( shape == SHAPE_DOT ) {
+    '	if ( shape == SHAPE_DOT ) {',
 
-    		rad = pow( abs( rad ), 1.125 ) * rad_max;
+    '		rad = pow( abs( rad ), 1.125 ) * rad_max;',
 
-    	} else if ( shape == SHAPE_ELLIPSE ) {
+    '	} else if ( shape == SHAPE_ELLIPSE ) {',
 
-    		rad = pow( abs( rad ), 1.125 ) * rad_max;
+    '		rad = pow( abs( rad ), 1.125 ) * rad_max;',
 
-    		if ( dist != 0.0 ) {
-    			float dot_p = abs( ( p.x - coord.x ) / dist * normal.x + ( p.y - coord.y ) / dist * normal.y );
-    			dist = ( dist * ( 1.0 - SQRT2_HALF_MINUS_ONE ) ) + dot_p * dist * SQRT2_MINUS_ONE;
-    		}
+    '		if ( dist != 0.0 ) {',
+    '			float dot_p = abs( ( p.x - coord.x ) / dist * normal.x + ( p.y - coord.y ) / dist * normal.y );',
+    '			dist = ( dist * ( 1.0 - SQRT2_HALF_MINUS_ONE ) ) + dot_p * dist * SQRT2_MINUS_ONE;',
+    '		}',
 
-    	} else if ( shape == SHAPE_LINE ) {
+    '	} else if ( shape == SHAPE_LINE ) {',
 
-    		rad = pow( abs( rad ), 1.5) * rad_max;
-    		float dot_p = ( p.x - coord.x ) * normal.x + ( p.y - coord.y ) * normal.y;
-    		dist = hypot( normal.x * dot_p, normal.y * dot_p );
+    '		rad = pow( abs( rad ), 1.5) * rad_max;',
+    '		float dot_p = ( p.x - coord.x ) * normal.x + ( p.y - coord.y ) * normal.y;',
+    '		dist = hypot( normal.x * dot_p, normal.y * dot_p );',
 
-    	} else if ( shape == SHAPE_SQUARE ) {
+    '	} else if ( shape == SHAPE_SQUARE ) {',
 
-    		float theta = atan( p.y - coord.y, p.x - coord.x ) - angle;
-    		float sin_t = abs( sin( theta ) );
-    		float cos_t = abs( cos( theta ) );
-    		rad = pow( abs( rad ), 1.4 );
-    		rad = rad_max * ( rad + ( ( sin_t > cos_t ) ? rad - sin_t * rad : rad - cos_t * rad ) );
+    '		float theta = atan( p.y - coord.y, p.x - coord.x ) - angle;',
+    '		float sin_t = abs( sin( theta ) );',
+    '		float cos_t = abs( cos( theta ) );',
+    '		rad = pow( abs( rad ), 1.4 );',
+    '		rad = rad_max * ( rad + ( ( sin_t > cos_t ) ? rad - sin_t * rad : rad - cos_t * rad ) );',
 
-    	}
+    '	}',
 
-    	return rad - dist;
+    '	return rad - dist;',
 
-    }
+    '}',
 
-    struct Cell {
+    'struct Cell {',
 
     // grid sample positions
-    	vec2 normal;
-    	vec2 p1;
-    	vec2 p2;
-    	vec2 p3;
-    	vec2 p4;
-    	float samp2;
-    	float samp1;
-    	float samp3;
-    	float samp4;
+    '	vec2 normal;',
+    '	vec2 p1;',
+    '	vec2 p2;',
+    '	vec2 p3;',
+    '	vec2 p4;',
+    '	float samp2;',
+    '	float samp1;',
+    '	float samp3;',
+    '	float samp4;',
 
-    };
+    '};',
 
-    vec4 getSample( vec2 point ) {
+    'vec4 getSample( vec2 point ) {',
 
     // multi-sampled point
-    	vec4 tex = texture2D( tDiffuse, vec2( point.x / width, point.y / height ) );
-    	float base = rand( vec2( floor( point.x ), floor( point.y ) ) ) * PI2;
-    	float step = PI2 / float( samples );
-    	float dist = radius * 0.66;
+    '	vec4 tex = texture2D( tDiffuse, vec2( point.x / width, point.y / height ) );',
+    '	float base = rand( vec2( floor( point.x ), floor( point.y ) ) ) * PI2;',
+    '	float step = PI2 / float( samples );',
+    '	float dist = radius * 0.66;',
 
-    	for ( int i = 0; i < samples; ++i ) {
+    '	for ( int i = 0; i < samples; ++i ) {',
 
-    		float r = base + step * float( i );
-    		vec2 coord = point + vec2( cos( r ) * dist, sin( r ) * dist );
-    		tex += texture2D( tDiffuse, vec2( coord.x / width, coord.y / height ) );
+    '		float r = base + step * float( i );',
+    '		vec2 coord = point + vec2( cos( r ) * dist, sin( r ) * dist );',
+    '		tex += texture2D( tDiffuse, vec2( coord.x / width, coord.y / height ) );',
 
-    	}
+    '	}',
 
-    	tex /= float( samples ) + 1.0;
-    	return tex;
+    '	tex /= float( samples ) + 1.0;',
+    '	return tex;',
 
-    }
+    '}',
 
-    float getDotColour( Cell c, vec2 p, int channel, float angle, float aa ) {
+    'float getDotColour( Cell c, vec2 p, int channel, float angle, float aa ) {',
 
     // get colour for given point
-    	float dist_c_1, dist_c_2, dist_c_3, dist_c_4, res;
+    '	float dist_c_1, dist_c_2, dist_c_3, dist_c_4, res;',
 
-    	if ( channel == 0 ) {
+    '	if ( channel == 0 ) {',
 
-    		c.samp1 = getSample( c.p1 ).r;
-    		c.samp2 = getSample( c.p2 ).r;
-    		c.samp3 = getSample( c.p3 ).r;
-    		c.samp4 = getSample( c.p4 ).r;
+    '		c.samp1 = getSample( c.p1 ).r;',
+    '		c.samp2 = getSample( c.p2 ).r;',
+    '		c.samp3 = getSample( c.p3 ).r;',
+    '		c.samp4 = getSample( c.p4 ).r;',
 
-    	} else if (channel == 1) {
+    '	} else if (channel == 1) {',
 
-    		c.samp1 = getSample( c.p1 ).g;
-    		c.samp2 = getSample( c.p2 ).g;
-    		c.samp3 = getSample( c.p3 ).g;
-    		c.samp4 = getSample( c.p4 ).g;
+    '		c.samp1 = getSample( c.p1 ).g;',
+    '		c.samp2 = getSample( c.p2 ).g;',
+    '		c.samp3 = getSample( c.p3 ).g;',
+    '		c.samp4 = getSample( c.p4 ).g;',
 
-    	} else {
+    '	} else {',
 
-    		c.samp1 = getSample( c.p1 ).b;
-    		c.samp3 = getSample( c.p3 ).b;
-    		c.samp2 = getSample( c.p2 ).b;
-    		c.samp4 = getSample( c.p4 ).b;
+    '		c.samp1 = getSample( c.p1 ).b;',
+    '		c.samp3 = getSample( c.p3 ).b;',
+    '		c.samp2 = getSample( c.p2 ).b;',
+    '		c.samp4 = getSample( c.p4 ).b;',
 
-    	}
+    '	}',
 
-    	dist_c_1 = distanceToDotRadius( c.samp1, c.p1, c.normal, p, angle, radius );
-    	dist_c_2 = distanceToDotRadius( c.samp2, c.p2, c.normal, p, angle, radius );
-    	dist_c_3 = distanceToDotRadius( c.samp3, c.p3, c.normal, p, angle, radius );
-    	dist_c_4 = distanceToDotRadius( c.samp4, c.p4, c.normal, p, angle, radius );
-    	res = ( dist_c_1 > 0.0 ) ? clamp( dist_c_1 / aa, 0.0, 1.0 ) : 0.0;
-    	res += ( dist_c_2 > 0.0 ) ? clamp( dist_c_2 / aa, 0.0, 1.0 ) : 0.0;
-    	res += ( dist_c_3 > 0.0 ) ? clamp( dist_c_3 / aa, 0.0, 1.0 ) : 0.0;
-    	res += ( dist_c_4 > 0.0 ) ? clamp( dist_c_4 / aa, 0.0, 1.0 ) : 0.0;
-    	res = clamp( res, 0.0, 1.0 );
+    '	dist_c_1 = distanceToDotRadius( c.samp1, c.p1, c.normal, p, angle, radius );',
+    '	dist_c_2 = distanceToDotRadius( c.samp2, c.p2, c.normal, p, angle, radius );',
+    '	dist_c_3 = distanceToDotRadius( c.samp3, c.p3, c.normal, p, angle, radius );',
+    '	dist_c_4 = distanceToDotRadius( c.samp4, c.p4, c.normal, p, angle, radius );',
+    '	res = ( dist_c_1 > 0.0 ) ? clamp( dist_c_1 / aa, 0.0, 1.0 ) : 0.0;',
+    '	res += ( dist_c_2 > 0.0 ) ? clamp( dist_c_2 / aa, 0.0, 1.0 ) : 0.0;',
+    '	res += ( dist_c_3 > 0.0 ) ? clamp( dist_c_3 / aa, 0.0, 1.0 ) : 0.0;',
+    '	res += ( dist_c_4 > 0.0 ) ? clamp( dist_c_4 / aa, 0.0, 1.0 ) : 0.0;',
+    '	res = clamp( res, 0.0, 1.0 );',
 
-    	return res;
+    '	return res;',
 
-    }
+    '}',
 
-    Cell getReferenceCell( vec2 p, vec2 origin, float grid_angle, float step ) {
+    'Cell getReferenceCell( vec2 p, vec2 origin, float grid_angle, float step ) {',
 
     // get containing cell
-    	Cell c;
+    '	Cell c;',
 
     // calc grid
-    	vec2 n = vec2( cos( grid_angle ), sin( grid_angle ) );
-    	float threshold = step * 0.5;
-    	float dot_normal = n.x * ( p.x - origin.x ) + n.y * ( p.y - origin.y );
-    	float dot_line = -n.y * ( p.x - origin.x ) + n.x * ( p.y - origin.y );
-    	vec2 offset = vec2( n.x * dot_normal, n.y * dot_normal );
-    	float offset_normal = mod( hypot( offset.x, offset.y ), step );
-    	float normal_dir = ( dot_normal < 0.0 ) ? 1.0 : -1.0;
-    	float normal_scale = ( ( offset_normal < threshold ) ? -offset_normal : step - offset_normal ) * normal_dir;
-    	float offset_line = mod( hypot( ( p.x - offset.x ) - origin.x, ( p.y - offset.y ) - origin.y ), step );
-    	float line_dir = ( dot_line < 0.0 ) ? 1.0 : -1.0;
-    	float line_scale = ( ( offset_line < threshold ) ? -offset_line : step - offset_line ) * line_dir;
+    '	vec2 n = vec2( cos( grid_angle ), sin( grid_angle ) );',
+    '	float threshold = step * 0.5;',
+    '	float dot_normal = n.x * ( p.x - origin.x ) + n.y * ( p.y - origin.y );',
+    '	float dot_line = -n.y * ( p.x - origin.x ) + n.x * ( p.y - origin.y );',
+    '	vec2 offset = vec2( n.x * dot_normal, n.y * dot_normal );',
+    '	float offset_normal = mod( hypot( offset.x, offset.y ), step );',
+    '	float normal_dir = ( dot_normal < 0.0 ) ? 1.0 : -1.0;',
+    '	float normal_scale = ( ( offset_normal < threshold ) ? -offset_normal : step - offset_normal ) * normal_dir;',
+    '	float offset_line = mod( hypot( ( p.x - offset.x ) - origin.x, ( p.y - offset.y ) - origin.y ), step );',
+    '	float line_dir = ( dot_line < 0.0 ) ? 1.0 : -1.0;',
+    '	float line_scale = ( ( offset_line < threshold ) ? -offset_line : step - offset_line ) * line_dir;',
 
     // get closest corner
-    	c.normal = n;
-    	c.p1.x = p.x - n.x * normal_scale + n.y * line_scale;
-    	c.p1.y = p.y - n.y * normal_scale - n.x * line_scale;
+    '	c.normal = n;',
+    '	c.p1.x = p.x - n.x * normal_scale + n.y * line_scale;',
+    '	c.p1.y = p.y - n.y * normal_scale - n.x * line_scale;',
 
     // scatter
-    	if ( scatter != 0.0 ) {
+    '	if ( scatter != 0.0 ) {',
 
-    		float off_mag = scatter * threshold * 0.5;
-    		float off_angle = rand( vec2( floor( c.p1.x ), floor( c.p1.y ) ) ) * PI2;
-    		c.p1.x += cos( off_angle ) * off_mag;
-    		c.p1.y += sin( off_angle ) * off_mag;
+    '		float off_mag = scatter * threshold * 0.5;',
+    '		float off_angle = rand( vec2( floor( c.p1.x ), floor( c.p1.y ) ) ) * PI2;',
+    '		c.p1.x += cos( off_angle ) * off_mag;',
+    '		c.p1.y += sin( off_angle ) * off_mag;',
 
-    	}
+    '	}',
 
     // find corners
-    	float normal_step = normal_dir * ( ( offset_normal < threshold ) ? step : -step );
-    	float line_step = line_dir * ( ( offset_line < threshold ) ? step : -step );
-    	c.p2.x = c.p1.x - n.x * normal_step;
-    	c.p2.y = c.p1.y - n.y * normal_step;
-    	c.p3.x = c.p1.x + n.y * line_step;
-    	c.p3.y = c.p1.y - n.x * line_step;
-    	c.p4.x = c.p1.x - n.x * normal_step + n.y * line_step;
-    	c.p4.y = c.p1.y - n.y * normal_step - n.x * line_step;
+    '	float normal_step = normal_dir * ( ( offset_normal < threshold ) ? step : -step );',
+    '	float line_step = line_dir * ( ( offset_line < threshold ) ? step : -step );',
+    '	c.p2.x = c.p1.x - n.x * normal_step;',
+    '	c.p2.y = c.p1.y - n.y * normal_step;',
+    '	c.p3.x = c.p1.x + n.y * line_step;',
+    '	c.p3.y = c.p1.y - n.x * line_step;',
+    '	c.p4.x = c.p1.x - n.x * normal_step + n.y * line_step;',
+    '	c.p4.y = c.p1.y - n.y * normal_step - n.x * line_step;',
 
-    	return c;
+    '	return c;',
 
-    }
+    '}',
 
-    float blendColour( float a, float b, float t ) {
+    'float blendColour( float a, float b, float t ) {',
 
     // blend colours
-    	if ( blendingMode == BLENDING_LINEAR ) {
-    		return blend( a, b, 1.0 - t );
-    	} else if ( blendingMode == BLENDING_ADD ) {
-    		return blend( a, min( 1.0, a + b ), t );
-    	} else if ( blendingMode == BLENDING_MULTIPLY ) {
-    		return blend( a, max( 0.0, a * b ), t );
-    	} else if ( blendingMode == BLENDING_LIGHTER ) {
-    		return blend( a, max( a, b ), t );
-    	} else if ( blendingMode == BLENDING_DARKER ) {
-    		return blend( a, min( a, b ), t );
-    	} else {
-    		return blend( a, b, 1.0 - t );
-    	}
-
-    }
-
-    void main() {
-
-    	if ( ! disable ) {
+    '	if ( blendingMode == BLENDING_LINEAR ) {',
+    '		return blend( a, b, 1.0 - t );',
+    '	} else if ( blendingMode == BLENDING_ADD ) {',
+    '		return blend( a, min( 1.0, a + b ), t );',
+    '	} else if ( blendingMode == BLENDING_MULTIPLY ) {',
+    '		return blend( a, max( 0.0, a * b ), t );',
+    '	} else if ( blendingMode == BLENDING_LIGHTER ) {',
+    '		return blend( a, max( a, b ), t );',
+    '	} else if ( blendingMode == BLENDING_DARKER ) {',
+    '		return blend( a, min( a, b ), t );',
+    '	} else {',
+    '		return blend( a, b, 1.0 - t );',
+    '	}',
+
+    '}',
+
+    'void main() {',
+
+    '	if ( ! disable ) {',
 
     // setup
-    		vec2 p = vec2( vUV.x * width, vUV.y * height );
-    		vec2 origin = vec2( 0, 0 );
-    		float aa = ( radius < 2.5 ) ? radius * 0.5 : 1.25;
+    '		vec2 p = vec2( vUV.x * width, vUV.y * height );',
+    '		vec2 origin = vec2( 0, 0 );',
+    '		float aa = ( radius < 2.5 ) ? radius * 0.5 : 1.25;',
 
     // get channel samples
-    		Cell cell_r = getReferenceCell( p, origin, rotateR, radius );
-    		Cell cell_g = getReferenceCell( p, origin, rotateG, radius );
-    		Cell cell_b = getReferenceCell( p, origin, rotateB, radius );
-    		float r = getDotColour( cell_r, p, 0, rotateR, aa );
-    		float g = getDotColour( cell_g, p, 1, rotateG, aa );
-    		float b = getDotColour( cell_b, p, 2, rotateB, aa );
+    '		Cell cell_r = getReferenceCell( p, origin, rotateR, radius );',
+    '		Cell cell_g = getReferenceCell( p, origin, rotateG, radius );',
+    '		Cell cell_b = getReferenceCell( p, origin, rotateB, radius );',
+    '		float r = getDotColour( cell_r, p, 0, rotateR, aa );',
+    '		float g = getDotColour( cell_g, p, 1, rotateG, aa );',
+    '		float b = getDotColour( cell_b, p, 2, rotateB, aa );',
 
     // blend with original
-    		vec4 colour = texture2D( tDiffuse, vUV );
-    		r = blendColour( r, colour.r, blending );
-    		g = blendColour( g, colour.g, blending );
-    		b = blendColour( b, colour.b, blending );
+    '		vec4 colour = texture2D( tDiffuse, vUV );',
+    '		r = blendColour( r, colour.r, blending );',
+    '		g = blendColour( g, colour.g, blending );',
+    '		b = blendColour( b, colour.b, blending );',
 
-    		if ( greyscale ) {
-    			r = g = b = (r + b + g) / 3.0;
-    		}
+    '		if ( greyscale ) {',
+    '			r = g = b = (r + b + g) / 3.0;',
+    '		}',
 
-    		gl_FragColor = vec4( r, g, b, 1.0 );
+    '		gl_FragColor = vec4( r, g, b, 1.0 );',
 
-    	} else {
+    '	} else {',
 
-    		gl_FragColor = texture2D( tDiffuse, vUV );
+    '		gl_FragColor = texture2D( tDiffuse, vUV );',
 
-    	}
+    '	}',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 }
diff --git a/src/shaders/HorizontalTiltShiftShader.ts b/src/shaders/HorizontalTiltShiftShader.ts
index ab395017..62fe7f14 100644
--- a/src/shaders/HorizontalTiltShiftShader.ts
+++ b/src/shaders/HorizontalTiltShiftShader.ts
@@ -14,42 +14,42 @@ export const HorizontalTiltShiftShader = {
     r: { value: 0.35 },
   },
 
-  vertexShader: /* glsl */ `
-    varying vec2 vUv;
+  vertexShader: [
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vUv = uv;
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    '	vUv = uv;',
+    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    uniform sampler2D tDiffuse;
-    uniform float h;
-    uniform float r;
+  fragmentShader: [
+    'uniform sampler2D tDiffuse;',
+    'uniform float h;',
+    'uniform float r;',
 
-    varying vec2 vUv;
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vec4 sum = vec4( 0.0 );
+    '	vec4 sum = vec4( 0.0 );',
 
-    	float hh = h * abs( r - vUv.y );
+    '	float hh = h * abs( r - vUv.y );',
 
-    	sum += texture2D( tDiffuse, vec2( vUv.x - 4.0 * hh, vUv.y ) ) * 0.051;
-    	sum += texture2D( tDiffuse, vec2( vUv.x - 3.0 * hh, vUv.y ) ) * 0.0918;
-    	sum += texture2D( tDiffuse, vec2( vUv.x - 2.0 * hh, vUv.y ) ) * 0.12245;
-    	sum += texture2D( tDiffuse, vec2( vUv.x - 1.0 * hh, vUv.y ) ) * 0.1531;
-    	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y ) ) * 0.1633;
-    	sum += texture2D( tDiffuse, vec2( vUv.x + 1.0 * hh, vUv.y ) ) * 0.1531;
-    	sum += texture2D( tDiffuse, vec2( vUv.x + 2.0 * hh, vUv.y ) ) * 0.12245;
-    	sum += texture2D( tDiffuse, vec2( vUv.x + 3.0 * hh, vUv.y ) ) * 0.0918;
-    	sum += texture2D( tDiffuse, vec2( vUv.x + 4.0 * hh, vUv.y ) ) * 0.051;
+    '	sum += texture2D( tDiffuse, vec2( vUv.x - 4.0 * hh, vUv.y ) ) * 0.051;',
+    '	sum += texture2D( tDiffuse, vec2( vUv.x - 3.0 * hh, vUv.y ) ) * 0.0918;',
+    '	sum += texture2D( tDiffuse, vec2( vUv.x - 2.0 * hh, vUv.y ) ) * 0.12245;',
+    '	sum += texture2D( tDiffuse, vec2( vUv.x - 1.0 * hh, vUv.y ) ) * 0.1531;',
+    '	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y ) ) * 0.1633;',
+    '	sum += texture2D( tDiffuse, vec2( vUv.x + 1.0 * hh, vUv.y ) ) * 0.1531;',
+    '	sum += texture2D( tDiffuse, vec2( vUv.x + 2.0 * hh, vUv.y ) ) * 0.12245;',
+    '	sum += texture2D( tDiffuse, vec2( vUv.x + 3.0 * hh, vUv.y ) ) * 0.0918;',
+    '	sum += texture2D( tDiffuse, vec2( vUv.x + 4.0 * hh, vUv.y ) ) * 0.051;',
 
-    	gl_FragColor = sum;
+    '	gl_FragColor = sum;',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 }
diff --git a/src/shaders/HueSaturationShader.ts b/src/shaders/HueSaturationShader.ts
index 6dbf9464..0fe823b9 100644
--- a/src/shaders/HueSaturationShader.ts
+++ b/src/shaders/HueSaturationShader.ts
@@ -12,48 +12,48 @@ export const HueSaturationShader = {
     saturation: { value: 0 },
   },
 
-  vertexShader: /* glsl */ `
-    varying vec2 vUv;
+  vertexShader: [
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vUv = uv;
+    '	vUv = uv;',
 
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    uniform sampler2D tDiffuse;
-    uniform float hue;
-    uniform float saturation;
+  fragmentShader: [
+    'uniform sampler2D tDiffuse;',
+    'uniform float hue;',
+    'uniform float saturation;',
 
-    varying vec2 vUv;
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	gl_FragColor = texture2D( tDiffuse, vUv );
+    '	gl_FragColor = texture2D( tDiffuse, vUv );',
 
     // hue
-    	float angle = hue * 3.14159265;
-    	float s = sin(angle), c = cos(angle);
-    	vec3 weights = (vec3(2.0 * c, -sqrt(3.0) * s - c, sqrt(3.0) * s - c) + 1.0) / 3.0;
-    	float len = length(gl_FragColor.rgb);
-    	gl_FragColor.rgb = vec3(
-    		dot(gl_FragColor.rgb, weights.xyz),
-    		dot(gl_FragColor.rgb, weights.zxy),
-    		dot(gl_FragColor.rgb, weights.yzx)
-    	);
+    '	float angle = hue * 3.14159265;',
+    '	float s = sin(angle), c = cos(angle);',
+    '	vec3 weights = (vec3(2.0 * c, -sqrt(3.0) * s - c, sqrt(3.0) * s - c) + 1.0) / 3.0;',
+    '	float len = length(gl_FragColor.rgb);',
+    '	gl_FragColor.rgb = vec3(',
+    '		dot(gl_FragColor.rgb, weights.xyz),',
+    '		dot(gl_FragColor.rgb, weights.zxy),',
+    '		dot(gl_FragColor.rgb, weights.yzx)',
+    '	);',
 
     // saturation
-    	float average = (gl_FragColor.r + gl_FragColor.g + gl_FragColor.b) / 3.0;
-    	if (saturation > 0.0) {
-    		gl_FragColor.rgb += (average - gl_FragColor.rgb) * (1.0 - 1.0 / (1.001 - saturation));
-    	} else {
-    		gl_FragColor.rgb += (average - gl_FragColor.rgb) * (-saturation);
-    	}
-
-    }
-  `,
+    '	float average = (gl_FragColor.r + gl_FragColor.g + gl_FragColor.b) / 3.0;',
+    '	if (saturation > 0.0) {',
+    '		gl_FragColor.rgb += (average - gl_FragColor.rgb) * (1.0 - 1.0 / (1.001 - saturation));',
+    '	} else {',
+    '		gl_FragColor.rgb += (average - gl_FragColor.rgb) * (-saturation);',
+    '	}',
+
+    '}',
+  ].join('\n'),
 }
diff --git a/src/shaders/KaleidoShader.ts b/src/shaders/KaleidoShader.ts
index 0c269141..a879be43 100644
--- a/src/shaders/KaleidoShader.ts
+++ b/src/shaders/KaleidoShader.ts
@@ -15,36 +15,36 @@ export const KaleidoShader = {
     angle: { value: 0.0 },
   },
 
-  vertexShader: /* glsl */ `
-    varying vec2 vUv;
+  vertexShader: [
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vUv = uv;
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    '	vUv = uv;',
+    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    uniform sampler2D tDiffuse;
-    uniform float sides;
-    uniform float angle;
+  fragmentShader: [
+    'uniform sampler2D tDiffuse;',
+    'uniform float sides;',
+    'uniform float angle;',
 
-    varying vec2 vUv;
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vec2 p = vUv - 0.5;
-    	float r = length(p);
-    	float a = atan(p.y, p.x) + angle;
-    	float tau = 2. * 3.1416 ;
-    	a = mod(a, tau/sides);
-    	a = abs(a - tau/sides/2.) ;
-    	p = r * vec2(cos(a), sin(a));
-    	vec4 color = texture2D(tDiffuse, p + 0.5);
-    	gl_FragColor = color;
+    '	vec2 p = vUv - 0.5;',
+    '	float r = length(p);',
+    '	float a = atan(p.y, p.x) + angle;',
+    '	float tau = 2. * 3.1416 ;',
+    '	a = mod(a, tau/sides);',
+    '	a = abs(a - tau/sides/2.) ;',
+    '	p = r * vec2(cos(a), sin(a));',
+    '	vec4 color = texture2D(tDiffuse, p + 0.5);',
+    '	gl_FragColor = color;',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 }
diff --git a/src/shaders/LuminosityHighPassShader.ts b/src/shaders/LuminosityHighPassShader.ts
index 7e08295f..88709b49 100644
--- a/src/shaders/LuminosityHighPassShader.ts
+++ b/src/shaders/LuminosityHighPassShader.ts
@@ -12,45 +12,45 @@ export const LuminosityHighPassShader = {
     tDiffuse: { value: null },
     luminosityThreshold: { value: 1.0 },
     smoothWidth: { value: 1.0 },
-    defaultColor: { value: /* @__PURE__ */ new Color(0x000000) },
+    defaultColor: { value: new Color(0x000000) },
     defaultOpacity: { value: 0.0 },
   },
 
-  vertexShader: /* glsl */ `
-    varying vec2 vUv;
+  vertexShader: [
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vUv = uv;
+    '	vUv = uv;',
 
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    uniform sampler2D tDiffuse;
-    uniform vec3 defaultColor;
-    uniform float defaultOpacity;
-    uniform float luminosityThreshold;
-    uniform float smoothWidth;
+  fragmentShader: [
+    'uniform sampler2D tDiffuse;',
+    'uniform vec3 defaultColor;',
+    'uniform float defaultOpacity;',
+    'uniform float luminosityThreshold;',
+    'uniform float smoothWidth;',
 
-    varying vec2 vUv;
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vec4 texel = texture2D( tDiffuse, vUv );
+    '	vec4 texel = texture2D( tDiffuse, vUv );',
 
-    	vec3 luma = vec3( 0.299, 0.587, 0.114 );
+    '	vec3 luma = vec3( 0.299, 0.587, 0.114 );',
 
-    	float v = dot( texel.xyz, luma );
+    '	float v = dot( texel.xyz, luma );',
 
-    	vec4 outputColor = vec4( defaultColor.rgb, defaultOpacity );
+    '	vec4 outputColor = vec4( defaultColor.rgb, defaultOpacity );',
 
-    	float alpha = smoothstep( luminosityThreshold, luminosityThreshold + smoothWidth, v );
+    '	float alpha = smoothstep( luminosityThreshold, luminosityThreshold + smoothWidth, v );',
 
-    	gl_FragColor = mix( outputColor, texel, alpha );
+    '	gl_FragColor = mix( outputColor, texel, alpha );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 }
diff --git a/src/shaders/LuminosityShader.ts b/src/shaders/LuminosityShader.ts
index 73053c53..149f7990 100644
--- a/src/shaders/LuminosityShader.ts
+++ b/src/shaders/LuminosityShader.ts
@@ -8,33 +8,33 @@ export const LuminosityShader = {
     tDiffuse: { value: null },
   },
 
-  vertexShader: /* glsl */ `
-    varying vec2 vUv;
+  vertexShader: [
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vUv = uv;
+    '	vUv = uv;',
 
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    #include <common>
+  fragmentShader: [
+    '#include <common>',
 
-    uniform sampler2D tDiffuse;
+    'uniform sampler2D tDiffuse;',
 
-    varying vec2 vUv;
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vec4 texel = texture2D( tDiffuse, vUv );
+    '	vec4 texel = texture2D( tDiffuse, vUv );',
 
-    	float l = linearToRelativeLuminance( texel.rgb );
+    '	float l = linearToRelativeLuminance( texel.rgb );',
 
-    	gl_FragColor = vec4( l, l, l, texel.w );
+    '	gl_FragColor = vec4( l, l, l, texel.w );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 }
diff --git a/src/shaders/MirrorShader.ts b/src/shaders/MirrorShader.ts
index 1c8f147d..bcfade64 100644
--- a/src/shaders/MirrorShader.ts
+++ b/src/shaders/MirrorShader.ts
@@ -11,38 +11,38 @@ export const MirrorShader = {
     side: { value: 1 },
   },
 
-  vertexShader: /* glsl */ `
-    varying vec2 vUv;
+  vertexShader: [
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vUv = uv;
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    '	vUv = uv;',
+    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    uniform sampler2D tDiffuse;
-    uniform int side;
+  fragmentShader: [
+    'uniform sampler2D tDiffuse;',
+    'uniform int side;',
 
-    varying vec2 vUv;
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vec2 p = vUv;
-    	if (side == 0){
-    		if (p.x > 0.5) p.x = 1.0 - p.x;
-    	}else if (side == 1){
-    		if (p.x < 0.5) p.x = 1.0 - p.x;
-    	}else if (side == 2){
-    		if (p.y < 0.5) p.y = 1.0 - p.y;
-    	}else if (side == 3){
-    		if (p.y > 0.5) p.y = 1.0 - p.y;
-    	} 
-    	vec4 color = texture2D(tDiffuse, p);
-    	gl_FragColor = color;
+    '	vec2 p = vUv;',
+    '	if (side == 0){',
+    '		if (p.x > 0.5) p.x = 1.0 - p.x;',
+    '	}else if (side == 1){',
+    '		if (p.x < 0.5) p.x = 1.0 - p.x;',
+    '	}else if (side == 2){',
+    '		if (p.y < 0.5) p.y = 1.0 - p.y;',
+    '	}else if (side == 3){',
+    '		if (p.y > 0.5) p.y = 1.0 - p.y;',
+    '	} ',
+    '	vec4 color = texture2D(tDiffuse, p);',
+    '	gl_FragColor = color;',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 }
diff --git a/src/shaders/NormalMapShader.ts b/src/shaders/NormalMapShader.ts
index a6813519..56258ad7 100644
--- a/src/shaders/NormalMapShader.ts
+++ b/src/shaders/NormalMapShader.ts
@@ -8,38 +8,38 @@ import { Vector2 } from 'three'
 export const NormalMapShader = {
   uniforms: {
     heightMap: { value: null },
-    resolution: { value: /* @__PURE__ */ new Vector2(512, 512) },
-    scale: { value: /* @__PURE__ */ new Vector2(1, 1) },
+    resolution: { value: new Vector2(512, 512) },
+    scale: { value: new Vector2(1, 1) },
     height: { value: 0.05 },
   },
 
-  vertexShader: /* glsl */ `
-    varying vec2 vUv;
+  vertexShader: [
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vUv = uv;
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    '	vUv = uv;',
+    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    uniform float height;
-    uniform vec2 resolution;
-    uniform sampler2D heightMap;
+  fragmentShader: [
+    'uniform float height;',
+    'uniform vec2 resolution;',
+    'uniform sampler2D heightMap;',
 
-    varying vec2 vUv;
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	float val = texture2D( heightMap, vUv ).x;
+    '	float val = texture2D( heightMap, vUv ).x;',
 
-    	float valU = texture2D( heightMap, vUv + vec2( 1.0 / resolution.x, 0.0 ) ).x;
-    	float valV = texture2D( heightMap, vUv + vec2( 0.0, 1.0 / resolution.y ) ).x;
+    '	float valU = texture2D( heightMap, vUv + vec2( 1.0 / resolution.x, 0.0 ) ).x;',
+    '	float valV = texture2D( heightMap, vUv + vec2( 0.0, 1.0 / resolution.y ) ).x;',
 
-    	gl_FragColor = vec4( ( 0.5 * normalize( vec3( val - valU, val - valV, height  ) ) + 0.5 ), 1.0 );
+    '	gl_FragColor = vec4( ( 0.5 * normalize( vec3( val - valU, val - valV, height  ) ) + 0.5 ), 1.0 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 }
diff --git a/src/shaders/ParallaxShader.ts b/src/shaders/ParallaxShader.ts
index ddb998d4..adc2f921 100644
--- a/src/shaders/ParallaxShader.ts
+++ b/src/shaders/ParallaxShader.ts
@@ -21,161 +21,161 @@ export const ParallaxShader = {
     parallaxMaxLayers: { value: null },
   },
 
-  vertexShader: /* glsl */ `
-    varying vec2 vUv;
-    varying vec3 vViewPosition;
-    varying vec3 vNormal;
+  vertexShader: [
+    'varying vec2 vUv;',
+    'varying vec3 vViewPosition;',
+    'varying vec3 vNormal;',
 
-    void main() {
+    'void main() {',
 
-    	vUv = uv;
-    	vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );
-    	vViewPosition = -mvPosition.xyz;
-    	vNormal = normalize( normalMatrix * normal );
-    	gl_Position = projectionMatrix * mvPosition;
+    '	vUv = uv;',
+    '	vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );',
+    '	vViewPosition = -mvPosition.xyz;',
+    '	vNormal = normalize( normalMatrix * normal );',
+    '	gl_Position = projectionMatrix * mvPosition;',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    uniform sampler2D bumpMap;
-    uniform sampler2D map;
+  fragmentShader: [
+    'uniform sampler2D bumpMap;',
+    'uniform sampler2D map;',
 
-    uniform float parallaxScale;
-    uniform float parallaxMinLayers;
-    uniform float parallaxMaxLayers;
+    'uniform float parallaxScale;',
+    'uniform float parallaxMinLayers;',
+    'uniform float parallaxMaxLayers;',
 
-    varying vec2 vUv;
-    varying vec3 vViewPosition;
-    varying vec3 vNormal;
+    'varying vec2 vUv;',
+    'varying vec3 vViewPosition;',
+    'varying vec3 vNormal;',
 
-    #ifdef USE_BASIC_PARALLAX
+    '#ifdef USE_BASIC_PARALLAX',
 
-    	vec2 parallaxMap( in vec3 V ) {
+    '	vec2 parallaxMap( in vec3 V ) {',
 
-    		float initialHeight = texture2D( bumpMap, vUv ).r;
+    '		float initialHeight = texture2D( bumpMap, vUv ).r;',
 
     // No Offset Limitting: messy, floating output at grazing angles.
     //"vec2 texCoordOffset = parallaxScale * V.xy / V.z * initialHeight;",
 
     // Offset Limiting
-    		vec2 texCoordOffset = parallaxScale * V.xy * initialHeight;
-    		return vUv - texCoordOffset;
+    '		vec2 texCoordOffset = parallaxScale * V.xy * initialHeight;',
+    '		return vUv - texCoordOffset;',
 
-    	}
+    '	}',
 
-    #else
+    '#else',
 
-    	vec2 parallaxMap( in vec3 V ) {
+    '	vec2 parallaxMap( in vec3 V ) {',
 
     // Determine number of layers from angle between V and N
-    		float numLayers = mix( parallaxMaxLayers, parallaxMinLayers, abs( dot( vec3( 0.0, 0.0, 1.0 ), V ) ) );
+    '		float numLayers = mix( parallaxMaxLayers, parallaxMinLayers, abs( dot( vec3( 0.0, 0.0, 1.0 ), V ) ) );',
 
-    		float layerHeight = 1.0 / numLayers;
-    		float currentLayerHeight = 0.0;
+    '		float layerHeight = 1.0 / numLayers;',
+    '		float currentLayerHeight = 0.0;',
     // Shift of texture coordinates for each iteration
-    		vec2 dtex = parallaxScale * V.xy / V.z / numLayers;
+    '		vec2 dtex = parallaxScale * V.xy / V.z / numLayers;',
 
-    		vec2 currentTextureCoords = vUv;
+    '		vec2 currentTextureCoords = vUv;',
 
-    		float heightFromTexture = texture2D( bumpMap, currentTextureCoords ).r;
+    '		float heightFromTexture = texture2D( bumpMap, currentTextureCoords ).r;',
 
     // while ( heightFromTexture > currentLayerHeight )
     // Infinite loops are not well supported. Do a "large" finite
     // loop, but not too large, as it slows down some compilers.
-    		for ( int i = 0; i < 30; i += 1 ) {
-    			if ( heightFromTexture <= currentLayerHeight ) {
-    				break;
-    			}
-    			currentLayerHeight += layerHeight;
+    '		for ( int i = 0; i < 30; i += 1 ) {',
+    '			if ( heightFromTexture <= currentLayerHeight ) {',
+    '				break;',
+    '			}',
+    '			currentLayerHeight += layerHeight;',
     // Shift texture coordinates along vector V
-    			currentTextureCoords -= dtex;
-    			heightFromTexture = texture2D( bumpMap, currentTextureCoords ).r;
-    		}
+    '			currentTextureCoords -= dtex;',
+    '			heightFromTexture = texture2D( bumpMap, currentTextureCoords ).r;',
+    '		}',
 
-    		#ifdef USE_STEEP_PARALLAX
+    '		#ifdef USE_STEEP_PARALLAX',
 
-    			return currentTextureCoords;
+    '			return currentTextureCoords;',
 
-    		#elif defined( USE_RELIEF_PARALLAX )
+    '		#elif defined( USE_RELIEF_PARALLAX )',
 
-    			vec2 deltaTexCoord = dtex / 2.0;
-    			float deltaHeight = layerHeight / 2.0;
+    '			vec2 deltaTexCoord = dtex / 2.0;',
+    '			float deltaHeight = layerHeight / 2.0;',
 
     // Return to the mid point of previous layer
-    			currentTextureCoords += deltaTexCoord;
-    			currentLayerHeight -= deltaHeight;
+    '			currentTextureCoords += deltaTexCoord;',
+    '			currentLayerHeight -= deltaHeight;',
 
     // Binary search to increase precision of Steep Parallax Mapping
-    			const int numSearches = 5;
-    			for ( int i = 0; i < numSearches; i += 1 ) {
+    '			const int numSearches = 5;',
+    '			for ( int i = 0; i < numSearches; i += 1 ) {',
 
-    				deltaTexCoord /= 2.0;
-    				deltaHeight /= 2.0;
-    				heightFromTexture = texture2D( bumpMap, currentTextureCoords ).r;
+    '				deltaTexCoord /= 2.0;',
+    '				deltaHeight /= 2.0;',
+    '				heightFromTexture = texture2D( bumpMap, currentTextureCoords ).r;',
     // Shift along or against vector V
-    				if( heightFromTexture > currentLayerHeight ) { // Below the surface
+    '				if( heightFromTexture > currentLayerHeight ) {', // Below the surface
 
-    					currentTextureCoords -= deltaTexCoord;
-    					currentLayerHeight += deltaHeight;
+    '					currentTextureCoords -= deltaTexCoord;',
+    '					currentLayerHeight += deltaHeight;',
 
-    				} else { // above the surface
+    '				} else {', // above the surface
 
-    					currentTextureCoords += deltaTexCoord;
-    					currentLayerHeight -= deltaHeight;
+    '					currentTextureCoords += deltaTexCoord;',
+    '					currentLayerHeight -= deltaHeight;',
 
-    				}
+    '				}',
 
-    			}
-    			return currentTextureCoords;
+    '			}',
+    '			return currentTextureCoords;',
 
-    		#elif defined( USE_OCLUSION_PARALLAX )
+    '		#elif defined( USE_OCLUSION_PARALLAX )',
 
-    			vec2 prevTCoords = currentTextureCoords + dtex;
+    '			vec2 prevTCoords = currentTextureCoords + dtex;',
 
     // Heights for linear interpolation
-    			float nextH = heightFromTexture - currentLayerHeight;
-    			float prevH = texture2D( bumpMap, prevTCoords ).r - currentLayerHeight + layerHeight;
+    '			float nextH = heightFromTexture - currentLayerHeight;',
+    '			float prevH = texture2D( bumpMap, prevTCoords ).r - currentLayerHeight + layerHeight;',
 
     // Proportions for linear interpolation
-    			float weight = nextH / ( nextH - prevH );
+    '			float weight = nextH / ( nextH - prevH );',
 
     // Interpolation of texture coordinates
-    			return prevTCoords * weight + currentTextureCoords * ( 1.0 - weight );
+    '			return prevTCoords * weight + currentTextureCoords * ( 1.0 - weight );',
 
-    		#else // NO_PARALLAX
+    '		#else', // NO_PARALLAX
 
-    			return vUv;
+    '			return vUv;',
 
-    		#endif
+    '		#endif',
 
-    	}
-    #endif
+    '	}',
+    '#endif',
 
-    vec2 perturbUv( vec3 surfPosition, vec3 surfNormal, vec3 viewPosition ) {
+    'vec2 perturbUv( vec3 surfPosition, vec3 surfNormal, vec3 viewPosition ) {',
 
-    	vec2 texDx = dFdx( vUv );
-    	vec2 texDy = dFdy( vUv );
+    '	vec2 texDx = dFdx( vUv );',
+    '	vec2 texDy = dFdy( vUv );',
 
-    	vec3 vSigmaX = dFdx( surfPosition );
-    	vec3 vSigmaY = dFdy( surfPosition );
-    	vec3 vR1 = cross( vSigmaY, surfNormal );
-    	vec3 vR2 = cross( surfNormal, vSigmaX );
-    	float fDet = dot( vSigmaX, vR1 );
+    '	vec3 vSigmaX = dFdx( surfPosition );',
+    '	vec3 vSigmaY = dFdy( surfPosition );',
+    '	vec3 vR1 = cross( vSigmaY, surfNormal );',
+    '	vec3 vR2 = cross( surfNormal, vSigmaX );',
+    '	float fDet = dot( vSigmaX, vR1 );',
 
-    	vec2 vProjVscr = ( 1.0 / fDet ) * vec2( dot( vR1, viewPosition ), dot( vR2, viewPosition ) );
-    	vec3 vProjVtex;
-    	vProjVtex.xy = texDx * vProjVscr.x + texDy * vProjVscr.y;
-    	vProjVtex.z = dot( surfNormal, viewPosition );
+    '	vec2 vProjVscr = ( 1.0 / fDet ) * vec2( dot( vR1, viewPosition ), dot( vR2, viewPosition ) );',
+    '	vec3 vProjVtex;',
+    '	vProjVtex.xy = texDx * vProjVscr.x + texDy * vProjVscr.y;',
+    '	vProjVtex.z = dot( surfNormal, viewPosition );',
 
-    	return parallaxMap( vProjVtex );
-    }
+    '	return parallaxMap( vProjVtex );',
+    '}',
 
-    void main() {
+    'void main() {',
 
-    	vec2 mapUv = perturbUv( -vViewPosition, normalize( vNormal ), normalize( vViewPosition ) );
-    	gl_FragColor = texture2D( map, mapUv );
+    '	vec2 mapUv = perturbUv( -vViewPosition, normalize( vNormal ), normalize( vViewPosition ) );',
+    '	gl_FragColor = texture2D( map, mapUv );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 }
diff --git a/src/shaders/PixelShader.ts b/src/shaders/PixelShader.ts
index 3408aed2..f9594f59 100644
--- a/src/shaders/PixelShader.ts
+++ b/src/shaders/PixelShader.ts
@@ -9,30 +9,30 @@ export const PixelShader = {
     pixelSize: { value: 1 },
   },
 
-  vertexShader: /* glsl */ `
-    varying highp vec2 vUv;
+  vertexShader: [
+    'varying highp vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-      vUv = uv;
-      gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    'vUv = uv;',
+    'gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    uniform sampler2D tDiffuse;
-    uniform float pixelSize;
-    uniform vec2 resolution;
+  fragmentShader: [
+    'uniform sampler2D tDiffuse;',
+    'uniform float pixelSize;',
+    'uniform vec2 resolution;',
 
-    varying highp vec2 vUv;
+    'varying highp vec2 vUv;',
 
-    void main(){
+    'void main(){',
 
-      vec2 dxy = pixelSize / resolution;
-      vec2 coord = dxy * floor( vUv / dxy );
-      gl_FragColor = texture2D(tDiffuse, coord);
+    'vec2 dxy = pixelSize / resolution;',
+    'vec2 coord = dxy * floor( vUv / dxy );',
+    'gl_FragColor = texture2D(tDiffuse, coord);',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 }
diff --git a/src/shaders/RGBShiftShader.ts b/src/shaders/RGBShiftShader.ts
index abfc5640..b545112f 100644
--- a/src/shaders/RGBShiftShader.ts
+++ b/src/shaders/RGBShiftShader.ts
@@ -15,32 +15,32 @@ export const RGBShiftShader = {
     angle: { value: 0.0 },
   },
 
-  vertexShader: /* glsl */ `
-    varying vec2 vUv;
+  vertexShader: [
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vUv = uv;
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    '	vUv = uv;',
+    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    uniform sampler2D tDiffuse;
-    uniform float amount;
-    uniform float angle;
+  fragmentShader: [
+    'uniform sampler2D tDiffuse;',
+    'uniform float amount;',
+    'uniform float angle;',
 
-    varying vec2 vUv;
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vec2 offset = amount * vec2( cos(angle), sin(angle));
-    	vec4 cr = texture2D(tDiffuse, vUv + offset);
-    	vec4 cga = texture2D(tDiffuse, vUv);
-    	vec4 cb = texture2D(tDiffuse, vUv - offset);
-    	gl_FragColor = vec4(cr.r, cga.g, cb.b, cga.a);
+    '	vec2 offset = amount * vec2( cos(angle), sin(angle));',
+    '	vec4 cr = texture2D(tDiffuse, vUv + offset);',
+    '	vec4 cga = texture2D(tDiffuse, vUv);',
+    '	vec4 cb = texture2D(tDiffuse, vUv - offset);',
+    '	gl_FragColor = vec4(cr.r, cga.g, cb.b, cga.a);',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 }
diff --git a/src/shaders/SAOShader.ts b/src/shaders/SAOShader.ts
index 0843688b..69b1546c 100644
--- a/src/shaders/SAOShader.ts
+++ b/src/shaders/SAOShader.ts
@@ -43,12 +43,12 @@ export const SAOShader: ISAOShader = {
     tDepth: { value: null },
     tDiffuse: { value: null },
     tNormal: { value: null },
-    size: { value: /* @__PURE__ */ new Vector2(512, 512) },
+    size: { value: new Vector2(512, 512) },
 
     cameraNear: { value: 1 },
     cameraFar: { value: 100 },
-    cameraProjectionMatrix: { value: /* @__PURE__ */ new Matrix4() },
-    cameraInverseProjectionMatrix: { value: /* @__PURE__ */ new Matrix4() },
+    cameraProjectionMatrix: { value: new Matrix4() },
+    cameraInverseProjectionMatrix: { value: new Matrix4() },
 
     scale: { value: 1.0 },
     intensity: { value: 0.1 },
@@ -58,149 +58,149 @@ export const SAOShader: ISAOShader = {
     kernelRadius: { value: 100.0 },
     randomSeed: { value: 0.0 },
   },
-  vertexShader: /* glsl */ `
-    varying vec2 vUv;
-
-    void main() {
-    	vUv = uv;
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
-    }
-  `,
-  fragmentShader: /* glsl */ `
-    #include <common>
-
-    varying vec2 vUv;
-
-    #if DIFFUSE_TEXTURE == 1
-    uniform sampler2D tDiffuse;
-    #endif
-
-    uniform sampler2D tDepth;
-
-    #if NORMAL_TEXTURE == 1
-    uniform sampler2D tNormal;
-    #endif
-
-    uniform float cameraNear;
-    uniform float cameraFar;
-    uniform mat4 cameraProjectionMatrix;
-    uniform mat4 cameraInverseProjectionMatrix;
-
-    uniform float scale;
-    uniform float intensity;
-    uniform float bias;
-    uniform float kernelRadius;
-    uniform float minResolution;
-    uniform vec2 size;
-    uniform float randomSeed;
-
-    // RGBA depth
-
-    #include <packing>
-
-    vec4 getDefaultColor( const in vec2 screenPosition ) {
-    	#if DIFFUSE_TEXTURE == 1
-    	return texture2D( tDiffuse, vUv );
-    	#else
-    	return vec4( 1.0 );
-    	#endif
-    }
-
-    float getDepth( const in vec2 screenPosition ) {
-    	#if DEPTH_PACKING == 1
-    	return unpackRGBAToDepth( texture2D( tDepth, screenPosition ) );
-    	#else
-    	return texture2D( tDepth, screenPosition ).x;
-    	#endif
-    }
-
-    float getViewZ( const in float depth ) {
-    	#if PERSPECTIVE_CAMERA == 1
-    	return perspectiveDepthToViewZ( depth, cameraNear, cameraFar );
-    	#else
-    	return orthographicDepthToViewZ( depth, cameraNear, cameraFar );
-    	#endif
-    }
-
-    vec3 getViewPosition( const in vec2 screenPosition, const in float depth, const in float viewZ ) {
-    	float clipW = cameraProjectionMatrix[2][3] * viewZ + cameraProjectionMatrix[3][3];
-    	vec4 clipPosition = vec4( ( vec3( screenPosition, depth ) - 0.5 ) * 2.0, 1.0 );
-    	clipPosition *= clipW; // unprojection.
-
-    	return ( cameraInverseProjectionMatrix * clipPosition ).xyz;
-    }
-
-    vec3 getViewNormal( const in vec3 viewPosition, const in vec2 screenPosition ) {
-    	#if NORMAL_TEXTURE == 1
-    	return unpackRGBToNormal( texture2D( tNormal, screenPosition ).xyz );
-    	#else
-    	return normalize( cross( dFdx( viewPosition ), dFdy( viewPosition ) ) );
-    	#endif
-    }
-
-    float scaleDividedByCameraFar;
-    float minResolutionMultipliedByCameraFar;
-
-    float getOcclusion( const in vec3 centerViewPosition, const in vec3 centerViewNormal, const in vec3 sampleViewPosition ) {
-    	vec3 viewDelta = sampleViewPosition - centerViewPosition;
-    	float viewDistance = length( viewDelta );
-    	float scaledScreenDistance = scaleDividedByCameraFar * viewDistance;
-
-    	return max(0.0, (dot(centerViewNormal, viewDelta) - minResolutionMultipliedByCameraFar) / scaledScreenDistance - bias) / (1.0 + pow2( scaledScreenDistance ) );
-    }
-
-    // moving costly divides into consts
-    const float ANGLE_STEP = PI2 * float( NUM_RINGS ) / float( NUM_SAMPLES );
-    const float INV_NUM_SAMPLES = 1.0 / float( NUM_SAMPLES );
-
-    float getAmbientOcclusion( const in vec3 centerViewPosition ) {
-    	// precompute some variables require in getOcclusion.
-    	scaleDividedByCameraFar = scale / cameraFar;
-    	minResolutionMultipliedByCameraFar = minResolution * cameraFar;
-    	vec3 centerViewNormal = getViewNormal( centerViewPosition, vUv );
-
-    	// jsfiddle that shows sample pattern: https://jsfiddle.net/a16ff1p7/
-    	float angle = rand( vUv + randomSeed ) * PI2;
-    	vec2 radius = vec2( kernelRadius * INV_NUM_SAMPLES ) / size;
-    	vec2 radiusStep = radius;
-
-    	float occlusionSum = 0.0;
-    	float weightSum = 0.0;
-
-    	for( int i = 0; i < NUM_SAMPLES; i ++ ) {
-    		vec2 sampleUv = vUv + vec2( cos( angle ), sin( angle ) ) * radius;
-    		radius += radiusStep;
-    		angle += ANGLE_STEP;
-
-    		float sampleDepth = getDepth( sampleUv );
-    		if( sampleDepth >= ( 1.0 - EPSILON ) ) {
-    			continue;
-    		}
-
-    		float sampleViewZ = getViewZ( sampleDepth );
-    		vec3 sampleViewPosition = getViewPosition( sampleUv, sampleDepth, sampleViewZ );
-    		occlusionSum += getOcclusion( centerViewPosition, centerViewNormal, sampleViewPosition );
-    		weightSum += 1.0;
-    	}
-
-    	if( weightSum == 0.0 ) discard;
-
-    	return occlusionSum * ( intensity / weightSum );
-    }
-
-    void main() {
-    	float centerDepth = getDepth( vUv );
-    	if( centerDepth >= ( 1.0 - EPSILON ) ) {
-    		discard;
-    	}
-
-    	float centerViewZ = getViewZ( centerDepth );
-    	vec3 viewPosition = getViewPosition( vUv, centerDepth, centerViewZ );
-
-    	float ambientOcclusion = getAmbientOcclusion( viewPosition );
-
-    	gl_FragColor = getDefaultColor( vUv );
-    	gl_FragColor.xyz *=  1.0 - ambientOcclusion;
-    }
-  `,
+  vertexShader: [
+    'varying vec2 vUv;',
+
+    'void main() {',
+    '	vUv = uv;',
+    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    '}',
+  ].join('\n'),
+  fragmentShader: [
+    '#include <common>',
+
+    'varying vec2 vUv;',
+
+    '#if DIFFUSE_TEXTURE == 1',
+    'uniform sampler2D tDiffuse;',
+    '#endif',
+
+    'uniform sampler2D tDepth;',
+
+    '#if NORMAL_TEXTURE == 1',
+    'uniform sampler2D tNormal;',
+    '#endif',
+
+    'uniform float cameraNear;',
+    'uniform float cameraFar;',
+    'uniform mat4 cameraProjectionMatrix;',
+    'uniform mat4 cameraInverseProjectionMatrix;',
+
+    'uniform float scale;',
+    'uniform float intensity;',
+    'uniform float bias;',
+    'uniform float kernelRadius;',
+    'uniform float minResolution;',
+    'uniform vec2 size;',
+    'uniform float randomSeed;',
+
+    '// RGBA depth',
+
+    '#include <packing>',
+
+    'vec4 getDefaultColor( const in vec2 screenPosition ) {',
+    '	#if DIFFUSE_TEXTURE == 1',
+    '	return texture2D( tDiffuse, vUv );',
+    '	#else',
+    '	return vec4( 1.0 );',
+    '	#endif',
+    '}',
+
+    'float getDepth( const in vec2 screenPosition ) {',
+    '	#if DEPTH_PACKING == 1',
+    '	return unpackRGBAToDepth( texture2D( tDepth, screenPosition ) );',
+    '	#else',
+    '	return texture2D( tDepth, screenPosition ).x;',
+    '	#endif',
+    '}',
+
+    'float getViewZ( const in float depth ) {',
+    '	#if PERSPECTIVE_CAMERA == 1',
+    '	return perspectiveDepthToViewZ( depth, cameraNear, cameraFar );',
+    '	#else',
+    '	return orthographicDepthToViewZ( depth, cameraNear, cameraFar );',
+    '	#endif',
+    '}',
+
+    'vec3 getViewPosition( const in vec2 screenPosition, const in float depth, const in float viewZ ) {',
+    '	float clipW = cameraProjectionMatrix[2][3] * viewZ + cameraProjectionMatrix[3][3];',
+    '	vec4 clipPosition = vec4( ( vec3( screenPosition, depth ) - 0.5 ) * 2.0, 1.0 );',
+    '	clipPosition *= clipW; // unprojection.',
+
+    '	return ( cameraInverseProjectionMatrix * clipPosition ).xyz;',
+    '}',
+
+    'vec3 getViewNormal( const in vec3 viewPosition, const in vec2 screenPosition ) {',
+    '	#if NORMAL_TEXTURE == 1',
+    '	return unpackRGBToNormal( texture2D( tNormal, screenPosition ).xyz );',
+    '	#else',
+    '	return normalize( cross( dFdx( viewPosition ), dFdy( viewPosition ) ) );',
+    '	#endif',
+    '}',
+
+    'float scaleDividedByCameraFar;',
+    'float minResolutionMultipliedByCameraFar;',
+
+    'float getOcclusion( const in vec3 centerViewPosition, const in vec3 centerViewNormal, const in vec3 sampleViewPosition ) {',
+    '	vec3 viewDelta = sampleViewPosition - centerViewPosition;',
+    '	float viewDistance = length( viewDelta );',
+    '	float scaledScreenDistance = scaleDividedByCameraFar * viewDistance;',
+
+    '	return max(0.0, (dot(centerViewNormal, viewDelta) - minResolutionMultipliedByCameraFar) / scaledScreenDistance - bias) / (1.0 + pow2( scaledScreenDistance ) );',
+    '}',
+
+    '// moving costly divides into consts',
+    'const float ANGLE_STEP = PI2 * float( NUM_RINGS ) / float( NUM_SAMPLES );',
+    'const float INV_NUM_SAMPLES = 1.0 / float( NUM_SAMPLES );',
+
+    'float getAmbientOcclusion( const in vec3 centerViewPosition ) {',
+    '	// precompute some variables require in getOcclusion.',
+    '	scaleDividedByCameraFar = scale / cameraFar;',
+    '	minResolutionMultipliedByCameraFar = minResolution * cameraFar;',
+    '	vec3 centerViewNormal = getViewNormal( centerViewPosition, vUv );',
+
+    '	// jsfiddle that shows sample pattern: https://jsfiddle.net/a16ff1p7/',
+    '	float angle = rand( vUv + randomSeed ) * PI2;',
+    '	vec2 radius = vec2( kernelRadius * INV_NUM_SAMPLES ) / size;',
+    '	vec2 radiusStep = radius;',
+
+    '	float occlusionSum = 0.0;',
+    '	float weightSum = 0.0;',
+
+    '	for( int i = 0; i < NUM_SAMPLES; i ++ ) {',
+    '		vec2 sampleUv = vUv + vec2( cos( angle ), sin( angle ) ) * radius;',
+    '		radius += radiusStep;',
+    '		angle += ANGLE_STEP;',
+
+    '		float sampleDepth = getDepth( sampleUv );',
+    '		if( sampleDepth >= ( 1.0 - EPSILON ) ) {',
+    '			continue;',
+    '		}',
+
+    '		float sampleViewZ = getViewZ( sampleDepth );',
+    '		vec3 sampleViewPosition = getViewPosition( sampleUv, sampleDepth, sampleViewZ );',
+    '		occlusionSum += getOcclusion( centerViewPosition, centerViewNormal, sampleViewPosition );',
+    '		weightSum += 1.0;',
+    '	}',
+
+    '	if( weightSum == 0.0 ) discard;',
+
+    '	return occlusionSum * ( intensity / weightSum );',
+    '}',
+
+    'void main() {',
+    '	float centerDepth = getDepth( vUv );',
+    '	if( centerDepth >= ( 1.0 - EPSILON ) ) {',
+    '		discard;',
+    '	}',
+
+    '	float centerViewZ = getViewZ( centerDepth );',
+    '	vec3 viewPosition = getViewPosition( vUv, centerDepth, centerViewZ );',
+
+    '	float ambientOcclusion = getAmbientOcclusion( viewPosition );',
+
+    '	gl_FragColor = getDefaultColor( vUv );',
+    '	gl_FragColor.xyz *=  1.0 - ambientOcclusion;',
+    '}',
+  ].join('\n'),
 }
diff --git a/src/shaders/SMAAShader.ts b/src/shaders/SMAAShader.ts
index 17cde98c..95813a82 100644
--- a/src/shaders/SMAAShader.ts
+++ b/src/shaders/SMAAShader.ts
@@ -13,96 +13,96 @@ export const SMAAEdgesShader = {
 
   uniforms: {
     tDiffuse: { value: null },
-    resolution: { value: /* @__PURE__ */ new Vector2(1 / 1024, 1 / 512) },
+    resolution: { value: new Vector2(1 / 1024, 1 / 512) },
   },
 
-  vertexShader: /* glsl */ `
-    uniform vec2 resolution;
+  vertexShader: [
+    'uniform vec2 resolution;',
 
-    varying vec2 vUv;
-    varying vec4 vOffset[ 3 ];
+    'varying vec2 vUv;',
+    'varying vec4 vOffset[ 3 ];',
 
-    void SMAAEdgeDetectionVS( vec2 texcoord ) {
-    	vOffset[ 0 ] = texcoord.xyxy + resolution.xyxy * vec4( -1.0, 0.0, 0.0,  1.0 ); // WebGL port note: Changed sign in W component
-    	vOffset[ 1 ] = texcoord.xyxy + resolution.xyxy * vec4(  1.0, 0.0, 0.0, -1.0 ); // WebGL port note: Changed sign in W component
-    	vOffset[ 2 ] = texcoord.xyxy + resolution.xyxy * vec4( -2.0, 0.0, 0.0,  2.0 ); // WebGL port note: Changed sign in W component
-    }
+    'void SMAAEdgeDetectionVS( vec2 texcoord ) {',
+    '	vOffset[ 0 ] = texcoord.xyxy + resolution.xyxy * vec4( -1.0, 0.0, 0.0,  1.0 );', // WebGL port note: Changed sign in W component
+    '	vOffset[ 1 ] = texcoord.xyxy + resolution.xyxy * vec4(  1.0, 0.0, 0.0, -1.0 );', // WebGL port note: Changed sign in W component
+    '	vOffset[ 2 ] = texcoord.xyxy + resolution.xyxy * vec4( -2.0, 0.0, 0.0,  2.0 );', // WebGL port note: Changed sign in W component
+    '}',
 
-    void main() {
+    'void main() {',
 
-    	vUv = uv;
+    '	vUv = uv;',
 
-    	SMAAEdgeDetectionVS( vUv );
+    '	SMAAEdgeDetectionVS( vUv );',
 
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    uniform sampler2D tDiffuse;
+  fragmentShader: [
+    'uniform sampler2D tDiffuse;',
 
-    varying vec2 vUv;
-    varying vec4 vOffset[ 3 ];
+    'varying vec2 vUv;',
+    'varying vec4 vOffset[ 3 ];',
 
-    vec4 SMAAColorEdgeDetectionPS( vec2 texcoord, vec4 offset[3], sampler2D colorTex ) {
-    	vec2 threshold = vec2( SMAA_THRESHOLD, SMAA_THRESHOLD );
+    'vec4 SMAAColorEdgeDetectionPS( vec2 texcoord, vec4 offset[3], sampler2D colorTex ) {',
+    '	vec2 threshold = vec2( SMAA_THRESHOLD, SMAA_THRESHOLD );',
 
     // Calculate color deltas:
-    	vec4 delta;
-    	vec3 C = texture2D( colorTex, texcoord ).rgb;
+    '	vec4 delta;',
+    '	vec3 C = texture2D( colorTex, texcoord ).rgb;',
 
-    	vec3 Cleft = texture2D( colorTex, offset[0].xy ).rgb;
-    	vec3 t = abs( C - Cleft );
-    	delta.x = max( max( t.r, t.g ), t.b );
+    '	vec3 Cleft = texture2D( colorTex, offset[0].xy ).rgb;',
+    '	vec3 t = abs( C - Cleft );',
+    '	delta.x = max( max( t.r, t.g ), t.b );',
 
-    	vec3 Ctop = texture2D( colorTex, offset[0].zw ).rgb;
-    	t = abs( C - Ctop );
-    	delta.y = max( max( t.r, t.g ), t.b );
+    '	vec3 Ctop = texture2D( colorTex, offset[0].zw ).rgb;',
+    '	t = abs( C - Ctop );',
+    '	delta.y = max( max( t.r, t.g ), t.b );',
 
     // We do the usual threshold:
-    	vec2 edges = step( threshold, delta.xy );
+    '	vec2 edges = step( threshold, delta.xy );',
 
     // Then discard if there is no edge:
-    	if ( dot( edges, vec2( 1.0, 1.0 ) ) == 0.0 )
-    		discard;
+    '	if ( dot( edges, vec2( 1.0, 1.0 ) ) == 0.0 )',
+    '		discard;',
 
     // Calculate right and bottom deltas:
-    	vec3 Cright = texture2D( colorTex, offset[1].xy ).rgb;
-    	t = abs( C - Cright );
-    	delta.z = max( max( t.r, t.g ), t.b );
+    '	vec3 Cright = texture2D( colorTex, offset[1].xy ).rgb;',
+    '	t = abs( C - Cright );',
+    '	delta.z = max( max( t.r, t.g ), t.b );',
 
-    	vec3 Cbottom  = texture2D( colorTex, offset[1].zw ).rgb;
-    	t = abs( C - Cbottom );
-    	delta.w = max( max( t.r, t.g ), t.b );
+    '	vec3 Cbottom  = texture2D( colorTex, offset[1].zw ).rgb;',
+    '	t = abs( C - Cbottom );',
+    '	delta.w = max( max( t.r, t.g ), t.b );',
 
     // Calculate the maximum delta in the direct neighborhood:
-    	float maxDelta = max( max( max( delta.x, delta.y ), delta.z ), delta.w );
+    '	float maxDelta = max( max( max( delta.x, delta.y ), delta.z ), delta.w );',
 
     // Calculate left-left and top-top deltas:
-    	vec3 Cleftleft  = texture2D( colorTex, offset[2].xy ).rgb;
-    	t = abs( C - Cleftleft );
-    	delta.z = max( max( t.r, t.g ), t.b );
+    '	vec3 Cleftleft  = texture2D( colorTex, offset[2].xy ).rgb;',
+    '	t = abs( C - Cleftleft );',
+    '	delta.z = max( max( t.r, t.g ), t.b );',
 
-    	vec3 Ctoptop = texture2D( colorTex, offset[2].zw ).rgb;
-    	t = abs( C - Ctoptop );
-    	delta.w = max( max( t.r, t.g ), t.b );
+    '	vec3 Ctoptop = texture2D( colorTex, offset[2].zw ).rgb;',
+    '	t = abs( C - Ctoptop );',
+    '	delta.w = max( max( t.r, t.g ), t.b );',
 
     // Calculate the final maximum delta:
-    	maxDelta = max( max( maxDelta, delta.z ), delta.w );
+    '	maxDelta = max( max( maxDelta, delta.z ), delta.w );',
 
     // Local contrast adaptation in action:
-    	edges.xy *= step( 0.5 * maxDelta, delta.xy );
+    '	edges.xy *= step( 0.5 * maxDelta, delta.xy );',
 
-    	return vec4( edges, 0.0, 0.0 );
-    }
+    '	return vec4( edges, 0.0, 0.0 );',
+    '}',
 
-    void main() {
+    'void main() {',
 
-    	gl_FragColor = SMAAColorEdgeDetectionPS( vUv, vOffset, tDiffuse );
+    '	gl_FragColor = SMAAColorEdgeDetectionPS( vUv, vOffset, tDiffuse );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 }
 
 export const SMAAWeightsShader = {
@@ -117,67 +117,67 @@ export const SMAAWeightsShader = {
     tDiffuse: { value: null },
     tArea: { value: null },
     tSearch: { value: null },
-    resolution: { value: /* @__PURE__ */ new Vector2(1 / 1024, 1 / 512) },
+    resolution: { value: new Vector2(1 / 1024, 1 / 512) },
   },
 
-  vertexShader: /* glsl */ `
-    uniform vec2 resolution;
+  vertexShader: [
+    'uniform vec2 resolution;',
 
-    varying vec2 vUv;
-    varying vec4 vOffset[ 3 ];
-    varying vec2 vPixcoord;
+    'varying vec2 vUv;',
+    'varying vec4 vOffset[ 3 ];',
+    'varying vec2 vPixcoord;',
 
-    void SMAABlendingWeightCalculationVS( vec2 texcoord ) {
-    	vPixcoord = texcoord / resolution;
+    'void SMAABlendingWeightCalculationVS( vec2 texcoord ) {',
+    '	vPixcoord = texcoord / resolution;',
 
     // We will use these offsets for the searches later on (see @PSEUDO_GATHER4):
-    	vOffset[ 0 ] = texcoord.xyxy + resolution.xyxy * vec4( -0.25, 0.125, 1.25, 0.125 ); // WebGL port note: Changed sign in Y and W components
-    	vOffset[ 1 ] = texcoord.xyxy + resolution.xyxy * vec4( -0.125, 0.25, -0.125, -1.25 ); // WebGL port note: Changed sign in Y and W components
+    '	vOffset[ 0 ] = texcoord.xyxy + resolution.xyxy * vec4( -0.25, 0.125, 1.25, 0.125 );', // WebGL port note: Changed sign in Y and W components
+    '	vOffset[ 1 ] = texcoord.xyxy + resolution.xyxy * vec4( -0.125, 0.25, -0.125, -1.25 );', // WebGL port note: Changed sign in Y and W components
 
     // And these for the searches, they indicate the ends of the loops:
-    	vOffset[ 2 ] = vec4( vOffset[ 0 ].xz, vOffset[ 1 ].yw ) + vec4( -2.0, 2.0, -2.0, 2.0 ) * resolution.xxyy * float( SMAA_MAX_SEARCH_STEPS );
+    '	vOffset[ 2 ] = vec4( vOffset[ 0 ].xz, vOffset[ 1 ].yw ) + vec4( -2.0, 2.0, -2.0, 2.0 ) * resolution.xxyy * float( SMAA_MAX_SEARCH_STEPS );',
 
-    }
+    '}',
 
-    void main() {
+    'void main() {',
 
-    	vUv = uv;
+    '	vUv = uv;',
 
-    	SMAABlendingWeightCalculationVS( vUv );
+    '	SMAABlendingWeightCalculationVS( vUv );',
 
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    #define SMAASampleLevelZeroOffset( tex, coord, offset ) texture2D( tex, coord + float( offset ) * resolution, 0.0 )
+  fragmentShader: [
+    '#define SMAASampleLevelZeroOffset( tex, coord, offset ) texture2D( tex, coord + float( offset ) * resolution, 0.0 )',
 
-    uniform sampler2D tDiffuse;
-    uniform sampler2D tArea;
-    uniform sampler2D tSearch;
-    uniform vec2 resolution;
+    'uniform sampler2D tDiffuse;',
+    'uniform sampler2D tArea;',
+    'uniform sampler2D tSearch;',
+    'uniform vec2 resolution;',
 
-    varying vec2 vUv;
-    varying vec4 vOffset[3];
-    varying vec2 vPixcoord;
+    'varying vec2 vUv;',
+    'varying vec4 vOffset[3];',
+    'varying vec2 vPixcoord;',
 
-    #if __VERSION__ == 100
-    vec2 round( vec2 x ) {
-    	return sign( x ) * floor( abs( x ) + 0.5 );
-    }
-    #endif
+    '#if __VERSION__ == 100',
+    'vec2 round( vec2 x ) {',
+    '	return sign( x ) * floor( abs( x ) + 0.5 );',
+    '}',
+    '#endif',
 
-    float SMAASearchLength( sampler2D searchTex, vec2 e, float bias, float scale ) {
+    'float SMAASearchLength( sampler2D searchTex, vec2 e, float bias, float scale ) {',
     // Not required if searchTex accesses are set to point:
     // float2 SEARCH_TEX_PIXEL_SIZE = 1.0 / float2(66.0, 33.0);
     // e = float2(bias, 0.0) + 0.5 * SEARCH_TEX_PIXEL_SIZE +
     //     e * float2(scale, 1.0) * float2(64.0, 32.0) * SEARCH_TEX_PIXEL_SIZE;
-    	e.r = bias + e.r * scale;
-    	return 255.0 * texture2D( searchTex, e, 0.0 ).r;
-    }
+    '	e.r = bias + e.r * scale;',
+    '	return 255.0 * texture2D( searchTex, e, 0.0 ).r;',
+    '}',
 
-    float SMAASearchXLeft( sampler2D edgesTex, sampler2D searchTex, vec2 texcoord, float end ) {
+    'float SMAASearchXLeft( sampler2D edgesTex, sampler2D searchTex, vec2 texcoord, float end ) {',
     /**
      * @PSEUDO_GATHER4
      * This texcoord has been offset by (-0.25, -0.125) in the vertex shader to
@@ -185,256 +185,256 @@ export const SMAAWeightsShader = {
      * Sampling with different offsets in each direction allows to disambiguate
      * which edges are active from the four fetched ones.
      */
-    	vec2 e = vec2( 0.0, 1.0 );
+    '	vec2 e = vec2( 0.0, 1.0 );',
 
-    	for ( int i = 0; i < SMAA_MAX_SEARCH_STEPS; i ++ ) { // WebGL port note: Changed while to for
-    		e = texture2D( edgesTex, texcoord, 0.0 ).rg;
-    		texcoord -= vec2( 2.0, 0.0 ) * resolution;
-    		if ( ! ( texcoord.x > end && e.g > 0.8281 && e.r == 0.0 ) ) break;
-    	}
+    '	for ( int i = 0; i < SMAA_MAX_SEARCH_STEPS; i ++ ) {', // WebGL port note: Changed while to for
+    '		e = texture2D( edgesTex, texcoord, 0.0 ).rg;',
+    '		texcoord -= vec2( 2.0, 0.0 ) * resolution;',
+    '		if ( ! ( texcoord.x > end && e.g > 0.8281 && e.r == 0.0 ) ) break;',
+    '	}',
 
     // We correct the previous (-0.25, -0.125) offset we applied:
-    	texcoord.x += 0.25 * resolution.x;
+    '	texcoord.x += 0.25 * resolution.x;',
 
     // The searches are bias by 1, so adjust the coords accordingly:
-    	texcoord.x += resolution.x;
+    '	texcoord.x += resolution.x;',
 
     // Disambiguate the length added by the last step:
-    	texcoord.x += 2.0 * resolution.x; // Undo last step
-    	texcoord.x -= resolution.x * SMAASearchLength(searchTex, e, 0.0, 0.5);
+    '	texcoord.x += 2.0 * resolution.x;', // Undo last step
+    '	texcoord.x -= resolution.x * SMAASearchLength(searchTex, e, 0.0, 0.5);',
 
-    	return texcoord.x;
-    }
+    '	return texcoord.x;',
+    '}',
 
-    float SMAASearchXRight( sampler2D edgesTex, sampler2D searchTex, vec2 texcoord, float end ) {
-    	vec2 e = vec2( 0.0, 1.0 );
+    'float SMAASearchXRight( sampler2D edgesTex, sampler2D searchTex, vec2 texcoord, float end ) {',
+    '	vec2 e = vec2( 0.0, 1.0 );',
 
-    	for ( int i = 0; i < SMAA_MAX_SEARCH_STEPS; i ++ ) { // WebGL port note: Changed while to for
-    		e = texture2D( edgesTex, texcoord, 0.0 ).rg;
-    		texcoord += vec2( 2.0, 0.0 ) * resolution;
-    		if ( ! ( texcoord.x < end && e.g > 0.8281 && e.r == 0.0 ) ) break;
-    	}
+    '	for ( int i = 0; i < SMAA_MAX_SEARCH_STEPS; i ++ ) {', // WebGL port note: Changed while to for
+    '		e = texture2D( edgesTex, texcoord, 0.0 ).rg;',
+    '		texcoord += vec2( 2.0, 0.0 ) * resolution;',
+    '		if ( ! ( texcoord.x < end && e.g > 0.8281 && e.r == 0.0 ) ) break;',
+    '	}',
 
-    	texcoord.x -= 0.25 * resolution.x;
-    	texcoord.x -= resolution.x;
-    	texcoord.x -= 2.0 * resolution.x;
-    	texcoord.x += resolution.x * SMAASearchLength( searchTex, e, 0.5, 0.5 );
+    '	texcoord.x -= 0.25 * resolution.x;',
+    '	texcoord.x -= resolution.x;',
+    '	texcoord.x -= 2.0 * resolution.x;',
+    '	texcoord.x += resolution.x * SMAASearchLength( searchTex, e, 0.5, 0.5 );',
 
-    	return texcoord.x;
-    }
+    '	return texcoord.x;',
+    '}',
 
-    float SMAASearchYUp( sampler2D edgesTex, sampler2D searchTex, vec2 texcoord, float end ) {
-    	vec2 e = vec2( 1.0, 0.0 );
+    'float SMAASearchYUp( sampler2D edgesTex, sampler2D searchTex, vec2 texcoord, float end ) {',
+    '	vec2 e = vec2( 1.0, 0.0 );',
 
-    	for ( int i = 0; i < SMAA_MAX_SEARCH_STEPS; i ++ ) { // WebGL port note: Changed while to for
-    		e = texture2D( edgesTex, texcoord, 0.0 ).rg;
-    		texcoord += vec2( 0.0, 2.0 ) * resolution; // WebGL port note: Changed sign
-    		if ( ! ( texcoord.y > end && e.r > 0.8281 && e.g == 0.0 ) ) break;
-    	}
+    '	for ( int i = 0; i < SMAA_MAX_SEARCH_STEPS; i ++ ) {', // WebGL port note: Changed while to for
+    '		e = texture2D( edgesTex, texcoord, 0.0 ).rg;',
+    '		texcoord += vec2( 0.0, 2.0 ) * resolution;', // WebGL port note: Changed sign
+    '		if ( ! ( texcoord.y > end && e.r > 0.8281 && e.g == 0.0 ) ) break;',
+    '	}',
 
-    	texcoord.y -= 0.25 * resolution.y; // WebGL port note: Changed sign
-    	texcoord.y -= resolution.y; // WebGL port note: Changed sign
-    	texcoord.y -= 2.0 * resolution.y; // WebGL port note: Changed sign
-    	texcoord.y += resolution.y * SMAASearchLength( searchTex, e.gr, 0.0, 0.5 ); // WebGL port note: Changed sign
+    '	texcoord.y -= 0.25 * resolution.y;', // WebGL port note: Changed sign
+    '	texcoord.y -= resolution.y;', // WebGL port note: Changed sign
+    '	texcoord.y -= 2.0 * resolution.y;', // WebGL port note: Changed sign
+    '	texcoord.y += resolution.y * SMAASearchLength( searchTex, e.gr, 0.0, 0.5 );', // WebGL port note: Changed sign
 
-    	return texcoord.y;
-    }
+    '	return texcoord.y;',
+    '}',
 
-    float SMAASearchYDown( sampler2D edgesTex, sampler2D searchTex, vec2 texcoord, float end ) {
-    	vec2 e = vec2( 1.0, 0.0 );
+    'float SMAASearchYDown( sampler2D edgesTex, sampler2D searchTex, vec2 texcoord, float end ) {',
+    '	vec2 e = vec2( 1.0, 0.0 );',
 
-    	for ( int i = 0; i < SMAA_MAX_SEARCH_STEPS; i ++ ) { // WebGL port note: Changed while to for
-    		e = texture2D( edgesTex, texcoord, 0.0 ).rg;
-    		texcoord -= vec2( 0.0, 2.0 ) * resolution; // WebGL port note: Changed sign
-    		if ( ! ( texcoord.y < end && e.r > 0.8281 && e.g == 0.0 ) ) break;
-    	}
+    '	for ( int i = 0; i < SMAA_MAX_SEARCH_STEPS; i ++ ) {', // WebGL port note: Changed while to for
+    '		e = texture2D( edgesTex, texcoord, 0.0 ).rg;',
+    '		texcoord -= vec2( 0.0, 2.0 ) * resolution;', // WebGL port note: Changed sign
+    '		if ( ! ( texcoord.y < end && e.r > 0.8281 && e.g == 0.0 ) ) break;',
+    '	}',
 
-    	texcoord.y += 0.25 * resolution.y; // WebGL port note: Changed sign
-    	texcoord.y += resolution.y; // WebGL port note: Changed sign
-    	texcoord.y += 2.0 * resolution.y; // WebGL port note: Changed sign
-    	texcoord.y -= resolution.y * SMAASearchLength( searchTex, e.gr, 0.5, 0.5 ); // WebGL port note: Changed sign
+    '	texcoord.y += 0.25 * resolution.y;', // WebGL port note: Changed sign
+    '	texcoord.y += resolution.y;', // WebGL port note: Changed sign
+    '	texcoord.y += 2.0 * resolution.y;', // WebGL port note: Changed sign
+    '	texcoord.y -= resolution.y * SMAASearchLength( searchTex, e.gr, 0.5, 0.5 );', // WebGL port note: Changed sign
 
-    	return texcoord.y;
-    }
+    '	return texcoord.y;',
+    '}',
 
-    vec2 SMAAArea( sampler2D areaTex, vec2 dist, float e1, float e2, float offset ) {
+    'vec2 SMAAArea( sampler2D areaTex, vec2 dist, float e1, float e2, float offset ) {',
     // Rounding prevents precision errors of bilinear filtering:
-    	vec2 texcoord = float( SMAA_AREATEX_MAX_DISTANCE ) * round( 4.0 * vec2( e1, e2 ) ) + dist;
+    '	vec2 texcoord = float( SMAA_AREATEX_MAX_DISTANCE ) * round( 4.0 * vec2( e1, e2 ) ) + dist;',
 
     // We do a scale and bias for mapping to texel space:
-    	texcoord = SMAA_AREATEX_PIXEL_SIZE * texcoord + ( 0.5 * SMAA_AREATEX_PIXEL_SIZE );
+    '	texcoord = SMAA_AREATEX_PIXEL_SIZE * texcoord + ( 0.5 * SMAA_AREATEX_PIXEL_SIZE );',
 
     // Move to proper place, according to the subpixel offset:
-    	texcoord.y += SMAA_AREATEX_SUBTEX_SIZE * offset;
+    '	texcoord.y += SMAA_AREATEX_SUBTEX_SIZE * offset;',
 
-    	return texture2D( areaTex, texcoord, 0.0 ).rg;
-    }
+    '	return texture2D( areaTex, texcoord, 0.0 ).rg;',
+    '}',
 
-    vec4 SMAABlendingWeightCalculationPS( vec2 texcoord, vec2 pixcoord, vec4 offset[ 3 ], sampler2D edgesTex, sampler2D areaTex, sampler2D searchTex, ivec4 subsampleIndices ) {
-    	vec4 weights = vec4( 0.0, 0.0, 0.0, 0.0 );
+    'vec4 SMAABlendingWeightCalculationPS( vec2 texcoord, vec2 pixcoord, vec4 offset[ 3 ], sampler2D edgesTex, sampler2D areaTex, sampler2D searchTex, ivec4 subsampleIndices ) {',
+    '	vec4 weights = vec4( 0.0, 0.0, 0.0, 0.0 );',
 
-    	vec2 e = texture2D( edgesTex, texcoord ).rg;
+    '	vec2 e = texture2D( edgesTex, texcoord ).rg;',
 
-    	if ( e.g > 0.0 ) { // Edge at north
-    		vec2 d;
+    '	if ( e.g > 0.0 ) {', // Edge at north
+    '		vec2 d;',
 
     // Find the distance to the left:
-    		vec2 coords;
-    		coords.x = SMAASearchXLeft( edgesTex, searchTex, offset[ 0 ].xy, offset[ 2 ].x );
-    		coords.y = offset[ 1 ].y; // offset[1].y = texcoord.y - 0.25 * resolution.y (@CROSSING_OFFSET)
-    		d.x = coords.x;
+    '		vec2 coords;',
+    '		coords.x = SMAASearchXLeft( edgesTex, searchTex, offset[ 0 ].xy, offset[ 2 ].x );',
+    '		coords.y = offset[ 1 ].y;', // offset[1].y = texcoord.y - 0.25 * resolution.y (@CROSSING_OFFSET)
+    '		d.x = coords.x;',
 
     // Now fetch the left crossing edges, two at a time using bilinear
     // filtering. Sampling at -0.25 (see @CROSSING_OFFSET) enables to
     // discern what value each edge has:
-    		float e1 = texture2D( edgesTex, coords, 0.0 ).r;
+    '		float e1 = texture2D( edgesTex, coords, 0.0 ).r;',
 
     // Find the distance to the right:
-    		coords.x = SMAASearchXRight( edgesTex, searchTex, offset[ 0 ].zw, offset[ 2 ].y );
-    		d.y = coords.x;
+    '		coords.x = SMAASearchXRight( edgesTex, searchTex, offset[ 0 ].zw, offset[ 2 ].y );',
+    '		d.y = coords.x;',
 
     // We want the distances to be in pixel units (doing this here allow to
     // better interleave arithmetic and memory accesses):
-    		d = d / resolution.x - pixcoord.x;
+    '		d = d / resolution.x - pixcoord.x;',
 
     // SMAAArea below needs a sqrt, as the areas texture is compressed
     // quadratically:
-    		vec2 sqrt_d = sqrt( abs( d ) );
+    '		vec2 sqrt_d = sqrt( abs( d ) );',
 
     // Fetch the right crossing edges:
-    		coords.y -= 1.0 * resolution.y; // WebGL port note: Added
-    		float e2 = SMAASampleLevelZeroOffset( edgesTex, coords, ivec2( 1, 0 ) ).r;
+    '		coords.y -= 1.0 * resolution.y;', // WebGL port note: Added
+    '		float e2 = SMAASampleLevelZeroOffset( edgesTex, coords, ivec2( 1, 0 ) ).r;',
 
     // Ok, we know how this pattern looks like, now it is time for getting
     // the actual area:
-    		weights.rg = SMAAArea( areaTex, sqrt_d, e1, e2, float( subsampleIndices.y ) );
-    	}
+    '		weights.rg = SMAAArea( areaTex, sqrt_d, e1, e2, float( subsampleIndices.y ) );',
+    '	}',
 
-    	if ( e.r > 0.0 ) { // Edge at west
-    		vec2 d;
+    '	if ( e.r > 0.0 ) {', // Edge at west
+    '		vec2 d;',
 
     // Find the distance to the top:
-    		vec2 coords;
+    '		vec2 coords;',
 
-    		coords.y = SMAASearchYUp( edgesTex, searchTex, offset[ 1 ].xy, offset[ 2 ].z );
-    		coords.x = offset[ 0 ].x; // offset[1].x = texcoord.x - 0.25 * resolution.x;
-    		d.x = coords.y;
+    '		coords.y = SMAASearchYUp( edgesTex, searchTex, offset[ 1 ].xy, offset[ 2 ].z );',
+    '		coords.x = offset[ 0 ].x;', // offset[1].x = texcoord.x - 0.25 * resolution.x;
+    '		d.x = coords.y;',
 
     // Fetch the top crossing edges:
-    		float e1 = texture2D( edgesTex, coords, 0.0 ).g;
+    '		float e1 = texture2D( edgesTex, coords, 0.0 ).g;',
 
     // Find the distance to the bottom:
-    		coords.y = SMAASearchYDown( edgesTex, searchTex, offset[ 1 ].zw, offset[ 2 ].w );
-    		d.y = coords.y;
+    '		coords.y = SMAASearchYDown( edgesTex, searchTex, offset[ 1 ].zw, offset[ 2 ].w );',
+    '		d.y = coords.y;',
 
     // We want the distances to be in pixel units:
-    		d = d / resolution.y - pixcoord.y;
+    '		d = d / resolution.y - pixcoord.y;',
 
     // SMAAArea below needs a sqrt, as the areas texture is compressed
     // quadratically:
-    		vec2 sqrt_d = sqrt( abs( d ) );
+    '		vec2 sqrt_d = sqrt( abs( d ) );',
 
     // Fetch the bottom crossing edges:
-    		coords.y -= 1.0 * resolution.y; // WebGL port note: Added
-    		float e2 = SMAASampleLevelZeroOffset( edgesTex, coords, ivec2( 0, 1 ) ).g;
+    '		coords.y -= 1.0 * resolution.y;', // WebGL port note: Added
+    '		float e2 = SMAASampleLevelZeroOffset( edgesTex, coords, ivec2( 0, 1 ) ).g;',
 
     // Get the area for this direction:
-    		weights.ba = SMAAArea( areaTex, sqrt_d, e1, e2, float( subsampleIndices.x ) );
-    	}
+    '		weights.ba = SMAAArea( areaTex, sqrt_d, e1, e2, float( subsampleIndices.x ) );',
+    '	}',
 
-    	return weights;
-    }
+    '	return weights;',
+    '}',
 
-    void main() {
+    'void main() {',
 
-    	gl_FragColor = SMAABlendingWeightCalculationPS( vUv, vPixcoord, vOffset, tDiffuse, tArea, tSearch, ivec4( 0.0 ) );
+    '	gl_FragColor = SMAABlendingWeightCalculationPS( vUv, vPixcoord, vOffset, tDiffuse, tArea, tSearch, ivec4( 0.0 ) );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 }
 
 export const SMAABlendShader = {
   uniforms: {
     tDiffuse: { value: null },
     tColor: { value: null },
-    resolution: { value: /* @__PURE__ */ new Vector2(1 / 1024, 1 / 512) },
+    resolution: { value: new Vector2(1 / 1024, 1 / 512) },
   },
 
-  vertexShader: /* glsl */ `
-    uniform vec2 resolution;
+  vertexShader: [
+    'uniform vec2 resolution;',
 
-    varying vec2 vUv;
-    varying vec4 vOffset[ 2 ];
+    'varying vec2 vUv;',
+    'varying vec4 vOffset[ 2 ];',
 
-    void SMAANeighborhoodBlendingVS( vec2 texcoord ) {
-    	vOffset[ 0 ] = texcoord.xyxy + resolution.xyxy * vec4( -1.0, 0.0, 0.0, 1.0 ); // WebGL port note: Changed sign in W component
-    	vOffset[ 1 ] = texcoord.xyxy + resolution.xyxy * vec4( 1.0, 0.0, 0.0, -1.0 ); // WebGL port note: Changed sign in W component
-    }
+    'void SMAANeighborhoodBlendingVS( vec2 texcoord ) {',
+    '	vOffset[ 0 ] = texcoord.xyxy + resolution.xyxy * vec4( -1.0, 0.0, 0.0, 1.0 );', // WebGL port note: Changed sign in W component
+    '	vOffset[ 1 ] = texcoord.xyxy + resolution.xyxy * vec4( 1.0, 0.0, 0.0, -1.0 );', // WebGL port note: Changed sign in W component
+    '}',
 
-    void main() {
+    'void main() {',
 
-    	vUv = uv;
+    '	vUv = uv;',
 
-    	SMAANeighborhoodBlendingVS( vUv );
+    '	SMAANeighborhoodBlendingVS( vUv );',
 
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    uniform sampler2D tDiffuse;
-    uniform sampler2D tColor;
-    uniform vec2 resolution;
+  fragmentShader: [
+    'uniform sampler2D tDiffuse;',
+    'uniform sampler2D tColor;',
+    'uniform vec2 resolution;',
 
-    varying vec2 vUv;
-    varying vec4 vOffset[ 2 ];
+    'varying vec2 vUv;',
+    'varying vec4 vOffset[ 2 ];',
 
-    vec4 SMAANeighborhoodBlendingPS( vec2 texcoord, vec4 offset[ 2 ], sampler2D colorTex, sampler2D blendTex ) {
+    'vec4 SMAANeighborhoodBlendingPS( vec2 texcoord, vec4 offset[ 2 ], sampler2D colorTex, sampler2D blendTex ) {',
     // Fetch the blending weights for current pixel:
-    	vec4 a;
-    	a.xz = texture2D( blendTex, texcoord ).xz;
-    	a.y = texture2D( blendTex, offset[ 1 ].zw ).g;
-    	a.w = texture2D( blendTex, offset[ 1 ].xy ).a;
+    '	vec4 a;',
+    '	a.xz = texture2D( blendTex, texcoord ).xz;',
+    '	a.y = texture2D( blendTex, offset[ 1 ].zw ).g;',
+    '	a.w = texture2D( blendTex, offset[ 1 ].xy ).a;',
 
     // Is there any blending weight with a value greater than 0.0?
-    	if ( dot(a, vec4( 1.0, 1.0, 1.0, 1.0 )) < 1e-5 ) {
-    		return texture2D( colorTex, texcoord, 0.0 );
-    	} else {
+    '	if ( dot(a, vec4( 1.0, 1.0, 1.0, 1.0 )) < 1e-5 ) {',
+    '		return texture2D( colorTex, texcoord, 0.0 );',
+    '	} else {',
     // Up to 4 lines can be crossing a pixel (one through each edge). We
     // favor blending by choosing the line with the maximum weight for each
     // direction:
-    		vec2 offset;
-    		offset.x = a.a > a.b ? a.a : -a.b; // left vs. right
-    		offset.y = a.g > a.r ? -a.g : a.r; // top vs. bottom // WebGL port note: Changed signs
+    '		vec2 offset;',
+    '		offset.x = a.a > a.b ? a.a : -a.b;', // left vs. right
+    '		offset.y = a.g > a.r ? -a.g : a.r;', // top vs. bottom // WebGL port note: Changed signs
 
     // Then we go in the direction that has the maximum weight:
-    		if ( abs( offset.x ) > abs( offset.y )) { // horizontal vs. vertical
-    			offset.y = 0.0;
-    		} else {
-    			offset.x = 0.0;
-    		}
+    '		if ( abs( offset.x ) > abs( offset.y )) {', // horizontal vs. vertical
+    '			offset.y = 0.0;',
+    '		} else {',
+    '			offset.x = 0.0;',
+    '		}',
 
     // Fetch the opposite color and lerp by hand:
-    		vec4 C = texture2D( colorTex, texcoord, 0.0 );
-    		texcoord += sign( offset ) * resolution;
-    		vec4 Cop = texture2D( colorTex, texcoord, 0.0 );
-    		float s = abs( offset.x ) > abs( offset.y ) ? abs( offset.x ) : abs( offset.y );
+    '		vec4 C = texture2D( colorTex, texcoord, 0.0 );',
+    '		texcoord += sign( offset ) * resolution;',
+    '		vec4 Cop = texture2D( colorTex, texcoord, 0.0 );',
+    '		float s = abs( offset.x ) > abs( offset.y ) ? abs( offset.x ) : abs( offset.y );',
 
     // WebGL port note: Added gamma correction
-    		C.xyz = pow(C.xyz, vec3(2.2));
-    		Cop.xyz = pow(Cop.xyz, vec3(2.2));
-    		vec4 mixed = mix(C, Cop, s);
-    		mixed.xyz = pow(mixed.xyz, vec3(1.0 / 2.2));
+    '		C.xyz = pow(C.xyz, vec3(2.2));',
+    '		Cop.xyz = pow(Cop.xyz, vec3(2.2));',
+    '		vec4 mixed = mix(C, Cop, s);',
+    '		mixed.xyz = pow(mixed.xyz, vec3(1.0 / 2.2));',
 
-    		return mixed;
-    	}
-    }
+    '		return mixed;',
+    '	}',
+    '}',
 
-    void main() {
+    'void main() {',
 
-    	gl_FragColor = SMAANeighborhoodBlendingPS( vUv, vOffset, tColor, tDiffuse );
+    '	gl_FragColor = SMAANeighborhoodBlendingPS( vUv, vOffset, tColor, tDiffuse );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 }
diff --git a/src/shaders/SSAOShader.ts b/src/shaders/SSAOShader.ts
index e5d17aef..98475a18 100644
--- a/src/shaders/SSAOShader.ts
+++ b/src/shaders/SSAOShader.ts
@@ -21,150 +21,150 @@ export const SSAOShader = {
     kernel: { value: null },
     cameraNear: { value: null },
     cameraFar: { value: null },
-    resolution: { value: /* @__PURE__ */ new Vector2() },
-    cameraProjectionMatrix: { value: /* @__PURE__ */ new Matrix4() },
-    cameraInverseProjectionMatrix: { value: /* @__PURE__ */ new Matrix4() },
+    resolution: { value: new Vector2() },
+    cameraProjectionMatrix: { value: new Matrix4() },
+    cameraInverseProjectionMatrix: { value: new Matrix4() },
     kernelRadius: { value: 8 },
     minDistance: { value: 0.005 },
     maxDistance: { value: 0.05 },
   },
 
-  vertexShader: /* glsl */ `
-    varying vec2 vUv;
+  vertexShader: [
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vUv = uv;
+    '	vUv = uv;',
 
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    uniform sampler2D tDiffuse;
-    uniform sampler2D tNormal;
-    uniform sampler2D tDepth;
-    uniform sampler2D tNoise;
+  fragmentShader: [
+    'uniform sampler2D tDiffuse;',
+    'uniform sampler2D tNormal;',
+    'uniform sampler2D tDepth;',
+    'uniform sampler2D tNoise;',
 
-    uniform vec3 kernel[ KERNEL_SIZE ];
+    'uniform vec3 kernel[ KERNEL_SIZE ];',
 
-    uniform vec2 resolution;
+    'uniform vec2 resolution;',
 
-    uniform float cameraNear;
-    uniform float cameraFar;
-    uniform mat4 cameraProjectionMatrix;
-    uniform mat4 cameraInverseProjectionMatrix;
+    'uniform float cameraNear;',
+    'uniform float cameraFar;',
+    'uniform mat4 cameraProjectionMatrix;',
+    'uniform mat4 cameraInverseProjectionMatrix;',
 
-    uniform float kernelRadius;
-    uniform float minDistance; // avoid artifacts caused by neighbour fragments with minimal depth difference
-    uniform float maxDistance; // avoid the influence of fragments which are too far away
+    'uniform float kernelRadius;',
+    'uniform float minDistance;', // avoid artifacts caused by neighbour fragments with minimal depth difference
+    'uniform float maxDistance;', // avoid the influence of fragments which are too far away
 
-    varying vec2 vUv;
+    'varying vec2 vUv;',
 
-    #include <packing>
+    '#include <packing>',
 
-    float getDepth( const in vec2 screenPosition ) {
+    'float getDepth( const in vec2 screenPosition ) {',
 
-    	return texture2D( tDepth, screenPosition ).x;
+    '	return texture2D( tDepth, screenPosition ).x;',
 
-    }
+    '}',
 
-    float getLinearDepth( const in vec2 screenPosition ) {
+    'float getLinearDepth( const in vec2 screenPosition ) {',
 
-    	#if PERSPECTIVE_CAMERA == 1
+    '	#if PERSPECTIVE_CAMERA == 1',
 
-    		float fragCoordZ = texture2D( tDepth, screenPosition ).x;
-    		float viewZ = perspectiveDepthToViewZ( fragCoordZ, cameraNear, cameraFar );
-    		return viewZToOrthographicDepth( viewZ, cameraNear, cameraFar );
+    '		float fragCoordZ = texture2D( tDepth, screenPosition ).x;',
+    '		float viewZ = perspectiveDepthToViewZ( fragCoordZ, cameraNear, cameraFar );',
+    '		return viewZToOrthographicDepth( viewZ, cameraNear, cameraFar );',
 
-    	#else
+    '	#else',
 
-    		return texture2D( tDepth, screenPosition ).x;
+    '		return texture2D( tDepth, screenPosition ).x;',
 
-    	#endif
+    '	#endif',
 
-    }
+    '}',
 
-    float getViewZ( const in float depth ) {
+    'float getViewZ( const in float depth ) {',
 
-    	#if PERSPECTIVE_CAMERA == 1
+    '	#if PERSPECTIVE_CAMERA == 1',
 
-    		return perspectiveDepthToViewZ( depth, cameraNear, cameraFar );
+    '		return perspectiveDepthToViewZ( depth, cameraNear, cameraFar );',
 
-    	#else
+    '	#else',
 
-    		return orthographicDepthToViewZ( depth, cameraNear, cameraFar );
+    '		return orthographicDepthToViewZ( depth, cameraNear, cameraFar );',
 
-    	#endif
+    '	#endif',
 
-    }
+    '}',
 
-    vec3 getViewPosition( const in vec2 screenPosition, const in float depth, const in float viewZ ) {
+    'vec3 getViewPosition( const in vec2 screenPosition, const in float depth, const in float viewZ ) {',
 
-    	float clipW = cameraProjectionMatrix[2][3] * viewZ + cameraProjectionMatrix[3][3];
+    '	float clipW = cameraProjectionMatrix[2][3] * viewZ + cameraProjectionMatrix[3][3];',
 
-    	vec4 clipPosition = vec4( ( vec3( screenPosition, depth ) - 0.5 ) * 2.0, 1.0 );
+    '	vec4 clipPosition = vec4( ( vec3( screenPosition, depth ) - 0.5 ) * 2.0, 1.0 );',
 
-    	clipPosition *= clipW; // unprojection.
+    '	clipPosition *= clipW; // unprojection.',
 
-    	return ( cameraInverseProjectionMatrix * clipPosition ).xyz;
+    '	return ( cameraInverseProjectionMatrix * clipPosition ).xyz;',
 
-    }
+    '}',
 
-    vec3 getViewNormal( const in vec2 screenPosition ) {
+    'vec3 getViewNormal( const in vec2 screenPosition ) {',
 
-    	return unpackRGBToNormal( texture2D( tNormal, screenPosition ).xyz );
+    '	return unpackRGBToNormal( texture2D( tNormal, screenPosition ).xyz );',
 
-    }
+    '}',
 
-    void main() {
+    'void main() {',
 
-    	float depth = getDepth( vUv );
-    	float viewZ = getViewZ( depth );
+    '	float depth = getDepth( vUv );',
+    '	float viewZ = getViewZ( depth );',
 
-    	vec3 viewPosition = getViewPosition( vUv, depth, viewZ );
-    	vec3 viewNormal = getViewNormal( vUv );
+    '	vec3 viewPosition = getViewPosition( vUv, depth, viewZ );',
+    '	vec3 viewNormal = getViewNormal( vUv );',
 
-     vec2 noiseScale = vec2( resolution.x / 4.0, resolution.y / 4.0 );
-    	vec3 random = texture2D( tNoise, vUv * noiseScale ).xyz;
+    ' vec2 noiseScale = vec2( resolution.x / 4.0, resolution.y / 4.0 );',
+    '	vec3 random = texture2D( tNoise, vUv * noiseScale ).xyz;',
 
     // compute matrix used to reorient a kernel vector
 
-    	vec3 tangent = normalize( random - viewNormal * dot( random, viewNormal ) );
-    	vec3 bitangent = cross( viewNormal, tangent );
-    	mat3 kernelMatrix = mat3( tangent, bitangent, viewNormal );
+    '	vec3 tangent = normalize( random - viewNormal * dot( random, viewNormal ) );',
+    '	vec3 bitangent = cross( viewNormal, tangent );',
+    '	mat3 kernelMatrix = mat3( tangent, bitangent, viewNormal );',
 
-     float occlusion = 0.0;
+    ' float occlusion = 0.0;',
 
-     for ( int i = 0; i < KERNEL_SIZE; i ++ ) {
+    ' for ( int i = 0; i < KERNEL_SIZE; i ++ ) {',
 
-    		vec3 sampleVector = kernelMatrix * kernel[ i ]; // reorient sample vector in view space
-    		vec3 samplePoint = viewPosition + ( sampleVector * kernelRadius ); // calculate sample point
+    '		vec3 sampleVector = kernelMatrix * kernel[ i ];', // reorient sample vector in view space
+    '		vec3 samplePoint = viewPosition + ( sampleVector * kernelRadius );', // calculate sample point
 
-    		vec4 samplePointNDC = cameraProjectionMatrix * vec4( samplePoint, 1.0 ); // project point and calculate NDC
-    		samplePointNDC /= samplePointNDC.w;
+    '		vec4 samplePointNDC = cameraProjectionMatrix * vec4( samplePoint, 1.0 );', // project point and calculate NDC
+    '		samplePointNDC /= samplePointNDC.w;',
 
-    		vec2 samplePointUv = samplePointNDC.xy * 0.5 + 0.5; // compute uv coordinates
+    '		vec2 samplePointUv = samplePointNDC.xy * 0.5 + 0.5;', // compute uv coordinates
 
-    		float realDepth = getLinearDepth( samplePointUv ); // get linear depth from depth texture
-    		float sampleDepth = viewZToOrthographicDepth( samplePoint.z, cameraNear, cameraFar ); // compute linear depth of the sample view Z value
-    		float delta = sampleDepth - realDepth;
+    '		float realDepth = getLinearDepth( samplePointUv );', // get linear depth from depth texture
+    '		float sampleDepth = viewZToOrthographicDepth( samplePoint.z, cameraNear, cameraFar );', // compute linear depth of the sample view Z value
+    '		float delta = sampleDepth - realDepth;',
 
-    		if ( delta > minDistance && delta < maxDistance ) { // if fragment is before sample point, increase occlusion
+    '		if ( delta > minDistance && delta < maxDistance ) {', // if fragment is before sample point, increase occlusion
 
-    			occlusion += 1.0;
+    '			occlusion += 1.0;',
 
-    		}
+    '		}',
 
-    	}
+    '	}',
 
-    	occlusion = clamp( occlusion / float( KERNEL_SIZE ), 0.0, 1.0 );
+    '	occlusion = clamp( occlusion / float( KERNEL_SIZE ), 0.0, 1.0 );',
 
-    	gl_FragColor = vec4( vec3( 1.0 - occlusion ), 1.0 );
+    '	gl_FragColor = vec4( vec3( 1.0 - occlusion ), 1.0 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 }
 
 export const SSAODepthShader = {
@@ -178,94 +178,94 @@ export const SSAODepthShader = {
     cameraFar: { value: null },
   },
 
-  vertexShader: /* glsl */ `
-    varying vec2 vUv;
+  vertexShader: [
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vUv = uv;
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    '	vUv = uv;',
+    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    uniform sampler2D tDepth;
+  fragmentShader: [
+    'uniform sampler2D tDepth;',
 
-    uniform float cameraNear;
-    uniform float cameraFar;
+    'uniform float cameraNear;',
+    'uniform float cameraFar;',
 
-    varying vec2 vUv;
+    'varying vec2 vUv;',
 
-    #include <packing>
+    '#include <packing>',
 
-    float getLinearDepth( const in vec2 screenPosition ) {
+    'float getLinearDepth( const in vec2 screenPosition ) {',
 
-    	#if PERSPECTIVE_CAMERA == 1
+    '	#if PERSPECTIVE_CAMERA == 1',
 
-    		float fragCoordZ = texture2D( tDepth, screenPosition ).x;
-    		float viewZ = perspectiveDepthToViewZ( fragCoordZ, cameraNear, cameraFar );
-    		return viewZToOrthographicDepth( viewZ, cameraNear, cameraFar );
+    '		float fragCoordZ = texture2D( tDepth, screenPosition ).x;',
+    '		float viewZ = perspectiveDepthToViewZ( fragCoordZ, cameraNear, cameraFar );',
+    '		return viewZToOrthographicDepth( viewZ, cameraNear, cameraFar );',
 
-    	#else
+    '	#else',
 
-    		return texture2D( tDepth, screenPosition ).x;
+    '		return texture2D( tDepth, screenPosition ).x;',
 
-    	#endif
+    '	#endif',
 
-    }
+    '}',
 
-    void main() {
+    'void main() {',
 
-    	float depth = getLinearDepth( vUv );
-    	gl_FragColor = vec4( vec3( 1.0 - depth ), 1.0 );
+    '	float depth = getLinearDepth( vUv );',
+    '	gl_FragColor = vec4( vec3( 1.0 - depth ), 1.0 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 }
 
 export const SSAOBlurShader = {
   uniforms: {
     tDiffuse: { value: null },
-    resolution: { value: /* @__PURE__ */ new Vector2() },
+    resolution: { value: new Vector2() },
   },
 
-  vertexShader: /* glsl */ `
-    varying vec2 vUv;
+  vertexShader: [
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vUv = uv;
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    '	vUv = uv;',
+    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    uniform sampler2D tDiffuse;
+  fragmentShader: [
+    'uniform sampler2D tDiffuse;',
 
-    uniform vec2 resolution;
+    'uniform vec2 resolution;',
 
-    varying vec2 vUv;
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vec2 texelSize = ( 1.0 / resolution );
-    	float result = 0.0;
+    '	vec2 texelSize = ( 1.0 / resolution );',
+    '	float result = 0.0;',
 
-    	for ( int i = - 2; i <= 2; i ++ ) {
+    '	for ( int i = - 2; i <= 2; i ++ ) {',
 
-    		for ( int j = - 2; j <= 2; j ++ ) {
+    '		for ( int j = - 2; j <= 2; j ++ ) {',
 
-    			vec2 offset = ( vec2( float( i ), float( j ) ) ) * texelSize;
-    			result += texture2D( tDiffuse, vUv + offset ).r;
+    '			vec2 offset = ( vec2( float( i ), float( j ) ) ) * texelSize;',
+    '			result += texture2D( tDiffuse, vUv + offset ).r;',
 
-    		}
+    '		}',
 
-    	}
+    '	}',
 
-    	gl_FragColor = vec4( vec3( result / ( 5.0 * 5.0 ) ), 1.0 );
+    '	gl_FragColor = vec4( vec3( result / ( 5.0 * 5.0 ) ), 1.0 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 }
diff --git a/src/shaders/SSRShader.ts b/src/shaders/SSRShader.ts
index fe073f1f..a212b977 100644
--- a/src/shaders/SSRShader.ts
+++ b/src/shaders/SSRShader.ts
@@ -21,9 +21,9 @@ export const SSRShader = {
     tDepth: { value: null },
     cameraNear: { value: null },
     cameraFar: { value: null },
-    resolution: { value: /* @__PURE__ */ new Vector2() },
-    cameraProjectionMatrix: { value: /* @__PURE__ */ new Matrix4() },
-    cameraInverseProjectionMatrix: { value: /* @__PURE__ */ new Matrix4() },
+    resolution: { value: new Vector2() },
+    cameraProjectionMatrix: { value: new Matrix4() },
+    cameraInverseProjectionMatrix: { value: new Matrix4() },
     opacity: { value: 0.5 },
     maxDistance: { value: 180 },
     cameraRange: { value: 0 },
@@ -278,7 +278,7 @@ export const SSRDepthShader = {
 export const SSRBlurShader = {
   uniforms: {
     tDiffuse: { value: null },
-    resolution: { value: /* @__PURE__ */ new Vector2() },
+    resolution: { value: new Vector2() },
     opacity: { value: 0.5 },
   },
 
diff --git a/src/shaders/SepiaShader.ts b/src/shaders/SepiaShader.ts
index 3048d490..fdd9f8d1 100644
--- a/src/shaders/SepiaShader.ts
+++ b/src/shaders/SepiaShader.ts
@@ -10,35 +10,35 @@ export const SepiaShader = {
     amount: { value: 1.0 },
   },
 
-  vertexShader: /* glsl */ `
-    varying vec2 vUv;
+  vertexShader: [
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vUv = uv;
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    '	vUv = uv;',
+    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    uniform float amount;
+  fragmentShader: [
+    'uniform float amount;',
 
-    uniform sampler2D tDiffuse;
+    'uniform sampler2D tDiffuse;',
 
-    varying vec2 vUv;
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vec4 color = texture2D( tDiffuse, vUv );
-    	vec3 c = color.rgb;
+    '	vec4 color = texture2D( tDiffuse, vUv );',
+    '	vec3 c = color.rgb;',
 
-    	color.r = dot( c, vec3( 1.0 - 0.607 * amount, 0.769 * amount, 0.189 * amount ) );
-    	color.g = dot( c, vec3( 0.349 * amount, 1.0 - 0.314 * amount, 0.168 * amount ) );
-    	color.b = dot( c, vec3( 0.272 * amount, 0.534 * amount, 1.0 - 0.869 * amount ) );
+    '	color.r = dot( c, vec3( 1.0 - 0.607 * amount, 0.769 * amount, 0.189 * amount ) );',
+    '	color.g = dot( c, vec3( 0.349 * amount, 1.0 - 0.314 * amount, 0.168 * amount ) );',
+    '	color.b = dot( c, vec3( 0.272 * amount, 0.534 * amount, 1.0 - 0.869 * amount ) );',
 
-    	gl_FragColor = vec4( min( vec3( 1.0 ), color.rgb ), color.a );
+    '	gl_FragColor = vec4( min( vec3( 1.0 ), color.rgb ), color.a );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 }
diff --git a/src/shaders/SobelOperatorShader.ts b/src/shaders/SobelOperatorShader.ts
index f88f3601..2401781f 100644
--- a/src/shaders/SobelOperatorShader.ts
+++ b/src/shaders/SobelOperatorShader.ts
@@ -10,73 +10,73 @@ import { Vector2 } from 'three'
 export const SobelOperatorShader = {
   uniforms: {
     tDiffuse: { value: null },
-    resolution: { value: /* @__PURE__ */ new Vector2() },
+    resolution: { value: new Vector2() },
   },
 
-  vertexShader: /* glsl */ `
-    varying vec2 vUv;
+  vertexShader: [
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vUv = uv;
+    '	vUv = uv;',
 
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    uniform sampler2D tDiffuse;
-    uniform vec2 resolution;
-    varying vec2 vUv;
+  fragmentShader: [
+    'uniform sampler2D tDiffuse;',
+    'uniform vec2 resolution;',
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vec2 texel = vec2( 1.0 / resolution.x, 1.0 / resolution.y );
+    '	vec2 texel = vec2( 1.0 / resolution.x, 1.0 / resolution.y );',
 
     // kernel definition (in glsl matrices are filled in column-major order)
 
-    	const mat3 Gx = mat3( -1, -2, -1, 0, 0, 0, 1, 2, 1 ); // x direction kernel
-    	const mat3 Gy = mat3( -1, 0, 1, -2, 0, 2, -1, 0, 1 ); // y direction kernel
+    '	const mat3 Gx = mat3( -1, -2, -1, 0, 0, 0, 1, 2, 1 );', // x direction kernel
+    '	const mat3 Gy = mat3( -1, 0, 1, -2, 0, 2, -1, 0, 1 );', // y direction kernel
 
     // fetch the 3x3 neighbourhood of a fragment
 
     // first column
 
-    	float tx0y0 = texture2D( tDiffuse, vUv + texel * vec2( -1, -1 ) ).r;
-    	float tx0y1 = texture2D( tDiffuse, vUv + texel * vec2( -1,  0 ) ).r;
-    	float tx0y2 = texture2D( tDiffuse, vUv + texel * vec2( -1,  1 ) ).r;
+    '	float tx0y0 = texture2D( tDiffuse, vUv + texel * vec2( -1, -1 ) ).r;',
+    '	float tx0y1 = texture2D( tDiffuse, vUv + texel * vec2( -1,  0 ) ).r;',
+    '	float tx0y2 = texture2D( tDiffuse, vUv + texel * vec2( -1,  1 ) ).r;',
 
     // second column
 
-    	float tx1y0 = texture2D( tDiffuse, vUv + texel * vec2(  0, -1 ) ).r;
-    	float tx1y1 = texture2D( tDiffuse, vUv + texel * vec2(  0,  0 ) ).r;
-    	float tx1y2 = texture2D( tDiffuse, vUv + texel * vec2(  0,  1 ) ).r;
+    '	float tx1y0 = texture2D( tDiffuse, vUv + texel * vec2(  0, -1 ) ).r;',
+    '	float tx1y1 = texture2D( tDiffuse, vUv + texel * vec2(  0,  0 ) ).r;',
+    '	float tx1y2 = texture2D( tDiffuse, vUv + texel * vec2(  0,  1 ) ).r;',
 
     // third column
 
-    	float tx2y0 = texture2D( tDiffuse, vUv + texel * vec2(  1, -1 ) ).r;
-    	float tx2y1 = texture2D( tDiffuse, vUv + texel * vec2(  1,  0 ) ).r;
-    	float tx2y2 = texture2D( tDiffuse, vUv + texel * vec2(  1,  1 ) ).r;
+    '	float tx2y0 = texture2D( tDiffuse, vUv + texel * vec2(  1, -1 ) ).r;',
+    '	float tx2y1 = texture2D( tDiffuse, vUv + texel * vec2(  1,  0 ) ).r;',
+    '	float tx2y2 = texture2D( tDiffuse, vUv + texel * vec2(  1,  1 ) ).r;',
 
     // gradient value in x direction
 
-    	float valueGx = Gx[0][0] * tx0y0 + Gx[1][0] * tx1y0 + Gx[2][0] * tx2y0 + 
-    		Gx[0][1] * tx0y1 + Gx[1][1] * tx1y1 + Gx[2][1] * tx2y1 + 
-    		Gx[0][2] * tx0y2 + Gx[1][2] * tx1y2 + Gx[2][2] * tx2y2; 
+    '	float valueGx = Gx[0][0] * tx0y0 + Gx[1][0] * tx1y0 + Gx[2][0] * tx2y0 + ',
+    '		Gx[0][1] * tx0y1 + Gx[1][1] * tx1y1 + Gx[2][1] * tx2y1 + ',
+    '		Gx[0][2] * tx0y2 + Gx[1][2] * tx1y2 + Gx[2][2] * tx2y2; ',
 
     // gradient value in y direction
 
-    	float valueGy = Gy[0][0] * tx0y0 + Gy[1][0] * tx1y0 + Gy[2][0] * tx2y0 + 
-    		Gy[0][1] * tx0y1 + Gy[1][1] * tx1y1 + Gy[2][1] * tx2y1 + 
-    		Gy[0][2] * tx0y2 + Gy[1][2] * tx1y2 + Gy[2][2] * tx2y2; 
+    '	float valueGy = Gy[0][0] * tx0y0 + Gy[1][0] * tx1y0 + Gy[2][0] * tx2y0 + ',
+    '		Gy[0][1] * tx0y1 + Gy[1][1] * tx1y1 + Gy[2][1] * tx2y1 + ',
+    '		Gy[0][2] * tx0y2 + Gy[1][2] * tx1y2 + Gy[2][2] * tx2y2; ',
 
     // magnitute of the total gradient
 
-    	float G = sqrt( ( valueGx * valueGx ) + ( valueGy * valueGy ) );
+    '	float G = sqrt( ( valueGx * valueGx ) + ( valueGy * valueGy ) );',
 
-    	gl_FragColor = vec4( vec3( G ), 1 );
+    '	gl_FragColor = vec4( vec3( G ), 1 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 }
diff --git a/src/shaders/TechnicolorShader.ts b/src/shaders/TechnicolorShader.ts
index 076bb5d0..91799c01 100644
--- a/src/shaders/TechnicolorShader.ts
+++ b/src/shaders/TechnicolorShader.ts
@@ -10,28 +10,28 @@ export const TechnicolorShader = {
     tDiffuse: { value: null },
   },
 
-  vertexShader: /* glsl */ `
-    varying vec2 vUv;
+  vertexShader: [
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vUv = uv;
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    '	vUv = uv;',
+    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    uniform sampler2D tDiffuse;
-    varying vec2 vUv;
+  fragmentShader: [
+    'uniform sampler2D tDiffuse;',
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vec4 tex = texture2D( tDiffuse, vec2( vUv.x, vUv.y ) );
-    	vec4 newTex = vec4(tex.r, (tex.g + tex.b) * .5, (tex.g + tex.b) * .5, 1.0);
+    '	vec4 tex = texture2D( tDiffuse, vec2( vUv.x, vUv.y ) );',
+    '	vec4 newTex = vec4(tex.r, (tex.g + tex.b) * .5, (tex.g + tex.b) * .5, 1.0);',
 
-    	gl_FragColor = newTex;
+    '	gl_FragColor = newTex;',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 }
diff --git a/src/shaders/ToneMapShader.ts b/src/shaders/ToneMapShader.ts
index c167f980..d0c52936 100644
--- a/src/shaders/ToneMapShader.ts
+++ b/src/shaders/ToneMapShader.ts
@@ -12,57 +12,57 @@ export const ToneMapShader = {
     middleGrey: { value: 0.6 },
   },
 
-  vertexShader: /* glsl */ `
-    varying vec2 vUv;
+  vertexShader: [
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vUv = uv;
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    '	vUv = uv;',
+    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    #include <common>
+  fragmentShader: [
+    '#include <common>',
 
-    uniform sampler2D tDiffuse;
+    'uniform sampler2D tDiffuse;',
 
-    varying vec2 vUv;
+    'varying vec2 vUv;',
 
-    uniform float middleGrey;
-    uniform float minLuminance;
-    uniform float maxLuminance;
-    #ifdef ADAPTED_LUMINANCE
-    	uniform sampler2D luminanceMap;
-    #else
-    	uniform float averageLuminance;
-    #endif
+    'uniform float middleGrey;',
+    'uniform float minLuminance;',
+    'uniform float maxLuminance;',
+    '#ifdef ADAPTED_LUMINANCE',
+    '	uniform sampler2D luminanceMap;',
+    '#else',
+    '	uniform float averageLuminance;',
+    '#endif',
 
-    vec3 ToneMap( vec3 vColor ) {
-    	#ifdef ADAPTED_LUMINANCE
+    'vec3 ToneMap( vec3 vColor ) {',
+    '	#ifdef ADAPTED_LUMINANCE',
     // Get the calculated average luminance
-    		float fLumAvg = texture2D(luminanceMap, vec2(0.5, 0.5)).r;
-    	#else
-    		float fLumAvg = averageLuminance;
-    	#endif
+    '		float fLumAvg = texture2D(luminanceMap, vec2(0.5, 0.5)).r;',
+    '	#else',
+    '		float fLumAvg = averageLuminance;',
+    '	#endif',
 
     // Calculate the luminance of the current pixel
-    	float fLumPixel = linearToRelativeLuminance( vColor );
+    '	float fLumPixel = linearToRelativeLuminance( vColor );',
 
     // Apply the modified operator (Eq. 4)
-    	float fLumScaled = (fLumPixel * middleGrey) / max( minLuminance, fLumAvg );
+    '	float fLumScaled = (fLumPixel * middleGrey) / max( minLuminance, fLumAvg );',
 
-    	float fLumCompressed = (fLumScaled * (1.0 + (fLumScaled / (maxLuminance * maxLuminance)))) / (1.0 + fLumScaled);
-    	return fLumCompressed * vColor;
-    }
+    '	float fLumCompressed = (fLumScaled * (1.0 + (fLumScaled / (maxLuminance * maxLuminance)))) / (1.0 + fLumScaled);',
+    '	return fLumCompressed * vColor;',
+    '}',
 
-    void main() {
+    'void main() {',
 
-    	vec4 texel = texture2D( tDiffuse, vUv );
+    '	vec4 texel = texture2D( tDiffuse, vUv );',
 
-    	gl_FragColor = vec4( ToneMap( texel.xyz ), texel.w );
+    '	gl_FragColor = vec4( ToneMap( texel.xyz ), texel.w );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 }
diff --git a/src/shaders/ToonShader.ts b/src/shaders/ToonShader.ts
index 7909c631..d541f81c 100644
--- a/src/shaders/ToonShader.ts
+++ b/src/shaders/ToonShader.ts
@@ -11,287 +11,287 @@ import { Color, Vector3 } from 'three'
 
 export const ToonShader1 = {
   uniforms: {
-    uDirLightPos: { value: /* @__PURE__ */ new Vector3() },
-    uDirLightColor: { value: /* @__PURE__ */ new Color(0xeeeeee) },
+    uDirLightPos: { value: new Vector3() },
+    uDirLightColor: { value: new Color(0xeeeeee) },
 
-    uAmbientLightColor: { value: /* @__PURE__ */ new Color(0x050505) },
+    uAmbientLightColor: { value: new Color(0x050505) },
 
-    uBaseColor: { value: /* @__PURE__ */ new Color(0xffffff) },
+    uBaseColor: { value: new Color(0xffffff) },
   },
 
-  vertexShader: /* glsl */ `
-    varying vec3 vNormal;
-    varying vec3 vRefract;
+  vertexShader: [
+    'varying vec3 vNormal;',
+    'varying vec3 vRefract;',
 
-    void main() {
+    'void main() {',
 
-    	vec4 worldPosition = modelMatrix * vec4( position, 1.0 );
-    	vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );
-    	vec3 worldNormal = normalize ( mat3( modelMatrix[0].xyz, modelMatrix[1].xyz, modelMatrix[2].xyz ) * normal );
+    '	vec4 worldPosition = modelMatrix * vec4( position, 1.0 );',
+    '	vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );',
+    '	vec3 worldNormal = normalize ( mat3( modelMatrix[0].xyz, modelMatrix[1].xyz, modelMatrix[2].xyz ) * normal );',
 
-    	vNormal = normalize( normalMatrix * normal );
+    '	vNormal = normalize( normalMatrix * normal );',
 
-    	vec3 I = worldPosition.xyz - cameraPosition;
-    	vRefract = refract( normalize( I ), worldNormal, 1.02 );
+    '	vec3 I = worldPosition.xyz - cameraPosition;',
+    '	vRefract = refract( normalize( I ), worldNormal, 1.02 );',
 
-    	gl_Position = projectionMatrix * mvPosition;
+    '	gl_Position = projectionMatrix * mvPosition;',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    uniform vec3 uBaseColor;
+  fragmentShader: [
+    'uniform vec3 uBaseColor;',
 
-    uniform vec3 uDirLightPos;
-    uniform vec3 uDirLightColor;
+    'uniform vec3 uDirLightPos;',
+    'uniform vec3 uDirLightColor;',
 
-    uniform vec3 uAmbientLightColor;
+    'uniform vec3 uAmbientLightColor;',
 
-    varying vec3 vNormal;
+    'varying vec3 vNormal;',
 
-    varying vec3 vRefract;
+    'varying vec3 vRefract;',
 
-    void main() {
+    'void main() {',
 
-    	float directionalLightWeighting = max( dot( normalize( vNormal ), uDirLightPos ), 0.0);
-    	vec3 lightWeighting = uAmbientLightColor + uDirLightColor * directionalLightWeighting;
+    '	float directionalLightWeighting = max( dot( normalize( vNormal ), uDirLightPos ), 0.0);',
+    '	vec3 lightWeighting = uAmbientLightColor + uDirLightColor * directionalLightWeighting;',
 
-    	float intensity = smoothstep( - 0.5, 1.0, pow( length(lightWeighting), 20.0 ) );
-    	intensity += length(lightWeighting) * 0.2;
+    '	float intensity = smoothstep( - 0.5, 1.0, pow( length(lightWeighting), 20.0 ) );',
+    '	intensity += length(lightWeighting) * 0.2;',
 
-    	float cameraWeighting = dot( normalize( vNormal ), vRefract );
-    	intensity += pow( 1.0 - length( cameraWeighting ), 6.0 );
-    	intensity = intensity * 0.2 + 0.3;
+    '	float cameraWeighting = dot( normalize( vNormal ), vRefract );',
+    '	intensity += pow( 1.0 - length( cameraWeighting ), 6.0 );',
+    '	intensity = intensity * 0.2 + 0.3;',
 
-    	if ( intensity < 0.50 ) {
+    '	if ( intensity < 0.50 ) {',
 
-    		gl_FragColor = vec4( 2.0 * intensity * uBaseColor, 1.0 );
+    '		gl_FragColor = vec4( 2.0 * intensity * uBaseColor, 1.0 );',
 
-    	} else {
+    '	} else {',
 
-    		gl_FragColor = vec4( 1.0 - 2.0 * ( 1.0 - intensity ) * ( 1.0 - uBaseColor ), 1.0 );
+    '		gl_FragColor = vec4( 1.0 - 2.0 * ( 1.0 - intensity ) * ( 1.0 - uBaseColor ), 1.0 );',
 
-    }
+    '}',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 }
 
 export const ToonShader2 = {
   uniforms: {
-    uDirLightPos: { value: /* @__PURE__ */ new Vector3() },
-    uDirLightColor: { value: /* @__PURE__ */ new Color(0xeeeeee) },
+    uDirLightPos: { value: new Vector3() },
+    uDirLightColor: { value: new Color(0xeeeeee) },
 
-    uAmbientLightColor: { value: /* @__PURE__ */ new Color(0x050505) },
+    uAmbientLightColor: { value: new Color(0x050505) },
 
-    uBaseColor: { value: /* @__PURE__ */ new Color(0xeeeeee) },
-    uLineColor1: { value: /* @__PURE__ */ new Color(0x808080) },
-    uLineColor2: { value: /* @__PURE__ */ new Color(0x000000) },
-    uLineColor3: { value: /* @__PURE__ */ new Color(0x000000) },
-    uLineColor4: { value: /* @__PURE__ */ new Color(0x000000) },
+    uBaseColor: { value: new Color(0xeeeeee) },
+    uLineColor1: { value: new Color(0x808080) },
+    uLineColor2: { value: new Color(0x000000) },
+    uLineColor3: { value: new Color(0x000000) },
+    uLineColor4: { value: new Color(0x000000) },
   },
 
-  vertexShader: /* glsl */ `
-    varying vec3 vNormal;
+  vertexShader: [
+    'varying vec3 vNormal;',
 
-    void main() {
+    'void main() {',
 
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
-    	vNormal = normalize( normalMatrix * normal );
+    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    '	vNormal = normalize( normalMatrix * normal );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    uniform vec3 uBaseColor;
-    uniform vec3 uLineColor1;
-    uniform vec3 uLineColor2;
-    uniform vec3 uLineColor3;
-    uniform vec3 uLineColor4;
+  fragmentShader: [
+    'uniform vec3 uBaseColor;',
+    'uniform vec3 uLineColor1;',
+    'uniform vec3 uLineColor2;',
+    'uniform vec3 uLineColor3;',
+    'uniform vec3 uLineColor4;',
 
-    uniform vec3 uDirLightPos;
-    uniform vec3 uDirLightColor;
+    'uniform vec3 uDirLightPos;',
+    'uniform vec3 uDirLightColor;',
 
-    uniform vec3 uAmbientLightColor;
+    'uniform vec3 uAmbientLightColor;',
 
-    varying vec3 vNormal;
+    'varying vec3 vNormal;',
 
-    void main() {
+    'void main() {',
 
-    	float camera = max( dot( normalize( vNormal ), vec3( 0.0, 0.0, 1.0 ) ), 0.4);
-    	float light = max( dot( normalize( vNormal ), uDirLightPos ), 0.0);
+    '	float camera = max( dot( normalize( vNormal ), vec3( 0.0, 0.0, 1.0 ) ), 0.4);',
+    '	float light = max( dot( normalize( vNormal ), uDirLightPos ), 0.0);',
 
-    	gl_FragColor = vec4( uBaseColor, 1.0 );
+    '	gl_FragColor = vec4( uBaseColor, 1.0 );',
 
-    	if ( length(uAmbientLightColor + uDirLightColor * light) < 1.00 ) {
+    '	if ( length(uAmbientLightColor + uDirLightColor * light) < 1.00 ) {',
 
-    		gl_FragColor *= vec4( uLineColor1, 1.0 );
+    '		gl_FragColor *= vec4( uLineColor1, 1.0 );',
 
-    	}
+    '	}',
 
-    	if ( length(uAmbientLightColor + uDirLightColor * camera) < 0.50 ) {
+    '	if ( length(uAmbientLightColor + uDirLightColor * camera) < 0.50 ) {',
 
-    		gl_FragColor *= vec4( uLineColor2, 1.0 );
+    '		gl_FragColor *= vec4( uLineColor2, 1.0 );',
 
-    	}
+    '	}',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 }
 
 export const ToonShaderHatching = {
   uniforms: {
-    uDirLightPos: { value: /* @__PURE__ */ new Vector3() },
-    uDirLightColor: { value: /* @__PURE__ */ new Color(0xeeeeee) },
+    uDirLightPos: { value: new Vector3() },
+    uDirLightColor: { value: new Color(0xeeeeee) },
 
-    uAmbientLightColor: { value: /* @__PURE__ */ new Color(0x050505) },
+    uAmbientLightColor: { value: new Color(0x050505) },
 
-    uBaseColor: { value: /* @__PURE__ */ new Color(0xffffff) },
-    uLineColor1: { value: /* @__PURE__ */ new Color(0x000000) },
-    uLineColor2: { value: /* @__PURE__ */ new Color(0x000000) },
-    uLineColor3: { value: /* @__PURE__ */ new Color(0x000000) },
-    uLineColor4: { value: /* @__PURE__ */ new Color(0x000000) },
+    uBaseColor: { value: new Color(0xffffff) },
+    uLineColor1: { value: new Color(0x000000) },
+    uLineColor2: { value: new Color(0x000000) },
+    uLineColor3: { value: new Color(0x000000) },
+    uLineColor4: { value: new Color(0x000000) },
   },
 
-  vertexShader: /* glsl */ `
-    varying vec3 vNormal;
+  vertexShader: [
+    'varying vec3 vNormal;',
 
-    void main() {
+    'void main() {',
 
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
-    	vNormal = normalize( normalMatrix * normal );
+    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    '	vNormal = normalize( normalMatrix * normal );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    uniform vec3 uBaseColor;
-    uniform vec3 uLineColor1;
-    uniform vec3 uLineColor2;
-    uniform vec3 uLineColor3;
-    uniform vec3 uLineColor4;
+  fragmentShader: [
+    'uniform vec3 uBaseColor;',
+    'uniform vec3 uLineColor1;',
+    'uniform vec3 uLineColor2;',
+    'uniform vec3 uLineColor3;',
+    'uniform vec3 uLineColor4;',
 
-    uniform vec3 uDirLightPos;
-    uniform vec3 uDirLightColor;
+    'uniform vec3 uDirLightPos;',
+    'uniform vec3 uDirLightColor;',
 
-    uniform vec3 uAmbientLightColor;
+    'uniform vec3 uAmbientLightColor;',
 
-    varying vec3 vNormal;
+    'varying vec3 vNormal;',
 
-    void main() {
+    'void main() {',
 
-    	float directionalLightWeighting = max( dot( normalize(vNormal), uDirLightPos ), 0.0);
-    	vec3 lightWeighting = uAmbientLightColor + uDirLightColor * directionalLightWeighting;
+    '	float directionalLightWeighting = max( dot( normalize(vNormal), uDirLightPos ), 0.0);',
+    '	vec3 lightWeighting = uAmbientLightColor + uDirLightColor * directionalLightWeighting;',
 
-    	gl_FragColor = vec4( uBaseColor, 1.0 );
+    '	gl_FragColor = vec4( uBaseColor, 1.0 );',
 
-    	if ( length(lightWeighting) < 1.00 ) {
+    '	if ( length(lightWeighting) < 1.00 ) {',
 
-    		if ( mod(gl_FragCoord.x + gl_FragCoord.y, 10.0) == 0.0) {
+    '		if ( mod(gl_FragCoord.x + gl_FragCoord.y, 10.0) == 0.0) {',
 
-    			gl_FragColor = vec4( uLineColor1, 1.0 );
+    '			gl_FragColor = vec4( uLineColor1, 1.0 );',
 
-    		}
+    '		}',
 
-    	}
+    '	}',
 
-    	if ( length(lightWeighting) < 0.75 ) {
+    '	if ( length(lightWeighting) < 0.75 ) {',
 
-    		if (mod(gl_FragCoord.x - gl_FragCoord.y, 10.0) == 0.0) {
+    '		if (mod(gl_FragCoord.x - gl_FragCoord.y, 10.0) == 0.0) {',
 
-    			gl_FragColor = vec4( uLineColor2, 1.0 );
+    '			gl_FragColor = vec4( uLineColor2, 1.0 );',
 
-    		}
+    '		}',
 
-    	}
+    '	}',
 
-    	if ( length(lightWeighting) < 0.50 ) {
+    '	if ( length(lightWeighting) < 0.50 ) {',
 
-    		if (mod(gl_FragCoord.x + gl_FragCoord.y - 5.0, 10.0) == 0.0) {
+    '		if (mod(gl_FragCoord.x + gl_FragCoord.y - 5.0, 10.0) == 0.0) {',
 
-    			gl_FragColor = vec4( uLineColor3, 1.0 );
+    '			gl_FragColor = vec4( uLineColor3, 1.0 );',
 
-    		}
+    '		}',
 
-    	}
+    '	}',
 
-    	if ( length(lightWeighting) < 0.3465 ) {
+    '	if ( length(lightWeighting) < 0.3465 ) {',
 
-    		if (mod(gl_FragCoord.x - gl_FragCoord.y - 5.0, 10.0) == 0.0) {
+    '		if (mod(gl_FragCoord.x - gl_FragCoord.y - 5.0, 10.0) == 0.0) {',
 
-    			gl_FragColor = vec4( uLineColor4, 1.0 );
+    '			gl_FragColor = vec4( uLineColor4, 1.0 );',
 
-    	}
+    '	}',
 
-    	}
+    '	}',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 }
 
 export const ToonShaderDotted = {
   uniforms: {
-    uDirLightPos: { value: /* @__PURE__ */ new Vector3() },
-    uDirLightColor: { value: /* @__PURE__ */ new Color(0xeeeeee) },
+    uDirLightPos: { value: new Vector3() },
+    uDirLightColor: { value: new Color(0xeeeeee) },
 
-    uAmbientLightColor: { value: /* @__PURE__ */ new Color(0x050505) },
+    uAmbientLightColor: { value: new Color(0x050505) },
 
-    uBaseColor: { value: /* @__PURE__ */ new Color(0xffffff) },
-    uLineColor1: { value: /* @__PURE__ */ new Color(0x000000) },
+    uBaseColor: { value: new Color(0xffffff) },
+    uLineColor1: { value: new Color(0x000000) },
   },
 
-  vertexShader: /* glsl */ `
-    varying vec3 vNormal;
+  vertexShader: [
+    'varying vec3 vNormal;',
 
-    void main() {
+    'void main() {',
 
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
-    	vNormal = normalize( normalMatrix * normal );
+    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    '	vNormal = normalize( normalMatrix * normal );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    uniform vec3 uBaseColor;
-    uniform vec3 uLineColor1;
-    uniform vec3 uLineColor2;
-    uniform vec3 uLineColor3;
-    uniform vec3 uLineColor4;
+  fragmentShader: [
+    'uniform vec3 uBaseColor;',
+    'uniform vec3 uLineColor1;',
+    'uniform vec3 uLineColor2;',
+    'uniform vec3 uLineColor3;',
+    'uniform vec3 uLineColor4;',
 
-    uniform vec3 uDirLightPos;
-    uniform vec3 uDirLightColor;
+    'uniform vec3 uDirLightPos;',
+    'uniform vec3 uDirLightColor;',
 
-    uniform vec3 uAmbientLightColor;
+    'uniform vec3 uAmbientLightColor;',
 
-    varying vec3 vNormal;
+    'varying vec3 vNormal;',
 
-    void main() {
+    'void main() {',
 
-    float directionalLightWeighting = max( dot( normalize(vNormal), uDirLightPos ), 0.0);
-    vec3 lightWeighting = uAmbientLightColor + uDirLightColor * directionalLightWeighting;
+    'float directionalLightWeighting = max( dot( normalize(vNormal), uDirLightPos ), 0.0);',
+    'vec3 lightWeighting = uAmbientLightColor + uDirLightColor * directionalLightWeighting;',
 
-    gl_FragColor = vec4( uBaseColor, 1.0 );
+    'gl_FragColor = vec4( uBaseColor, 1.0 );',
 
-    if ( length(lightWeighting) < 1.00 ) {
+    'if ( length(lightWeighting) < 1.00 ) {',
 
-    		if ( ( mod(gl_FragCoord.x, 4.001) + mod(gl_FragCoord.y, 4.0) ) > 6.00 ) {
+    '		if ( ( mod(gl_FragCoord.x, 4.001) + mod(gl_FragCoord.y, 4.0) ) > 6.00 ) {',
 
-    			gl_FragColor = vec4( uLineColor1, 1.0 );
+    '			gl_FragColor = vec4( uLineColor1, 1.0 );',
 
-    		}
+    '		}',
 
-    	}
+    '	}',
 
-    	if ( length(lightWeighting) < 0.50 ) {
+    '	if ( length(lightWeighting) < 0.50 ) {',
 
-    		if ( ( mod(gl_FragCoord.x + 2.0, 4.001) + mod(gl_FragCoord.y + 2.0, 4.0) ) > 6.00 ) {
+    '		if ( ( mod(gl_FragCoord.x + 2.0, 4.001) + mod(gl_FragCoord.y + 2.0, 4.0) ) > 6.00 ) {',
 
-    			gl_FragColor = vec4( uLineColor1, 1.0 );
+    '			gl_FragColor = vec4( uLineColor1, 1.0 );',
 
-    		}
+    '		}',
 
-    	}
+    '	}',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 }
diff --git a/src/shaders/TriangleBlurShader.ts b/src/shaders/TriangleBlurShader.ts
index da98a712..e24c0838 100644
--- a/src/shaders/TriangleBlurShader.ts
+++ b/src/shaders/TriangleBlurShader.ts
@@ -13,52 +13,52 @@ import { Vector2 } from 'three'
 export const TriangleBlurShader = {
   uniforms: {
     texture: { value: null },
-    delta: { value: /* @__PURE__ */ new Vector2(1, 1) },
+    delta: { value: new Vector2(1, 1) },
   },
 
-  vertexShader: /* glsl */ `
-    varying vec2 vUv;
+  vertexShader: [
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vUv = uv;
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    '	vUv = uv;',
+    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    #include <common>
+  fragmentShader: [
+    '#include <common>',
 
-    #define ITERATIONS 10.0
+    '#define ITERATIONS 10.0',
 
-    uniform sampler2D texture;
-    uniform vec2 delta;
+    'uniform sampler2D texture;',
+    'uniform vec2 delta;',
 
-    varying vec2 vUv;
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vec4 color = vec4( 0.0 );
+    '	vec4 color = vec4( 0.0 );',
 
-    	float total = 0.0;
+    '	float total = 0.0;',
 
     // randomize the lookup values to hide the fixed number of samples
 
-    	float offset = rand( vUv );
+    '	float offset = rand( vUv );',
 
-    	for ( float t = -ITERATIONS; t <= ITERATIONS; t ++ ) {
+    '	for ( float t = -ITERATIONS; t <= ITERATIONS; t ++ ) {',
 
-    		float percent = ( t + offset - 0.5 ) / ITERATIONS;
-    		float weight = 1.0 - abs( percent );
+    '		float percent = ( t + offset - 0.5 ) / ITERATIONS;',
+    '		float weight = 1.0 - abs( percent );',
 
-    		color += texture2D( texture, vUv + delta * percent ) * weight;
-    		total += weight;
+    '		color += texture2D( texture, vUv + delta * percent ) * weight;',
+    '		total += weight;',
 
-    	}
+    '	}',
 
-    	gl_FragColor = color / total;
+    '	gl_FragColor = color / total;',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 }
diff --git a/src/shaders/UnpackDepthRGBAShader.ts b/src/shaders/UnpackDepthRGBAShader.ts
index dcc16d4e..28a43b09 100644
--- a/src/shaders/UnpackDepthRGBAShader.ts
+++ b/src/shaders/UnpackDepthRGBAShader.ts
@@ -9,31 +9,31 @@ export const UnpackDepthRGBAShader = {
     opacity: { value: 1.0 },
   },
 
-  vertexShader: /* glsl */ `
-    varying vec2 vUv;
+  vertexShader: [
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vUv = uv;
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    '	vUv = uv;',
+    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    uniform float opacity;
+  fragmentShader: [
+    'uniform float opacity;',
 
-    uniform sampler2D tDiffuse;
+    'uniform sampler2D tDiffuse;',
 
-    varying vec2 vUv;
+    'varying vec2 vUv;',
 
-    #include <packing>
+    '#include <packing>',
 
-    void main() {
+    'void main() {',
 
-    	float depth = 1.0 - unpackRGBAToDepth( texture2D( tDiffuse, vUv ) );
-    	gl_FragColor = vec4( vec3( depth ), opacity );
+    '	float depth = 1.0 - unpackRGBAToDepth( texture2D( tDiffuse, vUv ) );',
+    '	gl_FragColor = vec4( vec3( depth ), opacity );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 }
diff --git a/src/shaders/VerticalTiltShiftShader.ts b/src/shaders/VerticalTiltShiftShader.ts
index 47fd6a0d..bb237b0d 100644
--- a/src/shaders/VerticalTiltShiftShader.ts
+++ b/src/shaders/VerticalTiltShiftShader.ts
@@ -14,42 +14,42 @@ export const VerticalTiltShiftShader = {
     r: { value: 0.35 },
   },
 
-  vertexShader: /* glsl */ `
-    varying vec2 vUv;
+  vertexShader: [
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vUv = uv;
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    '	vUv = uv;',
+    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    uniform sampler2D tDiffuse;
-    uniform float v;
-    uniform float r;
+  fragmentShader: [
+    'uniform sampler2D tDiffuse;',
+    'uniform float v;',
+    'uniform float r;',
 
-    varying vec2 vUv;
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vec4 sum = vec4( 0.0 );
+    '	vec4 sum = vec4( 0.0 );',
 
-    	float vv = v * abs( r - vUv.y );
+    '	float vv = v * abs( r - vUv.y );',
 
-    	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 4.0 * vv ) ) * 0.051;
-    	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 3.0 * vv ) ) * 0.0918;
-    	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 2.0 * vv ) ) * 0.12245;
-    	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 1.0 * vv ) ) * 0.1531;
-    	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y ) ) * 0.1633;
-    	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 1.0 * vv ) ) * 0.1531;
-    	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 2.0 * vv ) ) * 0.12245;
-    	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 3.0 * vv ) ) * 0.0918;
-    	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 4.0 * vv ) ) * 0.051;
+    '	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 4.0 * vv ) ) * 0.051;',
+    '	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 3.0 * vv ) ) * 0.0918;',
+    '	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 2.0 * vv ) ) * 0.12245;',
+    '	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 1.0 * vv ) ) * 0.1531;',
+    '	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y ) ) * 0.1633;',
+    '	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 1.0 * vv ) ) * 0.1531;',
+    '	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 2.0 * vv ) ) * 0.12245;',
+    '	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 3.0 * vv ) ) * 0.0918;',
+    '	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 4.0 * vv ) ) * 0.051;',
 
-    	gl_FragColor = sum;
+    '	gl_FragColor = sum;',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 }
diff --git a/src/shaders/VignetteShader.ts b/src/shaders/VignetteShader.ts
index e3e9b30f..756478e2 100644
--- a/src/shaders/VignetteShader.ts
+++ b/src/shaders/VignetteShader.ts
@@ -11,32 +11,32 @@ export const VignetteShader = {
     darkness: { value: 1.0 },
   },
 
-  vertexShader: /* glsl */ `
-    varying vec2 vUv;
+  vertexShader: [
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    	vUv = uv;
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    '	vUv = uv;',
+    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    uniform float offset;
-    uniform float darkness;
+  fragmentShader: [
+    'uniform float offset;',
+    'uniform float darkness;',
 
-    uniform sampler2D tDiffuse;
+    'uniform sampler2D tDiffuse;',
 
-    varying vec2 vUv;
+    'varying vec2 vUv;',
 
-    void main() {
+    'void main() {',
 
-    // Eskils vignette
+    // Eskil's vignette
 
-    	vec4 texel = texture2D( tDiffuse, vUv );
-    	vec2 uv = ( vUv - vec2( 0.5 ) ) * vec2( offset );
-    	gl_FragColor = vec4( mix( texel.rgb, vec3( 1.0 - darkness ), dot( uv, uv ) ), texel.a );
+    '	vec4 texel = texture2D( tDiffuse, vUv );',
+    '	vec2 uv = ( vUv - vec2( 0.5 ) ) * vec2( offset );',
+    '	gl_FragColor = vec4( mix( texel.rgb, vec3( 1.0 - darkness ), dot( uv, uv ) ), texel.a );',
 
     /*
 		// alternative version from glfx.js
@@ -48,6 +48,6 @@ export const VignetteShader = {
 		"	gl_FragColor = color;",
 		*/
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 }
diff --git a/src/shaders/VolumeShader.ts b/src/shaders/VolumeShader.ts
index 7abcb6a0..eb321679 100644
--- a/src/shaders/VolumeShader.ts
+++ b/src/shaders/VolumeShader.ts
@@ -8,267 +8,267 @@ import { Vector2, Vector3 } from 'three'
 
 export const VolumeRenderShader1 = {
   uniforms: {
-    u_size: { value: /* @__PURE__ */ new Vector3(1, 1, 1) },
+    u_size: { value: new Vector3(1, 1, 1) },
     u_renderstyle: { value: 0 },
     u_renderthreshold: { value: 0.5 },
-    u_clim: { value: /* @__PURE__ */ new Vector2(1, 1) },
+    u_clim: { value: new Vector2(1, 1) },
     u_data: { value: null },
     u_cmdata: { value: null },
   },
-  vertexShader: /* glsl */ `
-		varying vec4 v_nearpos;
-		varying vec4 v_farpos;
-		varying vec3 v_position;
-
-		void main() {
-			// Prepare transforms to map to "camera view". See also:
-			// https://threejs.org/docs/#api/renderers/webgl/WebGLProgram
-			mat4 viewtransformf = modelViewMatrix;
-			mat4 viewtransformi = inverse(modelViewMatrix);
-
-			// Project local vertex coordinate to camera position. Then do a step
-			// backward (in cam coords) to the near clipping plane, and project back. Do
-			// the same for the far clipping plane. This gives us all the information we
-			// need to calculate the ray and truncate it to the viewing cone.
-			vec4 position4 = vec4(position, 1.0);
-			vec4 pos_in_cam = viewtransformf * position4;
-
-			// Intersection of ray and near clipping plane (z = -1 in clip coords)
-			pos_in_cam.z = -pos_in_cam.w;
-			v_nearpos = viewtransformi * pos_in_cam;
-
-			// Intersection of ray and far clipping plane (z = +1 in clip coords)
-			pos_in_cam.z = pos_in_cam.w;
-			v_farpos = viewtransformi * pos_in_cam;
-
-			// Set varyings and output pos
-			v_position = position;
-			gl_Position = projectionMatrix * viewMatrix * modelMatrix * position4;
-		}
-  `,
-  fragmentShader: /* glsl */ `
-		precision highp float;
-		precision mediump sampler3D;
-
-		uniform vec3 u_size;
-		uniform int u_renderstyle;
-		uniform float u_renderthreshold;
-		uniform vec2 u_clim;
-
-		uniform sampler3D u_data;
-		uniform sampler2D u_cmdata;
-
-		varying vec3 v_position;
-		varying vec4 v_nearpos;
-		varying vec4 v_farpos;
-
-	// The maximum distance through our rendering volume is sqrt(3).
-		const int MAX_STEPS = 887;	// 887 for 512^3, 1774 for 1024^3
-		const int REFINEMENT_STEPS = 4;
-		const float relative_step_size = 1.0;
-		const vec4 ambient_color = vec4(0.2, 0.4, 0.2, 1.0);
-		const vec4 diffuse_color = vec4(0.8, 0.2, 0.2, 1.0);
-		const vec4 specular_color = vec4(1.0, 1.0, 1.0, 1.0);
-		const float shininess = 40.0;
-
-		void cast_mip(vec3 start_loc, vec3 step, int nsteps, vec3 view_ray);
-		void cast_iso(vec3 start_loc, vec3 step, int nsteps, vec3 view_ray);
-
-		float sample1(vec3 texcoords);
-		vec4 apply_colormap(float val);
-		vec4 add_lighting(float val, vec3 loc, vec3 step, vec3 view_ray);
-
-		void main() {
-	// Normalize clipping plane info
-			vec3 farpos = v_farpos.xyz / v_farpos.w;
-			vec3 nearpos = v_nearpos.xyz / v_nearpos.w;
-
-	// Calculate unit vector pointing in the view direction through this fragment.
-			vec3 view_ray = normalize(nearpos.xyz - farpos.xyz);
-
-	// Compute the (negative) distance to the front surface or near clipping plane.
-	// v_position is the back face of the cuboid, so the initial distance calculated in the dot
-	// product below is the distance from near clip plane to the back of the cuboid
-			float distance = dot(nearpos - v_position, view_ray);
-			distance = max(distance, min((-0.5 - v_position.x) / view_ray.x,
-										(u_size.x - 0.5 - v_position.x) / view_ray.x));
-			distance = max(distance, min((-0.5 - v_position.y) / view_ray.y,
-										(u_size.y - 0.5 - v_position.y) / view_ray.y));
-			distance = max(distance, min((-0.5 - v_position.z) / view_ray.z,
-										(u_size.z - 0.5 - v_position.z) / view_ray.z));
-
-	// Now we have the starting position on the front surface
-			vec3 front = v_position + view_ray * distance;
-
-	// Decide how many steps to take
-			int nsteps = int(-distance / relative_step_size + 0.5);
-			if ( nsteps < 1 )
-				discard;
-
-	// Get starting location and step vector in texture coordinates
-			vec3 step = ((v_position - front) / u_size) / float(nsteps);
-			vec3 start_loc = front / u_size;
-
-	// For testing: show the number of steps. This helps to establish
-	// whether the rays are correctly oriented
-	//gl_FragColor = vec4(0.0, float(nsteps) / 1.0 / u_size.x, 1.0, 1.0);
-	//return;
-
-			if (u_renderstyle == 0)
-				cast_mip(start_loc, step, nsteps, view_ray);
-			else if (u_renderstyle == 1)
-				cast_iso(start_loc, step, nsteps, view_ray);
-
-			if (gl_FragColor.a < 0.05)
-				discard;
-		}
-
-		float sample1(vec3 texcoords) {
-			/* Sample float value from a 3D texture. Assumes intensity data. */
-			return texture(u_data, texcoords.xyz).r;
-		}
-
-		vec4 apply_colormap(float val) {
-			val = (val - u_clim[0]) / (u_clim[1] - u_clim[0]);
-			return texture2D(u_cmdata, vec2(val, 0.5));
-		}
-
-		void cast_mip(vec3 start_loc, vec3 step, int nsteps, vec3 view_ray) {
-
-			float max_val = -1e6;
-			int max_i = 100;
-			vec3 loc = start_loc;
-
-	// Enter the raycasting loop. In WebGL 1 the loop index cannot be compared with
-	// non-constant expression. So we use a hard-coded max, and an additional condition
-	// inside the loop.
-			for (int iter=0; iter<MAX_STEPS; iter++) {
-				if (iter >= nsteps)
-					break;
-	// Sample from the 3D texture
-				float val = sample1(loc);
-	// Apply MIP operation
-				if (val > max_val) {
-					max_val = val;
-					max_i = iter;
-				}
-	// Advance location deeper into the volume
-				loc += step;
-			}
-
-	// Refine location, gives crispier images
-			vec3 iloc = start_loc + step * (float(max_i) - 0.5);
-			vec3 istep = step / float(REFINEMENT_STEPS);
-			for (int i=0; i<REFINEMENT_STEPS; i++) {
-				max_val = max(max_val, sample1(iloc));
-				iloc += istep;
-			}
-
-	// Resolve final color
-			gl_FragColor = apply_colormap(max_val);
-		}
-
-		void cast_iso(vec3 start_loc, vec3 step, int nsteps, vec3 view_ray) {
-
-			gl_FragColor = vec4(0.0);	// init transparent
-			vec4 color3 = vec4(0.0);	// final color
-			vec3 dstep = 1.5 / u_size;	// step to sample derivative
-			vec3 loc = start_loc;
-
-			float low_threshold = u_renderthreshold - 0.02 * (u_clim[1] - u_clim[0]);
-
-	// Enter the raycasting loop. In WebGL 1 the loop index cannot be compared with
-	// non-constant expression. So we use a hard-coded max, and an additional condition
-	// inside the loop.
-			for (int iter=0; iter<MAX_STEPS; iter++) {
-				if (iter >= nsteps)
-					break;
-
-	// Sample from the 3D texture
-				float val = sample1(loc);
-
-				if (val > low_threshold) {
-	// Take the last interval in smaller steps
-					vec3 iloc = loc - 0.5 * step;
-					vec3 istep = step / float(REFINEMENT_STEPS);
-					for (int i=0; i<REFINEMENT_STEPS; i++) {
-						val = sample1(iloc);
-						if (val > u_renderthreshold) {
-							gl_FragColor = add_lighting(val, iloc, dstep, view_ray);
-							return;
-						}
-						iloc += istep;
-					}
-				}
-
-	// Advance location deeper into the volume
-				loc += step;
-			}
-		}
-
-		vec4 add_lighting(float val, vec3 loc, vec3 step, vec3 view_ray)
-		{
-	// Calculate color by incorporating lighting
-
-	// View direction
-			vec3 V = normalize(view_ray);
-
-	// calculate normal vector from gradient
-			vec3 N;
-			float val1, val2;
-			val1 = sample1(loc + vec3(-step[0], 0.0, 0.0));
-			val2 = sample1(loc + vec3(+step[0], 0.0, 0.0));
-			N[0] = val1 - val2;
-			val = max(max(val1, val2), val);
-			val1 = sample1(loc + vec3(0.0, -step[1], 0.0));
-			val2 = sample1(loc + vec3(0.0, +step[1], 0.0));
-			N[1] = val1 - val2;
-			val = max(max(val1, val2), val);
-			val1 = sample1(loc + vec3(0.0, 0.0, -step[2]));
-			val2 = sample1(loc + vec3(0.0, 0.0, +step[2]));
-			N[2] = val1 - val2;
-			val = max(max(val1, val2), val);
-
-			float gm = length(N); // gradient magnitude
-			N = normalize(N);
-
-	// Flip normal so it points towards viewer
-			float Nselect = float(dot(N, V) > 0.0);
-			N = (2.0 * Nselect - 1.0) * N;	// ==	Nselect * N - (1.0-Nselect)*N;
-
-	// Init colors
-			vec4 ambient_color = vec4(0.0, 0.0, 0.0, 0.0);
-			vec4 diffuse_color = vec4(0.0, 0.0, 0.0, 0.0);
-			vec4 specular_color = vec4(0.0, 0.0, 0.0, 0.0);
-
-	// note: could allow multiple lights
-			for (int i=0; i<1; i++)
-			{
-	// Get light direction (make sure to prevent zero devision)
-				vec3 L = normalize(view_ray);	//lightDirs[i];
-				float lightEnabled = float( length(L) > 0.0 );
-				L = normalize(L + (1.0 - lightEnabled));
-
-	// Calculate lighting properties
-				float lambertTerm = clamp(dot(N, L), 0.0, 1.0);
-				vec3 H = normalize(L+V); // Halfway vector
-				float specularTerm = pow(max(dot(H, N), 0.0), shininess);
-
-	// Calculate mask
-				float mask1 = lightEnabled;
-
-	// Calculate colors
-				ambient_color +=	mask1 * ambient_color;	// * gl_LightSource[i].ambient;
-				diffuse_color +=	mask1 * lambertTerm;
-				specular_color += mask1 * specularTerm * specular_color;
-			}
-
-	// Calculate final color by componing different components
-			vec4 final_color;
-			vec4 color = apply_colormap(val);
-			final_color = color * (ambient_color + diffuse_color) + specular_color;
-			final_color.a = color.a;
-			return final_color;
-		}
-  `,
+  vertexShader: [
+    '		varying vec4 v_nearpos;',
+    '		varying vec4 v_farpos;',
+    '		varying vec3 v_position;',
+
+    '		void main() {',
+    // Prepare transforms to map to "camera view". See also:
+    // https://threejs.org/docs/#api/renderers/webgl/WebGLProgram
+    '				mat4 viewtransformf = modelViewMatrix;',
+    '				mat4 viewtransformi = inverse(modelViewMatrix);',
+
+    // Project local vertex coordinate to camera position. Then do a step
+    // backward (in cam coords) to the near clipping plane, and project back. Do
+    // the same for the far clipping plane. This gives us all the information we
+    // need to calculate the ray and truncate it to the viewing cone.
+    '				vec4 position4 = vec4(position, 1.0);',
+    '				vec4 pos_in_cam = viewtransformf * position4;',
+
+    // Intersection of ray and near clipping plane (z = -1 in clip coords)
+    '				pos_in_cam.z = -pos_in_cam.w;',
+    '				v_nearpos = viewtransformi * pos_in_cam;',
+
+    // Intersection of ray and far clipping plane (z = +1 in clip coords)
+    '				pos_in_cam.z = pos_in_cam.w;',
+    '				v_farpos = viewtransformi * pos_in_cam;',
+
+    // Set varyings and output pos
+    '				v_position = position;',
+    '				gl_Position = projectionMatrix * viewMatrix * modelMatrix * position4;',
+    '		}',
+  ].join('\n'),
+  fragmentShader: [
+    '		precision highp float;',
+    '		precision mediump sampler3D;',
+
+    '		uniform vec3 u_size;',
+    '		uniform int u_renderstyle;',
+    '		uniform float u_renderthreshold;',
+    '		uniform vec2 u_clim;',
+
+    '		uniform sampler3D u_data;',
+    '		uniform sampler2D u_cmdata;',
+
+    '		varying vec3 v_position;',
+    '		varying vec4 v_nearpos;',
+    '		varying vec4 v_farpos;',
+
+    // The maximum distance through our rendering volume is sqrt(3).
+    '		const int MAX_STEPS = 887;	// 887 for 512^3, 1774 for 1024^3',
+    '		const int REFINEMENT_STEPS = 4;',
+    '		const float relative_step_size = 1.0;',
+    '		const vec4 ambient_color = vec4(0.2, 0.4, 0.2, 1.0);',
+    '		const vec4 diffuse_color = vec4(0.8, 0.2, 0.2, 1.0);',
+    '		const vec4 specular_color = vec4(1.0, 1.0, 1.0, 1.0);',
+    '		const float shininess = 40.0;',
+
+    '		void cast_mip(vec3 start_loc, vec3 step, int nsteps, vec3 view_ray);',
+    '		void cast_iso(vec3 start_loc, vec3 step, int nsteps, vec3 view_ray);',
+
+    '		float sample1(vec3 texcoords);',
+    '		vec4 apply_colormap(float val);',
+    '		vec4 add_lighting(float val, vec3 loc, vec3 step, vec3 view_ray);',
+
+    '		void main() {',
+    // Normalize clipping plane info
+    '				vec3 farpos = v_farpos.xyz / v_farpos.w;',
+    '				vec3 nearpos = v_nearpos.xyz / v_nearpos.w;',
+
+    // Calculate unit vector pointing in the view direction through this fragment.
+    '				vec3 view_ray = normalize(nearpos.xyz - farpos.xyz);',
+
+    // Compute the (negative) distance to the front surface or near clipping plane.
+    // v_position is the back face of the cuboid, so the initial distance calculated in the dot
+    // product below is the distance from near clip plane to the back of the cuboid
+    '				float distance = dot(nearpos - v_position, view_ray);',
+    '				distance = max(distance, min((-0.5 - v_position.x) / view_ray.x,',
+    '																		(u_size.x - 0.5 - v_position.x) / view_ray.x));',
+    '				distance = max(distance, min((-0.5 - v_position.y) / view_ray.y,',
+    '																		(u_size.y - 0.5 - v_position.y) / view_ray.y));',
+    '				distance = max(distance, min((-0.5 - v_position.z) / view_ray.z,',
+    '																		(u_size.z - 0.5 - v_position.z) / view_ray.z));',
+
+    // Now we have the starting position on the front surface
+    '				vec3 front = v_position + view_ray * distance;',
+
+    // Decide how many steps to take
+    '				int nsteps = int(-distance / relative_step_size + 0.5);',
+    '				if ( nsteps < 1 )',
+    '						discard;',
+
+    // Get starting location and step vector in texture coordinates
+    '				vec3 step = ((v_position - front) / u_size) / float(nsteps);',
+    '				vec3 start_loc = front / u_size;',
+
+    // For testing: show the number of steps. This helps to establish
+    // whether the rays are correctly oriented
+    //'gl_FragColor = vec4(0.0, float(nsteps) / 1.0 / u_size.x, 1.0, 1.0);',
+    //'return;',
+
+    '				if (u_renderstyle == 0)',
+    '						cast_mip(start_loc, step, nsteps, view_ray);',
+    '				else if (u_renderstyle == 1)',
+    '						cast_iso(start_loc, step, nsteps, view_ray);',
+
+    '				if (gl_FragColor.a < 0.05)',
+    '						discard;',
+    '		}',
+
+    '		float sample1(vec3 texcoords) {',
+    '				/* Sample float value from a 3D texture. Assumes intensity data. */',
+    '				return texture(u_data, texcoords.xyz).r;',
+    '		}',
+
+    '		vec4 apply_colormap(float val) {',
+    '				val = (val - u_clim[0]) / (u_clim[1] - u_clim[0]);',
+    '				return texture2D(u_cmdata, vec2(val, 0.5));',
+    '		}',
+
+    '		void cast_mip(vec3 start_loc, vec3 step, int nsteps, vec3 view_ray) {',
+
+    '				float max_val = -1e6;',
+    '				int max_i = 100;',
+    '				vec3 loc = start_loc;',
+
+    // Enter the raycasting loop. In WebGL 1 the loop index cannot be compared with
+    // non-constant expression. So we use a hard-coded max, and an additional condition
+    // inside the loop.
+    '				for (int iter=0; iter<MAX_STEPS; iter++) {',
+    '						if (iter >= nsteps)',
+    '								break;',
+    // Sample from the 3D texture
+    '						float val = sample1(loc);',
+    // Apply MIP operation
+    '						if (val > max_val) {',
+    '								max_val = val;',
+    '								max_i = iter;',
+    '						}',
+    // Advance location deeper into the volume
+    '						loc += step;',
+    '				}',
+
+    // Refine location, gives crispier images
+    '				vec3 iloc = start_loc + step * (float(max_i) - 0.5);',
+    '				vec3 istep = step / float(REFINEMENT_STEPS);',
+    '				for (int i=0; i<REFINEMENT_STEPS; i++) {',
+    '						max_val = max(max_val, sample1(iloc));',
+    '						iloc += istep;',
+    '				}',
+
+    // Resolve final color
+    '				gl_FragColor = apply_colormap(max_val);',
+    '		}',
+
+    '		void cast_iso(vec3 start_loc, vec3 step, int nsteps, vec3 view_ray) {',
+
+    '				gl_FragColor = vec4(0.0);	// init transparent',
+    '				vec4 color3 = vec4(0.0);	// final color',
+    '				vec3 dstep = 1.5 / u_size;	// step to sample derivative',
+    '				vec3 loc = start_loc;',
+
+    '				float low_threshold = u_renderthreshold - 0.02 * (u_clim[1] - u_clim[0]);',
+
+    // Enter the raycasting loop. In WebGL 1 the loop index cannot be compared with
+    // non-constant expression. So we use a hard-coded max, and an additional condition
+    // inside the loop.
+    '				for (int iter=0; iter<MAX_STEPS; iter++) {',
+    '						if (iter >= nsteps)',
+    '								break;',
+
+    // Sample from the 3D texture
+    '						float val = sample1(loc);',
+
+    '						if (val > low_threshold) {',
+    // Take the last interval in smaller steps
+    '								vec3 iloc = loc - 0.5 * step;',
+    '								vec3 istep = step / float(REFINEMENT_STEPS);',
+    '								for (int i=0; i<REFINEMENT_STEPS; i++) {',
+    '										val = sample1(iloc);',
+    '										if (val > u_renderthreshold) {',
+    '												gl_FragColor = add_lighting(val, iloc, dstep, view_ray);',
+    '												return;',
+    '										}',
+    '										iloc += istep;',
+    '								}',
+    '						}',
+
+    // Advance location deeper into the volume
+    '						loc += step;',
+    '				}',
+    '		}',
+
+    '		vec4 add_lighting(float val, vec3 loc, vec3 step, vec3 view_ray)',
+    '		{',
+    // Calculate color by incorporating lighting
+
+    // View direction
+    '				vec3 V = normalize(view_ray);',
+
+    // calculate normal vector from gradient
+    '				vec3 N;',
+    '				float val1, val2;',
+    '				val1 = sample1(loc + vec3(-step[0], 0.0, 0.0));',
+    '				val2 = sample1(loc + vec3(+step[0], 0.0, 0.0));',
+    '				N[0] = val1 - val2;',
+    '				val = max(max(val1, val2), val);',
+    '				val1 = sample1(loc + vec3(0.0, -step[1], 0.0));',
+    '				val2 = sample1(loc + vec3(0.0, +step[1], 0.0));',
+    '				N[1] = val1 - val2;',
+    '				val = max(max(val1, val2), val);',
+    '				val1 = sample1(loc + vec3(0.0, 0.0, -step[2]));',
+    '				val2 = sample1(loc + vec3(0.0, 0.0, +step[2]));',
+    '				N[2] = val1 - val2;',
+    '				val = max(max(val1, val2), val);',
+
+    '				float gm = length(N); // gradient magnitude',
+    '				N = normalize(N);',
+
+    // Flip normal so it points towards viewer
+    '				float Nselect = float(dot(N, V) > 0.0);',
+    '				N = (2.0 * Nselect - 1.0) * N;	// ==	Nselect * N - (1.0-Nselect)*N;',
+
+    // Init colors
+    '				vec4 ambient_color = vec4(0.0, 0.0, 0.0, 0.0);',
+    '				vec4 diffuse_color = vec4(0.0, 0.0, 0.0, 0.0);',
+    '				vec4 specular_color = vec4(0.0, 0.0, 0.0, 0.0);',
+
+    // note: could allow multiple lights
+    '				for (int i=0; i<1; i++)',
+    '				{',
+    // Get light direction (make sure to prevent zero devision)
+    '						vec3 L = normalize(view_ray);	//lightDirs[i];',
+    '						float lightEnabled = float( length(L) > 0.0 );',
+    '						L = normalize(L + (1.0 - lightEnabled));',
+
+    // Calculate lighting properties
+    '						float lambertTerm = clamp(dot(N, L), 0.0, 1.0);',
+    '						vec3 H = normalize(L+V); // Halfway vector',
+    '						float specularTerm = pow(max(dot(H, N), 0.0), shininess);',
+
+    // Calculate mask
+    '						float mask1 = lightEnabled;',
+
+    // Calculate colors
+    '						ambient_color +=	mask1 * ambient_color;	// * gl_LightSource[i].ambient;',
+    '						diffuse_color +=	mask1 * lambertTerm;',
+    '						specular_color += mask1 * specularTerm * specular_color;',
+    '				}',
+
+    // Calculate final color by componing different components
+    '				vec4 final_color;',
+    '				vec4 color = apply_colormap(val);',
+    '				final_color = color * (ambient_color + diffuse_color) + specular_color;',
+    '				final_color.a = color.a;',
+    '				return final_color;',
+    '		}',
+  ].join('\n'),
 }
diff --git a/src/shaders/WaterRefractionShader.ts b/src/shaders/WaterRefractionShader.ts
index 7f14e079..32f2cb7b 100644
--- a/src/shaders/WaterRefractionShader.ts
+++ b/src/shaders/WaterRefractionShader.ts
@@ -21,64 +21,64 @@ export const WaterRefractionShader = {
     },
   },
 
-  vertexShader: /* glsl */ `
-    uniform mat4 textureMatrix;
+  vertexShader: [
+    'uniform mat4 textureMatrix;',
 
-    varying vec2 vUv;
-    varying vec4 vUvRefraction;
+    'varying vec2 vUv;',
+    'varying vec4 vUvRefraction;',
 
-    void main() {
+    'void main() {',
 
-    	vUv = uv;
+    '	vUv = uv;',
 
-    	vUvRefraction = textureMatrix * vec4( position, 1.0 );
+    '	vUvRefraction = textureMatrix * vec4( position, 1.0 );',
 
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 
-  fragmentShader: /* glsl */ `
-    uniform vec3 color;
-    uniform float time;
-    uniform sampler2D tDiffuse;
-    uniform sampler2D tDudv;
+  fragmentShader: [
+    'uniform vec3 color;',
+    'uniform float time;',
+    'uniform sampler2D tDiffuse;',
+    'uniform sampler2D tDudv;',
 
-    varying vec2 vUv;
-    varying vec4 vUvRefraction;
+    'varying vec2 vUv;',
+    'varying vec4 vUvRefraction;',
 
-    float blendOverlay( float base, float blend ) {
+    'float blendOverlay( float base, float blend ) {',
 
-    	return( base < 0.5 ? ( 2.0 * base * blend ) : ( 1.0 - 2.0 * ( 1.0 - base ) * ( 1.0 - blend ) ) );
+    '	return( base < 0.5 ? ( 2.0 * base * blend ) : ( 1.0 - 2.0 * ( 1.0 - base ) * ( 1.0 - blend ) ) );',
 
-    }
+    '}',
 
-    vec3 blendOverlay( vec3 base, vec3 blend ) {
+    'vec3 blendOverlay( vec3 base, vec3 blend ) {',
 
-    	return vec3( blendOverlay( base.r, blend.r ), blendOverlay( base.g, blend.g ),blendOverlay( base.b, blend.b ) );
+    '	return vec3( blendOverlay( base.r, blend.r ), blendOverlay( base.g, blend.g ),blendOverlay( base.b, blend.b ) );',
 
-    }
+    '}',
 
-    void main() {
+    'void main() {',
 
-     float waveStrength = 0.1;
-     float waveSpeed = 0.03;
+    ' float waveStrength = 0.1;',
+    ' float waveSpeed = 0.03;',
 
     // simple distortion (ripple) via dudv map (see https://www.youtube.com/watch?v=6B7IF6GOu7s)
 
-    	vec2 distortedUv = texture2D( tDudv, vec2( vUv.x + time * waveSpeed, vUv.y ) ).rg * waveStrength;
-    	distortedUv = vUv.xy + vec2( distortedUv.x, distortedUv.y + time * waveSpeed );
-    	vec2 distortion = ( texture2D( tDudv, distortedUv ).rg * 2.0 - 1.0 ) * waveStrength;
+    '	vec2 distortedUv = texture2D( tDudv, vec2( vUv.x + time * waveSpeed, vUv.y ) ).rg * waveStrength;',
+    '	distortedUv = vUv.xy + vec2( distortedUv.x, distortedUv.y + time * waveSpeed );',
+    '	vec2 distortion = ( texture2D( tDudv, distortedUv ).rg * 2.0 - 1.0 ) * waveStrength;',
 
     // new uv coords
 
-     vec4 uv = vec4( vUvRefraction );
-     uv.xy += distortion;
+    ' vec4 uv = vec4( vUvRefraction );',
+    ' uv.xy += distortion;',
 
-    	vec4 base = texture2DProj( tDiffuse, uv );
+    '	vec4 base = texture2DProj( tDiffuse, uv );',
 
-    	gl_FragColor = vec4( blendOverlay( base.rgb, color ), 1.0 );
+    '	gl_FragColor = vec4( blendOverlay( base.rgb, color ), 1.0 );',
 
-    }
-  `,
+    '}',
+  ].join('\n'),
 }
diff --git a/src/utils/GeometryCompressionUtils.js b/src/utils/GeometryCompressionUtils.js
index 7bee13fe..dec6b46e 100644
--- a/src/utils/GeometryCompressionUtils.js
+++ b/src/utils/GeometryCompressionUtils.js
@@ -14,8 +14,8 @@ import {
   ShaderLib,
   UniformsUtils,
   Vector3,
+  REVISION,
 } from 'three'
-import { version } from '../_polyfill/constants'
 
 var GeometryCompressionUtils = {
   /**
@@ -732,7 +732,7 @@ class PackedPhongMaterial extends MeshPhongMaterial {
       'gl_FragColor = vec4( outgoingLight, diffuseColor.a );',
 
       ShaderChunk.tonemapping_fragment,
-      version >= 154 ? ShaderChunk.colorspace_fragment : ShaderChunk.encodings_fragment,
+      parseInt(REVISION.replace(/\D+/g, '')) >= 154 ? ShaderChunk.colorspace_fragment : ShaderChunk.encodings_fragment,
       ShaderChunk.fog_fragment,
       ShaderChunk.premultiplied_alpha_fragment,
       ShaderChunk.dithering_fragment,
diff --git a/src/utils/LDrawUtils.js b/src/utils/LDrawUtils.js
index de7ab99c..1329807f 100644
--- a/src/utils/LDrawUtils.js
+++ b/src/utils/LDrawUtils.js
@@ -1,8 +1,8 @@
 import { BufferAttribute, BufferGeometry, Group, LineSegments, Matrix3, Mesh } from 'three'
 import { mergeBufferGeometries } from './BufferGeometryUtils'
 
-const LDrawUtils = {
-  mergeObject(object) {
+class LDrawUtils {
+  static mergeObject(object) {
     // Merges geometries in object by materials and returns new object. Use on not indexed geometries.
     // The object buffers reference the old object ones.
     // Special treatment is done to the conditional lines generated by LDrawLoader.
@@ -150,7 +150,7 @@ const LDrawUtils = {
     mergedObject.userData.numConstructionSteps = 1
 
     return mergedObject
-  },
+  }
 }
 
 export { LDrawUtils }
diff --git a/src/utils/RoughnessMipmapper.js b/src/utils/RoughnessMipmapper.js
index 6b58a42b..46e58c7c 100644
--- a/src/utils/RoughnessMipmapper.js
+++ b/src/utils/RoughnessMipmapper.js
@@ -17,11 +17,11 @@ import {
   WebGLRenderTarget,
 } from 'three'
 
-var _mipmapMaterial = /* @__PURE__ */ _getMipmapMaterial()
+var _mipmapMaterial = _getMipmapMaterial()
 
-var _mesh = /* @__PURE__ */ new Mesh(/* @__PURE__ */ new PlaneGeometry(2, 2), _mipmapMaterial)
+var _mesh = new Mesh(new PlaneGeometry(2, 2), _mipmapMaterial)
 
-var _flatCamera = /* @__PURE__ */ new OrthographicCamera(0, 1, 0, 1, 0, 1)
+var _flatCamera = new OrthographicCamera(0, 1, 0, 1, 0, 1)
 
 var _tempTarget = null
 
diff --git a/src/webxr/ARButton.ts b/src/webxr/ARButton.ts
index ba806fea..d29b80dc 100644
--- a/src/webxr/ARButton.ts
+++ b/src/webxr/ARButton.ts
@@ -1,169 +1,162 @@
 import { WebGLRenderer } from 'three'
 
-const ARButton = /* @__PURE__ */ (() => {
-  class ARButton {
-    static createButton(
-      renderer: WebGLRenderer,
-      sessionInit: XRSessionInit = {},
-    ): HTMLButtonElement | HTMLAnchorElement {
-      const button = document.createElement('button')
-
-      function showStartAR(/*device*/): void {
-        if ((sessionInit as any).domOverlay === undefined) {
-          const overlay = document.createElement('div')
-          overlay.style.display = 'none'
-          document.body.appendChild(overlay)
-
-          const svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg')
-          svg.setAttribute('width', '38px')
-          svg.setAttribute('height', '38px')
-          svg.style.position = 'absolute'
-          svg.style.right = '20px'
-          svg.style.top = '20px'
-          svg.addEventListener('click', function () {
-            currentSession?.end()
-          })
-          overlay.appendChild(svg)
-
-          const path = document.createElementNS('http://www.w3.org/2000/svg', 'path')
-          path.setAttribute('d', 'M 12,12 L 28,28 M 28,12 12,28')
-          path.setAttribute('stroke', '#fff')
-          path.setAttribute('stroke-width', '2px')
-          svg.appendChild(path)
-
-          if (sessionInit.optionalFeatures === undefined) {
-            sessionInit.optionalFeatures = []
-          }
-
-          sessionInit.optionalFeatures.push('dom-overlay')
-          ;(sessionInit as any).domOverlay = { root: overlay }
+class ARButton {
+  static createButton(renderer: WebGLRenderer, sessionInit: XRSessionInit = {}): HTMLButtonElement | HTMLAnchorElement {
+    const button = document.createElement('button')
+
+    function showStartAR(/*device*/): void {
+      if ((sessionInit as any).domOverlay === undefined) {
+        const overlay = document.createElement('div')
+        overlay.style.display = 'none'
+        document.body.appendChild(overlay)
+
+        const svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg')
+        svg.setAttribute('width', '38px')
+        svg.setAttribute('height', '38px')
+        svg.style.position = 'absolute'
+        svg.style.right = '20px'
+        svg.style.top = '20px'
+        svg.addEventListener('click', function () {
+          currentSession?.end()
+        })
+        overlay.appendChild(svg)
+
+        const path = document.createElementNS('http://www.w3.org/2000/svg', 'path')
+        path.setAttribute('d', 'M 12,12 L 28,28 M 28,12 12,28')
+        path.setAttribute('stroke', '#fff')
+        path.setAttribute('stroke-width', '2px')
+        svg.appendChild(path)
+
+        if (sessionInit.optionalFeatures === undefined) {
+          sessionInit.optionalFeatures = []
         }
 
-        //
+        sessionInit.optionalFeatures.push('dom-overlay')
+        ;(sessionInit as any).domOverlay = { root: overlay }
+      }
 
-        let currentSession: XRSession | null = null
+      //
 
-        async function onSessionStarted(session: XRSession): Promise<void> {
-          session.addEventListener('end', onSessionEnded)
+      let currentSession: XRSession | null = null
 
-          renderer.xr.setReferenceSpaceType('local')
+      async function onSessionStarted(session: XRSession): Promise<void> {
+        session.addEventListener('end', onSessionEnded)
 
-          await renderer.xr.setSession(session as any)
+        renderer.xr.setReferenceSpaceType('local')
 
-          button.textContent = 'STOP AR'
-          ;(sessionInit as any).domOverlay!.root.style.display = ''
+        await renderer.xr.setSession(session as any)
 
-          currentSession = session
-        }
+        button.textContent = 'STOP AR'
+        ;(sessionInit as any).domOverlay!.root.style.display = ''
 
-        function onSessionEnded(/*event*/): void {
-          currentSession!.removeEventListener('end', onSessionEnded)
+        currentSession = session
+      }
 
-          button.textContent = 'START AR'
-          ;(sessionInit as any).domOverlay!.root.style.display = 'none'
+      function onSessionEnded(/*event*/): void {
+        currentSession!.removeEventListener('end', onSessionEnded)
 
-          currentSession = null
-        }
+        button.textContent = 'START AR'
+        ;(sessionInit as any).domOverlay!.root.style.display = 'none'
 
-        //
+        currentSession = null
+      }
 
-        button.style.display = ''
+      //
 
-        button.style.cursor = 'pointer'
-        button.style.left = 'calc(50% - 50px)'
-        button.style.width = '100px'
+      button.style.display = ''
 
-        button.textContent = 'START AR'
+      button.style.cursor = 'pointer'
+      button.style.left = 'calc(50% - 50px)'
+      button.style.width = '100px'
 
-        button.onmouseenter = (): void => {
-          button.style.opacity = '1.0'
-        }
+      button.textContent = 'START AR'
 
-        button.onmouseleave = (): void => {
-          button.style.opacity = '0.5'
-        }
+      button.onmouseenter = (): void => {
+        button.style.opacity = '1.0'
+      }
 
-        button.onclick = (): void => {
-          if (currentSession === null) {
-            ;(navigator as Navigator).xr!.requestSession('immersive-ar', sessionInit).then(onSessionStarted)
-          } else {
-            currentSession.end()
-          }
+      button.onmouseleave = (): void => {
+        button.style.opacity = '0.5'
+      }
+
+      button.onclick = (): void => {
+        if (currentSession === null) {
+          ;(navigator as Navigator).xr!.requestSession('immersive-ar', sessionInit).then(onSessionStarted)
+        } else {
+          currentSession.end()
         }
       }
+    }
 
-      function disableButton(): void {
-        button.style.display = ''
+    function disableButton(): void {
+      button.style.display = ''
 
-        button.style.cursor = 'auto'
-        button.style.left = 'calc(50% - 75px)'
-        button.style.width = '150px'
+      button.style.cursor = 'auto'
+      button.style.left = 'calc(50% - 75px)'
+      button.style.width = '150px'
 
-        button.onmouseenter = null
-        button.onmouseleave = null
+      button.onmouseenter = null
+      button.onmouseleave = null
 
-        button.onclick = null
-      }
+      button.onclick = null
+    }
 
-      function showARNotSupported(): void {
-        disableButton()
+    function showARNotSupported(): void {
+      disableButton()
 
-        button.textContent = 'AR NOT SUPPORTED'
-      }
+      button.textContent = 'AR NOT SUPPORTED'
+    }
 
-      function stylizeElement(element: HTMLElement): void {
-        element.style.position = 'absolute'
-        element.style.bottom = '20px'
-        element.style.padding = '12px 6px'
-        element.style.border = '1px solid #fff'
-        element.style.borderRadius = '4px'
-        element.style.background = 'rgba(0,0,0,0.1)'
-        element.style.color = '#fff'
-        element.style.font = 'normal 13px sans-serif'
-        element.style.textAlign = 'center'
-        element.style.opacity = '0.5'
-        element.style.outline = 'none'
-        element.style.zIndex = '999'
-      }
+    function stylizeElement(element: HTMLElement): void {
+      element.style.position = 'absolute'
+      element.style.bottom = '20px'
+      element.style.padding = '12px 6px'
+      element.style.border = '1px solid #fff'
+      element.style.borderRadius = '4px'
+      element.style.background = 'rgba(0,0,0,0.1)'
+      element.style.color = '#fff'
+      element.style.font = 'normal 13px sans-serif'
+      element.style.textAlign = 'center'
+      element.style.opacity = '0.5'
+      element.style.outline = 'none'
+      element.style.zIndex = '999'
+    }
 
-      if ('xr' in navigator) {
-        button.id = 'ARButton'
-        button.style.display = 'none'
+    if ('xr' in navigator) {
+      button.id = 'ARButton'
+      button.style.display = 'none'
 
-        stylizeElement(button)
+      stylizeElement(button)
 
-        // Query for session mode
-        ;(navigator as Navigator)
-          .xr!.isSessionSupported('immersive-ar')
-          .then(function (supported: boolean) {
-            supported ? showStartAR() : showARNotSupported()
-          })
-          .catch(showARNotSupported)
+      // Query for session mode
+      ;(navigator as Navigator)
+        .xr!.isSessionSupported('immersive-ar')
+        .then(function (supported: boolean) {
+          supported ? showStartAR() : showARNotSupported()
+        })
+        .catch(showARNotSupported)
 
-        return button
-      } else {
-        const message = document.createElement('a')
+      return button
+    } else {
+      const message = document.createElement('a')
 
-        if (window.isSecureContext === false) {
-          message.href = document.location.href.replace(/^http:/, 'https:')
-          message.innerHTML = 'WEBXR NEEDS HTTPS' // TODO Improve message
-        } else {
-          message.href = 'https://immersiveweb.dev/'
-          message.innerHTML = 'WEBXR NOT AVAILABLE'
-        }
+      if (window.isSecureContext === false) {
+        message.href = document.location.href.replace(/^http:/, 'https:')
+        message.innerHTML = 'WEBXR NEEDS HTTPS' // TODO Improve message
+      } else {
+        message.href = 'https://immersiveweb.dev/'
+        message.innerHTML = 'WEBXR NOT AVAILABLE'
+      }
 
-        message.style.left = 'calc(50% - 90px)'
-        message.style.width = '180px'
-        message.style.textDecoration = 'none'
+      message.style.left = 'calc(50% - 90px)'
+      message.style.width = '180px'
+      message.style.textDecoration = 'none'
 
-        stylizeElement(message)
+      stylizeElement(message)
 
-        return message
-      }
+      return message
     }
   }
-
-  return ARButton
-})()
+}
 
 export { ARButton }
diff --git a/src/webxr/OculusHandPointerModel.js b/src/webxr/OculusHandPointerModel.js
index 00e044a5..4881455c 100644
--- a/src/webxr/OculusHandPointerModel.js
+++ b/src/webxr/OculusHandPointerModel.js
@@ -13,8 +13,8 @@ const POINTER_LENGTH = 0.035
 const POINTER_SEGMENTS = 16
 const POINTER_RINGS = 12
 const POINTER_HEMISPHERE_ANGLE = 110
-const YAXIS = /* @__PURE__ */ new THREE.Vector3(0, 1, 0)
-const ZAXIS = /* @__PURE__ */ new THREE.Vector3(0, 0, 1)
+const YAXIS = new THREE.Vector3(0, 1, 0)
+const ZAXIS = new THREE.Vector3(0, 0, 1)
 
 const CURSOR_RADIUS = 0.02
 const CURSOR_MAX_DISTANCE = 1.5
diff --git a/src/webxr/VRButton.ts b/src/webxr/VRButton.ts
index c83ef9a5..1ec7a521 100644
--- a/src/webxr/VRButton.ts
+++ b/src/webxr/VRButton.ts
@@ -1,157 +1,150 @@
 import { WebGLRenderer } from 'three'
 
-const VRButton = /* @__PURE__ */ (() => {
-  class VRButton {
-    static createButton(
-      renderer: WebGLRenderer,
-      sessionInit: XRSessionInit = {},
-    ): HTMLButtonElement | HTMLAnchorElement {
-      const button = document.createElement('button')
+class VRButton {
+  static createButton(renderer: WebGLRenderer, sessionInit: XRSessionInit = {}): HTMLButtonElement | HTMLAnchorElement {
+    const button = document.createElement('button')
 
-      function showEnterVR(/*device*/): void {
-        let currentSession: XRSession | null = null
+    function showEnterVR(/*device*/): void {
+      let currentSession: XRSession | null = null
 
-        async function onSessionStarted(session: XRSession): Promise<void> {
-          session.addEventListener('end', onSessionEnded)
+      async function onSessionStarted(session: XRSession): Promise<void> {
+        session.addEventListener('end', onSessionEnded)
 
-          await renderer.xr.setSession(session as any)
-          button.textContent = 'EXIT VR'
+        await renderer.xr.setSession(session as any)
+        button.textContent = 'EXIT VR'
 
-          currentSession = session
-        }
+        currentSession = session
+      }
 
-        function onSessionEnded(/*event*/): void {
-          currentSession!.removeEventListener('end', onSessionEnded)
+      function onSessionEnded(/*event*/): void {
+        currentSession!.removeEventListener('end', onSessionEnded)
 
-          button.textContent = 'ENTER VR'
+        button.textContent = 'ENTER VR'
 
-          currentSession = null
-        }
+        currentSession = null
+      }
 
-        //
+      //
 
-        button.style.display = ''
+      button.style.display = ''
 
-        button.style.cursor = 'pointer'
-        button.style.left = 'calc(50% - 50px)'
-        button.style.width = '100px'
+      button.style.cursor = 'pointer'
+      button.style.left = 'calc(50% - 50px)'
+      button.style.width = '100px'
 
-        button.textContent = 'ENTER VR'
+      button.textContent = 'ENTER VR'
 
-        button.onmouseenter = (): void => {
-          button.style.opacity = '1.0'
-        }
+      button.onmouseenter = (): void => {
+        button.style.opacity = '1.0'
+      }
 
-        button.onmouseleave = (): void => {
-          button.style.opacity = '0.5'
-        }
+      button.onmouseleave = (): void => {
+        button.style.opacity = '0.5'
+      }
 
-        button.onclick = (): void => {
-          if (currentSession === null) {
-            // WebXR's requestReferenceSpace only works if the corresponding feature
-            // was requested at session creation time. For simplicity, just ask for
-            // the interesting ones as optional features, but be aware that the
-            // requestReferenceSpace call will fail if it turns out to be unavailable.
-            // ('local' is always available for immersive sessions and doesn't need to
-            // be requested separately.)
-
-            const optionalFeatures = [sessionInit.optionalFeatures, 'local-floor', 'bounded-floor', 'hand-tracking']
-              .flat()
-              .filter(Boolean) as string[]
-
-            ;(navigator as Navigator).xr
-              ?.requestSession('immersive-vr', { ...sessionInit, optionalFeatures })
-              .then(onSessionStarted)
-          } else {
-            currentSession.end()
-          }
+      button.onclick = (): void => {
+        if (currentSession === null) {
+          // WebXR's requestReferenceSpace only works if the corresponding feature
+          // was requested at session creation time. For simplicity, just ask for
+          // the interesting ones as optional features, but be aware that the
+          // requestReferenceSpace call will fail if it turns out to be unavailable.
+          // ('local' is always available for immersive sessions and doesn't need to
+          // be requested separately.)
+
+          const optionalFeatures = [sessionInit.optionalFeatures, 'local-floor', 'bounded-floor', 'hand-tracking']
+            .flat()
+            .filter(Boolean) as string[]
+
+          ;(navigator as Navigator).xr
+            ?.requestSession('immersive-vr', { ...sessionInit, optionalFeatures })
+            .then(onSessionStarted)
+        } else {
+          currentSession.end()
         }
       }
+    }
 
-      function disableButton(): void {
-        button.style.display = ''
+    function disableButton(): void {
+      button.style.display = ''
 
-        button.style.cursor = 'auto'
-        button.style.left = 'calc(50% - 75px)'
-        button.style.width = '150px'
+      button.style.cursor = 'auto'
+      button.style.left = 'calc(50% - 75px)'
+      button.style.width = '150px'
 
-        button.onmouseenter = null
-        button.onmouseleave = null
+      button.onmouseenter = null
+      button.onmouseleave = null
 
-        button.onclick = null
-      }
+      button.onclick = null
+    }
 
-      function showWebXRNotFound(): void {
-        disableButton()
+    function showWebXRNotFound(): void {
+      disableButton()
 
-        button.textContent = 'VR NOT SUPPORTED'
-      }
+      button.textContent = 'VR NOT SUPPORTED'
+    }
 
-      function stylizeElement(element: HTMLElement): void {
-        element.style.position = 'absolute'
-        element.style.bottom = '20px'
-        element.style.padding = '12px 6px'
-        element.style.border = '1px solid #fff'
-        element.style.borderRadius = '4px'
-        element.style.background = 'rgba(0,0,0,0.1)'
-        element.style.color = '#fff'
-        element.style.font = 'normal 13px sans-serif'
-        element.style.textAlign = 'center'
-        element.style.opacity = '0.5'
-        element.style.outline = 'none'
-        element.style.zIndex = '999'
-      }
+    function stylizeElement(element: HTMLElement): void {
+      element.style.position = 'absolute'
+      element.style.bottom = '20px'
+      element.style.padding = '12px 6px'
+      element.style.border = '1px solid #fff'
+      element.style.borderRadius = '4px'
+      element.style.background = 'rgba(0,0,0,0.1)'
+      element.style.color = '#fff'
+      element.style.font = 'normal 13px sans-serif'
+      element.style.textAlign = 'center'
+      element.style.opacity = '0.5'
+      element.style.outline = 'none'
+      element.style.zIndex = '999'
+    }
 
-      if ('xr' in navigator) {
-        stylizeElement(button)
-        button.id = 'VRButton'
-        button.style.display = 'none'
+    if ('xr' in navigator) {
+      stylizeElement(button)
+      button.id = 'VRButton'
+      button.style.display = 'none'
 
-        // Query for session mode
-        navigator.xr!.isSessionSupported('immersive-vr').then((supported) => {
-          supported ? showEnterVR() : showWebXRNotFound()
+      // Query for session mode
+      navigator.xr!.isSessionSupported('immersive-vr').then((supported) => {
+        supported ? showEnterVR() : showWebXRNotFound()
 
-          if (supported && VRButton.xrSessionIsGranted) {
-            button.click()
-          }
-        })
+        if (supported && VRButton.xrSessionIsGranted) {
+          button.click()
+        }
+      })
 
-        return button
-      } else {
-        const message = document.createElement('a')
+      return button
+    } else {
+      const message = document.createElement('a')
 
-        if (window.isSecureContext === false) {
-          message.href = document.location.href.replace(/^http:/, 'https:')
-          message.innerHTML = 'WEBXR NEEDS HTTPS' // TODO Improve message
-        } else {
-          message.href = 'https://immersiveweb.dev/'
-          message.innerHTML = 'WEBXR NOT AVAILABLE'
-        }
+      if (window.isSecureContext === false) {
+        message.href = document.location.href.replace(/^http:/, 'https:')
+        message.innerHTML = 'WEBXR NEEDS HTTPS' // TODO Improve message
+      } else {
+        message.href = 'https://immersiveweb.dev/'
+        message.innerHTML = 'WEBXR NOT AVAILABLE'
+      }
 
-        message.style.left = 'calc(50% - 90px)'
-        message.style.width = '180px'
-        message.style.textDecoration = 'none'
+      message.style.left = 'calc(50% - 90px)'
+      message.style.width = '180px'
+      message.style.textDecoration = 'none'
 
-        stylizeElement(message)
+      stylizeElement(message)
 
-        return message
-      }
+      return message
     }
+  }
 
-    static xrSessionIsGranted = false
+  static xrSessionIsGranted = false
 
-    static registerSessionGrantedListener(): void {
-      if (typeof navigator !== 'undefined' && 'xr' in navigator) {
-        ;(navigator as Navigator).xr!.addEventListener('sessiongranted', () => {
-          VRButton.xrSessionIsGranted = true
-        })
-      }
+  static registerSessionGrantedListener(): void {
+    if (typeof navigator !== 'undefined' && 'xr' in navigator) {
+      ;(navigator as Navigator).xr!.addEventListener('sessiongranted', () => {
+        VRButton.xrSessionIsGranted = true
+      })
     }
   }
+}
 
-  VRButton.registerSessionGrantedListener()
-
-  return VRButton
-})()
+VRButton.registerSessionGrantedListener()
 
 export { VRButton }
diff --git a/src/webxr/XRHandPrimitiveModel.js b/src/webxr/XRHandPrimitiveModel.js
index a967f563..9e98456a 100644
--- a/src/webxr/XRHandPrimitiveModel.js
+++ b/src/webxr/XRHandPrimitiveModel.js
@@ -8,8 +8,8 @@ import {
   Vector3,
 } from 'three'
 
-const _matrix = /* @__PURE__ */ new Matrix4()
-const _vector = /* @__PURE__ */ new Vector3()
+const _matrix = new Matrix4()
+const _vector = new Vector3()
 
 class XRHandPrimitiveModel {
   constructor(handModel, controller, path, handedness, options) {

From e92556307e99df07f26d1daea8c3bab13b011b4a Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Wed, 8 Jan 2025 13:46:02 -0600
Subject: [PATCH 35/36] fix: tree-shaking

Re-release of #395 with necessary workarounds for TypeScript class inference
---
 src/_polyfill/CapsuleGeometry.js           |   36 +-
 src/_polyfill/constants.ts                 |    2 +-
 src/animation/AnimationClipCreator.js      |   26 +-
 src/animation/CCDIKSolver.js               |   22 +-
 src/animation/MMDAnimationHelper.js        |    2 +-
 src/animation/MMDPhysics.js                |    8 +-
 src/controls/ArcballControls.ts            |    4 +-
 src/controls/FirstPersonControls.ts        |    2 +-
 src/controls/OrbitControls.ts              |   17 +-
 src/controls/PointerLockControls.ts        |   10 +-
 src/csm/CSM.js                             |    8 +-
 src/csm/CSMFrustum.js                      |    2 +-
 src/deprecated/Geometry.js                 | 1614 ++++----
 src/effects/AnaglyphEffect.js              |    4 +-
 src/effects/OutlineEffect.js               |    5 +-
 src/effects/ParallaxBarrierEffect.js       |    4 +-
 src/exporters/DRACOExporter.d.ts           |   36 +
 src/exporters/DRACOExporter.js             |  216 ++
 src/exporters/DRACOExporter.ts             |  207 -
 src/exporters/GLTFExporter.js              |  392 +-
 src/geometries/LightningStrike.js          | 1314 +++----
 src/geometries/RoundedBoxGeometry.js       |    2 +-
 src/helpers/RaycasterHelper.ts             |    4 +-
 src/helpers/VertexNormalsHelper.js         |    6 +-
 src/helpers/VertexTangentsHelper.js        |    4 +-
 src/interactive/InteractiveGroup.js        |    2 +-
 src/interactive/SelectionBox.js            |   30 +-
 src/libs/chevrotain.js                     |    2 +-
 src/libs/lottie.js                         |    2 +-
 src/libs/opentype.js                       |    2 +-
 src/lights/LightProbeGenerator.js          |   10 +-
 src/lights/RectAreaLightUniformsLib.js     |    6 +-
 src/lines/LineMaterial.js                  |    5 +-
 src/lines/LineSegments2.js                 |   51 +-
 src/lines/LineSegmentsGeometry.js          |    4 +-
 src/lines/Wireframe.js                     |   16 +-
 src/loaders/BasisTextureLoader.js          |  963 ++---
 src/loaders/EXRLoader.js                   |    4 +-
 src/loaders/FBXLoader.js                   |    8 +-
 src/loaders/FontLoader.ts                  |    4 +-
 src/loaders/GLTFLoader.js                  |    4 +-
 src/loaders/KTX2Loader.js                  |  876 ++---
 src/loaders/LDrawLoader.js                 |   10 +-
 src/loaders/OBJLoader.js                   |   10 +-
 src/loaders/PRWMLoader.js                  |  104 +-
 src/loaders/SVGLoader.js                   | 3953 ++++++++++----------
 src/loaders/XLoader.js                     |    2 +-
 src/math/Capsule.js                        |    6 +-
 src/math/ColorConverter.js                 |   18 +-
 src/math/ConvexHull.js                     |  110 +-
 src/math/ImprovedNoise.js                  |    2 +-
 src/math/MeshSurfaceSampler.js             |    4 +-
 src/math/OBB.js                            |   28 +-
 src/math/Octree.js                         |   14 +-
 src/misc/ConvexObjectBreaker.js            |  658 ++--
 src/misc/Gyroscope.js                      |   12 +-
 src/modifiers/CurveModifier.ts             |    2 +-
 src/modifiers/SimplifyModifier.ts          |    4 +-
 src/objects/BatchedMesh.ts                 |    4 +-
 src/objects/GroundProjectedEnv.ts          |   14 +-
 src/objects/Lensflare.js                   |  390 +-
 src/objects/Reflector.js                   |  291 +-
 src/objects/ReflectorForSSRPass.js         |  384 +-
 src/objects/Refractor.js                   |  352 +-
 src/objects/ShadowMesh.js                  |    2 +-
 src/objects/Sky.d.ts                       |   18 +
 src/objects/{Sky.ts => Sky.js}             |   86 +-
 src/objects/Water.js                       |    4 +-
 src/objects/Water2.js                      |  312 +-
 src/postprocessing/SAOPass.js              |  616 +--
 src/postprocessing/SSAOPass.js             |  572 +--
 src/postprocessing/SSRPass.js              |  932 ++---
 src/postprocessing/UnrealBloomPass.js      |  456 +--
 src/renderers/CSS2DRenderer.js             |   10 +-
 src/renderers/CSS3DRenderer.js             |   10 +-
 src/shaders/ACESFilmicToneMappingShader.ts |   87 +-
 src/shaders/AfterimageShader.ts            |   44 +-
 src/shaders/BasicShader.ts                 |   18 +-
 src/shaders/BleachBypassShader.ts          |   52 +-
 src/shaders/BlendShader.ts                 |   38 +-
 src/shaders/BokehShader.ts                 |  224 +-
 src/shaders/BokehShader2.ts                |  464 +--
 src/shaders/BrightnessContrastShader.ts    |   44 +-
 src/shaders/ColorCorrectionShader.ts       |   42 +-
 src/shaders/ColorifyShader.ts              |   38 +-
 src/shaders/ConvolutionShader.ts           |   48 +-
 src/shaders/CopyShader.ts                  |   32 +-
 src/shaders/DOFMipMapShader.ts             |   42 +-
 src/shaders/DepthLimitedBlurShader.ts      |  148 +-
 src/shaders/DigitalGlitch.ts               |  123 +-
 src/shaders/DotScreenShader.ts             |   56 +-
 src/shaders/FXAAShader.ts                  | 2178 +++++------
 src/shaders/FilmShader.ts                  |   58 +-
 src/shaders/FocusShader.ts                 |   86 +-
 src/shaders/FreiChenShader.ts              |  114 +-
 src/shaders/FresnelShader.ts               |   70 +-
 src/shaders/GammaCorrectionShader.ts       |   38 +-
 src/shaders/GodRaysShader.ts               |  196 +-
 src/shaders/HalftoneShader.ts              |  400 +-
 src/shaders/HorizontalTiltShiftShader.ts   |   54 +-
 src/shaders/HueSaturationShader.ts         |   64 +-
 src/shaders/KaleidoShader.ts               |   48 +-
 src/shaders/LuminosityHighPassShader.ts    |   48 +-
 src/shaders/LuminosityShader.ts            |   34 +-
 src/shaders/MirrorShader.ts                |   52 +-
 src/shaders/NormalMapShader.ts             |   42 +-
 src/shaders/ParallaxShader.ts              |  188 +-
 src/shaders/PixelShader.ts                 |   36 +-
 src/shaders/RGBShiftShader.ts              |   40 +-
 src/shaders/SAOShader.ts                   |  296 +-
 src/shaders/SMAAShader.ts                  |  478 +--
 src/shaders/SSAOShader.ts                  |  266 +-
 src/shaders/SSRShader.ts                   |    8 +-
 src/shaders/SepiaShader.ts                 |   40 +-
 src/shaders/SobelOperatorShader.ts         |   70 +-
 src/shaders/TechnicolorShader.ts           |   32 +-
 src/shaders/ToneMapShader.ts               |   70 +-
 src/shaders/ToonShader.ts                  |  330 +-
 src/shaders/TriangleBlurShader.ts          |   54 +-
 src/shaders/UnpackDepthRGBAShader.ts       |   34 +-
 src/shaders/VerticalTiltShiftShader.ts     |   54 +-
 src/shaders/VignetteShader.ts              |   38 +-
 src/shaders/VolumeShader.ts                |  516 +--
 src/shaders/WaterRefractionShader.ts       |   70 +-
 src/utils/GeometryCompressionUtils.js      |    4 +-
 src/utils/LDrawUtils.js                    |    6 +-
 src/utils/RoughnessMipmapper.js            |    6 +-
 src/webxr/ARButton.ts                      |    6 +-
 src/webxr/OculusHandPointerModel.js        |    4 +-
 src/webxr/VRButton.d.ts                    |   11 +
 src/webxr/VRButton.js                      |  150 +
 src/webxr/VRButton.ts                      |  150 -
 src/webxr/XRHandPrimitiveModel.js          |    4 +-
 133 files changed, 11725 insertions(+), 11544 deletions(-)
 create mode 100644 src/exporters/DRACOExporter.d.ts
 create mode 100644 src/exporters/DRACOExporter.js
 delete mode 100644 src/exporters/DRACOExporter.ts
 create mode 100644 src/objects/Sky.d.ts
 rename src/objects/{Sky.ts => Sky.js} (89%)
 create mode 100644 src/webxr/VRButton.d.ts
 create mode 100644 src/webxr/VRButton.js
 delete mode 100644 src/webxr/VRButton.ts

diff --git a/src/_polyfill/CapsuleGeometry.js b/src/_polyfill/CapsuleGeometry.js
index c2e655a5..8a5fc0ff 100644
--- a/src/_polyfill/CapsuleGeometry.js
+++ b/src/_polyfill/CapsuleGeometry.js
@@ -1,26 +1,30 @@
 import { Path, LatheGeometry } from 'three'
 
-class CapsuleGeometry extends LatheGeometry {
-  constructor(radius = 1, length = 1, capSegments = 4, radialSegments = 8) {
-    const path = new Path()
-    path.absarc(0, -length / 2, radius, Math.PI * 1.5, 0)
-    path.absarc(0, length / 2, radius, 0, Math.PI * 0.5)
+const CapsuleGeometry = /* @__PURE__ */ (() => {
+  class CapsuleGeometry extends LatheGeometry {
+    constructor(radius = 1, length = 1, capSegments = 4, radialSegments = 8) {
+      const path = new Path()
+      path.absarc(0, -length / 2, radius, Math.PI * 1.5, 0)
+      path.absarc(0, length / 2, radius, 0, Math.PI * 0.5)
 
-    super(path.getPoints(capSegments), radialSegments)
+      super(path.getPoints(capSegments), radialSegments)
 
-    this.type = 'CapsuleGeometry'
+      this.type = 'CapsuleGeometry'
 
-    this.parameters = {
-      radius: radius,
-      height: length,
-      capSegments: capSegments,
-      radialSegments: radialSegments,
+      this.parameters = {
+        radius: radius,
+        height: length,
+        capSegments: capSegments,
+        radialSegments: radialSegments,
+      }
     }
-  }
 
-  static fromJSON(data) {
-    return new CapsuleGeometry(data.radius, data.length, data.capSegments, data.radialSegments)
+    static fromJSON(data) {
+      return new CapsuleGeometry(data.radius, data.length, data.capSegments, data.radialSegments)
+    }
   }
-}
+
+  return CapsuleGeometry
+})()
 
 export { CapsuleGeometry }
diff --git a/src/_polyfill/constants.ts b/src/_polyfill/constants.ts
index 1237ca1f..aabfc441 100644
--- a/src/_polyfill/constants.ts
+++ b/src/_polyfill/constants.ts
@@ -1,3 +1,3 @@
 import { REVISION } from 'three'
 
-export const version = parseInt(REVISION.replace(/\D+/g, ''))
+export const version = /* @__PURE__ */ (() => parseInt(REVISION.replace(/\D+/g, '')))()
diff --git a/src/animation/AnimationClipCreator.js b/src/animation/AnimationClipCreator.js
index 2befa398..23ea4050 100644
--- a/src/animation/AnimationClipCreator.js
+++ b/src/animation/AnimationClipCreator.js
@@ -7,8 +7,8 @@ import {
   VectorKeyframeTrack,
 } from 'three'
 
-class AnimationClipCreator {
-  static CreateRotationAnimation(period, axis = 'x') {
+const AnimationClipCreator = {
+  CreateRotationAnimation(period, axis = 'x') {
     const times = [0, period],
       values = [0, 360]
 
@@ -17,9 +17,9 @@ class AnimationClipCreator {
     const track = new NumberKeyframeTrack(trackName, times, values)
 
     return new AnimationClip(null, period, [track])
-  }
+  },
 
-  static CreateScaleAxisAnimation(period, axis = 'x') {
+  CreateScaleAxisAnimation(period, axis = 'x') {
     const times = [0, period],
       values = [0, 1]
 
@@ -28,9 +28,9 @@ class AnimationClipCreator {
     const track = new NumberKeyframeTrack(trackName, times, values)
 
     return new AnimationClip(null, period, [track])
-  }
+  },
 
-  static CreateShakeAnimation(duration, shakeScale) {
+  CreateShakeAnimation(duration, shakeScale) {
     const times = [],
       values = [],
       tmp = new Vector3()
@@ -49,9 +49,9 @@ class AnimationClipCreator {
     const track = new VectorKeyframeTrack(trackName, times, values)
 
     return new AnimationClip(null, duration, [track])
-  }
+  },
 
-  static CreatePulsationAnimation(duration, pulseScale) {
+  CreatePulsationAnimation(duration, pulseScale) {
     const times = [],
       values = [],
       tmp = new Vector3()
@@ -68,9 +68,9 @@ class AnimationClipCreator {
     const track = new VectorKeyframeTrack(trackName, times, values)
 
     return new AnimationClip(null, duration, [track])
-  }
+  },
 
-  static CreateVisibilityAnimation(duration) {
+  CreateVisibilityAnimation(duration) {
     const times = [0, duration / 2, duration],
       values = [true, false, true]
 
@@ -79,9 +79,9 @@ class AnimationClipCreator {
     const track = new BooleanKeyframeTrack(trackName, times, values)
 
     return new AnimationClip(null, duration, [track])
-  }
+  },
 
-  static CreateMaterialColorAnimation(duration, colors) {
+  CreateMaterialColorAnimation(duration, colors) {
     const times = [],
       values = [],
       timeStep = duration / colors.length
@@ -98,7 +98,7 @@ class AnimationClipCreator {
     const track = new ColorKeyframeTrack(trackName, times, values)
 
     return new AnimationClip(null, duration, [track])
-  }
+  },
 }
 
 export { AnimationClipCreator }
diff --git a/src/animation/CCDIKSolver.js b/src/animation/CCDIKSolver.js
index 0e5650a0..75fff7e4 100644
--- a/src/animation/CCDIKSolver.js
+++ b/src/animation/CCDIKSolver.js
@@ -13,17 +13,17 @@ import {
   Vector3,
 } from 'three'
 
-const _q = new Quaternion()
-const _targetPos = new Vector3()
-const _targetVec = new Vector3()
-const _effectorPos = new Vector3()
-const _effectorVec = new Vector3()
-const _linkPos = new Vector3()
-const _invLinkQ = new Quaternion()
-const _linkScale = new Vector3()
-const _axis = new Vector3()
-const _vector = new Vector3()
-const _matrix = new Matrix4()
+const _q = /* @__PURE__ */ new Quaternion()
+const _targetPos = /* @__PURE__ */ new Vector3()
+const _targetVec = /* @__PURE__ */ new Vector3()
+const _effectorPos = /* @__PURE__ */ new Vector3()
+const _effectorVec = /* @__PURE__ */ new Vector3()
+const _linkPos = /* @__PURE__ */ new Vector3()
+const _invLinkQ = /* @__PURE__ */ new Quaternion()
+const _linkScale = /* @__PURE__ */ new Vector3()
+const _axis = /* @__PURE__ */ new Vector3()
+const _vector = /* @__PURE__ */ new Vector3()
+const _matrix = /* @__PURE__ */ new Matrix4()
 
 /**
  * CCD Algorithm
diff --git a/src/animation/MMDAnimationHelper.js b/src/animation/MMDAnimationHelper.js
index 8ec13284..396c7424 100644
--- a/src/animation/MMDAnimationHelper.js
+++ b/src/animation/MMDAnimationHelper.js
@@ -861,7 +861,7 @@ class AudioManager {
   }
 }
 
-const _q = new Quaternion()
+const _q = /* @__PURE__ */ new Quaternion()
 
 /**
  * Solver for Grant (Fuyo in Japanese. I just google translated because
diff --git a/src/animation/MMDPhysics.js b/src/animation/MMDPhysics.js
index c11992cc..22ea4ea2 100644
--- a/src/animation/MMDPhysics.js
+++ b/src/animation/MMDPhysics.js
@@ -1001,10 +1001,10 @@ class Constraint {
   }
 }
 
-const _position = new Vector3()
-const _quaternion = new Quaternion()
-const _scale = new Vector3()
-const _matrixWorldInv = new Matrix4()
+const _position = /* @__PURE__ */ new Vector3()
+const _quaternion = /* @__PURE__ */ new Quaternion()
+const _scale = /* @__PURE__ */ new Vector3()
+const _matrixWorldInv = /* @__PURE__ */ new Matrix4()
 
 class MMDPhysicsHelper extends Object3D {
   /**
diff --git a/src/controls/ArcballControls.ts b/src/controls/ArcballControls.ts
index 9a64a49c..c048168f 100644
--- a/src/controls/ArcballControls.ts
+++ b/src/controls/ArcballControls.ts
@@ -68,8 +68,8 @@ const _center = {
 
 //transformation matrices for gizmos and camera
 const _transformation: Transformation = {
-  camera: new Matrix4(),
-  gizmos: new Matrix4(),
+  camera: /* @__PURE__ */ new Matrix4(),
+  gizmos: /* @__PURE__ */ new Matrix4(),
 }
 
 //events
diff --git a/src/controls/FirstPersonControls.ts b/src/controls/FirstPersonControls.ts
index b69983f6..bc40ae9b 100644
--- a/src/controls/FirstPersonControls.ts
+++ b/src/controls/FirstPersonControls.ts
@@ -2,7 +2,7 @@ import { MathUtils, Spherical, Vector3, Camera } from 'three'
 import { EventDispatcher } from './EventDispatcher'
 import { StandardControlsEventMap } from './StandardControlsEventMap'
 
-const targetPosition = new Vector3()
+const targetPosition = /* @__PURE__ */ new Vector3()
 
 export class FirstPersonControls extends EventDispatcher<{}> {
   public object: Camera
diff --git a/src/controls/OrbitControls.ts b/src/controls/OrbitControls.ts
index 93d8a764..cad6a154 100644
--- a/src/controls/OrbitControls.ts
+++ b/src/controls/OrbitControls.ts
@@ -14,8 +14,8 @@ import {
 import { EventDispatcher } from './EventDispatcher'
 import { StandardControlsEventMap } from './StandardControlsEventMap'
 
-const _ray = new Ray()
-const _plane = new Plane()
+const _ray = /* @__PURE__ */ new Ray()
+const _plane = /* @__PURE__ */ new Plane()
 const TILT_LIMIT = Math.cos(70 * (Math.PI / 180))
 
 // This set of controls performs orbiting, dollying (zooming), and panning.
@@ -119,7 +119,6 @@ class OrbitControls extends EventDispatcher<StandardControlsEventMap> {
   getScale: () => number
   // Set the current scale (these are not used in most scenarios, however they can be useful for specific use cases)
   setScale: (newScale: number) => void
-  
 
   constructor(object: PerspectiveCamera | OrthographicCamera, domElement?: HTMLElement) {
     super()
@@ -1096,21 +1095,21 @@ class OrbitControls extends EventDispatcher<StandardControlsEventMap> {
     }
 
     this.dollyOut = (dollyScale = getZoomScale()) => {
-        dollyOut(dollyScale)
-        scope.update()
+      dollyOut(dollyScale)
+      scope.update()
     }
 
     this.getScale = () => {
-        return scale;
+      return scale
     }
 
     this.setScale = (newScale) => {
-        setScale(newScale)
-        scope.update()
+      setScale(newScale)
+      scope.update()
     }
 
     this.getZoomScale = () => {
-        return getZoomScale();
+      return getZoomScale()
     }
 
     // connect events
diff --git a/src/controls/PointerLockControls.ts b/src/controls/PointerLockControls.ts
index ee93891e..19d6fd0f 100644
--- a/src/controls/PointerLockControls.ts
+++ b/src/controls/PointerLockControls.ts
@@ -1,8 +1,8 @@
 import { Euler, Camera, Vector3 } from 'three'
 import { EventDispatcher } from './EventDispatcher'
 
-const _euler = new Euler(0, 0, 0, 'YXZ')
-const _vector = new Vector3()
+const _euler = /* @__PURE__ */ new Euler(0, 0, 0, 'YXZ')
+const _vector = /* @__PURE__ */ new Vector3()
 const _changeEvent = { type: 'change' }
 const _lockEvent = { type: 'lock' }
 const _unlockEvent = { type: 'unlock' }
@@ -12,17 +12,17 @@ export interface PointerLockControlsEventMap {
   /**
    * Fires when the user moves the mouse.
    */
-  change: {};
+  change: {}
 
   /**
    * Fires when the pointer lock status is "locked" (in other words: the mouse is captured).
    */
-  lock: {};
+  lock: {}
 
   /**
    * Fires when the pointer lock status is "unlocked" (in other words: the mouse is not captured anymore).
    */
-  unlock: {};
+  unlock: {}
 }
 
 class PointerLockControls extends EventDispatcher<PointerLockControlsEventMap> {
diff --git a/src/csm/CSM.js b/src/csm/CSM.js
index afa6cdee..ce5359af 100644
--- a/src/csm/CSM.js
+++ b/src/csm/CSM.js
@@ -2,10 +2,10 @@ import { Vector2, Vector3, DirectionalLight, MathUtils, ShaderChunk, Matrix4, Bo
 import { CSMFrustum } from './CSMFrustum'
 import { CSMShader } from './CSMShader'
 
-const _cameraToLightMatrix = new Matrix4()
-const _lightSpaceFrustum = new CSMFrustum()
-const _center = new Vector3()
-const _bbox = new Box3()
+const _cameraToLightMatrix = /* @__PURE__ */ new Matrix4()
+const _lightSpaceFrustum = /* @__PURE__ */ new CSMFrustum()
+const _center = /* @__PURE__ */ new Vector3()
+const _bbox = /* @__PURE__ */ new Box3()
 const _uniformArray = []
 const _logArray = []
 
diff --git a/src/csm/CSMFrustum.js b/src/csm/CSMFrustum.js
index ab8f7d15..3e375417 100644
--- a/src/csm/CSMFrustum.js
+++ b/src/csm/CSMFrustum.js
@@ -1,6 +1,6 @@
 import { Vector3, Matrix4 } from 'three'
 
-const inverseProjectionMatrix = new Matrix4()
+const inverseProjectionMatrix = /* @__PURE__ */ new Matrix4()
 
 class CSMFrustum {
   constructor(data) {
diff --git a/src/deprecated/Geometry.js b/src/deprecated/Geometry.js
index d4d5afc2..c720b2a2 100644
--- a/src/deprecated/Geometry.js
+++ b/src/deprecated/Geometry.js
@@ -14,330 +14,300 @@ import {
   Vector3,
 } from 'three'
 
-const _m1 = new Matrix4()
-const _obj = new Object3D()
-const _offset = new Vector3()
+const _m1 = /* @__PURE__ */ new Matrix4()
+const _obj = /* @__PURE__ */ new Object3D()
+const _offset = /* @__PURE__ */ new Vector3()
 
-class Geometry extends EventDispatcher {
-  static createBufferGeometryFromObject(object) {
-    let buffergeometry = new BufferGeometry()
+const Geometry = /* @__PURE__ */ (() => {
+  class Geometry extends EventDispatcher {
+    static createBufferGeometryFromObject(object) {
+      let buffergeometry = new BufferGeometry()
 
-    const geometry = object.geometry
+      const geometry = object.geometry
 
-    if (object.isPoints || object.isLine) {
-      const positions = new Float32BufferAttribute(geometry.vertices.length * 3, 3)
-      const colors = new Float32BufferAttribute(geometry.colors.length * 3, 3)
+      if (object.isPoints || object.isLine) {
+        const positions = new Float32BufferAttribute(geometry.vertices.length * 3, 3)
+        const colors = new Float32BufferAttribute(geometry.colors.length * 3, 3)
 
-      buffergeometry.setAttribute('position', positions.copyVector3sArray(geometry.vertices))
-      buffergeometry.setAttribute('color', colors.copyColorsArray(geometry.colors))
+        buffergeometry.setAttribute('position', positions.copyVector3sArray(geometry.vertices))
+        buffergeometry.setAttribute('color', colors.copyColorsArray(geometry.colors))
 
-      if (geometry.lineDistances && geometry.lineDistances.length === geometry.vertices.length) {
-        const lineDistances = new Float32BufferAttribute(geometry.lineDistances.length, 1)
+        if (geometry.lineDistances && geometry.lineDistances.length === geometry.vertices.length) {
+          const lineDistances = new Float32BufferAttribute(geometry.lineDistances.length, 1)
 
-        buffergeometry.setAttribute('lineDistance', lineDistances.copyArray(geometry.lineDistances))
-      }
+          buffergeometry.setAttribute('lineDistance', lineDistances.copyArray(geometry.lineDistances))
+        }
 
-      if (geometry.boundingSphere !== null) {
-        buffergeometry.boundingSphere = geometry.boundingSphere.clone()
-      }
+        if (geometry.boundingSphere !== null) {
+          buffergeometry.boundingSphere = geometry.boundingSphere.clone()
+        }
 
-      if (geometry.boundingBox !== null) {
-        buffergeometry.boundingBox = geometry.boundingBox.clone()
+        if (geometry.boundingBox !== null) {
+          buffergeometry.boundingBox = geometry.boundingBox.clone()
+        }
+      } else if (object.isMesh) {
+        buffergeometry = geometry.toBufferGeometry()
       }
-    } else if (object.isMesh) {
-      buffergeometry = geometry.toBufferGeometry()
+
+      return buffergeometry
     }
 
-    return buffergeometry
-  }
+    constructor() {
+      super()
+      this.isGeometry = true
+      this.uuid = MathUtils.generateUUID()
 
-  constructor() {
-    super()
-    this.isGeometry = true
-    this.uuid = MathUtils.generateUUID()
+      this.name = ''
+      this.type = 'Geometry'
 
-    this.name = ''
-    this.type = 'Geometry'
+      this.vertices = []
+      this.colors = []
+      this.faces = []
+      this.faceVertexUvs = [[]]
 
-    this.vertices = []
-    this.colors = []
-    this.faces = []
-    this.faceVertexUvs = [[]]
+      this.morphTargets = []
+      this.morphNormals = []
 
-    this.morphTargets = []
-    this.morphNormals = []
+      this.skinWeights = []
+      this.skinIndices = []
 
-    this.skinWeights = []
-    this.skinIndices = []
+      this.lineDistances = []
 
-    this.lineDistances = []
+      this.boundingBox = null
+      this.boundingSphere = null
 
-    this.boundingBox = null
-    this.boundingSphere = null
+      // update flags
 
-    // update flags
-
-    this.elementsNeedUpdate = false
-    this.verticesNeedUpdate = false
-    this.uvsNeedUpdate = false
-    this.normalsNeedUpdate = false
-    this.colorsNeedUpdate = false
-    this.lineDistancesNeedUpdate = false
-    this.groupsNeedUpdate = false
-  }
-
-  applyMatrix4(matrix) {
-    const normalMatrix = new Matrix3().getNormalMatrix(matrix)
-
-    for (let i = 0, il = this.vertices.length; i < il; i++) {
-      const vertex = this.vertices[i]
-      vertex.applyMatrix4(matrix)
+      this.elementsNeedUpdate = false
+      this.verticesNeedUpdate = false
+      this.uvsNeedUpdate = false
+      this.normalsNeedUpdate = false
+      this.colorsNeedUpdate = false
+      this.lineDistancesNeedUpdate = false
+      this.groupsNeedUpdate = false
     }
 
-    for (let i = 0, il = this.faces.length; i < il; i++) {
-      const face = this.faces[i]
-      face.normal.applyMatrix3(normalMatrix).normalize()
+    applyMatrix4(matrix) {
+      const normalMatrix = new Matrix3().getNormalMatrix(matrix)
 
-      for (let j = 0, jl = face.vertexNormals.length; j < jl; j++) {
-        face.vertexNormals[j].applyMatrix3(normalMatrix).normalize()
+      for (let i = 0, il = this.vertices.length; i < il; i++) {
+        const vertex = this.vertices[i]
+        vertex.applyMatrix4(matrix)
       }
-    }
 
-    if (this.boundingBox !== null) {
-      this.computeBoundingBox()
-    }
-
-    if (this.boundingSphere !== null) {
-      this.computeBoundingSphere()
-    }
+      for (let i = 0, il = this.faces.length; i < il; i++) {
+        const face = this.faces[i]
+        face.normal.applyMatrix3(normalMatrix).normalize()
 
-    this.verticesNeedUpdate = true
-    this.normalsNeedUpdate = true
+        for (let j = 0, jl = face.vertexNormals.length; j < jl; j++) {
+          face.vertexNormals[j].applyMatrix3(normalMatrix).normalize()
+        }
+      }
 
-    return this
-  }
+      if (this.boundingBox !== null) {
+        this.computeBoundingBox()
+      }
 
-  rotateX(angle) {
-    // rotate geometry around world x-axis
+      if (this.boundingSphere !== null) {
+        this.computeBoundingSphere()
+      }
 
-    _m1.makeRotationX(angle)
+      this.verticesNeedUpdate = true
+      this.normalsNeedUpdate = true
 
-    this.applyMatrix4(_m1)
+      return this
+    }
 
-    return this
-  }
+    rotateX(angle) {
+      // rotate geometry around world x-axis
 
-  rotateY(angle) {
-    // rotate geometry around world y-axis
+      _m1.makeRotationX(angle)
 
-    _m1.makeRotationY(angle)
+      this.applyMatrix4(_m1)
 
-    this.applyMatrix4(_m1)
+      return this
+    }
 
-    return this
-  }
+    rotateY(angle) {
+      // rotate geometry around world y-axis
 
-  rotateZ(angle) {
-    // rotate geometry around world z-axis
+      _m1.makeRotationY(angle)
 
-    _m1.makeRotationZ(angle)
+      this.applyMatrix4(_m1)
 
-    this.applyMatrix4(_m1)
+      return this
+    }
 
-    return this
-  }
+    rotateZ(angle) {
+      // rotate geometry around world z-axis
 
-  translate(x, y, z) {
-    // translate geometry
+      _m1.makeRotationZ(angle)
 
-    _m1.makeTranslation(x, y, z)
+      this.applyMatrix4(_m1)
 
-    this.applyMatrix4(_m1)
+      return this
+    }
 
-    return this
-  }
+    translate(x, y, z) {
+      // translate geometry
 
-  scale(x, y, z) {
-    // scale geometry
+      _m1.makeTranslation(x, y, z)
 
-    _m1.makeScale(x, y, z)
+      this.applyMatrix4(_m1)
 
-    this.applyMatrix4(_m1)
+      return this
+    }
 
-    return this
-  }
+    scale(x, y, z) {
+      // scale geometry
 
-  lookAt(vector) {
-    _obj.lookAt(vector)
+      _m1.makeScale(x, y, z)
 
-    _obj.updateMatrix()
+      this.applyMatrix4(_m1)
 
-    this.applyMatrix4(_obj.matrix)
+      return this
+    }
 
-    return this
-  }
+    lookAt(vector) {
+      _obj.lookAt(vector)
 
-  fromBufferGeometry(geometry) {
-    const scope = this
+      _obj.updateMatrix()
 
-    const index = geometry.index !== null ? geometry.index : undefined
-    const attributes = geometry.attributes
+      this.applyMatrix4(_obj.matrix)
 
-    if (attributes.position === undefined) {
-      console.error('THREE.Geometry.fromBufferGeometry(): Position attribute required for conversion.')
       return this
     }
 
-    const position = attributes.position
-    const normal = attributes.normal
-    const color = attributes.color
-    const uv = attributes.uv
-    const uv2 = attributes.uv2
-
-    if (uv2 !== undefined) this.faceVertexUvs[1] = []
+    fromBufferGeometry(geometry) {
+      const scope = this
 
-    for (let i = 0; i < position.count; i++) {
-      scope.vertices.push(new Vector3().fromBufferAttribute(position, i))
+      const index = geometry.index !== null ? geometry.index : undefined
+      const attributes = geometry.attributes
 
-      if (color !== undefined) {
-        scope.colors.push(new Color().fromBufferAttribute(color, i))
+      if (attributes.position === undefined) {
+        console.error('THREE.Geometry.fromBufferGeometry(): Position attribute required for conversion.')
+        return this
       }
-    }
-
-    function addFace(a, b, c, materialIndex) {
-      const vertexColors =
-        color === undefined ? [] : [scope.colors[a].clone(), scope.colors[b].clone(), scope.colors[c].clone()]
 
-      const vertexNormals =
-        normal === undefined
-          ? []
-          : [
-              new Vector3().fromBufferAttribute(normal, a),
-              new Vector3().fromBufferAttribute(normal, b),
-              new Vector3().fromBufferAttribute(normal, c),
-            ]
+      const position = attributes.position
+      const normal = attributes.normal
+      const color = attributes.color
+      const uv = attributes.uv
+      const uv2 = attributes.uv2
 
-      const face = new Face3(a, b, c, vertexNormals, vertexColors, materialIndex)
+      if (uv2 !== undefined) this.faceVertexUvs[1] = []
 
-      scope.faces.push(face)
+      for (let i = 0; i < position.count; i++) {
+        scope.vertices.push(new Vector3().fromBufferAttribute(position, i))
 
-      if (uv !== undefined) {
-        scope.faceVertexUvs[0].push([
-          new Vector2().fromBufferAttribute(uv, a),
-          new Vector2().fromBufferAttribute(uv, b),
-          new Vector2().fromBufferAttribute(uv, c),
-        ])
+        if (color !== undefined) {
+          scope.colors.push(new Color().fromBufferAttribute(color, i))
+        }
       }
 
-      if (uv2 !== undefined) {
-        scope.faceVertexUvs[1].push([
-          new Vector2().fromBufferAttribute(uv2, a),
-          new Vector2().fromBufferAttribute(uv2, b),
-          new Vector2().fromBufferAttribute(uv2, c),
-        ])
+      function addFace(a, b, c, materialIndex) {
+        const vertexColors =
+          color === undefined ? [] : [scope.colors[a].clone(), scope.colors[b].clone(), scope.colors[c].clone()]
+
+        const vertexNormals =
+          normal === undefined
+            ? []
+            : [
+                new Vector3().fromBufferAttribute(normal, a),
+                new Vector3().fromBufferAttribute(normal, b),
+                new Vector3().fromBufferAttribute(normal, c),
+              ]
+
+        const face = new Face3(a, b, c, vertexNormals, vertexColors, materialIndex)
+
+        scope.faces.push(face)
+
+        if (uv !== undefined) {
+          scope.faceVertexUvs[0].push([
+            new Vector2().fromBufferAttribute(uv, a),
+            new Vector2().fromBufferAttribute(uv, b),
+            new Vector2().fromBufferAttribute(uv, c),
+          ])
+        }
+
+        if (uv2 !== undefined) {
+          scope.faceVertexUvs[1].push([
+            new Vector2().fromBufferAttribute(uv2, a),
+            new Vector2().fromBufferAttribute(uv2, b),
+            new Vector2().fromBufferAttribute(uv2, c),
+          ])
+        }
       }
-    }
 
-    const groups = geometry.groups
+      const groups = geometry.groups
 
-    if (groups.length > 0) {
-      for (let i = 0; i < groups.length; i++) {
-        const group = groups[i]
+      if (groups.length > 0) {
+        for (let i = 0; i < groups.length; i++) {
+          const group = groups[i]
 
-        const start = group.start
-        const count = group.count
+          const start = group.start
+          const count = group.count
 
-        for (let j = start, jl = start + count; j < jl; j += 3) {
-          if (index !== undefined) {
-            addFace(index.getX(j), index.getX(j + 1), index.getX(j + 2), group.materialIndex)
-          } else {
-            addFace(j, j + 1, j + 2, group.materialIndex)
+          for (let j = start, jl = start + count; j < jl; j += 3) {
+            if (index !== undefined) {
+              addFace(index.getX(j), index.getX(j + 1), index.getX(j + 2), group.materialIndex)
+            } else {
+              addFace(j, j + 1, j + 2, group.materialIndex)
+            }
           }
         }
-      }
-    } else {
-      if (index !== undefined) {
-        for (let i = 0; i < index.count; i += 3) {
-          addFace(index.getX(i), index.getX(i + 1), index.getX(i + 2))
-        }
       } else {
-        for (let i = 0; i < position.count; i += 3) {
-          addFace(i, i + 1, i + 2)
+        if (index !== undefined) {
+          for (let i = 0; i < index.count; i += 3) {
+            addFace(index.getX(i), index.getX(i + 1), index.getX(i + 2))
+          }
+        } else {
+          for (let i = 0; i < position.count; i += 3) {
+            addFace(i, i + 1, i + 2)
+          }
         }
       }
-    }
-
-    this.computeFaceNormals()
-
-    if (geometry.boundingBox !== null) {
-      this.boundingBox = geometry.boundingBox.clone()
-    }
 
-    if (geometry.boundingSphere !== null) {
-      this.boundingSphere = geometry.boundingSphere.clone()
-    }
-
-    return this
-  }
-
-  center() {
-    this.computeBoundingBox()
-
-    this.boundingBox.getCenter(_offset).negate()
-
-    this.translate(_offset.x, _offset.y, _offset.z)
-
-    return this
-  }
-
-  normalize() {
-    this.computeBoundingSphere()
+      this.computeFaceNormals()
 
-    const center = this.boundingSphere.center
-    const radius = this.boundingSphere.radius
+      if (geometry.boundingBox !== null) {
+        this.boundingBox = geometry.boundingBox.clone()
+      }
 
-    const s = radius === 0 ? 1 : 1.0 / radius
+      if (geometry.boundingSphere !== null) {
+        this.boundingSphere = geometry.boundingSphere.clone()
+      }
 
-    const matrix = new Matrix4()
-    matrix.set(s, 0, 0, -s * center.x, 0, s, 0, -s * center.y, 0, 0, s, -s * center.z, 0, 0, 0, 1)
+      return this
+    }
 
-    this.applyMatrix4(matrix)
+    center() {
+      this.computeBoundingBox()
 
-    return this
-  }
+      this.boundingBox.getCenter(_offset).negate()
 
-  computeFaceNormals() {
-    const cb = new Vector3(),
-      ab = new Vector3()
+      this.translate(_offset.x, _offset.y, _offset.z)
 
-    for (let f = 0, fl = this.faces.length; f < fl; f++) {
-      const face = this.faces[f]
+      return this
+    }
 
-      const vA = this.vertices[face.a]
-      const vB = this.vertices[face.b]
-      const vC = this.vertices[face.c]
+    normalize() {
+      this.computeBoundingSphere()
 
-      cb.subVectors(vC, vB)
-      ab.subVectors(vA, vB)
-      cb.cross(ab)
+      const center = this.boundingSphere.center
+      const radius = this.boundingSphere.radius
 
-      cb.normalize()
+      const s = radius === 0 ? 1 : 1.0 / radius
 
-      face.normal.copy(cb)
-    }
-  }
+      const matrix = new Matrix4()
+      matrix.set(s, 0, 0, -s * center.x, 0, s, 0, -s * center.y, 0, 0, s, -s * center.z, 0, 0, 0, 1)
 
-  computeVertexNormals(areaWeighted = true) {
-    const vertices = new Array(this.vertices.length)
+      this.applyMatrix4(matrix)
 
-    for (let v = 0, vl = this.vertices.length; v < vl; v++) {
-      vertices[v] = new Vector3()
+      return this
     }
 
-    if (areaWeighted) {
-      // vertex normals weighted by triangle areas
-      // http://www.iquilezles.org/www/articles/normals/normals.htm
-
+    computeFaceNormals() {
       const cb = new Vector3(),
         ab = new Vector3()
 
@@ -352,549 +322,584 @@ class Geometry extends EventDispatcher {
         ab.subVectors(vA, vB)
         cb.cross(ab)
 
-        vertices[face.a].add(cb)
-        vertices[face.b].add(cb)
-        vertices[face.c].add(cb)
+        cb.normalize()
+
+        face.normal.copy(cb)
       }
-    } else {
-      this.computeFaceNormals()
+    }
 
-      for (let f = 0, fl = this.faces.length; f < fl; f++) {
-        const face = this.faces[f]
+    computeVertexNormals(areaWeighted = true) {
+      const vertices = new Array(this.vertices.length)
 
-        vertices[face.a].add(face.normal)
-        vertices[face.b].add(face.normal)
-        vertices[face.c].add(face.normal)
+      for (let v = 0, vl = this.vertices.length; v < vl; v++) {
+        vertices[v] = new Vector3()
       }
-    }
 
-    for (let v = 0, vl = this.vertices.length; v < vl; v++) {
-      vertices[v].normalize()
-    }
+      if (areaWeighted) {
+        // vertex normals weighted by triangle areas
+        // http://www.iquilezles.org/www/articles/normals/normals.htm
 
-    for (let f = 0, fl = this.faces.length; f < fl; f++) {
-      const face = this.faces[f]
+        const cb = new Vector3(),
+          ab = new Vector3()
 
-      const vertexNormals = face.vertexNormals
+        for (let f = 0, fl = this.faces.length; f < fl; f++) {
+          const face = this.faces[f]
 
-      if (vertexNormals.length === 3) {
-        vertexNormals[0].copy(vertices[face.a])
-        vertexNormals[1].copy(vertices[face.b])
-        vertexNormals[2].copy(vertices[face.c])
-      } else {
-        vertexNormals[0] = vertices[face.a].clone()
-        vertexNormals[1] = vertices[face.b].clone()
-        vertexNormals[2] = vertices[face.c].clone()
-      }
-    }
+          const vA = this.vertices[face.a]
+          const vB = this.vertices[face.b]
+          const vC = this.vertices[face.c]
 
-    if (this.faces.length > 0) {
-      this.normalsNeedUpdate = true
-    }
-  }
+          cb.subVectors(vC, vB)
+          ab.subVectors(vA, vB)
+          cb.cross(ab)
 
-  computeFlatVertexNormals() {
-    this.computeFaceNormals()
+          vertices[face.a].add(cb)
+          vertices[face.b].add(cb)
+          vertices[face.c].add(cb)
+        }
+      } else {
+        this.computeFaceNormals()
 
-    for (let f = 0, fl = this.faces.length; f < fl; f++) {
-      const face = this.faces[f]
+        for (let f = 0, fl = this.faces.length; f < fl; f++) {
+          const face = this.faces[f]
 
-      const vertexNormals = face.vertexNormals
+          vertices[face.a].add(face.normal)
+          vertices[face.b].add(face.normal)
+          vertices[face.c].add(face.normal)
+        }
+      }
 
-      if (vertexNormals.length === 3) {
-        vertexNormals[0].copy(face.normal)
-        vertexNormals[1].copy(face.normal)
-        vertexNormals[2].copy(face.normal)
-      } else {
-        vertexNormals[0] = face.normal.clone()
-        vertexNormals[1] = face.normal.clone()
-        vertexNormals[2] = face.normal.clone()
+      for (let v = 0, vl = this.vertices.length; v < vl; v++) {
+        vertices[v].normalize()
       }
-    }
 
-    if (this.faces.length > 0) {
-      this.normalsNeedUpdate = true
-    }
-  }
+      for (let f = 0, fl = this.faces.length; f < fl; f++) {
+        const face = this.faces[f]
 
-  computeMorphNormals() {
-    // save original normals
-    // - create temp variables on first access
-    //   otherwise just copy (for faster repeated calls)
+        const vertexNormals = face.vertexNormals
 
-    for (let f = 0, fl = this.faces.length; f < fl; f++) {
-      const face = this.faces[f]
+        if (vertexNormals.length === 3) {
+          vertexNormals[0].copy(vertices[face.a])
+          vertexNormals[1].copy(vertices[face.b])
+          vertexNormals[2].copy(vertices[face.c])
+        } else {
+          vertexNormals[0] = vertices[face.a].clone()
+          vertexNormals[1] = vertices[face.b].clone()
+          vertexNormals[2] = vertices[face.c].clone()
+        }
+      }
 
-      if (!face.__originalFaceNormal) {
-        face.__originalFaceNormal = face.normal.clone()
-      } else {
-        face.__originalFaceNormal.copy(face.normal)
+      if (this.faces.length > 0) {
+        this.normalsNeedUpdate = true
       }
+    }
 
-      if (!face.__originalVertexNormals) face.__originalVertexNormals = []
+    computeFlatVertexNormals() {
+      this.computeFaceNormals()
+
+      for (let f = 0, fl = this.faces.length; f < fl; f++) {
+        const face = this.faces[f]
+
+        const vertexNormals = face.vertexNormals
 
-      for (let i = 0, il = face.vertexNormals.length; i < il; i++) {
-        if (!face.__originalVertexNormals[i]) {
-          face.__originalVertexNormals[i] = face.vertexNormals[i].clone()
+        if (vertexNormals.length === 3) {
+          vertexNormals[0].copy(face.normal)
+          vertexNormals[1].copy(face.normal)
+          vertexNormals[2].copy(face.normal)
         } else {
-          face.__originalVertexNormals[i].copy(face.vertexNormals[i])
+          vertexNormals[0] = face.normal.clone()
+          vertexNormals[1] = face.normal.clone()
+          vertexNormals[2] = face.normal.clone()
         }
       }
-    }
 
-    // use temp geometry to compute face and vertex normals for each morph
+      if (this.faces.length > 0) {
+        this.normalsNeedUpdate = true
+      }
+    }
 
-    const tmpGeo = new Geometry()
-    tmpGeo.faces = this.faces
+    computeMorphNormals() {
+      // save original normals
+      // - create temp variables on first access
+      //   otherwise just copy (for faster repeated calls)
 
-    for (let i = 0, il = this.morphTargets.length; i < il; i++) {
-      // create on first access
+      for (let f = 0, fl = this.faces.length; f < fl; f++) {
+        const face = this.faces[f]
 
-      if (!this.morphNormals[i]) {
-        this.morphNormals[i] = {}
-        this.morphNormals[i].faceNormals = []
-        this.morphNormals[i].vertexNormals = []
+        if (!face.__originalFaceNormal) {
+          face.__originalFaceNormal = face.normal.clone()
+        } else {
+          face.__originalFaceNormal.copy(face.normal)
+        }
 
-        const dstNormalsFace = this.morphNormals[i].faceNormals
-        const dstNormalsVertex = this.morphNormals[i].vertexNormals
+        if (!face.__originalVertexNormals) face.__originalVertexNormals = []
 
-        for (let f = 0, fl = this.faces.length; f < fl; f++) {
-          const faceNormal = new Vector3()
-          const vertexNormals = {
-            a: new Vector3(),
-            b: new Vector3(),
-            c: new Vector3(),
+        for (let i = 0, il = face.vertexNormals.length; i < il; i++) {
+          if (!face.__originalVertexNormals[i]) {
+            face.__originalVertexNormals[i] = face.vertexNormals[i].clone()
+          } else {
+            face.__originalVertexNormals[i].copy(face.vertexNormals[i])
           }
-
-          dstNormalsFace.push(faceNormal)
-          dstNormalsVertex.push(vertexNormals)
         }
       }
 
-      const morphNormals = this.morphNormals[i]
-
-      // set vertices to morph target
+      // use temp geometry to compute face and vertex normals for each morph
 
-      tmpGeo.vertices = this.morphTargets[i].vertices
+      const tmpGeo = new Geometry()
+      tmpGeo.faces = this.faces
 
-      // compute morph normals
+      for (let i = 0, il = this.morphTargets.length; i < il; i++) {
+        // create on first access
 
-      tmpGeo.computeFaceNormals()
-      tmpGeo.computeVertexNormals()
+        if (!this.morphNormals[i]) {
+          this.morphNormals[i] = {}
+          this.morphNormals[i].faceNormals = []
+          this.morphNormals[i].vertexNormals = []
 
-      // store morph normals
+          const dstNormalsFace = this.morphNormals[i].faceNormals
+          const dstNormalsVertex = this.morphNormals[i].vertexNormals
 
-      for (let f = 0, fl = this.faces.length; f < fl; f++) {
-        const face = this.faces[f]
+          for (let f = 0, fl = this.faces.length; f < fl; f++) {
+            const faceNormal = new Vector3()
+            const vertexNormals = {
+              a: new Vector3(),
+              b: new Vector3(),
+              c: new Vector3(),
+            }
 
-        const faceNormal = morphNormals.faceNormals[f]
-        const vertexNormals = morphNormals.vertexNormals[f]
+            dstNormalsFace.push(faceNormal)
+            dstNormalsVertex.push(vertexNormals)
+          }
+        }
 
-        faceNormal.copy(face.normal)
+        const morphNormals = this.morphNormals[i]
 
-        vertexNormals.a.copy(face.vertexNormals[0])
-        vertexNormals.b.copy(face.vertexNormals[1])
-        vertexNormals.c.copy(face.vertexNormals[2])
-      }
-    }
+        // set vertices to morph target
 
-    // restore original normals
+        tmpGeo.vertices = this.morphTargets[i].vertices
 
-    for (let f = 0, fl = this.faces.length; f < fl; f++) {
-      const face = this.faces[f]
+        // compute morph normals
 
-      face.normal = face.__originalFaceNormal
-      face.vertexNormals = face.__originalVertexNormals
-    }
-  }
+        tmpGeo.computeFaceNormals()
+        tmpGeo.computeVertexNormals()
 
-  computeBoundingBox() {
-    if (this.boundingBox === null) {
-      this.boundingBox = new Box3()
-    }
-
-    this.boundingBox.setFromPoints(this.vertices)
-  }
+        // store morph normals
 
-  computeBoundingSphere() {
-    if (this.boundingSphere === null) {
-      this.boundingSphere = new Sphere()
-    }
+        for (let f = 0, fl = this.faces.length; f < fl; f++) {
+          const face = this.faces[f]
 
-    this.boundingSphere.setFromPoints(this.vertices)
-  }
+          const faceNormal = morphNormals.faceNormals[f]
+          const vertexNormals = morphNormals.vertexNormals[f]
 
-  merge(geometry, matrix, materialIndexOffset = 0) {
-    if (!(geometry && geometry.isGeometry)) {
-      console.error('THREE.Geometry.merge(): geometry not an instance of THREE.Geometry.', geometry)
-      return
-    }
+          faceNormal.copy(face.normal)
 
-    let normalMatrix
-    const vertexOffset = this.vertices.length,
-      vertices1 = this.vertices,
-      vertices2 = geometry.vertices,
-      faces1 = this.faces,
-      faces2 = geometry.faces,
-      colors1 = this.colors,
-      colors2 = geometry.colors
-
-    if (matrix !== undefined) {
-      normalMatrix = new Matrix3().getNormalMatrix(matrix)
-    }
+          vertexNormals.a.copy(face.vertexNormals[0])
+          vertexNormals.b.copy(face.vertexNormals[1])
+          vertexNormals.c.copy(face.vertexNormals[2])
+        }
+      }
 
-    // vertices
+      // restore original normals
 
-    for (let i = 0, il = vertices2.length; i < il; i++) {
-      const vertex = vertices2[i]
+      for (let f = 0, fl = this.faces.length; f < fl; f++) {
+        const face = this.faces[f]
 
-      const vertexCopy = vertex.clone()
+        face.normal = face.__originalFaceNormal
+        face.vertexNormals = face.__originalVertexNormals
+      }
+    }
 
-      if (matrix !== undefined) vertexCopy.applyMatrix4(matrix)
+    computeBoundingBox() {
+      if (this.boundingBox === null) {
+        this.boundingBox = new Box3()
+      }
 
-      vertices1.push(vertexCopy)
+      this.boundingBox.setFromPoints(this.vertices)
     }
 
-    // colors
+    computeBoundingSphere() {
+      if (this.boundingSphere === null) {
+        this.boundingSphere = new Sphere()
+      }
 
-    for (let i = 0, il = colors2.length; i < il; i++) {
-      colors1.push(colors2[i].clone())
+      this.boundingSphere.setFromPoints(this.vertices)
     }
 
-    // faces
+    merge(geometry, matrix, materialIndexOffset = 0) {
+      if (!(geometry && geometry.isGeometry)) {
+        console.error('THREE.Geometry.merge(): geometry not an instance of THREE.Geometry.', geometry)
+        return
+      }
 
-    for (let i = 0, il = faces2.length; i < il; i++) {
-      const face = faces2[i]
-      let normal, color
-      const faceVertexNormals = face.vertexNormals,
-        faceVertexColors = face.vertexColors
+      let normalMatrix
+      const vertexOffset = this.vertices.length,
+        vertices1 = this.vertices,
+        vertices2 = geometry.vertices,
+        faces1 = this.faces,
+        faces2 = geometry.faces,
+        colors1 = this.colors,
+        colors2 = geometry.colors
+
+      if (matrix !== undefined) {
+        normalMatrix = new Matrix3().getNormalMatrix(matrix)
+      }
 
-      const faceCopy = new Face3(face.a + vertexOffset, face.b + vertexOffset, face.c + vertexOffset)
-      faceCopy.normal.copy(face.normal)
+      // vertices
 
-      if (normalMatrix !== undefined) {
-        faceCopy.normal.applyMatrix3(normalMatrix).normalize()
-      }
+      for (let i = 0, il = vertices2.length; i < il; i++) {
+        const vertex = vertices2[i]
 
-      for (let j = 0, jl = faceVertexNormals.length; j < jl; j++) {
-        normal = faceVertexNormals[j].clone()
+        const vertexCopy = vertex.clone()
 
-        if (normalMatrix !== undefined) {
-          normal.applyMatrix3(normalMatrix).normalize()
-        }
+        if (matrix !== undefined) vertexCopy.applyMatrix4(matrix)
 
-        faceCopy.vertexNormals.push(normal)
+        vertices1.push(vertexCopy)
       }
 
-      faceCopy.color.copy(face.color)
+      // colors
 
-      for (let j = 0, jl = faceVertexColors.length; j < jl; j++) {
-        color = faceVertexColors[j]
-        faceCopy.vertexColors.push(color.clone())
+      for (let i = 0, il = colors2.length; i < il; i++) {
+        colors1.push(colors2[i].clone())
       }
 
-      faceCopy.materialIndex = face.materialIndex + materialIndexOffset
+      // faces
 
-      faces1.push(faceCopy)
-    }
+      for (let i = 0, il = faces2.length; i < il; i++) {
+        const face = faces2[i]
+        let normal, color
+        const faceVertexNormals = face.vertexNormals,
+          faceVertexColors = face.vertexColors
 
-    // uvs
+        const faceCopy = new Face3(face.a + vertexOffset, face.b + vertexOffset, face.c + vertexOffset)
+        faceCopy.normal.copy(face.normal)
 
-    for (let i = 0, il = geometry.faceVertexUvs.length; i < il; i++) {
-      const faceVertexUvs2 = geometry.faceVertexUvs[i]
+        if (normalMatrix !== undefined) {
+          faceCopy.normal.applyMatrix3(normalMatrix).normalize()
+        }
 
-      if (this.faceVertexUvs[i] === undefined) this.faceVertexUvs[i] = []
+        for (let j = 0, jl = faceVertexNormals.length; j < jl; j++) {
+          normal = faceVertexNormals[j].clone()
 
-      for (let j = 0, jl = faceVertexUvs2.length; j < jl; j++) {
-        const uvs2 = faceVertexUvs2[j],
-          uvsCopy = []
+          if (normalMatrix !== undefined) {
+            normal.applyMatrix3(normalMatrix).normalize()
+          }
 
-        for (let k = 0, kl = uvs2.length; k < kl; k++) {
-          uvsCopy.push(uvs2[k].clone())
+          faceCopy.vertexNormals.push(normal)
         }
 
-        this.faceVertexUvs[i].push(uvsCopy)
-      }
-    }
-  }
+        faceCopy.color.copy(face.color)
 
-  mergeMesh(mesh) {
-    if (!(mesh && mesh.isMesh)) {
-      console.error('THREE.Geometry.mergeMesh(): mesh not an instance of THREE.Mesh.', mesh)
-      return
-    }
+        for (let j = 0, jl = faceVertexColors.length; j < jl; j++) {
+          color = faceVertexColors[j]
+          faceCopy.vertexColors.push(color.clone())
+        }
 
-    if (mesh.matrixAutoUpdate) mesh.updateMatrix()
+        faceCopy.materialIndex = face.materialIndex + materialIndexOffset
 
-    this.merge(mesh.geometry, mesh.matrix)
-  }
+        faces1.push(faceCopy)
+      }
 
-  /*
-   * Checks for duplicate vertices with hashmap.
-   * Duplicated vertices are removed
-   * and faces' vertices are updated.
-   */
+      // uvs
 
-  mergeVertices(precisionPoints = 4) {
-    const verticesMap = {} // Hashmap for looking up vertices by position coordinates (and making sure they are unique)
-    const unique = [],
-      changes = []
+      for (let i = 0, il = geometry.faceVertexUvs.length; i < il; i++) {
+        const faceVertexUvs2 = geometry.faceVertexUvs[i]
 
-    const precision = Math.pow(10, precisionPoints)
+        if (this.faceVertexUvs[i] === undefined) this.faceVertexUvs[i] = []
 
-    for (let i = 0, il = this.vertices.length; i < il; i++) {
-      const v = this.vertices[i]
-      const key = `${Math.round(v.x * precision)}_${Math.round(v.y * precision)}_${Math.round(v.z * precision)}`
+        for (let j = 0, jl = faceVertexUvs2.length; j < jl; j++) {
+          const uvs2 = faceVertexUvs2[j],
+            uvsCopy = []
 
-      if (verticesMap[key] === undefined) {
-        verticesMap[key] = i
-        unique.push(this.vertices[i])
-        changes[i] = unique.length - 1
-      } else {
-        //console.log('Duplicate vertex found. ', i, ' could be using ', verticesMap[key]);
-        changes[i] = changes[verticesMap[key]]
+          for (let k = 0, kl = uvs2.length; k < kl; k++) {
+            uvsCopy.push(uvs2[k].clone())
+          }
+
+          this.faceVertexUvs[i].push(uvsCopy)
+        }
       }
     }
 
-    // if faces are completely degenerate after merging vertices, we
-    // have to remove them from the geometry.
-    const faceIndicesToRemove = []
-
-    for (let i = 0, il = this.faces.length; i < il; i++) {
-      const face = this.faces[i]
+    mergeMesh(mesh) {
+      if (!(mesh && mesh.isMesh)) {
+        console.error('THREE.Geometry.mergeMesh(): mesh not an instance of THREE.Mesh.', mesh)
+        return
+      }
 
-      face.a = changes[face.a]
-      face.b = changes[face.b]
-      face.c = changes[face.c]
+      if (mesh.matrixAutoUpdate) mesh.updateMatrix()
 
-      const indices = [face.a, face.b, face.c]
+      this.merge(mesh.geometry, mesh.matrix)
+    }
 
-      // if any duplicate vertices are found in a Face3
-      // we have to remove the face as nothing can be saved
-      for (let n = 0; n < 3; n++) {
-        if (indices[n] === indices[(n + 1) % 3]) {
-          faceIndicesToRemove.push(i)
-          break
+    /*
+     * Checks for duplicate vertices with hashmap.
+     * Duplicated vertices are removed
+     * and faces' vertices are updated.
+     */
+
+    mergeVertices(precisionPoints = 4) {
+      const verticesMap = {} // Hashmap for looking up vertices by position coordinates (and making sure they are unique)
+      const unique = [],
+        changes = []
+
+      const precision = Math.pow(10, precisionPoints)
+
+      for (let i = 0, il = this.vertices.length; i < il; i++) {
+        const v = this.vertices[i]
+        const key = `${Math.round(v.x * precision)}_${Math.round(v.y * precision)}_${Math.round(v.z * precision)}`
+
+        if (verticesMap[key] === undefined) {
+          verticesMap[key] = i
+          unique.push(this.vertices[i])
+          changes[i] = unique.length - 1
+        } else {
+          //console.log('Duplicate vertex found. ', i, ' could be using ', verticesMap[key]);
+          changes[i] = changes[verticesMap[key]]
         }
       }
-    }
 
-    for (let i = faceIndicesToRemove.length - 1; i >= 0; i--) {
-      const idx = faceIndicesToRemove[i]
+      // if faces are completely degenerate after merging vertices, we
+      // have to remove them from the geometry.
+      const faceIndicesToRemove = []
 
-      this.faces.splice(idx, 1)
+      for (let i = 0, il = this.faces.length; i < il; i++) {
+        const face = this.faces[i]
 
-      for (let j = 0, jl = this.faceVertexUvs.length; j < jl; j++) {
-        this.faceVertexUvs[j].splice(idx, 1)
-      }
-    }
+        face.a = changes[face.a]
+        face.b = changes[face.b]
+        face.c = changes[face.c]
 
-    // Use unique set of vertices
+        const indices = [face.a, face.b, face.c]
 
-    const diff = this.vertices.length - unique.length
-    this.vertices = unique
-    return diff
-  }
-
-  setFromPoints(points) {
-    this.vertices = []
+        // if any duplicate vertices are found in a Face3
+        // we have to remove the face as nothing can be saved
+        for (let n = 0; n < 3; n++) {
+          if (indices[n] === indices[(n + 1) % 3]) {
+            faceIndicesToRemove.push(i)
+            break
+          }
+        }
+      }
 
-    for (let i = 0, l = points.length; i < l; i++) {
-      const point = points[i]
-      this.vertices.push(new Vector3(point.x, point.y, point.z || 0))
-    }
+      for (let i = faceIndicesToRemove.length - 1; i >= 0; i--) {
+        const idx = faceIndicesToRemove[i]
 
-    return this
-  }
+        this.faces.splice(idx, 1)
 
-  sortFacesByMaterialIndex() {
-    const faces = this.faces
-    const length = faces.length
+        for (let j = 0, jl = this.faceVertexUvs.length; j < jl; j++) {
+          this.faceVertexUvs[j].splice(idx, 1)
+        }
+      }
 
-    // tag faces
+      // Use unique set of vertices
 
-    for (let i = 0; i < length; i++) {
-      faces[i]._id = i
+      const diff = this.vertices.length - unique.length
+      this.vertices = unique
+      return diff
     }
 
-    // sort faces
+    setFromPoints(points) {
+      this.vertices = []
 
-    function materialIndexSort(a, b) {
-      return a.materialIndex - b.materialIndex
-    }
+      for (let i = 0, l = points.length; i < l; i++) {
+        const point = points[i]
+        this.vertices.push(new Vector3(point.x, point.y, point.z || 0))
+      }
 
-    faces.sort(materialIndexSort)
+      return this
+    }
 
-    // sort uvs
+    sortFacesByMaterialIndex() {
+      const faces = this.faces
+      const length = faces.length
 
-    const uvs1 = this.faceVertexUvs[0]
-    const uvs2 = this.faceVertexUvs[1]
+      // tag faces
 
-    let newUvs1, newUvs2
+      for (let i = 0; i < length; i++) {
+        faces[i]._id = i
+      }
 
-    if (uvs1 && uvs1.length === length) newUvs1 = []
-    if (uvs2 && uvs2.length === length) newUvs2 = []
+      // sort faces
 
-    for (let i = 0; i < length; i++) {
-      const id = faces[i]._id
+      function materialIndexSort(a, b) {
+        return a.materialIndex - b.materialIndex
+      }
 
-      if (newUvs1) newUvs1.push(uvs1[id])
-      if (newUvs2) newUvs2.push(uvs2[id])
-    }
+      faces.sort(materialIndexSort)
 
-    if (newUvs1) this.faceVertexUvs[0] = newUvs1
-    if (newUvs2) this.faceVertexUvs[1] = newUvs2
-  }
+      // sort uvs
 
-  toJSON() {
-    const data = {
-      metadata: {
-        version: 4.5,
-        type: 'Geometry',
-        generator: 'Geometry.toJSON',
-      },
-    }
+      const uvs1 = this.faceVertexUvs[0]
+      const uvs2 = this.faceVertexUvs[1]
 
-    // standard Geometry serialization
+      let newUvs1, newUvs2
 
-    data.uuid = this.uuid
-    data.type = this.type
-    if (this.name !== '') data.name = this.name
+      if (uvs1 && uvs1.length === length) newUvs1 = []
+      if (uvs2 && uvs2.length === length) newUvs2 = []
 
-    if (this.parameters !== undefined) {
-      const parameters = this.parameters
+      for (let i = 0; i < length; i++) {
+        const id = faces[i]._id
 
-      for (let key in parameters) {
-        if (parameters[key] !== undefined) data[key] = parameters[key]
+        if (newUvs1) newUvs1.push(uvs1[id])
+        if (newUvs2) newUvs2.push(uvs2[id])
       }
 
-      return data
+      if (newUvs1) this.faceVertexUvs[0] = newUvs1
+      if (newUvs2) this.faceVertexUvs[1] = newUvs2
     }
 
-    const vertices = []
+    toJSON() {
+      const data = {
+        metadata: {
+          version: 4.5,
+          type: 'Geometry',
+          generator: 'Geometry.toJSON',
+        },
+      }
 
-    for (let i = 0; i < this.vertices.length; i++) {
-      const vertex = this.vertices[i]
-      vertices.push(vertex.x, vertex.y, vertex.z)
-    }
+      // standard Geometry serialization
 
-    const faces = []
-    const normals = []
-    const normalsHash = {}
-    const colors = []
-    const colorsHash = {}
-    const uvs = []
-    const uvsHash = {}
+      data.uuid = this.uuid
+      data.type = this.type
+      if (this.name !== '') data.name = this.name
 
-    for (let i = 0; i < this.faces.length; i++) {
-      const face = this.faces[i]
+      if (this.parameters !== undefined) {
+        const parameters = this.parameters
 
-      const hasMaterial = true
-      const hasFaceUv = false // deprecated
-      const hasFaceVertexUv = this.faceVertexUvs[0][i] !== undefined
-      const hasFaceNormal = face.normal.length() > 0
-      const hasFaceVertexNormal = face.vertexNormals.length > 0
-      const hasFaceColor = face.color.r !== 1 || face.color.g !== 1 || face.color.b !== 1
-      const hasFaceVertexColor = face.vertexColors.length > 0
+        for (let key in parameters) {
+          if (parameters[key] !== undefined) data[key] = parameters[key]
+        }
 
-      let faceType = 0
+        return data
+      }
 
-      faceType = setBit(faceType, 0, 0) // isQuad
-      faceType = setBit(faceType, 1, hasMaterial)
-      faceType = setBit(faceType, 2, hasFaceUv)
-      faceType = setBit(faceType, 3, hasFaceVertexUv)
-      faceType = setBit(faceType, 4, hasFaceNormal)
-      faceType = setBit(faceType, 5, hasFaceVertexNormal)
-      faceType = setBit(faceType, 6, hasFaceColor)
-      faceType = setBit(faceType, 7, hasFaceVertexColor)
+      const vertices = []
 
-      faces.push(faceType)
-      faces.push(face.a, face.b, face.c)
-      faces.push(face.materialIndex)
+      for (let i = 0; i < this.vertices.length; i++) {
+        const vertex = this.vertices[i]
+        vertices.push(vertex.x, vertex.y, vertex.z)
+      }
 
-      if (hasFaceVertexUv) {
-        const faceVertexUvs = this.faceVertexUvs[0][i]
+      const faces = []
+      const normals = []
+      const normalsHash = {}
+      const colors = []
+      const colorsHash = {}
+      const uvs = []
+      const uvsHash = {}
+
+      for (let i = 0; i < this.faces.length; i++) {
+        const face = this.faces[i]
+
+        const hasMaterial = true
+        const hasFaceUv = false // deprecated
+        const hasFaceVertexUv = this.faceVertexUvs[0][i] !== undefined
+        const hasFaceNormal = face.normal.length() > 0
+        const hasFaceVertexNormal = face.vertexNormals.length > 0
+        const hasFaceColor = face.color.r !== 1 || face.color.g !== 1 || face.color.b !== 1
+        const hasFaceVertexColor = face.vertexColors.length > 0
+
+        let faceType = 0
+
+        faceType = setBit(faceType, 0, 0) // isQuad
+        faceType = setBit(faceType, 1, hasMaterial)
+        faceType = setBit(faceType, 2, hasFaceUv)
+        faceType = setBit(faceType, 3, hasFaceVertexUv)
+        faceType = setBit(faceType, 4, hasFaceNormal)
+        faceType = setBit(faceType, 5, hasFaceVertexNormal)
+        faceType = setBit(faceType, 6, hasFaceColor)
+        faceType = setBit(faceType, 7, hasFaceVertexColor)
+
+        faces.push(faceType)
+        faces.push(face.a, face.b, face.c)
+        faces.push(face.materialIndex)
+
+        if (hasFaceVertexUv) {
+          const faceVertexUvs = this.faceVertexUvs[0][i]
+
+          faces.push(getUvIndex(faceVertexUvs[0]), getUvIndex(faceVertexUvs[1]), getUvIndex(faceVertexUvs[2]))
+        }
 
-        faces.push(getUvIndex(faceVertexUvs[0]), getUvIndex(faceVertexUvs[1]), getUvIndex(faceVertexUvs[2]))
-      }
+        if (hasFaceNormal) {
+          faces.push(getNormalIndex(face.normal))
+        }
 
-      if (hasFaceNormal) {
-        faces.push(getNormalIndex(face.normal))
-      }
+        if (hasFaceVertexNormal) {
+          const vertexNormals = face.vertexNormals
 
-      if (hasFaceVertexNormal) {
-        const vertexNormals = face.vertexNormals
+          faces.push(
+            getNormalIndex(vertexNormals[0]),
+            getNormalIndex(vertexNormals[1]),
+            getNormalIndex(vertexNormals[2]),
+          )
+        }
 
-        faces.push(getNormalIndex(vertexNormals[0]), getNormalIndex(vertexNormals[1]), getNormalIndex(vertexNormals[2]))
-      }
+        if (hasFaceColor) {
+          faces.push(getColorIndex(face.color))
+        }
 
-      if (hasFaceColor) {
-        faces.push(getColorIndex(face.color))
-      }
+        if (hasFaceVertexColor) {
+          const vertexColors = face.vertexColors
 
-      if (hasFaceVertexColor) {
-        const vertexColors = face.vertexColors
+          faces.push(getColorIndex(vertexColors[0]), getColorIndex(vertexColors[1]), getColorIndex(vertexColors[2]))
+        }
+      }
 
-        faces.push(getColorIndex(vertexColors[0]), getColorIndex(vertexColors[1]), getColorIndex(vertexColors[2]))
+      function setBit(value, position, enabled) {
+        return enabled ? value | (1 << position) : value & ~(1 << position)
       }
-    }
 
-    function setBit(value, position, enabled) {
-      return enabled ? value | (1 << position) : value & ~(1 << position)
-    }
+      function getNormalIndex(normal) {
+        const hash = normal.x.toString() + normal.y.toString() + normal.z.toString()
+
+        if (normalsHash[hash] !== undefined) {
+          return normalsHash[hash]
+        }
 
-    function getNormalIndex(normal) {
-      const hash = normal.x.toString() + normal.y.toString() + normal.z.toString()
+        normalsHash[hash] = normals.length / 3
+        normals.push(normal.x, normal.y, normal.z)
 
-      if (normalsHash[hash] !== undefined) {
         return normalsHash[hash]
       }
 
-      normalsHash[hash] = normals.length / 3
-      normals.push(normal.x, normal.y, normal.z)
+      function getColorIndex(color) {
+        const hash = color.r.toString() + color.g.toString() + color.b.toString()
 
-      return normalsHash[hash]
-    }
+        if (colorsHash[hash] !== undefined) {
+          return colorsHash[hash]
+        }
 
-    function getColorIndex(color) {
-      const hash = color.r.toString() + color.g.toString() + color.b.toString()
+        colorsHash[hash] = colors.length
+        colors.push(color.getHex())
 
-      if (colorsHash[hash] !== undefined) {
         return colorsHash[hash]
       }
 
-      colorsHash[hash] = colors.length
-      colors.push(color.getHex())
+      function getUvIndex(uv) {
+        const hash = uv.x.toString() + uv.y.toString()
 
-      return colorsHash[hash]
-    }
+        if (uvsHash[hash] !== undefined) {
+          return uvsHash[hash]
+        }
 
-    function getUvIndex(uv) {
-      const hash = uv.x.toString() + uv.y.toString()
+        uvsHash[hash] = uvs.length / 2
+        uvs.push(uv.x, uv.y)
 
-      if (uvsHash[hash] !== undefined) {
         return uvsHash[hash]
       }
 
-      uvsHash[hash] = uvs.length / 2
-      uvs.push(uv.x, uv.y)
-
-      return uvsHash[hash]
-    }
-
-    data.data = {}
+      data.data = {}
 
-    data.data.vertices = vertices
-    data.data.normals = normals
-    if (colors.length > 0) data.data.colors = colors
-    if (uvs.length > 0) data.data.uvs = [uvs] // temporal backward compatibility
-    data.data.faces = faces
+      data.data.vertices = vertices
+      data.data.normals = normals
+      if (colors.length > 0) data.data.colors = colors
+      if (uvs.length > 0) data.data.uvs = [uvs] // temporal backward compatibility
+      data.data.faces = faces
 
-    return data
-  }
+      return data
+    }
 
-  clone() {
-    /*
+    clone() {
+      /*
 		 // Handle primitives
 
 		 const parameters = this.parameters;
@@ -918,290 +923,293 @@ class Geometry extends EventDispatcher {
 		 return new this.constructor().copy( this );
 		 */
 
-    return new Geometry().copy(this)
-  }
+      return new Geometry().copy(this)
+    }
 
-  copy(source) {
-    // reset
+    copy(source) {
+      // reset
 
-    this.vertices = []
-    this.colors = []
-    this.faces = []
-    this.faceVertexUvs = [[]]
-    this.morphTargets = []
-    this.morphNormals = []
-    this.skinWeights = []
-    this.skinIndices = []
-    this.lineDistances = []
-    this.boundingBox = null
-    this.boundingSphere = null
+      this.vertices = []
+      this.colors = []
+      this.faces = []
+      this.faceVertexUvs = [[]]
+      this.morphTargets = []
+      this.morphNormals = []
+      this.skinWeights = []
+      this.skinIndices = []
+      this.lineDistances = []
+      this.boundingBox = null
+      this.boundingSphere = null
 
-    // name
+      // name
 
-    this.name = source.name
+      this.name = source.name
 
-    // vertices
+      // vertices
 
-    const vertices = source.vertices
+      const vertices = source.vertices
 
-    for (let i = 0, il = vertices.length; i < il; i++) {
-      this.vertices.push(vertices[i].clone())
-    }
+      for (let i = 0, il = vertices.length; i < il; i++) {
+        this.vertices.push(vertices[i].clone())
+      }
 
-    // colors
+      // colors
 
-    const colors = source.colors
+      const colors = source.colors
 
-    for (let i = 0, il = colors.length; i < il; i++) {
-      this.colors.push(colors[i].clone())
-    }
+      for (let i = 0, il = colors.length; i < il; i++) {
+        this.colors.push(colors[i].clone())
+      }
 
-    // faces
+      // faces
 
-    const faces = source.faces
+      const faces = source.faces
 
-    for (let i = 0, il = faces.length; i < il; i++) {
-      this.faces.push(faces[i].clone())
-    }
+      for (let i = 0, il = faces.length; i < il; i++) {
+        this.faces.push(faces[i].clone())
+      }
 
-    // face vertex uvs
+      // face vertex uvs
 
-    for (let i = 0, il = source.faceVertexUvs.length; i < il; i++) {
-      const faceVertexUvs = source.faceVertexUvs[i]
+      for (let i = 0, il = source.faceVertexUvs.length; i < il; i++) {
+        const faceVertexUvs = source.faceVertexUvs[i]
 
-      if (this.faceVertexUvs[i] === undefined) {
-        this.faceVertexUvs[i] = []
-      }
+        if (this.faceVertexUvs[i] === undefined) {
+          this.faceVertexUvs[i] = []
+        }
 
-      for (let j = 0, jl = faceVertexUvs.length; j < jl; j++) {
-        const uvs = faceVertexUvs[j],
-          uvsCopy = []
+        for (let j = 0, jl = faceVertexUvs.length; j < jl; j++) {
+          const uvs = faceVertexUvs[j],
+            uvsCopy = []
 
-        for (let k = 0, kl = uvs.length; k < kl; k++) {
-          const uv = uvs[k]
+          for (let k = 0, kl = uvs.length; k < kl; k++) {
+            const uv = uvs[k]
 
-          uvsCopy.push(uv.clone())
-        }
+            uvsCopy.push(uv.clone())
+          }
 
-        this.faceVertexUvs[i].push(uvsCopy)
+          this.faceVertexUvs[i].push(uvsCopy)
+        }
       }
-    }
 
-    // morph targets
+      // morph targets
 
-    const morphTargets = source.morphTargets
+      const morphTargets = source.morphTargets
 
-    for (let i = 0, il = morphTargets.length; i < il; i++) {
-      const morphTarget = {}
-      morphTarget.name = morphTargets[i].name
+      for (let i = 0, il = morphTargets.length; i < il; i++) {
+        const morphTarget = {}
+        morphTarget.name = morphTargets[i].name
 
-      // vertices
+        // vertices
 
-      if (morphTargets[i].vertices !== undefined) {
-        morphTarget.vertices = []
+        if (morphTargets[i].vertices !== undefined) {
+          morphTarget.vertices = []
 
-        for (let j = 0, jl = morphTargets[i].vertices.length; j < jl; j++) {
-          morphTarget.vertices.push(morphTargets[i].vertices[j].clone())
+          for (let j = 0, jl = morphTargets[i].vertices.length; j < jl; j++) {
+            morphTarget.vertices.push(morphTargets[i].vertices[j].clone())
+          }
         }
-      }
 
-      // normals
+        // normals
 
-      if (morphTargets[i].normals !== undefined) {
-        morphTarget.normals = []
+        if (morphTargets[i].normals !== undefined) {
+          morphTarget.normals = []
 
-        for (let j = 0, jl = morphTargets[i].normals.length; j < jl; j++) {
-          morphTarget.normals.push(morphTargets[i].normals[j].clone())
+          for (let j = 0, jl = morphTargets[i].normals.length; j < jl; j++) {
+            morphTarget.normals.push(morphTargets[i].normals[j].clone())
+          }
         }
-      }
 
-      this.morphTargets.push(morphTarget)
-    }
+        this.morphTargets.push(morphTarget)
+      }
 
-    // morph normals
+      // morph normals
 
-    const morphNormals = source.morphNormals
+      const morphNormals = source.morphNormals
 
-    for (let i = 0, il = morphNormals.length; i < il; i++) {
-      const morphNormal = {}
+      for (let i = 0, il = morphNormals.length; i < il; i++) {
+        const morphNormal = {}
 
-      // vertex normals
+        // vertex normals
 
-      if (morphNormals[i].vertexNormals !== undefined) {
-        morphNormal.vertexNormals = []
+        if (morphNormals[i].vertexNormals !== undefined) {
+          morphNormal.vertexNormals = []
 
-        for (let j = 0, jl = morphNormals[i].vertexNormals.length; j < jl; j++) {
-          const srcVertexNormal = morphNormals[i].vertexNormals[j]
-          const destVertexNormal = {}
+          for (let j = 0, jl = morphNormals[i].vertexNormals.length; j < jl; j++) {
+            const srcVertexNormal = morphNormals[i].vertexNormals[j]
+            const destVertexNormal = {}
 
-          destVertexNormal.a = srcVertexNormal.a.clone()
-          destVertexNormal.b = srcVertexNormal.b.clone()
-          destVertexNormal.c = srcVertexNormal.c.clone()
+            destVertexNormal.a = srcVertexNormal.a.clone()
+            destVertexNormal.b = srcVertexNormal.b.clone()
+            destVertexNormal.c = srcVertexNormal.c.clone()
 
-          morphNormal.vertexNormals.push(destVertexNormal)
+            morphNormal.vertexNormals.push(destVertexNormal)
+          }
         }
-      }
 
-      // face normals
+        // face normals
 
-      if (morphNormals[i].faceNormals !== undefined) {
-        morphNormal.faceNormals = []
+        if (morphNormals[i].faceNormals !== undefined) {
+          morphNormal.faceNormals = []
 
-        for (let j = 0, jl = morphNormals[i].faceNormals.length; j < jl; j++) {
-          morphNormal.faceNormals.push(morphNormals[i].faceNormals[j].clone())
+          for (let j = 0, jl = morphNormals[i].faceNormals.length; j < jl; j++) {
+            morphNormal.faceNormals.push(morphNormals[i].faceNormals[j].clone())
+          }
         }
+
+        this.morphNormals.push(morphNormal)
       }
 
-      this.morphNormals.push(morphNormal)
-    }
+      // skin weights
 
-    // skin weights
+      const skinWeights = source.skinWeights
 
-    const skinWeights = source.skinWeights
+      for (let i = 0, il = skinWeights.length; i < il; i++) {
+        this.skinWeights.push(skinWeights[i].clone())
+      }
 
-    for (let i = 0, il = skinWeights.length; i < il; i++) {
-      this.skinWeights.push(skinWeights[i].clone())
-    }
+      // skin indices
 
-    // skin indices
+      const skinIndices = source.skinIndices
 
-    const skinIndices = source.skinIndices
+      for (let i = 0, il = skinIndices.length; i < il; i++) {
+        this.skinIndices.push(skinIndices[i].clone())
+      }
 
-    for (let i = 0, il = skinIndices.length; i < il; i++) {
-      this.skinIndices.push(skinIndices[i].clone())
-    }
+      // line distances
 
-    // line distances
+      const lineDistances = source.lineDistances
 
-    const lineDistances = source.lineDistances
+      for (let i = 0, il = lineDistances.length; i < il; i++) {
+        this.lineDistances.push(lineDistances[i])
+      }
 
-    for (let i = 0, il = lineDistances.length; i < il; i++) {
-      this.lineDistances.push(lineDistances[i])
-    }
+      // bounding box
 
-    // bounding box
+      const boundingBox = source.boundingBox
 
-    const boundingBox = source.boundingBox
+      if (boundingBox !== null) {
+        this.boundingBox = boundingBox.clone()
+      }
 
-    if (boundingBox !== null) {
-      this.boundingBox = boundingBox.clone()
-    }
+      // bounding sphere
 
-    // bounding sphere
+      const boundingSphere = source.boundingSphere
 
-    const boundingSphere = source.boundingSphere
+      if (boundingSphere !== null) {
+        this.boundingSphere = boundingSphere.clone()
+      }
 
-    if (boundingSphere !== null) {
-      this.boundingSphere = boundingSphere.clone()
-    }
+      // update flags
 
-    // update flags
+      this.elementsNeedUpdate = source.elementsNeedUpdate
+      this.verticesNeedUpdate = source.verticesNeedUpdate
+      this.uvsNeedUpdate = source.uvsNeedUpdate
+      this.normalsNeedUpdate = source.normalsNeedUpdate
+      this.colorsNeedUpdate = source.colorsNeedUpdate
+      this.lineDistancesNeedUpdate = source.lineDistancesNeedUpdate
+      this.groupsNeedUpdate = source.groupsNeedUpdate
 
-    this.elementsNeedUpdate = source.elementsNeedUpdate
-    this.verticesNeedUpdate = source.verticesNeedUpdate
-    this.uvsNeedUpdate = source.uvsNeedUpdate
-    this.normalsNeedUpdate = source.normalsNeedUpdate
-    this.colorsNeedUpdate = source.colorsNeedUpdate
-    this.lineDistancesNeedUpdate = source.lineDistancesNeedUpdate
-    this.groupsNeedUpdate = source.groupsNeedUpdate
+      return this
+    }
 
-    return this
-  }
+    toBufferGeometry() {
+      const geometry = new DirectGeometry().fromGeometry(this)
 
-  toBufferGeometry() {
-    const geometry = new DirectGeometry().fromGeometry(this)
+      const buffergeometry = new BufferGeometry()
 
-    const buffergeometry = new BufferGeometry()
+      const positions = new Float32Array(geometry.vertices.length * 3)
+      buffergeometry.setAttribute('position', new BufferAttribute(positions, 3).copyVector3sArray(geometry.vertices))
 
-    const positions = new Float32Array(geometry.vertices.length * 3)
-    buffergeometry.setAttribute('position', new BufferAttribute(positions, 3).copyVector3sArray(geometry.vertices))
+      if (geometry.normals.length > 0) {
+        const normals = new Float32Array(geometry.normals.length * 3)
+        buffergeometry.setAttribute('normal', new BufferAttribute(normals, 3).copyVector3sArray(geometry.normals))
+      }
 
-    if (geometry.normals.length > 0) {
-      const normals = new Float32Array(geometry.normals.length * 3)
-      buffergeometry.setAttribute('normal', new BufferAttribute(normals, 3).copyVector3sArray(geometry.normals))
-    }
+      if (geometry.colors.length > 0) {
+        const colors = new Float32Array(geometry.colors.length * 3)
+        buffergeometry.setAttribute('color', new BufferAttribute(colors, 3).copyColorsArray(geometry.colors))
+      }
 
-    if (geometry.colors.length > 0) {
-      const colors = new Float32Array(geometry.colors.length * 3)
-      buffergeometry.setAttribute('color', new BufferAttribute(colors, 3).copyColorsArray(geometry.colors))
-    }
+      if (geometry.uvs.length > 0) {
+        const uvs = new Float32Array(geometry.uvs.length * 2)
+        buffergeometry.setAttribute('uv', new BufferAttribute(uvs, 2).copyVector2sArray(geometry.uvs))
+      }
 
-    if (geometry.uvs.length > 0) {
-      const uvs = new Float32Array(geometry.uvs.length * 2)
-      buffergeometry.setAttribute('uv', new BufferAttribute(uvs, 2).copyVector2sArray(geometry.uvs))
-    }
+      if (geometry.uvs2.length > 0) {
+        const uvs2 = new Float32Array(geometry.uvs2.length * 2)
+        buffergeometry.setAttribute('uv2', new BufferAttribute(uvs2, 2).copyVector2sArray(geometry.uvs2))
+      }
 
-    if (geometry.uvs2.length > 0) {
-      const uvs2 = new Float32Array(geometry.uvs2.length * 2)
-      buffergeometry.setAttribute('uv2', new BufferAttribute(uvs2, 2).copyVector2sArray(geometry.uvs2))
-    }
+      // groups
 
-    // groups
+      buffergeometry.groups = geometry.groups
 
-    buffergeometry.groups = geometry.groups
+      // morphs
 
-    // morphs
+      for (let name in geometry.morphTargets) {
+        const array = []
+        const morphTargets = geometry.morphTargets[name]
 
-    for (let name in geometry.morphTargets) {
-      const array = []
-      const morphTargets = geometry.morphTargets[name]
+        for (let i = 0, l = morphTargets.length; i < l; i++) {
+          const morphTarget = morphTargets[i]
 
-      for (let i = 0, l = morphTargets.length; i < l; i++) {
-        const morphTarget = morphTargets[i]
+          const attribute = new Float32BufferAttribute(morphTarget.data.length * 3, 3)
+          attribute.name = morphTarget.name
 
-        const attribute = new Float32BufferAttribute(morphTarget.data.length * 3, 3)
-        attribute.name = morphTarget.name
+          array.push(attribute.copyVector3sArray(morphTarget.data))
+        }
 
-        array.push(attribute.copyVector3sArray(morphTarget.data))
+        buffergeometry.morphAttributes[name] = array
       }
 
-      buffergeometry.morphAttributes[name] = array
-    }
+      // skinning
+
+      if (geometry.skinIndices.length > 0) {
+        const skinIndices = new Float32BufferAttribute(geometry.skinIndices.length * 4, 4)
+        buffergeometry.setAttribute('skinIndex', skinIndices.copyVector4sArray(geometry.skinIndices))
+      }
 
-    // skinning
+      if (geometry.skinWeights.length > 0) {
+        const skinWeights = new Float32BufferAttribute(geometry.skinWeights.length * 4, 4)
+        buffergeometry.setAttribute('skinWeight', skinWeights.copyVector4sArray(geometry.skinWeights))
+      }
 
-    if (geometry.skinIndices.length > 0) {
-      const skinIndices = new Float32BufferAttribute(geometry.skinIndices.length * 4, 4)
-      buffergeometry.setAttribute('skinIndex', skinIndices.copyVector4sArray(geometry.skinIndices))
-    }
+      //
 
-    if (geometry.skinWeights.length > 0) {
-      const skinWeights = new Float32BufferAttribute(geometry.skinWeights.length * 4, 4)
-      buffergeometry.setAttribute('skinWeight', skinWeights.copyVector4sArray(geometry.skinWeights))
-    }
+      if (geometry.boundingSphere !== null) {
+        buffergeometry.boundingSphere = geometry.boundingSphere.clone()
+      }
 
-    //
+      if (geometry.boundingBox !== null) {
+        buffergeometry.boundingBox = geometry.boundingBox.clone()
+      }
 
-    if (geometry.boundingSphere !== null) {
-      buffergeometry.boundingSphere = geometry.boundingSphere.clone()
+      return buffergeometry
     }
 
-    if (geometry.boundingBox !== null) {
-      buffergeometry.boundingBox = geometry.boundingBox.clone()
+    computeTangents() {
+      console.error('THREE.Geometry: .computeTangents() has been removed.')
     }
 
-    return buffergeometry
-  }
-
-  computeTangents() {
-    console.error('THREE.Geometry: .computeTangents() has been removed.')
-  }
+    computeLineDistances() {
+      console.error(
+        'THREE.Geometry: .computeLineDistances() has been removed. Use THREE.Line.computeLineDistances() instead.',
+      )
+    }
 
-  computeLineDistances() {
-    console.error(
-      'THREE.Geometry: .computeLineDistances() has been removed. Use THREE.Line.computeLineDistances() instead.',
-    )
-  }
+    applyMatrix(matrix) {
+      console.warn('THREE.Geometry: .applyMatrix() has been renamed to .applyMatrix4().')
+      return this.applyMatrix4(matrix)
+    }
 
-  applyMatrix(matrix) {
-    console.warn('THREE.Geometry: .applyMatrix() has been renamed to .applyMatrix4().')
-    return this.applyMatrix4(matrix)
+    dispose() {
+      this.dispatchEvent({ type: 'dispose' })
+    }
   }
 
-  dispose() {
-    this.dispatchEvent({ type: 'dispose' })
-  }
-}
+  return Geometry
+})()
 
 class DirectGeometry {
   constructor() {
diff --git a/src/effects/AnaglyphEffect.js b/src/effects/AnaglyphEffect.js
index fdbdc8c3..7713e65e 100644
--- a/src/effects/AnaglyphEffect.js
+++ b/src/effects/AnaglyphEffect.js
@@ -10,8 +10,8 @@ import {
   ShaderMaterial,
   StereoCamera,
   WebGLRenderTarget,
-  REVISION,
 } from 'three'
+import { version } from '../_polyfill/constants'
 
 class AnaglyphEffect {
   constructor(renderer, width = 512, height = 512) {
@@ -96,7 +96,7 @@ class AnaglyphEffect {
         '			max( colorL.a, colorR.a ) );',
 
         '	#include <tonemapping_fragment>',
-        `	#include <${parseInt(REVISION.replace(/\D+/g, '')) >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>`,
+        `	#include <${version >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>`,
 
         '}',
       ].join('\n'),
diff --git a/src/effects/OutlineEffect.js b/src/effects/OutlineEffect.js
index 2999048c..581b2349 100644
--- a/src/effects/OutlineEffect.js
+++ b/src/effects/OutlineEffect.js
@@ -1,4 +1,5 @@
-import { BackSide, Color, ShaderMaterial, UniformsLib, UniformsUtils, REVISION } from 'three'
+import { BackSide, Color, ShaderMaterial, UniformsLib, UniformsUtils } from 'three'
+import { version } from '../_polyfill/constants'
 
 /**
  * Reference: https://en.wikipedia.org/wiki/Cel_shading
@@ -157,7 +158,7 @@ class OutlineEffect {
       '	gl_FragColor = vec4( outlineColor, outlineAlpha );',
 
       '	#include <tonemapping_fragment>',
-      `	#include <${parseInt(REVISION.replace(/\D+/g, '')) >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>`,
+      `	#include <${version >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>`,
       '	#include <fog_fragment>',
       '	#include <premultiplied_alpha_fragment>',
 
diff --git a/src/effects/ParallaxBarrierEffect.js b/src/effects/ParallaxBarrierEffect.js
index 00ae33f4..8cee4954 100644
--- a/src/effects/ParallaxBarrierEffect.js
+++ b/src/effects/ParallaxBarrierEffect.js
@@ -9,8 +9,8 @@ import {
   ShaderMaterial,
   StereoCamera,
   WebGLRenderTarget,
-  REVISION,
 } from 'three'
+import { version } from '../_polyfill/constants'
 
 class ParallaxBarrierEffect {
   constructor(renderer) {
@@ -62,7 +62,7 @@ class ParallaxBarrierEffect {
         '	}',
 
         '	#include <tonemapping_fragment>',
-        `	#include <${parseInt(REVISION.replace(/\D+/g, '')) >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>`,
+        `	#include <${version >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>`,
 
         '}',
       ].join('\n'),
diff --git a/src/exporters/DRACOExporter.d.ts b/src/exporters/DRACOExporter.d.ts
new file mode 100644
index 00000000..01a57ca5
--- /dev/null
+++ b/src/exporters/DRACOExporter.d.ts
@@ -0,0 +1,36 @@
+import * as THREE from 'three'
+
+declare class DRACOExporter {
+  // Encoder methods
+
+  public static MESH_EDGEBREAKER_ENCODING: number
+  public static MESH_SEQUENTIAL_ENCODING: number
+
+  // Geometry type
+
+  public static POINT_CLOUD: number
+  public static TRIANGULAR_MESH: number
+
+  // Attribute type
+  public static INVALID: number
+  public static POSITION: number
+  public static NORMAL: number
+  public static COLOR: number
+  public static TEX_COORD: number
+  public static GENERIC: number
+
+  public parse(
+    object: THREE.Mesh | THREE.Points,
+    options?: {
+      decodeSpeed?: number
+      encodeSpeed?: number
+      encoderMethod?: number
+      quantization?: [number, number, number, number, number]
+      exportUvs?: boolean
+      exportNormals?: boolean
+      exportColor?: boolean
+    },
+  ): Int8Array
+}
+
+export { DRACOExporter }
diff --git a/src/exporters/DRACOExporter.js b/src/exporters/DRACOExporter.js
new file mode 100644
index 00000000..e698fc2f
--- /dev/null
+++ b/src/exporters/DRACOExporter.js
@@ -0,0 +1,216 @@
+import { BufferGeometry, Mesh, Points } from 'three'
+
+/**
+ * Export draco compressed files from threejs geometry objects.
+ *
+ * Draco files are compressed and usually are smaller than conventional 3D file formats.
+ *
+ * The exporter receives a options object containing
+ *  - decodeSpeed, indicates how to tune the encoder regarding decode speed (0 gives better speed but worst quality)
+ *  - encodeSpeed, indicates how to tune the encoder parameters (0 gives better speed but worst quality)
+ *  - encoderMethod
+ *  - quantization, indicates the presision of each type of data stored in the draco file in the order (POSITION, NORMAL, COLOR, TEX_COORD, GENERIC)
+ *  - exportUvs
+ *  - exportNormals
+ */
+
+const DRACOExporter = /* @__PURE__ */ (() => {
+  class DRACOExporter {
+    // Encoder methods
+
+    static MESH_EDGEBREAKER_ENCODING = 1
+    static MESH_SEQUENTIAL_ENCODING = 0
+
+    // Geometry type
+
+    static POINT_CLOUD = 0
+    static TRIANGULAR_MESH = 1
+
+    // Attribute type
+    static INVALID = -1
+    static POSITION = 0
+    static NORMAL = 1
+    static COLOR = 2
+    static TEX_COORD = 3
+    static GENERIC = 4
+
+    parse(
+      object,
+      options = {
+        decodeSpeed: 5,
+        encodeSpeed: 5,
+        encoderMethod: DRACOExporter.MESH_EDGEBREAKER_ENCODING,
+        quantization: [16, 8, 8, 8, 8],
+        exportUvs: true,
+        exportNormals: true,
+        exportColor: false,
+      },
+    ) {
+      if (object instanceof BufferGeometry && object.isBufferGeometry) {
+        throw new Error('DRACOExporter: The first parameter of parse() is now an instance of Mesh or Points.')
+      }
+
+      if (DracoEncoderModule === undefined) {
+        throw new Error('THREE.DRACOExporter: required the draco_encoder to work.')
+      }
+
+      const geometry = object.geometry
+
+      const dracoEncoder = DracoEncoderModule()
+      const encoder = new dracoEncoder.Encoder()
+      let builder
+      let dracoObject
+
+      if (!geometry.isBufferGeometry) {
+        throw new Error(
+          'THREE.DRACOExporter.parse(geometry, options): geometry is not a THREE.BufferGeometry instance.',
+        )
+      }
+
+      if (object instanceof Mesh && object.isMesh) {
+        builder = new dracoEncoder.MeshBuilder()
+        dracoObject = new dracoEncoder.Mesh()
+
+        const vertices = geometry.getAttribute('position')
+        // @ts-ignore
+        builder.AddFloatAttributeToMesh(
+          dracoObject,
+          dracoEncoder.POSITION,
+          vertices.count,
+          vertices.itemSize,
+          vertices.array,
+        )
+
+        const faces = geometry.getIndex()
+
+        if (faces !== null) {
+          builder.AddFacesToMesh(dracoObject, faces.count / 3, faces.array)
+        } else {
+          const faces = new (vertices.count > 65535 ? Uint32Array : Uint16Array)(vertices.count)
+
+          for (let i = 0; i < faces.length; i++) {
+            faces[i] = i
+          }
+
+          builder.AddFacesToMesh(dracoObject, vertices.count, faces)
+        }
+
+        if (options.exportNormals) {
+          const normals = geometry.getAttribute('normal')
+
+          if (normals !== undefined) {
+            // @ts-ignore
+            builder.AddFloatAttributeToMesh(
+              dracoObject,
+              dracoEncoder.NORMAL,
+              normals.count,
+              normals.itemSize,
+              normals.array,
+            )
+          }
+        }
+
+        if (options.exportUvs) {
+          const uvs = geometry.getAttribute('uv')
+
+          if (uvs !== undefined) {
+            // @ts-ignore
+            builder.AddFloatAttributeToMesh(dracoObject, dracoEncoder.TEX_COORD, uvs.count, uvs.itemSize, uvs.array)
+          }
+        }
+
+        if (options.exportColor) {
+          const colors = geometry.getAttribute('color')
+
+          if (colors !== undefined) {
+            // @ts-ignore
+            builder.AddFloatAttributeToMesh(
+              dracoObject,
+              dracoEncoder.COLOR,
+              colors.count,
+              colors.itemSize,
+              colors.array,
+            )
+          }
+        }
+      } else if (object instanceof Points && object.isPoints) {
+        // @ts-ignore
+        builder = new dracoEncoder.PointCloudBuilder()
+        // @ts-ignore
+        dracoObject = new dracoEncoder.PointCloud()
+
+        const vertices = geometry.getAttribute('position')
+        builder.AddFloatAttribute(dracoObject, dracoEncoder.POSITION, vertices.count, vertices.itemSize, vertices.array)
+
+        if (options.exportColor) {
+          const colors = geometry.getAttribute('color')
+
+          if (colors !== undefined) {
+            builder.AddFloatAttribute(dracoObject, dracoEncoder.COLOR, colors.count, colors.itemSize, colors.array)
+          }
+        }
+      } else {
+        throw new Error('DRACOExporter: Unsupported object type.')
+      }
+
+      //Compress using draco encoder
+
+      const encodedData = new dracoEncoder.DracoInt8Array()
+
+      //Sets the desired encoding and decoding speed for the given options from 0 (slowest speed, but the best compression) to 10 (fastest, but the worst compression).
+
+      const encodeSpeed = options.encodeSpeed !== undefined ? options.encodeSpeed : 5
+      const decodeSpeed = options.decodeSpeed !== undefined ? options.decodeSpeed : 5
+
+      encoder.SetSpeedOptions(encodeSpeed, decodeSpeed)
+
+      // Sets the desired encoding method for a given geometry.
+
+      if (options.encoderMethod !== undefined) {
+        encoder.SetEncodingMethod(options.encoderMethod)
+      }
+
+      // Sets the quantization (number of bits used to represent) compression options for a named attribute.
+      // The attribute values will be quantized in a box defined by the maximum extent of the attribute values.
+      if (options.quantization !== undefined) {
+        for (let i = 0; i < 5; i++) {
+          if (options.quantization[i] !== undefined) {
+            encoder.SetAttributeQuantization(i, options.quantization[i])
+          }
+        }
+      }
+
+      let length
+
+      if (object instanceof Mesh && object.isMesh) {
+        length = encoder.EncodeMeshToDracoBuffer(dracoObject, encodedData)
+      } else {
+        // @ts-ignore
+        length = encoder.EncodePointCloudToDracoBuffer(dracoObject, true, encodedData)
+      }
+
+      dracoEncoder.destroy(dracoObject)
+
+      if (length === 0) {
+        throw new Error('THREE.DRACOExporter: Draco encoding failed.')
+      }
+
+      //Copy encoded data to buffer.
+      const outputData = new Int8Array(new ArrayBuffer(length))
+
+      for (let i = 0; i < length; i++) {
+        outputData[i] = encodedData.GetValue(i)
+      }
+
+      dracoEncoder.destroy(encodedData)
+      dracoEncoder.destroy(encoder)
+      dracoEncoder.destroy(builder)
+
+      return outputData
+    }
+  }
+
+  return DRACOExporter
+})()
+
+export { DRACOExporter }
diff --git a/src/exporters/DRACOExporter.ts b/src/exporters/DRACOExporter.ts
deleted file mode 100644
index 474d6097..00000000
--- a/src/exporters/DRACOExporter.ts
+++ /dev/null
@@ -1,207 +0,0 @@
-import type { EncoderModule } from 'draco3d'
-import { BufferGeometry, Mesh, Points } from 'three'
-
-/**
- * Export draco compressed files from threejs geometry objects.
- *
- * Draco files are compressed and usually are smaller than conventional 3D file formats.
- *
- * The exporter receives a options object containing
- *  - decodeSpeed, indicates how to tune the encoder regarding decode speed (0 gives better speed but worst quality)
- *  - encodeSpeed, indicates how to tune the encoder parameters (0 gives better speed but worst quality)
- *  - encoderMethod
- *  - quantization, indicates the presision of each type of data stored in the draco file in the order (POSITION, NORMAL, COLOR, TEX_COORD, GENERIC)
- *  - exportUvs
- *  - exportNormals
- */
-
-declare const DracoEncoderModule: () => EncoderModule
-
-class DRACOExporter {
-  // Encoder methods
-
-  public static MESH_EDGEBREAKER_ENCODING = 1
-  public static MESH_SEQUENTIAL_ENCODING = 0
-
-  // Geometry type
-
-  public static POINT_CLOUD = 0
-  public static TRIANGULAR_MESH = 1
-
-  // Attribute type
-  public static INVALID = -1
-  public static POSITION = 0
-  public static NORMAL = 1
-  public static COLOR = 2
-  public static TEX_COORD = 3
-  public static GENERIC = 4
-
-  public parse(
-    object: Mesh | Points,
-    options = {
-      decodeSpeed: 5,
-      encodeSpeed: 5,
-      encoderMethod: DRACOExporter.MESH_EDGEBREAKER_ENCODING,
-      quantization: [16, 8, 8, 8, 8],
-      exportUvs: true,
-      exportNormals: true,
-      exportColor: false,
-    },
-  ): Int8Array {
-    if (object instanceof BufferGeometry && object.isBufferGeometry) {
-      throw new Error('DRACOExporter: The first parameter of parse() is now an instance of Mesh or Points.')
-    }
-
-    if (DracoEncoderModule === undefined) {
-      throw new Error('THREE.DRACOExporter: required the draco_encoder to work.')
-    }
-
-    const geometry = object.geometry
-
-    const dracoEncoder = DracoEncoderModule()
-    const encoder = new dracoEncoder.Encoder()
-    let builder
-    let dracoObject
-
-    if (!geometry.isBufferGeometry) {
-      throw new Error('THREE.DRACOExporter.parse(geometry, options): geometry is not a THREE.BufferGeometry instance.')
-    }
-
-    if (object instanceof Mesh && object.isMesh) {
-      builder = new dracoEncoder.MeshBuilder()
-      dracoObject = new dracoEncoder.Mesh()
-
-      const vertices = geometry.getAttribute('position')
-      // @ts-ignore
-      builder.AddFloatAttributeToMesh(
-        dracoObject,
-        dracoEncoder.POSITION,
-        vertices.count,
-        vertices.itemSize,
-        vertices.array,
-      )
-
-      const faces = geometry.getIndex()
-
-      if (faces !== null) {
-        builder.AddFacesToMesh(dracoObject, faces.count / 3, faces.array as Uint16Array | Uint32Array)
-      } else {
-        const faces = new (vertices.count > 65535 ? Uint32Array : Uint16Array)(vertices.count)
-
-        for (let i = 0; i < faces.length; i++) {
-          faces[i] = i
-        }
-
-        builder.AddFacesToMesh(dracoObject, vertices.count, faces)
-      }
-
-      if (options.exportNormals) {
-        const normals = geometry.getAttribute('normal')
-
-        if (normals !== undefined) {
-          // @ts-ignore
-          builder.AddFloatAttributeToMesh(
-            dracoObject,
-            dracoEncoder.NORMAL,
-            normals.count,
-            normals.itemSize,
-            normals.array,
-          )
-        }
-      }
-
-      if (options.exportUvs) {
-        const uvs = geometry.getAttribute('uv')
-
-        if (uvs !== undefined) {
-          // @ts-ignore
-          builder.AddFloatAttributeToMesh(dracoObject, dracoEncoder.TEX_COORD, uvs.count, uvs.itemSize, uvs.array)
-        }
-      }
-
-      if (options.exportColor) {
-        const colors = geometry.getAttribute('color')
-
-        if (colors !== undefined) {
-          // @ts-ignore
-          builder.AddFloatAttributeToMesh(dracoObject, dracoEncoder.COLOR, colors.count, colors.itemSize, colors.array)
-        }
-      }
-    } else if (object instanceof Points && object.isPoints) {
-      // @ts-ignore
-      builder = new dracoEncoder.PointCloudBuilder()
-      // @ts-ignore
-      dracoObject = new dracoEncoder.PointCloud()
-
-      const vertices = geometry.getAttribute('position')
-      builder.AddFloatAttribute(dracoObject, dracoEncoder.POSITION, vertices.count, vertices.itemSize, vertices.array)
-
-      if (options.exportColor) {
-        const colors = geometry.getAttribute('color')
-
-        if (colors !== undefined) {
-          builder.AddFloatAttribute(dracoObject, dracoEncoder.COLOR, colors.count, colors.itemSize, colors.array)
-        }
-      }
-    } else {
-      throw new Error('DRACOExporter: Unsupported object type.')
-    }
-
-    //Compress using draco encoder
-
-    const encodedData = new dracoEncoder.DracoInt8Array()
-
-    //Sets the desired encoding and decoding speed for the given options from 0 (slowest speed, but the best compression) to 10 (fastest, but the worst compression).
-
-    const encodeSpeed = options.encodeSpeed !== undefined ? options.encodeSpeed : 5
-    const decodeSpeed = options.decodeSpeed !== undefined ? options.decodeSpeed : 5
-
-    encoder.SetSpeedOptions(encodeSpeed, decodeSpeed)
-
-    // Sets the desired encoding method for a given geometry.
-
-    if (options.encoderMethod !== undefined) {
-      encoder.SetEncodingMethod(options.encoderMethod)
-    }
-
-    // Sets the quantization (number of bits used to represent) compression options for a named attribute.
-    // The attribute values will be quantized in a box defined by the maximum extent of the attribute values.
-    if (options.quantization !== undefined) {
-      for (let i = 0; i < 5; i++) {
-        if (options.quantization[i] !== undefined) {
-          encoder.SetAttributeQuantization(i, options.quantization[i])
-        }
-      }
-    }
-
-    let length
-
-    if (object instanceof Mesh && object.isMesh) {
-      length = encoder.EncodeMeshToDracoBuffer(dracoObject, encodedData)
-    } else {
-      // @ts-ignore
-      length = encoder.EncodePointCloudToDracoBuffer(dracoObject, true, encodedData)
-    }
-
-    dracoEncoder.destroy(dracoObject)
-
-    if (length === 0) {
-      throw new Error('THREE.DRACOExporter: Draco encoding failed.')
-    }
-
-    //Copy encoded data to buffer.
-    const outputData = new Int8Array(new ArrayBuffer(length))
-
-    for (let i = 0; i < length; i++) {
-      outputData[i] = encodedData.GetValue(i)
-    }
-
-    dracoEncoder.destroy(encodedData)
-    dracoEncoder.destroy(encoder)
-    dracoEncoder.destroy(builder)
-
-    return outputData
-  }
-}
-
-export { DRACOExporter }
diff --git a/src/exporters/GLTFExporter.js b/src/exporters/GLTFExporter.js
index 143a42d5..b2c9736b 100644
--- a/src/exporters/GLTFExporter.js
+++ b/src/exporters/GLTFExporter.js
@@ -129,259 +129,263 @@ const KHR_mesh_quantization_ExtraAttrTypes = {
   TEXCOORD: ['byte', 'byte normalized', 'unsigned byte', 'short', 'short normalized', 'unsigned short'],
 }
 
-class GLTFExporter {
-  /**
-   * Static utility functions
-   */
-  static Utils = {
-    insertKeyframe: function (track, time) {
-      const tolerance = 0.001 // 1ms
-      const valueSize = track.getValueSize()
-
-      const times = new track.TimeBufferType(track.times.length + 1)
-      const values = new track.ValueBufferType(track.values.length + valueSize)
-      const interpolant = track.createInterpolant(new track.ValueBufferType(valueSize))
+const GLTFExporter = /* @__PURE__ */ (() => {
+  class GLTFExporter {
+    /**
+     * Static utility functions
+     */
+    static Utils = {
+      insertKeyframe: function (track, time) {
+        const tolerance = 0.001 // 1ms
+        const valueSize = track.getValueSize()
+
+        const times = new track.TimeBufferType(track.times.length + 1)
+        const values = new track.ValueBufferType(track.values.length + valueSize)
+        const interpolant = track.createInterpolant(new track.ValueBufferType(valueSize))
+
+        let index
+
+        if (track.times.length === 0) {
+          times[0] = time
+
+          for (let i = 0; i < valueSize; i++) {
+            values[i] = 0
+          }
 
-      let index
+          index = 0
+        } else if (time < track.times[0]) {
+          if (Math.abs(track.times[0] - time) < tolerance) return 0
 
-      if (track.times.length === 0) {
-        times[0] = time
+          times[0] = time
+          times.set(track.times, 1)
 
-        for (let i = 0; i < valueSize; i++) {
-          values[i] = 0
-        }
+          values.set(interpolant.evaluate(time), 0)
+          values.set(track.values, valueSize)
 
-        index = 0
-      } else if (time < track.times[0]) {
-        if (Math.abs(track.times[0] - time) < tolerance) return 0
+          index = 0
+        } else if (time > track.times[track.times.length - 1]) {
+          if (Math.abs(track.times[track.times.length - 1] - time) < tolerance) {
+            return track.times.length - 1
+          }
 
-        times[0] = time
-        times.set(track.times, 1)
+          times[times.length - 1] = time
+          times.set(track.times, 0)
 
-        values.set(interpolant.evaluate(time), 0)
-        values.set(track.values, valueSize)
+          values.set(track.values, 0)
+          values.set(interpolant.evaluate(time), track.values.length)
 
-        index = 0
-      } else if (time > track.times[track.times.length - 1]) {
-        if (Math.abs(track.times[track.times.length - 1] - time) < tolerance) {
-          return track.times.length - 1
-        }
+          index = times.length - 1
+        } else {
+          for (let i = 0; i < track.times.length; i++) {
+            if (Math.abs(track.times[i] - time) < tolerance) return i
 
-        times[times.length - 1] = time
-        times.set(track.times, 0)
+            if (track.times[i] < time && track.times[i + 1] > time) {
+              times.set(track.times.slice(0, i + 1), 0)
+              times[i + 1] = time
+              times.set(track.times.slice(i + 1), i + 2)
 
-        values.set(track.values, 0)
-        values.set(interpolant.evaluate(time), track.values.length)
+              values.set(track.values.slice(0, (i + 1) * valueSize), 0)
+              values.set(interpolant.evaluate(time), (i + 1) * valueSize)
+              values.set(track.values.slice((i + 1) * valueSize), (i + 2) * valueSize)
 
-        index = times.length - 1
-      } else {
-        for (let i = 0; i < track.times.length; i++) {
-          if (Math.abs(track.times[i] - time) < tolerance) return i
+              index = i + 1
 
-          if (track.times[i] < time && track.times[i + 1] > time) {
-            times.set(track.times.slice(0, i + 1), 0)
-            times[i + 1] = time
-            times.set(track.times.slice(i + 1), i + 2)
+              break
+            }
+          }
+        }
 
-            values.set(track.values.slice(0, (i + 1) * valueSize), 0)
-            values.set(interpolant.evaluate(time), (i + 1) * valueSize)
-            values.set(track.values.slice((i + 1) * valueSize), (i + 2) * valueSize)
+        track.times = times
+        track.values = values
 
-            index = i + 1
+        return index
+      },
 
-            break
+      mergeMorphTargetTracks: function (clip, root) {
+        const tracks = []
+        const mergedTracks = {}
+        const sourceTracks = clip.tracks
+
+        for (let i = 0; i < sourceTracks.length; ++i) {
+          let sourceTrack = sourceTracks[i]
+          const sourceTrackBinding = PropertyBinding.parseTrackName(sourceTrack.name)
+          const sourceTrackNode = PropertyBinding.findNode(root, sourceTrackBinding.nodeName)
+
+          if (
+            sourceTrackBinding.propertyName !== 'morphTargetInfluences' ||
+            sourceTrackBinding.propertyIndex === undefined
+          ) {
+            // Tracks that don't affect morph targets, or that affect all morph targets together, can be left as-is.
+            tracks.push(sourceTrack)
+            continue
           }
-        }
-      }
 
-      track.times = times
-      track.values = values
+          if (
+            sourceTrack.createInterpolant !== sourceTrack.InterpolantFactoryMethodDiscrete &&
+            sourceTrack.createInterpolant !== sourceTrack.InterpolantFactoryMethodLinear
+          ) {
+            if (sourceTrack.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline) {
+              // This should never happen, because glTF morph target animations
+              // affect all targets already.
+              throw new Error('THREE.GLTFExporter: Cannot merge tracks with glTF CUBICSPLINE interpolation.')
+            }
 
-      return index
-    },
-
-    mergeMorphTargetTracks: function (clip, root) {
-      const tracks = []
-      const mergedTracks = {}
-      const sourceTracks = clip.tracks
-
-      for (let i = 0; i < sourceTracks.length; ++i) {
-        let sourceTrack = sourceTracks[i]
-        const sourceTrackBinding = PropertyBinding.parseTrackName(sourceTrack.name)
-        const sourceTrackNode = PropertyBinding.findNode(root, sourceTrackBinding.nodeName)
-
-        if (
-          sourceTrackBinding.propertyName !== 'morphTargetInfluences' ||
-          sourceTrackBinding.propertyIndex === undefined
-        ) {
-          // Tracks that don't affect morph targets, or that affect all morph targets together, can be left as-is.
-          tracks.push(sourceTrack)
-          continue
-        }
+            console.warn('THREE.GLTFExporter: Morph target interpolation mode not yet supported. Using LINEAR instead.')
 
-        if (
-          sourceTrack.createInterpolant !== sourceTrack.InterpolantFactoryMethodDiscrete &&
-          sourceTrack.createInterpolant !== sourceTrack.InterpolantFactoryMethodLinear
-        ) {
-          if (sourceTrack.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline) {
-            // This should never happen, because glTF morph target animations
-            // affect all targets already.
-            throw new Error('THREE.GLTFExporter: Cannot merge tracks with glTF CUBICSPLINE interpolation.')
+            sourceTrack = sourceTrack.clone()
+            sourceTrack.setInterpolation(InterpolateLinear)
           }
 
-          console.warn('THREE.GLTFExporter: Morph target interpolation mode not yet supported. Using LINEAR instead.')
-
-          sourceTrack = sourceTrack.clone()
-          sourceTrack.setInterpolation(InterpolateLinear)
-        }
+          const targetCount = sourceTrackNode.morphTargetInfluences.length
+          const targetIndex = sourceTrackNode.morphTargetDictionary[sourceTrackBinding.propertyIndex]
 
-        const targetCount = sourceTrackNode.morphTargetInfluences.length
-        const targetIndex = sourceTrackNode.morphTargetDictionary[sourceTrackBinding.propertyIndex]
+          if (targetIndex === undefined) {
+            throw new Error('THREE.GLTFExporter: Morph target name not found: ' + sourceTrackBinding.propertyIndex)
+          }
 
-        if (targetIndex === undefined) {
-          throw new Error('THREE.GLTFExporter: Morph target name not found: ' + sourceTrackBinding.propertyIndex)
-        }
+          let mergedTrack
 
-        let mergedTrack
+          // If this is the first time we've seen this object, create a new
+          // track to store merged keyframe data for each morph target.
+          if (mergedTracks[sourceTrackNode.uuid] === undefined) {
+            mergedTrack = sourceTrack.clone()
 
-        // If this is the first time we've seen this object, create a new
-        // track to store merged keyframe data for each morph target.
-        if (mergedTracks[sourceTrackNode.uuid] === undefined) {
-          mergedTrack = sourceTrack.clone()
+            const values = new mergedTrack.ValueBufferType(targetCount * mergedTrack.times.length)
 
-          const values = new mergedTrack.ValueBufferType(targetCount * mergedTrack.times.length)
+            for (let j = 0; j < mergedTrack.times.length; j++) {
+              values[j * targetCount + targetIndex] = mergedTrack.values[j]
+            }
 
-          for (let j = 0; j < mergedTrack.times.length; j++) {
-            values[j * targetCount + targetIndex] = mergedTrack.values[j]
-          }
+            // We need to take into consideration the intended target node
+            // of our original un-merged morphTarget animation.
+            mergedTrack.name = (sourceTrackBinding.nodeName || '') + '.morphTargetInfluences'
+            mergedTrack.values = values
 
-          // We need to take into consideration the intended target node
-          // of our original un-merged morphTarget animation.
-          mergedTrack.name = (sourceTrackBinding.nodeName || '') + '.morphTargetInfluences'
-          mergedTrack.values = values
+            mergedTracks[sourceTrackNode.uuid] = mergedTrack
+            tracks.push(mergedTrack)
 
-          mergedTracks[sourceTrackNode.uuid] = mergedTrack
-          tracks.push(mergedTrack)
+            continue
+          }
 
-          continue
-        }
+          const sourceInterpolant = sourceTrack.createInterpolant(new sourceTrack.ValueBufferType(1))
 
-        const sourceInterpolant = sourceTrack.createInterpolant(new sourceTrack.ValueBufferType(1))
+          mergedTrack = mergedTracks[sourceTrackNode.uuid]
 
-        mergedTrack = mergedTracks[sourceTrackNode.uuid]
+          // For every existing keyframe of the merged track, write a (possibly
+          // interpolated) value from the source track.
+          for (let j = 0; j < mergedTrack.times.length; j++) {
+            mergedTrack.values[j * targetCount + targetIndex] = sourceInterpolant.evaluate(mergedTrack.times[j])
+          }
 
-        // For every existing keyframe of the merged track, write a (possibly
-        // interpolated) value from the source track.
-        for (let j = 0; j < mergedTrack.times.length; j++) {
-          mergedTrack.values[j * targetCount + targetIndex] = sourceInterpolant.evaluate(mergedTrack.times[j])
+          // For every existing keyframe of the source track, write a (possibly
+          // new) keyframe to the merged track. Values from the previous loop may
+          // be written again, but keyframes are de-duplicated.
+          for (let j = 0; j < sourceTrack.times.length; j++) {
+            const keyframeIndex = this.insertKeyframe(mergedTrack, sourceTrack.times[j])
+            mergedTrack.values[keyframeIndex * targetCount + targetIndex] = sourceTrack.values[j]
+          }
         }
 
-        // For every existing keyframe of the source track, write a (possibly
-        // new) keyframe to the merged track. Values from the previous loop may
-        // be written again, but keyframes are de-duplicated.
-        for (let j = 0; j < sourceTrack.times.length; j++) {
-          const keyframeIndex = this.insertKeyframe(mergedTrack, sourceTrack.times[j])
-          mergedTrack.values[keyframeIndex * targetCount + targetIndex] = sourceTrack.values[j]
-        }
-      }
+        clip.tracks = tracks
 
-      clip.tracks = tracks
+        return clip
+      },
+    }
 
-      return clip
-    },
-  }
+    constructor() {
+      this.pluginCallbacks = []
 
-  constructor() {
-    this.pluginCallbacks = []
+      this.register(function (writer) {
+        return new GLTFLightExtension(writer)
+      })
 
-    this.register(function (writer) {
-      return new GLTFLightExtension(writer)
-    })
+      this.register(function (writer) {
+        return new GLTFMaterialsUnlitExtension(writer)
+      })
 
-    this.register(function (writer) {
-      return new GLTFMaterialsUnlitExtension(writer)
-    })
+      this.register(function (writer) {
+        return new GLTFMaterialsTransmissionExtension(writer)
+      })
 
-    this.register(function (writer) {
-      return new GLTFMaterialsTransmissionExtension(writer)
-    })
+      this.register(function (writer) {
+        return new GLTFMaterialsVolumeExtension(writer)
+      })
 
-    this.register(function (writer) {
-      return new GLTFMaterialsVolumeExtension(writer)
-    })
+      this.register(function (writer) {
+        return new GLTFMaterialsIorExtension(writer)
+      })
 
-    this.register(function (writer) {
-      return new GLTFMaterialsIorExtension(writer)
-    })
+      this.register(function (writer) {
+        return new GLTFMaterialsSpecularExtension(writer)
+      })
 
-    this.register(function (writer) {
-      return new GLTFMaterialsSpecularExtension(writer)
-    })
+      this.register(function (writer) {
+        return new GLTFMaterialsClearcoatExtension(writer)
+      })
 
-    this.register(function (writer) {
-      return new GLTFMaterialsClearcoatExtension(writer)
-    })
+      this.register(function (writer) {
+        return new GLTFMaterialsIridescenceExtension(writer)
+      })
 
-    this.register(function (writer) {
-      return new GLTFMaterialsIridescenceExtension(writer)
-    })
+      this.register(function (writer) {
+        return new GLTFMaterialsSheenExtension(writer)
+      })
 
-    this.register(function (writer) {
-      return new GLTFMaterialsSheenExtension(writer)
-    })
+      this.register(function (writer) {
+        return new GLTFMaterialsAnisotropyExtension(writer)
+      })
 
-    this.register(function (writer) {
-      return new GLTFMaterialsAnisotropyExtension(writer)
-    })
+      this.register(function (writer) {
+        return new GLTFMaterialsEmissiveStrengthExtension(writer)
+      })
+    }
 
-    this.register(function (writer) {
-      return new GLTFMaterialsEmissiveStrengthExtension(writer)
-    })
-  }
+    register(callback) {
+      if (this.pluginCallbacks.indexOf(callback) === -1) {
+        this.pluginCallbacks.push(callback)
+      }
 
-  register(callback) {
-    if (this.pluginCallbacks.indexOf(callback) === -1) {
-      this.pluginCallbacks.push(callback)
+      return this
     }
 
-    return this
-  }
+    unregister(callback) {
+      if (this.pluginCallbacks.indexOf(callback) !== -1) {
+        this.pluginCallbacks.splice(this.pluginCallbacks.indexOf(callback), 1)
+      }
 
-  unregister(callback) {
-    if (this.pluginCallbacks.indexOf(callback) !== -1) {
-      this.pluginCallbacks.splice(this.pluginCallbacks.indexOf(callback), 1)
+      return this
     }
 
-    return this
-  }
+    /**
+     * Parse scenes and generate GLTF output
+     * @param  {Scene or [THREE.Scenes]} input   Scene or Array of THREE.Scenes
+     * @param  {Function} onDone  Callback on completed
+     * @param  {Function} onError  Callback on errors
+     * @param  {Object} options options
+     */
+    parse(input, onDone, onError, options) {
+      const writer = new GLTFWriter()
+      const plugins = []
 
-  /**
-   * Parse scenes and generate GLTF output
-   * @param  {Scene or [THREE.Scenes]} input   Scene or Array of THREE.Scenes
-   * @param  {Function} onDone  Callback on completed
-   * @param  {Function} onError  Callback on errors
-   * @param  {Object} options options
-   */
-  parse(input, onDone, onError, options) {
-    const writer = new GLTFWriter()
-    const plugins = []
+      for (let i = 0, il = this.pluginCallbacks.length; i < il; i++) {
+        plugins.push(this.pluginCallbacks[i](writer))
+      }
 
-    for (let i = 0, il = this.pluginCallbacks.length; i < il; i++) {
-      plugins.push(this.pluginCallbacks[i](writer))
+      writer.setPlugins(plugins)
+      writer.write(input, onDone, options).catch(onError)
     }
 
-    writer.setPlugins(plugins)
-    writer.write(input, onDone, options).catch(onError)
-  }
-
-  parseAsync(input, options) {
-    const scope = this
+    parseAsync(input, options) {
+      const scope = this
 
-    return new Promise(function (resolve, reject) {
-      scope.parse(input, resolve, reject, options)
-    })
+      return new Promise(function (resolve, reject) {
+        scope.parse(input, resolve, reject, options)
+      })
+    }
   }
-}
+
+  return GLTFExporter
+})()
 
 //------------------------------------------------------------------------------
 // Constants
@@ -441,7 +445,7 @@ const PATH_PROPERTIES = {
   morphTargetInfluences: 'weights',
 }
 
-const DEFAULT_SPECULAR_COLOR = new Color()
+const DEFAULT_SPECULAR_COLOR = /* @__PURE__ */ new Color()
 
 // GLB constants
 // https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#glb-file-format-specification
diff --git a/src/geometries/LightningStrike.js b/src/geometries/LightningStrike.js
index 36cb6bc0..fe434a24 100644
--- a/src/geometries/LightningStrike.js
+++ b/src/geometries/LightningStrike.js
@@ -109,811 +109,821 @@ import { SimplexNoise } from '../math/SimplexNoise'
  *
  */
 
-class LightningStrike extends BufferGeometry {
-  // Ray states
-  static RAY_INITIALIZED = 0
-  static RAY_UNBORN = 1
-  static RAY_PROPAGATING = 2
-  static RAY_STEADY = 3
-  static RAY_VANISHING = 4
-  static RAY_EXTINGUISHED = 5
+const LightningStrike = /* @__PURE__ */ (() => {
+  class LightningStrike extends BufferGeometry {
+    // Ray states
+    static RAY_INITIALIZED = 0
+    static RAY_UNBORN = 1
+    static RAY_PROPAGATING = 2
+    static RAY_STEADY = 3
+    static RAY_VANISHING = 4
+    static RAY_EXTINGUISHED = 5
 
-  static COS30DEG = Math.cos((30 * Math.PI) / 180)
-  static SIN30DEG = Math.sin((30 * Math.PI) / 180)
+    static COS30DEG = Math.cos((30 * Math.PI) / 180)
+    static SIN30DEG = Math.sin((30 * Math.PI) / 180)
 
-  constructor(rayParameters = {}) {
-    super()
+    constructor(rayParameters = {}) {
+      super()
 
-    this.isLightningStrike = true
+      this.isLightningStrike = true
 
-    this.type = 'LightningStrike'
+      this.type = 'LightningStrike'
 
-    // Set parameters, and set undefined parameters to default values
-    this.init(LightningStrike.copyParameters(rayParameters, rayParameters))
+      // Set parameters, and set undefined parameters to default values
+      this.init(LightningStrike.copyParameters(rayParameters, rayParameters))
 
-    // Creates and populates the mesh
-    this.createMesh()
-  }
-
-  static createRandomGenerator() {
-    const numSeeds = 2053
-    const seeds = []
-
-    for (let i = 0; i < numSeeds; i++) {
-      seeds.push(Math.random())
+      // Creates and populates the mesh
+      this.createMesh()
     }
 
-    const generator = {
-      currentSeed: 0,
+    static createRandomGenerator() {
+      const numSeeds = 2053
+      const seeds = []
 
-      random: function () {
-        const value = seeds[generator.currentSeed]
+      for (let i = 0; i < numSeeds; i++) {
+        seeds.push(Math.random())
+      }
 
-        generator.currentSeed = (generator.currentSeed + 1) % numSeeds
+      const generator = {
+        currentSeed: 0,
 
-        return value
-      },
+        random: function () {
+          const value = seeds[generator.currentSeed]
 
-      getSeed: function () {
-        return generator.currentSeed / numSeeds
-      },
+          generator.currentSeed = (generator.currentSeed + 1) % numSeeds
 
-      setSeed: function (seed) {
-        generator.currentSeed = Math.floor(seed * numSeeds) % numSeeds
-      },
-    }
+          return value
+        },
 
-    return generator
-  }
+        getSeed: function () {
+          return generator.currentSeed / numSeeds
+        },
 
-  static copyParameters(dest = {}, source = {}) {
-    const vecCopy = function (v) {
-      if (source === dest) {
-        return v
-      } else {
-        return v.clone()
+        setSeed: function (seed) {
+          generator.currentSeed = Math.floor(seed * numSeeds) % numSeeds
+        },
       }
-    }
 
-    ;(dest.sourceOffset = source.sourceOffset !== undefined ? vecCopy(source.sourceOffset) : new Vector3(0, 100, 0)),
-      (dest.destOffset = source.destOffset !== undefined ? vecCopy(source.destOffset) : new Vector3(0, 0, 0)),
-      (dest.timeScale = source.timeScale !== undefined ? source.timeScale : 1),
-      (dest.roughness = source.roughness !== undefined ? source.roughness : 0.9),
-      (dest.straightness = source.straightness !== undefined ? source.straightness : 0.7),
-      (dest.up0 = source.up0 !== undefined ? vecCopy(source.up0) : new Vector3(0, 0, 1))
-    ;(dest.up1 = source.up1 !== undefined ? vecCopy(source.up1) : new Vector3(0, 0, 1)),
-      (dest.radius0 = source.radius0 !== undefined ? source.radius0 : 1),
-      (dest.radius1 = source.radius1 !== undefined ? source.radius1 : 1),
-      (dest.radius0Factor = source.radius0Factor !== undefined ? source.radius0Factor : 0.5),
-      (dest.radius1Factor = source.radius1Factor !== undefined ? source.radius1Factor : 0.2),
-      (dest.minRadius = source.minRadius !== undefined ? source.minRadius : 0.2),
-      // These parameters should not be changed after lightning creation. They can be changed but the ray will change its form abruptly:
-
-      (dest.isEternal =
-        source.isEternal !== undefined
-          ? source.isEternal
-          : source.birthTime === undefined || source.deathTime === undefined),
-      (dest.birthTime = source.birthTime),
-      (dest.deathTime = source.deathTime),
-      (dest.propagationTimeFactor = source.propagationTimeFactor !== undefined ? source.propagationTimeFactor : 0.1),
-      (dest.vanishingTimeFactor = source.vanishingTimeFactor !== undefined ? source.vanishingTimeFactor : 0.9),
-      (dest.subrayPeriod = source.subrayPeriod !== undefined ? source.subrayPeriod : 4),
-      (dest.subrayDutyCycle = source.subrayDutyCycle !== undefined ? source.subrayDutyCycle : 0.6)
-
-    // These parameters cannot change after lightning creation:
-
-    dest.maxIterations = source.maxIterations !== undefined ? source.maxIterations : 9
-    dest.isStatic = source.isStatic !== undefined ? source.isStatic : false
-    dest.ramification = source.ramification !== undefined ? source.ramification : 5
-    dest.maxSubrayRecursion = source.maxSubrayRecursion !== undefined ? source.maxSubrayRecursion : 3
-    dest.recursionProbability = source.recursionProbability !== undefined ? source.recursionProbability : 0.6
-    dest.generateUVs = source.generateUVs !== undefined ? source.generateUVs : false
-    ;(dest.randomGenerator = source.randomGenerator),
-      (dest.noiseSeed = source.noiseSeed),
-      (dest.onDecideSubrayCreation = source.onDecideSubrayCreation),
-      (dest.onSubrayCreation = source.onSubrayCreation)
-
-    return dest
-  }
+      return generator
+    }
 
-  update(time) {
-    if (this.isStatic) return
+    static copyParameters(dest = {}, source = {}) {
+      const vecCopy = function (v) {
+        if (source === dest) {
+          return v
+        } else {
+          return v.clone()
+        }
+      }
 
-    if (
-      this.rayParameters.isEternal ||
-      (this.rayParameters.birthTime <= time && time <= this.rayParameters.deathTime)
-    ) {
-      this.updateMesh(time)
+      ;(dest.sourceOffset = source.sourceOffset !== undefined ? vecCopy(source.sourceOffset) : new Vector3(0, 100, 0)),
+        (dest.destOffset = source.destOffset !== undefined ? vecCopy(source.destOffset) : new Vector3(0, 0, 0)),
+        (dest.timeScale = source.timeScale !== undefined ? source.timeScale : 1),
+        (dest.roughness = source.roughness !== undefined ? source.roughness : 0.9),
+        (dest.straightness = source.straightness !== undefined ? source.straightness : 0.7),
+        (dest.up0 = source.up0 !== undefined ? vecCopy(source.up0) : new Vector3(0, 0, 1))
+      ;(dest.up1 = source.up1 !== undefined ? vecCopy(source.up1) : new Vector3(0, 0, 1)),
+        (dest.radius0 = source.radius0 !== undefined ? source.radius0 : 1),
+        (dest.radius1 = source.radius1 !== undefined ? source.radius1 : 1),
+        (dest.radius0Factor = source.radius0Factor !== undefined ? source.radius0Factor : 0.5),
+        (dest.radius1Factor = source.radius1Factor !== undefined ? source.radius1Factor : 0.2),
+        (dest.minRadius = source.minRadius !== undefined ? source.minRadius : 0.2),
+        // These parameters should not be changed after lightning creation. They can be changed but the ray will change its form abruptly:
+
+        (dest.isEternal =
+          source.isEternal !== undefined
+            ? source.isEternal
+            : source.birthTime === undefined || source.deathTime === undefined),
+        (dest.birthTime = source.birthTime),
+        (dest.deathTime = source.deathTime),
+        (dest.propagationTimeFactor = source.propagationTimeFactor !== undefined ? source.propagationTimeFactor : 0.1),
+        (dest.vanishingTimeFactor = source.vanishingTimeFactor !== undefined ? source.vanishingTimeFactor : 0.9),
+        (dest.subrayPeriod = source.subrayPeriod !== undefined ? source.subrayPeriod : 4),
+        (dest.subrayDutyCycle = source.subrayDutyCycle !== undefined ? source.subrayDutyCycle : 0.6)
+
+      // These parameters cannot change after lightning creation:
+
+      dest.maxIterations = source.maxIterations !== undefined ? source.maxIterations : 9
+      dest.isStatic = source.isStatic !== undefined ? source.isStatic : false
+      dest.ramification = source.ramification !== undefined ? source.ramification : 5
+      dest.maxSubrayRecursion = source.maxSubrayRecursion !== undefined ? source.maxSubrayRecursion : 3
+      dest.recursionProbability = source.recursionProbability !== undefined ? source.recursionProbability : 0.6
+      dest.generateUVs = source.generateUVs !== undefined ? source.generateUVs : false
+      ;(dest.randomGenerator = source.randomGenerator),
+        (dest.noiseSeed = source.noiseSeed),
+        (dest.onDecideSubrayCreation = source.onDecideSubrayCreation),
+        (dest.onSubrayCreation = source.onSubrayCreation)
+
+      return dest
+    }
 
-      if (time < this.subrays[0].endPropagationTime) {
-        this.state = LightningStrike.RAY_PROPAGATING
-      } else if (time > this.subrays[0].beginVanishingTime) {
-        this.state = LightningStrike.RAY_VANISHING
-      } else {
-        this.state = LightningStrike.RAY_STEADY
-      }
+    update(time) {
+      if (this.isStatic) return
 
-      this.visible = true
-    } else {
-      this.visible = false
+      if (
+        this.rayParameters.isEternal ||
+        (this.rayParameters.birthTime <= time && time <= this.rayParameters.deathTime)
+      ) {
+        this.updateMesh(time)
+
+        if (time < this.subrays[0].endPropagationTime) {
+          this.state = LightningStrike.RAY_PROPAGATING
+        } else if (time > this.subrays[0].beginVanishingTime) {
+          this.state = LightningStrike.RAY_VANISHING
+        } else {
+          this.state = LightningStrike.RAY_STEADY
+        }
 
-      if (time < this.rayParameters.birthTime) {
-        this.state = LightningStrike.RAY_UNBORN
+        this.visible = true
       } else {
-        this.state = LightningStrike.RAY_EXTINGUISHED
+        this.visible = false
+
+        if (time < this.rayParameters.birthTime) {
+          this.state = LightningStrike.RAY_UNBORN
+        } else {
+          this.state = LightningStrike.RAY_EXTINGUISHED
+        }
       }
     }
-  }
 
-  init(rayParameters) {
-    // Init all the state from the parameters
-
-    this.rayParameters = rayParameters
-
-    // These parameters cannot change after lightning creation:
-
-    this.maxIterations = rayParameters.maxIterations !== undefined ? Math.floor(rayParameters.maxIterations) : 9
-    rayParameters.maxIterations = this.maxIterations
-    this.isStatic = rayParameters.isStatic !== undefined ? rayParameters.isStatic : false
-    rayParameters.isStatic = this.isStatic
-    this.ramification = rayParameters.ramification !== undefined ? Math.floor(rayParameters.ramification) : 5
-    rayParameters.ramification = this.ramification
-    this.maxSubrayRecursion =
-      rayParameters.maxSubrayRecursion !== undefined ? Math.floor(rayParameters.maxSubrayRecursion) : 3
-    rayParameters.maxSubrayRecursion = this.maxSubrayRecursion
-    this.recursionProbability =
-      rayParameters.recursionProbability !== undefined ? rayParameters.recursionProbability : 0.6
-    rayParameters.recursionProbability = this.recursionProbability
-    this.generateUVs = rayParameters.generateUVs !== undefined ? rayParameters.generateUVs : false
-    rayParameters.generateUVs = this.generateUVs
-
-    // Random generator
-    if (rayParameters.randomGenerator !== undefined) {
-      this.randomGenerator = rayParameters.randomGenerator
-      this.seedGenerator = rayParameters.randomGenerator
-
-      if (rayParameters.noiseSeed !== undefined) {
-        this.seedGenerator.setSeed(rayParameters.noiseSeed)
+    init(rayParameters) {
+      // Init all the state from the parameters
+
+      this.rayParameters = rayParameters
+
+      // These parameters cannot change after lightning creation:
+
+      this.maxIterations = rayParameters.maxIterations !== undefined ? Math.floor(rayParameters.maxIterations) : 9
+      rayParameters.maxIterations = this.maxIterations
+      this.isStatic = rayParameters.isStatic !== undefined ? rayParameters.isStatic : false
+      rayParameters.isStatic = this.isStatic
+      this.ramification = rayParameters.ramification !== undefined ? Math.floor(rayParameters.ramification) : 5
+      rayParameters.ramification = this.ramification
+      this.maxSubrayRecursion =
+        rayParameters.maxSubrayRecursion !== undefined ? Math.floor(rayParameters.maxSubrayRecursion) : 3
+      rayParameters.maxSubrayRecursion = this.maxSubrayRecursion
+      this.recursionProbability =
+        rayParameters.recursionProbability !== undefined ? rayParameters.recursionProbability : 0.6
+      rayParameters.recursionProbability = this.recursionProbability
+      this.generateUVs = rayParameters.generateUVs !== undefined ? rayParameters.generateUVs : false
+      rayParameters.generateUVs = this.generateUVs
+
+      // Random generator
+      if (rayParameters.randomGenerator !== undefined) {
+        this.randomGenerator = rayParameters.randomGenerator
+        this.seedGenerator = rayParameters.randomGenerator
+
+        if (rayParameters.noiseSeed !== undefined) {
+          this.seedGenerator.setSeed(rayParameters.noiseSeed)
+        }
+      } else {
+        this.randomGenerator = LightningStrike.createRandomGenerator()
+        this.seedGenerator = Math
       }
-    } else {
-      this.randomGenerator = LightningStrike.createRandomGenerator()
-      this.seedGenerator = Math
-    }
 
-    // Ray creation callbacks
-    if (rayParameters.onDecideSubrayCreation !== undefined) {
-      this.onDecideSubrayCreation = rayParameters.onDecideSubrayCreation
-    } else {
-      this.createDefaultSubrayCreationCallbacks()
+      // Ray creation callbacks
+      if (rayParameters.onDecideSubrayCreation !== undefined) {
+        this.onDecideSubrayCreation = rayParameters.onDecideSubrayCreation
+      } else {
+        this.createDefaultSubrayCreationCallbacks()
 
-      if (rayParameters.onSubrayCreation !== undefined) {
-        this.onSubrayCreation = rayParameters.onSubrayCreation
+        if (rayParameters.onSubrayCreation !== undefined) {
+          this.onSubrayCreation = rayParameters.onSubrayCreation
+        }
       }
-    }
 
-    // Internal state
+      // Internal state
 
-    this.state = LightningStrike.RAY_INITIALIZED
+      this.state = LightningStrike.RAY_INITIALIZED
 
-    this.maxSubrays = Math.ceil(1 + Math.pow(this.ramification, Math.max(0, this.maxSubrayRecursion - 1)))
-    rayParameters.maxSubrays = this.maxSubrays
+      this.maxSubrays = Math.ceil(1 + Math.pow(this.ramification, Math.max(0, this.maxSubrayRecursion - 1)))
+      rayParameters.maxSubrays = this.maxSubrays
 
-    this.maxRaySegments = 2 * (1 << this.maxIterations)
+      this.maxRaySegments = 2 * (1 << this.maxIterations)
 
-    this.subrays = []
+      this.subrays = []
 
-    for (let i = 0; i < this.maxSubrays; i++) {
-      this.subrays.push(this.createSubray())
-    }
+      for (let i = 0; i < this.maxSubrays; i++) {
+        this.subrays.push(this.createSubray())
+      }
+
+      this.raySegments = []
 
-    this.raySegments = []
+      for (let i = 0; i < this.maxRaySegments; i++) {
+        this.raySegments.push(this.createSegment())
+      }
 
-    for (let i = 0; i < this.maxRaySegments; i++) {
-      this.raySegments.push(this.createSegment())
+      this.time = 0
+      this.timeFraction = 0
+      this.currentSegmentCallback = null
+      this.currentCreateTriangleVertices = this.generateUVs
+        ? this.createTriangleVerticesWithUVs
+        : this.createTriangleVerticesWithoutUVs
+      this.numSubrays = 0
+      this.currentSubray = null
+      this.currentSegmentIndex = 0
+      this.isInitialSegment = false
+      this.subrayProbability = 0
+
+      this.currentVertex = 0
+      this.currentIndex = 0
+      this.currentCoordinate = 0
+      this.currentUVCoordinate = 0
+      this.vertices = null
+      this.uvs = null
+      this.indices = null
+      this.positionAttribute = null
+      this.uvsAttribute = null
+
+      this.simplexX = new SimplexNoise(this.seedGenerator)
+      this.simplexY = new SimplexNoise(this.seedGenerator)
+      this.simplexZ = new SimplexNoise(this.seedGenerator)
+
+      // Temp vectors
+      this.forwards = new Vector3()
+      this.forwardsFill = new Vector3()
+      this.side = new Vector3()
+      this.down = new Vector3()
+      this.middlePos = new Vector3()
+      this.middleLinPos = new Vector3()
+      this.newPos = new Vector3()
+      this.vPos = new Vector3()
+      this.cross1 = new Vector3()
     }
 
-    this.time = 0
-    this.timeFraction = 0
-    this.currentSegmentCallback = null
-    this.currentCreateTriangleVertices = this.generateUVs
-      ? this.createTriangleVerticesWithUVs
-      : this.createTriangleVerticesWithoutUVs
-    this.numSubrays = 0
-    this.currentSubray = null
-    this.currentSegmentIndex = 0
-    this.isInitialSegment = false
-    this.subrayProbability = 0
-
-    this.currentVertex = 0
-    this.currentIndex = 0
-    this.currentCoordinate = 0
-    this.currentUVCoordinate = 0
-    this.vertices = null
-    this.uvs = null
-    this.indices = null
-    this.positionAttribute = null
-    this.uvsAttribute = null
-
-    this.simplexX = new SimplexNoise(this.seedGenerator)
-    this.simplexY = new SimplexNoise(this.seedGenerator)
-    this.simplexZ = new SimplexNoise(this.seedGenerator)
-
-    // Temp vectors
-    this.forwards = new Vector3()
-    this.forwardsFill = new Vector3()
-    this.side = new Vector3()
-    this.down = new Vector3()
-    this.middlePos = new Vector3()
-    this.middleLinPos = new Vector3()
-    this.newPos = new Vector3()
-    this.vPos = new Vector3()
-    this.cross1 = new Vector3()
-  }
+    createMesh() {
+      const maxDrawableSegmentsPerSubRay = 1 << this.maxIterations
 
-  createMesh() {
-    const maxDrawableSegmentsPerSubRay = 1 << this.maxIterations
+      const maxVerts = 3 * (maxDrawableSegmentsPerSubRay + 1) * this.maxSubrays
+      const maxIndices = 18 * maxDrawableSegmentsPerSubRay * this.maxSubrays
 
-    const maxVerts = 3 * (maxDrawableSegmentsPerSubRay + 1) * this.maxSubrays
-    const maxIndices = 18 * maxDrawableSegmentsPerSubRay * this.maxSubrays
+      this.vertices = new Float32Array(maxVerts * 3)
+      this.indices = new Uint32Array(maxIndices)
 
-    this.vertices = new Float32Array(maxVerts * 3)
-    this.indices = new Uint32Array(maxIndices)
+      if (this.generateUVs) {
+        this.uvs = new Float32Array(maxVerts * 2)
+      }
 
-    if (this.generateUVs) {
-      this.uvs = new Float32Array(maxVerts * 2)
-    }
+      // Populate the mesh
+      this.fillMesh(0)
 
-    // Populate the mesh
-    this.fillMesh(0)
+      this.setIndex(new Uint32BufferAttribute(this.indices, 1))
 
-    this.setIndex(new Uint32BufferAttribute(this.indices, 1))
+      this.positionAttribute = new Float32BufferAttribute(this.vertices, 3)
+      this.setAttribute('position', this.positionAttribute)
 
-    this.positionAttribute = new Float32BufferAttribute(this.vertices, 3)
-    this.setAttribute('position', this.positionAttribute)
+      if (this.generateUVs) {
+        this.uvsAttribute = new Float32BufferAttribute(new Float32Array(this.uvs), 2)
+        this.setAttribute('uv', this.uvsAttribute)
+      }
 
-    if (this.generateUVs) {
-      this.uvsAttribute = new Float32BufferAttribute(new Float32Array(this.uvs), 2)
-      this.setAttribute('uv', this.uvsAttribute)
-    }
+      if (!this.isStatic) {
+        this.index.usage = DynamicDrawUsage
+        this.positionAttribute.usage = DynamicDrawUsage
 
-    if (!this.isStatic) {
-      this.index.usage = DynamicDrawUsage
-      this.positionAttribute.usage = DynamicDrawUsage
+        if (this.generateUVs) {
+          this.uvsAttribute.usage = DynamicDrawUsage
+        }
+      }
+
+      // Store buffers for later modification
+      this.vertices = this.positionAttribute.array
+      this.indices = this.index.array
 
       if (this.generateUVs) {
-        this.uvsAttribute.usage = DynamicDrawUsage
+        this.uvs = this.uvsAttribute.array
       }
     }
 
-    // Store buffers for later modification
-    this.vertices = this.positionAttribute.array
-    this.indices = this.index.array
+    updateMesh(time) {
+      this.fillMesh(time)
 
-    if (this.generateUVs) {
-      this.uvs = this.uvsAttribute.array
-    }
-  }
+      this.drawRange.count = this.currentIndex
 
-  updateMesh(time) {
-    this.fillMesh(time)
+      this.index.needsUpdate = true
 
-    this.drawRange.count = this.currentIndex
+      this.positionAttribute.needsUpdate = true
 
-    this.index.needsUpdate = true
+      if (this.generateUVs) {
+        this.uvsAttribute.needsUpdate = true
+      }
+    }
 
-    this.positionAttribute.needsUpdate = true
+    fillMesh(time) {
+      const scope = this
 
-    if (this.generateUVs) {
-      this.uvsAttribute.needsUpdate = true
-    }
-  }
+      this.currentVertex = 0
+      this.currentIndex = 0
+      this.currentCoordinate = 0
+      this.currentUVCoordinate = 0
 
-  fillMesh(time) {
-    const scope = this
+      this.fractalRay(time, function fillVertices(segment) {
+        const subray = scope.currentSubray
 
-    this.currentVertex = 0
-    this.currentIndex = 0
-    this.currentCoordinate = 0
-    this.currentUVCoordinate = 0
+        if (time < subray.birthTime) {
+          //&& ( ! this.rayParameters.isEternal || scope.currentSubray.recursion > 0 ) ) {
 
-    this.fractalRay(time, function fillVertices(segment) {
-      const subray = scope.currentSubray
+          return
+        } else if (this.rayParameters.isEternal && scope.currentSubray.recursion == 0) {
+          // Eternal rays don't propagate nor vanish, but its subrays do
 
-      if (time < subray.birthTime) {
-        //&& ( ! this.rayParameters.isEternal || scope.currentSubray.recursion > 0 ) ) {
+          scope.createPrism(segment)
 
-        return
-      } else if (this.rayParameters.isEternal && scope.currentSubray.recursion == 0) {
-        // Eternal rays don't propagate nor vanish, but its subrays do
+          scope.onDecideSubrayCreation(segment, scope)
+        } else if (time < subray.endPropagationTime) {
+          if (scope.timeFraction >= segment.fraction0 * subray.propagationTimeFactor) {
+            // Ray propagation has arrived to this segment
 
-        scope.createPrism(segment)
+            scope.createPrism(segment)
 
-        scope.onDecideSubrayCreation(segment, scope)
-      } else if (time < subray.endPropagationTime) {
-        if (scope.timeFraction >= segment.fraction0 * subray.propagationTimeFactor) {
-          // Ray propagation has arrived to this segment
+            scope.onDecideSubrayCreation(segment, scope)
+          }
+        } else if (time < subray.beginVanishingTime) {
+          // Ray is steady (nor propagating nor vanishing)
 
           scope.createPrism(segment)
 
+          scope.onDecideSubrayCreation(segment, scope)
+        } else {
+          if (scope.timeFraction <= subray.vanishingTimeFactor + segment.fraction1 * (1 - subray.vanishingTimeFactor)) {
+            // Segment has not yet vanished
+
+            scope.createPrism(segment)
+          }
+
           scope.onDecideSubrayCreation(segment, scope)
         }
-      } else if (time < subray.beginVanishingTime) {
-        // Ray is steady (nor propagating nor vanishing)
+      })
+    }
 
-        scope.createPrism(segment)
+    addNewSubray(/*rayParameters*/) {
+      return this.subrays[this.numSubrays++]
+    }
 
-        scope.onDecideSubrayCreation(segment, scope)
-      } else {
-        if (scope.timeFraction <= subray.vanishingTimeFactor + segment.fraction1 * (1 - subray.vanishingTimeFactor)) {
-          // Segment has not yet vanished
+    initSubray(subray, rayParameters) {
+      subray.pos0.copy(rayParameters.sourceOffset)
+      subray.pos1.copy(rayParameters.destOffset)
+      subray.up0.copy(rayParameters.up0)
+      subray.up1.copy(rayParameters.up1)
+      subray.radius0 = rayParameters.radius0
+      subray.radius1 = rayParameters.radius1
+      subray.birthTime = rayParameters.birthTime
+      subray.deathTime = rayParameters.deathTime
+      subray.timeScale = rayParameters.timeScale
+      subray.roughness = rayParameters.roughness
+      subray.straightness = rayParameters.straightness
+      subray.propagationTimeFactor = rayParameters.propagationTimeFactor
+      subray.vanishingTimeFactor = rayParameters.vanishingTimeFactor
+
+      subray.maxIterations = this.maxIterations
+      subray.seed = rayParameters.noiseSeed !== undefined ? rayParameters.noiseSeed : 0
+      subray.recursion = 0
+    }
 
-          scope.createPrism(segment)
-        }
+    fractalRay(time, segmentCallback) {
+      this.time = time
+      this.currentSegmentCallback = segmentCallback
+      this.numSubrays = 0
 
-        scope.onDecideSubrayCreation(segment, scope)
-      }
-    })
-  }
+      // Add the top level subray
+      this.initSubray(this.addNewSubray(), this.rayParameters)
 
-  addNewSubray(/*rayParameters*/) {
-    return this.subrays[this.numSubrays++]
-  }
+      // Process all subrays that are being generated until consuming all of them
+      for (let subrayIndex = 0; subrayIndex < this.numSubrays; subrayIndex++) {
+        const subray = this.subrays[subrayIndex]
+        this.currentSubray = subray
 
-  initSubray(subray, rayParameters) {
-    subray.pos0.copy(rayParameters.sourceOffset)
-    subray.pos1.copy(rayParameters.destOffset)
-    subray.up0.copy(rayParameters.up0)
-    subray.up1.copy(rayParameters.up1)
-    subray.radius0 = rayParameters.radius0
-    subray.radius1 = rayParameters.radius1
-    subray.birthTime = rayParameters.birthTime
-    subray.deathTime = rayParameters.deathTime
-    subray.timeScale = rayParameters.timeScale
-    subray.roughness = rayParameters.roughness
-    subray.straightness = rayParameters.straightness
-    subray.propagationTimeFactor = rayParameters.propagationTimeFactor
-    subray.vanishingTimeFactor = rayParameters.vanishingTimeFactor
-
-    subray.maxIterations = this.maxIterations
-    subray.seed = rayParameters.noiseSeed !== undefined ? rayParameters.noiseSeed : 0
-    subray.recursion = 0
-  }
+        this.randomGenerator.setSeed(subray.seed)
 
-  fractalRay(time, segmentCallback) {
-    this.time = time
-    this.currentSegmentCallback = segmentCallback
-    this.numSubrays = 0
+        subray.endPropagationTime = MathUtils.lerp(subray.birthTime, subray.deathTime, subray.propagationTimeFactor)
+        subray.beginVanishingTime = MathUtils.lerp(subray.deathTime, subray.birthTime, 1 - subray.vanishingTimeFactor)
 
-    // Add the top level subray
-    this.initSubray(this.addNewSubray(), this.rayParameters)
+        const random1 = this.randomGenerator.random
+        subray.linPos0.set(random1(), random1(), random1()).multiplyScalar(1000)
+        subray.linPos1.set(random1(), random1(), random1()).multiplyScalar(1000)
 
-    // Process all subrays that are being generated until consuming all of them
-    for (let subrayIndex = 0; subrayIndex < this.numSubrays; subrayIndex++) {
-      const subray = this.subrays[subrayIndex]
-      this.currentSubray = subray
+        this.timeFraction = (time - subray.birthTime) / (subray.deathTime - subray.birthTime)
 
-      this.randomGenerator.setSeed(subray.seed)
+        this.currentSegmentIndex = 0
+        this.isInitialSegment = true
 
-      subray.endPropagationTime = MathUtils.lerp(subray.birthTime, subray.deathTime, subray.propagationTimeFactor)
-      subray.beginVanishingTime = MathUtils.lerp(subray.deathTime, subray.birthTime, 1 - subray.vanishingTimeFactor)
+        const segment = this.getNewSegment()
+        segment.iteration = 0
+        segment.pos0.copy(subray.pos0)
+        segment.pos1.copy(subray.pos1)
+        segment.linPos0.copy(subray.linPos0)
+        segment.linPos1.copy(subray.linPos1)
+        segment.up0.copy(subray.up0)
+        segment.up1.copy(subray.up1)
+        segment.radius0 = subray.radius0
+        segment.radius1 = subray.radius1
+        segment.fraction0 = 0
+        segment.fraction1 = 1
+        segment.positionVariationFactor = 1 - subray.straightness
 
-      const random1 = this.randomGenerator.random
-      subray.linPos0.set(random1(), random1(), random1()).multiplyScalar(1000)
-      subray.linPos1.set(random1(), random1(), random1()).multiplyScalar(1000)
+        this.subrayProbability =
+          (this.ramification * Math.pow(this.recursionProbability, subray.recursion)) / (1 << subray.maxIterations)
 
-      this.timeFraction = (time - subray.birthTime) / (subray.deathTime - subray.birthTime)
+        this.fractalRayRecursive(segment)
+      }
 
-      this.currentSegmentIndex = 0
-      this.isInitialSegment = true
-
-      const segment = this.getNewSegment()
-      segment.iteration = 0
-      segment.pos0.copy(subray.pos0)
-      segment.pos1.copy(subray.pos1)
-      segment.linPos0.copy(subray.linPos0)
-      segment.linPos1.copy(subray.linPos1)
-      segment.up0.copy(subray.up0)
-      segment.up1.copy(subray.up1)
-      segment.radius0 = subray.radius0
-      segment.radius1 = subray.radius1
-      segment.fraction0 = 0
-      segment.fraction1 = 1
-      segment.positionVariationFactor = 1 - subray.straightness
-
-      this.subrayProbability =
-        (this.ramification * Math.pow(this.recursionProbability, subray.recursion)) / (1 << subray.maxIterations)
-
-      this.fractalRayRecursive(segment)
+      this.currentSegmentCallback = null
+      this.currentSubray = null
     }
 
-    this.currentSegmentCallback = null
-    this.currentSubray = null
-  }
+    fractalRayRecursive(segment) {
+      // Leave recursion condition
+      if (segment.iteration >= this.currentSubray.maxIterations) {
+        this.currentSegmentCallback(segment)
 
-  fractalRayRecursive(segment) {
-    // Leave recursion condition
-    if (segment.iteration >= this.currentSubray.maxIterations) {
-      this.currentSegmentCallback(segment)
+        return
+      }
 
-      return
-    }
+      // Interpolation
+      this.forwards.subVectors(segment.pos1, segment.pos0)
+      let lForwards = this.forwards.length()
 
-    // Interpolation
-    this.forwards.subVectors(segment.pos1, segment.pos0)
-    let lForwards = this.forwards.length()
+      if (lForwards < 0.000001) {
+        this.forwards.set(0, 0, 0.01)
+        lForwards = this.forwards.length()
+      }
 
-    if (lForwards < 0.000001) {
-      this.forwards.set(0, 0, 0.01)
-      lForwards = this.forwards.length()
+      const middleRadius = (segment.radius0 + segment.radius1) * 0.5
+      const middleFraction = (segment.fraction0 + segment.fraction1) * 0.5
+
+      const timeDimension = this.time * this.currentSubray.timeScale * Math.pow(2, segment.iteration)
+
+      this.middlePos.lerpVectors(segment.pos0, segment.pos1, 0.5)
+      this.middleLinPos.lerpVectors(segment.linPos0, segment.linPos1, 0.5)
+      const p = this.middleLinPos
+
+      // Noise
+      this.newPos.set(
+        this.simplexX.noise4d(p.x, p.y, p.z, timeDimension),
+        this.simplexY.noise4d(p.x, p.y, p.z, timeDimension),
+        this.simplexZ.noise4d(p.x, p.y, p.z, timeDimension),
+      )
+
+      this.newPos.multiplyScalar(segment.positionVariationFactor * lForwards)
+      this.newPos.add(this.middlePos)
+
+      // Recursion
+
+      const newSegment1 = this.getNewSegment()
+      newSegment1.pos0.copy(segment.pos0)
+      newSegment1.pos1.copy(this.newPos)
+      newSegment1.linPos0.copy(segment.linPos0)
+      newSegment1.linPos1.copy(this.middleLinPos)
+      newSegment1.up0.copy(segment.up0)
+      newSegment1.up1.copy(segment.up1)
+      newSegment1.radius0 = segment.radius0
+      newSegment1.radius1 = middleRadius
+      newSegment1.fraction0 = segment.fraction0
+      newSegment1.fraction1 = middleFraction
+      newSegment1.positionVariationFactor = segment.positionVariationFactor * this.currentSubray.roughness
+      newSegment1.iteration = segment.iteration + 1
+
+      const newSegment2 = this.getNewSegment()
+      newSegment2.pos0.copy(this.newPos)
+      newSegment2.pos1.copy(segment.pos1)
+      newSegment2.linPos0.copy(this.middleLinPos)
+      newSegment2.linPos1.copy(segment.linPos1)
+      this.cross1.crossVectors(segment.up0, this.forwards.normalize())
+      newSegment2.up0.crossVectors(this.forwards, this.cross1).normalize()
+      newSegment2.up1.copy(segment.up1)
+      newSegment2.radius0 = middleRadius
+      newSegment2.radius1 = segment.radius1
+      newSegment2.fraction0 = middleFraction
+      newSegment2.fraction1 = segment.fraction1
+      newSegment2.positionVariationFactor = segment.positionVariationFactor * this.currentSubray.roughness
+      newSegment2.iteration = segment.iteration + 1
+
+      this.fractalRayRecursive(newSegment1)
+
+      this.fractalRayRecursive(newSegment2)
     }
 
-    const middleRadius = (segment.radius0 + segment.radius1) * 0.5
-    const middleFraction = (segment.fraction0 + segment.fraction1) * 0.5
-
-    const timeDimension = this.time * this.currentSubray.timeScale * Math.pow(2, segment.iteration)
-
-    this.middlePos.lerpVectors(segment.pos0, segment.pos1, 0.5)
-    this.middleLinPos.lerpVectors(segment.linPos0, segment.linPos1, 0.5)
-    const p = this.middleLinPos
-
-    // Noise
-    this.newPos.set(
-      this.simplexX.noise4d(p.x, p.y, p.z, timeDimension),
-      this.simplexY.noise4d(p.x, p.y, p.z, timeDimension),
-      this.simplexZ.noise4d(p.x, p.y, p.z, timeDimension),
-    )
-
-    this.newPos.multiplyScalar(segment.positionVariationFactor * lForwards)
-    this.newPos.add(this.middlePos)
-
-    // Recursion
-
-    const newSegment1 = this.getNewSegment()
-    newSegment1.pos0.copy(segment.pos0)
-    newSegment1.pos1.copy(this.newPos)
-    newSegment1.linPos0.copy(segment.linPos0)
-    newSegment1.linPos1.copy(this.middleLinPos)
-    newSegment1.up0.copy(segment.up0)
-    newSegment1.up1.copy(segment.up1)
-    newSegment1.radius0 = segment.radius0
-    newSegment1.radius1 = middleRadius
-    newSegment1.fraction0 = segment.fraction0
-    newSegment1.fraction1 = middleFraction
-    newSegment1.positionVariationFactor = segment.positionVariationFactor * this.currentSubray.roughness
-    newSegment1.iteration = segment.iteration + 1
-
-    const newSegment2 = this.getNewSegment()
-    newSegment2.pos0.copy(this.newPos)
-    newSegment2.pos1.copy(segment.pos1)
-    newSegment2.linPos0.copy(this.middleLinPos)
-    newSegment2.linPos1.copy(segment.linPos1)
-    this.cross1.crossVectors(segment.up0, this.forwards.normalize())
-    newSegment2.up0.crossVectors(this.forwards, this.cross1).normalize()
-    newSegment2.up1.copy(segment.up1)
-    newSegment2.radius0 = middleRadius
-    newSegment2.radius1 = segment.radius1
-    newSegment2.fraction0 = middleFraction
-    newSegment2.fraction1 = segment.fraction1
-    newSegment2.positionVariationFactor = segment.positionVariationFactor * this.currentSubray.roughness
-    newSegment2.iteration = segment.iteration + 1
-
-    this.fractalRayRecursive(newSegment1)
-
-    this.fractalRayRecursive(newSegment2)
-  }
-
-  createPrism(segment) {
-    // Creates one triangular prism and its vertices at the segment
+    createPrism(segment) {
+      // Creates one triangular prism and its vertices at the segment
 
-    this.forwardsFill.subVectors(segment.pos1, segment.pos0).normalize()
+      this.forwardsFill.subVectors(segment.pos1, segment.pos0).normalize()
 
-    if (this.isInitialSegment) {
-      this.currentCreateTriangleVertices(segment.pos0, segment.up0, this.forwardsFill, segment.radius0, 0)
+      if (this.isInitialSegment) {
+        this.currentCreateTriangleVertices(segment.pos0, segment.up0, this.forwardsFill, segment.radius0, 0)
 
-      this.isInitialSegment = false
-    }
+        this.isInitialSegment = false
+      }
 
-    this.currentCreateTriangleVertices(segment.pos1, segment.up0, this.forwardsFill, segment.radius1, segment.fraction1)
+      this.currentCreateTriangleVertices(
+        segment.pos1,
+        segment.up0,
+        this.forwardsFill,
+        segment.radius1,
+        segment.fraction1,
+      )
 
-    this.createPrismFaces()
-  }
+      this.createPrismFaces()
+    }
 
-  createTriangleVerticesWithoutUVs(pos, up, forwards, radius) {
-    // Create an equilateral triangle (only vertices)
+    createTriangleVerticesWithoutUVs(pos, up, forwards, radius) {
+      // Create an equilateral triangle (only vertices)
 
-    this.side.crossVectors(up, forwards).multiplyScalar(radius * LightningStrike.COS30DEG)
-    this.down.copy(up).multiplyScalar(-radius * LightningStrike.SIN30DEG)
+      this.side.crossVectors(up, forwards).multiplyScalar(radius * LightningStrike.COS30DEG)
+      this.down.copy(up).multiplyScalar(-radius * LightningStrike.SIN30DEG)
 
-    const p = this.vPos
-    const v = this.vertices
+      const p = this.vPos
+      const v = this.vertices
 
-    p.copy(pos).sub(this.side).add(this.down)
+      p.copy(pos).sub(this.side).add(this.down)
 
-    v[this.currentCoordinate++] = p.x
-    v[this.currentCoordinate++] = p.y
-    v[this.currentCoordinate++] = p.z
+      v[this.currentCoordinate++] = p.x
+      v[this.currentCoordinate++] = p.y
+      v[this.currentCoordinate++] = p.z
 
-    p.copy(pos).add(this.side).add(this.down)
+      p.copy(pos).add(this.side).add(this.down)
 
-    v[this.currentCoordinate++] = p.x
-    v[this.currentCoordinate++] = p.y
-    v[this.currentCoordinate++] = p.z
+      v[this.currentCoordinate++] = p.x
+      v[this.currentCoordinate++] = p.y
+      v[this.currentCoordinate++] = p.z
 
-    p.copy(up).multiplyScalar(radius).add(pos)
+      p.copy(up).multiplyScalar(radius).add(pos)
 
-    v[this.currentCoordinate++] = p.x
-    v[this.currentCoordinate++] = p.y
-    v[this.currentCoordinate++] = p.z
+      v[this.currentCoordinate++] = p.x
+      v[this.currentCoordinate++] = p.y
+      v[this.currentCoordinate++] = p.z
 
-    this.currentVertex += 3
-  }
+      this.currentVertex += 3
+    }
 
-  createTriangleVerticesWithUVs(pos, up, forwards, radius, u) {
-    // Create an equilateral triangle (only vertices)
+    createTriangleVerticesWithUVs(pos, up, forwards, radius, u) {
+      // Create an equilateral triangle (only vertices)
 
-    this.side.crossVectors(up, forwards).multiplyScalar(radius * LightningStrike.COS30DEG)
-    this.down.copy(up).multiplyScalar(-radius * LightningStrike.SIN30DEG)
+      this.side.crossVectors(up, forwards).multiplyScalar(radius * LightningStrike.COS30DEG)
+      this.down.copy(up).multiplyScalar(-radius * LightningStrike.SIN30DEG)
 
-    const p = this.vPos
-    const v = this.vertices
-    const uv = this.uvs
+      const p = this.vPos
+      const v = this.vertices
+      const uv = this.uvs
 
-    p.copy(pos).sub(this.side).add(this.down)
+      p.copy(pos).sub(this.side).add(this.down)
 
-    v[this.currentCoordinate++] = p.x
-    v[this.currentCoordinate++] = p.y
-    v[this.currentCoordinate++] = p.z
+      v[this.currentCoordinate++] = p.x
+      v[this.currentCoordinate++] = p.y
+      v[this.currentCoordinate++] = p.z
 
-    uv[this.currentUVCoordinate++] = u
-    uv[this.currentUVCoordinate++] = 0
+      uv[this.currentUVCoordinate++] = u
+      uv[this.currentUVCoordinate++] = 0
 
-    p.copy(pos).add(this.side).add(this.down)
+      p.copy(pos).add(this.side).add(this.down)
 
-    v[this.currentCoordinate++] = p.x
-    v[this.currentCoordinate++] = p.y
-    v[this.currentCoordinate++] = p.z
+      v[this.currentCoordinate++] = p.x
+      v[this.currentCoordinate++] = p.y
+      v[this.currentCoordinate++] = p.z
 
-    uv[this.currentUVCoordinate++] = u
-    uv[this.currentUVCoordinate++] = 0.5
+      uv[this.currentUVCoordinate++] = u
+      uv[this.currentUVCoordinate++] = 0.5
 
-    p.copy(up).multiplyScalar(radius).add(pos)
+      p.copy(up).multiplyScalar(radius).add(pos)
 
-    v[this.currentCoordinate++] = p.x
-    v[this.currentCoordinate++] = p.y
-    v[this.currentCoordinate++] = p.z
+      v[this.currentCoordinate++] = p.x
+      v[this.currentCoordinate++] = p.y
+      v[this.currentCoordinate++] = p.z
 
-    uv[this.currentUVCoordinate++] = u
-    uv[this.currentUVCoordinate++] = 1
+      uv[this.currentUVCoordinate++] = u
+      uv[this.currentUVCoordinate++] = 1
 
-    this.currentVertex += 3
-  }
+      this.currentVertex += 3
+    }
 
-  createPrismFaces(vertex /*, index*/) {
-    const indices = this.indices
-    vertex = this.currentVertex - 6
-
-    indices[this.currentIndex++] = vertex + 1
-    indices[this.currentIndex++] = vertex + 2
-    indices[this.currentIndex++] = vertex + 5
-    indices[this.currentIndex++] = vertex + 1
-    indices[this.currentIndex++] = vertex + 5
-    indices[this.currentIndex++] = vertex + 4
-    indices[this.currentIndex++] = vertex + 0
-    indices[this.currentIndex++] = vertex + 1
-    indices[this.currentIndex++] = vertex + 4
-    indices[this.currentIndex++] = vertex + 0
-    indices[this.currentIndex++] = vertex + 4
-    indices[this.currentIndex++] = vertex + 3
-    indices[this.currentIndex++] = vertex + 2
-    indices[this.currentIndex++] = vertex + 0
-    indices[this.currentIndex++] = vertex + 3
-    indices[this.currentIndex++] = vertex + 2
-    indices[this.currentIndex++] = vertex + 3
-    indices[this.currentIndex++] = vertex + 5
-  }
+    createPrismFaces(vertex /*, index*/) {
+      const indices = this.indices
+      vertex = this.currentVertex - 6
+
+      indices[this.currentIndex++] = vertex + 1
+      indices[this.currentIndex++] = vertex + 2
+      indices[this.currentIndex++] = vertex + 5
+      indices[this.currentIndex++] = vertex + 1
+      indices[this.currentIndex++] = vertex + 5
+      indices[this.currentIndex++] = vertex + 4
+      indices[this.currentIndex++] = vertex + 0
+      indices[this.currentIndex++] = vertex + 1
+      indices[this.currentIndex++] = vertex + 4
+      indices[this.currentIndex++] = vertex + 0
+      indices[this.currentIndex++] = vertex + 4
+      indices[this.currentIndex++] = vertex + 3
+      indices[this.currentIndex++] = vertex + 2
+      indices[this.currentIndex++] = vertex + 0
+      indices[this.currentIndex++] = vertex + 3
+      indices[this.currentIndex++] = vertex + 2
+      indices[this.currentIndex++] = vertex + 3
+      indices[this.currentIndex++] = vertex + 5
+    }
 
-  createDefaultSubrayCreationCallbacks() {
-    const random1 = this.randomGenerator.random
+    createDefaultSubrayCreationCallbacks() {
+      const random1 = this.randomGenerator.random
 
-    this.onDecideSubrayCreation = function (segment, lightningStrike) {
-      // Decide subrays creation at parent (sub)ray segment
+      this.onDecideSubrayCreation = function (segment, lightningStrike) {
+        // Decide subrays creation at parent (sub)ray segment
 
-      const subray = lightningStrike.currentSubray
+        const subray = lightningStrike.currentSubray
 
-      const period = lightningStrike.rayParameters.subrayPeriod
-      const dutyCycle = lightningStrike.rayParameters.subrayDutyCycle
+        const period = lightningStrike.rayParameters.subrayPeriod
+        const dutyCycle = lightningStrike.rayParameters.subrayDutyCycle
 
-      const phase0 =
-        lightningStrike.rayParameters.isEternal && subray.recursion == 0
-          ? -random1() * period
-          : MathUtils.lerp(subray.birthTime, subray.endPropagationTime, segment.fraction0) - random1() * period
+        const phase0 =
+          lightningStrike.rayParameters.isEternal && subray.recursion == 0
+            ? -random1() * period
+            : MathUtils.lerp(subray.birthTime, subray.endPropagationTime, segment.fraction0) - random1() * period
 
-      const phase = lightningStrike.time - phase0
-      const currentCycle = Math.floor(phase / period)
+        const phase = lightningStrike.time - phase0
+        const currentCycle = Math.floor(phase / period)
 
-      const childSubraySeed = random1() * (currentCycle + 1)
+        const childSubraySeed = random1() * (currentCycle + 1)
 
-      const isActive = phase % period <= dutyCycle * period
+        const isActive = phase % period <= dutyCycle * period
 
-      let probability = 0
+        let probability = 0
 
-      if (isActive) {
-        probability = lightningStrike.subrayProbability
-        // Distribution test: probability *= segment.fraction0 > 0.5 && segment.fraction0 < 0.9 ? 1 / 0.4 : 0;
-      }
+        if (isActive) {
+          probability = lightningStrike.subrayProbability
+          // Distribution test: probability *= segment.fraction0 > 0.5 && segment.fraction0 < 0.9 ? 1 / 0.4 : 0;
+        }
 
-      if (
-        subray.recursion < lightningStrike.maxSubrayRecursion &&
-        lightningStrike.numSubrays < lightningStrike.maxSubrays &&
-        random1() < probability
-      ) {
-        const childSubray = lightningStrike.addNewSubray()
-
-        const parentSeed = lightningStrike.randomGenerator.getSeed()
-        childSubray.seed = childSubraySeed
-        lightningStrike.randomGenerator.setSeed(childSubraySeed)
-
-        childSubray.recursion = subray.recursion + 1
-        childSubray.maxIterations = Math.max(1, subray.maxIterations - 1)
-
-        childSubray.linPos0.set(random1(), random1(), random1()).multiplyScalar(1000)
-        childSubray.linPos1.set(random1(), random1(), random1()).multiplyScalar(1000)
-        childSubray.up0.copy(subray.up0)
-        childSubray.up1.copy(subray.up1)
-        childSubray.radius0 = segment.radius0 * lightningStrike.rayParameters.radius0Factor
-        childSubray.radius1 = Math.min(
-          lightningStrike.rayParameters.minRadius,
-          segment.radius1 * lightningStrike.rayParameters.radius1Factor,
-        )
-
-        childSubray.birthTime = phase0 + currentCycle * period
-        childSubray.deathTime = childSubray.birthTime + period * dutyCycle
-
-        if (!lightningStrike.rayParameters.isEternal && subray.recursion == 0) {
-          childSubray.birthTime = Math.max(childSubray.birthTime, subray.birthTime)
-          childSubray.deathTime = Math.min(childSubray.deathTime, subray.deathTime)
+        if (
+          subray.recursion < lightningStrike.maxSubrayRecursion &&
+          lightningStrike.numSubrays < lightningStrike.maxSubrays &&
+          random1() < probability
+        ) {
+          const childSubray = lightningStrike.addNewSubray()
+
+          const parentSeed = lightningStrike.randomGenerator.getSeed()
+          childSubray.seed = childSubraySeed
+          lightningStrike.randomGenerator.setSeed(childSubraySeed)
+
+          childSubray.recursion = subray.recursion + 1
+          childSubray.maxIterations = Math.max(1, subray.maxIterations - 1)
+
+          childSubray.linPos0.set(random1(), random1(), random1()).multiplyScalar(1000)
+          childSubray.linPos1.set(random1(), random1(), random1()).multiplyScalar(1000)
+          childSubray.up0.copy(subray.up0)
+          childSubray.up1.copy(subray.up1)
+          childSubray.radius0 = segment.radius0 * lightningStrike.rayParameters.radius0Factor
+          childSubray.radius1 = Math.min(
+            lightningStrike.rayParameters.minRadius,
+            segment.radius1 * lightningStrike.rayParameters.radius1Factor,
+          )
+
+          childSubray.birthTime = phase0 + currentCycle * period
+          childSubray.deathTime = childSubray.birthTime + period * dutyCycle
+
+          if (!lightningStrike.rayParameters.isEternal && subray.recursion == 0) {
+            childSubray.birthTime = Math.max(childSubray.birthTime, subray.birthTime)
+            childSubray.deathTime = Math.min(childSubray.deathTime, subray.deathTime)
+          }
+
+          childSubray.timeScale = subray.timeScale * 2
+          childSubray.roughness = subray.roughness
+          childSubray.straightness = subray.straightness
+          childSubray.propagationTimeFactor = subray.propagationTimeFactor
+          childSubray.vanishingTimeFactor = subray.vanishingTimeFactor
+
+          lightningStrike.onSubrayCreation(segment, subray, childSubray, lightningStrike)
+
+          lightningStrike.randomGenerator.setSeed(parentSeed)
         }
+      }
 
-        childSubray.timeScale = subray.timeScale * 2
-        childSubray.roughness = subray.roughness
-        childSubray.straightness = subray.straightness
-        childSubray.propagationTimeFactor = subray.propagationTimeFactor
-        childSubray.vanishingTimeFactor = subray.vanishingTimeFactor
+      const vec1Pos = new Vector3()
+      const vec2Forward = new Vector3()
+      const vec3Side = new Vector3()
+      const vec4Up = new Vector3()
 
-        lightningStrike.onSubrayCreation(segment, subray, childSubray, lightningStrike)
+      this.onSubrayCreation = function (segment, parentSubray, childSubray, lightningStrike) {
+        // Decide childSubray origin and destination positions (pos0 and pos1) and possibly other properties of childSubray
 
-        lightningStrike.randomGenerator.setSeed(parentSeed)
+        // Just use the default cone position generator
+        lightningStrike.subrayCylinderPosition(segment, parentSubray, childSubray, 0.5, 0.6, 0.2)
       }
-    }
 
-    const vec1Pos = new Vector3()
-    const vec2Forward = new Vector3()
-    const vec3Side = new Vector3()
-    const vec4Up = new Vector3()
-
-    this.onSubrayCreation = function (segment, parentSubray, childSubray, lightningStrike) {
-      // Decide childSubray origin and destination positions (pos0 and pos1) and possibly other properties of childSubray
-
-      // Just use the default cone position generator
-      lightningStrike.subrayCylinderPosition(segment, parentSubray, childSubray, 0.5, 0.6, 0.2)
-    }
+      this.subrayConePosition = function (
+        segment,
+        parentSubray,
+        childSubray,
+        heightFactor,
+        sideWidthFactor,
+        minSideWidthFactor,
+      ) {
+        // Sets childSubray pos0 and pos1 in a cone
+
+        childSubray.pos0.copy(segment.pos0)
+
+        vec1Pos.subVectors(parentSubray.pos1, parentSubray.pos0)
+        vec2Forward.copy(vec1Pos).normalize()
+        vec1Pos.multiplyScalar(segment.fraction0 + (1 - segment.fraction0) * (random1() * heightFactor))
+        const length = vec1Pos.length()
+        vec3Side.crossVectors(parentSubray.up0, vec2Forward)
+        const angle = 2 * Math.PI * random1()
+        vec3Side.multiplyScalar(Math.cos(angle))
+        vec4Up.copy(parentSubray.up0).multiplyScalar(Math.sin(angle))
+
+        childSubray.pos1
+          .copy(vec3Side)
+          .add(vec4Up)
+          .multiplyScalar(length * sideWidthFactor * (minSideWidthFactor + random1() * (1 - minSideWidthFactor)))
+          .add(vec1Pos)
+          .add(parentSubray.pos0)
+      }
 
-    this.subrayConePosition = function (
-      segment,
-      parentSubray,
-      childSubray,
-      heightFactor,
-      sideWidthFactor,
-      minSideWidthFactor,
-    ) {
-      // Sets childSubray pos0 and pos1 in a cone
-
-      childSubray.pos0.copy(segment.pos0)
-
-      vec1Pos.subVectors(parentSubray.pos1, parentSubray.pos0)
-      vec2Forward.copy(vec1Pos).normalize()
-      vec1Pos.multiplyScalar(segment.fraction0 + (1 - segment.fraction0) * (random1() * heightFactor))
-      const length = vec1Pos.length()
-      vec3Side.crossVectors(parentSubray.up0, vec2Forward)
-      const angle = 2 * Math.PI * random1()
-      vec3Side.multiplyScalar(Math.cos(angle))
-      vec4Up.copy(parentSubray.up0).multiplyScalar(Math.sin(angle))
-
-      childSubray.pos1
-        .copy(vec3Side)
-        .add(vec4Up)
-        .multiplyScalar(length * sideWidthFactor * (minSideWidthFactor + random1() * (1 - minSideWidthFactor)))
-        .add(vec1Pos)
-        .add(parentSubray.pos0)
+      this.subrayCylinderPosition = function (
+        segment,
+        parentSubray,
+        childSubray,
+        heightFactor,
+        sideWidthFactor,
+        minSideWidthFactor,
+      ) {
+        // Sets childSubray pos0 and pos1 in a cylinder
+
+        childSubray.pos0.copy(segment.pos0)
+
+        vec1Pos.subVectors(parentSubray.pos1, parentSubray.pos0)
+        vec2Forward.copy(vec1Pos).normalize()
+        vec1Pos.multiplyScalar(segment.fraction0 + (1 - segment.fraction0) * ((2 * random1() - 1) * heightFactor))
+        const length = vec1Pos.length()
+        vec3Side.crossVectors(parentSubray.up0, vec2Forward)
+        const angle = 2 * Math.PI * random1()
+        vec3Side.multiplyScalar(Math.cos(angle))
+        vec4Up.copy(parentSubray.up0).multiplyScalar(Math.sin(angle))
+
+        childSubray.pos1
+          .copy(vec3Side)
+          .add(vec4Up)
+          .multiplyScalar(length * sideWidthFactor * (minSideWidthFactor + random1() * (1 - minSideWidthFactor)))
+          .add(vec1Pos)
+          .add(parentSubray.pos0)
+      }
     }
 
-    this.subrayCylinderPosition = function (
-      segment,
-      parentSubray,
-      childSubray,
-      heightFactor,
-      sideWidthFactor,
-      minSideWidthFactor,
-    ) {
-      // Sets childSubray pos0 and pos1 in a cylinder
-
-      childSubray.pos0.copy(segment.pos0)
-
-      vec1Pos.subVectors(parentSubray.pos1, parentSubray.pos0)
-      vec2Forward.copy(vec1Pos).normalize()
-      vec1Pos.multiplyScalar(segment.fraction0 + (1 - segment.fraction0) * ((2 * random1() - 1) * heightFactor))
-      const length = vec1Pos.length()
-      vec3Side.crossVectors(parentSubray.up0, vec2Forward)
-      const angle = 2 * Math.PI * random1()
-      vec3Side.multiplyScalar(Math.cos(angle))
-      vec4Up.copy(parentSubray.up0).multiplyScalar(Math.sin(angle))
-
-      childSubray.pos1
-        .copy(vec3Side)
-        .add(vec4Up)
-        .multiplyScalar(length * sideWidthFactor * (minSideWidthFactor + random1() * (1 - minSideWidthFactor)))
-        .add(vec1Pos)
-        .add(parentSubray.pos0)
+    createSubray() {
+      return {
+        seed: 0,
+        maxIterations: 0,
+        recursion: 0,
+        pos0: new Vector3(),
+        pos1: new Vector3(),
+        linPos0: new Vector3(),
+        linPos1: new Vector3(),
+        up0: new Vector3(),
+        up1: new Vector3(),
+        radius0: 0,
+        radius1: 0,
+        birthTime: 0,
+        deathTime: 0,
+        timeScale: 0,
+        roughness: 0,
+        straightness: 0,
+        propagationTimeFactor: 0,
+        vanishingTimeFactor: 0,
+        endPropagationTime: 0,
+        beginVanishingTime: 0,
+      }
     }
-  }
 
-  createSubray() {
-    return {
-      seed: 0,
-      maxIterations: 0,
-      recursion: 0,
-      pos0: new Vector3(),
-      pos1: new Vector3(),
-      linPos0: new Vector3(),
-      linPos1: new Vector3(),
-      up0: new Vector3(),
-      up1: new Vector3(),
-      radius0: 0,
-      radius1: 0,
-      birthTime: 0,
-      deathTime: 0,
-      timeScale: 0,
-      roughness: 0,
-      straightness: 0,
-      propagationTimeFactor: 0,
-      vanishingTimeFactor: 0,
-      endPropagationTime: 0,
-      beginVanishingTime: 0,
+    createSegment() {
+      return {
+        iteration: 0,
+        pos0: new Vector3(),
+        pos1: new Vector3(),
+        linPos0: new Vector3(),
+        linPos1: new Vector3(),
+        up0: new Vector3(),
+        up1: new Vector3(),
+        radius0: 0,
+        radius1: 0,
+        fraction0: 0,
+        fraction1: 0,
+        positionVariationFactor: 0,
+      }
     }
-  }
 
-  createSegment() {
-    return {
-      iteration: 0,
-      pos0: new Vector3(),
-      pos1: new Vector3(),
-      linPos0: new Vector3(),
-      linPos1: new Vector3(),
-      up0: new Vector3(),
-      up1: new Vector3(),
-      radius0: 0,
-      radius1: 0,
-      fraction0: 0,
-      fraction1: 0,
-      positionVariationFactor: 0,
+    getNewSegment() {
+      return this.raySegments[this.currentSegmentIndex++]
     }
-  }
 
-  getNewSegment() {
-    return this.raySegments[this.currentSegmentIndex++]
-  }
+    copy(source) {
+      super.copy(source)
 
-  copy(source) {
-    super.copy(source)
+      this.init(LightningStrike.copyParameters({}, source.rayParameters))
 
-    this.init(LightningStrike.copyParameters({}, source.rayParameters))
+      return this
+    }
 
-    return this
+    clone() {
+      return new this.constructor(LightningStrike.copyParameters({}, this.rayParameters))
+    }
   }
 
-  clone() {
-    return new this.constructor(LightningStrike.copyParameters({}, this.rayParameters))
-  }
-}
+  return LightningStrike
+})()
 
 export { LightningStrike }
diff --git a/src/geometries/RoundedBoxGeometry.js b/src/geometries/RoundedBoxGeometry.js
index 80c5f35b..3a10f247 100644
--- a/src/geometries/RoundedBoxGeometry.js
+++ b/src/geometries/RoundedBoxGeometry.js
@@ -1,6 +1,6 @@
 import { BoxGeometry, Vector3 } from 'three'
 
-const tempNormal = new Vector3()
+const tempNormal = /* @__PURE__ */ new Vector3()
 
 function getUv(faceDirVector, normal, uvAxis, projectionAxis, radius, sideLength) {
   const totArcLength = (2 * Math.PI * radius) / 4
diff --git a/src/helpers/RaycasterHelper.ts b/src/helpers/RaycasterHelper.ts
index f5f57644..ed093375 100644
--- a/src/helpers/RaycasterHelper.ts
+++ b/src/helpers/RaycasterHelper.ts
@@ -18,8 +18,8 @@ import {
   Vector3,
 } from 'three'
 
-const _o = new Object3D()
-const _v = new Vector3()
+const _o = /* @__PURE__ */ new Object3D()
+const _v = /* @__PURE__ */ new Vector3()
 
 class RaycasterHelper extends Object3D {
   raycaster: Raycaster
diff --git a/src/helpers/VertexNormalsHelper.js b/src/helpers/VertexNormalsHelper.js
index 18e8addb..b586a130 100644
--- a/src/helpers/VertexNormalsHelper.js
+++ b/src/helpers/VertexNormalsHelper.js
@@ -1,8 +1,8 @@
 import { BufferGeometry, Float32BufferAttribute, LineSegments, LineBasicMaterial, Matrix3, Vector3 } from 'three'
 
-const _v1 = new Vector3()
-const _v2 = new Vector3()
-const _normalMatrix = new Matrix3()
+const _v1 = /* @__PURE__ */ new Vector3()
+const _v2 = /* @__PURE__ */ new Vector3()
+const _normalMatrix = /* @__PURE__ */ new Matrix3()
 
 class VertexNormalsHelper extends LineSegments {
   constructor(object, size = 1, color = 0xff0000) {
diff --git a/src/helpers/VertexTangentsHelper.js b/src/helpers/VertexTangentsHelper.js
index 42d50ee5..a9af184a 100644
--- a/src/helpers/VertexTangentsHelper.js
+++ b/src/helpers/VertexTangentsHelper.js
@@ -1,7 +1,7 @@
 import { BufferGeometry, Float32BufferAttribute, LineSegments, LineBasicMaterial, Vector3 } from 'three'
 
-const _v1 = new Vector3()
-const _v2 = new Vector3()
+const _v1 = /* @__PURE__ */ new Vector3()
+const _v2 = /* @__PURE__ */ new Vector3()
 
 class VertexTangentsHelper extends LineSegments {
   constructor(object, size = 1, color = 0x00ffff) {
diff --git a/src/interactive/InteractiveGroup.js b/src/interactive/InteractiveGroup.js
index 704f4ffb..263e979b 100644
--- a/src/interactive/InteractiveGroup.js
+++ b/src/interactive/InteractiveGroup.js
@@ -1,6 +1,6 @@
 import { Group, Matrix4, Raycaster, Vector2 } from 'three'
 
-const _pointer = new Vector2()
+const _pointer = /* @__PURE__ */ new Vector2()
 const _event = { type: '', data: _pointer }
 
 class InteractiveGroup extends Group {
diff --git a/src/interactive/SelectionBox.js b/src/interactive/SelectionBox.js
index 4db0205e..dda5dd6e 100644
--- a/src/interactive/SelectionBox.js
+++ b/src/interactive/SelectionBox.js
@@ -1,24 +1,24 @@
 import { Frustum, Vector3 } from 'three'
 
-const frustum = new Frustum()
-const center = new Vector3()
+const frustum = /* @__PURE__ */ new Frustum()
+const center = /* @__PURE__ */ new Vector3()
 
-const tmpPoint = new Vector3()
+const tmpPoint = /* @__PURE__ */ new Vector3()
 
-const vecNear = new Vector3()
-const vecTopLeft = new Vector3()
-const vecTopRight = new Vector3()
-const vecDownRight = new Vector3()
-const vecDownLeft = new Vector3()
+const vecNear = /* @__PURE__ */ new Vector3()
+const vecTopLeft = /* @__PURE__ */ new Vector3()
+const vecTopRight = /* @__PURE__ */ new Vector3()
+const vecDownRight = /* @__PURE__ */ new Vector3()
+const vecDownLeft = /* @__PURE__ */ new Vector3()
 
-const vecFarTopLeft = new Vector3()
-const vecFarTopRight = new Vector3()
-const vecFarDownRight = new Vector3()
-const vecFarDownLeft = new Vector3()
+const vecFarTopLeft = /* @__PURE__ */ new Vector3()
+const vecFarTopRight = /* @__PURE__ */ new Vector3()
+const vecFarDownRight = /* @__PURE__ */ new Vector3()
+const vecFarDownLeft = /* @__PURE__ */ new Vector3()
 
-const vectemp1 = new Vector3()
-const vectemp2 = new Vector3()
-const vectemp3 = new Vector3()
+const vectemp1 = /* @__PURE__ */ new Vector3()
+const vectemp2 = /* @__PURE__ */ new Vector3()
+const vectemp3 = /* @__PURE__ */ new Vector3()
 
 class SelectionBox {
   constructor(camera, scene, deep) {
diff --git a/src/libs/chevrotain.js b/src/libs/chevrotain.js
index 8e23804d..4d8c0e48 100644
--- a/src/libs/chevrotain.js
+++ b/src/libs/chevrotain.js
@@ -1,4 +1,4 @@
-const { CstParser, Lexer, createToken } = (() => {
+const { CstParser, Lexer, createToken } = /* @__PURE__ */ (() => {
   /** Detect free variable `global` from Node.js. */
   var freeGlobal = typeof global == 'object' && global && global.Object === Object && global
 
diff --git a/src/libs/lottie.js b/src/libs/lottie.js
index 2c2d699d..e6e503df 100644
--- a/src/libs/lottie.js
+++ b/src/libs/lottie.js
@@ -1,4 +1,4 @@
-const lottie = (() => {
+const lottie = /* @__PURE__ */ (() => {
   if (typeof navigator === 'undefined' || typeof document === 'undefined') return {}
 
   const svgNS = 'http://www.w3.org/2000/svg'
diff --git a/src/libs/opentype.js b/src/libs/opentype.js
index ecb8c687..d8aa0d04 100644
--- a/src/libs/opentype.js
+++ b/src/libs/opentype.js
@@ -1,4 +1,4 @@
-const { parseBuffer } = (() => {
+const { parseBuffer } = /* @__PURE__ */ (() => {
   /**
    * https://opentype.js.org v1.3.4 | (c) Frederik De Bleser and other contributors | MIT License | Uses tiny-inflate by Devon Govett and string.prototype.codepointat polyfill by Mathias Bynens
    */
diff --git a/src/lights/LightProbeGenerator.js b/src/lights/LightProbeGenerator.js
index 216438e4..bd38bf06 100644
--- a/src/lights/LightProbeGenerator.js
+++ b/src/lights/LightProbeGenerator.js
@@ -1,8 +1,8 @@
 import { Color, LightProbe, SphericalHarmonics3, Vector3 } from 'three'
 
-class LightProbeGenerator {
+const LightProbeGenerator = {
   // https://www.ppsloan.org/publications/StupidSH36.pdf
-  static fromCubeTexture(cubeTexture) {
+  fromCubeTexture(cubeTexture) {
     let totalWeight = 0
 
     const coord = new Vector3()
@@ -122,9 +122,9 @@ class LightProbeGenerator {
     }
 
     return new LightProbe(sh)
-  }
+  },
 
-  static fromCubeRenderTarget(renderer, cubeRenderTarget) {
+  fromCubeRenderTarget(renderer, cubeRenderTarget) {
     // The renderTarget must be set to RGBA in order to make readRenderTargetPixels works
     let totalWeight = 0
 
@@ -229,7 +229,7 @@ class LightProbeGenerator {
     }
 
     return new LightProbe(sh)
-  }
+  },
 }
 
 export { LightProbeGenerator }
diff --git a/src/lights/RectAreaLightUniformsLib.js b/src/lights/RectAreaLightUniformsLib.js
index c14634f1..3f495939 100644
--- a/src/lights/RectAreaLightUniformsLib.js
+++ b/src/lights/RectAreaLightUniformsLib.js
@@ -28,8 +28,8 @@ import {
 // by Eric Heitz, Jonathan Dupuy, Stephen Hill and David Neubelt
 // code: https://github.com/selfshadow/ltc_code/
 
-class RectAreaLightUniformsLib {
-  static init() {
+const RectAreaLightUniformsLib = {
+  init() {
     // source: https://github.com/selfshadow/ltc_code/tree/master/fit/results/ltc.js
 
     const LTC_MAT_1 = [
@@ -32882,7 +32882,7 @@ class RectAreaLightUniformsLib {
 
     UniformsLib.LTC_HALF_1.needsUpdate = true
     UniformsLib.LTC_HALF_2.needsUpdate = true
-  }
+  },
 }
 
 export { RectAreaLightUniformsLib }
diff --git a/src/lines/LineMaterial.js b/src/lines/LineMaterial.js
index 3c4959de..8e54c9e8 100644
--- a/src/lines/LineMaterial.js
+++ b/src/lines/LineMaterial.js
@@ -10,7 +10,8 @@
  * }
  */
 
-import { ShaderMaterial, UniformsLib, UniformsUtils, Vector2, REVISION } from 'three'
+import { ShaderMaterial, UniformsLib, UniformsUtils, Vector2 } from 'three'
+import { version } from '../_polyfill/constants'
 
 class LineMaterial extends ShaderMaterial {
   constructor(parameters) {
@@ -437,7 +438,7 @@ class LineMaterial extends ShaderMaterial {
 					gl_FragColor = diffuseColor;
 
 					#include <tonemapping_fragment>
-					#include <${parseInt(REVISION.replace(/\D+/g, '')) >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>
+					#include <${version >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>
 					#include <fog_fragment>
 					#include <premultiplied_alpha_fragment>
 
diff --git a/src/lines/LineSegments2.js b/src/lines/LineSegments2.js
index b514fe81..461e240a 100644
--- a/src/lines/LineSegments2.js
+++ b/src/lines/LineSegments2.js
@@ -14,23 +14,23 @@ import { LineSegmentsGeometry } from '../lines/LineSegmentsGeometry'
 import { LineMaterial } from '../lines/LineMaterial'
 import { UV1 } from '../_polyfill/uv1'
 
-const _viewport = new Vector4();
+const _viewport = /* @__PURE__ */ new Vector4()
 
-const _start = new Vector3()
-const _end = new Vector3()
+const _start = /* @__PURE__ */ new Vector3()
+const _end = /* @__PURE__ */ new Vector3()
 
-const _start4 = new Vector4()
-const _end4 = new Vector4()
+const _start4 = /* @__PURE__ */ new Vector4()
+const _end4 = /* @__PURE__ */ new Vector4()
 
-const _ssOrigin = new Vector4()
-const _ssOrigin3 = new Vector3()
-const _mvMatrix = new Matrix4()
-const _line = new Line3()
-const _closestPoint = new Vector3()
+const _ssOrigin = /* @__PURE__ */ new Vector4()
+const _ssOrigin3 = /* @__PURE__ */ new Vector3()
+const _mvMatrix = /* @__PURE__ */ new Matrix4()
+const _line = /* @__PURE__ */ new Line3()
+const _closestPoint = /* @__PURE__ */ new Vector3()
 
-const _box = new Box3()
-const _sphere = new Sphere()
-const _clipToWorldVector = new Vector4()
+const _box = /* @__PURE__ */ new Box3()
+const _sphere = /* @__PURE__ */ new Sphere()
+const _clipToWorldVector = /* @__PURE__ */ new Vector4()
 
 let _ray, _lineWidth
 
@@ -51,18 +51,17 @@ function getWorldSpaceHalfWidth(camera, distance, resolution) {
 }
 
 function raycastWorldUnits(lineSegments, intersects) {
-
-  const matrixWorld = lineSegments.matrixWorld;
-  const geometry = lineSegments.geometry;
-  const instanceStart = geometry.attributes.instanceStart;
-  const instanceEnd = geometry.attributes.instanceEnd;
-  const segmentCount = Math.min(geometry.instanceCount, instanceStart.count);
+  const matrixWorld = lineSegments.matrixWorld
+  const geometry = lineSegments.geometry
+  const instanceStart = geometry.attributes.instanceStart
+  const instanceEnd = geometry.attributes.instanceEnd
+  const segmentCount = Math.min(geometry.instanceCount, instanceStart.count)
 
   for (let i = 0, l = segmentCount; i < l; i++) {
     _line.start.fromBufferAttribute(instanceStart, i)
     _line.end.fromBufferAttribute(instanceEnd, i)
 
-    _line.applyMatrix4(matrixWorld);
+    _line.applyMatrix4(matrixWorld)
 
     const pointOnLine = new Vector3()
     const point = new Vector3()
@@ -94,7 +93,7 @@ function raycastScreenSpace(lineSegments, camera, intersects) {
   const geometry = lineSegments.geometry
   const instanceStart = geometry.attributes.instanceStart
   const instanceEnd = geometry.attributes.instanceEnd
-  const segmentCount = Math.min(geometry.instanceCount, instanceStart.count);
+  const segmentCount = Math.min(geometry.instanceCount, instanceStart.count)
 
   const near = -camera.near
 
@@ -312,16 +311,12 @@ class LineSegments2 extends Mesh {
   }
 
   onBeforeRender(renderer) {
-
-    const uniforms = this.material.uniforms;
+    const uniforms = this.material.uniforms
 
     if (uniforms && uniforms.resolution) {
-
-      renderer.getViewport(_viewport);
-      this.material.uniforms.resolution.value.set(_viewport.z, _viewport.w);
-
+      renderer.getViewport(_viewport)
+      this.material.uniforms.resolution.value.set(_viewport.z, _viewport.w)
     }
-
   }
 }
 
diff --git a/src/lines/LineSegmentsGeometry.js b/src/lines/LineSegmentsGeometry.js
index 967b2fcb..5b1fb7bb 100644
--- a/src/lines/LineSegmentsGeometry.js
+++ b/src/lines/LineSegmentsGeometry.js
@@ -9,8 +9,8 @@ import {
   WireframeGeometry,
 } from 'three'
 
-const _box = new Box3()
-const _vector = new Vector3()
+const _box = /* @__PURE__ */ new Box3()
+const _vector = /* @__PURE__ */ new Vector3()
 
 class LineSegmentsGeometry extends InstancedBufferGeometry {
   constructor() {
diff --git a/src/lines/Wireframe.js b/src/lines/Wireframe.js
index 5c3bfe87..5d97668b 100644
--- a/src/lines/Wireframe.js
+++ b/src/lines/Wireframe.js
@@ -2,9 +2,9 @@ import { InstancedInterleavedBuffer, InterleavedBufferAttribute, Mesh, Vector3,
 import { LineSegmentsGeometry } from '../lines/LineSegmentsGeometry'
 import { LineMaterial } from '../lines/LineMaterial'
 
-const _start = new Vector3()
-const _end = new Vector3()
-const _viewport = new Vector4();
+const _start = /* @__PURE__ */ new Vector3()
+const _end = /* @__PURE__ */ new Vector3()
+const _viewport = /* @__PURE__ */ new Vector4()
 
 class Wireframe extends Mesh {
   constructor(geometry = new LineSegmentsGeometry(), material = new LineMaterial({ color: Math.random() * 0xffffff })) {
@@ -41,16 +41,12 @@ class Wireframe extends Mesh {
   }
 
   onBeforeRender(renderer) {
-
-    const uniforms = this.material.uniforms;
+    const uniforms = this.material.uniforms
 
     if (uniforms && uniforms.resolution) {
-
-      renderer.getViewport(_viewport);
-      this.material.uniforms.resolution.value.set(_viewport.z, _viewport.w);
-
+      renderer.getViewport(_viewport)
+      this.material.uniforms.resolution.value.set(_viewport.z, _viewport.w)
     }
-
   }
 }
 
diff --git a/src/loaders/BasisTextureLoader.js b/src/loaders/BasisTextureLoader.js
index f568464c..6d2babf6 100644
--- a/src/loaders/BasisTextureLoader.js
+++ b/src/loaders/BasisTextureLoader.js
@@ -32,135 +32,174 @@ import {
 
 const _taskCache = new WeakMap()
 
-class BasisTextureLoader extends Loader {
-  /* CONSTANTS */
+const BasisTextureLoader = /* @__PURE__ */ (() => {
+  class BasisTextureLoader extends Loader {
+    /* CONSTANTS */
 
-  static BasisFormat = {
-    ETC1S: 0,
-    UASTC_4x4: 1,
-  }
+    static BasisFormat = {
+      ETC1S: 0,
+      UASTC_4x4: 1,
+    }
 
-  static TranscoderFormat = {
-    ETC1: 0,
-    ETC2: 1,
-    BC1: 2,
-    BC3: 3,
-    BC4: 4,
-    BC5: 5,
-    BC7_M6_OPAQUE_ONLY: 6,
-    BC7_M5: 7,
-    PVRTC1_4_RGB: 8,
-    PVRTC1_4_RGBA: 9,
-    ASTC_4x4: 10,
-    ATC_RGB: 11,
-    ATC_RGBA_INTERPOLATED_ALPHA: 12,
-    RGBA32: 13,
-    RGB565: 14,
-    BGR565: 15,
-    RGBA4444: 16,
-  }
+    static TranscoderFormat = {
+      ETC1: 0,
+      ETC2: 1,
+      BC1: 2,
+      BC3: 3,
+      BC4: 4,
+      BC5: 5,
+      BC7_M6_OPAQUE_ONLY: 6,
+      BC7_M5: 7,
+      PVRTC1_4_RGB: 8,
+      PVRTC1_4_RGBA: 9,
+      ASTC_4x4: 10,
+      ATC_RGB: 11,
+      ATC_RGBA_INTERPOLATED_ALPHA: 12,
+      RGBA32: 13,
+      RGB565: 14,
+      BGR565: 15,
+      RGBA4444: 16,
+    }
 
-  static EngineFormat = {
-    RGBAFormat: RGBAFormat,
-    RGBA_ASTC_4x4_Format: RGBA_ASTC_4x4_Format,
-    RGBA_BPTC_Format: RGBA_BPTC_Format,
-    RGBA_ETC2_EAC_Format: RGBA_ETC2_EAC_Format,
-    RGBA_PVRTC_4BPPV1_Format: RGBA_PVRTC_4BPPV1_Format,
-    RGBA_S3TC_DXT5_Format: RGBA_S3TC_DXT5_Format,
-    RGB_ETC1_Format: RGB_ETC1_Format,
-    RGB_ETC2_Format: RGB_ETC2_Format,
-    RGB_PVRTC_4BPPV1_Format: RGB_PVRTC_4BPPV1_Format,
-    RGB_S3TC_DXT1_Format: RGB_S3TC_DXT1_Format,
-  }
+    static EngineFormat = {
+      RGBAFormat: RGBAFormat,
+      RGBA_ASTC_4x4_Format: RGBA_ASTC_4x4_Format,
+      RGBA_BPTC_Format: RGBA_BPTC_Format,
+      RGBA_ETC2_EAC_Format: RGBA_ETC2_EAC_Format,
+      RGBA_PVRTC_4BPPV1_Format: RGBA_PVRTC_4BPPV1_Format,
+      RGBA_S3TC_DXT5_Format: RGBA_S3TC_DXT5_Format,
+      RGB_ETC1_Format: RGB_ETC1_Format,
+      RGB_ETC2_Format: RGB_ETC2_Format,
+      RGB_PVRTC_4BPPV1_Format: RGB_PVRTC_4BPPV1_Format,
+      RGB_S3TC_DXT1_Format: RGB_S3TC_DXT1_Format,
+    }
 
-  /* WEB WORKER */
+    /* WEB WORKER */
 
-  static BasisWorker = function () {
-    let config
-    let transcoderPending
-    let BasisModule
+    static BasisWorker = function () {
+      let config
+      let transcoderPending
+      let BasisModule
 
-    const EngineFormat = _EngineFormat
-    const TranscoderFormat = _TranscoderFormat
-    const BasisFormat = _BasisFormat
+      const EngineFormat = _EngineFormat
+      const TranscoderFormat = _TranscoderFormat
+      const BasisFormat = _BasisFormat
 
-    onmessage = function (e) {
-      const message = e.data
+      onmessage = function (e) {
+        const message = e.data
 
-      switch (message.type) {
-        case 'init':
-          config = message.config
-          init(message.transcoderBinary)
-          break
+        switch (message.type) {
+          case 'init':
+            config = message.config
+            init(message.transcoderBinary)
+            break
 
-        case 'transcode':
-          transcoderPending.then(() => {
-            try {
-              const { width, height, hasAlpha, mipmaps, format } = message.taskConfig.lowLevel
-                ? transcodeLowLevel(message.taskConfig)
-                : transcode(message.buffers[0])
+          case 'transcode':
+            transcoderPending.then(() => {
+              try {
+                const { width, height, hasAlpha, mipmaps, format } = message.taskConfig.lowLevel
+                  ? transcodeLowLevel(message.taskConfig)
+                  : transcode(message.buffers[0])
 
-              const buffers = []
+                const buffers = []
 
-              for (let i = 0; i < mipmaps.length; ++i) {
-                buffers.push(mipmaps[i].data.buffer)
-              }
+                for (let i = 0; i < mipmaps.length; ++i) {
+                  buffers.push(mipmaps[i].data.buffer)
+                }
 
-              self.postMessage({ type: 'transcode', id: message.id, width, height, hasAlpha, mipmaps, format }, buffers)
-            } catch (error) {
-              console.error(error)
+                self.postMessage(
+                  { type: 'transcode', id: message.id, width, height, hasAlpha, mipmaps, format },
+                  buffers,
+                )
+              } catch (error) {
+                console.error(error)
 
-              self.postMessage({ type: 'error', id: message.id, error: error.message })
-            }
-          })
-          break
+                self.postMessage({ type: 'error', id: message.id, error: error.message })
+              }
+            })
+            break
+        }
       }
-    }
 
-    function init(wasmBinary) {
-      transcoderPending = new Promise((resolve) => {
-        BasisModule = { wasmBinary, onRuntimeInitialized: resolve }
-        BASIS(BasisModule)
-      }).then(() => {
-        BasisModule.initializeBasis()
-      })
-    }
+      function init(wasmBinary) {
+        transcoderPending = new Promise((resolve) => {
+          BasisModule = { wasmBinary, onRuntimeInitialized: resolve }
+          BASIS(BasisModule)
+        }).then(() => {
+          BasisModule.initializeBasis()
+        })
+      }
+
+      function transcodeLowLevel(taskConfig) {
+        const { basisFormat, width, height, hasAlpha } = taskConfig
+
+        const { transcoderFormat, engineFormat } = getTranscoderFormat(basisFormat, width, height, hasAlpha)
+
+        const blockByteLength = BasisModule.getBytesPerBlockOrPixel(transcoderFormat)
 
-    function transcodeLowLevel(taskConfig) {
-      const { basisFormat, width, height, hasAlpha } = taskConfig
+        assert(BasisModule.isFormatSupported(transcoderFormat), 'THREE.BasisTextureLoader: Unsupported format.')
 
-      const { transcoderFormat, engineFormat } = getTranscoderFormat(basisFormat, width, height, hasAlpha)
+        const mipmaps = []
 
-      const blockByteLength = BasisModule.getBytesPerBlockOrPixel(transcoderFormat)
+        if (basisFormat === BasisFormat.ETC1S) {
+          const transcoder = new BasisModule.LowLevelETC1SImageTranscoder()
 
-      assert(BasisModule.isFormatSupported(transcoderFormat), 'THREE.BasisTextureLoader: Unsupported format.')
+          const { endpointCount, endpointsData, selectorCount, selectorsData, tablesData } = taskConfig.globalData
 
-      const mipmaps = []
+          try {
+            let ok
 
-      if (basisFormat === BasisFormat.ETC1S) {
-        const transcoder = new BasisModule.LowLevelETC1SImageTranscoder()
+            ok = transcoder.decodePalettes(endpointCount, endpointsData, selectorCount, selectorsData)
 
-        const { endpointCount, endpointsData, selectorCount, selectorsData, tablesData } = taskConfig.globalData
+            assert(ok, 'THREE.BasisTextureLoader: decodePalettes() failed.')
 
-        try {
-          let ok
+            ok = transcoder.decodeTables(tablesData)
 
-          ok = transcoder.decodePalettes(endpointCount, endpointsData, selectorCount, selectorsData)
+            assert(ok, 'THREE.BasisTextureLoader: decodeTables() failed.')
 
-          assert(ok, 'THREE.BasisTextureLoader: decodePalettes() failed.')
+            for (let i = 0; i < taskConfig.levels.length; i++) {
+              const level = taskConfig.levels[i]
+              const imageDesc = taskConfig.globalData.imageDescs[i]
 
-          ok = transcoder.decodeTables(tablesData)
+              const dstByteLength = getTranscodedImageByteLength(transcoderFormat, level.width, level.height)
+              const dst = new Uint8Array(dstByteLength)
 
-          assert(ok, 'THREE.BasisTextureLoader: decodeTables() failed.')
+              ok = transcoder.transcodeImage(
+                transcoderFormat,
+                dst,
+                dstByteLength / blockByteLength,
+                level.data,
+                getWidthInBlocks(transcoderFormat, level.width),
+                getHeightInBlocks(transcoderFormat, level.height),
+                level.width,
+                level.height,
+                level.index,
+                imageDesc.rgbSliceByteOffset,
+                imageDesc.rgbSliceByteLength,
+                imageDesc.alphaSliceByteOffset,
+                imageDesc.alphaSliceByteLength,
+                imageDesc.imageFlags,
+                hasAlpha,
+                false,
+                0,
+                0,
+              )
 
+              assert(ok, 'THREE.BasisTextureLoader: transcodeImage() failed for level ' + level.index + '.')
+
+              mipmaps.push({ data: dst, width: level.width, height: level.height })
+            }
+          } finally {
+            transcoder.delete()
+          }
+        } else {
           for (let i = 0; i < taskConfig.levels.length; i++) {
             const level = taskConfig.levels[i]
-            const imageDesc = taskConfig.globalData.imageDescs[i]
 
             const dstByteLength = getTranscodedImageByteLength(transcoderFormat, level.width, level.height)
             const dst = new Uint8Array(dstByteLength)
 
-            ok = transcoder.transcodeImage(
+            const ok = BasisModule.transcodeUASTCImage(
               transcoderFormat,
               dst,
               dstByteLength / blockByteLength,
@@ -170,487 +209,455 @@ class BasisTextureLoader extends Loader {
               level.width,
               level.height,
               level.index,
-              imageDesc.rgbSliceByteOffset,
-              imageDesc.rgbSliceByteLength,
-              imageDesc.alphaSliceByteOffset,
-              imageDesc.alphaSliceByteLength,
-              imageDesc.imageFlags,
+              0,
+              level.data.byteLength,
+              0,
               hasAlpha,
               false,
               0,
               0,
+              -1,
+              -1,
             )
 
-            assert(ok, 'THREE.BasisTextureLoader: transcodeImage() failed for level ' + level.index + '.')
+            assert(ok, 'THREE.BasisTextureLoader: transcodeUASTCImage() failed for level ' + level.index + '.')
 
             mipmaps.push({ data: dst, width: level.width, height: level.height })
           }
-        } finally {
-          transcoder.delete()
-        }
-      } else {
-        for (let i = 0; i < taskConfig.levels.length; i++) {
-          const level = taskConfig.levels[i]
-
-          const dstByteLength = getTranscodedImageByteLength(transcoderFormat, level.width, level.height)
-          const dst = new Uint8Array(dstByteLength)
-
-          const ok = BasisModule.transcodeUASTCImage(
-            transcoderFormat,
-            dst,
-            dstByteLength / blockByteLength,
-            level.data,
-            getWidthInBlocks(transcoderFormat, level.width),
-            getHeightInBlocks(transcoderFormat, level.height),
-            level.width,
-            level.height,
-            level.index,
-            0,
-            level.data.byteLength,
-            0,
-            hasAlpha,
-            false,
-            0,
-            0,
-            -1,
-            -1,
-          )
-
-          assert(ok, 'THREE.BasisTextureLoader: transcodeUASTCImage() failed for level ' + level.index + '.')
-
-          mipmaps.push({ data: dst, width: level.width, height: level.height })
         }
+
+        return { width, height, hasAlpha, mipmaps, format: engineFormat }
       }
 
-      return { width, height, hasAlpha, mipmaps, format: engineFormat }
-    }
+      function transcode(buffer) {
+        const basisFile = new BasisModule.BasisFile(new Uint8Array(buffer))
 
-    function transcode(buffer) {
-      const basisFile = new BasisModule.BasisFile(new Uint8Array(buffer))
+        const basisFormat = basisFile.isUASTC() ? BasisFormat.UASTC_4x4 : BasisFormat.ETC1S
+        const width = basisFile.getImageWidth(0, 0)
+        const height = basisFile.getImageHeight(0, 0)
+        const levels = basisFile.getNumLevels(0)
+        const hasAlpha = basisFile.getHasAlpha()
 
-      const basisFormat = basisFile.isUASTC() ? BasisFormat.UASTC_4x4 : BasisFormat.ETC1S
-      const width = basisFile.getImageWidth(0, 0)
-      const height = basisFile.getImageHeight(0, 0)
-      const levels = basisFile.getNumLevels(0)
-      const hasAlpha = basisFile.getHasAlpha()
+        function cleanup() {
+          basisFile.close()
+          basisFile.delete()
+        }
 
-      function cleanup() {
-        basisFile.close()
-        basisFile.delete()
-      }
+        const { transcoderFormat, engineFormat } = getTranscoderFormat(basisFormat, width, height, hasAlpha)
 
-      const { transcoderFormat, engineFormat } = getTranscoderFormat(basisFormat, width, height, hasAlpha)
+        if (!width || !height || !levels) {
+          cleanup()
+          throw new Error('THREE.BasisTextureLoader:	Invalid texture')
+        }
 
-      if (!width || !height || !levels) {
-        cleanup()
-        throw new Error('THREE.BasisTextureLoader:	Invalid texture')
-      }
+        if (!basisFile.startTranscoding()) {
+          cleanup()
+          throw new Error('THREE.BasisTextureLoader: .startTranscoding failed')
+        }
 
-      if (!basisFile.startTranscoding()) {
-        cleanup()
-        throw new Error('THREE.BasisTextureLoader: .startTranscoding failed')
-      }
+        const mipmaps = []
 
-      const mipmaps = []
+        for (let mip = 0; mip < levels; mip++) {
+          const mipWidth = basisFile.getImageWidth(0, mip)
+          const mipHeight = basisFile.getImageHeight(0, mip)
+          const dst = new Uint8Array(basisFile.getImageTranscodedSizeInBytes(0, mip, transcoderFormat))
 
-      for (let mip = 0; mip < levels; mip++) {
-        const mipWidth = basisFile.getImageWidth(0, mip)
-        const mipHeight = basisFile.getImageHeight(0, mip)
-        const dst = new Uint8Array(basisFile.getImageTranscodedSizeInBytes(0, mip, transcoderFormat))
+          const status = basisFile.transcodeImage(dst, 0, mip, transcoderFormat, 0, hasAlpha)
 
-        const status = basisFile.transcodeImage(dst, 0, mip, transcoderFormat, 0, hasAlpha)
+          if (!status) {
+            cleanup()
+            throw new Error('THREE.BasisTextureLoader: .transcodeImage failed.')
+          }
 
-        if (!status) {
-          cleanup()
-          throw new Error('THREE.BasisTextureLoader: .transcodeImage failed.')
+          mipmaps.push({ data: dst, width: mipWidth, height: mipHeight })
         }
 
-        mipmaps.push({ data: dst, width: mipWidth, height: mipHeight })
+        cleanup()
+
+        return { width, height, hasAlpha, mipmaps, format: engineFormat }
       }
 
-      cleanup()
+      //
+
+      // Optimal choice of a transcoder target format depends on the Basis format (ETC1S or UASTC),
+      // device capabilities, and texture dimensions. The list below ranks the formats separately
+      // for ETC1S and UASTC.
+      //
+      // In some cases, transcoding UASTC to RGBA32 might be preferred for higher quality (at
+      // significant memory cost) compared to ETC1/2, BC1/3, and PVRTC. The transcoder currently
+      // chooses RGBA32 only as a last resort and does not expose that option to the caller.
+      const FORMAT_OPTIONS = [
+        {
+          if: 'astcSupported',
+          basisFormat: [BasisFormat.UASTC_4x4],
+          transcoderFormat: [TranscoderFormat.ASTC_4x4, TranscoderFormat.ASTC_4x4],
+          engineFormat: [EngineFormat.RGBA_ASTC_4x4_Format, EngineFormat.RGBA_ASTC_4x4_Format],
+          priorityETC1S: Infinity,
+          priorityUASTC: 1,
+          needsPowerOfTwo: false,
+        },
+        {
+          if: 'bptcSupported',
+          basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
+          transcoderFormat: [TranscoderFormat.BC7_M5, TranscoderFormat.BC7_M5],
+          engineFormat: [EngineFormat.RGBA_BPTC_Format, EngineFormat.RGBA_BPTC_Format],
+          priorityETC1S: 3,
+          priorityUASTC: 2,
+          needsPowerOfTwo: false,
+        },
+        {
+          if: 'dxtSupported',
+          basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
+          transcoderFormat: [TranscoderFormat.BC1, TranscoderFormat.BC3],
+          engineFormat: [EngineFormat.RGB_S3TC_DXT1_Format, EngineFormat.RGBA_S3TC_DXT5_Format],
+          priorityETC1S: 4,
+          priorityUASTC: 5,
+          needsPowerOfTwo: false,
+        },
+        {
+          if: 'etc2Supported',
+          basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
+          transcoderFormat: [TranscoderFormat.ETC1, TranscoderFormat.ETC2],
+          engineFormat: [EngineFormat.RGB_ETC2_Format, EngineFormat.RGBA_ETC2_EAC_Format],
+          priorityETC1S: 1,
+          priorityUASTC: 3,
+          needsPowerOfTwo: false,
+        },
+        {
+          if: 'etc1Supported',
+          basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
+          transcoderFormat: [TranscoderFormat.ETC1, TranscoderFormat.ETC1],
+          engineFormat: [EngineFormat.RGB_ETC1_Format, EngineFormat.RGB_ETC1_Format],
+          priorityETC1S: 2,
+          priorityUASTC: 4,
+          needsPowerOfTwo: false,
+        },
+        {
+          if: 'pvrtcSupported',
+          basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
+          transcoderFormat: [TranscoderFormat.PVRTC1_4_RGB, TranscoderFormat.PVRTC1_4_RGBA],
+          engineFormat: [EngineFormat.RGB_PVRTC_4BPPV1_Format, EngineFormat.RGBA_PVRTC_4BPPV1_Format],
+          priorityETC1S: 5,
+          priorityUASTC: 6,
+          needsPowerOfTwo: true,
+        },
+      ]
+
+      const ETC1S_OPTIONS = FORMAT_OPTIONS.sort(function (a, b) {
+        return a.priorityETC1S - b.priorityETC1S
+      })
+      const UASTC_OPTIONS = FORMAT_OPTIONS.sort(function (a, b) {
+        return a.priorityUASTC - b.priorityUASTC
+      })
 
-      return { width, height, hasAlpha, mipmaps, format: engineFormat }
-    }
+      function getTranscoderFormat(basisFormat, width, height, hasAlpha) {
+        let transcoderFormat
+        let engineFormat
 
-    //
-
-    // Optimal choice of a transcoder target format depends on the Basis format (ETC1S or UASTC),
-    // device capabilities, and texture dimensions. The list below ranks the formats separately
-    // for ETC1S and UASTC.
-    //
-    // In some cases, transcoding UASTC to RGBA32 might be preferred for higher quality (at
-    // significant memory cost) compared to ETC1/2, BC1/3, and PVRTC. The transcoder currently
-    // chooses RGBA32 only as a last resort and does not expose that option to the caller.
-    const FORMAT_OPTIONS = [
-      {
-        if: 'astcSupported',
-        basisFormat: [BasisFormat.UASTC_4x4],
-        transcoderFormat: [TranscoderFormat.ASTC_4x4, TranscoderFormat.ASTC_4x4],
-        engineFormat: [EngineFormat.RGBA_ASTC_4x4_Format, EngineFormat.RGBA_ASTC_4x4_Format],
-        priorityETC1S: Infinity,
-        priorityUASTC: 1,
-        needsPowerOfTwo: false,
-      },
-      {
-        if: 'bptcSupported',
-        basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
-        transcoderFormat: [TranscoderFormat.BC7_M5, TranscoderFormat.BC7_M5],
-        engineFormat: [EngineFormat.RGBA_BPTC_Format, EngineFormat.RGBA_BPTC_Format],
-        priorityETC1S: 3,
-        priorityUASTC: 2,
-        needsPowerOfTwo: false,
-      },
-      {
-        if: 'dxtSupported',
-        basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
-        transcoderFormat: [TranscoderFormat.BC1, TranscoderFormat.BC3],
-        engineFormat: [EngineFormat.RGB_S3TC_DXT1_Format, EngineFormat.RGBA_S3TC_DXT5_Format],
-        priorityETC1S: 4,
-        priorityUASTC: 5,
-        needsPowerOfTwo: false,
-      },
-      {
-        if: 'etc2Supported',
-        basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
-        transcoderFormat: [TranscoderFormat.ETC1, TranscoderFormat.ETC2],
-        engineFormat: [EngineFormat.RGB_ETC2_Format, EngineFormat.RGBA_ETC2_EAC_Format],
-        priorityETC1S: 1,
-        priorityUASTC: 3,
-        needsPowerOfTwo: false,
-      },
-      {
-        if: 'etc1Supported',
-        basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
-        transcoderFormat: [TranscoderFormat.ETC1, TranscoderFormat.ETC1],
-        engineFormat: [EngineFormat.RGB_ETC1_Format, EngineFormat.RGB_ETC1_Format],
-        priorityETC1S: 2,
-        priorityUASTC: 4,
-        needsPowerOfTwo: false,
-      },
-      {
-        if: 'pvrtcSupported',
-        basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
-        transcoderFormat: [TranscoderFormat.PVRTC1_4_RGB, TranscoderFormat.PVRTC1_4_RGBA],
-        engineFormat: [EngineFormat.RGB_PVRTC_4BPPV1_Format, EngineFormat.RGBA_PVRTC_4BPPV1_Format],
-        priorityETC1S: 5,
-        priorityUASTC: 6,
-        needsPowerOfTwo: true,
-      },
-    ]
-
-    const ETC1S_OPTIONS = FORMAT_OPTIONS.sort(function (a, b) {
-      return a.priorityETC1S - b.priorityETC1S
-    })
-    const UASTC_OPTIONS = FORMAT_OPTIONS.sort(function (a, b) {
-      return a.priorityUASTC - b.priorityUASTC
-    })
-
-    function getTranscoderFormat(basisFormat, width, height, hasAlpha) {
-      let transcoderFormat
-      let engineFormat
-
-      const options = basisFormat === BasisFormat.ETC1S ? ETC1S_OPTIONS : UASTC_OPTIONS
-
-      for (let i = 0; i < options.length; i++) {
-        const opt = options[i]
-
-        if (!config[opt.if]) continue
-        if (!opt.basisFormat.includes(basisFormat)) continue
-        if (opt.needsPowerOfTwo && !(isPowerOfTwo(width) && isPowerOfTwo(height))) continue
-
-        transcoderFormat = opt.transcoderFormat[hasAlpha ? 1 : 0]
-        engineFormat = opt.engineFormat[hasAlpha ? 1 : 0]
+        const options = basisFormat === BasisFormat.ETC1S ? ETC1S_OPTIONS : UASTC_OPTIONS
 
-        return { transcoderFormat, engineFormat }
-      }
-
-      console.warn('THREE.BasisTextureLoader: No suitable compressed texture format found. Decoding to RGBA32.')
+        for (let i = 0; i < options.length; i++) {
+          const opt = options[i]
 
-      transcoderFormat = TranscoderFormat.RGBA32
-      engineFormat = EngineFormat.RGBAFormat
+          if (!config[opt.if]) continue
+          if (!opt.basisFormat.includes(basisFormat)) continue
+          if (opt.needsPowerOfTwo && !(isPowerOfTwo(width) && isPowerOfTwo(height))) continue
 
-      return { transcoderFormat, engineFormat }
-    }
+          transcoderFormat = opt.transcoderFormat[hasAlpha ? 1 : 0]
+          engineFormat = opt.engineFormat[hasAlpha ? 1 : 0]
 
-    function assert(ok, message) {
-      if (!ok) throw new Error(message)
-    }
+          return { transcoderFormat, engineFormat }
+        }
 
-    function getWidthInBlocks(transcoderFormat, width) {
-      return Math.ceil(width / BasisModule.getFormatBlockWidth(transcoderFormat))
-    }
+        console.warn('THREE.BasisTextureLoader: No suitable compressed texture format found. Decoding to RGBA32.')
 
-    function getHeightInBlocks(transcoderFormat, height) {
-      return Math.ceil(height / BasisModule.getFormatBlockHeight(transcoderFormat))
-    }
+        transcoderFormat = TranscoderFormat.RGBA32
+        engineFormat = EngineFormat.RGBAFormat
 
-    function getTranscodedImageByteLength(transcoderFormat, width, height) {
-      const blockByteLength = BasisModule.getBytesPerBlockOrPixel(transcoderFormat)
+        return { transcoderFormat, engineFormat }
+      }
 
-      if (BasisModule.formatIsUncompressed(transcoderFormat)) {
-        return width * height * blockByteLength
+      function assert(ok, message) {
+        if (!ok) throw new Error(message)
       }
 
-      if (transcoderFormat === TranscoderFormat.PVRTC1_4_RGB || transcoderFormat === TranscoderFormat.PVRTC1_4_RGBA) {
-        // GL requires extra padding for very small textures:
-        // https://www.khronos.org/registry/OpenGL/extensions/IMG/IMG_texture_compression_pvrtc.txt
-        const paddedWidth = (width + 3) & ~3
-        const paddedHeight = (height + 3) & ~3
+      function getWidthInBlocks(transcoderFormat, width) {
+        return Math.ceil(width / BasisModule.getFormatBlockWidth(transcoderFormat))
+      }
 
-        return (Math.max(8, paddedWidth) * Math.max(8, paddedHeight) * 4 + 7) / 8
+      function getHeightInBlocks(transcoderFormat, height) {
+        return Math.ceil(height / BasisModule.getFormatBlockHeight(transcoderFormat))
       }
 
-      return getWidthInBlocks(transcoderFormat, width) * getHeightInBlocks(transcoderFormat, height) * blockByteLength
-    }
+      function getTranscodedImageByteLength(transcoderFormat, width, height) {
+        const blockByteLength = BasisModule.getBytesPerBlockOrPixel(transcoderFormat)
 
-    function isPowerOfTwo(value) {
-      if (value <= 2) return true
+        if (BasisModule.formatIsUncompressed(transcoderFormat)) {
+          return width * height * blockByteLength
+        }
 
-      return (value & (value - 1)) === 0 && value !== 0
-    }
-  }
+        if (transcoderFormat === TranscoderFormat.PVRTC1_4_RGB || transcoderFormat === TranscoderFormat.PVRTC1_4_RGBA) {
+          // GL requires extra padding for very small textures:
+          // https://www.khronos.org/registry/OpenGL/extensions/IMG/IMG_texture_compression_pvrtc.txt
+          const paddedWidth = (width + 3) & ~3
+          const paddedHeight = (height + 3) & ~3
 
-  constructor(manager) {
-    super(manager)
+          return (Math.max(8, paddedWidth) * Math.max(8, paddedHeight) * 4 + 7) / 8
+        }
 
-    this.transcoderPath = ''
-    this.transcoderBinary = null
-    this.transcoderPending = null
+        return getWidthInBlocks(transcoderFormat, width) * getHeightInBlocks(transcoderFormat, height) * blockByteLength
+      }
 
-    this.workerLimit = 4
-    this.workerPool = []
-    this.workerNextTaskID = 1
-    this.workerSourceURL = ''
-    this.workerConfig = null
-  }
+      function isPowerOfTwo(value) {
+        if (value <= 2) return true
 
-  setTranscoderPath(path) {
-    this.transcoderPath = path
+        return (value & (value - 1)) === 0 && value !== 0
+      }
+    }
 
-    return this
-  }
+    constructor(manager) {
+      super(manager)
 
-  setWorkerLimit(workerLimit) {
-    this.workerLimit = workerLimit
+      this.transcoderPath = ''
+      this.transcoderBinary = null
+      this.transcoderPending = null
 
-    return this
-  }
+      this.workerLimit = 4
+      this.workerPool = []
+      this.workerNextTaskID = 1
+      this.workerSourceURL = ''
+      this.workerConfig = null
+    }
 
-  detectSupport(renderer) {
-    this.workerConfig = {
-      astcSupported: renderer.extensions.has('WEBGL_compressed_texture_astc'),
-      etc1Supported: renderer.extensions.has('WEBGL_compressed_texture_etc1'),
-      etc2Supported: renderer.extensions.has('WEBGL_compressed_texture_etc'),
-      dxtSupported: renderer.extensions.has('WEBGL_compressed_texture_s3tc'),
-      bptcSupported: renderer.extensions.has('EXT_texture_compression_bptc'),
-      pvrtcSupported:
-        renderer.extensions.has('WEBGL_compressed_texture_pvrtc') ||
-        renderer.extensions.has('WEBKIT_WEBGL_compressed_texture_pvrtc'),
+    setTranscoderPath(path) {
+      this.transcoderPath = path
+
+      return this
     }
 
-    return this
-  }
+    setWorkerLimit(workerLimit) {
+      this.workerLimit = workerLimit
 
-  load(url, onLoad, onProgress, onError) {
-    const loader = new FileLoader(this.manager)
+      return this
+    }
 
-    loader.setResponseType('arraybuffer')
-    loader.setWithCredentials(this.withCredentials)
+    detectSupport(renderer) {
+      this.workerConfig = {
+        astcSupported: renderer.extensions.has('WEBGL_compressed_texture_astc'),
+        etc1Supported: renderer.extensions.has('WEBGL_compressed_texture_etc1'),
+        etc2Supported: renderer.extensions.has('WEBGL_compressed_texture_etc'),
+        dxtSupported: renderer.extensions.has('WEBGL_compressed_texture_s3tc'),
+        bptcSupported: renderer.extensions.has('EXT_texture_compression_bptc'),
+        pvrtcSupported:
+          renderer.extensions.has('WEBGL_compressed_texture_pvrtc') ||
+          renderer.extensions.has('WEBKIT_WEBGL_compressed_texture_pvrtc'),
+      }
 
-    const texture = new CompressedTexture()
+      return this
+    }
 
-    loader.load(
-      url,
-      (buffer) => {
-        // Check for an existing task using this buffer. A transferred buffer cannot be transferred
-        // again from this thread.
-        if (_taskCache.has(buffer)) {
-          const cachedTask = _taskCache.get(buffer)
+    load(url, onLoad, onProgress, onError) {
+      const loader = new FileLoader(this.manager)
 
-          return cachedTask.promise.then(onLoad).catch(onError)
-        }
+      loader.setResponseType('arraybuffer')
+      loader.setWithCredentials(this.withCredentials)
 
-        this._createTexture([buffer])
-          .then(function (_texture) {
-            texture.copy(_texture)
-            texture.needsUpdate = true
+      const texture = new CompressedTexture()
 
-            if (onLoad) onLoad(texture)
-          })
-          .catch(onError)
-      },
-      onProgress,
-      onError,
-    )
+      loader.load(
+        url,
+        (buffer) => {
+          // Check for an existing task using this buffer. A transferred buffer cannot be transferred
+          // again from this thread.
+          if (_taskCache.has(buffer)) {
+            const cachedTask = _taskCache.get(buffer)
 
-    return texture
-  }
+            return cachedTask.promise.then(onLoad).catch(onError)
+          }
 
-  /** Low-level transcoding API, exposed for use by KTX2Loader. */
-  parseInternalAsync(options) {
-    const { levels } = options
+          this._createTexture([buffer])
+            .then(function (_texture) {
+              texture.copy(_texture)
+              texture.needsUpdate = true
 
-    const buffers = new Set()
+              if (onLoad) onLoad(texture)
+            })
+            .catch(onError)
+        },
+        onProgress,
+        onError,
+      )
 
-    for (let i = 0; i < levels.length; i++) {
-      buffers.add(levels[i].data.buffer)
+      return texture
     }
 
-    return this._createTexture(Array.from(buffers), { ...options, lowLevel: true })
-  }
+    /** Low-level transcoding API, exposed for use by KTX2Loader. */
+    parseInternalAsync(options) {
+      const { levels } = options
 
-  /**
-   * @param {ArrayBuffer[]} buffers
-   * @param {object?} config
-   * @return {Promise<CompressedTexture>}
-   */
-  _createTexture(buffers, config = {}) {
-    let worker
-    let taskID
+      const buffers = new Set()
 
-    const taskConfig = config
-    let taskCost = 0
+      for (let i = 0; i < levels.length; i++) {
+        buffers.add(levels[i].data.buffer)
+      }
 
-    for (let i = 0; i < buffers.length; i++) {
-      taskCost += buffers[i].byteLength
+      return this._createTexture(Array.from(buffers), { ...options, lowLevel: true })
     }
 
-    const texturePending = this._allocateWorker(taskCost)
-      .then((_worker) => {
-        worker = _worker
-        taskID = this.workerNextTaskID++
+    /**
+     * @param {ArrayBuffer[]} buffers
+     * @param {object?} config
+     * @return {Promise<CompressedTexture>}
+     */
+    _createTexture(buffers, config = {}) {
+      let worker
+      let taskID
 
-        return new Promise((resolve, reject) => {
-          worker._callbacks[taskID] = { resolve, reject }
+      const taskConfig = config
+      let taskCost = 0
 
-          worker.postMessage({ type: 'transcode', id: taskID, buffers: buffers, taskConfig: taskConfig }, buffers)
-        })
-      })
-      .then((message) => {
-        const { mipmaps, width, height, format } = message
+      for (let i = 0; i < buffers.length; i++) {
+        taskCost += buffers[i].byteLength
+      }
 
-        const texture = new CompressedTexture(mipmaps, width, height, format, UnsignedByteType)
-        texture.minFilter = mipmaps.length === 1 ? LinearFilter : LinearMipmapLinearFilter
-        texture.magFilter = LinearFilter
-        texture.generateMipmaps = false
-        texture.needsUpdate = true
+      const texturePending = this._allocateWorker(taskCost)
+        .then((_worker) => {
+          worker = _worker
+          taskID = this.workerNextTaskID++
 
-        return texture
-      })
+          return new Promise((resolve, reject) => {
+            worker._callbacks[taskID] = { resolve, reject }
 
-    // Note: replaced '.finally()' with '.catch().then()' block - iOS 11 support (#19416)
-    texturePending
-      .catch(() => true)
-      .then(() => {
-        if (worker && taskID) {
-          worker._taskLoad -= taskCost
-          delete worker._callbacks[taskID]
-        }
-      })
+            worker.postMessage({ type: 'transcode', id: taskID, buffers: buffers, taskConfig: taskConfig }, buffers)
+          })
+        })
+        .then((message) => {
+          const { mipmaps, width, height, format } = message
 
-    // Cache the task result.
-    _taskCache.set(buffers[0], { promise: texturePending })
+          const texture = new CompressedTexture(mipmaps, width, height, format, UnsignedByteType)
+          texture.minFilter = mipmaps.length === 1 ? LinearFilter : LinearMipmapLinearFilter
+          texture.magFilter = LinearFilter
+          texture.generateMipmaps = false
+          texture.needsUpdate = true
 
-    return texturePending
-  }
+          return texture
+        })
 
-  _initTranscoder() {
-    if (!this.transcoderPending) {
-      // Load transcoder wrapper.
-      const jsLoader = new FileLoader(this.manager)
-      jsLoader.setPath(this.transcoderPath)
-      jsLoader.setWithCredentials(this.withCredentials)
-      const jsContent = new Promise((resolve, reject) => {
-        jsLoader.load('basis_transcoder.js', resolve, undefined, reject)
-      })
+      // Note: replaced '.finally()' with '.catch().then()' block - iOS 11 support (#19416)
+      texturePending
+        .catch(() => true)
+        .then(() => {
+          if (worker && taskID) {
+            worker._taskLoad -= taskCost
+            delete worker._callbacks[taskID]
+          }
+        })
 
-      // Load transcoder WASM binary.
-      const binaryLoader = new FileLoader(this.manager)
-      binaryLoader.setPath(this.transcoderPath)
-      binaryLoader.setResponseType('arraybuffer')
-      binaryLoader.setWithCredentials(this.withCredentials)
-      const binaryContent = new Promise((resolve, reject) => {
-        binaryLoader.load('basis_transcoder.wasm', resolve, undefined, reject)
-      })
+      // Cache the task result.
+      _taskCache.set(buffers[0], { promise: texturePending })
 
-      this.transcoderPending = Promise.all([jsContent, binaryContent]).then(([jsContent, binaryContent]) => {
-        const fn = BasisTextureLoader.BasisWorker.toString()
-
-        const body = [
-          '/* constants */',
-          'let _EngineFormat = ' + JSON.stringify(BasisTextureLoader.EngineFormat),
-          'let _TranscoderFormat = ' + JSON.stringify(BasisTextureLoader.TranscoderFormat),
-          'let _BasisFormat = ' + JSON.stringify(BasisTextureLoader.BasisFormat),
-          '/* basis_transcoder.js */',
-          jsContent,
-          '/* worker */',
-          fn.substring(fn.indexOf('{') + 1, fn.lastIndexOf('}')),
-        ].join('\n')
-
-        this.workerSourceURL = URL.createObjectURL(new Blob([body]))
-        this.transcoderBinary = binaryContent
-      })
+      return texturePending
     }
 
-    return this.transcoderPending
-  }
-
-  _allocateWorker(taskCost) {
-    return this._initTranscoder().then(() => {
-      if (this.workerPool.length < this.workerLimit) {
-        const worker = new Worker(this.workerSourceURL)
+    _initTranscoder() {
+      if (!this.transcoderPending) {
+        // Load transcoder wrapper.
+        const jsLoader = new FileLoader(this.manager)
+        jsLoader.setPath(this.transcoderPath)
+        jsLoader.setWithCredentials(this.withCredentials)
+        const jsContent = new Promise((resolve, reject) => {
+          jsLoader.load('basis_transcoder.js', resolve, undefined, reject)
+        })
 
-        worker._callbacks = {}
-        worker._taskLoad = 0
+        // Load transcoder WASM binary.
+        const binaryLoader = new FileLoader(this.manager)
+        binaryLoader.setPath(this.transcoderPath)
+        binaryLoader.setResponseType('arraybuffer')
+        binaryLoader.setWithCredentials(this.withCredentials)
+        const binaryContent = new Promise((resolve, reject) => {
+          binaryLoader.load('basis_transcoder.wasm', resolve, undefined, reject)
+        })
 
-        worker.postMessage({
-          type: 'init',
-          config: this.workerConfig,
-          transcoderBinary: this.transcoderBinary,
+        this.transcoderPending = Promise.all([jsContent, binaryContent]).then(([jsContent, binaryContent]) => {
+          const fn = BasisTextureLoader.BasisWorker.toString()
+
+          const body = [
+            '/* constants */',
+            'let _EngineFormat = ' + JSON.stringify(BasisTextureLoader.EngineFormat),
+            'let _TranscoderFormat = ' + JSON.stringify(BasisTextureLoader.TranscoderFormat),
+            'let _BasisFormat = ' + JSON.stringify(BasisTextureLoader.BasisFormat),
+            '/* basis_transcoder.js */',
+            jsContent,
+            '/* worker */',
+            fn.substring(fn.indexOf('{') + 1, fn.lastIndexOf('}')),
+          ].join('\n')
+
+          this.workerSourceURL = URL.createObjectURL(new Blob([body]))
+          this.transcoderBinary = binaryContent
         })
+      }
 
-        worker.onmessage = function (e) {
-          const message = e.data
+      return this.transcoderPending
+    }
 
-          switch (message.type) {
-            case 'transcode':
-              worker._callbacks[message.id].resolve(message)
-              break
+    _allocateWorker(taskCost) {
+      return this._initTranscoder().then(() => {
+        if (this.workerPool.length < this.workerLimit) {
+          const worker = new Worker(this.workerSourceURL)
 
-            case 'error':
-              worker._callbacks[message.id].reject(message)
-              break
+          worker._callbacks = {}
+          worker._taskLoad = 0
 
-            default:
-              console.error('THREE.BasisTextureLoader: Unexpected message, "' + message.type + '"')
-          }
-        }
+          worker.postMessage({
+            type: 'init',
+            config: this.workerConfig,
+            transcoderBinary: this.transcoderBinary,
+          })
 
-        this.workerPool.push(worker)
-      } else {
-        this.workerPool.sort(function (a, b) {
-          return a._taskLoad > b._taskLoad ? -1 : 1
-        })
-      }
+          worker.onmessage = function (e) {
+            const message = e.data
 
-      const worker = this.workerPool[this.workerPool.length - 1]
+            switch (message.type) {
+              case 'transcode':
+                worker._callbacks[message.id].resolve(message)
+                break
 
-      worker._taskLoad += taskCost
+              case 'error':
+                worker._callbacks[message.id].reject(message)
+                break
 
-      return worker
-    })
-  }
+              default:
+                console.error('THREE.BasisTextureLoader: Unexpected message, "' + message.type + '"')
+            }
+          }
+
+          this.workerPool.push(worker)
+        } else {
+          this.workerPool.sort(function (a, b) {
+            return a._taskLoad > b._taskLoad ? -1 : 1
+          })
+        }
 
-  dispose() {
-    for (let i = 0; i < this.workerPool.length; i++) {
-      this.workerPool[i].terminate()
+        const worker = this.workerPool[this.workerPool.length - 1]
+
+        worker._taskLoad += taskCost
+
+        return worker
+      })
     }
 
-    this.workerPool.length = 0
+    dispose() {
+      for (let i = 0; i < this.workerPool.length; i++) {
+        this.workerPool[i].terminate()
+      }
 
-    return this
+      this.workerPool.length = 0
+
+      return this
+    }
   }
-}
+
+  return BasisTextureLoader
+})()
 
 export { BasisTextureLoader }
diff --git a/src/loaders/EXRLoader.js b/src/loaders/EXRLoader.js
index fd311038..002bfefd 100644
--- a/src/loaders/EXRLoader.js
+++ b/src/loaders/EXRLoader.js
@@ -9,6 +9,7 @@ import {
   RGBAFormat,
 } from 'three'
 import { unzlibSync } from 'fflate'
+import { version } from '../_polyfill/constants'
 
 /**
  * OpenEXR loader currently supports uncompressed, ZIP(S), RLE, PIZ and DWA/B compression.
@@ -83,7 +84,8 @@ import { unzlibSync } from 'fflate'
 
 // // End of OpenEXR license -------------------------------------------------
 
-const hasColorSpace = 'colorSpace' in new Texture()
+// https://github.com/mrdoob/three.js/pull/25771
+const hasColorSpace = version >= 152
 
 class EXRLoader extends DataTextureLoader {
   constructor(manager) {
diff --git a/src/loaders/FBXLoader.js b/src/loaders/FBXLoader.js
index e171ec87..034e4bb3 100644
--- a/src/loaders/FBXLoader.js
+++ b/src/loaders/FBXLoader.js
@@ -1275,8 +1275,8 @@ class GeometryParser {
     }
 
     buffers.uvs.forEach(function (uvBuffer, i) {
-      if (UV1 === 'uv2') i++;
-      const name = i === 0 ? 'uv' : `uv${i}`;
+      if (UV1 === 'uv2') i++
+      const name = i === 0 ? 'uv' : `uv${i}`
 
       geo.setAttribute(name, new Float32BufferAttribute(buffers.uvs[i], 2))
     })
@@ -3113,8 +3113,8 @@ function getData(polygonVertexIndex, polygonIndex, vertexIndex, infoObject) {
   return slice(dataArray, infoObject.buffer, from, to)
 }
 
-const tempEuler = new Euler()
-const tempVec = new Vector3()
+const tempEuler = /* @__PURE__ */ new Euler()
+const tempVec = /* @__PURE__ */ new Vector3()
 
 // generate transformation from FBX transform data
 // ref: https://help.autodesk.com/view/FBX/2017/ENU/?guid=__files_GUID_10CDD63C_79C1_4F2D_BB28_AD2BE65A02ED_htm
diff --git a/src/loaders/FontLoader.ts b/src/loaders/FontLoader.ts
index cb0e4ee4..00aa0643 100644
--- a/src/loaders/FontLoader.ts
+++ b/src/loaders/FontLoader.ts
@@ -66,8 +66,8 @@ type FontData = {
 
 export class Font {
   public data: FontData
-  public static isFont: true
-  public static type: 'Font'
+  public isFont = true
+  public type = 'Font'
 
   constructor(data: FontData) {
     this.data = data
diff --git a/src/loaders/GLTFLoader.js b/src/loaders/GLTFLoader.js
index c4b7d01c..dd037655 100644
--- a/src/loaders/GLTFLoader.js
+++ b/src/loaders/GLTFLoader.js
@@ -1676,7 +1676,7 @@ class GLTFCubicSplineInterpolant extends Interpolant {
   }
 }
 
-const _q = new Quaternion()
+const _q = /* @__PURE__ */ new Quaternion()
 
 class GLTFCubicSplineQuaternionInterpolant extends GLTFCubicSplineInterpolant {
   interpolate_(i1, t0, t, t1) {
@@ -2006,7 +2006,7 @@ function getImageURIMimeType(uri) {
   return 'image/png'
 }
 
-const _identityMatrix = new Matrix4()
+const _identityMatrix = /* @__PURE__ */ new Matrix4()
 
 /* GLTF PARSER */
 
diff --git a/src/loaders/KTX2Loader.js b/src/loaders/KTX2Loader.js
index f2b25571..ae2758c7 100644
--- a/src/loaders/KTX2Loader.js
+++ b/src/loaders/KTX2Loader.js
@@ -81,534 +81,538 @@ let _activeLoaders = 0
 
 let _zstd
 
-class KTX2Loader extends Loader {
-  /* CONSTANTS */
+const KTX2Loader = /* @__PURE__ */ (() => {
+  class KTX2Loader extends Loader {
+    /* CONSTANTS */
 
-  static BasisFormat = {
-    ETC1S: 0,
-    UASTC_4x4: 1,
-  }
-
-  static TranscoderFormat = {
-    ETC1: 0,
-    ETC2: 1,
-    BC1: 2,
-    BC3: 3,
-    BC4: 4,
-    BC5: 5,
-    BC7_M6_OPAQUE_ONLY: 6,
-    BC7_M5: 7,
-    PVRTC1_4_RGB: 8,
-    PVRTC1_4_RGBA: 9,
-    ASTC_4x4: 10,
-    ATC_RGB: 11,
-    ATC_RGBA_INTERPOLATED_ALPHA: 12,
-    RGBA32: 13,
-    RGB565: 14,
-    BGR565: 15,
-    RGBA4444: 16,
-  }
-
-  static EngineFormat = {
-    RGBAFormat: RGBAFormat,
-    RGBA_ASTC_4x4_Format: RGBA_ASTC_4x4_Format,
-    RGBA_BPTC_Format: RGBA_BPTC_Format,
-    RGBA_ETC2_EAC_Format: RGBA_ETC2_EAC_Format,
-    RGBA_PVRTC_4BPPV1_Format: RGBA_PVRTC_4BPPV1_Format,
-    RGBA_S3TC_DXT5_Format: RGBA_S3TC_DXT5_Format,
-    RGB_ETC1_Format: RGB_ETC1_Format,
-    RGB_ETC2_Format: RGB_ETC2_Format,
-    RGB_PVRTC_4BPPV1_Format: RGB_PVRTC_4BPPV1_Format,
-    RGB_S3TC_DXT1_Format: RGB_S3TC_DXT1_Format,
-  }
+    static BasisFormat = {
+      ETC1S: 0,
+      UASTC_4x4: 1,
+    }
 
-  /* WEB WORKER */
-
-  static BasisWorker = function () {
-    let config
-    let transcoderPending
-    let BasisModule
-
-    /** @type KTX2Loader.EngineFormat */
-    const EngineFormat = _EngineFormat
-    /** @type KTX2Loader.TranscoderFormat */
-    const TranscoderFormat = _TranscoderFormat
-    /** @type KTX2Loader.BasisFormat */
-    const BasisFormat = _BasisFormat
-
-    self.addEventListener('message', function (e) {
-      const message = e.data
-
-      switch (message.type) {
-        case 'init':
-          config = message.config
-          init(message.transcoderBinary)
-          break
-
-        case 'transcode':
-          transcoderPending.then(() => {
-            try {
-              const { faces, buffers, width, height, hasAlpha, format, dfdFlags } = transcode(message.buffer)
-
-              self.postMessage(
-                { type: 'transcode', id: message.id, faces, width, height, hasAlpha, format, dfdFlags },
-                buffers,
-              )
-            } catch (error) {
-              console.error(error)
-
-              self.postMessage({ type: 'error', id: message.id, error: error.message })
-            }
-          })
-          break
-      }
-    })
+    static TranscoderFormat = {
+      ETC1: 0,
+      ETC2: 1,
+      BC1: 2,
+      BC3: 3,
+      BC4: 4,
+      BC5: 5,
+      BC7_M6_OPAQUE_ONLY: 6,
+      BC7_M5: 7,
+      PVRTC1_4_RGB: 8,
+      PVRTC1_4_RGBA: 9,
+      ASTC_4x4: 10,
+      ATC_RGB: 11,
+      ATC_RGBA_INTERPOLATED_ALPHA: 12,
+      RGBA32: 13,
+      RGB565: 14,
+      BGR565: 15,
+      RGBA4444: 16,
+    }
 
-    function init(wasmBinary) {
-      transcoderPending = new Promise((resolve) => {
-        BasisModule = { wasmBinary, onRuntimeInitialized: resolve }
-        BASIS(BasisModule)
-      }).then(() => {
-        BasisModule.initializeBasis()
+    static EngineFormat = {
+      RGBAFormat: RGBAFormat,
+      RGBA_ASTC_4x4_Format: RGBA_ASTC_4x4_Format,
+      RGBA_BPTC_Format: RGBA_BPTC_Format,
+      RGBA_ETC2_EAC_Format: RGBA_ETC2_EAC_Format,
+      RGBA_PVRTC_4BPPV1_Format: RGBA_PVRTC_4BPPV1_Format,
+      RGBA_S3TC_DXT5_Format: RGBA_S3TC_DXT5_Format,
+      RGB_ETC1_Format: RGB_ETC1_Format,
+      RGB_ETC2_Format: RGB_ETC2_Format,
+      RGB_PVRTC_4BPPV1_Format: RGB_PVRTC_4BPPV1_Format,
+      RGB_S3TC_DXT1_Format: RGB_S3TC_DXT1_Format,
+    }
 
-        if (BasisModule.KTX2File === undefined) {
-          console.warn('THREE.KTX2Loader: Please update Basis Universal transcoder.')
+    /* WEB WORKER */
+
+    static BasisWorker = function () {
+      let config
+      let transcoderPending
+      let BasisModule
+
+      /** @type KTX2Loader.EngineFormat */
+      const EngineFormat = _EngineFormat
+      /** @type KTX2Loader.TranscoderFormat */
+      const TranscoderFormat = _TranscoderFormat
+      /** @type KTX2Loader.BasisFormat */
+      const BasisFormat = _BasisFormat
+
+      self.addEventListener('message', function (e) {
+        const message = e.data
+
+        switch (message.type) {
+          case 'init':
+            config = message.config
+            init(message.transcoderBinary)
+            break
+
+          case 'transcode':
+            transcoderPending.then(() => {
+              try {
+                const { faces, buffers, width, height, hasAlpha, format, dfdFlags } = transcode(message.buffer)
+
+                self.postMessage(
+                  { type: 'transcode', id: message.id, faces, width, height, hasAlpha, format, dfdFlags },
+                  buffers,
+                )
+              } catch (error) {
+                console.error(error)
+
+                self.postMessage({ type: 'error', id: message.id, error: error.message })
+              }
+            })
+            break
         }
       })
-    }
-
-    function transcode(buffer) {
-      const ktx2File = new BasisModule.KTX2File(new Uint8Array(buffer))
-
-      function cleanup() {
-        ktx2File.close()
-        ktx2File.delete()
-      }
-
-      if (!ktx2File.isValid()) {
-        cleanup()
-        throw new Error('THREE.KTX2Loader:	Invalid or unsupported .ktx2 file')
-      }
-
-      const basisFormat = ktx2File.isUASTC() ? BasisFormat.UASTC_4x4 : BasisFormat.ETC1S
-      const width = ktx2File.getWidth()
-      const height = ktx2File.getHeight()
-      const layerCount = ktx2File.getLayers() || 1
-      const levelCount = ktx2File.getLevels()
-      const faceCount = ktx2File.getFaces()
-      const hasAlpha = ktx2File.getHasAlpha()
-      const dfdFlags = ktx2File.getDFDFlags()
 
-      const { transcoderFormat, engineFormat } = getTranscoderFormat(basisFormat, width, height, hasAlpha)
+      function init(wasmBinary) {
+        transcoderPending = new Promise((resolve) => {
+          BasisModule = { wasmBinary, onRuntimeInitialized: resolve }
+          BASIS(BasisModule)
+        }).then(() => {
+          BasisModule.initializeBasis()
 
-      if (!width || !height || !levelCount) {
-        cleanup()
-        throw new Error('THREE.KTX2Loader:	Invalid texture')
+          if (BasisModule.KTX2File === undefined) {
+            console.warn('THREE.KTX2Loader: Please update Basis Universal transcoder.')
+          }
+        })
       }
 
-      if (!ktx2File.startTranscoding()) {
-        cleanup()
-        throw new Error('THREE.KTX2Loader: .startTranscoding failed')
-      }
+      function transcode(buffer) {
+        const ktx2File = new BasisModule.KTX2File(new Uint8Array(buffer))
 
-      const faces = []
-      const buffers = []
+        function cleanup() {
+          ktx2File.close()
+          ktx2File.delete()
+        }
 
-      for (let face = 0; face < faceCount; face++) {
-        const mipmaps = []
+        if (!ktx2File.isValid()) {
+          cleanup()
+          throw new Error('THREE.KTX2Loader:	Invalid or unsupported .ktx2 file')
+        }
 
-        for (let mip = 0; mip < levelCount; mip++) {
-          const layerMips = []
+        const basisFormat = ktx2File.isUASTC() ? BasisFormat.UASTC_4x4 : BasisFormat.ETC1S
+        const width = ktx2File.getWidth()
+        const height = ktx2File.getHeight()
+        const layerCount = ktx2File.getLayers() || 1
+        const levelCount = ktx2File.getLevels()
+        const faceCount = ktx2File.getFaces()
+        const hasAlpha = ktx2File.getHasAlpha()
+        const dfdFlags = ktx2File.getDFDFlags()
 
-          let mipWidth, mipHeight
+        const { transcoderFormat, engineFormat } = getTranscoderFormat(basisFormat, width, height, hasAlpha)
 
-          for (let layer = 0; layer < layerCount; layer++) {
-            const levelInfo = ktx2File.getImageLevelInfo(mip, layer, face)
+        if (!width || !height || !levelCount) {
+          cleanup()
+          throw new Error('THREE.KTX2Loader:	Invalid texture')
+        }
 
-            if (
-              face === 0 &&
-              mip === 0 &&
-              layer === 0 &&
-              (levelInfo.origWidth % 4 !== 0 || levelInfo.origHeight % 4 !== 0)
-            ) {
-              console.warn('THREE.KTX2Loader: ETC1S and UASTC textures should use multiple-of-four dimensions.')
-            }
+        if (!ktx2File.startTranscoding()) {
+          cleanup()
+          throw new Error('THREE.KTX2Loader: .startTranscoding failed')
+        }
 
-            if (levelCount > 1) {
-              mipWidth = levelInfo.origWidth
-              mipHeight = levelInfo.origHeight
-            } else {
-              // Handles non-multiple-of-four dimensions in textures without mipmaps. Textures with
-              // mipmaps must use multiple-of-four dimensions, for some texture formats and APIs.
-              // See mrdoob/three.js#25908.
-              mipWidth = levelInfo.width
-              mipHeight = levelInfo.height
+        const faces = []
+        const buffers = []
+
+        for (let face = 0; face < faceCount; face++) {
+          const mipmaps = []
+
+          for (let mip = 0; mip < levelCount; mip++) {
+            const layerMips = []
+
+            let mipWidth, mipHeight
+
+            for (let layer = 0; layer < layerCount; layer++) {
+              const levelInfo = ktx2File.getImageLevelInfo(mip, layer, face)
+
+              if (
+                face === 0 &&
+                mip === 0 &&
+                layer === 0 &&
+                (levelInfo.origWidth % 4 !== 0 || levelInfo.origHeight % 4 !== 0)
+              ) {
+                console.warn('THREE.KTX2Loader: ETC1S and UASTC textures should use multiple-of-four dimensions.')
+              }
+
+              if (levelCount > 1) {
+                mipWidth = levelInfo.origWidth
+                mipHeight = levelInfo.origHeight
+              } else {
+                // Handles non-multiple-of-four dimensions in textures without mipmaps. Textures with
+                // mipmaps must use multiple-of-four dimensions, for some texture formats and APIs.
+                // See mrdoob/three.js#25908.
+                mipWidth = levelInfo.width
+                mipHeight = levelInfo.height
+              }
+
+              const dst = new Uint8Array(ktx2File.getImageTranscodedSizeInBytes(mip, layer, 0, transcoderFormat))
+              const status = ktx2File.transcodeImage(dst, mip, layer, face, transcoderFormat, 0, -1, -1)
+
+              if (!status) {
+                cleanup()
+                throw new Error('THREE.KTX2Loader: .transcodeImage failed.')
+              }
+
+              layerMips.push(dst)
             }
 
-            const dst = new Uint8Array(ktx2File.getImageTranscodedSizeInBytes(mip, layer, 0, transcoderFormat))
-            const status = ktx2File.transcodeImage(dst, mip, layer, face, transcoderFormat, 0, -1, -1)
+            const mipData = concat(layerMips)
 
-            if (!status) {
-              cleanup()
-              throw new Error('THREE.KTX2Loader: .transcodeImage failed.')
-            }
-
-            layerMips.push(dst)
+            mipmaps.push({ data: mipData, width: mipWidth, height: mipHeight })
+            buffers.push(mipData.buffer)
           }
 
-          const mipData = concat(layerMips)
-
-          mipmaps.push({ data: mipData, width: mipWidth, height: mipHeight })
-          buffers.push(mipData.buffer)
+          faces.push({ mipmaps, width, height, format: engineFormat })
         }
 
-        faces.push({ mipmaps, width, height, format: engineFormat })
+        cleanup()
+
+        return { faces, buffers, width, height, hasAlpha, format: engineFormat, dfdFlags }
       }
 
-      cleanup()
+      //
+
+      // Optimal choice of a transcoder target format depends on the Basis format (ETC1S or UASTC),
+      // device capabilities, and texture dimensions. The list below ranks the formats separately
+      // for ETC1S and UASTC.
+      //
+      // In some cases, transcoding UASTC to RGBA32 might be preferred for higher quality (at
+      // significant memory cost) compared to ETC1/2, BC1/3, and PVRTC. The transcoder currently
+      // chooses RGBA32 only as a last resort and does not expose that option to the caller.
+      const FORMAT_OPTIONS = [
+        {
+          if: 'astcSupported',
+          basisFormat: [BasisFormat.UASTC_4x4],
+          transcoderFormat: [TranscoderFormat.ASTC_4x4, TranscoderFormat.ASTC_4x4],
+          engineFormat: [EngineFormat.RGBA_ASTC_4x4_Format, EngineFormat.RGBA_ASTC_4x4_Format],
+          priorityETC1S: Infinity,
+          priorityUASTC: 1,
+          needsPowerOfTwo: false,
+        },
+        {
+          if: 'bptcSupported',
+          basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
+          transcoderFormat: [TranscoderFormat.BC7_M5, TranscoderFormat.BC7_M5],
+          engineFormat: [EngineFormat.RGBA_BPTC_Format, EngineFormat.RGBA_BPTC_Format],
+          priorityETC1S: 3,
+          priorityUASTC: 2,
+          needsPowerOfTwo: false,
+        },
+        {
+          if: 'dxtSupported',
+          basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
+          transcoderFormat: [TranscoderFormat.BC1, TranscoderFormat.BC3],
+          engineFormat: [EngineFormat.RGB_S3TC_DXT1_Format, EngineFormat.RGBA_S3TC_DXT5_Format],
+          priorityETC1S: 4,
+          priorityUASTC: 5,
+          needsPowerOfTwo: false,
+        },
+        {
+          if: 'etc2Supported',
+          basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
+          transcoderFormat: [TranscoderFormat.ETC1, TranscoderFormat.ETC2],
+          engineFormat: [EngineFormat.RGB_ETC2_Format, EngineFormat.RGBA_ETC2_EAC_Format],
+          priorityETC1S: 1,
+          priorityUASTC: 3,
+          needsPowerOfTwo: false,
+        },
+        {
+          if: 'etc1Supported',
+          basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
+          transcoderFormat: [TranscoderFormat.ETC1],
+          engineFormat: [EngineFormat.RGB_ETC1_Format],
+          priorityETC1S: 2,
+          priorityUASTC: 4,
+          needsPowerOfTwo: false,
+        },
+        {
+          if: 'pvrtcSupported',
+          basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
+          transcoderFormat: [TranscoderFormat.PVRTC1_4_RGB, TranscoderFormat.PVRTC1_4_RGBA],
+          engineFormat: [EngineFormat.RGB_PVRTC_4BPPV1_Format, EngineFormat.RGBA_PVRTC_4BPPV1_Format],
+          priorityETC1S: 5,
+          priorityUASTC: 6,
+          needsPowerOfTwo: true,
+        },
+      ]
+
+      const ETC1S_OPTIONS = FORMAT_OPTIONS.sort(function (a, b) {
+        return a.priorityETC1S - b.priorityETC1S
+      })
+      const UASTC_OPTIONS = FORMAT_OPTIONS.sort(function (a, b) {
+        return a.priorityUASTC - b.priorityUASTC
+      })
+
+      function getTranscoderFormat(basisFormat, width, height, hasAlpha) {
+        let transcoderFormat
+        let engineFormat
 
-      return { faces, buffers, width, height, hasAlpha, format: engineFormat, dfdFlags }
-    }
+        const options = basisFormat === BasisFormat.ETC1S ? ETC1S_OPTIONS : UASTC_OPTIONS
 
-    //
-
-    // Optimal choice of a transcoder target format depends on the Basis format (ETC1S or UASTC),
-    // device capabilities, and texture dimensions. The list below ranks the formats separately
-    // for ETC1S and UASTC.
-    //
-    // In some cases, transcoding UASTC to RGBA32 might be preferred for higher quality (at
-    // significant memory cost) compared to ETC1/2, BC1/3, and PVRTC. The transcoder currently
-    // chooses RGBA32 only as a last resort and does not expose that option to the caller.
-    const FORMAT_OPTIONS = [
-      {
-        if: 'astcSupported',
-        basisFormat: [BasisFormat.UASTC_4x4],
-        transcoderFormat: [TranscoderFormat.ASTC_4x4, TranscoderFormat.ASTC_4x4],
-        engineFormat: [EngineFormat.RGBA_ASTC_4x4_Format, EngineFormat.RGBA_ASTC_4x4_Format],
-        priorityETC1S: Infinity,
-        priorityUASTC: 1,
-        needsPowerOfTwo: false,
-      },
-      {
-        if: 'bptcSupported',
-        basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
-        transcoderFormat: [TranscoderFormat.BC7_M5, TranscoderFormat.BC7_M5],
-        engineFormat: [EngineFormat.RGBA_BPTC_Format, EngineFormat.RGBA_BPTC_Format],
-        priorityETC1S: 3,
-        priorityUASTC: 2,
-        needsPowerOfTwo: false,
-      },
-      {
-        if: 'dxtSupported',
-        basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
-        transcoderFormat: [TranscoderFormat.BC1, TranscoderFormat.BC3],
-        engineFormat: [EngineFormat.RGB_S3TC_DXT1_Format, EngineFormat.RGBA_S3TC_DXT5_Format],
-        priorityETC1S: 4,
-        priorityUASTC: 5,
-        needsPowerOfTwo: false,
-      },
-      {
-        if: 'etc2Supported',
-        basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
-        transcoderFormat: [TranscoderFormat.ETC1, TranscoderFormat.ETC2],
-        engineFormat: [EngineFormat.RGB_ETC2_Format, EngineFormat.RGBA_ETC2_EAC_Format],
-        priorityETC1S: 1,
-        priorityUASTC: 3,
-        needsPowerOfTwo: false,
-      },
-      {
-        if: 'etc1Supported',
-        basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
-        transcoderFormat: [TranscoderFormat.ETC1],
-        engineFormat: [EngineFormat.RGB_ETC1_Format],
-        priorityETC1S: 2,
-        priorityUASTC: 4,
-        needsPowerOfTwo: false,
-      },
-      {
-        if: 'pvrtcSupported',
-        basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
-        transcoderFormat: [TranscoderFormat.PVRTC1_4_RGB, TranscoderFormat.PVRTC1_4_RGBA],
-        engineFormat: [EngineFormat.RGB_PVRTC_4BPPV1_Format, EngineFormat.RGBA_PVRTC_4BPPV1_Format],
-        priorityETC1S: 5,
-        priorityUASTC: 6,
-        needsPowerOfTwo: true,
-      },
-    ]
-
-    const ETC1S_OPTIONS = FORMAT_OPTIONS.sort(function (a, b) {
-      return a.priorityETC1S - b.priorityETC1S
-    })
-    const UASTC_OPTIONS = FORMAT_OPTIONS.sort(function (a, b) {
-      return a.priorityUASTC - b.priorityUASTC
-    })
+        for (let i = 0; i < options.length; i++) {
+          const opt = options[i]
 
-    function getTranscoderFormat(basisFormat, width, height, hasAlpha) {
-      let transcoderFormat
-      let engineFormat
+          if (!config[opt.if]) continue
+          if (!opt.basisFormat.includes(basisFormat)) continue
+          if (hasAlpha && opt.transcoderFormat.length < 2) continue
+          if (opt.needsPowerOfTwo && !(isPowerOfTwo(width) && isPowerOfTwo(height))) continue
 
-      const options = basisFormat === BasisFormat.ETC1S ? ETC1S_OPTIONS : UASTC_OPTIONS
+          transcoderFormat = opt.transcoderFormat[hasAlpha ? 1 : 0]
+          engineFormat = opt.engineFormat[hasAlpha ? 1 : 0]
 
-      for (let i = 0; i < options.length; i++) {
-        const opt = options[i]
+          return { transcoderFormat, engineFormat }
+        }
 
-        if (!config[opt.if]) continue
-        if (!opt.basisFormat.includes(basisFormat)) continue
-        if (hasAlpha && opt.transcoderFormat.length < 2) continue
-        if (opt.needsPowerOfTwo && !(isPowerOfTwo(width) && isPowerOfTwo(height))) continue
+        console.warn('THREE.KTX2Loader: No suitable compressed texture format found. Decoding to RGBA32.')
 
-        transcoderFormat = opt.transcoderFormat[hasAlpha ? 1 : 0]
-        engineFormat = opt.engineFormat[hasAlpha ? 1 : 0]
+        transcoderFormat = TranscoderFormat.RGBA32
+        engineFormat = EngineFormat.RGBAFormat
 
         return { transcoderFormat, engineFormat }
       }
 
-      console.warn('THREE.KTX2Loader: No suitable compressed texture format found. Decoding to RGBA32.')
+      function isPowerOfTwo(value) {
+        if (value <= 2) return true
 
-      transcoderFormat = TranscoderFormat.RGBA32
-      engineFormat = EngineFormat.RGBAFormat
-
-      return { transcoderFormat, engineFormat }
-    }
-
-    function isPowerOfTwo(value) {
-      if (value <= 2) return true
+        return (value & (value - 1)) === 0 && value !== 0
+      }
 
-      return (value & (value - 1)) === 0 && value !== 0
-    }
+      /** Concatenates N byte arrays. */
+      function concat(arrays) {
+        if (arrays.length === 1) return arrays[0]
 
-    /** Concatenates N byte arrays. */
-    function concat(arrays) {
-      if (arrays.length === 1) return arrays[0]
+        let totalByteLength = 0
 
-      let totalByteLength = 0
+        for (let i = 0; i < arrays.length; i++) {
+          const array = arrays[i]
+          totalByteLength += array.byteLength
+        }
 
-      for (let i = 0; i < arrays.length; i++) {
-        const array = arrays[i]
-        totalByteLength += array.byteLength
-      }
+        const result = new Uint8Array(totalByteLength)
 
-      const result = new Uint8Array(totalByteLength)
+        let byteOffset = 0
 
-      let byteOffset = 0
+        for (let i = 0; i < arrays.length; i++) {
+          const array = arrays[i]
+          result.set(array, byteOffset)
 
-      for (let i = 0; i < arrays.length; i++) {
-        const array = arrays[i]
-        result.set(array, byteOffset)
+          byteOffset += array.byteLength
+        }
 
-        byteOffset += array.byteLength
+        return result
       }
-
-      return result
     }
-  }
 
-  constructor(manager) {
-    super(manager)
+    constructor(manager) {
+      super(manager)
 
-    this.transcoderPath = ''
-    this.transcoderBinary = null
-    this.transcoderPending = null
+      this.transcoderPath = ''
+      this.transcoderBinary = null
+      this.transcoderPending = null
 
-    this.workerPool = new WorkerPool()
-    this.workerSourceURL = ''
-    this.workerConfig = null
+      this.workerPool = new WorkerPool()
+      this.workerSourceURL = ''
+      this.workerConfig = null
 
-    if (typeof MSC_TRANSCODER !== 'undefined') {
-      console.warn(
-        'THREE.KTX2Loader: Please update to latest "basis_transcoder".' +
-          ' "msc_basis_transcoder" is no longer supported in three.js r125+.',
-      )
+      if (typeof MSC_TRANSCODER !== 'undefined') {
+        console.warn(
+          'THREE.KTX2Loader: Please update to latest "basis_transcoder".' +
+            ' "msc_basis_transcoder" is no longer supported in three.js r125+.',
+        )
+      }
     }
-  }
 
-  setTranscoderPath(path) {
-    this.transcoderPath = path
+    setTranscoderPath(path) {
+      this.transcoderPath = path
 
-    return this
-  }
-
-  setWorkerLimit(num) {
-    this.workerPool.setWorkerLimit(num)
+      return this
+    }
 
-    return this
-  }
+    setWorkerLimit(num) {
+      this.workerPool.setWorkerLimit(num)
 
-  detectSupport(renderer) {
-    this.workerConfig = {
-      astcSupported: renderer.extensions.has('WEBGL_compressed_texture_astc'),
-      etc1Supported: renderer.extensions.has('WEBGL_compressed_texture_etc1'),
-      etc2Supported: renderer.extensions.has('WEBGL_compressed_texture_etc'),
-      dxtSupported: renderer.extensions.has('WEBGL_compressed_texture_s3tc'),
-      bptcSupported: renderer.extensions.has('EXT_texture_compression_bptc'),
-      pvrtcSupported:
-        renderer.extensions.has('WEBGL_compressed_texture_pvrtc') ||
-        renderer.extensions.has('WEBKIT_WEBGL_compressed_texture_pvrtc'),
+      return this
     }
 
-    if (renderer.capabilities.isWebGL2) {
-      // https://github.com/mrdoob/three.js/pull/22928
-      this.workerConfig.etc1Supported = false
-    }
+    detectSupport(renderer) {
+      this.workerConfig = {
+        astcSupported: renderer.extensions.has('WEBGL_compressed_texture_astc'),
+        etc1Supported: renderer.extensions.has('WEBGL_compressed_texture_etc1'),
+        etc2Supported: renderer.extensions.has('WEBGL_compressed_texture_etc'),
+        dxtSupported: renderer.extensions.has('WEBGL_compressed_texture_s3tc'),
+        bptcSupported: renderer.extensions.has('EXT_texture_compression_bptc'),
+        pvrtcSupported:
+          renderer.extensions.has('WEBGL_compressed_texture_pvrtc') ||
+          renderer.extensions.has('WEBKIT_WEBGL_compressed_texture_pvrtc'),
+      }
 
-    return this
-  }
+      if (renderer.capabilities.isWebGL2) {
+        // https://github.com/mrdoob/three.js/pull/22928
+        this.workerConfig.etc1Supported = false
+      }
+
+      return this
+    }
 
-  init() {
-    if (!this.transcoderPending) {
-      // Load transcoder wrapper.
-      const jsLoader = new FileLoader(this.manager)
-      jsLoader.setPath(this.transcoderPath)
-      jsLoader.setWithCredentials(this.withCredentials)
-      const jsContent = jsLoader.loadAsync('basis_transcoder.js')
-
-      // Load transcoder WASM binary.
-      const binaryLoader = new FileLoader(this.manager)
-      binaryLoader.setPath(this.transcoderPath)
-      binaryLoader.setResponseType('arraybuffer')
-      binaryLoader.setWithCredentials(this.withCredentials)
-      const binaryContent = binaryLoader.loadAsync('basis_transcoder.wasm')
-
-      this.transcoderPending = Promise.all([jsContent, binaryContent]).then(([jsContent, binaryContent]) => {
-        const fn = KTX2Loader.BasisWorker.toString()
-
-        const body = [
-          '/* constants */',
-          'let _EngineFormat = ' + JSON.stringify(KTX2Loader.EngineFormat),
-          'let _TranscoderFormat = ' + JSON.stringify(KTX2Loader.TranscoderFormat),
-          'let _BasisFormat = ' + JSON.stringify(KTX2Loader.BasisFormat),
-          '/* basis_transcoder.js */',
-          jsContent,
-          '/* worker */',
-          fn.substring(fn.indexOf('{') + 1, fn.lastIndexOf('}')),
-        ].join('\n')
-
-        this.workerSourceURL = URL.createObjectURL(new Blob([body]))
-        this.transcoderBinary = binaryContent
-
-        this.workerPool.setWorkerCreator(() => {
-          const worker = new Worker(this.workerSourceURL)
-          const transcoderBinary = this.transcoderBinary.slice(0)
-
-          worker.postMessage({ type: 'init', config: this.workerConfig, transcoderBinary }, [transcoderBinary])
-
-          return worker
+    init() {
+      if (!this.transcoderPending) {
+        // Load transcoder wrapper.
+        const jsLoader = new FileLoader(this.manager)
+        jsLoader.setPath(this.transcoderPath)
+        jsLoader.setWithCredentials(this.withCredentials)
+        const jsContent = jsLoader.loadAsync('basis_transcoder.js')
+
+        // Load transcoder WASM binary.
+        const binaryLoader = new FileLoader(this.manager)
+        binaryLoader.setPath(this.transcoderPath)
+        binaryLoader.setResponseType('arraybuffer')
+        binaryLoader.setWithCredentials(this.withCredentials)
+        const binaryContent = binaryLoader.loadAsync('basis_transcoder.wasm')
+
+        this.transcoderPending = Promise.all([jsContent, binaryContent]).then(([jsContent, binaryContent]) => {
+          const fn = KTX2Loader.BasisWorker.toString()
+
+          const body = [
+            '/* constants */',
+            'let _EngineFormat = ' + JSON.stringify(KTX2Loader.EngineFormat),
+            'let _TranscoderFormat = ' + JSON.stringify(KTX2Loader.TranscoderFormat),
+            'let _BasisFormat = ' + JSON.stringify(KTX2Loader.BasisFormat),
+            '/* basis_transcoder.js */',
+            jsContent,
+            '/* worker */',
+            fn.substring(fn.indexOf('{') + 1, fn.lastIndexOf('}')),
+          ].join('\n')
+
+          this.workerSourceURL = URL.createObjectURL(new Blob([body]))
+          this.transcoderBinary = binaryContent
+
+          this.workerPool.setWorkerCreator(() => {
+            const worker = new Worker(this.workerSourceURL)
+            const transcoderBinary = this.transcoderBinary.slice(0)
+
+            worker.postMessage({ type: 'init', config: this.workerConfig, transcoderBinary }, [transcoderBinary])
+
+            return worker
+          })
         })
-      })
 
-      if (_activeLoaders > 0) {
-        // Each instance loads a transcoder and allocates workers, increasing network and memory cost.
+        if (_activeLoaders > 0) {
+          // Each instance loads a transcoder and allocates workers, increasing network and memory cost.
 
-        console.warn(
-          'THREE.KTX2Loader: Multiple active KTX2 loaders may cause performance issues.' +
-            ' Use a single KTX2Loader instance, or call .dispose() on old instances.',
-        )
+          console.warn(
+            'THREE.KTX2Loader: Multiple active KTX2 loaders may cause performance issues.' +
+              ' Use a single KTX2Loader instance, or call .dispose() on old instances.',
+          )
+        }
+
+        _activeLoaders++
       }
 
-      _activeLoaders++
+      return this.transcoderPending
     }
 
-    return this.transcoderPending
-  }
-
-  load(url, onLoad, onProgress, onError) {
-    if (this.workerConfig === null) {
-      throw new Error('THREE.KTX2Loader: Missing initialization with `.detectSupport( renderer )`.')
-    }
+    load(url, onLoad, onProgress, onError) {
+      if (this.workerConfig === null) {
+        throw new Error('THREE.KTX2Loader: Missing initialization with `.detectSupport( renderer )`.')
+      }
 
-    const loader = new FileLoader(this.manager)
+      const loader = new FileLoader(this.manager)
 
-    loader.setResponseType('arraybuffer')
-    loader.setWithCredentials(this.withCredentials)
+      loader.setResponseType('arraybuffer')
+      loader.setWithCredentials(this.withCredentials)
 
-    loader.load(
-      url,
-      (buffer) => {
-        // Check for an existing task using this buffer. A transferred buffer cannot be transferred
-        // again from this thread.
-        if (_taskCache.has(buffer)) {
-          const cachedTask = _taskCache.get(buffer)
+      loader.load(
+        url,
+        (buffer) => {
+          // Check for an existing task using this buffer. A transferred buffer cannot be transferred
+          // again from this thread.
+          if (_taskCache.has(buffer)) {
+            const cachedTask = _taskCache.get(buffer)
 
-          return cachedTask.promise.then(onLoad).catch(onError)
-        }
+            return cachedTask.promise.then(onLoad).catch(onError)
+          }
 
-        this._createTexture(buffer)
-          .then((texture) => (onLoad ? onLoad(texture) : null))
-          .catch(onError)
-      },
-      onProgress,
-      onError,
-    )
-  }
+          this._createTexture(buffer)
+            .then((texture) => (onLoad ? onLoad(texture) : null))
+            .catch(onError)
+        },
+        onProgress,
+        onError,
+      )
+    }
 
-  _createTextureFrom(transcodeResult, container) {
-    const { faces, width, height, format, type, error, dfdFlags } = transcodeResult
+    _createTextureFrom(transcodeResult, container) {
+      const { faces, width, height, format, type, error, dfdFlags } = transcodeResult
 
-    if (type === 'error') return Promise.reject(error)
+      if (type === 'error') return Promise.reject(error)
 
-    let texture
+      let texture
 
-    if (container.faceCount === 6) {
-      texture = new CompressedCubeTexture(faces, format, UnsignedByteType)
-    } else {
-      const mipmaps = faces[0].mipmaps
+      if (container.faceCount === 6) {
+        texture = new CompressedCubeTexture(faces, format, UnsignedByteType)
+      } else {
+        const mipmaps = faces[0].mipmaps
 
-      texture =
-        container.layerCount > 1
-          ? new CompressedArrayTexture(mipmaps, width, height, container.layerCount, format, UnsignedByteType)
-          : new CompressedTexture(mipmaps, width, height, format, UnsignedByteType)
-    }
+        texture =
+          container.layerCount > 1
+            ? new CompressedArrayTexture(mipmaps, width, height, container.layerCount, format, UnsignedByteType)
+            : new CompressedTexture(mipmaps, width, height, format, UnsignedByteType)
+      }
 
-    texture.minFilter = faces[0].mipmaps.length === 1 ? LinearFilter : LinearMipmapLinearFilter
-    texture.magFilter = LinearFilter
-    texture.generateMipmaps = false
-    texture.needsUpdate = true
+      texture.minFilter = faces[0].mipmaps.length === 1 ? LinearFilter : LinearMipmapLinearFilter
+      texture.magFilter = LinearFilter
+      texture.generateMipmaps = false
+      texture.needsUpdate = true
 
-    const colorSpace = parseColorSpace(container)
-    if ('colorSpace' in texture) texture.colorSpace = colorSpace
-    else texture.encoding = colorSpace === SRGBColorSpace ? sRGBEncoding : LinearEncoding
+      const colorSpace = parseColorSpace(container)
+      if ('colorSpace' in texture) texture.colorSpace = colorSpace
+      else texture.encoding = colorSpace === SRGBColorSpace ? sRGBEncoding : LinearEncoding
 
-    texture.premultiplyAlpha = !!(dfdFlags & KHR_DF_FLAG_ALPHA_PREMULTIPLIED)
+      texture.premultiplyAlpha = !!(dfdFlags & KHR_DF_FLAG_ALPHA_PREMULTIPLIED)
 
-    return texture
-  }
+      return texture
+    }
 
-  /**
-   * @param {ArrayBuffer} buffer
-   * @param {object?} config
-   * @return {Promise<CompressedTexture|CompressedArrayTexture|DataTexture|Data3DTexture>}
-   */
-  async _createTexture(buffer, config = {}) {
-    const container = read(new Uint8Array(buffer))
+    /**
+     * @param {ArrayBuffer} buffer
+     * @param {object?} config
+     * @return {Promise<CompressedTexture|CompressedArrayTexture|DataTexture|Data3DTexture>}
+     */
+    async _createTexture(buffer, config = {}) {
+      const container = read(new Uint8Array(buffer))
 
-    if (container.vkFormat !== VK_FORMAT_UNDEFINED) {
-      return createRawTexture(container)
-    }
+      if (container.vkFormat !== VK_FORMAT_UNDEFINED) {
+        return createRawTexture(container)
+      }
 
-    //
+      //
 
-    const taskConfig = config
-    const texturePending = this.init()
-      .then(() => {
-        return this.workerPool.postMessage({ type: 'transcode', buffer, taskConfig: taskConfig }, [buffer])
-      })
-      .then((e) => this._createTextureFrom(e.data, container))
+      const taskConfig = config
+      const texturePending = this.init()
+        .then(() => {
+          return this.workerPool.postMessage({ type: 'transcode', buffer, taskConfig: taskConfig }, [buffer])
+        })
+        .then((e) => this._createTextureFrom(e.data, container))
 
-    // Cache the task result.
-    _taskCache.set(buffer, { promise: texturePending })
+      // Cache the task result.
+      _taskCache.set(buffer, { promise: texturePending })
 
-    return texturePending
-  }
+      return texturePending
+    }
 
-  dispose() {
-    this.workerPool.dispose()
-    if (this.workerSourceURL) URL.revokeObjectURL(this.workerSourceURL)
+    dispose() {
+      this.workerPool.dispose()
+      if (this.workerSourceURL) URL.revokeObjectURL(this.workerSourceURL)
 
-    _activeLoaders--
+      _activeLoaders--
 
-    return this
+      return this
+    }
   }
-}
+
+  return KTX2Loader
+})()
 
 //
 // Parsing for non-Basis textures. These textures are may have supercompression
diff --git a/src/loaders/LDrawLoader.js b/src/loaders/LDrawLoader.js
index 41c39c67..ea6323a6 100644
--- a/src/loaders/LDrawLoader.js
+++ b/src/loaders/LDrawLoader.js
@@ -15,8 +15,8 @@ import {
   UniformsUtils,
   Vector3,
   Ray,
-  REVISION,
 } from 'three'
+import { version } from '../_polyfill/constants'
 
 // Special surface finish tag types.
 // Note: "MATERIAL" tag (e.g. GLITTER, SPECKLE) is not implemented
@@ -40,8 +40,8 @@ const FILE_LOCATION_NOT_FOUND = 6
 const MAIN_COLOUR_CODE = '16'
 const MAIN_EDGE_COLOUR_CODE = '24'
 
-const _tempVec0 = new Vector3()
-const _tempVec1 = new Vector3()
+const _tempVec0 = /* @__PURE__ */ new Vector3()
+const _tempVec1 = /* @__PURE__ */ new Vector3()
 
 class LDrawConditionalLineMaterial extends ShaderMaterial {
   constructor(parameters) {
@@ -129,7 +129,7 @@ class LDrawConditionalLineMaterial extends ShaderMaterial {
           outgoingLight = diffuseColor.rgb; // simple shader
           gl_FragColor = vec4(outgoingLight, diffuseColor.a);
           #include <tonemapping_fragment>
-          #include <${parseInt(REVISION.replace(/\D+/g, '')) >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>
+          #include <${version >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>
           #include <fog_fragment>
           #include <premultiplied_alpha_fragment>
         }
@@ -180,7 +180,7 @@ function generateFaceNormals(faces) {
   }
 }
 
-const _ray = new Ray()
+const _ray = /* @__PURE__ */ new Ray()
 function smoothNormals(faces, lineSegments, checkSubSegments = false) {
   // NOTE: 1e2 is pretty coarse but was chosen to quantize the resulting value because
   // it allows edges to be smoothed as expected (see minifig arms).
diff --git a/src/loaders/OBJLoader.js b/src/loaders/OBJLoader.js
index f5a5ffce..82ffde04 100644
--- a/src/loaders/OBJLoader.js
+++ b/src/loaders/OBJLoader.js
@@ -23,12 +23,12 @@ const _material_use_pattern = /^usemtl /
 // usemap map_name
 const _map_use_pattern = /^usemap /
 
-const _vA = new Vector3()
-const _vB = new Vector3()
-const _vC = new Vector3()
+const _vA = /* @__PURE__ */ new Vector3()
+const _vB = /* @__PURE__ */ new Vector3()
+const _vC = /* @__PURE__ */ new Vector3()
 
-const _ab = new Vector3()
-const _cb = new Vector3()
+const _ab = /* @__PURE__ */ new Vector3()
+const _cb = /* @__PURE__ */ new Vector3()
 
 function ParserState() {
   const state = {
diff --git a/src/loaders/PRWMLoader.js b/src/loaders/PRWMLoader.js
index b839b1bf..a2604cc8 100644
--- a/src/loaders/PRWMLoader.js
+++ b/src/loaders/PRWMLoader.js
@@ -168,65 +168,69 @@ function decodePrwm(buffer) {
 
 // Define the public interface
 
-class PRWMLoader extends Loader {
-  constructor(manager) {
-    super(manager)
-  }
+const PRWMLoader = /* @__PURE__ */ (() => {
+  class PRWMLoader extends Loader {
+    constructor(manager) {
+      super(manager)
+    }
 
-  load(url, onLoad, onProgress, onError) {
-    const scope = this
-
-    const loader = new FileLoader(scope.manager)
-    loader.setPath(scope.path)
-    loader.setResponseType('arraybuffer')
-    loader.setRequestHeader(scope.requestHeader)
-    loader.setWithCredentials(scope.withCredentials)
-
-    url = url.replace(/\*/g, isBigEndianPlatform() ? 'be' : 'le')
-
-    loader.load(
-      url,
-      function (arrayBuffer) {
-        try {
-          onLoad(scope.parse(arrayBuffer))
-        } catch (e) {
-          if (onError) {
-            onError(e)
-          } else {
-            console.error(e)
+    load(url, onLoad, onProgress, onError) {
+      const scope = this
+
+      const loader = new FileLoader(scope.manager)
+      loader.setPath(scope.path)
+      loader.setResponseType('arraybuffer')
+      loader.setRequestHeader(scope.requestHeader)
+      loader.setWithCredentials(scope.withCredentials)
+
+      url = url.replace(/\*/g, isBigEndianPlatform() ? 'be' : 'le')
+
+      loader.load(
+        url,
+        function (arrayBuffer) {
+          try {
+            onLoad(scope.parse(arrayBuffer))
+          } catch (e) {
+            if (onError) {
+              onError(e)
+            } else {
+              console.error(e)
+            }
+
+            scope.manager.itemError(url)
           }
+        },
+        onProgress,
+        onError,
+      )
+    }
 
-          scope.manager.itemError(url)
-        }
-      },
-      onProgress,
-      onError,
-    )
-  }
+    parse(arrayBuffer) {
+      const data = decodePrwm(arrayBuffer),
+        attributesKey = Object.keys(data.attributes),
+        bufferGeometry = new BufferGeometry()
+
+      for (let i = 0; i < attributesKey.length; i++) {
+        const attribute = data.attributes[attributesKey[i]]
+        bufferGeometry.setAttribute(
+          attributesKey[i],
+          new BufferAttribute(attribute.values, attribute.cardinality, attribute.normalized),
+        )
+      }
 
-  parse(arrayBuffer) {
-    const data = decodePrwm(arrayBuffer),
-      attributesKey = Object.keys(data.attributes),
-      bufferGeometry = new BufferGeometry()
+      if (data.indices !== null) {
+        bufferGeometry.setIndex(new BufferAttribute(data.indices, 1))
+      }
 
-    for (let i = 0; i < attributesKey.length; i++) {
-      const attribute = data.attributes[attributesKey[i]]
-      bufferGeometry.setAttribute(
-        attributesKey[i],
-        new BufferAttribute(attribute.values, attribute.cardinality, attribute.normalized),
-      )
+      return bufferGeometry
     }
 
-    if (data.indices !== null) {
-      bufferGeometry.setIndex(new BufferAttribute(data.indices, 1))
+    static isBigEndianPlatform() {
+      return isBigEndianPlatform()
     }
-
-    return bufferGeometry
   }
 
-  static isBigEndianPlatform() {
-    return isBigEndianPlatform()
-  }
-}
+  return PRWMLoader
+})()
 
 export { PRWMLoader }
diff --git a/src/loaders/SVGLoader.js b/src/loaders/SVGLoader.js
index b8879e62..8bbb51c2 100644
--- a/src/loaders/SVGLoader.js
+++ b/src/loaders/SVGLoader.js
@@ -15,2513 +15,2520 @@ import {
 
 const COLOR_SPACE_SVG = 'srgb'
 
-class SVGLoader extends Loader {
-  constructor(manager) {
-    super(manager)
+const SVGLoader = /* @__PURE__ */ (() => {
+  class SVGLoader extends Loader {
+    constructor(manager) {
+      super(manager)
 
-    // Default dots per inch
-    this.defaultDPI = 90
+      // Default dots per inch
+      this.defaultDPI = 90
 
-    // Accepted units: 'mm', 'cm', 'in', 'pt', 'pc', 'px'
-    this.defaultUnit = 'px'
-  }
+      // Accepted units: 'mm', 'cm', 'in', 'pt', 'pc', 'px'
+      this.defaultUnit = 'px'
+    }
 
-  load(url, onLoad, onProgress, onError) {
-    const scope = this
-
-    const loader = new FileLoader(scope.manager)
-    loader.setPath(scope.path)
-    loader.setRequestHeader(scope.requestHeader)
-    loader.setWithCredentials(scope.withCredentials)
-    loader.load(
-      url,
-      function (text) {
-        try {
-          onLoad(scope.parse(text))
-        } catch (e) {
-          if (onError) {
-            onError(e)
-          } else {
-            console.error(e)
+    load(url, onLoad, onProgress, onError) {
+      const scope = this
+
+      const loader = new FileLoader(scope.manager)
+      loader.setPath(scope.path)
+      loader.setRequestHeader(scope.requestHeader)
+      loader.setWithCredentials(scope.withCredentials)
+      loader.load(
+        url,
+        function (text) {
+          try {
+            onLoad(scope.parse(text))
+          } catch (e) {
+            if (onError) {
+              onError(e)
+            } else {
+              console.error(e)
+            }
+
+            scope.manager.itemError(url)
           }
+        },
+        onProgress,
+        onError,
+      )
+    }
 
-          scope.manager.itemError(url)
-        }
-      },
-      onProgress,
-      onError,
-    )
-  }
+    parse(text) {
+      const scope = this
 
-  parse(text) {
-    const scope = this
+      function parseNode(node, style) {
+        if (node.nodeType !== 1) return
 
-    function parseNode(node, style) {
-      if (node.nodeType !== 1) return
+        const transform = getNodeTransform(node)
 
-      const transform = getNodeTransform(node)
+        let isDefsNode = false
 
-      let isDefsNode = false
+        let path = null
 
-      let path = null
+        switch (node.nodeName) {
+          case 'svg':
+            style = parseStyle(node, style)
+            break
 
-      switch (node.nodeName) {
-        case 'svg':
-          style = parseStyle(node, style)
-          break
+          case 'style':
+            parseCSSStylesheet(node)
+            break
 
-        case 'style':
-          parseCSSStylesheet(node)
-          break
+          case 'g':
+            style = parseStyle(node, style)
+            break
 
-        case 'g':
-          style = parseStyle(node, style)
-          break
+          case 'path':
+            style = parseStyle(node, style)
+            if (node.hasAttribute('d')) path = parsePathNode(node)
+            break
 
-        case 'path':
-          style = parseStyle(node, style)
-          if (node.hasAttribute('d')) path = parsePathNode(node)
-          break
+          case 'rect':
+            style = parseStyle(node, style)
+            path = parseRectNode(node)
+            break
 
-        case 'rect':
-          style = parseStyle(node, style)
-          path = parseRectNode(node)
-          break
+          case 'polygon':
+            style = parseStyle(node, style)
+            path = parsePolygonNode(node)
+            break
 
-        case 'polygon':
-          style = parseStyle(node, style)
-          path = parsePolygonNode(node)
-          break
+          case 'polyline':
+            style = parseStyle(node, style)
+            path = parsePolylineNode(node)
+            break
 
-        case 'polyline':
-          style = parseStyle(node, style)
-          path = parsePolylineNode(node)
-          break
+          case 'circle':
+            style = parseStyle(node, style)
+            path = parseCircleNode(node)
+            break
 
-        case 'circle':
-          style = parseStyle(node, style)
-          path = parseCircleNode(node)
-          break
+          case 'ellipse':
+            style = parseStyle(node, style)
+            path = parseEllipseNode(node)
+            break
 
-        case 'ellipse':
-          style = parseStyle(node, style)
-          path = parseEllipseNode(node)
-          break
+          case 'line':
+            style = parseStyle(node, style)
+            path = parseLineNode(node)
+            break
 
-        case 'line':
-          style = parseStyle(node, style)
-          path = parseLineNode(node)
-          break
+          case 'defs':
+            isDefsNode = true
+            break
 
-        case 'defs':
-          isDefsNode = true
-          break
+          case 'use':
+            style = parseStyle(node, style)
 
-        case 'use':
-          style = parseStyle(node, style)
+            const href = node.getAttributeNS('http://www.w3.org/1999/xlink', 'href') || ''
+            const usedNodeId = href.substring(1)
+            const usedNode = node.viewportElement.getElementById(usedNodeId)
+            if (usedNode) {
+              parseNode(usedNode, style)
+            } else {
+              console.warn("SVGLoader: 'use node' references non-existent node id: " + usedNodeId)
+            }
 
-          const href = node.getAttributeNS('http://www.w3.org/1999/xlink', 'href') || ''
-          const usedNodeId = href.substring(1)
-          const usedNode = node.viewportElement.getElementById(usedNodeId)
-          if (usedNode) {
-            parseNode(usedNode, style)
-          } else {
-            console.warn("SVGLoader: 'use node' references non-existent node id: " + usedNodeId)
-          }
+            break
 
-          break
+          default:
+          // console.log( node );
+        }
 
-        default:
-        // console.log( node );
-      }
+        if (path) {
+          if (style.fill !== undefined && style.fill !== 'none') {
+            path.color.setStyle(style.fill, COLOR_SPACE_SVG)
+          }
 
-      if (path) {
-        if (style.fill !== undefined && style.fill !== 'none') {
-          path.color.setStyle(style.fill, COLOR_SPACE_SVG)
-        }
+          transformPath(path, currentTransform)
 
-        transformPath(path, currentTransform)
+          paths.push(path)
 
-        paths.push(path)
+          path.userData = { node: node, style: style }
+        }
 
-        path.userData = { node: node, style: style }
-      }
+        const childNodes = node.childNodes
 
-      const childNodes = node.childNodes
+        for (let i = 0; i < childNodes.length; i++) {
+          const node = childNodes[i]
 
-      for (let i = 0; i < childNodes.length; i++) {
-        const node = childNodes[i]
+          if (isDefsNode && node.nodeName !== 'style' && node.nodeName !== 'defs') {
+            // Ignore everything in defs except CSS style definitions
+            // and nested defs, because it is OK by the standard to have
+            // <style/> there.
+            continue
+          }
 
-        if (isDefsNode && node.nodeName !== 'style' && node.nodeName !== 'defs') {
-          // Ignore everything in defs except CSS style definitions
-          // and nested defs, because it is OK by the standard to have
-          // <style/> there.
-          continue
+          parseNode(node, style)
         }
 
-        parseNode(node, style)
-      }
+        if (transform) {
+          transformStack.pop()
 
-      if (transform) {
-        transformStack.pop()
-
-        if (transformStack.length > 0) {
-          currentTransform.copy(transformStack[transformStack.length - 1])
-        } else {
-          currentTransform.identity()
+          if (transformStack.length > 0) {
+            currentTransform.copy(transformStack[transformStack.length - 1])
+          } else {
+            currentTransform.identity()
+          }
         }
       }
-    }
-
-    function parsePathNode(node) {
-      const path = new ShapePath()
-
-      const point = new Vector2()
-      const control = new Vector2()
 
-      const firstPoint = new Vector2()
-      let isFirstPoint = true
-      let doSetFirstPoint = false
+      function parsePathNode(node) {
+        const path = new ShapePath()
 
-      const d = node.getAttribute('d')
+        const point = new Vector2()
+        const control = new Vector2()
 
-      if (d === '' || d === 'none') return null
+        const firstPoint = new Vector2()
+        let isFirstPoint = true
+        let doSetFirstPoint = false
 
-      // console.log( d );
-
-      const commands = d.match(/[a-df-z][^a-df-z]*/gi)
-
-      for (let i = 0, l = commands.length; i < l; i++) {
-        const command = commands[i]
-
-        const type = command.charAt(0)
-        const data = command.slice(1).trim()
-
-        if (isFirstPoint === true) {
-          doSetFirstPoint = true
-          isFirstPoint = false
-        }
+        const d = node.getAttribute('d')
 
-        let numbers
+        if (d === '' || d === 'none') return null
 
-        switch (type) {
-          case 'M':
-            numbers = parseFloats(data)
-            for (let j = 0, jl = numbers.length; j < jl; j += 2) {
-              point.x = numbers[j + 0]
-              point.y = numbers[j + 1]
-              control.x = point.x
-              control.y = point.y
+        // console.log( d );
 
-              if (j === 0) {
-                path.moveTo(point.x, point.y)
-              } else {
-                path.lineTo(point.x, point.y)
-              }
+        const commands = d.match(/[a-df-z][^a-df-z]*/gi)
 
-              if (j === 0) firstPoint.copy(point)
-            }
+        for (let i = 0, l = commands.length; i < l; i++) {
+          const command = commands[i]
 
-            break
+          const type = command.charAt(0)
+          const data = command.slice(1).trim()
 
-          case 'H':
-            numbers = parseFloats(data)
+          if (isFirstPoint === true) {
+            doSetFirstPoint = true
+            isFirstPoint = false
+          }
 
-            for (let j = 0, jl = numbers.length; j < jl; j++) {
-              point.x = numbers[j]
-              control.x = point.x
-              control.y = point.y
-              path.lineTo(point.x, point.y)
+          let numbers
 
-              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
-            }
+          switch (type) {
+            case 'M':
+              numbers = parseFloats(data)
+              for (let j = 0, jl = numbers.length; j < jl; j += 2) {
+                point.x = numbers[j + 0]
+                point.y = numbers[j + 1]
+                control.x = point.x
+                control.y = point.y
 
-            break
+                if (j === 0) {
+                  path.moveTo(point.x, point.y)
+                } else {
+                  path.lineTo(point.x, point.y)
+                }
 
-          case 'V':
-            numbers = parseFloats(data)
+                if (j === 0) firstPoint.copy(point)
+              }
 
-            for (let j = 0, jl = numbers.length; j < jl; j++) {
-              point.y = numbers[j]
-              control.x = point.x
-              control.y = point.y
-              path.lineTo(point.x, point.y)
+              break
 
-              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
-            }
+            case 'H':
+              numbers = parseFloats(data)
 
-            break
+              for (let j = 0, jl = numbers.length; j < jl; j++) {
+                point.x = numbers[j]
+                control.x = point.x
+                control.y = point.y
+                path.lineTo(point.x, point.y)
 
-          case 'L':
-            numbers = parseFloats(data)
+                if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
+              }
 
-            for (let j = 0, jl = numbers.length; j < jl; j += 2) {
-              point.x = numbers[j + 0]
-              point.y = numbers[j + 1]
-              control.x = point.x
-              control.y = point.y
-              path.lineTo(point.x, point.y)
+              break
 
-              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
-            }
+            case 'V':
+              numbers = parseFloats(data)
 
-            break
+              for (let j = 0, jl = numbers.length; j < jl; j++) {
+                point.y = numbers[j]
+                control.x = point.x
+                control.y = point.y
+                path.lineTo(point.x, point.y)
 
-          case 'C':
-            numbers = parseFloats(data)
-
-            for (let j = 0, jl = numbers.length; j < jl; j += 6) {
-              path.bezierCurveTo(
-                numbers[j + 0],
-                numbers[j + 1],
-                numbers[j + 2],
-                numbers[j + 3],
-                numbers[j + 4],
-                numbers[j + 5],
-              )
-              control.x = numbers[j + 2]
-              control.y = numbers[j + 3]
-              point.x = numbers[j + 4]
-              point.y = numbers[j + 5]
-
-              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
-            }
+                if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
+              }
 
-            break
+              break
 
-          case 'S':
-            numbers = parseFloats(data)
-
-            for (let j = 0, jl = numbers.length; j < jl; j += 4) {
-              path.bezierCurveTo(
-                getReflection(point.x, control.x),
-                getReflection(point.y, control.y),
-                numbers[j + 0],
-                numbers[j + 1],
-                numbers[j + 2],
-                numbers[j + 3],
-              )
-              control.x = numbers[j + 0]
-              control.y = numbers[j + 1]
-              point.x = numbers[j + 2]
-              point.y = numbers[j + 3]
-
-              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
-            }
+            case 'L':
+              numbers = parseFloats(data)
 
-            break
+              for (let j = 0, jl = numbers.length; j < jl; j += 2) {
+                point.x = numbers[j + 0]
+                point.y = numbers[j + 1]
+                control.x = point.x
+                control.y = point.y
+                path.lineTo(point.x, point.y)
 
-          case 'Q':
-            numbers = parseFloats(data)
+                if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
+              }
 
-            for (let j = 0, jl = numbers.length; j < jl; j += 4) {
-              path.quadraticCurveTo(numbers[j + 0], numbers[j + 1], numbers[j + 2], numbers[j + 3])
-              control.x = numbers[j + 0]
-              control.y = numbers[j + 1]
-              point.x = numbers[j + 2]
-              point.y = numbers[j + 3]
+              break
 
-              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
-            }
+            case 'C':
+              numbers = parseFloats(data)
+
+              for (let j = 0, jl = numbers.length; j < jl; j += 6) {
+                path.bezierCurveTo(
+                  numbers[j + 0],
+                  numbers[j + 1],
+                  numbers[j + 2],
+                  numbers[j + 3],
+                  numbers[j + 4],
+                  numbers[j + 5],
+                )
+                control.x = numbers[j + 2]
+                control.y = numbers[j + 3]
+                point.x = numbers[j + 4]
+                point.y = numbers[j + 5]
+
+                if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
+              }
 
-            break
+              break
 
-          case 'T':
-            numbers = parseFloats(data)
+            case 'S':
+              numbers = parseFloats(data)
+
+              for (let j = 0, jl = numbers.length; j < jl; j += 4) {
+                path.bezierCurveTo(
+                  getReflection(point.x, control.x),
+                  getReflection(point.y, control.y),
+                  numbers[j + 0],
+                  numbers[j + 1],
+                  numbers[j + 2],
+                  numbers[j + 3],
+                )
+                control.x = numbers[j + 0]
+                control.y = numbers[j + 1]
+                point.x = numbers[j + 2]
+                point.y = numbers[j + 3]
+
+                if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
+              }
 
-            for (let j = 0, jl = numbers.length; j < jl; j += 2) {
-              const rx = getReflection(point.x, control.x)
-              const ry = getReflection(point.y, control.y)
-              path.quadraticCurveTo(rx, ry, numbers[j + 0], numbers[j + 1])
-              control.x = rx
-              control.y = ry
-              point.x = numbers[j + 0]
-              point.y = numbers[j + 1]
+              break
 
-              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
-            }
+            case 'Q':
+              numbers = parseFloats(data)
 
-            break
+              for (let j = 0, jl = numbers.length; j < jl; j += 4) {
+                path.quadraticCurveTo(numbers[j + 0], numbers[j + 1], numbers[j + 2], numbers[j + 3])
+                control.x = numbers[j + 0]
+                control.y = numbers[j + 1]
+                point.x = numbers[j + 2]
+                point.y = numbers[j + 3]
 
-          case 'A':
-            numbers = parseFloats(data, [3, 4], 7)
-
-            for (let j = 0, jl = numbers.length; j < jl; j += 7) {
-              // skip command if start point == end point
-              if (numbers[j + 5] == point.x && numbers[j + 6] == point.y) continue
-
-              const start = point.clone()
-              point.x = numbers[j + 5]
-              point.y = numbers[j + 6]
-              control.x = point.x
-              control.y = point.y
-              parseArcCommand(
-                path,
-                numbers[j],
-                numbers[j + 1],
-                numbers[j + 2],
-                numbers[j + 3],
-                numbers[j + 4],
-                start,
-                point,
-              )
-
-              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
-            }
+                if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
+              }
 
-            break
+              break
 
-          case 'm':
-            numbers = parseFloats(data)
+            case 'T':
+              numbers = parseFloats(data)
 
-            for (let j = 0, jl = numbers.length; j < jl; j += 2) {
-              point.x += numbers[j + 0]
-              point.y += numbers[j + 1]
-              control.x = point.x
-              control.y = point.y
+              for (let j = 0, jl = numbers.length; j < jl; j += 2) {
+                const rx = getReflection(point.x, control.x)
+                const ry = getReflection(point.y, control.y)
+                path.quadraticCurveTo(rx, ry, numbers[j + 0], numbers[j + 1])
+                control.x = rx
+                control.y = ry
+                point.x = numbers[j + 0]
+                point.y = numbers[j + 1]
 
-              if (j === 0) {
-                path.moveTo(point.x, point.y)
-              } else {
-                path.lineTo(point.x, point.y)
+                if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
               }
 
-              if (j === 0) firstPoint.copy(point)
-            }
+              break
 
-            break
+            case 'A':
+              numbers = parseFloats(data, [3, 4], 7)
+
+              for (let j = 0, jl = numbers.length; j < jl; j += 7) {
+                // skip command if start point == end point
+                if (numbers[j + 5] == point.x && numbers[j + 6] == point.y) continue
+
+                const start = point.clone()
+                point.x = numbers[j + 5]
+                point.y = numbers[j + 6]
+                control.x = point.x
+                control.y = point.y
+                parseArcCommand(
+                  path,
+                  numbers[j],
+                  numbers[j + 1],
+                  numbers[j + 2],
+                  numbers[j + 3],
+                  numbers[j + 4],
+                  start,
+                  point,
+                )
+
+                if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
+              }
 
-          case 'h':
-            numbers = parseFloats(data)
+              break
 
-            for (let j = 0, jl = numbers.length; j < jl; j++) {
-              point.x += numbers[j]
-              control.x = point.x
-              control.y = point.y
-              path.lineTo(point.x, point.y)
+            case 'm':
+              numbers = parseFloats(data)
 
-              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
-            }
+              for (let j = 0, jl = numbers.length; j < jl; j += 2) {
+                point.x += numbers[j + 0]
+                point.y += numbers[j + 1]
+                control.x = point.x
+                control.y = point.y
 
-            break
-
-          case 'v':
-            numbers = parseFloats(data)
+                if (j === 0) {
+                  path.moveTo(point.x, point.y)
+                } else {
+                  path.lineTo(point.x, point.y)
+                }
 
-            for (let j = 0, jl = numbers.length; j < jl; j++) {
-              point.y += numbers[j]
-              control.x = point.x
-              control.y = point.y
-              path.lineTo(point.x, point.y)
+                if (j === 0) firstPoint.copy(point)
+              }
 
-              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
-            }
+              break
 
-            break
+            case 'h':
+              numbers = parseFloats(data)
 
-          case 'l':
-            numbers = parseFloats(data)
+              for (let j = 0, jl = numbers.length; j < jl; j++) {
+                point.x += numbers[j]
+                control.x = point.x
+                control.y = point.y
+                path.lineTo(point.x, point.y)
 
-            for (let j = 0, jl = numbers.length; j < jl; j += 2) {
-              point.x += numbers[j + 0]
-              point.y += numbers[j + 1]
-              control.x = point.x
-              control.y = point.y
-              path.lineTo(point.x, point.y)
+                if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
+              }
 
-              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
-            }
+              break
 
-            break
+            case 'v':
+              numbers = parseFloats(data)
 
-          case 'c':
-            numbers = parseFloats(data)
-
-            for (let j = 0, jl = numbers.length; j < jl; j += 6) {
-              path.bezierCurveTo(
-                point.x + numbers[j + 0],
-                point.y + numbers[j + 1],
-                point.x + numbers[j + 2],
-                point.y + numbers[j + 3],
-                point.x + numbers[j + 4],
-                point.y + numbers[j + 5],
-              )
-              control.x = point.x + numbers[j + 2]
-              control.y = point.y + numbers[j + 3]
-              point.x += numbers[j + 4]
-              point.y += numbers[j + 5]
-
-              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
-            }
+              for (let j = 0, jl = numbers.length; j < jl; j++) {
+                point.y += numbers[j]
+                control.x = point.x
+                control.y = point.y
+                path.lineTo(point.x, point.y)
 
-            break
+                if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
+              }
 
-          case 's':
-            numbers = parseFloats(data)
-
-            for (let j = 0, jl = numbers.length; j < jl; j += 4) {
-              path.bezierCurveTo(
-                getReflection(point.x, control.x),
-                getReflection(point.y, control.y),
-                point.x + numbers[j + 0],
-                point.y + numbers[j + 1],
-                point.x + numbers[j + 2],
-                point.y + numbers[j + 3],
-              )
-              control.x = point.x + numbers[j + 0]
-              control.y = point.y + numbers[j + 1]
-              point.x += numbers[j + 2]
-              point.y += numbers[j + 3]
-
-              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
-            }
+              break
 
-            break
+            case 'l':
+              numbers = parseFloats(data)
 
-          case 'q':
-            numbers = parseFloats(data)
-
-            for (let j = 0, jl = numbers.length; j < jl; j += 4) {
-              path.quadraticCurveTo(
-                point.x + numbers[j + 0],
-                point.y + numbers[j + 1],
-                point.x + numbers[j + 2],
-                point.y + numbers[j + 3],
-              )
-              control.x = point.x + numbers[j + 0]
-              control.y = point.y + numbers[j + 1]
-              point.x += numbers[j + 2]
-              point.y += numbers[j + 3]
-
-              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
-            }
+              for (let j = 0, jl = numbers.length; j < jl; j += 2) {
+                point.x += numbers[j + 0]
+                point.y += numbers[j + 1]
+                control.x = point.x
+                control.y = point.y
+                path.lineTo(point.x, point.y)
 
-            break
+                if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
+              }
 
-          case 't':
-            numbers = parseFloats(data)
+              break
 
-            for (let j = 0, jl = numbers.length; j < jl; j += 2) {
-              const rx = getReflection(point.x, control.x)
-              const ry = getReflection(point.y, control.y)
-              path.quadraticCurveTo(rx, ry, point.x + numbers[j + 0], point.y + numbers[j + 1])
-              control.x = rx
-              control.y = ry
-              point.x = point.x + numbers[j + 0]
-              point.y = point.y + numbers[j + 1]
+            case 'c':
+              numbers = parseFloats(data)
+
+              for (let j = 0, jl = numbers.length; j < jl; j += 6) {
+                path.bezierCurveTo(
+                  point.x + numbers[j + 0],
+                  point.y + numbers[j + 1],
+                  point.x + numbers[j + 2],
+                  point.y + numbers[j + 3],
+                  point.x + numbers[j + 4],
+                  point.y + numbers[j + 5],
+                )
+                control.x = point.x + numbers[j + 2]
+                control.y = point.y + numbers[j + 3]
+                point.x += numbers[j + 4]
+                point.y += numbers[j + 5]
+
+                if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
+              }
 
-              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
-            }
+              break
 
-            break
+            case 's':
+              numbers = parseFloats(data)
+
+              for (let j = 0, jl = numbers.length; j < jl; j += 4) {
+                path.bezierCurveTo(
+                  getReflection(point.x, control.x),
+                  getReflection(point.y, control.y),
+                  point.x + numbers[j + 0],
+                  point.y + numbers[j + 1],
+                  point.x + numbers[j + 2],
+                  point.y + numbers[j + 3],
+                )
+                control.x = point.x + numbers[j + 0]
+                control.y = point.y + numbers[j + 1]
+                point.x += numbers[j + 2]
+                point.y += numbers[j + 3]
+
+                if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
+              }
 
-          case 'a':
-            numbers = parseFloats(data, [3, 4], 7)
-
-            for (let j = 0, jl = numbers.length; j < jl; j += 7) {
-              // skip command if no displacement
-              if (numbers[j + 5] == 0 && numbers[j + 6] == 0) continue
-
-              const start = point.clone()
-              point.x += numbers[j + 5]
-              point.y += numbers[j + 6]
-              control.x = point.x
-              control.y = point.y
-              parseArcCommand(
-                path,
-                numbers[j],
-                numbers[j + 1],
-                numbers[j + 2],
-                numbers[j + 3],
-                numbers[j + 4],
-                start,
-                point,
-              )
-
-              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
-            }
+              break
 
-            break
+            case 'q':
+              numbers = parseFloats(data)
+
+              for (let j = 0, jl = numbers.length; j < jl; j += 4) {
+                path.quadraticCurveTo(
+                  point.x + numbers[j + 0],
+                  point.y + numbers[j + 1],
+                  point.x + numbers[j + 2],
+                  point.y + numbers[j + 3],
+                )
+                control.x = point.x + numbers[j + 0]
+                control.y = point.y + numbers[j + 1]
+                point.x += numbers[j + 2]
+                point.y += numbers[j + 3]
+
+                if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
+              }
 
-          case 'Z':
-          case 'z':
-            path.currentPath.autoClose = true
+              break
 
-            if (path.currentPath.curves.length > 0) {
-              // Reset point to beginning of Path
-              point.copy(firstPoint)
-              path.currentPath.currentPoint.copy(point)
-              isFirstPoint = true
-            }
+            case 't':
+              numbers = parseFloats(data)
 
-            break
+              for (let j = 0, jl = numbers.length; j < jl; j += 2) {
+                const rx = getReflection(point.x, control.x)
+                const ry = getReflection(point.y, control.y)
+                path.quadraticCurveTo(rx, ry, point.x + numbers[j + 0], point.y + numbers[j + 1])
+                control.x = rx
+                control.y = ry
+                point.x = point.x + numbers[j + 0]
+                point.y = point.y + numbers[j + 1]
 
-          default:
-            console.warn(command)
-        }
+                if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
+              }
 
-        // console.log( type, parseFloats( data ), parseFloats( data ).length  )
+              break
 
-        doSetFirstPoint = false
-      }
+            case 'a':
+              numbers = parseFloats(data, [3, 4], 7)
+
+              for (let j = 0, jl = numbers.length; j < jl; j += 7) {
+                // skip command if no displacement
+                if (numbers[j + 5] == 0 && numbers[j + 6] == 0) continue
+
+                const start = point.clone()
+                point.x += numbers[j + 5]
+                point.y += numbers[j + 6]
+                control.x = point.x
+                control.y = point.y
+                parseArcCommand(
+                  path,
+                  numbers[j],
+                  numbers[j + 1],
+                  numbers[j + 2],
+                  numbers[j + 3],
+                  numbers[j + 4],
+                  start,
+                  point,
+                )
+
+                if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
+              }
 
-      return path
-    }
+              break
 
-    function parseCSSStylesheet(node) {
-      if (!node.sheet || !node.sheet.cssRules || !node.sheet.cssRules.length) return
+            case 'Z':
+            case 'z':
+              path.currentPath.autoClose = true
 
-      for (let i = 0; i < node.sheet.cssRules.length; i++) {
-        const stylesheet = node.sheet.cssRules[i]
+              if (path.currentPath.curves.length > 0) {
+                // Reset point to beginning of Path
+                point.copy(firstPoint)
+                path.currentPath.currentPoint.copy(point)
+                isFirstPoint = true
+              }
 
-        if (stylesheet.type !== 1) continue
+              break
 
-        const selectorList = stylesheet.selectorText
-          .split(/,/gm)
-          .filter(Boolean)
-          .map((i) => i.trim())
+            default:
+              console.warn(command)
+          }
 
-        for (let j = 0; j < selectorList.length; j++) {
-          // Remove empty rules
-          const definitions = Object.fromEntries(Object.entries(stylesheet.style).filter(([, v]) => v !== ''))
+          // console.log( type, parseFloats( data ), parseFloats( data ).length  )
 
-          stylesheets[selectorList[j]] = Object.assign(stylesheets[selectorList[j]] || {}, definitions)
+          doSetFirstPoint = false
         }
-      }
-    }
 
-    /**
-     * https://www.w3.org/TR/SVG/implnote.html#ArcImplementationNotes
-     * https://mortoray.com/2017/02/16/rendering-an-svg-elliptical-arc-as-bezier-curves/ Appendix: Endpoint to center arc conversion
-     * From
-     * rx ry x-axis-rotation large-arc-flag sweep-flag x y
-     * To
-     * aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation
-     */
-
-    function parseArcCommand(path, rx, ry, x_axis_rotation, large_arc_flag, sweep_flag, start, end) {
-      if (rx == 0 || ry == 0) {
-        // draw a line if either of the radii == 0
-        path.lineTo(end.x, end.y)
-        return
+        return path
       }
 
-      x_axis_rotation = (x_axis_rotation * Math.PI) / 180
-
-      // Ensure radii are positive
-      rx = Math.abs(rx)
-      ry = Math.abs(ry)
-
-      // Compute (x1', y1')
-      const dx2 = (start.x - end.x) / 2.0
-      const dy2 = (start.y - end.y) / 2.0
-      const x1p = Math.cos(x_axis_rotation) * dx2 + Math.sin(x_axis_rotation) * dy2
-      const y1p = -Math.sin(x_axis_rotation) * dx2 + Math.cos(x_axis_rotation) * dy2
-
-      // Compute (cx', cy')
-      let rxs = rx * rx
-      let rys = ry * ry
-      const x1ps = x1p * x1p
-      const y1ps = y1p * y1p
-
-      // Ensure radii are large enough
-      const cr = x1ps / rxs + y1ps / rys
-
-      if (cr > 1) {
-        // scale up rx,ry equally so cr == 1
-        const s = Math.sqrt(cr)
-        rx = s * rx
-        ry = s * ry
-        rxs = rx * rx
-        rys = ry * ry
-      }
+      function parseCSSStylesheet(node) {
+        if (!node.sheet || !node.sheet.cssRules || !node.sheet.cssRules.length) return
 
-      const dq = rxs * y1ps + rys * x1ps
-      const pq = (rxs * rys - dq) / dq
-      let q = Math.sqrt(Math.max(0, pq))
-      if (large_arc_flag === sweep_flag) q = -q
-      const cxp = (q * rx * y1p) / ry
-      const cyp = (-q * ry * x1p) / rx
+        for (let i = 0; i < node.sheet.cssRules.length; i++) {
+          const stylesheet = node.sheet.cssRules[i]
 
-      // Step 3: Compute (cx, cy) from (cx', cy')
-      const cx = Math.cos(x_axis_rotation) * cxp - Math.sin(x_axis_rotation) * cyp + (start.x + end.x) / 2
-      const cy = Math.sin(x_axis_rotation) * cxp + Math.cos(x_axis_rotation) * cyp + (start.y + end.y) / 2
+          if (stylesheet.type !== 1) continue
 
-      // Step 4: Compute θ1 and Δθ
-      const theta = svgAngle(1, 0, (x1p - cxp) / rx, (y1p - cyp) / ry)
-      const delta = svgAngle((x1p - cxp) / rx, (y1p - cyp) / ry, (-x1p - cxp) / rx, (-y1p - cyp) / ry) % (Math.PI * 2)
+          const selectorList = stylesheet.selectorText
+            .split(/,/gm)
+            .filter(Boolean)
+            .map((i) => i.trim())
 
-      path.currentPath.absellipse(cx, cy, rx, ry, theta, theta + delta, sweep_flag === 0, x_axis_rotation)
-    }
+          for (let j = 0; j < selectorList.length; j++) {
+            // Remove empty rules
+            const definitions = Object.fromEntries(Object.entries(stylesheet.style).filter(([, v]) => v !== ''))
 
-    function svgAngle(ux, uy, vx, vy) {
-      const dot = ux * vx + uy * vy
-      const len = Math.sqrt(ux * ux + uy * uy) * Math.sqrt(vx * vx + vy * vy)
-      let ang = Math.acos(Math.max(-1, Math.min(1, dot / len))) // floating point precision, slightly over values appear
-      if (ux * vy - uy * vx < 0) ang = -ang
-      return ang
-    }
-
-    /*
-     * According to https://www.w3.org/TR/SVG/shapes.html#RectElementRXAttribute
-     * rounded corner should be rendered to elliptical arc, but bezier curve does the job well enough
-     */
-    function parseRectNode(node) {
-      const x = parseFloatWithUnits(node.getAttribute('x') || 0)
-      const y = parseFloatWithUnits(node.getAttribute('y') || 0)
-      const rx = parseFloatWithUnits(node.getAttribute('rx') || node.getAttribute('ry') || 0)
-      const ry = parseFloatWithUnits(node.getAttribute('ry') || node.getAttribute('rx') || 0)
-      const w = parseFloatWithUnits(node.getAttribute('width'))
-      const h = parseFloatWithUnits(node.getAttribute('height'))
-
-      // Ellipse arc to Bezier approximation Coefficient (Inversed). See:
-      // https://spencermortensen.com/articles/bezier-circle/
-      const bci = 1 - 0.551915024494
-
-      const path = new ShapePath()
-
-      // top left
-      path.moveTo(x + rx, y)
-
-      // top right
-      path.lineTo(x + w - rx, y)
-      if (rx !== 0 || ry !== 0) {
-        path.bezierCurveTo(x + w - rx * bci, y, x + w, y + ry * bci, x + w, y + ry)
+            stylesheets[selectorList[j]] = Object.assign(stylesheets[selectorList[j]] || {}, definitions)
+          }
+        }
       }
 
-      // bottom right
-      path.lineTo(x + w, y + h - ry)
-      if (rx !== 0 || ry !== 0) {
-        path.bezierCurveTo(x + w, y + h - ry * bci, x + w - rx * bci, y + h, x + w - rx, y + h)
-      }
+      /**
+       * https://www.w3.org/TR/SVG/implnote.html#ArcImplementationNotes
+       * https://mortoray.com/2017/02/16/rendering-an-svg-elliptical-arc-as-bezier-curves/ Appendix: Endpoint to center arc conversion
+       * From
+       * rx ry x-axis-rotation large-arc-flag sweep-flag x y
+       * To
+       * aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation
+       */
+
+      function parseArcCommand(path, rx, ry, x_axis_rotation, large_arc_flag, sweep_flag, start, end) {
+        if (rx == 0 || ry == 0) {
+          // draw a line if either of the radii == 0
+          path.lineTo(end.x, end.y)
+          return
+        }
 
-      // bottom left
-      path.lineTo(x + rx, y + h)
-      if (rx !== 0 || ry !== 0) {
-        path.bezierCurveTo(x + rx * bci, y + h, x, y + h - ry * bci, x, y + h - ry)
-      }
+        x_axis_rotation = (x_axis_rotation * Math.PI) / 180
+
+        // Ensure radii are positive
+        rx = Math.abs(rx)
+        ry = Math.abs(ry)
+
+        // Compute (x1', y1')
+        const dx2 = (start.x - end.x) / 2.0
+        const dy2 = (start.y - end.y) / 2.0
+        const x1p = Math.cos(x_axis_rotation) * dx2 + Math.sin(x_axis_rotation) * dy2
+        const y1p = -Math.sin(x_axis_rotation) * dx2 + Math.cos(x_axis_rotation) * dy2
+
+        // Compute (cx', cy')
+        let rxs = rx * rx
+        let rys = ry * ry
+        const x1ps = x1p * x1p
+        const y1ps = y1p * y1p
+
+        // Ensure radii are large enough
+        const cr = x1ps / rxs + y1ps / rys
+
+        if (cr > 1) {
+          // scale up rx,ry equally so cr == 1
+          const s = Math.sqrt(cr)
+          rx = s * rx
+          ry = s * ry
+          rxs = rx * rx
+          rys = ry * ry
+        }
 
-      // back to top left
-      path.lineTo(x, y + ry)
-      if (rx !== 0 || ry !== 0) {
-        path.bezierCurveTo(x, y + ry * bci, x + rx * bci, y, x + rx, y)
-      }
+        const dq = rxs * y1ps + rys * x1ps
+        const pq = (rxs * rys - dq) / dq
+        let q = Math.sqrt(Math.max(0, pq))
+        if (large_arc_flag === sweep_flag) q = -q
+        const cxp = (q * rx * y1p) / ry
+        const cyp = (-q * ry * x1p) / rx
+
+        // Step 3: Compute (cx, cy) from (cx', cy')
+        const cx = Math.cos(x_axis_rotation) * cxp - Math.sin(x_axis_rotation) * cyp + (start.x + end.x) / 2
+        const cy = Math.sin(x_axis_rotation) * cxp + Math.cos(x_axis_rotation) * cyp + (start.y + end.y) / 2
+
+        // Step 4: Compute θ1 and Δθ
+        const theta = svgAngle(1, 0, (x1p - cxp) / rx, (y1p - cyp) / ry)
+        const delta = svgAngle((x1p - cxp) / rx, (y1p - cyp) / ry, (-x1p - cxp) / rx, (-y1p - cyp) / ry) % (Math.PI * 2)
+
+        path.currentPath.absellipse(cx, cy, rx, ry, theta, theta + delta, sweep_flag === 0, x_axis_rotation)
+      }
+
+      function svgAngle(ux, uy, vx, vy) {
+        const dot = ux * vx + uy * vy
+        const len = Math.sqrt(ux * ux + uy * uy) * Math.sqrt(vx * vx + vy * vy)
+        let ang = Math.acos(Math.max(-1, Math.min(1, dot / len))) // floating point precision, slightly over values appear
+        if (ux * vy - uy * vx < 0) ang = -ang
+        return ang
+      }
+
+      /*
+       * According to https://www.w3.org/TR/SVG/shapes.html#RectElementRXAttribute
+       * rounded corner should be rendered to elliptical arc, but bezier curve does the job well enough
+       */
+      function parseRectNode(node) {
+        const x = parseFloatWithUnits(node.getAttribute('x') || 0)
+        const y = parseFloatWithUnits(node.getAttribute('y') || 0)
+        const rx = parseFloatWithUnits(node.getAttribute('rx') || node.getAttribute('ry') || 0)
+        const ry = parseFloatWithUnits(node.getAttribute('ry') || node.getAttribute('rx') || 0)
+        const w = parseFloatWithUnits(node.getAttribute('width'))
+        const h = parseFloatWithUnits(node.getAttribute('height'))
+
+        // Ellipse arc to Bezier approximation Coefficient (Inversed). See:
+        // https://spencermortensen.com/articles/bezier-circle/
+        const bci = 1 - 0.551915024494
+
+        const path = new ShapePath()
+
+        // top left
+        path.moveTo(x + rx, y)
+
+        // top right
+        path.lineTo(x + w - rx, y)
+        if (rx !== 0 || ry !== 0) {
+          path.bezierCurveTo(x + w - rx * bci, y, x + w, y + ry * bci, x + w, y + ry)
+        }
 
-      return path
-    }
+        // bottom right
+        path.lineTo(x + w, y + h - ry)
+        if (rx !== 0 || ry !== 0) {
+          path.bezierCurveTo(x + w, y + h - ry * bci, x + w - rx * bci, y + h, x + w - rx, y + h)
+        }
 
-    function parsePolygonNode(node) {
-      function iterator(match, a, b) {
-        const x = parseFloatWithUnits(a)
-        const y = parseFloatWithUnits(b)
+        // bottom left
+        path.lineTo(x + rx, y + h)
+        if (rx !== 0 || ry !== 0) {
+          path.bezierCurveTo(x + rx * bci, y + h, x, y + h - ry * bci, x, y + h - ry)
+        }
 
-        if (index === 0) {
-          path.moveTo(x, y)
-        } else {
-          path.lineTo(x, y)
+        // back to top left
+        path.lineTo(x, y + ry)
+        if (rx !== 0 || ry !== 0) {
+          path.bezierCurveTo(x, y + ry * bci, x + rx * bci, y, x + rx, y)
         }
 
-        index++
+        return path
       }
 
-      const regex = /([+-]?\d*\.?\d+(?:e[+-]?\d+)?)(?:,|\s)([+-]?\d*\.?\d+(?:e[+-]?\d+)?)/g
+      function parsePolygonNode(node) {
+        function iterator(match, a, b) {
+          const x = parseFloatWithUnits(a)
+          const y = parseFloatWithUnits(b)
 
-      const path = new ShapePath()
+          if (index === 0) {
+            path.moveTo(x, y)
+          } else {
+            path.lineTo(x, y)
+          }
 
-      let index = 0
+          index++
+        }
 
-      node.getAttribute('points').replace(regex, iterator)
+        const regex = /([+-]?\d*\.?\d+(?:e[+-]?\d+)?)(?:,|\s)([+-]?\d*\.?\d+(?:e[+-]?\d+)?)/g
 
-      path.currentPath.autoClose = true
+        const path = new ShapePath()
 
-      return path
-    }
+        let index = 0
 
-    function parsePolylineNode(node) {
-      function iterator(match, a, b) {
-        const x = parseFloatWithUnits(a)
-        const y = parseFloatWithUnits(b)
+        node.getAttribute('points').replace(regex, iterator)
 
-        if (index === 0) {
-          path.moveTo(x, y)
-        } else {
-          path.lineTo(x, y)
-        }
+        path.currentPath.autoClose = true
 
-        index++
+        return path
       }
 
-      const regex = /([+-]?\d*\.?\d+(?:e[+-]?\d+)?)(?:,|\s)([+-]?\d*\.?\d+(?:e[+-]?\d+)?)/g
+      function parsePolylineNode(node) {
+        function iterator(match, a, b) {
+          const x = parseFloatWithUnits(a)
+          const y = parseFloatWithUnits(b)
 
-      const path = new ShapePath()
+          if (index === 0) {
+            path.moveTo(x, y)
+          } else {
+            path.lineTo(x, y)
+          }
 
-      let index = 0
+          index++
+        }
 
-      node.getAttribute('points').replace(regex, iterator)
+        const regex = /([+-]?\d*\.?\d+(?:e[+-]?\d+)?)(?:,|\s)([+-]?\d*\.?\d+(?:e[+-]?\d+)?)/g
 
-      path.currentPath.autoClose = false
+        const path = new ShapePath()
 
-      return path
-    }
+        let index = 0
 
-    function parseCircleNode(node) {
-      const x = parseFloatWithUnits(node.getAttribute('cx') || 0)
-      const y = parseFloatWithUnits(node.getAttribute('cy') || 0)
-      const r = parseFloatWithUnits(node.getAttribute('r') || 0)
+        node.getAttribute('points').replace(regex, iterator)
 
-      const subpath = new Path()
-      subpath.absarc(x, y, r, 0, Math.PI * 2)
+        path.currentPath.autoClose = false
 
-      const path = new ShapePath()
-      path.subPaths.push(subpath)
+        return path
+      }
 
-      return path
-    }
+      function parseCircleNode(node) {
+        const x = parseFloatWithUnits(node.getAttribute('cx') || 0)
+        const y = parseFloatWithUnits(node.getAttribute('cy') || 0)
+        const r = parseFloatWithUnits(node.getAttribute('r') || 0)
 
-    function parseEllipseNode(node) {
-      const x = parseFloatWithUnits(node.getAttribute('cx') || 0)
-      const y = parseFloatWithUnits(node.getAttribute('cy') || 0)
-      const rx = parseFloatWithUnits(node.getAttribute('rx') || 0)
-      const ry = parseFloatWithUnits(node.getAttribute('ry') || 0)
+        const subpath = new Path()
+        subpath.absarc(x, y, r, 0, Math.PI * 2)
 
-      const subpath = new Path()
-      subpath.absellipse(x, y, rx, ry, 0, Math.PI * 2)
+        const path = new ShapePath()
+        path.subPaths.push(subpath)
 
-      const path = new ShapePath()
-      path.subPaths.push(subpath)
+        return path
+      }
 
-      return path
-    }
+      function parseEllipseNode(node) {
+        const x = parseFloatWithUnits(node.getAttribute('cx') || 0)
+        const y = parseFloatWithUnits(node.getAttribute('cy') || 0)
+        const rx = parseFloatWithUnits(node.getAttribute('rx') || 0)
+        const ry = parseFloatWithUnits(node.getAttribute('ry') || 0)
 
-    function parseLineNode(node) {
-      const x1 = parseFloatWithUnits(node.getAttribute('x1') || 0)
-      const y1 = parseFloatWithUnits(node.getAttribute('y1') || 0)
-      const x2 = parseFloatWithUnits(node.getAttribute('x2') || 0)
-      const y2 = parseFloatWithUnits(node.getAttribute('y2') || 0)
+        const subpath = new Path()
+        subpath.absellipse(x, y, rx, ry, 0, Math.PI * 2)
 
-      const path = new ShapePath()
-      path.moveTo(x1, y1)
-      path.lineTo(x2, y2)
-      path.currentPath.autoClose = false
+        const path = new ShapePath()
+        path.subPaths.push(subpath)
 
-      return path
-    }
+        return path
+      }
 
-    //
+      function parseLineNode(node) {
+        const x1 = parseFloatWithUnits(node.getAttribute('x1') || 0)
+        const y1 = parseFloatWithUnits(node.getAttribute('y1') || 0)
+        const x2 = parseFloatWithUnits(node.getAttribute('x2') || 0)
+        const y2 = parseFloatWithUnits(node.getAttribute('y2') || 0)
 
-    function parseStyle(node, style) {
-      style = Object.assign({}, style) // clone style
+        const path = new ShapePath()
+        path.moveTo(x1, y1)
+        path.lineTo(x2, y2)
+        path.currentPath.autoClose = false
 
-      let stylesheetStyles = {}
+        return path
+      }
 
-      if (node.hasAttribute('class')) {
-        const classSelectors = node
-          .getAttribute('class')
-          .split(/\s/)
-          .filter(Boolean)
-          .map((i) => i.trim())
+      //
 
-        for (let i = 0; i < classSelectors.length; i++) {
-          stylesheetStyles = Object.assign(stylesheetStyles, stylesheets['.' + classSelectors[i]])
-        }
-      }
+      function parseStyle(node, style) {
+        style = Object.assign({}, style) // clone style
 
-      if (node.hasAttribute('id')) {
-        stylesheetStyles = Object.assign(stylesheetStyles, stylesheets['#' + node.getAttribute('id')])
-      }
+        let stylesheetStyles = {}
 
-      function addStyle(svgName, jsName, adjustFunction) {
-        if (adjustFunction === undefined)
-          adjustFunction = function copy(v) {
-            if (v.startsWith('url')) console.warn('SVGLoader: url access in attributes is not implemented.')
+        if (node.hasAttribute('class')) {
+          const classSelectors = node
+            .getAttribute('class')
+            .split(/\s/)
+            .filter(Boolean)
+            .map((i) => i.trim())
 
-            return v
+          for (let i = 0; i < classSelectors.length; i++) {
+            stylesheetStyles = Object.assign(stylesheetStyles, stylesheets['.' + classSelectors[i]])
           }
+        }
 
-        if (node.hasAttribute(svgName)) style[jsName] = adjustFunction(node.getAttribute(svgName))
-        if (stylesheetStyles[svgName]) style[jsName] = adjustFunction(stylesheetStyles[svgName])
-        if (node.style && node.style[svgName] !== '') style[jsName] = adjustFunction(node.style[svgName])
-      }
+        if (node.hasAttribute('id')) {
+          stylesheetStyles = Object.assign(stylesheetStyles, stylesheets['#' + node.getAttribute('id')])
+        }
 
-      function clamp(v) {
-        return Math.max(0, Math.min(1, parseFloatWithUnits(v)))
-      }
+        function addStyle(svgName, jsName, adjustFunction) {
+          if (adjustFunction === undefined)
+            adjustFunction = function copy(v) {
+              if (v.startsWith('url')) console.warn('SVGLoader: url access in attributes is not implemented.')
 
-      function positive(v) {
-        return Math.max(0, parseFloatWithUnits(v))
-      }
+              return v
+            }
 
-      addStyle('fill', 'fill')
-      addStyle('fill-opacity', 'fillOpacity', clamp)
-      addStyle('fill-rule', 'fillRule')
-      addStyle('opacity', 'opacity', clamp)
-      addStyle('stroke', 'stroke')
-      addStyle('stroke-opacity', 'strokeOpacity', clamp)
-      addStyle('stroke-width', 'strokeWidth', positive)
-      addStyle('stroke-linejoin', 'strokeLineJoin')
-      addStyle('stroke-linecap', 'strokeLineCap')
-      addStyle('stroke-miterlimit', 'strokeMiterLimit', positive)
-      addStyle('visibility', 'visibility')
-
-      return style
-    }
+          if (node.hasAttribute(svgName)) style[jsName] = adjustFunction(node.getAttribute(svgName))
+          if (stylesheetStyles[svgName]) style[jsName] = adjustFunction(stylesheetStyles[svgName])
+          if (node.style && node.style[svgName] !== '') style[jsName] = adjustFunction(node.style[svgName])
+        }
 
-    // http://www.w3.org/TR/SVG11/implnote.html#PathElementImplementationNotes
+        function clamp(v) {
+          return Math.max(0, Math.min(1, parseFloatWithUnits(v)))
+        }
 
-    function getReflection(a, b) {
-      return a - (b - a)
-    }
+        function positive(v) {
+          return Math.max(0, parseFloatWithUnits(v))
+        }
 
-    // from https://github.com/ppvg/svg-numbers (MIT License)
+        addStyle('fill', 'fill')
+        addStyle('fill-opacity', 'fillOpacity', clamp)
+        addStyle('fill-rule', 'fillRule')
+        addStyle('opacity', 'opacity', clamp)
+        addStyle('stroke', 'stroke')
+        addStyle('stroke-opacity', 'strokeOpacity', clamp)
+        addStyle('stroke-width', 'strokeWidth', positive)
+        addStyle('stroke-linejoin', 'strokeLineJoin')
+        addStyle('stroke-linecap', 'strokeLineCap')
+        addStyle('stroke-miterlimit', 'strokeMiterLimit', positive)
+        addStyle('visibility', 'visibility')
 
-    function parseFloats(input, flags, stride) {
-      if (typeof input !== 'string') {
-        throw new TypeError('Invalid input: ' + typeof input)
+        return style
       }
 
-      // Character groups
-      const RE = {
-        SEPARATOR: /[ \t\r\n\,.\-+]/,
-        WHITESPACE: /[ \t\r\n]/,
-        DIGIT: /[\d]/,
-        SIGN: /[-+]/,
-        POINT: /\./,
-        COMMA: /,/,
-        EXP: /e/i,
-        FLAGS: /[01]/,
-      }
+      // http://www.w3.org/TR/SVG11/implnote.html#PathElementImplementationNotes
 
-      // States
-      const SEP = 0
-      const INT = 1
-      const FLOAT = 2
-      const EXP = 3
-
-      let state = SEP
-      let seenComma = true
-      let number = '',
-        exponent = ''
-      const result = []
-
-      function throwSyntaxError(current, i, partial) {
-        const error = new SyntaxError('Unexpected character "' + current + '" at index ' + i + '.')
-        error.partial = partial
-        throw error
+      function getReflection(a, b) {
+        return a - (b - a)
       }
 
-      function newNumber() {
-        if (number !== '') {
-          if (exponent === '') result.push(Number(number))
-          else result.push(Number(number) * Math.pow(10, Number(exponent)))
+      // from https://github.com/ppvg/svg-numbers (MIT License)
+
+      function parseFloats(input, flags, stride) {
+        if (typeof input !== 'string') {
+          throw new TypeError('Invalid input: ' + typeof input)
         }
 
-        number = ''
-        exponent = ''
-      }
+        // Character groups
+        const RE = {
+          SEPARATOR: /[ \t\r\n\,.\-+]/,
+          WHITESPACE: /[ \t\r\n]/,
+          DIGIT: /[\d]/,
+          SIGN: /[-+]/,
+          POINT: /\./,
+          COMMA: /,/,
+          EXP: /e/i,
+          FLAGS: /[01]/,
+        }
 
-      let current
-      const length = input.length
+        // States
+        const SEP = 0
+        const INT = 1
+        const FLOAT = 2
+        const EXP = 3
+
+        let state = SEP
+        let seenComma = true
+        let number = '',
+          exponent = ''
+        const result = []
+
+        function throwSyntaxError(current, i, partial) {
+          const error = new SyntaxError('Unexpected character "' + current + '" at index ' + i + '.')
+          error.partial = partial
+          throw error
+        }
 
-      for (let i = 0; i < length; i++) {
-        current = input[i]
+        function newNumber() {
+          if (number !== '') {
+            if (exponent === '') result.push(Number(number))
+            else result.push(Number(number) * Math.pow(10, Number(exponent)))
+          }
 
-        // check for flags
-        if (Array.isArray(flags) && flags.includes(result.length % stride) && RE.FLAGS.test(current)) {
-          state = INT
-          number = current
-          newNumber()
-          continue
+          number = ''
+          exponent = ''
         }
 
-        // parse until next number
-        if (state === SEP) {
-          // eat whitespace
-          if (RE.WHITESPACE.test(current)) {
-            continue
-          }
+        let current
+        const length = input.length
+
+        for (let i = 0; i < length; i++) {
+          current = input[i]
 
-          // start new number
-          if (RE.DIGIT.test(current) || RE.SIGN.test(current)) {
+          // check for flags
+          if (Array.isArray(flags) && flags.includes(result.length % stride) && RE.FLAGS.test(current)) {
             state = INT
             number = current
+            newNumber()
             continue
           }
 
-          if (RE.POINT.test(current)) {
-            state = FLOAT
-            number = current
-            continue
-          }
+          // parse until next number
+          if (state === SEP) {
+            // eat whitespace
+            if (RE.WHITESPACE.test(current)) {
+              continue
+            }
 
-          // throw on double commas (e.g. "1, , 2")
-          if (RE.COMMA.test(current)) {
-            if (seenComma) {
-              throwSyntaxError(current, i, result)
+            // start new number
+            if (RE.DIGIT.test(current) || RE.SIGN.test(current)) {
+              state = INT
+              number = current
+              continue
             }
 
-            seenComma = true
-          }
-        }
+            if (RE.POINT.test(current)) {
+              state = FLOAT
+              number = current
+              continue
+            }
 
-        // parse integer part
-        if (state === INT) {
-          if (RE.DIGIT.test(current)) {
-            number += current
-            continue
-          }
+            // throw on double commas (e.g. "1, , 2")
+            if (RE.COMMA.test(current)) {
+              if (seenComma) {
+                throwSyntaxError(current, i, result)
+              }
 
-          if (RE.POINT.test(current)) {
-            number += current
-            state = FLOAT
-            continue
+              seenComma = true
+            }
           }
 
-          if (RE.EXP.test(current)) {
-            state = EXP
-            continue
-          }
+          // parse integer part
+          if (state === INT) {
+            if (RE.DIGIT.test(current)) {
+              number += current
+              continue
+            }
 
-          // throw on double signs ("-+1"), but not on sign as separator ("-1-2")
-          if (RE.SIGN.test(current) && number.length === 1 && RE.SIGN.test(number[0])) {
-            throwSyntaxError(current, i, result)
-          }
-        }
+            if (RE.POINT.test(current)) {
+              number += current
+              state = FLOAT
+              continue
+            }
 
-        // parse decimal part
-        if (state === FLOAT) {
-          if (RE.DIGIT.test(current)) {
-            number += current
-            continue
-          }
+            if (RE.EXP.test(current)) {
+              state = EXP
+              continue
+            }
 
-          if (RE.EXP.test(current)) {
-            state = EXP
-            continue
+            // throw on double signs ("-+1"), but not on sign as separator ("-1-2")
+            if (RE.SIGN.test(current) && number.length === 1 && RE.SIGN.test(number[0])) {
+              throwSyntaxError(current, i, result)
+            }
           }
 
-          // throw on double decimal points (e.g. "1..2")
-          if (RE.POINT.test(current) && number[number.length - 1] === '.') {
-            throwSyntaxError(current, i, result)
-          }
-        }
+          // parse decimal part
+          if (state === FLOAT) {
+            if (RE.DIGIT.test(current)) {
+              number += current
+              continue
+            }
 
-        // parse exponent part
-        if (state === EXP) {
-          if (RE.DIGIT.test(current)) {
-            exponent += current
-            continue
+            if (RE.EXP.test(current)) {
+              state = EXP
+              continue
+            }
+
+            // throw on double decimal points (e.g. "1..2")
+            if (RE.POINT.test(current) && number[number.length - 1] === '.') {
+              throwSyntaxError(current, i, result)
+            }
           }
 
-          if (RE.SIGN.test(current)) {
-            if (exponent === '') {
+          // parse exponent part
+          if (state === EXP) {
+            if (RE.DIGIT.test(current)) {
               exponent += current
               continue
             }
 
-            if (exponent.length === 1 && RE.SIGN.test(exponent)) {
-              throwSyntaxError(current, i, result)
+            if (RE.SIGN.test(current)) {
+              if (exponent === '') {
+                exponent += current
+                continue
+              }
+
+              if (exponent.length === 1 && RE.SIGN.test(exponent)) {
+                throwSyntaxError(current, i, result)
+              }
             }
           }
-        }
 
-        // end of number
-        if (RE.WHITESPACE.test(current)) {
-          newNumber()
-          state = SEP
-          seenComma = false
-        } else if (RE.COMMA.test(current)) {
-          newNumber()
-          state = SEP
-          seenComma = true
-        } else if (RE.SIGN.test(current)) {
-          newNumber()
-          state = INT
-          number = current
-        } else if (RE.POINT.test(current)) {
-          newNumber()
-          state = FLOAT
-          number = current
-        } else {
-          throwSyntaxError(current, i, result)
+          // end of number
+          if (RE.WHITESPACE.test(current)) {
+            newNumber()
+            state = SEP
+            seenComma = false
+          } else if (RE.COMMA.test(current)) {
+            newNumber()
+            state = SEP
+            seenComma = true
+          } else if (RE.SIGN.test(current)) {
+            newNumber()
+            state = INT
+            number = current
+          } else if (RE.POINT.test(current)) {
+            newNumber()
+            state = FLOAT
+            number = current
+          } else {
+            throwSyntaxError(current, i, result)
+          }
         }
-      }
 
-      // add the last number found (if any)
-      newNumber()
+        // add the last number found (if any)
+        newNumber()
+
+        return result
+      }
+
+      // Units
+
+      const units = ['mm', 'cm', 'in', 'pt', 'pc', 'px']
+
+      // Conversion: [ fromUnit ][ toUnit ] (-1 means dpi dependent)
+      const unitConversion = {
+        mm: {
+          mm: 1,
+          cm: 0.1,
+          in: 1 / 25.4,
+          pt: 72 / 25.4,
+          pc: 6 / 25.4,
+          px: -1,
+        },
+        cm: {
+          mm: 10,
+          cm: 1,
+          in: 1 / 2.54,
+          pt: 72 / 2.54,
+          pc: 6 / 2.54,
+          px: -1,
+        },
+        in: {
+          mm: 25.4,
+          cm: 2.54,
+          in: 1,
+          pt: 72,
+          pc: 6,
+          px: -1,
+        },
+        pt: {
+          mm: 25.4 / 72,
+          cm: 2.54 / 72,
+          in: 1 / 72,
+          pt: 1,
+          pc: 6 / 72,
+          px: -1,
+        },
+        pc: {
+          mm: 25.4 / 6,
+          cm: 2.54 / 6,
+          in: 1 / 6,
+          pt: 72 / 6,
+          pc: 1,
+          px: -1,
+        },
+        px: {
+          px: 1,
+        },
+      }
+
+      function parseFloatWithUnits(string) {
+        let theUnit = 'px'
+
+        if (typeof string === 'string' || string instanceof String) {
+          for (let i = 0, n = units.length; i < n; i++) {
+            const u = units[i]
+
+            if (string.endsWith(u)) {
+              theUnit = u
+              string = string.substring(0, string.length - u.length)
+              break
+            }
+          }
+        }
 
-      return result
-    }
+        let scale = undefined
 
-    // Units
-
-    const units = ['mm', 'cm', 'in', 'pt', 'pc', 'px']
-
-    // Conversion: [ fromUnit ][ toUnit ] (-1 means dpi dependent)
-    const unitConversion = {
-      mm: {
-        mm: 1,
-        cm: 0.1,
-        in: 1 / 25.4,
-        pt: 72 / 25.4,
-        pc: 6 / 25.4,
-        px: -1,
-      },
-      cm: {
-        mm: 10,
-        cm: 1,
-        in: 1 / 2.54,
-        pt: 72 / 2.54,
-        pc: 6 / 2.54,
-        px: -1,
-      },
-      in: {
-        mm: 25.4,
-        cm: 2.54,
-        in: 1,
-        pt: 72,
-        pc: 6,
-        px: -1,
-      },
-      pt: {
-        mm: 25.4 / 72,
-        cm: 2.54 / 72,
-        in: 1 / 72,
-        pt: 1,
-        pc: 6 / 72,
-        px: -1,
-      },
-      pc: {
-        mm: 25.4 / 6,
-        cm: 2.54 / 6,
-        in: 1 / 6,
-        pt: 72 / 6,
-        pc: 1,
-        px: -1,
-      },
-      px: {
-        px: 1,
-      },
-    }
+        if (theUnit === 'px' && scope.defaultUnit !== 'px') {
+          // Conversion scale from  pixels to inches, then to default units
 
-    function parseFloatWithUnits(string) {
-      let theUnit = 'px'
+          scale = unitConversion['in'][scope.defaultUnit] / scope.defaultDPI
+        } else {
+          scale = unitConversion[theUnit][scope.defaultUnit]
 
-      if (typeof string === 'string' || string instanceof String) {
-        for (let i = 0, n = units.length; i < n; i++) {
-          const u = units[i]
+          if (scale < 0) {
+            // Conversion scale to pixels
 
-          if (string.endsWith(u)) {
-            theUnit = u
-            string = string.substring(0, string.length - u.length)
-            break
+            scale = unitConversion[theUnit]['in'] * scope.defaultDPI
           }
         }
-      }
 
-      let scale = undefined
-
-      if (theUnit === 'px' && scope.defaultUnit !== 'px') {
-        // Conversion scale from  pixels to inches, then to default units
-
-        scale = unitConversion['in'][scope.defaultUnit] / scope.defaultDPI
-      } else {
-        scale = unitConversion[theUnit][scope.defaultUnit]
+        return scale * parseFloat(string)
+      }
 
-        if (scale < 0) {
-          // Conversion scale to pixels
+      // Transforms
 
-          scale = unitConversion[theUnit]['in'] * scope.defaultDPI
+      function getNodeTransform(node) {
+        if (
+          !(
+            node.hasAttribute('transform') ||
+            (node.nodeName === 'use' && (node.hasAttribute('x') || node.hasAttribute('y')))
+          )
+        ) {
+          return null
         }
-      }
-
-      return scale * parseFloat(string)
-    }
 
-    // Transforms
+        const transform = parseNodeTransform(node)
 
-    function getNodeTransform(node) {
-      if (
-        !(
-          node.hasAttribute('transform') ||
-          (node.nodeName === 'use' && (node.hasAttribute('x') || node.hasAttribute('y')))
-        )
-      ) {
-        return null
-      }
+        if (transformStack.length > 0) {
+          transform.premultiply(transformStack[transformStack.length - 1])
+        }
 
-      const transform = parseNodeTransform(node)
+        currentTransform.copy(transform)
+        transformStack.push(transform)
 
-      if (transformStack.length > 0) {
-        transform.premultiply(transformStack[transformStack.length - 1])
+        return transform
       }
 
-      currentTransform.copy(transform)
-      transformStack.push(transform)
+      function parseNodeTransform(node) {
+        const transform = new Matrix3()
+        const currentTransform = tempTransform0
 
-      return transform
-    }
+        if (node.nodeName === 'use' && (node.hasAttribute('x') || node.hasAttribute('y'))) {
+          const tx = parseFloatWithUnits(node.getAttribute('x'))
+          const ty = parseFloatWithUnits(node.getAttribute('y'))
 
-    function parseNodeTransform(node) {
-      const transform = new Matrix3()
-      const currentTransform = tempTransform0
+          transform.translate(tx, ty)
+        }
 
-      if (node.nodeName === 'use' && (node.hasAttribute('x') || node.hasAttribute('y'))) {
-        const tx = parseFloatWithUnits(node.getAttribute('x'))
-        const ty = parseFloatWithUnits(node.getAttribute('y'))
+        if (node.hasAttribute('transform')) {
+          const transformsTexts = node.getAttribute('transform').split(')')
 
-        transform.translate(tx, ty)
-      }
+          for (let tIndex = transformsTexts.length - 1; tIndex >= 0; tIndex--) {
+            const transformText = transformsTexts[tIndex].trim()
 
-      if (node.hasAttribute('transform')) {
-        const transformsTexts = node.getAttribute('transform').split(')')
+            if (transformText === '') continue
 
-        for (let tIndex = transformsTexts.length - 1; tIndex >= 0; tIndex--) {
-          const transformText = transformsTexts[tIndex].trim()
+            const openParPos = transformText.indexOf('(')
+            const closeParPos = transformText.length
 
-          if (transformText === '') continue
+            if (openParPos > 0 && openParPos < closeParPos) {
+              const transformType = transformText.slice(0, openParPos)
 
-          const openParPos = transformText.indexOf('(')
-          const closeParPos = transformText.length
+              const array = parseFloats(transformText.slice(openParPos + 1))
 
-          if (openParPos > 0 && openParPos < closeParPos) {
-            const transformType = transformText.slice(0, openParPos)
+              currentTransform.identity()
 
-            const array = parseFloats(transformText.slice(openParPos + 1))
-
-            currentTransform.identity()
+              switch (transformType) {
+                case 'translate':
+                  if (array.length >= 1) {
+                    const tx = array[0]
+                    let ty = 0
 
-            switch (transformType) {
-              case 'translate':
-                if (array.length >= 1) {
-                  const tx = array[0]
-                  let ty = 0
+                    if (array.length >= 2) {
+                      ty = array[1]
+                    }
 
-                  if (array.length >= 2) {
-                    ty = array[1]
+                    currentTransform.translate(tx, ty)
                   }
 
-                  currentTransform.translate(tx, ty)
-                }
-
-                break
-
-              case 'rotate':
-                if (array.length >= 1) {
-                  let angle = 0
-                  let cx = 0
-                  let cy = 0
-
-                  // Angle
-                  angle = (array[0] * Math.PI) / 180
+                  break
 
-                  if (array.length >= 3) {
-                    // Center x, y
-                    cx = array[1]
-                    cy = array[2]
+                case 'rotate':
+                  if (array.length >= 1) {
+                    let angle = 0
+                    let cx = 0
+                    let cy = 0
+
+                    // Angle
+                    angle = (array[0] * Math.PI) / 180
+
+                    if (array.length >= 3) {
+                      // Center x, y
+                      cx = array[1]
+                      cy = array[2]
+                    }
+
+                    // Rotate around center (cx, cy)
+                    tempTransform1.makeTranslation(-cx, -cy)
+                    tempTransform2.makeRotation(angle)
+                    tempTransform3.multiplyMatrices(tempTransform2, tempTransform1)
+                    tempTransform1.makeTranslation(cx, cy)
+                    currentTransform.multiplyMatrices(tempTransform1, tempTransform3)
                   }
 
-                  // Rotate around center (cx, cy)
-                  tempTransform1.makeTranslation(-cx, -cy)
-                  tempTransform2.makeRotation(angle)
-                  tempTransform3.multiplyMatrices(tempTransform2, tempTransform1)
-                  tempTransform1.makeTranslation(cx, cy)
-                  currentTransform.multiplyMatrices(tempTransform1, tempTransform3)
-                }
+                  break
 
-                break
+                case 'scale':
+                  if (array.length >= 1) {
+                    const scaleX = array[0]
+                    let scaleY = scaleX
 
-              case 'scale':
-                if (array.length >= 1) {
-                  const scaleX = array[0]
-                  let scaleY = scaleX
+                    if (array.length >= 2) {
+                      scaleY = array[1]
+                    }
 
-                  if (array.length >= 2) {
-                    scaleY = array[1]
+                    currentTransform.scale(scaleX, scaleY)
                   }
 
-                  currentTransform.scale(scaleX, scaleY)
-                }
-
-                break
+                  break
 
-              case 'skewX':
-                if (array.length === 1) {
-                  currentTransform.set(1, Math.tan((array[0] * Math.PI) / 180), 0, 0, 1, 0, 0, 0, 1)
-                }
+                case 'skewX':
+                  if (array.length === 1) {
+                    currentTransform.set(1, Math.tan((array[0] * Math.PI) / 180), 0, 0, 1, 0, 0, 0, 1)
+                  }
 
-                break
+                  break
 
-              case 'skewY':
-                if (array.length === 1) {
-                  currentTransform.set(1, 0, 0, Math.tan((array[0] * Math.PI) / 180), 1, 0, 0, 0, 1)
-                }
+                case 'skewY':
+                  if (array.length === 1) {
+                    currentTransform.set(1, 0, 0, Math.tan((array[0] * Math.PI) / 180), 1, 0, 0, 0, 1)
+                  }
 
-                break
+                  break
 
-              case 'matrix':
-                if (array.length === 6) {
-                  currentTransform.set(array[0], array[2], array[4], array[1], array[3], array[5], 0, 0, 1)
-                }
+                case 'matrix':
+                  if (array.length === 6) {
+                    currentTransform.set(array[0], array[2], array[4], array[1], array[3], array[5], 0, 0, 1)
+                  }
 
-                break
+                  break
+              }
             }
-          }
 
-          transform.premultiply(currentTransform)
+            transform.premultiply(currentTransform)
+          }
         }
-      }
 
-      return transform
-    }
+        return transform
+      }
 
-    function transformPath(path, m) {
-      function transfVec2(v2) {
-        tempV3.set(v2.x, v2.y, 1).applyMatrix3(m)
+      function transformPath(path, m) {
+        function transfVec2(v2) {
+          tempV3.set(v2.x, v2.y, 1).applyMatrix3(m)
 
-        v2.set(tempV3.x, tempV3.y)
-      }
+          v2.set(tempV3.x, tempV3.y)
+        }
 
-      function transfEllipseGeneric(curve) {
-        // For math description see:
-        // https://math.stackexchange.com/questions/4544164
+        function transfEllipseGeneric(curve) {
+          // For math description see:
+          // https://math.stackexchange.com/questions/4544164
 
-        const a = curve.xRadius
-        const b = curve.yRadius
+          const a = curve.xRadius
+          const b = curve.yRadius
 
-        const cosTheta = Math.cos(curve.aRotation)
-        const sinTheta = Math.sin(curve.aRotation)
+          const cosTheta = Math.cos(curve.aRotation)
+          const sinTheta = Math.sin(curve.aRotation)
 
-        const v1 = new Vector3(a * cosTheta, a * sinTheta, 0)
-        const v2 = new Vector3(-b * sinTheta, b * cosTheta, 0)
+          const v1 = new Vector3(a * cosTheta, a * sinTheta, 0)
+          const v2 = new Vector3(-b * sinTheta, b * cosTheta, 0)
 
-        const f1 = v1.applyMatrix3(m)
-        const f2 = v2.applyMatrix3(m)
+          const f1 = v1.applyMatrix3(m)
+          const f2 = v2.applyMatrix3(m)
 
-        const mF = tempTransform0.set(f1.x, f2.x, 0, f1.y, f2.y, 0, 0, 0, 1)
+          const mF = tempTransform0.set(f1.x, f2.x, 0, f1.y, f2.y, 0, 0, 0, 1)
 
-        const mFInv = tempTransform1.copy(mF).invert()
-        const mFInvT = tempTransform2.copy(mFInv).transpose()
-        const mQ = mFInvT.multiply(mFInv)
-        const mQe = mQ.elements
+          const mFInv = tempTransform1.copy(mF).invert()
+          const mFInvT = tempTransform2.copy(mFInv).transpose()
+          const mQ = mFInvT.multiply(mFInv)
+          const mQe = mQ.elements
 
-        const ed = eigenDecomposition(mQe[0], mQe[1], mQe[4])
-        const rt1sqrt = Math.sqrt(ed.rt1)
-        const rt2sqrt = Math.sqrt(ed.rt2)
+          const ed = eigenDecomposition(mQe[0], mQe[1], mQe[4])
+          const rt1sqrt = Math.sqrt(ed.rt1)
+          const rt2sqrt = Math.sqrt(ed.rt2)
 
-        curve.xRadius = 1 / rt1sqrt
-        curve.yRadius = 1 / rt2sqrt
-        curve.aRotation = Math.atan2(ed.sn, ed.cs)
+          curve.xRadius = 1 / rt1sqrt
+          curve.yRadius = 1 / rt2sqrt
+          curve.aRotation = Math.atan2(ed.sn, ed.cs)
 
-        const isFullEllipse = (curve.aEndAngle - curve.aStartAngle) % (2 * Math.PI) < Number.EPSILON
+          const isFullEllipse = (curve.aEndAngle - curve.aStartAngle) % (2 * Math.PI) < Number.EPSILON
 
-        // Do not touch angles of a full ellipse because after transformation they
-        // would converge to a sinle value effectively removing the whole curve
+          // Do not touch angles of a full ellipse because after transformation they
+          // would converge to a sinle value effectively removing the whole curve
 
-        if (!isFullEllipse) {
-          const mDsqrt = tempTransform1.set(rt1sqrt, 0, 0, 0, rt2sqrt, 0, 0, 0, 1)
+          if (!isFullEllipse) {
+            const mDsqrt = tempTransform1.set(rt1sqrt, 0, 0, 0, rt2sqrt, 0, 0, 0, 1)
 
-          const mRT = tempTransform2.set(ed.cs, ed.sn, 0, -ed.sn, ed.cs, 0, 0, 0, 1)
+            const mRT = tempTransform2.set(ed.cs, ed.sn, 0, -ed.sn, ed.cs, 0, 0, 0, 1)
 
-          const mDRF = mDsqrt.multiply(mRT).multiply(mF)
+            const mDRF = mDsqrt.multiply(mRT).multiply(mF)
 
-          const transformAngle = (phi) => {
-            const { x: cosR, y: sinR } = new Vector3(Math.cos(phi), Math.sin(phi), 0).applyMatrix3(mDRF)
+            const transformAngle = (phi) => {
+              const { x: cosR, y: sinR } = new Vector3(Math.cos(phi), Math.sin(phi), 0).applyMatrix3(mDRF)
 
-            return Math.atan2(sinR, cosR)
-          }
+              return Math.atan2(sinR, cosR)
+            }
 
-          curve.aStartAngle = transformAngle(curve.aStartAngle)
-          curve.aEndAngle = transformAngle(curve.aEndAngle)
+            curve.aStartAngle = transformAngle(curve.aStartAngle)
+            curve.aEndAngle = transformAngle(curve.aEndAngle)
 
-          if (isTransformFlipped(m)) {
-            curve.aClockwise = !curve.aClockwise
+            if (isTransformFlipped(m)) {
+              curve.aClockwise = !curve.aClockwise
+            }
           }
         }
-      }
 
-      function transfEllipseNoSkew(curve) {
-        // Faster shortcut if no skew is applied
-        // (e.g, a euclidean transform of a group containing the ellipse)
+        function transfEllipseNoSkew(curve) {
+          // Faster shortcut if no skew is applied
+          // (e.g, a euclidean transform of a group containing the ellipse)
 
-        const sx = getTransformScaleX(m)
-        const sy = getTransformScaleY(m)
+          const sx = getTransformScaleX(m)
+          const sy = getTransformScaleY(m)
 
-        curve.xRadius *= sx
-        curve.yRadius *= sy
+          curve.xRadius *= sx
+          curve.yRadius *= sy
 
-        // Extract rotation angle from the matrix of form:
-        //
-        //  | cosθ sx   -sinθ sy |
-        //  | sinθ sx    cosθ sy |
-        //
-        // Remembering that tanθ = sinθ / cosθ; and that
-        // `sx`, `sy`, or both might be zero.
-        const theta =
-          sx > Number.EPSILON ? Math.atan2(m.elements[1], m.elements[0]) : Math.atan2(-m.elements[3], m.elements[4])
+          // Extract rotation angle from the matrix of form:
+          //
+          //  | cosθ sx   -sinθ sy |
+          //  | sinθ sx    cosθ sy |
+          //
+          // Remembering that tanθ = sinθ / cosθ; and that
+          // `sx`, `sy`, or both might be zero.
+          const theta =
+            sx > Number.EPSILON ? Math.atan2(m.elements[1], m.elements[0]) : Math.atan2(-m.elements[3], m.elements[4])
 
-        curve.aRotation += theta
+          curve.aRotation += theta
 
-        if (isTransformFlipped(m)) {
-          curve.aStartAngle *= -1
-          curve.aEndAngle *= -1
-          curve.aClockwise = !curve.aClockwise
+          if (isTransformFlipped(m)) {
+            curve.aStartAngle *= -1
+            curve.aEndAngle *= -1
+            curve.aClockwise = !curve.aClockwise
+          }
         }
-      }
 
-      const subPaths = path.subPaths
-
-      for (let i = 0, n = subPaths.length; i < n; i++) {
-        const subPath = subPaths[i]
-        const curves = subPath.curves
-
-        for (let j = 0; j < curves.length; j++) {
-          const curve = curves[j]
-
-          if (curve.isLineCurve) {
-            transfVec2(curve.v1)
-            transfVec2(curve.v2)
-          } else if (curve.isCubicBezierCurve) {
-            transfVec2(curve.v0)
-            transfVec2(curve.v1)
-            transfVec2(curve.v2)
-            transfVec2(curve.v3)
-          } else if (curve.isQuadraticBezierCurve) {
-            transfVec2(curve.v0)
-            transfVec2(curve.v1)
-            transfVec2(curve.v2)
-          } else if (curve.isEllipseCurve) {
-            // Transform ellipse center point
-
-            tempV2.set(curve.aX, curve.aY)
-            transfVec2(tempV2)
-            curve.aX = tempV2.x
-            curve.aY = tempV2.y
-
-            // Transform ellipse shape parameters
-
-            if (isTransformSkewed(m)) {
-              transfEllipseGeneric(curve)
-            } else {
-              transfEllipseNoSkew(curve)
+        const subPaths = path.subPaths
+
+        for (let i = 0, n = subPaths.length; i < n; i++) {
+          const subPath = subPaths[i]
+          const curves = subPath.curves
+
+          for (let j = 0; j < curves.length; j++) {
+            const curve = curves[j]
+
+            if (curve.isLineCurve) {
+              transfVec2(curve.v1)
+              transfVec2(curve.v2)
+            } else if (curve.isCubicBezierCurve) {
+              transfVec2(curve.v0)
+              transfVec2(curve.v1)
+              transfVec2(curve.v2)
+              transfVec2(curve.v3)
+            } else if (curve.isQuadraticBezierCurve) {
+              transfVec2(curve.v0)
+              transfVec2(curve.v1)
+              transfVec2(curve.v2)
+            } else if (curve.isEllipseCurve) {
+              // Transform ellipse center point
+
+              tempV2.set(curve.aX, curve.aY)
+              transfVec2(tempV2)
+              curve.aX = tempV2.x
+              curve.aY = tempV2.y
+
+              // Transform ellipse shape parameters
+
+              if (isTransformSkewed(m)) {
+                transfEllipseGeneric(curve)
+              } else {
+                transfEllipseNoSkew(curve)
+              }
             }
           }
         }
       }
-    }
 
-    function isTransformFlipped(m) {
-      const te = m.elements
-      return te[0] * te[4] - te[1] * te[3] < 0
-    }
-
-    function isTransformSkewed(m) {
-      const te = m.elements
-      const basisDot = te[0] * te[3] + te[1] * te[4]
-
-      // Shortcut for trivial rotations and transformations
-      if (basisDot === 0) return false
-
-      const sx = getTransformScaleX(m)
-      const sy = getTransformScaleY(m)
+      function isTransformFlipped(m) {
+        const te = m.elements
+        return te[0] * te[4] - te[1] * te[3] < 0
+      }
 
-      return Math.abs(basisDot / (sx * sy)) > Number.EPSILON
-    }
+      function isTransformSkewed(m) {
+        const te = m.elements
+        const basisDot = te[0] * te[3] + te[1] * te[4]
 
-    function getTransformScaleX(m) {
-      const te = m.elements
-      return Math.sqrt(te[0] * te[0] + te[1] * te[1])
-    }
+        // Shortcut for trivial rotations and transformations
+        if (basisDot === 0) return false
 
-    function getTransformScaleY(m) {
-      const te = m.elements
-      return Math.sqrt(te[3] * te[3] + te[4] * te[4])
-    }
+        const sx = getTransformScaleX(m)
+        const sy = getTransformScaleY(m)
 
-    // Calculates the eigensystem of a real symmetric 2x2 matrix
-    //    [ A  B ]
-    //    [ B  C ]
-    // in the form
-    //    [ A  B ]  =  [ cs  -sn ] [ rt1   0  ] [  cs  sn ]
-    //    [ B  C ]     [ sn   cs ] [  0   rt2 ] [ -sn  cs ]
-    // where rt1 >= rt2.
-    //
-    // Adapted from: https://www.mpi-hd.mpg.de/personalhomes/globes/3x3/index.html
-    // -> Algorithms for real symmetric matrices -> Analytical (2x2 symmetric)
-    function eigenDecomposition(A, B, C) {
-      let rt1, rt2, cs, sn, t
-      const sm = A + C
-      const df = A - C
-      const rt = Math.sqrt(df * df + 4 * B * B)
-
-      if (sm > 0) {
-        rt1 = 0.5 * (sm + rt)
-        t = 1 / rt1
-        rt2 = A * t * C - B * t * B
-      } else if (sm < 0) {
-        rt2 = 0.5 * (sm - rt)
-      } else {
-        // This case needs to be treated separately to avoid div by 0
-
-        rt1 = 0.5 * rt
-        rt2 = -0.5 * rt
+        return Math.abs(basisDot / (sx * sy)) > Number.EPSILON
       }
 
-      // Calculate eigenvectors
-
-      if (df > 0) {
-        cs = df + rt
-      } else {
-        cs = df - rt
+      function getTransformScaleX(m) {
+        const te = m.elements
+        return Math.sqrt(te[0] * te[0] + te[1] * te[1])
       }
 
-      if (Math.abs(cs) > 2 * Math.abs(B)) {
-        t = (-2 * B) / cs
-        sn = 1 / Math.sqrt(1 + t * t)
-        cs = t * sn
-      } else if (Math.abs(B) === 0) {
-        cs = 1
-        sn = 0
-      } else {
-        t = (-0.5 * cs) / B
-        cs = 1 / Math.sqrt(1 + t * t)
-        sn = t * cs
+      function getTransformScaleY(m) {
+        const te = m.elements
+        return Math.sqrt(te[3] * te[3] + te[4] * te[4])
       }
 
-      if (df > 0) {
-        t = cs
-        cs = -sn
-        sn = t
-      }
+      // Calculates the eigensystem of a real symmetric 2x2 matrix
+      //    [ A  B ]
+      //    [ B  C ]
+      // in the form
+      //    [ A  B ]  =  [ cs  -sn ] [ rt1   0  ] [  cs  sn ]
+      //    [ B  C ]     [ sn   cs ] [  0   rt2 ] [ -sn  cs ]
+      // where rt1 >= rt2.
+      //
+      // Adapted from: https://www.mpi-hd.mpg.de/personalhomes/globes/3x3/index.html
+      // -> Algorithms for real symmetric matrices -> Analytical (2x2 symmetric)
+      function eigenDecomposition(A, B, C) {
+        let rt1, rt2, cs, sn, t
+        const sm = A + C
+        const df = A - C
+        const rt = Math.sqrt(df * df + 4 * B * B)
+
+        if (sm > 0) {
+          rt1 = 0.5 * (sm + rt)
+          t = 1 / rt1
+          rt2 = A * t * C - B * t * B
+        } else if (sm < 0) {
+          rt2 = 0.5 * (sm - rt)
+        } else {
+          // This case needs to be treated separately to avoid div by 0
 
-      return { rt1, rt2, cs, sn }
-    }
+          rt1 = 0.5 * rt
+          rt2 = -0.5 * rt
+        }
 
-    //
+        // Calculate eigenvectors
 
-    const paths = []
-    const stylesheets = {}
+        if (df > 0) {
+          cs = df + rt
+        } else {
+          cs = df - rt
+        }
 
-    const transformStack = []
+        if (Math.abs(cs) > 2 * Math.abs(B)) {
+          t = (-2 * B) / cs
+          sn = 1 / Math.sqrt(1 + t * t)
+          cs = t * sn
+        } else if (Math.abs(B) === 0) {
+          cs = 1
+          sn = 0
+        } else {
+          t = (-0.5 * cs) / B
+          cs = 1 / Math.sqrt(1 + t * t)
+          sn = t * cs
+        }
 
-    const tempTransform0 = new Matrix3()
-    const tempTransform1 = new Matrix3()
-    const tempTransform2 = new Matrix3()
-    const tempTransform3 = new Matrix3()
-    const tempV2 = new Vector2()
-    const tempV3 = new Vector3()
+        if (df > 0) {
+          t = cs
+          cs = -sn
+          sn = t
+        }
 
-    const currentTransform = new Matrix3()
+        return { rt1, rt2, cs, sn }
+      }
 
-    const xml = new DOMParser().parseFromString(text, 'image/svg+xml') // application/xml
+      //
 
-    parseNode(xml.documentElement, {
-      fill: '#000',
-      fillOpacity: 1,
-      strokeOpacity: 1,
-      strokeWidth: 1,
-      strokeLineJoin: 'miter',
-      strokeLineCap: 'butt',
-      strokeMiterLimit: 4,
-    })
+      const paths = []
+      const stylesheets = {}
 
-    const data = { paths: paths, xml: xml.documentElement }
+      const transformStack = []
 
-    // console.log( paths );
-    return data
-  }
+      const tempTransform0 = new Matrix3()
+      const tempTransform1 = new Matrix3()
+      const tempTransform2 = new Matrix3()
+      const tempTransform3 = new Matrix3()
+      const tempV2 = new Vector2()
+      const tempV3 = new Vector3()
 
-  static createShapes(shapePath) {
-    // Param shapePath: a shapepath as returned by the parse function of this class
-    // Returns Shape object
+      const currentTransform = new Matrix3()
 
-    const BIGNUMBER = 999999999
+      const xml = new DOMParser().parseFromString(text, 'image/svg+xml') // application/xml
 
-    const IntersectionLocationType = {
-      ORIGIN: 0,
-      DESTINATION: 1,
-      BETWEEN: 2,
-      LEFT: 3,
-      RIGHT: 4,
-      BEHIND: 5,
-      BEYOND: 6,
-    }
+      parseNode(xml.documentElement, {
+        fill: '#000',
+        fillOpacity: 1,
+        strokeOpacity: 1,
+        strokeWidth: 1,
+        strokeLineJoin: 'miter',
+        strokeLineCap: 'butt',
+        strokeMiterLimit: 4,
+      })
 
-    const classifyResult = {
-      loc: IntersectionLocationType.ORIGIN,
-      t: 0,
-    }
+      const data = { paths: paths, xml: xml.documentElement }
 
-    function findEdgeIntersection(a0, a1, b0, b1) {
-      const x1 = a0.x
-      const x2 = a1.x
-      const x3 = b0.x
-      const x4 = b1.x
-      const y1 = a0.y
-      const y2 = a1.y
-      const y3 = b0.y
-      const y4 = b1.y
-      const nom1 = (x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3)
-      const nom2 = (x2 - x1) * (y1 - y3) - (y2 - y1) * (x1 - x3)
-      const denom = (y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1)
-      const t1 = nom1 / denom
-      const t2 = nom2 / denom
-
-      if ((denom === 0 && nom1 !== 0) || t1 <= 0 || t1 >= 1 || t2 < 0 || t2 > 1) {
-        //1. lines are parallel or edges don't intersect
+      // console.log( paths );
+      return data
+    }
 
-        return null
-      } else if (nom1 === 0 && denom === 0) {
-        //2. lines are colinear
-
-        //check if endpoints of edge2 (b0-b1) lies on edge1 (a0-a1)
-        for (let i = 0; i < 2; i++) {
-          classifyPoint(i === 0 ? b0 : b1, a0, a1)
-          //find position of this endpoints relatively to edge1
-          if (classifyResult.loc == IntersectionLocationType.ORIGIN) {
-            const point = i === 0 ? b0 : b1
-            return { x: point.x, y: point.y, t: classifyResult.t }
-          } else if (classifyResult.loc == IntersectionLocationType.BETWEEN) {
-            const x = +(x1 + classifyResult.t * (x2 - x1)).toPrecision(10)
-            const y = +(y1 + classifyResult.t * (y2 - y1)).toPrecision(10)
-            return { x: x, y: y, t: classifyResult.t }
+    static createShapes(shapePath) {
+      // Param shapePath: a shapepath as returned by the parse function of this class
+      // Returns Shape object
+
+      const BIGNUMBER = 999999999
+
+      const IntersectionLocationType = {
+        ORIGIN: 0,
+        DESTINATION: 1,
+        BETWEEN: 2,
+        LEFT: 3,
+        RIGHT: 4,
+        BEHIND: 5,
+        BEYOND: 6,
+      }
+
+      const classifyResult = {
+        loc: IntersectionLocationType.ORIGIN,
+        t: 0,
+      }
+
+      function findEdgeIntersection(a0, a1, b0, b1) {
+        const x1 = a0.x
+        const x2 = a1.x
+        const x3 = b0.x
+        const x4 = b1.x
+        const y1 = a0.y
+        const y2 = a1.y
+        const y3 = b0.y
+        const y4 = b1.y
+        const nom1 = (x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3)
+        const nom2 = (x2 - x1) * (y1 - y3) - (y2 - y1) * (x1 - x3)
+        const denom = (y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1)
+        const t1 = nom1 / denom
+        const t2 = nom2 / denom
+
+        if ((denom === 0 && nom1 !== 0) || t1 <= 0 || t1 >= 1 || t2 < 0 || t2 > 1) {
+          //1. lines are parallel or edges don't intersect
+
+          return null
+        } else if (nom1 === 0 && denom === 0) {
+          //2. lines are colinear
+
+          //check if endpoints of edge2 (b0-b1) lies on edge1 (a0-a1)
+          for (let i = 0; i < 2; i++) {
+            classifyPoint(i === 0 ? b0 : b1, a0, a1)
+            //find position of this endpoints relatively to edge1
+            if (classifyResult.loc == IntersectionLocationType.ORIGIN) {
+              const point = i === 0 ? b0 : b1
+              return { x: point.x, y: point.y, t: classifyResult.t }
+            } else if (classifyResult.loc == IntersectionLocationType.BETWEEN) {
+              const x = +(x1 + classifyResult.t * (x2 - x1)).toPrecision(10)
+              const y = +(y1 + classifyResult.t * (y2 - y1)).toPrecision(10)
+              return { x: x, y: y, t: classifyResult.t }
+            }
           }
-        }
 
-        return null
-      } else {
-        //3. edges intersect
+          return null
+        } else {
+          //3. edges intersect
 
-        for (let i = 0; i < 2; i++) {
-          classifyPoint(i === 0 ? b0 : b1, a0, a1)
+          for (let i = 0; i < 2; i++) {
+            classifyPoint(i === 0 ? b0 : b1, a0, a1)
 
-          if (classifyResult.loc == IntersectionLocationType.ORIGIN) {
-            const point = i === 0 ? b0 : b1
-            return { x: point.x, y: point.y, t: classifyResult.t }
+            if (classifyResult.loc == IntersectionLocationType.ORIGIN) {
+              const point = i === 0 ? b0 : b1
+              return { x: point.x, y: point.y, t: classifyResult.t }
+            }
           }
-        }
 
-        const x = +(x1 + t1 * (x2 - x1)).toPrecision(10)
-        const y = +(y1 + t1 * (y2 - y1)).toPrecision(10)
-        return { x: x, y: y, t: t1 }
+          const x = +(x1 + t1 * (x2 - x1)).toPrecision(10)
+          const y = +(y1 + t1 * (y2 - y1)).toPrecision(10)
+          return { x: x, y: y, t: t1 }
+        }
       }
-    }
 
-    function classifyPoint(p, edgeStart, edgeEnd) {
-      const ax = edgeEnd.x - edgeStart.x
-      const ay = edgeEnd.y - edgeStart.y
-      const bx = p.x - edgeStart.x
-      const by = p.y - edgeStart.y
-      const sa = ax * by - bx * ay
-
-      if (p.x === edgeStart.x && p.y === edgeStart.y) {
-        classifyResult.loc = IntersectionLocationType.ORIGIN
-        classifyResult.t = 0
-        return
-      }
+      function classifyPoint(p, edgeStart, edgeEnd) {
+        const ax = edgeEnd.x - edgeStart.x
+        const ay = edgeEnd.y - edgeStart.y
+        const bx = p.x - edgeStart.x
+        const by = p.y - edgeStart.y
+        const sa = ax * by - bx * ay
 
-      if (p.x === edgeEnd.x && p.y === edgeEnd.y) {
-        classifyResult.loc = IntersectionLocationType.DESTINATION
-        classifyResult.t = 1
-        return
-      }
+        if (p.x === edgeStart.x && p.y === edgeStart.y) {
+          classifyResult.loc = IntersectionLocationType.ORIGIN
+          classifyResult.t = 0
+          return
+        }
 
-      if (sa < -Number.EPSILON) {
-        classifyResult.loc = IntersectionLocationType.LEFT
-        return
-      }
+        if (p.x === edgeEnd.x && p.y === edgeEnd.y) {
+          classifyResult.loc = IntersectionLocationType.DESTINATION
+          classifyResult.t = 1
+          return
+        }
 
-      if (sa > Number.EPSILON) {
-        classifyResult.loc = IntersectionLocationType.RIGHT
-        return
-      }
+        if (sa < -Number.EPSILON) {
+          classifyResult.loc = IntersectionLocationType.LEFT
+          return
+        }
 
-      if (ax * bx < 0 || ay * by < 0) {
-        classifyResult.loc = IntersectionLocationType.BEHIND
-        return
-      }
+        if (sa > Number.EPSILON) {
+          classifyResult.loc = IntersectionLocationType.RIGHT
+          return
+        }
 
-      if (Math.sqrt(ax * ax + ay * ay) < Math.sqrt(bx * bx + by * by)) {
-        classifyResult.loc = IntersectionLocationType.BEYOND
-        return
-      }
+        if (ax * bx < 0 || ay * by < 0) {
+          classifyResult.loc = IntersectionLocationType.BEHIND
+          return
+        }
 
-      let t
+        if (Math.sqrt(ax * ax + ay * ay) < Math.sqrt(bx * bx + by * by)) {
+          classifyResult.loc = IntersectionLocationType.BEYOND
+          return
+        }
 
-      if (ax !== 0) {
-        t = bx / ax
-      } else {
-        t = by / ay
-      }
+        let t
 
-      classifyResult.loc = IntersectionLocationType.BETWEEN
-      classifyResult.t = t
-    }
+        if (ax !== 0) {
+          t = bx / ax
+        } else {
+          t = by / ay
+        }
+
+        classifyResult.loc = IntersectionLocationType.BETWEEN
+        classifyResult.t = t
+      }
 
-    function getIntersections(path1, path2) {
-      const intersectionsRaw = []
-      const intersections = []
+      function getIntersections(path1, path2) {
+        const intersectionsRaw = []
+        const intersections = []
 
-      for (let index = 1; index < path1.length; index++) {
-        const path1EdgeStart = path1[index - 1]
-        const path1EdgeEnd = path1[index]
+        for (let index = 1; index < path1.length; index++) {
+          const path1EdgeStart = path1[index - 1]
+          const path1EdgeEnd = path1[index]
 
-        for (let index2 = 1; index2 < path2.length; index2++) {
-          const path2EdgeStart = path2[index2 - 1]
-          const path2EdgeEnd = path2[index2]
+          for (let index2 = 1; index2 < path2.length; index2++) {
+            const path2EdgeStart = path2[index2 - 1]
+            const path2EdgeEnd = path2[index2]
 
-          const intersection = findEdgeIntersection(path1EdgeStart, path1EdgeEnd, path2EdgeStart, path2EdgeEnd)
+            const intersection = findEdgeIntersection(path1EdgeStart, path1EdgeEnd, path2EdgeStart, path2EdgeEnd)
 
-          if (
-            intersection !== null &&
-            intersectionsRaw.find(
-              (i) => i.t <= intersection.t + Number.EPSILON && i.t >= intersection.t - Number.EPSILON,
-            ) === undefined
-          ) {
-            intersectionsRaw.push(intersection)
-            intersections.push(new Vector2(intersection.x, intersection.y))
+            if (
+              intersection !== null &&
+              intersectionsRaw.find(
+                (i) => i.t <= intersection.t + Number.EPSILON && i.t >= intersection.t - Number.EPSILON,
+              ) === undefined
+            ) {
+              intersectionsRaw.push(intersection)
+              intersections.push(new Vector2(intersection.x, intersection.y))
+            }
           }
         }
+
+        return intersections
       }
 
-      return intersections
-    }
+      function getScanlineIntersections(scanline, boundingBox, paths) {
+        const center = new Vector2()
+        boundingBox.getCenter(center)
 
-    function getScanlineIntersections(scanline, boundingBox, paths) {
-      const center = new Vector2()
-      boundingBox.getCenter(center)
+        const allIntersections = []
 
-      const allIntersections = []
+        paths.forEach((path) => {
+          // check if the center of the bounding box is in the bounding box of the paths.
+          // this is a pruning method to limit the search of intersections in paths that can't envelop of the current path.
+          // if a path envelops another path. The center of that oter path, has to be inside the bounding box of the enveloping path.
+          if (path.boundingBox.containsPoint(center)) {
+            const intersections = getIntersections(scanline, path.points)
+
+            intersections.forEach((p) => {
+              allIntersections.push({ identifier: path.identifier, isCW: path.isCW, point: p })
+            })
+          }
+        })
 
-      paths.forEach((path) => {
-        // check if the center of the bounding box is in the bounding box of the paths.
-        // this is a pruning method to limit the search of intersections in paths that can't envelop of the current path.
-        // if a path envelops another path. The center of that oter path, has to be inside the bounding box of the enveloping path.
-        if (path.boundingBox.containsPoint(center)) {
-          const intersections = getIntersections(scanline, path.points)
+        allIntersections.sort((i1, i2) => {
+          return i1.point.x - i2.point.x
+        })
 
-          intersections.forEach((p) => {
-            allIntersections.push({ identifier: path.identifier, isCW: path.isCW, point: p })
-          })
+        return allIntersections
+      }
+
+      function isHoleTo(simplePath, allPaths, scanlineMinX, scanlineMaxX, _fillRule) {
+        if (_fillRule === null || _fillRule === undefined || _fillRule === '') {
+          _fillRule = 'nonzero'
         }
-      })
 
-      allIntersections.sort((i1, i2) => {
-        return i1.point.x - i2.point.x
-      })
+        const centerBoundingBox = new Vector2()
+        simplePath.boundingBox.getCenter(centerBoundingBox)
 
-      return allIntersections
-    }
+        const scanline = [
+          new Vector2(scanlineMinX, centerBoundingBox.y),
+          new Vector2(scanlineMaxX, centerBoundingBox.y),
+        ]
 
-    function isHoleTo(simplePath, allPaths, scanlineMinX, scanlineMaxX, _fillRule) {
-      if (_fillRule === null || _fillRule === undefined || _fillRule === '') {
-        _fillRule = 'nonzero'
-      }
+        const scanlineIntersections = getScanlineIntersections(scanline, simplePath.boundingBox, allPaths)
+
+        scanlineIntersections.sort((i1, i2) => {
+          return i1.point.x - i2.point.x
+        })
 
-      const centerBoundingBox = new Vector2()
-      simplePath.boundingBox.getCenter(centerBoundingBox)
+        const baseIntersections = []
+        const otherIntersections = []
 
-      const scanline = [new Vector2(scanlineMinX, centerBoundingBox.y), new Vector2(scanlineMaxX, centerBoundingBox.y)]
+        scanlineIntersections.forEach((i) => {
+          if (i.identifier === simplePath.identifier) {
+            baseIntersections.push(i)
+          } else {
+            otherIntersections.push(i)
+          }
+        })
 
-      const scanlineIntersections = getScanlineIntersections(scanline, simplePath.boundingBox, allPaths)
+        const firstXOfPath = baseIntersections[0].point.x
 
-      scanlineIntersections.sort((i1, i2) => {
-        return i1.point.x - i2.point.x
-      })
+        // build up the path hierarchy
+        const stack = []
+        let i = 0
 
-      const baseIntersections = []
-      const otherIntersections = []
+        while (i < otherIntersections.length && otherIntersections[i].point.x < firstXOfPath) {
+          if (stack.length > 0 && stack[stack.length - 1] === otherIntersections[i].identifier) {
+            stack.pop()
+          } else {
+            stack.push(otherIntersections[i].identifier)
+          }
 
-      scanlineIntersections.forEach((i) => {
-        if (i.identifier === simplePath.identifier) {
-          baseIntersections.push(i)
-        } else {
-          otherIntersections.push(i)
+          i++
         }
-      })
-
-      const firstXOfPath = baseIntersections[0].point.x
 
-      // build up the path hierarchy
-      const stack = []
-      let i = 0
+        stack.push(simplePath.identifier)
+
+        if (_fillRule === 'evenodd') {
+          const isHole = stack.length % 2 === 0 ? true : false
+          const isHoleFor = stack[stack.length - 2]
+
+          return { identifier: simplePath.identifier, isHole: isHole, for: isHoleFor }
+        } else if (_fillRule === 'nonzero') {
+          // check if path is a hole by counting the amount of paths with alternating rotations it has to cross.
+          let isHole = true
+          let isHoleFor = null
+          let lastCWValue = null
+
+          for (let i = 0; i < stack.length; i++) {
+            const identifier = stack[i]
+            if (isHole) {
+              lastCWValue = allPaths[identifier].isCW
+              isHole = false
+              isHoleFor = identifier
+            } else if (lastCWValue !== allPaths[identifier].isCW) {
+              lastCWValue = allPaths[identifier].isCW
+              isHole = true
+            }
+          }
 
-      while (i < otherIntersections.length && otherIntersections[i].point.x < firstXOfPath) {
-        if (stack.length > 0 && stack[stack.length - 1] === otherIntersections[i].identifier) {
-          stack.pop()
+          return { identifier: simplePath.identifier, isHole: isHole, for: isHoleFor }
         } else {
-          stack.push(otherIntersections[i].identifier)
+          console.warn('fill-rule: "' + _fillRule + '" is currently not implemented.')
         }
-
-        i++
       }
 
-      stack.push(simplePath.identifier)
-
-      if (_fillRule === 'evenodd') {
-        const isHole = stack.length % 2 === 0 ? true : false
-        const isHoleFor = stack[stack.length - 2]
-
-        return { identifier: simplePath.identifier, isHole: isHole, for: isHoleFor }
-      } else if (_fillRule === 'nonzero') {
-        // check if path is a hole by counting the amount of paths with alternating rotations it has to cross.
-        let isHole = true
-        let isHoleFor = null
-        let lastCWValue = null
-
-        for (let i = 0; i < stack.length; i++) {
-          const identifier = stack[i]
-          if (isHole) {
-            lastCWValue = allPaths[identifier].isCW
-            isHole = false
-            isHoleFor = identifier
-          } else if (lastCWValue !== allPaths[identifier].isCW) {
-            lastCWValue = allPaths[identifier].isCW
-            isHole = true
-          }
-        }
+      // check for self intersecting paths
+      // TODO
 
-        return { identifier: simplePath.identifier, isHole: isHole, for: isHoleFor }
-      } else {
-        console.warn('fill-rule: "' + _fillRule + '" is currently not implemented.')
-      }
-    }
+      // check intersecting paths
+      // TODO
+
+      // prepare paths for hole detection
+      let scanlineMinX = BIGNUMBER
+      let scanlineMaxX = -BIGNUMBER
 
-    // check for self intersecting paths
-    // TODO
+      let simplePaths = shapePath.subPaths.map((p) => {
+        const points = p.getPoints()
+        let maxY = -BIGNUMBER
+        let minY = BIGNUMBER
+        let maxX = -BIGNUMBER
+        let minX = BIGNUMBER
 
-    // check intersecting paths
-    // TODO
+        //points.forEach(p => p.y *= -1);
 
-    // prepare paths for hole detection
-    let scanlineMinX = BIGNUMBER
-    let scanlineMaxX = -BIGNUMBER
+        for (let i = 0; i < points.length; i++) {
+          const p = points[i]
 
-    let simplePaths = shapePath.subPaths.map((p) => {
-      const points = p.getPoints()
-      let maxY = -BIGNUMBER
-      let minY = BIGNUMBER
-      let maxX = -BIGNUMBER
-      let minX = BIGNUMBER
+          if (p.y > maxY) {
+            maxY = p.y
+          }
 
-      //points.forEach(p => p.y *= -1);
+          if (p.y < minY) {
+            minY = p.y
+          }
 
-      for (let i = 0; i < points.length; i++) {
-        const p = points[i]
+          if (p.x > maxX) {
+            maxX = p.x
+          }
 
-        if (p.y > maxY) {
-          maxY = p.y
+          if (p.x < minX) {
+            minX = p.x
+          }
         }
 
-        if (p.y < minY) {
-          minY = p.y
+        //
+        if (scanlineMaxX <= maxX) {
+          scanlineMaxX = maxX + 1
         }
 
-        if (p.x > maxX) {
-          maxX = p.x
+        if (scanlineMinX >= minX) {
+          scanlineMinX = minX - 1
         }
 
-        if (p.x < minX) {
-          minX = p.x
+        return {
+          curves: p.curves,
+          points: points,
+          isCW: ShapeUtils.isClockWise(points),
+          identifier: -1,
+          boundingBox: new Box2(new Vector2(minX, minY), new Vector2(maxX, maxY)),
         }
-      }
+      })
 
-      //
-      if (scanlineMaxX <= maxX) {
-        scanlineMaxX = maxX + 1
-      }
+      simplePaths = simplePaths.filter((sp) => sp.points.length > 1)
+
+      for (let identifier = 0; identifier < simplePaths.length; identifier++) {
+        simplePaths[identifier].identifier = identifier
+      }
+
+      // check if path is solid or a hole
+      const isAHole = simplePaths.map((p) =>
+        isHoleTo(
+          p,
+          simplePaths,
+          scanlineMinX,
+          scanlineMaxX,
+          shapePath.userData ? shapePath.userData.style.fillRule : undefined,
+        ),
+      )
+
+      const shapesToReturn = []
+      simplePaths.forEach((p) => {
+        const amIAHole = isAHole[p.identifier]
+
+        if (!amIAHole.isHole) {
+          const shape = new Shape()
+          shape.curves = p.curves
+          const holes = isAHole.filter((h) => h.isHole && h.for === p.identifier)
+          holes.forEach((h) => {
+            const hole = simplePaths[h.identifier]
+            const path = new Path()
+            path.curves = hole.curves
+            shape.holes.push(path)
+          })
+          shapesToReturn.push(shape)
+        }
+      })
 
-      if (scanlineMinX >= minX) {
-        scanlineMinX = minX - 1
-      }
+      return shapesToReturn
+    }
+
+    static getStrokeStyle(width, color, lineJoin, lineCap, miterLimit) {
+      // Param width: Stroke width
+      // Param color: As returned by THREE.Color.getStyle()
+      // Param lineJoin: One of "round", "bevel", "miter" or "miter-limit"
+      // Param lineCap: One of "round", "square" or "butt"
+      // Param miterLimit: Maximum join length, in multiples of the "width" parameter (join is truncated if it exceeds that distance)
+      // Returns style object
+
+      width = width !== undefined ? width : 1
+      color = color !== undefined ? color : '#000'
+      lineJoin = lineJoin !== undefined ? lineJoin : 'miter'
+      lineCap = lineCap !== undefined ? lineCap : 'butt'
+      miterLimit = miterLimit !== undefined ? miterLimit : 4
 
       return {
-        curves: p.curves,
-        points: points,
-        isCW: ShapeUtils.isClockWise(points),
-        identifier: -1,
-        boundingBox: new Box2(new Vector2(minX, minY), new Vector2(maxX, maxY)),
+        strokeColor: color,
+        strokeWidth: width,
+        strokeLineJoin: lineJoin,
+        strokeLineCap: lineCap,
+        strokeMiterLimit: miterLimit,
       }
-    })
+    }
 
-    simplePaths = simplePaths.filter((sp) => sp.points.length > 1)
+    static pointsToStroke(points, style, arcDivisions, minDistance) {
+      // Generates a stroke with some width around the given path.
+      // The path can be open or closed (last point equals to first point)
+      // Param points: Array of Vector2D (the path). Minimum 2 points.
+      // Param style: Object with SVG properties as returned by SVGLoader.getStrokeStyle(), or SVGLoader.parse() in the path.userData.style object
+      // Params arcDivisions: Arc divisions for round joins and endcaps. (Optional)
+      // Param minDistance: Points closer to this distance will be merged. (Optional)
+      // Returns BufferGeometry with stroke triangles (In plane z = 0). UV coordinates are generated ('u' along path. 'v' across it, from left to right)
 
-    for (let identifier = 0; identifier < simplePaths.length; identifier++) {
-      simplePaths[identifier].identifier = identifier
-    }
+      const vertices = []
+      const normals = []
+      const uvs = []
 
-    // check if path is solid or a hole
-    const isAHole = simplePaths.map((p) =>
-      isHoleTo(
-        p,
-        simplePaths,
-        scanlineMinX,
-        scanlineMaxX,
-        shapePath.userData ? shapePath.userData.style.fillRule : undefined,
-      ),
-    )
-
-    const shapesToReturn = []
-    simplePaths.forEach((p) => {
-      const amIAHole = isAHole[p.identifier]
-
-      if (!amIAHole.isHole) {
-        const shape = new Shape()
-        shape.curves = p.curves
-        const holes = isAHole.filter((h) => h.isHole && h.for === p.identifier)
-        holes.forEach((h) => {
-          const hole = simplePaths[h.identifier]
-          const path = new Path()
-          path.curves = hole.curves
-          shape.holes.push(path)
-        })
-        shapesToReturn.push(shape)
+      if (SVGLoader.pointsToStrokeWithBuffers(points, style, arcDivisions, minDistance, vertices, normals, uvs) === 0) {
+        return null
       }
-    })
 
-    return shapesToReturn
-  }
-
-  static getStrokeStyle(width, color, lineJoin, lineCap, miterLimit) {
-    // Param width: Stroke width
-    // Param color: As returned by THREE.Color.getStyle()
-    // Param lineJoin: One of "round", "bevel", "miter" or "miter-limit"
-    // Param lineCap: One of "round", "square" or "butt"
-    // Param miterLimit: Maximum join length, in multiples of the "width" parameter (join is truncated if it exceeds that distance)
-    // Returns style object
-
-    width = width !== undefined ? width : 1
-    color = color !== undefined ? color : '#000'
-    lineJoin = lineJoin !== undefined ? lineJoin : 'miter'
-    lineCap = lineCap !== undefined ? lineCap : 'butt'
-    miterLimit = miterLimit !== undefined ? miterLimit : 4
-
-    return {
-      strokeColor: color,
-      strokeWidth: width,
-      strokeLineJoin: lineJoin,
-      strokeLineCap: lineCap,
-      strokeMiterLimit: miterLimit,
-    }
-  }
+      const geometry = new BufferGeometry()
+      geometry.setAttribute('position', new Float32BufferAttribute(vertices, 3))
+      geometry.setAttribute('normal', new Float32BufferAttribute(normals, 3))
+      geometry.setAttribute('uv', new Float32BufferAttribute(uvs, 2))
 
-  static pointsToStroke(points, style, arcDivisions, minDistance) {
-    // Generates a stroke with some width around the given path.
-    // The path can be open or closed (last point equals to first point)
-    // Param points: Array of Vector2D (the path). Minimum 2 points.
-    // Param style: Object with SVG properties as returned by SVGLoader.getStrokeStyle(), or SVGLoader.parse() in the path.userData.style object
-    // Params arcDivisions: Arc divisions for round joins and endcaps. (Optional)
-    // Param minDistance: Points closer to this distance will be merged. (Optional)
-    // Returns BufferGeometry with stroke triangles (In plane z = 0). UV coordinates are generated ('u' along path. 'v' across it, from left to right)
-
-    const vertices = []
-    const normals = []
-    const uvs = []
-
-    if (SVGLoader.pointsToStrokeWithBuffers(points, style, arcDivisions, minDistance, vertices, normals, uvs) === 0) {
-      return null
+      return geometry
     }
 
-    const geometry = new BufferGeometry()
-    geometry.setAttribute('position', new Float32BufferAttribute(vertices, 3))
-    geometry.setAttribute('normal', new Float32BufferAttribute(normals, 3))
-    geometry.setAttribute('uv', new Float32BufferAttribute(uvs, 2))
+    static pointsToStrokeWithBuffers(points, style, arcDivisions, minDistance, vertices, normals, uvs, vertexOffset) {
+      // This function can be called to update existing arrays or buffers.
+      // Accepts same parameters as pointsToStroke, plus the buffers and optional offset.
+      // Param vertexOffset: Offset vertices to start writing in the buffers (3 elements/vertex for vertices and normals, and 2 elements/vertex for uvs)
+      // Returns number of written vertices / normals / uvs pairs
+      // if 'vertices' parameter is undefined no triangles will be generated, but the returned vertices count will still be valid (useful to preallocate the buffers)
+      // 'normals' and 'uvs' buffers are optional
+
+      const tempV2_1 = new Vector2()
+      const tempV2_2 = new Vector2()
+      const tempV2_3 = new Vector2()
+      const tempV2_4 = new Vector2()
+      const tempV2_5 = new Vector2()
+      const tempV2_6 = new Vector2()
+      const tempV2_7 = new Vector2()
+      const lastPointL = new Vector2()
+      const lastPointR = new Vector2()
+      const point0L = new Vector2()
+      const point0R = new Vector2()
+      const currentPointL = new Vector2()
+      const currentPointR = new Vector2()
+      const nextPointL = new Vector2()
+      const nextPointR = new Vector2()
+      const innerPoint = new Vector2()
+      const outerPoint = new Vector2()
+
+      arcDivisions = arcDivisions !== undefined ? arcDivisions : 12
+      minDistance = minDistance !== undefined ? minDistance : 0.001
+      vertexOffset = vertexOffset !== undefined ? vertexOffset : 0
+
+      // First ensure there are no duplicated points
+      points = removeDuplicatedPoints(points)
+
+      const numPoints = points.length
+
+      if (numPoints < 2) return 0
+
+      const isClosed = points[0].equals(points[numPoints - 1])
+
+      let currentPoint
+      let previousPoint = points[0]
+      let nextPoint
+
+      const strokeWidth2 = style.strokeWidth / 2
+
+      const deltaU = 1 / (numPoints - 1)
+      let u0 = 0,
+        u1
+
+      let innerSideModified
+      let joinIsOnLeftSide
+      let isMiter
+      let initialJoinIsOnLeftSide = false
+
+      let numVertices = 0
+      let currentCoordinate = vertexOffset * 3
+      let currentCoordinateUV = vertexOffset * 2
+
+      // Get initial left and right stroke points
+      getNormal(points[0], points[1], tempV2_1).multiplyScalar(strokeWidth2)
+      lastPointL.copy(points[0]).sub(tempV2_1)
+      lastPointR.copy(points[0]).add(tempV2_1)
+      point0L.copy(lastPointL)
+      point0R.copy(lastPointR)
+
+      for (let iPoint = 1; iPoint < numPoints; iPoint++) {
+        currentPoint = points[iPoint]
+
+        // Get next point
+        if (iPoint === numPoints - 1) {
+          if (isClosed) {
+            // Skip duplicated initial point
+            nextPoint = points[1]
+          } else nextPoint = undefined
+        } else {
+          nextPoint = points[iPoint + 1]
+        }
 
-    return geometry
-  }
+        // Normal of previous segment in tempV2_1
+        const normal1 = tempV2_1
+        getNormal(previousPoint, currentPoint, normal1)
 
-  static pointsToStrokeWithBuffers(points, style, arcDivisions, minDistance, vertices, normals, uvs, vertexOffset) {
-    // This function can be called to update existing arrays or buffers.
-    // Accepts same parameters as pointsToStroke, plus the buffers and optional offset.
-    // Param vertexOffset: Offset vertices to start writing in the buffers (3 elements/vertex for vertices and normals, and 2 elements/vertex for uvs)
-    // Returns number of written vertices / normals / uvs pairs
-    // if 'vertices' parameter is undefined no triangles will be generated, but the returned vertices count will still be valid (useful to preallocate the buffers)
-    // 'normals' and 'uvs' buffers are optional
-
-    const tempV2_1 = new Vector2()
-    const tempV2_2 = new Vector2()
-    const tempV2_3 = new Vector2()
-    const tempV2_4 = new Vector2()
-    const tempV2_5 = new Vector2()
-    const tempV2_6 = new Vector2()
-    const tempV2_7 = new Vector2()
-    const lastPointL = new Vector2()
-    const lastPointR = new Vector2()
-    const point0L = new Vector2()
-    const point0R = new Vector2()
-    const currentPointL = new Vector2()
-    const currentPointR = new Vector2()
-    const nextPointL = new Vector2()
-    const nextPointR = new Vector2()
-    const innerPoint = new Vector2()
-    const outerPoint = new Vector2()
-
-    arcDivisions = arcDivisions !== undefined ? arcDivisions : 12
-    minDistance = minDistance !== undefined ? minDistance : 0.001
-    vertexOffset = vertexOffset !== undefined ? vertexOffset : 0
-
-    // First ensure there are no duplicated points
-    points = removeDuplicatedPoints(points)
-
-    const numPoints = points.length
-
-    if (numPoints < 2) return 0
-
-    const isClosed = points[0].equals(points[numPoints - 1])
-
-    let currentPoint
-    let previousPoint = points[0]
-    let nextPoint
-
-    const strokeWidth2 = style.strokeWidth / 2
-
-    const deltaU = 1 / (numPoints - 1)
-    let u0 = 0,
-      u1
-
-    let innerSideModified
-    let joinIsOnLeftSide
-    let isMiter
-    let initialJoinIsOnLeftSide = false
-
-    let numVertices = 0
-    let currentCoordinate = vertexOffset * 3
-    let currentCoordinateUV = vertexOffset * 2
-
-    // Get initial left and right stroke points
-    getNormal(points[0], points[1], tempV2_1).multiplyScalar(strokeWidth2)
-    lastPointL.copy(points[0]).sub(tempV2_1)
-    lastPointR.copy(points[0]).add(tempV2_1)
-    point0L.copy(lastPointL)
-    point0R.copy(lastPointR)
-
-    for (let iPoint = 1; iPoint < numPoints; iPoint++) {
-      currentPoint = points[iPoint]
-
-      // Get next point
-      if (iPoint === numPoints - 1) {
-        if (isClosed) {
-          // Skip duplicated initial point
-          nextPoint = points[1]
-        } else nextPoint = undefined
-      } else {
-        nextPoint = points[iPoint + 1]
-      }
+        tempV2_3.copy(normal1).multiplyScalar(strokeWidth2)
+        currentPointL.copy(currentPoint).sub(tempV2_3)
+        currentPointR.copy(currentPoint).add(tempV2_3)
 
-      // Normal of previous segment in tempV2_1
-      const normal1 = tempV2_1
-      getNormal(previousPoint, currentPoint, normal1)
-
-      tempV2_3.copy(normal1).multiplyScalar(strokeWidth2)
-      currentPointL.copy(currentPoint).sub(tempV2_3)
-      currentPointR.copy(currentPoint).add(tempV2_3)
-
-      u1 = u0 + deltaU
-
-      innerSideModified = false
-
-      if (nextPoint !== undefined) {
-        // Normal of next segment in tempV2_2
-        getNormal(currentPoint, nextPoint, tempV2_2)
-
-        tempV2_3.copy(tempV2_2).multiplyScalar(strokeWidth2)
-        nextPointL.copy(currentPoint).sub(tempV2_3)
-        nextPointR.copy(currentPoint).add(tempV2_3)
-
-        joinIsOnLeftSide = true
-        tempV2_3.subVectors(nextPoint, previousPoint)
-        if (normal1.dot(tempV2_3) < 0) {
-          joinIsOnLeftSide = false
-        }
-
-        if (iPoint === 1) initialJoinIsOnLeftSide = joinIsOnLeftSide
-
-        tempV2_3.subVectors(nextPoint, currentPoint)
-        tempV2_3.normalize()
-        const dot = Math.abs(normal1.dot(tempV2_3))
-
-        // If path is straight, don't create join
-        if (dot > Number.EPSILON) {
-          // Compute inner and outer segment intersections
-          const miterSide = strokeWidth2 / dot
-          tempV2_3.multiplyScalar(-miterSide)
-          tempV2_4.subVectors(currentPoint, previousPoint)
-          tempV2_5.copy(tempV2_4).setLength(miterSide).add(tempV2_3)
-          innerPoint.copy(tempV2_5).negate()
-          const miterLength2 = tempV2_5.length()
-          const segmentLengthPrev = tempV2_4.length()
-          tempV2_4.divideScalar(segmentLengthPrev)
-          tempV2_6.subVectors(nextPoint, currentPoint)
-          const segmentLengthNext = tempV2_6.length()
-          tempV2_6.divideScalar(segmentLengthNext)
-          // Check that previous and next segments doesn't overlap with the innerPoint of intersection
-          if (tempV2_4.dot(innerPoint) < segmentLengthPrev && tempV2_6.dot(innerPoint) < segmentLengthNext) {
-            innerSideModified = true
-          }
+        u1 = u0 + deltaU
 
-          outerPoint.copy(tempV2_5).add(currentPoint)
-          innerPoint.add(currentPoint)
+        innerSideModified = false
 
-          isMiter = false
+        if (nextPoint !== undefined) {
+          // Normal of next segment in tempV2_2
+          getNormal(currentPoint, nextPoint, tempV2_2)
 
-          if (innerSideModified) {
-            if (joinIsOnLeftSide) {
-              nextPointR.copy(innerPoint)
-              currentPointR.copy(innerPoint)
-            } else {
-              nextPointL.copy(innerPoint)
-              currentPointL.copy(innerPoint)
-            }
-          } else {
-            // The segment triangles are generated here if there was overlapping
+          tempV2_3.copy(tempV2_2).multiplyScalar(strokeWidth2)
+          nextPointL.copy(currentPoint).sub(tempV2_3)
+          nextPointR.copy(currentPoint).add(tempV2_3)
 
-            makeSegmentTriangles()
+          joinIsOnLeftSide = true
+          tempV2_3.subVectors(nextPoint, previousPoint)
+          if (normal1.dot(tempV2_3) < 0) {
+            joinIsOnLeftSide = false
           }
 
-          switch (style.strokeLineJoin) {
-            case 'bevel':
-              makeSegmentWithBevelJoin(joinIsOnLeftSide, innerSideModified, u1)
-
-              break
-
-            case 'round':
-              // Segment triangles
+          if (iPoint === 1) initialJoinIsOnLeftSide = joinIsOnLeftSide
+
+          tempV2_3.subVectors(nextPoint, currentPoint)
+          tempV2_3.normalize()
+          const dot = Math.abs(normal1.dot(tempV2_3))
+
+          // If path is straight, don't create join
+          if (dot > Number.EPSILON) {
+            // Compute inner and outer segment intersections
+            const miterSide = strokeWidth2 / dot
+            tempV2_3.multiplyScalar(-miterSide)
+            tempV2_4.subVectors(currentPoint, previousPoint)
+            tempV2_5.copy(tempV2_4).setLength(miterSide).add(tempV2_3)
+            innerPoint.copy(tempV2_5).negate()
+            const miterLength2 = tempV2_5.length()
+            const segmentLengthPrev = tempV2_4.length()
+            tempV2_4.divideScalar(segmentLengthPrev)
+            tempV2_6.subVectors(nextPoint, currentPoint)
+            const segmentLengthNext = tempV2_6.length()
+            tempV2_6.divideScalar(segmentLengthNext)
+            // Check that previous and next segments doesn't overlap with the innerPoint of intersection
+            if (tempV2_4.dot(innerPoint) < segmentLengthPrev && tempV2_6.dot(innerPoint) < segmentLengthNext) {
+              innerSideModified = true
+            }
 
-              createSegmentTrianglesWithMiddleSection(joinIsOnLeftSide, innerSideModified)
+            outerPoint.copy(tempV2_5).add(currentPoint)
+            innerPoint.add(currentPoint)
 
-              // Join triangles
+            isMiter = false
 
+            if (innerSideModified) {
               if (joinIsOnLeftSide) {
-                makeCircularSector(currentPoint, currentPointL, nextPointL, u1, 0)
+                nextPointR.copy(innerPoint)
+                currentPointR.copy(innerPoint)
               } else {
-                makeCircularSector(currentPoint, nextPointR, currentPointR, u1, 1)
+                nextPointL.copy(innerPoint)
+                currentPointL.copy(innerPoint)
               }
+            } else {
+              // The segment triangles are generated here if there was overlapping
 
-              break
+              makeSegmentTriangles()
+            }
 
-            case 'miter':
-            case 'miter-clip':
-            default:
-              const miterFraction = (strokeWidth2 * style.strokeMiterLimit) / miterLength2
+            switch (style.strokeLineJoin) {
+              case 'bevel':
+                makeSegmentWithBevelJoin(joinIsOnLeftSide, innerSideModified, u1)
 
-              if (miterFraction < 1) {
-                // The join miter length exceeds the miter limit
+                break
 
-                if (style.strokeLineJoin !== 'miter-clip') {
-                  makeSegmentWithBevelJoin(joinIsOnLeftSide, innerSideModified, u1)
-                  break
-                } else {
-                  // Segment triangles
+              case 'round':
+                // Segment triangles
 
-                  createSegmentTrianglesWithMiddleSection(joinIsOnLeftSide, innerSideModified)
+                createSegmentTrianglesWithMiddleSection(joinIsOnLeftSide, innerSideModified)
 
-                  // Miter-clip join triangles
+                // Join triangles
 
-                  if (joinIsOnLeftSide) {
-                    tempV2_6.subVectors(outerPoint, currentPointL).multiplyScalar(miterFraction).add(currentPointL)
-                    tempV2_7.subVectors(outerPoint, nextPointL).multiplyScalar(miterFraction).add(nextPointL)
+                if (joinIsOnLeftSide) {
+                  makeCircularSector(currentPoint, currentPointL, nextPointL, u1, 0)
+                } else {
+                  makeCircularSector(currentPoint, nextPointR, currentPointR, u1, 1)
+                }
+
+                break
 
-                    addVertex(currentPointL, u1, 0)
-                    addVertex(tempV2_6, u1, 0)
-                    addVertex(currentPoint, u1, 0.5)
+              case 'miter':
+              case 'miter-clip':
+              default:
+                const miterFraction = (strokeWidth2 * style.strokeMiterLimit) / miterLength2
 
-                    addVertex(currentPoint, u1, 0.5)
-                    addVertex(tempV2_6, u1, 0)
-                    addVertex(tempV2_7, u1, 0)
+                if (miterFraction < 1) {
+                  // The join miter length exceeds the miter limit
 
-                    addVertex(currentPoint, u1, 0.5)
-                    addVertex(tempV2_7, u1, 0)
-                    addVertex(nextPointL, u1, 0)
+                  if (style.strokeLineJoin !== 'miter-clip') {
+                    makeSegmentWithBevelJoin(joinIsOnLeftSide, innerSideModified, u1)
+                    break
                   } else {
-                    tempV2_6.subVectors(outerPoint, currentPointR).multiplyScalar(miterFraction).add(currentPointR)
-                    tempV2_7.subVectors(outerPoint, nextPointR).multiplyScalar(miterFraction).add(nextPointR)
+                    // Segment triangles
 
-                    addVertex(currentPointR, u1, 1)
-                    addVertex(tempV2_6, u1, 1)
-                    addVertex(currentPoint, u1, 0.5)
+                    createSegmentTrianglesWithMiddleSection(joinIsOnLeftSide, innerSideModified)
 
-                    addVertex(currentPoint, u1, 0.5)
-                    addVertex(tempV2_6, u1, 1)
-                    addVertex(tempV2_7, u1, 1)
+                    // Miter-clip join triangles
 
-                    addVertex(currentPoint, u1, 0.5)
-                    addVertex(tempV2_7, u1, 1)
-                    addVertex(nextPointR, u1, 1)
-                  }
-                }
-              } else {
-                // Miter join segment triangles
+                    if (joinIsOnLeftSide) {
+                      tempV2_6.subVectors(outerPoint, currentPointL).multiplyScalar(miterFraction).add(currentPointL)
+                      tempV2_7.subVectors(outerPoint, nextPointL).multiplyScalar(miterFraction).add(nextPointL)
 
-                if (innerSideModified) {
-                  // Optimized segment + join triangles
+                      addVertex(currentPointL, u1, 0)
+                      addVertex(tempV2_6, u1, 0)
+                      addVertex(currentPoint, u1, 0.5)
 
-                  if (joinIsOnLeftSide) {
-                    addVertex(lastPointR, u0, 1)
-                    addVertex(lastPointL, u0, 0)
-                    addVertex(outerPoint, u1, 0)
+                      addVertex(currentPoint, u1, 0.5)
+                      addVertex(tempV2_6, u1, 0)
+                      addVertex(tempV2_7, u1, 0)
 
-                    addVertex(lastPointR, u0, 1)
-                    addVertex(outerPoint, u1, 0)
-                    addVertex(innerPoint, u1, 1)
-                  } else {
-                    addVertex(lastPointR, u0, 1)
-                    addVertex(lastPointL, u0, 0)
-                    addVertex(outerPoint, u1, 1)
+                      addVertex(currentPoint, u1, 0.5)
+                      addVertex(tempV2_7, u1, 0)
+                      addVertex(nextPointL, u1, 0)
+                    } else {
+                      tempV2_6.subVectors(outerPoint, currentPointR).multiplyScalar(miterFraction).add(currentPointR)
+                      tempV2_7.subVectors(outerPoint, nextPointR).multiplyScalar(miterFraction).add(nextPointR)
 
-                    addVertex(lastPointL, u0, 0)
-                    addVertex(innerPoint, u1, 0)
-                    addVertex(outerPoint, u1, 1)
-                  }
+                      addVertex(currentPointR, u1, 1)
+                      addVertex(tempV2_6, u1, 1)
+                      addVertex(currentPoint, u1, 0.5)
 
-                  if (joinIsOnLeftSide) {
-                    nextPointL.copy(outerPoint)
-                  } else {
-                    nextPointR.copy(outerPoint)
+                      addVertex(currentPoint, u1, 0.5)
+                      addVertex(tempV2_6, u1, 1)
+                      addVertex(tempV2_7, u1, 1)
+
+                      addVertex(currentPoint, u1, 0.5)
+                      addVertex(tempV2_7, u1, 1)
+                      addVertex(nextPointR, u1, 1)
+                    }
                   }
                 } else {
-                  // Add extra miter join triangles
-
-                  if (joinIsOnLeftSide) {
-                    addVertex(currentPointL, u1, 0)
-                    addVertex(outerPoint, u1, 0)
-                    addVertex(currentPoint, u1, 0.5)
-
-                    addVertex(currentPoint, u1, 0.5)
-                    addVertex(outerPoint, u1, 0)
-                    addVertex(nextPointL, u1, 0)
+                  // Miter join segment triangles
+
+                  if (innerSideModified) {
+                    // Optimized segment + join triangles
+
+                    if (joinIsOnLeftSide) {
+                      addVertex(lastPointR, u0, 1)
+                      addVertex(lastPointL, u0, 0)
+                      addVertex(outerPoint, u1, 0)
+
+                      addVertex(lastPointR, u0, 1)
+                      addVertex(outerPoint, u1, 0)
+                      addVertex(innerPoint, u1, 1)
+                    } else {
+                      addVertex(lastPointR, u0, 1)
+                      addVertex(lastPointL, u0, 0)
+                      addVertex(outerPoint, u1, 1)
+
+                      addVertex(lastPointL, u0, 0)
+                      addVertex(innerPoint, u1, 0)
+                      addVertex(outerPoint, u1, 1)
+                    }
+
+                    if (joinIsOnLeftSide) {
+                      nextPointL.copy(outerPoint)
+                    } else {
+                      nextPointR.copy(outerPoint)
+                    }
                   } else {
-                    addVertex(currentPointR, u1, 1)
-                    addVertex(outerPoint, u1, 1)
-                    addVertex(currentPoint, u1, 0.5)
-
-                    addVertex(currentPoint, u1, 0.5)
-                    addVertex(outerPoint, u1, 1)
-                    addVertex(nextPointR, u1, 1)
+                    // Add extra miter join triangles
+
+                    if (joinIsOnLeftSide) {
+                      addVertex(currentPointL, u1, 0)
+                      addVertex(outerPoint, u1, 0)
+                      addVertex(currentPoint, u1, 0.5)
+
+                      addVertex(currentPoint, u1, 0.5)
+                      addVertex(outerPoint, u1, 0)
+                      addVertex(nextPointL, u1, 0)
+                    } else {
+                      addVertex(currentPointR, u1, 1)
+                      addVertex(outerPoint, u1, 1)
+                      addVertex(currentPoint, u1, 0.5)
+
+                      addVertex(currentPoint, u1, 0.5)
+                      addVertex(outerPoint, u1, 1)
+                      addVertex(nextPointR, u1, 1)
+                    }
                   }
+
+                  isMiter = true
                 }
 
-                isMiter = true
-              }
+                break
+            }
+          } else {
+            // The segment triangles are generated here when two consecutive points are collinear
 
-              break
+            makeSegmentTriangles()
           }
         } else {
-          // The segment triangles are generated here when two consecutive points are collinear
+          // The segment triangles are generated here if it is the ending segment
 
           makeSegmentTriangles()
         }
-      } else {
-        // The segment triangles are generated here if it is the ending segment
-
-        makeSegmentTriangles()
-      }
 
-      if (!isClosed && iPoint === numPoints - 1) {
-        // Start line endcap
-        addCapGeometry(points[0], point0L, point0R, joinIsOnLeftSide, true, u0)
-      }
+        if (!isClosed && iPoint === numPoints - 1) {
+          // Start line endcap
+          addCapGeometry(points[0], point0L, point0R, joinIsOnLeftSide, true, u0)
+        }
 
-      // Increment loop variables
+        // Increment loop variables
 
-      u0 = u1
+        u0 = u1
 
-      previousPoint = currentPoint
+        previousPoint = currentPoint
 
-      lastPointL.copy(nextPointL)
-      lastPointR.copy(nextPointR)
-    }
+        lastPointL.copy(nextPointL)
+        lastPointR.copy(nextPointR)
+      }
 
-    if (!isClosed) {
-      // Ending line endcap
-      addCapGeometry(currentPoint, currentPointL, currentPointR, joinIsOnLeftSide, false, u1)
-    } else if (innerSideModified && vertices) {
-      // Modify path first segment vertices to adjust to the segments inner and outer intersections
+      if (!isClosed) {
+        // Ending line endcap
+        addCapGeometry(currentPoint, currentPointL, currentPointR, joinIsOnLeftSide, false, u1)
+      } else if (innerSideModified && vertices) {
+        // Modify path first segment vertices to adjust to the segments inner and outer intersections
 
-      let lastOuter = outerPoint
-      let lastInner = innerPoint
+        let lastOuter = outerPoint
+        let lastInner = innerPoint
 
-      if (initialJoinIsOnLeftSide !== joinIsOnLeftSide) {
-        lastOuter = innerPoint
-        lastInner = outerPoint
-      }
+        if (initialJoinIsOnLeftSide !== joinIsOnLeftSide) {
+          lastOuter = innerPoint
+          lastInner = outerPoint
+        }
 
-      if (joinIsOnLeftSide) {
-        if (isMiter || initialJoinIsOnLeftSide) {
-          lastInner.toArray(vertices, 0 * 3)
-          lastInner.toArray(vertices, 3 * 3)
+        if (joinIsOnLeftSide) {
+          if (isMiter || initialJoinIsOnLeftSide) {
+            lastInner.toArray(vertices, 0 * 3)
+            lastInner.toArray(vertices, 3 * 3)
 
-          if (isMiter) {
-            lastOuter.toArray(vertices, 1 * 3)
+            if (isMiter) {
+              lastOuter.toArray(vertices, 1 * 3)
+            }
           }
-        }
-      } else {
-        if (isMiter || !initialJoinIsOnLeftSide) {
-          lastInner.toArray(vertices, 1 * 3)
-          lastInner.toArray(vertices, 3 * 3)
+        } else {
+          if (isMiter || !initialJoinIsOnLeftSide) {
+            lastInner.toArray(vertices, 1 * 3)
+            lastInner.toArray(vertices, 3 * 3)
 
-          if (isMiter) {
-            lastOuter.toArray(vertices, 0 * 3)
+            if (isMiter) {
+              lastOuter.toArray(vertices, 0 * 3)
+            }
           }
         }
       }
-    }
 
-    return numVertices
+      return numVertices
 
-    // -- End of algorithm
+      // -- End of algorithm
 
-    // -- Functions
+      // -- Functions
 
-    function getNormal(p1, p2, result) {
-      result.subVectors(p2, p1)
-      return result.set(-result.y, result.x).normalize()
-    }
+      function getNormal(p1, p2, result) {
+        result.subVectors(p2, p1)
+        return result.set(-result.y, result.x).normalize()
+      }
 
-    function addVertex(position, u, v) {
-      if (vertices) {
-        vertices[currentCoordinate] = position.x
-        vertices[currentCoordinate + 1] = position.y
-        vertices[currentCoordinate + 2] = 0
+      function addVertex(position, u, v) {
+        if (vertices) {
+          vertices[currentCoordinate] = position.x
+          vertices[currentCoordinate + 1] = position.y
+          vertices[currentCoordinate + 2] = 0
 
-        if (normals) {
-          normals[currentCoordinate] = 0
-          normals[currentCoordinate + 1] = 0
-          normals[currentCoordinate + 2] = 1
-        }
+          if (normals) {
+            normals[currentCoordinate] = 0
+            normals[currentCoordinate + 1] = 0
+            normals[currentCoordinate + 2] = 1
+          }
 
-        currentCoordinate += 3
+          currentCoordinate += 3
 
-        if (uvs) {
-          uvs[currentCoordinateUV] = u
-          uvs[currentCoordinateUV + 1] = v
+          if (uvs) {
+            uvs[currentCoordinateUV] = u
+            uvs[currentCoordinateUV + 1] = v
 
-          currentCoordinateUV += 2
+            currentCoordinateUV += 2
+          }
         }
+
+        numVertices += 3
       }
 
-      numVertices += 3
-    }
+      function makeCircularSector(center, p1, p2, u, v) {
+        // param p1, p2: Points in the circle arc.
+        // p1 and p2 are in clockwise direction.
 
-    function makeCircularSector(center, p1, p2, u, v) {
-      // param p1, p2: Points in the circle arc.
-      // p1 and p2 are in clockwise direction.
+        tempV2_1.copy(p1).sub(center).normalize()
+        tempV2_2.copy(p2).sub(center).normalize()
 
-      tempV2_1.copy(p1).sub(center).normalize()
-      tempV2_2.copy(p2).sub(center).normalize()
+        let angle = Math.PI
+        const dot = tempV2_1.dot(tempV2_2)
+        if (Math.abs(dot) < 1) angle = Math.abs(Math.acos(dot))
 
-      let angle = Math.PI
-      const dot = tempV2_1.dot(tempV2_2)
-      if (Math.abs(dot) < 1) angle = Math.abs(Math.acos(dot))
+        angle /= arcDivisions
 
-      angle /= arcDivisions
+        tempV2_3.copy(p1)
 
-      tempV2_3.copy(p1)
+        for (let i = 0, il = arcDivisions - 1; i < il; i++) {
+          tempV2_4.copy(tempV2_3).rotateAround(center, angle)
 
-      for (let i = 0, il = arcDivisions - 1; i < il; i++) {
-        tempV2_4.copy(tempV2_3).rotateAround(center, angle)
+          addVertex(tempV2_3, u, v)
+          addVertex(tempV2_4, u, v)
+          addVertex(center, u, 0.5)
+
+          tempV2_3.copy(tempV2_4)
+        }
 
-        addVertex(tempV2_3, u, v)
         addVertex(tempV2_4, u, v)
+        addVertex(p2, u, v)
         addVertex(center, u, 0.5)
-
-        tempV2_3.copy(tempV2_4)
       }
 
-      addVertex(tempV2_4, u, v)
-      addVertex(p2, u, v)
-      addVertex(center, u, 0.5)
-    }
-
-    function makeSegmentTriangles() {
-      addVertex(lastPointR, u0, 1)
-      addVertex(lastPointL, u0, 0)
-      addVertex(currentPointL, u1, 0)
-
-      addVertex(lastPointR, u0, 1)
-      addVertex(currentPointL, u1, 0)
-      addVertex(currentPointR, u1, 1)
-    }
+      function makeSegmentTriangles() {
+        addVertex(lastPointR, u0, 1)
+        addVertex(lastPointL, u0, 0)
+        addVertex(currentPointL, u1, 0)
 
-    function makeSegmentWithBevelJoin(joinIsOnLeftSide, innerSideModified, u) {
-      if (innerSideModified) {
-        // Optimized segment + bevel triangles
+        addVertex(lastPointR, u0, 1)
+        addVertex(currentPointL, u1, 0)
+        addVertex(currentPointR, u1, 1)
+      }
 
-        if (joinIsOnLeftSide) {
-          // Path segments triangles
+      function makeSegmentWithBevelJoin(joinIsOnLeftSide, innerSideModified, u) {
+        if (innerSideModified) {
+          // Optimized segment + bevel triangles
 
-          addVertex(lastPointR, u0, 1)
-          addVertex(lastPointL, u0, 0)
-          addVertex(currentPointL, u1, 0)
+          if (joinIsOnLeftSide) {
+            // Path segments triangles
 
-          addVertex(lastPointR, u0, 1)
-          addVertex(currentPointL, u1, 0)
-          addVertex(innerPoint, u1, 1)
+            addVertex(lastPointR, u0, 1)
+            addVertex(lastPointL, u0, 0)
+            addVertex(currentPointL, u1, 0)
 
-          // Bevel join triangle
+            addVertex(lastPointR, u0, 1)
+            addVertex(currentPointL, u1, 0)
+            addVertex(innerPoint, u1, 1)
 
-          addVertex(currentPointL, u, 0)
-          addVertex(nextPointL, u, 0)
-          addVertex(innerPoint, u, 0.5)
-        } else {
-          // Path segments triangles
+            // Bevel join triangle
 
-          addVertex(lastPointR, u0, 1)
-          addVertex(lastPointL, u0, 0)
-          addVertex(currentPointR, u1, 1)
+            addVertex(currentPointL, u, 0)
+            addVertex(nextPointL, u, 0)
+            addVertex(innerPoint, u, 0.5)
+          } else {
+            // Path segments triangles
 
-          addVertex(lastPointL, u0, 0)
-          addVertex(innerPoint, u1, 0)
-          addVertex(currentPointR, u1, 1)
+            addVertex(lastPointR, u0, 1)
+            addVertex(lastPointL, u0, 0)
+            addVertex(currentPointR, u1, 1)
 
-          // Bevel join triangle
+            addVertex(lastPointL, u0, 0)
+            addVertex(innerPoint, u1, 0)
+            addVertex(currentPointR, u1, 1)
 
-          addVertex(currentPointR, u, 1)
-          addVertex(innerPoint, u, 0)
-          addVertex(nextPointR, u, 1)
-        }
-      } else {
-        // Bevel join triangle. The segment triangles are done in the main loop
+            // Bevel join triangle
 
-        if (joinIsOnLeftSide) {
-          addVertex(currentPointL, u, 0)
-          addVertex(nextPointL, u, 0)
-          addVertex(currentPoint, u, 0.5)
+            addVertex(currentPointR, u, 1)
+            addVertex(innerPoint, u, 0)
+            addVertex(nextPointR, u, 1)
+          }
         } else {
-          addVertex(currentPointR, u, 1)
-          addVertex(nextPointR, u, 0)
-          addVertex(currentPoint, u, 0.5)
+          // Bevel join triangle. The segment triangles are done in the main loop
+
+          if (joinIsOnLeftSide) {
+            addVertex(currentPointL, u, 0)
+            addVertex(nextPointL, u, 0)
+            addVertex(currentPoint, u, 0.5)
+          } else {
+            addVertex(currentPointR, u, 1)
+            addVertex(nextPointR, u, 0)
+            addVertex(currentPoint, u, 0.5)
+          }
         }
       }
-    }
 
-    function createSegmentTrianglesWithMiddleSection(joinIsOnLeftSide, innerSideModified) {
-      if (innerSideModified) {
-        if (joinIsOnLeftSide) {
-          addVertex(lastPointR, u0, 1)
-          addVertex(lastPointL, u0, 0)
-          addVertex(currentPointL, u1, 0)
+      function createSegmentTrianglesWithMiddleSection(joinIsOnLeftSide, innerSideModified) {
+        if (innerSideModified) {
+          if (joinIsOnLeftSide) {
+            addVertex(lastPointR, u0, 1)
+            addVertex(lastPointL, u0, 0)
+            addVertex(currentPointL, u1, 0)
 
-          addVertex(lastPointR, u0, 1)
-          addVertex(currentPointL, u1, 0)
-          addVertex(innerPoint, u1, 1)
+            addVertex(lastPointR, u0, 1)
+            addVertex(currentPointL, u1, 0)
+            addVertex(innerPoint, u1, 1)
 
-          addVertex(currentPointL, u0, 0)
-          addVertex(currentPoint, u1, 0.5)
-          addVertex(innerPoint, u1, 1)
+            addVertex(currentPointL, u0, 0)
+            addVertex(currentPoint, u1, 0.5)
+            addVertex(innerPoint, u1, 1)
 
-          addVertex(currentPoint, u1, 0.5)
-          addVertex(nextPointL, u0, 0)
-          addVertex(innerPoint, u1, 1)
-        } else {
-          addVertex(lastPointR, u0, 1)
-          addVertex(lastPointL, u0, 0)
-          addVertex(currentPointR, u1, 1)
+            addVertex(currentPoint, u1, 0.5)
+            addVertex(nextPointL, u0, 0)
+            addVertex(innerPoint, u1, 1)
+          } else {
+            addVertex(lastPointR, u0, 1)
+            addVertex(lastPointL, u0, 0)
+            addVertex(currentPointR, u1, 1)
 
-          addVertex(lastPointL, u0, 0)
-          addVertex(innerPoint, u1, 0)
-          addVertex(currentPointR, u1, 1)
+            addVertex(lastPointL, u0, 0)
+            addVertex(innerPoint, u1, 0)
+            addVertex(currentPointR, u1, 1)
 
-          addVertex(currentPointR, u0, 1)
-          addVertex(innerPoint, u1, 0)
-          addVertex(currentPoint, u1, 0.5)
+            addVertex(currentPointR, u0, 1)
+            addVertex(innerPoint, u1, 0)
+            addVertex(currentPoint, u1, 0.5)
 
-          addVertex(currentPoint, u1, 0.5)
-          addVertex(innerPoint, u1, 0)
-          addVertex(nextPointR, u0, 1)
+            addVertex(currentPoint, u1, 0.5)
+            addVertex(innerPoint, u1, 0)
+            addVertex(nextPointR, u0, 1)
+          }
         }
       }
-    }
 
-    function addCapGeometry(center, p1, p2, joinIsOnLeftSide, start, u) {
-      // param center: End point of the path
-      // param p1, p2: Left and right cap points
+      function addCapGeometry(center, p1, p2, joinIsOnLeftSide, start, u) {
+        // param center: End point of the path
+        // param p1, p2: Left and right cap points
 
-      switch (style.strokeLineCap) {
-        case 'round':
-          if (start) {
-            makeCircularSector(center, p2, p1, u, 0.5)
-          } else {
-            makeCircularSector(center, p1, p2, u, 0.5)
-          }
+        switch (style.strokeLineCap) {
+          case 'round':
+            if (start) {
+              makeCircularSector(center, p2, p1, u, 0.5)
+            } else {
+              makeCircularSector(center, p1, p2, u, 0.5)
+            }
 
-          break
+            break
 
-        case 'square':
-          if (start) {
-            tempV2_1.subVectors(p1, center)
-            tempV2_2.set(tempV2_1.y, -tempV2_1.x)
+          case 'square':
+            if (start) {
+              tempV2_1.subVectors(p1, center)
+              tempV2_2.set(tempV2_1.y, -tempV2_1.x)
 
-            tempV2_3.addVectors(tempV2_1, tempV2_2).add(center)
-            tempV2_4.subVectors(tempV2_2, tempV2_1).add(center)
+              tempV2_3.addVectors(tempV2_1, tempV2_2).add(center)
+              tempV2_4.subVectors(tempV2_2, tempV2_1).add(center)
 
-            // Modify already existing vertices
-            if (joinIsOnLeftSide) {
-              tempV2_3.toArray(vertices, 1 * 3)
-              tempV2_4.toArray(vertices, 0 * 3)
-              tempV2_4.toArray(vertices, 3 * 3)
+              // Modify already existing vertices
+              if (joinIsOnLeftSide) {
+                tempV2_3.toArray(vertices, 1 * 3)
+                tempV2_4.toArray(vertices, 0 * 3)
+                tempV2_4.toArray(vertices, 3 * 3)
+              } else {
+                tempV2_3.toArray(vertices, 1 * 3)
+                // using tempV2_4 to update 3rd vertex if the uv.y of 3rd vertex is 1
+                uvs[3 * 2 + 1] === 1 ? tempV2_4.toArray(vertices, 3 * 3) : tempV2_3.toArray(vertices, 3 * 3)
+                tempV2_4.toArray(vertices, 0 * 3)
+              }
             } else {
-              tempV2_3.toArray(vertices, 1 * 3)
-              // using tempV2_4 to update 3rd vertex if the uv.y of 3rd vertex is 1
-              uvs[3 * 2 + 1] === 1 ? tempV2_4.toArray(vertices, 3 * 3) : tempV2_3.toArray(vertices, 3 * 3)
-              tempV2_4.toArray(vertices, 0 * 3)
-            }
-          } else {
-            tempV2_1.subVectors(p2, center)
-            tempV2_2.set(tempV2_1.y, -tempV2_1.x)
+              tempV2_1.subVectors(p2, center)
+              tempV2_2.set(tempV2_1.y, -tempV2_1.x)
 
-            tempV2_3.addVectors(tempV2_1, tempV2_2).add(center)
-            tempV2_4.subVectors(tempV2_2, tempV2_1).add(center)
+              tempV2_3.addVectors(tempV2_1, tempV2_2).add(center)
+              tempV2_4.subVectors(tempV2_2, tempV2_1).add(center)
 
-            const vl = vertices.length
+              const vl = vertices.length
 
-            // Modify already existing vertices
-            if (joinIsOnLeftSide) {
-              tempV2_3.toArray(vertices, vl - 1 * 3)
-              tempV2_4.toArray(vertices, vl - 2 * 3)
-              tempV2_4.toArray(vertices, vl - 4 * 3)
-            } else {
-              tempV2_4.toArray(vertices, vl - 2 * 3)
-              tempV2_3.toArray(vertices, vl - 1 * 3)
-              tempV2_4.toArray(vertices, vl - 4 * 3)
+              // Modify already existing vertices
+              if (joinIsOnLeftSide) {
+                tempV2_3.toArray(vertices, vl - 1 * 3)
+                tempV2_4.toArray(vertices, vl - 2 * 3)
+                tempV2_4.toArray(vertices, vl - 4 * 3)
+              } else {
+                tempV2_4.toArray(vertices, vl - 2 * 3)
+                tempV2_3.toArray(vertices, vl - 1 * 3)
+                tempV2_4.toArray(vertices, vl - 4 * 3)
+              }
             }
-          }
 
-          break
+            break
 
-        case 'butt':
-        default:
-          // Nothing to do here
-          break
+          case 'butt':
+          default:
+            // Nothing to do here
+            break
+        }
       }
-    }
 
-    function removeDuplicatedPoints(points) {
-      // Creates a new array if necessary with duplicated points removed.
-      // This does not remove duplicated initial and ending points of a closed path.
+      function removeDuplicatedPoints(points) {
+        // Creates a new array if necessary with duplicated points removed.
+        // This does not remove duplicated initial and ending points of a closed path.
 
-      let dupPoints = false
-      for (let i = 1, n = points.length - 1; i < n; i++) {
-        if (points[i].distanceTo(points[i + 1]) < minDistance) {
-          dupPoints = true
-          break
+        let dupPoints = false
+        for (let i = 1, n = points.length - 1; i < n; i++) {
+          if (points[i].distanceTo(points[i + 1]) < minDistance) {
+            dupPoints = true
+            break
+          }
         }
-      }
 
-      if (!dupPoints) return points
+        if (!dupPoints) return points
 
-      const newPoints = []
-      newPoints.push(points[0])
+        const newPoints = []
+        newPoints.push(points[0])
 
-      for (let i = 1, n = points.length - 1; i < n; i++) {
-        if (points[i].distanceTo(points[i + 1]) >= minDistance) {
-          newPoints.push(points[i])
+        for (let i = 1, n = points.length - 1; i < n; i++) {
+          if (points[i].distanceTo(points[i + 1]) >= minDistance) {
+            newPoints.push(points[i])
+          }
         }
-      }
 
-      newPoints.push(points[points.length - 1])
+        newPoints.push(points[points.length - 1])
 
-      return newPoints
+        return newPoints
+      }
     }
   }
-}
+
+  return SVGLoader
+})()
 
 export { SVGLoader }
diff --git a/src/loaders/XLoader.js b/src/loaders/XLoader.js
index 60cba98b..073382b5 100644
--- a/src/loaders/XLoader.js
+++ b/src/loaders/XLoader.js
@@ -21,7 +21,7 @@ import {
 } from 'three'
 import { decodeText } from '../_polyfill/LoaderUtils'
 
-var XLoader = (function () {
+var XLoader = /* @__PURE__ */ (function () {
   var classCallCheck = function (instance, Constructor) {
     if (!(instance instanceof Constructor)) {
       throw new TypeError('Cannot call a class as a function')
diff --git a/src/math/Capsule.js b/src/math/Capsule.js
index bf2d12e1..63a0c956 100644
--- a/src/math/Capsule.js
+++ b/src/math/Capsule.js
@@ -1,8 +1,8 @@
 import { Vector3 } from 'three'
 
-const _v1 = new Vector3()
-const _v2 = new Vector3()
-const _v3 = new Vector3()
+const _v1 = /* @__PURE__ */ new Vector3()
+const _v2 = /* @__PURE__ */ new Vector3()
+const _v3 = /* @__PURE__ */ new Vector3()
 
 const EPS = 1e-10
 
diff --git a/src/math/ColorConverter.js b/src/math/ColorConverter.js
index 714a2c98..1fdd400b 100644
--- a/src/math/ColorConverter.js
+++ b/src/math/ColorConverter.js
@@ -2,8 +2,8 @@ import { MathUtils } from 'three'
 
 const _hsl = {}
 
-class ColorConverter {
-  static setHSV(color, h, s, v) {
+const ColorConverter = {
+  setHSV(color, h, s, v) {
     // https://gist.github.com/xpansive/1337890#file-index-js
 
     h = MathUtils.euclideanModulo(h, 1)
@@ -11,9 +11,9 @@ class ColorConverter {
     v = MathUtils.clamp(v, 0, 1)
 
     return color.setHSL(h, (s * v) / ((h = (2 - s) * v) < 1 ? h : 2 - h), h * 0.5)
-  }
+  },
 
-  static getHSV(color, target) {
+  getHSV(color, target) {
     color.getHSL(_hsl)
 
     // based on https://gist.github.com/xpansive/1337890#file-index-js
@@ -24,19 +24,19 @@ class ColorConverter {
     target.v = _hsl.l + _hsl.s
 
     return target
-  }
+  },
 
   // where c, m, y, k is between 0 and 1
 
-  static setCMYK(color, c, m, y, k) {
+  setCMYK(color, c, m, y, k) {
     const r = (1 - c) * (1 - k)
     const g = (1 - m) * (1 - k)
     const b = (1 - y) * (1 - k)
 
     return color.setRGB(r, g, b)
-  }
+  },
 
-  static getCMYK(color, target) {
+  getCMYK(color, target) {
     const r = color.r
     const g = color.g
     const b = color.b
@@ -52,7 +52,7 @@ class ColorConverter {
     target.k = k
 
     return target
-  }
+  },
 }
 
 export { ColorConverter }
diff --git a/src/math/ConvexHull.js b/src/math/ConvexHull.js
index bc345894..55633bc1 100644
--- a/src/math/ConvexHull.js
+++ b/src/math/ConvexHull.js
@@ -7,11 +7,11 @@ import { Line3, Plane, Triangle, Vector3 } from 'three'
 const Visible = 0
 const Deleted = 1
 
-const _v1 = new Vector3()
-const _line3 = new Line3()
-const _plane = new Plane()
-const _closestPoint = new Vector3()
-const _triangle = new Triangle()
+const _v1 = /* @__PURE__ */ new Vector3()
+const _line3 = /* @__PURE__ */ new Line3()
+const _plane = /* @__PURE__ */ new Plane()
+const _closestPoint = /* @__PURE__ */ new Vector3()
+const _triangle = /* @__PURE__ */ new Triangle()
 
 class ConvexHull {
   constructor() {
@@ -703,74 +703,78 @@ class ConvexHull {
 
 //
 
-class Face {
-  constructor() {
-    this.normal = new Vector3()
-    this.midpoint = new Vector3()
-    this.area = 0
+const Face = /* @__PURE__ */ (() => {
+  class Face {
+    constructor() {
+      this.normal = new Vector3()
+      this.midpoint = new Vector3()
+      this.area = 0
 
-    this.constant = 0 // signed distance from face to the origin
-    this.outside = null // reference to a vertex in a vertex list this face can see
-    this.mark = Visible
-    this.edge = null
-  }
+      this.constant = 0 // signed distance from face to the origin
+      this.outside = null // reference to a vertex in a vertex list this face can see
+      this.mark = Visible
+      this.edge = null
+    }
 
-  static create(a, b, c) {
-    const face = new Face()
+    static create(a, b, c) {
+      const face = new Face()
 
-    const e0 = new HalfEdge(a, face)
-    const e1 = new HalfEdge(b, face)
-    const e2 = new HalfEdge(c, face)
+      const e0 = new HalfEdge(a, face)
+      const e1 = new HalfEdge(b, face)
+      const e2 = new HalfEdge(c, face)
 
-    // join edges
+      // join edges
 
-    e0.next = e2.prev = e1
-    e1.next = e0.prev = e2
-    e2.next = e1.prev = e0
+      e0.next = e2.prev = e1
+      e1.next = e0.prev = e2
+      e2.next = e1.prev = e0
 
-    // main half edge reference
+      // main half edge reference
 
-    face.edge = e0
+      face.edge = e0
 
-    return face.compute()
-  }
+      return face.compute()
+    }
 
-  getEdge(i) {
-    let edge = this.edge
+    getEdge(i) {
+      let edge = this.edge
 
-    while (i > 0) {
-      edge = edge.next
-      i--
-    }
+      while (i > 0) {
+        edge = edge.next
+        i--
+      }
 
-    while (i < 0) {
-      edge = edge.prev
-      i++
+      while (i < 0) {
+        edge = edge.prev
+        i++
+      }
+
+      return edge
     }
 
-    return edge
-  }
+    compute() {
+      const a = this.edge.tail()
+      const b = this.edge.head()
+      const c = this.edge.next.head()
 
-  compute() {
-    const a = this.edge.tail()
-    const b = this.edge.head()
-    const c = this.edge.next.head()
+      _triangle.set(a.point, b.point, c.point)
 
-    _triangle.set(a.point, b.point, c.point)
+      _triangle.getNormal(this.normal)
+      _triangle.getMidpoint(this.midpoint)
+      this.area = _triangle.getArea()
 
-    _triangle.getNormal(this.normal)
-    _triangle.getMidpoint(this.midpoint)
-    this.area = _triangle.getArea()
+      this.constant = this.normal.dot(this.midpoint)
 
-    this.constant = this.normal.dot(this.midpoint)
+      return this
+    }
 
-    return this
+    distanceToPoint(point) {
+      return this.normal.dot(point) - this.constant
+    }
   }
 
-  distanceToPoint(point) {
-    return this.normal.dot(point) - this.constant
-  }
-}
+  return Face
+})()
 
 // Entity for a Doubly-Connected Edge List (DCEL).
 
diff --git a/src/math/ImprovedNoise.js b/src/math/ImprovedNoise.js
index d48fa581..f0d6981a 100644
--- a/src/math/ImprovedNoise.js
+++ b/src/math/ImprovedNoise.js
@@ -20,7 +20,7 @@ function init() {
   return _p
 }
 
-const _p = init()
+const _p = /* @__PURE__ */ init()
 
 function fade(t) {
   return t * t * t * (t * (t * 6 - 15) + 10)
diff --git a/src/math/MeshSurfaceSampler.js b/src/math/MeshSurfaceSampler.js
index 274736c4..51778207 100644
--- a/src/math/MeshSurfaceSampler.js
+++ b/src/math/MeshSurfaceSampler.js
@@ -11,8 +11,8 @@ import { Triangle, Vector3 } from 'three'
  * - https://stackoverflow.com/a/4322940/1314762
  */
 
-const _face = new Triangle()
-const _color = new Vector3()
+const _face = /* @__PURE__ */ new Triangle()
+const _color = /* @__PURE__ */ new Vector3()
 
 class MeshSurfaceSampler {
   constructor(mesh) {
diff --git a/src/math/OBB.js b/src/math/OBB.js
index c50b8032..b82b7514 100644
--- a/src/math/OBB.js
+++ b/src/math/OBB.js
@@ -4,13 +4,13 @@ import { Box3, MathUtils, Matrix4, Matrix3, Ray, Vector3 } from 'three'
 
 const a = {
   c: null, // center
-  u: [new Vector3(), new Vector3(), new Vector3()], // basis vectors
+  u: [/* @__PURE__ */ new Vector3(), /* @__PURE__ */ new Vector3(), /* @__PURE__ */ new Vector3()], // basis vectors
   e: [], // half width
 }
 
 const b = {
   c: null, // center
-  u: [new Vector3(), new Vector3(), new Vector3()], // basis vectors
+  u: [/* @__PURE__ */ new Vector3(), /* @__PURE__ */ new Vector3(), /* @__PURE__ */ new Vector3()], // basis vectors
   e: [], // half width
 }
 
@@ -18,17 +18,17 @@ const R = [[], [], []]
 const AbsR = [[], [], []]
 const t = []
 
-const xAxis = new Vector3()
-const yAxis = new Vector3()
-const zAxis = new Vector3()
-const v1 = new Vector3()
-const size = new Vector3()
-const closestPoint = new Vector3()
-const rotationMatrix = new Matrix3()
-const aabb = new Box3()
-const matrix = new Matrix4()
-const inverse = new Matrix4()
-const localRay = new Ray()
+const xAxis = /* @__PURE__ */ new Vector3()
+const yAxis = /* @__PURE__ */ new Vector3()
+const zAxis = /* @__PURE__ */ new Vector3()
+const v1 = /* @__PURE__ */ new Vector3()
+const size = /* @__PURE__ */ new Vector3()
+const closestPoint = /* @__PURE__ */ new Vector3()
+const rotationMatrix = /* @__PURE__ */ new Matrix3()
+const aabb = /* @__PURE__ */ new Box3()
+const matrix = /* @__PURE__ */ new Matrix4()
+const inverse = /* @__PURE__ */ new Matrix4()
+const localRay = /* @__PURE__ */ new Ray()
 
 // OBB
 
@@ -361,6 +361,6 @@ class OBB {
   }
 }
 
-const obb = new OBB()
+const obb = /* @__PURE__ */ new OBB()
 
 export { OBB }
diff --git a/src/math/Octree.js b/src/math/Octree.js
index 1a332e59..9882264b 100644
--- a/src/math/Octree.js
+++ b/src/math/Octree.js
@@ -1,13 +1,13 @@
 import { Box3, Line3, Plane, Sphere, Triangle, Vector3 } from 'three'
 import { Capsule } from '../math/Capsule'
 
-const _v1 = new Vector3()
-const _v2 = new Vector3()
-const _plane = new Plane()
-const _line1 = new Line3()
-const _line2 = new Line3()
-const _sphere = new Sphere()
-const _capsule = new Capsule()
+const _v1 = /* @__PURE__ */ new Vector3()
+const _v2 = /* @__PURE__ */ new Vector3()
+const _plane = /* @__PURE__ */ new Plane()
+const _line1 = /* @__PURE__ */ new Line3()
+const _line2 = /* @__PURE__ */ new Line3()
+const _sphere = /* @__PURE__ */ new Sphere()
+const _capsule = /* @__PURE__ */ new Capsule()
 
 class Octree {
   constructor(box) {
diff --git a/src/misc/ConvexObjectBreaker.js b/src/misc/ConvexObjectBreaker.js
index 76d72c63..891a2e57 100644
--- a/src/misc/ConvexObjectBreaker.js
+++ b/src/misc/ConvexObjectBreaker.js
@@ -30,423 +30,431 @@ import { ConvexGeometry } from '../geometries/ConvexGeometry'
  *
  */
 
-const _v1 = new Vector3()
-
-class ConvexObjectBreaker {
-  constructor(minSizeForBreak = 1.4, smallDelta = 0.0001) {
-    this.minSizeForBreak = minSizeForBreak
-    this.smallDelta = smallDelta
-
-    this.tempLine1 = new Line3()
-    this.tempPlane1 = new Plane()
-    this.tempPlane2 = new Plane()
-    this.tempPlane_Cut = new Plane()
-    this.tempCM1 = new Vector3()
-    this.tempCM2 = new Vector3()
-    this.tempVector3 = new Vector3()
-    this.tempVector3_2 = new Vector3()
-    this.tempVector3_3 = new Vector3()
-    this.tempVector3_P0 = new Vector3()
-    this.tempVector3_P1 = new Vector3()
-    this.tempVector3_P2 = new Vector3()
-    this.tempVector3_N0 = new Vector3()
-    this.tempVector3_N1 = new Vector3()
-    this.tempVector3_AB = new Vector3()
-    this.tempVector3_CB = new Vector3()
-    this.tempResultObjects = { object1: null, object2: null }
-
-    this.segments = []
-    const n = 30 * 30
-    for (let i = 0; i < n; i++) this.segments[i] = false
-  }
-
-  prepareBreakableObject(object, mass, velocity, angularVelocity, breakable) {
-    // object is a Object3d (normally a Mesh), must have a buffer geometry, and it must be convex.
-    // Its material property is propagated to its children (sub-pieces)
-    // mass must be > 0
+const _v1 = /* @__PURE__ */ new Vector3()
+
+const ConvexObjectBreaker = /* @__PURE__ */ (() => {
+  class ConvexObjectBreaker {
+    constructor(minSizeForBreak = 1.4, smallDelta = 0.0001) {
+      this.minSizeForBreak = minSizeForBreak
+      this.smallDelta = smallDelta
+
+      this.tempLine1 = new Line3()
+      this.tempPlane1 = new Plane()
+      this.tempPlane2 = new Plane()
+      this.tempPlane_Cut = new Plane()
+      this.tempCM1 = new Vector3()
+      this.tempCM2 = new Vector3()
+      this.tempVector3 = new Vector3()
+      this.tempVector3_2 = new Vector3()
+      this.tempVector3_3 = new Vector3()
+      this.tempVector3_P0 = new Vector3()
+      this.tempVector3_P1 = new Vector3()
+      this.tempVector3_P2 = new Vector3()
+      this.tempVector3_N0 = new Vector3()
+      this.tempVector3_N1 = new Vector3()
+      this.tempVector3_AB = new Vector3()
+      this.tempVector3_CB = new Vector3()
+      this.tempResultObjects = { object1: null, object2: null }
+
+      this.segments = []
+      const n = 30 * 30
+      for (let i = 0; i < n; i++) this.segments[i] = false
+    }
 
-    const userData = object.userData
-    userData.mass = mass
-    userData.velocity = velocity.clone()
-    userData.angularVelocity = angularVelocity.clone()
-    userData.breakable = breakable
-  }
+    prepareBreakableObject(object, mass, velocity, angularVelocity, breakable) {
+      // object is a Object3d (normally a Mesh), must have a buffer geometry, and it must be convex.
+      // Its material property is propagated to its children (sub-pieces)
+      // mass must be > 0
 
-  /*
-   * @param {int} maxRadialIterations Iterations for radial cuts.
-   * @param {int} maxRandomIterations Max random iterations for not-radial cuts
-   *
-   * Returns the array of pieces
-   */
-  subdivideByImpact(object, pointOfImpact, normal, maxRadialIterations, maxRandomIterations) {
-    const debris = []
+      const userData = object.userData
+      userData.mass = mass
+      userData.velocity = velocity.clone()
+      userData.angularVelocity = angularVelocity.clone()
+      userData.breakable = breakable
+    }
 
-    const tempPlane1 = this.tempPlane1
-    const tempPlane2 = this.tempPlane2
+    /*
+     * @param {int} maxRadialIterations Iterations for radial cuts.
+     * @param {int} maxRandomIterations Max random iterations for not-radial cuts
+     *
+     * Returns the array of pieces
+     */
+    subdivideByImpact(object, pointOfImpact, normal, maxRadialIterations, maxRandomIterations) {
+      const debris = []
 
-    this.tempVector3.addVectors(pointOfImpact, normal)
-    tempPlane1.setFromCoplanarPoints(pointOfImpact, object.position, this.tempVector3)
+      const tempPlane1 = this.tempPlane1
+      const tempPlane2 = this.tempPlane2
 
-    const maxTotalIterations = maxRandomIterations + maxRadialIterations
+      this.tempVector3.addVectors(pointOfImpact, normal)
+      tempPlane1.setFromCoplanarPoints(pointOfImpact, object.position, this.tempVector3)
 
-    const scope = this
+      const maxTotalIterations = maxRandomIterations + maxRadialIterations
 
-    function subdivideRadial(subObject, startAngle, endAngle, numIterations) {
-      if (Math.random() < numIterations * 0.05 || numIterations > maxTotalIterations) {
-        debris.push(subObject)
+      const scope = this
 
-        return
-      }
+      function subdivideRadial(subObject, startAngle, endAngle, numIterations) {
+        if (Math.random() < numIterations * 0.05 || numIterations > maxTotalIterations) {
+          debris.push(subObject)
 
-      let angle = Math.PI
+          return
+        }
 
-      if (numIterations === 0) {
-        tempPlane2.normal.copy(tempPlane1.normal)
-        tempPlane2.constant = tempPlane1.constant
-      } else {
-        if (numIterations <= maxRadialIterations) {
-          angle = (endAngle - startAngle) * (0.2 + 0.6 * Math.random()) + startAngle
+        let angle = Math.PI
 
-          // Rotate tempPlane2 at impact point around normal axis and the angle
-          scope.tempVector3_2.copy(object.position).sub(pointOfImpact).applyAxisAngle(normal, angle).add(pointOfImpact)
-          tempPlane2.setFromCoplanarPoints(pointOfImpact, scope.tempVector3, scope.tempVector3_2)
+        if (numIterations === 0) {
+          tempPlane2.normal.copy(tempPlane1.normal)
+          tempPlane2.constant = tempPlane1.constant
         } else {
-          angle = (0.5 * (numIterations & 1) + 0.2 * (2 - Math.random())) * Math.PI
-
-          // Rotate tempPlane2 at object position around normal axis and the angle
-          scope.tempVector3_2
-            .copy(pointOfImpact)
-            .sub(subObject.position)
-            .applyAxisAngle(normal, angle)
-            .add(subObject.position)
-          scope.tempVector3_3.copy(normal).add(subObject.position)
-          tempPlane2.setFromCoplanarPoints(subObject.position, scope.tempVector3_3, scope.tempVector3_2)
+          if (numIterations <= maxRadialIterations) {
+            angle = (endAngle - startAngle) * (0.2 + 0.6 * Math.random()) + startAngle
+
+            // Rotate tempPlane2 at impact point around normal axis and the angle
+            scope.tempVector3_2
+              .copy(object.position)
+              .sub(pointOfImpact)
+              .applyAxisAngle(normal, angle)
+              .add(pointOfImpact)
+            tempPlane2.setFromCoplanarPoints(pointOfImpact, scope.tempVector3, scope.tempVector3_2)
+          } else {
+            angle = (0.5 * (numIterations & 1) + 0.2 * (2 - Math.random())) * Math.PI
+
+            // Rotate tempPlane2 at object position around normal axis and the angle
+            scope.tempVector3_2
+              .copy(pointOfImpact)
+              .sub(subObject.position)
+              .applyAxisAngle(normal, angle)
+              .add(subObject.position)
+            scope.tempVector3_3.copy(normal).add(subObject.position)
+            tempPlane2.setFromCoplanarPoints(subObject.position, scope.tempVector3_3, scope.tempVector3_2)
+          }
         }
-      }
 
-      // Perform the cut
-      scope.cutByPlane(subObject, tempPlane2, scope.tempResultObjects)
+        // Perform the cut
+        scope.cutByPlane(subObject, tempPlane2, scope.tempResultObjects)
 
-      const obj1 = scope.tempResultObjects.object1
-      const obj2 = scope.tempResultObjects.object2
+        const obj1 = scope.tempResultObjects.object1
+        const obj2 = scope.tempResultObjects.object2
 
-      if (obj1) {
-        subdivideRadial(obj1, startAngle, angle, numIterations + 1)
-      }
+        if (obj1) {
+          subdivideRadial(obj1, startAngle, angle, numIterations + 1)
+        }
 
-      if (obj2) {
-        subdivideRadial(obj2, angle, endAngle, numIterations + 1)
+        if (obj2) {
+          subdivideRadial(obj2, angle, endAngle, numIterations + 1)
+        }
       }
-    }
 
-    subdivideRadial(object, 0, 2 * Math.PI, 0)
+      subdivideRadial(object, 0, 2 * Math.PI, 0)
 
-    return debris
-  }
-
-  cutByPlane(object, plane, output) {
-    // Returns breakable objects in output.object1 and output.object2 members, the resulting 2 pieces of the cut.
-    // object2 can be null if the plane doesn't cut the object.
-    // object1 can be null only in case of internal error
-    // Returned value is number of pieces, 0 for error.
+      return debris
+    }
 
-    const geometry = object.geometry
-    const coords = geometry.attributes.position.array
-    const normals = geometry.attributes.normal.array
+    cutByPlane(object, plane, output) {
+      // Returns breakable objects in output.object1 and output.object2 members, the resulting 2 pieces of the cut.
+      // object2 can be null if the plane doesn't cut the object.
+      // object1 can be null only in case of internal error
+      // Returned value is number of pieces, 0 for error.
 
-    const numPoints = coords.length / 3
-    let numFaces = numPoints / 3
+      const geometry = object.geometry
+      const coords = geometry.attributes.position.array
+      const normals = geometry.attributes.normal.array
 
-    let indices = geometry.getIndex()
+      const numPoints = coords.length / 3
+      let numFaces = numPoints / 3
 
-    if (indices) {
-      indices = indices.array
-      numFaces = indices.length / 3
-    }
+      let indices = geometry.getIndex()
 
-    function getVertexIndex(faceIdx, vert) {
-      // vert = 0, 1 or 2.
-
-      const idx = faceIdx * 3 + vert
+      if (indices) {
+        indices = indices.array
+        numFaces = indices.length / 3
+      }
 
-      return indices ? indices[idx] : idx
-    }
+      function getVertexIndex(faceIdx, vert) {
+        // vert = 0, 1 or 2.
 
-    const points1 = []
-    const points2 = []
+        const idx = faceIdx * 3 + vert
 
-    const delta = this.smallDelta
+        return indices ? indices[idx] : idx
+      }
 
-    // Reset segments mark
-    const numPointPairs = numPoints * numPoints
-    for (let i = 0; i < numPointPairs; i++) this.segments[i] = false
+      const points1 = []
+      const points2 = []
 
-    const p0 = this.tempVector3_P0
-    const p1 = this.tempVector3_P1
-    const n0 = this.tempVector3_N0
-    const n1 = this.tempVector3_N1
+      const delta = this.smallDelta
 
-    // Iterate through the faces to mark edges shared by coplanar faces
-    for (let i = 0; i < numFaces - 1; i++) {
-      const a1 = getVertexIndex(i, 0)
-      const b1 = getVertexIndex(i, 1)
-      const c1 = getVertexIndex(i, 2)
+      // Reset segments mark
+      const numPointPairs = numPoints * numPoints
+      for (let i = 0; i < numPointPairs; i++) this.segments[i] = false
 
-      // Assuming all 3 vertices have the same normal
-      n0.set(normals[a1], normals[a1] + 1, normals[a1] + 2)
+      const p0 = this.tempVector3_P0
+      const p1 = this.tempVector3_P1
+      const n0 = this.tempVector3_N0
+      const n1 = this.tempVector3_N1
 
-      for (let j = i + 1; j < numFaces; j++) {
-        const a2 = getVertexIndex(j, 0)
-        const b2 = getVertexIndex(j, 1)
-        const c2 = getVertexIndex(j, 2)
+      // Iterate through the faces to mark edges shared by coplanar faces
+      for (let i = 0; i < numFaces - 1; i++) {
+        const a1 = getVertexIndex(i, 0)
+        const b1 = getVertexIndex(i, 1)
+        const c1 = getVertexIndex(i, 2)
 
         // Assuming all 3 vertices have the same normal
-        n1.set(normals[a2], normals[a2] + 1, normals[a2] + 2)
-
-        const coplanar = 1 - n0.dot(n1) < delta
-
-        if (coplanar) {
-          if (a1 === a2 || a1 === b2 || a1 === c2) {
-            if (b1 === a2 || b1 === b2 || b1 === c2) {
-              this.segments[a1 * numPoints + b1] = true
-              this.segments[b1 * numPoints + a1] = true
-            } else {
-              this.segments[c1 * numPoints + a1] = true
-              this.segments[a1 * numPoints + c1] = true
+        n0.set(normals[a1], normals[a1] + 1, normals[a1] + 2)
+
+        for (let j = i + 1; j < numFaces; j++) {
+          const a2 = getVertexIndex(j, 0)
+          const b2 = getVertexIndex(j, 1)
+          const c2 = getVertexIndex(j, 2)
+
+          // Assuming all 3 vertices have the same normal
+          n1.set(normals[a2], normals[a2] + 1, normals[a2] + 2)
+
+          const coplanar = 1 - n0.dot(n1) < delta
+
+          if (coplanar) {
+            if (a1 === a2 || a1 === b2 || a1 === c2) {
+              if (b1 === a2 || b1 === b2 || b1 === c2) {
+                this.segments[a1 * numPoints + b1] = true
+                this.segments[b1 * numPoints + a1] = true
+              } else {
+                this.segments[c1 * numPoints + a1] = true
+                this.segments[a1 * numPoints + c1] = true
+              }
+            } else if (b1 === a2 || b1 === b2 || b1 === c2) {
+              this.segments[c1 * numPoints + b1] = true
+              this.segments[b1 * numPoints + c1] = true
             }
-          } else if (b1 === a2 || b1 === b2 || b1 === c2) {
-            this.segments[c1 * numPoints + b1] = true
-            this.segments[b1 * numPoints + c1] = true
           }
         }
       }
-    }
-
-    // Transform the plane to object local space
-    const localPlane = this.tempPlane_Cut
-    object.updateMatrix()
-    ConvexObjectBreaker.transformPlaneToLocalSpace(plane, object.matrix, localPlane)
 
-    // Iterate through the faces adding points to both pieces
-    for (let i = 0; i < numFaces; i++) {
-      const va = getVertexIndex(i, 0)
-      const vb = getVertexIndex(i, 1)
-      const vc = getVertexIndex(i, 2)
+      // Transform the plane to object local space
+      const localPlane = this.tempPlane_Cut
+      object.updateMatrix()
+      ConvexObjectBreaker.transformPlaneToLocalSpace(plane, object.matrix, localPlane)
 
-      for (let segment = 0; segment < 3; segment++) {
-        const i0 = segment === 0 ? va : segment === 1 ? vb : vc
-        const i1 = segment === 0 ? vb : segment === 1 ? vc : va
+      // Iterate through the faces adding points to both pieces
+      for (let i = 0; i < numFaces; i++) {
+        const va = getVertexIndex(i, 0)
+        const vb = getVertexIndex(i, 1)
+        const vc = getVertexIndex(i, 2)
 
-        const segmentState = this.segments[i0 * numPoints + i1]
+        for (let segment = 0; segment < 3; segment++) {
+          const i0 = segment === 0 ? va : segment === 1 ? vb : vc
+          const i1 = segment === 0 ? vb : segment === 1 ? vc : va
 
-        if (segmentState) continue // The segment already has been processed in another face
+          const segmentState = this.segments[i0 * numPoints + i1]
 
-        // Mark segment as processed (also inverted segment)
-        this.segments[i0 * numPoints + i1] = true
-        this.segments[i1 * numPoints + i0] = true
+          if (segmentState) continue // The segment already has been processed in another face
 
-        p0.set(coords[3 * i0], coords[3 * i0 + 1], coords[3 * i0 + 2])
-        p1.set(coords[3 * i1], coords[3 * i1 + 1], coords[3 * i1 + 2])
+          // Mark segment as processed (also inverted segment)
+          this.segments[i0 * numPoints + i1] = true
+          this.segments[i1 * numPoints + i0] = true
 
-        // mark: 1 for negative side, 2 for positive side, 3 for coplanar point
-        let mark0 = 0
+          p0.set(coords[3 * i0], coords[3 * i0 + 1], coords[3 * i0 + 2])
+          p1.set(coords[3 * i1], coords[3 * i1 + 1], coords[3 * i1 + 2])
 
-        let d = localPlane.distanceToPoint(p0)
+          // mark: 1 for negative side, 2 for positive side, 3 for coplanar point
+          let mark0 = 0
 
-        if (d > delta) {
-          mark0 = 2
-          points2.push(p0.clone())
-        } else if (d < -delta) {
-          mark0 = 1
-          points1.push(p0.clone())
-        } else {
-          mark0 = 3
-          points1.push(p0.clone())
-          points2.push(p0.clone())
-        }
+          let d = localPlane.distanceToPoint(p0)
 
-        // mark: 1 for negative side, 2 for positive side, 3 for coplanar point
-        let mark1 = 0
+          if (d > delta) {
+            mark0 = 2
+            points2.push(p0.clone())
+          } else if (d < -delta) {
+            mark0 = 1
+            points1.push(p0.clone())
+          } else {
+            mark0 = 3
+            points1.push(p0.clone())
+            points2.push(p0.clone())
+          }
 
-        d = localPlane.distanceToPoint(p1)
+          // mark: 1 for negative side, 2 for positive side, 3 for coplanar point
+          let mark1 = 0
+
+          d = localPlane.distanceToPoint(p1)
+
+          if (d > delta) {
+            mark1 = 2
+            points2.push(p1.clone())
+          } else if (d < -delta) {
+            mark1 = 1
+            points1.push(p1.clone())
+          } else {
+            mark1 = 3
+            points1.push(p1.clone())
+            points2.push(p1.clone())
+          }
 
-        if (d > delta) {
-          mark1 = 2
-          points2.push(p1.clone())
-        } else if (d < -delta) {
-          mark1 = 1
-          points1.push(p1.clone())
-        } else {
-          mark1 = 3
-          points1.push(p1.clone())
-          points2.push(p1.clone())
-        }
+          if ((mark0 === 1 && mark1 === 2) || (mark0 === 2 && mark1 === 1)) {
+            // Intersection of segment with the plane
 
-        if ((mark0 === 1 && mark1 === 2) || (mark0 === 2 && mark1 === 1)) {
-          // Intersection of segment with the plane
+            this.tempLine1.start.copy(p0)
+            this.tempLine1.end.copy(p1)
 
-          this.tempLine1.start.copy(p0)
-          this.tempLine1.end.copy(p1)
+            let intersection = new Vector3()
+            intersection = localPlane.intersectLine(this.tempLine1, intersection)
 
-          let intersection = new Vector3()
-          intersection = localPlane.intersectLine(this.tempLine1, intersection)
+            if (intersection === null) {
+              // Shouldn't happen
+              console.error('Internal error: segment does not intersect plane.')
+              output.segmentedObject1 = null
+              output.segmentedObject2 = null
+              return 0
+            }
 
-          if (intersection === null) {
-            // Shouldn't happen
-            console.error('Internal error: segment does not intersect plane.')
-            output.segmentedObject1 = null
-            output.segmentedObject2 = null
-            return 0
+            points1.push(intersection)
+            points2.push(intersection.clone())
           }
-
-          points1.push(intersection)
-          points2.push(intersection.clone())
         }
       }
-    }
 
-    // Calculate debris mass (very fast and imprecise):
-    const newMass = object.userData.mass * 0.5
+      // Calculate debris mass (very fast and imprecise):
+      const newMass = object.userData.mass * 0.5
 
-    // Calculate debris Center of Mass (again fast and imprecise)
-    this.tempCM1.set(0, 0, 0)
-    let radius1 = 0
-    const numPoints1 = points1.length
+      // Calculate debris Center of Mass (again fast and imprecise)
+      this.tempCM1.set(0, 0, 0)
+      let radius1 = 0
+      const numPoints1 = points1.length
 
-    if (numPoints1 > 0) {
-      for (let i = 0; i < numPoints1; i++) this.tempCM1.add(points1[i])
+      if (numPoints1 > 0) {
+        for (let i = 0; i < numPoints1; i++) this.tempCM1.add(points1[i])
 
-      this.tempCM1.divideScalar(numPoints1)
-      for (let i = 0; i < numPoints1; i++) {
-        const p = points1[i]
-        p.sub(this.tempCM1)
-        radius1 = Math.max(radius1, p.x, p.y, p.z)
+        this.tempCM1.divideScalar(numPoints1)
+        for (let i = 0; i < numPoints1; i++) {
+          const p = points1[i]
+          p.sub(this.tempCM1)
+          radius1 = Math.max(radius1, p.x, p.y, p.z)
+        }
+
+        this.tempCM1.add(object.position)
       }
 
-      this.tempCM1.add(object.position)
-    }
+      this.tempCM2.set(0, 0, 0)
+      let radius2 = 0
+      const numPoints2 = points2.length
+      if (numPoints2 > 0) {
+        for (let i = 0; i < numPoints2; i++) this.tempCM2.add(points2[i])
+
+        this.tempCM2.divideScalar(numPoints2)
+        for (let i = 0; i < numPoints2; i++) {
+          const p = points2[i]
+          p.sub(this.tempCM2)
+          radius2 = Math.max(radius2, p.x, p.y, p.z)
+        }
 
-    this.tempCM2.set(0, 0, 0)
-    let radius2 = 0
-    const numPoints2 = points2.length
-    if (numPoints2 > 0) {
-      for (let i = 0; i < numPoints2; i++) this.tempCM2.add(points2[i])
-
-      this.tempCM2.divideScalar(numPoints2)
-      for (let i = 0; i < numPoints2; i++) {
-        const p = points2[i]
-        p.sub(this.tempCM2)
-        radius2 = Math.max(radius2, p.x, p.y, p.z)
+        this.tempCM2.add(object.position)
       }
 
-      this.tempCM2.add(object.position)
-    }
-
-    let object1 = null
-    let object2 = null
+      let object1 = null
+      let object2 = null
 
-    let numObjects = 0
+      let numObjects = 0
 
-    if (numPoints1 > 4) {
-      object1 = new Mesh(new ConvexGeometry(points1), object.material)
-      object1.position.copy(this.tempCM1)
-      object1.quaternion.copy(object.quaternion)
+      if (numPoints1 > 4) {
+        object1 = new Mesh(new ConvexGeometry(points1), object.material)
+        object1.position.copy(this.tempCM1)
+        object1.quaternion.copy(object.quaternion)
 
-      this.prepareBreakableObject(
-        object1,
-        newMass,
-        object.userData.velocity,
-        object.userData.angularVelocity,
-        2 * radius1 > this.minSizeForBreak,
-      )
+        this.prepareBreakableObject(
+          object1,
+          newMass,
+          object.userData.velocity,
+          object.userData.angularVelocity,
+          2 * radius1 > this.minSizeForBreak,
+        )
 
-      numObjects++
-    }
+        numObjects++
+      }
 
-    if (numPoints2 > 4) {
-      object2 = new Mesh(new ConvexGeometry(points2), object.material)
-      object2.position.copy(this.tempCM2)
-      object2.quaternion.copy(object.quaternion)
+      if (numPoints2 > 4) {
+        object2 = new Mesh(new ConvexGeometry(points2), object.material)
+        object2.position.copy(this.tempCM2)
+        object2.quaternion.copy(object.quaternion)
 
-      this.prepareBreakableObject(
-        object2,
-        newMass,
-        object.userData.velocity,
-        object.userData.angularVelocity,
-        2 * radius2 > this.minSizeForBreak,
-      )
+        this.prepareBreakableObject(
+          object2,
+          newMass,
+          object.userData.velocity,
+          object.userData.angularVelocity,
+          2 * radius2 > this.minSizeForBreak,
+        )
 
-      numObjects++
-    }
+        numObjects++
+      }
 
-    output.object1 = object1
-    output.object2 = object2
+      output.object1 = object1
+      output.object2 = object2
 
-    return numObjects
-  }
+      return numObjects
+    }
 
-  static transformFreeVector(v, m) {
-    // input:
-    // vector interpreted as a free vector
-    // THREE.Matrix4 orthogonal matrix (matrix without scale)
+    static transformFreeVector(v, m) {
+      // input:
+      // vector interpreted as a free vector
+      // THREE.Matrix4 orthogonal matrix (matrix without scale)
 
-    const x = v.x,
-      y = v.y,
-      z = v.z
-    const e = m.elements
+      const x = v.x,
+        y = v.y,
+        z = v.z
+      const e = m.elements
 
-    v.x = e[0] * x + e[4] * y + e[8] * z
-    v.y = e[1] * x + e[5] * y + e[9] * z
-    v.z = e[2] * x + e[6] * y + e[10] * z
+      v.x = e[0] * x + e[4] * y + e[8] * z
+      v.y = e[1] * x + e[5] * y + e[9] * z
+      v.z = e[2] * x + e[6] * y + e[10] * z
 
-    return v
-  }
+      return v
+    }
 
-  static transformFreeVectorInverse(v, m) {
-    // input:
-    // vector interpreted as a free vector
-    // THREE.Matrix4 orthogonal matrix (matrix without scale)
+    static transformFreeVectorInverse(v, m) {
+      // input:
+      // vector interpreted as a free vector
+      // THREE.Matrix4 orthogonal matrix (matrix without scale)
 
-    const x = v.x,
-      y = v.y,
-      z = v.z
-    const e = m.elements
+      const x = v.x,
+        y = v.y,
+        z = v.z
+      const e = m.elements
 
-    v.x = e[0] * x + e[1] * y + e[2] * z
-    v.y = e[4] * x + e[5] * y + e[6] * z
-    v.z = e[8] * x + e[9] * y + e[10] * z
+      v.x = e[0] * x + e[1] * y + e[2] * z
+      v.y = e[4] * x + e[5] * y + e[6] * z
+      v.z = e[8] * x + e[9] * y + e[10] * z
 
-    return v
-  }
+      return v
+    }
 
-  static transformTiedVectorInverse(v, m) {
-    // input:
-    // vector interpreted as a tied (ordinary) vector
-    // THREE.Matrix4 orthogonal matrix (matrix without scale)
+    static transformTiedVectorInverse(v, m) {
+      // input:
+      // vector interpreted as a tied (ordinary) vector
+      // THREE.Matrix4 orthogonal matrix (matrix without scale)
 
-    const x = v.x,
-      y = v.y,
-      z = v.z
-    const e = m.elements
+      const x = v.x,
+        y = v.y,
+        z = v.z
+      const e = m.elements
 
-    v.x = e[0] * x + e[1] * y + e[2] * z - e[12]
-    v.y = e[4] * x + e[5] * y + e[6] * z - e[13]
-    v.z = e[8] * x + e[9] * y + e[10] * z - e[14]
+      v.x = e[0] * x + e[1] * y + e[2] * z - e[12]
+      v.y = e[4] * x + e[5] * y + e[6] * z - e[13]
+      v.z = e[8] * x + e[9] * y + e[10] * z - e[14]
 
-    return v
-  }
+      return v
+    }
 
-  static transformPlaneToLocalSpace(plane, m, resultPlane) {
-    resultPlane.normal.copy(plane.normal)
-    resultPlane.constant = plane.constant
+    static transformPlaneToLocalSpace(plane, m, resultPlane) {
+      resultPlane.normal.copy(plane.normal)
+      resultPlane.constant = plane.constant
 
-    const referencePoint = ConvexObjectBreaker.transformTiedVectorInverse(plane.coplanarPoint(_v1), m)
+      const referencePoint = ConvexObjectBreaker.transformTiedVectorInverse(plane.coplanarPoint(_v1), m)
 
-    ConvexObjectBreaker.transformFreeVectorInverse(resultPlane.normal, m)
+      ConvexObjectBreaker.transformFreeVectorInverse(resultPlane.normal, m)
 
-    // recalculate constant (like in setFromNormalAndCoplanarPoint)
-    resultPlane.constant = -referencePoint.dot(resultPlane.normal)
+      // recalculate constant (like in setFromNormalAndCoplanarPoint)
+      resultPlane.constant = -referencePoint.dot(resultPlane.normal)
+    }
   }
-}
+
+  return ConvexObjectBreaker
+})()
 
 export { ConvexObjectBreaker }
diff --git a/src/misc/Gyroscope.js b/src/misc/Gyroscope.js
index 0ab3fb72..570f40d3 100644
--- a/src/misc/Gyroscope.js
+++ b/src/misc/Gyroscope.js
@@ -1,12 +1,12 @@
 import { Object3D, Quaternion, Vector3 } from 'three'
 
-const _translationObject = new Vector3()
-const _quaternionObject = new Quaternion()
-const _scaleObject = new Vector3()
+const _translationObject = /* @__PURE__ */ new Vector3()
+const _quaternionObject = /* @__PURE__ */ new Quaternion()
+const _scaleObject = /* @__PURE__ */ new Vector3()
 
-const _translationWorld = new Vector3()
-const _quaternionWorld = new Quaternion()
-const _scaleWorld = new Vector3()
+const _translationWorld = /* @__PURE__ */ new Vector3()
+const _quaternionWorld = /* @__PURE__ */ new Quaternion()
+const _scaleWorld = /* @__PURE__ */ new Vector3()
 
 class Gyroscope extends Object3D {
   constructor() {
diff --git a/src/modifiers/CurveModifier.ts b/src/modifiers/CurveModifier.ts
index 2097a471..588a5865 100644
--- a/src/modifiers/CurveModifier.ts
+++ b/src/modifiers/CurveModifier.ts
@@ -250,7 +250,7 @@ export class Flow<TMesh extends Mesh = Mesh> {
     this.uniforms.pathOffset.value += amount
   }
 }
-const matrix = new Matrix4()
+const matrix = /* @__PURE__ */ new Matrix4()
 
 /**
  * A helper class for creating instanced versions of flow, where the instances are placed on the curve.
diff --git a/src/modifiers/SimplifyModifier.ts b/src/modifiers/SimplifyModifier.ts
index f5ae4779..d9d0348d 100644
--- a/src/modifiers/SimplifyModifier.ts
+++ b/src/modifiers/SimplifyModifier.ts
@@ -1,8 +1,8 @@
 import { BufferGeometry, Float32BufferAttribute, Vector3 } from 'three'
 import * as BufferGeometryUtils from '../utils/BufferGeometryUtils'
 
-const cb = new Vector3()
-const ab = new Vector3()
+const cb = /* @__PURE__ */ new Vector3()
+const ab = /* @__PURE__ */ new Vector3()
 
 function pushIfUnique<TItem>(array: TItem[], object: TItem): void {
   if (array.indexOf(object) === -1) array.push(object)
diff --git a/src/objects/BatchedMesh.ts b/src/objects/BatchedMesh.ts
index 8c2f7635..5c95ccb4 100644
--- a/src/objects/BatchedMesh.ts
+++ b/src/objects/BatchedMesh.ts
@@ -13,8 +13,8 @@ import {
 } from 'three'
 
 const ID_ATTR_NAME = '_batch_id_'
-const _identityMatrix = new Matrix4()
-const _zeroScaleMatrix = new Matrix4().set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1)
+const _identityMatrix = /* @__PURE__ */ new Matrix4()
+const _zeroScaleMatrix = /* @__PURE__ */ (() => new Matrix4().set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1))()
 
 // Custom shaders
 const batchingParsVertex = /* glsl */ `
diff --git a/src/objects/GroundProjectedEnv.ts b/src/objects/GroundProjectedEnv.ts
index 9012ec79..8787ae95 100644
--- a/src/objects/GroundProjectedEnv.ts
+++ b/src/objects/GroundProjectedEnv.ts
@@ -1,13 +1,5 @@
-import {
-  Mesh,
-  IcosahedronGeometry,
-  ShaderMaterial,
-  DoubleSide,
-  Texture,
-  CubeTexture,
-  BufferGeometry,
-  REVISION,
-} from 'three'
+import { Mesh, IcosahedronGeometry, ShaderMaterial, DoubleSide, Texture, CubeTexture, BufferGeometry } from 'three'
+import { version } from '../_polyfill/constants'
 
 export interface GroundProjectedEnvParameters {
   height?: number
@@ -114,7 +106,7 @@ export class GroundProjectedEnv extends Mesh<BufferGeometry, ShaderMaterial> {
             #endif
             gl_FragColor = vec4( outcolor, 1.0 );
             #include <tonemapping_fragment>
-            #include <${parseInt(REVISION.replace(/\D+/g, '')) >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>
+            #include <${version >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>
         }
         `
 
diff --git a/src/objects/Lensflare.js b/src/objects/Lensflare.js
index 70a698b1..736287ee 100644
--- a/src/objects/Lensflare.js
+++ b/src/objects/Lensflare.js
@@ -17,56 +17,45 @@ import {
   Vector4,
 } from 'three'
 
-const geometry = new BufferGeometry()
+const Lensflare = /* @__PURE__ */ (() => {
+  class Lensflare extends Mesh {
+    constructor() {
+      super(Lensflare.Geometry, new MeshBasicMaterial({ opacity: 0, transparent: true }))
 
-const float32Array = new Float32Array([-1, -1, 0, 0, 0, 1, -1, 0, 1, 0, 1, 1, 0, 1, 1, -1, 1, 0, 0, 1])
+      this.isLensflare = true
 
-const interleavedBuffer = new InterleavedBuffer(float32Array, 5)
+      this.type = 'Lensflare'
+      this.frustumCulled = false
+      this.renderOrder = Infinity
 
-geometry.setIndex([0, 1, 2, 0, 2, 3])
-geometry.setAttribute('position', new InterleavedBufferAttribute(interleavedBuffer, 3, 0, false))
-geometry.setAttribute('uv', new InterleavedBufferAttribute(interleavedBuffer, 2, 3, false))
+      //
 
-class Lensflare extends Mesh {
-  static Geometry = geometry
+      const positionScreen = new Vector3()
+      const positionView = new Vector3()
 
-  constructor() {
-    super(Lensflare.Geometry, new MeshBasicMaterial({ opacity: 0, transparent: true }))
+      // textures
+      const tempMap = new DataTexture(new Uint8Array(16 * 16 * 3), 16, 16, RGBAFormat)
+      tempMap.minFilter = NearestFilter
+      tempMap.magFilter = NearestFilter
+      tempMap.wrapS = ClampToEdgeWrapping
+      tempMap.wrapT = ClampToEdgeWrapping
 
-    this.isLensflare = true
+      const occlusionMap = new DataTexture(new Uint8Array(16 * 16 * 3), 16, 16, RGBAFormat)
+      occlusionMap.minFilter = NearestFilter
+      occlusionMap.magFilter = NearestFilter
+      occlusionMap.wrapS = ClampToEdgeWrapping
+      occlusionMap.wrapT = ClampToEdgeWrapping
 
-    this.type = 'Lensflare'
-    this.frustumCulled = false
-    this.renderOrder = Infinity
+      // material
 
-    //
+      const geometry = Lensflare.Geometry
 
-    const positionScreen = new Vector3()
-    const positionView = new Vector3()
-
-    // textures
-    const tempMap = new DataTexture(new Uint8Array(16 * 16 * 3), 16, 16, RGBAFormat)
-    tempMap.minFilter = NearestFilter
-    tempMap.magFilter = NearestFilter
-    tempMap.wrapS = ClampToEdgeWrapping
-    tempMap.wrapT = ClampToEdgeWrapping
-
-    const occlusionMap = new DataTexture(new Uint8Array(16 * 16 * 3), 16, 16, RGBAFormat)
-    occlusionMap.minFilter = NearestFilter
-    occlusionMap.magFilter = NearestFilter
-    occlusionMap.wrapS = ClampToEdgeWrapping
-    occlusionMap.wrapT = ClampToEdgeWrapping
-
-    // material
-
-    const geometry = Lensflare.Geometry
-
-    const material1a = new RawShaderMaterial({
-      uniforms: {
-        scale: { value: null },
-        screenPosition: { value: null },
-      },
-      vertexShader: /* glsl */ `
+      const material1a = new RawShaderMaterial({
+        uniforms: {
+          scale: { value: null },
+          screenPosition: { value: null },
+        },
+        vertexShader: /* glsl */ `
 
 				precision highp float;
 
@@ -81,7 +70,7 @@ class Lensflare extends Mesh {
 
 				}`,
 
-      fragmentShader: /* glsl */ `
+        fragmentShader: /* glsl */ `
 
 				precision highp float;
 
@@ -90,18 +79,18 @@ class Lensflare extends Mesh {
 					gl_FragColor = vec4( 1.0, 0.0, 1.0, 1.0 );
 
 				}`,
-      depthTest: true,
-      depthWrite: false,
-      transparent: false,
-    })
-
-    const material1b = new RawShaderMaterial({
-      uniforms: {
-        map: { value: tempMap },
-        scale: { value: null },
-        screenPosition: { value: null },
-      },
-      vertexShader: /* glsl */ `
+        depthTest: true,
+        depthWrite: false,
+        transparent: false,
+      })
+
+      const material1b = new RawShaderMaterial({
+        uniforms: {
+          map: { value: tempMap },
+          scale: { value: null },
+          screenPosition: { value: null },
+        },
+        vertexShader: /* glsl */ `
 
 				precision highp float;
 
@@ -121,7 +110,7 @@ class Lensflare extends Mesh {
 
 				}`,
 
-      fragmentShader: /* glsl */ `
+        fragmentShader: /* glsl */ `
 
 				precision highp float;
 
@@ -134,149 +123,173 @@ class Lensflare extends Mesh {
 					gl_FragColor = texture2D( map, vUV );
 
 				}`,
-      depthTest: false,
-      depthWrite: false,
-      transparent: false,
-    })
+        depthTest: false,
+        depthWrite: false,
+        transparent: false,
+      })
 
-    // the following object is used for occlusionMap generation
+      // the following object is used for occlusionMap generation
 
-    const mesh1 = new Mesh(geometry, material1a)
+      const mesh1 = new Mesh(geometry, material1a)
 
-    //
+      //
 
-    const elements = []
+      const elements = []
 
-    const shader = LensflareElement.Shader
+      const shader = LensflareElement.Shader
 
-    const material2 = new RawShaderMaterial({
-      uniforms: {
-        map: { value: null },
-        occlusionMap: { value: occlusionMap },
-        color: { value: new Color(0xffffff) },
-        scale: { value: new Vector2() },
-        screenPosition: { value: new Vector3() },
-      },
-      vertexShader: shader.vertexShader,
-      fragmentShader: shader.fragmentShader,
-      blending: AdditiveBlending,
-      transparent: true,
-      depthWrite: false,
-    })
+      const material2 = new RawShaderMaterial({
+        uniforms: {
+          map: { value: null },
+          occlusionMap: { value: occlusionMap },
+          color: { value: new Color(0xffffff) },
+          scale: { value: new Vector2() },
+          screenPosition: { value: new Vector3() },
+        },
+        vertexShader: shader.vertexShader,
+        fragmentShader: shader.fragmentShader,
+        blending: AdditiveBlending,
+        transparent: true,
+        depthWrite: false,
+      })
 
-    const mesh2 = new Mesh(geometry, material2)
+      const mesh2 = new Mesh(geometry, material2)
 
-    this.addElement = function (element) {
-      elements.push(element)
-    }
+      this.addElement = function (element) {
+        elements.push(element)
+      }
 
-    //
+      //
 
-    const scale = new Vector2()
-    const screenPositionPixels = new Vector2()
-    const validArea = new Box2()
-    const viewport = new Vector4()
+      const scale = new Vector2()
+      const screenPositionPixels = new Vector2()
+      const validArea = new Box2()
+      const viewport = new Vector4()
 
-    this.onBeforeRender = function (renderer, scene, camera) {
-      renderer.getCurrentViewport(viewport)
+      this.onBeforeRender = function (renderer, scene, camera) {
+        renderer.getCurrentViewport(viewport)
 
-      const invAspect = viewport.w / viewport.z
-      const halfViewportWidth = viewport.z / 2.0
-      const halfViewportHeight = viewport.w / 2.0
+        const invAspect = viewport.w / viewport.z
+        const halfViewportWidth = viewport.z / 2.0
+        const halfViewportHeight = viewport.w / 2.0
 
-      let size = 16 / viewport.w
-      scale.set(size * invAspect, size)
+        let size = 16 / viewport.w
+        scale.set(size * invAspect, size)
 
-      validArea.min.set(viewport.x, viewport.y)
-      validArea.max.set(viewport.x + (viewport.z - 16), viewport.y + (viewport.w - 16))
+        validArea.min.set(viewport.x, viewport.y)
+        validArea.max.set(viewport.x + (viewport.z - 16), viewport.y + (viewport.w - 16))
 
-      // calculate position in screen space
+        // calculate position in screen space
 
-      positionView.setFromMatrixPosition(this.matrixWorld)
-      positionView.applyMatrix4(camera.matrixWorldInverse)
+        positionView.setFromMatrixPosition(this.matrixWorld)
+        positionView.applyMatrix4(camera.matrixWorldInverse)
 
-      if (positionView.z > 0) return // lensflare is behind the camera
+        if (positionView.z > 0) return // lensflare is behind the camera
 
-      positionScreen.copy(positionView).applyMatrix4(camera.projectionMatrix)
+        positionScreen.copy(positionView).applyMatrix4(camera.projectionMatrix)
 
-      // horizontal and vertical coordinate of the lower left corner of the pixels to copy
+        // horizontal and vertical coordinate of the lower left corner of the pixels to copy
 
-      screenPositionPixels.x = viewport.x + positionScreen.x * halfViewportWidth + halfViewportWidth - 8
-      screenPositionPixels.y = viewport.y + positionScreen.y * halfViewportHeight + halfViewportHeight - 8
+        screenPositionPixels.x = viewport.x + positionScreen.x * halfViewportWidth + halfViewportWidth - 8
+        screenPositionPixels.y = viewport.y + positionScreen.y * halfViewportHeight + halfViewportHeight - 8
 
-      // screen cull
+        // screen cull
 
-      if (validArea.containsPoint(screenPositionPixels)) {
-        // save current RGB to temp texture
+        if (validArea.containsPoint(screenPositionPixels)) {
+          // save current RGB to temp texture
 
-        renderer.copyFramebufferToTexture(screenPositionPixels, tempMap)
+          renderer.copyFramebufferToTexture(screenPositionPixels, tempMap)
 
-        // render pink quad
+          // render pink quad
 
-        let uniforms = material1a.uniforms
-        uniforms['scale'].value = scale
-        uniforms['screenPosition'].value = positionScreen
+          let uniforms = material1a.uniforms
+          uniforms['scale'].value = scale
+          uniforms['screenPosition'].value = positionScreen
 
-        renderer.renderBufferDirect(camera, null, geometry, material1a, mesh1, null)
+          renderer.renderBufferDirect(camera, null, geometry, material1a, mesh1, null)
 
-        // copy result to occlusionMap
+          // copy result to occlusionMap
 
-        renderer.copyFramebufferToTexture(screenPositionPixels, occlusionMap)
+          renderer.copyFramebufferToTexture(screenPositionPixels, occlusionMap)
 
-        // restore graphics
+          // restore graphics
 
-        uniforms = material1b.uniforms
-        uniforms['scale'].value = scale
-        uniforms['screenPosition'].value = positionScreen
+          uniforms = material1b.uniforms
+          uniforms['scale'].value = scale
+          uniforms['screenPosition'].value = positionScreen
 
-        renderer.renderBufferDirect(camera, null, geometry, material1b, mesh1, null)
+          renderer.renderBufferDirect(camera, null, geometry, material1b, mesh1, null)
 
-        // render elements
+          // render elements
 
-        const vecX = -positionScreen.x * 2
-        const vecY = -positionScreen.y * 2
+          const vecX = -positionScreen.x * 2
+          const vecY = -positionScreen.y * 2
 
-        for (let i = 0, l = elements.length; i < l; i++) {
-          const element = elements[i]
+          for (let i = 0, l = elements.length; i < l; i++) {
+            const element = elements[i]
 
-          const uniforms = material2.uniforms
+            const uniforms = material2.uniforms
 
-          uniforms['color'].value.copy(element.color)
-          uniforms['map'].value = element.texture
-          uniforms['screenPosition'].value.x = positionScreen.x + vecX * element.distance
-          uniforms['screenPosition'].value.y = positionScreen.y + vecY * element.distance
+            uniforms['color'].value.copy(element.color)
+            uniforms['map'].value = element.texture
+            uniforms['screenPosition'].value.x = positionScreen.x + vecX * element.distance
+            uniforms['screenPosition'].value.y = positionScreen.y + vecY * element.distance
 
-          size = element.size / viewport.w
-          const invAspect = viewport.w / viewport.z
+            size = element.size / viewport.w
+            const invAspect = viewport.w / viewport.z
 
-          uniforms['scale'].value.set(size * invAspect, size)
+            uniforms['scale'].value.set(size * invAspect, size)
 
-          material2.uniformsNeedUpdate = true
+            material2.uniformsNeedUpdate = true
 
-          renderer.renderBufferDirect(camera, null, geometry, material2, mesh2, null)
+            renderer.renderBufferDirect(camera, null, geometry, material2, mesh2, null)
+          }
         }
       }
-    }
 
-    this.dispose = function () {
-      material1a.dispose()
-      material1b.dispose()
-      material2.dispose()
+      this.dispose = function () {
+        material1a.dispose()
+        material1b.dispose()
+        material2.dispose()
 
-      tempMap.dispose()
-      occlusionMap.dispose()
+        tempMap.dispose()
+        occlusionMap.dispose()
 
-      for (let i = 0, l = elements.length; i < l; i++) {
-        elements[i].texture.dispose()
+        for (let i = 0, l = elements.length; i < l; i++) {
+          elements[i].texture.dispose()
+        }
       }
     }
   }
-}
+
+  const _geometry = new BufferGeometry()
+  const interleavedBuffer = new InterleavedBuffer(
+    new Float32Array([-1, -1, 0, 0, 0, 1, -1, 0, 1, 0, 1, 1, 0, 1, 1, -1, 1, 0, 0, 1]),
+    5,
+  )
+
+  _geometry.setIndex([0, 1, 2, 0, 2, 3])
+  _geometry.setAttribute('position', new InterleavedBufferAttribute(interleavedBuffer, 3, 0, false))
+  _geometry.setAttribute('uv', new InterleavedBufferAttribute(interleavedBuffer, 2, 3, false))
+
+  Lensflare.Geometry = _geometry
+
+  return Lensflare
+})()
 
 //
 
-class LensflareElement {
-  static Shader = {
+const LensflareElement = /* @__PURE__ */ (() => {
+  class LensflareElement {
+    constructor(texture, size = 1, distance = 0, color = new Color(0xffffff)) {
+      this.texture = texture
+      this.size = size
+      this.distance = distance
+      this.color = color
+    }
+  }
+
+  LensflareElement.Shader = {
     uniforms: {
       map: { value: null },
       occlusionMap: { value: null },
@@ -287,69 +300,66 @@ class LensflareElement {
 
     vertexShader: /* glsl */ `
 
-		precision highp float;
+      precision highp float;
 
-		uniform vec3 screenPosition;
-		uniform vec2 scale;
+      uniform vec3 screenPosition;
+      uniform vec2 scale;
 
-		uniform sampler2D occlusionMap;
+      uniform sampler2D occlusionMap;
 
-		attribute vec3 position;
-		attribute vec2 uv;
+      attribute vec3 position;
+      attribute vec2 uv;
 
-		varying vec2 vUV;
-		varying float vVisibility;
+      varying vec2 vUV;
+      varying float vVisibility;
 
-		void main() {
+      void main() {
 
-			vUV = uv;
+        vUV = uv;
 
-			vec2 pos = position.xy;
+        vec2 pos = position.xy;
 
-			vec4 visibility = texture2D( occlusionMap, vec2( 0.1, 0.1 ) );
-			visibility += texture2D( occlusionMap, vec2( 0.5, 0.1 ) );
-			visibility += texture2D( occlusionMap, vec2( 0.9, 0.1 ) );
-			visibility += texture2D( occlusionMap, vec2( 0.9, 0.5 ) );
-			visibility += texture2D( occlusionMap, vec2( 0.9, 0.9 ) );
-			visibility += texture2D( occlusionMap, vec2( 0.5, 0.9 ) );
-			visibility += texture2D( occlusionMap, vec2( 0.1, 0.9 ) );
-			visibility += texture2D( occlusionMap, vec2( 0.1, 0.5 ) );
-			visibility += texture2D( occlusionMap, vec2( 0.5, 0.5 ) );
+        vec4 visibility = texture2D( occlusionMap, vec2( 0.1, 0.1 ) );
+        visibility += texture2D( occlusionMap, vec2( 0.5, 0.1 ) );
+        visibility += texture2D( occlusionMap, vec2( 0.9, 0.1 ) );
+        visibility += texture2D( occlusionMap, vec2( 0.9, 0.5 ) );
+        visibility += texture2D( occlusionMap, vec2( 0.9, 0.9 ) );
+        visibility += texture2D( occlusionMap, vec2( 0.5, 0.9 ) );
+        visibility += texture2D( occlusionMap, vec2( 0.1, 0.9 ) );
+        visibility += texture2D( occlusionMap, vec2( 0.1, 0.5 ) );
+        visibility += texture2D( occlusionMap, vec2( 0.5, 0.5 ) );
 
-			vVisibility =        visibility.r / 9.0;
-			vVisibility *= 1.0 - visibility.g / 9.0;
-			vVisibility *=       visibility.b / 9.0;
+        vVisibility =        visibility.r / 9.0;
+        vVisibility *= 1.0 - visibility.g / 9.0;
+        vVisibility *=       visibility.b / 9.0;
 
-			gl_Position = vec4( ( pos * scale + screenPosition.xy ).xy, screenPosition.z, 1.0 );
+        gl_Position = vec4( ( pos * scale + screenPosition.xy ).xy, screenPosition.z, 1.0 );
 
-		}`,
+      }
+    `,
 
     fragmentShader: /* glsl */ `
 
-		precision highp float;
+      precision highp float;
 
-		uniform sampler2D map;
-		uniform vec3 color;
+      uniform sampler2D map;
+      uniform vec3 color;
 
-		varying vec2 vUV;
-		varying float vVisibility;
+      varying vec2 vUV;
+      varying float vVisibility;
 
-		void main() {
+      void main() {
 
-			vec4 texture = texture2D( map, vUV );
-			texture.a *= vVisibility;
-			gl_FragColor = texture;
-			gl_FragColor.rgb *= color;
+        vec4 texture = texture2D( map, vUV );
+        texture.a *= vVisibility;
+        gl_FragColor = texture;
+        gl_FragColor.rgb *= color;
 
-		}`,
+      }
+    `,
   }
 
-  constructor(texture, size = 1, distance = 0, color = new Color(0xffffff)) {
-    this.texture = texture
-    this.size = size
-    this.distance = distance
-    this.color = color
-  }
-}
+  return LensflareElement
+})()
 
 export { Lensflare, LensflareElement }
diff --git a/src/objects/Reflector.js b/src/objects/Reflector.js
index 5d326eb6..d1fdd776 100644
--- a/src/objects/Reflector.js
+++ b/src/objects/Reflector.js
@@ -14,23 +14,24 @@ import {
 } from 'three'
 import { version } from '../_polyfill/constants'
 
-class Reflector extends Mesh {
-  static ReflectorShader = {
-    uniforms: {
-      color: {
-        value: null,
+const Reflector = /* @__PURE__ */ (() => {
+  class Reflector extends Mesh {
+    static ReflectorShader = {
+      uniforms: {
+        color: {
+          value: null,
+        },
+
+        tDiffuse: {
+          value: null,
+        },
+
+        textureMatrix: {
+          value: null,
+        },
       },
 
-      tDiffuse: {
-        value: null,
-      },
-
-      textureMatrix: {
-        value: null,
-      },
-    },
-
-    vertexShader: /* glsl */ `
+      vertexShader: /* glsl */ `
 		uniform mat4 textureMatrix;
 		varying vec4 vUv;
 
@@ -47,7 +48,7 @@ class Reflector extends Mesh {
 
 		}`,
 
-    fragmentShader: /* glsl */ `
+      fragmentShader: /* glsl */ `
 		uniform vec3 color;
 		uniform sampler2D tDiffuse;
 		varying vec4 vUv;
@@ -77,182 +78,190 @@ class Reflector extends Mesh {
 			#include <${version >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>
 
 		}`,
-  }
+    }
 
-  constructor(geometry, options = {}) {
-    super(geometry)
+    constructor(geometry, options = {}) {
+      super(geometry)
 
-    this.isReflector = true
+      this.isReflector = true
 
-    this.type = 'Reflector'
-    this.camera = new PerspectiveCamera()
+      this.type = 'Reflector'
+      this.camera = new PerspectiveCamera()
 
-    const scope = this
+      const scope = this
 
-    const color = options.color !== undefined ? new Color(options.color) : new Color(0x7f7f7f)
-    const textureWidth = options.textureWidth || 512
-    const textureHeight = options.textureHeight || 512
-    const clipBias = options.clipBias || 0
-    const shader = options.shader || Reflector.ReflectorShader
-    const multisample = options.multisample !== undefined ? options.multisample : 4
+      const color = options.color !== undefined ? new Color(options.color) : new Color(0x7f7f7f)
+      const textureWidth = options.textureWidth || 512
+      const textureHeight = options.textureHeight || 512
+      const clipBias = options.clipBias || 0
+      const shader = options.shader || Reflector.ReflectorShader
+      const multisample = options.multisample !== undefined ? options.multisample : 4
 
-    //
+      //
 
-    const reflectorPlane = new Plane()
-    const normal = new Vector3()
-    const reflectorWorldPosition = new Vector3()
-    const cameraWorldPosition = new Vector3()
-    const rotationMatrix = new Matrix4()
-    const lookAtPosition = new Vector3(0, 0, -1)
-    const clipPlane = new Vector4()
+      const reflectorPlane = new Plane()
+      const normal = new Vector3()
+      const reflectorWorldPosition = new Vector3()
+      const cameraWorldPosition = new Vector3()
+      const rotationMatrix = new Matrix4()
+      const lookAtPosition = new Vector3(0, 0, -1)
+      const clipPlane = new Vector4()
 
-    const view = new Vector3()
-    const target = new Vector3()
-    const q = new Vector4()
+      const view = new Vector3()
+      const target = new Vector3()
+      const q = new Vector4()
 
-    const textureMatrix = new Matrix4()
-    const virtualCamera = this.camera
+      const textureMatrix = new Matrix4()
+      const virtualCamera = this.camera
 
-    const renderTarget = new WebGLRenderTarget(textureWidth, textureHeight, {
-      samples: multisample,
-      type: HalfFloatType,
-    })
+      const renderTarget = new WebGLRenderTarget(textureWidth, textureHeight, {
+        samples: multisample,
+        type: HalfFloatType,
+      })
 
-    const material = new ShaderMaterial({
-      uniforms: UniformsUtils.clone(shader.uniforms),
-      fragmentShader: shader.fragmentShader,
-      vertexShader: shader.vertexShader,
-    })
+      const material = new ShaderMaterial({
+        uniforms: UniformsUtils.clone(shader.uniforms),
+        fragmentShader: shader.fragmentShader,
+        vertexShader: shader.vertexShader,
+      })
 
-    material.uniforms['tDiffuse'].value = renderTarget.texture
-    material.uniforms['color'].value = color
-    material.uniforms['textureMatrix'].value = textureMatrix
+      material.uniforms['tDiffuse'].value = renderTarget.texture
+      material.uniforms['color'].value = color
+      material.uniforms['textureMatrix'].value = textureMatrix
 
-    this.material = material
+      this.material = material
 
-    this.onBeforeRender = function (renderer, scene, camera) {
-      reflectorWorldPosition.setFromMatrixPosition(scope.matrixWorld)
-      cameraWorldPosition.setFromMatrixPosition(camera.matrixWorld)
+      this.onBeforeRender = function (renderer, scene, camera) {
+        reflectorWorldPosition.setFromMatrixPosition(scope.matrixWorld)
+        cameraWorldPosition.setFromMatrixPosition(camera.matrixWorld)
 
-      rotationMatrix.extractRotation(scope.matrixWorld)
+        rotationMatrix.extractRotation(scope.matrixWorld)
 
-      normal.set(0, 0, 1)
-      normal.applyMatrix4(rotationMatrix)
+        normal.set(0, 0, 1)
+        normal.applyMatrix4(rotationMatrix)
 
-      view.subVectors(reflectorWorldPosition, cameraWorldPosition)
+        view.subVectors(reflectorWorldPosition, cameraWorldPosition)
 
-      // Avoid rendering when reflector is facing away
+        // Avoid rendering when reflector is facing away
 
-      if (view.dot(normal) > 0) return
+        if (view.dot(normal) > 0) return
 
-      view.reflect(normal).negate()
-      view.add(reflectorWorldPosition)
+        view.reflect(normal).negate()
+        view.add(reflectorWorldPosition)
 
-      rotationMatrix.extractRotation(camera.matrixWorld)
+        rotationMatrix.extractRotation(camera.matrixWorld)
 
-      lookAtPosition.set(0, 0, -1)
-      lookAtPosition.applyMatrix4(rotationMatrix)
-      lookAtPosition.add(cameraWorldPosition)
+        lookAtPosition.set(0, 0, -1)
+        lookAtPosition.applyMatrix4(rotationMatrix)
+        lookAtPosition.add(cameraWorldPosition)
 
-      target.subVectors(reflectorWorldPosition, lookAtPosition)
-      target.reflect(normal).negate()
-      target.add(reflectorWorldPosition)
+        target.subVectors(reflectorWorldPosition, lookAtPosition)
+        target.reflect(normal).negate()
+        target.add(reflectorWorldPosition)
 
-      virtualCamera.position.copy(view)
-      virtualCamera.up.set(0, 1, 0)
-      virtualCamera.up.applyMatrix4(rotationMatrix)
-      virtualCamera.up.reflect(normal)
-      virtualCamera.lookAt(target)
+        virtualCamera.position.copy(view)
+        virtualCamera.up.set(0, 1, 0)
+        virtualCamera.up.applyMatrix4(rotationMatrix)
+        virtualCamera.up.reflect(normal)
+        virtualCamera.lookAt(target)
 
-      virtualCamera.far = camera.far // Used in WebGLBackground
+        virtualCamera.far = camera.far // Used in WebGLBackground
 
-      virtualCamera.updateMatrixWorld()
-      virtualCamera.projectionMatrix.copy(camera.projectionMatrix)
+        virtualCamera.updateMatrixWorld()
+        virtualCamera.projectionMatrix.copy(camera.projectionMatrix)
 
-      // Update the texture matrix
-      textureMatrix.set(0.5, 0.0, 0.0, 0.5, 0.0, 0.5, 0.0, 0.5, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.0, 1.0)
-      textureMatrix.multiply(virtualCamera.projectionMatrix)
-      textureMatrix.multiply(virtualCamera.matrixWorldInverse)
-      textureMatrix.multiply(scope.matrixWorld)
+        // Update the texture matrix
+        textureMatrix.set(0.5, 0.0, 0.0, 0.5, 0.0, 0.5, 0.0, 0.5, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.0, 1.0)
+        textureMatrix.multiply(virtualCamera.projectionMatrix)
+        textureMatrix.multiply(virtualCamera.matrixWorldInverse)
+        textureMatrix.multiply(scope.matrixWorld)
 
-      // Now update projection matrix with new clip plane, implementing code from: http://www.terathon.com/code/oblique.html
-      // Paper explaining this technique: http://www.terathon.com/lengyel/Lengyel-Oblique.pdf
-      reflectorPlane.setFromNormalAndCoplanarPoint(normal, reflectorWorldPosition)
-      reflectorPlane.applyMatrix4(virtualCamera.matrixWorldInverse)
+        // Now update projection matrix with new clip plane, implementing code from: http://www.terathon.com/code/oblique.html
+        // Paper explaining this technique: http://www.terathon.com/lengyel/Lengyel-Oblique.pdf
+        reflectorPlane.setFromNormalAndCoplanarPoint(normal, reflectorWorldPosition)
+        reflectorPlane.applyMatrix4(virtualCamera.matrixWorldInverse)
 
-      clipPlane.set(reflectorPlane.normal.x, reflectorPlane.normal.y, reflectorPlane.normal.z, reflectorPlane.constant)
+        clipPlane.set(
+          reflectorPlane.normal.x,
+          reflectorPlane.normal.y,
+          reflectorPlane.normal.z,
+          reflectorPlane.constant,
+        )
 
-      const projectionMatrix = virtualCamera.projectionMatrix
+        const projectionMatrix = virtualCamera.projectionMatrix
 
-      q.x = (Math.sign(clipPlane.x) + projectionMatrix.elements[8]) / projectionMatrix.elements[0]
-      q.y = (Math.sign(clipPlane.y) + projectionMatrix.elements[9]) / projectionMatrix.elements[5]
-      q.z = -1.0
-      q.w = (1.0 + projectionMatrix.elements[10]) / projectionMatrix.elements[14]
+        q.x = (Math.sign(clipPlane.x) + projectionMatrix.elements[8]) / projectionMatrix.elements[0]
+        q.y = (Math.sign(clipPlane.y) + projectionMatrix.elements[9]) / projectionMatrix.elements[5]
+        q.z = -1.0
+        q.w = (1.0 + projectionMatrix.elements[10]) / projectionMatrix.elements[14]
 
-      // Calculate the scaled plane vector
-      clipPlane.multiplyScalar(2.0 / clipPlane.dot(q))
+        // Calculate the scaled plane vector
+        clipPlane.multiplyScalar(2.0 / clipPlane.dot(q))
 
-      // Replacing the third row of the projection matrix
-      projectionMatrix.elements[2] = clipPlane.x
-      projectionMatrix.elements[6] = clipPlane.y
-      projectionMatrix.elements[10] = clipPlane.z + 1.0 - clipBias
-      projectionMatrix.elements[14] = clipPlane.w
+        // Replacing the third row of the projection matrix
+        projectionMatrix.elements[2] = clipPlane.x
+        projectionMatrix.elements[6] = clipPlane.y
+        projectionMatrix.elements[10] = clipPlane.z + 1.0 - clipBias
+        projectionMatrix.elements[14] = clipPlane.w
 
-      // Render
-      scope.visible = false
+        // Render
+        scope.visible = false
 
-      const currentRenderTarget = renderer.getRenderTarget()
+        const currentRenderTarget = renderer.getRenderTarget()
 
-      const currentXrEnabled = renderer.xr.enabled
-      const currentShadowAutoUpdate = renderer.shadowMap.autoUpdate
-      const currentToneMapping = renderer.toneMapping
+        const currentXrEnabled = renderer.xr.enabled
+        const currentShadowAutoUpdate = renderer.shadowMap.autoUpdate
+        const currentToneMapping = renderer.toneMapping
 
-      let isSRGB = false
-      if ('outputColorSpace' in renderer) isSRGB = renderer.outputColorSpace === 'srgb'
-      else isSRGB = renderer.outputEncoding === 3001 // sRGBEncoding
+        let isSRGB = false
+        if ('outputColorSpace' in renderer) isSRGB = renderer.outputColorSpace === 'srgb'
+        else isSRGB = renderer.outputEncoding === 3001 // sRGBEncoding
 
-      renderer.xr.enabled = false // Avoid camera modification
-      renderer.shadowMap.autoUpdate = false // Avoid re-computing shadows
-      if ('outputColorSpace' in renderer) renderer.outputColorSpace = 'srgb-linear'
-      else renderer.outputEncoding = 3000 // LinearEncoding
-      renderer.toneMapping = NoToneMapping
+        renderer.xr.enabled = false // Avoid camera modification
+        renderer.shadowMap.autoUpdate = false // Avoid re-computing shadows
+        if ('outputColorSpace' in renderer) renderer.outputColorSpace = 'srgb-linear'
+        else renderer.outputEncoding = 3000 // LinearEncoding
+        renderer.toneMapping = NoToneMapping
 
-      renderer.setRenderTarget(renderTarget)
+        renderer.setRenderTarget(renderTarget)
 
-      renderer.state.buffers.depth.setMask(true) // make sure the depth buffer is writable so it can be properly cleared, see #18897
+        renderer.state.buffers.depth.setMask(true) // make sure the depth buffer is writable so it can be properly cleared, see #18897
 
-      if (renderer.autoClear === false) renderer.clear()
-      renderer.render(scene, virtualCamera)
+        if (renderer.autoClear === false) renderer.clear()
+        renderer.render(scene, virtualCamera)
 
-      renderer.xr.enabled = currentXrEnabled
-      renderer.shadowMap.autoUpdate = currentShadowAutoUpdate
-      renderer.toneMapping = currentToneMapping
+        renderer.xr.enabled = currentXrEnabled
+        renderer.shadowMap.autoUpdate = currentShadowAutoUpdate
+        renderer.toneMapping = currentToneMapping
 
-      if ('outputColorSpace' in renderer) renderer.outputColorSpace = isSRGB ? 'srgb' : 'srgb-linear'
-      else renderer.outputEncoding = isSRGB ? 3001 : 3000
+        if ('outputColorSpace' in renderer) renderer.outputColorSpace = isSRGB ? 'srgb' : 'srgb-linear'
+        else renderer.outputEncoding = isSRGB ? 3001 : 3000
 
-      renderer.setRenderTarget(currentRenderTarget)
+        renderer.setRenderTarget(currentRenderTarget)
 
-      // Restore viewport
+        // Restore viewport
 
-      const viewport = camera.viewport
+        const viewport = camera.viewport
 
-      if (viewport !== undefined) {
-        renderer.state.viewport(viewport)
-      }
+        if (viewport !== undefined) {
+          renderer.state.viewport(viewport)
+        }
 
-      scope.visible = true
-    }
+        scope.visible = true
+      }
 
-    this.getRenderTarget = function () {
-      return renderTarget
-    }
+      this.getRenderTarget = function () {
+        return renderTarget
+      }
 
-    this.dispose = function () {
-      renderTarget.dispose()
-      scope.material.dispose()
+      this.dispose = function () {
+        renderTarget.dispose()
+        scope.material.dispose()
+      }
     }
   }
-}
+
+  return Reflector
+})()
 
 export { Reflector }
diff --git a/src/objects/ReflectorForSSRPass.js b/src/objects/ReflectorForSSRPass.js
index a03e7a82..4b8cde38 100644
--- a/src/objects/ReflectorForSSRPass.js
+++ b/src/objects/ReflectorForSSRPass.js
@@ -15,30 +15,31 @@ import {
   HalfFloatType,
 } from 'three'
 
-class ReflectorForSSRPass extends Mesh {
-  static ReflectorShader = {
-    defines: {
-      DISTANCE_ATTENUATION: true,
-      FRESNEL: true,
-    },
-
-    uniforms: {
-      color: { value: null },
-      tDiffuse: { value: null },
-      tDepth: { value: null },
-      textureMatrix: { value: new Matrix4() },
-      maxDistance: { value: 180 },
-      opacity: { value: 0.5 },
-      fresnelCoe: { value: null },
-      virtualCameraNear: { value: null },
-      virtualCameraFar: { value: null },
-      virtualCameraProjectionMatrix: { value: new Matrix4() },
-      virtualCameraMatrixWorld: { value: new Matrix4() },
-      virtualCameraProjectionMatrixInverse: { value: new Matrix4() },
-      resolution: { value: new Vector2() },
-    },
-
-    vertexShader: /* glsl */ `
+const ReflectorForSSRPass = /* @__PURE__ */ (() => {
+  class ReflectorForSSRPass extends Mesh {
+    static ReflectorShader = {
+      defines: {
+        DISTANCE_ATTENUATION: true,
+        FRESNEL: true,
+      },
+
+      uniforms: {
+        color: { value: null },
+        tDiffuse: { value: null },
+        tDepth: { value: null },
+        textureMatrix: { value: new Matrix4() },
+        maxDistance: { value: 180 },
+        opacity: { value: 0.5 },
+        fresnelCoe: { value: null },
+        virtualCameraNear: { value: null },
+        virtualCameraFar: { value: null },
+        virtualCameraProjectionMatrix: { value: new Matrix4() },
+        virtualCameraMatrixWorld: { value: new Matrix4() },
+        virtualCameraProjectionMatrixInverse: { value: new Matrix4() },
+        resolution: { value: new Vector2() },
+      },
+
+      vertexShader: /* glsl */ `
 		uniform mat4 textureMatrix;
 		varying vec4 vUv;
 
@@ -50,7 +51,7 @@ class ReflectorForSSRPass extends Mesh {
 
 		}`,
 
-    fragmentShader: /* glsl */ `
+      fragmentShader: /* glsl */ `
 		uniform vec3 color;
 		uniform sampler2D tDiffuse;
 		uniform sampler2D tDepth;
@@ -108,211 +109,214 @@ class ReflectorForSSRPass extends Mesh {
 			#endif
 		}
 	`,
-  }
-
-  constructor(geometry, options = {}) {
-    super(geometry)
-
-    this.isReflectorForSSRPass = true
-
-    this.type = 'ReflectorForSSRPass'
-
-    const scope = this
-
-    const color = options.color !== undefined ? new Color(options.color) : new Color(0x7f7f7f)
-    const textureWidth = options.textureWidth || 512
-    const textureHeight = options.textureHeight || 512
-    const clipBias = options.clipBias || 0
-    const shader = options.shader || ReflectorForSSRPass.ReflectorShader
-    const useDepthTexture = options.useDepthTexture === true
-    const yAxis = new Vector3(0, 1, 0)
-    const vecTemp0 = new Vector3()
-    const vecTemp1 = new Vector3()
-
-    //
-
-    scope.needsUpdate = false
-    scope.maxDistance = ReflectorForSSRPass.ReflectorShader.uniforms.maxDistance.value
-    scope.opacity = ReflectorForSSRPass.ReflectorShader.uniforms.opacity.value
-    scope.color = color
-    scope.resolution = options.resolution || new Vector2(window.innerWidth, window.innerHeight)
-
-    scope._distanceAttenuation = ReflectorForSSRPass.ReflectorShader.defines.DISTANCE_ATTENUATION
-    Object.defineProperty(scope, 'distanceAttenuation', {
-      get() {
-        return scope._distanceAttenuation
-      },
-      set(val) {
-        if (scope._distanceAttenuation === val) return
-        scope._distanceAttenuation = val
-        scope.material.defines.DISTANCE_ATTENUATION = val
-        scope.material.needsUpdate = true
-      },
-    })
-
-    scope._fresnel = ReflectorForSSRPass.ReflectorShader.defines.FRESNEL
-    Object.defineProperty(scope, 'fresnel', {
-      get() {
-        return scope._fresnel
-      },
-      set(val) {
-        if (scope._fresnel === val) return
-        scope._fresnel = val
-        scope.material.defines.FRESNEL = val
-        scope.material.needsUpdate = true
-      },
-    })
-
-    const normal = new Vector3()
-    const reflectorWorldPosition = new Vector3()
-    const cameraWorldPosition = new Vector3()
-    const rotationMatrix = new Matrix4()
-    const lookAtPosition = new Vector3(0, 0, -1)
+    }
 
-    const view = new Vector3()
-    const target = new Vector3()
+    constructor(geometry, options = {}) {
+      super(geometry)
+
+      this.isReflectorForSSRPass = true
+
+      this.type = 'ReflectorForSSRPass'
+
+      const scope = this
+
+      const color = options.color !== undefined ? new Color(options.color) : new Color(0x7f7f7f)
+      const textureWidth = options.textureWidth || 512
+      const textureHeight = options.textureHeight || 512
+      const clipBias = options.clipBias || 0
+      const shader = options.shader || ReflectorForSSRPass.ReflectorShader
+      const useDepthTexture = options.useDepthTexture === true
+      const yAxis = new Vector3(0, 1, 0)
+      const vecTemp0 = new Vector3()
+      const vecTemp1 = new Vector3()
+
+      //
+
+      scope.needsUpdate = false
+      scope.maxDistance = ReflectorForSSRPass.ReflectorShader.uniforms.maxDistance.value
+      scope.opacity = ReflectorForSSRPass.ReflectorShader.uniforms.opacity.value
+      scope.color = color
+      scope.resolution = options.resolution || new Vector2(window.innerWidth, window.innerHeight)
+
+      scope._distanceAttenuation = ReflectorForSSRPass.ReflectorShader.defines.DISTANCE_ATTENUATION
+      Object.defineProperty(scope, 'distanceAttenuation', {
+        get() {
+          return scope._distanceAttenuation
+        },
+        set(val) {
+          if (scope._distanceAttenuation === val) return
+          scope._distanceAttenuation = val
+          scope.material.defines.DISTANCE_ATTENUATION = val
+          scope.material.needsUpdate = true
+        },
+      })
+
+      scope._fresnel = ReflectorForSSRPass.ReflectorShader.defines.FRESNEL
+      Object.defineProperty(scope, 'fresnel', {
+        get() {
+          return scope._fresnel
+        },
+        set(val) {
+          if (scope._fresnel === val) return
+          scope._fresnel = val
+          scope.material.defines.FRESNEL = val
+          scope.material.needsUpdate = true
+        },
+      })
+
+      const normal = new Vector3()
+      const reflectorWorldPosition = new Vector3()
+      const cameraWorldPosition = new Vector3()
+      const rotationMatrix = new Matrix4()
+      const lookAtPosition = new Vector3(0, 0, -1)
+
+      const view = new Vector3()
+      const target = new Vector3()
+
+      const textureMatrix = new Matrix4()
+      const virtualCamera = new PerspectiveCamera()
+
+      let depthTexture
+
+      if (useDepthTexture) {
+        depthTexture = new DepthTexture()
+        depthTexture.type = UnsignedShortType
+        depthTexture.minFilter = NearestFilter
+        depthTexture.magFilter = NearestFilter
+      }
 
-    const textureMatrix = new Matrix4()
-    const virtualCamera = new PerspectiveCamera()
+      const parameters = {
+        depthTexture: useDepthTexture ? depthTexture : null,
+        type: HalfFloatType,
+      }
 
-    let depthTexture
+      const renderTarget = new WebGLRenderTarget(textureWidth, textureHeight, parameters)
 
-    if (useDepthTexture) {
-      depthTexture = new DepthTexture()
-      depthTexture.type = UnsignedShortType
-      depthTexture.minFilter = NearestFilter
-      depthTexture.magFilter = NearestFilter
-    }
+      const material = new ShaderMaterial({
+        transparent: useDepthTexture,
+        defines: Object.assign({}, ReflectorForSSRPass.ReflectorShader.defines, {
+          useDepthTexture,
+        }),
+        uniforms: UniformsUtils.clone(shader.uniforms),
+        fragmentShader: shader.fragmentShader,
+        vertexShader: shader.vertexShader,
+      })
 
-    const parameters = {
-      depthTexture: useDepthTexture ? depthTexture : null,
-      type: HalfFloatType,
-    }
+      material.uniforms['tDiffuse'].value = renderTarget.texture
+      material.uniforms['color'].value = scope.color
+      material.uniforms['textureMatrix'].value = textureMatrix
+      if (useDepthTexture) {
+        material.uniforms['tDepth'].value = renderTarget.depthTexture
+      }
 
-    const renderTarget = new WebGLRenderTarget(textureWidth, textureHeight, parameters)
-
-    const material = new ShaderMaterial({
-      transparent: useDepthTexture,
-      defines: Object.assign({}, ReflectorForSSRPass.ReflectorShader.defines, {
-        useDepthTexture,
-      }),
-      uniforms: UniformsUtils.clone(shader.uniforms),
-      fragmentShader: shader.fragmentShader,
-      vertexShader: shader.vertexShader,
-    })
-
-    material.uniforms['tDiffuse'].value = renderTarget.texture
-    material.uniforms['color'].value = scope.color
-    material.uniforms['textureMatrix'].value = textureMatrix
-    if (useDepthTexture) {
-      material.uniforms['tDepth'].value = renderTarget.depthTexture
-    }
+      this.material = material
 
-    this.material = material
+      const globalPlane = new Plane(new Vector3(0, 1, 0), clipBias)
+      const globalPlanes = [globalPlane]
 
-    const globalPlane = new Plane(new Vector3(0, 1, 0), clipBias)
-    const globalPlanes = [globalPlane]
+      this.doRender = function (renderer, scene, camera) {
+        material.uniforms['maxDistance'].value = scope.maxDistance
+        material.uniforms['color'].value = scope.color
+        material.uniforms['opacity'].value = scope.opacity
 
-    this.doRender = function (renderer, scene, camera) {
-      material.uniforms['maxDistance'].value = scope.maxDistance
-      material.uniforms['color'].value = scope.color
-      material.uniforms['opacity'].value = scope.opacity
+        vecTemp0.copy(camera.position).normalize()
+        vecTemp1.copy(vecTemp0).reflect(yAxis)
+        material.uniforms['fresnelCoe'].value = (vecTemp0.dot(vecTemp1) + 1) / 2 // TODO: Also need to use glsl viewPosition and viewNormal per pixel.
 
-      vecTemp0.copy(camera.position).normalize()
-      vecTemp1.copy(vecTemp0).reflect(yAxis)
-      material.uniforms['fresnelCoe'].value = (vecTemp0.dot(vecTemp1) + 1) / 2 // TODO: Also need to use glsl viewPosition and viewNormal per pixel.
+        reflectorWorldPosition.setFromMatrixPosition(scope.matrixWorld)
+        cameraWorldPosition.setFromMatrixPosition(camera.matrixWorld)
 
-      reflectorWorldPosition.setFromMatrixPosition(scope.matrixWorld)
-      cameraWorldPosition.setFromMatrixPosition(camera.matrixWorld)
+        rotationMatrix.extractRotation(scope.matrixWorld)
 
-      rotationMatrix.extractRotation(scope.matrixWorld)
+        normal.set(0, 0, 1)
+        normal.applyMatrix4(rotationMatrix)
 
-      normal.set(0, 0, 1)
-      normal.applyMatrix4(rotationMatrix)
+        view.subVectors(reflectorWorldPosition, cameraWorldPosition)
 
-      view.subVectors(reflectorWorldPosition, cameraWorldPosition)
+        // Avoid rendering when reflector is facing away
 
-      // Avoid rendering when reflector is facing away
+        if (view.dot(normal) > 0) return
 
-      if (view.dot(normal) > 0) return
+        view.reflect(normal).negate()
+        view.add(reflectorWorldPosition)
 
-      view.reflect(normal).negate()
-      view.add(reflectorWorldPosition)
+        rotationMatrix.extractRotation(camera.matrixWorld)
 
-      rotationMatrix.extractRotation(camera.matrixWorld)
+        lookAtPosition.set(0, 0, -1)
+        lookAtPosition.applyMatrix4(rotationMatrix)
+        lookAtPosition.add(cameraWorldPosition)
 
-      lookAtPosition.set(0, 0, -1)
-      lookAtPosition.applyMatrix4(rotationMatrix)
-      lookAtPosition.add(cameraWorldPosition)
+        target.subVectors(reflectorWorldPosition, lookAtPosition)
+        target.reflect(normal).negate()
+        target.add(reflectorWorldPosition)
 
-      target.subVectors(reflectorWorldPosition, lookAtPosition)
-      target.reflect(normal).negate()
-      target.add(reflectorWorldPosition)
+        virtualCamera.position.copy(view)
+        virtualCamera.up.set(0, 1, 0)
+        virtualCamera.up.applyMatrix4(rotationMatrix)
+        virtualCamera.up.reflect(normal)
+        virtualCamera.lookAt(target)
 
-      virtualCamera.position.copy(view)
-      virtualCamera.up.set(0, 1, 0)
-      virtualCamera.up.applyMatrix4(rotationMatrix)
-      virtualCamera.up.reflect(normal)
-      virtualCamera.lookAt(target)
+        virtualCamera.far = camera.far // Used in WebGLBackground
 
-      virtualCamera.far = camera.far // Used in WebGLBackground
+        virtualCamera.updateMatrixWorld()
+        virtualCamera.projectionMatrix.copy(camera.projectionMatrix)
 
-      virtualCamera.updateMatrixWorld()
-      virtualCamera.projectionMatrix.copy(camera.projectionMatrix)
+        material.uniforms['virtualCameraNear'].value = camera.near
+        material.uniforms['virtualCameraFar'].value = camera.far
+        material.uniforms['virtualCameraMatrixWorld'].value = virtualCamera.matrixWorld
+        material.uniforms['virtualCameraProjectionMatrix'].value = camera.projectionMatrix
+        material.uniforms['virtualCameraProjectionMatrixInverse'].value = camera.projectionMatrixInverse
+        material.uniforms['resolution'].value = scope.resolution
 
-      material.uniforms['virtualCameraNear'].value = camera.near
-      material.uniforms['virtualCameraFar'].value = camera.far
-      material.uniforms['virtualCameraMatrixWorld'].value = virtualCamera.matrixWorld
-      material.uniforms['virtualCameraProjectionMatrix'].value = camera.projectionMatrix
-      material.uniforms['virtualCameraProjectionMatrixInverse'].value = camera.projectionMatrixInverse
-      material.uniforms['resolution'].value = scope.resolution
+        // Update the texture matrix
+        textureMatrix.set(0.5, 0.0, 0.0, 0.5, 0.0, 0.5, 0.0, 0.5, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.0, 1.0)
+        textureMatrix.multiply(virtualCamera.projectionMatrix)
+        textureMatrix.multiply(virtualCamera.matrixWorldInverse)
+        textureMatrix.multiply(scope.matrixWorld)
 
-      // Update the texture matrix
-      textureMatrix.set(0.5, 0.0, 0.0, 0.5, 0.0, 0.5, 0.0, 0.5, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.0, 1.0)
-      textureMatrix.multiply(virtualCamera.projectionMatrix)
-      textureMatrix.multiply(virtualCamera.matrixWorldInverse)
-      textureMatrix.multiply(scope.matrixWorld)
+        // scope.visible = false;
 
-      // scope.visible = false;
+        const currentRenderTarget = renderer.getRenderTarget()
 
-      const currentRenderTarget = renderer.getRenderTarget()
+        const currentXrEnabled = renderer.xr.enabled
+        const currentShadowAutoUpdate = renderer.shadowMap.autoUpdate
+        const currentClippingPlanes = renderer.clippingPlanes
 
-      const currentXrEnabled = renderer.xr.enabled
-      const currentShadowAutoUpdate = renderer.shadowMap.autoUpdate
-      const currentClippingPlanes = renderer.clippingPlanes
+        renderer.xr.enabled = false // Avoid camera modification
+        renderer.shadowMap.autoUpdate = false // Avoid re-computing shadows
+        renderer.clippingPlanes = globalPlanes
 
-      renderer.xr.enabled = false // Avoid camera modification
-      renderer.shadowMap.autoUpdate = false // Avoid re-computing shadows
-      renderer.clippingPlanes = globalPlanes
+        renderer.setRenderTarget(renderTarget)
 
-      renderer.setRenderTarget(renderTarget)
+        renderer.state.buffers.depth.setMask(true) // make sure the depth buffer is writable so it can be properly cleared, see #18897
 
-      renderer.state.buffers.depth.setMask(true) // make sure the depth buffer is writable so it can be properly cleared, see #18897
+        if (renderer.autoClear === false) renderer.clear()
+        renderer.render(scene, virtualCamera)
 
-      if (renderer.autoClear === false) renderer.clear()
-      renderer.render(scene, virtualCamera)
+        renderer.xr.enabled = currentXrEnabled
+        renderer.shadowMap.autoUpdate = currentShadowAutoUpdate
+        renderer.clippingPlanes = currentClippingPlanes
 
-      renderer.xr.enabled = currentXrEnabled
-      renderer.shadowMap.autoUpdate = currentShadowAutoUpdate
-      renderer.clippingPlanes = currentClippingPlanes
+        renderer.setRenderTarget(currentRenderTarget)
 
-      renderer.setRenderTarget(currentRenderTarget)
+        // Restore viewport
 
-      // Restore viewport
+        const viewport = camera.viewport
 
-      const viewport = camera.viewport
+        if (viewport !== undefined) {
+          renderer.state.viewport(viewport)
+        }
 
-      if (viewport !== undefined) {
-        renderer.state.viewport(viewport)
+        // scope.visible = true;
       }
 
-      // scope.visible = true;
-    }
-
-    this.getRenderTarget = function () {
-      return renderTarget
+      this.getRenderTarget = function () {
+        return renderTarget
+      }
     }
   }
-}
+
+  return ReflectorForSSRPass
+})()
 
 export { ReflectorForSSRPass }
diff --git a/src/objects/Refractor.js b/src/objects/Refractor.js
index 09dda320..e5978f65 100644
--- a/src/objects/Refractor.js
+++ b/src/objects/Refractor.js
@@ -15,23 +15,24 @@ import {
 } from 'three'
 import { version } from '../_polyfill/constants'
 
-class Refractor extends Mesh {
-  static RefractorShader = {
-    uniforms: {
-      color: {
-        value: null,
+const Refractor = /* @__PURE__ */ (() => {
+  class Refractor extends Mesh {
+    static RefractorShader = {
+      uniforms: {
+        color: {
+          value: null,
+        },
+
+        tDiffuse: {
+          value: null,
+        },
+
+        textureMatrix: {
+          value: null,
+        },
       },
 
-      tDiffuse: {
-        value: null,
-      },
-
-      textureMatrix: {
-        value: null,
-      },
-    },
-
-    vertexShader: /* glsl */ `
+      vertexShader: /* glsl */ `
 
 		uniform mat4 textureMatrix;
 
@@ -44,7 +45,7 @@ class Refractor extends Mesh {
 
 		}`,
 
-    fragmentShader: /* glsl */ `
+      fragmentShader: /* glsl */ `
 
 		uniform vec3 color;
 		uniform sampler2D tDiffuse;
@@ -72,233 +73,236 @@ class Refractor extends Mesh {
 			#include <${version >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>
 
 		}`,
-  }
+    }
 
-  constructor(geometry, options = {}) {
-    super(geometry)
+    constructor(geometry, options = {}) {
+      super(geometry)
 
-    this.isRefractor = true
+      this.isRefractor = true
 
-    this.type = 'Refractor'
-    this.camera = new PerspectiveCamera()
+      this.type = 'Refractor'
+      this.camera = new PerspectiveCamera()
 
-    const scope = this
+      const scope = this
 
-    const color = options.color !== undefined ? new Color(options.color) : new Color(0x7f7f7f)
-    const textureWidth = options.textureWidth || 512
-    const textureHeight = options.textureHeight || 512
-    const clipBias = options.clipBias || 0
-    const shader = options.shader || Refractor.RefractorShader
-    const multisample = options.multisample !== undefined ? options.multisample : 4
+      const color = options.color !== undefined ? new Color(options.color) : new Color(0x7f7f7f)
+      const textureWidth = options.textureWidth || 512
+      const textureHeight = options.textureHeight || 512
+      const clipBias = options.clipBias || 0
+      const shader = options.shader || Refractor.RefractorShader
+      const multisample = options.multisample !== undefined ? options.multisample : 4
 
-    //
+      //
 
-    const virtualCamera = this.camera
-    virtualCamera.matrixAutoUpdate = false
-    virtualCamera.userData.refractor = true
+      const virtualCamera = this.camera
+      virtualCamera.matrixAutoUpdate = false
+      virtualCamera.userData.refractor = true
 
-    //
+      //
 
-    const refractorPlane = new Plane()
-    const textureMatrix = new Matrix4()
+      const refractorPlane = new Plane()
+      const textureMatrix = new Matrix4()
 
-    // render target
+      // render target
 
-    const renderTarget = new WebGLRenderTarget(textureWidth, textureHeight, {
-      samples: multisample,
-      type: HalfFloatType,
-    })
+      const renderTarget = new WebGLRenderTarget(textureWidth, textureHeight, {
+        samples: multisample,
+        type: HalfFloatType,
+      })
 
-    // material
+      // material
 
-    this.material = new ShaderMaterial({
-      uniforms: UniformsUtils.clone(shader.uniforms),
-      vertexShader: shader.vertexShader,
-      fragmentShader: shader.fragmentShader,
-      transparent: true, // ensures, refractors are drawn from farthest to closest
-    })
+      this.material = new ShaderMaterial({
+        uniforms: UniformsUtils.clone(shader.uniforms),
+        vertexShader: shader.vertexShader,
+        fragmentShader: shader.fragmentShader,
+        transparent: true, // ensures, refractors are drawn from farthest to closest
+      })
 
-    this.material.uniforms['color'].value = color
-    this.material.uniforms['tDiffuse'].value = renderTarget.texture
-    this.material.uniforms['textureMatrix'].value = textureMatrix
+      this.material.uniforms['color'].value = color
+      this.material.uniforms['tDiffuse'].value = renderTarget.texture
+      this.material.uniforms['textureMatrix'].value = textureMatrix
 
-    // functions
+      // functions
 
-    const visible = (function () {
-      const refractorWorldPosition = new Vector3()
-      const cameraWorldPosition = new Vector3()
-      const rotationMatrix = new Matrix4()
+      const visible = (function () {
+        const refractorWorldPosition = new Vector3()
+        const cameraWorldPosition = new Vector3()
+        const rotationMatrix = new Matrix4()
 
-      const view = new Vector3()
-      const normal = new Vector3()
+        const view = new Vector3()
+        const normal = new Vector3()
 
-      return function visible(camera) {
-        refractorWorldPosition.setFromMatrixPosition(scope.matrixWorld)
-        cameraWorldPosition.setFromMatrixPosition(camera.matrixWorld)
+        return function visible(camera) {
+          refractorWorldPosition.setFromMatrixPosition(scope.matrixWorld)
+          cameraWorldPosition.setFromMatrixPosition(camera.matrixWorld)
 
-        view.subVectors(refractorWorldPosition, cameraWorldPosition)
+          view.subVectors(refractorWorldPosition, cameraWorldPosition)
 
-        rotationMatrix.extractRotation(scope.matrixWorld)
+          rotationMatrix.extractRotation(scope.matrixWorld)
 
-        normal.set(0, 0, 1)
-        normal.applyMatrix4(rotationMatrix)
+          normal.set(0, 0, 1)
+          normal.applyMatrix4(rotationMatrix)
 
-        return view.dot(normal) < 0
-      }
-    })()
+          return view.dot(normal) < 0
+        }
+      })()
 
-    const updateRefractorPlane = (function () {
-      const normal = new Vector3()
-      const position = new Vector3()
-      const quaternion = new Quaternion()
-      const scale = new Vector3()
+      const updateRefractorPlane = (function () {
+        const normal = new Vector3()
+        const position = new Vector3()
+        const quaternion = new Quaternion()
+        const scale = new Vector3()
 
-      return function updateRefractorPlane() {
-        scope.matrixWorld.decompose(position, quaternion, scale)
-        normal.set(0, 0, 1).applyQuaternion(quaternion).normalize()
+        return function updateRefractorPlane() {
+          scope.matrixWorld.decompose(position, quaternion, scale)
+          normal.set(0, 0, 1).applyQuaternion(quaternion).normalize()
 
-        // flip the normal because we want to cull everything above the plane
+          // flip the normal because we want to cull everything above the plane
 
-        normal.negate()
+          normal.negate()
 
-        refractorPlane.setFromNormalAndCoplanarPoint(normal, position)
-      }
-    })()
+          refractorPlane.setFromNormalAndCoplanarPoint(normal, position)
+        }
+      })()
 
-    const updateVirtualCamera = (function () {
-      const clipPlane = new Plane()
-      const clipVector = new Vector4()
-      const q = new Vector4()
+      const updateVirtualCamera = (function () {
+        const clipPlane = new Plane()
+        const clipVector = new Vector4()
+        const q = new Vector4()
 
-      return function updateVirtualCamera(camera) {
-        virtualCamera.matrixWorld.copy(camera.matrixWorld)
-        virtualCamera.matrixWorldInverse.copy(virtualCamera.matrixWorld).invert()
-        virtualCamera.projectionMatrix.copy(camera.projectionMatrix)
-        virtualCamera.far = camera.far // used in WebGLBackground
+        return function updateVirtualCamera(camera) {
+          virtualCamera.matrixWorld.copy(camera.matrixWorld)
+          virtualCamera.matrixWorldInverse.copy(virtualCamera.matrixWorld).invert()
+          virtualCamera.projectionMatrix.copy(camera.projectionMatrix)
+          virtualCamera.far = camera.far // used in WebGLBackground
 
-        // The following code creates an oblique view frustum for clipping.
-        // see: Lengyel, Eric. “Oblique View Frustum Depth Projection and Clipping”.
-        // Journal of Game Development, Vol. 1, No. 2 (2005), Charles River Media, pp. 5–16
+          // The following code creates an oblique view frustum for clipping.
+          // see: Lengyel, Eric. “Oblique View Frustum Depth Projection and Clipping”.
+          // Journal of Game Development, Vol. 1, No. 2 (2005), Charles River Media, pp. 5–16
 
-        clipPlane.copy(refractorPlane)
-        clipPlane.applyMatrix4(virtualCamera.matrixWorldInverse)
+          clipPlane.copy(refractorPlane)
+          clipPlane.applyMatrix4(virtualCamera.matrixWorldInverse)
 
-        clipVector.set(clipPlane.normal.x, clipPlane.normal.y, clipPlane.normal.z, clipPlane.constant)
+          clipVector.set(clipPlane.normal.x, clipPlane.normal.y, clipPlane.normal.z, clipPlane.constant)
 
-        // calculate the clip-space corner point opposite the clipping plane and
-        // transform it into camera space by multiplying it by the inverse of the projection matrix
+          // calculate the clip-space corner point opposite the clipping plane and
+          // transform it into camera space by multiplying it by the inverse of the projection matrix
 
-        const projectionMatrix = virtualCamera.projectionMatrix
+          const projectionMatrix = virtualCamera.projectionMatrix
 
-        q.x = (Math.sign(clipVector.x) + projectionMatrix.elements[8]) / projectionMatrix.elements[0]
-        q.y = (Math.sign(clipVector.y) + projectionMatrix.elements[9]) / projectionMatrix.elements[5]
-        q.z = -1.0
-        q.w = (1.0 + projectionMatrix.elements[10]) / projectionMatrix.elements[14]
+          q.x = (Math.sign(clipVector.x) + projectionMatrix.elements[8]) / projectionMatrix.elements[0]
+          q.y = (Math.sign(clipVector.y) + projectionMatrix.elements[9]) / projectionMatrix.elements[5]
+          q.z = -1.0
+          q.w = (1.0 + projectionMatrix.elements[10]) / projectionMatrix.elements[14]
 
-        // calculate the scaled plane vector
+          // calculate the scaled plane vector
 
-        clipVector.multiplyScalar(2.0 / clipVector.dot(q))
+          clipVector.multiplyScalar(2.0 / clipVector.dot(q))
 
-        // replacing the third row of the projection matrix
+          // replacing the third row of the projection matrix
 
-        projectionMatrix.elements[2] = clipVector.x
-        projectionMatrix.elements[6] = clipVector.y
-        projectionMatrix.elements[10] = clipVector.z + 1.0 - clipBias
-        projectionMatrix.elements[14] = clipVector.w
-      }
-    })()
+          projectionMatrix.elements[2] = clipVector.x
+          projectionMatrix.elements[6] = clipVector.y
+          projectionMatrix.elements[10] = clipVector.z + 1.0 - clipBias
+          projectionMatrix.elements[14] = clipVector.w
+        }
+      })()
 
-    // This will update the texture matrix that is used for projective texture mapping in the shader.
-    // see: http://developer.download.nvidia.com/assets/gamedev/docs/projective_texture_mapping.pdf
+      // This will update the texture matrix that is used for projective texture mapping in the shader.
+      // see: http://developer.download.nvidia.com/assets/gamedev/docs/projective_texture_mapping.pdf
 
-    function updateTextureMatrix(camera) {
-      // this matrix does range mapping to [ 0, 1 ]
+      function updateTextureMatrix(camera) {
+        // this matrix does range mapping to [ 0, 1 ]
 
-      textureMatrix.set(0.5, 0.0, 0.0, 0.5, 0.0, 0.5, 0.0, 0.5, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.0, 1.0)
+        textureMatrix.set(0.5, 0.0, 0.0, 0.5, 0.0, 0.5, 0.0, 0.5, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.0, 1.0)
 
-      // we use "Object Linear Texgen", so we need to multiply the texture matrix T
-      // (matrix above) with the projection and view matrix of the virtual camera
-      // and the model matrix of the refractor
+        // we use "Object Linear Texgen", so we need to multiply the texture matrix T
+        // (matrix above) with the projection and view matrix of the virtual camera
+        // and the model matrix of the refractor
 
-      textureMatrix.multiply(camera.projectionMatrix)
-      textureMatrix.multiply(camera.matrixWorldInverse)
-      textureMatrix.multiply(scope.matrixWorld)
-    }
+        textureMatrix.multiply(camera.projectionMatrix)
+        textureMatrix.multiply(camera.matrixWorldInverse)
+        textureMatrix.multiply(scope.matrixWorld)
+      }
 
-    //
+      //
 
-    function render(renderer, scene, camera) {
-      scope.visible = false
+      function render(renderer, scene, camera) {
+        scope.visible = false
 
-      const currentRenderTarget = renderer.getRenderTarget()
-      const currentXrEnabled = renderer.xr.enabled
-      const currentShadowAutoUpdate = renderer.shadowMap.autoUpdate
-      const currentToneMapping = renderer.toneMapping
+        const currentRenderTarget = renderer.getRenderTarget()
+        const currentXrEnabled = renderer.xr.enabled
+        const currentShadowAutoUpdate = renderer.shadowMap.autoUpdate
+        const currentToneMapping = renderer.toneMapping
 
-      let isSRGB = false
-      if ('outputColorSpace' in renderer) isSRGB = renderer.outputColorSpace === 'srgb'
-      else isSRGB = renderer.outputEncoding === 3001 // sRGBEncoding
+        let isSRGB = false
+        if ('outputColorSpace' in renderer) isSRGB = renderer.outputColorSpace === 'srgb'
+        else isSRGB = renderer.outputEncoding === 3001 // sRGBEncoding
 
-      renderer.xr.enabled = false // avoid camera modification
-      renderer.shadowMap.autoUpdate = false // avoid re-computing shadows
-      if ('outputColorSpace' in renderer) renderer.outputColorSpace = 'srgb-linear'
-      else renderer.outputEncoding = 3000 // LinearEncoding
-      renderer.toneMapping = NoToneMapping
+        renderer.xr.enabled = false // avoid camera modification
+        renderer.shadowMap.autoUpdate = false // avoid re-computing shadows
+        if ('outputColorSpace' in renderer) renderer.outputColorSpace = 'srgb-linear'
+        else renderer.outputEncoding = 3000 // LinearEncoding
+        renderer.toneMapping = NoToneMapping
 
-      renderer.setRenderTarget(renderTarget)
-      if (renderer.autoClear === false) renderer.clear()
-      renderer.render(scene, virtualCamera)
+        renderer.setRenderTarget(renderTarget)
+        if (renderer.autoClear === false) renderer.clear()
+        renderer.render(scene, virtualCamera)
 
-      renderer.xr.enabled = currentXrEnabled
-      renderer.shadowMap.autoUpdate = currentShadowAutoUpdate
-      renderer.toneMapping = currentToneMapping
-      renderer.setRenderTarget(currentRenderTarget)
+        renderer.xr.enabled = currentXrEnabled
+        renderer.shadowMap.autoUpdate = currentShadowAutoUpdate
+        renderer.toneMapping = currentToneMapping
+        renderer.setRenderTarget(currentRenderTarget)
 
-      if ('outputColorSpace' in renderer) renderer.outputColorSpace = isSRGB ? 'srgb' : 'srgb-linear'
-      else renderer.outputEncoding = isSRGB ? 3001 : 3000
+        if ('outputColorSpace' in renderer) renderer.outputColorSpace = isSRGB ? 'srgb' : 'srgb-linear'
+        else renderer.outputEncoding = isSRGB ? 3001 : 3000
 
-      // restore viewport
+        // restore viewport
 
-      const viewport = camera.viewport
+        const viewport = camera.viewport
 
-      if (viewport !== undefined) {
-        renderer.state.viewport(viewport)
-      }
+        if (viewport !== undefined) {
+          renderer.state.viewport(viewport)
+        }
 
-      scope.visible = true
-    }
+        scope.visible = true
+      }
 
-    //
+      //
 
-    this.onBeforeRender = function (renderer, scene, camera) {
-      // ensure refractors are rendered only once per frame
+      this.onBeforeRender = function (renderer, scene, camera) {
+        // ensure refractors are rendered only once per frame
 
-      if (camera.userData.refractor === true) return
+        if (camera.userData.refractor === true) return
 
-      // avoid rendering when the refractor is viewed from behind
+        // avoid rendering when the refractor is viewed from behind
 
-      if (!visible(camera) === true) return
+        if (!visible(camera) === true) return
 
-      // update
+        // update
 
-      updateRefractorPlane()
+        updateRefractorPlane()
 
-      updateTextureMatrix(camera)
+        updateTextureMatrix(camera)
 
-      updateVirtualCamera(camera)
+        updateVirtualCamera(camera)
 
-      render(renderer, scene, camera)
-    }
+        render(renderer, scene, camera)
+      }
 
-    this.getRenderTarget = function () {
-      return renderTarget
-    }
+      this.getRenderTarget = function () {
+        return renderTarget
+      }
 
-    this.dispose = function () {
-      renderTarget.dispose()
-      scope.material.dispose()
+      this.dispose = function () {
+        renderTarget.dispose()
+        scope.material.dispose()
+      }
     }
   }
-}
+
+  return Refractor
+})()
 
 export { Refractor }
diff --git a/src/objects/ShadowMesh.js b/src/objects/ShadowMesh.js
index 41075b36..38f91193 100644
--- a/src/objects/ShadowMesh.js
+++ b/src/objects/ShadowMesh.js
@@ -4,7 +4,7 @@ import { Matrix4, Mesh, MeshBasicMaterial, EqualStencilFunc, IncrementStencilOp
  * A shadow Mesh that follows a shadow-casting Mesh in the scene, but is confined to a single plane.
  */
 
-const _shadowMatrix = new Matrix4()
+const _shadowMatrix = /* @__PURE__ */ new Matrix4()
 
 class ShadowMesh extends Mesh {
   constructor(mesh) {
diff --git a/src/objects/Sky.d.ts b/src/objects/Sky.d.ts
new file mode 100644
index 00000000..107a0fdf
--- /dev/null
+++ b/src/objects/Sky.d.ts
@@ -0,0 +1,18 @@
+import { Mesh, BoxGeometry, ShaderMaterial, Vector3 } from 'three'
+
+declare class Sky extends Mesh<BoxGeometry, ShaderMaterial> {
+  static SkyShader: {
+    uniforms: {
+      turbidity: { value: number }
+      rayleigh: { value: number }
+      mieCoefficient: { value: number }
+      mieDirectionalG: { value: number }
+      sunPosition: { value: Vector3 }
+      up: { value: Vector3 }
+    }
+  }
+
+  static material: ShaderMaterial
+}
+
+export { Sky }
diff --git a/src/objects/Sky.ts b/src/objects/Sky.js
similarity index 89%
rename from src/objects/Sky.ts
rename to src/objects/Sky.js
index 80c206a2..1d920d40 100644
--- a/src/objects/Sky.ts
+++ b/src/objects/Sky.js
@@ -1,17 +1,31 @@
 import { BackSide, BoxGeometry, Mesh, ShaderMaterial, UniformsUtils, Vector3 } from 'three'
 import { version } from '../_polyfill/constants'
 
-const SkyShader = {
-  uniforms: {
-    turbidity: { value: 2 },
-    rayleigh: { value: 1 },
-    mieCoefficient: { value: 0.005 },
-    mieDirectionalG: { value: 0.8 },
-    sunPosition: { value: new Vector3() },
-    up: { value: new Vector3(0, 1, 0) },
-  },
-
-  vertexShader: /* glsl */ `
+/**
+ * Based on "A Practical Analytic Model for Daylight"
+ * aka The Preetham Model, the de facto standard analytic skydome model
+ * https://www.researchgate.net/publication/220720443_A_Practical_Analytic_Model_for_Daylight
+ *
+ * First implemented by Simon Wallner
+ * http://www.simonwallner.at/projects/atmospheric-scattering
+ *
+ * Improved by Martin Upitis
+ * http://blenderartists.org/forum/showthread.php?245954-preethams-sky-impementation-HDR
+ *
+ * Three.js integration by zz85 http://twitter.com/blurspline
+ */
+const Sky = /* @__PURE__ */ (() => {
+  const SkyShader = {
+    uniforms: {
+      turbidity: { value: 2 },
+      rayleigh: { value: 1 },
+      mieCoefficient: { value: 0.005 },
+      mieDirectionalG: { value: 0.8 },
+      sunPosition: { value: new Vector3() },
+      up: { value: new Vector3(0, 1, 0) },
+    },
+
+    vertexShader: /* glsl */ `
       uniform vec3 sunPosition;
       uniform float rayleigh;
       uniform float turbidity;
@@ -84,7 +98,7 @@ const SkyShader = {
       }
     `,
 
-  fragmentShader: /* glsl */ `
+    fragmentShader: /* glsl */ `
       varying vec3 vWorldPosition;
       varying vec3 vSunDirection;
       varying float vSunfade;
@@ -171,37 +185,27 @@ const SkyShader = {
 
       }
     `,
-}
-
-const material = new ShaderMaterial({
-  name: 'SkyShader',
-  fragmentShader: SkyShader.fragmentShader,
-  vertexShader: SkyShader.vertexShader,
-  uniforms: UniformsUtils.clone(SkyShader.uniforms),
-  side: BackSide,
-  depthWrite: false,
-})
+  }
 
-/**
- * Based on "A Practical Analytic Model for Daylight"
- * aka The Preetham Model, the de facto standard analytic skydome model
- * https://www.researchgate.net/publication/220720443_A_Practical_Analytic_Model_for_Daylight
- *
- * First implemented by Simon Wallner
- * http://www.simonwallner.at/projects/atmospheric-scattering
- *
- * Improved by Martin Upitis
- * http://blenderartists.org/forum/showthread.php?245954-preethams-sky-impementation-HDR
- *
- * Three.js integration by zz85 http://twitter.com/blurspline
- */
-class Sky extends Mesh {
-  constructor() {
-    super(new BoxGeometry(1, 1, 1), material)
+  const material = new ShaderMaterial({
+    name: 'SkyShader',
+    fragmentShader: SkyShader.fragmentShader,
+    vertexShader: SkyShader.vertexShader,
+    uniforms: UniformsUtils.clone(SkyShader.uniforms),
+    side: BackSide,
+    depthWrite: false,
+  })
+
+  class Sky extends Mesh {
+    constructor() {
+      super(new BoxGeometry(1, 1, 1), material)
+    }
+
+    static SkyShader = SkyShader
+    static material = material
   }
 
-  static SkyShader = SkyShader
-  public static material = material
-}
+  return Sky
+})()
 
 export { Sky }
diff --git a/src/objects/Water.js b/src/objects/Water.js
index 540647af..33dd0f94 100644
--- a/src/objects/Water.js
+++ b/src/objects/Water.js
@@ -11,8 +11,8 @@ import {
   Vector3,
   Vector4,
   WebGLRenderTarget,
-  REVISION,
 } from 'three'
+import { version } from '../_polyfill/constants'
 
 /**
  * Work based on :
@@ -179,7 +179,7 @@ class Water extends Mesh {
 					gl_FragColor = vec4( outgoingLight, alpha );
 
 					#include <tonemapping_fragment>
-					#include <${parseInt(REVISION.replace(/\D+/g, '')) >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>
+					#include <${version >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>
 					#include <fog_fragment>	
 				}`,
     }
diff --git a/src/objects/Water2.js b/src/objects/Water2.js
index 4b73e8f2..4eed788e 100644
--- a/src/objects/Water2.js
+++ b/src/objects/Water2.js
@@ -21,43 +21,44 @@ import { version } from '../_polyfill/constants'
  *
  */
 
-class Water2 extends Mesh {
-  static WaterShader = {
-    uniforms: {
-      color: {
-        value: null,
+const Water2 = /* @__PURE__ */ (() => {
+  class Water2 extends Mesh {
+    static WaterShader = {
+      uniforms: {
+        color: {
+          value: null,
+        },
+
+        reflectivity: {
+          value: 0,
+        },
+
+        tReflectionMap: {
+          value: null,
+        },
+
+        tRefractionMap: {
+          value: null,
+        },
+
+        tNormalMap0: {
+          value: null,
+        },
+
+        tNormalMap1: {
+          value: null,
+        },
+
+        textureMatrix: {
+          value: null,
+        },
+
+        config: {
+          value: /* @__PURE__ */ new Vector4(),
+        },
       },
 
-      reflectivity: {
-        value: 0,
-      },
-
-      tReflectionMap: {
-        value: null,
-      },
-
-      tRefractionMap: {
-        value: null,
-      },
-
-      tNormalMap0: {
-        value: null,
-      },
-
-      tNormalMap1: {
-        value: null,
-      },
-
-      textureMatrix: {
-        value: null,
-      },
-
-      config: {
-        value: new Vector4(),
-      },
-    },
-
-    vertexShader: /* glsl */ `
+      vertexShader: /* glsl */ `
 
 		#include <common>
 		#include <fog_pars_vertex>
@@ -85,7 +86,7 @@ class Water2 extends Mesh {
 
 		}`,
 
-    fragmentShader: /* glsl */ `
+      fragmentShader: /* glsl */ `
 
 		#include <common>
 		#include <fog_pars_fragment>
@@ -160,158 +161,161 @@ class Water2 extends Mesh {
 			#include <fog_fragment>
 
 		}`,
-  }
-
-  constructor(geometry, options = {}) {
-    super(geometry)
+    }
 
-    this.isWater = true
+    constructor(geometry, options = {}) {
+      super(geometry)
 
-    this.type = 'Water'
+      this.isWater = true
 
-    const scope = this
+      this.type = 'Water'
 
-    const color = options.color !== undefined ? new Color(options.color) : new Color(0xffffff)
-    const textureWidth = options.textureWidth || 512
-    const textureHeight = options.textureHeight || 512
-    const clipBias = options.clipBias || 0
-    const flowDirection = options.flowDirection || new Vector2(1, 0)
-    const flowSpeed = options.flowSpeed || 0.03
-    const reflectivity = options.reflectivity || 0.02
-    const scale = options.scale || 1
-    const shader = options.shader || Water2.WaterShader
-    const encoding = options.encoding !== undefined ? options.encoding : 3000
+      const scope = this
 
-    const flowMap = options.flowMap || undefined
-    const normalMap0 = options.normalMap0
-    const normalMap1 = options.normalMap1
+      const color = options.color !== undefined ? new Color(options.color) : new Color(0xffffff)
+      const textureWidth = options.textureWidth || 512
+      const textureHeight = options.textureHeight || 512
+      const clipBias = options.clipBias || 0
+      const flowDirection = options.flowDirection || new Vector2(1, 0)
+      const flowSpeed = options.flowSpeed || 0.03
+      const reflectivity = options.reflectivity || 0.02
+      const scale = options.scale || 1
+      const shader = options.shader || Water2.WaterShader
+      const encoding = options.encoding !== undefined ? options.encoding : 3000
 
-    const cycle = 0.15 // a cycle of a flow map phase
-    const halfCycle = cycle * 0.5
-    const textureMatrix = new Matrix4()
-    const clock = new Clock()
+      const flowMap = options.flowMap || undefined
+      const normalMap0 = options.normalMap0
+      const normalMap1 = options.normalMap1
 
-    // internal components
+      const cycle = 0.15 // a cycle of a flow map phase
+      const halfCycle = cycle * 0.5
+      const textureMatrix = new Matrix4()
+      const clock = new Clock()
 
-    if (Reflector === undefined) {
-      console.error('THREE.Water: Required component Reflector not found.')
-      return
-    }
+      // internal components
 
-    if (Refractor === undefined) {
-      console.error('THREE.Water: Required component Refractor not found.')
-      return
-    }
+      if (Reflector === undefined) {
+        console.error('THREE.Water: Required component Reflector not found.')
+        return
+      }
 
-    const reflector = new Reflector(geometry, {
-      textureWidth: textureWidth,
-      textureHeight: textureHeight,
-      clipBias: clipBias,
-      encoding: encoding,
-    })
-
-    const refractor = new Refractor(geometry, {
-      textureWidth: textureWidth,
-      textureHeight: textureHeight,
-      clipBias: clipBias,
-      encoding: encoding,
-    })
-
-    reflector.matrixAutoUpdate = false
-    refractor.matrixAutoUpdate = false
-
-    // material
-
-    this.material = new ShaderMaterial({
-      uniforms: UniformsUtils.merge([UniformsLib['fog'], shader.uniforms]),
-      vertexShader: shader.vertexShader,
-      fragmentShader: shader.fragmentShader,
-      transparent: true,
-      fog: true,
-    })
-
-    if (flowMap !== undefined) {
-      this.material.defines.USE_FLOWMAP = ''
-      this.material.uniforms['tFlowMap'] = {
-        type: 't',
-        value: flowMap,
+      if (Refractor === undefined) {
+        console.error('THREE.Water: Required component Refractor not found.')
+        return
       }
-    } else {
-      this.material.uniforms['flowDirection'] = {
-        type: 'v2',
-        value: flowDirection,
+
+      const reflector = new Reflector(geometry, {
+        textureWidth: textureWidth,
+        textureHeight: textureHeight,
+        clipBias: clipBias,
+        encoding: encoding,
+      })
+
+      const refractor = new Refractor(geometry, {
+        textureWidth: textureWidth,
+        textureHeight: textureHeight,
+        clipBias: clipBias,
+        encoding: encoding,
+      })
+
+      reflector.matrixAutoUpdate = false
+      refractor.matrixAutoUpdate = false
+
+      // material
+
+      this.material = new ShaderMaterial({
+        uniforms: UniformsUtils.merge([UniformsLib['fog'], shader.uniforms]),
+        vertexShader: shader.vertexShader,
+        fragmentShader: shader.fragmentShader,
+        transparent: true,
+        fog: true,
+      })
+
+      if (flowMap !== undefined) {
+        this.material.defines.USE_FLOWMAP = ''
+        this.material.uniforms['tFlowMap'] = {
+          type: 't',
+          value: flowMap,
+        }
+      } else {
+        this.material.uniforms['flowDirection'] = {
+          type: 'v2',
+          value: flowDirection,
+        }
       }
-    }
 
-    // maps
+      // maps
 
-    normalMap0.wrapS = normalMap0.wrapT = RepeatWrapping
-    normalMap1.wrapS = normalMap1.wrapT = RepeatWrapping
+      normalMap0.wrapS = normalMap0.wrapT = RepeatWrapping
+      normalMap1.wrapS = normalMap1.wrapT = RepeatWrapping
 
-    this.material.uniforms['tReflectionMap'].value = reflector.getRenderTarget().texture
-    this.material.uniforms['tRefractionMap'].value = refractor.getRenderTarget().texture
-    this.material.uniforms['tNormalMap0'].value = normalMap0
-    this.material.uniforms['tNormalMap1'].value = normalMap1
+      this.material.uniforms['tReflectionMap'].value = reflector.getRenderTarget().texture
+      this.material.uniforms['tRefractionMap'].value = refractor.getRenderTarget().texture
+      this.material.uniforms['tNormalMap0'].value = normalMap0
+      this.material.uniforms['tNormalMap1'].value = normalMap1
 
-    // water
+      // water
 
-    this.material.uniforms['color'].value = color
-    this.material.uniforms['reflectivity'].value = reflectivity
-    this.material.uniforms['textureMatrix'].value = textureMatrix
+      this.material.uniforms['color'].value = color
+      this.material.uniforms['reflectivity'].value = reflectivity
+      this.material.uniforms['textureMatrix'].value = textureMatrix
 
-    // inital values
+      // inital values
 
-    this.material.uniforms['config'].value.x = 0 // flowMapOffset0
-    this.material.uniforms['config'].value.y = halfCycle // flowMapOffset1
-    this.material.uniforms['config'].value.z = halfCycle // halfCycle
-    this.material.uniforms['config'].value.w = scale // scale
+      this.material.uniforms['config'].value.x = 0 // flowMapOffset0
+      this.material.uniforms['config'].value.y = halfCycle // flowMapOffset1
+      this.material.uniforms['config'].value.z = halfCycle // halfCycle
+      this.material.uniforms['config'].value.w = scale // scale
 
-    // functions
+      // functions
 
-    function updateTextureMatrix(camera) {
-      textureMatrix.set(0.5, 0.0, 0.0, 0.5, 0.0, 0.5, 0.0, 0.5, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.0, 1.0)
+      function updateTextureMatrix(camera) {
+        textureMatrix.set(0.5, 0.0, 0.0, 0.5, 0.0, 0.5, 0.0, 0.5, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.0, 1.0)
 
-      textureMatrix.multiply(camera.projectionMatrix)
-      textureMatrix.multiply(camera.matrixWorldInverse)
-      textureMatrix.multiply(scope.matrixWorld)
-    }
+        textureMatrix.multiply(camera.projectionMatrix)
+        textureMatrix.multiply(camera.matrixWorldInverse)
+        textureMatrix.multiply(scope.matrixWorld)
+      }
 
-    function updateFlow() {
-      const delta = clock.getDelta()
-      const config = scope.material.uniforms['config']
+      function updateFlow() {
+        const delta = clock.getDelta()
+        const config = scope.material.uniforms['config']
 
-      config.value.x += flowSpeed * delta // flowMapOffset0
-      config.value.y = config.value.x + halfCycle // flowMapOffset1
+        config.value.x += flowSpeed * delta // flowMapOffset0
+        config.value.y = config.value.x + halfCycle // flowMapOffset1
 
-      // Important: The distance between offsets should be always the value of "halfCycle".
-      // Moreover, both offsets should be in the range of [ 0, cycle ].
-      // This approach ensures a smooth water flow and avoids "reset" effects.
+        // Important: The distance between offsets should be always the value of "halfCycle".
+        // Moreover, both offsets should be in the range of [ 0, cycle ].
+        // This approach ensures a smooth water flow and avoids "reset" effects.
 
-      if (config.value.x >= cycle) {
-        config.value.x = 0
-        config.value.y = halfCycle
-      } else if (config.value.y >= cycle) {
-        config.value.y = config.value.y - cycle
+        if (config.value.x >= cycle) {
+          config.value.x = 0
+          config.value.y = halfCycle
+        } else if (config.value.y >= cycle) {
+          config.value.y = config.value.y - cycle
+        }
       }
-    }
 
-    //
+      //
 
-    this.onBeforeRender = function (renderer, scene, camera) {
-      updateTextureMatrix(camera)
-      updateFlow()
+      this.onBeforeRender = function (renderer, scene, camera) {
+        updateTextureMatrix(camera)
+        updateFlow()
 
-      scope.visible = false
+        scope.visible = false
 
-      reflector.matrixWorld.copy(scope.matrixWorld)
-      refractor.matrixWorld.copy(scope.matrixWorld)
+        reflector.matrixWorld.copy(scope.matrixWorld)
+        refractor.matrixWorld.copy(scope.matrixWorld)
 
-      reflector.onBeforeRender(renderer, scene, camera)
-      refractor.onBeforeRender(renderer, scene, camera)
+        reflector.onBeforeRender(renderer, scene, camera)
+        refractor.onBeforeRender(renderer, scene, camera)
 
-      scope.visible = true
+        scope.visible = true
+      }
     }
   }
-}
+
+  return Water2
+})()
 
 export { Water2 }
diff --git a/src/postprocessing/SAOPass.js b/src/postprocessing/SAOPass.js
index 6125d3b8..caa026dc 100644
--- a/src/postprocessing/SAOPass.js
+++ b/src/postprocessing/SAOPass.js
@@ -28,353 +28,357 @@ import { UnpackDepthRGBAShader } from '../shaders/UnpackDepthRGBAShader'
 /**
  * SAO implementation inspired from bhouston previous SAO work
  */
-class SAOPass extends Pass {
-  static OUTPUT = {
-    Beauty: 1,
-    Default: 0,
-    SAO: 2,
-    Depth: 3,
-    Normal: 4,
-  }
-
-  constructor(scene, camera, useDepthTexture = false, useNormals = false, resolution = new Vector2(256, 256)) {
-    super()
-
-    this.scene = scene
-    this.camera = camera
-
-    this.clear = true
-    this.needsSwap = false
-
-    this.supportsDepthTextureExtension = useDepthTexture
-    this.supportsNormalTexture = useNormals
-
-    this.originalClearColor = new Color()
-    this._oldClearColor = new Color()
-    this.oldClearAlpha = 1
-
-    this.params = {
-      output: 0,
-      saoBias: 0.5,
-      saoIntensity: 0.18,
-      saoScale: 1,
-      saoKernelRadius: 100,
-      saoMinResolution: 0,
-      saoBlur: true,
-      saoBlurRadius: 8,
-      saoBlurStdDev: 4,
-      saoBlurDepthCutoff: 0.01,
+const SAOPass = /* @__PURE__ */ (() => {
+  class SAOPass extends Pass {
+    static OUTPUT = {
+      Beauty: 1,
+      Default: 0,
+      SAO: 2,
+      Depth: 3,
+      Normal: 4,
     }
 
-    this.resolution = new Vector2(resolution.x, resolution.y)
+    constructor(scene, camera, useDepthTexture = false, useNormals = false, resolution = new Vector2(256, 256)) {
+      super()
+
+      this.scene = scene
+      this.camera = camera
+
+      this.clear = true
+      this.needsSwap = false
+
+      this.supportsDepthTextureExtension = useDepthTexture
+      this.supportsNormalTexture = useNormals
+
+      this.originalClearColor = new Color()
+      this._oldClearColor = new Color()
+      this.oldClearAlpha = 1
+
+      this.params = {
+        output: 0,
+        saoBias: 0.5,
+        saoIntensity: 0.18,
+        saoScale: 1,
+        saoKernelRadius: 100,
+        saoMinResolution: 0,
+        saoBlur: true,
+        saoBlurRadius: 8,
+        saoBlurStdDev: 4,
+        saoBlurDepthCutoff: 0.01,
+      }
 
-    this.saoRenderTarget = new WebGLRenderTarget(this.resolution.x, this.resolution.y, { type: HalfFloatType })
-    this.blurIntermediateRenderTarget = this.saoRenderTarget.clone()
-    this.beautyRenderTarget = this.saoRenderTarget.clone()
+      this.resolution = new Vector2(resolution.x, resolution.y)
 
-    this.normalRenderTarget = new WebGLRenderTarget(this.resolution.x, this.resolution.y, {
-      minFilter: NearestFilter,
-      magFilter: NearestFilter,
-      type: HalfFloatType,
-    })
-    this.depthRenderTarget = this.normalRenderTarget.clone()
+      this.saoRenderTarget = new WebGLRenderTarget(this.resolution.x, this.resolution.y, { type: HalfFloatType })
+      this.blurIntermediateRenderTarget = this.saoRenderTarget.clone()
+      this.beautyRenderTarget = this.saoRenderTarget.clone()
 
-    let depthTexture
+      this.normalRenderTarget = new WebGLRenderTarget(this.resolution.x, this.resolution.y, {
+        minFilter: NearestFilter,
+        magFilter: NearestFilter,
+        type: HalfFloatType,
+      })
+      this.depthRenderTarget = this.normalRenderTarget.clone()
 
-    if (this.supportsDepthTextureExtension) {
-      depthTexture = new DepthTexture()
-      depthTexture.type = UnsignedShortType
+      let depthTexture
 
-      this.beautyRenderTarget.depthTexture = depthTexture
-      this.beautyRenderTarget.depthBuffer = true
-    }
+      if (this.supportsDepthTextureExtension) {
+        depthTexture = new DepthTexture()
+        depthTexture.type = UnsignedShortType
 
-    this.depthMaterial = new MeshDepthMaterial()
-    this.depthMaterial.depthPacking = RGBADepthPacking
-    this.depthMaterial.blending = NoBlending
-
-    this.normalMaterial = new MeshNormalMaterial()
-    this.normalMaterial.blending = NoBlending
-
-    this.saoMaterial = new ShaderMaterial({
-      defines: Object.assign({}, SAOShader.defines),
-      fragmentShader: SAOShader.fragmentShader,
-      vertexShader: SAOShader.vertexShader,
-      uniforms: UniformsUtils.clone(SAOShader.uniforms),
-    })
-    this.saoMaterial.extensions.derivatives = true
-    this.saoMaterial.defines['DEPTH_PACKING'] = this.supportsDepthTextureExtension ? 0 : 1
-    this.saoMaterial.defines['NORMAL_TEXTURE'] = this.supportsNormalTexture ? 1 : 0
-    this.saoMaterial.defines['PERSPECTIVE_CAMERA'] = this.camera.isPerspectiveCamera ? 1 : 0
-    this.saoMaterial.uniforms['tDepth'].value = this.supportsDepthTextureExtension
-      ? depthTexture
-      : this.depthRenderTarget.texture
-    this.saoMaterial.uniforms['tNormal'].value = this.normalRenderTarget.texture
-    this.saoMaterial.uniforms['size'].value.set(this.resolution.x, this.resolution.y)
-    this.saoMaterial.uniforms['cameraInverseProjectionMatrix'].value.copy(this.camera.projectionMatrixInverse)
-    this.saoMaterial.uniforms['cameraProjectionMatrix'].value = this.camera.projectionMatrix
-    this.saoMaterial.blending = NoBlending
-
-    this.vBlurMaterial = new ShaderMaterial({
-      uniforms: UniformsUtils.clone(DepthLimitedBlurShader.uniforms),
-      defines: Object.assign({}, DepthLimitedBlurShader.defines),
-      vertexShader: DepthLimitedBlurShader.vertexShader,
-      fragmentShader: DepthLimitedBlurShader.fragmentShader,
-    })
-    this.vBlurMaterial.defines['DEPTH_PACKING'] = this.supportsDepthTextureExtension ? 0 : 1
-    this.vBlurMaterial.defines['PERSPECTIVE_CAMERA'] = this.camera.isPerspectiveCamera ? 1 : 0
-    this.vBlurMaterial.uniforms['tDiffuse'].value = this.saoRenderTarget.texture
-    this.vBlurMaterial.uniforms['tDepth'].value = this.supportsDepthTextureExtension
-      ? depthTexture
-      : this.depthRenderTarget.texture
-    this.vBlurMaterial.uniforms['size'].value.set(this.resolution.x, this.resolution.y)
-    this.vBlurMaterial.blending = NoBlending
-
-    this.hBlurMaterial = new ShaderMaterial({
-      uniforms: UniformsUtils.clone(DepthLimitedBlurShader.uniforms),
-      defines: Object.assign({}, DepthLimitedBlurShader.defines),
-      vertexShader: DepthLimitedBlurShader.vertexShader,
-      fragmentShader: DepthLimitedBlurShader.fragmentShader,
-    })
-    this.hBlurMaterial.defines['DEPTH_PACKING'] = this.supportsDepthTextureExtension ? 0 : 1
-    this.hBlurMaterial.defines['PERSPECTIVE_CAMERA'] = this.camera.isPerspectiveCamera ? 1 : 0
-    this.hBlurMaterial.uniforms['tDiffuse'].value = this.blurIntermediateRenderTarget.texture
-    this.hBlurMaterial.uniforms['tDepth'].value = this.supportsDepthTextureExtension
-      ? depthTexture
-      : this.depthRenderTarget.texture
-    this.hBlurMaterial.uniforms['size'].value.set(this.resolution.x, this.resolution.y)
-    this.hBlurMaterial.blending = NoBlending
-
-    this.materialCopy = new ShaderMaterial({
-      uniforms: UniformsUtils.clone(CopyShader.uniforms),
-      vertexShader: CopyShader.vertexShader,
-      fragmentShader: CopyShader.fragmentShader,
-      blending: NoBlending,
-    })
-    this.materialCopy.transparent = true
-    this.materialCopy.depthTest = false
-    this.materialCopy.depthWrite = false
-    this.materialCopy.blending = CustomBlending
-    this.materialCopy.blendSrc = DstColorFactor
-    this.materialCopy.blendDst = ZeroFactor
-    this.materialCopy.blendEquation = AddEquation
-    this.materialCopy.blendSrcAlpha = DstAlphaFactor
-    this.materialCopy.blendDstAlpha = ZeroFactor
-    this.materialCopy.blendEquationAlpha = AddEquation
-
-    this.depthCopy = new ShaderMaterial({
-      uniforms: UniformsUtils.clone(UnpackDepthRGBAShader.uniforms),
-      vertexShader: UnpackDepthRGBAShader.vertexShader,
-      fragmentShader: UnpackDepthRGBAShader.fragmentShader,
-      blending: NoBlending,
-    })
-
-    this.fsQuad = new FullScreenQuad(null)
-  }
+        this.beautyRenderTarget.depthTexture = depthTexture
+        this.beautyRenderTarget.depthBuffer = true
+      }
 
-  render(renderer, writeBuffer, readBuffer /*, deltaTime, maskActive*/) {
-    // Rendering readBuffer first when rendering to screen
-    if (this.renderToScreen) {
-      this.materialCopy.blending = NoBlending
-      this.materialCopy.uniforms['tDiffuse'].value = readBuffer.texture
-      this.materialCopy.needsUpdate = true
-      this.renderPass(renderer, this.materialCopy, null)
+      this.depthMaterial = new MeshDepthMaterial()
+      this.depthMaterial.depthPacking = RGBADepthPacking
+      this.depthMaterial.blending = NoBlending
+
+      this.normalMaterial = new MeshNormalMaterial()
+      this.normalMaterial.blending = NoBlending
+
+      this.saoMaterial = new ShaderMaterial({
+        defines: Object.assign({}, SAOShader.defines),
+        fragmentShader: SAOShader.fragmentShader,
+        vertexShader: SAOShader.vertexShader,
+        uniforms: UniformsUtils.clone(SAOShader.uniforms),
+      })
+      this.saoMaterial.extensions.derivatives = true
+      this.saoMaterial.defines['DEPTH_PACKING'] = this.supportsDepthTextureExtension ? 0 : 1
+      this.saoMaterial.defines['NORMAL_TEXTURE'] = this.supportsNormalTexture ? 1 : 0
+      this.saoMaterial.defines['PERSPECTIVE_CAMERA'] = this.camera.isPerspectiveCamera ? 1 : 0
+      this.saoMaterial.uniforms['tDepth'].value = this.supportsDepthTextureExtension
+        ? depthTexture
+        : this.depthRenderTarget.texture
+      this.saoMaterial.uniforms['tNormal'].value = this.normalRenderTarget.texture
+      this.saoMaterial.uniforms['size'].value.set(this.resolution.x, this.resolution.y)
+      this.saoMaterial.uniforms['cameraInverseProjectionMatrix'].value.copy(this.camera.projectionMatrixInverse)
+      this.saoMaterial.uniforms['cameraProjectionMatrix'].value = this.camera.projectionMatrix
+      this.saoMaterial.blending = NoBlending
+
+      this.vBlurMaterial = new ShaderMaterial({
+        uniforms: UniformsUtils.clone(DepthLimitedBlurShader.uniforms),
+        defines: Object.assign({}, DepthLimitedBlurShader.defines),
+        vertexShader: DepthLimitedBlurShader.vertexShader,
+        fragmentShader: DepthLimitedBlurShader.fragmentShader,
+      })
+      this.vBlurMaterial.defines['DEPTH_PACKING'] = this.supportsDepthTextureExtension ? 0 : 1
+      this.vBlurMaterial.defines['PERSPECTIVE_CAMERA'] = this.camera.isPerspectiveCamera ? 1 : 0
+      this.vBlurMaterial.uniforms['tDiffuse'].value = this.saoRenderTarget.texture
+      this.vBlurMaterial.uniforms['tDepth'].value = this.supportsDepthTextureExtension
+        ? depthTexture
+        : this.depthRenderTarget.texture
+      this.vBlurMaterial.uniforms['size'].value.set(this.resolution.x, this.resolution.y)
+      this.vBlurMaterial.blending = NoBlending
+
+      this.hBlurMaterial = new ShaderMaterial({
+        uniforms: UniformsUtils.clone(DepthLimitedBlurShader.uniforms),
+        defines: Object.assign({}, DepthLimitedBlurShader.defines),
+        vertexShader: DepthLimitedBlurShader.vertexShader,
+        fragmentShader: DepthLimitedBlurShader.fragmentShader,
+      })
+      this.hBlurMaterial.defines['DEPTH_PACKING'] = this.supportsDepthTextureExtension ? 0 : 1
+      this.hBlurMaterial.defines['PERSPECTIVE_CAMERA'] = this.camera.isPerspectiveCamera ? 1 : 0
+      this.hBlurMaterial.uniforms['tDiffuse'].value = this.blurIntermediateRenderTarget.texture
+      this.hBlurMaterial.uniforms['tDepth'].value = this.supportsDepthTextureExtension
+        ? depthTexture
+        : this.depthRenderTarget.texture
+      this.hBlurMaterial.uniforms['size'].value.set(this.resolution.x, this.resolution.y)
+      this.hBlurMaterial.blending = NoBlending
+
+      this.materialCopy = new ShaderMaterial({
+        uniforms: UniformsUtils.clone(CopyShader.uniforms),
+        vertexShader: CopyShader.vertexShader,
+        fragmentShader: CopyShader.fragmentShader,
+        blending: NoBlending,
+      })
+      this.materialCopy.transparent = true
+      this.materialCopy.depthTest = false
+      this.materialCopy.depthWrite = false
+      this.materialCopy.blending = CustomBlending
+      this.materialCopy.blendSrc = DstColorFactor
+      this.materialCopy.blendDst = ZeroFactor
+      this.materialCopy.blendEquation = AddEquation
+      this.materialCopy.blendSrcAlpha = DstAlphaFactor
+      this.materialCopy.blendDstAlpha = ZeroFactor
+      this.materialCopy.blendEquationAlpha = AddEquation
+
+      this.depthCopy = new ShaderMaterial({
+        uniforms: UniformsUtils.clone(UnpackDepthRGBAShader.uniforms),
+        vertexShader: UnpackDepthRGBAShader.vertexShader,
+        fragmentShader: UnpackDepthRGBAShader.fragmentShader,
+        blending: NoBlending,
+      })
+
+      this.fsQuad = new FullScreenQuad(null)
     }
 
-    if (this.params.output === 1) {
-      return
-    }
+    render(renderer, writeBuffer, readBuffer /*, deltaTime, maskActive*/) {
+      // Rendering readBuffer first when rendering to screen
+      if (this.renderToScreen) {
+        this.materialCopy.blending = NoBlending
+        this.materialCopy.uniforms['tDiffuse'].value = readBuffer.texture
+        this.materialCopy.needsUpdate = true
+        this.renderPass(renderer, this.materialCopy, null)
+      }
 
-    renderer.getClearColor(this._oldClearColor)
-    this.oldClearAlpha = renderer.getClearAlpha()
-    const oldAutoClear = renderer.autoClear
-    renderer.autoClear = false
-
-    renderer.setRenderTarget(this.depthRenderTarget)
-    renderer.clear()
-
-    this.saoMaterial.uniforms['bias'].value = this.params.saoBias
-    this.saoMaterial.uniforms['intensity'].value = this.params.saoIntensity
-    this.saoMaterial.uniforms['scale'].value = this.params.saoScale
-    this.saoMaterial.uniforms['kernelRadius'].value = this.params.saoKernelRadius
-    this.saoMaterial.uniforms['minResolution'].value = this.params.saoMinResolution
-    this.saoMaterial.uniforms['cameraNear'].value = this.camera.near
-    this.saoMaterial.uniforms['cameraFar'].value = this.camera.far
-    // this.saoMaterial.uniforms['randomSeed'].value = Math.random();
-
-    const depthCutoff = this.params.saoBlurDepthCutoff * (this.camera.far - this.camera.near)
-    this.vBlurMaterial.uniforms['depthCutoff'].value = depthCutoff
-    this.hBlurMaterial.uniforms['depthCutoff'].value = depthCutoff
-
-    this.vBlurMaterial.uniforms['cameraNear'].value = this.camera.near
-    this.vBlurMaterial.uniforms['cameraFar'].value = this.camera.far
-    this.hBlurMaterial.uniforms['cameraNear'].value = this.camera.near
-    this.hBlurMaterial.uniforms['cameraFar'].value = this.camera.far
-
-    this.params.saoBlurRadius = Math.floor(this.params.saoBlurRadius)
-    if (this.prevStdDev !== this.params.saoBlurStdDev || this.prevNumSamples !== this.params.saoBlurRadius) {
-      BlurShaderUtils.configure(
-        this.vBlurMaterial,
-        this.params.saoBlurRadius,
-        this.params.saoBlurStdDev,
-        new Vector2(0, 1),
-      )
-      BlurShaderUtils.configure(
-        this.hBlurMaterial,
-        this.params.saoBlurRadius,
-        this.params.saoBlurStdDev,
-        new Vector2(1, 0),
-      )
-      this.prevStdDev = this.params.saoBlurStdDev
-      this.prevNumSamples = this.params.saoBlurRadius
-    }
+      if (this.params.output === 1) {
+        return
+      }
 
-    // Rendering scene to depth texture
-    renderer.setClearColor(0x000000)
-    renderer.setRenderTarget(this.beautyRenderTarget)
-    renderer.clear()
-    renderer.render(this.scene, this.camera)
+      renderer.getClearColor(this._oldClearColor)
+      this.oldClearAlpha = renderer.getClearAlpha()
+      const oldAutoClear = renderer.autoClear
+      renderer.autoClear = false
 
-    // Re-render scene if depth texture extension is not supported
-    if (!this.supportsDepthTextureExtension) {
-      // Clear rule : far clipping plane in both RGBA and Basic encoding
-      this.renderOverride(renderer, this.depthMaterial, this.depthRenderTarget, 0x000000, 1.0)
-    }
+      renderer.setRenderTarget(this.depthRenderTarget)
+      renderer.clear()
 
-    if (this.supportsNormalTexture) {
-      // Clear rule : default normal is facing the camera
-      this.renderOverride(renderer, this.normalMaterial, this.normalRenderTarget, 0x7777ff, 1.0)
-    }
+      this.saoMaterial.uniforms['bias'].value = this.params.saoBias
+      this.saoMaterial.uniforms['intensity'].value = this.params.saoIntensity
+      this.saoMaterial.uniforms['scale'].value = this.params.saoScale
+      this.saoMaterial.uniforms['kernelRadius'].value = this.params.saoKernelRadius
+      this.saoMaterial.uniforms['minResolution'].value = this.params.saoMinResolution
+      this.saoMaterial.uniforms['cameraNear'].value = this.camera.near
+      this.saoMaterial.uniforms['cameraFar'].value = this.camera.far
+      // this.saoMaterial.uniforms['randomSeed'].value = Math.random();
+
+      const depthCutoff = this.params.saoBlurDepthCutoff * (this.camera.far - this.camera.near)
+      this.vBlurMaterial.uniforms['depthCutoff'].value = depthCutoff
+      this.hBlurMaterial.uniforms['depthCutoff'].value = depthCutoff
+
+      this.vBlurMaterial.uniforms['cameraNear'].value = this.camera.near
+      this.vBlurMaterial.uniforms['cameraFar'].value = this.camera.far
+      this.hBlurMaterial.uniforms['cameraNear'].value = this.camera.near
+      this.hBlurMaterial.uniforms['cameraFar'].value = this.camera.far
+
+      this.params.saoBlurRadius = Math.floor(this.params.saoBlurRadius)
+      if (this.prevStdDev !== this.params.saoBlurStdDev || this.prevNumSamples !== this.params.saoBlurRadius) {
+        BlurShaderUtils.configure(
+          this.vBlurMaterial,
+          this.params.saoBlurRadius,
+          this.params.saoBlurStdDev,
+          new Vector2(0, 1),
+        )
+        BlurShaderUtils.configure(
+          this.hBlurMaterial,
+          this.params.saoBlurRadius,
+          this.params.saoBlurStdDev,
+          new Vector2(1, 0),
+        )
+        this.prevStdDev = this.params.saoBlurStdDev
+        this.prevNumSamples = this.params.saoBlurRadius
+      }
 
-    // Rendering SAO texture
-    this.renderPass(renderer, this.saoMaterial, this.saoRenderTarget, 0xffffff, 1.0)
+      // Rendering scene to depth texture
+      renderer.setClearColor(0x000000)
+      renderer.setRenderTarget(this.beautyRenderTarget)
+      renderer.clear()
+      renderer.render(this.scene, this.camera)
 
-    // Blurring SAO texture
-    if (this.params.saoBlur) {
-      this.renderPass(renderer, this.vBlurMaterial, this.blurIntermediateRenderTarget, 0xffffff, 1.0)
-      this.renderPass(renderer, this.hBlurMaterial, this.saoRenderTarget, 0xffffff, 1.0)
-    }
+      // Re-render scene if depth texture extension is not supported
+      if (!this.supportsDepthTextureExtension) {
+        // Clear rule : far clipping plane in both RGBA and Basic encoding
+        this.renderOverride(renderer, this.depthMaterial, this.depthRenderTarget, 0x000000, 1.0)
+      }
 
-    let outputMaterial = this.materialCopy
-    // Setting up SAO rendering
-    if (this.params.output === 3) {
-      if (this.supportsDepthTextureExtension) {
-        this.materialCopy.uniforms['tDiffuse'].value = this.beautyRenderTarget.depthTexture
+      if (this.supportsNormalTexture) {
+        // Clear rule : default normal is facing the camera
+        this.renderOverride(renderer, this.normalMaterial, this.normalRenderTarget, 0x7777ff, 1.0)
+      }
+
+      // Rendering SAO texture
+      this.renderPass(renderer, this.saoMaterial, this.saoRenderTarget, 0xffffff, 1.0)
+
+      // Blurring SAO texture
+      if (this.params.saoBlur) {
+        this.renderPass(renderer, this.vBlurMaterial, this.blurIntermediateRenderTarget, 0xffffff, 1.0)
+        this.renderPass(renderer, this.hBlurMaterial, this.saoRenderTarget, 0xffffff, 1.0)
+      }
+
+      let outputMaterial = this.materialCopy
+      // Setting up SAO rendering
+      if (this.params.output === 3) {
+        if (this.supportsDepthTextureExtension) {
+          this.materialCopy.uniforms['tDiffuse'].value = this.beautyRenderTarget.depthTexture
+          this.materialCopy.needsUpdate = true
+        } else {
+          this.depthCopy.uniforms['tDiffuse'].value = this.depthRenderTarget.texture
+          this.depthCopy.needsUpdate = true
+          outputMaterial = this.depthCopy
+        }
+      } else if (this.params.output === 4) {
+        this.materialCopy.uniforms['tDiffuse'].value = this.normalRenderTarget.texture
         this.materialCopy.needsUpdate = true
       } else {
-        this.depthCopy.uniforms['tDiffuse'].value = this.depthRenderTarget.texture
-        this.depthCopy.needsUpdate = true
-        outputMaterial = this.depthCopy
+        this.materialCopy.uniforms['tDiffuse'].value = this.saoRenderTarget.texture
+        this.materialCopy.needsUpdate = true
       }
-    } else if (this.params.output === 4) {
-      this.materialCopy.uniforms['tDiffuse'].value = this.normalRenderTarget.texture
-      this.materialCopy.needsUpdate = true
-    } else {
-      this.materialCopy.uniforms['tDiffuse'].value = this.saoRenderTarget.texture
-      this.materialCopy.needsUpdate = true
-    }
 
-    // Blending depends on output, only want a CustomBlending when showing SAO
-    if (this.params.output === 0) {
-      outputMaterial.blending = CustomBlending
-    } else {
-      outputMaterial.blending = NoBlending
+      // Blending depends on output, only want a CustomBlending when showing SAO
+      if (this.params.output === 0) {
+        outputMaterial.blending = CustomBlending
+      } else {
+        outputMaterial.blending = NoBlending
+      }
+
+      // Rendering SAOPass result on top of previous pass
+      this.renderPass(renderer, outputMaterial, this.renderToScreen ? null : readBuffer)
+
+      renderer.setClearColor(this._oldClearColor, this.oldClearAlpha)
+      renderer.autoClear = oldAutoClear
     }
 
-    // Rendering SAOPass result on top of previous pass
-    this.renderPass(renderer, outputMaterial, this.renderToScreen ? null : readBuffer)
+    renderPass(renderer, passMaterial, renderTarget, clearColor, clearAlpha) {
+      // save original state
+      renderer.getClearColor(this.originalClearColor)
+      const originalClearAlpha = renderer.getClearAlpha()
+      const originalAutoClear = renderer.autoClear
 
-    renderer.setClearColor(this._oldClearColor, this.oldClearAlpha)
-    renderer.autoClear = oldAutoClear
-  }
+      renderer.setRenderTarget(renderTarget)
 
-  renderPass(renderer, passMaterial, renderTarget, clearColor, clearAlpha) {
-    // save original state
-    renderer.getClearColor(this.originalClearColor)
-    const originalClearAlpha = renderer.getClearAlpha()
-    const originalAutoClear = renderer.autoClear
+      // setup pass state
+      renderer.autoClear = false
+      if (clearColor !== undefined && clearColor !== null) {
+        renderer.setClearColor(clearColor)
+        renderer.setClearAlpha(clearAlpha || 0.0)
+        renderer.clear()
+      }
 
-    renderer.setRenderTarget(renderTarget)
+      this.fsQuad.material = passMaterial
+      this.fsQuad.render(renderer)
 
-    // setup pass state
-    renderer.autoClear = false
-    if (clearColor !== undefined && clearColor !== null) {
-      renderer.setClearColor(clearColor)
-      renderer.setClearAlpha(clearAlpha || 0.0)
-      renderer.clear()
+      // restore original state
+      renderer.autoClear = originalAutoClear
+      renderer.setClearColor(this.originalClearColor)
+      renderer.setClearAlpha(originalClearAlpha)
     }
 
-    this.fsQuad.material = passMaterial
-    this.fsQuad.render(renderer)
+    renderOverride(renderer, overrideMaterial, renderTarget, clearColor, clearAlpha) {
+      renderer.getClearColor(this.originalClearColor)
+      const originalClearAlpha = renderer.getClearAlpha()
+      const originalAutoClear = renderer.autoClear
 
-    // restore original state
-    renderer.autoClear = originalAutoClear
-    renderer.setClearColor(this.originalClearColor)
-    renderer.setClearAlpha(originalClearAlpha)
-  }
+      renderer.setRenderTarget(renderTarget)
+      renderer.autoClear = false
 
-  renderOverride(renderer, overrideMaterial, renderTarget, clearColor, clearAlpha) {
-    renderer.getClearColor(this.originalClearColor)
-    const originalClearAlpha = renderer.getClearAlpha()
-    const originalAutoClear = renderer.autoClear
+      clearColor = overrideMaterial.clearColor || clearColor
+      clearAlpha = overrideMaterial.clearAlpha || clearAlpha
+      if (clearColor !== undefined && clearColor !== null) {
+        renderer.setClearColor(clearColor)
+        renderer.setClearAlpha(clearAlpha || 0.0)
+        renderer.clear()
+      }
 
-    renderer.setRenderTarget(renderTarget)
-    renderer.autoClear = false
+      this.scene.overrideMaterial = overrideMaterial
+      renderer.render(this.scene, this.camera)
+      this.scene.overrideMaterial = null
 
-    clearColor = overrideMaterial.clearColor || clearColor
-    clearAlpha = overrideMaterial.clearAlpha || clearAlpha
-    if (clearColor !== undefined && clearColor !== null) {
-      renderer.setClearColor(clearColor)
-      renderer.setClearAlpha(clearAlpha || 0.0)
-      renderer.clear()
+      // restore original state
+      renderer.autoClear = originalAutoClear
+      renderer.setClearColor(this.originalClearColor)
+      renderer.setClearAlpha(originalClearAlpha)
     }
 
-    this.scene.overrideMaterial = overrideMaterial
-    renderer.render(this.scene, this.camera)
-    this.scene.overrideMaterial = null
+    setSize(width, height) {
+      this.beautyRenderTarget.setSize(width, height)
+      this.saoRenderTarget.setSize(width, height)
+      this.blurIntermediateRenderTarget.setSize(width, height)
+      this.normalRenderTarget.setSize(width, height)
+      this.depthRenderTarget.setSize(width, height)
 
-    // restore original state
-    renderer.autoClear = originalAutoClear
-    renderer.setClearColor(this.originalClearColor)
-    renderer.setClearAlpha(originalClearAlpha)
-  }
-
-  setSize(width, height) {
-    this.beautyRenderTarget.setSize(width, height)
-    this.saoRenderTarget.setSize(width, height)
-    this.blurIntermediateRenderTarget.setSize(width, height)
-    this.normalRenderTarget.setSize(width, height)
-    this.depthRenderTarget.setSize(width, height)
+      this.saoMaterial.uniforms['size'].value.set(width, height)
+      this.saoMaterial.uniforms['cameraInverseProjectionMatrix'].value.copy(this.camera.projectionMatrixInverse)
+      this.saoMaterial.uniforms['cameraProjectionMatrix'].value = this.camera.projectionMatrix
+      this.saoMaterial.needsUpdate = true
 
-    this.saoMaterial.uniforms['size'].value.set(width, height)
-    this.saoMaterial.uniforms['cameraInverseProjectionMatrix'].value.copy(this.camera.projectionMatrixInverse)
-    this.saoMaterial.uniforms['cameraProjectionMatrix'].value = this.camera.projectionMatrix
-    this.saoMaterial.needsUpdate = true
+      this.vBlurMaterial.uniforms['size'].value.set(width, height)
+      this.vBlurMaterial.needsUpdate = true
 
-    this.vBlurMaterial.uniforms['size'].value.set(width, height)
-    this.vBlurMaterial.needsUpdate = true
+      this.hBlurMaterial.uniforms['size'].value.set(width, height)
+      this.hBlurMaterial.needsUpdate = true
+    }
 
-    this.hBlurMaterial.uniforms['size'].value.set(width, height)
-    this.hBlurMaterial.needsUpdate = true
+    dispose() {
+      this.saoRenderTarget.dispose()
+      this.blurIntermediateRenderTarget.dispose()
+      this.beautyRenderTarget.dispose()
+      this.normalRenderTarget.dispose()
+      this.depthRenderTarget.dispose()
+
+      this.depthMaterial.dispose()
+      this.normalMaterial.dispose()
+      this.saoMaterial.dispose()
+      this.vBlurMaterial.dispose()
+      this.hBlurMaterial.dispose()
+      this.materialCopy.dispose()
+      this.depthCopy.dispose()
+
+      this.fsQuad.dispose()
+    }
   }
 
-  dispose() {
-    this.saoRenderTarget.dispose()
-    this.blurIntermediateRenderTarget.dispose()
-    this.beautyRenderTarget.dispose()
-    this.normalRenderTarget.dispose()
-    this.depthRenderTarget.dispose()
-
-    this.depthMaterial.dispose()
-    this.normalMaterial.dispose()
-    this.saoMaterial.dispose()
-    this.vBlurMaterial.dispose()
-    this.hBlurMaterial.dispose()
-    this.materialCopy.dispose()
-    this.depthCopy.dispose()
-
-    this.fsQuad.dispose()
-  }
-}
+  return SAOPass
+})()
 
 export { SAOPass }
diff --git a/src/postprocessing/SSAOPass.js b/src/postprocessing/SSAOPass.js
index 52a5d0ed..1af8f82b 100644
--- a/src/postprocessing/SSAOPass.js
+++ b/src/postprocessing/SSAOPass.js
@@ -28,377 +28,381 @@ import { SSAOShader, SSAOBlurShader, SSAODepthShader } from '../shaders/SSAOShad
 
 import { CopyShader } from '../shaders/CopyShader'
 
-class SSAOPass extends Pass {
-  static OUTPUT = {
-    Default: 0,
-    SSAO: 1,
-    Blur: 2,
-    Beauty: 3,
-    Depth: 4,
-    Normal: 5,
-  }
+const SSAOPass = /* @__PURE__ */ (() => {
+  class SSAOPass extends Pass {
+    static OUTPUT = {
+      Default: 0,
+      SSAO: 1,
+      Blur: 2,
+      Beauty: 3,
+      Depth: 4,
+      Normal: 5,
+    }
 
-  constructor(scene, camera, width, height) {
-    super()
+    constructor(scene, camera, width, height) {
+      super()
 
-    this.width = width !== undefined ? width : 512
-    this.height = height !== undefined ? height : 512
+      this.width = width !== undefined ? width : 512
+      this.height = height !== undefined ? height : 512
 
-    this.clear = true
+      this.clear = true
 
-    this.camera = camera
-    this.scene = scene
+      this.camera = camera
+      this.scene = scene
 
-    this.kernelRadius = 8
-    this.kernelSize = 32
-    this.kernel = []
-    this.noiseTexture = null
-    this.output = 0
+      this.kernelRadius = 8
+      this.kernelSize = 32
+      this.kernel = []
+      this.noiseTexture = null
+      this.output = 0
 
-    this.minDistance = 0.005
-    this.maxDistance = 0.1
+      this.minDistance = 0.005
+      this.maxDistance = 0.1
 
-    this._visibilityCache = new Map()
+      this._visibilityCache = new Map()
 
-    //
+      //
 
-    this.generateSampleKernel()
-    this.generateRandomKernelRotations()
+      this.generateSampleKernel()
+      this.generateRandomKernelRotations()
 
-    // beauty render target
+      // beauty render target
 
-    const depthTexture = new DepthTexture()
-    depthTexture.format = DepthStencilFormat
-    depthTexture.type = UnsignedInt248Type
+      const depthTexture = new DepthTexture()
+      depthTexture.format = DepthStencilFormat
+      depthTexture.type = UnsignedInt248Type
 
-    this.beautyRenderTarget = new WebGLRenderTarget(this.width, this.height)
+      this.beautyRenderTarget = new WebGLRenderTarget(this.width, this.height)
 
-    // normal render target with depth buffer
+      // normal render target with depth buffer
 
-    this.normalRenderTarget = new WebGLRenderTarget(this.width, this.height, {
-      minFilter: NearestFilter,
-      magFilter: NearestFilter,
-      depthTexture: depthTexture,
-    })
+      this.normalRenderTarget = new WebGLRenderTarget(this.width, this.height, {
+        minFilter: NearestFilter,
+        magFilter: NearestFilter,
+        depthTexture: depthTexture,
+      })
 
-    // ssao render target
+      // ssao render target
 
-    this.ssaoRenderTarget = new WebGLRenderTarget(this.width, this.height)
+      this.ssaoRenderTarget = new WebGLRenderTarget(this.width, this.height)
 
-    this.blurRenderTarget = this.ssaoRenderTarget.clone()
+      this.blurRenderTarget = this.ssaoRenderTarget.clone()
 
-    // ssao material
+      // ssao material
 
-    if (SSAOShader === undefined) {
-      console.error('THREE.SSAOPass: The pass relies on SSAOShader.')
-    }
+      if (SSAOShader === undefined) {
+        console.error('THREE.SSAOPass: The pass relies on SSAOShader.')
+      }
 
-    this.ssaoMaterial = new ShaderMaterial({
-      defines: Object.assign({}, SSAOShader.defines),
-      uniforms: UniformsUtils.clone(SSAOShader.uniforms),
-      vertexShader: SSAOShader.vertexShader,
-      fragmentShader: SSAOShader.fragmentShader,
-      blending: NoBlending,
-    })
-
-    this.ssaoMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
-    this.ssaoMaterial.uniforms['tNormal'].value = this.normalRenderTarget.texture
-    this.ssaoMaterial.uniforms['tDepth'].value = this.normalRenderTarget.depthTexture
-    this.ssaoMaterial.uniforms['tNoise'].value = this.noiseTexture
-    this.ssaoMaterial.uniforms['kernel'].value = this.kernel
-    this.ssaoMaterial.uniforms['cameraNear'].value = this.camera.near
-    this.ssaoMaterial.uniforms['cameraFar'].value = this.camera.far
-    this.ssaoMaterial.uniforms['resolution'].value.set(this.width, this.height)
-    this.ssaoMaterial.uniforms['cameraProjectionMatrix'].value.copy(this.camera.projectionMatrix)
-    this.ssaoMaterial.uniforms['cameraInverseProjectionMatrix'].value.copy(this.camera.projectionMatrixInverse)
-
-    // normal material
-
-    this.normalMaterial = new MeshNormalMaterial()
-    this.normalMaterial.blending = NoBlending
-
-    // blur material
-
-    this.blurMaterial = new ShaderMaterial({
-      defines: Object.assign({}, SSAOBlurShader.defines),
-      uniforms: UniformsUtils.clone(SSAOBlurShader.uniforms),
-      vertexShader: SSAOBlurShader.vertexShader,
-      fragmentShader: SSAOBlurShader.fragmentShader,
-    })
-    this.blurMaterial.uniforms['tDiffuse'].value = this.ssaoRenderTarget.texture
-    this.blurMaterial.uniforms['resolution'].value.set(this.width, this.height)
-
-    // material for rendering the depth
-
-    this.depthRenderMaterial = new ShaderMaterial({
-      defines: Object.assign({}, SSAODepthShader.defines),
-      uniforms: UniformsUtils.clone(SSAODepthShader.uniforms),
-      vertexShader: SSAODepthShader.vertexShader,
-      fragmentShader: SSAODepthShader.fragmentShader,
-      blending: NoBlending,
-    })
-    this.depthRenderMaterial.uniforms['tDepth'].value = this.normalRenderTarget.depthTexture
-    this.depthRenderMaterial.uniforms['cameraNear'].value = this.camera.near
-    this.depthRenderMaterial.uniforms['cameraFar'].value = this.camera.far
-
-    // material for rendering the content of a render target
-
-    this.copyMaterial = new ShaderMaterial({
-      uniforms: UniformsUtils.clone(CopyShader.uniforms),
-      vertexShader: CopyShader.vertexShader,
-      fragmentShader: CopyShader.fragmentShader,
-      transparent: true,
-      depthTest: false,
-      depthWrite: false,
-      blendSrc: DstColorFactor,
-      blendDst: ZeroFactor,
-      blendEquation: AddEquation,
-      blendSrcAlpha: DstAlphaFactor,
-      blendDstAlpha: ZeroFactor,
-      blendEquationAlpha: AddEquation,
-    })
-
-    this.fsQuad = new FullScreenQuad(null)
-
-    this.originalClearColor = new Color()
-  }
+      this.ssaoMaterial = new ShaderMaterial({
+        defines: Object.assign({}, SSAOShader.defines),
+        uniforms: UniformsUtils.clone(SSAOShader.uniforms),
+        vertexShader: SSAOShader.vertexShader,
+        fragmentShader: SSAOShader.fragmentShader,
+        blending: NoBlending,
+      })
 
-  dispose() {
-    // dispose render targets
+      this.ssaoMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
+      this.ssaoMaterial.uniforms['tNormal'].value = this.normalRenderTarget.texture
+      this.ssaoMaterial.uniforms['tDepth'].value = this.normalRenderTarget.depthTexture
+      this.ssaoMaterial.uniforms['tNoise'].value = this.noiseTexture
+      this.ssaoMaterial.uniforms['kernel'].value = this.kernel
+      this.ssaoMaterial.uniforms['cameraNear'].value = this.camera.near
+      this.ssaoMaterial.uniforms['cameraFar'].value = this.camera.far
+      this.ssaoMaterial.uniforms['resolution'].value.set(this.width, this.height)
+      this.ssaoMaterial.uniforms['cameraProjectionMatrix'].value.copy(this.camera.projectionMatrix)
+      this.ssaoMaterial.uniforms['cameraInverseProjectionMatrix'].value.copy(this.camera.projectionMatrixInverse)
 
-    this.beautyRenderTarget.dispose()
-    this.normalRenderTarget.dispose()
-    this.ssaoRenderTarget.dispose()
-    this.blurRenderTarget.dispose()
+      // normal material
 
-    // dispose materials
+      this.normalMaterial = new MeshNormalMaterial()
+      this.normalMaterial.blending = NoBlending
 
-    this.normalMaterial.dispose()
-    this.blurMaterial.dispose()
-    this.copyMaterial.dispose()
-    this.depthRenderMaterial.dispose()
+      // blur material
 
-    // dipsose full screen quad
+      this.blurMaterial = new ShaderMaterial({
+        defines: Object.assign({}, SSAOBlurShader.defines),
+        uniforms: UniformsUtils.clone(SSAOBlurShader.uniforms),
+        vertexShader: SSAOBlurShader.vertexShader,
+        fragmentShader: SSAOBlurShader.fragmentShader,
+      })
+      this.blurMaterial.uniforms['tDiffuse'].value = this.ssaoRenderTarget.texture
+      this.blurMaterial.uniforms['resolution'].value.set(this.width, this.height)
 
-    this.fsQuad.dispose()
-  }
+      // material for rendering the depth
 
-  render(renderer, writeBuffer /*, readBuffer, deltaTime, maskActive */) {
-    if (renderer.capabilities.isWebGL2 === false) this.noiseTexture.format = LuminanceFormat
+      this.depthRenderMaterial = new ShaderMaterial({
+        defines: Object.assign({}, SSAODepthShader.defines),
+        uniforms: UniformsUtils.clone(SSAODepthShader.uniforms),
+        vertexShader: SSAODepthShader.vertexShader,
+        fragmentShader: SSAODepthShader.fragmentShader,
+        blending: NoBlending,
+      })
+      this.depthRenderMaterial.uniforms['tDepth'].value = this.normalRenderTarget.depthTexture
+      this.depthRenderMaterial.uniforms['cameraNear'].value = this.camera.near
+      this.depthRenderMaterial.uniforms['cameraFar'].value = this.camera.far
 
-    // render beauty
+      // material for rendering the content of a render target
 
-    renderer.setRenderTarget(this.beautyRenderTarget)
-    renderer.clear()
-    renderer.render(this.scene, this.camera)
+      this.copyMaterial = new ShaderMaterial({
+        uniforms: UniformsUtils.clone(CopyShader.uniforms),
+        vertexShader: CopyShader.vertexShader,
+        fragmentShader: CopyShader.fragmentShader,
+        transparent: true,
+        depthTest: false,
+        depthWrite: false,
+        blendSrc: DstColorFactor,
+        blendDst: ZeroFactor,
+        blendEquation: AddEquation,
+        blendSrcAlpha: DstAlphaFactor,
+        blendDstAlpha: ZeroFactor,
+        blendEquationAlpha: AddEquation,
+      })
+
+      this.fsQuad = new FullScreenQuad(null)
+
+      this.originalClearColor = new Color()
+    }
 
-    // render normals and depth (honor only meshes, points and lines do not contribute to SSAO)
+    dispose() {
+      // dispose render targets
 
-    this.overrideVisibility()
-    this.renderOverride(renderer, this.normalMaterial, this.normalRenderTarget, 0x7777ff, 1.0)
-    this.restoreVisibility()
+      this.beautyRenderTarget.dispose()
+      this.normalRenderTarget.dispose()
+      this.ssaoRenderTarget.dispose()
+      this.blurRenderTarget.dispose()
 
-    // render SSAO
+      // dispose materials
 
-    this.ssaoMaterial.uniforms['kernelRadius'].value = this.kernelRadius
-    this.ssaoMaterial.uniforms['minDistance'].value = this.minDistance
-    this.ssaoMaterial.uniforms['maxDistance'].value = this.maxDistance
-    this.renderPass(renderer, this.ssaoMaterial, this.ssaoRenderTarget)
+      this.normalMaterial.dispose()
+      this.blurMaterial.dispose()
+      this.copyMaterial.dispose()
+      this.depthRenderMaterial.dispose()
 
-    // render blur
+      // dipsose full screen quad
 
-    this.renderPass(renderer, this.blurMaterial, this.blurRenderTarget)
+      this.fsQuad.dispose()
+    }
 
-    // output result to screen
+    render(renderer, writeBuffer /*, readBuffer, deltaTime, maskActive */) {
+      if (renderer.capabilities.isWebGL2 === false) this.noiseTexture.format = LuminanceFormat
 
-    switch (this.output) {
-      case SSAOPass.OUTPUT.SSAO:
-        this.copyMaterial.uniforms['tDiffuse'].value = this.ssaoRenderTarget.texture
-        this.copyMaterial.blending = NoBlending
-        this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
+      // render beauty
 
-        break
+      renderer.setRenderTarget(this.beautyRenderTarget)
+      renderer.clear()
+      renderer.render(this.scene, this.camera)
 
-      case SSAOPass.OUTPUT.Blur:
-        this.copyMaterial.uniforms['tDiffuse'].value = this.blurRenderTarget.texture
-        this.copyMaterial.blending = NoBlending
-        this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
+      // render normals and depth (honor only meshes, points and lines do not contribute to SSAO)
 
-        break
+      this.overrideVisibility()
+      this.renderOverride(renderer, this.normalMaterial, this.normalRenderTarget, 0x7777ff, 1.0)
+      this.restoreVisibility()
 
-      case SSAOPass.OUTPUT.Beauty:
-        this.copyMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
-        this.copyMaterial.blending = NoBlending
-        this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
+      // render SSAO
 
-        break
+      this.ssaoMaterial.uniforms['kernelRadius'].value = this.kernelRadius
+      this.ssaoMaterial.uniforms['minDistance'].value = this.minDistance
+      this.ssaoMaterial.uniforms['maxDistance'].value = this.maxDistance
+      this.renderPass(renderer, this.ssaoMaterial, this.ssaoRenderTarget)
 
-      case SSAOPass.OUTPUT.Depth:
-        this.renderPass(renderer, this.depthRenderMaterial, this.renderToScreen ? null : writeBuffer)
+      // render blur
 
-        break
+      this.renderPass(renderer, this.blurMaterial, this.blurRenderTarget)
 
-      case SSAOPass.OUTPUT.Normal:
-        this.copyMaterial.uniforms['tDiffuse'].value = this.normalRenderTarget.texture
-        this.copyMaterial.blending = NoBlending
-        this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
+      // output result to screen
 
-        break
+      switch (this.output) {
+        case SSAOPass.OUTPUT.SSAO:
+          this.copyMaterial.uniforms['tDiffuse'].value = this.ssaoRenderTarget.texture
+          this.copyMaterial.blending = NoBlending
+          this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
 
-      case SSAOPass.OUTPUT.Default:
-        this.copyMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
-        this.copyMaterial.blending = NoBlending
-        this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
+          break
 
-        this.copyMaterial.uniforms['tDiffuse'].value = this.blurRenderTarget.texture
-        this.copyMaterial.blending = CustomBlending
-        this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
+        case SSAOPass.OUTPUT.Blur:
+          this.copyMaterial.uniforms['tDiffuse'].value = this.blurRenderTarget.texture
+          this.copyMaterial.blending = NoBlending
+          this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
 
-        break
+          break
 
-      default:
-        console.warn('THREE.SSAOPass: Unknown output type.')
-    }
-  }
+        case SSAOPass.OUTPUT.Beauty:
+          this.copyMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
+          this.copyMaterial.blending = NoBlending
+          this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
 
-  renderPass(renderer, passMaterial, renderTarget, clearColor, clearAlpha) {
-    // save original state
-    renderer.getClearColor(this.originalClearColor)
-    const originalClearAlpha = renderer.getClearAlpha()
-    const originalAutoClear = renderer.autoClear
+          break
 
-    renderer.setRenderTarget(renderTarget)
+        case SSAOPass.OUTPUT.Depth:
+          this.renderPass(renderer, this.depthRenderMaterial, this.renderToScreen ? null : writeBuffer)
 
-    // setup pass state
-    renderer.autoClear = false
-    if (clearColor !== undefined && clearColor !== null) {
-      renderer.setClearColor(clearColor)
-      renderer.setClearAlpha(clearAlpha || 0.0)
-      renderer.clear()
-    }
+          break
 
-    this.fsQuad.material = passMaterial
-    this.fsQuad.render(renderer)
+        case SSAOPass.OUTPUT.Normal:
+          this.copyMaterial.uniforms['tDiffuse'].value = this.normalRenderTarget.texture
+          this.copyMaterial.blending = NoBlending
+          this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
 
-    // restore original state
-    renderer.autoClear = originalAutoClear
-    renderer.setClearColor(this.originalClearColor)
-    renderer.setClearAlpha(originalClearAlpha)
-  }
+          break
 
-  renderOverride(renderer, overrideMaterial, renderTarget, clearColor, clearAlpha) {
-    renderer.getClearColor(this.originalClearColor)
-    const originalClearAlpha = renderer.getClearAlpha()
-    const originalAutoClear = renderer.autoClear
+        case SSAOPass.OUTPUT.Default:
+          this.copyMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
+          this.copyMaterial.blending = NoBlending
+          this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
 
-    renderer.setRenderTarget(renderTarget)
-    renderer.autoClear = false
+          this.copyMaterial.uniforms['tDiffuse'].value = this.blurRenderTarget.texture
+          this.copyMaterial.blending = CustomBlending
+          this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
 
-    clearColor = overrideMaterial.clearColor || clearColor
-    clearAlpha = overrideMaterial.clearAlpha || clearAlpha
+          break
 
-    if (clearColor !== undefined && clearColor !== null) {
-      renderer.setClearColor(clearColor)
-      renderer.setClearAlpha(clearAlpha || 0.0)
-      renderer.clear()
+        default:
+          console.warn('THREE.SSAOPass: Unknown output type.')
+      }
     }
 
-    this.scene.overrideMaterial = overrideMaterial
-    renderer.render(this.scene, this.camera)
-    this.scene.overrideMaterial = null
+    renderPass(renderer, passMaterial, renderTarget, clearColor, clearAlpha) {
+      // save original state
+      renderer.getClearColor(this.originalClearColor)
+      const originalClearAlpha = renderer.getClearAlpha()
+      const originalAutoClear = renderer.autoClear
+
+      renderer.setRenderTarget(renderTarget)
+
+      // setup pass state
+      renderer.autoClear = false
+      if (clearColor !== undefined && clearColor !== null) {
+        renderer.setClearColor(clearColor)
+        renderer.setClearAlpha(clearAlpha || 0.0)
+        renderer.clear()
+      }
+
+      this.fsQuad.material = passMaterial
+      this.fsQuad.render(renderer)
+
+      // restore original state
+      renderer.autoClear = originalAutoClear
+      renderer.setClearColor(this.originalClearColor)
+      renderer.setClearAlpha(originalClearAlpha)
+    }
 
-    // restore original state
+    renderOverride(renderer, overrideMaterial, renderTarget, clearColor, clearAlpha) {
+      renderer.getClearColor(this.originalClearColor)
+      const originalClearAlpha = renderer.getClearAlpha()
+      const originalAutoClear = renderer.autoClear
 
-    renderer.autoClear = originalAutoClear
-    renderer.setClearColor(this.originalClearColor)
-    renderer.setClearAlpha(originalClearAlpha)
-  }
+      renderer.setRenderTarget(renderTarget)
+      renderer.autoClear = false
 
-  setSize(width, height) {
-    this.width = width
-    this.height = height
+      clearColor = overrideMaterial.clearColor || clearColor
+      clearAlpha = overrideMaterial.clearAlpha || clearAlpha
 
-    this.beautyRenderTarget.setSize(width, height)
-    this.ssaoRenderTarget.setSize(width, height)
-    this.normalRenderTarget.setSize(width, height)
-    this.blurRenderTarget.setSize(width, height)
+      if (clearColor !== undefined && clearColor !== null) {
+        renderer.setClearColor(clearColor)
+        renderer.setClearAlpha(clearAlpha || 0.0)
+        renderer.clear()
+      }
 
-    this.ssaoMaterial.uniforms['resolution'].value.set(width, height)
-    this.ssaoMaterial.uniforms['cameraProjectionMatrix'].value.copy(this.camera.projectionMatrix)
-    this.ssaoMaterial.uniforms['cameraInverseProjectionMatrix'].value.copy(this.camera.projectionMatrixInverse)
+      this.scene.overrideMaterial = overrideMaterial
+      renderer.render(this.scene, this.camera)
+      this.scene.overrideMaterial = null
 
-    this.blurMaterial.uniforms['resolution'].value.set(width, height)
-  }
+      // restore original state
 
-  generateSampleKernel() {
-    const kernelSize = this.kernelSize
-    const kernel = this.kernel
+      renderer.autoClear = originalAutoClear
+      renderer.setClearColor(this.originalClearColor)
+      renderer.setClearAlpha(originalClearAlpha)
+    }
 
-    for (let i = 0; i < kernelSize; i++) {
-      const sample = new Vector3()
-      sample.x = Math.random() * 2 - 1
-      sample.y = Math.random() * 2 - 1
-      sample.z = Math.random()
+    setSize(width, height) {
+      this.width = width
+      this.height = height
 
-      sample.normalize()
+      this.beautyRenderTarget.setSize(width, height)
+      this.ssaoRenderTarget.setSize(width, height)
+      this.normalRenderTarget.setSize(width, height)
+      this.blurRenderTarget.setSize(width, height)
 
-      let scale = i / kernelSize
-      scale = MathUtils.lerp(0.1, 1, scale * scale)
-      sample.multiplyScalar(scale)
+      this.ssaoMaterial.uniforms['resolution'].value.set(width, height)
+      this.ssaoMaterial.uniforms['cameraProjectionMatrix'].value.copy(this.camera.projectionMatrix)
+      this.ssaoMaterial.uniforms['cameraInverseProjectionMatrix'].value.copy(this.camera.projectionMatrixInverse)
 
-      kernel.push(sample)
+      this.blurMaterial.uniforms['resolution'].value.set(width, height)
     }
-  }
 
-  generateRandomKernelRotations() {
-    const width = 4,
-      height = 4
+    generateSampleKernel() {
+      const kernelSize = this.kernelSize
+      const kernel = this.kernel
+
+      for (let i = 0; i < kernelSize; i++) {
+        const sample = new Vector3()
+        sample.x = Math.random() * 2 - 1
+        sample.y = Math.random() * 2 - 1
+        sample.z = Math.random()
 
-    if (SimplexNoise === undefined) {
-      console.error('THREE.SSAOPass: The pass relies on SimplexNoise.')
+        sample.normalize()
+
+        let scale = i / kernelSize
+        scale = MathUtils.lerp(0.1, 1, scale * scale)
+        sample.multiplyScalar(scale)
+
+        kernel.push(sample)
+      }
     }
 
-    const simplex = new SimplexNoise()
+    generateRandomKernelRotations() {
+      const width = 4,
+        height = 4
 
-    const size = width * height
-    const data = new Float32Array(size)
+      if (SimplexNoise === undefined) {
+        console.error('THREE.SSAOPass: The pass relies on SimplexNoise.')
+      }
 
-    for (let i = 0; i < size; i++) {
-      const x = Math.random() * 2 - 1
-      const y = Math.random() * 2 - 1
-      const z = 0
+      const simplex = new SimplexNoise()
 
-      data[i] = simplex.noise3d(x, y, z)
-    }
+      const size = width * height
+      const data = new Float32Array(size)
 
-    this.noiseTexture = new DataTexture(data, width, height, RedFormat, FloatType)
-    this.noiseTexture.wrapS = RepeatWrapping
-    this.noiseTexture.wrapT = RepeatWrapping
-    this.noiseTexture.needsUpdate = true
-  }
+      for (let i = 0; i < size; i++) {
+        const x = Math.random() * 2 - 1
+        const y = Math.random() * 2 - 1
+        const z = 0
 
-  overrideVisibility() {
-    const scene = this.scene
-    const cache = this._visibilityCache
+        data[i] = simplex.noise3d(x, y, z)
+      }
 
-    scene.traverse(function (object) {
-      cache.set(object, object.visible)
+      this.noiseTexture = new DataTexture(data, width, height, RedFormat, FloatType)
+      this.noiseTexture.wrapS = RepeatWrapping
+      this.noiseTexture.wrapT = RepeatWrapping
+      this.noiseTexture.needsUpdate = true
+    }
 
-      if (object.isPoints || object.isLine) object.visible = false
-    })
-  }
+    overrideVisibility() {
+      const scene = this.scene
+      const cache = this._visibilityCache
 
-  restoreVisibility() {
-    const scene = this.scene
-    const cache = this._visibilityCache
+      scene.traverse(function (object) {
+        cache.set(object, object.visible)
+
+        if (object.isPoints || object.isLine) object.visible = false
+      })
+    }
 
-    scene.traverse(function (object) {
-      const visible = cache.get(object)
-      object.visible = visible
-    })
+    restoreVisibility() {
+      const scene = this.scene
+      const cache = this._visibilityCache
 
-    cache.clear()
+      scene.traverse(function (object) {
+        const visible = cache.get(object)
+        object.visible = visible
+      })
+
+      cache.clear()
+    }
   }
-}
+
+  return SSAOPass
+})()
 
 export { SSAOPass }
diff --git a/src/postprocessing/SSRPass.js b/src/postprocessing/SSRPass.js
index c46038c5..b4e54852 100644
--- a/src/postprocessing/SSRPass.js
+++ b/src/postprocessing/SSRPass.js
@@ -21,530 +21,534 @@ import { SSRBlurShader } from '../shaders/SSRShader'
 import { SSRDepthShader } from '../shaders/SSRShader'
 import { CopyShader } from '../shaders/CopyShader'
 
-class SSRPass extends Pass {
-  static OUTPUT = {
-    Default: 0,
-    SSR: 1,
-    Beauty: 3,
-    Depth: 4,
-    Normal: 5,
-    Metalness: 7,
-  }
-  constructor({ renderer, scene, camera, width, height, selects, bouncing = false, groundReflector }) {
-    super()
-
-    this.width = width !== undefined ? width : 512
-    this.height = height !== undefined ? height : 512
-
-    this.clear = true
-
-    this.renderer = renderer
-    this.scene = scene
-    this.camera = camera
-    this.groundReflector = groundReflector
-
-    this.opacity = SSRShader.uniforms.opacity.value
-    this.output = 0
-
-    this.maxDistance = SSRShader.uniforms.maxDistance.value
-    this.thickness = SSRShader.uniforms.thickness.value
-
-    this.tempColor = new Color()
-
-    this._selects = selects
-    this.selective = Array.isArray(this._selects)
-    Object.defineProperty(this, 'selects', {
-      get() {
-        return this._selects
-      },
-      set(val) {
-        if (this._selects === val) return
-        this._selects = val
-        if (Array.isArray(val)) {
-          this.selective = true
-          this.ssrMaterial.defines.SELECTIVE = true
+const SSRPass = /* @__PURE__ */ (() => {
+  class SSRPass extends Pass {
+    static OUTPUT = {
+      Default: 0,
+      SSR: 1,
+      Beauty: 3,
+      Depth: 4,
+      Normal: 5,
+      Metalness: 7,
+    }
+    constructor({ renderer, scene, camera, width, height, selects, bouncing = false, groundReflector }) {
+      super()
+
+      this.width = width !== undefined ? width : 512
+      this.height = height !== undefined ? height : 512
+
+      this.clear = true
+
+      this.renderer = renderer
+      this.scene = scene
+      this.camera = camera
+      this.groundReflector = groundReflector
+
+      this.opacity = SSRShader.uniforms.opacity.value
+      this.output = 0
+
+      this.maxDistance = SSRShader.uniforms.maxDistance.value
+      this.thickness = SSRShader.uniforms.thickness.value
+
+      this.tempColor = new Color()
+
+      this._selects = selects
+      this.selective = Array.isArray(this._selects)
+      Object.defineProperty(this, 'selects', {
+        get() {
+          return this._selects
+        },
+        set(val) {
+          if (this._selects === val) return
+          this._selects = val
+          if (Array.isArray(val)) {
+            this.selective = true
+            this.ssrMaterial.defines.SELECTIVE = true
+            this.ssrMaterial.needsUpdate = true
+          } else {
+            this.selective = false
+            this.ssrMaterial.defines.SELECTIVE = false
+            this.ssrMaterial.needsUpdate = true
+          }
+        },
+      })
+
+      this._bouncing = bouncing
+      Object.defineProperty(this, 'bouncing', {
+        get() {
+          return this._bouncing
+        },
+        set(val) {
+          if (this._bouncing === val) return
+          this._bouncing = val
+          if (val) {
+            this.ssrMaterial.uniforms['tDiffuse'].value = this.prevRenderTarget.texture
+          } else {
+            this.ssrMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
+          }
+        },
+      })
+
+      this.blur = true
+
+      this._distanceAttenuation = SSRShader.defines.DISTANCE_ATTENUATION
+      Object.defineProperty(this, 'distanceAttenuation', {
+        get() {
+          return this._distanceAttenuation
+        },
+        set(val) {
+          if (this._distanceAttenuation === val) return
+          this._distanceAttenuation = val
+          this.ssrMaterial.defines.DISTANCE_ATTENUATION = val
           this.ssrMaterial.needsUpdate = true
-        } else {
-          this.selective = false
-          this.ssrMaterial.defines.SELECTIVE = false
+        },
+      })
+
+      this._fresnel = SSRShader.defines.FRESNEL
+      Object.defineProperty(this, 'fresnel', {
+        get() {
+          return this._fresnel
+        },
+        set(val) {
+          if (this._fresnel === val) return
+          this._fresnel = val
+          this.ssrMaterial.defines.FRESNEL = val
           this.ssrMaterial.needsUpdate = true
-        }
-      },
-    })
-
-    this._bouncing = bouncing
-    Object.defineProperty(this, 'bouncing', {
-      get() {
-        return this._bouncing
-      },
-      set(val) {
-        if (this._bouncing === val) return
-        this._bouncing = val
-        if (val) {
-          this.ssrMaterial.uniforms['tDiffuse'].value = this.prevRenderTarget.texture
-        } else {
-          this.ssrMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
-        }
-      },
-    })
-
-    this.blur = true
-
-    this._distanceAttenuation = SSRShader.defines.DISTANCE_ATTENUATION
-    Object.defineProperty(this, 'distanceAttenuation', {
-      get() {
-        return this._distanceAttenuation
-      },
-      set(val) {
-        if (this._distanceAttenuation === val) return
-        this._distanceAttenuation = val
-        this.ssrMaterial.defines.DISTANCE_ATTENUATION = val
-        this.ssrMaterial.needsUpdate = true
-      },
-    })
-
-    this._fresnel = SSRShader.defines.FRESNEL
-    Object.defineProperty(this, 'fresnel', {
-      get() {
-        return this._fresnel
-      },
-      set(val) {
-        if (this._fresnel === val) return
-        this._fresnel = val
-        this.ssrMaterial.defines.FRESNEL = val
-        this.ssrMaterial.needsUpdate = true
-      },
-    })
-
-    this._infiniteThick = SSRShader.defines.INFINITE_THICK
-    Object.defineProperty(this, 'infiniteThick', {
-      get() {
-        return this._infiniteThick
-      },
-      set(val) {
-        if (this._infiniteThick === val) return
-        this._infiniteThick = val
-        this.ssrMaterial.defines.INFINITE_THICK = val
-        this.ssrMaterial.needsUpdate = true
-      },
-    })
-
-    // beauty render target with depth buffer
-
-    const depthTexture = new DepthTexture()
-    depthTexture.type = UnsignedShortType
-    depthTexture.minFilter = NearestFilter
-    depthTexture.magFilter = NearestFilter
-
-    this.beautyRenderTarget = new WebGLRenderTarget(this.width, this.height, {
-      minFilter: NearestFilter,
-      magFilter: NearestFilter,
-      type: HalfFloatType,
-      depthTexture: depthTexture,
-      depthBuffer: true,
-    })
-
-    //for bouncing
-    this.prevRenderTarget = new WebGLRenderTarget(this.width, this.height, {
-      minFilter: NearestFilter,
-      magFilter: NearestFilter,
-    })
-
-    // normal render target
-
-    this.normalRenderTarget = new WebGLRenderTarget(this.width, this.height, {
-      minFilter: NearestFilter,
-      magFilter: NearestFilter,
-      type: HalfFloatType,
-    })
-
-    // metalness render target
-
-    this.metalnessRenderTarget = new WebGLRenderTarget(this.width, this.height, {
-      minFilter: NearestFilter,
-      magFilter: NearestFilter,
-      type: HalfFloatType,
-    })
-
-    // ssr render target
-
-    this.ssrRenderTarget = new WebGLRenderTarget(this.width, this.height, {
-      minFilter: NearestFilter,
-      magFilter: NearestFilter,
-    })
-
-    this.blurRenderTarget = this.ssrRenderTarget.clone()
-    this.blurRenderTarget2 = this.ssrRenderTarget.clone()
-    // this.blurRenderTarget3 = this.ssrRenderTarget.clone();
-
-    // ssr material
-
-    this.ssrMaterial = new ShaderMaterial({
-      defines: Object.assign({}, SSRShader.defines, {
-        MAX_STEP: Math.sqrt(this.width * this.width + this.height * this.height),
-      }),
-      uniforms: UniformsUtils.clone(SSRShader.uniforms),
-      vertexShader: SSRShader.vertexShader,
-      fragmentShader: SSRShader.fragmentShader,
-      blending: NoBlending,
-    })
-
-    this.ssrMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
-    this.ssrMaterial.uniforms['tNormal'].value = this.normalRenderTarget.texture
-    this.ssrMaterial.defines.SELECTIVE = this.selective
-    this.ssrMaterial.needsUpdate = true
-    this.ssrMaterial.uniforms['tMetalness'].value = this.metalnessRenderTarget.texture
-    this.ssrMaterial.uniforms['tDepth'].value = this.beautyRenderTarget.depthTexture
-    this.ssrMaterial.uniforms['cameraNear'].value = this.camera.near
-    this.ssrMaterial.uniforms['cameraFar'].value = this.camera.far
-    this.ssrMaterial.uniforms['thickness'].value = this.thickness
-    this.ssrMaterial.uniforms['resolution'].value.set(this.width, this.height)
-    this.ssrMaterial.uniforms['cameraProjectionMatrix'].value.copy(this.camera.projectionMatrix)
-    this.ssrMaterial.uniforms['cameraInverseProjectionMatrix'].value.copy(this.camera.projectionMatrixInverse)
-
-    // normal material
-
-    this.normalMaterial = new MeshNormalMaterial()
-    this.normalMaterial.blending = NoBlending
-
-    // metalnessOn material
-
-    this.metalnessOnMaterial = new MeshBasicMaterial({
-      color: 'white',
-    })
-
-    // metalnessOff material
-
-    this.metalnessOffMaterial = new MeshBasicMaterial({
-      color: 'black',
-    })
-
-    // blur material
-
-    this.blurMaterial = new ShaderMaterial({
-      defines: Object.assign({}, SSRBlurShader.defines),
-      uniforms: UniformsUtils.clone(SSRBlurShader.uniforms),
-      vertexShader: SSRBlurShader.vertexShader,
-      fragmentShader: SSRBlurShader.fragmentShader,
-    })
-    this.blurMaterial.uniforms['tDiffuse'].value = this.ssrRenderTarget.texture
-    this.blurMaterial.uniforms['resolution'].value.set(this.width, this.height)
-
-    // blur material 2
-
-    this.blurMaterial2 = new ShaderMaterial({
-      defines: Object.assign({}, SSRBlurShader.defines),
-      uniforms: UniformsUtils.clone(SSRBlurShader.uniforms),
-      vertexShader: SSRBlurShader.vertexShader,
-      fragmentShader: SSRBlurShader.fragmentShader,
-    })
-    this.blurMaterial2.uniforms['tDiffuse'].value = this.blurRenderTarget.texture
-    this.blurMaterial2.uniforms['resolution'].value.set(this.width, this.height)
-
-    // // blur material 3
-
-    // this.blurMaterial3 = new ShaderMaterial({
-    //   defines: Object.assign({}, SSRBlurShader.defines),
-    //   uniforms: UniformsUtils.clone(SSRBlurShader.uniforms),
-    //   vertexShader: SSRBlurShader.vertexShader,
-    //   fragmentShader: SSRBlurShader.fragmentShader
-    // });
-    // this.blurMaterial3.uniforms['tDiffuse'].value = this.blurRenderTarget2.texture;
-    // this.blurMaterial3.uniforms['resolution'].value.set(this.width, this.height);
-
-    // material for rendering the depth
-
-    this.depthRenderMaterial = new ShaderMaterial({
-      defines: Object.assign({}, SSRDepthShader.defines),
-      uniforms: UniformsUtils.clone(SSRDepthShader.uniforms),
-      vertexShader: SSRDepthShader.vertexShader,
-      fragmentShader: SSRDepthShader.fragmentShader,
-      blending: NoBlending,
-    })
-    this.depthRenderMaterial.uniforms['tDepth'].value = this.beautyRenderTarget.depthTexture
-    this.depthRenderMaterial.uniforms['cameraNear'].value = this.camera.near
-    this.depthRenderMaterial.uniforms['cameraFar'].value = this.camera.far
-
-    // material for rendering the content of a render target
-
-    this.copyMaterial = new ShaderMaterial({
-      uniforms: UniformsUtils.clone(CopyShader.uniforms),
-      vertexShader: CopyShader.vertexShader,
-      fragmentShader: CopyShader.fragmentShader,
-      transparent: true,
-      depthTest: false,
-      depthWrite: false,
-      blendSrc: SrcAlphaFactor,
-      blendDst: OneMinusSrcAlphaFactor,
-      blendEquation: AddEquation,
-      blendSrcAlpha: SrcAlphaFactor,
-      blendDstAlpha: OneMinusSrcAlphaFactor,
-      blendEquationAlpha: AddEquation,
-      // premultipliedAlpha:true,
-    })
-
-    this.fsQuad = new FullScreenQuad(null)
-
-    this.originalClearColor = new Color()
-  }
-
-  dispose() {
-    // dispose render targets
-
-    this.beautyRenderTarget.dispose()
-    this.prevRenderTarget.dispose()
-    this.normalRenderTarget.dispose()
-    this.metalnessRenderTarget.dispose()
-    this.ssrRenderTarget.dispose()
-    this.blurRenderTarget.dispose()
-    this.blurRenderTarget2.dispose()
-    // this.blurRenderTarget3.dispose();
+        },
+      })
+
+      this._infiniteThick = SSRShader.defines.INFINITE_THICK
+      Object.defineProperty(this, 'infiniteThick', {
+        get() {
+          return this._infiniteThick
+        },
+        set(val) {
+          if (this._infiniteThick === val) return
+          this._infiniteThick = val
+          this.ssrMaterial.defines.INFINITE_THICK = val
+          this.ssrMaterial.needsUpdate = true
+        },
+      })
+
+      // beauty render target with depth buffer
+
+      const depthTexture = new DepthTexture()
+      depthTexture.type = UnsignedShortType
+      depthTexture.minFilter = NearestFilter
+      depthTexture.magFilter = NearestFilter
+
+      this.beautyRenderTarget = new WebGLRenderTarget(this.width, this.height, {
+        minFilter: NearestFilter,
+        magFilter: NearestFilter,
+        type: HalfFloatType,
+        depthTexture: depthTexture,
+        depthBuffer: true,
+      })
+
+      //for bouncing
+      this.prevRenderTarget = new WebGLRenderTarget(this.width, this.height, {
+        minFilter: NearestFilter,
+        magFilter: NearestFilter,
+      })
+
+      // normal render target
+
+      this.normalRenderTarget = new WebGLRenderTarget(this.width, this.height, {
+        minFilter: NearestFilter,
+        magFilter: NearestFilter,
+        type: HalfFloatType,
+      })
+
+      // metalness render target
+
+      this.metalnessRenderTarget = new WebGLRenderTarget(this.width, this.height, {
+        minFilter: NearestFilter,
+        magFilter: NearestFilter,
+        type: HalfFloatType,
+      })
+
+      // ssr render target
+
+      this.ssrRenderTarget = new WebGLRenderTarget(this.width, this.height, {
+        minFilter: NearestFilter,
+        magFilter: NearestFilter,
+      })
+
+      this.blurRenderTarget = this.ssrRenderTarget.clone()
+      this.blurRenderTarget2 = this.ssrRenderTarget.clone()
+      // this.blurRenderTarget3 = this.ssrRenderTarget.clone();
+
+      // ssr material
+
+      this.ssrMaterial = new ShaderMaterial({
+        defines: Object.assign({}, SSRShader.defines, {
+          MAX_STEP: Math.sqrt(this.width * this.width + this.height * this.height),
+        }),
+        uniforms: UniformsUtils.clone(SSRShader.uniforms),
+        vertexShader: SSRShader.vertexShader,
+        fragmentShader: SSRShader.fragmentShader,
+        blending: NoBlending,
+      })
+
+      this.ssrMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
+      this.ssrMaterial.uniforms['tNormal'].value = this.normalRenderTarget.texture
+      this.ssrMaterial.defines.SELECTIVE = this.selective
+      this.ssrMaterial.needsUpdate = true
+      this.ssrMaterial.uniforms['tMetalness'].value = this.metalnessRenderTarget.texture
+      this.ssrMaterial.uniforms['tDepth'].value = this.beautyRenderTarget.depthTexture
+      this.ssrMaterial.uniforms['cameraNear'].value = this.camera.near
+      this.ssrMaterial.uniforms['cameraFar'].value = this.camera.far
+      this.ssrMaterial.uniforms['thickness'].value = this.thickness
+      this.ssrMaterial.uniforms['resolution'].value.set(this.width, this.height)
+      this.ssrMaterial.uniforms['cameraProjectionMatrix'].value.copy(this.camera.projectionMatrix)
+      this.ssrMaterial.uniforms['cameraInverseProjectionMatrix'].value.copy(this.camera.projectionMatrixInverse)
+
+      // normal material
+
+      this.normalMaterial = new MeshNormalMaterial()
+      this.normalMaterial.blending = NoBlending
+
+      // metalnessOn material
+
+      this.metalnessOnMaterial = new MeshBasicMaterial({
+        color: 'white',
+      })
+
+      // metalnessOff material
+
+      this.metalnessOffMaterial = new MeshBasicMaterial({
+        color: 'black',
+      })
+
+      // blur material
+
+      this.blurMaterial = new ShaderMaterial({
+        defines: Object.assign({}, SSRBlurShader.defines),
+        uniforms: UniformsUtils.clone(SSRBlurShader.uniforms),
+        vertexShader: SSRBlurShader.vertexShader,
+        fragmentShader: SSRBlurShader.fragmentShader,
+      })
+      this.blurMaterial.uniforms['tDiffuse'].value = this.ssrRenderTarget.texture
+      this.blurMaterial.uniforms['resolution'].value.set(this.width, this.height)
+
+      // blur material 2
+
+      this.blurMaterial2 = new ShaderMaterial({
+        defines: Object.assign({}, SSRBlurShader.defines),
+        uniforms: UniformsUtils.clone(SSRBlurShader.uniforms),
+        vertexShader: SSRBlurShader.vertexShader,
+        fragmentShader: SSRBlurShader.fragmentShader,
+      })
+      this.blurMaterial2.uniforms['tDiffuse'].value = this.blurRenderTarget.texture
+      this.blurMaterial2.uniforms['resolution'].value.set(this.width, this.height)
+
+      // // blur material 3
+
+      // this.blurMaterial3 = new ShaderMaterial({
+      //   defines: Object.assign({}, SSRBlurShader.defines),
+      //   uniforms: UniformsUtils.clone(SSRBlurShader.uniforms),
+      //   vertexShader: SSRBlurShader.vertexShader,
+      //   fragmentShader: SSRBlurShader.fragmentShader
+      // });
+      // this.blurMaterial3.uniforms['tDiffuse'].value = this.blurRenderTarget2.texture;
+      // this.blurMaterial3.uniforms['resolution'].value.set(this.width, this.height);
+
+      // material for rendering the depth
+
+      this.depthRenderMaterial = new ShaderMaterial({
+        defines: Object.assign({}, SSRDepthShader.defines),
+        uniforms: UniformsUtils.clone(SSRDepthShader.uniforms),
+        vertexShader: SSRDepthShader.vertexShader,
+        fragmentShader: SSRDepthShader.fragmentShader,
+        blending: NoBlending,
+      })
+      this.depthRenderMaterial.uniforms['tDepth'].value = this.beautyRenderTarget.depthTexture
+      this.depthRenderMaterial.uniforms['cameraNear'].value = this.camera.near
+      this.depthRenderMaterial.uniforms['cameraFar'].value = this.camera.far
+
+      // material for rendering the content of a render target
+
+      this.copyMaterial = new ShaderMaterial({
+        uniforms: UniformsUtils.clone(CopyShader.uniforms),
+        vertexShader: CopyShader.vertexShader,
+        fragmentShader: CopyShader.fragmentShader,
+        transparent: true,
+        depthTest: false,
+        depthWrite: false,
+        blendSrc: SrcAlphaFactor,
+        blendDst: OneMinusSrcAlphaFactor,
+        blendEquation: AddEquation,
+        blendSrcAlpha: SrcAlphaFactor,
+        blendDstAlpha: OneMinusSrcAlphaFactor,
+        blendEquationAlpha: AddEquation,
+        // premultipliedAlpha:true,
+      })
+
+      this.fsQuad = new FullScreenQuad(null)
+
+      this.originalClearColor = new Color()
+    }
 
-    // dispose materials
+    dispose() {
+      // dispose render targets
 
-    this.normalMaterial.dispose()
-    this.metalnessOnMaterial.dispose()
-    this.metalnessOffMaterial.dispose()
-    this.blurMaterial.dispose()
-    this.blurMaterial2.dispose()
-    this.copyMaterial.dispose()
-    this.depthRenderMaterial.dispose()
+      this.beautyRenderTarget.dispose()
+      this.prevRenderTarget.dispose()
+      this.normalRenderTarget.dispose()
+      this.metalnessRenderTarget.dispose()
+      this.ssrRenderTarget.dispose()
+      this.blurRenderTarget.dispose()
+      this.blurRenderTarget2.dispose()
+      // this.blurRenderTarget3.dispose();
 
-    // dipsose full screen quad
+      // dispose materials
 
-    this.fsQuad.dispose()
-  }
+      this.normalMaterial.dispose()
+      this.metalnessOnMaterial.dispose()
+      this.metalnessOffMaterial.dispose()
+      this.blurMaterial.dispose()
+      this.blurMaterial2.dispose()
+      this.copyMaterial.dispose()
+      this.depthRenderMaterial.dispose()
 
-  render(renderer, writeBuffer /*, readBuffer, deltaTime, maskActive */) {
-    // render beauty and depth
+      // dipsose full screen quad
 
-    renderer.setRenderTarget(this.beautyRenderTarget)
-    renderer.clear()
-    if (this.groundReflector) {
-      this.groundReflector.visible = false
-      this.groundReflector.doRender(this.renderer, this.scene, this.camera)
-      this.groundReflector.visible = true
+      this.fsQuad.dispose()
     }
 
-    renderer.render(this.scene, this.camera)
-    if (this.groundReflector) this.groundReflector.visible = false
+    render(renderer, writeBuffer /*, readBuffer, deltaTime, maskActive */) {
+      // render beauty and depth
 
-    // render normals
+      renderer.setRenderTarget(this.beautyRenderTarget)
+      renderer.clear()
+      if (this.groundReflector) {
+        this.groundReflector.visible = false
+        this.groundReflector.doRender(this.renderer, this.scene, this.camera)
+        this.groundReflector.visible = true
+      }
 
-    this.renderOverride(renderer, this.normalMaterial, this.normalRenderTarget, 0, 0)
+      renderer.render(this.scene, this.camera)
+      if (this.groundReflector) this.groundReflector.visible = false
 
-    // render metalnesses
+      // render normals
 
-    if (this.selective) {
-      this.renderMetalness(renderer, this.metalnessOnMaterial, this.metalnessRenderTarget, 0, 0)
-    }
+      this.renderOverride(renderer, this.normalMaterial, this.normalRenderTarget, 0, 0)
 
-    // render SSR
+      // render metalnesses
 
-    this.ssrMaterial.uniforms['opacity'].value = this.opacity
-    this.ssrMaterial.uniforms['maxDistance'].value = this.maxDistance
-    this.ssrMaterial.uniforms['thickness'].value = this.thickness
-    this.renderPass(renderer, this.ssrMaterial, this.ssrRenderTarget)
+      if (this.selective) {
+        this.renderMetalness(renderer, this.metalnessOnMaterial, this.metalnessRenderTarget, 0, 0)
+      }
 
-    // render blur
+      // render SSR
 
-    if (this.blur) {
-      this.renderPass(renderer, this.blurMaterial, this.blurRenderTarget)
-      this.renderPass(renderer, this.blurMaterial2, this.blurRenderTarget2)
-      // this.renderPass(renderer, this.blurMaterial3, this.blurRenderTarget3);
-    }
+      this.ssrMaterial.uniforms['opacity'].value = this.opacity
+      this.ssrMaterial.uniforms['maxDistance'].value = this.maxDistance
+      this.ssrMaterial.uniforms['thickness'].value = this.thickness
+      this.renderPass(renderer, this.ssrMaterial, this.ssrRenderTarget)
 
-    // output result to screen
+      // render blur
 
-    switch (this.output) {
-      case SSRPass.OUTPUT.Default:
-        if (this.bouncing) {
-          this.copyMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
-          this.copyMaterial.blending = NoBlending
-          this.renderPass(renderer, this.copyMaterial, this.prevRenderTarget)
+      if (this.blur) {
+        this.renderPass(renderer, this.blurMaterial, this.blurRenderTarget)
+        this.renderPass(renderer, this.blurMaterial2, this.blurRenderTarget2)
+        // this.renderPass(renderer, this.blurMaterial3, this.blurRenderTarget3);
+      }
 
+      // output result to screen
+
+      switch (this.output) {
+        case SSRPass.OUTPUT.Default:
+          if (this.bouncing) {
+            this.copyMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
+            this.copyMaterial.blending = NoBlending
+            this.renderPass(renderer, this.copyMaterial, this.prevRenderTarget)
+
+            if (this.blur) this.copyMaterial.uniforms['tDiffuse'].value = this.blurRenderTarget2.texture
+            else this.copyMaterial.uniforms['tDiffuse'].value = this.ssrRenderTarget.texture
+            this.copyMaterial.blending = NormalBlending
+            this.renderPass(renderer, this.copyMaterial, this.prevRenderTarget)
+
+            this.copyMaterial.uniforms['tDiffuse'].value = this.prevRenderTarget.texture
+            this.copyMaterial.blending = NoBlending
+            this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
+          } else {
+            this.copyMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
+            this.copyMaterial.blending = NoBlending
+            this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
+
+            if (this.blur) this.copyMaterial.uniforms['tDiffuse'].value = this.blurRenderTarget2.texture
+            else this.copyMaterial.uniforms['tDiffuse'].value = this.ssrRenderTarget.texture
+            this.copyMaterial.blending = NormalBlending
+            this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
+          }
+
+          break
+        case SSRPass.OUTPUT.SSR:
           if (this.blur) this.copyMaterial.uniforms['tDiffuse'].value = this.blurRenderTarget2.texture
           else this.copyMaterial.uniforms['tDiffuse'].value = this.ssrRenderTarget.texture
-          this.copyMaterial.blending = NormalBlending
-          this.renderPass(renderer, this.copyMaterial, this.prevRenderTarget)
-
-          this.copyMaterial.uniforms['tDiffuse'].value = this.prevRenderTarget.texture
-          this.copyMaterial.blending = NoBlending
-          this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
-        } else {
-          this.copyMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
           this.copyMaterial.blending = NoBlending
           this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
 
-          if (this.blur) this.copyMaterial.uniforms['tDiffuse'].value = this.blurRenderTarget2.texture
-          else this.copyMaterial.uniforms['tDiffuse'].value = this.ssrRenderTarget.texture
-          this.copyMaterial.blending = NormalBlending
-          this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
-        }
+          if (this.bouncing) {
+            if (this.blur) this.copyMaterial.uniforms['tDiffuse'].value = this.blurRenderTarget2.texture
+            else this.copyMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
+            this.copyMaterial.blending = NoBlending
+            this.renderPass(renderer, this.copyMaterial, this.prevRenderTarget)
 
-        break
-      case SSRPass.OUTPUT.SSR:
-        if (this.blur) this.copyMaterial.uniforms['tDiffuse'].value = this.blurRenderTarget2.texture
-        else this.copyMaterial.uniforms['tDiffuse'].value = this.ssrRenderTarget.texture
-        this.copyMaterial.blending = NoBlending
-        this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
+            this.copyMaterial.uniforms['tDiffuse'].value = this.ssrRenderTarget.texture
+            this.copyMaterial.blending = NormalBlending
+            this.renderPass(renderer, this.copyMaterial, this.prevRenderTarget)
+          }
 
-        if (this.bouncing) {
-          if (this.blur) this.copyMaterial.uniforms['tDiffuse'].value = this.blurRenderTarget2.texture
-          else this.copyMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
-          this.copyMaterial.blending = NoBlending
-          this.renderPass(renderer, this.copyMaterial, this.prevRenderTarget)
+          break
 
-          this.copyMaterial.uniforms['tDiffuse'].value = this.ssrRenderTarget.texture
-          this.copyMaterial.blending = NormalBlending
-          this.renderPass(renderer, this.copyMaterial, this.prevRenderTarget)
-        }
+        case SSRPass.OUTPUT.Beauty:
+          this.copyMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
+          this.copyMaterial.blending = NoBlending
+          this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
 
-        break
+          break
 
-      case SSRPass.OUTPUT.Beauty:
-        this.copyMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture
-        this.copyMaterial.blending = NoBlending
-        this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
+        case SSRPass.OUTPUT.Depth:
+          this.renderPass(renderer, this.depthRenderMaterial, this.renderToScreen ? null : writeBuffer)
 
-        break
+          break
 
-      case SSRPass.OUTPUT.Depth:
-        this.renderPass(renderer, this.depthRenderMaterial, this.renderToScreen ? null : writeBuffer)
+        case SSRPass.OUTPUT.Normal:
+          this.copyMaterial.uniforms['tDiffuse'].value = this.normalRenderTarget.texture
+          this.copyMaterial.blending = NoBlending
+          this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
 
-        break
+          break
 
-      case SSRPass.OUTPUT.Normal:
-        this.copyMaterial.uniforms['tDiffuse'].value = this.normalRenderTarget.texture
-        this.copyMaterial.blending = NoBlending
-        this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
+        case SSRPass.OUTPUT.Metalness:
+          this.copyMaterial.uniforms['tDiffuse'].value = this.metalnessRenderTarget.texture
+          this.copyMaterial.blending = NoBlending
+          this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
 
-        break
+          break
 
-      case SSRPass.OUTPUT.Metalness:
-        this.copyMaterial.uniforms['tDiffuse'].value = this.metalnessRenderTarget.texture
-        this.copyMaterial.blending = NoBlending
-        this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer)
+        default:
+          console.warn('THREE.SSRPass: Unknown output type.')
+      }
+    }
 
-        break
+    renderPass(renderer, passMaterial, renderTarget, clearColor, clearAlpha) {
+      // save original state
+      this.originalClearColor.copy(renderer.getClearColor(this.tempColor))
+      const originalClearAlpha = renderer.getClearAlpha(this.tempColor)
+      const originalAutoClear = renderer.autoClear
 
-      default:
-        console.warn('THREE.SSRPass: Unknown output type.')
-    }
-  }
+      renderer.setRenderTarget(renderTarget)
 
-  renderPass(renderer, passMaterial, renderTarget, clearColor, clearAlpha) {
-    // save original state
-    this.originalClearColor.copy(renderer.getClearColor(this.tempColor))
-    const originalClearAlpha = renderer.getClearAlpha(this.tempColor)
-    const originalAutoClear = renderer.autoClear
+      // setup pass state
+      renderer.autoClear = false
+      if (clearColor !== undefined && clearColor !== null) {
+        renderer.setClearColor(clearColor)
+        renderer.setClearAlpha(clearAlpha || 0.0)
+        renderer.clear()
+      }
 
-    renderer.setRenderTarget(renderTarget)
+      this.fsQuad.material = passMaterial
+      this.fsQuad.render(renderer)
 
-    // setup pass state
-    renderer.autoClear = false
-    if (clearColor !== undefined && clearColor !== null) {
-      renderer.setClearColor(clearColor)
-      renderer.setClearAlpha(clearAlpha || 0.0)
-      renderer.clear()
+      // restore original state
+      renderer.autoClear = originalAutoClear
+      renderer.setClearColor(this.originalClearColor)
+      renderer.setClearAlpha(originalClearAlpha)
     }
 
-    this.fsQuad.material = passMaterial
-    this.fsQuad.render(renderer)
+    renderOverride(renderer, overrideMaterial, renderTarget, clearColor, clearAlpha) {
+      this.originalClearColor.copy(renderer.getClearColor(this.tempColor))
+      const originalClearAlpha = renderer.getClearAlpha(this.tempColor)
+      const originalAutoClear = renderer.autoClear
 
-    // restore original state
-    renderer.autoClear = originalAutoClear
-    renderer.setClearColor(this.originalClearColor)
-    renderer.setClearAlpha(originalClearAlpha)
-  }
+      renderer.setRenderTarget(renderTarget)
+      renderer.autoClear = false
+
+      clearColor = overrideMaterial.clearColor || clearColor
+      clearAlpha = overrideMaterial.clearAlpha || clearAlpha
 
-  renderOverride(renderer, overrideMaterial, renderTarget, clearColor, clearAlpha) {
-    this.originalClearColor.copy(renderer.getClearColor(this.tempColor))
-    const originalClearAlpha = renderer.getClearAlpha(this.tempColor)
-    const originalAutoClear = renderer.autoClear
+      if (clearColor !== undefined && clearColor !== null) {
+        renderer.setClearColor(clearColor)
+        renderer.setClearAlpha(clearAlpha || 0.0)
+        renderer.clear()
+      }
 
-    renderer.setRenderTarget(renderTarget)
-    renderer.autoClear = false
+      this.scene.overrideMaterial = overrideMaterial
+      renderer.render(this.scene, this.camera)
+      this.scene.overrideMaterial = null
 
-    clearColor = overrideMaterial.clearColor || clearColor
-    clearAlpha = overrideMaterial.clearAlpha || clearAlpha
+      // restore original state
 
-    if (clearColor !== undefined && clearColor !== null) {
-      renderer.setClearColor(clearColor)
-      renderer.setClearAlpha(clearAlpha || 0.0)
-      renderer.clear()
+      renderer.autoClear = originalAutoClear
+      renderer.setClearColor(this.originalClearColor)
+      renderer.setClearAlpha(originalClearAlpha)
     }
 
-    this.scene.overrideMaterial = overrideMaterial
-    renderer.render(this.scene, this.camera)
-    this.scene.overrideMaterial = null
+    renderMetalness(renderer, overrideMaterial, renderTarget, clearColor, clearAlpha) {
+      this.originalClearColor.copy(renderer.getClearColor(this.tempColor))
+      const originalClearAlpha = renderer.getClearAlpha(this.tempColor)
+      const originalAutoClear = renderer.autoClear
 
-    // restore original state
+      renderer.setRenderTarget(renderTarget)
+      renderer.autoClear = false
 
-    renderer.autoClear = originalAutoClear
-    renderer.setClearColor(this.originalClearColor)
-    renderer.setClearAlpha(originalClearAlpha)
-  }
+      clearColor = overrideMaterial.clearColor || clearColor
+      clearAlpha = overrideMaterial.clearAlpha || clearAlpha
 
-  renderMetalness(renderer, overrideMaterial, renderTarget, clearColor, clearAlpha) {
-    this.originalClearColor.copy(renderer.getClearColor(this.tempColor))
-    const originalClearAlpha = renderer.getClearAlpha(this.tempColor)
-    const originalAutoClear = renderer.autoClear
+      if (clearColor !== undefined && clearColor !== null) {
+        renderer.setClearColor(clearColor)
+        renderer.setClearAlpha(clearAlpha || 0.0)
+        renderer.clear()
+      }
 
-    renderer.setRenderTarget(renderTarget)
-    renderer.autoClear = false
+      this.scene.traverseVisible((child) => {
+        child._SSRPassBackupMaterial = child.material
+        if (this._selects.includes(child)) {
+          child.material = this.metalnessOnMaterial
+        } else {
+          child.material = this.metalnessOffMaterial
+        }
+      })
+      renderer.render(this.scene, this.camera)
+      this.scene.traverseVisible((child) => {
+        child.material = child._SSRPassBackupMaterial
+      })
 
-    clearColor = overrideMaterial.clearColor || clearColor
-    clearAlpha = overrideMaterial.clearAlpha || clearAlpha
+      // restore original state
 
-    if (clearColor !== undefined && clearColor !== null) {
-      renderer.setClearColor(clearColor)
-      renderer.setClearAlpha(clearAlpha || 0.0)
-      renderer.clear()
+      renderer.autoClear = originalAutoClear
+      renderer.setClearColor(this.originalClearColor)
+      renderer.setClearAlpha(originalClearAlpha)
     }
 
-    this.scene.traverseVisible((child) => {
-      child._SSRPassBackupMaterial = child.material
-      if (this._selects.includes(child)) {
-        child.material = this.metalnessOnMaterial
-      } else {
-        child.material = this.metalnessOffMaterial
-      }
-    })
-    renderer.render(this.scene, this.camera)
-    this.scene.traverseVisible((child) => {
-      child.material = child._SSRPassBackupMaterial
-    })
-
-    // restore original state
-
-    renderer.autoClear = originalAutoClear
-    renderer.setClearColor(this.originalClearColor)
-    renderer.setClearAlpha(originalClearAlpha)
+    setSize(width, height) {
+      this.width = width
+      this.height = height
+
+      this.ssrMaterial.defines.MAX_STEP = Math.sqrt(width * width + height * height)
+      this.ssrMaterial.needsUpdate = true
+      this.beautyRenderTarget.setSize(width, height)
+      this.prevRenderTarget.setSize(width, height)
+      this.ssrRenderTarget.setSize(width, height)
+      this.normalRenderTarget.setSize(width, height)
+      this.metalnessRenderTarget.setSize(width, height)
+      this.blurRenderTarget.setSize(width, height)
+      this.blurRenderTarget2.setSize(width, height)
+      // this.blurRenderTarget3.setSize(width, height);
+
+      this.ssrMaterial.uniforms['resolution'].value.set(width, height)
+      this.ssrMaterial.uniforms['cameraProjectionMatrix'].value.copy(this.camera.projectionMatrix)
+      this.ssrMaterial.uniforms['cameraInverseProjectionMatrix'].value.copy(this.camera.projectionMatrixInverse)
+
+      this.blurMaterial.uniforms['resolution'].value.set(width, height)
+      this.blurMaterial2.uniforms['resolution'].value.set(width, height)
+    }
   }
 
-  setSize(width, height) {
-    this.width = width
-    this.height = height
-
-    this.ssrMaterial.defines.MAX_STEP = Math.sqrt(width * width + height * height)
-    this.ssrMaterial.needsUpdate = true
-    this.beautyRenderTarget.setSize(width, height)
-    this.prevRenderTarget.setSize(width, height)
-    this.ssrRenderTarget.setSize(width, height)
-    this.normalRenderTarget.setSize(width, height)
-    this.metalnessRenderTarget.setSize(width, height)
-    this.blurRenderTarget.setSize(width, height)
-    this.blurRenderTarget2.setSize(width, height)
-    // this.blurRenderTarget3.setSize(width, height);
-
-    this.ssrMaterial.uniforms['resolution'].value.set(width, height)
-    this.ssrMaterial.uniforms['cameraProjectionMatrix'].value.copy(this.camera.projectionMatrix)
-    this.ssrMaterial.uniforms['cameraInverseProjectionMatrix'].value.copy(this.camera.projectionMatrixInverse)
-
-    this.blurMaterial.uniforms['resolution'].value.set(width, height)
-    this.blurMaterial2.uniforms['resolution'].value.set(width, height)
-  }
-}
+  return SSRPass
+})()
 
 export { SSRPass }
diff --git a/src/postprocessing/UnrealBloomPass.js b/src/postprocessing/UnrealBloomPass.js
index 25e854c6..e0d1123c 100644
--- a/src/postprocessing/UnrealBloomPass.js
+++ b/src/postprocessing/UnrealBloomPass.js
@@ -22,281 +22,282 @@ import { LuminosityHighPassShader } from '../shaders/LuminosityHighPassShader'
  * Reference:
  * - https://docs.unrealengine.com/latest/INT/Engine/Rendering/PostProcessEffects/Bloom/
  */
-class UnrealBloomPass extends Pass {
-  static BlurDirectionX = new Vector2(1.0, 0.0)
-  static BlurDirectionY = new Vector2(0.0, 1.0)
+const UnrealBloomPass = /* @__PURE__ */ (() => {
+  class UnrealBloomPass extends Pass {
+    static BlurDirectionX = new Vector2(1.0, 0.0)
+    static BlurDirectionY = new Vector2(0.0, 1.0)
 
-  constructor(resolution, strength, radius, threshold) {
-    super()
+    constructor(resolution, strength, radius, threshold) {
+      super()
 
-    this.strength = strength !== undefined ? strength : 1
-    this.radius = radius
-    this.threshold = threshold
-    this.resolution = resolution !== undefined ? new Vector2(resolution.x, resolution.y) : new Vector2(256, 256)
+      this.strength = strength !== undefined ? strength : 1
+      this.radius = radius
+      this.threshold = threshold
+      this.resolution = resolution !== undefined ? new Vector2(resolution.x, resolution.y) : new Vector2(256, 256)
 
-    // create color only once here, reuse it later inside the render function
-    this.clearColor = new Color(0, 0, 0)
+      // create color only once here, reuse it later inside the render function
+      this.clearColor = new Color(0, 0, 0)
+
+      // render targets
+      this.renderTargetsHorizontal = []
+      this.renderTargetsVertical = []
+      this.nMips = 5
+      let resx = Math.round(this.resolution.x / 2)
+      let resy = Math.round(this.resolution.y / 2)
 
-    // render targets
-    this.renderTargetsHorizontal = []
-    this.renderTargetsVertical = []
-    this.nMips = 5
-    let resx = Math.round(this.resolution.x / 2)
-    let resy = Math.round(this.resolution.y / 2)
+      this.renderTargetBright = new WebGLRenderTarget(resx, resy, { type: HalfFloatType })
+      this.renderTargetBright.texture.name = 'UnrealBloomPass.bright'
+      this.renderTargetBright.texture.generateMipmaps = false
 
-    this.renderTargetBright = new WebGLRenderTarget(resx, resy, { type: HalfFloatType })
-    this.renderTargetBright.texture.name = 'UnrealBloomPass.bright'
-    this.renderTargetBright.texture.generateMipmaps = false
+      for (let i = 0; i < this.nMips; i++) {
+        const renderTargetHorizonal = new WebGLRenderTarget(resx, resy, { type: HalfFloatType })
 
-    for (let i = 0; i < this.nMips; i++) {
-      const renderTargetHorizonal = new WebGLRenderTarget(resx, resy, { type: HalfFloatType })
+        renderTargetHorizonal.texture.name = 'UnrealBloomPass.h' + i
+        renderTargetHorizonal.texture.generateMipmaps = false
 
-      renderTargetHorizonal.texture.name = 'UnrealBloomPass.h' + i
-      renderTargetHorizonal.texture.generateMipmaps = false
+        this.renderTargetsHorizontal.push(renderTargetHorizonal)
 
-      this.renderTargetsHorizontal.push(renderTargetHorizonal)
+        const renderTargetVertical = new WebGLRenderTarget(resx, resy, { type: HalfFloatType })
 
-      const renderTargetVertical = new WebGLRenderTarget(resx, resy, { type: HalfFloatType })
+        renderTargetVertical.texture.name = 'UnrealBloomPass.v' + i
+        renderTargetVertical.texture.generateMipmaps = false
 
-      renderTargetVertical.texture.name = 'UnrealBloomPass.v' + i
-      renderTargetVertical.texture.generateMipmaps = false
+        this.renderTargetsVertical.push(renderTargetVertical)
 
-      this.renderTargetsVertical.push(renderTargetVertical)
+        resx = Math.round(resx / 2)
 
-      resx = Math.round(resx / 2)
+        resy = Math.round(resy / 2)
+      }
 
-      resy = Math.round(resy / 2)
-    }
+      // luminosity high pass material
 
-    // luminosity high pass material
+      const highPassShader = LuminosityHighPassShader
+      this.highPassUniforms = UniformsUtils.clone(highPassShader.uniforms)
 
-    const highPassShader = LuminosityHighPassShader
-    this.highPassUniforms = UniformsUtils.clone(highPassShader.uniforms)
+      this.highPassUniforms['luminosityThreshold'].value = threshold
+      this.highPassUniforms['smoothWidth'].value = 0.01
 
-    this.highPassUniforms['luminosityThreshold'].value = threshold
-    this.highPassUniforms['smoothWidth'].value = 0.01
+      this.materialHighPassFilter = new ShaderMaterial({
+        uniforms: this.highPassUniforms,
+        vertexShader: highPassShader.vertexShader,
+        fragmentShader: highPassShader.fragmentShader,
+        defines: {},
+      })
 
-    this.materialHighPassFilter = new ShaderMaterial({
-      uniforms: this.highPassUniforms,
-      vertexShader: highPassShader.vertexShader,
-      fragmentShader: highPassShader.fragmentShader,
-      defines: {},
-    })
+      // Gaussian Blur Materials
+      this.separableBlurMaterials = []
+      const kernelSizeArray = [3, 5, 7, 9, 11]
+      resx = Math.round(this.resolution.x / 2)
+      resy = Math.round(this.resolution.y / 2)
 
-    // Gaussian Blur Materials
-    this.separableBlurMaterials = []
-    const kernelSizeArray = [3, 5, 7, 9, 11]
-    resx = Math.round(this.resolution.x / 2)
-    resy = Math.round(this.resolution.y / 2)
+      for (let i = 0; i < this.nMips; i++) {
+        this.separableBlurMaterials.push(this.getSeperableBlurMaterial(kernelSizeArray[i]))
 
-    for (let i = 0; i < this.nMips; i++) {
-      this.separableBlurMaterials.push(this.getSeperableBlurMaterial(kernelSizeArray[i]))
+        this.separableBlurMaterials[i].uniforms['texSize'].value = new Vector2(resx, resy)
 
-      this.separableBlurMaterials[i].uniforms['texSize'].value = new Vector2(resx, resy)
+        resx = Math.round(resx / 2)
 
-      resx = Math.round(resx / 2)
+        resy = Math.round(resy / 2)
+      }
 
-      resy = Math.round(resy / 2)
-    }
+      // Composite material
+      this.compositeMaterial = this.getCompositeMaterial(this.nMips)
+      this.compositeMaterial.uniforms['blurTexture1'].value = this.renderTargetsVertical[0].texture
+      this.compositeMaterial.uniforms['blurTexture2'].value = this.renderTargetsVertical[1].texture
+      this.compositeMaterial.uniforms['blurTexture3'].value = this.renderTargetsVertical[2].texture
+      this.compositeMaterial.uniforms['blurTexture4'].value = this.renderTargetsVertical[3].texture
+      this.compositeMaterial.uniforms['blurTexture5'].value = this.renderTargetsVertical[4].texture
+      this.compositeMaterial.uniforms['bloomStrength'].value = strength
+      this.compositeMaterial.uniforms['bloomRadius'].value = 0.1
+      this.compositeMaterial.needsUpdate = true
 
-    // Composite material
-    this.compositeMaterial = this.getCompositeMaterial(this.nMips)
-    this.compositeMaterial.uniforms['blurTexture1'].value = this.renderTargetsVertical[0].texture
-    this.compositeMaterial.uniforms['blurTexture2'].value = this.renderTargetsVertical[1].texture
-    this.compositeMaterial.uniforms['blurTexture3'].value = this.renderTargetsVertical[2].texture
-    this.compositeMaterial.uniforms['blurTexture4'].value = this.renderTargetsVertical[3].texture
-    this.compositeMaterial.uniforms['blurTexture5'].value = this.renderTargetsVertical[4].texture
-    this.compositeMaterial.uniforms['bloomStrength'].value = strength
-    this.compositeMaterial.uniforms['bloomRadius'].value = 0.1
-    this.compositeMaterial.needsUpdate = true
-
-    const bloomFactors = [1.0, 0.8, 0.6, 0.4, 0.2]
-    this.compositeMaterial.uniforms['bloomFactors'].value = bloomFactors
-    this.bloomTintColors = [
-      new Vector3(1, 1, 1),
-      new Vector3(1, 1, 1),
-      new Vector3(1, 1, 1),
-      new Vector3(1, 1, 1),
-      new Vector3(1, 1, 1),
-    ]
-    this.compositeMaterial.uniforms['bloomTintColors'].value = this.bloomTintColors
-
-    // copy material
-
-    const copyShader = CopyShader
-
-    this.copyUniforms = UniformsUtils.clone(copyShader.uniforms)
-    this.copyUniforms['opacity'].value = 1.0
-
-    this.materialCopy = new ShaderMaterial({
-      uniforms: this.copyUniforms,
-      vertexShader: copyShader.vertexShader,
-      fragmentShader: copyShader.fragmentShader,
-      blending: AdditiveBlending,
-      depthTest: false,
-      depthWrite: false,
-      transparent: true,
-    })
-
-    this.enabled = true
-    this.needsSwap = false
-
-    this._oldClearColor = new Color()
-    this.oldClearAlpha = 1
-
-    this.basic = new MeshBasicMaterial()
-
-    this.fsQuad = new FullScreenQuad(null)
-  }
+      const bloomFactors = [1.0, 0.8, 0.6, 0.4, 0.2]
+      this.compositeMaterial.uniforms['bloomFactors'].value = bloomFactors
+      this.bloomTintColors = [
+        new Vector3(1, 1, 1),
+        new Vector3(1, 1, 1),
+        new Vector3(1, 1, 1),
+        new Vector3(1, 1, 1),
+        new Vector3(1, 1, 1),
+      ]
+      this.compositeMaterial.uniforms['bloomTintColors'].value = this.bloomTintColors
 
-  dispose() {
-    for (let i = 0; i < this.renderTargetsHorizontal.length; i++) {
-      this.renderTargetsHorizontal[i].dispose()
-    }
+      // copy material
 
-    for (let i = 0; i < this.renderTargetsVertical.length; i++) {
-      this.renderTargetsVertical[i].dispose()
-    }
+      const copyShader = CopyShader
+
+      this.copyUniforms = UniformsUtils.clone(copyShader.uniforms)
+      this.copyUniforms['opacity'].value = 1.0
+
+      this.materialCopy = new ShaderMaterial({
+        uniforms: this.copyUniforms,
+        vertexShader: copyShader.vertexShader,
+        fragmentShader: copyShader.fragmentShader,
+        blending: AdditiveBlending,
+        depthTest: false,
+        depthWrite: false,
+        transparent: true,
+      })
+
+      this.enabled = true
+      this.needsSwap = false
 
-    this.renderTargetBright.dispose()
+      this._oldClearColor = new Color()
+      this.oldClearAlpha = 1
 
-    //
+      this.basic = new MeshBasicMaterial()
 
-    for (let i = 0; i < this.separableBlurMaterials.length; i++) {
-      this.separableBlurMaterials[i].dispose()
+      this.fsQuad = new FullScreenQuad(null)
     }
 
-    this.compositeMaterial.dispose()
-    this.materialCopy.dispose()
-    this.basic.dispose()
+    dispose() {
+      for (let i = 0; i < this.renderTargetsHorizontal.length; i++) {
+        this.renderTargetsHorizontal[i].dispose()
+      }
 
-    //
+      for (let i = 0; i < this.renderTargetsVertical.length; i++) {
+        this.renderTargetsVertical[i].dispose()
+      }
 
-    this.fsQuad.dispose()
-  }
+      this.renderTargetBright.dispose()
 
-  setSize(width, height) {
-    let resx = Math.round(width / 2)
-    let resy = Math.round(height / 2)
+      //
 
-    this.renderTargetBright.setSize(resx, resy)
+      for (let i = 0; i < this.separableBlurMaterials.length; i++) {
+        this.separableBlurMaterials[i].dispose()
+      }
 
-    for (let i = 0; i < this.nMips; i++) {
-      this.renderTargetsHorizontal[i].setSize(resx, resy)
-      this.renderTargetsVertical[i].setSize(resx, resy)
+      this.compositeMaterial.dispose()
+      this.materialCopy.dispose()
+      this.basic.dispose()
 
-      this.separableBlurMaterials[i].uniforms['texSize'].value = new Vector2(resx, resy)
+      //
 
-      resx = Math.round(resx / 2)
-      resy = Math.round(resy / 2)
+      this.fsQuad.dispose()
     }
-  }
 
-  render(renderer, writeBuffer, readBuffer, deltaTime, maskActive) {
-    renderer.getClearColor(this._oldClearColor)
-    this.oldClearAlpha = renderer.getClearAlpha()
-    const oldAutoClear = renderer.autoClear
-    renderer.autoClear = false
+    setSize(width, height) {
+      let resx = Math.round(width / 2)
+      let resy = Math.round(height / 2)
 
-    renderer.setClearColor(this.clearColor, 0)
+      this.renderTargetBright.setSize(resx, resy)
 
-    if (maskActive) renderer.state.buffers.stencil.setTest(false)
+      for (let i = 0; i < this.nMips; i++) {
+        this.renderTargetsHorizontal[i].setSize(resx, resy)
+        this.renderTargetsVertical[i].setSize(resx, resy)
 
-    // Render input to screen
+        this.separableBlurMaterials[i].uniforms['texSize'].value = new Vector2(resx, resy)
 
-    if (this.renderToScreen) {
-      this.fsQuad.material = this.basic
-      this.basic.map = readBuffer.texture
-
-      renderer.setRenderTarget(null)
-      renderer.clear()
-      this.fsQuad.render(renderer)
+        resx = Math.round(resx / 2)
+        resy = Math.round(resy / 2)
+      }
     }
 
-    // 1. Extract Bright Areas
+    render(renderer, writeBuffer, readBuffer, deltaTime, maskActive) {
+      renderer.getClearColor(this._oldClearColor)
+      this.oldClearAlpha = renderer.getClearAlpha()
+      const oldAutoClear = renderer.autoClear
+      renderer.autoClear = false
 
-    this.highPassUniforms['tDiffuse'].value = readBuffer.texture
-    this.highPassUniforms['luminosityThreshold'].value = this.threshold
-    this.fsQuad.material = this.materialHighPassFilter
+      renderer.setClearColor(this.clearColor, 0)
 
-    renderer.setRenderTarget(this.renderTargetBright)
-    renderer.clear()
-    this.fsQuad.render(renderer)
+      if (maskActive) renderer.state.buffers.stencil.setTest(false)
 
-    // 2. Blur All the mips progressively
+      // Render input to screen
 
-    let inputRenderTarget = this.renderTargetBright
+      if (this.renderToScreen) {
+        this.fsQuad.material = this.basic
+        this.basic.map = readBuffer.texture
 
-    for (let i = 0; i < this.nMips; i++) {
-      this.fsQuad.material = this.separableBlurMaterials[i]
+        renderer.setRenderTarget(null)
+        renderer.clear()
+        this.fsQuad.render(renderer)
+      }
 
-      this.separableBlurMaterials[i].uniforms['colorTexture'].value = inputRenderTarget.texture
-      this.separableBlurMaterials[i].uniforms['direction'].value = UnrealBloomPass.BlurDirectionX
-      renderer.setRenderTarget(this.renderTargetsHorizontal[i])
-      renderer.clear()
-      this.fsQuad.render(renderer)
+      // 1. Extract Bright Areas
+
+      this.highPassUniforms['tDiffuse'].value = readBuffer.texture
+      this.highPassUniforms['luminosityThreshold'].value = this.threshold
+      this.fsQuad.material = this.materialHighPassFilter
 
-      this.separableBlurMaterials[i].uniforms['colorTexture'].value = this.renderTargetsHorizontal[i].texture
-      this.separableBlurMaterials[i].uniforms['direction'].value = UnrealBloomPass.BlurDirectionY
-      renderer.setRenderTarget(this.renderTargetsVertical[i])
+      renderer.setRenderTarget(this.renderTargetBright)
       renderer.clear()
       this.fsQuad.render(renderer)
 
-      inputRenderTarget = this.renderTargetsVertical[i]
-    }
+      // 2. Blur All the mips progressively
 
-    // Composite All the mips
+      let inputRenderTarget = this.renderTargetBright
 
-    this.fsQuad.material = this.compositeMaterial
-    this.compositeMaterial.uniforms['bloomStrength'].value = this.strength
-    this.compositeMaterial.uniforms['bloomRadius'].value = this.radius
-    this.compositeMaterial.uniforms['bloomTintColors'].value = this.bloomTintColors
+      for (let i = 0; i < this.nMips; i++) {
+        this.fsQuad.material = this.separableBlurMaterials[i]
 
-    renderer.setRenderTarget(this.renderTargetsHorizontal[0])
-    renderer.clear()
-    this.fsQuad.render(renderer)
+        this.separableBlurMaterials[i].uniforms['colorTexture'].value = inputRenderTarget.texture
+        this.separableBlurMaterials[i].uniforms['direction'].value = UnrealBloomPass.BlurDirectionX
+        renderer.setRenderTarget(this.renderTargetsHorizontal[i])
+        renderer.clear()
+        this.fsQuad.render(renderer)
 
-    // Blend it additively over the input texture
+        this.separableBlurMaterials[i].uniforms['colorTexture'].value = this.renderTargetsHorizontal[i].texture
+        this.separableBlurMaterials[i].uniforms['direction'].value = UnrealBloomPass.BlurDirectionY
+        renderer.setRenderTarget(this.renderTargetsVertical[i])
+        renderer.clear()
+        this.fsQuad.render(renderer)
 
-    this.fsQuad.material = this.materialCopy
-    this.copyUniforms['tDiffuse'].value = this.renderTargetsHorizontal[0].texture
+        inputRenderTarget = this.renderTargetsVertical[i]
+      }
 
-    if (maskActive) renderer.state.buffers.stencil.setTest(true)
+      // Composite All the mips
 
-    if (this.renderToScreen) {
-      renderer.setRenderTarget(null)
-      this.fsQuad.render(renderer)
-    } else {
-      renderer.setRenderTarget(readBuffer)
+      this.fsQuad.material = this.compositeMaterial
+      this.compositeMaterial.uniforms['bloomStrength'].value = this.strength
+      this.compositeMaterial.uniforms['bloomRadius'].value = this.radius
+      this.compositeMaterial.uniforms['bloomTintColors'].value = this.bloomTintColors
+
+      renderer.setRenderTarget(this.renderTargetsHorizontal[0])
+      renderer.clear()
       this.fsQuad.render(renderer)
-    }
 
-    // Restore renderer settings
+      // Blend it additively over the input texture
 
-    renderer.setClearColor(this._oldClearColor, this.oldClearAlpha)
-    renderer.autoClear = oldAutoClear
-  }
+      this.fsQuad.material = this.materialCopy
+      this.copyUniforms['tDiffuse'].value = this.renderTargetsHorizontal[0].texture
 
-  getSeperableBlurMaterial(kernelRadius) {
-    return new ShaderMaterial({
-      defines: {
-        KERNEL_RADIUS: kernelRadius,
-        SIGMA: kernelRadius,
-      },
+      if (maskActive) renderer.state.buffers.stencil.setTest(true)
 
-      uniforms: {
-        colorTexture: { value: null },
-        texSize: { value: new Vector2(0.5, 0.5) },
-        direction: { value: new Vector2(0.5, 0.5) },
-      },
+      if (this.renderToScreen) {
+        renderer.setRenderTarget(null)
+        this.fsQuad.render(renderer)
+      } else {
+        renderer.setRenderTarget(readBuffer)
+        this.fsQuad.render(renderer)
+      }
 
-      vertexShader: `varying vec2 vUv;
+      // Restore renderer settings
+
+      renderer.setClearColor(this._oldClearColor, this.oldClearAlpha)
+      renderer.autoClear = oldAutoClear
+    }
+
+    getSeperableBlurMaterial(kernelRadius) {
+      return new ShaderMaterial({
+        defines: {
+          KERNEL_RADIUS: kernelRadius,
+          SIGMA: kernelRadius,
+        },
+
+        uniforms: {
+          colorTexture: { value: null },
+          texSize: { value: new Vector2(0.5, 0.5) },
+          direction: { value: new Vector2(0.5, 0.5) },
+        },
+
+        vertexShader: `varying vec2 vUv;
 				void main() {
 					vUv = uv;
 					gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 				}`,
 
-      fragmentShader: `#include <common>
+        fragmentShader: `#include <common>
 				varying vec2 vUv;
 				uniform sampler2D colorTexture;
 				uniform vec2 texSize;
@@ -321,34 +322,34 @@ class UnrealBloomPass extends Pass {
 					}
 					gl_FragColor = vec4(diffuseSum/weightSum, 1.0);
 				}`,
-    })
-  }
+      })
+    }
 
-  getCompositeMaterial(nMips) {
-    return new ShaderMaterial({
-      defines: {
-        NUM_MIPS: nMips,
-      },
-
-      uniforms: {
-        blurTexture1: { value: null },
-        blurTexture2: { value: null },
-        blurTexture3: { value: null },
-        blurTexture4: { value: null },
-        blurTexture5: { value: null },
-        bloomStrength: { value: 1.0 },
-        bloomFactors: { value: null },
-        bloomTintColors: { value: null },
-        bloomRadius: { value: 0.0 },
-      },
-
-      vertexShader: `varying vec2 vUv;
+    getCompositeMaterial(nMips) {
+      return new ShaderMaterial({
+        defines: {
+          NUM_MIPS: nMips,
+        },
+
+        uniforms: {
+          blurTexture1: { value: null },
+          blurTexture2: { value: null },
+          blurTexture3: { value: null },
+          blurTexture4: { value: null },
+          blurTexture5: { value: null },
+          bloomStrength: { value: 1.0 },
+          bloomFactors: { value: null },
+          bloomTintColors: { value: null },
+          bloomRadius: { value: 0.0 },
+        },
+
+        vertexShader: `varying vec2 vUv;
 				void main() {
 					vUv = uv;
 					gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 				}`,
 
-      fragmentShader: `varying vec2 vUv;
+        fragmentShader: `varying vec2 vUv;
 				uniform sampler2D blurTexture1;
 				uniform sampler2D blurTexture2;
 				uniform sampler2D blurTexture3;
@@ -371,8 +372,11 @@ class UnrealBloomPass extends Pass {
 						lerpBloomFactor(bloomFactors[3]) * vec4(bloomTintColors[3], 1.0) * texture2D(blurTexture4, vUv) +
 						lerpBloomFactor(bloomFactors[4]) * vec4(bloomTintColors[4], 1.0) * texture2D(blurTexture5, vUv) );
 				}`,
-    })
+      })
+    }
   }
-}
+
+  return UnrealBloomPass
+})()
 
 export { UnrealBloomPass }
diff --git a/src/renderers/CSS2DRenderer.js b/src/renderers/CSS2DRenderer.js
index 7caf2532..f0aa059e 100644
--- a/src/renderers/CSS2DRenderer.js
+++ b/src/renderers/CSS2DRenderer.js
@@ -35,11 +35,11 @@ class CSS2DObject extends Object3D {
   }
 }
 
-const _vector = new Vector3()
-const _viewMatrix = new Matrix4()
-const _viewProjectionMatrix = new Matrix4()
-const _a = new Vector3()
-const _b = new Vector3()
+const _vector = /* @__PURE__ */ new Vector3()
+const _viewMatrix = /* @__PURE__ */ new Matrix4()
+const _viewProjectionMatrix = /* @__PURE__ */ new Matrix4()
+const _a = /* @__PURE__ */ new Vector3()
+const _b = /* @__PURE__ */ new Vector3()
 
 class CSS2DRenderer {
   constructor(parameters = {}) {
diff --git a/src/renderers/CSS3DRenderer.js b/src/renderers/CSS3DRenderer.js
index cdeb32e8..292a0ba5 100644
--- a/src/renderers/CSS3DRenderer.js
+++ b/src/renderers/CSS3DRenderer.js
@@ -4,9 +4,9 @@ import { Matrix4, Object3D, Quaternion, Vector3 } from 'three'
  * Based on http://www.emagix.net/academic/mscs-project/item/camera-sync-with-css3-and-webgl-threejs
  */
 
-const _position = new Vector3()
-const _quaternion = new Quaternion()
-const _scale = new Vector3()
+const _position = /* @__PURE__ */ new Vector3()
+const _quaternion = /* @__PURE__ */ new Quaternion()
+const _scale = /* @__PURE__ */ new Vector3()
 
 class CSS3DObject extends Object3D {
   constructor(element = document.createElement('div')) {
@@ -59,8 +59,8 @@ class CSS3DSprite extends CSS3DObject {
 
 //
 
-const _matrix = new Matrix4()
-const _matrix2 = new Matrix4()
+const _matrix = /* @__PURE__ */ new Matrix4()
+const _matrix2 = /* @__PURE__ */ new Matrix4()
 
 class CSS3DRenderer {
   constructor(parameters = {}) {
diff --git a/src/shaders/ACESFilmicToneMappingShader.ts b/src/shaders/ACESFilmicToneMappingShader.ts
index e80700dc..db221340 100644
--- a/src/shaders/ACESFilmicToneMappingShader.ts
+++ b/src/shaders/ACESFilmicToneMappingShader.ts
@@ -22,70 +22,69 @@ export const ACESFilmicToneMappingShader: IACESFilmicToneMappingShader = {
     exposure: { value: 1.0 },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;,
 
-    'void main() {',
+    void main() {,
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;,
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );,
 
-    '}',
-  ].join('\n'),
+    },
+  `,
+  fragmentShader: /* glsl */ `
+    #define saturate(a) clamp( a, 0.0, 1.0 ),
 
-  fragmentShader: [
-    '#define saturate(a) clamp( a, 0.0, 1.0 )',
+    uniform sampler2D tDiffuse;,
 
-    'uniform sampler2D tDiffuse;',
+    uniform float exposure;,
 
-    'uniform float exposure;',
+    varying vec2 vUv;,
 
-    'varying vec2 vUv;',
+    vec3 RRTAndODTFit( vec3 v ) {,
 
-    'vec3 RRTAndODTFit( vec3 v ) {',
+    	vec3 a = v * ( v + 0.0245786 ) - 0.000090537;,
+    	vec3 b = v * ( 0.983729 * v + 0.4329510 ) + 0.238081;,
+    	return a / b;,
 
-    '	vec3 a = v * ( v + 0.0245786 ) - 0.000090537;',
-    '	vec3 b = v * ( 0.983729 * v + 0.4329510 ) + 0.238081;',
-    '	return a / b;',
+    },
 
-    '}',
+    vec3 ACESFilmicToneMapping( vec3 color ) {,
 
-    'vec3 ACESFilmicToneMapping( vec3 color ) {',
+      // sRGB => XYZ => D65_2_D60 => AP1 => RRT_SAT
+    	const mat3 ACESInputMat = mat3(,
+    		vec3( 0.59719, 0.07600, 0.02840 ),, // transposed from source
+    		vec3( 0.35458, 0.90834, 0.13383 ),,
+    		vec3( 0.04823, 0.01566, 0.83777 ),
+    	);,
 
-    // sRGB => XYZ => D65_2_D60 => AP1 => RRT_SAT
-    '	const mat3 ACESInputMat = mat3(',
-    '		vec3( 0.59719, 0.07600, 0.02840 ),', // transposed from source
-    '		vec3( 0.35458, 0.90834, 0.13383 ),',
-    '		vec3( 0.04823, 0.01566, 0.83777 )',
-    '	);',
+      // ODT_SAT => XYZ => D60_2_D65 => sRGB
+    	const mat3 ACESOutputMat = mat3(,
+    		vec3(  1.60475, -0.10208, -0.00327 ),, // transposed from source
+    		vec3( -0.53108,  1.10813, -0.07276 ),,
+    		vec3( -0.07367, -0.00605,  1.07602 ),
+    	);,
 
-    // ODT_SAT => XYZ => D60_2_D65 => sRGB
-    '	const mat3 ACESOutputMat = mat3(',
-    '		vec3(  1.60475, -0.10208, -0.00327 ),', // transposed from source
-    '		vec3( -0.53108,  1.10813, -0.07276 ),',
-    '		vec3( -0.07367, -0.00605,  1.07602 )',
-    '	);',
+    	color = ACESInputMat * color;,
 
-    '	color = ACESInputMat * color;',
+      // Apply RRT and ODT
+    	color = RRTAndODTFit( color );,
 
-    // Apply RRT and ODT
-    '	color = RRTAndODTFit( color );',
+    	color = ACESOutputMat * color;,
 
-    '	color = ACESOutputMat * color;',
+      // Clamp to [0, 1]
+    	return saturate( color );,
 
-    // Clamp to [0, 1]
-    '	return saturate( color );',
+    },
 
-    '}',
+    void main() {,
 
-    'void main() {',
+    	vec4 tex = texture2D( tDiffuse, vUv );,
 
-    '	vec4 tex = texture2D( tDiffuse, vUv );',
+    	tex.rgb *= exposure / 0.6;, // pre-exposed, outside of the tone mapping function
 
-    '	tex.rgb *= exposure / 0.6;', // pre-exposed, outside of the tone mapping function
+    	gl_FragColor = vec4( ACESFilmicToneMapping( tex.rgb ), tex.a );,
 
-    '	gl_FragColor = vec4( ACESFilmicToneMapping( tex.rgb ), tex.a );',
-
-    '}',
-  ].join('\n'),
+    },
+  `,
 }
diff --git a/src/shaders/AfterimageShader.ts b/src/shaders/AfterimageShader.ts
index a5214494..990c93b8 100644
--- a/src/shaders/AfterimageShader.ts
+++ b/src/shaders/AfterimageShader.ts
@@ -22,40 +22,40 @@ export const AfterimageShader: IAfterimageShader = {
     tNew: { value: null },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform float damp;',
+  fragmentShader: /* glsl */ `
+    uniform float damp;
 
-    'uniform sampler2D tOld;',
-    'uniform sampler2D tNew;',
+    uniform sampler2D tOld;
+    uniform sampler2D tNew;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'vec4 when_gt( vec4 x, float y ) {',
+    vec4 when_gt( vec4 x, float y ) {
 
-    '	return max( sign( x - y ), 0.0 );',
+    	return max( sign( x - y ), 0.0 );
 
-    '}',
+    }
 
-    'void main() {',
+    void main() {
 
-    '	vec4 texelOld = texture2D( tOld, vUv );',
-    '	vec4 texelNew = texture2D( tNew, vUv );',
+    	vec4 texelOld = texture2D( tOld, vUv );
+    	vec4 texelNew = texture2D( tNew, vUv );
 
-    '	texelOld *= damp * when_gt( texelOld, 0.1 );',
+    	texelOld *= damp * when_gt( texelOld, 0.1 );
 
-    '	gl_FragColor = max(texelNew, texelOld);',
+    	gl_FragColor = max(texelNew, texelOld);
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/BasicShader.ts b/src/shaders/BasicShader.ts
index 9226a3e0..36d0369b 100644
--- a/src/shaders/BasicShader.ts
+++ b/src/shaders/BasicShader.ts
@@ -11,13 +11,19 @@ export interface IBasicShader extends IShader<BasicShaderUniforms> {}
 export const BasicShader: IBasicShader = {
   uniforms: {},
 
-  vertexShader: [
-    'void main() {',
+  vertexShader: /* glsl */ `
+    void main() {
 
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: ['void main() {', '	gl_FragColor = vec4( 1.0, 0.0, 0.0, 0.5 );', '}'].join('\n'),
+  fragmentShader: /* glsl */ `
+    void main() {
+
+      gl_FragColor = vec4( 1.0, 0.0, 0.0, 0.5 );
+
+    }
+  `,
 }
diff --git a/src/shaders/BleachBypassShader.ts b/src/shaders/BleachBypassShader.ts
index 03d967d2..bed9ada9 100644
--- a/src/shaders/BleachBypassShader.ts
+++ b/src/shaders/BleachBypassShader.ts
@@ -20,45 +20,45 @@ export const BleachBypassShader: IBleachBypassShader = {
     opacity: { value: 1.0 },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform float opacity;',
+  fragmentShader: /* glsl */ `
+    uniform float opacity;
 
-    'uniform sampler2D tDiffuse;',
+    uniform sampler2D tDiffuse;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vec4 base = texture2D( tDiffuse, vUv );',
+    	vec4 base = texture2D( tDiffuse, vUv );
 
-    '	vec3 lumCoeff = vec3( 0.25, 0.65, 0.1 );',
-    '	float lum = dot( lumCoeff, base.rgb );',
-    '	vec3 blend = vec3( lum );',
+    	vec3 lumCoeff = vec3( 0.25, 0.65, 0.1 );
+    	float lum = dot( lumCoeff, base.rgb );
+    	vec3 blend = vec3( lum );
 
-    '	float L = min( 1.0, max( 0.0, 10.0 * ( lum - 0.45 ) ) );',
+    	float L = min( 1.0, max( 0.0, 10.0 * ( lum - 0.45 ) ) );
 
-    '	vec3 result1 = 2.0 * base.rgb * blend;',
-    '	vec3 result2 = 1.0 - 2.0 * ( 1.0 - blend ) * ( 1.0 - base.rgb );',
+    	vec3 result1 = 2.0 * base.rgb * blend;
+    	vec3 result2 = 1.0 - 2.0 * ( 1.0 - blend ) * ( 1.0 - base.rgb );
 
-    '	vec3 newColor = mix( result1, result2, L );',
+    	vec3 newColor = mix( result1, result2, L );
 
-    '	float A2 = opacity * base.a;',
-    '	vec3 mixRGB = A2 * newColor.rgb;',
-    '	mixRGB += ( ( 1.0 - A2 ) * base.rgb );',
+    	float A2 = opacity * base.a;
+    	vec3 mixRGB = A2 * newColor.rgb;
+    	mixRGB += ( ( 1.0 - A2 ) * base.rgb );
 
-    '	gl_FragColor = vec4( mixRGB, base.a );',
+    	gl_FragColor = vec4( mixRGB, base.a );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/BlendShader.ts b/src/shaders/BlendShader.ts
index d626c3a9..086160ef 100644
--- a/src/shaders/BlendShader.ts
+++ b/src/shaders/BlendShader.ts
@@ -10,32 +10,32 @@ export const BlendShader = {
     opacity: { value: 1.0 },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform float opacity;',
-    'uniform float mixRatio;',
+  fragmentShader: /* glsl */ `
+    uniform float opacity;
+    uniform float mixRatio;
 
-    'uniform sampler2D tDiffuse1;',
-    'uniform sampler2D tDiffuse2;',
+    uniform sampler2D tDiffuse1;
+    uniform sampler2D tDiffuse2;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vec4 texel1 = texture2D( tDiffuse1, vUv );',
-    '	vec4 texel2 = texture2D( tDiffuse2, vUv );',
-    '	gl_FragColor = opacity * mix( texel1, texel2, mixRatio );',
+    	vec4 texel1 = texture2D( tDiffuse1, vUv );
+    	vec4 texel2 = texture2D( tDiffuse2, vUv );
+    	gl_FragColor = opacity * mix( texel1, texel2, mixRatio );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/BokehShader.ts b/src/shaders/BokehShader.ts
index 6c80cf5f..f248cf4b 100644
--- a/src/shaders/BokehShader.ts
+++ b/src/shaders/BokehShader.ts
@@ -42,116 +42,116 @@ export const BokehShader: IBokehShader = {
     farClip: { value: 1000.0 },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
-
-    'void main() {',
-
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
-
-    '}',
-  ].join('\n'),
-
-  fragmentShader: [
-    '#include <common>',
-
-    'varying vec2 vUv;',
-
-    'uniform sampler2D tColor;',
-    'uniform sampler2D tDepth;',
-
-    'uniform float maxblur;', // max blur amount
-    'uniform float aperture;', // aperture - bigger values for shallower depth of field
-
-    'uniform float nearClip;',
-    'uniform float farClip;',
-
-    'uniform float focus;',
-    'uniform float aspect;',
-
-    '#include <packing>',
-
-    'float getDepth( const in vec2 screenPosition ) {',
-    '	#if DEPTH_PACKING == 1',
-    '	return unpackRGBAToDepth( texture2D( tDepth, screenPosition ) );',
-    '	#else',
-    '	return texture2D( tDepth, screenPosition ).x;',
-    '	#endif',
-    '}',
-
-    'float getViewZ( const in float depth ) {',
-    '	#if PERSPECTIVE_CAMERA == 1',
-    '	return perspectiveDepthToViewZ( depth, nearClip, farClip );',
-    '	#else',
-    '	return orthographicDepthToViewZ( depth, nearClip, farClip );',
-    '	#endif',
-    '}',
-
-    'void main() {',
-
-    '	vec2 aspectcorrect = vec2( 1.0, aspect );',
-
-    '	float viewZ = getViewZ( getDepth( vUv ) );',
-
-    '	float factor = ( focus + viewZ );', // viewZ is <= 0, so this is a difference equation
-
-    '	vec2 dofblur = vec2 ( clamp( factor * aperture, -maxblur, maxblur ) );',
-
-    '	vec2 dofblur9 = dofblur * 0.9;',
-    '	vec2 dofblur7 = dofblur * 0.7;',
-    '	vec2 dofblur4 = dofblur * 0.4;',
-
-    '	vec4 col = vec4( 0.0 );',
-
-    '	col += texture2D( tColor, vUv.xy );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.0,   0.4  ) * aspectcorrect ) * dofblur );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.15,  0.37 ) * aspectcorrect ) * dofblur );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.29,  0.29 ) * aspectcorrect ) * dofblur );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2( -0.37,  0.15 ) * aspectcorrect ) * dofblur );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.40,  0.0  ) * aspectcorrect ) * dofblur );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.37, -0.15 ) * aspectcorrect ) * dofblur );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.29, -0.29 ) * aspectcorrect ) * dofblur );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2( -0.15, -0.37 ) * aspectcorrect ) * dofblur );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.0,  -0.4  ) * aspectcorrect ) * dofblur );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2( -0.15,  0.37 ) * aspectcorrect ) * dofblur );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2( -0.29,  0.29 ) * aspectcorrect ) * dofblur );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.37,  0.15 ) * aspectcorrect ) * dofblur );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2( -0.4,   0.0  ) * aspectcorrect ) * dofblur );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2( -0.37, -0.15 ) * aspectcorrect ) * dofblur );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2( -0.29, -0.29 ) * aspectcorrect ) * dofblur );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.15, -0.37 ) * aspectcorrect ) * dofblur );',
-
-    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.15,  0.37 ) * aspectcorrect ) * dofblur9 );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2( -0.37,  0.15 ) * aspectcorrect ) * dofblur9 );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.37, -0.15 ) * aspectcorrect ) * dofblur9 );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2( -0.15, -0.37 ) * aspectcorrect ) * dofblur9 );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2( -0.15,  0.37 ) * aspectcorrect ) * dofblur9 );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.37,  0.15 ) * aspectcorrect ) * dofblur9 );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2( -0.37, -0.15 ) * aspectcorrect ) * dofblur9 );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.15, -0.37 ) * aspectcorrect ) * dofblur9 );',
-
-    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.29,  0.29 ) * aspectcorrect ) * dofblur7 );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.40,  0.0  ) * aspectcorrect ) * dofblur7 );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.29, -0.29 ) * aspectcorrect ) * dofblur7 );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.0,  -0.4  ) * aspectcorrect ) * dofblur7 );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2( -0.29,  0.29 ) * aspectcorrect ) * dofblur7 );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2( -0.4,   0.0  ) * aspectcorrect ) * dofblur7 );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2( -0.29, -0.29 ) * aspectcorrect ) * dofblur7 );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.0,   0.4  ) * aspectcorrect ) * dofblur7 );',
-
-    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.29,  0.29 ) * aspectcorrect ) * dofblur4 );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.4,   0.0  ) * aspectcorrect ) * dofblur4 );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.29, -0.29 ) * aspectcorrect ) * dofblur4 );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.0,  -0.4  ) * aspectcorrect ) * dofblur4 );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2( -0.29,  0.29 ) * aspectcorrect ) * dofblur4 );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2( -0.4,   0.0  ) * aspectcorrect ) * dofblur4 );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2( -0.29, -0.29 ) * aspectcorrect ) * dofblur4 );',
-    '	col += texture2D( tColor, vUv.xy + ( vec2(  0.0,   0.4  ) * aspectcorrect ) * dofblur4 );',
-
-    '	gl_FragColor = col / 41.0;',
-    '	gl_FragColor.a = 1.0;',
-
-    '}',
-  ].join('\n'),
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
+
+    void main() {
+
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+
+    }
+  `,
+
+  fragmentShader: /* glsl */ `
+    #include <common>
+
+    varying vec2 vUv;
+
+    uniform sampler2D tColor;
+    uniform sampler2D tDepth;
+
+    uniform float maxblur; // max blur amount
+    uniform float aperture; // aperture - bigger values for shallower depth of field
+
+    uniform float nearClip;
+    uniform float farClip;
+
+    uniform float focus;
+    uniform float aspect;
+
+    #include <packing>
+
+    float getDepth( const in vec2 screenPosition ) {
+    	#if DEPTH_PACKING == 1
+    	return unpackRGBAToDepth( texture2D( tDepth, screenPosition ) );
+    	#else
+    	return texture2D( tDepth, screenPosition ).x;
+    	#endif
+    }
+
+    float getViewZ( const in float depth ) {
+    	#if PERSPECTIVE_CAMERA == 1
+    	return perspectiveDepthToViewZ( depth, nearClip, farClip );
+    	#else
+    	return orthographicDepthToViewZ( depth, nearClip, farClip );
+    	#endif
+    }
+
+    void main() {
+
+    	vec2 aspectcorrect = vec2( 1.0, aspect );
+
+    	float viewZ = getViewZ( getDepth( vUv ) );
+
+    	float factor = ( focus + viewZ ); // viewZ is <= 0, so this is a difference equation
+
+    	vec2 dofblur = vec2 ( clamp( factor * aperture, -maxblur, maxblur ) );
+
+    	vec2 dofblur9 = dofblur * 0.9;
+    	vec2 dofblur7 = dofblur * 0.7;
+    	vec2 dofblur4 = dofblur * 0.4;
+
+    	vec4 col = vec4( 0.0 );
+
+    	col += texture2D( tColor, vUv.xy );
+    	col += texture2D( tColor, vUv.xy + ( vec2(  0.0,   0.4  ) * aspectcorrect ) * dofblur );
+    	col += texture2D( tColor, vUv.xy + ( vec2(  0.15,  0.37 ) * aspectcorrect ) * dofblur );
+    	col += texture2D( tColor, vUv.xy + ( vec2(  0.29,  0.29 ) * aspectcorrect ) * dofblur );
+    	col += texture2D( tColor, vUv.xy + ( vec2( -0.37,  0.15 ) * aspectcorrect ) * dofblur );
+    	col += texture2D( tColor, vUv.xy + ( vec2(  0.40,  0.0  ) * aspectcorrect ) * dofblur );
+    	col += texture2D( tColor, vUv.xy + ( vec2(  0.37, -0.15 ) * aspectcorrect ) * dofblur );
+    	col += texture2D( tColor, vUv.xy + ( vec2(  0.29, -0.29 ) * aspectcorrect ) * dofblur );
+    	col += texture2D( tColor, vUv.xy + ( vec2( -0.15, -0.37 ) * aspectcorrect ) * dofblur );
+    	col += texture2D( tColor, vUv.xy + ( vec2(  0.0,  -0.4  ) * aspectcorrect ) * dofblur );
+    	col += texture2D( tColor, vUv.xy + ( vec2( -0.15,  0.37 ) * aspectcorrect ) * dofblur );
+    	col += texture2D( tColor, vUv.xy + ( vec2( -0.29,  0.29 ) * aspectcorrect ) * dofblur );
+    	col += texture2D( tColor, vUv.xy + ( vec2(  0.37,  0.15 ) * aspectcorrect ) * dofblur );
+    	col += texture2D( tColor, vUv.xy + ( vec2( -0.4,   0.0  ) * aspectcorrect ) * dofblur );
+    	col += texture2D( tColor, vUv.xy + ( vec2( -0.37, -0.15 ) * aspectcorrect ) * dofblur );
+    	col += texture2D( tColor, vUv.xy + ( vec2( -0.29, -0.29 ) * aspectcorrect ) * dofblur );
+    	col += texture2D( tColor, vUv.xy + ( vec2(  0.15, -0.37 ) * aspectcorrect ) * dofblur );
+
+    	col += texture2D( tColor, vUv.xy + ( vec2(  0.15,  0.37 ) * aspectcorrect ) * dofblur9 );
+    	col += texture2D( tColor, vUv.xy + ( vec2( -0.37,  0.15 ) * aspectcorrect ) * dofblur9 );
+    	col += texture2D( tColor, vUv.xy + ( vec2(  0.37, -0.15 ) * aspectcorrect ) * dofblur9 );
+    	col += texture2D( tColor, vUv.xy + ( vec2( -0.15, -0.37 ) * aspectcorrect ) * dofblur9 );
+    	col += texture2D( tColor, vUv.xy + ( vec2( -0.15,  0.37 ) * aspectcorrect ) * dofblur9 );
+    	col += texture2D( tColor, vUv.xy + ( vec2(  0.37,  0.15 ) * aspectcorrect ) * dofblur9 );
+    	col += texture2D( tColor, vUv.xy + ( vec2( -0.37, -0.15 ) * aspectcorrect ) * dofblur9 );
+    	col += texture2D( tColor, vUv.xy + ( vec2(  0.15, -0.37 ) * aspectcorrect ) * dofblur9 );
+
+    	col += texture2D( tColor, vUv.xy + ( vec2(  0.29,  0.29 ) * aspectcorrect ) * dofblur7 );
+    	col += texture2D( tColor, vUv.xy + ( vec2(  0.40,  0.0  ) * aspectcorrect ) * dofblur7 );
+    	col += texture2D( tColor, vUv.xy + ( vec2(  0.29, -0.29 ) * aspectcorrect ) * dofblur7 );
+    	col += texture2D( tColor, vUv.xy + ( vec2(  0.0,  -0.4  ) * aspectcorrect ) * dofblur7 );
+    	col += texture2D( tColor, vUv.xy + ( vec2( -0.29,  0.29 ) * aspectcorrect ) * dofblur7 );
+    	col += texture2D( tColor, vUv.xy + ( vec2( -0.4,   0.0  ) * aspectcorrect ) * dofblur7 );
+    	col += texture2D( tColor, vUv.xy + ( vec2( -0.29, -0.29 ) * aspectcorrect ) * dofblur7 );
+    	col += texture2D( tColor, vUv.xy + ( vec2(  0.0,   0.4  ) * aspectcorrect ) * dofblur7 );
+
+    	col += texture2D( tColor, vUv.xy + ( vec2(  0.29,  0.29 ) * aspectcorrect ) * dofblur4 );
+    	col += texture2D( tColor, vUv.xy + ( vec2(  0.4,   0.0  ) * aspectcorrect ) * dofblur4 );
+    	col += texture2D( tColor, vUv.xy + ( vec2(  0.29, -0.29 ) * aspectcorrect ) * dofblur4 );
+    	col += texture2D( tColor, vUv.xy + ( vec2(  0.0,  -0.4  ) * aspectcorrect ) * dofblur4 );
+    	col += texture2D( tColor, vUv.xy + ( vec2( -0.29,  0.29 ) * aspectcorrect ) * dofblur4 );
+    	col += texture2D( tColor, vUv.xy + ( vec2( -0.4,   0.0  ) * aspectcorrect ) * dofblur4 );
+    	col += texture2D( tColor, vUv.xy + ( vec2( -0.29, -0.29 ) * aspectcorrect ) * dofblur4 );
+    	col += texture2D( tColor, vUv.xy + ( vec2(  0.0,   0.4  ) * aspectcorrect ) * dofblur4 );
+
+    	gl_FragColor = col / 41.0;
+    	gl_FragColor.a = 1.0;
+
+    }
+  `,
 }
diff --git a/src/shaders/BokehShader2.ts b/src/shaders/BokehShader2.ts
index f9734ebe..28f6bca6 100644
--- a/src/shaders/BokehShader2.ts
+++ b/src/shaders/BokehShader2.ts
@@ -78,305 +78,305 @@ export const BokehShader2: {
     pentagon: { value: 0 },
 
     shaderFocus: { value: 1 },
-    focusCoords: { value: new Vector2() },
+    focusCoords: { value: /* @__PURE__ */ new Vector2() },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    '#include <common>',
+  fragmentShader: /* glsl */ `
+    #include <common>
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'uniform sampler2D tColor;',
-    'uniform sampler2D tDepth;',
-    'uniform float textureWidth;',
-    'uniform float textureHeight;',
+    uniform sampler2D tColor;
+    uniform sampler2D tDepth;
+    uniform float textureWidth;
+    uniform float textureHeight;
 
-    'uniform float focalDepth;  //focal distance value in meters, but you may use autofocus option below',
-    'uniform float focalLength; //focal length in mm',
-    'uniform float fstop; //f-stop value',
-    'uniform bool showFocus; //show debug focus point and focal range (red = focal point, green = focal range)',
+    uniform float focalDepth;  //focal distance value in meters, but you may use autofocus option below
+    uniform float focalLength; //focal length in mm
+    uniform float fstop; //f-stop value
+    uniform bool showFocus; //show debug focus point and focal range (red = focal point, green = focal range)
 
-    '/*',
-    'make sure that these two values are the same for your camera, otherwise distances will be wrong.',
-    '*/',
+    /*
+    make sure that these two values are the same for your camera, otherwise distances will be wrong.
+    */
 
-    'uniform float znear; // camera clipping start',
-    'uniform float zfar; // camera clipping end',
+    uniform float znear; // camera clipping start
+    uniform float zfar; // camera clipping end
 
-    '//------------------------------------------',
-    '//user variables',
+    //------------------------------------------
+    //user variables
 
-    'const int samples = SAMPLES; //samples on the first ring',
-    'const int rings = RINGS; //ring count',
+    const int samples = SAMPLES; //samples on the first ring
+    const int rings = RINGS; //ring count
 
-    'const int maxringsamples = rings * samples;',
+    const int maxringsamples = rings * samples;
 
-    'uniform bool manualdof; // manual dof calculation',
-    'float ndofstart = 1.0; // near dof blur start',
-    'float ndofdist = 2.0; // near dof blur falloff distance',
-    'float fdofstart = 1.0; // far dof blur start',
-    'float fdofdist = 3.0; // far dof blur falloff distance',
+    uniform bool manualdof; // manual dof calculation
+    float ndofstart = 1.0; // near dof blur start
+    float ndofdist = 2.0; // near dof blur falloff distance
+    float fdofstart = 1.0; // far dof blur start
+    float fdofdist = 3.0; // far dof blur falloff distance
 
-    'float CoC = 0.03; //circle of confusion size in mm (35mm film = 0.03mm)',
+    float CoC = 0.03; //circle of confusion size in mm (35mm film = 0.03mm)
 
-    'uniform bool vignetting; // use optical lens vignetting',
+    uniform bool vignetting; // use optical lens vignetting
 
-    'float vignout = 1.3; // vignetting outer border',
-    'float vignin = 0.0; // vignetting inner border',
-    'float vignfade = 22.0; // f-stops till vignete fades',
+    float vignout = 1.3; // vignetting outer border
+    float vignin = 0.0; // vignetting inner border
+    float vignfade = 22.0; // f-stops till vignete fades
 
-    'uniform bool shaderFocus;',
-    '// disable if you use external focalDepth value',
+    uniform bool shaderFocus;
+    // disable if you use external focalDepth value
 
-    'uniform vec2 focusCoords;',
-    '// autofocus point on screen (0.0,0.0 - left lower corner, 1.0,1.0 - upper right)',
-    '// if center of screen use vec2(0.5, 0.5);',
+    uniform vec2 focusCoords;
+    // autofocus point on screen (0.0,0.0 - left lower corner, 1.0,1.0 - upper right)
+    // if center of screen use vec2(0.5, 0.5);
 
-    'uniform float maxblur;',
-    '//clamp value of max blur (0.0 = no blur, 1.0 default)',
+    uniform float maxblur;
+    //clamp value of max blur (0.0 = no blur, 1.0 default)
 
-    'uniform float threshold; // highlight threshold;',
-    'uniform float gain; // highlight gain;',
+    uniform float threshold; // highlight threshold;
+    uniform float gain; // highlight gain;
 
-    'uniform float bias; // bokeh edge bias',
-    'uniform float fringe; // bokeh chromatic aberration / fringing',
+    uniform float bias; // bokeh edge bias
+    uniform float fringe; // bokeh chromatic aberration / fringing
 
-    'uniform bool noise; //use noise instead of pattern for sample dithering',
+    uniform bool noise; //use noise instead of pattern for sample dithering
 
-    'uniform float dithering;',
+    uniform float dithering;
 
-    'uniform bool depthblur; // blur the depth buffer',
-    'float dbsize = 1.25; // depth blur size',
+    uniform bool depthblur; // blur the depth buffer
+    float dbsize = 1.25; // depth blur size
 
-    '/*',
-    'next part is experimental',
-    'not looking good with small sample and ring count',
-    'looks okay starting from samples = 4, rings = 4',
-    '*/',
+    /*
+    next part is experimental
+    not looking good with small sample and ring count
+    looks okay starting from samples = 4, rings = 4
+    */
 
-    'uniform bool pentagon; //use pentagon as bokeh shape?',
-    'float feather = 0.4; //pentagon shape feather',
+    uniform bool pentagon; //use pentagon as bokeh shape?
+    float feather = 0.4; //pentagon shape feather
 
-    '//------------------------------------------',
+    //------------------------------------------
 
-    'float penta(vec2 coords) {',
-    '	//pentagonal shape',
-    '	float scale = float(rings) - 1.3;',
-    '	vec4  HS0 = vec4( 1.0,         0.0,         0.0,  1.0);',
-    '	vec4  HS1 = vec4( 0.309016994, 0.951056516, 0.0,  1.0);',
-    '	vec4  HS2 = vec4(-0.809016994, 0.587785252, 0.0,  1.0);',
-    '	vec4  HS3 = vec4(-0.809016994,-0.587785252, 0.0,  1.0);',
-    '	vec4  HS4 = vec4( 0.309016994,-0.951056516, 0.0,  1.0);',
-    '	vec4  HS5 = vec4( 0.0        ,0.0         , 1.0,  1.0);',
+    float penta(vec2 coords) {
+    	//pentagonal shape
+    	float scale = float(rings) - 1.3;
+    	vec4  HS0 = vec4( 1.0,         0.0,         0.0,  1.0);
+    	vec4  HS1 = vec4( 0.309016994, 0.951056516, 0.0,  1.0);
+    	vec4  HS2 = vec4(-0.809016994, 0.587785252, 0.0,  1.0);
+    	vec4  HS3 = vec4(-0.809016994,-0.587785252, 0.0,  1.0);
+    	vec4  HS4 = vec4( 0.309016994,-0.951056516, 0.0,  1.0);
+    	vec4  HS5 = vec4( 0.0        ,0.0         , 1.0,  1.0);
 
-    '	vec4  one = vec4( 1.0 );',
+    	vec4  one = vec4( 1.0 );
 
-    '	vec4 P = vec4((coords),vec2(scale, scale));',
+    	vec4 P = vec4((coords),vec2(scale, scale));
 
-    '	vec4 dist = vec4(0.0);',
-    '	float inorout = -4.0;',
+    	vec4 dist = vec4(0.0);
+    	float inorout = -4.0;
 
-    '	dist.x = dot( P, HS0 );',
-    '	dist.y = dot( P, HS1 );',
-    '	dist.z = dot( P, HS2 );',
-    '	dist.w = dot( P, HS3 );',
+    	dist.x = dot( P, HS0 );
+    	dist.y = dot( P, HS1 );
+    	dist.z = dot( P, HS2 );
+    	dist.w = dot( P, HS3 );
 
-    '	dist = smoothstep( -feather, feather, dist );',
+    	dist = smoothstep( -feather, feather, dist );
 
-    '	inorout += dot( dist, one );',
+    	inorout += dot( dist, one );
 
-    '	dist.x = dot( P, HS4 );',
-    '	dist.y = HS5.w - abs( P.z );',
+    	dist.x = dot( P, HS4 );
+    	dist.y = HS5.w - abs( P.z );
 
-    '	dist = smoothstep( -feather, feather, dist );',
-    '	inorout += dist.x;',
+    	dist = smoothstep( -feather, feather, dist );
+    	inorout += dist.x;
 
-    '	return clamp( inorout, 0.0, 1.0 );',
-    '}',
+    	return clamp( inorout, 0.0, 1.0 );
+    }
 
-    'float bdepth(vec2 coords) {',
-    '	// Depth buffer blur',
-    '	float d = 0.0;',
-    '	float kernel[9];',
-    '	vec2 offset[9];',
+    float bdepth(vec2 coords) {
+    	// Depth buffer blur
+    	float d = 0.0;
+    	float kernel[9];
+    	vec2 offset[9];
 
-    '	vec2 wh = vec2(1.0/textureWidth,1.0/textureHeight) * dbsize;',
+    	vec2 wh = vec2(1.0/textureWidth,1.0/textureHeight) * dbsize;
 
-    '	offset[0] = vec2(-wh.x,-wh.y);',
-    '	offset[1] = vec2( 0.0, -wh.y);',
-    '	offset[2] = vec2( wh.x -wh.y);',
+    	offset[0] = vec2(-wh.x,-wh.y);
+    	offset[1] = vec2( 0.0, -wh.y);
+    	offset[2] = vec2( wh.x -wh.y);
 
-    '	offset[3] = vec2(-wh.x,  0.0);',
-    '	offset[4] = vec2( 0.0,   0.0);',
-    '	offset[5] = vec2( wh.x,  0.0);',
+    	offset[3] = vec2(-wh.x,  0.0);
+    	offset[4] = vec2( 0.0,   0.0);
+    	offset[5] = vec2( wh.x,  0.0);
 
-    '	offset[6] = vec2(-wh.x, wh.y);',
-    '	offset[7] = vec2( 0.0,  wh.y);',
-    '	offset[8] = vec2( wh.x, wh.y);',
+    	offset[6] = vec2(-wh.x, wh.y);
+    	offset[7] = vec2( 0.0,  wh.y);
+    	offset[8] = vec2( wh.x, wh.y);
 
-    '	kernel[0] = 1.0/16.0;   kernel[1] = 2.0/16.0;   kernel[2] = 1.0/16.0;',
-    '	kernel[3] = 2.0/16.0;   kernel[4] = 4.0/16.0;   kernel[5] = 2.0/16.0;',
-    '	kernel[6] = 1.0/16.0;   kernel[7] = 2.0/16.0;   kernel[8] = 1.0/16.0;',
+    	kernel[0] = 1.0/16.0;   kernel[1] = 2.0/16.0;   kernel[2] = 1.0/16.0;
+    	kernel[3] = 2.0/16.0;   kernel[4] = 4.0/16.0;   kernel[5] = 2.0/16.0;
+    	kernel[6] = 1.0/16.0;   kernel[7] = 2.0/16.0;   kernel[8] = 1.0/16.0;
 
-    '	for( int i=0; i<9; i++ ) {',
-    '		float tmp = texture2D(tDepth, coords + offset[i]).r;',
-    '		d += tmp * kernel[i];',
-    '	}',
+    	for( int i=0; i<9; i++ ) {
+    		float tmp = texture2D(tDepth, coords + offset[i]).r;
+    		d += tmp * kernel[i];
+    	}
 
-    '	return d;',
-    '}',
+    	return d;
+    }
 
-    'vec3 color(vec2 coords,float blur) {',
-    '	//processing the sample',
+    vec3 color(vec2 coords,float blur) {
+    	//processing the sample
 
-    '	vec3 col = vec3(0.0);',
-    '	vec2 texel = vec2(1.0/textureWidth,1.0/textureHeight);',
+    	vec3 col = vec3(0.0);
+    	vec2 texel = vec2(1.0/textureWidth,1.0/textureHeight);
 
-    '	col.r = texture2D(tColor,coords + vec2(0.0,1.0)*texel*fringe*blur).r;',
-    '	col.g = texture2D(tColor,coords + vec2(-0.866,-0.5)*texel*fringe*blur).g;',
-    '	col.b = texture2D(tColor,coords + vec2(0.866,-0.5)*texel*fringe*blur).b;',
+    	col.r = texture2D(tColor,coords + vec2(0.0,1.0)*texel*fringe*blur).r;
+    	col.g = texture2D(tColor,coords + vec2(-0.866,-0.5)*texel*fringe*blur).g;
+    	col.b = texture2D(tColor,coords + vec2(0.866,-0.5)*texel*fringe*blur).b;
 
-    '	vec3 lumcoeff = vec3(0.299,0.587,0.114);',
-    '	float lum = dot(col.rgb, lumcoeff);',
-    '	float thresh = max((lum-threshold)*gain, 0.0);',
-    '	return col+mix(vec3(0.0),col,thresh*blur);',
-    '}',
+    	vec3 lumcoeff = vec3(0.299,0.587,0.114);
+    	float lum = dot(col.rgb, lumcoeff);
+    	float thresh = max((lum-threshold)*gain, 0.0);
+    	return col+mix(vec3(0.0),col,thresh*blur);
+    }
 
-    'vec3 debugFocus(vec3 col, float blur, float depth) {',
-    '	float edge = 0.002*depth; //distance based edge smoothing',
-    '	float m = clamp(smoothstep(0.0,edge,blur),0.0,1.0);',
-    '	float e = clamp(smoothstep(1.0-edge,1.0,blur),0.0,1.0);',
+    vec3 debugFocus(vec3 col, float blur, float depth) {
+    	float edge = 0.002*depth; //distance based edge smoothing
+    	float m = clamp(smoothstep(0.0,edge,blur),0.0,1.0);
+    	float e = clamp(smoothstep(1.0-edge,1.0,blur),0.0,1.0);
 
-    '	col = mix(col,vec3(1.0,0.5,0.0),(1.0-m)*0.6);',
-    '	col = mix(col,vec3(0.0,0.5,1.0),((1.0-e)-(1.0-m))*0.2);',
+    	col = mix(col,vec3(1.0,0.5,0.0),(1.0-m)*0.6);
+    	col = mix(col,vec3(0.0,0.5,1.0),((1.0-e)-(1.0-m))*0.2);
 
-    '	return col;',
-    '}',
+    	return col;
+    }
 
-    'float linearize(float depth) {',
-    '	return -zfar * znear / (depth * (zfar - znear) - zfar);',
-    '}',
+    float linearize(float depth) {
+    	return -zfar * znear / (depth * (zfar - znear) - zfar);
+    }
 
-    'float vignette() {',
-    '	float dist = distance(vUv.xy, vec2(0.5,0.5));',
-    '	dist = smoothstep(vignout+(fstop/vignfade), vignin+(fstop/vignfade), dist);',
-    '	return clamp(dist,0.0,1.0);',
-    '}',
+    float vignette() {
+    	float dist = distance(vUv.xy, vec2(0.5,0.5));
+    	dist = smoothstep(vignout+(fstop/vignfade), vignin+(fstop/vignfade), dist);
+    	return clamp(dist,0.0,1.0);
+    }
 
-    'float gather(float i, float j, int ringsamples, inout vec3 col, float w, float h, float blur) {',
-    '	float rings2 = float(rings);',
-    '	float step = PI*2.0 / float(ringsamples);',
-    '	float pw = cos(j*step)*i;',
-    '	float ph = sin(j*step)*i;',
-    '	float p = 1.0;',
-    '	if (pentagon) {',
-    '		p = penta(vec2(pw,ph));',
-    '	}',
-    '	col += color(vUv.xy + vec2(pw*w,ph*h), blur) * mix(1.0, i/rings2, bias) * p;',
-    '	return 1.0 * mix(1.0, i /rings2, bias) * p;',
-    '}',
+    float gather(float i, float j, int ringsamples, inout vec3 col, float w, float h, float blur) {
+    	float rings2 = float(rings);
+    	float step = PI*2.0 / float(ringsamples);
+    	float pw = cos(j*step)*i;
+    	float ph = sin(j*step)*i;
+    	float p = 1.0;
+    	if (pentagon) {
+    		p = penta(vec2(pw,ph));
+    	}
+    	col += color(vUv.xy + vec2(pw*w,ph*h), blur) * mix(1.0, i/rings2, bias) * p;
+    	return 1.0 * mix(1.0, i /rings2, bias) * p;
+    }
 
-    'void main() {',
-    '	//scene depth calculation',
+    void main() {
+    	//scene depth calculation
 
-    '	float depth = linearize(texture2D(tDepth,vUv.xy).x);',
+    	float depth = linearize(texture2D(tDepth,vUv.xy).x);
 
-    '	// Blur depth?',
-    '	if ( depthblur ) {',
-    '		depth = linearize(bdepth(vUv.xy));',
-    '	}',
+    	// Blur depth?
+    	if ( depthblur ) {
+    		depth = linearize(bdepth(vUv.xy));
+    	}
 
-    '	//focal plane calculation',
+    	//focal plane calculation
 
-    '	float fDepth = focalDepth;',
+    	float fDepth = focalDepth;
 
-    '	if (shaderFocus) {',
+    	if (shaderFocus) {
 
-    '		fDepth = linearize(texture2D(tDepth,focusCoords).x);',
+    		fDepth = linearize(texture2D(tDepth,focusCoords).x);
 
-    '	}',
+    	}
 
-    '	// dof blur factor calculation',
+    	// dof blur factor calculation
 
-    '	float blur = 0.0;',
+    	float blur = 0.0;
 
-    '	if (manualdof) {',
-    '		float a = depth-fDepth; // Focal plane',
-    '		float b = (a-fdofstart)/fdofdist; // Far DoF',
-    '		float c = (-a-ndofstart)/ndofdist; // Near Dof',
-    '		blur = (a>0.0) ? b : c;',
-    '	} else {',
-    '		float f = focalLength; // focal length in mm',
-    '		float d = fDepth*1000.0; // focal plane in mm',
-    '		float o = depth*1000.0; // depth in mm',
+    	if (manualdof) {
+    		float a = depth-fDepth; // Focal plane
+    		float b = (a-fdofstart)/fdofdist; // Far DoF
+    		float c = (-a-ndofstart)/ndofdist; // Near Dof
+    		blur = (a>0.0) ? b : c;
+    	} else {
+    		float f = focalLength; // focal length in mm
+    		float d = fDepth*1000.0; // focal plane in mm
+    		float o = depth*1000.0; // depth in mm
 
-    '		float a = (o*f)/(o-f);',
-    '		float b = (d*f)/(d-f);',
-    '		float c = (d-f)/(d*fstop*CoC);',
+    		float a = (o*f)/(o-f);
+    		float b = (d*f)/(d-f);
+    		float c = (d-f)/(d*fstop*CoC);
 
-    '		blur = abs(a-b)*c;',
-    '	}',
+    		blur = abs(a-b)*c;
+    	}
 
-    '	blur = clamp(blur,0.0,1.0);',
+    	blur = clamp(blur,0.0,1.0);
 
-    '	// calculation of pattern for dithering',
+    	// calculation of pattern for dithering
 
-    '	vec2 noise = vec2(rand(vUv.xy), rand( vUv.xy + vec2( 0.4, 0.6 ) ) )*dithering*blur;',
+    	vec2 noise = vec2(rand(vUv.xy), rand( vUv.xy + vec2( 0.4, 0.6 ) ) )*dithering*blur;
 
-    '	// getting blur x and y step factor',
+    	// getting blur x and y step factor
 
-    '	float w = (1.0/textureWidth)*blur*maxblur+noise.x;',
-    '	float h = (1.0/textureHeight)*blur*maxblur+noise.y;',
+    	float w = (1.0/textureWidth)*blur*maxblur+noise.x;
+    	float h = (1.0/textureHeight)*blur*maxblur+noise.y;
 
-    '	// calculation of final color',
+    	// calculation of final color
 
-    '	vec3 col = vec3(0.0);',
+    	vec3 col = vec3(0.0);
 
-    '	if(blur < 0.05) {',
-    '		//some optimization thingy',
-    '		col = texture2D(tColor, vUv.xy).rgb;',
-    '	} else {',
-    '		col = texture2D(tColor, vUv.xy).rgb;',
-    '		float s = 1.0;',
-    '		int ringsamples;',
+    	if(blur < 0.05) {
+    		//some optimization thingy
+    		col = texture2D(tColor, vUv.xy).rgb;
+    	} else {
+    		col = texture2D(tColor, vUv.xy).rgb;
+    		float s = 1.0;
+    		int ringsamples;
 
-    '		for (int i = 1; i <= rings; i++) {',
-    '			/*unboxstart*/',
-    '			ringsamples = i * samples;',
+    		for (int i = 1; i <= rings; i++) {
+    			/*unboxstart*/
+    			ringsamples = i * samples;
 
-    '			for (int j = 0 ; j < maxringsamples ; j++) {',
-    '				if (j >= ringsamples) break;',
-    '				s += gather(float(i), float(j), ringsamples, col, w, h, blur);',
-    '			}',
-    '			/*unboxend*/',
-    '		}',
+    			for (int j = 0 ; j < maxringsamples ; j++) {
+    				if (j >= ringsamples) break;
+    				s += gather(float(i), float(j), ringsamples, col, w, h, blur);
+    			}
+    			/*unboxend*/
+    		}
 
-    '		col /= s; //divide by sample count',
-    '	}',
+    		col /= s; //divide by sample count
+    	}
 
-    '	if (showFocus) {',
-    '		col = debugFocus(col, blur, depth);',
-    '	}',
+    	if (showFocus) {
+    		col = debugFocus(col, blur, depth);
+    	}
 
-    '	if (vignetting) {',
-    '		col *= vignette();',
-    '	}',
+    	if (vignetting) {
+    		col *= vignette();
+    	}
 
-    '	gl_FragColor.rgb = col;',
-    '	gl_FragColor.a = 1.0;',
-    '} ',
-  ].join('\n'),
+    	gl_FragColor.rgb = col;
+    	gl_FragColor.a = 1.0;
+    } 
+  `,
 }
 
 export const BokehDepthShader = {
@@ -385,30 +385,30 @@ export const BokehDepthShader = {
     mFar: { value: 1000.0 },
   },
 
-  vertexShader: [
-    'varying float vViewZDepth;',
+  vertexShader: /* glsl */ `
+    varying float vViewZDepth;
 
-    'void main() {',
+    void main() {
 
-    '	#include <begin_vertex>',
-    '	#include <project_vertex>',
+    	#include <begin_vertex>
+    	#include <project_vertex>
 
-    '	vViewZDepth = - mvPosition.z;',
+    	vViewZDepth = - mvPosition.z;
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform float mNear;',
-    'uniform float mFar;',
+  fragmentShader: /* glsl */ `
+    uniform float mNear;
+    uniform float mFar;
 
-    'varying float vViewZDepth;',
+    varying float vViewZDepth;
 
-    'void main() {',
+    void main() {
 
-    '	float color = 1.0 - smoothstep( mNear, mFar, vViewZDepth );',
-    '	gl_FragColor = vec4( vec3( color ), 1.0 );',
+    	float color = 1.0 - smoothstep( mNear, mFar, vViewZDepth );
+    	gl_FragColor = vec4( vec3( color ), 1.0 );
 
-    '} ',
-  ].join('\n'),
+    } 
+  `,
 }
diff --git a/src/shaders/BrightnessContrastShader.ts b/src/shaders/BrightnessContrastShader.ts
index 56c15b3a..c2d77b3a 100644
--- a/src/shaders/BrightnessContrastShader.ts
+++ b/src/shaders/BrightnessContrastShader.ts
@@ -12,37 +12,37 @@ export const BrightnessContrastShader = {
     contrast: { value: 0 },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
+    	vUv = uv;
 
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform sampler2D tDiffuse;',
-    'uniform float brightness;',
-    'uniform float contrast;',
+  fragmentShader: /* glsl */ `
+    uniform sampler2D tDiffuse;
+    uniform float brightness;
+    uniform float contrast;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	gl_FragColor = texture2D( tDiffuse, vUv );',
+    	gl_FragColor = texture2D( tDiffuse, vUv );
 
-    '	gl_FragColor.rgb += brightness;',
+    	gl_FragColor.rgb += brightness;
 
-    '	if (contrast > 0.0) {',
-    '		gl_FragColor.rgb = (gl_FragColor.rgb - 0.5) / (1.0 - contrast) + 0.5;',
-    '	} else {',
-    '		gl_FragColor.rgb = (gl_FragColor.rgb - 0.5) * (1.0 + contrast) + 0.5;',
-    '	}',
+    	if (contrast > 0.0) {
+    		gl_FragColor.rgb = (gl_FragColor.rgb - 0.5) / (1.0 - contrast) + 0.5;
+    	} else {
+    		gl_FragColor.rgb = (gl_FragColor.rgb - 0.5) * (1.0 + contrast) + 0.5;
+    	}
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/ColorCorrectionShader.ts b/src/shaders/ColorCorrectionShader.ts
index 2e63a4b3..29e77305 100644
--- a/src/shaders/ColorCorrectionShader.ts
+++ b/src/shaders/ColorCorrectionShader.ts
@@ -7,36 +7,36 @@ import { Vector3 } from 'three'
 export const ColorCorrectionShader = {
   uniforms: {
     tDiffuse: { value: null },
-    powRGB: { value: new Vector3(2, 2, 2) },
-    mulRGB: { value: new Vector3(1, 1, 1) },
-    addRGB: { value: new Vector3(0, 0, 0) },
+    powRGB: { value: /* @__PURE__ */ new Vector3(2, 2, 2) },
+    mulRGB: { value: /* @__PURE__ */ new Vector3(1, 1, 1) },
+    addRGB: { value: /* @__PURE__ */ new Vector3(0, 0, 0) },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
+    	vUv = uv;
 
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform sampler2D tDiffuse;',
-    'uniform vec3 powRGB;',
-    'uniform vec3 mulRGB;',
-    'uniform vec3 addRGB;',
+  fragmentShader: /* glsl */ `
+    uniform sampler2D tDiffuse;
+    uniform vec3 powRGB;
+    uniform vec3 mulRGB;
+    uniform vec3 addRGB;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	gl_FragColor = texture2D( tDiffuse, vUv );',
-    '	gl_FragColor.rgb = mulRGB * pow( ( gl_FragColor.rgb + addRGB ), powRGB );',
+    	gl_FragColor = texture2D( tDiffuse, vUv );
+    	gl_FragColor.rgb = mulRGB * pow( ( gl_FragColor.rgb + addRGB ), powRGB );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/ColorifyShader.ts b/src/shaders/ColorifyShader.ts
index 68f74c5f..0554126b 100644
--- a/src/shaders/ColorifyShader.ts
+++ b/src/shaders/ColorifyShader.ts
@@ -7,35 +7,35 @@ import { Color } from 'three'
 export const ColorifyShader = {
   uniforms: {
     tDiffuse: { value: null },
-    color: { value: new Color(0xffffff) },
+    color: { value: /* @__PURE__ */ new Color(0xffffff) },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform vec3 color;',
-    'uniform sampler2D tDiffuse;',
+  fragmentShader: /* glsl */ `
+    uniform vec3 color;
+    uniform sampler2D tDiffuse;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vec4 texel = texture2D( tDiffuse, vUv );',
+    	vec4 texel = texture2D( tDiffuse, vUv );
 
-    '	vec3 luma = vec3( 0.299, 0.587, 0.114 );',
-    '	float v = dot( texel.xyz, luma );',
+    	vec3 luma = vec3( 0.299, 0.587, 0.114 );
+    	float v = dot( texel.xyz, luma );
 
-    '	gl_FragColor = vec4( v * color, texel.w );',
+    	gl_FragColor = vec4( v * color, texel.w );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/ConvolutionShader.ts b/src/shaders/ConvolutionShader.ts
index 3d1c5126..5a18083e 100644
--- a/src/shaders/ConvolutionShader.ts
+++ b/src/shaders/ConvolutionShader.ts
@@ -32,47 +32,47 @@ export const ConvolutionShader: IConvolutionShader = {
 
   uniforms: {
     tDiffuse: { value: null },
-    uImageIncrement: { value: new Vector2(0.001953125, 0.0) },
+    uImageIncrement: { value: /* @__PURE__ */ new Vector2(0.001953125, 0.0) },
     cKernel: { value: [] },
   },
 
-  vertexShader: [
-    'uniform vec2 uImageIncrement;',
+  vertexShader: /* glsl */ `
+    uniform vec2 uImageIncrement;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv - ( ( KERNEL_SIZE_FLOAT - 1.0 ) / 2.0 ) * uImageIncrement;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv - ( ( KERNEL_SIZE_FLOAT - 1.0 ) / 2.0 ) * uImageIncrement;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform float cKernel[ KERNEL_SIZE_INT ];',
+  fragmentShader: /* glsl */ `
+    uniform float cKernel[ KERNEL_SIZE_INT ];
 
-    'uniform sampler2D tDiffuse;',
-    'uniform vec2 uImageIncrement;',
+    uniform sampler2D tDiffuse;
+    uniform vec2 uImageIncrement;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vec2 imageCoord = vUv;',
-    '	vec4 sum = vec4( 0.0, 0.0, 0.0, 0.0 );',
+    	vec2 imageCoord = vUv;
+    	vec4 sum = vec4( 0.0, 0.0, 0.0, 0.0 );
 
-    '	for( int i = 0; i < KERNEL_SIZE_INT; i ++ ) {',
+    	for( int i = 0; i < KERNEL_SIZE_INT; i ++ ) {
 
-    '		sum += texture2D( tDiffuse, imageCoord ) * cKernel[ i ];',
-    '		imageCoord += uImageIncrement;',
+    		sum += texture2D( tDiffuse, imageCoord ) * cKernel[ i ];
+    		imageCoord += uImageIncrement;
 
-    '	}',
+    	}
 
-    '	gl_FragColor = sum;',
+    	gl_FragColor = sum;
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
   buildKernel: function (sigma) {
     // We lop off the sqrt(2 * pi) * sigma term, since we're going to normalize anyway.
diff --git a/src/shaders/CopyShader.ts b/src/shaders/CopyShader.ts
index ad38d817..3bae6f68 100644
--- a/src/shaders/CopyShader.ts
+++ b/src/shaders/CopyShader.ts
@@ -18,29 +18,29 @@ export const CopyShader: ICopyShader = {
     opacity: { value: 1.0 },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform float opacity;',
+  fragmentShader: /* glsl */ `
+    uniform float opacity;
 
-    'uniform sampler2D tDiffuse;',
+    uniform sampler2D tDiffuse;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vec4 texel = texture2D( tDiffuse, vUv );',
-    '	gl_FragColor = opacity * texel;',
+    	vec4 texel = texture2D( tDiffuse, vUv );
+    	gl_FragColor = opacity * texel;
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/DOFMipMapShader.ts b/src/shaders/DOFMipMapShader.ts
index 00c38c52..6b068ea3 100644
--- a/src/shaders/DOFMipMapShader.ts
+++ b/src/shaders/DOFMipMapShader.ts
@@ -12,37 +12,37 @@ export const DOFMipMapShader = {
     maxblur: { value: 1.0 },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform float focus;',
-    'uniform float maxblur;',
+  fragmentShader: /* glsl */ `
+    uniform float focus;
+    uniform float maxblur;
 
-    'uniform sampler2D tColor;',
-    'uniform sampler2D tDepth;',
+    uniform sampler2D tColor;
+    uniform sampler2D tDepth;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vec4 depth = texture2D( tDepth, vUv );',
+    	vec4 depth = texture2D( tDepth, vUv );
 
-    '	float factor = depth.x - focus;',
+    	float factor = depth.x - focus;
 
-    '	vec4 col = texture2D( tColor, vUv, 2.0 * maxblur * abs( focus - depth.x ) );',
+    	vec4 col = texture2D( tColor, vUv, 2.0 * maxblur * abs( focus - depth.x ) );
 
-    '	gl_FragColor = col;',
-    '	gl_FragColor.a = 1.0;',
+    	gl_FragColor = col;
+    	gl_FragColor.a = 1.0;
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/DepthLimitedBlurShader.ts b/src/shaders/DepthLimitedBlurShader.ts
index 2e962893..ddff62ec 100644
--- a/src/shaders/DepthLimitedBlurShader.ts
+++ b/src/shaders/DepthLimitedBlurShader.ts
@@ -33,104 +33,104 @@ export const DepthLimitedBlurShader: IDepthLimitedBlurShader = {
   },
   uniforms: {
     tDiffuse: { value: null },
-    size: { value: new Vector2(512, 512) },
-    sampleUvOffsets: { value: [new Vector2(0, 0)] },
+    size: { value: /* @__PURE__ */ new Vector2(512, 512) },
+    sampleUvOffsets: { value: [/* @__PURE__ */ new Vector2(0, 0)] },
     sampleWeights: { value: [1.0] },
     tDepth: { value: null },
     cameraNear: { value: 10 },
     cameraFar: { value: 1000 },
     depthCutoff: { value: 10 },
   },
-  vertexShader: [
-    '#include <common>',
+  vertexShader: /* glsl */ `
+    #include <common>
 
-    'uniform vec2 size;',
+    uniform vec2 size;
 
-    'varying vec2 vUv;',
-    'varying vec2 vInvSize;',
+    varying vec2 vUv;
+    varying vec2 vInvSize;
 
-    'void main() {',
-    '	vUv = uv;',
-    '	vInvSize = 1.0 / size;',
+    void main() {
+    	vUv = uv;
+    	vInvSize = 1.0 / size;
 
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
-    '}',
-  ].join('\n'),
-  fragmentShader: [
-    '#include <common>',
-    '#include <packing>',
-
-    'uniform sampler2D tDiffuse;',
-    'uniform sampler2D tDepth;',
-
-    'uniform float cameraNear;',
-    'uniform float cameraFar;',
-    'uniform float depthCutoff;',
-
-    'uniform vec2 sampleUvOffsets[ KERNEL_RADIUS + 1 ];',
-    'uniform float sampleWeights[ KERNEL_RADIUS + 1 ];',
-
-    'varying vec2 vUv;',
-    'varying vec2 vInvSize;',
-
-    'float getDepth( const in vec2 screenPosition ) {',
-    '	#if DEPTH_PACKING == 1',
-    '	return unpackRGBAToDepth( texture2D( tDepth, screenPosition ) );',
-    '	#else',
-    '	return texture2D( tDepth, screenPosition ).x;',
-    '	#endif',
-    '}',
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    }
+  `,
+  fragmentShader: /* glsl */ `
+    #include <common>
+    #include <packing>
+
+    uniform sampler2D tDiffuse;
+    uniform sampler2D tDepth;
+
+    uniform float cameraNear;
+    uniform float cameraFar;
+    uniform float depthCutoff;
+
+    uniform vec2 sampleUvOffsets[ KERNEL_RADIUS + 1 ];
+    uniform float sampleWeights[ KERNEL_RADIUS + 1 ];
+
+    varying vec2 vUv;
+    varying vec2 vInvSize;
+
+    float getDepth( const in vec2 screenPosition ) {
+    	#if DEPTH_PACKING == 1
+    	return unpackRGBAToDepth( texture2D( tDepth, screenPosition ) );
+    	#else
+    	return texture2D( tDepth, screenPosition ).x;
+    	#endif
+    }
 
-    'float getViewZ( const in float depth ) {',
-    '	#if PERSPECTIVE_CAMERA == 1',
-    '	return perspectiveDepthToViewZ( depth, cameraNear, cameraFar );',
-    '	#else',
-    '	return orthographicDepthToViewZ( depth, cameraNear, cameraFar );',
-    '	#endif',
-    '}',
+    float getViewZ( const in float depth ) {
+    	#if PERSPECTIVE_CAMERA == 1
+    	return perspectiveDepthToViewZ( depth, cameraNear, cameraFar );
+    	#else
+    	return orthographicDepthToViewZ( depth, cameraNear, cameraFar );
+    	#endif
+    }
 
-    'void main() {',
-    '	float depth = getDepth( vUv );',
-    '	if( depth >= ( 1.0 - EPSILON ) ) {',
-    '		discard;',
-    '	}',
+    void main() {
+    	float depth = getDepth( vUv );
+    	if( depth >= ( 1.0 - EPSILON ) ) {
+    		discard;
+    	}
 
-    '	float centerViewZ = -getViewZ( depth );',
-    '	bool rBreak = false, lBreak = false;',
+    	float centerViewZ = -getViewZ( depth );
+    	bool rBreak = false, lBreak = false;
 
-    '	float weightSum = sampleWeights[0];',
-    '	vec4 diffuseSum = texture2D( tDiffuse, vUv ) * weightSum;',
+    	float weightSum = sampleWeights[0];
+    	vec4 diffuseSum = texture2D( tDiffuse, vUv ) * weightSum;
 
-    '	for( int i = 1; i <= KERNEL_RADIUS; i ++ ) {',
+    	for( int i = 1; i <= KERNEL_RADIUS; i ++ ) {
 
-    '		float sampleWeight = sampleWeights[i];',
-    '		vec2 sampleUvOffset = sampleUvOffsets[i] * vInvSize;',
+    		float sampleWeight = sampleWeights[i];
+    		vec2 sampleUvOffset = sampleUvOffsets[i] * vInvSize;
 
-    '		vec2 sampleUv = vUv + sampleUvOffset;',
-    '		float viewZ = -getViewZ( getDepth( sampleUv ) );',
+    		vec2 sampleUv = vUv + sampleUvOffset;
+    		float viewZ = -getViewZ( getDepth( sampleUv ) );
 
-    '		if( abs( viewZ - centerViewZ ) > depthCutoff ) rBreak = true;',
+    		if( abs( viewZ - centerViewZ ) > depthCutoff ) rBreak = true;
 
-    '		if( ! rBreak ) {',
-    '			diffuseSum += texture2D( tDiffuse, sampleUv ) * sampleWeight;',
-    '			weightSum += sampleWeight;',
-    '		}',
+    		if( ! rBreak ) {
+    			diffuseSum += texture2D( tDiffuse, sampleUv ) * sampleWeight;
+    			weightSum += sampleWeight;
+    		}
 
-    '		sampleUv = vUv - sampleUvOffset;',
-    '		viewZ = -getViewZ( getDepth( sampleUv ) );',
+    		sampleUv = vUv - sampleUvOffset;
+    		viewZ = -getViewZ( getDepth( sampleUv ) );
 
-    '		if( abs( viewZ - centerViewZ ) > depthCutoff ) lBreak = true;',
+    		if( abs( viewZ - centerViewZ ) > depthCutoff ) lBreak = true;
 
-    '		if( ! lBreak ) {',
-    '			diffuseSum += texture2D( tDiffuse, sampleUv ) * sampleWeight;',
-    '			weightSum += sampleWeight;',
-    '		}',
+    		if( ! lBreak ) {
+    			diffuseSum += texture2D( tDiffuse, sampleUv ) * sampleWeight;
+    			weightSum += sampleWeight;
+    		}
 
-    '	}',
+    	}
 
-    '	gl_FragColor = diffuseSum / weightSum;',
-    '}',
-  ].join('\n'),
+    	gl_FragColor = diffuseSum / weightSum;
+    }
+  `,
 }
 
 export const BlurShaderUtils = {
diff --git a/src/shaders/DigitalGlitch.ts b/src/shaders/DigitalGlitch.ts
index 1a3ff844..c2244cf7 100644
--- a/src/shaders/DigitalGlitch.ts
+++ b/src/shaders/DigitalGlitch.ts
@@ -13,67 +13,72 @@ export const DigitalGlitch = {
     col_s: { value: 0.05 },
   },
 
-  vertexShader: `varying vec2 vUv;
-     void main() {
-     	 vUv = uv;
-     	 gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
-     }`,
+  vertexShader: /* glsl */ `
+		varying vec2 vUv;
 
-  fragmentShader: `uniform int byp; //should we apply the glitch ?
-     uniform sampler2D tDiffuse;
-     uniform sampler2D tDisp;
-     uniform float amount;
-     uniform float angle;
-     uniform float seed;
-     uniform float seed_x;
-     uniform float seed_y;
-     uniform float distortion_x;
-     uniform float distortion_y;
-     uniform float col_s;
+		void main() {
+			vUv = uv;
+			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+		}
+	`,
 
-     varying vec2 vUv;
+  fragmentShader: /* glsl */ `
+		uniform int byp; //should we apply the glitch ?
+		uniform sampler2D tDiffuse;
+		uniform sampler2D tDisp;
+		uniform float amount;
+		uniform float angle;
+		uniform float seed;
+		uniform float seed_x;
+		uniform float seed_y;
+		uniform float distortion_x;
+		uniform float distortion_y;
+		uniform float col_s;
 
-     float rand(vec2 co){
-     	 return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
-     }
+		varying vec2 vUv;
 
-     void main() {
-     	if(byp<1) {
-     		vec2 p = vUv;
-     		float xs = floor(gl_FragCoord.x / 0.5);
-     		float ys = floor(gl_FragCoord.y / 0.5);
-    //based on staffantans glitch shader for unity https://github.com/staffantan/unityglitch
-     		vec4 normal = texture2D (tDisp, p*seed*seed);
-     		if(p.y<distortion_x+col_s && p.y>distortion_x-col_s*seed) {
-     			if(seed_x>0.){
-     				p.y = 1. - (p.y + distortion_y);
-     			}
-     			else {
-     				p.y = distortion_y;
-     			}
-     		}
-     		if(p.x<distortion_y+col_s && p.x>distortion_y-col_s*seed) {
-     			if(seed_y>0.){
-     				p.x=distortion_x;
-     			}
-     			else {
-     				p.x = 1. - (p.x + distortion_x);
-     			}
-     		}
-     		p.x+=normal.x*seed_x*(seed/5.);
-     		p.y+=normal.y*seed_y*(seed/5.);
-    //base from RGB shift shader
-     		vec2 offset = amount * vec2( cos(angle), sin(angle));
-     		vec4 cr = texture2D(tDiffuse, p + offset);
-     		vec4 cga = texture2D(tDiffuse, p);
-     		vec4 cb = texture2D(tDiffuse, p - offset);
-     		gl_FragColor = vec4(cr.r, cga.g, cb.b, cga.a);
-    //add noise
-     		vec4 snow = 200.*amount*vec4(rand(vec2(xs * seed,ys * seed*50.))*0.2);
-     		gl_FragColor = gl_FragColor+ snow;
-     	}
-     	else {
-     		gl_FragColor=texture2D (tDiffuse, vUv);
-     	}
-    }`,
+		float rand(vec2 co){
+			return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
+		}
+
+		void main() {
+			if(byp<1) {
+				vec2 p = vUv;
+				float xs = floor(gl_FragCoord.x / 0.5);
+				float ys = floor(gl_FragCoord.y / 0.5);
+		//based on staffantans glitch shader for unity https://github.com/staffantan/unityglitch
+				vec4 normal = texture2D (tDisp, p*seed*seed);
+				if(p.y<distortion_x+col_s && p.y>distortion_x-col_s*seed) {
+					if(seed_x>0.){
+						p.y = 1. - (p.y + distortion_y);
+					}
+					else {
+						p.y = distortion_y;
+					}
+				}
+				if(p.x<distortion_y+col_s && p.x>distortion_y-col_s*seed) {
+					if(seed_y>0.){
+						p.x=distortion_x;
+					}
+					else {
+						p.x = 1. - (p.x + distortion_x);
+					}
+				}
+				p.x+=normal.x*seed_x*(seed/5.);
+				p.y+=normal.y*seed_y*(seed/5.);
+		//base from RGB shift shader
+				vec2 offset = amount * vec2( cos(angle), sin(angle));
+				vec4 cr = texture2D(tDiffuse, p + offset);
+				vec4 cga = texture2D(tDiffuse, p);
+				vec4 cb = texture2D(tDiffuse, p - offset);
+				gl_FragColor = vec4(cr.r, cga.g, cb.b, cga.a);
+		//add noise
+				vec4 snow = 200.*amount*vec4(rand(vec2(xs * seed,ys * seed*50.))*0.2);
+				gl_FragColor = gl_FragColor+ snow;
+			}
+			else {
+				gl_FragColor=texture2D (tDiffuse, vUv);
+			}
+		}
+`,
 }
diff --git a/src/shaders/DotScreenShader.ts b/src/shaders/DotScreenShader.ts
index aa01e7b1..83a205a8 100644
--- a/src/shaders/DotScreenShader.ts
+++ b/src/shaders/DotScreenShader.ts
@@ -9,52 +9,52 @@ import { Vector2 } from 'three'
 export const DotScreenShader = {
   uniforms: {
     tDiffuse: { value: null },
-    tSize: { value: new Vector2(256, 256) },
-    center: { value: new Vector2(0.5, 0.5) },
+    tSize: { value: /* @__PURE__ */ new Vector2(256, 256) },
+    center: { value: /* @__PURE__ */ new Vector2(0.5, 0.5) },
     angle: { value: 1.57 },
     scale: { value: 1.0 },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform vec2 center;',
-    'uniform float angle;',
-    'uniform float scale;',
-    'uniform vec2 tSize;',
+  fragmentShader: /* glsl */ `
+    uniform vec2 center;
+    uniform float angle;
+    uniform float scale;
+    uniform vec2 tSize;
 
-    'uniform sampler2D tDiffuse;',
+    uniform sampler2D tDiffuse;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'float pattern() {',
+    float pattern() {
 
-    '	float s = sin( angle ), c = cos( angle );',
+    	float s = sin( angle ), c = cos( angle );
 
-    '	vec2 tex = vUv * tSize - center;',
-    '	vec2 point = vec2( c * tex.x - s * tex.y, s * tex.x + c * tex.y ) * scale;',
+    	vec2 tex = vUv * tSize - center;
+    	vec2 point = vec2( c * tex.x - s * tex.y, s * tex.x + c * tex.y ) * scale;
 
-    '	return ( sin( point.x ) * sin( point.y ) ) * 4.0;',
+    	return ( sin( point.x ) * sin( point.y ) ) * 4.0;
 
-    '}',
+    }
 
-    'void main() {',
+    void main() {
 
-    '	vec4 color = texture2D( tDiffuse, vUv );',
+    	vec4 color = texture2D( tDiffuse, vUv );
 
-    '	float average = ( color.r + color.g + color.b ) / 3.0;',
+    	float average = ( color.r + color.g + color.b ) / 3.0;
 
-    '	gl_FragColor = vec4( vec3( average * 10.0 - 5.0 + pattern() ), color.a );',
+    	gl_FragColor = vec4( vec3( average * 10.0 - 5.0 + pattern() ), color.a );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/FXAAShader.ts b/src/shaders/FXAAShader.ts
index 795b5677..dbb313db 100644
--- a/src/shaders/FXAAShader.ts
+++ b/src/shaders/FXAAShader.ts
@@ -10,1099 +10,1099 @@ import { Vector2 } from 'three'
 export const FXAAShader = {
   uniforms: {
     tDiffuse: { value: null },
-    resolution: { value: new Vector2(1 / 1024, 1 / 512) },
+    resolution: { value: /* @__PURE__ */ new Vector2(1 / 1024, 1 / 512) },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'precision highp float;',
-    '',
-    'uniform sampler2D tDiffuse;',
-    '',
-    'uniform vec2 resolution;',
-    '',
-    'varying vec2 vUv;',
-    '',
-    '// FXAA 3.11 implementation by NVIDIA, ported to WebGL by Agost Biro (biro@archilogic.com)',
-    '',
-    '//----------------------------------------------------------------------------------',
-    '// File:        es3-keplerFXAAassetsshaders/FXAA_DefaultES.frag',
-    '// SDK Version: v3.00',
-    '// Email:       gameworks@nvidia.com',
-    '// Site:        http://developer.nvidia.com/',
-    '//',
-    '// Copyright (c) 2014-2015, NVIDIA CORPORATION. All rights reserved.',
-    '//',
-    '// Redistribution and use in source and binary forms, with or without',
-    '// modification, are permitted provided that the following conditions',
-    '// are met:',
-    '//  * Redistributions of source code must retain the above copyright',
-    '//    notice, this list of conditions and the following disclaimer.',
-    '//  * Redistributions in binary form must reproduce the above copyright',
-    '//    notice, this list of conditions and the following disclaimer in the',
-    '//    documentation and/or other materials provided with the distribution.',
-    '//  * Neither the name of NVIDIA CORPORATION nor the names of its',
-    '//    contributors may be used to endorse or promote products derived',
-    '//    from this software without specific prior written permission.',
-    '//',
-    "// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY",
-    '// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE',
-    '// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR',
-    '// PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR',
-    '// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,',
-    '// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,',
-    '// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR',
-    '// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY',
-    '// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT',
-    '// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE',
-    '// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.',
-    '//',
-    '//----------------------------------------------------------------------------------',
-    '',
-    '#define FXAA_PC 1',
-    '#define FXAA_GLSL_100 1',
-    '#define FXAA_QUALITY_PRESET 12',
-    '',
-    '#define FXAA_GREEN_AS_LUMA 1',
-    '',
-    '/*--------------------------------------------------------------------------*/',
-    '#ifndef FXAA_PC_CONSOLE',
-    '    //',
-    '    // The console algorithm for PC is included',
-    '    // for developers targeting really low spec machines.',
-    '    // Likely better to just run FXAA_PC, and use a really low preset.',
-    '    //',
-    '    #define FXAA_PC_CONSOLE 0',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#ifndef FXAA_GLSL_120',
-    '    #define FXAA_GLSL_120 0',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#ifndef FXAA_GLSL_130',
-    '    #define FXAA_GLSL_130 0',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#ifndef FXAA_HLSL_3',
-    '    #define FXAA_HLSL_3 0',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#ifndef FXAA_HLSL_4',
-    '    #define FXAA_HLSL_4 0',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#ifndef FXAA_HLSL_5',
-    '    #define FXAA_HLSL_5 0',
-    '#endif',
-    '/*==========================================================================*/',
-    '#ifndef FXAA_GREEN_AS_LUMA',
-    '    //',
-    '    // For those using non-linear color,',
-    '    // and either not able to get luma in alpha, or not wanting to,',
-    '    // this enables FXAA to run using green as a proxy for luma.',
-    '    // So with this enabled, no need to pack luma in alpha.',
-    '    //',
-    '    // This will turn off AA on anything which lacks some amount of green.',
-    '    // Pure red and blue or combination of only R and B, will get no AA.',
-    '    //',
-    '    // Might want to lower the settings for both,',
-    '    //    fxaaConsoleEdgeThresholdMin',
-    '    //    fxaaQualityEdgeThresholdMin',
-    '    // In order to insure AA does not get turned off on colors',
-    '    // which contain a minor amount of green.',
-    '    //',
-    '    // 1 = On.',
-    '    // 0 = Off.',
-    '    //',
-    '    #define FXAA_GREEN_AS_LUMA 0',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#ifndef FXAA_EARLY_EXIT',
-    '    //',
-    "    // Controls algorithm's early exit path.",
-    '    // On PS3 turning this ON adds 2 cycles to the shader.',
-    '    // On 360 turning this OFF adds 10ths of a millisecond to the shader.',
-    '    // Turning this off on console will result in a more blurry image.',
-    '    // So this defaults to on.',
-    '    //',
-    '    // 1 = On.',
-    '    // 0 = Off.',
-    '    //',
-    '    #define FXAA_EARLY_EXIT 1',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#ifndef FXAA_DISCARD',
-    '    //',
-    '    // Only valid for PC OpenGL currently.',
-    '    // Probably will not work when FXAA_GREEN_AS_LUMA = 1.',
-    '    //',
-    "    // 1 = Use discard on pixels which don't need AA.",
-    '    //     For APIs which enable concurrent TEX+ROP from same surface.',
-    "    // 0 = Return unchanged color on pixels which don't need AA.",
-    '    //',
-    '    #define FXAA_DISCARD 0',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#ifndef FXAA_FAST_PIXEL_OFFSET',
-    '    //',
-    '    // Used for GLSL 120 only.',
-    '    //',
-    '    // 1 = GL API supports fast pixel offsets',
-    '    // 0 = do not use fast pixel offsets',
-    '    //',
-    '    #ifdef GL_EXT_gpu_shader4',
-    '        #define FXAA_FAST_PIXEL_OFFSET 1',
-    '    #endif',
-    '    #ifdef GL_NV_gpu_shader5',
-    '        #define FXAA_FAST_PIXEL_OFFSET 1',
-    '    #endif',
-    '    #ifdef GL_ARB_gpu_shader5',
-    '        #define FXAA_FAST_PIXEL_OFFSET 1',
-    '    #endif',
-    '    #ifndef FXAA_FAST_PIXEL_OFFSET',
-    '        #define FXAA_FAST_PIXEL_OFFSET 0',
-    '    #endif',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#ifndef FXAA_GATHER4_ALPHA',
-    '    //',
-    '    // 1 = API supports gather4 on alpha channel.',
-    '    // 0 = API does not support gather4 on alpha channel.',
-    '    //',
-    '    #if (FXAA_HLSL_5 == 1)',
-    '        #define FXAA_GATHER4_ALPHA 1',
-    '    #endif',
-    '    #ifdef GL_ARB_gpu_shader5',
-    '        #define FXAA_GATHER4_ALPHA 1',
-    '    #endif',
-    '    #ifdef GL_NV_gpu_shader5',
-    '        #define FXAA_GATHER4_ALPHA 1',
-    '    #endif',
-    '    #ifndef FXAA_GATHER4_ALPHA',
-    '        #define FXAA_GATHER4_ALPHA 0',
-    '    #endif',
-    '#endif',
-    '',
-    '',
-    '/*============================================================================',
-    '                        FXAA QUALITY - TUNING KNOBS',
-    '------------------------------------------------------------------------------',
-    'NOTE the other tuning knobs are now in the shader function inputs!',
-    '============================================================================*/',
-    '#ifndef FXAA_QUALITY_PRESET',
-    '    //',
-    '    // Choose the quality preset.',
-    '    // This needs to be compiled into the shader as it effects code.',
-    '    // Best option to include multiple presets is to',
-    '    // in each shader define the preset, then include this file.',
-    '    //',
-    '    // OPTIONS',
-    '    // -----------------------------------------------------------------------',
-    '    // 10 to 15 - default medium dither (10=fastest, 15=highest quality)',
-    '    // 20 to 29 - less dither, more expensive (20=fastest, 29=highest quality)',
-    '    // 39       - no dither, very expensive',
-    '    //',
-    '    // NOTES',
-    '    // -----------------------------------------------------------------------',
-    '    // 12 = slightly faster then FXAA 3.9 and higher edge quality (default)',
-    '    // 13 = about same speed as FXAA 3.9 and better than 12',
-    '    // 23 = closest to FXAA 3.9 visually and performance wise',
-    '    //  _ = the lowest digit is directly related to performance',
-    '    // _  = the highest digit is directly related to style',
-    '    //',
-    '    #define FXAA_QUALITY_PRESET 12',
-    '#endif',
-    '',
-    '',
-    '/*============================================================================',
-    '',
-    '                           FXAA QUALITY - PRESETS',
-    '',
-    '============================================================================*/',
-    '',
-    '/*============================================================================',
-    '                     FXAA QUALITY - MEDIUM DITHER PRESETS',
-    '============================================================================*/',
-    '#if (FXAA_QUALITY_PRESET == 10)',
-    '    #define FXAA_QUALITY_PS 3',
-    '    #define FXAA_QUALITY_P0 1.5',
-    '    #define FXAA_QUALITY_P1 3.0',
-    '    #define FXAA_QUALITY_P2 12.0',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#if (FXAA_QUALITY_PRESET == 11)',
-    '    #define FXAA_QUALITY_PS 4',
-    '    #define FXAA_QUALITY_P0 1.0',
-    '    #define FXAA_QUALITY_P1 1.5',
-    '    #define FXAA_QUALITY_P2 3.0',
-    '    #define FXAA_QUALITY_P3 12.0',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#if (FXAA_QUALITY_PRESET == 12)',
-    '    #define FXAA_QUALITY_PS 5',
-    '    #define FXAA_QUALITY_P0 1.0',
-    '    #define FXAA_QUALITY_P1 1.5',
-    '    #define FXAA_QUALITY_P2 2.0',
-    '    #define FXAA_QUALITY_P3 4.0',
-    '    #define FXAA_QUALITY_P4 12.0',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#if (FXAA_QUALITY_PRESET == 13)',
-    '    #define FXAA_QUALITY_PS 6',
-    '    #define FXAA_QUALITY_P0 1.0',
-    '    #define FXAA_QUALITY_P1 1.5',
-    '    #define FXAA_QUALITY_P2 2.0',
-    '    #define FXAA_QUALITY_P3 2.0',
-    '    #define FXAA_QUALITY_P4 4.0',
-    '    #define FXAA_QUALITY_P5 12.0',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#if (FXAA_QUALITY_PRESET == 14)',
-    '    #define FXAA_QUALITY_PS 7',
-    '    #define FXAA_QUALITY_P0 1.0',
-    '    #define FXAA_QUALITY_P1 1.5',
-    '    #define FXAA_QUALITY_P2 2.0',
-    '    #define FXAA_QUALITY_P3 2.0',
-    '    #define FXAA_QUALITY_P4 2.0',
-    '    #define FXAA_QUALITY_P5 4.0',
-    '    #define FXAA_QUALITY_P6 12.0',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#if (FXAA_QUALITY_PRESET == 15)',
-    '    #define FXAA_QUALITY_PS 8',
-    '    #define FXAA_QUALITY_P0 1.0',
-    '    #define FXAA_QUALITY_P1 1.5',
-    '    #define FXAA_QUALITY_P2 2.0',
-    '    #define FXAA_QUALITY_P3 2.0',
-    '    #define FXAA_QUALITY_P4 2.0',
-    '    #define FXAA_QUALITY_P5 2.0',
-    '    #define FXAA_QUALITY_P6 4.0',
-    '    #define FXAA_QUALITY_P7 12.0',
-    '#endif',
-    '',
-    '/*============================================================================',
-    '                     FXAA QUALITY - LOW DITHER PRESETS',
-    '============================================================================*/',
-    '#if (FXAA_QUALITY_PRESET == 20)',
-    '    #define FXAA_QUALITY_PS 3',
-    '    #define FXAA_QUALITY_P0 1.5',
-    '    #define FXAA_QUALITY_P1 2.0',
-    '    #define FXAA_QUALITY_P2 8.0',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#if (FXAA_QUALITY_PRESET == 21)',
-    '    #define FXAA_QUALITY_PS 4',
-    '    #define FXAA_QUALITY_P0 1.0',
-    '    #define FXAA_QUALITY_P1 1.5',
-    '    #define FXAA_QUALITY_P2 2.0',
-    '    #define FXAA_QUALITY_P3 8.0',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#if (FXAA_QUALITY_PRESET == 22)',
-    '    #define FXAA_QUALITY_PS 5',
-    '    #define FXAA_QUALITY_P0 1.0',
-    '    #define FXAA_QUALITY_P1 1.5',
-    '    #define FXAA_QUALITY_P2 2.0',
-    '    #define FXAA_QUALITY_P3 2.0',
-    '    #define FXAA_QUALITY_P4 8.0',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#if (FXAA_QUALITY_PRESET == 23)',
-    '    #define FXAA_QUALITY_PS 6',
-    '    #define FXAA_QUALITY_P0 1.0',
-    '    #define FXAA_QUALITY_P1 1.5',
-    '    #define FXAA_QUALITY_P2 2.0',
-    '    #define FXAA_QUALITY_P3 2.0',
-    '    #define FXAA_QUALITY_P4 2.0',
-    '    #define FXAA_QUALITY_P5 8.0',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#if (FXAA_QUALITY_PRESET == 24)',
-    '    #define FXAA_QUALITY_PS 7',
-    '    #define FXAA_QUALITY_P0 1.0',
-    '    #define FXAA_QUALITY_P1 1.5',
-    '    #define FXAA_QUALITY_P2 2.0',
-    '    #define FXAA_QUALITY_P3 2.0',
-    '    #define FXAA_QUALITY_P4 2.0',
-    '    #define FXAA_QUALITY_P5 3.0',
-    '    #define FXAA_QUALITY_P6 8.0',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#if (FXAA_QUALITY_PRESET == 25)',
-    '    #define FXAA_QUALITY_PS 8',
-    '    #define FXAA_QUALITY_P0 1.0',
-    '    #define FXAA_QUALITY_P1 1.5',
-    '    #define FXAA_QUALITY_P2 2.0',
-    '    #define FXAA_QUALITY_P3 2.0',
-    '    #define FXAA_QUALITY_P4 2.0',
-    '    #define FXAA_QUALITY_P5 2.0',
-    '    #define FXAA_QUALITY_P6 4.0',
-    '    #define FXAA_QUALITY_P7 8.0',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#if (FXAA_QUALITY_PRESET == 26)',
-    '    #define FXAA_QUALITY_PS 9',
-    '    #define FXAA_QUALITY_P0 1.0',
-    '    #define FXAA_QUALITY_P1 1.5',
-    '    #define FXAA_QUALITY_P2 2.0',
-    '    #define FXAA_QUALITY_P3 2.0',
-    '    #define FXAA_QUALITY_P4 2.0',
-    '    #define FXAA_QUALITY_P5 2.0',
-    '    #define FXAA_QUALITY_P6 2.0',
-    '    #define FXAA_QUALITY_P7 4.0',
-    '    #define FXAA_QUALITY_P8 8.0',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#if (FXAA_QUALITY_PRESET == 27)',
-    '    #define FXAA_QUALITY_PS 10',
-    '    #define FXAA_QUALITY_P0 1.0',
-    '    #define FXAA_QUALITY_P1 1.5',
-    '    #define FXAA_QUALITY_P2 2.0',
-    '    #define FXAA_QUALITY_P3 2.0',
-    '    #define FXAA_QUALITY_P4 2.0',
-    '    #define FXAA_QUALITY_P5 2.0',
-    '    #define FXAA_QUALITY_P6 2.0',
-    '    #define FXAA_QUALITY_P7 2.0',
-    '    #define FXAA_QUALITY_P8 4.0',
-    '    #define FXAA_QUALITY_P9 8.0',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#if (FXAA_QUALITY_PRESET == 28)',
-    '    #define FXAA_QUALITY_PS 11',
-    '    #define FXAA_QUALITY_P0 1.0',
-    '    #define FXAA_QUALITY_P1 1.5',
-    '    #define FXAA_QUALITY_P2 2.0',
-    '    #define FXAA_QUALITY_P3 2.0',
-    '    #define FXAA_QUALITY_P4 2.0',
-    '    #define FXAA_QUALITY_P5 2.0',
-    '    #define FXAA_QUALITY_P6 2.0',
-    '    #define FXAA_QUALITY_P7 2.0',
-    '    #define FXAA_QUALITY_P8 2.0',
-    '    #define FXAA_QUALITY_P9 4.0',
-    '    #define FXAA_QUALITY_P10 8.0',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#if (FXAA_QUALITY_PRESET == 29)',
-    '    #define FXAA_QUALITY_PS 12',
-    '    #define FXAA_QUALITY_P0 1.0',
-    '    #define FXAA_QUALITY_P1 1.5',
-    '    #define FXAA_QUALITY_P2 2.0',
-    '    #define FXAA_QUALITY_P3 2.0',
-    '    #define FXAA_QUALITY_P4 2.0',
-    '    #define FXAA_QUALITY_P5 2.0',
-    '    #define FXAA_QUALITY_P6 2.0',
-    '    #define FXAA_QUALITY_P7 2.0',
-    '    #define FXAA_QUALITY_P8 2.0',
-    '    #define FXAA_QUALITY_P9 2.0',
-    '    #define FXAA_QUALITY_P10 4.0',
-    '    #define FXAA_QUALITY_P11 8.0',
-    '#endif',
-    '',
-    '/*============================================================================',
-    '                     FXAA QUALITY - EXTREME QUALITY',
-    '============================================================================*/',
-    '#if (FXAA_QUALITY_PRESET == 39)',
-    '    #define FXAA_QUALITY_PS 12',
-    '    #define FXAA_QUALITY_P0 1.0',
-    '    #define FXAA_QUALITY_P1 1.0',
-    '    #define FXAA_QUALITY_P2 1.0',
-    '    #define FXAA_QUALITY_P3 1.0',
-    '    #define FXAA_QUALITY_P4 1.0',
-    '    #define FXAA_QUALITY_P5 1.5',
-    '    #define FXAA_QUALITY_P6 2.0',
-    '    #define FXAA_QUALITY_P7 2.0',
-    '    #define FXAA_QUALITY_P8 2.0',
-    '    #define FXAA_QUALITY_P9 2.0',
-    '    #define FXAA_QUALITY_P10 4.0',
-    '    #define FXAA_QUALITY_P11 8.0',
-    '#endif',
-    '',
-    '',
-    '',
-    '/*============================================================================',
-    '',
-    '                                API PORTING',
-    '',
-    '============================================================================*/',
-    '#if (FXAA_GLSL_100 == 1) || (FXAA_GLSL_120 == 1) || (FXAA_GLSL_130 == 1)',
-    '    #define FxaaBool bool',
-    '    #define FxaaDiscard discard',
-    '    #define FxaaFloat float',
-    '    #define FxaaFloat2 vec2',
-    '    #define FxaaFloat3 vec3',
-    '    #define FxaaFloat4 vec4',
-    '    #define FxaaHalf float',
-    '    #define FxaaHalf2 vec2',
-    '    #define FxaaHalf3 vec3',
-    '    #define FxaaHalf4 vec4',
-    '    #define FxaaInt2 ivec2',
-    '    #define FxaaSat(x) clamp(x, 0.0, 1.0)',
-    '    #define FxaaTex sampler2D',
-    '#else',
-    '    #define FxaaBool bool',
-    '    #define FxaaDiscard clip(-1)',
-    '    #define FxaaFloat float',
-    '    #define FxaaFloat2 float2',
-    '    #define FxaaFloat3 float3',
-    '    #define FxaaFloat4 float4',
-    '    #define FxaaHalf half',
-    '    #define FxaaHalf2 half2',
-    '    #define FxaaHalf3 half3',
-    '    #define FxaaHalf4 half4',
-    '    #define FxaaSat(x) saturate(x)',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#if (FXAA_GLSL_100 == 1)',
-    '  #define FxaaTexTop(t, p) texture2D(t, p, 0.0)',
-    '  #define FxaaTexOff(t, p, o, r) texture2D(t, p + (o * r), 0.0)',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#if (FXAA_GLSL_120 == 1)',
-    '    // Requires,',
-    '    //  #version 120',
-    '    // And at least,',
-    '    //  #extension GL_EXT_gpu_shader4 : enable',
-    '    //  (or set FXAA_FAST_PIXEL_OFFSET 1 to work like DX9)',
-    '    #define FxaaTexTop(t, p) texture2DLod(t, p, 0.0)',
-    '    #if (FXAA_FAST_PIXEL_OFFSET == 1)',
-    '        #define FxaaTexOff(t, p, o, r) texture2DLodOffset(t, p, 0.0, o)',
-    '    #else',
-    '        #define FxaaTexOff(t, p, o, r) texture2DLod(t, p + (o * r), 0.0)',
-    '    #endif',
-    '    #if (FXAA_GATHER4_ALPHA == 1)',
-    '        // use #extension GL_ARB_gpu_shader5 : enable',
-    '        #define FxaaTexAlpha4(t, p) textureGather(t, p, 3)',
-    '        #define FxaaTexOffAlpha4(t, p, o) textureGatherOffset(t, p, o, 3)',
-    '        #define FxaaTexGreen4(t, p) textureGather(t, p, 1)',
-    '        #define FxaaTexOffGreen4(t, p, o) textureGatherOffset(t, p, o, 1)',
-    '    #endif',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#if (FXAA_GLSL_130 == 1)',
-    '    // Requires "#version 130" or better',
-    '    #define FxaaTexTop(t, p) textureLod(t, p, 0.0)',
-    '    #define FxaaTexOff(t, p, o, r) textureLodOffset(t, p, 0.0, o)',
-    '    #if (FXAA_GATHER4_ALPHA == 1)',
-    '        // use #extension GL_ARB_gpu_shader5 : enable',
-    '        #define FxaaTexAlpha4(t, p) textureGather(t, p, 3)',
-    '        #define FxaaTexOffAlpha4(t, p, o) textureGatherOffset(t, p, o, 3)',
-    '        #define FxaaTexGreen4(t, p) textureGather(t, p, 1)',
-    '        #define FxaaTexOffGreen4(t, p, o) textureGatherOffset(t, p, o, 1)',
-    '    #endif',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#if (FXAA_HLSL_3 == 1)',
-    '    #define FxaaInt2 float2',
-    '    #define FxaaTex sampler2D',
-    '    #define FxaaTexTop(t, p) tex2Dlod(t, float4(p, 0.0, 0.0))',
-    '    #define FxaaTexOff(t, p, o, r) tex2Dlod(t, float4(p + (o * r), 0, 0))',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#if (FXAA_HLSL_4 == 1)',
-    '    #define FxaaInt2 int2',
-    '    struct FxaaTex { SamplerState smpl; Texture2D tex; };',
-    '    #define FxaaTexTop(t, p) t.tex.SampleLevel(t.smpl, p, 0.0)',
-    '    #define FxaaTexOff(t, p, o, r) t.tex.SampleLevel(t.smpl, p, 0.0, o)',
-    '#endif',
-    '/*--------------------------------------------------------------------------*/',
-    '#if (FXAA_HLSL_5 == 1)',
-    '    #define FxaaInt2 int2',
-    '    struct FxaaTex { SamplerState smpl; Texture2D tex; };',
-    '    #define FxaaTexTop(t, p) t.tex.SampleLevel(t.smpl, p, 0.0)',
-    '    #define FxaaTexOff(t, p, o, r) t.tex.SampleLevel(t.smpl, p, 0.0, o)',
-    '    #define FxaaTexAlpha4(t, p) t.tex.GatherAlpha(t.smpl, p)',
-    '    #define FxaaTexOffAlpha4(t, p, o) t.tex.GatherAlpha(t.smpl, p, o)',
-    '    #define FxaaTexGreen4(t, p) t.tex.GatherGreen(t.smpl, p)',
-    '    #define FxaaTexOffGreen4(t, p, o) t.tex.GatherGreen(t.smpl, p, o)',
-    '#endif',
-    '',
-    '',
-    '/*============================================================================',
-    '                   GREEN AS LUMA OPTION SUPPORT FUNCTION',
-    '============================================================================*/',
-    '#if (FXAA_GREEN_AS_LUMA == 0)',
-    '    FxaaFloat FxaaLuma(FxaaFloat4 rgba) { return rgba.w; }',
-    '#else',
-    '    FxaaFloat FxaaLuma(FxaaFloat4 rgba) { return rgba.y; }',
-    '#endif',
-    '',
-    '',
-    '',
-    '',
-    '/*============================================================================',
-    '',
-    '                             FXAA3 QUALITY - PC',
-    '',
-    '============================================================================*/',
-    '#if (FXAA_PC == 1)',
-    '/*--------------------------------------------------------------------------*/',
-    'FxaaFloat4 FxaaPixelShader(',
-    '    //',
-    '    // Use noperspective interpolation here (turn off perspective interpolation).',
-    '    // {xy} = center of pixel',
-    '    FxaaFloat2 pos,',
-    '    //',
-    '    // Used only for FXAA Console, and not used on the 360 version.',
-    '    // Use noperspective interpolation here (turn off perspective interpolation).',
-    '    // {xy_} = upper left of pixel',
-    '    // {_zw} = lower right of pixel',
-    '    FxaaFloat4 fxaaConsolePosPos,',
-    '    //',
-    '    // Input color texture.',
-    '    // {rgb_} = color in linear or perceptual color space',
-    '    // if (FXAA_GREEN_AS_LUMA == 0)',
-    '    //     {__a} = luma in perceptual color space (not linear)',
-    '    FxaaTex tex,',
-    '    //',
-    '    // Only used on the optimized 360 version of FXAA Console.',
-    '    // For everything but 360, just use the same input here as for "tex".',
-    '    // For 360, same texture, just alias with a 2nd sampler.',
-    '    // This sampler needs to have an exponent bias of -1.',
-    '    FxaaTex fxaaConsole360TexExpBiasNegOne,',
-    '    //',
-    '    // Only used on the optimized 360 version of FXAA Console.',
-    '    // For everything but 360, just use the same input here as for "tex".',
-    '    // For 360, same texture, just alias with a 3nd sampler.',
-    '    // This sampler needs to have an exponent bias of -2.',
-    '    FxaaTex fxaaConsole360TexExpBiasNegTwo,',
-    '    //',
-    '    // Only used on FXAA Quality.',
-    '    // This must be from a constant/uniform.',
-    '    // {x_} = 1.0/screenWidthInPixels',
-    '    // {_y} = 1.0/screenHeightInPixels',
-    '    FxaaFloat2 fxaaQualityRcpFrame,',
-    '    //',
-    '    // Only used on FXAA Console.',
-    '    // This must be from a constant/uniform.',
-    '    // This effects sub-pixel AA quality and inversely sharpness.',
-    '    //   Where N ranges between,',
-    '    //     N = 0.50 (default)',
-    '    //     N = 0.33 (sharper)',
-    '    // {x__} = -N/screenWidthInPixels',
-    '    // {_y_} = -N/screenHeightInPixels',
-    '    // {_z_} =  N/screenWidthInPixels',
-    '    // {__w} =  N/screenHeightInPixels',
-    '    FxaaFloat4 fxaaConsoleRcpFrameOpt,',
-    '    //',
-    '    // Only used on FXAA Console.',
-    '    // Not used on 360, but used on PS3 and PC.',
-    '    // This must be from a constant/uniform.',
-    '    // {x__} = -2.0/screenWidthInPixels',
-    '    // {_y_} = -2.0/screenHeightInPixels',
-    '    // {_z_} =  2.0/screenWidthInPixels',
-    '    // {__w} =  2.0/screenHeightInPixels',
-    '    FxaaFloat4 fxaaConsoleRcpFrameOpt2,',
-    '    //',
-    '    // Only used on FXAA Console.',
-    '    // Only used on 360 in place of fxaaConsoleRcpFrameOpt2.',
-    '    // This must be from a constant/uniform.',
-    '    // {x__} =  8.0/screenWidthInPixels',
-    '    // {_y_} =  8.0/screenHeightInPixels',
-    '    // {_z_} = -4.0/screenWidthInPixels',
-    '    // {__w} = -4.0/screenHeightInPixels',
-    '    FxaaFloat4 fxaaConsole360RcpFrameOpt2,',
-    '    //',
-    '    // Only used on FXAA Quality.',
-    '    // This used to be the FXAA_QUALITY_SUBPIX define.',
-    '    // It is here now to allow easier tuning.',
-    '    // Choose the amount of sub-pixel aliasing removal.',
-    '    // This can effect sharpness.',
-    '    //   1.00 - upper limit (softer)',
-    '    //   0.75 - default amount of filtering',
-    '    //   0.50 - lower limit (sharper, less sub-pixel aliasing removal)',
-    '    //   0.25 - almost off',
-    '    //   0.00 - completely off',
-    '    FxaaFloat fxaaQualitySubpix,',
-    '    //',
-    '    // Only used on FXAA Quality.',
-    '    // This used to be the FXAA_QUALITY_EDGE_THRESHOLD define.',
-    '    // It is here now to allow easier tuning.',
-    '    // The minimum amount of local contrast required to apply algorithm.',
-    '    //   0.333 - too little (faster)',
-    '    //   0.250 - low quality',
-    '    //   0.166 - default',
-    '    //   0.125 - high quality',
-    '    //   0.063 - overkill (slower)',
-    '    FxaaFloat fxaaQualityEdgeThreshold,',
-    '    //',
-    '    // Only used on FXAA Quality.',
-    '    // This used to be the FXAA_QUALITY_EDGE_THRESHOLD_MIN define.',
-    '    // It is here now to allow easier tuning.',
-    '    // Trims the algorithm from processing darks.',
-    '    //   0.0833 - upper limit (default, the start of visible unfiltered edges)',
-    '    //   0.0625 - high quality (faster)',
-    '    //   0.0312 - visible limit (slower)',
-    '    // Special notes when using FXAA_GREEN_AS_LUMA,',
-    '    //   Likely want to set this to zero.',
-    '    //   As colors that are mostly not-green',
-    '    //   will appear very dark in the green channel!',
-    '    //   Tune by looking at mostly non-green content,',
-    '    //   then start at zero and increase until aliasing is a problem.',
-    '    FxaaFloat fxaaQualityEdgeThresholdMin,',
-    '    //',
-    '    // Only used on FXAA Console.',
-    '    // This used to be the FXAA_CONSOLE_EDGE_SHARPNESS define.',
-    '    // It is here now to allow easier tuning.',
-    '    // This does not effect PS3, as this needs to be compiled in.',
-    '    //   Use FXAA_CONSOLE_PS3_EDGE_SHARPNESS for PS3.',
-    '    //   Due to the PS3 being ALU bound,',
-    '    //   there are only three safe values here: 2 and 4 and 8.',
-    '    //   These options use the shaders ability to a free *|/ by 2|4|8.',
-    '    // For all other platforms can be a non-power of two.',
-    '    //   8.0 is sharper (default!!!)',
-    '    //   4.0 is softer',
-    '    //   2.0 is really soft (good only for vector graphics inputs)',
-    '    FxaaFloat fxaaConsoleEdgeSharpness,',
-    '    //',
-    '    // Only used on FXAA Console.',
-    '    // This used to be the FXAA_CONSOLE_EDGE_THRESHOLD define.',
-    '    // It is here now to allow easier tuning.',
-    '    // This does not effect PS3, as this needs to be compiled in.',
-    '    //   Use FXAA_CONSOLE_PS3_EDGE_THRESHOLD for PS3.',
-    '    //   Due to the PS3 being ALU bound,',
-    '    //   there are only two safe values here: 1/4 and 1/8.',
-    '    //   These options use the shaders ability to a free *|/ by 2|4|8.',
-    '    // The console setting has a different mapping than the quality setting.',
-    '    // Other platforms can use other values.',
-    '    //   0.125 leaves less aliasing, but is softer (default!!!)',
-    '    //   0.25 leaves more aliasing, and is sharper',
-    '    FxaaFloat fxaaConsoleEdgeThreshold,',
-    '    //',
-    '    // Only used on FXAA Console.',
-    '    // This used to be the FXAA_CONSOLE_EDGE_THRESHOLD_MIN define.',
-    '    // It is here now to allow easier tuning.',
-    '    // Trims the algorithm from processing darks.',
-    '    // The console setting has a different mapping than the quality setting.',
-    '    // This only applies when FXAA_EARLY_EXIT is 1.',
-    '    // This does not apply to PS3,',
-    '    // PS3 was simplified to avoid more shader instructions.',
-    '    //   0.06 - faster but more aliasing in darks',
-    '    //   0.05 - default',
-    '    //   0.04 - slower and less aliasing in darks',
-    '    // Special notes when using FXAA_GREEN_AS_LUMA,',
-    '    //   Likely want to set this to zero.',
-    '    //   As colors that are mostly not-green',
-    '    //   will appear very dark in the green channel!',
-    '    //   Tune by looking at mostly non-green content,',
-    '    //   then start at zero and increase until aliasing is a problem.',
-    '    FxaaFloat fxaaConsoleEdgeThresholdMin,',
-    '    //',
-    '    // Extra constants for 360 FXAA Console only.',
-    '    // Use zeros or anything else for other platforms.',
-    '    // These must be in physical constant registers and NOT immediates.',
-    '    // Immediates will result in compiler un-optimizing.',
-    '    // {xyzw} = float4(1.0, -1.0, 0.25, -0.25)',
-    '    FxaaFloat4 fxaaConsole360ConstDir',
-    ') {',
-    '/*--------------------------------------------------------------------------*/',
-    '    FxaaFloat2 posM;',
-    '    posM.x = pos.x;',
-    '    posM.y = pos.y;',
-    '    #if (FXAA_GATHER4_ALPHA == 1)',
-    '        #if (FXAA_DISCARD == 0)',
-    '            FxaaFloat4 rgbyM = FxaaTexTop(tex, posM);',
-    '            #if (FXAA_GREEN_AS_LUMA == 0)',
-    '                #define lumaM rgbyM.w',
-    '            #else',
-    '                #define lumaM rgbyM.y',
-    '            #endif',
-    '        #endif',
-    '        #if (FXAA_GREEN_AS_LUMA == 0)',
-    '            FxaaFloat4 luma4A = FxaaTexAlpha4(tex, posM);',
-    '            FxaaFloat4 luma4B = FxaaTexOffAlpha4(tex, posM, FxaaInt2(-1, -1));',
-    '        #else',
-    '            FxaaFloat4 luma4A = FxaaTexGreen4(tex, posM);',
-    '            FxaaFloat4 luma4B = FxaaTexOffGreen4(tex, posM, FxaaInt2(-1, -1));',
-    '        #endif',
-    '        #if (FXAA_DISCARD == 1)',
-    '            #define lumaM luma4A.w',
-    '        #endif',
-    '        #define lumaE luma4A.z',
-    '        #define lumaS luma4A.x',
-    '        #define lumaSE luma4A.y',
-    '        #define lumaNW luma4B.w',
-    '        #define lumaN luma4B.z',
-    '        #define lumaW luma4B.x',
-    '    #else',
-    '        FxaaFloat4 rgbyM = FxaaTexTop(tex, posM);',
-    '        #if (FXAA_GREEN_AS_LUMA == 0)',
-    '            #define lumaM rgbyM.w',
-    '        #else',
-    '            #define lumaM rgbyM.y',
-    '        #endif',
-    '        #if (FXAA_GLSL_100 == 1)',
-    '          FxaaFloat lumaS = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2( 0.0, 1.0), fxaaQualityRcpFrame.xy));',
-    '          FxaaFloat lumaE = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2( 1.0, 0.0), fxaaQualityRcpFrame.xy));',
-    '          FxaaFloat lumaN = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2( 0.0,-1.0), fxaaQualityRcpFrame.xy));',
-    '          FxaaFloat lumaW = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2(-1.0, 0.0), fxaaQualityRcpFrame.xy));',
-    '        #else',
-    '          FxaaFloat lumaS = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 0, 1), fxaaQualityRcpFrame.xy));',
-    '          FxaaFloat lumaE = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 1, 0), fxaaQualityRcpFrame.xy));',
-    '          FxaaFloat lumaN = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 0,-1), fxaaQualityRcpFrame.xy));',
-    '          FxaaFloat lumaW = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(-1, 0), fxaaQualityRcpFrame.xy));',
-    '        #endif',
-    '    #endif',
-    '/*--------------------------------------------------------------------------*/',
-    '    FxaaFloat maxSM = max(lumaS, lumaM);',
-    '    FxaaFloat minSM = min(lumaS, lumaM);',
-    '    FxaaFloat maxESM = max(lumaE, maxSM);',
-    '    FxaaFloat minESM = min(lumaE, minSM);',
-    '    FxaaFloat maxWN = max(lumaN, lumaW);',
-    '    FxaaFloat minWN = min(lumaN, lumaW);',
-    '    FxaaFloat rangeMax = max(maxWN, maxESM);',
-    '    FxaaFloat rangeMin = min(minWN, minESM);',
-    '    FxaaFloat rangeMaxScaled = rangeMax * fxaaQualityEdgeThreshold;',
-    '    FxaaFloat range = rangeMax - rangeMin;',
-    '    FxaaFloat rangeMaxClamped = max(fxaaQualityEdgeThresholdMin, rangeMaxScaled);',
-    '    FxaaBool earlyExit = range < rangeMaxClamped;',
-    '/*--------------------------------------------------------------------------*/',
-    '    if(earlyExit)',
-    '        #if (FXAA_DISCARD == 1)',
-    '            FxaaDiscard;',
-    '        #else',
-    '            return rgbyM;',
-    '        #endif',
-    '/*--------------------------------------------------------------------------*/',
-    '    #if (FXAA_GATHER4_ALPHA == 0)',
-    '        #if (FXAA_GLSL_100 == 1)',
-    '          FxaaFloat lumaNW = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2(-1.0,-1.0), fxaaQualityRcpFrame.xy));',
-    '          FxaaFloat lumaSE = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2( 1.0, 1.0), fxaaQualityRcpFrame.xy));',
-    '          FxaaFloat lumaNE = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2( 1.0,-1.0), fxaaQualityRcpFrame.xy));',
-    '          FxaaFloat lumaSW = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2(-1.0, 1.0), fxaaQualityRcpFrame.xy));',
-    '        #else',
-    '          FxaaFloat lumaNW = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(-1,-1), fxaaQualityRcpFrame.xy));',
-    '          FxaaFloat lumaSE = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 1, 1), fxaaQualityRcpFrame.xy));',
-    '          FxaaFloat lumaNE = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 1,-1), fxaaQualityRcpFrame.xy));',
-    '          FxaaFloat lumaSW = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(-1, 1), fxaaQualityRcpFrame.xy));',
-    '        #endif',
-    '    #else',
-    '        FxaaFloat lumaNE = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(1, -1), fxaaQualityRcpFrame.xy));',
-    '        FxaaFloat lumaSW = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(-1, 1), fxaaQualityRcpFrame.xy));',
-    '    #endif',
-    '/*--------------------------------------------------------------------------*/',
-    '    FxaaFloat lumaNS = lumaN + lumaS;',
-    '    FxaaFloat lumaWE = lumaW + lumaE;',
-    '    FxaaFloat subpixRcpRange = 1.0/range;',
-    '    FxaaFloat subpixNSWE = lumaNS + lumaWE;',
-    '    FxaaFloat edgeHorz1 = (-2.0 * lumaM) + lumaNS;',
-    '    FxaaFloat edgeVert1 = (-2.0 * lumaM) + lumaWE;',
-    '/*--------------------------------------------------------------------------*/',
-    '    FxaaFloat lumaNESE = lumaNE + lumaSE;',
-    '    FxaaFloat lumaNWNE = lumaNW + lumaNE;',
-    '    FxaaFloat edgeHorz2 = (-2.0 * lumaE) + lumaNESE;',
-    '    FxaaFloat edgeVert2 = (-2.0 * lumaN) + lumaNWNE;',
-    '/*--------------------------------------------------------------------------*/',
-    '    FxaaFloat lumaNWSW = lumaNW + lumaSW;',
-    '    FxaaFloat lumaSWSE = lumaSW + lumaSE;',
-    '    FxaaFloat edgeHorz4 = (abs(edgeHorz1) * 2.0) + abs(edgeHorz2);',
-    '    FxaaFloat edgeVert4 = (abs(edgeVert1) * 2.0) + abs(edgeVert2);',
-    '    FxaaFloat edgeHorz3 = (-2.0 * lumaW) + lumaNWSW;',
-    '    FxaaFloat edgeVert3 = (-2.0 * lumaS) + lumaSWSE;',
-    '    FxaaFloat edgeHorz = abs(edgeHorz3) + edgeHorz4;',
-    '    FxaaFloat edgeVert = abs(edgeVert3) + edgeVert4;',
-    '/*--------------------------------------------------------------------------*/',
-    '    FxaaFloat subpixNWSWNESE = lumaNWSW + lumaNESE;',
-    '    FxaaFloat lengthSign = fxaaQualityRcpFrame.x;',
-    '    FxaaBool horzSpan = edgeHorz >= edgeVert;',
-    '    FxaaFloat subpixA = subpixNSWE * 2.0 + subpixNWSWNESE;',
-    '/*--------------------------------------------------------------------------*/',
-    '    if(!horzSpan) lumaN = lumaW;',
-    '    if(!horzSpan) lumaS = lumaE;',
-    '    if(horzSpan) lengthSign = fxaaQualityRcpFrame.y;',
-    '    FxaaFloat subpixB = (subpixA * (1.0/12.0)) - lumaM;',
-    '/*--------------------------------------------------------------------------*/',
-    '    FxaaFloat gradientN = lumaN - lumaM;',
-    '    FxaaFloat gradientS = lumaS - lumaM;',
-    '    FxaaFloat lumaNN = lumaN + lumaM;',
-    '    FxaaFloat lumaSS = lumaS + lumaM;',
-    '    FxaaBool pairN = abs(gradientN) >= abs(gradientS);',
-    '    FxaaFloat gradient = max(abs(gradientN), abs(gradientS));',
-    '    if(pairN) lengthSign = -lengthSign;',
-    '    FxaaFloat subpixC = FxaaSat(abs(subpixB) * subpixRcpRange);',
-    '/*--------------------------------------------------------------------------*/',
-    '    FxaaFloat2 posB;',
-    '    posB.x = posM.x;',
-    '    posB.y = posM.y;',
-    '    FxaaFloat2 offNP;',
-    '    offNP.x = (!horzSpan) ? 0.0 : fxaaQualityRcpFrame.x;',
-    '    offNP.y = ( horzSpan) ? 0.0 : fxaaQualityRcpFrame.y;',
-    '    if(!horzSpan) posB.x += lengthSign * 0.5;',
-    '    if( horzSpan) posB.y += lengthSign * 0.5;',
-    '/*--------------------------------------------------------------------------*/',
-    '    FxaaFloat2 posN;',
-    '    posN.x = posB.x - offNP.x * FXAA_QUALITY_P0;',
-    '    posN.y = posB.y - offNP.y * FXAA_QUALITY_P0;',
-    '    FxaaFloat2 posP;',
-    '    posP.x = posB.x + offNP.x * FXAA_QUALITY_P0;',
-    '    posP.y = posB.y + offNP.y * FXAA_QUALITY_P0;',
-    '    FxaaFloat subpixD = ((-2.0)*subpixC) + 3.0;',
-    '    FxaaFloat lumaEndN = FxaaLuma(FxaaTexTop(tex, posN));',
-    '    FxaaFloat subpixE = subpixC * subpixC;',
-    '    FxaaFloat lumaEndP = FxaaLuma(FxaaTexTop(tex, posP));',
-    '/*--------------------------------------------------------------------------*/',
-    '    if(!pairN) lumaNN = lumaSS;',
-    '    FxaaFloat gradientScaled = gradient * 1.0/4.0;',
-    '    FxaaFloat lumaMM = lumaM - lumaNN * 0.5;',
-    '    FxaaFloat subpixF = subpixD * subpixE;',
-    '    FxaaBool lumaMLTZero = lumaMM < 0.0;',
-    '/*--------------------------------------------------------------------------*/',
-    '    lumaEndN -= lumaNN * 0.5;',
-    '    lumaEndP -= lumaNN * 0.5;',
-    '    FxaaBool doneN = abs(lumaEndN) >= gradientScaled;',
-    '    FxaaBool doneP = abs(lumaEndP) >= gradientScaled;',
-    '    if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P1;',
-    '    if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P1;',
-    '    FxaaBool doneNP = (!doneN) || (!doneP);',
-    '    if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P1;',
-    '    if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P1;',
-    '/*--------------------------------------------------------------------------*/',
-    '    if(doneNP) {',
-    '        if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));',
-    '        if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));',
-    '        if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;',
-    '        if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;',
-    '        doneN = abs(lumaEndN) >= gradientScaled;',
-    '        doneP = abs(lumaEndP) >= gradientScaled;',
-    '        if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P2;',
-    '        if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P2;',
-    '        doneNP = (!doneN) || (!doneP);',
-    '        if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P2;',
-    '        if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P2;',
-    '/*--------------------------------------------------------------------------*/',
-    '        #if (FXAA_QUALITY_PS > 3)',
-    '        if(doneNP) {',
-    '            if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));',
-    '            if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));',
-    '            if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;',
-    '            if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;',
-    '            doneN = abs(lumaEndN) >= gradientScaled;',
-    '            doneP = abs(lumaEndP) >= gradientScaled;',
-    '            if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P3;',
-    '            if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P3;',
-    '            doneNP = (!doneN) || (!doneP);',
-    '            if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P3;',
-    '            if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P3;',
-    '/*--------------------------------------------------------------------------*/',
-    '            #if (FXAA_QUALITY_PS > 4)',
-    '            if(doneNP) {',
-    '                if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));',
-    '                if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));',
-    '                if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;',
-    '                if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;',
-    '                doneN = abs(lumaEndN) >= gradientScaled;',
-    '                doneP = abs(lumaEndP) >= gradientScaled;',
-    '                if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P4;',
-    '                if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P4;',
-    '                doneNP = (!doneN) || (!doneP);',
-    '                if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P4;',
-    '                if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P4;',
-    '/*--------------------------------------------------------------------------*/',
-    '                #if (FXAA_QUALITY_PS > 5)',
-    '                if(doneNP) {',
-    '                    if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));',
-    '                    if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));',
-    '                    if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;',
-    '                    if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;',
-    '                    doneN = abs(lumaEndN) >= gradientScaled;',
-    '                    doneP = abs(lumaEndP) >= gradientScaled;',
-    '                    if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P5;',
-    '                    if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P5;',
-    '                    doneNP = (!doneN) || (!doneP);',
-    '                    if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P5;',
-    '                    if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P5;',
-    '/*--------------------------------------------------------------------------*/',
-    '                    #if (FXAA_QUALITY_PS > 6)',
-    '                    if(doneNP) {',
-    '                        if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));',
-    '                        if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));',
-    '                        if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;',
-    '                        if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;',
-    '                        doneN = abs(lumaEndN) >= gradientScaled;',
-    '                        doneP = abs(lumaEndP) >= gradientScaled;',
-    '                        if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P6;',
-    '                        if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P6;',
-    '                        doneNP = (!doneN) || (!doneP);',
-    '                        if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P6;',
-    '                        if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P6;',
-    '/*--------------------------------------------------------------------------*/',
-    '                        #if (FXAA_QUALITY_PS > 7)',
-    '                        if(doneNP) {',
-    '                            if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));',
-    '                            if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));',
-    '                            if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;',
-    '                            if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;',
-    '                            doneN = abs(lumaEndN) >= gradientScaled;',
-    '                            doneP = abs(lumaEndP) >= gradientScaled;',
-    '                            if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P7;',
-    '                            if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P7;',
-    '                            doneNP = (!doneN) || (!doneP);',
-    '                            if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P7;',
-    '                            if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P7;',
-    '/*--------------------------------------------------------------------------*/',
-    '    #if (FXAA_QUALITY_PS > 8)',
-    '    if(doneNP) {',
-    '        if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));',
-    '        if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));',
-    '        if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;',
-    '        if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;',
-    '        doneN = abs(lumaEndN) >= gradientScaled;',
-    '        doneP = abs(lumaEndP) >= gradientScaled;',
-    '        if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P8;',
-    '        if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P8;',
-    '        doneNP = (!doneN) || (!doneP);',
-    '        if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P8;',
-    '        if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P8;',
-    '/*--------------------------------------------------------------------------*/',
-    '        #if (FXAA_QUALITY_PS > 9)',
-    '        if(doneNP) {',
-    '            if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));',
-    '            if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));',
-    '            if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;',
-    '            if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;',
-    '            doneN = abs(lumaEndN) >= gradientScaled;',
-    '            doneP = abs(lumaEndP) >= gradientScaled;',
-    '            if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P9;',
-    '            if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P9;',
-    '            doneNP = (!doneN) || (!doneP);',
-    '            if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P9;',
-    '            if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P9;',
-    '/*--------------------------------------------------------------------------*/',
-    '            #if (FXAA_QUALITY_PS > 10)',
-    '            if(doneNP) {',
-    '                if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));',
-    '                if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));',
-    '                if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;',
-    '                if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;',
-    '                doneN = abs(lumaEndN) >= gradientScaled;',
-    '                doneP = abs(lumaEndP) >= gradientScaled;',
-    '                if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P10;',
-    '                if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P10;',
-    '                doneNP = (!doneN) || (!doneP);',
-    '                if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P10;',
-    '                if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P10;',
-    '/*--------------------------------------------------------------------------*/',
-    '                #if (FXAA_QUALITY_PS > 11)',
-    '                if(doneNP) {',
-    '                    if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));',
-    '                    if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));',
-    '                    if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;',
-    '                    if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;',
-    '                    doneN = abs(lumaEndN) >= gradientScaled;',
-    '                    doneP = abs(lumaEndP) >= gradientScaled;',
-    '                    if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P11;',
-    '                    if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P11;',
-    '                    doneNP = (!doneN) || (!doneP);',
-    '                    if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P11;',
-    '                    if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P11;',
-    '/*--------------------------------------------------------------------------*/',
-    '                    #if (FXAA_QUALITY_PS > 12)',
-    '                    if(doneNP) {',
-    '                        if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));',
-    '                        if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));',
-    '                        if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;',
-    '                        if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;',
-    '                        doneN = abs(lumaEndN) >= gradientScaled;',
-    '                        doneP = abs(lumaEndP) >= gradientScaled;',
-    '                        if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P12;',
-    '                        if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P12;',
-    '                        doneNP = (!doneN) || (!doneP);',
-    '                        if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P12;',
-    '                        if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P12;',
-    '/*--------------------------------------------------------------------------*/',
-    '                    }',
-    '                    #endif',
-    '/*--------------------------------------------------------------------------*/',
-    '                }',
-    '                #endif',
-    '/*--------------------------------------------------------------------------*/',
-    '            }',
-    '            #endif',
-    '/*--------------------------------------------------------------------------*/',
-    '        }',
-    '        #endif',
-    '/*--------------------------------------------------------------------------*/',
-    '    }',
-    '    #endif',
-    '/*--------------------------------------------------------------------------*/',
-    '                        }',
-    '                        #endif',
-    '/*--------------------------------------------------------------------------*/',
-    '                    }',
-    '                    #endif',
-    '/*--------------------------------------------------------------------------*/',
-    '                }',
-    '                #endif',
-    '/*--------------------------------------------------------------------------*/',
-    '            }',
-    '            #endif',
-    '/*--------------------------------------------------------------------------*/',
-    '        }',
-    '        #endif',
-    '/*--------------------------------------------------------------------------*/',
-    '    }',
-    '/*--------------------------------------------------------------------------*/',
-    '    FxaaFloat dstN = posM.x - posN.x;',
-    '    FxaaFloat dstP = posP.x - posM.x;',
-    '    if(!horzSpan) dstN = posM.y - posN.y;',
-    '    if(!horzSpan) dstP = posP.y - posM.y;',
-    '/*--------------------------------------------------------------------------*/',
-    '    FxaaBool goodSpanN = (lumaEndN < 0.0) != lumaMLTZero;',
-    '    FxaaFloat spanLength = (dstP + dstN);',
-    '    FxaaBool goodSpanP = (lumaEndP < 0.0) != lumaMLTZero;',
-    '    FxaaFloat spanLengthRcp = 1.0/spanLength;',
-    '/*--------------------------------------------------------------------------*/',
-    '    FxaaBool directionN = dstN < dstP;',
-    '    FxaaFloat dst = min(dstN, dstP);',
-    '    FxaaBool goodSpan = directionN ? goodSpanN : goodSpanP;',
-    '    FxaaFloat subpixG = subpixF * subpixF;',
-    '    FxaaFloat pixelOffset = (dst * (-spanLengthRcp)) + 0.5;',
-    '    FxaaFloat subpixH = subpixG * fxaaQualitySubpix;',
-    '/*--------------------------------------------------------------------------*/',
-    '    FxaaFloat pixelOffsetGood = goodSpan ? pixelOffset : 0.0;',
-    '    FxaaFloat pixelOffsetSubpix = max(pixelOffsetGood, subpixH);',
-    '    if(!horzSpan) posM.x += pixelOffsetSubpix * lengthSign;',
-    '    if( horzSpan) posM.y += pixelOffsetSubpix * lengthSign;',
-    '    #if (FXAA_DISCARD == 1)',
-    '        return FxaaTexTop(tex, posM);',
-    '    #else',
-    '        return FxaaFloat4(FxaaTexTop(tex, posM).xyz, lumaM);',
-    '    #endif',
-    '}',
-    '/*==========================================================================*/',
-    '#endif',
-    '',
-    'void main() {',
-    '  gl_FragColor = FxaaPixelShader(',
-    '    vUv,',
-    '    vec4(0.0),',
-    '    tDiffuse,',
-    '    tDiffuse,',
-    '    tDiffuse,',
-    '    resolution,',
-    '    vec4(0.0),',
-    '    vec4(0.0),',
-    '    vec4(0.0),',
-    '    0.75,',
-    '    0.166,',
-    '    0.0833,',
-    '    0.0,',
-    '    0.0,',
-    '    0.0,',
-    '    vec4(0.0)',
-    '  );',
-    '',
-    '  // TODO avoid querying texture twice for same texel',
-    '  gl_FragColor.a = texture2D(tDiffuse, vUv).a;',
-    '}',
-  ].join('\n'),
+  fragmentShader: /* glsl */ `
+    precision highp float;
+    
+    uniform sampler2D tDiffuse;
+    
+    uniform vec2 resolution;
+    
+    varying vec2 vUv;
+    
+    // FXAA 3.11 implementation by NVIDIA, ported to WebGL by Agost Biro (biro@archilogic.com)
+    
+    //----------------------------------------------------------------------------------
+    // File:        es3-keplerFXAAassetsshaders/FXAA_DefaultES.frag
+    // SDK Version: v3.00
+    // Email:       gameworks@nvidia.com
+    // Site:        http://developer.nvidia.com/
+    //
+    // Copyright (c) 2014-2015, NVIDIA CORPORATION. All rights reserved.
+    //
+    // Redistribution and use in source and binary forms, with or without
+    // modification, are permitted provided that the following conditions
+    // are met:
+    //  * Redistributions of source code must retain the above copyright
+    //    notice, this list of conditions and the following disclaimer.
+    //  * Redistributions in binary form must reproduce the above copyright
+    //    notice, this list of conditions and the following disclaimer in the
+    //    documentation and/or other materials provided with the distribution.
+    //  * Neither the name of NVIDIA CORPORATION nor the names of its
+    //    contributors may be used to endorse or promote products derived
+    //    from this software without specific prior written permission.
+    //
+    "// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AS IS AND ANY",
+    // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+    // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+    // PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+    // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+    // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+    // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+    // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+    // OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+    // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+    // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+    //
+    //----------------------------------------------------------------------------------
+    
+    #define FXAA_PC 1
+    #define FXAA_GLSL_100 1
+    #define FXAA_QUALITY_PRESET 12
+    
+    #define FXAA_GREEN_AS_LUMA 1
+    
+    /*--------------------------------------------------------------------------*/
+    #ifndef FXAA_PC_CONSOLE
+        //
+        // The console algorithm for PC is included
+        // for developers targeting really low spec machines.
+        // Likely better to just run FXAA_PC, and use a really low preset.
+        //
+        #define FXAA_PC_CONSOLE 0
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #ifndef FXAA_GLSL_120
+        #define FXAA_GLSL_120 0
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #ifndef FXAA_GLSL_130
+        #define FXAA_GLSL_130 0
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #ifndef FXAA_HLSL_3
+        #define FXAA_HLSL_3 0
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #ifndef FXAA_HLSL_4
+        #define FXAA_HLSL_4 0
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #ifndef FXAA_HLSL_5
+        #define FXAA_HLSL_5 0
+    #endif
+    /*==========================================================================*/
+    #ifndef FXAA_GREEN_AS_LUMA
+        //
+        // For those using non-linear color,
+        // and either not able to get luma in alpha, or not wanting to,
+        // this enables FXAA to run using green as a proxy for luma.
+        // So with this enabled, no need to pack luma in alpha.
+        //
+        // This will turn off AA on anything which lacks some amount of green.
+        // Pure red and blue or combination of only R and B, will get no AA.
+        //
+        // Might want to lower the settings for both,
+        //    fxaaConsoleEdgeThresholdMin
+        //    fxaaQualityEdgeThresholdMin
+        // In order to insure AA does not get turned off on colors
+        // which contain a minor amount of green.
+        //
+        // 1 = On.
+        // 0 = Off.
+        //
+        #define FXAA_GREEN_AS_LUMA 0
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #ifndef FXAA_EARLY_EXIT
+        //
+    "    // Controls algorithms early exit path.",
+        // On PS3 turning this ON adds 2 cycles to the shader.
+        // On 360 turning this OFF adds 10ths of a millisecond to the shader.
+        // Turning this off on console will result in a more blurry image.
+        // So this defaults to on.
+        //
+        // 1 = On.
+        // 0 = Off.
+        //
+        #define FXAA_EARLY_EXIT 1
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #ifndef FXAA_DISCARD
+        //
+        // Only valid for PC OpenGL currently.
+        // Probably will not work when FXAA_GREEN_AS_LUMA = 1.
+        //
+    "    // 1 = Use discard on pixels which dont need AA.",
+        //     For APIs which enable concurrent TEX+ROP from same surface.
+    "    // 0 = Return unchanged color on pixels which dont need AA.",
+        //
+        #define FXAA_DISCARD 0
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #ifndef FXAA_FAST_PIXEL_OFFSET
+        //
+        // Used for GLSL 120 only.
+        //
+        // 1 = GL API supports fast pixel offsets
+        // 0 = do not use fast pixel offsets
+        //
+        #ifdef GL_EXT_gpu_shader4
+            #define FXAA_FAST_PIXEL_OFFSET 1
+        #endif
+        #ifdef GL_NV_gpu_shader5
+            #define FXAA_FAST_PIXEL_OFFSET 1
+        #endif
+        #ifdef GL_ARB_gpu_shader5
+            #define FXAA_FAST_PIXEL_OFFSET 1
+        #endif
+        #ifndef FXAA_FAST_PIXEL_OFFSET
+            #define FXAA_FAST_PIXEL_OFFSET 0
+        #endif
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #ifndef FXAA_GATHER4_ALPHA
+        //
+        // 1 = API supports gather4 on alpha channel.
+        // 0 = API does not support gather4 on alpha channel.
+        //
+        #if (FXAA_HLSL_5 == 1)
+            #define FXAA_GATHER4_ALPHA 1
+        #endif
+        #ifdef GL_ARB_gpu_shader5
+            #define FXAA_GATHER4_ALPHA 1
+        #endif
+        #ifdef GL_NV_gpu_shader5
+            #define FXAA_GATHER4_ALPHA 1
+        #endif
+        #ifndef FXAA_GATHER4_ALPHA
+            #define FXAA_GATHER4_ALPHA 0
+        #endif
+    #endif
+    
+    
+    /*============================================================================
+                            FXAA QUALITY - TUNING KNOBS
+    ------------------------------------------------------------------------------
+    NOTE the other tuning knobs are now in the shader function inputs!
+    ============================================================================*/
+    #ifndef FXAA_QUALITY_PRESET
+        //
+        // Choose the quality preset.
+        // This needs to be compiled into the shader as it effects code.
+        // Best option to include multiple presets is to
+        // in each shader define the preset, then include this file.
+        //
+        // OPTIONS
+        // -----------------------------------------------------------------------
+        // 10 to 15 - default medium dither (10=fastest, 15=highest quality)
+        // 20 to 29 - less dither, more expensive (20=fastest, 29=highest quality)
+        // 39       - no dither, very expensive
+        //
+        // NOTES
+        // -----------------------------------------------------------------------
+        // 12 = slightly faster then FXAA 3.9 and higher edge quality (default)
+        // 13 = about same speed as FXAA 3.9 and better than 12
+        // 23 = closest to FXAA 3.9 visually and performance wise
+        //  _ = the lowest digit is directly related to performance
+        // _  = the highest digit is directly related to style
+        //
+        #define FXAA_QUALITY_PRESET 12
+    #endif
+    
+    
+    /*============================================================================
+    
+                               FXAA QUALITY - PRESETS
+    
+    ============================================================================*/
+    
+    /*============================================================================
+                         FXAA QUALITY - MEDIUM DITHER PRESETS
+    ============================================================================*/
+    #if (FXAA_QUALITY_PRESET == 10)
+        #define FXAA_QUALITY_PS 3
+        #define FXAA_QUALITY_P0 1.5
+        #define FXAA_QUALITY_P1 3.0
+        #define FXAA_QUALITY_P2 12.0
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #if (FXAA_QUALITY_PRESET == 11)
+        #define FXAA_QUALITY_PS 4
+        #define FXAA_QUALITY_P0 1.0
+        #define FXAA_QUALITY_P1 1.5
+        #define FXAA_QUALITY_P2 3.0
+        #define FXAA_QUALITY_P3 12.0
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #if (FXAA_QUALITY_PRESET == 12)
+        #define FXAA_QUALITY_PS 5
+        #define FXAA_QUALITY_P0 1.0
+        #define FXAA_QUALITY_P1 1.5
+        #define FXAA_QUALITY_P2 2.0
+        #define FXAA_QUALITY_P3 4.0
+        #define FXAA_QUALITY_P4 12.0
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #if (FXAA_QUALITY_PRESET == 13)
+        #define FXAA_QUALITY_PS 6
+        #define FXAA_QUALITY_P0 1.0
+        #define FXAA_QUALITY_P1 1.5
+        #define FXAA_QUALITY_P2 2.0
+        #define FXAA_QUALITY_P3 2.0
+        #define FXAA_QUALITY_P4 4.0
+        #define FXAA_QUALITY_P5 12.0
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #if (FXAA_QUALITY_PRESET == 14)
+        #define FXAA_QUALITY_PS 7
+        #define FXAA_QUALITY_P0 1.0
+        #define FXAA_QUALITY_P1 1.5
+        #define FXAA_QUALITY_P2 2.0
+        #define FXAA_QUALITY_P3 2.0
+        #define FXAA_QUALITY_P4 2.0
+        #define FXAA_QUALITY_P5 4.0
+        #define FXAA_QUALITY_P6 12.0
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #if (FXAA_QUALITY_PRESET == 15)
+        #define FXAA_QUALITY_PS 8
+        #define FXAA_QUALITY_P0 1.0
+        #define FXAA_QUALITY_P1 1.5
+        #define FXAA_QUALITY_P2 2.0
+        #define FXAA_QUALITY_P3 2.0
+        #define FXAA_QUALITY_P4 2.0
+        #define FXAA_QUALITY_P5 2.0
+        #define FXAA_QUALITY_P6 4.0
+        #define FXAA_QUALITY_P7 12.0
+    #endif
+    
+    /*============================================================================
+                         FXAA QUALITY - LOW DITHER PRESETS
+    ============================================================================*/
+    #if (FXAA_QUALITY_PRESET == 20)
+        #define FXAA_QUALITY_PS 3
+        #define FXAA_QUALITY_P0 1.5
+        #define FXAA_QUALITY_P1 2.0
+        #define FXAA_QUALITY_P2 8.0
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #if (FXAA_QUALITY_PRESET == 21)
+        #define FXAA_QUALITY_PS 4
+        #define FXAA_QUALITY_P0 1.0
+        #define FXAA_QUALITY_P1 1.5
+        #define FXAA_QUALITY_P2 2.0
+        #define FXAA_QUALITY_P3 8.0
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #if (FXAA_QUALITY_PRESET == 22)
+        #define FXAA_QUALITY_PS 5
+        #define FXAA_QUALITY_P0 1.0
+        #define FXAA_QUALITY_P1 1.5
+        #define FXAA_QUALITY_P2 2.0
+        #define FXAA_QUALITY_P3 2.0
+        #define FXAA_QUALITY_P4 8.0
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #if (FXAA_QUALITY_PRESET == 23)
+        #define FXAA_QUALITY_PS 6
+        #define FXAA_QUALITY_P0 1.0
+        #define FXAA_QUALITY_P1 1.5
+        #define FXAA_QUALITY_P2 2.0
+        #define FXAA_QUALITY_P3 2.0
+        #define FXAA_QUALITY_P4 2.0
+        #define FXAA_QUALITY_P5 8.0
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #if (FXAA_QUALITY_PRESET == 24)
+        #define FXAA_QUALITY_PS 7
+        #define FXAA_QUALITY_P0 1.0
+        #define FXAA_QUALITY_P1 1.5
+        #define FXAA_QUALITY_P2 2.0
+        #define FXAA_QUALITY_P3 2.0
+        #define FXAA_QUALITY_P4 2.0
+        #define FXAA_QUALITY_P5 3.0
+        #define FXAA_QUALITY_P6 8.0
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #if (FXAA_QUALITY_PRESET == 25)
+        #define FXAA_QUALITY_PS 8
+        #define FXAA_QUALITY_P0 1.0
+        #define FXAA_QUALITY_P1 1.5
+        #define FXAA_QUALITY_P2 2.0
+        #define FXAA_QUALITY_P3 2.0
+        #define FXAA_QUALITY_P4 2.0
+        #define FXAA_QUALITY_P5 2.0
+        #define FXAA_QUALITY_P6 4.0
+        #define FXAA_QUALITY_P7 8.0
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #if (FXAA_QUALITY_PRESET == 26)
+        #define FXAA_QUALITY_PS 9
+        #define FXAA_QUALITY_P0 1.0
+        #define FXAA_QUALITY_P1 1.5
+        #define FXAA_QUALITY_P2 2.0
+        #define FXAA_QUALITY_P3 2.0
+        #define FXAA_QUALITY_P4 2.0
+        #define FXAA_QUALITY_P5 2.0
+        #define FXAA_QUALITY_P6 2.0
+        #define FXAA_QUALITY_P7 4.0
+        #define FXAA_QUALITY_P8 8.0
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #if (FXAA_QUALITY_PRESET == 27)
+        #define FXAA_QUALITY_PS 10
+        #define FXAA_QUALITY_P0 1.0
+        #define FXAA_QUALITY_P1 1.5
+        #define FXAA_QUALITY_P2 2.0
+        #define FXAA_QUALITY_P3 2.0
+        #define FXAA_QUALITY_P4 2.0
+        #define FXAA_QUALITY_P5 2.0
+        #define FXAA_QUALITY_P6 2.0
+        #define FXAA_QUALITY_P7 2.0
+        #define FXAA_QUALITY_P8 4.0
+        #define FXAA_QUALITY_P9 8.0
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #if (FXAA_QUALITY_PRESET == 28)
+        #define FXAA_QUALITY_PS 11
+        #define FXAA_QUALITY_P0 1.0
+        #define FXAA_QUALITY_P1 1.5
+        #define FXAA_QUALITY_P2 2.0
+        #define FXAA_QUALITY_P3 2.0
+        #define FXAA_QUALITY_P4 2.0
+        #define FXAA_QUALITY_P5 2.0
+        #define FXAA_QUALITY_P6 2.0
+        #define FXAA_QUALITY_P7 2.0
+        #define FXAA_QUALITY_P8 2.0
+        #define FXAA_QUALITY_P9 4.0
+        #define FXAA_QUALITY_P10 8.0
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #if (FXAA_QUALITY_PRESET == 29)
+        #define FXAA_QUALITY_PS 12
+        #define FXAA_QUALITY_P0 1.0
+        #define FXAA_QUALITY_P1 1.5
+        #define FXAA_QUALITY_P2 2.0
+        #define FXAA_QUALITY_P3 2.0
+        #define FXAA_QUALITY_P4 2.0
+        #define FXAA_QUALITY_P5 2.0
+        #define FXAA_QUALITY_P6 2.0
+        #define FXAA_QUALITY_P7 2.0
+        #define FXAA_QUALITY_P8 2.0
+        #define FXAA_QUALITY_P9 2.0
+        #define FXAA_QUALITY_P10 4.0
+        #define FXAA_QUALITY_P11 8.0
+    #endif
+    
+    /*============================================================================
+                         FXAA QUALITY - EXTREME QUALITY
+    ============================================================================*/
+    #if (FXAA_QUALITY_PRESET == 39)
+        #define FXAA_QUALITY_PS 12
+        #define FXAA_QUALITY_P0 1.0
+        #define FXAA_QUALITY_P1 1.0
+        #define FXAA_QUALITY_P2 1.0
+        #define FXAA_QUALITY_P3 1.0
+        #define FXAA_QUALITY_P4 1.0
+        #define FXAA_QUALITY_P5 1.5
+        #define FXAA_QUALITY_P6 2.0
+        #define FXAA_QUALITY_P7 2.0
+        #define FXAA_QUALITY_P8 2.0
+        #define FXAA_QUALITY_P9 2.0
+        #define FXAA_QUALITY_P10 4.0
+        #define FXAA_QUALITY_P11 8.0
+    #endif
+    
+    
+    
+    /*============================================================================
+    
+                                    API PORTING
+    
+    ============================================================================*/
+    #if (FXAA_GLSL_100 == 1) || (FXAA_GLSL_120 == 1) || (FXAA_GLSL_130 == 1)
+        #define FxaaBool bool
+        #define FxaaDiscard discard
+        #define FxaaFloat float
+        #define FxaaFloat2 vec2
+        #define FxaaFloat3 vec3
+        #define FxaaFloat4 vec4
+        #define FxaaHalf float
+        #define FxaaHalf2 vec2
+        #define FxaaHalf3 vec3
+        #define FxaaHalf4 vec4
+        #define FxaaInt2 ivec2
+        #define FxaaSat(x) clamp(x, 0.0, 1.0)
+        #define FxaaTex sampler2D
+    #else
+        #define FxaaBool bool
+        #define FxaaDiscard clip(-1)
+        #define FxaaFloat float
+        #define FxaaFloat2 float2
+        #define FxaaFloat3 float3
+        #define FxaaFloat4 float4
+        #define FxaaHalf half
+        #define FxaaHalf2 half2
+        #define FxaaHalf3 half3
+        #define FxaaHalf4 half4
+        #define FxaaSat(x) saturate(x)
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #if (FXAA_GLSL_100 == 1)
+      #define FxaaTexTop(t, p) texture2D(t, p, 0.0)
+      #define FxaaTexOff(t, p, o, r) texture2D(t, p + (o * r), 0.0)
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #if (FXAA_GLSL_120 == 1)
+        // Requires,
+        //  #version 120
+        // And at least,
+        //  #extension GL_EXT_gpu_shader4 : enable
+        //  (or set FXAA_FAST_PIXEL_OFFSET 1 to work like DX9)
+        #define FxaaTexTop(t, p) texture2DLod(t, p, 0.0)
+        #if (FXAA_FAST_PIXEL_OFFSET == 1)
+            #define FxaaTexOff(t, p, o, r) texture2DLodOffset(t, p, 0.0, o)
+        #else
+            #define FxaaTexOff(t, p, o, r) texture2DLod(t, p + (o * r), 0.0)
+        #endif
+        #if (FXAA_GATHER4_ALPHA == 1)
+            // use #extension GL_ARB_gpu_shader5 : enable
+            #define FxaaTexAlpha4(t, p) textureGather(t, p, 3)
+            #define FxaaTexOffAlpha4(t, p, o) textureGatherOffset(t, p, o, 3)
+            #define FxaaTexGreen4(t, p) textureGather(t, p, 1)
+            #define FxaaTexOffGreen4(t, p, o) textureGatherOffset(t, p, o, 1)
+        #endif
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #if (FXAA_GLSL_130 == 1)
+        // Requires "#version 130" or better
+        #define FxaaTexTop(t, p) textureLod(t, p, 0.0)
+        #define FxaaTexOff(t, p, o, r) textureLodOffset(t, p, 0.0, o)
+        #if (FXAA_GATHER4_ALPHA == 1)
+            // use #extension GL_ARB_gpu_shader5 : enable
+            #define FxaaTexAlpha4(t, p) textureGather(t, p, 3)
+            #define FxaaTexOffAlpha4(t, p, o) textureGatherOffset(t, p, o, 3)
+            #define FxaaTexGreen4(t, p) textureGather(t, p, 1)
+            #define FxaaTexOffGreen4(t, p, o) textureGatherOffset(t, p, o, 1)
+        #endif
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #if (FXAA_HLSL_3 == 1)
+        #define FxaaInt2 float2
+        #define FxaaTex sampler2D
+        #define FxaaTexTop(t, p) tex2Dlod(t, float4(p, 0.0, 0.0))
+        #define FxaaTexOff(t, p, o, r) tex2Dlod(t, float4(p + (o * r), 0, 0))
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #if (FXAA_HLSL_4 == 1)
+        #define FxaaInt2 int2
+        struct FxaaTex { SamplerState smpl; Texture2D tex; };
+        #define FxaaTexTop(t, p) t.tex.SampleLevel(t.smpl, p, 0.0)
+        #define FxaaTexOff(t, p, o, r) t.tex.SampleLevel(t.smpl, p, 0.0, o)
+    #endif
+    /*--------------------------------------------------------------------------*/
+    #if (FXAA_HLSL_5 == 1)
+        #define FxaaInt2 int2
+        struct FxaaTex { SamplerState smpl; Texture2D tex; };
+        #define FxaaTexTop(t, p) t.tex.SampleLevel(t.smpl, p, 0.0)
+        #define FxaaTexOff(t, p, o, r) t.tex.SampleLevel(t.smpl, p, 0.0, o)
+        #define FxaaTexAlpha4(t, p) t.tex.GatherAlpha(t.smpl, p)
+        #define FxaaTexOffAlpha4(t, p, o) t.tex.GatherAlpha(t.smpl, p, o)
+        #define FxaaTexGreen4(t, p) t.tex.GatherGreen(t.smpl, p)
+        #define FxaaTexOffGreen4(t, p, o) t.tex.GatherGreen(t.smpl, p, o)
+    #endif
+    
+    
+    /*============================================================================
+                       GREEN AS LUMA OPTION SUPPORT FUNCTION
+    ============================================================================*/
+    #if (FXAA_GREEN_AS_LUMA == 0)
+        FxaaFloat FxaaLuma(FxaaFloat4 rgba) { return rgba.w; }
+    #else
+        FxaaFloat FxaaLuma(FxaaFloat4 rgba) { return rgba.y; }
+    #endif
+    
+    
+    
+    
+    /*============================================================================
+    
+                                 FXAA3 QUALITY - PC
+    
+    ============================================================================*/
+    #if (FXAA_PC == 1)
+    /*--------------------------------------------------------------------------*/
+    FxaaFloat4 FxaaPixelShader(
+        //
+        // Use noperspective interpolation here (turn off perspective interpolation).
+        // {xy} = center of pixel
+        FxaaFloat2 pos,
+        //
+        // Used only for FXAA Console, and not used on the 360 version.
+        // Use noperspective interpolation here (turn off perspective interpolation).
+        // {xy_} = upper left of pixel
+        // {_zw} = lower right of pixel
+        FxaaFloat4 fxaaConsolePosPos,
+        //
+        // Input color texture.
+        // {rgb_} = color in linear or perceptual color space
+        // if (FXAA_GREEN_AS_LUMA == 0)
+        //     {__a} = luma in perceptual color space (not linear)
+        FxaaTex tex,
+        //
+        // Only used on the optimized 360 version of FXAA Console.
+        // For everything but 360, just use the same input here as for "tex".
+        // For 360, same texture, just alias with a 2nd sampler.
+        // This sampler needs to have an exponent bias of -1.
+        FxaaTex fxaaConsole360TexExpBiasNegOne,
+        //
+        // Only used on the optimized 360 version of FXAA Console.
+        // For everything but 360, just use the same input here as for "tex".
+        // For 360, same texture, just alias with a 3nd sampler.
+        // This sampler needs to have an exponent bias of -2.
+        FxaaTex fxaaConsole360TexExpBiasNegTwo,
+        //
+        // Only used on FXAA Quality.
+        // This must be from a constant/uniform.
+        // {x_} = 1.0/screenWidthInPixels
+        // {_y} = 1.0/screenHeightInPixels
+        FxaaFloat2 fxaaQualityRcpFrame,
+        //
+        // Only used on FXAA Console.
+        // This must be from a constant/uniform.
+        // This effects sub-pixel AA quality and inversely sharpness.
+        //   Where N ranges between,
+        //     N = 0.50 (default)
+        //     N = 0.33 (sharper)
+        // {x__} = -N/screenWidthInPixels
+        // {_y_} = -N/screenHeightInPixels
+        // {_z_} =  N/screenWidthInPixels
+        // {__w} =  N/screenHeightInPixels
+        FxaaFloat4 fxaaConsoleRcpFrameOpt,
+        //
+        // Only used on FXAA Console.
+        // Not used on 360, but used on PS3 and PC.
+        // This must be from a constant/uniform.
+        // {x__} = -2.0/screenWidthInPixels
+        // {_y_} = -2.0/screenHeightInPixels
+        // {_z_} =  2.0/screenWidthInPixels
+        // {__w} =  2.0/screenHeightInPixels
+        FxaaFloat4 fxaaConsoleRcpFrameOpt2,
+        //
+        // Only used on FXAA Console.
+        // Only used on 360 in place of fxaaConsoleRcpFrameOpt2.
+        // This must be from a constant/uniform.
+        // {x__} =  8.0/screenWidthInPixels
+        // {_y_} =  8.0/screenHeightInPixels
+        // {_z_} = -4.0/screenWidthInPixels
+        // {__w} = -4.0/screenHeightInPixels
+        FxaaFloat4 fxaaConsole360RcpFrameOpt2,
+        //
+        // Only used on FXAA Quality.
+        // This used to be the FXAA_QUALITY_SUBPIX define.
+        // It is here now to allow easier tuning.
+        // Choose the amount of sub-pixel aliasing removal.
+        // This can effect sharpness.
+        //   1.00 - upper limit (softer)
+        //   0.75 - default amount of filtering
+        //   0.50 - lower limit (sharper, less sub-pixel aliasing removal)
+        //   0.25 - almost off
+        //   0.00 - completely off
+        FxaaFloat fxaaQualitySubpix,
+        //
+        // Only used on FXAA Quality.
+        // This used to be the FXAA_QUALITY_EDGE_THRESHOLD define.
+        // It is here now to allow easier tuning.
+        // The minimum amount of local contrast required to apply algorithm.
+        //   0.333 - too little (faster)
+        //   0.250 - low quality
+        //   0.166 - default
+        //   0.125 - high quality
+        //   0.063 - overkill (slower)
+        FxaaFloat fxaaQualityEdgeThreshold,
+        //
+        // Only used on FXAA Quality.
+        // This used to be the FXAA_QUALITY_EDGE_THRESHOLD_MIN define.
+        // It is here now to allow easier tuning.
+        // Trims the algorithm from processing darks.
+        //   0.0833 - upper limit (default, the start of visible unfiltered edges)
+        //   0.0625 - high quality (faster)
+        //   0.0312 - visible limit (slower)
+        // Special notes when using FXAA_GREEN_AS_LUMA,
+        //   Likely want to set this to zero.
+        //   As colors that are mostly not-green
+        //   will appear very dark in the green channel!
+        //   Tune by looking at mostly non-green content,
+        //   then start at zero and increase until aliasing is a problem.
+        FxaaFloat fxaaQualityEdgeThresholdMin,
+        //
+        // Only used on FXAA Console.
+        // This used to be the FXAA_CONSOLE_EDGE_SHARPNESS define.
+        // It is here now to allow easier tuning.
+        // This does not effect PS3, as this needs to be compiled in.
+        //   Use FXAA_CONSOLE_PS3_EDGE_SHARPNESS for PS3.
+        //   Due to the PS3 being ALU bound,
+        //   there are only three safe values here: 2 and 4 and 8.
+        //   These options use the shaders ability to a free *|/ by 2|4|8.
+        // For all other platforms can be a non-power of two.
+        //   8.0 is sharper (default!!!)
+        //   4.0 is softer
+        //   2.0 is really soft (good only for vector graphics inputs)
+        FxaaFloat fxaaConsoleEdgeSharpness,
+        //
+        // Only used on FXAA Console.
+        // This used to be the FXAA_CONSOLE_EDGE_THRESHOLD define.
+        // It is here now to allow easier tuning.
+        // This does not effect PS3, as this needs to be compiled in.
+        //   Use FXAA_CONSOLE_PS3_EDGE_THRESHOLD for PS3.
+        //   Due to the PS3 being ALU bound,
+        //   there are only two safe values here: 1/4 and 1/8.
+        //   These options use the shaders ability to a free *|/ by 2|4|8.
+        // The console setting has a different mapping than the quality setting.
+        // Other platforms can use other values.
+        //   0.125 leaves less aliasing, but is softer (default!!!)
+        //   0.25 leaves more aliasing, and is sharper
+        FxaaFloat fxaaConsoleEdgeThreshold,
+        //
+        // Only used on FXAA Console.
+        // This used to be the FXAA_CONSOLE_EDGE_THRESHOLD_MIN define.
+        // It is here now to allow easier tuning.
+        // Trims the algorithm from processing darks.
+        // The console setting has a different mapping than the quality setting.
+        // This only applies when FXAA_EARLY_EXIT is 1.
+        // This does not apply to PS3,
+        // PS3 was simplified to avoid more shader instructions.
+        //   0.06 - faster but more aliasing in darks
+        //   0.05 - default
+        //   0.04 - slower and less aliasing in darks
+        // Special notes when using FXAA_GREEN_AS_LUMA,
+        //   Likely want to set this to zero.
+        //   As colors that are mostly not-green
+        //   will appear very dark in the green channel!
+        //   Tune by looking at mostly non-green content,
+        //   then start at zero and increase until aliasing is a problem.
+        FxaaFloat fxaaConsoleEdgeThresholdMin,
+        //
+        // Extra constants for 360 FXAA Console only.
+        // Use zeros or anything else for other platforms.
+        // These must be in physical constant registers and NOT immediates.
+        // Immediates will result in compiler un-optimizing.
+        // {xyzw} = float4(1.0, -1.0, 0.25, -0.25)
+        FxaaFloat4 fxaaConsole360ConstDir
+    ) {
+    /*--------------------------------------------------------------------------*/
+        FxaaFloat2 posM;
+        posM.x = pos.x;
+        posM.y = pos.y;
+        #if (FXAA_GATHER4_ALPHA == 1)
+            #if (FXAA_DISCARD == 0)
+                FxaaFloat4 rgbyM = FxaaTexTop(tex, posM);
+                #if (FXAA_GREEN_AS_LUMA == 0)
+                    #define lumaM rgbyM.w
+                #else
+                    #define lumaM rgbyM.y
+                #endif
+            #endif
+            #if (FXAA_GREEN_AS_LUMA == 0)
+                FxaaFloat4 luma4A = FxaaTexAlpha4(tex, posM);
+                FxaaFloat4 luma4B = FxaaTexOffAlpha4(tex, posM, FxaaInt2(-1, -1));
+            #else
+                FxaaFloat4 luma4A = FxaaTexGreen4(tex, posM);
+                FxaaFloat4 luma4B = FxaaTexOffGreen4(tex, posM, FxaaInt2(-1, -1));
+            #endif
+            #if (FXAA_DISCARD == 1)
+                #define lumaM luma4A.w
+            #endif
+            #define lumaE luma4A.z
+            #define lumaS luma4A.x
+            #define lumaSE luma4A.y
+            #define lumaNW luma4B.w
+            #define lumaN luma4B.z
+            #define lumaW luma4B.x
+        #else
+            FxaaFloat4 rgbyM = FxaaTexTop(tex, posM);
+            #if (FXAA_GREEN_AS_LUMA == 0)
+                #define lumaM rgbyM.w
+            #else
+                #define lumaM rgbyM.y
+            #endif
+            #if (FXAA_GLSL_100 == 1)
+              FxaaFloat lumaS = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2( 0.0, 1.0), fxaaQualityRcpFrame.xy));
+              FxaaFloat lumaE = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2( 1.0, 0.0), fxaaQualityRcpFrame.xy));
+              FxaaFloat lumaN = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2( 0.0,-1.0), fxaaQualityRcpFrame.xy));
+              FxaaFloat lumaW = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2(-1.0, 0.0), fxaaQualityRcpFrame.xy));
+            #else
+              FxaaFloat lumaS = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 0, 1), fxaaQualityRcpFrame.xy));
+              FxaaFloat lumaE = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 1, 0), fxaaQualityRcpFrame.xy));
+              FxaaFloat lumaN = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 0,-1), fxaaQualityRcpFrame.xy));
+              FxaaFloat lumaW = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(-1, 0), fxaaQualityRcpFrame.xy));
+            #endif
+        #endif
+    /*--------------------------------------------------------------------------*/
+        FxaaFloat maxSM = max(lumaS, lumaM);
+        FxaaFloat minSM = min(lumaS, lumaM);
+        FxaaFloat maxESM = max(lumaE, maxSM);
+        FxaaFloat minESM = min(lumaE, minSM);
+        FxaaFloat maxWN = max(lumaN, lumaW);
+        FxaaFloat minWN = min(lumaN, lumaW);
+        FxaaFloat rangeMax = max(maxWN, maxESM);
+        FxaaFloat rangeMin = min(minWN, minESM);
+        FxaaFloat rangeMaxScaled = rangeMax * fxaaQualityEdgeThreshold;
+        FxaaFloat range = rangeMax - rangeMin;
+        FxaaFloat rangeMaxClamped = max(fxaaQualityEdgeThresholdMin, rangeMaxScaled);
+        FxaaBool earlyExit = range < rangeMaxClamped;
+    /*--------------------------------------------------------------------------*/
+        if(earlyExit)
+            #if (FXAA_DISCARD == 1)
+                FxaaDiscard;
+            #else
+                return rgbyM;
+            #endif
+    /*--------------------------------------------------------------------------*/
+        #if (FXAA_GATHER4_ALPHA == 0)
+            #if (FXAA_GLSL_100 == 1)
+              FxaaFloat lumaNW = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2(-1.0,-1.0), fxaaQualityRcpFrame.xy));
+              FxaaFloat lumaSE = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2( 1.0, 1.0), fxaaQualityRcpFrame.xy));
+              FxaaFloat lumaNE = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2( 1.0,-1.0), fxaaQualityRcpFrame.xy));
+              FxaaFloat lumaSW = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2(-1.0, 1.0), fxaaQualityRcpFrame.xy));
+            #else
+              FxaaFloat lumaNW = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(-1,-1), fxaaQualityRcpFrame.xy));
+              FxaaFloat lumaSE = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 1, 1), fxaaQualityRcpFrame.xy));
+              FxaaFloat lumaNE = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 1,-1), fxaaQualityRcpFrame.xy));
+              FxaaFloat lumaSW = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(-1, 1), fxaaQualityRcpFrame.xy));
+            #endif
+        #else
+            FxaaFloat lumaNE = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(1, -1), fxaaQualityRcpFrame.xy));
+            FxaaFloat lumaSW = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(-1, 1), fxaaQualityRcpFrame.xy));
+        #endif
+    /*--------------------------------------------------------------------------*/
+        FxaaFloat lumaNS = lumaN + lumaS;
+        FxaaFloat lumaWE = lumaW + lumaE;
+        FxaaFloat subpixRcpRange = 1.0/range;
+        FxaaFloat subpixNSWE = lumaNS + lumaWE;
+        FxaaFloat edgeHorz1 = (-2.0 * lumaM) + lumaNS;
+        FxaaFloat edgeVert1 = (-2.0 * lumaM) + lumaWE;
+    /*--------------------------------------------------------------------------*/
+        FxaaFloat lumaNESE = lumaNE + lumaSE;
+        FxaaFloat lumaNWNE = lumaNW + lumaNE;
+        FxaaFloat edgeHorz2 = (-2.0 * lumaE) + lumaNESE;
+        FxaaFloat edgeVert2 = (-2.0 * lumaN) + lumaNWNE;
+    /*--------------------------------------------------------------------------*/
+        FxaaFloat lumaNWSW = lumaNW + lumaSW;
+        FxaaFloat lumaSWSE = lumaSW + lumaSE;
+        FxaaFloat edgeHorz4 = (abs(edgeHorz1) * 2.0) + abs(edgeHorz2);
+        FxaaFloat edgeVert4 = (abs(edgeVert1) * 2.0) + abs(edgeVert2);
+        FxaaFloat edgeHorz3 = (-2.0 * lumaW) + lumaNWSW;
+        FxaaFloat edgeVert3 = (-2.0 * lumaS) + lumaSWSE;
+        FxaaFloat edgeHorz = abs(edgeHorz3) + edgeHorz4;
+        FxaaFloat edgeVert = abs(edgeVert3) + edgeVert4;
+    /*--------------------------------------------------------------------------*/
+        FxaaFloat subpixNWSWNESE = lumaNWSW + lumaNESE;
+        FxaaFloat lengthSign = fxaaQualityRcpFrame.x;
+        FxaaBool horzSpan = edgeHorz >= edgeVert;
+        FxaaFloat subpixA = subpixNSWE * 2.0 + subpixNWSWNESE;
+    /*--------------------------------------------------------------------------*/
+        if(!horzSpan) lumaN = lumaW;
+        if(!horzSpan) lumaS = lumaE;
+        if(horzSpan) lengthSign = fxaaQualityRcpFrame.y;
+        FxaaFloat subpixB = (subpixA * (1.0/12.0)) - lumaM;
+    /*--------------------------------------------------------------------------*/
+        FxaaFloat gradientN = lumaN - lumaM;
+        FxaaFloat gradientS = lumaS - lumaM;
+        FxaaFloat lumaNN = lumaN + lumaM;
+        FxaaFloat lumaSS = lumaS + lumaM;
+        FxaaBool pairN = abs(gradientN) >= abs(gradientS);
+        FxaaFloat gradient = max(abs(gradientN), abs(gradientS));
+        if(pairN) lengthSign = -lengthSign;
+        FxaaFloat subpixC = FxaaSat(abs(subpixB) * subpixRcpRange);
+    /*--------------------------------------------------------------------------*/
+        FxaaFloat2 posB;
+        posB.x = posM.x;
+        posB.y = posM.y;
+        FxaaFloat2 offNP;
+        offNP.x = (!horzSpan) ? 0.0 : fxaaQualityRcpFrame.x;
+        offNP.y = ( horzSpan) ? 0.0 : fxaaQualityRcpFrame.y;
+        if(!horzSpan) posB.x += lengthSign * 0.5;
+        if( horzSpan) posB.y += lengthSign * 0.5;
+    /*--------------------------------------------------------------------------*/
+        FxaaFloat2 posN;
+        posN.x = posB.x - offNP.x * FXAA_QUALITY_P0;
+        posN.y = posB.y - offNP.y * FXAA_QUALITY_P0;
+        FxaaFloat2 posP;
+        posP.x = posB.x + offNP.x * FXAA_QUALITY_P0;
+        posP.y = posB.y + offNP.y * FXAA_QUALITY_P0;
+        FxaaFloat subpixD = ((-2.0)*subpixC) + 3.0;
+        FxaaFloat lumaEndN = FxaaLuma(FxaaTexTop(tex, posN));
+        FxaaFloat subpixE = subpixC * subpixC;
+        FxaaFloat lumaEndP = FxaaLuma(FxaaTexTop(tex, posP));
+    /*--------------------------------------------------------------------------*/
+        if(!pairN) lumaNN = lumaSS;
+        FxaaFloat gradientScaled = gradient * 1.0/4.0;
+        FxaaFloat lumaMM = lumaM - lumaNN * 0.5;
+        FxaaFloat subpixF = subpixD * subpixE;
+        FxaaBool lumaMLTZero = lumaMM < 0.0;
+    /*--------------------------------------------------------------------------*/
+        lumaEndN -= lumaNN * 0.5;
+        lumaEndP -= lumaNN * 0.5;
+        FxaaBool doneN = abs(lumaEndN) >= gradientScaled;
+        FxaaBool doneP = abs(lumaEndP) >= gradientScaled;
+        if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P1;
+        if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P1;
+        FxaaBool doneNP = (!doneN) || (!doneP);
+        if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P1;
+        if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P1;
+    /*--------------------------------------------------------------------------*/
+        if(doneNP) {
+            if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
+            if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
+            if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
+            if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
+            doneN = abs(lumaEndN) >= gradientScaled;
+            doneP = abs(lumaEndP) >= gradientScaled;
+            if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P2;
+            if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P2;
+            doneNP = (!doneN) || (!doneP);
+            if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P2;
+            if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P2;
+    /*--------------------------------------------------------------------------*/
+            #if (FXAA_QUALITY_PS > 3)
+            if(doneNP) {
+                if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
+                if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
+                if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
+                if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
+                doneN = abs(lumaEndN) >= gradientScaled;
+                doneP = abs(lumaEndP) >= gradientScaled;
+                if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P3;
+                if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P3;
+                doneNP = (!doneN) || (!doneP);
+                if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P3;
+                if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P3;
+    /*--------------------------------------------------------------------------*/
+                #if (FXAA_QUALITY_PS > 4)
+                if(doneNP) {
+                    if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
+                    if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
+                    if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
+                    if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
+                    doneN = abs(lumaEndN) >= gradientScaled;
+                    doneP = abs(lumaEndP) >= gradientScaled;
+                    if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P4;
+                    if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P4;
+                    doneNP = (!doneN) || (!doneP);
+                    if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P4;
+                    if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P4;
+    /*--------------------------------------------------------------------------*/
+                    #if (FXAA_QUALITY_PS > 5)
+                    if(doneNP) {
+                        if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
+                        if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
+                        if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
+                        if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
+                        doneN = abs(lumaEndN) >= gradientScaled;
+                        doneP = abs(lumaEndP) >= gradientScaled;
+                        if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P5;
+                        if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P5;
+                        doneNP = (!doneN) || (!doneP);
+                        if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P5;
+                        if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P5;
+    /*--------------------------------------------------------------------------*/
+                        #if (FXAA_QUALITY_PS > 6)
+                        if(doneNP) {
+                            if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
+                            if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
+                            if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
+                            if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
+                            doneN = abs(lumaEndN) >= gradientScaled;
+                            doneP = abs(lumaEndP) >= gradientScaled;
+                            if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P6;
+                            if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P6;
+                            doneNP = (!doneN) || (!doneP);
+                            if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P6;
+                            if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P6;
+    /*--------------------------------------------------------------------------*/
+                            #if (FXAA_QUALITY_PS > 7)
+                            if(doneNP) {
+                                if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
+                                if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
+                                if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
+                                if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
+                                doneN = abs(lumaEndN) >= gradientScaled;
+                                doneP = abs(lumaEndP) >= gradientScaled;
+                                if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P7;
+                                if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P7;
+                                doneNP = (!doneN) || (!doneP);
+                                if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P7;
+                                if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P7;
+    /*--------------------------------------------------------------------------*/
+        #if (FXAA_QUALITY_PS > 8)
+        if(doneNP) {
+            if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
+            if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
+            if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
+            if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
+            doneN = abs(lumaEndN) >= gradientScaled;
+            doneP = abs(lumaEndP) >= gradientScaled;
+            if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P8;
+            if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P8;
+            doneNP = (!doneN) || (!doneP);
+            if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P8;
+            if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P8;
+    /*--------------------------------------------------------------------------*/
+            #if (FXAA_QUALITY_PS > 9)
+            if(doneNP) {
+                if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
+                if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
+                if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
+                if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
+                doneN = abs(lumaEndN) >= gradientScaled;
+                doneP = abs(lumaEndP) >= gradientScaled;
+                if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P9;
+                if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P9;
+                doneNP = (!doneN) || (!doneP);
+                if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P9;
+                if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P9;
+    /*--------------------------------------------------------------------------*/
+                #if (FXAA_QUALITY_PS > 10)
+                if(doneNP) {
+                    if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
+                    if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
+                    if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
+                    if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
+                    doneN = abs(lumaEndN) >= gradientScaled;
+                    doneP = abs(lumaEndP) >= gradientScaled;
+                    if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P10;
+                    if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P10;
+                    doneNP = (!doneN) || (!doneP);
+                    if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P10;
+                    if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P10;
+    /*--------------------------------------------------------------------------*/
+                    #if (FXAA_QUALITY_PS > 11)
+                    if(doneNP) {
+                        if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
+                        if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
+                        if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
+                        if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
+                        doneN = abs(lumaEndN) >= gradientScaled;
+                        doneP = abs(lumaEndP) >= gradientScaled;
+                        if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P11;
+                        if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P11;
+                        doneNP = (!doneN) || (!doneP);
+                        if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P11;
+                        if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P11;
+    /*--------------------------------------------------------------------------*/
+                        #if (FXAA_QUALITY_PS > 12)
+                        if(doneNP) {
+                            if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
+                            if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
+                            if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
+                            if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
+                            doneN = abs(lumaEndN) >= gradientScaled;
+                            doneP = abs(lumaEndP) >= gradientScaled;
+                            if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P12;
+                            if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P12;
+                            doneNP = (!doneN) || (!doneP);
+                            if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P12;
+                            if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P12;
+    /*--------------------------------------------------------------------------*/
+                        }
+                        #endif
+    /*--------------------------------------------------------------------------*/
+                    }
+                    #endif
+    /*--------------------------------------------------------------------------*/
+                }
+                #endif
+    /*--------------------------------------------------------------------------*/
+            }
+            #endif
+    /*--------------------------------------------------------------------------*/
+        }
+        #endif
+    /*--------------------------------------------------------------------------*/
+                            }
+                            #endif
+    /*--------------------------------------------------------------------------*/
+                        }
+                        #endif
+    /*--------------------------------------------------------------------------*/
+                    }
+                    #endif
+    /*--------------------------------------------------------------------------*/
+                }
+                #endif
+    /*--------------------------------------------------------------------------*/
+            }
+            #endif
+    /*--------------------------------------------------------------------------*/
+        }
+    /*--------------------------------------------------------------------------*/
+        FxaaFloat dstN = posM.x - posN.x;
+        FxaaFloat dstP = posP.x - posM.x;
+        if(!horzSpan) dstN = posM.y - posN.y;
+        if(!horzSpan) dstP = posP.y - posM.y;
+    /*--------------------------------------------------------------------------*/
+        FxaaBool goodSpanN = (lumaEndN < 0.0) != lumaMLTZero;
+        FxaaFloat spanLength = (dstP + dstN);
+        FxaaBool goodSpanP = (lumaEndP < 0.0) != lumaMLTZero;
+        FxaaFloat spanLengthRcp = 1.0/spanLength;
+    /*--------------------------------------------------------------------------*/
+        FxaaBool directionN = dstN < dstP;
+        FxaaFloat dst = min(dstN, dstP);
+        FxaaBool goodSpan = directionN ? goodSpanN : goodSpanP;
+        FxaaFloat subpixG = subpixF * subpixF;
+        FxaaFloat pixelOffset = (dst * (-spanLengthRcp)) + 0.5;
+        FxaaFloat subpixH = subpixG * fxaaQualitySubpix;
+    /*--------------------------------------------------------------------------*/
+        FxaaFloat pixelOffsetGood = goodSpan ? pixelOffset : 0.0;
+        FxaaFloat pixelOffsetSubpix = max(pixelOffsetGood, subpixH);
+        if(!horzSpan) posM.x += pixelOffsetSubpix * lengthSign;
+        if( horzSpan) posM.y += pixelOffsetSubpix * lengthSign;
+        #if (FXAA_DISCARD == 1)
+            return FxaaTexTop(tex, posM);
+        #else
+            return FxaaFloat4(FxaaTexTop(tex, posM).xyz, lumaM);
+        #endif
+    }
+    /*==========================================================================*/
+    #endif
+    
+    void main() {
+      gl_FragColor = FxaaPixelShader(
+        vUv,
+        vec4(0.0),
+        tDiffuse,
+        tDiffuse,
+        tDiffuse,
+        resolution,
+        vec4(0.0),
+        vec4(0.0),
+        vec4(0.0),
+        0.75,
+        0.166,
+        0.0833,
+        0.0,
+        0.0,
+        0.0,
+        vec4(0.0)
+      );
+    
+      // TODO avoid querying texture twice for same texel
+      gl_FragColor.a = texture2D(tDiffuse, vUv).a;
+    }
+  `,
 }
diff --git a/src/shaders/FilmShader.ts b/src/shaders/FilmShader.ts
index bc98b542..e05b9c7e 100644
--- a/src/shaders/FilmShader.ts
+++ b/src/shaders/FilmShader.ts
@@ -28,67 +28,67 @@ export const FilmShader = {
     grayscale: { value: 1 },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    '#include <common>',
+  fragmentShader: /* glsl */ `
+    #include <common>
 
     // control parameter
-    'uniform float time;',
+    uniform float time;
 
-    'uniform bool grayscale;',
+    uniform bool grayscale;
 
     // noise effect intensity value (0 = no effect, 1 = full effect)
-    'uniform float nIntensity;',
+    uniform float nIntensity;
 
     // scanlines effect intensity value (0 = no effect, 1 = full effect)
-    'uniform float sIntensity;',
+    uniform float sIntensity;
 
     // scanlines effect count value (0 = no effect, 4096 = full effect)
-    'uniform float sCount;',
+    uniform float sCount;
 
-    'uniform sampler2D tDiffuse;',
+    uniform sampler2D tDiffuse;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
     // sample the source
-    '	vec4 cTextureScreen = texture2D( tDiffuse, vUv );',
+    	vec4 cTextureScreen = texture2D( tDiffuse, vUv );
 
     // make some noise
-    '	float dx = rand( vUv + time );',
+    	float dx = rand( vUv + time );
 
     // add noise
-    '	vec3 cResult = cTextureScreen.rgb + cTextureScreen.rgb * clamp( 0.1 + dx, 0.0, 1.0 );',
+    	vec3 cResult = cTextureScreen.rgb + cTextureScreen.rgb * clamp( 0.1 + dx, 0.0, 1.0 );
 
     // get us a sine and cosine
-    '	vec2 sc = vec2( sin( vUv.y * sCount ), cos( vUv.y * sCount ) );',
+    	vec2 sc = vec2( sin( vUv.y * sCount ), cos( vUv.y * sCount ) );
 
     // add scanlines
-    '	cResult += cTextureScreen.rgb * vec3( sc.x, sc.y, sc.x ) * sIntensity;',
+    	cResult += cTextureScreen.rgb * vec3( sc.x, sc.y, sc.x ) * sIntensity;
 
     // interpolate between source and result by intensity
-    '	cResult = cTextureScreen.rgb + clamp( nIntensity, 0.0,1.0 ) * ( cResult - cTextureScreen.rgb );',
+    	cResult = cTextureScreen.rgb + clamp( nIntensity, 0.0,1.0 ) * ( cResult - cTextureScreen.rgb );
 
     // convert to grayscale if desired
-    '	if( grayscale ) {',
+    	if( grayscale ) {
 
-    '		cResult = vec3( cResult.r * 0.3 + cResult.g * 0.59 + cResult.b * 0.11 );',
+    		cResult = vec3( cResult.r * 0.3 + cResult.g * 0.59 + cResult.b * 0.11 );
 
-    '	}',
+    	}
 
-    '	gl_FragColor =  vec4( cResult, cTextureScreen.a );',
+    	gl_FragColor =  vec4( cResult, cTextureScreen.a );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/FocusShader.ts b/src/shaders/FocusShader.ts
index 8e49a8ba..68261a59 100644
--- a/src/shaders/FocusShader.ts
+++ b/src/shaders/FocusShader.ts
@@ -13,69 +13,69 @@ export const FocusShader = {
     waveFactor: { value: 0.00125 },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform float screenWidth;',
-    'uniform float screenHeight;',
-    'uniform float sampleDistance;',
-    'uniform float waveFactor;',
+  fragmentShader: /* glsl */ `
+    uniform float screenWidth;
+    uniform float screenHeight;
+    uniform float sampleDistance;
+    uniform float waveFactor;
 
-    'uniform sampler2D tDiffuse;',
+    uniform sampler2D tDiffuse;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vec4 color, org, tmp, add;',
-    '	float sample_dist, f;',
-    '	vec2 vin;',
-    '	vec2 uv = vUv;',
+    	vec4 color, org, tmp, add;
+    	float sample_dist, f;
+    	vec2 vin;
+    	vec2 uv = vUv;
 
-    '	add = color = org = texture2D( tDiffuse, uv );',
+    	add = color = org = texture2D( tDiffuse, uv );
 
-    '	vin = ( uv - vec2( 0.5 ) ) * vec2( 1.4 );',
-    '	sample_dist = dot( vin, vin ) * 2.0;',
+    	vin = ( uv - vec2( 0.5 ) ) * vec2( 1.4 );
+    	sample_dist = dot( vin, vin ) * 2.0;
 
-    '	f = ( waveFactor * 100.0 + sample_dist ) * sampleDistance * 4.0;',
+    	f = ( waveFactor * 100.0 + sample_dist ) * sampleDistance * 4.0;
 
-    '	vec2 sampleSize = vec2(  1.0 / screenWidth, 1.0 / screenHeight ) * vec2( f );',
+    	vec2 sampleSize = vec2(  1.0 / screenWidth, 1.0 / screenHeight ) * vec2( f );
 
-    '	add += tmp = texture2D( tDiffuse, uv + vec2( 0.111964, 0.993712 ) * sampleSize );',
-    '	if( tmp.b < color.b ) color = tmp;',
+    	add += tmp = texture2D( tDiffuse, uv + vec2( 0.111964, 0.993712 ) * sampleSize );
+    	if( tmp.b < color.b ) color = tmp;
 
-    '	add += tmp = texture2D( tDiffuse, uv + vec2( 0.846724, 0.532032 ) * sampleSize );',
-    '	if( tmp.b < color.b ) color = tmp;',
+    	add += tmp = texture2D( tDiffuse, uv + vec2( 0.846724, 0.532032 ) * sampleSize );
+    	if( tmp.b < color.b ) color = tmp;
 
-    '	add += tmp = texture2D( tDiffuse, uv + vec2( 0.943883, -0.330279 ) * sampleSize );',
-    '	if( tmp.b < color.b ) color = tmp;',
+    	add += tmp = texture2D( tDiffuse, uv + vec2( 0.943883, -0.330279 ) * sampleSize );
+    	if( tmp.b < color.b ) color = tmp;
 
-    '	add += tmp = texture2D( tDiffuse, uv + vec2( 0.330279, -0.943883 ) * sampleSize );',
-    '	if( tmp.b < color.b ) color = tmp;',
+    	add += tmp = texture2D( tDiffuse, uv + vec2( 0.330279, -0.943883 ) * sampleSize );
+    	if( tmp.b < color.b ) color = tmp;
 
-    '	add += tmp = texture2D( tDiffuse, uv + vec2( -0.532032, -0.846724 ) * sampleSize );',
-    '	if( tmp.b < color.b ) color = tmp;',
+    	add += tmp = texture2D( tDiffuse, uv + vec2( -0.532032, -0.846724 ) * sampleSize );
+    	if( tmp.b < color.b ) color = tmp;
 
-    '	add += tmp = texture2D( tDiffuse, uv + vec2( -0.993712, -0.111964 ) * sampleSize );',
-    '	if( tmp.b < color.b ) color = tmp;',
+    	add += tmp = texture2D( tDiffuse, uv + vec2( -0.993712, -0.111964 ) * sampleSize );
+    	if( tmp.b < color.b ) color = tmp;
 
-    '	add += tmp = texture2D( tDiffuse, uv + vec2( -0.707107, 0.707107 ) * sampleSize );',
-    '	if( tmp.b < color.b ) color = tmp;',
+    	add += tmp = texture2D( tDiffuse, uv + vec2( -0.707107, 0.707107 ) * sampleSize );
+    	if( tmp.b < color.b ) color = tmp;
 
-    '	color = color * vec4( 2.0 ) - ( add / vec4( 8.0 ) );',
-    '	color = color + ( add / vec4( 8.0 ) - color ) * ( vec4( 1.0 ) - vec4( sample_dist * 0.5 ) );',
+    	color = color * vec4( 2.0 ) - ( add / vec4( 8.0 ) );
+    	color = color + ( add / vec4( 8.0 ) - color ) * ( vec4( 1.0 ) - vec4( sample_dist * 0.5 ) );
 
-    '	gl_FragColor = vec4( color.rgb * color.rgb * vec3( 0.95 ) + color.rgb, 1.0 );',
+    	gl_FragColor = vec4( color.rgb * color.rgb * vec3( 0.95 ) + color.rgb, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/FreiChenShader.ts b/src/shaders/FreiChenShader.ts
index 4a0e2ea7..9778f4f1 100644
--- a/src/shaders/FreiChenShader.ts
+++ b/src/shaders/FreiChenShader.ts
@@ -10,77 +10,77 @@ import { Vector2 } from 'three'
 export const FreiChenShader = {
   uniforms: {
     tDiffuse: { value: null },
-    aspect: { value: new Vector2(512, 512) },
+    aspect: { value: /* @__PURE__ */ new Vector2(512, 512) },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform sampler2D tDiffuse;',
-    'varying vec2 vUv;',
+  fragmentShader: /* glsl */ `
+    uniform sampler2D tDiffuse;
+    varying vec2 vUv;
 
-    'uniform vec2 aspect;',
+    uniform vec2 aspect;
 
-    'vec2 texel = vec2(1.0 / aspect.x, 1.0 / aspect.y);',
+    vec2 texel = vec2(1.0 / aspect.x, 1.0 / aspect.y);
 
-    'mat3 G[9];',
+    mat3 G[9];
 
     // hard coded matrix values!!!! as suggested in https://github.com/neilmendoza/ofxPostProcessing/blob/master/src/EdgePass.cpp#L45
 
-    'const mat3 g0 = mat3( 0.3535533845424652, 0, -0.3535533845424652, 0.5, 0, -0.5, 0.3535533845424652, 0, -0.3535533845424652 );',
-    'const mat3 g1 = mat3( 0.3535533845424652, 0.5, 0.3535533845424652, 0, 0, 0, -0.3535533845424652, -0.5, -0.3535533845424652 );',
-    'const mat3 g2 = mat3( 0, 0.3535533845424652, -0.5, -0.3535533845424652, 0, 0.3535533845424652, 0.5, -0.3535533845424652, 0 );',
-    'const mat3 g3 = mat3( 0.5, -0.3535533845424652, 0, -0.3535533845424652, 0, 0.3535533845424652, 0, 0.3535533845424652, -0.5 );',
-    'const mat3 g4 = mat3( 0, -0.5, 0, 0.5, 0, 0.5, 0, -0.5, 0 );',
-    'const mat3 g5 = mat3( -0.5, 0, 0.5, 0, 0, 0, 0.5, 0, -0.5 );',
-    'const mat3 g6 = mat3( 0.1666666716337204, -0.3333333432674408, 0.1666666716337204, -0.3333333432674408, 0.6666666865348816, -0.3333333432674408, 0.1666666716337204, -0.3333333432674408, 0.1666666716337204 );',
-    'const mat3 g7 = mat3( -0.3333333432674408, 0.1666666716337204, -0.3333333432674408, 0.1666666716337204, 0.6666666865348816, 0.1666666716337204, -0.3333333432674408, 0.1666666716337204, -0.3333333432674408 );',
-    'const mat3 g8 = mat3( 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408 );',
-
-    'void main(void)',
-    '{',
-
-    '	G[0] = g0,',
-    '	G[1] = g1,',
-    '	G[2] = g2,',
-    '	G[3] = g3,',
-    '	G[4] = g4,',
-    '	G[5] = g5,',
-    '	G[6] = g6,',
-    '	G[7] = g7,',
-    '	G[8] = g8;',
-
-    '	mat3 I;',
-    '	float cnv[9];',
-    '	vec3 sample;',
-
-    /* fetch the 3x3 neighbourhood and use the RGB vector's length as intensity value */
-    '	for (float i=0.0; i<3.0; i++) {',
-    '		for (float j=0.0; j<3.0; j++) {',
-    '			sample = texture2D(tDiffuse, vUv + texel * vec2(i-1.0,j-1.0) ).rgb;',
-    '			I[int(i)][int(j)] = length(sample);',
-    '		}',
-    '	}',
+    const mat3 g0 = mat3( 0.3535533845424652, 0, -0.3535533845424652, 0.5, 0, -0.5, 0.3535533845424652, 0, -0.3535533845424652 );
+    const mat3 g1 = mat3( 0.3535533845424652, 0.5, 0.3535533845424652, 0, 0, 0, -0.3535533845424652, -0.5, -0.3535533845424652 );
+    const mat3 g2 = mat3( 0, 0.3535533845424652, -0.5, -0.3535533845424652, 0, 0.3535533845424652, 0.5, -0.3535533845424652, 0 );
+    const mat3 g3 = mat3( 0.5, -0.3535533845424652, 0, -0.3535533845424652, 0, 0.3535533845424652, 0, 0.3535533845424652, -0.5 );
+    const mat3 g4 = mat3( 0, -0.5, 0, 0.5, 0, 0.5, 0, -0.5, 0 );
+    const mat3 g5 = mat3( -0.5, 0, 0.5, 0, 0, 0, 0.5, 0, -0.5 );
+    const mat3 g6 = mat3( 0.1666666716337204, -0.3333333432674408, 0.1666666716337204, -0.3333333432674408, 0.6666666865348816, -0.3333333432674408, 0.1666666716337204, -0.3333333432674408, 0.1666666716337204 );
+    const mat3 g7 = mat3( -0.3333333432674408, 0.1666666716337204, -0.3333333432674408, 0.1666666716337204, 0.6666666865348816, 0.1666666716337204, -0.3333333432674408, 0.1666666716337204, -0.3333333432674408 );
+    const mat3 g8 = mat3( 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408 );
+
+    void main(void)
+    {
+
+    	G[0] = g0,
+    	G[1] = g1,
+    	G[2] = g2,
+    	G[3] = g3,
+    	G[4] = g4,
+    	G[5] = g5,
+    	G[6] = g6,
+    	G[7] = g7,
+    	G[8] = g8;
+
+    	mat3 I;
+    	float cnv[9];
+    	vec3 sample;
+
+    /* fetch the 3x3 neighbourhood and use the RGB vectors length as intensity value */
+    	for (float i=0.0; i<3.0; i++) {
+    		for (float j=0.0; j<3.0; j++) {
+    			sample = texture2D(tDiffuse, vUv + texel * vec2(i-1.0,j-1.0) ).rgb;
+    			I[int(i)][int(j)] = length(sample);
+    		}
+    	}
 
     /* calculate the convolution values for all the masks */
-    '	for (int i=0; i<9; i++) {',
-    '		float dp3 = dot(G[i][0], I[0]) + dot(G[i][1], I[1]) + dot(G[i][2], I[2]);',
-    '		cnv[i] = dp3 * dp3;',
-    '	}',
+    	for (int i=0; i<9; i++) {
+    		float dp3 = dot(G[i][0], I[0]) + dot(G[i][1], I[1]) + dot(G[i][2], I[2]);
+    		cnv[i] = dp3 * dp3;
+    	}
 
-    '	float M = (cnv[0] + cnv[1]) + (cnv[2] + cnv[3]);',
-    '	float S = (cnv[4] + cnv[5]) + (cnv[6] + cnv[7]) + (cnv[8] + M);',
+    	float M = (cnv[0] + cnv[1]) + (cnv[2] + cnv[3]);
+    	float S = (cnv[4] + cnv[5]) + (cnv[6] + cnv[7]) + (cnv[8] + M);
 
-    '	gl_FragColor = vec4(vec3(sqrt(M/S)), 1.0);',
-    '}',
-  ].join('\n'),
+    	gl_FragColor = vec4(vec3(sqrt(M/S)), 1.0);
+    }
+  `,
 }
diff --git a/src/shaders/FresnelShader.ts b/src/shaders/FresnelShader.ts
index c016ed90..d11c4424 100644
--- a/src/shaders/FresnelShader.ts
+++ b/src/shaders/FresnelShader.ts
@@ -11,54 +11,54 @@ export const FresnelShader = {
     tCube: { value: null },
   },
 
-  vertexShader: [
-    'uniform float mRefractionRatio;',
-    'uniform float mFresnelBias;',
-    'uniform float mFresnelScale;',
-    'uniform float mFresnelPower;',
+  vertexShader: /* glsl */ `
+    uniform float mRefractionRatio;
+    uniform float mFresnelBias;
+    uniform float mFresnelScale;
+    uniform float mFresnelPower;
 
-    'varying vec3 vReflect;',
-    'varying vec3 vRefract[3];',
-    'varying float vReflectionFactor;',
+    varying vec3 vReflect;
+    varying vec3 vRefract[3];
+    varying float vReflectionFactor;
 
-    'void main() {',
+    void main() {
 
-    '	vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );',
-    '	vec4 worldPosition = modelMatrix * vec4( position, 1.0 );',
+    	vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );
+    	vec4 worldPosition = modelMatrix * vec4( position, 1.0 );
 
-    '	vec3 worldNormal = normalize( mat3( modelMatrix[0].xyz, modelMatrix[1].xyz, modelMatrix[2].xyz ) * normal );',
+    	vec3 worldNormal = normalize( mat3( modelMatrix[0].xyz, modelMatrix[1].xyz, modelMatrix[2].xyz ) * normal );
 
-    '	vec3 I = worldPosition.xyz - cameraPosition;',
+    	vec3 I = worldPosition.xyz - cameraPosition;
 
-    '	vReflect = reflect( I, worldNormal );',
-    '	vRefract[0] = refract( normalize( I ), worldNormal, mRefractionRatio );',
-    '	vRefract[1] = refract( normalize( I ), worldNormal, mRefractionRatio * 0.99 );',
-    '	vRefract[2] = refract( normalize( I ), worldNormal, mRefractionRatio * 0.98 );',
-    '	vReflectionFactor = mFresnelBias + mFresnelScale * pow( 1.0 + dot( normalize( I ), worldNormal ), mFresnelPower );',
+    	vReflect = reflect( I, worldNormal );
+    	vRefract[0] = refract( normalize( I ), worldNormal, mRefractionRatio );
+    	vRefract[1] = refract( normalize( I ), worldNormal, mRefractionRatio * 0.99 );
+    	vRefract[2] = refract( normalize( I ), worldNormal, mRefractionRatio * 0.98 );
+    	vReflectionFactor = mFresnelBias + mFresnelScale * pow( 1.0 + dot( normalize( I ), worldNormal ), mFresnelPower );
 
-    '	gl_Position = projectionMatrix * mvPosition;',
+    	gl_Position = projectionMatrix * mvPosition;
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform samplerCube tCube;',
+  fragmentShader: /* glsl */ `
+    uniform samplerCube tCube;
 
-    'varying vec3 vReflect;',
-    'varying vec3 vRefract[3];',
-    'varying float vReflectionFactor;',
+    varying vec3 vReflect;
+    varying vec3 vRefract[3];
+    varying float vReflectionFactor;
 
-    'void main() {',
+    void main() {
 
-    '	vec4 reflectedColor = textureCube( tCube, vec3( -vReflect.x, vReflect.yz ) );',
-    '	vec4 refractedColor = vec4( 1.0 );',
+    	vec4 reflectedColor = textureCube( tCube, vec3( -vReflect.x, vReflect.yz ) );
+    	vec4 refractedColor = vec4( 1.0 );
 
-    '	refractedColor.r = textureCube( tCube, vec3( -vRefract[0].x, vRefract[0].yz ) ).r;',
-    '	refractedColor.g = textureCube( tCube, vec3( -vRefract[1].x, vRefract[1].yz ) ).g;',
-    '	refractedColor.b = textureCube( tCube, vec3( -vRefract[2].x, vRefract[2].yz ) ).b;',
+    	refractedColor.r = textureCube( tCube, vec3( -vRefract[0].x, vRefract[0].yz ) ).r;
+    	refractedColor.g = textureCube( tCube, vec3( -vRefract[1].x, vRefract[1].yz ) ).g;
+    	refractedColor.b = textureCube( tCube, vec3( -vRefract[2].x, vRefract[2].yz ) ).b;
 
-    '	gl_FragColor = mix( refractedColor, reflectedColor, clamp( vReflectionFactor, 0.0, 1.0 ) );',
+    	gl_FragColor = mix( refractedColor, reflectedColor, clamp( vReflectionFactor, 0.0, 1.0 ) );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/GammaCorrectionShader.ts b/src/shaders/GammaCorrectionShader.ts
index 00f0425d..0b5173c0 100644
--- a/src/shaders/GammaCorrectionShader.ts
+++ b/src/shaders/GammaCorrectionShader.ts
@@ -17,32 +17,32 @@ export const GammaCorrectionShader: IGammaCorrectionShader = {
     tDiffuse: { value: null },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform sampler2D tDiffuse;',
+  fragmentShader: /* glsl */ `
+    uniform sampler2D tDiffuse;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vec4 tex = texture2D( tDiffuse, vUv );',
+    	vec4 tex = texture2D( tDiffuse, vUv );
 
-    '	#ifdef LinearTosRGB',
-    '		gl_FragColor = LinearTosRGB( tex );',
-    '	#else',
-    '		gl_FragColor = sRGBTransferOETF( tex );',
-    '	#endif',
+    	#ifdef LinearTosRGB
+    		gl_FragColor = LinearTosRGB( tex );
+    	#else
+    		gl_FragColor = sRGBTransferOETF( tex );
+    	#endif
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/GodRaysShader.ts b/src/shaders/GodRaysShader.ts
index 6cfa2629..c3c0f1fa 100644
--- a/src/shaders/GodRaysShader.ts
+++ b/src/shaders/GodRaysShader.ts
@@ -25,28 +25,28 @@ export const GodRaysDepthMaskShader = {
     },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    ' vUv = uv;',
-    ' gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+     vUv = uv;
+     gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'varying vec2 vUv;',
+  fragmentShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'uniform sampler2D tInput;',
+    uniform sampler2D tInput;
 
-    'void main() {',
+    void main() {
 
-    '	gl_FragColor = vec4( 1.0 ) - texture2D( tInput, vUv );',
+    	gl_FragColor = vec4( 1.0 ) - texture2D( tInput, vUv );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
 
 /**
@@ -73,62 +73,62 @@ export const GodRaysGenerateShader = {
       value: 1.0,
     },
     vSunPositionScreenSpace: {
-      value: new Vector3(),
+      value: /* @__PURE__ */ new Vector3(),
     },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    ' vUv = uv;',
-    ' gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+     vUv = uv;
+     gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    '#define TAPS_PER_PASS 6.0',
+  fragmentShader: /* glsl */ `
+    #define TAPS_PER_PASS 6.0
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'uniform sampler2D tInput;',
+    uniform sampler2D tInput;
 
-    'uniform vec3 vSunPositionScreenSpace;',
-    'uniform float fStepSize;', // filter step size
+    uniform vec3 vSunPositionScreenSpace;
+    uniform float fStepSize; // filter step size
 
-    'void main() {',
+    void main() {
 
     // delta from current pixel to "sun" position
 
-    '	vec2 delta = vSunPositionScreenSpace.xy - vUv;',
-    '	float dist = length( delta );',
+    	vec2 delta = vSunPositionScreenSpace.xy - vUv;
+    	float dist = length( delta );
 
     // Step vector (uv space)
 
-    '	vec2 stepv = fStepSize * delta / dist;',
+    	vec2 stepv = fStepSize * delta / dist;
 
     // Number of iterations between pixel and sun
 
-    '	float iters = dist/fStepSize;',
+    	float iters = dist/fStepSize;
 
-    '	vec2 uv = vUv.xy;',
-    '	float col = 0.0;',
+    	vec2 uv = vUv.xy;
+    	float col = 0.0;
 
     // This breaks ANGLE in Chrome 22
     //	- see http://code.google.com/p/chromium/issues/detail?id=153105
 
     /*
 		// Unrolling didnt do much on my hardware (ATI Mobility Radeon 3450),
-		// so i've just left the loop
+		// so ive just left the loop
 
 		"for ( float i = 0.0; i < TAPS_PER_PASS; i += 1.0 ) {",
 
 		// Accumulate samples, making sure we dont walk past the light source.
 
 		// The check for uv.y < 1 would not be necessary with "border" UV wrap
-		// mode, with a black border color. I don't think this is currently
+		// mode, with a black border color. I dont think this is currently
 		// exposed by three.js. As a result there might be artifacts when the
 		// sun is to the left, right or bottom of screen as these cases are
 		// not specifically handled.
@@ -141,38 +141,38 @@ export const GodRaysGenerateShader = {
 
     // Unrolling loop manually makes it work in ANGLE
 
-    '	float f = min( 1.0, max( vSunPositionScreenSpace.z / 1000.0, 0.0 ) );', // used to fade out godrays
+    	float f = min( 1.0, max( vSunPositionScreenSpace.z / 1000.0, 0.0 ) ); // used to fade out godrays
 
-    '	if ( 0.0 <= iters && uv.y < 1.0 ) col += texture2D( tInput, uv ).r * f;',
-    '	uv += stepv;',
+    	if ( 0.0 <= iters && uv.y < 1.0 ) col += texture2D( tInput, uv ).r * f;
+    	uv += stepv;
 
-    '	if ( 1.0 <= iters && uv.y < 1.0 ) col += texture2D( tInput, uv ).r * f;',
-    '	uv += stepv;',
+    	if ( 1.0 <= iters && uv.y < 1.0 ) col += texture2D( tInput, uv ).r * f;
+    	uv += stepv;
 
-    '	if ( 2.0 <= iters && uv.y < 1.0 ) col += texture2D( tInput, uv ).r * f;',
-    '	uv += stepv;',
+    	if ( 2.0 <= iters && uv.y < 1.0 ) col += texture2D( tInput, uv ).r * f;
+    	uv += stepv;
 
-    '	if ( 3.0 <= iters && uv.y < 1.0 ) col += texture2D( tInput, uv ).r * f;',
-    '	uv += stepv;',
+    	if ( 3.0 <= iters && uv.y < 1.0 ) col += texture2D( tInput, uv ).r * f;
+    	uv += stepv;
 
-    '	if ( 4.0 <= iters && uv.y < 1.0 ) col += texture2D( tInput, uv ).r * f;',
-    '	uv += stepv;',
+    	if ( 4.0 <= iters && uv.y < 1.0 ) col += texture2D( tInput, uv ).r * f;
+    	uv += stepv;
 
-    '	if ( 5.0 <= iters && uv.y < 1.0 ) col += texture2D( tInput, uv ).r * f;',
-    '	uv += stepv;',
+    	if ( 5.0 <= iters && uv.y < 1.0 ) col += texture2D( tInput, uv ).r * f;
+    	uv += stepv;
 
-    // Should technically be dividing by 'iters', but 'TAPS_PER_PASS' smooths out
+    // Should technically be dividing by iters but TAPS_PER_PASS smooths out
     // objectionable artifacts, in particular near the sun position. The side
     // effect is that the result is darker than it should be around the sun, as
     // TAPS_PER_PASS is greater than the number of samples actually accumulated.
-    // When the result is inverted (in the shader 'godrays_combine', this produces
+    // When the result is inverted (in the shader godrays_combine this produces
     // a slight bright spot at the position of the sun, even when it is occluded.
 
-    '	gl_FragColor = vec4( col/TAPS_PER_PASS );',
-    '	gl_FragColor.a = 1.0;',
+    	gl_FragColor = vec4( col/TAPS_PER_PASS );
+    	gl_FragColor.a = 1.0;
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
 
 /**
@@ -195,36 +195,36 @@ export const GodRaysCombineShader = {
     },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'varying vec2 vUv;',
+  fragmentShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'uniform sampler2D tColors;',
-    'uniform sampler2D tGodRays;',
+    uniform sampler2D tColors;
+    uniform sampler2D tGodRays;
 
-    'uniform float fGodRayIntensity;',
+    uniform float fGodRayIntensity;
 
-    'void main() {',
+    void main() {
 
     // Since THREE.MeshDepthMaterial renders foreground objects white and background
     // objects black, the god-rays will be white streaks. Therefore value is inverted
     // before being combined with tColors
 
-    '	gl_FragColor = texture2D( tColors, vUv ) + fGodRayIntensity * vec4( 1.0 - texture2D( tGodRays, vUv ).r );',
-    '	gl_FragColor.a = 1.0;',
+    	gl_FragColor = texture2D( tColors, vUv ) + fGodRayIntensity * vec4( 1.0 - texture2D( tGodRays, vUv ).r );
+    	gl_FragColor.a = 1.0;
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
 
 /**
@@ -235,7 +235,7 @@ export const GodRaysCombineShader = {
 export const GodRaysFakeSunShader = {
   uniforms: {
     vSunPositionScreenSpace: {
-      value: new Vector3(),
+      value: /* @__PURE__ */ new Vector3(),
     },
 
     fAspect: {
@@ -243,48 +243,48 @@ export const GodRaysFakeSunShader = {
     },
 
     sunColor: {
-      value: new Color(0xffee00),
+      value: /* @__PURE__ */ new Color(0xffee00),
     },
 
     bgColor: {
-      value: new Color(0x000000),
+      value: /* @__PURE__ */ new Color(0x000000),
     },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'varying vec2 vUv;',
+  fragmentShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'uniform vec3 vSunPositionScreenSpace;',
-    'uniform float fAspect;',
+    uniform vec3 vSunPositionScreenSpace;
+    uniform float fAspect;
 
-    'uniform vec3 sunColor;',
-    'uniform vec3 bgColor;',
+    uniform vec3 sunColor;
+    uniform vec3 bgColor;
 
-    'void main() {',
+    void main() {
 
-    '	vec2 diff = vUv - vSunPositionScreenSpace.xy;',
+    	vec2 diff = vUv - vSunPositionScreenSpace.xy;
 
     // Correct for aspect ratio
 
-    '	diff.x *= fAspect;',
+    	diff.x *= fAspect;
 
-    '	float prop = clamp( length( diff ) / 0.5, 0.0, 1.0 );',
-    '	prop = 0.35 * pow( 1.0 - prop, 3.0 );',
+    	float prop = clamp( length( diff ) / 0.5, 0.0, 1.0 );
+    	prop = 0.35 * pow( 1.0 - prop, 3.0 );
 
-    '	gl_FragColor.xyz = ( vSunPositionScreenSpace.z > 0.0 ) ? mix( sunColor, bgColor, 1.0 - prop ) : bgColor;',
-    '	gl_FragColor.w = 1.0;',
+    	gl_FragColor.xyz = ( vSunPositionScreenSpace.z > 0.0 ) ? mix( sunColor, bgColor, 1.0 - prop ) : bgColor;
+    	gl_FragColor.w = 1.0;
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/HalftoneShader.ts b/src/shaders/HalftoneShader.ts
index 47eed4a8..2bbf5104 100644
--- a/src/shaders/HalftoneShader.ts
+++ b/src/shaders/HalftoneShader.ts
@@ -22,285 +22,285 @@ export const HalftoneShader = {
     disable: { value: false },
   },
 
-  vertexShader: [
-    'varying vec2 vUV;',
-
-    'void main() {',
-
-    '	vUV = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);',
-
-    '}',
-  ].join('\n'),
-
-  fragmentShader: [
-    '#define SQRT2_MINUS_ONE 0.41421356',
-    '#define SQRT2_HALF_MINUS_ONE 0.20710678',
-    '#define PI2 6.28318531',
-    '#define SHAPE_DOT 1',
-    '#define SHAPE_ELLIPSE 2',
-    '#define SHAPE_LINE 3',
-    '#define SHAPE_SQUARE 4',
-    '#define BLENDING_LINEAR 1',
-    '#define BLENDING_MULTIPLY 2',
-    '#define BLENDING_ADD 3',
-    '#define BLENDING_LIGHTER 4',
-    '#define BLENDING_DARKER 5',
-    'uniform sampler2D tDiffuse;',
-    'uniform float radius;',
-    'uniform float rotateR;',
-    'uniform float rotateG;',
-    'uniform float rotateB;',
-    'uniform float scatter;',
-    'uniform float width;',
-    'uniform float height;',
-    'uniform int shape;',
-    'uniform bool disable;',
-    'uniform float blending;',
-    'uniform int blendingMode;',
-    'varying vec2 vUV;',
-    'uniform bool greyscale;',
-    'const int samples = 8;',
-
-    'float blend( float a, float b, float t ) {',
+  vertexShader: /* glsl */ `
+    varying vec2 vUV;
+
+    void main() {
+
+    	vUV = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+
+    }
+  `,
+
+  fragmentShader: /* glsl */ `
+    #define SQRT2_MINUS_ONE 0.41421356
+    #define SQRT2_HALF_MINUS_ONE 0.20710678
+    #define PI2 6.28318531
+    #define SHAPE_DOT 1
+    #define SHAPE_ELLIPSE 2
+    #define SHAPE_LINE 3
+    #define SHAPE_SQUARE 4
+    #define BLENDING_LINEAR 1
+    #define BLENDING_MULTIPLY 2
+    #define BLENDING_ADD 3
+    #define BLENDING_LIGHTER 4
+    #define BLENDING_DARKER 5
+    uniform sampler2D tDiffuse;
+    uniform float radius;
+    uniform float rotateR;
+    uniform float rotateG;
+    uniform float rotateB;
+    uniform float scatter;
+    uniform float width;
+    uniform float height;
+    uniform int shape;
+    uniform bool disable;
+    uniform float blending;
+    uniform int blendingMode;
+    varying vec2 vUV;
+    uniform bool greyscale;
+    const int samples = 8;
+
+    float blend( float a, float b, float t ) {
 
     // linear blend
-    '	return a * ( 1.0 - t ) + b * t;',
+    	return a * ( 1.0 - t ) + b * t;
 
-    '}',
+    }
 
-    'float hypot( float x, float y ) {',
+    float hypot( float x, float y ) {
 
     // vector magnitude
-    '	return sqrt( x * x + y * y );',
+    	return sqrt( x * x + y * y );
 
-    '}',
+    }
 
-    'float rand( vec2 seed ){',
+    float rand( vec2 seed ){
 
     // get pseudo-random number
-    'return fract( sin( dot( seed.xy, vec2( 12.9898, 78.233 ) ) ) * 43758.5453 );',
+    return fract( sin( dot( seed.xy, vec2( 12.9898, 78.233 ) ) ) * 43758.5453 );
 
-    '}',
+    }
 
-    'float distanceToDotRadius( float channel, vec2 coord, vec2 normal, vec2 p, float angle, float rad_max ) {',
+    float distanceToDotRadius( float channel, vec2 coord, vec2 normal, vec2 p, float angle, float rad_max ) {
 
     // apply shape-specific transforms
-    '	float dist = hypot( coord.x - p.x, coord.y - p.y );',
-    '	float rad = channel;',
+    	float dist = hypot( coord.x - p.x, coord.y - p.y );
+    	float rad = channel;
 
-    '	if ( shape == SHAPE_DOT ) {',
+    	if ( shape == SHAPE_DOT ) {
 
-    '		rad = pow( abs( rad ), 1.125 ) * rad_max;',
+    		rad = pow( abs( rad ), 1.125 ) * rad_max;
 
-    '	} else if ( shape == SHAPE_ELLIPSE ) {',
+    	} else if ( shape == SHAPE_ELLIPSE ) {
 
-    '		rad = pow( abs( rad ), 1.125 ) * rad_max;',
+    		rad = pow( abs( rad ), 1.125 ) * rad_max;
 
-    '		if ( dist != 0.0 ) {',
-    '			float dot_p = abs( ( p.x - coord.x ) / dist * normal.x + ( p.y - coord.y ) / dist * normal.y );',
-    '			dist = ( dist * ( 1.0 - SQRT2_HALF_MINUS_ONE ) ) + dot_p * dist * SQRT2_MINUS_ONE;',
-    '		}',
+    		if ( dist != 0.0 ) {
+    			float dot_p = abs( ( p.x - coord.x ) / dist * normal.x + ( p.y - coord.y ) / dist * normal.y );
+    			dist = ( dist * ( 1.0 - SQRT2_HALF_MINUS_ONE ) ) + dot_p * dist * SQRT2_MINUS_ONE;
+    		}
 
-    '	} else if ( shape == SHAPE_LINE ) {',
+    	} else if ( shape == SHAPE_LINE ) {
 
-    '		rad = pow( abs( rad ), 1.5) * rad_max;',
-    '		float dot_p = ( p.x - coord.x ) * normal.x + ( p.y - coord.y ) * normal.y;',
-    '		dist = hypot( normal.x * dot_p, normal.y * dot_p );',
+    		rad = pow( abs( rad ), 1.5) * rad_max;
+    		float dot_p = ( p.x - coord.x ) * normal.x + ( p.y - coord.y ) * normal.y;
+    		dist = hypot( normal.x * dot_p, normal.y * dot_p );
 
-    '	} else if ( shape == SHAPE_SQUARE ) {',
+    	} else if ( shape == SHAPE_SQUARE ) {
 
-    '		float theta = atan( p.y - coord.y, p.x - coord.x ) - angle;',
-    '		float sin_t = abs( sin( theta ) );',
-    '		float cos_t = abs( cos( theta ) );',
-    '		rad = pow( abs( rad ), 1.4 );',
-    '		rad = rad_max * ( rad + ( ( sin_t > cos_t ) ? rad - sin_t * rad : rad - cos_t * rad ) );',
+    		float theta = atan( p.y - coord.y, p.x - coord.x ) - angle;
+    		float sin_t = abs( sin( theta ) );
+    		float cos_t = abs( cos( theta ) );
+    		rad = pow( abs( rad ), 1.4 );
+    		rad = rad_max * ( rad + ( ( sin_t > cos_t ) ? rad - sin_t * rad : rad - cos_t * rad ) );
 
-    '	}',
+    	}
 
-    '	return rad - dist;',
+    	return rad - dist;
 
-    '}',
+    }
 
-    'struct Cell {',
+    struct Cell {
 
     // grid sample positions
-    '	vec2 normal;',
-    '	vec2 p1;',
-    '	vec2 p2;',
-    '	vec2 p3;',
-    '	vec2 p4;',
-    '	float samp2;',
-    '	float samp1;',
-    '	float samp3;',
-    '	float samp4;',
+    	vec2 normal;
+    	vec2 p1;
+    	vec2 p2;
+    	vec2 p3;
+    	vec2 p4;
+    	float samp2;
+    	float samp1;
+    	float samp3;
+    	float samp4;
 
-    '};',
+    };
 
-    'vec4 getSample( vec2 point ) {',
+    vec4 getSample( vec2 point ) {
 
     // multi-sampled point
-    '	vec4 tex = texture2D( tDiffuse, vec2( point.x / width, point.y / height ) );',
-    '	float base = rand( vec2( floor( point.x ), floor( point.y ) ) ) * PI2;',
-    '	float step = PI2 / float( samples );',
-    '	float dist = radius * 0.66;',
+    	vec4 tex = texture2D( tDiffuse, vec2( point.x / width, point.y / height ) );
+    	float base = rand( vec2( floor( point.x ), floor( point.y ) ) ) * PI2;
+    	float step = PI2 / float( samples );
+    	float dist = radius * 0.66;
 
-    '	for ( int i = 0; i < samples; ++i ) {',
+    	for ( int i = 0; i < samples; ++i ) {
 
-    '		float r = base + step * float( i );',
-    '		vec2 coord = point + vec2( cos( r ) * dist, sin( r ) * dist );',
-    '		tex += texture2D( tDiffuse, vec2( coord.x / width, coord.y / height ) );',
+    		float r = base + step * float( i );
+    		vec2 coord = point + vec2( cos( r ) * dist, sin( r ) * dist );
+    		tex += texture2D( tDiffuse, vec2( coord.x / width, coord.y / height ) );
 
-    '	}',
+    	}
 
-    '	tex /= float( samples ) + 1.0;',
-    '	return tex;',
+    	tex /= float( samples ) + 1.0;
+    	return tex;
 
-    '}',
+    }
 
-    'float getDotColour( Cell c, vec2 p, int channel, float angle, float aa ) {',
+    float getDotColour( Cell c, vec2 p, int channel, float angle, float aa ) {
 
     // get colour for given point
-    '	float dist_c_1, dist_c_2, dist_c_3, dist_c_4, res;',
+    	float dist_c_1, dist_c_2, dist_c_3, dist_c_4, res;
 
-    '	if ( channel == 0 ) {',
+    	if ( channel == 0 ) {
 
-    '		c.samp1 = getSample( c.p1 ).r;',
-    '		c.samp2 = getSample( c.p2 ).r;',
-    '		c.samp3 = getSample( c.p3 ).r;',
-    '		c.samp4 = getSample( c.p4 ).r;',
+    		c.samp1 = getSample( c.p1 ).r;
+    		c.samp2 = getSample( c.p2 ).r;
+    		c.samp3 = getSample( c.p3 ).r;
+    		c.samp4 = getSample( c.p4 ).r;
 
-    '	} else if (channel == 1) {',
+    	} else if (channel == 1) {
 
-    '		c.samp1 = getSample( c.p1 ).g;',
-    '		c.samp2 = getSample( c.p2 ).g;',
-    '		c.samp3 = getSample( c.p3 ).g;',
-    '		c.samp4 = getSample( c.p4 ).g;',
+    		c.samp1 = getSample( c.p1 ).g;
+    		c.samp2 = getSample( c.p2 ).g;
+    		c.samp3 = getSample( c.p3 ).g;
+    		c.samp4 = getSample( c.p4 ).g;
 
-    '	} else {',
+    	} else {
 
-    '		c.samp1 = getSample( c.p1 ).b;',
-    '		c.samp3 = getSample( c.p3 ).b;',
-    '		c.samp2 = getSample( c.p2 ).b;',
-    '		c.samp4 = getSample( c.p4 ).b;',
+    		c.samp1 = getSample( c.p1 ).b;
+    		c.samp3 = getSample( c.p3 ).b;
+    		c.samp2 = getSample( c.p2 ).b;
+    		c.samp4 = getSample( c.p4 ).b;
 
-    '	}',
+    	}
 
-    '	dist_c_1 = distanceToDotRadius( c.samp1, c.p1, c.normal, p, angle, radius );',
-    '	dist_c_2 = distanceToDotRadius( c.samp2, c.p2, c.normal, p, angle, radius );',
-    '	dist_c_3 = distanceToDotRadius( c.samp3, c.p3, c.normal, p, angle, radius );',
-    '	dist_c_4 = distanceToDotRadius( c.samp4, c.p4, c.normal, p, angle, radius );',
-    '	res = ( dist_c_1 > 0.0 ) ? clamp( dist_c_1 / aa, 0.0, 1.0 ) : 0.0;',
-    '	res += ( dist_c_2 > 0.0 ) ? clamp( dist_c_2 / aa, 0.0, 1.0 ) : 0.0;',
-    '	res += ( dist_c_3 > 0.0 ) ? clamp( dist_c_3 / aa, 0.0, 1.0 ) : 0.0;',
-    '	res += ( dist_c_4 > 0.0 ) ? clamp( dist_c_4 / aa, 0.0, 1.0 ) : 0.0;',
-    '	res = clamp( res, 0.0, 1.0 );',
+    	dist_c_1 = distanceToDotRadius( c.samp1, c.p1, c.normal, p, angle, radius );
+    	dist_c_2 = distanceToDotRadius( c.samp2, c.p2, c.normal, p, angle, radius );
+    	dist_c_3 = distanceToDotRadius( c.samp3, c.p3, c.normal, p, angle, radius );
+    	dist_c_4 = distanceToDotRadius( c.samp4, c.p4, c.normal, p, angle, radius );
+    	res = ( dist_c_1 > 0.0 ) ? clamp( dist_c_1 / aa, 0.0, 1.0 ) : 0.0;
+    	res += ( dist_c_2 > 0.0 ) ? clamp( dist_c_2 / aa, 0.0, 1.0 ) : 0.0;
+    	res += ( dist_c_3 > 0.0 ) ? clamp( dist_c_3 / aa, 0.0, 1.0 ) : 0.0;
+    	res += ( dist_c_4 > 0.0 ) ? clamp( dist_c_4 / aa, 0.0, 1.0 ) : 0.0;
+    	res = clamp( res, 0.0, 1.0 );
 
-    '	return res;',
+    	return res;
 
-    '}',
+    }
 
-    'Cell getReferenceCell( vec2 p, vec2 origin, float grid_angle, float step ) {',
+    Cell getReferenceCell( vec2 p, vec2 origin, float grid_angle, float step ) {
 
     // get containing cell
-    '	Cell c;',
+    	Cell c;
 
     // calc grid
-    '	vec2 n = vec2( cos( grid_angle ), sin( grid_angle ) );',
-    '	float threshold = step * 0.5;',
-    '	float dot_normal = n.x * ( p.x - origin.x ) + n.y * ( p.y - origin.y );',
-    '	float dot_line = -n.y * ( p.x - origin.x ) + n.x * ( p.y - origin.y );',
-    '	vec2 offset = vec2( n.x * dot_normal, n.y * dot_normal );',
-    '	float offset_normal = mod( hypot( offset.x, offset.y ), step );',
-    '	float normal_dir = ( dot_normal < 0.0 ) ? 1.0 : -1.0;',
-    '	float normal_scale = ( ( offset_normal < threshold ) ? -offset_normal : step - offset_normal ) * normal_dir;',
-    '	float offset_line = mod( hypot( ( p.x - offset.x ) - origin.x, ( p.y - offset.y ) - origin.y ), step );',
-    '	float line_dir = ( dot_line < 0.0 ) ? 1.0 : -1.0;',
-    '	float line_scale = ( ( offset_line < threshold ) ? -offset_line : step - offset_line ) * line_dir;',
+    	vec2 n = vec2( cos( grid_angle ), sin( grid_angle ) );
+    	float threshold = step * 0.5;
+    	float dot_normal = n.x * ( p.x - origin.x ) + n.y * ( p.y - origin.y );
+    	float dot_line = -n.y * ( p.x - origin.x ) + n.x * ( p.y - origin.y );
+    	vec2 offset = vec2( n.x * dot_normal, n.y * dot_normal );
+    	float offset_normal = mod( hypot( offset.x, offset.y ), step );
+    	float normal_dir = ( dot_normal < 0.0 ) ? 1.0 : -1.0;
+    	float normal_scale = ( ( offset_normal < threshold ) ? -offset_normal : step - offset_normal ) * normal_dir;
+    	float offset_line = mod( hypot( ( p.x - offset.x ) - origin.x, ( p.y - offset.y ) - origin.y ), step );
+    	float line_dir = ( dot_line < 0.0 ) ? 1.0 : -1.0;
+    	float line_scale = ( ( offset_line < threshold ) ? -offset_line : step - offset_line ) * line_dir;
 
     // get closest corner
-    '	c.normal = n;',
-    '	c.p1.x = p.x - n.x * normal_scale + n.y * line_scale;',
-    '	c.p1.y = p.y - n.y * normal_scale - n.x * line_scale;',
+    	c.normal = n;
+    	c.p1.x = p.x - n.x * normal_scale + n.y * line_scale;
+    	c.p1.y = p.y - n.y * normal_scale - n.x * line_scale;
 
     // scatter
-    '	if ( scatter != 0.0 ) {',
+    	if ( scatter != 0.0 ) {
 
-    '		float off_mag = scatter * threshold * 0.5;',
-    '		float off_angle = rand( vec2( floor( c.p1.x ), floor( c.p1.y ) ) ) * PI2;',
-    '		c.p1.x += cos( off_angle ) * off_mag;',
-    '		c.p1.y += sin( off_angle ) * off_mag;',
+    		float off_mag = scatter * threshold * 0.5;
+    		float off_angle = rand( vec2( floor( c.p1.x ), floor( c.p1.y ) ) ) * PI2;
+    		c.p1.x += cos( off_angle ) * off_mag;
+    		c.p1.y += sin( off_angle ) * off_mag;
 
-    '	}',
+    	}
 
     // find corners
-    '	float normal_step = normal_dir * ( ( offset_normal < threshold ) ? step : -step );',
-    '	float line_step = line_dir * ( ( offset_line < threshold ) ? step : -step );',
-    '	c.p2.x = c.p1.x - n.x * normal_step;',
-    '	c.p2.y = c.p1.y - n.y * normal_step;',
-    '	c.p3.x = c.p1.x + n.y * line_step;',
-    '	c.p3.y = c.p1.y - n.x * line_step;',
-    '	c.p4.x = c.p1.x - n.x * normal_step + n.y * line_step;',
-    '	c.p4.y = c.p1.y - n.y * normal_step - n.x * line_step;',
+    	float normal_step = normal_dir * ( ( offset_normal < threshold ) ? step : -step );
+    	float line_step = line_dir * ( ( offset_line < threshold ) ? step : -step );
+    	c.p2.x = c.p1.x - n.x * normal_step;
+    	c.p2.y = c.p1.y - n.y * normal_step;
+    	c.p3.x = c.p1.x + n.y * line_step;
+    	c.p3.y = c.p1.y - n.x * line_step;
+    	c.p4.x = c.p1.x - n.x * normal_step + n.y * line_step;
+    	c.p4.y = c.p1.y - n.y * normal_step - n.x * line_step;
 
-    '	return c;',
+    	return c;
 
-    '}',
+    }
 
-    'float blendColour( float a, float b, float t ) {',
+    float blendColour( float a, float b, float t ) {
 
     // blend colours
-    '	if ( blendingMode == BLENDING_LINEAR ) {',
-    '		return blend( a, b, 1.0 - t );',
-    '	} else if ( blendingMode == BLENDING_ADD ) {',
-    '		return blend( a, min( 1.0, a + b ), t );',
-    '	} else if ( blendingMode == BLENDING_MULTIPLY ) {',
-    '		return blend( a, max( 0.0, a * b ), t );',
-    '	} else if ( blendingMode == BLENDING_LIGHTER ) {',
-    '		return blend( a, max( a, b ), t );',
-    '	} else if ( blendingMode == BLENDING_DARKER ) {',
-    '		return blend( a, min( a, b ), t );',
-    '	} else {',
-    '		return blend( a, b, 1.0 - t );',
-    '	}',
-
-    '}',
-
-    'void main() {',
-
-    '	if ( ! disable ) {',
+    	if ( blendingMode == BLENDING_LINEAR ) {
+    		return blend( a, b, 1.0 - t );
+    	} else if ( blendingMode == BLENDING_ADD ) {
+    		return blend( a, min( 1.0, a + b ), t );
+    	} else if ( blendingMode == BLENDING_MULTIPLY ) {
+    		return blend( a, max( 0.0, a * b ), t );
+    	} else if ( blendingMode == BLENDING_LIGHTER ) {
+    		return blend( a, max( a, b ), t );
+    	} else if ( blendingMode == BLENDING_DARKER ) {
+    		return blend( a, min( a, b ), t );
+    	} else {
+    		return blend( a, b, 1.0 - t );
+    	}
+
+    }
+
+    void main() {
+
+    	if ( ! disable ) {
 
     // setup
-    '		vec2 p = vec2( vUV.x * width, vUV.y * height );',
-    '		vec2 origin = vec2( 0, 0 );',
-    '		float aa = ( radius < 2.5 ) ? radius * 0.5 : 1.25;',
+    		vec2 p = vec2( vUV.x * width, vUV.y * height );
+    		vec2 origin = vec2( 0, 0 );
+    		float aa = ( radius < 2.5 ) ? radius * 0.5 : 1.25;
 
     // get channel samples
-    '		Cell cell_r = getReferenceCell( p, origin, rotateR, radius );',
-    '		Cell cell_g = getReferenceCell( p, origin, rotateG, radius );',
-    '		Cell cell_b = getReferenceCell( p, origin, rotateB, radius );',
-    '		float r = getDotColour( cell_r, p, 0, rotateR, aa );',
-    '		float g = getDotColour( cell_g, p, 1, rotateG, aa );',
-    '		float b = getDotColour( cell_b, p, 2, rotateB, aa );',
+    		Cell cell_r = getReferenceCell( p, origin, rotateR, radius );
+    		Cell cell_g = getReferenceCell( p, origin, rotateG, radius );
+    		Cell cell_b = getReferenceCell( p, origin, rotateB, radius );
+    		float r = getDotColour( cell_r, p, 0, rotateR, aa );
+    		float g = getDotColour( cell_g, p, 1, rotateG, aa );
+    		float b = getDotColour( cell_b, p, 2, rotateB, aa );
 
     // blend with original
-    '		vec4 colour = texture2D( tDiffuse, vUV );',
-    '		r = blendColour( r, colour.r, blending );',
-    '		g = blendColour( g, colour.g, blending );',
-    '		b = blendColour( b, colour.b, blending );',
+    		vec4 colour = texture2D( tDiffuse, vUV );
+    		r = blendColour( r, colour.r, blending );
+    		g = blendColour( g, colour.g, blending );
+    		b = blendColour( b, colour.b, blending );
 
-    '		if ( greyscale ) {',
-    '			r = g = b = (r + b + g) / 3.0;',
-    '		}',
+    		if ( greyscale ) {
+    			r = g = b = (r + b + g) / 3.0;
+    		}
 
-    '		gl_FragColor = vec4( r, g, b, 1.0 );',
+    		gl_FragColor = vec4( r, g, b, 1.0 );
 
-    '	} else {',
+    	} else {
 
-    '		gl_FragColor = texture2D( tDiffuse, vUV );',
+    		gl_FragColor = texture2D( tDiffuse, vUV );
 
-    '	}',
+    	}
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/HorizontalTiltShiftShader.ts b/src/shaders/HorizontalTiltShiftShader.ts
index 62fe7f14..ab395017 100644
--- a/src/shaders/HorizontalTiltShiftShader.ts
+++ b/src/shaders/HorizontalTiltShiftShader.ts
@@ -14,42 +14,42 @@ export const HorizontalTiltShiftShader = {
     r: { value: 0.35 },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform sampler2D tDiffuse;',
-    'uniform float h;',
-    'uniform float r;',
+  fragmentShader: /* glsl */ `
+    uniform sampler2D tDiffuse;
+    uniform float h;
+    uniform float r;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vec4 sum = vec4( 0.0 );',
+    	vec4 sum = vec4( 0.0 );
 
-    '	float hh = h * abs( r - vUv.y );',
+    	float hh = h * abs( r - vUv.y );
 
-    '	sum += texture2D( tDiffuse, vec2( vUv.x - 4.0 * hh, vUv.y ) ) * 0.051;',
-    '	sum += texture2D( tDiffuse, vec2( vUv.x - 3.0 * hh, vUv.y ) ) * 0.0918;',
-    '	sum += texture2D( tDiffuse, vec2( vUv.x - 2.0 * hh, vUv.y ) ) * 0.12245;',
-    '	sum += texture2D( tDiffuse, vec2( vUv.x - 1.0 * hh, vUv.y ) ) * 0.1531;',
-    '	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y ) ) * 0.1633;',
-    '	sum += texture2D( tDiffuse, vec2( vUv.x + 1.0 * hh, vUv.y ) ) * 0.1531;',
-    '	sum += texture2D( tDiffuse, vec2( vUv.x + 2.0 * hh, vUv.y ) ) * 0.12245;',
-    '	sum += texture2D( tDiffuse, vec2( vUv.x + 3.0 * hh, vUv.y ) ) * 0.0918;',
-    '	sum += texture2D( tDiffuse, vec2( vUv.x + 4.0 * hh, vUv.y ) ) * 0.051;',
+    	sum += texture2D( tDiffuse, vec2( vUv.x - 4.0 * hh, vUv.y ) ) * 0.051;
+    	sum += texture2D( tDiffuse, vec2( vUv.x - 3.0 * hh, vUv.y ) ) * 0.0918;
+    	sum += texture2D( tDiffuse, vec2( vUv.x - 2.0 * hh, vUv.y ) ) * 0.12245;
+    	sum += texture2D( tDiffuse, vec2( vUv.x - 1.0 * hh, vUv.y ) ) * 0.1531;
+    	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y ) ) * 0.1633;
+    	sum += texture2D( tDiffuse, vec2( vUv.x + 1.0 * hh, vUv.y ) ) * 0.1531;
+    	sum += texture2D( tDiffuse, vec2( vUv.x + 2.0 * hh, vUv.y ) ) * 0.12245;
+    	sum += texture2D( tDiffuse, vec2( vUv.x + 3.0 * hh, vUv.y ) ) * 0.0918;
+    	sum += texture2D( tDiffuse, vec2( vUv.x + 4.0 * hh, vUv.y ) ) * 0.051;
 
-    '	gl_FragColor = sum;',
+    	gl_FragColor = sum;
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/HueSaturationShader.ts b/src/shaders/HueSaturationShader.ts
index 0fe823b9..6dbf9464 100644
--- a/src/shaders/HueSaturationShader.ts
+++ b/src/shaders/HueSaturationShader.ts
@@ -12,48 +12,48 @@ export const HueSaturationShader = {
     saturation: { value: 0 },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
+    	vUv = uv;
 
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform sampler2D tDiffuse;',
-    'uniform float hue;',
-    'uniform float saturation;',
+  fragmentShader: /* glsl */ `
+    uniform sampler2D tDiffuse;
+    uniform float hue;
+    uniform float saturation;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	gl_FragColor = texture2D( tDiffuse, vUv );',
+    	gl_FragColor = texture2D( tDiffuse, vUv );
 
     // hue
-    '	float angle = hue * 3.14159265;',
-    '	float s = sin(angle), c = cos(angle);',
-    '	vec3 weights = (vec3(2.0 * c, -sqrt(3.0) * s - c, sqrt(3.0) * s - c) + 1.0) / 3.0;',
-    '	float len = length(gl_FragColor.rgb);',
-    '	gl_FragColor.rgb = vec3(',
-    '		dot(gl_FragColor.rgb, weights.xyz),',
-    '		dot(gl_FragColor.rgb, weights.zxy),',
-    '		dot(gl_FragColor.rgb, weights.yzx)',
-    '	);',
+    	float angle = hue * 3.14159265;
+    	float s = sin(angle), c = cos(angle);
+    	vec3 weights = (vec3(2.0 * c, -sqrt(3.0) * s - c, sqrt(3.0) * s - c) + 1.0) / 3.0;
+    	float len = length(gl_FragColor.rgb);
+    	gl_FragColor.rgb = vec3(
+    		dot(gl_FragColor.rgb, weights.xyz),
+    		dot(gl_FragColor.rgb, weights.zxy),
+    		dot(gl_FragColor.rgb, weights.yzx)
+    	);
 
     // saturation
-    '	float average = (gl_FragColor.r + gl_FragColor.g + gl_FragColor.b) / 3.0;',
-    '	if (saturation > 0.0) {',
-    '		gl_FragColor.rgb += (average - gl_FragColor.rgb) * (1.0 - 1.0 / (1.001 - saturation));',
-    '	} else {',
-    '		gl_FragColor.rgb += (average - gl_FragColor.rgb) * (-saturation);',
-    '	}',
-
-    '}',
-  ].join('\n'),
+    	float average = (gl_FragColor.r + gl_FragColor.g + gl_FragColor.b) / 3.0;
+    	if (saturation > 0.0) {
+    		gl_FragColor.rgb += (average - gl_FragColor.rgb) * (1.0 - 1.0 / (1.001 - saturation));
+    	} else {
+    		gl_FragColor.rgb += (average - gl_FragColor.rgb) * (-saturation);
+    	}
+
+    }
+  `,
 }
diff --git a/src/shaders/KaleidoShader.ts b/src/shaders/KaleidoShader.ts
index a879be43..0c269141 100644
--- a/src/shaders/KaleidoShader.ts
+++ b/src/shaders/KaleidoShader.ts
@@ -15,36 +15,36 @@ export const KaleidoShader = {
     angle: { value: 0.0 },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform sampler2D tDiffuse;',
-    'uniform float sides;',
-    'uniform float angle;',
+  fragmentShader: /* glsl */ `
+    uniform sampler2D tDiffuse;
+    uniform float sides;
+    uniform float angle;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vec2 p = vUv - 0.5;',
-    '	float r = length(p);',
-    '	float a = atan(p.y, p.x) + angle;',
-    '	float tau = 2. * 3.1416 ;',
-    '	a = mod(a, tau/sides);',
-    '	a = abs(a - tau/sides/2.) ;',
-    '	p = r * vec2(cos(a), sin(a));',
-    '	vec4 color = texture2D(tDiffuse, p + 0.5);',
-    '	gl_FragColor = color;',
+    	vec2 p = vUv - 0.5;
+    	float r = length(p);
+    	float a = atan(p.y, p.x) + angle;
+    	float tau = 2. * 3.1416 ;
+    	a = mod(a, tau/sides);
+    	a = abs(a - tau/sides/2.) ;
+    	p = r * vec2(cos(a), sin(a));
+    	vec4 color = texture2D(tDiffuse, p + 0.5);
+    	gl_FragColor = color;
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/LuminosityHighPassShader.ts b/src/shaders/LuminosityHighPassShader.ts
index 88709b49..7e08295f 100644
--- a/src/shaders/LuminosityHighPassShader.ts
+++ b/src/shaders/LuminosityHighPassShader.ts
@@ -12,45 +12,45 @@ export const LuminosityHighPassShader = {
     tDiffuse: { value: null },
     luminosityThreshold: { value: 1.0 },
     smoothWidth: { value: 1.0 },
-    defaultColor: { value: new Color(0x000000) },
+    defaultColor: { value: /* @__PURE__ */ new Color(0x000000) },
     defaultOpacity: { value: 0.0 },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
+    	vUv = uv;
 
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform sampler2D tDiffuse;',
-    'uniform vec3 defaultColor;',
-    'uniform float defaultOpacity;',
-    'uniform float luminosityThreshold;',
-    'uniform float smoothWidth;',
+  fragmentShader: /* glsl */ `
+    uniform sampler2D tDiffuse;
+    uniform vec3 defaultColor;
+    uniform float defaultOpacity;
+    uniform float luminosityThreshold;
+    uniform float smoothWidth;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vec4 texel = texture2D( tDiffuse, vUv );',
+    	vec4 texel = texture2D( tDiffuse, vUv );
 
-    '	vec3 luma = vec3( 0.299, 0.587, 0.114 );',
+    	vec3 luma = vec3( 0.299, 0.587, 0.114 );
 
-    '	float v = dot( texel.xyz, luma );',
+    	float v = dot( texel.xyz, luma );
 
-    '	vec4 outputColor = vec4( defaultColor.rgb, defaultOpacity );',
+    	vec4 outputColor = vec4( defaultColor.rgb, defaultOpacity );
 
-    '	float alpha = smoothstep( luminosityThreshold, luminosityThreshold + smoothWidth, v );',
+    	float alpha = smoothstep( luminosityThreshold, luminosityThreshold + smoothWidth, v );
 
-    '	gl_FragColor = mix( outputColor, texel, alpha );',
+    	gl_FragColor = mix( outputColor, texel, alpha );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/LuminosityShader.ts b/src/shaders/LuminosityShader.ts
index 149f7990..73053c53 100644
--- a/src/shaders/LuminosityShader.ts
+++ b/src/shaders/LuminosityShader.ts
@@ -8,33 +8,33 @@ export const LuminosityShader = {
     tDiffuse: { value: null },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
+    	vUv = uv;
 
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    '#include <common>',
+  fragmentShader: /* glsl */ `
+    #include <common>
 
-    'uniform sampler2D tDiffuse;',
+    uniform sampler2D tDiffuse;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vec4 texel = texture2D( tDiffuse, vUv );',
+    	vec4 texel = texture2D( tDiffuse, vUv );
 
-    '	float l = linearToRelativeLuminance( texel.rgb );',
+    	float l = linearToRelativeLuminance( texel.rgb );
 
-    '	gl_FragColor = vec4( l, l, l, texel.w );',
+    	gl_FragColor = vec4( l, l, l, texel.w );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/MirrorShader.ts b/src/shaders/MirrorShader.ts
index bcfade64..1c8f147d 100644
--- a/src/shaders/MirrorShader.ts
+++ b/src/shaders/MirrorShader.ts
@@ -11,38 +11,38 @@ export const MirrorShader = {
     side: { value: 1 },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform sampler2D tDiffuse;',
-    'uniform int side;',
+  fragmentShader: /* glsl */ `
+    uniform sampler2D tDiffuse;
+    uniform int side;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vec2 p = vUv;',
-    '	if (side == 0){',
-    '		if (p.x > 0.5) p.x = 1.0 - p.x;',
-    '	}else if (side == 1){',
-    '		if (p.x < 0.5) p.x = 1.0 - p.x;',
-    '	}else if (side == 2){',
-    '		if (p.y < 0.5) p.y = 1.0 - p.y;',
-    '	}else if (side == 3){',
-    '		if (p.y > 0.5) p.y = 1.0 - p.y;',
-    '	} ',
-    '	vec4 color = texture2D(tDiffuse, p);',
-    '	gl_FragColor = color;',
+    	vec2 p = vUv;
+    	if (side == 0){
+    		if (p.x > 0.5) p.x = 1.0 - p.x;
+    	}else if (side == 1){
+    		if (p.x < 0.5) p.x = 1.0 - p.x;
+    	}else if (side == 2){
+    		if (p.y < 0.5) p.y = 1.0 - p.y;
+    	}else if (side == 3){
+    		if (p.y > 0.5) p.y = 1.0 - p.y;
+    	} 
+    	vec4 color = texture2D(tDiffuse, p);
+    	gl_FragColor = color;
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/NormalMapShader.ts b/src/shaders/NormalMapShader.ts
index 56258ad7..a6813519 100644
--- a/src/shaders/NormalMapShader.ts
+++ b/src/shaders/NormalMapShader.ts
@@ -8,38 +8,38 @@ import { Vector2 } from 'three'
 export const NormalMapShader = {
   uniforms: {
     heightMap: { value: null },
-    resolution: { value: new Vector2(512, 512) },
-    scale: { value: new Vector2(1, 1) },
+    resolution: { value: /* @__PURE__ */ new Vector2(512, 512) },
+    scale: { value: /* @__PURE__ */ new Vector2(1, 1) },
     height: { value: 0.05 },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform float height;',
-    'uniform vec2 resolution;',
-    'uniform sampler2D heightMap;',
+  fragmentShader: /* glsl */ `
+    uniform float height;
+    uniform vec2 resolution;
+    uniform sampler2D heightMap;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	float val = texture2D( heightMap, vUv ).x;',
+    	float val = texture2D( heightMap, vUv ).x;
 
-    '	float valU = texture2D( heightMap, vUv + vec2( 1.0 / resolution.x, 0.0 ) ).x;',
-    '	float valV = texture2D( heightMap, vUv + vec2( 0.0, 1.0 / resolution.y ) ).x;',
+    	float valU = texture2D( heightMap, vUv + vec2( 1.0 / resolution.x, 0.0 ) ).x;
+    	float valV = texture2D( heightMap, vUv + vec2( 0.0, 1.0 / resolution.y ) ).x;
 
-    '	gl_FragColor = vec4( ( 0.5 * normalize( vec3( val - valU, val - valV, height  ) ) + 0.5 ), 1.0 );',
+    	gl_FragColor = vec4( ( 0.5 * normalize( vec3( val - valU, val - valV, height  ) ) + 0.5 ), 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/ParallaxShader.ts b/src/shaders/ParallaxShader.ts
index adc2f921..ddb998d4 100644
--- a/src/shaders/ParallaxShader.ts
+++ b/src/shaders/ParallaxShader.ts
@@ -21,161 +21,161 @@ export const ParallaxShader = {
     parallaxMaxLayers: { value: null },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
-    'varying vec3 vViewPosition;',
-    'varying vec3 vNormal;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
+    varying vec3 vViewPosition;
+    varying vec3 vNormal;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );',
-    '	vViewPosition = -mvPosition.xyz;',
-    '	vNormal = normalize( normalMatrix * normal );',
-    '	gl_Position = projectionMatrix * mvPosition;',
+    	vUv = uv;
+    	vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );
+    	vViewPosition = -mvPosition.xyz;
+    	vNormal = normalize( normalMatrix * normal );
+    	gl_Position = projectionMatrix * mvPosition;
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform sampler2D bumpMap;',
-    'uniform sampler2D map;',
+  fragmentShader: /* glsl */ `
+    uniform sampler2D bumpMap;
+    uniform sampler2D map;
 
-    'uniform float parallaxScale;',
-    'uniform float parallaxMinLayers;',
-    'uniform float parallaxMaxLayers;',
+    uniform float parallaxScale;
+    uniform float parallaxMinLayers;
+    uniform float parallaxMaxLayers;
 
-    'varying vec2 vUv;',
-    'varying vec3 vViewPosition;',
-    'varying vec3 vNormal;',
+    varying vec2 vUv;
+    varying vec3 vViewPosition;
+    varying vec3 vNormal;
 
-    '#ifdef USE_BASIC_PARALLAX',
+    #ifdef USE_BASIC_PARALLAX
 
-    '	vec2 parallaxMap( in vec3 V ) {',
+    	vec2 parallaxMap( in vec3 V ) {
 
-    '		float initialHeight = texture2D( bumpMap, vUv ).r;',
+    		float initialHeight = texture2D( bumpMap, vUv ).r;
 
     // No Offset Limitting: messy, floating output at grazing angles.
     //"vec2 texCoordOffset = parallaxScale * V.xy / V.z * initialHeight;",
 
     // Offset Limiting
-    '		vec2 texCoordOffset = parallaxScale * V.xy * initialHeight;',
-    '		return vUv - texCoordOffset;',
+    		vec2 texCoordOffset = parallaxScale * V.xy * initialHeight;
+    		return vUv - texCoordOffset;
 
-    '	}',
+    	}
 
-    '#else',
+    #else
 
-    '	vec2 parallaxMap( in vec3 V ) {',
+    	vec2 parallaxMap( in vec3 V ) {
 
     // Determine number of layers from angle between V and N
-    '		float numLayers = mix( parallaxMaxLayers, parallaxMinLayers, abs( dot( vec3( 0.0, 0.0, 1.0 ), V ) ) );',
+    		float numLayers = mix( parallaxMaxLayers, parallaxMinLayers, abs( dot( vec3( 0.0, 0.0, 1.0 ), V ) ) );
 
-    '		float layerHeight = 1.0 / numLayers;',
-    '		float currentLayerHeight = 0.0;',
+    		float layerHeight = 1.0 / numLayers;
+    		float currentLayerHeight = 0.0;
     // Shift of texture coordinates for each iteration
-    '		vec2 dtex = parallaxScale * V.xy / V.z / numLayers;',
+    		vec2 dtex = parallaxScale * V.xy / V.z / numLayers;
 
-    '		vec2 currentTextureCoords = vUv;',
+    		vec2 currentTextureCoords = vUv;
 
-    '		float heightFromTexture = texture2D( bumpMap, currentTextureCoords ).r;',
+    		float heightFromTexture = texture2D( bumpMap, currentTextureCoords ).r;
 
     // while ( heightFromTexture > currentLayerHeight )
     // Infinite loops are not well supported. Do a "large" finite
     // loop, but not too large, as it slows down some compilers.
-    '		for ( int i = 0; i < 30; i += 1 ) {',
-    '			if ( heightFromTexture <= currentLayerHeight ) {',
-    '				break;',
-    '			}',
-    '			currentLayerHeight += layerHeight;',
+    		for ( int i = 0; i < 30; i += 1 ) {
+    			if ( heightFromTexture <= currentLayerHeight ) {
+    				break;
+    			}
+    			currentLayerHeight += layerHeight;
     // Shift texture coordinates along vector V
-    '			currentTextureCoords -= dtex;',
-    '			heightFromTexture = texture2D( bumpMap, currentTextureCoords ).r;',
-    '		}',
+    			currentTextureCoords -= dtex;
+    			heightFromTexture = texture2D( bumpMap, currentTextureCoords ).r;
+    		}
 
-    '		#ifdef USE_STEEP_PARALLAX',
+    		#ifdef USE_STEEP_PARALLAX
 
-    '			return currentTextureCoords;',
+    			return currentTextureCoords;
 
-    '		#elif defined( USE_RELIEF_PARALLAX )',
+    		#elif defined( USE_RELIEF_PARALLAX )
 
-    '			vec2 deltaTexCoord = dtex / 2.0;',
-    '			float deltaHeight = layerHeight / 2.0;',
+    			vec2 deltaTexCoord = dtex / 2.0;
+    			float deltaHeight = layerHeight / 2.0;
 
     // Return to the mid point of previous layer
-    '			currentTextureCoords += deltaTexCoord;',
-    '			currentLayerHeight -= deltaHeight;',
+    			currentTextureCoords += deltaTexCoord;
+    			currentLayerHeight -= deltaHeight;
 
     // Binary search to increase precision of Steep Parallax Mapping
-    '			const int numSearches = 5;',
-    '			for ( int i = 0; i < numSearches; i += 1 ) {',
+    			const int numSearches = 5;
+    			for ( int i = 0; i < numSearches; i += 1 ) {
 
-    '				deltaTexCoord /= 2.0;',
-    '				deltaHeight /= 2.0;',
-    '				heightFromTexture = texture2D( bumpMap, currentTextureCoords ).r;',
+    				deltaTexCoord /= 2.0;
+    				deltaHeight /= 2.0;
+    				heightFromTexture = texture2D( bumpMap, currentTextureCoords ).r;
     // Shift along or against vector V
-    '				if( heightFromTexture > currentLayerHeight ) {', // Below the surface
+    				if( heightFromTexture > currentLayerHeight ) { // Below the surface
 
-    '					currentTextureCoords -= deltaTexCoord;',
-    '					currentLayerHeight += deltaHeight;',
+    					currentTextureCoords -= deltaTexCoord;
+    					currentLayerHeight += deltaHeight;
 
-    '				} else {', // above the surface
+    				} else { // above the surface
 
-    '					currentTextureCoords += deltaTexCoord;',
-    '					currentLayerHeight -= deltaHeight;',
+    					currentTextureCoords += deltaTexCoord;
+    					currentLayerHeight -= deltaHeight;
 
-    '				}',
+    				}
 
-    '			}',
-    '			return currentTextureCoords;',
+    			}
+    			return currentTextureCoords;
 
-    '		#elif defined( USE_OCLUSION_PARALLAX )',
+    		#elif defined( USE_OCLUSION_PARALLAX )
 
-    '			vec2 prevTCoords = currentTextureCoords + dtex;',
+    			vec2 prevTCoords = currentTextureCoords + dtex;
 
     // Heights for linear interpolation
-    '			float nextH = heightFromTexture - currentLayerHeight;',
-    '			float prevH = texture2D( bumpMap, prevTCoords ).r - currentLayerHeight + layerHeight;',
+    			float nextH = heightFromTexture - currentLayerHeight;
+    			float prevH = texture2D( bumpMap, prevTCoords ).r - currentLayerHeight + layerHeight;
 
     // Proportions for linear interpolation
-    '			float weight = nextH / ( nextH - prevH );',
+    			float weight = nextH / ( nextH - prevH );
 
     // Interpolation of texture coordinates
-    '			return prevTCoords * weight + currentTextureCoords * ( 1.0 - weight );',
+    			return prevTCoords * weight + currentTextureCoords * ( 1.0 - weight );
 
-    '		#else', // NO_PARALLAX
+    		#else // NO_PARALLAX
 
-    '			return vUv;',
+    			return vUv;
 
-    '		#endif',
+    		#endif
 
-    '	}',
-    '#endif',
+    	}
+    #endif
 
-    'vec2 perturbUv( vec3 surfPosition, vec3 surfNormal, vec3 viewPosition ) {',
+    vec2 perturbUv( vec3 surfPosition, vec3 surfNormal, vec3 viewPosition ) {
 
-    '	vec2 texDx = dFdx( vUv );',
-    '	vec2 texDy = dFdy( vUv );',
+    	vec2 texDx = dFdx( vUv );
+    	vec2 texDy = dFdy( vUv );
 
-    '	vec3 vSigmaX = dFdx( surfPosition );',
-    '	vec3 vSigmaY = dFdy( surfPosition );',
-    '	vec3 vR1 = cross( vSigmaY, surfNormal );',
-    '	vec3 vR2 = cross( surfNormal, vSigmaX );',
-    '	float fDet = dot( vSigmaX, vR1 );',
+    	vec3 vSigmaX = dFdx( surfPosition );
+    	vec3 vSigmaY = dFdy( surfPosition );
+    	vec3 vR1 = cross( vSigmaY, surfNormal );
+    	vec3 vR2 = cross( surfNormal, vSigmaX );
+    	float fDet = dot( vSigmaX, vR1 );
 
-    '	vec2 vProjVscr = ( 1.0 / fDet ) * vec2( dot( vR1, viewPosition ), dot( vR2, viewPosition ) );',
-    '	vec3 vProjVtex;',
-    '	vProjVtex.xy = texDx * vProjVscr.x + texDy * vProjVscr.y;',
-    '	vProjVtex.z = dot( surfNormal, viewPosition );',
+    	vec2 vProjVscr = ( 1.0 / fDet ) * vec2( dot( vR1, viewPosition ), dot( vR2, viewPosition ) );
+    	vec3 vProjVtex;
+    	vProjVtex.xy = texDx * vProjVscr.x + texDy * vProjVscr.y;
+    	vProjVtex.z = dot( surfNormal, viewPosition );
 
-    '	return parallaxMap( vProjVtex );',
-    '}',
+    	return parallaxMap( vProjVtex );
+    }
 
-    'void main() {',
+    void main() {
 
-    '	vec2 mapUv = perturbUv( -vViewPosition, normalize( vNormal ), normalize( vViewPosition ) );',
-    '	gl_FragColor = texture2D( map, mapUv );',
+    	vec2 mapUv = perturbUv( -vViewPosition, normalize( vNormal ), normalize( vViewPosition ) );
+    	gl_FragColor = texture2D( map, mapUv );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/PixelShader.ts b/src/shaders/PixelShader.ts
index f9594f59..3408aed2 100644
--- a/src/shaders/PixelShader.ts
+++ b/src/shaders/PixelShader.ts
@@ -9,30 +9,30 @@ export const PixelShader = {
     pixelSize: { value: 1 },
   },
 
-  vertexShader: [
-    'varying highp vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying highp vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    'vUv = uv;',
-    'gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+      vUv = uv;
+      gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform sampler2D tDiffuse;',
-    'uniform float pixelSize;',
-    'uniform vec2 resolution;',
+  fragmentShader: /* glsl */ `
+    uniform sampler2D tDiffuse;
+    uniform float pixelSize;
+    uniform vec2 resolution;
 
-    'varying highp vec2 vUv;',
+    varying highp vec2 vUv;
 
-    'void main(){',
+    void main(){
 
-    'vec2 dxy = pixelSize / resolution;',
-    'vec2 coord = dxy * floor( vUv / dxy );',
-    'gl_FragColor = texture2D(tDiffuse, coord);',
+      vec2 dxy = pixelSize / resolution;
+      vec2 coord = dxy * floor( vUv / dxy );
+      gl_FragColor = texture2D(tDiffuse, coord);
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/RGBShiftShader.ts b/src/shaders/RGBShiftShader.ts
index b545112f..abfc5640 100644
--- a/src/shaders/RGBShiftShader.ts
+++ b/src/shaders/RGBShiftShader.ts
@@ -15,32 +15,32 @@ export const RGBShiftShader = {
     angle: { value: 0.0 },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform sampler2D tDiffuse;',
-    'uniform float amount;',
-    'uniform float angle;',
+  fragmentShader: /* glsl */ `
+    uniform sampler2D tDiffuse;
+    uniform float amount;
+    uniform float angle;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vec2 offset = amount * vec2( cos(angle), sin(angle));',
-    '	vec4 cr = texture2D(tDiffuse, vUv + offset);',
-    '	vec4 cga = texture2D(tDiffuse, vUv);',
-    '	vec4 cb = texture2D(tDiffuse, vUv - offset);',
-    '	gl_FragColor = vec4(cr.r, cga.g, cb.b, cga.a);',
+    	vec2 offset = amount * vec2( cos(angle), sin(angle));
+    	vec4 cr = texture2D(tDiffuse, vUv + offset);
+    	vec4 cga = texture2D(tDiffuse, vUv);
+    	vec4 cb = texture2D(tDiffuse, vUv - offset);
+    	gl_FragColor = vec4(cr.r, cga.g, cb.b, cga.a);
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/SAOShader.ts b/src/shaders/SAOShader.ts
index 69b1546c..0843688b 100644
--- a/src/shaders/SAOShader.ts
+++ b/src/shaders/SAOShader.ts
@@ -43,12 +43,12 @@ export const SAOShader: ISAOShader = {
     tDepth: { value: null },
     tDiffuse: { value: null },
     tNormal: { value: null },
-    size: { value: new Vector2(512, 512) },
+    size: { value: /* @__PURE__ */ new Vector2(512, 512) },
 
     cameraNear: { value: 1 },
     cameraFar: { value: 100 },
-    cameraProjectionMatrix: { value: new Matrix4() },
-    cameraInverseProjectionMatrix: { value: new Matrix4() },
+    cameraProjectionMatrix: { value: /* @__PURE__ */ new Matrix4() },
+    cameraInverseProjectionMatrix: { value: /* @__PURE__ */ new Matrix4() },
 
     scale: { value: 1.0 },
     intensity: { value: 0.1 },
@@ -58,149 +58,149 @@ export const SAOShader: ISAOShader = {
     kernelRadius: { value: 100.0 },
     randomSeed: { value: 0.0 },
   },
-  vertexShader: [
-    'varying vec2 vUv;',
-
-    'void main() {',
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
-    '}',
-  ].join('\n'),
-  fragmentShader: [
-    '#include <common>',
-
-    'varying vec2 vUv;',
-
-    '#if DIFFUSE_TEXTURE == 1',
-    'uniform sampler2D tDiffuse;',
-    '#endif',
-
-    'uniform sampler2D tDepth;',
-
-    '#if NORMAL_TEXTURE == 1',
-    'uniform sampler2D tNormal;',
-    '#endif',
-
-    'uniform float cameraNear;',
-    'uniform float cameraFar;',
-    'uniform mat4 cameraProjectionMatrix;',
-    'uniform mat4 cameraInverseProjectionMatrix;',
-
-    'uniform float scale;',
-    'uniform float intensity;',
-    'uniform float bias;',
-    'uniform float kernelRadius;',
-    'uniform float minResolution;',
-    'uniform vec2 size;',
-    'uniform float randomSeed;',
-
-    '// RGBA depth',
-
-    '#include <packing>',
-
-    'vec4 getDefaultColor( const in vec2 screenPosition ) {',
-    '	#if DIFFUSE_TEXTURE == 1',
-    '	return texture2D( tDiffuse, vUv );',
-    '	#else',
-    '	return vec4( 1.0 );',
-    '	#endif',
-    '}',
-
-    'float getDepth( const in vec2 screenPosition ) {',
-    '	#if DEPTH_PACKING == 1',
-    '	return unpackRGBAToDepth( texture2D( tDepth, screenPosition ) );',
-    '	#else',
-    '	return texture2D( tDepth, screenPosition ).x;',
-    '	#endif',
-    '}',
-
-    'float getViewZ( const in float depth ) {',
-    '	#if PERSPECTIVE_CAMERA == 1',
-    '	return perspectiveDepthToViewZ( depth, cameraNear, cameraFar );',
-    '	#else',
-    '	return orthographicDepthToViewZ( depth, cameraNear, cameraFar );',
-    '	#endif',
-    '}',
-
-    'vec3 getViewPosition( const in vec2 screenPosition, const in float depth, const in float viewZ ) {',
-    '	float clipW = cameraProjectionMatrix[2][3] * viewZ + cameraProjectionMatrix[3][3];',
-    '	vec4 clipPosition = vec4( ( vec3( screenPosition, depth ) - 0.5 ) * 2.0, 1.0 );',
-    '	clipPosition *= clipW; // unprojection.',
-
-    '	return ( cameraInverseProjectionMatrix * clipPosition ).xyz;',
-    '}',
-
-    'vec3 getViewNormal( const in vec3 viewPosition, const in vec2 screenPosition ) {',
-    '	#if NORMAL_TEXTURE == 1',
-    '	return unpackRGBToNormal( texture2D( tNormal, screenPosition ).xyz );',
-    '	#else',
-    '	return normalize( cross( dFdx( viewPosition ), dFdy( viewPosition ) ) );',
-    '	#endif',
-    '}',
-
-    'float scaleDividedByCameraFar;',
-    'float minResolutionMultipliedByCameraFar;',
-
-    'float getOcclusion( const in vec3 centerViewPosition, const in vec3 centerViewNormal, const in vec3 sampleViewPosition ) {',
-    '	vec3 viewDelta = sampleViewPosition - centerViewPosition;',
-    '	float viewDistance = length( viewDelta );',
-    '	float scaledScreenDistance = scaleDividedByCameraFar * viewDistance;',
-
-    '	return max(0.0, (dot(centerViewNormal, viewDelta) - minResolutionMultipliedByCameraFar) / scaledScreenDistance - bias) / (1.0 + pow2( scaledScreenDistance ) );',
-    '}',
-
-    '// moving costly divides into consts',
-    'const float ANGLE_STEP = PI2 * float( NUM_RINGS ) / float( NUM_SAMPLES );',
-    'const float INV_NUM_SAMPLES = 1.0 / float( NUM_SAMPLES );',
-
-    'float getAmbientOcclusion( const in vec3 centerViewPosition ) {',
-    '	// precompute some variables require in getOcclusion.',
-    '	scaleDividedByCameraFar = scale / cameraFar;',
-    '	minResolutionMultipliedByCameraFar = minResolution * cameraFar;',
-    '	vec3 centerViewNormal = getViewNormal( centerViewPosition, vUv );',
-
-    '	// jsfiddle that shows sample pattern: https://jsfiddle.net/a16ff1p7/',
-    '	float angle = rand( vUv + randomSeed ) * PI2;',
-    '	vec2 radius = vec2( kernelRadius * INV_NUM_SAMPLES ) / size;',
-    '	vec2 radiusStep = radius;',
-
-    '	float occlusionSum = 0.0;',
-    '	float weightSum = 0.0;',
-
-    '	for( int i = 0; i < NUM_SAMPLES; i ++ ) {',
-    '		vec2 sampleUv = vUv + vec2( cos( angle ), sin( angle ) ) * radius;',
-    '		radius += radiusStep;',
-    '		angle += ANGLE_STEP;',
-
-    '		float sampleDepth = getDepth( sampleUv );',
-    '		if( sampleDepth >= ( 1.0 - EPSILON ) ) {',
-    '			continue;',
-    '		}',
-
-    '		float sampleViewZ = getViewZ( sampleDepth );',
-    '		vec3 sampleViewPosition = getViewPosition( sampleUv, sampleDepth, sampleViewZ );',
-    '		occlusionSum += getOcclusion( centerViewPosition, centerViewNormal, sampleViewPosition );',
-    '		weightSum += 1.0;',
-    '	}',
-
-    '	if( weightSum == 0.0 ) discard;',
-
-    '	return occlusionSum * ( intensity / weightSum );',
-    '}',
-
-    'void main() {',
-    '	float centerDepth = getDepth( vUv );',
-    '	if( centerDepth >= ( 1.0 - EPSILON ) ) {',
-    '		discard;',
-    '	}',
-
-    '	float centerViewZ = getViewZ( centerDepth );',
-    '	vec3 viewPosition = getViewPosition( vUv, centerDepth, centerViewZ );',
-
-    '	float ambientOcclusion = getAmbientOcclusion( viewPosition );',
-
-    '	gl_FragColor = getDefaultColor( vUv );',
-    '	gl_FragColor.xyz *=  1.0 - ambientOcclusion;',
-    '}',
-  ].join('\n'),
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
+
+    void main() {
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    }
+  `,
+  fragmentShader: /* glsl */ `
+    #include <common>
+
+    varying vec2 vUv;
+
+    #if DIFFUSE_TEXTURE == 1
+    uniform sampler2D tDiffuse;
+    #endif
+
+    uniform sampler2D tDepth;
+
+    #if NORMAL_TEXTURE == 1
+    uniform sampler2D tNormal;
+    #endif
+
+    uniform float cameraNear;
+    uniform float cameraFar;
+    uniform mat4 cameraProjectionMatrix;
+    uniform mat4 cameraInverseProjectionMatrix;
+
+    uniform float scale;
+    uniform float intensity;
+    uniform float bias;
+    uniform float kernelRadius;
+    uniform float minResolution;
+    uniform vec2 size;
+    uniform float randomSeed;
+
+    // RGBA depth
+
+    #include <packing>
+
+    vec4 getDefaultColor( const in vec2 screenPosition ) {
+    	#if DIFFUSE_TEXTURE == 1
+    	return texture2D( tDiffuse, vUv );
+    	#else
+    	return vec4( 1.0 );
+    	#endif
+    }
+
+    float getDepth( const in vec2 screenPosition ) {
+    	#if DEPTH_PACKING == 1
+    	return unpackRGBAToDepth( texture2D( tDepth, screenPosition ) );
+    	#else
+    	return texture2D( tDepth, screenPosition ).x;
+    	#endif
+    }
+
+    float getViewZ( const in float depth ) {
+    	#if PERSPECTIVE_CAMERA == 1
+    	return perspectiveDepthToViewZ( depth, cameraNear, cameraFar );
+    	#else
+    	return orthographicDepthToViewZ( depth, cameraNear, cameraFar );
+    	#endif
+    }
+
+    vec3 getViewPosition( const in vec2 screenPosition, const in float depth, const in float viewZ ) {
+    	float clipW = cameraProjectionMatrix[2][3] * viewZ + cameraProjectionMatrix[3][3];
+    	vec4 clipPosition = vec4( ( vec3( screenPosition, depth ) - 0.5 ) * 2.0, 1.0 );
+    	clipPosition *= clipW; // unprojection.
+
+    	return ( cameraInverseProjectionMatrix * clipPosition ).xyz;
+    }
+
+    vec3 getViewNormal( const in vec3 viewPosition, const in vec2 screenPosition ) {
+    	#if NORMAL_TEXTURE == 1
+    	return unpackRGBToNormal( texture2D( tNormal, screenPosition ).xyz );
+    	#else
+    	return normalize( cross( dFdx( viewPosition ), dFdy( viewPosition ) ) );
+    	#endif
+    }
+
+    float scaleDividedByCameraFar;
+    float minResolutionMultipliedByCameraFar;
+
+    float getOcclusion( const in vec3 centerViewPosition, const in vec3 centerViewNormal, const in vec3 sampleViewPosition ) {
+    	vec3 viewDelta = sampleViewPosition - centerViewPosition;
+    	float viewDistance = length( viewDelta );
+    	float scaledScreenDistance = scaleDividedByCameraFar * viewDistance;
+
+    	return max(0.0, (dot(centerViewNormal, viewDelta) - minResolutionMultipliedByCameraFar) / scaledScreenDistance - bias) / (1.0 + pow2( scaledScreenDistance ) );
+    }
+
+    // moving costly divides into consts
+    const float ANGLE_STEP = PI2 * float( NUM_RINGS ) / float( NUM_SAMPLES );
+    const float INV_NUM_SAMPLES = 1.0 / float( NUM_SAMPLES );
+
+    float getAmbientOcclusion( const in vec3 centerViewPosition ) {
+    	// precompute some variables require in getOcclusion.
+    	scaleDividedByCameraFar = scale / cameraFar;
+    	minResolutionMultipliedByCameraFar = minResolution * cameraFar;
+    	vec3 centerViewNormal = getViewNormal( centerViewPosition, vUv );
+
+    	// jsfiddle that shows sample pattern: https://jsfiddle.net/a16ff1p7/
+    	float angle = rand( vUv + randomSeed ) * PI2;
+    	vec2 radius = vec2( kernelRadius * INV_NUM_SAMPLES ) / size;
+    	vec2 radiusStep = radius;
+
+    	float occlusionSum = 0.0;
+    	float weightSum = 0.0;
+
+    	for( int i = 0; i < NUM_SAMPLES; i ++ ) {
+    		vec2 sampleUv = vUv + vec2( cos( angle ), sin( angle ) ) * radius;
+    		radius += radiusStep;
+    		angle += ANGLE_STEP;
+
+    		float sampleDepth = getDepth( sampleUv );
+    		if( sampleDepth >= ( 1.0 - EPSILON ) ) {
+    			continue;
+    		}
+
+    		float sampleViewZ = getViewZ( sampleDepth );
+    		vec3 sampleViewPosition = getViewPosition( sampleUv, sampleDepth, sampleViewZ );
+    		occlusionSum += getOcclusion( centerViewPosition, centerViewNormal, sampleViewPosition );
+    		weightSum += 1.0;
+    	}
+
+    	if( weightSum == 0.0 ) discard;
+
+    	return occlusionSum * ( intensity / weightSum );
+    }
+
+    void main() {
+    	float centerDepth = getDepth( vUv );
+    	if( centerDepth >= ( 1.0 - EPSILON ) ) {
+    		discard;
+    	}
+
+    	float centerViewZ = getViewZ( centerDepth );
+    	vec3 viewPosition = getViewPosition( vUv, centerDepth, centerViewZ );
+
+    	float ambientOcclusion = getAmbientOcclusion( viewPosition );
+
+    	gl_FragColor = getDefaultColor( vUv );
+    	gl_FragColor.xyz *=  1.0 - ambientOcclusion;
+    }
+  `,
 }
diff --git a/src/shaders/SMAAShader.ts b/src/shaders/SMAAShader.ts
index 95813a82..17cde98c 100644
--- a/src/shaders/SMAAShader.ts
+++ b/src/shaders/SMAAShader.ts
@@ -13,96 +13,96 @@ export const SMAAEdgesShader = {
 
   uniforms: {
     tDiffuse: { value: null },
-    resolution: { value: new Vector2(1 / 1024, 1 / 512) },
+    resolution: { value: /* @__PURE__ */ new Vector2(1 / 1024, 1 / 512) },
   },
 
-  vertexShader: [
-    'uniform vec2 resolution;',
+  vertexShader: /* glsl */ `
+    uniform vec2 resolution;
 
-    'varying vec2 vUv;',
-    'varying vec4 vOffset[ 3 ];',
+    varying vec2 vUv;
+    varying vec4 vOffset[ 3 ];
 
-    'void SMAAEdgeDetectionVS( vec2 texcoord ) {',
-    '	vOffset[ 0 ] = texcoord.xyxy + resolution.xyxy * vec4( -1.0, 0.0, 0.0,  1.0 );', // WebGL port note: Changed sign in W component
-    '	vOffset[ 1 ] = texcoord.xyxy + resolution.xyxy * vec4(  1.0, 0.0, 0.0, -1.0 );', // WebGL port note: Changed sign in W component
-    '	vOffset[ 2 ] = texcoord.xyxy + resolution.xyxy * vec4( -2.0, 0.0, 0.0,  2.0 );', // WebGL port note: Changed sign in W component
-    '}',
+    void SMAAEdgeDetectionVS( vec2 texcoord ) {
+    	vOffset[ 0 ] = texcoord.xyxy + resolution.xyxy * vec4( -1.0, 0.0, 0.0,  1.0 ); // WebGL port note: Changed sign in W component
+    	vOffset[ 1 ] = texcoord.xyxy + resolution.xyxy * vec4(  1.0, 0.0, 0.0, -1.0 ); // WebGL port note: Changed sign in W component
+    	vOffset[ 2 ] = texcoord.xyxy + resolution.xyxy * vec4( -2.0, 0.0, 0.0,  2.0 ); // WebGL port note: Changed sign in W component
+    }
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
+    	vUv = uv;
 
-    '	SMAAEdgeDetectionVS( vUv );',
+    	SMAAEdgeDetectionVS( vUv );
 
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform sampler2D tDiffuse;',
+  fragmentShader: /* glsl */ `
+    uniform sampler2D tDiffuse;
 
-    'varying vec2 vUv;',
-    'varying vec4 vOffset[ 3 ];',
+    varying vec2 vUv;
+    varying vec4 vOffset[ 3 ];
 
-    'vec4 SMAAColorEdgeDetectionPS( vec2 texcoord, vec4 offset[3], sampler2D colorTex ) {',
-    '	vec2 threshold = vec2( SMAA_THRESHOLD, SMAA_THRESHOLD );',
+    vec4 SMAAColorEdgeDetectionPS( vec2 texcoord, vec4 offset[3], sampler2D colorTex ) {
+    	vec2 threshold = vec2( SMAA_THRESHOLD, SMAA_THRESHOLD );
 
     // Calculate color deltas:
-    '	vec4 delta;',
-    '	vec3 C = texture2D( colorTex, texcoord ).rgb;',
+    	vec4 delta;
+    	vec3 C = texture2D( colorTex, texcoord ).rgb;
 
-    '	vec3 Cleft = texture2D( colorTex, offset[0].xy ).rgb;',
-    '	vec3 t = abs( C - Cleft );',
-    '	delta.x = max( max( t.r, t.g ), t.b );',
+    	vec3 Cleft = texture2D( colorTex, offset[0].xy ).rgb;
+    	vec3 t = abs( C - Cleft );
+    	delta.x = max( max( t.r, t.g ), t.b );
 
-    '	vec3 Ctop = texture2D( colorTex, offset[0].zw ).rgb;',
-    '	t = abs( C - Ctop );',
-    '	delta.y = max( max( t.r, t.g ), t.b );',
+    	vec3 Ctop = texture2D( colorTex, offset[0].zw ).rgb;
+    	t = abs( C - Ctop );
+    	delta.y = max( max( t.r, t.g ), t.b );
 
     // We do the usual threshold:
-    '	vec2 edges = step( threshold, delta.xy );',
+    	vec2 edges = step( threshold, delta.xy );
 
     // Then discard if there is no edge:
-    '	if ( dot( edges, vec2( 1.0, 1.0 ) ) == 0.0 )',
-    '		discard;',
+    	if ( dot( edges, vec2( 1.0, 1.0 ) ) == 0.0 )
+    		discard;
 
     // Calculate right and bottom deltas:
-    '	vec3 Cright = texture2D( colorTex, offset[1].xy ).rgb;',
-    '	t = abs( C - Cright );',
-    '	delta.z = max( max( t.r, t.g ), t.b );',
+    	vec3 Cright = texture2D( colorTex, offset[1].xy ).rgb;
+    	t = abs( C - Cright );
+    	delta.z = max( max( t.r, t.g ), t.b );
 
-    '	vec3 Cbottom  = texture2D( colorTex, offset[1].zw ).rgb;',
-    '	t = abs( C - Cbottom );',
-    '	delta.w = max( max( t.r, t.g ), t.b );',
+    	vec3 Cbottom  = texture2D( colorTex, offset[1].zw ).rgb;
+    	t = abs( C - Cbottom );
+    	delta.w = max( max( t.r, t.g ), t.b );
 
     // Calculate the maximum delta in the direct neighborhood:
-    '	float maxDelta = max( max( max( delta.x, delta.y ), delta.z ), delta.w );',
+    	float maxDelta = max( max( max( delta.x, delta.y ), delta.z ), delta.w );
 
     // Calculate left-left and top-top deltas:
-    '	vec3 Cleftleft  = texture2D( colorTex, offset[2].xy ).rgb;',
-    '	t = abs( C - Cleftleft );',
-    '	delta.z = max( max( t.r, t.g ), t.b );',
+    	vec3 Cleftleft  = texture2D( colorTex, offset[2].xy ).rgb;
+    	t = abs( C - Cleftleft );
+    	delta.z = max( max( t.r, t.g ), t.b );
 
-    '	vec3 Ctoptop = texture2D( colorTex, offset[2].zw ).rgb;',
-    '	t = abs( C - Ctoptop );',
-    '	delta.w = max( max( t.r, t.g ), t.b );',
+    	vec3 Ctoptop = texture2D( colorTex, offset[2].zw ).rgb;
+    	t = abs( C - Ctoptop );
+    	delta.w = max( max( t.r, t.g ), t.b );
 
     // Calculate the final maximum delta:
-    '	maxDelta = max( max( maxDelta, delta.z ), delta.w );',
+    	maxDelta = max( max( maxDelta, delta.z ), delta.w );
 
     // Local contrast adaptation in action:
-    '	edges.xy *= step( 0.5 * maxDelta, delta.xy );',
+    	edges.xy *= step( 0.5 * maxDelta, delta.xy );
 
-    '	return vec4( edges, 0.0, 0.0 );',
-    '}',
+    	return vec4( edges, 0.0, 0.0 );
+    }
 
-    'void main() {',
+    void main() {
 
-    '	gl_FragColor = SMAAColorEdgeDetectionPS( vUv, vOffset, tDiffuse );',
+    	gl_FragColor = SMAAColorEdgeDetectionPS( vUv, vOffset, tDiffuse );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
 
 export const SMAAWeightsShader = {
@@ -117,67 +117,67 @@ export const SMAAWeightsShader = {
     tDiffuse: { value: null },
     tArea: { value: null },
     tSearch: { value: null },
-    resolution: { value: new Vector2(1 / 1024, 1 / 512) },
+    resolution: { value: /* @__PURE__ */ new Vector2(1 / 1024, 1 / 512) },
   },
 
-  vertexShader: [
-    'uniform vec2 resolution;',
+  vertexShader: /* glsl */ `
+    uniform vec2 resolution;
 
-    'varying vec2 vUv;',
-    'varying vec4 vOffset[ 3 ];',
-    'varying vec2 vPixcoord;',
+    varying vec2 vUv;
+    varying vec4 vOffset[ 3 ];
+    varying vec2 vPixcoord;
 
-    'void SMAABlendingWeightCalculationVS( vec2 texcoord ) {',
-    '	vPixcoord = texcoord / resolution;',
+    void SMAABlendingWeightCalculationVS( vec2 texcoord ) {
+    	vPixcoord = texcoord / resolution;
 
     // We will use these offsets for the searches later on (see @PSEUDO_GATHER4):
-    '	vOffset[ 0 ] = texcoord.xyxy + resolution.xyxy * vec4( -0.25, 0.125, 1.25, 0.125 );', // WebGL port note: Changed sign in Y and W components
-    '	vOffset[ 1 ] = texcoord.xyxy + resolution.xyxy * vec4( -0.125, 0.25, -0.125, -1.25 );', // WebGL port note: Changed sign in Y and W components
+    	vOffset[ 0 ] = texcoord.xyxy + resolution.xyxy * vec4( -0.25, 0.125, 1.25, 0.125 ); // WebGL port note: Changed sign in Y and W components
+    	vOffset[ 1 ] = texcoord.xyxy + resolution.xyxy * vec4( -0.125, 0.25, -0.125, -1.25 ); // WebGL port note: Changed sign in Y and W components
 
     // And these for the searches, they indicate the ends of the loops:
-    '	vOffset[ 2 ] = vec4( vOffset[ 0 ].xz, vOffset[ 1 ].yw ) + vec4( -2.0, 2.0, -2.0, 2.0 ) * resolution.xxyy * float( SMAA_MAX_SEARCH_STEPS );',
+    	vOffset[ 2 ] = vec4( vOffset[ 0 ].xz, vOffset[ 1 ].yw ) + vec4( -2.0, 2.0, -2.0, 2.0 ) * resolution.xxyy * float( SMAA_MAX_SEARCH_STEPS );
 
-    '}',
+    }
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
+    	vUv = uv;
 
-    '	SMAABlendingWeightCalculationVS( vUv );',
+    	SMAABlendingWeightCalculationVS( vUv );
 
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    '#define SMAASampleLevelZeroOffset( tex, coord, offset ) texture2D( tex, coord + float( offset ) * resolution, 0.0 )',
+  fragmentShader: /* glsl */ `
+    #define SMAASampleLevelZeroOffset( tex, coord, offset ) texture2D( tex, coord + float( offset ) * resolution, 0.0 )
 
-    'uniform sampler2D tDiffuse;',
-    'uniform sampler2D tArea;',
-    'uniform sampler2D tSearch;',
-    'uniform vec2 resolution;',
+    uniform sampler2D tDiffuse;
+    uniform sampler2D tArea;
+    uniform sampler2D tSearch;
+    uniform vec2 resolution;
 
-    'varying vec2 vUv;',
-    'varying vec4 vOffset[3];',
-    'varying vec2 vPixcoord;',
+    varying vec2 vUv;
+    varying vec4 vOffset[3];
+    varying vec2 vPixcoord;
 
-    '#if __VERSION__ == 100',
-    'vec2 round( vec2 x ) {',
-    '	return sign( x ) * floor( abs( x ) + 0.5 );',
-    '}',
-    '#endif',
+    #if __VERSION__ == 100
+    vec2 round( vec2 x ) {
+    	return sign( x ) * floor( abs( x ) + 0.5 );
+    }
+    #endif
 
-    'float SMAASearchLength( sampler2D searchTex, vec2 e, float bias, float scale ) {',
+    float SMAASearchLength( sampler2D searchTex, vec2 e, float bias, float scale ) {
     // Not required if searchTex accesses are set to point:
     // float2 SEARCH_TEX_PIXEL_SIZE = 1.0 / float2(66.0, 33.0);
     // e = float2(bias, 0.0) + 0.5 * SEARCH_TEX_PIXEL_SIZE +
     //     e * float2(scale, 1.0) * float2(64.0, 32.0) * SEARCH_TEX_PIXEL_SIZE;
-    '	e.r = bias + e.r * scale;',
-    '	return 255.0 * texture2D( searchTex, e, 0.0 ).r;',
-    '}',
+    	e.r = bias + e.r * scale;
+    	return 255.0 * texture2D( searchTex, e, 0.0 ).r;
+    }
 
-    'float SMAASearchXLeft( sampler2D edgesTex, sampler2D searchTex, vec2 texcoord, float end ) {',
+    float SMAASearchXLeft( sampler2D edgesTex, sampler2D searchTex, vec2 texcoord, float end ) {
     /**
      * @PSEUDO_GATHER4
      * This texcoord has been offset by (-0.25, -0.125) in the vertex shader to
@@ -185,256 +185,256 @@ export const SMAAWeightsShader = {
      * Sampling with different offsets in each direction allows to disambiguate
      * which edges are active from the four fetched ones.
      */
-    '	vec2 e = vec2( 0.0, 1.0 );',
+    	vec2 e = vec2( 0.0, 1.0 );
 
-    '	for ( int i = 0; i < SMAA_MAX_SEARCH_STEPS; i ++ ) {', // WebGL port note: Changed while to for
-    '		e = texture2D( edgesTex, texcoord, 0.0 ).rg;',
-    '		texcoord -= vec2( 2.0, 0.0 ) * resolution;',
-    '		if ( ! ( texcoord.x > end && e.g > 0.8281 && e.r == 0.0 ) ) break;',
-    '	}',
+    	for ( int i = 0; i < SMAA_MAX_SEARCH_STEPS; i ++ ) { // WebGL port note: Changed while to for
+    		e = texture2D( edgesTex, texcoord, 0.0 ).rg;
+    		texcoord -= vec2( 2.0, 0.0 ) * resolution;
+    		if ( ! ( texcoord.x > end && e.g > 0.8281 && e.r == 0.0 ) ) break;
+    	}
 
     // We correct the previous (-0.25, -0.125) offset we applied:
-    '	texcoord.x += 0.25 * resolution.x;',
+    	texcoord.x += 0.25 * resolution.x;
 
     // The searches are bias by 1, so adjust the coords accordingly:
-    '	texcoord.x += resolution.x;',
+    	texcoord.x += resolution.x;
 
     // Disambiguate the length added by the last step:
-    '	texcoord.x += 2.0 * resolution.x;', // Undo last step
-    '	texcoord.x -= resolution.x * SMAASearchLength(searchTex, e, 0.0, 0.5);',
+    	texcoord.x += 2.0 * resolution.x; // Undo last step
+    	texcoord.x -= resolution.x * SMAASearchLength(searchTex, e, 0.0, 0.5);
 
-    '	return texcoord.x;',
-    '}',
+    	return texcoord.x;
+    }
 
-    'float SMAASearchXRight( sampler2D edgesTex, sampler2D searchTex, vec2 texcoord, float end ) {',
-    '	vec2 e = vec2( 0.0, 1.0 );',
+    float SMAASearchXRight( sampler2D edgesTex, sampler2D searchTex, vec2 texcoord, float end ) {
+    	vec2 e = vec2( 0.0, 1.0 );
 
-    '	for ( int i = 0; i < SMAA_MAX_SEARCH_STEPS; i ++ ) {', // WebGL port note: Changed while to for
-    '		e = texture2D( edgesTex, texcoord, 0.0 ).rg;',
-    '		texcoord += vec2( 2.0, 0.0 ) * resolution;',
-    '		if ( ! ( texcoord.x < end && e.g > 0.8281 && e.r == 0.0 ) ) break;',
-    '	}',
+    	for ( int i = 0; i < SMAA_MAX_SEARCH_STEPS; i ++ ) { // WebGL port note: Changed while to for
+    		e = texture2D( edgesTex, texcoord, 0.0 ).rg;
+    		texcoord += vec2( 2.0, 0.0 ) * resolution;
+    		if ( ! ( texcoord.x < end && e.g > 0.8281 && e.r == 0.0 ) ) break;
+    	}
 
-    '	texcoord.x -= 0.25 * resolution.x;',
-    '	texcoord.x -= resolution.x;',
-    '	texcoord.x -= 2.0 * resolution.x;',
-    '	texcoord.x += resolution.x * SMAASearchLength( searchTex, e, 0.5, 0.5 );',
+    	texcoord.x -= 0.25 * resolution.x;
+    	texcoord.x -= resolution.x;
+    	texcoord.x -= 2.0 * resolution.x;
+    	texcoord.x += resolution.x * SMAASearchLength( searchTex, e, 0.5, 0.5 );
 
-    '	return texcoord.x;',
-    '}',
+    	return texcoord.x;
+    }
 
-    'float SMAASearchYUp( sampler2D edgesTex, sampler2D searchTex, vec2 texcoord, float end ) {',
-    '	vec2 e = vec2( 1.0, 0.0 );',
+    float SMAASearchYUp( sampler2D edgesTex, sampler2D searchTex, vec2 texcoord, float end ) {
+    	vec2 e = vec2( 1.0, 0.0 );
 
-    '	for ( int i = 0; i < SMAA_MAX_SEARCH_STEPS; i ++ ) {', // WebGL port note: Changed while to for
-    '		e = texture2D( edgesTex, texcoord, 0.0 ).rg;',
-    '		texcoord += vec2( 0.0, 2.0 ) * resolution;', // WebGL port note: Changed sign
-    '		if ( ! ( texcoord.y > end && e.r > 0.8281 && e.g == 0.0 ) ) break;',
-    '	}',
+    	for ( int i = 0; i < SMAA_MAX_SEARCH_STEPS; i ++ ) { // WebGL port note: Changed while to for
+    		e = texture2D( edgesTex, texcoord, 0.0 ).rg;
+    		texcoord += vec2( 0.0, 2.0 ) * resolution; // WebGL port note: Changed sign
+    		if ( ! ( texcoord.y > end && e.r > 0.8281 && e.g == 0.0 ) ) break;
+    	}
 
-    '	texcoord.y -= 0.25 * resolution.y;', // WebGL port note: Changed sign
-    '	texcoord.y -= resolution.y;', // WebGL port note: Changed sign
-    '	texcoord.y -= 2.0 * resolution.y;', // WebGL port note: Changed sign
-    '	texcoord.y += resolution.y * SMAASearchLength( searchTex, e.gr, 0.0, 0.5 );', // WebGL port note: Changed sign
+    	texcoord.y -= 0.25 * resolution.y; // WebGL port note: Changed sign
+    	texcoord.y -= resolution.y; // WebGL port note: Changed sign
+    	texcoord.y -= 2.0 * resolution.y; // WebGL port note: Changed sign
+    	texcoord.y += resolution.y * SMAASearchLength( searchTex, e.gr, 0.0, 0.5 ); // WebGL port note: Changed sign
 
-    '	return texcoord.y;',
-    '}',
+    	return texcoord.y;
+    }
 
-    'float SMAASearchYDown( sampler2D edgesTex, sampler2D searchTex, vec2 texcoord, float end ) {',
-    '	vec2 e = vec2( 1.0, 0.0 );',
+    float SMAASearchYDown( sampler2D edgesTex, sampler2D searchTex, vec2 texcoord, float end ) {
+    	vec2 e = vec2( 1.0, 0.0 );
 
-    '	for ( int i = 0; i < SMAA_MAX_SEARCH_STEPS; i ++ ) {', // WebGL port note: Changed while to for
-    '		e = texture2D( edgesTex, texcoord, 0.0 ).rg;',
-    '		texcoord -= vec2( 0.0, 2.0 ) * resolution;', // WebGL port note: Changed sign
-    '		if ( ! ( texcoord.y < end && e.r > 0.8281 && e.g == 0.0 ) ) break;',
-    '	}',
+    	for ( int i = 0; i < SMAA_MAX_SEARCH_STEPS; i ++ ) { // WebGL port note: Changed while to for
+    		e = texture2D( edgesTex, texcoord, 0.0 ).rg;
+    		texcoord -= vec2( 0.0, 2.0 ) * resolution; // WebGL port note: Changed sign
+    		if ( ! ( texcoord.y < end && e.r > 0.8281 && e.g == 0.0 ) ) break;
+    	}
 
-    '	texcoord.y += 0.25 * resolution.y;', // WebGL port note: Changed sign
-    '	texcoord.y += resolution.y;', // WebGL port note: Changed sign
-    '	texcoord.y += 2.0 * resolution.y;', // WebGL port note: Changed sign
-    '	texcoord.y -= resolution.y * SMAASearchLength( searchTex, e.gr, 0.5, 0.5 );', // WebGL port note: Changed sign
+    	texcoord.y += 0.25 * resolution.y; // WebGL port note: Changed sign
+    	texcoord.y += resolution.y; // WebGL port note: Changed sign
+    	texcoord.y += 2.0 * resolution.y; // WebGL port note: Changed sign
+    	texcoord.y -= resolution.y * SMAASearchLength( searchTex, e.gr, 0.5, 0.5 ); // WebGL port note: Changed sign
 
-    '	return texcoord.y;',
-    '}',
+    	return texcoord.y;
+    }
 
-    'vec2 SMAAArea( sampler2D areaTex, vec2 dist, float e1, float e2, float offset ) {',
+    vec2 SMAAArea( sampler2D areaTex, vec2 dist, float e1, float e2, float offset ) {
     // Rounding prevents precision errors of bilinear filtering:
-    '	vec2 texcoord = float( SMAA_AREATEX_MAX_DISTANCE ) * round( 4.0 * vec2( e1, e2 ) ) + dist;',
+    	vec2 texcoord = float( SMAA_AREATEX_MAX_DISTANCE ) * round( 4.0 * vec2( e1, e2 ) ) + dist;
 
     // We do a scale and bias for mapping to texel space:
-    '	texcoord = SMAA_AREATEX_PIXEL_SIZE * texcoord + ( 0.5 * SMAA_AREATEX_PIXEL_SIZE );',
+    	texcoord = SMAA_AREATEX_PIXEL_SIZE * texcoord + ( 0.5 * SMAA_AREATEX_PIXEL_SIZE );
 
     // Move to proper place, according to the subpixel offset:
-    '	texcoord.y += SMAA_AREATEX_SUBTEX_SIZE * offset;',
+    	texcoord.y += SMAA_AREATEX_SUBTEX_SIZE * offset;
 
-    '	return texture2D( areaTex, texcoord, 0.0 ).rg;',
-    '}',
+    	return texture2D( areaTex, texcoord, 0.0 ).rg;
+    }
 
-    'vec4 SMAABlendingWeightCalculationPS( vec2 texcoord, vec2 pixcoord, vec4 offset[ 3 ], sampler2D edgesTex, sampler2D areaTex, sampler2D searchTex, ivec4 subsampleIndices ) {',
-    '	vec4 weights = vec4( 0.0, 0.0, 0.0, 0.0 );',
+    vec4 SMAABlendingWeightCalculationPS( vec2 texcoord, vec2 pixcoord, vec4 offset[ 3 ], sampler2D edgesTex, sampler2D areaTex, sampler2D searchTex, ivec4 subsampleIndices ) {
+    	vec4 weights = vec4( 0.0, 0.0, 0.0, 0.0 );
 
-    '	vec2 e = texture2D( edgesTex, texcoord ).rg;',
+    	vec2 e = texture2D( edgesTex, texcoord ).rg;
 
-    '	if ( e.g > 0.0 ) {', // Edge at north
-    '		vec2 d;',
+    	if ( e.g > 0.0 ) { // Edge at north
+    		vec2 d;
 
     // Find the distance to the left:
-    '		vec2 coords;',
-    '		coords.x = SMAASearchXLeft( edgesTex, searchTex, offset[ 0 ].xy, offset[ 2 ].x );',
-    '		coords.y = offset[ 1 ].y;', // offset[1].y = texcoord.y - 0.25 * resolution.y (@CROSSING_OFFSET)
-    '		d.x = coords.x;',
+    		vec2 coords;
+    		coords.x = SMAASearchXLeft( edgesTex, searchTex, offset[ 0 ].xy, offset[ 2 ].x );
+    		coords.y = offset[ 1 ].y; // offset[1].y = texcoord.y - 0.25 * resolution.y (@CROSSING_OFFSET)
+    		d.x = coords.x;
 
     // Now fetch the left crossing edges, two at a time using bilinear
     // filtering. Sampling at -0.25 (see @CROSSING_OFFSET) enables to
     // discern what value each edge has:
-    '		float e1 = texture2D( edgesTex, coords, 0.0 ).r;',
+    		float e1 = texture2D( edgesTex, coords, 0.0 ).r;
 
     // Find the distance to the right:
-    '		coords.x = SMAASearchXRight( edgesTex, searchTex, offset[ 0 ].zw, offset[ 2 ].y );',
-    '		d.y = coords.x;',
+    		coords.x = SMAASearchXRight( edgesTex, searchTex, offset[ 0 ].zw, offset[ 2 ].y );
+    		d.y = coords.x;
 
     // We want the distances to be in pixel units (doing this here allow to
     // better interleave arithmetic and memory accesses):
-    '		d = d / resolution.x - pixcoord.x;',
+    		d = d / resolution.x - pixcoord.x;
 
     // SMAAArea below needs a sqrt, as the areas texture is compressed
     // quadratically:
-    '		vec2 sqrt_d = sqrt( abs( d ) );',
+    		vec2 sqrt_d = sqrt( abs( d ) );
 
     // Fetch the right crossing edges:
-    '		coords.y -= 1.0 * resolution.y;', // WebGL port note: Added
-    '		float e2 = SMAASampleLevelZeroOffset( edgesTex, coords, ivec2( 1, 0 ) ).r;',
+    		coords.y -= 1.0 * resolution.y; // WebGL port note: Added
+    		float e2 = SMAASampleLevelZeroOffset( edgesTex, coords, ivec2( 1, 0 ) ).r;
 
     // Ok, we know how this pattern looks like, now it is time for getting
     // the actual area:
-    '		weights.rg = SMAAArea( areaTex, sqrt_d, e1, e2, float( subsampleIndices.y ) );',
-    '	}',
+    		weights.rg = SMAAArea( areaTex, sqrt_d, e1, e2, float( subsampleIndices.y ) );
+    	}
 
-    '	if ( e.r > 0.0 ) {', // Edge at west
-    '		vec2 d;',
+    	if ( e.r > 0.0 ) { // Edge at west
+    		vec2 d;
 
     // Find the distance to the top:
-    '		vec2 coords;',
+    		vec2 coords;
 
-    '		coords.y = SMAASearchYUp( edgesTex, searchTex, offset[ 1 ].xy, offset[ 2 ].z );',
-    '		coords.x = offset[ 0 ].x;', // offset[1].x = texcoord.x - 0.25 * resolution.x;
-    '		d.x = coords.y;',
+    		coords.y = SMAASearchYUp( edgesTex, searchTex, offset[ 1 ].xy, offset[ 2 ].z );
+    		coords.x = offset[ 0 ].x; // offset[1].x = texcoord.x - 0.25 * resolution.x;
+    		d.x = coords.y;
 
     // Fetch the top crossing edges:
-    '		float e1 = texture2D( edgesTex, coords, 0.0 ).g;',
+    		float e1 = texture2D( edgesTex, coords, 0.0 ).g;
 
     // Find the distance to the bottom:
-    '		coords.y = SMAASearchYDown( edgesTex, searchTex, offset[ 1 ].zw, offset[ 2 ].w );',
-    '		d.y = coords.y;',
+    		coords.y = SMAASearchYDown( edgesTex, searchTex, offset[ 1 ].zw, offset[ 2 ].w );
+    		d.y = coords.y;
 
     // We want the distances to be in pixel units:
-    '		d = d / resolution.y - pixcoord.y;',
+    		d = d / resolution.y - pixcoord.y;
 
     // SMAAArea below needs a sqrt, as the areas texture is compressed
     // quadratically:
-    '		vec2 sqrt_d = sqrt( abs( d ) );',
+    		vec2 sqrt_d = sqrt( abs( d ) );
 
     // Fetch the bottom crossing edges:
-    '		coords.y -= 1.0 * resolution.y;', // WebGL port note: Added
-    '		float e2 = SMAASampleLevelZeroOffset( edgesTex, coords, ivec2( 0, 1 ) ).g;',
+    		coords.y -= 1.0 * resolution.y; // WebGL port note: Added
+    		float e2 = SMAASampleLevelZeroOffset( edgesTex, coords, ivec2( 0, 1 ) ).g;
 
     // Get the area for this direction:
-    '		weights.ba = SMAAArea( areaTex, sqrt_d, e1, e2, float( subsampleIndices.x ) );',
-    '	}',
+    		weights.ba = SMAAArea( areaTex, sqrt_d, e1, e2, float( subsampleIndices.x ) );
+    	}
 
-    '	return weights;',
-    '}',
+    	return weights;
+    }
 
-    'void main() {',
+    void main() {
 
-    '	gl_FragColor = SMAABlendingWeightCalculationPS( vUv, vPixcoord, vOffset, tDiffuse, tArea, tSearch, ivec4( 0.0 ) );',
+    	gl_FragColor = SMAABlendingWeightCalculationPS( vUv, vPixcoord, vOffset, tDiffuse, tArea, tSearch, ivec4( 0.0 ) );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
 
 export const SMAABlendShader = {
   uniforms: {
     tDiffuse: { value: null },
     tColor: { value: null },
-    resolution: { value: new Vector2(1 / 1024, 1 / 512) },
+    resolution: { value: /* @__PURE__ */ new Vector2(1 / 1024, 1 / 512) },
   },
 
-  vertexShader: [
-    'uniform vec2 resolution;',
+  vertexShader: /* glsl */ `
+    uniform vec2 resolution;
 
-    'varying vec2 vUv;',
-    'varying vec4 vOffset[ 2 ];',
+    varying vec2 vUv;
+    varying vec4 vOffset[ 2 ];
 
-    'void SMAANeighborhoodBlendingVS( vec2 texcoord ) {',
-    '	vOffset[ 0 ] = texcoord.xyxy + resolution.xyxy * vec4( -1.0, 0.0, 0.0, 1.0 );', // WebGL port note: Changed sign in W component
-    '	vOffset[ 1 ] = texcoord.xyxy + resolution.xyxy * vec4( 1.0, 0.0, 0.0, -1.0 );', // WebGL port note: Changed sign in W component
-    '}',
+    void SMAANeighborhoodBlendingVS( vec2 texcoord ) {
+    	vOffset[ 0 ] = texcoord.xyxy + resolution.xyxy * vec4( -1.0, 0.0, 0.0, 1.0 ); // WebGL port note: Changed sign in W component
+    	vOffset[ 1 ] = texcoord.xyxy + resolution.xyxy * vec4( 1.0, 0.0, 0.0, -1.0 ); // WebGL port note: Changed sign in W component
+    }
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
+    	vUv = uv;
 
-    '	SMAANeighborhoodBlendingVS( vUv );',
+    	SMAANeighborhoodBlendingVS( vUv );
 
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform sampler2D tDiffuse;',
-    'uniform sampler2D tColor;',
-    'uniform vec2 resolution;',
+  fragmentShader: /* glsl */ `
+    uniform sampler2D tDiffuse;
+    uniform sampler2D tColor;
+    uniform vec2 resolution;
 
-    'varying vec2 vUv;',
-    'varying vec4 vOffset[ 2 ];',
+    varying vec2 vUv;
+    varying vec4 vOffset[ 2 ];
 
-    'vec4 SMAANeighborhoodBlendingPS( vec2 texcoord, vec4 offset[ 2 ], sampler2D colorTex, sampler2D blendTex ) {',
+    vec4 SMAANeighborhoodBlendingPS( vec2 texcoord, vec4 offset[ 2 ], sampler2D colorTex, sampler2D blendTex ) {
     // Fetch the blending weights for current pixel:
-    '	vec4 a;',
-    '	a.xz = texture2D( blendTex, texcoord ).xz;',
-    '	a.y = texture2D( blendTex, offset[ 1 ].zw ).g;',
-    '	a.w = texture2D( blendTex, offset[ 1 ].xy ).a;',
+    	vec4 a;
+    	a.xz = texture2D( blendTex, texcoord ).xz;
+    	a.y = texture2D( blendTex, offset[ 1 ].zw ).g;
+    	a.w = texture2D( blendTex, offset[ 1 ].xy ).a;
 
     // Is there any blending weight with a value greater than 0.0?
-    '	if ( dot(a, vec4( 1.0, 1.0, 1.0, 1.0 )) < 1e-5 ) {',
-    '		return texture2D( colorTex, texcoord, 0.0 );',
-    '	} else {',
+    	if ( dot(a, vec4( 1.0, 1.0, 1.0, 1.0 )) < 1e-5 ) {
+    		return texture2D( colorTex, texcoord, 0.0 );
+    	} else {
     // Up to 4 lines can be crossing a pixel (one through each edge). We
     // favor blending by choosing the line with the maximum weight for each
     // direction:
-    '		vec2 offset;',
-    '		offset.x = a.a > a.b ? a.a : -a.b;', // left vs. right
-    '		offset.y = a.g > a.r ? -a.g : a.r;', // top vs. bottom // WebGL port note: Changed signs
+    		vec2 offset;
+    		offset.x = a.a > a.b ? a.a : -a.b; // left vs. right
+    		offset.y = a.g > a.r ? -a.g : a.r; // top vs. bottom // WebGL port note: Changed signs
 
     // Then we go in the direction that has the maximum weight:
-    '		if ( abs( offset.x ) > abs( offset.y )) {', // horizontal vs. vertical
-    '			offset.y = 0.0;',
-    '		} else {',
-    '			offset.x = 0.0;',
-    '		}',
+    		if ( abs( offset.x ) > abs( offset.y )) { // horizontal vs. vertical
+    			offset.y = 0.0;
+    		} else {
+    			offset.x = 0.0;
+    		}
 
     // Fetch the opposite color and lerp by hand:
-    '		vec4 C = texture2D( colorTex, texcoord, 0.0 );',
-    '		texcoord += sign( offset ) * resolution;',
-    '		vec4 Cop = texture2D( colorTex, texcoord, 0.0 );',
-    '		float s = abs( offset.x ) > abs( offset.y ) ? abs( offset.x ) : abs( offset.y );',
+    		vec4 C = texture2D( colorTex, texcoord, 0.0 );
+    		texcoord += sign( offset ) * resolution;
+    		vec4 Cop = texture2D( colorTex, texcoord, 0.0 );
+    		float s = abs( offset.x ) > abs( offset.y ) ? abs( offset.x ) : abs( offset.y );
 
     // WebGL port note: Added gamma correction
-    '		C.xyz = pow(C.xyz, vec3(2.2));',
-    '		Cop.xyz = pow(Cop.xyz, vec3(2.2));',
-    '		vec4 mixed = mix(C, Cop, s);',
-    '		mixed.xyz = pow(mixed.xyz, vec3(1.0 / 2.2));',
+    		C.xyz = pow(C.xyz, vec3(2.2));
+    		Cop.xyz = pow(Cop.xyz, vec3(2.2));
+    		vec4 mixed = mix(C, Cop, s);
+    		mixed.xyz = pow(mixed.xyz, vec3(1.0 / 2.2));
 
-    '		return mixed;',
-    '	}',
-    '}',
+    		return mixed;
+    	}
+    }
 
-    'void main() {',
+    void main() {
 
-    '	gl_FragColor = SMAANeighborhoodBlendingPS( vUv, vOffset, tColor, tDiffuse );',
+    	gl_FragColor = SMAANeighborhoodBlendingPS( vUv, vOffset, tColor, tDiffuse );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/SSAOShader.ts b/src/shaders/SSAOShader.ts
index 98475a18..e5d17aef 100644
--- a/src/shaders/SSAOShader.ts
+++ b/src/shaders/SSAOShader.ts
@@ -21,150 +21,150 @@ export const SSAOShader = {
     kernel: { value: null },
     cameraNear: { value: null },
     cameraFar: { value: null },
-    resolution: { value: new Vector2() },
-    cameraProjectionMatrix: { value: new Matrix4() },
-    cameraInverseProjectionMatrix: { value: new Matrix4() },
+    resolution: { value: /* @__PURE__ */ new Vector2() },
+    cameraProjectionMatrix: { value: /* @__PURE__ */ new Matrix4() },
+    cameraInverseProjectionMatrix: { value: /* @__PURE__ */ new Matrix4() },
     kernelRadius: { value: 8 },
     minDistance: { value: 0.005 },
     maxDistance: { value: 0.05 },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
+    	vUv = uv;
 
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform sampler2D tDiffuse;',
-    'uniform sampler2D tNormal;',
-    'uniform sampler2D tDepth;',
-    'uniform sampler2D tNoise;',
+  fragmentShader: /* glsl */ `
+    uniform sampler2D tDiffuse;
+    uniform sampler2D tNormal;
+    uniform sampler2D tDepth;
+    uniform sampler2D tNoise;
 
-    'uniform vec3 kernel[ KERNEL_SIZE ];',
+    uniform vec3 kernel[ KERNEL_SIZE ];
 
-    'uniform vec2 resolution;',
+    uniform vec2 resolution;
 
-    'uniform float cameraNear;',
-    'uniform float cameraFar;',
-    'uniform mat4 cameraProjectionMatrix;',
-    'uniform mat4 cameraInverseProjectionMatrix;',
+    uniform float cameraNear;
+    uniform float cameraFar;
+    uniform mat4 cameraProjectionMatrix;
+    uniform mat4 cameraInverseProjectionMatrix;
 
-    'uniform float kernelRadius;',
-    'uniform float minDistance;', // avoid artifacts caused by neighbour fragments with minimal depth difference
-    'uniform float maxDistance;', // avoid the influence of fragments which are too far away
+    uniform float kernelRadius;
+    uniform float minDistance; // avoid artifacts caused by neighbour fragments with minimal depth difference
+    uniform float maxDistance; // avoid the influence of fragments which are too far away
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    '#include <packing>',
+    #include <packing>
 
-    'float getDepth( const in vec2 screenPosition ) {',
+    float getDepth( const in vec2 screenPosition ) {
 
-    '	return texture2D( tDepth, screenPosition ).x;',
+    	return texture2D( tDepth, screenPosition ).x;
 
-    '}',
+    }
 
-    'float getLinearDepth( const in vec2 screenPosition ) {',
+    float getLinearDepth( const in vec2 screenPosition ) {
 
-    '	#if PERSPECTIVE_CAMERA == 1',
+    	#if PERSPECTIVE_CAMERA == 1
 
-    '		float fragCoordZ = texture2D( tDepth, screenPosition ).x;',
-    '		float viewZ = perspectiveDepthToViewZ( fragCoordZ, cameraNear, cameraFar );',
-    '		return viewZToOrthographicDepth( viewZ, cameraNear, cameraFar );',
+    		float fragCoordZ = texture2D( tDepth, screenPosition ).x;
+    		float viewZ = perspectiveDepthToViewZ( fragCoordZ, cameraNear, cameraFar );
+    		return viewZToOrthographicDepth( viewZ, cameraNear, cameraFar );
 
-    '	#else',
+    	#else
 
-    '		return texture2D( tDepth, screenPosition ).x;',
+    		return texture2D( tDepth, screenPosition ).x;
 
-    '	#endif',
+    	#endif
 
-    '}',
+    }
 
-    'float getViewZ( const in float depth ) {',
+    float getViewZ( const in float depth ) {
 
-    '	#if PERSPECTIVE_CAMERA == 1',
+    	#if PERSPECTIVE_CAMERA == 1
 
-    '		return perspectiveDepthToViewZ( depth, cameraNear, cameraFar );',
+    		return perspectiveDepthToViewZ( depth, cameraNear, cameraFar );
 
-    '	#else',
+    	#else
 
-    '		return orthographicDepthToViewZ( depth, cameraNear, cameraFar );',
+    		return orthographicDepthToViewZ( depth, cameraNear, cameraFar );
 
-    '	#endif',
+    	#endif
 
-    '}',
+    }
 
-    'vec3 getViewPosition( const in vec2 screenPosition, const in float depth, const in float viewZ ) {',
+    vec3 getViewPosition( const in vec2 screenPosition, const in float depth, const in float viewZ ) {
 
-    '	float clipW = cameraProjectionMatrix[2][3] * viewZ + cameraProjectionMatrix[3][3];',
+    	float clipW = cameraProjectionMatrix[2][3] * viewZ + cameraProjectionMatrix[3][3];
 
-    '	vec4 clipPosition = vec4( ( vec3( screenPosition, depth ) - 0.5 ) * 2.0, 1.0 );',
+    	vec4 clipPosition = vec4( ( vec3( screenPosition, depth ) - 0.5 ) * 2.0, 1.0 );
 
-    '	clipPosition *= clipW; // unprojection.',
+    	clipPosition *= clipW; // unprojection.
 
-    '	return ( cameraInverseProjectionMatrix * clipPosition ).xyz;',
+    	return ( cameraInverseProjectionMatrix * clipPosition ).xyz;
 
-    '}',
+    }
 
-    'vec3 getViewNormal( const in vec2 screenPosition ) {',
+    vec3 getViewNormal( const in vec2 screenPosition ) {
 
-    '	return unpackRGBToNormal( texture2D( tNormal, screenPosition ).xyz );',
+    	return unpackRGBToNormal( texture2D( tNormal, screenPosition ).xyz );
 
-    '}',
+    }
 
-    'void main() {',
+    void main() {
 
-    '	float depth = getDepth( vUv );',
-    '	float viewZ = getViewZ( depth );',
+    	float depth = getDepth( vUv );
+    	float viewZ = getViewZ( depth );
 
-    '	vec3 viewPosition = getViewPosition( vUv, depth, viewZ );',
-    '	vec3 viewNormal = getViewNormal( vUv );',
+    	vec3 viewPosition = getViewPosition( vUv, depth, viewZ );
+    	vec3 viewNormal = getViewNormal( vUv );
 
-    ' vec2 noiseScale = vec2( resolution.x / 4.0, resolution.y / 4.0 );',
-    '	vec3 random = texture2D( tNoise, vUv * noiseScale ).xyz;',
+     vec2 noiseScale = vec2( resolution.x / 4.0, resolution.y / 4.0 );
+    	vec3 random = texture2D( tNoise, vUv * noiseScale ).xyz;
 
     // compute matrix used to reorient a kernel vector
 
-    '	vec3 tangent = normalize( random - viewNormal * dot( random, viewNormal ) );',
-    '	vec3 bitangent = cross( viewNormal, tangent );',
-    '	mat3 kernelMatrix = mat3( tangent, bitangent, viewNormal );',
+    	vec3 tangent = normalize( random - viewNormal * dot( random, viewNormal ) );
+    	vec3 bitangent = cross( viewNormal, tangent );
+    	mat3 kernelMatrix = mat3( tangent, bitangent, viewNormal );
 
-    ' float occlusion = 0.0;',
+     float occlusion = 0.0;
 
-    ' for ( int i = 0; i < KERNEL_SIZE; i ++ ) {',
+     for ( int i = 0; i < KERNEL_SIZE; i ++ ) {
 
-    '		vec3 sampleVector = kernelMatrix * kernel[ i ];', // reorient sample vector in view space
-    '		vec3 samplePoint = viewPosition + ( sampleVector * kernelRadius );', // calculate sample point
+    		vec3 sampleVector = kernelMatrix * kernel[ i ]; // reorient sample vector in view space
+    		vec3 samplePoint = viewPosition + ( sampleVector * kernelRadius ); // calculate sample point
 
-    '		vec4 samplePointNDC = cameraProjectionMatrix * vec4( samplePoint, 1.0 );', // project point and calculate NDC
-    '		samplePointNDC /= samplePointNDC.w;',
+    		vec4 samplePointNDC = cameraProjectionMatrix * vec4( samplePoint, 1.0 ); // project point and calculate NDC
+    		samplePointNDC /= samplePointNDC.w;
 
-    '		vec2 samplePointUv = samplePointNDC.xy * 0.5 + 0.5;', // compute uv coordinates
+    		vec2 samplePointUv = samplePointNDC.xy * 0.5 + 0.5; // compute uv coordinates
 
-    '		float realDepth = getLinearDepth( samplePointUv );', // get linear depth from depth texture
-    '		float sampleDepth = viewZToOrthographicDepth( samplePoint.z, cameraNear, cameraFar );', // compute linear depth of the sample view Z value
-    '		float delta = sampleDepth - realDepth;',
+    		float realDepth = getLinearDepth( samplePointUv ); // get linear depth from depth texture
+    		float sampleDepth = viewZToOrthographicDepth( samplePoint.z, cameraNear, cameraFar ); // compute linear depth of the sample view Z value
+    		float delta = sampleDepth - realDepth;
 
-    '		if ( delta > minDistance && delta < maxDistance ) {', // if fragment is before sample point, increase occlusion
+    		if ( delta > minDistance && delta < maxDistance ) { // if fragment is before sample point, increase occlusion
 
-    '			occlusion += 1.0;',
+    			occlusion += 1.0;
 
-    '		}',
+    		}
 
-    '	}',
+    	}
 
-    '	occlusion = clamp( occlusion / float( KERNEL_SIZE ), 0.0, 1.0 );',
+    	occlusion = clamp( occlusion / float( KERNEL_SIZE ), 0.0, 1.0 );
 
-    '	gl_FragColor = vec4( vec3( 1.0 - occlusion ), 1.0 );',
+    	gl_FragColor = vec4( vec3( 1.0 - occlusion ), 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
 
 export const SSAODepthShader = {
@@ -178,94 +178,94 @@ export const SSAODepthShader = {
     cameraFar: { value: null },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform sampler2D tDepth;',
+  fragmentShader: /* glsl */ `
+    uniform sampler2D tDepth;
 
-    'uniform float cameraNear;',
-    'uniform float cameraFar;',
+    uniform float cameraNear;
+    uniform float cameraFar;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    '#include <packing>',
+    #include <packing>
 
-    'float getLinearDepth( const in vec2 screenPosition ) {',
+    float getLinearDepth( const in vec2 screenPosition ) {
 
-    '	#if PERSPECTIVE_CAMERA == 1',
+    	#if PERSPECTIVE_CAMERA == 1
 
-    '		float fragCoordZ = texture2D( tDepth, screenPosition ).x;',
-    '		float viewZ = perspectiveDepthToViewZ( fragCoordZ, cameraNear, cameraFar );',
-    '		return viewZToOrthographicDepth( viewZ, cameraNear, cameraFar );',
+    		float fragCoordZ = texture2D( tDepth, screenPosition ).x;
+    		float viewZ = perspectiveDepthToViewZ( fragCoordZ, cameraNear, cameraFar );
+    		return viewZToOrthographicDepth( viewZ, cameraNear, cameraFar );
 
-    '	#else',
+    	#else
 
-    '		return texture2D( tDepth, screenPosition ).x;',
+    		return texture2D( tDepth, screenPosition ).x;
 
-    '	#endif',
+    	#endif
 
-    '}',
+    }
 
-    'void main() {',
+    void main() {
 
-    '	float depth = getLinearDepth( vUv );',
-    '	gl_FragColor = vec4( vec3( 1.0 - depth ), 1.0 );',
+    	float depth = getLinearDepth( vUv );
+    	gl_FragColor = vec4( vec3( 1.0 - depth ), 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
 
 export const SSAOBlurShader = {
   uniforms: {
     tDiffuse: { value: null },
-    resolution: { value: new Vector2() },
+    resolution: { value: /* @__PURE__ */ new Vector2() },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform sampler2D tDiffuse;',
+  fragmentShader: /* glsl */ `
+    uniform sampler2D tDiffuse;
 
-    'uniform vec2 resolution;',
+    uniform vec2 resolution;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vec2 texelSize = ( 1.0 / resolution );',
-    '	float result = 0.0;',
+    	vec2 texelSize = ( 1.0 / resolution );
+    	float result = 0.0;
 
-    '	for ( int i = - 2; i <= 2; i ++ ) {',
+    	for ( int i = - 2; i <= 2; i ++ ) {
 
-    '		for ( int j = - 2; j <= 2; j ++ ) {',
+    		for ( int j = - 2; j <= 2; j ++ ) {
 
-    '			vec2 offset = ( vec2( float( i ), float( j ) ) ) * texelSize;',
-    '			result += texture2D( tDiffuse, vUv + offset ).r;',
+    			vec2 offset = ( vec2( float( i ), float( j ) ) ) * texelSize;
+    			result += texture2D( tDiffuse, vUv + offset ).r;
 
-    '		}',
+    		}
 
-    '	}',
+    	}
 
-    '	gl_FragColor = vec4( vec3( result / ( 5.0 * 5.0 ) ), 1.0 );',
+    	gl_FragColor = vec4( vec3( result / ( 5.0 * 5.0 ) ), 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/SSRShader.ts b/src/shaders/SSRShader.ts
index a212b977..fe073f1f 100644
--- a/src/shaders/SSRShader.ts
+++ b/src/shaders/SSRShader.ts
@@ -21,9 +21,9 @@ export const SSRShader = {
     tDepth: { value: null },
     cameraNear: { value: null },
     cameraFar: { value: null },
-    resolution: { value: new Vector2() },
-    cameraProjectionMatrix: { value: new Matrix4() },
-    cameraInverseProjectionMatrix: { value: new Matrix4() },
+    resolution: { value: /* @__PURE__ */ new Vector2() },
+    cameraProjectionMatrix: { value: /* @__PURE__ */ new Matrix4() },
+    cameraInverseProjectionMatrix: { value: /* @__PURE__ */ new Matrix4() },
     opacity: { value: 0.5 },
     maxDistance: { value: 180 },
     cameraRange: { value: 0 },
@@ -278,7 +278,7 @@ export const SSRDepthShader = {
 export const SSRBlurShader = {
   uniforms: {
     tDiffuse: { value: null },
-    resolution: { value: new Vector2() },
+    resolution: { value: /* @__PURE__ */ new Vector2() },
     opacity: { value: 0.5 },
   },
 
diff --git a/src/shaders/SepiaShader.ts b/src/shaders/SepiaShader.ts
index fdd9f8d1..3048d490 100644
--- a/src/shaders/SepiaShader.ts
+++ b/src/shaders/SepiaShader.ts
@@ -10,35 +10,35 @@ export const SepiaShader = {
     amount: { value: 1.0 },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform float amount;',
+  fragmentShader: /* glsl */ `
+    uniform float amount;
 
-    'uniform sampler2D tDiffuse;',
+    uniform sampler2D tDiffuse;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vec4 color = texture2D( tDiffuse, vUv );',
-    '	vec3 c = color.rgb;',
+    	vec4 color = texture2D( tDiffuse, vUv );
+    	vec3 c = color.rgb;
 
-    '	color.r = dot( c, vec3( 1.0 - 0.607 * amount, 0.769 * amount, 0.189 * amount ) );',
-    '	color.g = dot( c, vec3( 0.349 * amount, 1.0 - 0.314 * amount, 0.168 * amount ) );',
-    '	color.b = dot( c, vec3( 0.272 * amount, 0.534 * amount, 1.0 - 0.869 * amount ) );',
+    	color.r = dot( c, vec3( 1.0 - 0.607 * amount, 0.769 * amount, 0.189 * amount ) );
+    	color.g = dot( c, vec3( 0.349 * amount, 1.0 - 0.314 * amount, 0.168 * amount ) );
+    	color.b = dot( c, vec3( 0.272 * amount, 0.534 * amount, 1.0 - 0.869 * amount ) );
 
-    '	gl_FragColor = vec4( min( vec3( 1.0 ), color.rgb ), color.a );',
+    	gl_FragColor = vec4( min( vec3( 1.0 ), color.rgb ), color.a );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/SobelOperatorShader.ts b/src/shaders/SobelOperatorShader.ts
index 2401781f..f88f3601 100644
--- a/src/shaders/SobelOperatorShader.ts
+++ b/src/shaders/SobelOperatorShader.ts
@@ -10,73 +10,73 @@ import { Vector2 } from 'three'
 export const SobelOperatorShader = {
   uniforms: {
     tDiffuse: { value: null },
-    resolution: { value: new Vector2() },
+    resolution: { value: /* @__PURE__ */ new Vector2() },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
+    	vUv = uv;
 
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform sampler2D tDiffuse;',
-    'uniform vec2 resolution;',
-    'varying vec2 vUv;',
+  fragmentShader: /* glsl */ `
+    uniform sampler2D tDiffuse;
+    uniform vec2 resolution;
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vec2 texel = vec2( 1.0 / resolution.x, 1.0 / resolution.y );',
+    	vec2 texel = vec2( 1.0 / resolution.x, 1.0 / resolution.y );
 
     // kernel definition (in glsl matrices are filled in column-major order)
 
-    '	const mat3 Gx = mat3( -1, -2, -1, 0, 0, 0, 1, 2, 1 );', // x direction kernel
-    '	const mat3 Gy = mat3( -1, 0, 1, -2, 0, 2, -1, 0, 1 );', // y direction kernel
+    	const mat3 Gx = mat3( -1, -2, -1, 0, 0, 0, 1, 2, 1 ); // x direction kernel
+    	const mat3 Gy = mat3( -1, 0, 1, -2, 0, 2, -1, 0, 1 ); // y direction kernel
 
     // fetch the 3x3 neighbourhood of a fragment
 
     // first column
 
-    '	float tx0y0 = texture2D( tDiffuse, vUv + texel * vec2( -1, -1 ) ).r;',
-    '	float tx0y1 = texture2D( tDiffuse, vUv + texel * vec2( -1,  0 ) ).r;',
-    '	float tx0y2 = texture2D( tDiffuse, vUv + texel * vec2( -1,  1 ) ).r;',
+    	float tx0y0 = texture2D( tDiffuse, vUv + texel * vec2( -1, -1 ) ).r;
+    	float tx0y1 = texture2D( tDiffuse, vUv + texel * vec2( -1,  0 ) ).r;
+    	float tx0y2 = texture2D( tDiffuse, vUv + texel * vec2( -1,  1 ) ).r;
 
     // second column
 
-    '	float tx1y0 = texture2D( tDiffuse, vUv + texel * vec2(  0, -1 ) ).r;',
-    '	float tx1y1 = texture2D( tDiffuse, vUv + texel * vec2(  0,  0 ) ).r;',
-    '	float tx1y2 = texture2D( tDiffuse, vUv + texel * vec2(  0,  1 ) ).r;',
+    	float tx1y0 = texture2D( tDiffuse, vUv + texel * vec2(  0, -1 ) ).r;
+    	float tx1y1 = texture2D( tDiffuse, vUv + texel * vec2(  0,  0 ) ).r;
+    	float tx1y2 = texture2D( tDiffuse, vUv + texel * vec2(  0,  1 ) ).r;
 
     // third column
 
-    '	float tx2y0 = texture2D( tDiffuse, vUv + texel * vec2(  1, -1 ) ).r;',
-    '	float tx2y1 = texture2D( tDiffuse, vUv + texel * vec2(  1,  0 ) ).r;',
-    '	float tx2y2 = texture2D( tDiffuse, vUv + texel * vec2(  1,  1 ) ).r;',
+    	float tx2y0 = texture2D( tDiffuse, vUv + texel * vec2(  1, -1 ) ).r;
+    	float tx2y1 = texture2D( tDiffuse, vUv + texel * vec2(  1,  0 ) ).r;
+    	float tx2y2 = texture2D( tDiffuse, vUv + texel * vec2(  1,  1 ) ).r;
 
     // gradient value in x direction
 
-    '	float valueGx = Gx[0][0] * tx0y0 + Gx[1][0] * tx1y0 + Gx[2][0] * tx2y0 + ',
-    '		Gx[0][1] * tx0y1 + Gx[1][1] * tx1y1 + Gx[2][1] * tx2y1 + ',
-    '		Gx[0][2] * tx0y2 + Gx[1][2] * tx1y2 + Gx[2][2] * tx2y2; ',
+    	float valueGx = Gx[0][0] * tx0y0 + Gx[1][0] * tx1y0 + Gx[2][0] * tx2y0 + 
+    		Gx[0][1] * tx0y1 + Gx[1][1] * tx1y1 + Gx[2][1] * tx2y1 + 
+    		Gx[0][2] * tx0y2 + Gx[1][2] * tx1y2 + Gx[2][2] * tx2y2; 
 
     // gradient value in y direction
 
-    '	float valueGy = Gy[0][0] * tx0y0 + Gy[1][0] * tx1y0 + Gy[2][0] * tx2y0 + ',
-    '		Gy[0][1] * tx0y1 + Gy[1][1] * tx1y1 + Gy[2][1] * tx2y1 + ',
-    '		Gy[0][2] * tx0y2 + Gy[1][2] * tx1y2 + Gy[2][2] * tx2y2; ',
+    	float valueGy = Gy[0][0] * tx0y0 + Gy[1][0] * tx1y0 + Gy[2][0] * tx2y0 + 
+    		Gy[0][1] * tx0y1 + Gy[1][1] * tx1y1 + Gy[2][1] * tx2y1 + 
+    		Gy[0][2] * tx0y2 + Gy[1][2] * tx1y2 + Gy[2][2] * tx2y2; 
 
     // magnitute of the total gradient
 
-    '	float G = sqrt( ( valueGx * valueGx ) + ( valueGy * valueGy ) );',
+    	float G = sqrt( ( valueGx * valueGx ) + ( valueGy * valueGy ) );
 
-    '	gl_FragColor = vec4( vec3( G ), 1 );',
+    	gl_FragColor = vec4( vec3( G ), 1 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/TechnicolorShader.ts b/src/shaders/TechnicolorShader.ts
index 91799c01..076bb5d0 100644
--- a/src/shaders/TechnicolorShader.ts
+++ b/src/shaders/TechnicolorShader.ts
@@ -10,28 +10,28 @@ export const TechnicolorShader = {
     tDiffuse: { value: null },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform sampler2D tDiffuse;',
-    'varying vec2 vUv;',
+  fragmentShader: /* glsl */ `
+    uniform sampler2D tDiffuse;
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vec4 tex = texture2D( tDiffuse, vec2( vUv.x, vUv.y ) );',
-    '	vec4 newTex = vec4(tex.r, (tex.g + tex.b) * .5, (tex.g + tex.b) * .5, 1.0);',
+    	vec4 tex = texture2D( tDiffuse, vec2( vUv.x, vUv.y ) );
+    	vec4 newTex = vec4(tex.r, (tex.g + tex.b) * .5, (tex.g + tex.b) * .5, 1.0);
 
-    '	gl_FragColor = newTex;',
+    	gl_FragColor = newTex;
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/ToneMapShader.ts b/src/shaders/ToneMapShader.ts
index d0c52936..c167f980 100644
--- a/src/shaders/ToneMapShader.ts
+++ b/src/shaders/ToneMapShader.ts
@@ -12,57 +12,57 @@ export const ToneMapShader = {
     middleGrey: { value: 0.6 },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    '#include <common>',
+  fragmentShader: /* glsl */ `
+    #include <common>
 
-    'uniform sampler2D tDiffuse;',
+    uniform sampler2D tDiffuse;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'uniform float middleGrey;',
-    'uniform float minLuminance;',
-    'uniform float maxLuminance;',
-    '#ifdef ADAPTED_LUMINANCE',
-    '	uniform sampler2D luminanceMap;',
-    '#else',
-    '	uniform float averageLuminance;',
-    '#endif',
+    uniform float middleGrey;
+    uniform float minLuminance;
+    uniform float maxLuminance;
+    #ifdef ADAPTED_LUMINANCE
+    	uniform sampler2D luminanceMap;
+    #else
+    	uniform float averageLuminance;
+    #endif
 
-    'vec3 ToneMap( vec3 vColor ) {',
-    '	#ifdef ADAPTED_LUMINANCE',
+    vec3 ToneMap( vec3 vColor ) {
+    	#ifdef ADAPTED_LUMINANCE
     // Get the calculated average luminance
-    '		float fLumAvg = texture2D(luminanceMap, vec2(0.5, 0.5)).r;',
-    '	#else',
-    '		float fLumAvg = averageLuminance;',
-    '	#endif',
+    		float fLumAvg = texture2D(luminanceMap, vec2(0.5, 0.5)).r;
+    	#else
+    		float fLumAvg = averageLuminance;
+    	#endif
 
     // Calculate the luminance of the current pixel
-    '	float fLumPixel = linearToRelativeLuminance( vColor );',
+    	float fLumPixel = linearToRelativeLuminance( vColor );
 
     // Apply the modified operator (Eq. 4)
-    '	float fLumScaled = (fLumPixel * middleGrey) / max( minLuminance, fLumAvg );',
+    	float fLumScaled = (fLumPixel * middleGrey) / max( minLuminance, fLumAvg );
 
-    '	float fLumCompressed = (fLumScaled * (1.0 + (fLumScaled / (maxLuminance * maxLuminance)))) / (1.0 + fLumScaled);',
-    '	return fLumCompressed * vColor;',
-    '}',
+    	float fLumCompressed = (fLumScaled * (1.0 + (fLumScaled / (maxLuminance * maxLuminance)))) / (1.0 + fLumScaled);
+    	return fLumCompressed * vColor;
+    }
 
-    'void main() {',
+    void main() {
 
-    '	vec4 texel = texture2D( tDiffuse, vUv );',
+    	vec4 texel = texture2D( tDiffuse, vUv );
 
-    '	gl_FragColor = vec4( ToneMap( texel.xyz ), texel.w );',
+    	gl_FragColor = vec4( ToneMap( texel.xyz ), texel.w );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/ToonShader.ts b/src/shaders/ToonShader.ts
index d541f81c..7909c631 100644
--- a/src/shaders/ToonShader.ts
+++ b/src/shaders/ToonShader.ts
@@ -11,287 +11,287 @@ import { Color, Vector3 } from 'three'
 
 export const ToonShader1 = {
   uniforms: {
-    uDirLightPos: { value: new Vector3() },
-    uDirLightColor: { value: new Color(0xeeeeee) },
+    uDirLightPos: { value: /* @__PURE__ */ new Vector3() },
+    uDirLightColor: { value: /* @__PURE__ */ new Color(0xeeeeee) },
 
-    uAmbientLightColor: { value: new Color(0x050505) },
+    uAmbientLightColor: { value: /* @__PURE__ */ new Color(0x050505) },
 
-    uBaseColor: { value: new Color(0xffffff) },
+    uBaseColor: { value: /* @__PURE__ */ new Color(0xffffff) },
   },
 
-  vertexShader: [
-    'varying vec3 vNormal;',
-    'varying vec3 vRefract;',
+  vertexShader: /* glsl */ `
+    varying vec3 vNormal;
+    varying vec3 vRefract;
 
-    'void main() {',
+    void main() {
 
-    '	vec4 worldPosition = modelMatrix * vec4( position, 1.0 );',
-    '	vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );',
-    '	vec3 worldNormal = normalize ( mat3( modelMatrix[0].xyz, modelMatrix[1].xyz, modelMatrix[2].xyz ) * normal );',
+    	vec4 worldPosition = modelMatrix * vec4( position, 1.0 );
+    	vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );
+    	vec3 worldNormal = normalize ( mat3( modelMatrix[0].xyz, modelMatrix[1].xyz, modelMatrix[2].xyz ) * normal );
 
-    '	vNormal = normalize( normalMatrix * normal );',
+    	vNormal = normalize( normalMatrix * normal );
 
-    '	vec3 I = worldPosition.xyz - cameraPosition;',
-    '	vRefract = refract( normalize( I ), worldNormal, 1.02 );',
+    	vec3 I = worldPosition.xyz - cameraPosition;
+    	vRefract = refract( normalize( I ), worldNormal, 1.02 );
 
-    '	gl_Position = projectionMatrix * mvPosition;',
+    	gl_Position = projectionMatrix * mvPosition;
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform vec3 uBaseColor;',
+  fragmentShader: /* glsl */ `
+    uniform vec3 uBaseColor;
 
-    'uniform vec3 uDirLightPos;',
-    'uniform vec3 uDirLightColor;',
+    uniform vec3 uDirLightPos;
+    uniform vec3 uDirLightColor;
 
-    'uniform vec3 uAmbientLightColor;',
+    uniform vec3 uAmbientLightColor;
 
-    'varying vec3 vNormal;',
+    varying vec3 vNormal;
 
-    'varying vec3 vRefract;',
+    varying vec3 vRefract;
 
-    'void main() {',
+    void main() {
 
-    '	float directionalLightWeighting = max( dot( normalize( vNormal ), uDirLightPos ), 0.0);',
-    '	vec3 lightWeighting = uAmbientLightColor + uDirLightColor * directionalLightWeighting;',
+    	float directionalLightWeighting = max( dot( normalize( vNormal ), uDirLightPos ), 0.0);
+    	vec3 lightWeighting = uAmbientLightColor + uDirLightColor * directionalLightWeighting;
 
-    '	float intensity = smoothstep( - 0.5, 1.0, pow( length(lightWeighting), 20.0 ) );',
-    '	intensity += length(lightWeighting) * 0.2;',
+    	float intensity = smoothstep( - 0.5, 1.0, pow( length(lightWeighting), 20.0 ) );
+    	intensity += length(lightWeighting) * 0.2;
 
-    '	float cameraWeighting = dot( normalize( vNormal ), vRefract );',
-    '	intensity += pow( 1.0 - length( cameraWeighting ), 6.0 );',
-    '	intensity = intensity * 0.2 + 0.3;',
+    	float cameraWeighting = dot( normalize( vNormal ), vRefract );
+    	intensity += pow( 1.0 - length( cameraWeighting ), 6.0 );
+    	intensity = intensity * 0.2 + 0.3;
 
-    '	if ( intensity < 0.50 ) {',
+    	if ( intensity < 0.50 ) {
 
-    '		gl_FragColor = vec4( 2.0 * intensity * uBaseColor, 1.0 );',
+    		gl_FragColor = vec4( 2.0 * intensity * uBaseColor, 1.0 );
 
-    '	} else {',
+    	} else {
 
-    '		gl_FragColor = vec4( 1.0 - 2.0 * ( 1.0 - intensity ) * ( 1.0 - uBaseColor ), 1.0 );',
+    		gl_FragColor = vec4( 1.0 - 2.0 * ( 1.0 - intensity ) * ( 1.0 - uBaseColor ), 1.0 );
 
-    '}',
+    }
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
 
 export const ToonShader2 = {
   uniforms: {
-    uDirLightPos: { value: new Vector3() },
-    uDirLightColor: { value: new Color(0xeeeeee) },
+    uDirLightPos: { value: /* @__PURE__ */ new Vector3() },
+    uDirLightColor: { value: /* @__PURE__ */ new Color(0xeeeeee) },
 
-    uAmbientLightColor: { value: new Color(0x050505) },
+    uAmbientLightColor: { value: /* @__PURE__ */ new Color(0x050505) },
 
-    uBaseColor: { value: new Color(0xeeeeee) },
-    uLineColor1: { value: new Color(0x808080) },
-    uLineColor2: { value: new Color(0x000000) },
-    uLineColor3: { value: new Color(0x000000) },
-    uLineColor4: { value: new Color(0x000000) },
+    uBaseColor: { value: /* @__PURE__ */ new Color(0xeeeeee) },
+    uLineColor1: { value: /* @__PURE__ */ new Color(0x808080) },
+    uLineColor2: { value: /* @__PURE__ */ new Color(0x000000) },
+    uLineColor3: { value: /* @__PURE__ */ new Color(0x000000) },
+    uLineColor4: { value: /* @__PURE__ */ new Color(0x000000) },
   },
 
-  vertexShader: [
-    'varying vec3 vNormal;',
+  vertexShader: /* glsl */ `
+    varying vec3 vNormal;
 
-    'void main() {',
+    void main() {
 
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
-    '	vNormal = normalize( normalMatrix * normal );',
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    	vNormal = normalize( normalMatrix * normal );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform vec3 uBaseColor;',
-    'uniform vec3 uLineColor1;',
-    'uniform vec3 uLineColor2;',
-    'uniform vec3 uLineColor3;',
-    'uniform vec3 uLineColor4;',
+  fragmentShader: /* glsl */ `
+    uniform vec3 uBaseColor;
+    uniform vec3 uLineColor1;
+    uniform vec3 uLineColor2;
+    uniform vec3 uLineColor3;
+    uniform vec3 uLineColor4;
 
-    'uniform vec3 uDirLightPos;',
-    'uniform vec3 uDirLightColor;',
+    uniform vec3 uDirLightPos;
+    uniform vec3 uDirLightColor;
 
-    'uniform vec3 uAmbientLightColor;',
+    uniform vec3 uAmbientLightColor;
 
-    'varying vec3 vNormal;',
+    varying vec3 vNormal;
 
-    'void main() {',
+    void main() {
 
-    '	float camera = max( dot( normalize( vNormal ), vec3( 0.0, 0.0, 1.0 ) ), 0.4);',
-    '	float light = max( dot( normalize( vNormal ), uDirLightPos ), 0.0);',
+    	float camera = max( dot( normalize( vNormal ), vec3( 0.0, 0.0, 1.0 ) ), 0.4);
+    	float light = max( dot( normalize( vNormal ), uDirLightPos ), 0.0);
 
-    '	gl_FragColor = vec4( uBaseColor, 1.0 );',
+    	gl_FragColor = vec4( uBaseColor, 1.0 );
 
-    '	if ( length(uAmbientLightColor + uDirLightColor * light) < 1.00 ) {',
+    	if ( length(uAmbientLightColor + uDirLightColor * light) < 1.00 ) {
 
-    '		gl_FragColor *= vec4( uLineColor1, 1.0 );',
+    		gl_FragColor *= vec4( uLineColor1, 1.0 );
 
-    '	}',
+    	}
 
-    '	if ( length(uAmbientLightColor + uDirLightColor * camera) < 0.50 ) {',
+    	if ( length(uAmbientLightColor + uDirLightColor * camera) < 0.50 ) {
 
-    '		gl_FragColor *= vec4( uLineColor2, 1.0 );',
+    		gl_FragColor *= vec4( uLineColor2, 1.0 );
 
-    '	}',
+    	}
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
 
 export const ToonShaderHatching = {
   uniforms: {
-    uDirLightPos: { value: new Vector3() },
-    uDirLightColor: { value: new Color(0xeeeeee) },
+    uDirLightPos: { value: /* @__PURE__ */ new Vector3() },
+    uDirLightColor: { value: /* @__PURE__ */ new Color(0xeeeeee) },
 
-    uAmbientLightColor: { value: new Color(0x050505) },
+    uAmbientLightColor: { value: /* @__PURE__ */ new Color(0x050505) },
 
-    uBaseColor: { value: new Color(0xffffff) },
-    uLineColor1: { value: new Color(0x000000) },
-    uLineColor2: { value: new Color(0x000000) },
-    uLineColor3: { value: new Color(0x000000) },
-    uLineColor4: { value: new Color(0x000000) },
+    uBaseColor: { value: /* @__PURE__ */ new Color(0xffffff) },
+    uLineColor1: { value: /* @__PURE__ */ new Color(0x000000) },
+    uLineColor2: { value: /* @__PURE__ */ new Color(0x000000) },
+    uLineColor3: { value: /* @__PURE__ */ new Color(0x000000) },
+    uLineColor4: { value: /* @__PURE__ */ new Color(0x000000) },
   },
 
-  vertexShader: [
-    'varying vec3 vNormal;',
+  vertexShader: /* glsl */ `
+    varying vec3 vNormal;
 
-    'void main() {',
+    void main() {
 
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
-    '	vNormal = normalize( normalMatrix * normal );',
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    	vNormal = normalize( normalMatrix * normal );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform vec3 uBaseColor;',
-    'uniform vec3 uLineColor1;',
-    'uniform vec3 uLineColor2;',
-    'uniform vec3 uLineColor3;',
-    'uniform vec3 uLineColor4;',
+  fragmentShader: /* glsl */ `
+    uniform vec3 uBaseColor;
+    uniform vec3 uLineColor1;
+    uniform vec3 uLineColor2;
+    uniform vec3 uLineColor3;
+    uniform vec3 uLineColor4;
 
-    'uniform vec3 uDirLightPos;',
-    'uniform vec3 uDirLightColor;',
+    uniform vec3 uDirLightPos;
+    uniform vec3 uDirLightColor;
 
-    'uniform vec3 uAmbientLightColor;',
+    uniform vec3 uAmbientLightColor;
 
-    'varying vec3 vNormal;',
+    varying vec3 vNormal;
 
-    'void main() {',
+    void main() {
 
-    '	float directionalLightWeighting = max( dot( normalize(vNormal), uDirLightPos ), 0.0);',
-    '	vec3 lightWeighting = uAmbientLightColor + uDirLightColor * directionalLightWeighting;',
+    	float directionalLightWeighting = max( dot( normalize(vNormal), uDirLightPos ), 0.0);
+    	vec3 lightWeighting = uAmbientLightColor + uDirLightColor * directionalLightWeighting;
 
-    '	gl_FragColor = vec4( uBaseColor, 1.0 );',
+    	gl_FragColor = vec4( uBaseColor, 1.0 );
 
-    '	if ( length(lightWeighting) < 1.00 ) {',
+    	if ( length(lightWeighting) < 1.00 ) {
 
-    '		if ( mod(gl_FragCoord.x + gl_FragCoord.y, 10.0) == 0.0) {',
+    		if ( mod(gl_FragCoord.x + gl_FragCoord.y, 10.0) == 0.0) {
 
-    '			gl_FragColor = vec4( uLineColor1, 1.0 );',
+    			gl_FragColor = vec4( uLineColor1, 1.0 );
 
-    '		}',
+    		}
 
-    '	}',
+    	}
 
-    '	if ( length(lightWeighting) < 0.75 ) {',
+    	if ( length(lightWeighting) < 0.75 ) {
 
-    '		if (mod(gl_FragCoord.x - gl_FragCoord.y, 10.0) == 0.0) {',
+    		if (mod(gl_FragCoord.x - gl_FragCoord.y, 10.0) == 0.0) {
 
-    '			gl_FragColor = vec4( uLineColor2, 1.0 );',
+    			gl_FragColor = vec4( uLineColor2, 1.0 );
 
-    '		}',
+    		}
 
-    '	}',
+    	}
 
-    '	if ( length(lightWeighting) < 0.50 ) {',
+    	if ( length(lightWeighting) < 0.50 ) {
 
-    '		if (mod(gl_FragCoord.x + gl_FragCoord.y - 5.0, 10.0) == 0.0) {',
+    		if (mod(gl_FragCoord.x + gl_FragCoord.y - 5.0, 10.0) == 0.0) {
 
-    '			gl_FragColor = vec4( uLineColor3, 1.0 );',
+    			gl_FragColor = vec4( uLineColor3, 1.0 );
 
-    '		}',
+    		}
 
-    '	}',
+    	}
 
-    '	if ( length(lightWeighting) < 0.3465 ) {',
+    	if ( length(lightWeighting) < 0.3465 ) {
 
-    '		if (mod(gl_FragCoord.x - gl_FragCoord.y - 5.0, 10.0) == 0.0) {',
+    		if (mod(gl_FragCoord.x - gl_FragCoord.y - 5.0, 10.0) == 0.0) {
 
-    '			gl_FragColor = vec4( uLineColor4, 1.0 );',
+    			gl_FragColor = vec4( uLineColor4, 1.0 );
 
-    '	}',
+    	}
 
-    '	}',
+    	}
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
 
 export const ToonShaderDotted = {
   uniforms: {
-    uDirLightPos: { value: new Vector3() },
-    uDirLightColor: { value: new Color(0xeeeeee) },
+    uDirLightPos: { value: /* @__PURE__ */ new Vector3() },
+    uDirLightColor: { value: /* @__PURE__ */ new Color(0xeeeeee) },
 
-    uAmbientLightColor: { value: new Color(0x050505) },
+    uAmbientLightColor: { value: /* @__PURE__ */ new Color(0x050505) },
 
-    uBaseColor: { value: new Color(0xffffff) },
-    uLineColor1: { value: new Color(0x000000) },
+    uBaseColor: { value: /* @__PURE__ */ new Color(0xffffff) },
+    uLineColor1: { value: /* @__PURE__ */ new Color(0x000000) },
   },
 
-  vertexShader: [
-    'varying vec3 vNormal;',
+  vertexShader: /* glsl */ `
+    varying vec3 vNormal;
 
-    'void main() {',
+    void main() {
 
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
-    '	vNormal = normalize( normalMatrix * normal );',
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+    	vNormal = normalize( normalMatrix * normal );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform vec3 uBaseColor;',
-    'uniform vec3 uLineColor1;',
-    'uniform vec3 uLineColor2;',
-    'uniform vec3 uLineColor3;',
-    'uniform vec3 uLineColor4;',
+  fragmentShader: /* glsl */ `
+    uniform vec3 uBaseColor;
+    uniform vec3 uLineColor1;
+    uniform vec3 uLineColor2;
+    uniform vec3 uLineColor3;
+    uniform vec3 uLineColor4;
 
-    'uniform vec3 uDirLightPos;',
-    'uniform vec3 uDirLightColor;',
+    uniform vec3 uDirLightPos;
+    uniform vec3 uDirLightColor;
 
-    'uniform vec3 uAmbientLightColor;',
+    uniform vec3 uAmbientLightColor;
 
-    'varying vec3 vNormal;',
+    varying vec3 vNormal;
 
-    'void main() {',
+    void main() {
 
-    'float directionalLightWeighting = max( dot( normalize(vNormal), uDirLightPos ), 0.0);',
-    'vec3 lightWeighting = uAmbientLightColor + uDirLightColor * directionalLightWeighting;',
+    float directionalLightWeighting = max( dot( normalize(vNormal), uDirLightPos ), 0.0);
+    vec3 lightWeighting = uAmbientLightColor + uDirLightColor * directionalLightWeighting;
 
-    'gl_FragColor = vec4( uBaseColor, 1.0 );',
+    gl_FragColor = vec4( uBaseColor, 1.0 );
 
-    'if ( length(lightWeighting) < 1.00 ) {',
+    if ( length(lightWeighting) < 1.00 ) {
 
-    '		if ( ( mod(gl_FragCoord.x, 4.001) + mod(gl_FragCoord.y, 4.0) ) > 6.00 ) {',
+    		if ( ( mod(gl_FragCoord.x, 4.001) + mod(gl_FragCoord.y, 4.0) ) > 6.00 ) {
 
-    '			gl_FragColor = vec4( uLineColor1, 1.0 );',
+    			gl_FragColor = vec4( uLineColor1, 1.0 );
 
-    '		}',
+    		}
 
-    '	}',
+    	}
 
-    '	if ( length(lightWeighting) < 0.50 ) {',
+    	if ( length(lightWeighting) < 0.50 ) {
 
-    '		if ( ( mod(gl_FragCoord.x + 2.0, 4.001) + mod(gl_FragCoord.y + 2.0, 4.0) ) > 6.00 ) {',
+    		if ( ( mod(gl_FragCoord.x + 2.0, 4.001) + mod(gl_FragCoord.y + 2.0, 4.0) ) > 6.00 ) {
 
-    '			gl_FragColor = vec4( uLineColor1, 1.0 );',
+    			gl_FragColor = vec4( uLineColor1, 1.0 );
 
-    '		}',
+    		}
 
-    '	}',
+    	}
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/TriangleBlurShader.ts b/src/shaders/TriangleBlurShader.ts
index e24c0838..da98a712 100644
--- a/src/shaders/TriangleBlurShader.ts
+++ b/src/shaders/TriangleBlurShader.ts
@@ -13,52 +13,52 @@ import { Vector2 } from 'three'
 export const TriangleBlurShader = {
   uniforms: {
     texture: { value: null },
-    delta: { value: new Vector2(1, 1) },
+    delta: { value: /* @__PURE__ */ new Vector2(1, 1) },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    '#include <common>',
+  fragmentShader: /* glsl */ `
+    #include <common>
 
-    '#define ITERATIONS 10.0',
+    #define ITERATIONS 10.0
 
-    'uniform sampler2D texture;',
-    'uniform vec2 delta;',
+    uniform sampler2D texture;
+    uniform vec2 delta;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vec4 color = vec4( 0.0 );',
+    	vec4 color = vec4( 0.0 );
 
-    '	float total = 0.0;',
+    	float total = 0.0;
 
     // randomize the lookup values to hide the fixed number of samples
 
-    '	float offset = rand( vUv );',
+    	float offset = rand( vUv );
 
-    '	for ( float t = -ITERATIONS; t <= ITERATIONS; t ++ ) {',
+    	for ( float t = -ITERATIONS; t <= ITERATIONS; t ++ ) {
 
-    '		float percent = ( t + offset - 0.5 ) / ITERATIONS;',
-    '		float weight = 1.0 - abs( percent );',
+    		float percent = ( t + offset - 0.5 ) / ITERATIONS;
+    		float weight = 1.0 - abs( percent );
 
-    '		color += texture2D( texture, vUv + delta * percent ) * weight;',
-    '		total += weight;',
+    		color += texture2D( texture, vUv + delta * percent ) * weight;
+    		total += weight;
 
-    '	}',
+    	}
 
-    '	gl_FragColor = color / total;',
+    	gl_FragColor = color / total;
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/UnpackDepthRGBAShader.ts b/src/shaders/UnpackDepthRGBAShader.ts
index 28a43b09..dcc16d4e 100644
--- a/src/shaders/UnpackDepthRGBAShader.ts
+++ b/src/shaders/UnpackDepthRGBAShader.ts
@@ -9,31 +9,31 @@ export const UnpackDepthRGBAShader = {
     opacity: { value: 1.0 },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform float opacity;',
+  fragmentShader: /* glsl */ `
+    uniform float opacity;
 
-    'uniform sampler2D tDiffuse;',
+    uniform sampler2D tDiffuse;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    '#include <packing>',
+    #include <packing>
 
-    'void main() {',
+    void main() {
 
-    '	float depth = 1.0 - unpackRGBAToDepth( texture2D( tDiffuse, vUv ) );',
-    '	gl_FragColor = vec4( vec3( depth ), opacity );',
+    	float depth = 1.0 - unpackRGBAToDepth( texture2D( tDiffuse, vUv ) );
+    	gl_FragColor = vec4( vec3( depth ), opacity );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/VerticalTiltShiftShader.ts b/src/shaders/VerticalTiltShiftShader.ts
index bb237b0d..47fd6a0d 100644
--- a/src/shaders/VerticalTiltShiftShader.ts
+++ b/src/shaders/VerticalTiltShiftShader.ts
@@ -14,42 +14,42 @@ export const VerticalTiltShiftShader = {
     r: { value: 0.35 },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform sampler2D tDiffuse;',
-    'uniform float v;',
-    'uniform float r;',
+  fragmentShader: /* glsl */ `
+    uniform sampler2D tDiffuse;
+    uniform float v;
+    uniform float r;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vec4 sum = vec4( 0.0 );',
+    	vec4 sum = vec4( 0.0 );
 
-    '	float vv = v * abs( r - vUv.y );',
+    	float vv = v * abs( r - vUv.y );
 
-    '	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 4.0 * vv ) ) * 0.051;',
-    '	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 3.0 * vv ) ) * 0.0918;',
-    '	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 2.0 * vv ) ) * 0.12245;',
-    '	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 1.0 * vv ) ) * 0.1531;',
-    '	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y ) ) * 0.1633;',
-    '	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 1.0 * vv ) ) * 0.1531;',
-    '	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 2.0 * vv ) ) * 0.12245;',
-    '	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 3.0 * vv ) ) * 0.0918;',
-    '	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 4.0 * vv ) ) * 0.051;',
+    	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 4.0 * vv ) ) * 0.051;
+    	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 3.0 * vv ) ) * 0.0918;
+    	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 2.0 * vv ) ) * 0.12245;
+    	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 1.0 * vv ) ) * 0.1531;
+    	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y ) ) * 0.1633;
+    	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 1.0 * vv ) ) * 0.1531;
+    	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 2.0 * vv ) ) * 0.12245;
+    	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 3.0 * vv ) ) * 0.0918;
+    	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 4.0 * vv ) ) * 0.051;
 
-    '	gl_FragColor = sum;',
+    	gl_FragColor = sum;
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/VignetteShader.ts b/src/shaders/VignetteShader.ts
index 756478e2..e3e9b30f 100644
--- a/src/shaders/VignetteShader.ts
+++ b/src/shaders/VignetteShader.ts
@@ -11,32 +11,32 @@ export const VignetteShader = {
     darkness: { value: 1.0 },
   },
 
-  vertexShader: [
-    'varying vec2 vUv;',
+  vertexShader: /* glsl */ `
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	vUv = uv;
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform float offset;',
-    'uniform float darkness;',
+  fragmentShader: /* glsl */ `
+    uniform float offset;
+    uniform float darkness;
 
-    'uniform sampler2D tDiffuse;',
+    uniform sampler2D tDiffuse;
 
-    'varying vec2 vUv;',
+    varying vec2 vUv;
 
-    'void main() {',
+    void main() {
 
-    // Eskil's vignette
+    // Eskils vignette
 
-    '	vec4 texel = texture2D( tDiffuse, vUv );',
-    '	vec2 uv = ( vUv - vec2( 0.5 ) ) * vec2( offset );',
-    '	gl_FragColor = vec4( mix( texel.rgb, vec3( 1.0 - darkness ), dot( uv, uv ) ), texel.a );',
+    	vec4 texel = texture2D( tDiffuse, vUv );
+    	vec2 uv = ( vUv - vec2( 0.5 ) ) * vec2( offset );
+    	gl_FragColor = vec4( mix( texel.rgb, vec3( 1.0 - darkness ), dot( uv, uv ) ), texel.a );
 
     /*
 		// alternative version from glfx.js
@@ -48,6 +48,6 @@ export const VignetteShader = {
 		"	gl_FragColor = color;",
 		*/
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/shaders/VolumeShader.ts b/src/shaders/VolumeShader.ts
index eb321679..7abcb6a0 100644
--- a/src/shaders/VolumeShader.ts
+++ b/src/shaders/VolumeShader.ts
@@ -8,267 +8,267 @@ import { Vector2, Vector3 } from 'three'
 
 export const VolumeRenderShader1 = {
   uniforms: {
-    u_size: { value: new Vector3(1, 1, 1) },
+    u_size: { value: /* @__PURE__ */ new Vector3(1, 1, 1) },
     u_renderstyle: { value: 0 },
     u_renderthreshold: { value: 0.5 },
-    u_clim: { value: new Vector2(1, 1) },
+    u_clim: { value: /* @__PURE__ */ new Vector2(1, 1) },
     u_data: { value: null },
     u_cmdata: { value: null },
   },
-  vertexShader: [
-    '		varying vec4 v_nearpos;',
-    '		varying vec4 v_farpos;',
-    '		varying vec3 v_position;',
-
-    '		void main() {',
-    // Prepare transforms to map to "camera view". See also:
-    // https://threejs.org/docs/#api/renderers/webgl/WebGLProgram
-    '				mat4 viewtransformf = modelViewMatrix;',
-    '				mat4 viewtransformi = inverse(modelViewMatrix);',
-
-    // Project local vertex coordinate to camera position. Then do a step
-    // backward (in cam coords) to the near clipping plane, and project back. Do
-    // the same for the far clipping plane. This gives us all the information we
-    // need to calculate the ray and truncate it to the viewing cone.
-    '				vec4 position4 = vec4(position, 1.0);',
-    '				vec4 pos_in_cam = viewtransformf * position4;',
-
-    // Intersection of ray and near clipping plane (z = -1 in clip coords)
-    '				pos_in_cam.z = -pos_in_cam.w;',
-    '				v_nearpos = viewtransformi * pos_in_cam;',
-
-    // Intersection of ray and far clipping plane (z = +1 in clip coords)
-    '				pos_in_cam.z = pos_in_cam.w;',
-    '				v_farpos = viewtransformi * pos_in_cam;',
-
-    // Set varyings and output pos
-    '				v_position = position;',
-    '				gl_Position = projectionMatrix * viewMatrix * modelMatrix * position4;',
-    '		}',
-  ].join('\n'),
-  fragmentShader: [
-    '		precision highp float;',
-    '		precision mediump sampler3D;',
-
-    '		uniform vec3 u_size;',
-    '		uniform int u_renderstyle;',
-    '		uniform float u_renderthreshold;',
-    '		uniform vec2 u_clim;',
-
-    '		uniform sampler3D u_data;',
-    '		uniform sampler2D u_cmdata;',
-
-    '		varying vec3 v_position;',
-    '		varying vec4 v_nearpos;',
-    '		varying vec4 v_farpos;',
-
-    // The maximum distance through our rendering volume is sqrt(3).
-    '		const int MAX_STEPS = 887;	// 887 for 512^3, 1774 for 1024^3',
-    '		const int REFINEMENT_STEPS = 4;',
-    '		const float relative_step_size = 1.0;',
-    '		const vec4 ambient_color = vec4(0.2, 0.4, 0.2, 1.0);',
-    '		const vec4 diffuse_color = vec4(0.8, 0.2, 0.2, 1.0);',
-    '		const vec4 specular_color = vec4(1.0, 1.0, 1.0, 1.0);',
-    '		const float shininess = 40.0;',
-
-    '		void cast_mip(vec3 start_loc, vec3 step, int nsteps, vec3 view_ray);',
-    '		void cast_iso(vec3 start_loc, vec3 step, int nsteps, vec3 view_ray);',
-
-    '		float sample1(vec3 texcoords);',
-    '		vec4 apply_colormap(float val);',
-    '		vec4 add_lighting(float val, vec3 loc, vec3 step, vec3 view_ray);',
-
-    '		void main() {',
-    // Normalize clipping plane info
-    '				vec3 farpos = v_farpos.xyz / v_farpos.w;',
-    '				vec3 nearpos = v_nearpos.xyz / v_nearpos.w;',
-
-    // Calculate unit vector pointing in the view direction through this fragment.
-    '				vec3 view_ray = normalize(nearpos.xyz - farpos.xyz);',
-
-    // Compute the (negative) distance to the front surface or near clipping plane.
-    // v_position is the back face of the cuboid, so the initial distance calculated in the dot
-    // product below is the distance from near clip plane to the back of the cuboid
-    '				float distance = dot(nearpos - v_position, view_ray);',
-    '				distance = max(distance, min((-0.5 - v_position.x) / view_ray.x,',
-    '																		(u_size.x - 0.5 - v_position.x) / view_ray.x));',
-    '				distance = max(distance, min((-0.5 - v_position.y) / view_ray.y,',
-    '																		(u_size.y - 0.5 - v_position.y) / view_ray.y));',
-    '				distance = max(distance, min((-0.5 - v_position.z) / view_ray.z,',
-    '																		(u_size.z - 0.5 - v_position.z) / view_ray.z));',
-
-    // Now we have the starting position on the front surface
-    '				vec3 front = v_position + view_ray * distance;',
-
-    // Decide how many steps to take
-    '				int nsteps = int(-distance / relative_step_size + 0.5);',
-    '				if ( nsteps < 1 )',
-    '						discard;',
-
-    // Get starting location and step vector in texture coordinates
-    '				vec3 step = ((v_position - front) / u_size) / float(nsteps);',
-    '				vec3 start_loc = front / u_size;',
-
-    // For testing: show the number of steps. This helps to establish
-    // whether the rays are correctly oriented
-    //'gl_FragColor = vec4(0.0, float(nsteps) / 1.0 / u_size.x, 1.0, 1.0);',
-    //'return;',
-
-    '				if (u_renderstyle == 0)',
-    '						cast_mip(start_loc, step, nsteps, view_ray);',
-    '				else if (u_renderstyle == 1)',
-    '						cast_iso(start_loc, step, nsteps, view_ray);',
-
-    '				if (gl_FragColor.a < 0.05)',
-    '						discard;',
-    '		}',
-
-    '		float sample1(vec3 texcoords) {',
-    '				/* Sample float value from a 3D texture. Assumes intensity data. */',
-    '				return texture(u_data, texcoords.xyz).r;',
-    '		}',
-
-    '		vec4 apply_colormap(float val) {',
-    '				val = (val - u_clim[0]) / (u_clim[1] - u_clim[0]);',
-    '				return texture2D(u_cmdata, vec2(val, 0.5));',
-    '		}',
-
-    '		void cast_mip(vec3 start_loc, vec3 step, int nsteps, vec3 view_ray) {',
-
-    '				float max_val = -1e6;',
-    '				int max_i = 100;',
-    '				vec3 loc = start_loc;',
-
-    // Enter the raycasting loop. In WebGL 1 the loop index cannot be compared with
-    // non-constant expression. So we use a hard-coded max, and an additional condition
-    // inside the loop.
-    '				for (int iter=0; iter<MAX_STEPS; iter++) {',
-    '						if (iter >= nsteps)',
-    '								break;',
-    // Sample from the 3D texture
-    '						float val = sample1(loc);',
-    // Apply MIP operation
-    '						if (val > max_val) {',
-    '								max_val = val;',
-    '								max_i = iter;',
-    '						}',
-    // Advance location deeper into the volume
-    '						loc += step;',
-    '				}',
-
-    // Refine location, gives crispier images
-    '				vec3 iloc = start_loc + step * (float(max_i) - 0.5);',
-    '				vec3 istep = step / float(REFINEMENT_STEPS);',
-    '				for (int i=0; i<REFINEMENT_STEPS; i++) {',
-    '						max_val = max(max_val, sample1(iloc));',
-    '						iloc += istep;',
-    '				}',
-
-    // Resolve final color
-    '				gl_FragColor = apply_colormap(max_val);',
-    '		}',
-
-    '		void cast_iso(vec3 start_loc, vec3 step, int nsteps, vec3 view_ray) {',
-
-    '				gl_FragColor = vec4(0.0);	// init transparent',
-    '				vec4 color3 = vec4(0.0);	// final color',
-    '				vec3 dstep = 1.5 / u_size;	// step to sample derivative',
-    '				vec3 loc = start_loc;',
-
-    '				float low_threshold = u_renderthreshold - 0.02 * (u_clim[1] - u_clim[0]);',
-
-    // Enter the raycasting loop. In WebGL 1 the loop index cannot be compared with
-    // non-constant expression. So we use a hard-coded max, and an additional condition
-    // inside the loop.
-    '				for (int iter=0; iter<MAX_STEPS; iter++) {',
-    '						if (iter >= nsteps)',
-    '								break;',
-
-    // Sample from the 3D texture
-    '						float val = sample1(loc);',
-
-    '						if (val > low_threshold) {',
-    // Take the last interval in smaller steps
-    '								vec3 iloc = loc - 0.5 * step;',
-    '								vec3 istep = step / float(REFINEMENT_STEPS);',
-    '								for (int i=0; i<REFINEMENT_STEPS; i++) {',
-    '										val = sample1(iloc);',
-    '										if (val > u_renderthreshold) {',
-    '												gl_FragColor = add_lighting(val, iloc, dstep, view_ray);',
-    '												return;',
-    '										}',
-    '										iloc += istep;',
-    '								}',
-    '						}',
-
-    // Advance location deeper into the volume
-    '						loc += step;',
-    '				}',
-    '		}',
-
-    '		vec4 add_lighting(float val, vec3 loc, vec3 step, vec3 view_ray)',
-    '		{',
-    // Calculate color by incorporating lighting
-
-    // View direction
-    '				vec3 V = normalize(view_ray);',
-
-    // calculate normal vector from gradient
-    '				vec3 N;',
-    '				float val1, val2;',
-    '				val1 = sample1(loc + vec3(-step[0], 0.0, 0.0));',
-    '				val2 = sample1(loc + vec3(+step[0], 0.0, 0.0));',
-    '				N[0] = val1 - val2;',
-    '				val = max(max(val1, val2), val);',
-    '				val1 = sample1(loc + vec3(0.0, -step[1], 0.0));',
-    '				val2 = sample1(loc + vec3(0.0, +step[1], 0.0));',
-    '				N[1] = val1 - val2;',
-    '				val = max(max(val1, val2), val);',
-    '				val1 = sample1(loc + vec3(0.0, 0.0, -step[2]));',
-    '				val2 = sample1(loc + vec3(0.0, 0.0, +step[2]));',
-    '				N[2] = val1 - val2;',
-    '				val = max(max(val1, val2), val);',
-
-    '				float gm = length(N); // gradient magnitude',
-    '				N = normalize(N);',
-
-    // Flip normal so it points towards viewer
-    '				float Nselect = float(dot(N, V) > 0.0);',
-    '				N = (2.0 * Nselect - 1.0) * N;	// ==	Nselect * N - (1.0-Nselect)*N;',
-
-    // Init colors
-    '				vec4 ambient_color = vec4(0.0, 0.0, 0.0, 0.0);',
-    '				vec4 diffuse_color = vec4(0.0, 0.0, 0.0, 0.0);',
-    '				vec4 specular_color = vec4(0.0, 0.0, 0.0, 0.0);',
-
-    // note: could allow multiple lights
-    '				for (int i=0; i<1; i++)',
-    '				{',
-    // Get light direction (make sure to prevent zero devision)
-    '						vec3 L = normalize(view_ray);	//lightDirs[i];',
-    '						float lightEnabled = float( length(L) > 0.0 );',
-    '						L = normalize(L + (1.0 - lightEnabled));',
-
-    // Calculate lighting properties
-    '						float lambertTerm = clamp(dot(N, L), 0.0, 1.0);',
-    '						vec3 H = normalize(L+V); // Halfway vector',
-    '						float specularTerm = pow(max(dot(H, N), 0.0), shininess);',
-
-    // Calculate mask
-    '						float mask1 = lightEnabled;',
-
-    // Calculate colors
-    '						ambient_color +=	mask1 * ambient_color;	// * gl_LightSource[i].ambient;',
-    '						diffuse_color +=	mask1 * lambertTerm;',
-    '						specular_color += mask1 * specularTerm * specular_color;',
-    '				}',
-
-    // Calculate final color by componing different components
-    '				vec4 final_color;',
-    '				vec4 color = apply_colormap(val);',
-    '				final_color = color * (ambient_color + diffuse_color) + specular_color;',
-    '				final_color.a = color.a;',
-    '				return final_color;',
-    '		}',
-  ].join('\n'),
+  vertexShader: /* glsl */ `
+		varying vec4 v_nearpos;
+		varying vec4 v_farpos;
+		varying vec3 v_position;
+
+		void main() {
+			// Prepare transforms to map to "camera view". See also:
+			// https://threejs.org/docs/#api/renderers/webgl/WebGLProgram
+			mat4 viewtransformf = modelViewMatrix;
+			mat4 viewtransformi = inverse(modelViewMatrix);
+
+			// Project local vertex coordinate to camera position. Then do a step
+			// backward (in cam coords) to the near clipping plane, and project back. Do
+			// the same for the far clipping plane. This gives us all the information we
+			// need to calculate the ray and truncate it to the viewing cone.
+			vec4 position4 = vec4(position, 1.0);
+			vec4 pos_in_cam = viewtransformf * position4;
+
+			// Intersection of ray and near clipping plane (z = -1 in clip coords)
+			pos_in_cam.z = -pos_in_cam.w;
+			v_nearpos = viewtransformi * pos_in_cam;
+
+			// Intersection of ray and far clipping plane (z = +1 in clip coords)
+			pos_in_cam.z = pos_in_cam.w;
+			v_farpos = viewtransformi * pos_in_cam;
+
+			// Set varyings and output pos
+			v_position = position;
+			gl_Position = projectionMatrix * viewMatrix * modelMatrix * position4;
+		}
+  `,
+  fragmentShader: /* glsl */ `
+		precision highp float;
+		precision mediump sampler3D;
+
+		uniform vec3 u_size;
+		uniform int u_renderstyle;
+		uniform float u_renderthreshold;
+		uniform vec2 u_clim;
+
+		uniform sampler3D u_data;
+		uniform sampler2D u_cmdata;
+
+		varying vec3 v_position;
+		varying vec4 v_nearpos;
+		varying vec4 v_farpos;
+
+	// The maximum distance through our rendering volume is sqrt(3).
+		const int MAX_STEPS = 887;	// 887 for 512^3, 1774 for 1024^3
+		const int REFINEMENT_STEPS = 4;
+		const float relative_step_size = 1.0;
+		const vec4 ambient_color = vec4(0.2, 0.4, 0.2, 1.0);
+		const vec4 diffuse_color = vec4(0.8, 0.2, 0.2, 1.0);
+		const vec4 specular_color = vec4(1.0, 1.0, 1.0, 1.0);
+		const float shininess = 40.0;
+
+		void cast_mip(vec3 start_loc, vec3 step, int nsteps, vec3 view_ray);
+		void cast_iso(vec3 start_loc, vec3 step, int nsteps, vec3 view_ray);
+
+		float sample1(vec3 texcoords);
+		vec4 apply_colormap(float val);
+		vec4 add_lighting(float val, vec3 loc, vec3 step, vec3 view_ray);
+
+		void main() {
+	// Normalize clipping plane info
+			vec3 farpos = v_farpos.xyz / v_farpos.w;
+			vec3 nearpos = v_nearpos.xyz / v_nearpos.w;
+
+	// Calculate unit vector pointing in the view direction through this fragment.
+			vec3 view_ray = normalize(nearpos.xyz - farpos.xyz);
+
+	// Compute the (negative) distance to the front surface or near clipping plane.
+	// v_position is the back face of the cuboid, so the initial distance calculated in the dot
+	// product below is the distance from near clip plane to the back of the cuboid
+			float distance = dot(nearpos - v_position, view_ray);
+			distance = max(distance, min((-0.5 - v_position.x) / view_ray.x,
+										(u_size.x - 0.5 - v_position.x) / view_ray.x));
+			distance = max(distance, min((-0.5 - v_position.y) / view_ray.y,
+										(u_size.y - 0.5 - v_position.y) / view_ray.y));
+			distance = max(distance, min((-0.5 - v_position.z) / view_ray.z,
+										(u_size.z - 0.5 - v_position.z) / view_ray.z));
+
+	// Now we have the starting position on the front surface
+			vec3 front = v_position + view_ray * distance;
+
+	// Decide how many steps to take
+			int nsteps = int(-distance / relative_step_size + 0.5);
+			if ( nsteps < 1 )
+				discard;
+
+	// Get starting location and step vector in texture coordinates
+			vec3 step = ((v_position - front) / u_size) / float(nsteps);
+			vec3 start_loc = front / u_size;
+
+	// For testing: show the number of steps. This helps to establish
+	// whether the rays are correctly oriented
+	//gl_FragColor = vec4(0.0, float(nsteps) / 1.0 / u_size.x, 1.0, 1.0);
+	//return;
+
+			if (u_renderstyle == 0)
+				cast_mip(start_loc, step, nsteps, view_ray);
+			else if (u_renderstyle == 1)
+				cast_iso(start_loc, step, nsteps, view_ray);
+
+			if (gl_FragColor.a < 0.05)
+				discard;
+		}
+
+		float sample1(vec3 texcoords) {
+			/* Sample float value from a 3D texture. Assumes intensity data. */
+			return texture(u_data, texcoords.xyz).r;
+		}
+
+		vec4 apply_colormap(float val) {
+			val = (val - u_clim[0]) / (u_clim[1] - u_clim[0]);
+			return texture2D(u_cmdata, vec2(val, 0.5));
+		}
+
+		void cast_mip(vec3 start_loc, vec3 step, int nsteps, vec3 view_ray) {
+
+			float max_val = -1e6;
+			int max_i = 100;
+			vec3 loc = start_loc;
+
+	// Enter the raycasting loop. In WebGL 1 the loop index cannot be compared with
+	// non-constant expression. So we use a hard-coded max, and an additional condition
+	// inside the loop.
+			for (int iter=0; iter<MAX_STEPS; iter++) {
+				if (iter >= nsteps)
+					break;
+	// Sample from the 3D texture
+				float val = sample1(loc);
+	// Apply MIP operation
+				if (val > max_val) {
+					max_val = val;
+					max_i = iter;
+				}
+	// Advance location deeper into the volume
+				loc += step;
+			}
+
+	// Refine location, gives crispier images
+			vec3 iloc = start_loc + step * (float(max_i) - 0.5);
+			vec3 istep = step / float(REFINEMENT_STEPS);
+			for (int i=0; i<REFINEMENT_STEPS; i++) {
+				max_val = max(max_val, sample1(iloc));
+				iloc += istep;
+			}
+
+	// Resolve final color
+			gl_FragColor = apply_colormap(max_val);
+		}
+
+		void cast_iso(vec3 start_loc, vec3 step, int nsteps, vec3 view_ray) {
+
+			gl_FragColor = vec4(0.0);	// init transparent
+			vec4 color3 = vec4(0.0);	// final color
+			vec3 dstep = 1.5 / u_size;	// step to sample derivative
+			vec3 loc = start_loc;
+
+			float low_threshold = u_renderthreshold - 0.02 * (u_clim[1] - u_clim[0]);
+
+	// Enter the raycasting loop. In WebGL 1 the loop index cannot be compared with
+	// non-constant expression. So we use a hard-coded max, and an additional condition
+	// inside the loop.
+			for (int iter=0; iter<MAX_STEPS; iter++) {
+				if (iter >= nsteps)
+					break;
+
+	// Sample from the 3D texture
+				float val = sample1(loc);
+
+				if (val > low_threshold) {
+	// Take the last interval in smaller steps
+					vec3 iloc = loc - 0.5 * step;
+					vec3 istep = step / float(REFINEMENT_STEPS);
+					for (int i=0; i<REFINEMENT_STEPS; i++) {
+						val = sample1(iloc);
+						if (val > u_renderthreshold) {
+							gl_FragColor = add_lighting(val, iloc, dstep, view_ray);
+							return;
+						}
+						iloc += istep;
+					}
+				}
+
+	// Advance location deeper into the volume
+				loc += step;
+			}
+		}
+
+		vec4 add_lighting(float val, vec3 loc, vec3 step, vec3 view_ray)
+		{
+	// Calculate color by incorporating lighting
+
+	// View direction
+			vec3 V = normalize(view_ray);
+
+	// calculate normal vector from gradient
+			vec3 N;
+			float val1, val2;
+			val1 = sample1(loc + vec3(-step[0], 0.0, 0.0));
+			val2 = sample1(loc + vec3(+step[0], 0.0, 0.0));
+			N[0] = val1 - val2;
+			val = max(max(val1, val2), val);
+			val1 = sample1(loc + vec3(0.0, -step[1], 0.0));
+			val2 = sample1(loc + vec3(0.0, +step[1], 0.0));
+			N[1] = val1 - val2;
+			val = max(max(val1, val2), val);
+			val1 = sample1(loc + vec3(0.0, 0.0, -step[2]));
+			val2 = sample1(loc + vec3(0.0, 0.0, +step[2]));
+			N[2] = val1 - val2;
+			val = max(max(val1, val2), val);
+
+			float gm = length(N); // gradient magnitude
+			N = normalize(N);
+
+	// Flip normal so it points towards viewer
+			float Nselect = float(dot(N, V) > 0.0);
+			N = (2.0 * Nselect - 1.0) * N;	// ==	Nselect * N - (1.0-Nselect)*N;
+
+	// Init colors
+			vec4 ambient_color = vec4(0.0, 0.0, 0.0, 0.0);
+			vec4 diffuse_color = vec4(0.0, 0.0, 0.0, 0.0);
+			vec4 specular_color = vec4(0.0, 0.0, 0.0, 0.0);
+
+	// note: could allow multiple lights
+			for (int i=0; i<1; i++)
+			{
+	// Get light direction (make sure to prevent zero devision)
+				vec3 L = normalize(view_ray);	//lightDirs[i];
+				float lightEnabled = float( length(L) > 0.0 );
+				L = normalize(L + (1.0 - lightEnabled));
+
+	// Calculate lighting properties
+				float lambertTerm = clamp(dot(N, L), 0.0, 1.0);
+				vec3 H = normalize(L+V); // Halfway vector
+				float specularTerm = pow(max(dot(H, N), 0.0), shininess);
+
+	// Calculate mask
+				float mask1 = lightEnabled;
+
+	// Calculate colors
+				ambient_color +=	mask1 * ambient_color;	// * gl_LightSource[i].ambient;
+				diffuse_color +=	mask1 * lambertTerm;
+				specular_color += mask1 * specularTerm * specular_color;
+			}
+
+	// Calculate final color by componing different components
+			vec4 final_color;
+			vec4 color = apply_colormap(val);
+			final_color = color * (ambient_color + diffuse_color) + specular_color;
+			final_color.a = color.a;
+			return final_color;
+		}
+  `,
 }
diff --git a/src/shaders/WaterRefractionShader.ts b/src/shaders/WaterRefractionShader.ts
index 32f2cb7b..7f14e079 100644
--- a/src/shaders/WaterRefractionShader.ts
+++ b/src/shaders/WaterRefractionShader.ts
@@ -21,64 +21,64 @@ export const WaterRefractionShader = {
     },
   },
 
-  vertexShader: [
-    'uniform mat4 textureMatrix;',
+  vertexShader: /* glsl */ `
+    uniform mat4 textureMatrix;
 
-    'varying vec2 vUv;',
-    'varying vec4 vUvRefraction;',
+    varying vec2 vUv;
+    varying vec4 vUvRefraction;
 
-    'void main() {',
+    void main() {
 
-    '	vUv = uv;',
+    	vUv = uv;
 
-    '	vUvRefraction = textureMatrix * vec4( position, 1.0 );',
+    	vUvRefraction = textureMatrix * vec4( position, 1.0 );
 
-    '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 
-  fragmentShader: [
-    'uniform vec3 color;',
-    'uniform float time;',
-    'uniform sampler2D tDiffuse;',
-    'uniform sampler2D tDudv;',
+  fragmentShader: /* glsl */ `
+    uniform vec3 color;
+    uniform float time;
+    uniform sampler2D tDiffuse;
+    uniform sampler2D tDudv;
 
-    'varying vec2 vUv;',
-    'varying vec4 vUvRefraction;',
+    varying vec2 vUv;
+    varying vec4 vUvRefraction;
 
-    'float blendOverlay( float base, float blend ) {',
+    float blendOverlay( float base, float blend ) {
 
-    '	return( base < 0.5 ? ( 2.0 * base * blend ) : ( 1.0 - 2.0 * ( 1.0 - base ) * ( 1.0 - blend ) ) );',
+    	return( base < 0.5 ? ( 2.0 * base * blend ) : ( 1.0 - 2.0 * ( 1.0 - base ) * ( 1.0 - blend ) ) );
 
-    '}',
+    }
 
-    'vec3 blendOverlay( vec3 base, vec3 blend ) {',
+    vec3 blendOverlay( vec3 base, vec3 blend ) {
 
-    '	return vec3( blendOverlay( base.r, blend.r ), blendOverlay( base.g, blend.g ),blendOverlay( base.b, blend.b ) );',
+    	return vec3( blendOverlay( base.r, blend.r ), blendOverlay( base.g, blend.g ),blendOverlay( base.b, blend.b ) );
 
-    '}',
+    }
 
-    'void main() {',
+    void main() {
 
-    ' float waveStrength = 0.1;',
-    ' float waveSpeed = 0.03;',
+     float waveStrength = 0.1;
+     float waveSpeed = 0.03;
 
     // simple distortion (ripple) via dudv map (see https://www.youtube.com/watch?v=6B7IF6GOu7s)
 
-    '	vec2 distortedUv = texture2D( tDudv, vec2( vUv.x + time * waveSpeed, vUv.y ) ).rg * waveStrength;',
-    '	distortedUv = vUv.xy + vec2( distortedUv.x, distortedUv.y + time * waveSpeed );',
-    '	vec2 distortion = ( texture2D( tDudv, distortedUv ).rg * 2.0 - 1.0 ) * waveStrength;',
+    	vec2 distortedUv = texture2D( tDudv, vec2( vUv.x + time * waveSpeed, vUv.y ) ).rg * waveStrength;
+    	distortedUv = vUv.xy + vec2( distortedUv.x, distortedUv.y + time * waveSpeed );
+    	vec2 distortion = ( texture2D( tDudv, distortedUv ).rg * 2.0 - 1.0 ) * waveStrength;
 
     // new uv coords
 
-    ' vec4 uv = vec4( vUvRefraction );',
-    ' uv.xy += distortion;',
+     vec4 uv = vec4( vUvRefraction );
+     uv.xy += distortion;
 
-    '	vec4 base = texture2DProj( tDiffuse, uv );',
+    	vec4 base = texture2DProj( tDiffuse, uv );
 
-    '	gl_FragColor = vec4( blendOverlay( base.rgb, color ), 1.0 );',
+    	gl_FragColor = vec4( blendOverlay( base.rgb, color ), 1.0 );
 
-    '}',
-  ].join('\n'),
+    }
+  `,
 }
diff --git a/src/utils/GeometryCompressionUtils.js b/src/utils/GeometryCompressionUtils.js
index dec6b46e..7bee13fe 100644
--- a/src/utils/GeometryCompressionUtils.js
+++ b/src/utils/GeometryCompressionUtils.js
@@ -14,8 +14,8 @@ import {
   ShaderLib,
   UniformsUtils,
   Vector3,
-  REVISION,
 } from 'three'
+import { version } from '../_polyfill/constants'
 
 var GeometryCompressionUtils = {
   /**
@@ -732,7 +732,7 @@ class PackedPhongMaterial extends MeshPhongMaterial {
       'gl_FragColor = vec4( outgoingLight, diffuseColor.a );',
 
       ShaderChunk.tonemapping_fragment,
-      parseInt(REVISION.replace(/\D+/g, '')) >= 154 ? ShaderChunk.colorspace_fragment : ShaderChunk.encodings_fragment,
+      version >= 154 ? ShaderChunk.colorspace_fragment : ShaderChunk.encodings_fragment,
       ShaderChunk.fog_fragment,
       ShaderChunk.premultiplied_alpha_fragment,
       ShaderChunk.dithering_fragment,
diff --git a/src/utils/LDrawUtils.js b/src/utils/LDrawUtils.js
index 1329807f..de7ab99c 100644
--- a/src/utils/LDrawUtils.js
+++ b/src/utils/LDrawUtils.js
@@ -1,8 +1,8 @@
 import { BufferAttribute, BufferGeometry, Group, LineSegments, Matrix3, Mesh } from 'three'
 import { mergeBufferGeometries } from './BufferGeometryUtils'
 
-class LDrawUtils {
-  static mergeObject(object) {
+const LDrawUtils = {
+  mergeObject(object) {
     // Merges geometries in object by materials and returns new object. Use on not indexed geometries.
     // The object buffers reference the old object ones.
     // Special treatment is done to the conditional lines generated by LDrawLoader.
@@ -150,7 +150,7 @@ class LDrawUtils {
     mergedObject.userData.numConstructionSteps = 1
 
     return mergedObject
-  }
+  },
 }
 
 export { LDrawUtils }
diff --git a/src/utils/RoughnessMipmapper.js b/src/utils/RoughnessMipmapper.js
index 46e58c7c..6b58a42b 100644
--- a/src/utils/RoughnessMipmapper.js
+++ b/src/utils/RoughnessMipmapper.js
@@ -17,11 +17,11 @@ import {
   WebGLRenderTarget,
 } from 'three'
 
-var _mipmapMaterial = _getMipmapMaterial()
+var _mipmapMaterial = /* @__PURE__ */ _getMipmapMaterial()
 
-var _mesh = new Mesh(new PlaneGeometry(2, 2), _mipmapMaterial)
+var _mesh = /* @__PURE__ */ new Mesh(/* @__PURE__ */ new PlaneGeometry(2, 2), _mipmapMaterial)
 
-var _flatCamera = new OrthographicCamera(0, 1, 0, 1, 0, 1)
+var _flatCamera = /* @__PURE__ */ new OrthographicCamera(0, 1, 0, 1, 0, 1)
 
 var _tempTarget = null
 
diff --git a/src/webxr/ARButton.ts b/src/webxr/ARButton.ts
index d29b80dc..e3423354 100644
--- a/src/webxr/ARButton.ts
+++ b/src/webxr/ARButton.ts
@@ -1,7 +1,7 @@
 import { WebGLRenderer } from 'three'
 
-class ARButton {
-  static createButton(renderer: WebGLRenderer, sessionInit: XRSessionInit = {}): HTMLButtonElement | HTMLAnchorElement {
+const ARButton = {
+  createButton(renderer: WebGLRenderer, sessionInit: XRSessionInit = {}): HTMLButtonElement | HTMLAnchorElement {
     const button = document.createElement('button')
 
     function showStartAR(/*device*/): void {
@@ -156,7 +156,7 @@ class ARButton {
 
       return message
     }
-  }
+  },
 }
 
 export { ARButton }
diff --git a/src/webxr/OculusHandPointerModel.js b/src/webxr/OculusHandPointerModel.js
index 4881455c..00e044a5 100644
--- a/src/webxr/OculusHandPointerModel.js
+++ b/src/webxr/OculusHandPointerModel.js
@@ -13,8 +13,8 @@ const POINTER_LENGTH = 0.035
 const POINTER_SEGMENTS = 16
 const POINTER_RINGS = 12
 const POINTER_HEMISPHERE_ANGLE = 110
-const YAXIS = new THREE.Vector3(0, 1, 0)
-const ZAXIS = new THREE.Vector3(0, 0, 1)
+const YAXIS = /* @__PURE__ */ new THREE.Vector3(0, 1, 0)
+const ZAXIS = /* @__PURE__ */ new THREE.Vector3(0, 0, 1)
 
 const CURSOR_RADIUS = 0.02
 const CURSOR_MAX_DISTANCE = 1.5
diff --git a/src/webxr/VRButton.d.ts b/src/webxr/VRButton.d.ts
new file mode 100644
index 00000000..10849ef8
--- /dev/null
+++ b/src/webxr/VRButton.d.ts
@@ -0,0 +1,11 @@
+import { WebGLRenderer } from 'three'
+
+declare class VRButton {
+  static createButton(renderer: WebGLRenderer, sessionInit?: XRSessionInit): HTMLButtonElement | HTMLAnchorElement
+
+  static xrSessionIsGranted: boolean
+
+  static registerSessionGrantedListener(): void
+}
+
+export { VRButton }
diff --git a/src/webxr/VRButton.js b/src/webxr/VRButton.js
new file mode 100644
index 00000000..5fe15783
--- /dev/null
+++ b/src/webxr/VRButton.js
@@ -0,0 +1,150 @@
+const VRButton = /* @__PURE__ */ (() => {
+  class VRButton {
+    static createButton(renderer, sessionInit = {}) {
+      const button = document.createElement('button')
+
+      function showEnterVR(/*device*/) {
+        let currentSession = null
+
+        async function onSessionStarted(session) {
+          session.addEventListener('end', onSessionEnded)
+
+          await renderer.xr.setSession(session)
+          button.textContent = 'EXIT VR'
+
+          currentSession = session
+        }
+
+        function onSessionEnded(/*event*/) {
+          currentSession.removeEventListener('end', onSessionEnded)
+
+          button.textContent = 'ENTER VR'
+
+          currentSession = null
+        }
+
+        //
+
+        button.style.display = ''
+
+        button.style.cursor = 'pointer'
+        button.style.left = 'calc(50% - 50px)'
+        button.style.width = '100px'
+
+        button.textContent = 'ENTER VR'
+
+        button.onmouseenter = () => {
+          button.style.opacity = '1.0'
+        }
+
+        button.onmouseleave = () => {
+          button.style.opacity = '0.5'
+        }
+
+        button.onclick = () => {
+          if (currentSession === null) {
+            // WebXR's requestReferenceSpace only works if the corresponding feature
+            // was requested at session creation time. For simplicity, just ask for
+            // the interesting ones as optional features, but be aware that the
+            // requestReferenceSpace call will fail if it turns out to be unavailable.
+            // ('local' is always available for immersive sessions and doesn't need to
+            // be requested separately.)
+
+            const optionalFeatures = [sessionInit.optionalFeatures, 'local-floor', 'bounded-floor', 'hand-tracking']
+              .flat()
+              .filter(Boolean)
+
+            navigator.xr?.requestSession('immersive-vr', { ...sessionInit, optionalFeatures }).then(onSessionStarted)
+          } else {
+            currentSession.end()
+          }
+        }
+      }
+
+      function disableButton() {
+        button.style.display = ''
+
+        button.style.cursor = 'auto'
+        button.style.left = 'calc(50% - 75px)'
+        button.style.width = '150px'
+
+        button.onmouseenter = null
+        button.onmouseleave = null
+
+        button.onclick = null
+      }
+
+      function showWebXRNotFound() {
+        disableButton()
+
+        button.textContent = 'VR NOT SUPPORTED'
+      }
+
+      function stylizeElement(element) {
+        element.style.position = 'absolute'
+        element.style.bottom = '20px'
+        element.style.padding = '12px 6px'
+        element.style.border = '1px solid #fff'
+        element.style.borderRadius = '4px'
+        element.style.background = 'rgba(0,0,0,0.1)'
+        element.style.color = '#fff'
+        element.style.font = 'normal 13px sans-serif'
+        element.style.textAlign = 'center'
+        element.style.opacity = '0.5'
+        element.style.outline = 'none'
+        element.style.zIndex = '999'
+      }
+
+      if ('xr' in navigator) {
+        stylizeElement(button)
+        button.id = 'VRButton'
+        button.style.display = 'none'
+
+        // Query for session mode
+        navigator.xr.isSessionSupported('immersive-vr').then((supported) => {
+          supported ? showEnterVR() : showWebXRNotFound()
+
+          if (supported && VRButton.xrSessionIsGranted) {
+            button.click()
+          }
+        })
+
+        return button
+      } else {
+        const message = document.createElement('a')
+
+        if (window.isSecureContext === false) {
+          message.href = document.location.href.replace(/^http:/, 'https:')
+          message.innerHTML = 'WEBXR NEEDS HTTPS' // TODO Improve message
+        } else {
+          message.href = 'https://immersiveweb.dev/'
+          message.innerHTML = 'WEBXR NOT AVAILABLE'
+        }
+
+        message.style.left = 'calc(50% - 90px)'
+        message.style.width = '180px'
+        message.style.textDecoration = 'none'
+
+        stylizeElement(message)
+
+        return message
+      }
+    }
+
+    static xrSessionIsGranted = false
+
+    static registerSessionGrantedListener() {
+      if (typeof navigator !== 'undefined' && 'xr' in navigator) {
+        navigator.xr.addEventListener('sessiongranted', () => {
+          VRButton.xrSessionIsGranted = true
+        })
+      }
+    }
+  }
+
+  VRButton.registerSessionGrantedListener()
+
+  return VRButton
+})()
+
+export { VRButton }
diff --git a/src/webxr/VRButton.ts b/src/webxr/VRButton.ts
deleted file mode 100644
index 1ec7a521..00000000
--- a/src/webxr/VRButton.ts
+++ /dev/null
@@ -1,150 +0,0 @@
-import { WebGLRenderer } from 'three'
-
-class VRButton {
-  static createButton(renderer: WebGLRenderer, sessionInit: XRSessionInit = {}): HTMLButtonElement | HTMLAnchorElement {
-    const button = document.createElement('button')
-
-    function showEnterVR(/*device*/): void {
-      let currentSession: XRSession | null = null
-
-      async function onSessionStarted(session: XRSession): Promise<void> {
-        session.addEventListener('end', onSessionEnded)
-
-        await renderer.xr.setSession(session as any)
-        button.textContent = 'EXIT VR'
-
-        currentSession = session
-      }
-
-      function onSessionEnded(/*event*/): void {
-        currentSession!.removeEventListener('end', onSessionEnded)
-
-        button.textContent = 'ENTER VR'
-
-        currentSession = null
-      }
-
-      //
-
-      button.style.display = ''
-
-      button.style.cursor = 'pointer'
-      button.style.left = 'calc(50% - 50px)'
-      button.style.width = '100px'
-
-      button.textContent = 'ENTER VR'
-
-      button.onmouseenter = (): void => {
-        button.style.opacity = '1.0'
-      }
-
-      button.onmouseleave = (): void => {
-        button.style.opacity = '0.5'
-      }
-
-      button.onclick = (): void => {
-        if (currentSession === null) {
-          // WebXR's requestReferenceSpace only works if the corresponding feature
-          // was requested at session creation time. For simplicity, just ask for
-          // the interesting ones as optional features, but be aware that the
-          // requestReferenceSpace call will fail if it turns out to be unavailable.
-          // ('local' is always available for immersive sessions and doesn't need to
-          // be requested separately.)
-
-          const optionalFeatures = [sessionInit.optionalFeatures, 'local-floor', 'bounded-floor', 'hand-tracking']
-            .flat()
-            .filter(Boolean) as string[]
-
-          ;(navigator as Navigator).xr
-            ?.requestSession('immersive-vr', { ...sessionInit, optionalFeatures })
-            .then(onSessionStarted)
-        } else {
-          currentSession.end()
-        }
-      }
-    }
-
-    function disableButton(): void {
-      button.style.display = ''
-
-      button.style.cursor = 'auto'
-      button.style.left = 'calc(50% - 75px)'
-      button.style.width = '150px'
-
-      button.onmouseenter = null
-      button.onmouseleave = null
-
-      button.onclick = null
-    }
-
-    function showWebXRNotFound(): void {
-      disableButton()
-
-      button.textContent = 'VR NOT SUPPORTED'
-    }
-
-    function stylizeElement(element: HTMLElement): void {
-      element.style.position = 'absolute'
-      element.style.bottom = '20px'
-      element.style.padding = '12px 6px'
-      element.style.border = '1px solid #fff'
-      element.style.borderRadius = '4px'
-      element.style.background = 'rgba(0,0,0,0.1)'
-      element.style.color = '#fff'
-      element.style.font = 'normal 13px sans-serif'
-      element.style.textAlign = 'center'
-      element.style.opacity = '0.5'
-      element.style.outline = 'none'
-      element.style.zIndex = '999'
-    }
-
-    if ('xr' in navigator) {
-      stylizeElement(button)
-      button.id = 'VRButton'
-      button.style.display = 'none'
-
-      // Query for session mode
-      navigator.xr!.isSessionSupported('immersive-vr').then((supported) => {
-        supported ? showEnterVR() : showWebXRNotFound()
-
-        if (supported && VRButton.xrSessionIsGranted) {
-          button.click()
-        }
-      })
-
-      return button
-    } else {
-      const message = document.createElement('a')
-
-      if (window.isSecureContext === false) {
-        message.href = document.location.href.replace(/^http:/, 'https:')
-        message.innerHTML = 'WEBXR NEEDS HTTPS' // TODO Improve message
-      } else {
-        message.href = 'https://immersiveweb.dev/'
-        message.innerHTML = 'WEBXR NOT AVAILABLE'
-      }
-
-      message.style.left = 'calc(50% - 90px)'
-      message.style.width = '180px'
-      message.style.textDecoration = 'none'
-
-      stylizeElement(message)
-
-      return message
-    }
-  }
-
-  static xrSessionIsGranted = false
-
-  static registerSessionGrantedListener(): void {
-    if (typeof navigator !== 'undefined' && 'xr' in navigator) {
-      ;(navigator as Navigator).xr!.addEventListener('sessiongranted', () => {
-        VRButton.xrSessionIsGranted = true
-      })
-    }
-  }
-}
-
-VRButton.registerSessionGrantedListener()
-
-export { VRButton }
diff --git a/src/webxr/XRHandPrimitiveModel.js b/src/webxr/XRHandPrimitiveModel.js
index 9e98456a..a967f563 100644
--- a/src/webxr/XRHandPrimitiveModel.js
+++ b/src/webxr/XRHandPrimitiveModel.js
@@ -8,8 +8,8 @@ import {
   Vector3,
 } from 'three'
 
-const _matrix = new Matrix4()
-const _vector = new Vector3()
+const _matrix = /* @__PURE__ */ new Matrix4()
+const _vector = /* @__PURE__ */ new Vector3()
 
 class XRHandPrimitiveModel {
   constructor(handModel, controller, path, handedness, options) {

From 75554358091d33a60cd95e25544a3de2a304907a Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Sat, 11 Jan 2025 16:55:31 -0600
Subject: [PATCH 36/36] fix(Lensflare): implement framebuffer texture for GPU
 storage (#397)

---
 src/objects/Lensflare.js | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/objects/Lensflare.js b/src/objects/Lensflare.js
index 736287ee..969dcdc2 100644
--- a/src/objects/Lensflare.js
+++ b/src/objects/Lensflare.js
@@ -2,15 +2,13 @@ import {
   AdditiveBlending,
   Box2,
   BufferGeometry,
-  ClampToEdgeWrapping,
   Color,
-  DataTexture,
+  Texture,
+  NearestFilter,
   InterleavedBuffer,
   InterleavedBufferAttribute,
   Mesh,
   MeshBasicMaterial,
-  NearestFilter,
-  RGBAFormat,
   RawShaderMaterial,
   Vector2,
   Vector3,
@@ -34,17 +32,19 @@ const Lensflare = /* @__PURE__ */ (() => {
       const positionView = new Vector3()
 
       // textures
-      const tempMap = new DataTexture(new Uint8Array(16 * 16 * 3), 16, 16, RGBAFormat)
-      tempMap.minFilter = NearestFilter
+      const tempMap = new Texture({ width: 16, height: 16 })
+      tempMap.isFramebufferTexture = true
       tempMap.magFilter = NearestFilter
-      tempMap.wrapS = ClampToEdgeWrapping
-      tempMap.wrapT = ClampToEdgeWrapping
+      tempMap.minFilter = NearestFilter
+      tempMap.generateMipmaps = false
+      tempMap.needsUpdate = true
 
-      const occlusionMap = new DataTexture(new Uint8Array(16 * 16 * 3), 16, 16, RGBAFormat)
-      occlusionMap.minFilter = NearestFilter
+      const occlusionMap = new Texture({ width: 16, height: 16 })
+      occlusionMap.isFramebufferTexture = true
       occlusionMap.magFilter = NearestFilter
-      occlusionMap.wrapS = ClampToEdgeWrapping
-      occlusionMap.wrapT = ClampToEdgeWrapping
+      occlusionMap.minFilter = NearestFilter
+      occlusionMap.generateMipmaps = false
+      occlusionMap.needsUpdate = true
 
       // material