3d-force-graph 1.77.1 → 1.78.0

package/dist/3d-force-graph.js

@@ -1,4 +1,4 @@
-// Version 1.77.1 3d-force-graph - https://github.com/vasturiano/3d-force-graph
+// Version 1.78.0 3d-force-graph - https://github.com/vasturiano/3d-force-graph
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
   typeof define === 'function' && define.amd ? define(factory) :
@@ -108,7 +108,7 @@
    * Copyright 2010-2025 Three.js Authors
    * SPDX-License-Identifier: MIT
    */
-  const REVISION = '177';
+  const REVISION = '178';
 
   /**
    * Represents mouse buttons and interaction types in context of controls.
@@ -3704,7 +3704,7 @@
 
   		let r = vFrom.dot( vTo ) + 1;
 
-  		if ( r < Number.EPSILON ) {
+  		if ( r < 1e-8 ) { // the epsilon value has been discussed in #31286
 
   			// vFrom and vTo point in opposite directions
 
@@ -12919,7 +12919,7 @@
   const _childaddedEvent = { type: 'childadded', child: null };
 
   /**
-   * Fires when a new child object has been added.
+   * Fires when a child object has been removed.
    *
    * @event Object3D#childremoved
    * @type {Object}
@@ -17480,7 +17480,7 @@
   		/**
   		 * Applies to integer data only. Indicates how the underlying data in the buffer maps to
   		 * the values in the GLSL code. For instance, if `array` is an instance of `UInt16Array`,
-  		 * and `normalized` is `true`, the values `0 -+65535` in the array data will be mapped to
+  		 * and `normalized` is `true`, the values `0 - +65535` in the array data will be mapped to
   		 * `0.0f - +1.0f` in the GLSL attribute. If `normalized` is `false`, the values will be converted
   		 * to floats unmodified, i.e. `65535` becomes `65535.0f`.
   		 *
@@ -18118,8 +18118,8 @@
    * Convenient class that can be used when creating a `Float16` buffer attribute with
    * a plain `Array` instance.
    *
-   * This class automatically converts to and from FP16 since `Float16Array` is not
-   * natively supported in JavaScript.
+   * This class automatically converts to and from FP16 via `Uint16Array` since `Float16Array`
+   * browser support is still problematic.
    *
    * @augments BufferAttribute
    */
@@ -24013,6 +24013,7 @@
   }
 
   const _sphere$3 = /*@__PURE__*/ new Sphere();
+  const _defaultSpriteCenter = /*@__PURE__*/ new Vector2( 0.5, 0.5 );
   const _vector$6 = /*@__PURE__*/ new Vector3();
 
   /**
@@ -24170,7 +24171,10 @@
   	intersectsSprite( sprite ) {
 
   		_sphere$3.center.set( 0, 0, 0 );
-  		_sphere$3.radius = 0.7071067811865476;
+
+  		const offset = _defaultSpriteCenter.distanceTo( sprite.center );
+
+  		_sphere$3.radius = 0.7071067811865476 + offset;
   		_sphere$3.applyMatrix4( sprite.matrixWorld );
 
   		return this.intersectsSphere( _sphere$3 );
@@ -31768,6 +31772,8 @@
    */
   Loader.DEFAULT_MATERIAL_NAME = '__DEFAULT';
 
+  const _loading = new WeakMap();
+
   /**
    * A loader for loading images. The class loads images with the HTML `Image` API.
    *
@@ -31814,19 +31820,36 @@
 
   		const scope = this;
 
-  		const cached = Cache.get( url );
+  		const cached = Cache.get( `image:${url}` );
 
   		if ( cached !== undefined ) {
 
-  			scope.manager.itemStart( url );
+  			if ( cached.complete === true ) {
+
+  				scope.manager.itemStart( url );
+
+  				setTimeout( function () {
+
+  					if ( onLoad ) onLoad( cached );
+
+  					scope.manager.itemEnd( url );
+
+  				}, 0 );
 
-  			setTimeout( function () {
+  			} else {
+
+  				let arr = _loading.get( cached );
 
-  				if ( onLoad ) onLoad( cached );
+  				if ( arr === undefined ) {
 
-  				scope.manager.itemEnd( url );
+  					arr = [];
+  					_loading.set( cached, arr );
 
-  			}, 0 );
+  				}
+
+  				arr.push( { onLoad, onError } );
+
+  			}
 
   			return cached;
 
@@ -31838,10 +31861,21 @@
 
   			removeEventListeners();
 
-  			Cache.add( url, this );
-
   			if ( onLoad ) onLoad( this );
 
+  			//
+
+  			const callbacks = _loading.get( this ) || [];
+
+  			for ( let i = 0; i < callbacks.length; i ++ ) {
+
+  				const callback = callbacks[ i ];
+  				if ( callback.onLoad ) callback.onLoad( this );
+
+  			}
+
+  			_loading.delete( this );
+
   			scope.manager.itemEnd( url );
 
   		}
@@ -31852,6 +31886,22 @@
 
   			if ( onError ) onError( event );
 
+  			Cache.remove( `image:${url}` );
+
+  			//
+
+  			const callbacks = _loading.get( this ) || [];
+
+  			for ( let i = 0; i < callbacks.length; i ++ ) {
+
+  				const callback = callbacks[ i ];
+  				if ( callback.onError ) callback.onError( event );
+
+  			}
+
+  			_loading.delete( this );
+
+
   			scope.manager.itemError( url );
   			scope.manager.itemEnd( url );
 
@@ -31873,6 +31923,7 @@
 
   		}
 
+  		Cache.add( `image:${url}`, image );
   		scope.manager.itemStart( url );
 
   		image.src = url;
@@ -33937,7 +33988,7 @@
   	 */
   	start() {
 
-  		this.startTime = now$3();
+  		this.startTime = performance.now();
 
   		this.oldTime = this.startTime;
   		this.elapsedTime = 0;
@@ -33986,7 +34037,7 @@
 
   		if ( this.running ) {
 
-  			const newTime = now$3();
+  			const newTime = performance.now();
 
   			diff = ( newTime - this.oldTime ) / 1000;
   			this.oldTime = newTime;
@@ -34001,12 +34052,6 @@
 
   }
 
-  function now$3() {
-
-  	return performance.now();
-
-  }
-
   /**
    * An instanced version of an interleaved buffer.
    *
@@ -34957,6 +35002,10 @@
 
   			type = gl.FLOAT;
 
+  		} else if ( typeof Float16Array !== 'undefined' && array instanceof Float16Array ) {
+
+  			type = gl.HALF_FLOAT;
+
   		} else if ( array instanceof Uint16Array ) {
 
   			if ( attribute.isFloat16BufferAttribute ) {
@@ -41934,7 +41983,7 @@
   			useFog: material.fog === true,
   			fogExp2: ( !! fog && fog.isFogExp2 ),
 
-  			flatShading: material.flatShading === true,
+  			flatShading: ( material.flatShading === true && material.wireframe === false ),
 
   			sizeAttenuation: material.sizeAttenuation === true,
   			logarithmicDepthBuffer: logarithmicDepthBuffer,
@@ -42147,6 +42196,8 @@
   			_programLayers.enable( 20 );
   		if ( parameters.batchingColor )
   			_programLayers.enable( 21 );
+  		if ( parameters.gradientMap )
+  			_programLayers.enable( 22 );
 
   		array.push( _programLayers.mask );
   		_programLayers.disableAll();
@@ -44328,7 +44379,7 @@
   							break;
 
   						case MultiplyBlending:
-  							gl.blendFuncSeparate( gl.ZERO, gl.SRC_COLOR, gl.ZERO, gl.SRC_ALPHA );
+  							gl.blendFuncSeparate( gl.DST_COLOR, gl.ONE_MINUS_SRC_ALPHA, gl.ZERO, gl.ONE );
   							break;
 
   						default:
@@ -44346,15 +44397,15 @@
   							break;
 
   						case AdditiveBlending:
-  							gl.blendFunc( gl.SRC_ALPHA, gl.ONE );
+  							gl.blendFuncSeparate( gl.SRC_ALPHA, gl.ONE, gl.ONE, gl.ONE );
   							break;
 
   						case SubtractiveBlending:
-  							gl.blendFuncSeparate( gl.ZERO, gl.ONE_MINUS_SRC_COLOR, gl.ZERO, gl.ONE );
+  							console.error( 'THREE.WebGLState: SubtractiveBlending requires material.premultipliedAlpha = true' );
   							break;
 
   						case MultiplyBlending:
-  							gl.blendFunc( gl.ZERO, gl.SRC_COLOR );
+  							console.error( 'THREE.WebGLState: MultiplyBlending requires material.premultipliedAlpha = true' );
   							break;
 
   						default:
@@ -51489,6 +51540,9 @@ void main() {
   			//
 
   			const currentRenderTarget = _this.getRenderTarget();
+  			const currentActiveCubeFace = _this.getActiveCubeFace();
+  			const currentActiveMipmapLevel = _this.getActiveMipmapLevel();
+
   			_this.setRenderTarget( transmissionRenderTarget );
 
   			_this.getClearColor( _currentClearColor );
@@ -51558,7 +51612,7 @@ void main() {
 
   			}
 
-  			_this.setRenderTarget( currentRenderTarget );
+  			_this.setRenderTarget( currentRenderTarget, currentActiveCubeFace, currentActiveMipmapLevel );
 
   			_this.setClearColor( _currentClearColor, _currentClearAlpha );
 
@@ -52488,7 +52542,7 @@ void main() {
 
   					if ( ( x >= 0 && x <= ( renderTarget.width - width ) ) && ( y >= 0 && y <= ( renderTarget.height - height ) ) ) {
 
-  						// when using MRT, select the corect color buffer for the subsequent read command
+  						// when using MRT, select the correct color buffer for the subsequent read command
 
   						if ( renderTarget.textures.length > 1 ) _gl.readBuffer( _gl.COLOR_ATTACHMENT0 + textureIndex );
 
@@ -60879,6 +60933,11 @@ function InsertStackElement(node, body) {
         triggerUpdate: false
       },
       // in link length ratio per frame
+      linkDirectionalParticleOffset: {
+        "default": 0,
+        triggerUpdate: false
+      },
+      // starting position offset along the link's length, like a pre-delay. Values between [0, 1]
       linkDirectionalParticleWidth: {
         "default": 0.5
       },
@@ -60887,6 +60946,7 @@ function InsertStackElement(node, body) {
         "default": 4
       },
       // how many slice segments in the particle sphere's circumference
+      linkDirectionalParticleThreeObject: {},
       forceEngine: {
         "default": 'd3'
       },
@@ -61229,6 +61289,7 @@ function InsertStackElement(node, body) {
         function updatePhotons() {
           // update link particle positions
           var particleSpeedAccessor = index$1(state.linkDirectionalParticleSpeed);
+          var particleOffsetAccessor = index$1(state.linkDirectionalParticleOffset);
           state.graphData.links.forEach(function (link) {
             var photonsObj = state.particlesDataMapper.getObj(link);
             var cyclePhotons = photonsObj && photonsObj.children;
@@ -61240,6 +61301,7 @@ function InsertStackElement(node, body) {
             if (!start || !end || !start.hasOwnProperty('x') || !end.hasOwnProperty('x')) return; // skip invalid link
 
             var particleSpeed = particleSpeedAccessor(link);
+            var particleOffset = Math.abs(particleOffsetAccessor(link));
             var getPhotonPos = link.__curve ? function (t) {
               return link.__curve.getPoint(t);
             } // interpolate along bezier curve
@@ -61258,7 +61320,7 @@ function InsertStackElement(node, body) {
             photons.forEach(function (photon, idx) {
               var singleHop = photon.parent.__linkThreeObjType === 'singleHopPhotons';
               if (!photon.hasOwnProperty('__progressRatio')) {
-                photon.__progressRatio = singleHop ? 0 : idx / cyclePhotons.length;
+                photon.__progressRatio = singleHop ? 0 : (idx + particleOffset) / cyclePhotons.length;
               }
               photon.__progressRatio += particleSpeed;
               if (photon.__progressRatio >= 1) {
@@ -61273,6 +61335,9 @@ function InsertStackElement(node, body) {
               }
               var photonPosRatio = photon.__progressRatio;
               var pos = getPhotonPos(photonPosRatio);
+
+              // Orient asymmetrical particles to target
+              photon.geometry.type !== 'SphereGeometry' && photon.lookAt(pos.x, pos.y, pos.z);
               ['x', 'y', 'z'].forEach(function (dim) {
                 return photon.position[dim] = pos[dim];
               });
@@ -61288,23 +61353,31 @@ function InsertStackElement(node, body) {
             link.__singleHopPhotonsObj = obj;
             state.graphScene.add(obj);
           }
-          var particleWidthAccessor = index$1(state.linkDirectionalParticleWidth);
-          var photonR = Math.ceil(particleWidthAccessor(link) * 10) / 10 / 2;
-          var numSegments = state.linkDirectionalParticleResolution;
-          var particleGeometry = new three$1$1.SphereGeometry(photonR, numSegments, numSegments);
-          var linkColorAccessor = index$1(state.linkColor);
-          var particleColorAccessor = index$1(state.linkDirectionalParticleColor);
-          var photonColor = particleColorAccessor(link) || linkColorAccessor(link) || '#f0f0f0';
-          var materialColor = new three$1$1.Color(colorStr2Hex(photonColor));
-          var opacity = state.linkOpacity * 3;
-          var particleMaterial = new three$1$1.MeshLambertMaterial({
-            color: materialColor,
-            transparent: true,
-            opacity: opacity
-          });
+          var particleObj = index$1(state.linkDirectionalParticleThreeObject)(link);
+          if (particleObj && state.linkDirectionalParticleThreeObject === particleObj) {
+            // clone object if it's a shared object among all links
+            particleObj = particleObj.clone();
+          }
+          if (!particleObj) {
+            var particleWidthAccessor = index$1(state.linkDirectionalParticleWidth);
+            var photonR = Math.ceil(particleWidthAccessor(link) * 10) / 10 / 2;
+            var numSegments = state.linkDirectionalParticleResolution;
+            var particleGeometry = new three$1$1.SphereGeometry(photonR, numSegments, numSegments);
+            var linkColorAccessor = index$1(state.linkColor);
+            var particleColorAccessor = index$1(state.linkDirectionalParticleColor);
+            var photonColor = particleColorAccessor(link) || linkColorAccessor(link) || '#f0f0f0';
+            var materialColor = new three$1$1.Color(colorStr2Hex(photonColor));
+            var opacity = state.linkOpacity * 3;
+            var particleMaterial = new three$1$1.MeshLambertMaterial({
+              color: materialColor,
+              transparent: true,
+              opacity: opacity
+            });
+            particleObj = new three$1$1.Mesh(particleGeometry, particleMaterial);
+          }
 
           // add a single hop particle
-          link.__singleHopPhotonsObj.add(new three$1$1.Mesh(particleGeometry, particleMaterial));
+          link.__singleHopPhotonsObj.add(particleObj);
         }
         return this;
       },
@@ -61445,7 +61518,7 @@ function InsertStackElement(node, body) {
       }
 
       // Digest links WebGL objects
-      if (state._flushObjects || hasAnyPropChanged(['graphData', 'linkThreeObject', 'linkThreeObjectExtend', 'linkMaterial', 'linkColor', 'linkWidth', 'linkVisibility', 'linkResolution', 'linkOpacity', 'linkDirectionalArrowLength', 'linkDirectionalArrowColor', 'linkDirectionalArrowResolution', 'linkDirectionalParticles', 'linkDirectionalParticleWidth', 'linkDirectionalParticleColor', 'linkDirectionalParticleResolution'])) {
+      if (state._flushObjects || hasAnyPropChanged(['graphData', 'linkThreeObject', 'linkThreeObjectExtend', 'linkMaterial', 'linkColor', 'linkWidth', 'linkVisibility', 'linkResolution', 'linkOpacity', 'linkDirectionalArrowLength', 'linkDirectionalArrowColor', 'linkDirectionalArrowResolution', 'linkDirectionalParticles', 'linkDirectionalParticleWidth', 'linkDirectionalParticleColor', 'linkDirectionalParticleResolution', 'linkDirectionalParticleThreeObject'])) {
         var _customObjectAccessor = index$1(state.linkThreeObject);
         var _customObjectExtendAccessor = index$1(state.linkThreeObjectExtend);
         var customMaterialAccessor = index$1(state.linkMaterial);
@@ -61590,6 +61663,7 @@ function InsertStackElement(node, body) {
           var particlesAccessor = index$1(state.linkDirectionalParticles);
           var particleWidthAccessor = index$1(state.linkDirectionalParticleWidth);
           var particleColorAccessor = index$1(state.linkDirectionalParticleColor);
+          var particleObjectAccessor = index$1(state.linkDirectionalParticleThreeObject);
           var particleMaterials = {}; // indexed by link color
           var particleGeometries = {}; // indexed by particle width
 
@@ -61600,39 +61674,47 @@ function InsertStackElement(node, body) {
             obj.__photonDataMapper = new ThreeDigest(obj);
             return obj;
           }).onUpdateObj(function (obj, link) {
-            var numPhotons = Math.round(Math.abs(particlesAccessor(link)));
             var curPhoton = !!obj.children.length && obj.children[0];
-            var photonR = Math.ceil(particleWidthAccessor(link) * 10) / 10 / 2;
-            var numSegments = state.linkDirectionalParticleResolution;
-            var particleGeometry;
-            if (curPhoton && curPhoton.geometry.parameters.radius === photonR && curPhoton.geometry.parameters.widthSegments === numSegments) {
-              particleGeometry = curPhoton.geometry;
+            var customObj = particleObjectAccessor(link);
+            var particleGeometry, particleMaterial;
+            if (customObj) {
+              particleGeometry = customObj.geometry;
+              particleMaterial = customObj.material;
             } else {
-              if (!particleGeometries.hasOwnProperty(photonR)) {
-                particleGeometries[photonR] = new three$1$1.SphereGeometry(photonR, numSegments, numSegments);
+              var photonR = Math.ceil(particleWidthAccessor(link) * 10) / 10 / 2;
+              var numSegments = state.linkDirectionalParticleResolution;
+              if (curPhoton && curPhoton.geometry.parameters.radius === photonR && curPhoton.geometry.parameters.widthSegments === numSegments) {
+                particleGeometry = curPhoton.geometry;
+              } else {
+                if (!particleGeometries.hasOwnProperty(photonR)) {
+                  particleGeometries[photonR] = new three$1$1.SphereGeometry(photonR, numSegments, numSegments);
+                }
+                particleGeometry = particleGeometries[photonR];
               }
-              particleGeometry = particleGeometries[photonR];
-              curPhoton && curPhoton.geometry.dispose();
-            }
-            var photonColor = particleColorAccessor(link) || _colorAccessor(link) || '#f0f0f0';
-            var materialColor = new three$1$1.Color(colorStr2Hex(photonColor));
-            var opacity = state.linkOpacity * 3;
-            var particleMaterial;
-            if (curPhoton && curPhoton.material.color.equals(materialColor) && curPhoton.material.opacity === opacity) {
-              particleMaterial = curPhoton.material;
-            } else {
-              if (!particleMaterials.hasOwnProperty(photonColor)) {
-                particleMaterials[photonColor] = new three$1$1.MeshLambertMaterial({
-                  color: materialColor,
-                  transparent: true,
-                  opacity: opacity
-                });
+              var photonColor = particleColorAccessor(link) || _colorAccessor(link) || '#f0f0f0';
+              var materialColor = new three$1$1.Color(colorStr2Hex(photonColor));
+              var opacity = state.linkOpacity * 3;
+              if (curPhoton && curPhoton.material.color.equals(materialColor) && curPhoton.material.opacity === opacity) {
+                particleMaterial = curPhoton.material;
+              } else {
+                if (!particleMaterials.hasOwnProperty(photonColor)) {
+                  particleMaterials[photonColor] = new three$1$1.MeshLambertMaterial({
+                    color: materialColor,
+                    transparent: true,
+                    opacity: opacity
+                  });
+                }
+                particleMaterial = particleMaterials[photonColor];
               }
-              particleMaterial = particleMaterials[photonColor];
-              curPhoton && curPhoton.material.dispose();
+            }
+            if (curPhoton) {
+              // Dispose of previous particles
+              curPhoton.geometry !== particleGeometry && curPhoton.geometry.dispose();
+              curPhoton.material !== particleMaterial && curPhoton.material.dispose();
             }
 
             // digest cycle for each photon
+            var numPhotons = Math.round(Math.abs(particlesAccessor(link)));
             obj.__photonDataMapper.id(function (d) {
               return d.idx;
             }).onCreateObj(function () {
@@ -63452,7 +63534,7 @@ function InsertStackElement(node, body) {
 
   						console.warn( 'THREE.Node: Recursion detected.', this );
 
-  						result = '';
+  						result = '/* Recursion detected. */';
 
   					}
 
@@ -64827,7 +64909,7 @@ function InsertStackElement(node, body) {
 
   	} else if ( type === 'shader' ) {
 
-  		return Fn( obj );
+  		return obj.isFn ? obj : Fn( obj );
 
   	}
 
@@ -64977,16 +65059,22 @@ function InsertStackElement(node, body) {
   		const { shaderNode, inputNodes } = this;
 
   		const properties = builder.getNodeProperties( shaderNode );
-  		const onceNS = shaderNode.namespace && shaderNode.namespace === builder.namespace ? builder.getNamespace( 'once' ) : 'once';
 
-  		if ( properties[ onceNS ] ) {
+  		const subBuild = builder.getClosestSubBuild( shaderNode.subBuilds ) || '';
+  		const subBuildProperty = subBuild || 'default';
 
-  			return properties[ onceNS ];
+  		if ( properties[ subBuildProperty ] ) {
+
+  			return properties[ subBuildProperty ];
 
   		}
 
   		//
 
+  		const previousSubBuildFn = builder.subBuildFn;
+
+  		builder.subBuildFn = subBuild;
+
   		let result = null;
 
   		if ( shaderNode.layout ) {
@@ -65024,9 +65112,11 @@ function InsertStackElement(node, body) {
 
   		}
 
+  		builder.subBuildFn = previousSubBuildFn;
+
   		if ( shaderNode.once ) {
 
-  			properties[ onceNS ] = result;
+  			properties[ subBuildProperty ] = result;
 
   		}
 
@@ -65047,11 +65137,12 @@ function InsertStackElement(node, body) {
   	getOutputNode( builder ) {
 
   		const properties = builder.getNodeProperties( this );
-  		const outputNamespace = builder.getOutputNamespace();
+  		const subBuildOutput = builder.getSubBuildOutput( this );
 
-  		properties[ outputNamespace ] = properties[ outputNamespace ] || this.setupOutput( builder );
+  		properties[ subBuildOutput ] = properties[ subBuildOutput ] || this.setupOutput( builder );
+  		properties[ subBuildOutput ].subBuild = builder.getClosestSubBuild( this );
 
-  		return properties[ outputNamespace ];
+  		return properties[ subBuildOutput ];
 
   	}
 
@@ -65062,23 +65153,45 @@ function InsertStackElement(node, body) {
   		const buildStage = builder.getBuildStage();
   		const properties = builder.getNodeProperties( this );
 
-  		const outputNamespace = builder.getOutputNamespace();
+  		const subBuildOutput = builder.getSubBuildOutput( this );
   		const outputNode = this.getOutputNode( builder );
 
   		if ( buildStage === 'setup' ) {
 
-  			const initializedNamespace = builder.getNamespace( 'initialized' );
+  			const subBuildInitialized = builder.getSubBuildProperty( 'initialized', this );
+
+  			if ( properties[ subBuildInitialized ] !== true ) {
+
+  				properties[ subBuildInitialized ] = true;
+
+  				properties[ subBuildOutput ] = this.getOutputNode( builder );
+  				properties[ subBuildOutput ].build( builder );
 
-  			if ( properties[ initializedNamespace ] !== true ) {
+  				// If the shaderNode has subBuilds, add them to the chaining nodes
+  				// so they can be built later in the build process.
 
-  				properties[ initializedNamespace ] = true;
+  				if ( this.shaderNode.subBuilds ) {
 
-  				properties[ outputNamespace ] = this.getOutputNode( builder );
-  				properties[ outputNamespace ].build( builder );
+  					for ( const node of builder.chaining ) {
+
+  						const nodeData = builder.getDataFromNode( node, 'any' );
+  						nodeData.subBuilds = nodeData.subBuilds || new Set();
+
+  						for ( const subBuild of this.shaderNode.subBuilds ) {
+
+  							nodeData.subBuilds.add( subBuild );
+
+  						}
+
+  						//builder.getDataFromNode( node ).subBuilds = nodeData.subBuilds;
+
+  					}
+
+  				}
 
   			}
 
-  			result = properties[ outputNamespace ];
+  			result = properties[ subBuildOutput ];
 
   		} else if ( buildStage === 'analyze' ) {
 
@@ -65108,7 +65221,6 @@ function InsertStackElement(node, body) {
   		this.global = true;
 
   		this.once = false;
-  		this.namespace = null;
 
   	}
 
@@ -65176,20 +65288,6 @@ function InsertStackElement(node, body) {
 
   };
 
-  const safeGetNodeType = ( node ) => {
-
-  	try {
-
-  		return node.getNodeType();
-
-  	} catch ( _ ) {
-
-  		return undefined;
-
-  	}
-
-  };
-
   const ConvertType = function ( type, cacheMap = null ) {
 
   	return ( ...params ) => {
@@ -65209,7 +65307,7 @@ function InsertStackElement(node, body) {
   		if ( params.length === 1 ) {
 
   			const node = getConstNode( params[ 0 ], type );
-  			if ( safeGetNodeType( node ) === type ) return nodeObject( node );
+  			if ( node.nodeType === type ) return nodeObject( node );
   			return nodeObject( new ConvertNode( node, type ) );
 
   		}
@@ -65304,6 +65402,8 @@ function InsertStackElement(node, body) {
   	fn.shaderNode = shaderNode;
   	fn.id = shaderNode.id;
 
+  	fn.isFn = true;
+
   	fn.getNodeType = ( ...params ) => shaderNode.getNodeType( ...params );
   	fn.getCacheKey = ( ...params ) => shaderNode.getCacheKey( ...params );
 
@@ -65315,10 +65415,10 @@ function InsertStackElement(node, body) {
 
   	};
 
-  	fn.once = ( namespace = null ) => {
+  	fn.once = ( subBuilds = null ) => {
 
   		shaderNode.once = true;
-  		shaderNode.namespace = namespace;
+  		shaderNode.subBuilds = subBuilds;
 
   		return fn;
 
@@ -67316,22 +67416,6 @@ function InsertStackElement(node, body) {
   addMethodChaining( 'increment', increment );
   addMethodChaining( 'decrement', decrement );
 
-  /**
-   * @tsl
-   * @function
-   * @deprecated since r168. Use {@link mod} instead.
-   *
-   * @param {Node} a - The first input.
-   * @param {Node} b - The second input.
-   * @returns {OperatorNode}
-   */
-  const remainder = ( a, b ) => { // @deprecated, r168
-
-  	console.warn( 'THREE.TSL: "remainder()" is deprecated. Use "mod( int( ... ) )" instead.' );
-  	return mod( a, b );
-
-  };
-
   /**
    * @tsl
    * @function
@@ -67348,7 +67432,6 @@ function InsertStackElement(node, body) {
 
   };
 
-  addMethodChaining( 'remainder', remainder );
   addMethodChaining( 'modInt', modInt );
 
   /**
@@ -68359,6 +68442,17 @@ function InsertStackElement(node, body) {
    */
   const smoothstepElement = ( x, low, high ) => smoothstep( low, high, x );
 
+  /**
+   * Alias for `step()` with a different parameter order.
+   *
+   * @tsl
+   * @function
+   * @param {Node | number} x - The source value for interpolation.
+   * @param {Node | number} edge - The edge value.
+   * @returns {Node}
+   */
+  const stepElement = ( x, edge ) => step( edge, x );
+
   /**
    * Returns the arc-tangent of the quotient of its parameters.
    *
@@ -68416,7 +68510,7 @@ function InsertStackElement(node, body) {
   addMethodChaining( 'atan2', atan2 );
   addMethodChaining( 'min', min$1 );
   addMethodChaining( 'max', max$1 );
-  addMethodChaining( 'step', step );
+  addMethodChaining( 'step', stepElement );
   addMethodChaining( 'reflect', reflect );
   addMethodChaining( 'distance', distance );
   addMethodChaining( 'dot', dot );
@@ -68660,25 +68754,6 @@ function InsertStackElement(node, body) {
 
   addMethodChaining( 'select', select$1 );
 
-  // Deprecated
-
-  /**
-   * @tsl
-   * @function
-   * @deprecated since r168. Use {@link select} instead.
-   *
-   * @param {...any} params
-   * @returns {ConditionalNode}
-   */
-  const cond = ( ...params ) => { // @deprecated, r168
-
-  	console.warn( 'THREE.TSL: cond() has been renamed to select().' );
-  	return select$1( ...params );
-
-  };
-
-  addMethodChaining( 'cond', cond );
-
   /**
    * This node can be used as a context management component for another node.
    * {@link NodeBuilder} performs its node building process in a specific context and
@@ -69032,6 +69107,91 @@ function InsertStackElement(node, body) {
 
   addMethodChaining( 'temp', temp );
 
+  /**
+   * This node is used to build a sub-build in the node system.
+   *
+   * @augments Node
+   * @param {Node} node - The node to be built in the sub-build.
+   * @param {string} name - The name of the sub-build.
+   * @param {string|null} [nodeType=null] - The type of the node, if known.
+   */
+  class SubBuildNode extends Node {
+
+  	static get type() {
+
+  		return 'SubBuild';
+
+  	}
+
+  	constructor( node, name, nodeType = null ) {
+
+  		super( nodeType );
+
+  		/**
+  		 * The node to be built in the sub-build.
+  		 *
+  		 * @type {Node}
+  		 */
+  		this.node = node;
+
+  		/**
+  		 * The name of the sub-build.
+  		 *
+  		 * @type {string}
+  		 */
+  		this.name = name;
+
+  		/**
+  		 * This flag can be used for type testing.
+  		 *
+  		 * @type {boolean}
+  		 * @readonly
+  		 * @default true
+  		 */
+  		this.isSubBuildNode = true;
+
+  	}
+
+  	getNodeType( builder ) {
+
+  		if ( this.nodeType !== null ) return this.nodeType;
+
+  		builder.addSubBuild( this.name );
+
+  		const nodeType = this.node.getNodeType( builder );
+
+  		builder.removeSubBuild();
+
+  		return nodeType;
+
+  	}
+
+  	build( builder, ...params ) {
+
+  		builder.addSubBuild( this.name );
+
+  		const data = this.node.build( builder, ...params );
+
+  		builder.removeSubBuild();
+
+  		return data;
+
+  	}
+
+  }
+
+  /**
+   * Creates a new sub-build node.
+   *
+   * @tsl
+   * @function
+   * @param {Node} node - The node to be built in the sub-build.
+   * @param {string} name - The name of the sub-build.
+   * @param {string|null} [type=null] - The type of the node, if known.
+   * @returns {Node} A node object wrapping the SubBuildNode instance.
+   */
+  const subBuild = ( node, name, type = null ) => nodeObject( new SubBuildNode( nodeObject( node ), name, type ) );
+
   /**
    * Class for representing shader varyings as nodes. Varyings are create from
    * existing nodes like the following:
@@ -69161,7 +69321,7 @@ function InsertStackElement(node, body) {
   			const interpolationSampling = this.interpolationSampling;
 
   			properties.varying = varying = builder.getVaryingFromNode( this, name, type, interpolationType, interpolationSampling );
-  			properties.node = this.node;
+  			properties.node = subBuild( this.node, 'VERTEX' );
 
   		}
 
@@ -69190,18 +69350,19 @@ function InsertStackElement(node, body) {
 
   	generate( builder ) {
 
+  		const propertyKey = builder.getSubBuildProperty( 'property', builder.currentStack );
   		const properties = builder.getNodeProperties( this );
   		const varying = this.setupVarying( builder );
 
-  		if ( properties.propertyName === undefined ) {
+  		if ( properties[ propertyKey ] === undefined ) {
 
   			const type = this.getNodeType( builder );
   			const propertyName = builder.getPropertyName( varying, NodeShaderStage.VERTEX );
 
   			// force node run in vertex stage
-  			builder.flowNodeFromShaderStage( NodeShaderStage.VERTEX, this.node, type, propertyName );
+  			builder.flowNodeFromShaderStage( NodeShaderStage.VERTEX, properties.node, type, propertyName );
 
-  			properties.propertyName = propertyName;
+  			properties[ propertyKey ] = propertyName;
 
   		}
 
@@ -70616,20 +70777,6 @@ function InsertStackElement(node, body) {
    */
   const cache = ( node, parent ) => nodeObject( new CacheNode( nodeObject( node ), parent ) );
 
-  /**
-   * Assigns a namespace to the given node by updating its context.
-   *
-   * Important for TSL functions that use `.once( namespace )` to ensure that the namespace will run twice,
-   * once when the node is build in the specific namespace and once when the node is built in the others namespace.
-   *
-   * This is useful for nodes like `positionWorld` that need to be re-updated if used in `material.positionNode` and outside of it in the same material.
-   *
-   * @param {Object} node - The node to which the namespace will be assigned.
-   * @param {string} namespace - The namespace to be assigned to the node.
-   * @returns {Object} The updated node with the new namespace in its context.
-   */
-  const namespace$1 = ( node, namespace ) => node.context( { namespace } );
-
   addMethodChaining( 'cache', cache );
 
   /**
@@ -71284,7 +71431,7 @@ function InsertStackElement(node, body) {
    * @param {number} [index=0] - The uv index.
    * @return {AttributeNode<vec2>} The uv attribute node.
    */
-  const uv = ( index = 0 ) => attribute( 'uv' + ( index > 0 ? index : '' ), 'vec2' );
+  const uv$1 = ( index = 0 ) => attribute( 'uv' + ( index > 0 ? index : '' ), 'vec2' );
 
   /**
    * A node that represents the dimensions of a texture. The texture size is
@@ -71677,7 +71824,7 @@ function InsertStackElement(node, body) {
   	 */
   	getDefaultUV() {
 
-  		return uv( this.value.channel );
+  		return uv$1( this.value.channel );
 
   	}
 
@@ -73247,9 +73394,9 @@ function InsertStackElement(node, body) {
    */
   const positionWorld = /*@__PURE__*/ ( Fn( ( builder ) => {
 
-  	return modelWorldMatrix.mul( positionLocal ).xyz.toVarying( builder.getNamespace( 'v_positionWorld' ) );
+  	return modelWorldMatrix.mul( positionLocal ).xyz.toVarying( builder.getSubBuildProperty( 'v_positionWorld' ) );
 
-  }, 'vec3' ).once( 'POSITION' ) )();
+  }, 'vec3' ).once( [ 'POSITION' ] ) )();
 
   /**
    * TSL object that represents the position world direction of the current rendered object.
@@ -73257,13 +73404,13 @@ function InsertStackElement(node, body) {
    * @tsl
    * @type {Node<vec3>}
    */
-  const positionWorldDirection = /*@__PURE__*/ ( Fn( ( builder ) => {
+  const positionWorldDirection = /*@__PURE__*/ ( Fn( () => {
 
-  	const vertexPWD = positionLocal.transformDirection( modelWorldMatrix ).toVarying( builder.getNamespace( 'v_positionWorldDirection' ) );
+  	const vertexPWD = positionLocal.transformDirection( modelWorldMatrix ).toVarying( 'v_positionWorldDirection' );
 
   	return vertexPWD.normalize().toVar( 'positionWorldDirection' );
 
-  }, 'vec3' ).once( 'POSITION' ) )();
+  }, 'vec3' ).once( [ 'POSITION' ] ) )();
 
   /**
    * TSL object that represents the vertex position in view space of the current rendered object.
@@ -73273,9 +73420,9 @@ function InsertStackElement(node, body) {
    */
   const positionView = /*@__PURE__*/ ( Fn( ( builder ) => {
 
-  	return builder.context.setupPositionView().toVarying( builder.getNamespace( 'v_positionView' ) );
+  	return builder.context.setupPositionView().toVarying( 'v_positionView' );
 
-  }, 'vec3' ).once( 'POSITION' ) )();
+  }, 'vec3' ).once( [ 'POSITION' ] ) )();
 
   /**
    * TSL object that represents the position view direction of the current rendered object.
@@ -73318,6 +73465,10 @@ function InsertStackElement(node, body) {
 
   	generate( builder ) {
 
+  		if ( builder.shaderStage !== 'fragment' ) return 'true';
+
+  		//
+
   		const { renderer, material } = builder;
 
   		if ( renderer.coordinateSystem === WebGLCoordinateSystem ) {
@@ -73353,6 +73504,34 @@ function InsertStackElement(node, body) {
    */
   const faceDirection = /*@__PURE__*/ float( frontFacing ).mul( 2.0 ).sub( 1.0 );
 
+  /**
+   * Converts a direction vector to a face direction vector based on the material's side.
+   *
+   * If the material is set to `BackSide`, the direction is inverted.
+   * If the material is set to `DoubleSide`, the direction is multiplied by `faceDirection`.
+   *
+   * @tsl
+   * @param {Node<vec3>} direction - The direction vector to convert.
+   * @returns {Node<vec3>} The converted direction vector.
+   */
+  const directionToFaceDirection = /*@__PURE__*/ Fn( ( [ direction ], { material } ) => {
+
+  	const side = material.side;
+
+  	if ( side === BackSide ) {
+
+  		direction = direction.mul( -1 );
+
+  	} else if ( side === DoubleSide ) {
+
+  		direction = direction.mul( faceDirection );
+
+  	}
+
+  	return direction;
+
+  } );
+
   /**
    * TSL object that represents the normal attribute of the current rendered object.
    *
@@ -73395,7 +73574,7 @@ function InsertStackElement(node, body) {
    * @tsl
    * @type {Node<vec3>}
    */
-  const normalView = /*@__PURE__*/ ( Fn( ( builder ) => {
+  const normalViewGeometry = /*@__PURE__*/ ( Fn( ( builder ) => {
 
   	let node;
 
@@ -73405,13 +73584,13 @@ function InsertStackElement(node, body) {
 
   	} else {
 
-  		node = varying( transformNormalToView( normalLocal ), 'v_normalView' ).normalize();
+  		node = transformNormalToView( normalLocal ).toVarying( 'v_normalViewGeometry' ).normalize();
 
   	}
 
   	return node;
 
-  }, 'vec3' ).once() )().toVar( 'normalView' );
+  }, 'vec3' ).once() )().toVar( 'normalViewGeometry' );
 
   /**
    * TSL object that represents the vertex normal in world space of the current rendered object.
@@ -73419,19 +73598,19 @@ function InsertStackElement(node, body) {
    * @tsl
    * @type {Node<vec3>}
    */
-  const normalWorld = /*@__PURE__*/ ( Fn( ( builder ) => {
+  const normalWorldGeometry = /*@__PURE__*/ ( Fn( ( builder ) => {
 
-  	let normal = normalView.transformDirection( cameraViewMatrix );
+  	let normal = normalViewGeometry.transformDirection( cameraViewMatrix );
 
   	if ( builder.material.flatShading !== true ) {
 
-  		normal = varying( normal, 'v_normalWorld' );
+  		normal = normal.toVarying( 'v_normalWorldGeometry' );
 
   	}
 
-  	return normal;
+  	return normal.normalize().toVar( 'normalWorldGeometry' );
 
-  }, 'vec3' ).once() )().normalize().toVar( 'normalWorld' );
+  }, 'vec3' ).once() )();
 
   /**
    * TSL object that represents the transformed vertex normal in view space of the current rendered object.
@@ -73439,17 +73618,31 @@ function InsertStackElement(node, body) {
    * @tsl
    * @type {Node<vec3>}
    */
-  const transformedNormalView = /*@__PURE__*/ ( Fn( ( builder ) => {
+  const normalView = /*@__PURE__*/ ( Fn( ( { subBuildFn, material, context } ) => {
 
-  	// Use getUV context to avoid side effects from nodes overwriting getUV in the context (e.g. EnvironmentNode)
+  	let node;
 
-  	let node = builder.context.setupNormal().context( { getUV: null } );
+  	if ( subBuildFn === 'NORMAL' || subBuildFn === 'VERTEX' ) {
 
-  	if ( builder.material.flatShading !== true ) node = node.mul( faceDirection );
+  		node = normalViewGeometry;
+
+  		if ( material.flatShading !== true ) {
+
+  			node = directionToFaceDirection( node );
+
+  		}
+
+  	} else {
+
+  		// Use getUV context to avoid side effects from nodes overwriting getUV in the context (e.g. EnvironmentNode)
+
+  		node = context.setupNormal().context( { getUV: null } );
+
+  	}
 
   	return node;
 
-  }, 'vec3' ).once() )().toVar( 'transformedNormalView' );
+  }, 'vec3' ).once( [ 'NORMAL', 'VERTEX' ] ) )().toVar( 'normalView' );
 
   /**
    * TSL object that represents the transformed vertex normal in world space of the current rendered object.
@@ -73457,7 +73650,7 @@ function InsertStackElement(node, body) {
    * @tsl
    * @type {Node<vec3>}
    */
-  const transformedNormalWorld = /*@__PURE__*/ transformedNormalView.transformDirection( cameraViewMatrix ).toVar( 'transformedNormalWorld' );
+  const normalWorld = /*@__PURE__*/ normalView.transformDirection( cameraViewMatrix ).toVar( 'normalWorld' );
 
   /**
    * TSL object that represents the transformed clearcoat vertex normal in view space of the current rendered object.
@@ -73465,17 +73658,25 @@ function InsertStackElement(node, body) {
    * @tsl
    * @type {Node<vec3>}
    */
-  const transformedClearcoatNormalView = /*@__PURE__*/ ( Fn( ( builder ) => {
+  const clearcoatNormalView = /*@__PURE__*/ ( Fn( ( { subBuildFn, context } ) => {
+
+  	let node;
 
-  	// Use getUV context to avoid side effects from nodes overwriting getUV in the context (e.g. EnvironmentNode)
+  	if ( subBuildFn === 'NORMAL' || subBuildFn === 'VERTEX' ) {
 
-  	let node = builder.context.setupClearcoatNormal().context( { getUV: null } );
+  		node = normalView;
 
-  	if ( builder.material.flatShading !== true ) node = node.mul( faceDirection );
+  	} else {
+
+  		// Use getUV context to avoid side effects from nodes overwriting getUV in the context (e.g. EnvironmentNode)
+
+  		node = context.setupClearcoatNormal().context( { getUV: null } );
+
+  	}
 
   	return node;
 
-  }, 'vec3' ).once() )().toVar( 'transformedClearcoatNormalView' );
+  }, 'vec3' ).once( [ 'NORMAL', 'VERTEX' ] ) )().toVar( 'clearcoatNormalView' );
 
   /**
    * Transforms the normal with the given matrix.
@@ -73523,6 +73724,50 @@ function InsertStackElement(node, body) {
 
   } );
 
+  // Deprecated
+
+  /**
+   * TSL object that represents the transformed vertex normal in view space of the current rendered object.
+   *
+   * @tsl
+   * @type {Node<vec3>}
+   * @deprecated since r178. Use `normalView` instead.
+   */
+  ( Fn( () => { // @deprecated, r177
+
+  	console.warn( 'THREE.TSL: "transformedNormalView" is deprecated. Use "normalView" instead.' );
+  	return normalView;
+
+  } ).once( [ 'NORMAL', 'VERTEX' ] ) )();
+
+  /**
+   * TSL object that represents the transformed vertex normal in world space of the current rendered object.
+   *
+   * @tsl
+   * @type {Node<vec3>}
+   * @deprecated since r178. Use `normalWorld` instead.
+   */
+  ( Fn( () => { // @deprecated, r177
+
+  	console.warn( 'THREE.TSL: "transformedNormalWorld" is deprecated. Use "normalWorld" instead.' );
+  	return normalWorld;
+
+  } ).once( [ 'NORMAL', 'VERTEX' ] ) )();
+
+  /**
+   * TSL object that represents the transformed clearcoat vertex normal in view space of the current rendered object.
+   *
+   * @tsl
+   * @type {Node<vec3>}
+   * @deprecated since r178. Use `clearcoatNormalView` instead.
+   */
+  ( Fn( () => { // @deprecated, r177
+
+  	console.warn( 'THREE.TSL: "transformedClearcoatNormalView" is deprecated. Use "clearcoatNormalView" instead.' );
+  	return clearcoatNormalView;
+
+  } ).once( [ 'NORMAL', 'VERTEX' ] ) )();
+
   const _e1$1 = /*@__PURE__*/ new Euler();
   const _m1$1 = /*@__PURE__*/ new Matrix4();
 
@@ -73585,7 +73830,7 @@ function InsertStackElement(node, body) {
    * @tsl
    * @type {Node<vec3>}
    */
-  const reflectView = /*@__PURE__*/ positionViewDirection.negate().reflect( transformedNormalView );
+  const reflectView = /*@__PURE__*/ positionViewDirection.negate().reflect( normalView );
 
   /**
    * The refract vector in view space.
@@ -73593,7 +73838,7 @@ function InsertStackElement(node, body) {
    * @tsl
    * @type {Node<vec3>}
    */
-  const refractView = /*@__PURE__*/ positionViewDirection.negate().refract( transformedNormalView, materialRefractionRatio );
+  const refractView = /*@__PURE__*/ positionViewDirection.negate().refract( normalView, materialRefractionRatio );
 
   /**
    * Used for sampling cube maps when using cube reflection mapping.
@@ -74258,6 +74503,49 @@ function InsertStackElement(node, body) {
    */
   const materialReference = ( name, type, material = null ) => nodeObject( new MaterialReferenceNode( name, type, material ) );
 
+  // Normal Mapping Without Precomputed Tangents
+  // http://www.thetenthplanet.de/archives/1180
+
+  const uv = uv$1();
+
+  const q0 = positionView.dFdx();
+  const q1 = positionView.dFdy();
+  const st0 = uv.dFdx();
+  const st1 = uv.dFdy();
+
+  const N$1 = normalView;
+
+  const q1perp = q1.cross( N$1 );
+  const q0perp = N$1.cross( q0 );
+
+  const T$1 = q1perp.mul( st0.x ).add( q0perp.mul( st1.x ) );
+  const B$1 = q1perp.mul( st0.y ).add( q0perp.mul( st1.y ) );
+
+  const det = T$1.dot( T$1 ).max( B$1.dot( B$1 ) );
+  const scale = det.equal( 0.0 ).select( 0.0, det.inverseSqrt() );
+
+  /**
+   * Tangent vector in view space, computed dynamically from geometry and UV derivatives.
+   * Useful for normal mapping without precomputed tangents.
+   *
+   * Reference: http://www.thetenthplanet.de/archives/1180
+   *
+   * @tsl
+   * @type {Node<vec3>}
+   */
+  const tangentViewFrame = /*@__PURE__*/ T$1.mul( scale ).toVar( 'tangentViewFrame' );
+
+  /**
+   * Bitangent vector in view space, computed dynamically from geometry and UV derivatives.
+   * Complements the tangentViewFrame for constructing the tangent space basis.
+   *
+   * Reference: http://www.thetenthplanet.de/archives/1180
+   *
+   * @tsl
+   * @type {Node<vec3>}
+   */
+  const bitangentViewFrame = /*@__PURE__*/ B$1.mul( scale ).toVar( 'bitangentViewFrame' );
+
   /**
    * TSL object that represents the tangent attribute of the current rendered object.
    *
@@ -74290,7 +74578,29 @@ function InsertStackElement(node, body) {
    * @tsl
    * @type {Node<vec3>}
    */
-  const tangentView = /*@__PURE__*/ modelViewMatrix.mul( vec4( tangentLocal, 0 ) ).xyz.toVarying( 'v_tangentView' ).normalize().toVar( 'tangentView' );
+  const tangentView = /*@__PURE__*/ ( Fn( ( { subBuildFn, geometry, material } ) => {
+
+  	let node;
+
+  	if ( subBuildFn === 'VERTEX' || geometry.hasAttribute( 'tangent' ) ) {
+
+  		node = modelViewMatrix.mul( vec4( tangentLocal, 0 ) ).xyz.toVarying( 'v_tangentView' ).normalize();
+
+  	} else {
+
+  		node = tangentViewFrame;
+
+  	}
+
+  	if ( material.flatShading !== true ) {
+
+  		node = directionToFaceDirection( node );
+
+  	}
+
+  	return node;
+
+  }, 'vec3' ).once( [ 'NORMAL', 'VERTEX' ] ) )().toVar( 'tangentView' );
 
   /**
    * Returns the bitangent node and assigns it to a varying if the material is not flat shaded.
@@ -74301,19 +74611,19 @@ function InsertStackElement(node, body) {
    * @param {string} varyingName - The name of the varying to assign the bitangent to.
    * @returns {Node<vec3>} The bitangent node.
    */
-  const getBitangent = /*@__PURE__*/ Fn( ( [ crossNormalTangent, varyingName ], builder ) => {
+  const getBitangent = /*@__PURE__*/ Fn( ( [ crossNormalTangent, varyingName ], { subBuildFn, material } ) => {
 
   	let bitangent = crossNormalTangent.mul( tangentGeometry.w ).xyz;
 
-  	if ( builder.material.flatShading !== true ) {
+  	if ( subBuildFn === 'NORMAL' && material.flatShading !== true ) {
 
-  		bitangent = varying( bitangent, varyingName );
+  		bitangent = bitangent.toVarying( varyingName );
 
   	}
 
   	return bitangent;
 
-  } ).once();
+  } ).once( [ 'NORMAL' ] );
 
   /**
    * TSL object that represents the vertex bitangent in view space of the current rendered object.
@@ -74321,7 +74631,29 @@ function InsertStackElement(node, body) {
    * @tsl
    * @type {Node<vec3>}
    */
-  const bitangentView = getBitangent( normalView.cross( tangentView ), 'v_bitangentView' ).normalize().toVar( 'bitangentView' );
+  const bitangentView = /*@__PURE__*/ ( Fn( ( { subBuildFn, geometry, material } ) => {
+
+  	let node;
+
+  	if ( subBuildFn === 'VERTEX' || geometry.hasAttribute( 'tangent' ) ) {
+
+  		node = getBitangent( normalView.cross( tangentView ), 'v_bitangentView' ).normalize();
+
+  	} else {
+
+  		node = bitangentViewFrame;
+
+  	}
+
+  	if ( material.flatShading !== true ) {
+
+  		node = directionToFaceDirection( node );
+
+  	}
+
+  	return node;
+
+  }, 'vec3' ).once( [ 'NORMAL', 'VERTEX' ] ) )().toVar( 'bitangentView' );
 
   /**
    * TSL object that represents the TBN matrix in view space.
@@ -74329,7 +74661,7 @@ function InsertStackElement(node, body) {
    * @tsl
    * @type {Node<mat3>}
    */
-  const TBNViewMatrix = /*@__PURE__*/ mat3( tangentView, bitangentView, normalView );
+  const TBNViewMatrix = /*@__PURE__*/ mat3( tangentView, bitangentView, normalView ).toVar( 'TBNViewMatrix' );
 
   /**
    * TSL function for computing bent normals.
@@ -74338,45 +74670,17 @@ function InsertStackElement(node, body) {
    * @function
    * @returns {Node<vec3>} Bent normals.
    */
-  const transformedBentNormalView = /*@__PURE__*/ ( () => {
+  const bentNormalView = /*@__PURE__*/ ( Fn( () => {
 
   	// https://google.github.io/filament/Filament.md.html#lighting/imagebasedlights/anisotropy
 
   	let bentNormal = anisotropyB.cross( positionViewDirection );
   	bentNormal = bentNormal.cross( anisotropyB ).normalize();
-  	bentNormal = mix$2( bentNormal, transformedNormalView, anisotropy.mul( roughness.oneMinus() ).oneMinus().pow2().pow2() ).normalize();
+  	bentNormal = mix$2( bentNormal, normalView, anisotropy.mul( roughness.oneMinus() ).oneMinus().pow2().pow2() ).normalize();
 
   	return bentNormal;
 
-
-  } )();
-
-  // Normal Mapping Without Precomputed Tangents
-  // http://www.thetenthplanet.de/archives/1180
-
-  const perturbNormal2Arb = /*@__PURE__*/ Fn( ( inputs ) => {
-
-  	const { eye_pos, surf_norm, mapN, uv } = inputs;
-
-  	const q0 = eye_pos.dFdx();
-  	const q1 = eye_pos.dFdy();
-  	const st0 = uv.dFdx();
-  	const st1 = uv.dFdy();
-
-  	const N = surf_norm; // normalized
-
-  	const q1perp = q1.cross( N );
-  	const q0perp = N.cross( q0 );
-
-  	const T = q1perp.mul( st0.x ).add( q0perp.mul( st1.x ) );
-  	const B = q1perp.mul( st0.y ).add( q0perp.mul( st1.y ) );
-
-  	const det = T.dot( T ).max( B.dot( B ) );
-  	const scale = faceDirection.mul( det.inverseSqrt() );
-
-  	return add( T.mul( mapN.x, scale ), B.mul( mapN.y, scale ), N.mul( mapN.z ) ).normalize();
-
-  } );
+  } ).once() )();
 
   /**
    * This class can be used for applying normals maps to materials.
@@ -74430,7 +74734,7 @@ function InsertStackElement(node, body) {
 
   	}
 
-  	setup( builder ) {
+  	setup( { material } ) {
 
   		const { normalMapType, scaleNode } = this;
 
@@ -74438,38 +74742,37 @@ function InsertStackElement(node, body) {
 
   		if ( scaleNode !== null ) {
 
-  			normalMap = vec3( normalMap.xy.mul( scaleNode ), normalMap.z );
+  			let scale = scaleNode;
+
+  			if ( material.flatShading === true ) {
+
+  				scale = directionToFaceDirection( scale );
+
+  			}
+
+  			normalMap = vec3( normalMap.xy.mul( scale ), normalMap.z );
 
   		}
 
-  		let outputNode = null;
+  		let output = null;
 
   		if ( normalMapType === ObjectSpaceNormalMap ) {
 
-  			outputNode = transformNormalToView( normalMap );
+  			output = transformNormalToView( normalMap );
 
   		} else if ( normalMapType === TangentSpaceNormalMap ) {
 
-  			const tangent = builder.hasGeometryAttribute( 'tangent' );
-
-  			if ( tangent === true ) {
+  			output = TBNViewMatrix.mul( normalMap ).normalize();
 
-  				outputNode = TBNViewMatrix.mul( normalMap ).normalize();
-
-  			} else {
+  		} else {
 
-  				outputNode = perturbNormal2Arb( {
-  					eye_pos: positionView,
-  					surf_norm: normalView,
-  					mapN: normalMap,
-  					uv: uv()
-  				} );
+  			console.error( `THREE.NodeMaterial: Unsupported normal map type: ${ normalMapType }` );
 
-  			}
+  			output = normalView; // Fallback to default normal view
 
   		}
 
-  		return outputNode;
+  		return output;
 
   	}
 
@@ -74492,7 +74795,7 @@ function InsertStackElement(node, body) {
   const dHdxy_fwd = Fn( ( { textureNode, bumpScale } ) => {
 
   	// It's used to preserve the same TextureNode instance
-  	const sampleTexture = ( callback ) => textureNode.cache().context( { getUV: ( texNode ) => callback( texNode.uvNode || uv() ), forceUVContext: true } );
+  	const sampleTexture = ( callback ) => textureNode.cache().context( { getUV: ( texNode ) => callback( texNode.uvNode || uv$1() ), forceUVContext: true } );
 
   	const Hll = float( sampleTexture( ( uvNode ) => uvNode ) );
 
@@ -78133,6 +78436,25 @@ function InsertStackElement(node, body) {
    */
   const vertexColor = ( index = 0 ) => nodeObject( new VertexColorNode( index ) );
 
+  /**
+   * Premultiplies the RGB channels of a color by its alpha channel.
+   *
+   * This function is useful for converting a non-premultiplied alpha color
+   * into a premultiplied alpha format, where the RGB values are scaled
+   * by the alpha value. Premultiplied alpha is often used in graphics
+   * rendering for certain operations, such as compositing and image processing.
+   *
+   * @tsl
+   * @function
+   * @param {Node<vec4>} color - The input color with non-premultiplied alpha.
+   * @return {Node<vec4>} The color with premultiplied alpha.
+   */
+  const premultiplyAlpha = /*@__PURE__*/ Fn( ( [ color ] ) => {
+
+  	return vec4( color.rgb.mul( color.a ), color.a );
+
+  }, { color: 'vec4', return: 'vec4' } );
+
   /**
    * Base class for all node materials.
    *
@@ -78552,7 +78874,7 @@ function InsertStackElement(node, body) {
   	 */
   	setup( builder ) {
 
-  		builder.context.setupNormal = () => this.setupNormal( builder );
+  		builder.context.setupNormal = () => subBuild( this.setupNormal( builder ), 'NORMAL', 'vec3' );
   		builder.context.setupPositionView = () => this.setupPositionView( builder );
   		builder.context.setupModelViewProjection = () => this.setupModelViewProjection( builder );
 
@@ -78563,7 +78885,7 @@ function InsertStackElement(node, body) {
 
   		builder.addStack();
 
-  		const mvp = this.setupVertex( builder );
+  		const mvp = subBuild( this.setupVertex( builder ), 'VERTEX' );
 
   		const vertexNode = this.vertexNode || mvp;
 
@@ -78875,7 +79197,7 @@ function InsertStackElement(node, body) {
 
   		if ( this.positionNode !== null ) {
 
-  			positionLocal.assign( namespace$1( this.positionNode, 'POSITION' ) );
+  			positionLocal.assign( subBuild( this.positionNode, 'POSITION', 'vec3' ) );
 
   		}
 
@@ -79185,6 +79507,19 @@ function InsertStackElement(node, body) {
 
   	}
 
+  	/**
+  	 * Setups premultiplied alpha.
+  	 *
+  	 * @param {NodeBuilder} builder - The current node builder.
+  	 * @param {Node<vec4>} outputNode - The existing output node.
+  	 * @return {Node<vec4>} The output node.
+  	 */
+  	setupPremultipliedAlpha( builder, outputNode ) {
+
+  		return premultiplyAlpha( outputNode );
+
+  	}
+
   	/**
   	 * Setups the output node.
   	 *
@@ -79202,6 +79537,14 @@ function InsertStackElement(node, body) {
 
   		}
 
+  		// PREMULTIPLIED ALPHA
+
+  		if ( this.premultipliedAlpha === true ) {
+
+  			outputNode = this.setupPremultipliedAlpha( builder, outputNode );
+
+  		}
+
   		return outputNode;
 
   	}
@@ -79575,13 +79918,15 @@ function InsertStackElement(node, body) {
 
   		// By convention, a normal packed to RGB is in sRGB color space. Convert it to working color space.
 
-  		diffuseColor.assign( colorSpaceToWorking( vec4( directionToColor( transformedNormalView ), opacityNode ), SRGBColorSpace ) );
+  		diffuseColor.assign( colorSpaceToWorking( vec4( directionToColor( normalView ), opacityNode ), SRGBColorSpace ) );
 
   	}
 
   }
 
   /**
+   * TSL function for creating an equirect uv node.
+   *
    * Can be used to compute texture coordinates for projecting an
    * equirectangular texture onto a mesh for using it as the scene's
    * background.
@@ -79590,56 +79935,19 @@ function InsertStackElement(node, body) {
    * scene.backgroundNode = texture( equirectTexture, equirectUV() );
    * ```
    *
-   * @augments TempNode
-   */
-  class EquirectUVNode extends TempNode {
-
-  	static get type() {
-
-  		return 'EquirectUVNode';
-
-  	}
-
-  	/**
-  	 * Constructs a new equirect uv node.
-  	 *
-  	 * @param {Node<vec3>} [dirNode=positionWorldDirection] - A direction vector for sampling which is by default `positionWorldDirection`.
-  	 */
-  	constructor( dirNode = positionWorldDirection ) {
-
-  		super( 'vec2' );
-
-  		/**
-  		 * A direction vector for sampling why is by default `positionWorldDirection`.
-  		 *
-  		 * @type {Node<vec3>}
-  		 */
-  		this.dirNode = dirNode;
-
-  	}
-
-  	setup() {
-
-  		const dir = this.dirNode;
-
-  		const u = dir.z.atan( dir.x ).mul( 1 / ( Math.PI * 2 ) ).add( 0.5 );
-  		const v = dir.y.clamp( -1, 1.0 ).asin().mul( 1 / Math.PI ).add( 0.5 );
-
-  		return vec2( u, v );
-
-  	}
-
-  }
-
-  /**
-   * TSL function for creating an equirect uv node.
-   *
    * @tsl
    * @function
    * @param {?Node<vec3>} [dirNode=positionWorldDirection] - A direction vector for sampling which is by default `positionWorldDirection`.
-   * @returns {EquirectUVNode}
+   * @returns {Node<vec2>}
    */
-  const equirectUV = /*@__PURE__*/ nodeProxy( EquirectUVNode ).setParameterLength( 0, 1 );
+  const equirectUV = /*@__PURE__*/ Fn( ( [ dir = positionWorldDirection ] ) => {
+
+  	const u = dir.z.atan( dir.x ).mul( 1 / ( Math.PI * 2 ) ).add( 0.5 );
+  	const v = dir.y.clamp( -1, 1.0 ).asin().mul( 1 / Math.PI ).add( 0.5 );
+
+  	return vec2( u, v );
+
+  } );
 
   // @TODO: Consider rename WebGLCubeRenderTarget to just CubeRenderTarget
 
@@ -80267,13 +80575,13 @@ function InsertStackElement(node, body) {
 
   	/**
   	 * Basic materials are not affected by normal and bump maps so we
-  	 * return by default {@link normalView}.
+  	 * return by default {@link normalViewGeometry}.
   	 *
   	 * @return {Node<vec3>} The normal node.
   	 */
   	setupNormal() {
 
-  		return normalView; // see #28839
+  		return directionToFaceDirection( normalViewGeometry ); // see #28839
 
   	}
 
@@ -80369,7 +80677,7 @@ function InsertStackElement(node, body) {
 
   	const halfDir = lightDirection.add( positionViewDirection ).normalize();
 
-  	const dotNH = transformedNormalView.dot( halfDir ).clamp();
+  	const dotNH = normalView.dot( halfDir ).clamp();
   	const dotVH = positionViewDirection.dot( halfDir ).clamp();
 
   	const F = F_Schlick( { f0: specularColor, f90: 1.0, dotVH } );
@@ -80416,7 +80724,7 @@ function InsertStackElement(node, body) {
   	 */
   	direct( { lightDirection, lightColor, reflectedLight } ) {
 
-  		const dotNL = transformedNormalView.dot( lightDirection ).clamp();
+  		const dotNL = normalView.dot( lightDirection ).clamp();
   		const irradiance = dotNL.mul( lightColor );
 
   		reflectedLight.directDiffuse.addAssign( irradiance.mul( BRDF_Lambert( { diffuseColor: diffuseColor.rgb } ) ) );
@@ -80660,7 +80968,7 @@ function InsertStackElement(node, body) {
 
   	}
 
-  	const dxy = normalView.dFdx().abs().max( normalView.dFdy().abs() );
+  	const dxy = normalViewGeometry.dFdx().abs().max( normalViewGeometry.dFdy().abs() );
   	const geometryRoughness = dxy.x.max( dxy.y ).max( dxy.z );
 
   	return geometryRoughness;
@@ -80773,19 +81081,15 @@ function InsertStackElement(node, body) {
   } );
 
   // GGX Distribution, Schlick Fresnel, GGX_SmithCorrelated Visibility
-  const BRDF_GGX = /*@__PURE__*/ Fn( ( inputs ) => {
-
-  	const { lightDirection, f0, f90, roughness, f, USE_IRIDESCENCE, USE_ANISOTROPY } = inputs;
-
-  	const normalView = inputs.normalView || transformedNormalView;
+  const BRDF_GGX = /*@__PURE__*/ Fn( ( { lightDirection, f0, f90, roughness, f, normalView: normalView$1 = normalView, USE_IRIDESCENCE, USE_ANISOTROPY } ) => {
 
   	const alpha = roughness.pow2(); // UE4's roughness
 
   	const halfDir = lightDirection.add( positionViewDirection ).normalize();
 
-  	const dotNL = normalView.dot( lightDirection ).clamp();
-  	const dotNV = normalView.dot( positionViewDirection ).clamp(); // @ TODO: Move to core dotNV
-  	const dotNH = normalView.dot( halfDir ).clamp();
+  	const dotNL = normalView$1.dot( lightDirection ).clamp();
+  	const dotNV = normalView$1.dot( positionViewDirection ).clamp(); // @ TODO: Move to core dotNV
+  	const dotNH = normalView$1.dot( halfDir ).clamp();
   	const dotVH = positionViewDirection.dot( halfDir ).clamp();
 
   	let F = F_Schlick( { f0, f90, dotVH } );
@@ -80914,9 +81218,9 @@ function InsertStackElement(node, body) {
 
   	const halfDir = lightDirection.add( positionViewDirection ).normalize();
 
-  	const dotNL = transformedNormalView.dot( lightDirection ).clamp();
-  	const dotNV = transformedNormalView.dot( positionViewDirection ).clamp();
-  	const dotNH = transformedNormalView.dot( halfDir ).clamp();
+  	const dotNL = normalView.dot( lightDirection ).clamp();
+  	const dotNV = normalView.dot( positionViewDirection ).clamp();
+  	const dotNH = normalView.dot( halfDir ).clamp();
 
   	const D = D_Charlie( { roughness: sheenRoughness, dotNH } );
   	const V = V_Neubelt( { dotNV, dotNL } );
@@ -81106,10 +81410,10 @@ function InsertStackElement(node, body) {
    * @tsl
    * @function
    * @param {TextureNode} textureNode - The texture node that should be filtered.
-   * @param {Node<float>} [lodNode=float(3)] - Defines the LOD to sample from.
+   * @param {Node<float>} lodNode - Defines the LOD to sample from.
    * @return {Node} The filtered texture sample.
    */
-  const textureBicubic = /*@__PURE__*/ Fn( ( [ textureNode, lodNode = float( 3 ) ] ) => {
+  const textureBicubicLevel = /*@__PURE__*/ Fn( ( [ textureNode, lodNode ] ) => {
 
   	const fLodSize = vec2( textureNode.size( int( lodNode ) ) );
   	const cLodSize = vec2( textureNode.size( int( lodNode.add( 1.0 ) ) ) );
@@ -81180,7 +81484,7 @@ function InsertStackElement(node, body) {
 
   	const lod = log2( screenSize.x ).mul( applyIorToRoughness( roughness, ior ) );
 
-  	return textureBicubic( transmissionSample, lod );
+  	return textureBicubicLevel( transmissionSample, lod );
 
   } );
 
@@ -81594,7 +81898,7 @@ function InsertStackElement(node, body) {
 
   		if ( this.iridescence === true ) {
 
-  			const dotNVi = transformedNormalView.dot( positionViewDirection ).clamp();
+  			const dotNVi = normalView.dot( positionViewDirection ).clamp();
 
   			this.iridescenceFresnel = evalIridescence( {
   				outsideIOR: float( 1.0 ),
@@ -81612,7 +81916,7 @@ function InsertStackElement(node, body) {
 
   			const position = positionWorld;
   			const v = cameraPosition.sub( positionWorld ).normalize(); // TODO: Create Node for this, same issue in MaterialX
-  			const n = transformedNormalWorld;
+  			const n = normalWorld;
 
   			const context = builder.context;
 
@@ -81650,7 +81954,7 @@ function InsertStackElement(node, body) {
 
   	computeMultiscattering( singleScatter, multiScatter, specularF90 ) {
 
-  		const dotNV = transformedNormalView.dot( positionViewDirection ).clamp(); // @ TODO: Move to core dotNV
+  		const dotNV = normalView.dot( positionViewDirection ).clamp(); // @ TODO: Move to core dotNV
 
   		const fab = DFGApprox( { roughness, dotNV } );
 
@@ -81677,7 +81981,7 @@ function InsertStackElement(node, body) {
   	 */
   	direct( { lightDirection, lightColor, reflectedLight } ) {
 
-  		const dotNL = transformedNormalView.dot( lightDirection ).clamp();
+  		const dotNL = normalView.dot( lightDirection ).clamp();
   		const irradiance = dotNL.mul( lightColor );
 
   		if ( this.sheen === true ) {
@@ -81688,10 +81992,10 @@ function InsertStackElement(node, body) {
 
   		if ( this.clearcoat === true ) {
 
-  			const dotNLcc = transformedClearcoatNormalView.dot( lightDirection ).clamp();
+  			const dotNLcc = clearcoatNormalView.dot( lightDirection ).clamp();
   			const ccIrradiance = dotNLcc.mul( lightColor );
 
-  			this.clearcoatSpecularDirect.addAssign( ccIrradiance.mul( BRDF_GGX( { lightDirection, f0: clearcoatF0, f90: clearcoatF90, roughness: clearcoatRoughness, normalView: transformedClearcoatNormalView } ) ) );
+  			this.clearcoatSpecularDirect.addAssign( ccIrradiance.mul( BRDF_GGX( { lightDirection, f0: clearcoatF0, f90: clearcoatF90, roughness: clearcoatRoughness, normalView: clearcoatNormalView } ) ) );
 
   		}
 
@@ -81715,7 +82019,7 @@ function InsertStackElement(node, body) {
   		const p2 = lightPosition.sub( halfWidth ).add( halfHeight );
   		const p3 = lightPosition.add( halfWidth ).add( halfHeight );
 
-  		const N = transformedNormalView;
+  		const N = normalView;
   		const V = positionViewDirection;
   		const P = positionView.toVar();
 
@@ -81780,7 +82084,7 @@ function InsertStackElement(node, body) {
   			this.sheenSpecularIndirect.addAssign( iblIrradiance.mul(
   				sheen,
   				IBLSheenBRDF( {
-  					normal: transformedNormalView,
+  					normal: normalView,
   					viewDir: positionViewDirection,
   					roughness: sheenRoughness
   				} )
@@ -81790,7 +82094,7 @@ function InsertStackElement(node, body) {
 
   		if ( this.clearcoat === true ) {
 
-  			const dotNVcc = transformedClearcoatNormalView.dot( positionViewDirection ).clamp();
+  			const dotNVcc = clearcoatNormalView.dot( positionViewDirection ).clamp();
 
   			const clearcoatEnv = EnvironmentBRDF( {
   				dotNV: dotNVcc,
@@ -81831,7 +82135,7 @@ function InsertStackElement(node, body) {
 
   		const { ambientOcclusion, reflectedLight } = builder.context;
 
-  		const dotNV = transformedNormalView.dot( positionViewDirection ).clamp(); // @ TODO: Move to core dotNV
+  		const dotNV = normalView.dot( positionViewDirection ).clamp(); // @ TODO: Move to core dotNV
 
   		const aoNV = dotNV.add( ambientOcclusion );
   		const aoExp = roughness.mul( -16 ).oneMinus().negate().exp2();
@@ -81866,7 +82170,7 @@ function InsertStackElement(node, body) {
 
   		if ( this.clearcoat === true ) {
 
-  			const dotNVcc = transformedClearcoatNormalView.dot( positionViewDirection ).clamp();
+  			const dotNVcc = clearcoatNormalView.dot( positionViewDirection ).clamp();
 
   			const Fcc = F_Schlick( {
   				dotVH: dotNVcc,
@@ -82226,7 +82530,7 @@ function InsertStackElement(node, body) {
   	0, 4, 2
   ];
 
-  const _direction = /*@__PURE__*/ getDirection( uv(), attribute( 'faceIndex' ) ).normalize();
+  const _direction = /*@__PURE__*/ getDirection( uv$1(), attribute( 'faceIndex' ) ).normalize();
   const _outputDirection = /*@__PURE__*/ vec3( _direction.x, _direction.y, _direction.z );
 
   /**
@@ -83535,10 +83839,10 @@ function InsertStackElement(node, body) {
   		//
 
   		const useAnisotropy = material.useAnisotropy === true || material.anisotropy > 0;
-  		const radianceNormalView = useAnisotropy ? transformedBentNormalView : transformedNormalView;
+  		const radianceNormalView = useAnisotropy ? bentNormalView : normalView;
 
   		const radiance = envNode.context( createRadianceContext( roughness, radianceNormalView ) ).mul( materialEnvIntensity );
-  		const irradiance = envNode.context( createIrradianceContext( transformedNormalWorld ) ).mul( Math.PI ).mul( materialEnvIntensity );
+  		const irradiance = envNode.context( createIrradianceContext( normalWorld ) ).mul( Math.PI ).mul( materialEnvIntensity );
 
   		const isolateRadiance = cache( radiance );
   		const isolateIrradiance = cache( irradiance );
@@ -83555,7 +83859,7 @@ function InsertStackElement(node, body) {
 
   		if ( clearcoatRadiance ) {
 
-  			const clearcoatRadianceContext = envNode.context( createRadianceContext( clearcoatRoughness, transformedClearcoatNormalView ) ).mul( materialEnvIntensity );
+  			const clearcoatRadianceContext = envNode.context( createRadianceContext( clearcoatRoughness, clearcoatNormalView ) ).mul( materialEnvIntensity );
   			const isolateClearcoatRadiance = cache( clearcoatRadianceContext );
 
   			clearcoatRadiance.addAssign( isolateClearcoatRadiance );
@@ -84256,7 +84560,7 @@ function InsertStackElement(node, body) {
 
   	setup( builder ) {
 
-  		builder.context.setupClearcoatNormal = () => this.setupClearcoatNormal( builder );
+  		builder.context.setupClearcoatNormal = () => subBuild( this.setupClearcoatNormal( builder ), 'NORMAL', 'vec3' );
 
   		super.setup( builder );
 
@@ -84414,47 +84718,23 @@ function InsertStackElement(node, body) {
   }
 
   /**
+   * TSL function for creating a matcap uv node.
+   *
    * Can be used to compute texture coordinates for projecting a
    * matcap onto a mesh. Used by {@link MeshMatcapNodeMaterial}.
    *
-   * @augments TempNode
+   * @tsl
+   * @function
+   * @returns {Node<vec2>} The matcap UV coordinates.
    */
-  class MatcapUVNode extends TempNode {
-
-  	static get type() {
-
-  		return 'MatcapUVNode';
-
-  	}
-
-  	/**
-  	 * Constructs a new matcap uv node.
-  	 */
-  	constructor() {
-
-  		super( 'vec2' );
+  const matcapUV = /*@__PURE__*/ Fn( () => {
 
-  	}
-
-  	setup() {
+  	const x = vec3( positionViewDirection.z, 0, positionViewDirection.x.negate() ).normalize();
+  	const y = positionViewDirection.cross( x );
 
-  		const x = vec3( positionViewDirection.z, 0, positionViewDirection.x.negate() ).normalize();
-  		const y = positionViewDirection.cross( x );
+  	return vec2( x.dot( normalView ), y.dot( normalView ) ).mul( 0.495 ).add( 0.5 ); // 0.495 to remove artifacts caused by undersized matcap disks
 
-  		return vec2( x.dot( transformedNormalView ), y.dot( transformedNormalView ) ).mul( 0.495 ).add( 0.5 ); // 0.495 to remove artifacts caused by undersized matcap disks
-
-  	}
-
-  }
-
-  /**
-   * TSL function for creating a matcap uv node.
-   *
-   * @tsl
-   * @function
-   * @returns {MatcapUVNode}
-   */
-  const matcapUV = /*@__PURE__*/ nodeImmutable( MatcapUVNode );
+  } ).once( [ 'NORMAL', 'VERTEX' ] )().toVar( 'matcapUV' );
 
   const _defaultValues$3 = /*@__PURE__*/ new MeshMatcapMaterial();
 
@@ -85488,6 +85768,16 @@ function InsertStackElement(node, body) {
   		 */
   		this.attributes = null;
 
+  		/**
+  		 * An object holding the version of the
+  		 * attributes. The keys are the attribute names
+  		 * and the values are the attribute versions.
+  		 *
+  		 * @type {?Object<string, number>}
+  		 * @default null
+  		 */
+  		this.attributesId = null;
+
   		/**
   		 * A reference to a render pipeline the render
   		 * object is processed with.
@@ -85607,7 +85897,7 @@ function InsertStackElement(node, body) {
 
   		/**
   		 * An event listener which is executed when `dispose()` is called on
-  		 * the render object's material.
+  		 * the material of this render object.
   		 *
   		 * @method
   		 */
@@ -85617,7 +85907,23 @@ function InsertStackElement(node, body) {
 
   		};
 
+  		/**
+  		 * An event listener which is executed when `dispose()` is called on
+  		 * the geometry of this render object.
+  		 *
+  		 * @method
+  		 */
+  		this.onGeometryDispose = () => {
+
+  			// clear geometry cache attributes
+
+  			this.attributes = null;
+  			this.attributesId = null;
+
+  		};
+
   		this.material.addEventListener( 'dispose', this.onMaterialDispose );
+  		this.geometry.addEventListener( 'dispose', this.onGeometryDispose );
 
   	}
 
@@ -85756,6 +86062,7 @@ function InsertStackElement(node, body) {
 
   		this.geometry = geometry;
   		this.attributes = null;
+  		this.attributesId = null;
 
   	}
 
@@ -85775,9 +86082,25 @@ function InsertStackElement(node, body) {
   		const attributes = [];
   		const vertexBuffers = new Set();
 
+  		const attributesId = {};
+
   		for ( const nodeAttribute of nodeAttributes ) {
 
-  			const attribute = nodeAttribute.node && nodeAttribute.node.attribute ? nodeAttribute.node.attribute : geometry.getAttribute( nodeAttribute.name );
+  			let attribute;
+
+  			if ( nodeAttribute.node && nodeAttribute.node.attribute ) {
+
+  				// node attribute
+  				attribute = nodeAttribute.node.attribute;
+
+  			} else {
+
+  				// geometry attribute
+  				attribute = geometry.getAttribute( nodeAttribute.name );
+
+  				attributesId[ nodeAttribute.name ] = attribute.version;
+
+  			}
 
   			if ( attribute === undefined ) continue;
 
@@ -85789,6 +86112,7 @@ function InsertStackElement(node, body) {
   		}
 
   		this.attributes = attributes;
+  		this.attributesId = attributesId;
   		this.vertexBuffers = Array.from( vertexBuffers.values() );
 
   		return attributes;
@@ -86053,7 +86377,27 @@ function InsertStackElement(node, body) {
   	 */
   	get needsGeometryUpdate() {
 
-  		return this.geometry.id !== this.object.geometry.id;
+  		if ( this.geometry.id !== this.object.geometry.id ) return true;
+
+  		if ( this.attributes !== null ) {
+
+  			const attributesId = this.attributesId;
+
+  			for ( const name in attributesId ) {
+
+  				const attribute = this.geometry.getAttribute( name );
+
+  				if ( attribute === undefined || attributesId[ name ] !== attribute.id ) {
+
+  					return true;
+
+  				}
+
+  			}
+
+  		}
+
+  		return false;
 
   	}
 
@@ -86131,6 +86475,7 @@ function InsertStackElement(node, body) {
   	dispose() {
 
   		this.material.removeEventListener( 'dispose', this.onMaterialDispose );
+  		this.geometry.removeEventListener( 'dispose', this.onGeometryDispose );
 
   		this.onDispose();
 
@@ -89674,10 +90019,13 @@ function InsertStackElement(node, body) {
 
   	build( builder, ...params ) {
 
+  		const previousBuildStack = builder.currentStack;
   		const previousStack = getCurrentStack();
 
   		setCurrentStack( this );
 
+  		builder.currentStack = this;
+
   		const buildStage = builder.buildStage;
 
   		for ( const node of this.nodes ) {
@@ -89707,38 +90055,13 @@ function InsertStackElement(node, body) {
 
   		}
 
-  		setCurrentStack( previousStack );
-
-  		return this.outputNode ? this.outputNode.build( builder, ...params ) : super.build( builder, ...params );
-
-  	}
-
-  	// Deprecated
-
-  	/**
-  	 * @function
-  	 * @deprecated since r168. Use {@link StackNode#Else} instead.
-  	 *
-  	 * @param {...any} params
-  	 * @returns {StackNode}
-  	 */
-  	else( ...params ) { // @deprecated, r168
-
-  		console.warn( 'THREE.TSL: .else() has been renamed to .Else().' );
-  		return this.Else( ...params );
+  		const result = this.outputNode ? this.outputNode.build( builder, ...params ) : super.build( builder, ...params );
 
-  	}
+  		setCurrentStack( previousStack );
 
-  	/**
-  	 * @deprecated since r168. Use {@link StackNode#ElseIf} instead.
-  	 *
-  	 * @param {...any} params
-  	 * @returns {StackNode}
-  	 */
-  	elseif( ...params ) { // @deprecated, r168
+  		builder.currentStack = previousBuildStack;
 
-  		console.warn( 'THREE.TSL: .elseif() has been renamed to .ElseIf().' );
-  		return this.ElseIf( ...params );
+  		return result;
 
   	}
 
@@ -90042,9 +90365,9 @@ function InsertStackElement(node, body) {
 
   		const step = 0.01;
 
-  		const x = texture.sample( uv.add( vec3( -0.01, 0.0, 0.0 ) ) ).r.sub( texture.sample( uv.add( vec3( step, 0.0, 0.0 ) ) ).r );
-  		const y = texture.sample( uv.add( vec3( 0.0, -0.01, 0.0 ) ) ).r.sub( texture.sample( uv.add( vec3( 0.0, step, 0.0 ) ) ).r );
-  		const z = texture.sample( uv.add( vec3( 0.0, 0.0, -0.01 ) ) ).r.sub( texture.sample( uv.add( vec3( 0.0, 0.0, step ) ) ).r );
+  		const x = texture.sample( uv.add( vec3( - step, 0.0, 0.0 ) ) ).r.sub( texture.sample( uv.add( vec3( step, 0.0, 0.0 ) ) ).r );
+  		const y = texture.sample( uv.add( vec3( 0.0, - step, 0.0 ) ) ).r.sub( texture.sample( uv.add( vec3( 0.0, step, 0.0 ) ) ).r );
+  		const z = texture.sample( uv.add( vec3( 0.0, 0.0, - step ) ) ).r.sub( texture.sample( uv.add( vec3( 0.0, 0.0, step ) ) ).r );
 
   		ret.assign( vec3( x, y, z ) );
 
@@ -90305,7 +90628,16 @@ function InsertStackElement(node, body) {
 
   	clone() {
 
-  		return new this.constructor( this.passNode, this.textureName, this.previousTexture );
+  		const newNode = new this.constructor( this.passNode, this.textureName, this.previousTexture );
+  		newNode.uvNode = this.uvNode;
+  		newNode.levelNode = this.levelNode;
+  		newNode.biasNode = this.biasNode;
+  		newNode.sampler = this.sampler;
+  		newNode.depthNode = this.depthNode;
+  		newNode.compareNode = this.compareNode;
+  		newNode.gradNode = this.gradNode;
+
+  		return newNode;
 
   	}
 
@@ -90765,13 +91097,6 @@ function InsertStackElement(node, body) {
 
   		this.renderTarget.samples = this.options.samples === undefined ? renderer.samples : this.options.samples;
 
-  		// TODO: Disable MSAA for WebGL backend for now
-  		if ( renderer.backend.isWebGLBackend === true ) {
-
-  			this.renderTarget.samples = 0;
-
-  		}
-
   		this.renderTarget.texture.type = renderer.getColorBufferType();
 
   		return this.scope === PassNode.COLOR ? this.getTextureNode() : this.getLinearDepthNode();
@@ -91853,21 +92178,21 @@ function InsertStackElement(node, body) {
   		 *
   		 * @type {Node<vec3>}
   		 */
-  		this.totalDiffuseNode = vec3().toVar();
+  		this.totalDiffuseNode = property( 'vec3', 'totalDiffuse' );
 
   		/**
   		 * A node representing the total specular light.
   		 *
   		 * @type {Node<vec3>}
   		 */
-  		this.totalSpecularNode = vec3().toVar();
+  		this.totalSpecularNode = property( 'vec3', 'totalSpecular' );
 
   		/**
   		 * A node representing the outgoing light.
   		 *
   		 * @type {Node<vec3>}
   		 */
-  		this.outgoingLightNode = vec3().toVar();
+  		this.outgoingLightNode = property( 'vec3', 'outgoingLight' );
 
   		/**
   		 * An array representing the lights in the scene.
@@ -93214,7 +93539,7 @@ function InsertStackElement(node, body) {
   		const shadowIntensity = reference( 'intensity', 'float', shadow ).setGroup( renderGroup );
   		const normalBias = reference( 'normalBias', 'float', shadow ).setGroup( renderGroup );
 
-  		const shadowPosition = lightShadowMatrix( light ).mul( shadowPositionWorld.add( transformedNormalWorld.mul( normalBias ) ) );
+  		const shadowPosition = lightShadowMatrix( light ).mul( shadowPositionWorld.add( normalWorld.mul( normalBias ) ) );
   		const shadowCoord = this.setupShadowCoord( builder, shadowPosition );
 
   		//
@@ -94135,7 +94460,7 @@ function InsertStackElement(node, body) {
    * @param {Node<vec2>} coord - The uv to generate the circle.
    * @return {Node<float>} The circle shape.
    */
-  Fn( ( [ coord = uv() ], { renderer, material } ) => {
+  Fn( ( [ coord = uv$1() ], { renderer, material } ) => {
 
   	const len2 = lengthSq( coord.mul( 2 ).sub( 1 ) );
 
@@ -94264,7 +94589,7 @@ function InsertStackElement(node, body) {
 
   				const backgroundMeshNode = context( vec4( backgroundNode ).mul( backgroundIntensity ), {
   					// @TODO: Add Texture2D support using node context
-  					getUV: () => backgroundRotation.mul( normalWorld ),
+  					getUV: () => backgroundRotation.mul( normalWorldGeometry ),
   					getTextureLevel: () => backgroundBlurriness
   				} );
 
@@ -96134,6 +96459,30 @@ function InsertStackElement(node, body) {
   		 */
   		this.buildStage = null;
 
+  		/**
+  		 * The sub-build layers.
+  		 *
+  		 * @type {Array<SubBuildNode>}
+  		 * @default []
+  		 */
+  		this.subBuildLayers = [];
+
+  		/**
+  		 * The current stack of nodes.
+  		 *
+  		 * @type {?StackNode}
+  		 * @default null
+  		 */
+  		this.currentStack = null;
+
+  		/**
+  		 * The current sub-build TSL function(Fn).
+  		 *
+  		 * @type {?string}
+  		 * @default null
+  		 */
+  		this.subBuildFn = null;
+
   	}
 
   	/**
@@ -97290,7 +97639,23 @@ function InsertStackElement(node, body) {
 
   		if ( nodeData[ shaderStage ] === undefined ) nodeData[ shaderStage ] = {};
 
-  		return nodeData[ shaderStage ];
+  		//
+
+  		let data = nodeData[ shaderStage ];
+
+  		const subBuilds = nodeData.any ? nodeData.any.subBuilds : null;
+  		const subBuild = this.getClosestSubBuild( subBuilds );
+
+  		if ( subBuild ) {
+
+  			if ( data.subBuildsCache === undefined ) data.subBuildsCache = {};
+
+  			data = data.subBuildsCache[ subBuild ] || ( data.subBuildsCache[ subBuild ] = {} );
+  			data.subBuilds = subBuilds;
+
+  		}
+
+  		return data;
 
   	}
 
@@ -97451,8 +97816,9 @@ function InsertStackElement(node, body) {
   	getVarFromNode( node, name = null, type = node.getNodeType( this ), shaderStage = this.shaderStage, readOnly = false ) {
 
   		const nodeData = this.getDataFromNode( node, shaderStage );
+  		const subBuildVariable = this.getSubBuildProperty( 'variable', nodeData.subBuilds );
 
-  		let nodeVar = nodeData.variable;
+  		let nodeVar = nodeData[ subBuildVariable ];
 
   		if ( nodeVar === undefined ) {
 
@@ -97471,6 +97837,14 @@ function InsertStackElement(node, body) {
 
   			//
 
+  			if ( subBuildVariable !== 'variable' ) {
+
+  				name = this.getSubBuildProperty( name, nodeData.subBuilds );
+
+  			}
+
+  			//
+
   			const count = this.getArrayCount( node );
 
   			nodeVar = new NodeVar( name, type, readOnly, count );
@@ -97483,7 +97857,7 @@ function InsertStackElement(node, body) {
 
   			this.registerDeclaration( nodeVar );
 
-  			nodeData.variable = nodeVar;
+  			nodeData[ subBuildVariable ] = nodeVar;
 
   		}
 
@@ -97551,8 +97925,9 @@ function InsertStackElement(node, body) {
   	getVaryingFromNode( node, name = null, type = node.getNodeType( this ), interpolationType = null, interpolationSampling = null ) {
 
   		const nodeData = this.getDataFromNode( node, 'any' );
+  		const subBuildVarying = this.getSubBuildProperty( 'varying', nodeData.subBuilds );
 
-  		let nodeVarying = nodeData.varying;
+  		let nodeVarying = nodeData[ subBuildVarying ];
 
   		if ( nodeVarying === undefined ) {
 
@@ -97561,69 +97936,27 @@ function InsertStackElement(node, body) {
 
   			if ( name === null ) name = 'nodeVarying' + index;
 
-  			nodeVarying = new NodeVarying( name, type, interpolationType, interpolationSampling );
-
-  			varyings.push( nodeVarying );
-
-  			this.registerDeclaration( nodeVarying );
-
-  			nodeData.varying = nodeVarying;
-
-  		}
-
-  		return nodeVarying;
-
-  	}
-
-  	/**
-  	 * Returns the current namespace for the node builder.
-  	 *
-  	 * @return {string} The current namespace.
-  	 */
-  	get namespace() {
-
-  		return this.context.namespace;
-
-  	}
-
-  	/**
-  	 * Returns the output namespace for the node builder, which is used for the current output node.
-  	 *
-  	 * @return {string} The output namespace.
-  	 */
-  	getOutputNamespace() {
-
-  		return this.getNamespace( 'outputNode' );
+  			//
 
-  	}
+  			if ( subBuildVarying !== 'varying' ) {
 
-  	/**
-  	 * Returns the namespace for the given property.
-  	 *
-  	 * If the property name is not set, it returns the namespace only.
-  	 * If the namespace is not set, it returns the property name.
-  	 * If the namespace is set, it returns the namespace concatenated with the property name.
-  	 *
-  	 * @param {string} [property=''] - The property name.
-  	 * @return {string} The namespace for the property.
-  	 */
-  	getNamespace( property = '' ) {
+  				name = this.getSubBuildProperty( name, nodeData.subBuilds );
 
-  		const ns = this.namespace;
+  			}
 
-  		let nsName;
+  			//
 
-  		if ( ns ) {
+  			nodeVarying = new NodeVarying( name, type, interpolationType, interpolationSampling );
 
-  			nsName = property ? ( ns + '_' + property ) : ns;
+  			varyings.push( nodeVarying );
 
-  		} else {
+  			this.registerDeclaration( nodeVarying );
 
-  			nsName = property;
+  			nodeData[ subBuildVarying ] = nodeVarying;
 
   		}
 
-  		return nsName;
+  		return nodeVarying;
 
   	}
 
@@ -98280,6 +98613,145 @@ function InsertStackElement(node, body) {
 
   	}
 
+  	/**
+  	 * Returns the current sub-build layer.
+  	 *
+  	 * @return {SubBuildNode} The current sub-build layers.
+  	 */
+  	get subBuild() {
+
+  		return this.subBuildLayers[ this.subBuildLayers.length - 1 ] || null;
+
+  	}
+
+  	/**
+  	 * Adds a sub-build layer to the node builder.
+  	 *
+  	 * @param {SubBuildNode} subBuild - The sub-build layer to add.
+  	 */
+  	addSubBuild( subBuild ) {
+
+  		this.subBuildLayers.push( subBuild );
+
+  	}
+
+  	/**
+  	 * Removes the last sub-build layer from the node builder.
+  	 *
+  	 * @return {SubBuildNode} The removed sub-build layer.
+  	 */
+  	removeSubBuild() {
+
+  		return this.subBuildLayers.pop();
+
+  	}
+
+  	/**
+  	 * Returns the closest sub-build layer for the given data.
+  	 *
+  	 * @param {Node|Set|Array} data - The data to get the closest sub-build layer from.
+  	 * @return {?string} The closest sub-build name or null if none found.
+  	 */
+  	getClosestSubBuild( data ) {
+
+  		let subBuilds;
+
+  		if ( data && data.isNode ) {
+
+  			if ( data.isShaderCallNodeInternal ) {
+
+  				subBuilds = data.shaderNode.subBuilds;
+
+  			} else if ( data.isStackNode ) {
+
+  				subBuilds = [ data.subBuild ];
+
+  			} else {
+
+  				subBuilds = this.getDataFromNode( data, 'any' ).subBuilds;
+
+  			}
+
+  		} else if ( data instanceof Set ) {
+
+  			subBuilds = [ ...data ];
+
+  		} else {
+
+  			subBuilds = data;
+
+  		}
+
+  		if ( ! subBuilds ) return null;
+
+  		const subBuildLayers = this.subBuildLayers;
+
+  		for ( let i = subBuilds.length - 1; i >= 0; i -- ) {
+
+  			const subBuild = subBuilds[ i ];
+
+  			if ( subBuildLayers.includes( subBuild ) ) {
+
+  				return subBuild;
+
+  			}
+
+  		}
+
+  		return null;
+
+  	}
+
+
+  	/**
+  	 * Returns the output node of a sub-build layer.
+  	 *
+  	 * @param {Node} node - The node to get the output from.
+  	 * @return {string} The output node name.
+  	 */
+  	getSubBuildOutput( node ) {
+
+  		return this.getSubBuildProperty( 'outputNode', node );
+
+  	}
+
+  	/**
+  	 * Returns the sub-build property name for the given property and node.
+  	 *
+  	 * @param {string} [property=''] - The property name.
+  	 * @param {?Node} [node=null] - The node to get the sub-build from.
+  	 * @return {string} The sub-build property name.
+  	 */
+  	getSubBuildProperty( property = '', node = null ) {
+
+  		let subBuild;
+
+  		if ( node !== null ) {
+
+  			subBuild = this.getClosestSubBuild( node );
+
+  		} else {
+
+  			subBuild = this.subBuildFn;
+
+  		}
+
+  		let result;
+
+  		if ( subBuild ) {
+
+  			result = property ? ( subBuild + '_' + property ) : subBuild;
+
+  		} else {
+
+  			result = property;
+
+  		}
+
+  		return result;
+
+  	}
+
   	/**
   	 * Central build method which controls the build for the given object.
   	 *
@@ -98489,22 +98961,6 @@ function InsertStackElement(node, body) {
   	 */
   	*[ Symbol.iterator ]() { }
 
-  	// Deprecated
-
-  	/**
-  	 * @function
-  	 * @deprecated since r168. Use `new NodeMaterial()` instead, with targeted node material name.
-  	 *
-  	 * @param {string} [type='NodeMaterial'] - The node material type.
-  	 * @throws {Error}
-  	 */
-  	createNodeMaterial( type = 'NodeMaterial' ) { // @deprecated, r168
-
-  		throw new Error( `THREE.NodeBuilder: createNodeMaterial() was deprecated. Use new ${ type }() instead.` );
-
-  	}
-
-
   }
 
   /**
@@ -101194,10 +101650,11 @@ function InsertStackElement(node, body) {
   		 * are defined by external textures. This flag is
   		 * set to `true` when using the WebXR Layers API.
   		 *
+  		 * @private
   		 * @type {boolean}
   		 * @default false
   		 */
-  		this.hasExternalTextures = false;
+  		this._hasExternalTextures = false;
 
   		/**
   		 * Whether a depth buffer should automatically be allocated
@@ -101210,10 +101667,25 @@ function InsertStackElement(node, body) {
   		 *
   		 * Reference: {@link https://www.w3.org/TR/webxrlayers-1/#dom-xrprojectionlayer-ignoredepthvalues}.
   		 *
+  		 * @private
   		 * @type {boolean}
   		 * @default true
   		 */
-  		this.autoAllocateDepthBuffer = true;
+  		this._autoAllocateDepthBuffer = true;
+
+  		/**
+  		 * Whether this render target is associated with a XRWebGLLayer.
+  		 *
+  		 * A XRWebGLLayer points to an opaque framebuffer. Basically,
+  		 * this means that you don't have access to its bound color,
+  		 * stencil and depth buffers. We need to handle this framebuffer
+  		 * differently since its textures are always bound.
+  		 *
+  		 * @private
+  		 * @type {boolean}
+  		 * @default false
+  		 * */
+  		this._isOpaqueFramebuffer = false;
 
   	}
 
@@ -101221,8 +101693,9 @@ function InsertStackElement(node, body) {
 
   		super.copy( source );
 
-  		this.hasExternalTextures = source.hasExternalTextures;
-  		this.autoAllocateDepthBuffer = source.autoAllocateDepthBuffer;
+  		this._hasExternalTextures = source._hasExternalTextures;
+  		this._autoAllocateDepthBuffer = source._autoAllocateDepthBuffer;
+  		this._isOpaqueFramebuffer = source._isOpaqueFramebuffer;
 
   		return this;
 
@@ -101855,7 +102328,7 @@ function InsertStackElement(node, body) {
   				resolveStencilBuffer: false
   			} );
 
-  		renderTarget.autoAllocateDepthBuffer = true;
+  		renderTarget._autoAllocateDepthBuffer = true;
 
   		const material = new MeshBasicMaterial( { color: 0xffffff, side: FrontSide } );
   		material.map = renderTarget.texture;
@@ -101946,7 +102419,7 @@ function InsertStackElement(node, body) {
   				resolveStencilBuffer: false
   			} );
 
-  		renderTarget.autoAllocateDepthBuffer = true;
+  		renderTarget._autoAllocateDepthBuffer = true;
 
   		const material = new MeshBasicMaterial( { color: 0xffffff, side: BackSide } );
   		material.map = renderTarget.texture;
@@ -102020,7 +102493,7 @@ function InsertStackElement(node, body) {
   		for ( const layer of this._layers ) {
 
   			layer.renderTarget.isXRRenderTarget = this._session !== null;
-  			layer.renderTarget.hasExternalTextures = layer.renderTarget.isXRRenderTarget;
+  			layer.renderTarget._hasExternalTextures = layer.renderTarget.isXRRenderTarget;
 
   			if ( layer.renderTarget.isXRRenderTarget && this._supportsLayers ) {
 
@@ -102188,7 +102661,7 @@ function InsertStackElement(node, body) {
   						multiview: this._useMultiview
   					} );
 
-  				this._xrRenderTarget.hasExternalTextures = true;
+  				this._xrRenderTarget._hasExternalTextures = true;
   				this._xrRenderTarget.depth = this._useMultiview ? 2 : 1;
 
   				this._supportsLayers = session.enabledFeatures.includes( 'layers' );
@@ -102250,6 +102723,7 @@ function InsertStackElement(node, body) {
   					}
   				);
 
+  				this._xrRenderTarget._isOpaqueFramebuffer = true;
   				this._referenceSpace = await session.requestReferenceSpace( this.getReferenceSpaceType() );
 
   			}
@@ -104077,7 +104551,7 @@ function InsertStackElement(node, body) {
   		frameBufferTarget.scissorTest = this._scissorTest;
   		frameBufferTarget.multiview = outputRenderTarget !== null ? outputRenderTarget.multiview : false;
   		frameBufferTarget.resolveDepthBuffer = outputRenderTarget !== null ? outputRenderTarget.resolveDepthBuffer : true;
-  		frameBufferTarget.autoAllocateDepthBuffer = outputRenderTarget !== null ? outputRenderTarget.autoAllocateDepthBuffer : false;
+  		frameBufferTarget._autoAllocateDepthBuffer = outputRenderTarget !== null ? outputRenderTarget._autoAllocateDepthBuffer : false;
 
   		return frameBufferTarget;
 
@@ -106929,9 +107403,7 @@ function InsertStackElement(node, body) {
   };
 
   const interpolationModeMap = {
-  	'centroid': 'centroid',
-  	'flat first': 'flat',
-  	'flat either': 'flat'
+  	'centroid': 'centroid'
   };
 
   const defaultPrecisions = `
@@ -109094,6 +109566,10 @@ void main() {
 
   			type = gl.FLOAT;
 
+  		} else if ( typeof Float16Array !== 'undefined' && array instanceof Float16Array ) {
+
+  			type = gl.HALF_FLOAT;
+
   		} else if ( array instanceof Uint16Array ) {
 
   			if ( attribute.isFloat16BufferAttribute ) {
@@ -109629,7 +110105,7 @@ void main() {
   							break;
 
   						case MultiplyBlending:
-  							gl.blendFuncSeparate( gl.ZERO, gl.SRC_COLOR, gl.ZERO, gl.SRC_ALPHA );
+  							gl.blendFuncSeparate( gl.DST_COLOR, gl.ONE_MINUS_SRC_ALPHA, gl.ZERO, gl.ONE );
   							break;
 
   						default:
@@ -109647,15 +110123,15 @@ void main() {
   							break;
 
   						case AdditiveBlending:
-  							gl.blendFunc( gl.SRC_ALPHA, gl.ONE );
+  							gl.blendFuncSeparate( gl.SRC_ALPHA, gl.ONE, gl.ONE, gl.ONE );
   							break;
 
   						case SubtractiveBlending:
-  							gl.blendFuncSeparate( gl.ZERO, gl.ONE_MINUS_SRC_COLOR, gl.ZERO, gl.ONE );
+  							console.error( 'THREE.WebGLState: SubtractiveBlending requires material.premultipliedAlpha = true' );
   							break;
 
   						case MultiplyBlending:
-  							gl.blendFunc( gl.ZERO, gl.SRC_COLOR );
+  							console.error( 'THREE.WebGLState: MultiplyBlending requires material.premultipliedAlpha = true' );
   							break;
 
   						default:
@@ -111758,6 +112234,8 @@ void main() {
 
   		}
 
+  		gl.bindRenderbuffer( gl.RENDERBUFFER, null );
+
   	}
 
   	/**
@@ -112998,13 +113476,13 @@ void main() {
 
   			// The multisample_render_to_texture extension doesn't work properly if there
   			// are midframe flushes and an external depth texture.
-  			if ( ( this.extensions.has( 'WEBGL_multisampled_render_to_texture' ) === true ) && renderTarget.autoAllocateDepthBuffer === true && renderTarget.multiview === false ) {
+  			if ( ( this.extensions.has( 'WEBGL_multisampled_render_to_texture' ) === true ) && renderTarget._autoAllocateDepthBuffer === true && renderTarget.multiview === false ) {
 
   				console.warn( 'THREE.WebGLBackend: Render-to-texture extension was disabled because an external texture was provided' );
 
   			}
 
-  			renderTarget.autoAllocateDepthBuffer = false;
+  			renderTarget._autoAllocateDepthBuffer = false;
 
   		}
 
@@ -113177,29 +113655,60 @@ void main() {
   		}
 
   		this._currentContext = previousContext;
+  		const renderTarget = renderContext.renderTarget;
 
-  		if ( renderContext.textures !== null && renderContext.renderTarget ) {
-
-  			const renderTargetContextData = this.get( renderContext.renderTarget );
+  		if ( renderContext.textures !== null && renderTarget ) {
 
-  			const { resolveDepthBuffer, samples } = renderContext.renderTarget;
+  			const renderTargetContextData = this.get( renderTarget );
 
-  			if ( samples > 0 && this._useMultisampledExtension( renderContext.renderTarget ) === false ) {
+  			if ( renderTarget.samples > 0 && this._useMultisampledExtension( renderTarget ) === false ) {
 
   				const fb = renderTargetContextData.framebuffers[ renderContext.getCacheKey() ];
 
-  				const mask = gl.COLOR_BUFFER_BIT;
+  				let mask = gl.COLOR_BUFFER_BIT;
+
+  				if ( renderTarget.resolveDepthBuffer ) {
+
+  					if ( renderTarget.depthBuffer ) mask |= gl.DEPTH_BUFFER_BIT;
+  					if ( renderTarget.stencilBuffer && renderTarget.resolveStencilBuffer ) mask |= gl.STENCIL_BUFFER_BIT;
+
+  				}
 
   				const msaaFrameBuffer = renderTargetContextData.msaaFrameBuffer;
+  				const msaaRenderbuffers = renderTargetContextData.msaaRenderbuffers;
 
   				const textures = renderContext.textures;
+  				const isMRT = textures.length > 1;
 
   				state.bindFramebuffer( gl.READ_FRAMEBUFFER, msaaFrameBuffer );
   				state.bindFramebuffer( gl.DRAW_FRAMEBUFFER, fb );
 
+  				if ( isMRT ) {
+
+  					// blitFramebuffer() can only copy/resolve the first color attachment of a framebuffer. When using MRT,
+  					// the engine temporarily removes all attachments and then configures each attachment for the resolve.
+
+  					for ( let i = 0; i < textures.length; i ++ ) {
+
+  						gl.framebufferRenderbuffer( gl.READ_FRAMEBUFFER, gl.COLOR_ATTACHMENT0 + i, gl.RENDERBUFFER, null );
+  						gl.framebufferTexture2D( gl.DRAW_FRAMEBUFFER, gl.COLOR_ATTACHMENT0 + i, gl.TEXTURE_2D, null, 0 );
+
+  					}
+
+  				}
+
   				for ( let i = 0; i < textures.length; i ++ ) {
 
-  					// TODO Add support for MRT
+  					if ( isMRT ) {
+
+  						// configure attachment for resolve
+
+  						const { textureGPU } = this.get( textures[ i ] );
+
+  						gl.framebufferRenderbuffer( gl.READ_FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.RENDERBUFFER, msaaRenderbuffers[ i ] );
+  						gl.framebufferTexture2D( gl.DRAW_FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, textureGPU, 0 );
+
+  					}
 
   					if ( renderContext.scissor ) {
 
@@ -113209,27 +113718,36 @@ void main() {
 
   						gl.blitFramebuffer( x, viewY, x + width, viewY + height, x, viewY, x + width, viewY + height, mask, gl.NEAREST );
 
-  						if ( this._supportsInvalidateFramebuffer === true ) {
+  					} else {
 
-  							gl.invalidateSubFramebuffer( gl.READ_FRAMEBUFFER, renderTargetContextData.invalidationArray, x, viewY, width, height );
+  						gl.blitFramebuffer( 0, 0, renderContext.width, renderContext.height, 0, 0, renderContext.width, renderContext.height, mask, gl.NEAREST );
 
-  						}
+  					}
 
-  					} else {
+  				}
 
-  						gl.blitFramebuffer( 0, 0, renderContext.width, renderContext.height, 0, 0, renderContext.width, renderContext.height, mask, gl.NEAREST );
+  				if ( isMRT ) {
 
-  						if ( this._supportsInvalidateFramebuffer === true ) {
+  					// restore attachments
 
-  							gl.invalidateFramebuffer( gl.READ_FRAMEBUFFER, renderTargetContextData.invalidationArray );
+  					for ( let i = 0; i < textures.length; i ++ ) {
 
-  						}
+  						const { textureGPU } = this.get( textures[ i ] );
+
+  						gl.framebufferRenderbuffer( gl.READ_FRAMEBUFFER, gl.COLOR_ATTACHMENT0 + i, gl.RENDERBUFFER, msaaRenderbuffers[ i ] );
+  						gl.framebufferTexture2D( gl.DRAW_FRAMEBUFFER, gl.COLOR_ATTACHMENT0 + i, gl.TEXTURE_2D, textureGPU, 0 );
 
   					}
 
   				}
 
-  			} else if ( resolveDepthBuffer === false && renderTargetContextData.framebuffers ) {
+  				if ( this._supportsInvalidateFramebuffer === true ) {
+
+  					gl.invalidateFramebuffer( gl.READ_FRAMEBUFFER, renderTargetContextData.invalidationArray );
+
+  				}
+
+  			} else if ( renderTarget.resolveDepthBuffer === false && renderTargetContextData.framebuffers ) {
 
   				const fb = renderTargetContextData.framebuffers[ renderContext.getCacheKey() ];
   				state.bindFramebuffer( gl.DRAW_FRAMEBUFFER, fb );
@@ -113530,7 +114048,7 @@ void main() {
 
   		if ( vaoGPU === undefined ) {
 
-  			this._createVao( attributes );
+  			this.vaoCache[ vaoKey ] = this._createVao( attributes );
 
   		} else {
 
@@ -113566,7 +114084,7 @@ void main() {
 
   			const dualAttributeData = transformBuffers[ i ];
 
-  			if ( dualAttributeData.pbo ) {
+  			if ( dualAttributeData.pbo && this.has( dualAttributeData.pbo ) ) {
 
   				this.textureUtils.copyBufferToTexture( dualAttributeData.transformBuffer, dualAttributeData.pbo );
 
@@ -113648,28 +114166,23 @@ void main() {
 
   		// vertex state
 
-  		const renderObjectData = this.get( renderObject );
+  		const attributes = renderObject.getAttributes();
+  		const attributesData = this.get( attributes );
 
-  		let vaoGPU = renderObjectData.staticVao;
+  		let vaoGPU = attributesData.vaoGPU;
 
-  		if ( vaoGPU === undefined || renderObjectData.geometryId !== renderObject.geometry.id ) {
+  		if ( vaoGPU === undefined ) {
 
-  			const vaoKey = this._getVaoKey( renderObject.getAttributes() );
+  			const vaoKey = this._getVaoKey( attributes );
 
   			vaoGPU = this.vaoCache[ vaoKey ];
 
   			if ( vaoGPU === undefined ) {
 
-  				let staticVao;
+  				vaoGPU = this._createVao( attributes );
 
-  				( { vaoGPU, staticVao } = this._createVao( renderObject.getAttributes() ) );
-
-  				if ( staticVao ) {
-
-  					renderObjectData.staticVao = vaoGPU;
-  					renderObjectData.geometryId = renderObject.geometry.id;
-
-  				}
+  				this.vaoCache[ vaoKey ] = vaoGPU;
+  				attributesData.vaoGPU = vaoGPU;
 
   			}
 
@@ -114636,7 +115149,7 @@ void main() {
   			const isRenderTarget3D = renderTarget.isRenderTarget3D === true;
   			const isRenderTargetArray = renderTarget.depth > 1;
   			const isXRRenderTarget = renderTarget.isXRRenderTarget === true;
-  			const hasExternalTextures = ( isXRRenderTarget === true && renderTarget.hasExternalTextures === true );
+  			const _hasExternalTextures = ( isXRRenderTarget === true && renderTarget._hasExternalTextures === true );
 
   			let msaaFb = renderTargetContextData.msaaFrameBuffer;
   			let depthRenderbuffer = renderTargetContextData.depthRenderbuffer;
@@ -114653,7 +115166,7 @@ void main() {
 
   				fb = renderTargetContextData.cubeFramebuffers[ cacheKey ];
 
-  			} else if ( isXRRenderTarget && hasExternalTextures === false ) {
+  			} else if ( isXRRenderTarget && _hasExternalTextures === false ) {
 
   				fb = this._xrFramebuffer;
 
@@ -114723,13 +115236,11 @@ void main() {
 
   					}
 
-  					state.drawBuffers( descriptor, fb );
-
   				}
 
   				const depthStyle = stencilBuffer ? gl.DEPTH_STENCIL_ATTACHMENT : gl.DEPTH_ATTACHMENT;
 
-  				if ( renderTarget.autoAllocateDepthBuffer === true ) {
+  				if ( renderTarget._autoAllocateDepthBuffer === true ) {
 
   					const renderbuffer = gl.createRenderbuffer();
   					this.textureUtils.setupRenderBufferStorage( renderbuffer, descriptor, 0, useMultisampledRTT );
@@ -114754,7 +115265,7 @@ void main() {
 
   							multiviewExt.framebufferTextureMultisampleMultiviewOVR( gl.FRAMEBUFFER, depthStyle, textureData.textureGPU, 0, samples, 0, 2 );
 
-  						} else if ( hasExternalTextures && useMultisampledRTT ) {
+  						} else if ( _hasExternalTextures && useMultisampledRTT ) {
 
   							multisampledRTTExt.framebufferTexture2DMultisampleEXT( gl.FRAMEBUFFER, depthStyle, gl.TEXTURE_2D, textureData.textureGPU, 0, samples );
 
@@ -114805,7 +115316,7 @@ void main() {
 
   				// rebind external XR textures
 
-  				if ( isXRRenderTarget || useMultisampledRTT || renderTarget.multiview ) {
+  				if ( ( isXRRenderTarget || useMultisampledRTT || renderTarget.multiview ) && ( renderTarget._isOpaqueFramebuffer !== true ) ) {
 
   					state.bindFramebuffer( gl.FRAMEBUFFER, fb );
 
@@ -114831,7 +115342,7 @@ void main() {
 
   					const depthStyle = stencilBuffer ? gl.DEPTH_STENCIL_ATTACHMENT : gl.DEPTH_ATTACHMENT;
 
-  					if ( renderTarget.autoAllocateDepthBuffer === true ) {
+  					if ( renderTarget._autoAllocateDepthBuffer === true ) {
 
   						const renderbuffer = renderTargetContextData.xrDepthRenderbuffer;
   						gl.bindRenderbuffer( gl.RENDERBUFFER, renderbuffer );
@@ -114883,13 +115394,6 @@ void main() {
 
   						invalidationArray.push( gl.COLOR_ATTACHMENT0 + i );
 
-  						if ( depthBuffer ) {
-
-  							const depthStyle = stencilBuffer ? gl.DEPTH_STENCIL_ATTACHMENT : gl.DEPTH_ATTACHMENT;
-  							invalidationArray.push( depthStyle );
-
-  						}
-
   						const texture = descriptor.textures[ i ];
   						const textureData = this.get( texture );
 
@@ -114899,10 +115403,12 @@ void main() {
 
   					}
 
+  					gl.bindRenderbuffer( gl.RENDERBUFFER, null );
+
   					renderTargetContextData.msaaFrameBuffer = msaaFb;
   					renderTargetContextData.msaaRenderbuffers = msaaRenderbuffers;
 
-  					if ( depthRenderbuffer === undefined ) {
+  					if ( depthBuffer && depthRenderbuffer === undefined ) {
 
   						depthRenderbuffer = gl.createRenderbuffer();
   						this.textureUtils.setupRenderBufferStorage( depthRenderbuffer, descriptor, samples );
@@ -114926,6 +115432,8 @@ void main() {
 
   			}
 
+  			state.drawBuffers( descriptor, fb );
+
   		}
 
   		state.bindFramebuffer( gl.FRAMEBUFFER, currentFrameBuffer );
@@ -114967,9 +115475,6 @@ void main() {
   		const { gl } = this;
 
   		const vaoGPU = gl.createVertexArray();
-  		let key = '';
-
-  		let staticVao = true;
 
   		gl.bindVertexArray( vaoGPU );
 
@@ -114978,13 +115483,9 @@ void main() {
   			const attribute = attributes[ i ];
   			const attributeData = this.get( attribute );
 
-  			key += ':' + attributeData.id;
-
   			gl.bindBuffer( gl.ARRAY_BUFFER, attributeData.bufferGPU );
   			gl.enableVertexAttribArray( i );
 
-  			if ( attribute.isStorageBufferAttribute || attribute.isStorageInstancedBufferAttribute ) staticVao = false;
-
   			let stride, offset;
 
   			if ( attribute.isInterleavedBufferAttribute === true ) {
@@ -115023,9 +115524,7 @@ void main() {
 
   		gl.bindBuffer( gl.ARRAY_BUFFER, null );
 
-  		this.vaoCache[ key ] = vaoGPU;
-
-  		return { vaoGPU, staticVao };
+  		return vaoGPU;
 
   	}
 
@@ -115162,7 +115661,7 @@ void main() {
 
   		}
 
-  		return renderTarget.samples > 0 && this.extensions.has( 'WEBGL_multisampled_render_to_texture' ) === true && renderTarget.autoAllocateDepthBuffer !== false;
+  		return renderTarget.samples > 0 && this.extensions.has( 'WEBGL_multisampled_render_to_texture' ) === true && renderTarget._autoAllocateDepthBuffer !== false;
 
   	}
 
@@ -115446,20 +115945,26 @@ void main() {
   };
 
   const GPUFeatureName = {
+  	CoreFeaturesAndLimits: 'core-features-and-limits',
   	DepthClipControl: 'depth-clip-control',
   	Depth32FloatStencil8: 'depth32float-stencil8',
   	TextureCompressionBC: 'texture-compression-bc',
+  	TextureCompressionBCSliced3D: 'texture-compression-bc-sliced-3d',
   	TextureCompressionETC2: 'texture-compression-etc2',
   	TextureCompressionASTC: 'texture-compression-astc',
+  	TextureCompressionASTCSliced3D: 'texture-compression-astc-sliced-3d',
   	TimestampQuery: 'timestamp-query',
   	IndirectFirstInstance: 'indirect-first-instance',
   	ShaderF16: 'shader-f16',
   	RG11B10UFloat: 'rg11b10ufloat-renderable',
   	BGRA8UNormStorage: 'bgra8unorm-storage',
   	Float32Filterable: 'float32-filterable',
+  	Float32Blendable: 'float32-blendable',
   	ClipDistances: 'clip-distances',
   	DualSourceBlending: 'dual-source-blending',
-  	Subgroups: 'subgroups'
+  	Subgroups: 'subgroups',
+  	TextureFormatsTier1: 'texture-formats-tier1',
+  	TextureFormatsTier2: 'texture-formats-tier2'
   };
 
   /**
@@ -117143,7 +117648,7 @@ fn main( @location( 0 ) vTex : vec2<f32> ) -> @location( 0 ) vec4<f32> {
 
   		let dimension;
 
-  		if ( texture.isData3DTexture ) {
+  		if ( texture.is3DTexture || texture.isData3DTexture ) {
 
   			dimension = GPUTextureDimension.ThreeD;
 
@@ -119417,24 +119922,29 @@ ${ flowData.code }
 
   					}
 
-  				} else if ( texture.isArrayTexture === true || texture.isDataArrayTexture === true || texture.isCompressedArrayTexture === true ) {
+  				} else if ( uniform.node.isStorageTextureNode === true ) {
 
-  					textureType = 'texture_2d_array<f32>';
+  					const format = getFormat( texture );
+  					const access = this.getStorageAccess( uniform.node, shaderStage );
 
-  				} else if ( texture.isVideoTexture === true ) {
+  					const is3D = uniform.node.value.is3DTexture;
+  					const isArrayTexture = uniform.node.value.isArrayTexture;
 
-  					textureType = 'texture_external';
+  					const dimension = is3D ? '3d' : `2d${ isArrayTexture ? '_array' : '' }`;
 
-  				} else if ( texture.isData3DTexture === true ) {
+  					textureType = `texture_storage_${ dimension }<${ format }, ${ access }>`;
 
-  					textureType = 'texture_3d<f32>';
+  				} else if ( texture.isArrayTexture === true || texture.isDataArrayTexture === true || texture.isCompressedArrayTexture === true ) {
 
-  				} else if ( uniform.node.isStorageTextureNode === true ) {
+  					textureType = 'texture_2d_array<f32>';
 
-  					const format = getFormat( texture );
-  					const access = this.getStorageAccess( uniform.node, shaderStage );
+  				} else if ( texture.is3DTexture === true || texture.isData3DTexture === true ) {
+
+  					textureType = 'texture_3d<f32>';
 
-  					textureType = `texture_storage_2d<${ format }, ${ access }>`;
+  				} else if ( texture.isVideoTexture === true ) {
+
+  					textureType = 'texture_external';
 
   				} else {
 
@@ -120131,6 +120641,12 @@ var<${access}> ${ name } : ${ structName };`;
   	[ Float32Array, [ 'float32', ]],
   ] );
 
+  if ( typeof Float16Array !== 'undefined' ) {
+
+  	typedArraysToVertexFormatPrefix.set( Float16Array, [ 'float16' ] );
+
+  }
+
   const typedAttributeToVertexFormatPrefix = new Map( [
   	[ Float16BufferAttribute, [ 'float16', ]],
   ] );
@@ -120690,6 +121206,16 @@ var<${access}> ${ name } : ${ structName };`;
 
   				}
 
+  				if ( binding.texture.isArrayTexture ) {
+
+  					storageTexture.viewDimension = GPUTextureViewDimension.TwoDArray;
+
+  				} else if ( binding.texture.is3DTexture ) {
+
+  					storageTexture.viewDimension = GPUTextureViewDimension.ThreeD;
+
+  				}
+
   				bindingGPU.storageTexture = storageTexture;
 
   			} else if ( binding.isSampledTexture ) {
@@ -121392,7 +121918,7 @@ var<${access}> ${ name } : ${ structName };`;
   						break;
 
   					case MultiplyBlending:
-  						setBlend( GPUBlendFactor.Zero, GPUBlendFactor.Src, GPUBlendFactor.Zero, GPUBlendFactor.SrcAlpha );
+  						setBlend( GPUBlendFactor.Dst, GPUBlendFactor.OneMinusSrcAlpha, GPUBlendFactor.Zero, GPUBlendFactor.One );
   						break;
 
   				}
@@ -121406,15 +121932,15 @@ var<${access}> ${ name } : ${ structName };`;
   						break;
 
   					case AdditiveBlending:
-  						setBlend( GPUBlendFactor.SrcAlpha, GPUBlendFactor.One, GPUBlendFactor.SrcAlpha, GPUBlendFactor.One );
+  						setBlend( GPUBlendFactor.SrcAlpha, GPUBlendFactor.One, GPUBlendFactor.One, GPUBlendFactor.One );
   						break;
 
   					case SubtractiveBlending:
-  						setBlend( GPUBlendFactor.Zero, GPUBlendFactor.OneMinusSrc, GPUBlendFactor.Zero, GPUBlendFactor.One );
+  						console.error( 'THREE.WebGPURenderer: SubtractiveBlending requires material.premultipliedAlpha = true' );
   						break;
 
   					case MultiplyBlending:
-  						setBlend( GPUBlendFactor.Zero, GPUBlendFactor.Src, GPUBlendFactor.Zero, GPUBlendFactor.Src );
+  						console.error( 'THREE.WebGPURenderer: MultiplyBlending requires material.premultipliedAlpha = true' );
   						break;
 
   				}
@@ -124152,7 +124678,15 @@ var<${access}> ${ name } : ${ structName };`;
   	 */
   	createIndexAttribute( attribute ) {
 
-  		this.attributeUtils.createAttribute( attribute, GPUBufferUsage.INDEX | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST );
+  		let usage = GPUBufferUsage.INDEX | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST;
+
+  		if ( attribute.isStorageBufferAttribute || attribute.isStorageInstancedBufferAttribute ) {
+
+  			usage |= GPUBufferUsage.STORAGE;
+
+  		}
+
+  		this.attributeUtils.createAttribute( attribute, usage );
 
   	}
 
@@ -133257,7 +133791,7 @@ var<${access}> ${ name } : ${ structName };`;
 
   // Expose config from forceGraph
   var bindFG = linkKapsule('forceGraph', threeForcegraph);
-  var linkedFGProps = Object.assign.apply(Object, _toConsumableArray$3(['jsonUrl', 'graphData', 'numDimensions', 'dagMode', 'dagLevelDistance', 'dagNodeFilter', 'onDagError', 'nodeRelSize', 'nodeId', 'nodeVal', 'nodeResolution', 'nodeColor', 'nodeAutoColorBy', 'nodeOpacity', 'nodeVisibility', 'nodeThreeObject', 'nodeThreeObjectExtend', 'nodePositionUpdate', 'linkSource', 'linkTarget', 'linkVisibility', 'linkColor', 'linkAutoColorBy', 'linkOpacity', 'linkWidth', 'linkResolution', 'linkCurvature', 'linkCurveRotation', 'linkMaterial', 'linkThreeObject', 'linkThreeObjectExtend', 'linkPositionUpdate', 'linkDirectionalArrowLength', 'linkDirectionalArrowColor', 'linkDirectionalArrowRelPos', 'linkDirectionalArrowResolution', 'linkDirectionalParticles', 'linkDirectionalParticleSpeed', 'linkDirectionalParticleWidth', 'linkDirectionalParticleColor', 'linkDirectionalParticleResolution', 'forceEngine', 'd3AlphaDecay', 'd3VelocityDecay', 'd3AlphaMin', 'ngraphPhysics', 'warmupTicks', 'cooldownTicks', 'cooldownTime', 'onEngineTick', 'onEngineStop'].map(function (p) {
+  var linkedFGProps = Object.assign.apply(Object, _toConsumableArray$3(['jsonUrl', 'graphData', 'numDimensions', 'dagMode', 'dagLevelDistance', 'dagNodeFilter', 'onDagError', 'nodeRelSize', 'nodeId', 'nodeVal', 'nodeResolution', 'nodeColor', 'nodeAutoColorBy', 'nodeOpacity', 'nodeVisibility', 'nodeThreeObject', 'nodeThreeObjectExtend', 'nodePositionUpdate', 'linkSource', 'linkTarget', 'linkVisibility', 'linkColor', 'linkAutoColorBy', 'linkOpacity', 'linkWidth', 'linkResolution', 'linkCurvature', 'linkCurveRotation', 'linkMaterial', 'linkThreeObject', 'linkThreeObjectExtend', 'linkPositionUpdate', 'linkDirectionalArrowLength', 'linkDirectionalArrowColor', 'linkDirectionalArrowRelPos', 'linkDirectionalArrowResolution', 'linkDirectionalParticles', 'linkDirectionalParticleSpeed', 'linkDirectionalParticleOffset', 'linkDirectionalParticleWidth', 'linkDirectionalParticleColor', 'linkDirectionalParticleResolution', 'linkDirectionalParticleThreeObject', 'forceEngine', 'd3AlphaDecay', 'd3VelocityDecay', 'd3AlphaMin', 'ngraphPhysics', 'warmupTicks', 'cooldownTicks', 'cooldownTime', 'onEngineTick', 'onEngineStop'].map(function (p) {
     return _defineProperty$3({}, p, bindFG.linkProp(p));
   })));
   var linkedFGMethods = Object.assign.apply(Object, _toConsumableArray$3(['refresh', 'getGraphBbox', 'd3Force', 'd3ReheatSimulation', 'emitParticle'].map(function (p) {