tsl-textures 2.1.2 → 2.2.0

package/dist/cjs/tsl-textures.js

@@ -1,4 +1,4 @@
-// TSL Textures v2.1.1
+// TSL Textures v2.1.2
 
 'use strict';
 
@@ -538,9 +538,30 @@ function hideFallbackWarning( ) {
 
 
 // converts all numeric, color and vector properties to nodes
-function prepare( params ) {
+function prepare( userParams, defaults ) {
 
-	for ( var name of Object.keys( params ) ) {
+	var propertyNames = [];
+	for ( var item of userParams ) {
+
+	  if ( item && typeof item === 'object' ) {
+
+			propertyNames = Object.keys( item );
+			break;
+
+		}
+
+	}
+
+	var params = { ...defaults };
+
+	for ( var key of propertyNames ) {
+
+		if ( typeof userParams[ key ] !== 'undefined' )
+			params[ key ] = userParams[ key ];
+
+	}
+
+	for ( var name of Object.keys( params ) ) {
 
 		if ( typeof params[ name ] === 'number' )
 			params[ name ] = tsl.float( params[ name ]);
@@ -564,11 +585,196 @@ function noised( pos, scale=1, octave=1, seed=0 ) {
 
 	return tsl.mx_noise_float( pos.mul( scale, octave ).add( seed ) );
 
-}
+}
+
+
+
+// a shim (proposed by Grok) to recover from a change of how Fn
+// is proxied since Three.js v0.180.0
+
+// explanation from Grok:
+/*
+In 0.179.0, TSL.Fn likely returned a plain function, allowing a.defaults
+to work without Proxy interference. In 0.180.0, the Proxy wrapping an FnNode
+instance blocks defaults access (returns undefined) and requires specific FnNode
+behavior, making the wrapper incompatible.
+
+Solutions to Fix the Error and Access a.defaultsWe need a solution that:
+
+* Makes a.defaults directly accessible.
+* Preserves TSL compatibility by ensuring the object passed to TSL behaves
+like a TSL.Fn Proxy.
+* Avoids separate defaults variables.
+* Mimics the 0.179.0 API where a.defaults worked.
+
+Given the error, direct property access on the TSL.Fn Proxy (e.g., Object.defineProperty(a, 'defaults', {...})) fails because the get trap
+returns undefined for unknown properties on FnNode. The non-Proxy wrapper
+breaks TSL, so let’s try a refined approach that balances compatibility and
+accessibility.1. Proxy Wrapper with FnNode PrototypeInstead of a non-Proxy
+wrapper, create a Proxy that mimics TSL.Fn but stores defaults separately to
+bypass FnNode’s get behavior. To avoid breaking TSL, ensure the Proxy’s target
+has the FnNode prototype.
+
+Why This Might Work:
+
+* The Proxy’s target inherits the FnNode prototype (via fn.call), making it
+appear more like the original TSL.Fn Proxy to TSL’s checks.
+* defaults is stored in a Map, bypassing FnNode’s get trap that returns
+undefined.
+* a.fn exposes the original TSL.Fn Proxy for TSL operations.
+* Function calls (a(...)) are forwarded to the original Proxy.
+* Matches Object.getOwnPropertyDescriptor behavior.
+
+*/
+
+function TSLFn( jsFunc, defaults, layout = null ) {
+
+	var opacity = null;
+	var roughness = null;
+	var normal = null;
+
+	const fn = tsl.Fn( jsFunc, layout );
+	const customProps = new Map();
+	customProps.set( 'defaults', defaults );
+	customProps.set( 'opacity', opacity );
+	customProps.set( 'roughness', roughness );
+	customProps.set( 'normal', normal );
+
+	// Create a target with FnNode prototype to mimic TSL.Fn
+	const target = function () {};
+
+	Object.setPrototypeOf( target, Object.getPrototypeOf( fn.call ) ); // Inherit FnNode prototype
+
+	return new Proxy( target, {
+		get( target, prop, receiver ) {
+
+			if ( prop === 'defaults' ) {
+
+				return customProps.get( 'defaults' );
+
+			}
+
+			if ( prop === 'opacity' ) {
+
+				return customProps.get( 'opacity' );
+
+			}
+
+			if ( prop === 'roughness' ) {
+
+				return customProps.get( 'roughness' );
+
+			}
+
+			if ( prop === 'normal' ) {
+
+				return customProps.get( 'normal' );
+
+			}
+
+			if ( prop === 'fn' ) {
+
+				return fn; // Expose original TSL.Fn Proxy
+
+			}
+
+			return Reflect.get( fn, prop, receiver ); // Forward to original Proxy
 
-var camouflage = tsl.Fn( ( params )=>{
+		},
+		set( target, prop, value, receiver ) {
+
+			if ( prop === 'defaults' ) {
+
+				customProps.set( 'defaults', value );
+				return true;
+
+			}
+
+			if ( prop === 'opacity' ) {
+
+				customProps.set( 'opacity', value );
+				return true;
+
+			}
+
+			if ( prop === 'roughness' ) {
+
+				customProps.set( 'roughness', value );
+				return true;
+
+			}
+
+			if ( prop === 'normal' ) {
+
+				customProps.set( 'normal', value );
+				return true;
+
+			}
+
+			return Reflect.set( fn, prop, value, receiver );
+
+		},
+		apply( target, thisArg, args ) {
+
+			return Reflect.apply( fn, thisArg, args ); // Delegate calls to original Proxy
+
+		},
+		getOwnPropertyDescriptor( target, prop ) {
+
+			if ( prop === 'defaults' ) {
+
+				return {
+					value: customProps.get( 'defaults' ),
+					writable: true,
+					enumerable: true,
+					configurable: true,
+				};
+
+			}
+
+			if ( prop === 'opacity' ) {
+
+				Reflect.getOwnPropertyDescriptor( opacity, prop );
+
+			}
+
+			if ( prop === 'roughness' ) {
+
+				Reflect.getOwnPropertyDescriptor( roughness, prop );
+
+			}
+
+			if ( prop === 'normal' ) {
+
+				Reflect.getOwnPropertyDescriptor( normal, prop );
+
+			}
+
+			return Reflect.getOwnPropertyDescriptor( fn, prop );
+
+		}
+	} );
+
+} // TSLFn
+
+var defaults$C = {
+	$name: 'Camouflage',
+
+	scale: 2,
+
+	colorA: new three.Color( 0xc2bea8 ),
+	colorB: new three.Color( 0x9c895e ),
+	colorC: new three.Color( 0x92a375 ),
+	colorD: new three.Color( 0x717561 ),
+
+	seed: 0,
+};
+
 
-	params = prepare( { ...camouflage.defaults, ...params } );
+
+var camouflage = TSLFn( ( params )=>{
+
+	params = prepare( params, defaults$C );
 
 	var pos = tsl.positionGeometry.mul( tsl.exp( params.scale ) ).add( params.seed ).toVar( );
 
@@ -601,26 +807,26 @@ var camouflage = tsl.Fn( ( params )=>{
 
 	return color;
 
-} );
+}, defaults$C );
+
+var defaults$B = {
+	$name: 'Cave art',
 
+	scale: 2,
+	thinness: 2,
+	noise: 0.3,
 
+	color: new three.Color( 0xD34545 ),
+	background: new three.Color( 0xFFF8F0 ),
 
-camouflage.defaults = {
-	$name: 'Camouflage',
+	seed: 0,
+};
 
-	scale: 2,
 
-	colorA: new three.Color( 0xc2bea8 ),
-	colorB: new three.Color( 0x9c895e ),
-	colorC: new three.Color( 0x92a375 ),
-	colorD: new three.Color( 0x717561 ),
 
-	seed: 0,
-};
-
-var caveArt = tsl.Fn( ( params ) => {
+var caveArt = TSLFn( ( params ) => {
 
-	params = prepare( { ...caveArt.defaults, ...params } );
+	params = prepare( params, defaults$B );
 
 	var pos = tsl.positionGeometry.mul( tsl.exp( params.scale ) ).add( params.seed ).toVar( );
 
@@ -644,26 +850,26 @@ var caveArt = tsl.Fn( ( params ) => {
 
 	return tsl.mix( params.background, params.color, k );
 
-} );
+}, defaults$B );
+
+var defaults$A = {
+	$name: 'Circles',
 
+	scale: 2,
+	variety: 1,
 
+	color: new three.Color( 0xF0E0D0 ),
 
-caveArt.defaults = {
-	$name: 'Cave art',
+	flat: 0,
 
-	scale: 2,
-	thinness: 2,
-	noise: 0.3,
+	seed: 0,
+};
 
-	color: new three.Color( 0xD34545 ),
-	background: new three.Color( 0xFFF8F0 ),
 
-	seed: 0,
-};
-
-var circles = tsl.Fn( ( params ) => {
 
-	params = prepare( { ...circles.defaults, ...params } );
+var circles = TSLFn( ( params ) => {
+
+	params = prepare( params, defaults$A );
 
 	var pos = tsl.select( params.flat, tsl.positionGeometry, tsl.positionGeometry.normalize() );
 
@@ -693,28 +899,25 @@ var circles = tsl.Fn( ( params ) => {
 
 	return hsl( huei.add( huef ).div( 10 ), HSL.y, HSL.z );
 
-} );
-
+}, defaults$A );
+
+var defaults$z = {
+	$name: 'Clouds',
 
+	scale: 2,
+	density: 0.5,
+	opacity: 1,
 
-circles.defaults = {
-	$name: 'Circles',
+	color: new three.Color( 0xFFFFFF ),
+	subcolor: new three.Color( 0xA0A0B0 ),
 
-	scale: 2,
-	variety: 1,
+	seed: 0,
+};
 
-	color: new three.Color( 0xF0E0D0 ),
 
-	flat: 0,
 
-	seed: 0,
-};
-
 var _clouds = tsl.Fn( ( params ) => {
 
-	// prepare parameters
-	params = prepare( { ...clouds.defaults, ...params } );
-
 	const pos = tsl.positionGeometry;
 	const scale = tsl.exp( params.scale.div( 1.5 ).sub( 0.5 ) );
 
@@ -737,35 +940,39 @@ var _clouds = tsl.Fn( ( params ) => {
 
 
 
-var clouds = tsl.Fn( ( params ) => {
-
-	return _clouds( params ).rgb;
+var clouds = TSLFn( ( params ) => {
 
-} );
+	// prepare parameters
+	params = prepare( params, defaults$z );
 
+	return _clouds( params ).rgb;
 
+}, defaults$z );
 
-clouds.opacity = tsl.Fn( ( params ) => {
 
-	return _clouds( params ).a;
 
-} );
+clouds.opacity = TSLFn( ( params ) => {
 
+	// prepare parameters
+	params = prepare( params, defaults$z );
 
+	return _clouds( params ).a;
 
-clouds.defaults = {
-	$name: 'Clouds',
+}, defaults$z );
+
+var defaults$y = {
+	$name: 'Concrete',
+	$normalNode: true,
 
 	scale: 2,
 	density: 0.5,
-	opacity: 1,
-
-	color: new three.Color( 0xFFFFFF ),
-	subcolor: new three.Color( 0xA0A0B0 ),
+	bump: 0.5,
 
 	seed: 0,
-};
-
+};
+
+
+
 var surfacePos$7 = tsl.Fn( ([ pos, normal, bump, density, seed ]) => {
 
 	var k = tsl.mx_noise_float( pos.add( seed ) ).mul( 0.5 ).add( 0.5 );
@@ -776,9 +983,9 @@ var surfacePos$7 = tsl.Fn( ([ pos, normal, bump, density, seed ]) => {
 } );
 
 
-var concrete = tsl.Fn( ( params ) => {
+var concrete = TSLFn( ( params ) => {
 
-	params = prepare( { ...concrete.defaults, ...params } );
+	params = prepare( params, defaults$y );
 
 	var eps = 0.001;
 
@@ -799,21 +1006,23 @@ var concrete = tsl.Fn( ( params ) => {
 
 	return tsl.transformNormalToView( tsl.cross( dU, dV ).normalize() );
 
-} );
+}, defaults$y );
+
+var defaults$x = {
+	$name: 'Cork',
 
+	scale: 1,
+	straight: 1,
+	noise: 0.3,
+
+	color: new three.Color( 0xfff0c0 ),
+	background: new three.Color( 0xd08060 ),
 
+	seed: 0,
+};
 
-concrete.defaults = {
-	$name: 'Concrete',
-	$normalNode: true,
 
-	scale: 2,
-	density: 0.5,
-	bump: 0.5,
 
-	seed: 0,
-};
-
 var cellCenter$1 = tsl.Fn( ([ cell ])=>{
 
 	return cell.add( vnoise( cell ) );
@@ -821,9 +1030,9 @@ var cellCenter$1 = tsl.Fn( ([ cell ])=>{
 } );
 
 
-var cork = tsl.Fn( ( params )=>{
+var cork = TSLFn( ( params )=>{
 
-	params = prepare( { ...cork.defaults, ...params } );
+	params = prepare( params, defaults$x );
 
 	var pos = tsl.positionGeometry.mul( tsl.exp( params.scale.div( 1.5 ).add( 1 ) ) ).add( params.seed ).toVar( );
 
@@ -868,26 +1077,26 @@ var cork = tsl.Fn( ( params )=>{
 
 	return color;
 
-} );
+}, defaults$x );
+
+var defaults$w = {
+	$name: 'Dalmatian spots',
+	$width: 260,
 
+	scale: 2,
+	density: 0.6,
 
+	color: new three.Color( 0xFFFFFF ),
+	background: new three.Color( 0x000000 ),
 
-cork.defaults = {
-	$name: 'Cork',
+	seed: 0,
+};
 
-	scale: 1,
-	straight: 1,
-	noise: 0.3,
 
-	color: new three.Color( 0xfff0c0 ),
-	background: new three.Color( 0xd08060 ),
 
-	seed: 0,
-};
-
-var dalmatianSpots = tsl.Fn( ( params )=>{
+var dalmatianSpots = TSLFn( ( params )=>{
 
-	params = prepare( { ...dalmatianSpots.defaults, ...params } );
+	params = prepare( params, defaults$w );
 
 	var pos = tsl.positionGeometry.mul( tsl.exp( params.scale ) ).add( params.seed ).sub( 1000 ).toVar( );
 
@@ -909,22 +1118,24 @@ var dalmatianSpots = tsl.Fn( ( params )=>{
 
 	return tsl.mix( params.background, params.color, k.clamp( 0, 1 ) );
 
-} );
-
-
-dalmatianSpots.defaults = {
-	$name: 'Dalmatian spots',
-	$width: 260,
+}, defaults$w );
+
+var defaults$v = {
+	$name: 'Dyson sphere',
 
 	scale: 2,
-	density: 0.6,
+	complexity: 2,
 
-	color: new three.Color( 0xFFFFFF ),
-	background: new three.Color( 0x000000 ),
+	variation: 0,
+
+	color: new three.Color( 0xc0d0ff ),
+	background: new three.Color( 0 ),
 
 	seed: 0,
-};
-
+};
+
+
+
 var noisea = tsl.Fn( ([ pos ])=>{
 
 	var p = pos.mul( 5**0.5 ).fract().toVar();
@@ -976,9 +1187,9 @@ var noiseg = tsl.Fn( ([ pos ])=>{
 
 
 
-var dysonSphere = tsl.Fn( ( params )=>{
+var dysonSphere = TSLFn( ( params )=>{
 
-	params = prepare( { ...dysonSphere.defaults, ...params } );
+	params = prepare( params, defaults$v );
 
 	var pos = tsl.positionGeometry.mul( tsl.exp( params.scale.div( 2 ).add( 0.5 ) ) ).add( params.seed ).toVar( );
 
@@ -994,27 +1205,25 @@ var dysonSphere = tsl.Fn( ( params )=>{
 
 	return tsl.mix( params.background, params.color, res.x.add( 1 ).div( 5 ) );
 
-} );
-
+}, defaults$v );
+
+var defaults$u = {
+	$name: 'Entangled',
 
+	scale: 2,
+	density: 10,
 
-dysonSphere.defaults = {
-	$name: 'Dyson sphere',
+	color: new three.Color( 0x002040 ),
+	background: new three.Color( 0xFFFFFF ),
 
-	scale: 2,
-	complexity: 2,
+	seed: 0,
+};
 
-	variation: 0,
 
-	color: new three.Color( 0xc0d0ff ),
-	background: new three.Color( 0 ),
 
-	seed: 0,
-};
-
-var entangled = tsl.Fn( ( params ) => {
+var entangled = TSLFn( ( params ) => {
 
-	params = prepare( { ...entangled.defaults, ...params } );
+	params = prepare( params, defaults$u );
 
 	var scale = tsl.exp( params.scale.div( 2 ) ).toVar( );
 	var pos = tsl.positionGeometry.add( params.seed ).toVar( );
@@ -1033,25 +1242,20 @@ var entangled = tsl.Fn( ( params ) => {
 
 	return tsl.mix( params.color, params.background, k );
 
-} );
-
-
-
-entangled.defaults = {
-	$name: 'Entangled',
-
+}, defaults$u );
+
+var defaults$t = {
+	$name: 'Fordite',
 	scale: 2,
-	density: 10,
+	color: new three.Color( 0, 0, 0 ),
+	seed: 0,
+};
 
-	color: new three.Color( 0x002040 ),
-	background: new three.Color( 0xFFFFFF ),
 
-	seed: 0,
-};
-
-var fordite = tsl.Fn( ( params ) => {
 
-	params = prepare( { ...fordite.defaults, ...params } );
+var fordite = TSLFn( ( params ) => {
+
+	params = prepare( params, defaults$t );
 
 	var pos = tsl.positionGeometry.mul( tsl.exp( params.scale ) ).add( params.seed ).toVar( );
 
@@ -1069,20 +1273,27 @@ var fordite = tsl.Fn( ( params ) => {
 		tsl.sin( tsl.mul( k, Math.PI, 4 ) ).mul( 0.5 ).add( 0.5 )
 	).add( params.color );
 
-} );
+}, defaults$t );
+
+var defaults$s = {
+	$name: 'Gas giant',
 
+	scale: 2,
+	turbulence: 0.3,
+	blur: 0.6,
 
+	colorA: new three.Color( 0xFFF8F0 ),
+	colorB: new three.Color( 0xF0E8B0 ),
+	colorC: new three.Color( 0xAFA0D0 ),
 
-fordite.defaults = {
-	$name: 'Fordite',
-	scale: 2,
-	color: new three.Color( 0, 0, 0 ),
 	seed: 0,
-};
-
-var gasGiant = tsl.Fn( ( params )=>{
+};
+
+
 
-	params = prepare( { ...gasGiant.defaults, ...params } );
+var gasGiant = TSLFn( ( params )=>{
+
+	params = prepare( params, defaults$s );
 
 	var scale = params.scale.div( 2 ).add( 1 ).toVar();
 	var pos = tsl.positionGeometry.mul( tsl.exp( scale ) ).add( params.seed ).toVar( );
@@ -1116,26 +1327,27 @@ var gasGiant = tsl.Fn( ( params )=>{
 
 	return color.mul( k );
 
-} );
+}, defaults$s );
+
+var defaults$r = {
+	$name: 'Grid',
 
+	countU: 32,
+	countV: 16,
 
-gasGiant.defaults = {
-	$name: 'Gas giant',
+	thinness: 0.8,
 
-	scale: 2,
-	turbulence: 0.3,
-	blur: 0.6,
+	color: new three.Color( 0x000000 ),
+	background: new three.Color( 0xFFFFFF ),
 
-	colorA: new three.Color( 0xFFF8F0 ),
-	colorB: new three.Color( 0xF0E8B0 ),
-	colorC: new three.Color( 0xAFA0D0 ),
+	flat: 0,
+};
 
-	seed: 0,
-};
-
-var grid = tsl.Fn( ( params ) => {
 
-	params = prepare( { ...grid.defaults, ...params } );
+
+var grid = TSLFn( ( params ) => {
+
+	params = prepare( params, defaults$r );
 
 	var aspect = tsl.select( params.flat, tsl.screenSize.x.div( tsl.screenSize.y ), 2 );
 
@@ -1157,27 +1369,27 @@ var grid = tsl.Fn( ( params ) => {
 
 	return tsl.mix( params.background, params.color, k );
 
-} );
+}, defaults$r );
+
+var defaults$q = {
+	$name: 'Isolines',
 
+	scale: 2,
+	density: 40,
+	blur: 0.3,
+	thinness: 0.6,
 
+	color: new three.Color( 0xFFFFFF ),
+	background: new three.Color( 0x000000 ),
 
-grid.defaults = {
-	$name: 'Grid',
+	seed: 0,
+};
 
-	countU: 32,
-	countV: 16,
 
-	thinness: 0.8,
 
-	color: new three.Color( 0x000000 ),
-	background: new three.Color( 0xFFFFFF ),
-
-	flat: 0,
-};
-
-var isolines = tsl.Fn( ( params )=>{
+var isolines = TSLFn( ( params )=>{
 
-	params = prepare( { ...isolines.defaults, ...params } );
+	params = prepare( params, defaults$q );
 
 	var pos = tsl.positionGeometry.mul( tsl.exp( params.scale ) ).add( params.seed ).toVar( );
 
@@ -1189,26 +1401,24 @@ var isolines = tsl.Fn( ( params )=>{
 
 	return tsl.mix( params.color, params.background, k );
 
-} );
-
-
-isolines.defaults = {
-	$name: 'Isolines',
+}, defaults$q );
+
+var defaults$p = {
+	$name: 'Karst rock',
 
 	scale: 2,
-	density: 40,
-	blur: 0.3,
-	thinness: 0.6,
 
-	color: new three.Color( 0xFFFFFF ),
-	background: new three.Color( 0x000000 ),
+	color: new three.Color( 0xFFF4F0 ),
+	background: new three.Color( 0xD0D0D0 ),
 
 	seed: 0,
-};
-
-var karstRock = tsl.Fn( ( params )=>{
+};
+
 
-	params = prepare( { ...karstRock.defaults, ...params } );
+
+var karstRock = TSLFn( ( params )=>{
+
+	params = prepare( params, defaults$p );
 
 	var pos = tsl.positionGeometry.mul( tsl.exp( params.scale ) ).add( params.seed.sin().mul( 5 ) ).toVar( );
 
@@ -1221,24 +1431,26 @@ var karstRock = tsl.Fn( ( params )=>{
 
 	return tsl.mix( params.background, params.color, k ).mul( k.pow( 0.1 ) );
 
-} );
+}, defaults$p );
+
+var defaults$o = {
+	$name: 'Marble',
 
+	scale: 1.2,
+	thinness: 5,
+	noise: 0.3,
 
+	color: new three.Color( 0x4545D3 ),
+	background: new three.Color( 0xF0F8FF ),
 
-karstRock.defaults = {
-	$name: 'Karst rock',
+	seed: 0,
+};
 
-	scale: 2,
 
-	color: new three.Color( 0xFFF4F0 ),
-	background: new three.Color( 0xD0D0D0 ),
 
-	seed: 0,
-};
-
-var marble = tsl.Fn( ( params ) => {
+var marble = TSLFn( ( params ) => {
 
-	params = prepare( { ...marble.defaults, ...params } );
+	params = prepare( params, defaults$o );
 
 	var pos = tsl.positionGeometry.mul( tsl.exp( params.scale ) ).add( params.seed ).toVar( );
 
@@ -1276,26 +1488,28 @@ var marble = tsl.Fn( ( params ) => {
 
 	return tsl.mix( params.background, params.color, k );
 
-} );
+}, defaults$o );
+
+var defaults$n = {
+	$name: 'Neon Lights',
 
+	scale: 1.5,
+	thinness: 0.8,
+	mode: 0, // 0=additive, 1=subtractive
 
+	colorA: new three.Color( 0xFF0000 ),
+	colorB: new three.Color( 0x00FF00 ),
+	colorC: new three.Color( 0x0000FF ),
+	background: new three.Color( 0x000000 ),
 
-marble.defaults = {
-	$name: 'Marble',
+	seed: 0,
+};
 
-	scale: 1.2,
-	thinness: 5,
-	noise: 0.3,
 
-	color: new three.Color( 0x4545D3 ),
-	background: new three.Color( 0xF0F8FF ),
 
-	seed: 0,
-};
-
-var neonLights = tsl.Fn( ( params ) => {
+var neonLights = TSLFn( ( params ) => {
 
-	params = prepare( { ...neonLights.defaults, ...params } );
+	params = prepare( params, defaults$n );
 
 	var pos = tsl.positionGeometry;//.mul( exp( params.scale ) ).add( params.seed ).toVar( );
 
@@ -1339,28 +1553,24 @@ var neonLights = tsl.Fn( ( params ) => {
 
 	return color;
 
-} );
+}, defaults$n );
+
+var defaults$m = {
+	$name: 'Photosphere',
 
+	scale: 2,
 
+	color: new three.Color( 0xFFFF00 ),
+	background: new three.Color( 0xFF0000 ),
 
-neonLights.defaults = {
-	$name: 'Neon Lights',
+	seed: 0,
+};
 
-	scale: 1.5,
-	thinness: 0.8,
-	mode: 0, // 0=additive, 1=subtractive
 
-	colorA: new three.Color( 0xFF0000 ),
-	colorB: new three.Color( 0x00FF00 ),
-	colorC: new three.Color( 0x0000FF ),
-	background: new three.Color( 0x000000 ),
 
-	seed: 0,
-};
-
-var photosphere = tsl.Fn( ( params ) => {
+var photosphere = TSLFn( ( params ) => {
 
-	params = prepare( { ...photosphere.defaults, ...params } );
+	params = prepare( params, defaults$m );
 
 	var scale = tsl.exp( params.scale.add( 1 ) ).toVar( );
 	var pos = tsl.positionGeometry.toVar( );
@@ -1379,24 +1589,37 @@ var photosphere = tsl.Fn( ( params ) => {
 
 	return tsl.mix( params.background, params.color, k );
 
-} );
+}, defaults$m );
+
+var defaults$l = {
+	$name: 'Planet',
 
+	scale: 2,
 
+	iterations: 5,
 
-photosphere.defaults = {
-	$name: 'Photosphere',
+	levelSea: 0.3,
+	levelMountain: 0.7,
 
-	scale: 2,
+	balanceWater: 0.3,
+	balanceSand: 0.2,
+	balanceSnow: 0.8,
 
-	color: new three.Color( 0xFFFF00 ),
-	background: new three.Color( 0xFF0000 ),
+	colorDeep: new three.Color( 0x123a59 ).convertLinearToSRGB(), // SteelBlue
+	colorShallow: new three.Color( 0x87CEEB ).convertLinearToSRGB(), // SkyBlue
+	colorBeach: new three.Color( 0xFFFACD ).convertLinearToSRGB(), // LemonChiffon
+	colorGrass: new three.Color( 0x3CB371 ).convertLinearToSRGB(), // MediumSeaGreen
+	colorForest: new three.Color( 0x003000 ).convertLinearToSRGB(), // Dark green
+	colorSnow: new three.Color( 0xF0FFFF ).convertLinearToSRGB(), // Azure
 
 	seed: 0,
-};
-
-var planet = tsl.Fn( ( params )=>{
+};
 
-	params = prepare( { ...planet.defaults, ...params } );
+
+
+var planet = TSLFn( ( params )=>{
+
+	params = prepare( params, defaults$l );
 
 	var k = tsl.float( 0 ).toVar(),
 		sum = tsl.float( 0 ).toVar(),
@@ -1483,41 +1706,30 @@ var planet = tsl.Fn( ( params )=>{
 
 	return color;
 
-} );
-
-
-
-planet.defaults = {
-	$name: 'Planet',
+}, defaults$l );
+
+var defaults$k = {
+	$name: 'Polka dots',
 
-	scale: 2,
+	count: 2,
+	size: 0.5,
+	blur: 0.25,
 
-	iterations: 5,
+	color: new three.Color( 0x000000 ),
+	background: new three.Color( 0xFFFFFF ),
 
-	levelSea: 0.3,
-	levelMountain: 0.7,
+	flat: 0,
+};
 
-	balanceWater: 0.3,
-	balanceSand: 0.2,
-	balanceSnow: 0.8,
 
-	colorDeep: new three.Color( 0x123a59 ).convertLinearToSRGB(), // SteelBlue
-	colorShallow: new three.Color( 0x87CEEB ).convertLinearToSRGB(), // SkyBlue
-	colorBeach: new three.Color( 0xFFFACD ).convertLinearToSRGB(), // LemonChiffon
-	colorGrass: new three.Color( 0x3CB371 ).convertLinearToSRGB(), // MediumSeaGreen
-	colorForest: new three.Color( 0x003000 ).convertLinearToSRGB(), // Dark green
-	colorSnow: new three.Color( 0xF0FFFF ).convertLinearToSRGB(), // Azure
 
-	seed: 0,
-};
-
 var goldenRatio = ( 1+5**0.5 )/2;
 
 
 
-var polkaDots = tsl.Fn( ( params ) => {
+var polkaDots = TSLFn( ( params ) => {
 
-	params = prepare( { ...polkaDots.defaults, ...params } );
+	params = prepare( params, defaults$k );
 
 	var dist = tsl.float( 1 ).toVar();
 
@@ -1561,26 +1773,28 @@ var polkaDots = tsl.Fn( ( params ) => {
 
 	return tsl.mix( params.color, params.background, k );
 
-} );
+}, defaults$k );
+
+var defaults$j = {
+	$name: 'Processed wood',
+	$width: 260,
 
+	scale: 2,
+	length: 4,
+	strength: 0.3,
+	angle: 0,
 
+	color: new three.Color( 0x702020 ),
+	background: new three.Color( 0xF0D0A0 ),
 
-polkaDots.defaults = {
-	$name: 'Polka dots',
+	seed: 0,
+};
 
-	count: 2,
-	size: 0.5,
-	blur: 0.25,
 
-	color: new three.Color( 0x000000 ),
-	background: new three.Color( 0xFFFFFF ),
 
-	flat: 0,
-};
-
-var processedWood = tsl.Fn( ( params )=>{
+var processedWood = TSLFn( ( params )=>{
 
-	params = prepare( { ...processedWood.defaults, ...params } );
+	params = prepare( params, defaults$j );
 
 	var angle = tsl.radians( params.angle ).toVar();
 	var posLocal = tsl.vec3(
@@ -1599,24 +1813,24 @@ var processedWood = tsl.Fn( ( params )=>{
 
 	return tsl.mix( params.color, params.background, k );
 
-} );
+}, defaults$j );
+
+var defaults$i = {
+	$name: 'Protozoa',
 
+	scale: 1.5,
+	fat: 0.7,
+	amount: 0.4,
 
-processedWood.defaults = {
-	$name: 'Processed wood',
-	$width: 260,
+	color: new three.Color( 0xA0A0A0 ),
+	subcolor: new three.Color( 0xE0E8FF ),
+	background: new three.Color( 0xF0F8FF ),
+
+	seed: 0,
+};
 
-	scale: 2,
-	length: 4,
-	strength: 0.3,
-	angle: 0,
 
-	color: new three.Color( 0x702020 ),
-	background: new three.Color( 0xF0D0A0 ),
 
-	seed: 0,
-};
-
 var pnoise = tsl.Fn( ([ pos, fat ])=>{
 
 	return tsl.mx_noise_float( pos ).mul( fat ).clamp( -3.14, 3.14 ).cos().add( 1 ).div( 2 );
@@ -1625,9 +1839,9 @@ var pnoise = tsl.Fn( ([ pos, fat ])=>{
 
 
 
-var protozoa = tsl.Fn( ( params )=>{
+var protozoa = TSLFn( ( params )=>{
 
-	params = prepare( { ...protozoa.defaults, ...params } );
+	params = prepare( params, defaults$i );
 
 	var pos = tsl.positionGeometry.mul( tsl.exp( params.scale.sub( 1 ) ) ).add( params.seed ).toVar( );
 
@@ -1660,23 +1874,24 @@ var protozoa = tsl.Fn( ( params )=>{
 
 	return tsl.mix( params.background, tsl.mix( params.color, params.subcolor, n2.mul( 0.1 ) ), n1 );
 
-} );
+}, defaults$i );
+
+var defaults$h = {
+	$name: 'Rotator',
+	$positionNode: true,
+	$selectorPlanar: true,
 
+	angles: new three.Vector3( 0.4, -0.6, 0 ),
+	center: new three.Vector3( 0, 0, 0 ),
 
-protozoa.defaults = {
-	$name: 'Protozoa',
+	selectorCenter: new three.Vector3( 0, 0, 0 ),
+	selectorAngles: new three.Vector2( 0, 0 ),
+	selectorWidth: 2,
+
+};
 
-	scale: 1.5,
-	fat: 0.7,
-	amount: 0.4,
 
-	color: new three.Color( 0xA0A0A0 ),
-	subcolor: new three.Color( 0xE0E8FF ),
-	background: new three.Color( 0xF0F8FF ),
 
-	seed: 0,
-};
-
 var surfacePos$6 = tsl.Fn( ([ pos, params ])=>{
 
 	var zone = selectPlanar( pos, params.selectorAngles, params.selectorCenter, params.selectorWidth );
@@ -1691,19 +1906,19 @@ var surfacePos$6 = tsl.Fn( ([ pos, params ])=>{
 
 
 
-var rotator = tsl.Fn( ( params )=>{
+var rotator = TSLFn( ( params )=>{
 
-	params = prepare( { ...rotator.defaults, ...params } );
+	params = prepare( params, defaults$h );
 
 	return surfacePos$6( tsl.positionGeometry, params );
 
-} );
+}, defaults$h );
 
 
 
-rotator.normal = tsl.Fn( ( params ) => {
+rotator.normal = TSLFn( ( params ) => {
 
-	params = prepare( { ...rotator.defaults, ...params } );
+	params = prepare( params, defaults$h );
 
 	var eps = 0.01;
 
@@ -1721,24 +1936,21 @@ rotator.normal = tsl.Fn( ( params ) => {
 
 	return tsl.transformNormalToView( tsl.cross( dU, dV ).normalize() );
 
-} );
-
+}, defaults$h );
+
+var defaults$g = {
+	$name: 'Rough clay',
+	$normalNode: true,
 
+	scale: 2,
+	bump: 0.5,
+	curvature: 0.2,
 
-rotator.defaults = {
-	$name: 'Rotator',
-	$positionNode: true,
-	$selectorPlanar: true,
+	seed: 0,
+};
 
-	angles: new three.Vector3( 0.4, -0.6, 0 ),
-	center: new three.Vector3( 0, 0, 0 ),
 
-	selectorCenter: new three.Vector3( 0, 0, 0 ),
-	selectorAngles: new three.Vector2( 0, 0 ),
-	selectorWidth: 2,
 
-};
-
 var surfacePos$5 = tsl.Fn( ([ pos, normal, bump, curvature ]) => {
 
 	var k1 = tsl.mx_worley_noise_float( pos.add( tsl.mx_noise_float( pos ).mul( curvature ) ) ).add( 0.8 ).pow( 5 ).toVar();
@@ -1748,9 +1960,11 @@ var surfacePos$5 = tsl.Fn( ([ pos, normal, bump, curvature ]) => {
 
 } );
 
-var roughClay = tsl.Fn( ( params ) => {
 
-	params = prepare( { ...roughClay.defaults, ...params } );
+
+var roughClay = TSLFn( ( params ) => {
+
+	params = prepare( params, defaults$g );
 
 	var eps = 0.001;
 
@@ -1771,24 +1985,28 @@ var roughClay = tsl.Fn( ( params ) => {
 	return tsl.transformNormalToView( tsl.cross( dU, dV ).normalize() );
 
 
-} );
-
+}, defaults$g );
+
+var defaults$f = {
+	$name: 'Runny eggs',
 
+	scale: 1,
 
-roughClay.defaults = {
-	$name: 'Rough clay',
-	$normalNode: true,
+	sizeYolk: 0.2,
+	sizeWhite: 0.7,
 
-	scale: 2,
-	bump: 0.5,
-	curvature: 0.2,
+	colorYolk: new three.Color( 'orange' ),
+	colorWhite: new three.Color( 'white' ),
+	colorBackground: new three.Color( 'lightgray' ),
 
 	seed: 0,
-};
-
-var runnyEggs = tsl.Fn( ( params ) => {
+};
+
+
 
-	params = prepare( { ...runnyEggs.defaults, ...params } );
+var runnyEggs = TSLFn( ( params ) => {
+
+	params = prepare( params, defaults$f );
 
 	var pos = tsl.positionGeometry.mul( tsl.exp( params.scale.div( 1 ) ) ).add( params.seed.sin().mul( 10 ) ).toVar( );
 
@@ -1801,7 +2019,7 @@ var runnyEggs = tsl.Fn( ( params ) => {
 
 	return tsl.mix( params.colorBackground, tsl.mix( params.colorWhite, params.colorYolk, yolks ), whites );
 
-} );
+}, defaults$f );
 
 
 var surfacePos$4 = tsl.Fn( ([ pos, normal, bump, sizeYolk, sizeWhite ]) => {
@@ -1817,9 +2035,9 @@ var surfacePos$4 = tsl.Fn( ([ pos, normal, bump, sizeYolk, sizeWhite ]) => {
 } );
 
 
-runnyEggs.normal = tsl.Fn( ( params ) => {
+runnyEggs.normal = TSLFn( ( params ) => {
 
-	params = prepare( { ...runnyEggs.defaults, ...params } );
+	params = prepare( params, defaults$f );
 
 	var eps = 0.001;
 	var bump = 0.05;
@@ -1841,12 +2059,12 @@ runnyEggs.normal = tsl.Fn( ( params ) => {
 
 	return tsl.transformNormalToView( tsl.cross( dU, dV ).normalize() );
 
-} );
+}, defaults$f );
 
 
-runnyEggs.roughness = tsl.Fn( ( params ) => {
+runnyEggs.roughness = TSLFn( ( params ) => {
 
-	params = prepare( { ...runnyEggs.defaults, ...params } );
+	params = prepare( params, defaults$f );
 
 	var pos = tsl.positionGeometry.mul( tsl.exp( params.scale.div( 1 ) ) ).add( params.seed.sin().mul( 10 ) ).toVar( );
 
@@ -1857,24 +2075,26 @@ runnyEggs.roughness = tsl.Fn( ( params ) => {
 
 	return yolks;
 
-} );
+}, defaults$f );
+
+var defaults$e = {
+	$name: 'rust',
 
+	scale: 2,
+	iterations: 8,
+	amount: -0.3,
+	opacity: 0.5,
+	noise: 0.5,
+	noiseScale: 0.5,
 
-runnyEggs.defaults = {
-	$name: 'Runny eggs',
+	color: new three.Color( 0xC08000 ),
+	background: new three.Color( 0x000020 ),
 
-	scale: 1,
+	seed: 0,
+};
 
-	sizeYolk: 0.2,
-	sizeWhite: 0.7,
 
-	colorYolk: new three.Color( 'orange' ),
-	colorWhite: new three.Color( 'white' ),
-	colorBackground: new three.Color( 'lightgray' ),
 
-	seed: 0,
-};
-
 var _rust = tsl.Fn( ( params )=>{
 
 	var pos = tsl.positionGeometry.mul( tsl.exp( params.scale.div( 4 ).add( -1 ) ) ).add( params.seed ).toVar( );
@@ -1899,9 +2119,9 @@ var _rust = tsl.Fn( ( params )=>{
 } );
 
 
-var rust = tsl.Fn( ( params )=>{
+var rust = TSLFn( ( params )=>{
 
-	params = prepare( { ...rust.defaults, ...params } );
+	params = prepare( params, defaults$e );
 
 	var k = _rust( params ).mul( 1.25 ).pow( 0.5 );
 
@@ -1911,40 +2131,36 @@ var rust = tsl.Fn( ( params )=>{
 
 	return tsl.mix( params.color, params.background, k );
 
-} );
+}, defaults$e );
 
 
 
-rust.opacity = tsl.Fn( ( params )=>{
+rust.opacity = TSLFn( ( params )=>{
 
-	params = prepare( { ...rust.defaults, ...params } );
+	params = prepare( params, defaults$e );
 
 	var k = _rust( params ).mul( params.opacity.add( 0.2 ) );
 
 	return k.oneMinus();
 
-} );
-
-
-rust.defaults = {
-	$name: 'rust',
+}, defaults$e );
+
+var defaults$d = {
+	$name: 'Satin',
 
 	scale: 2,
-	iterations: 8,
-	amount: -0.3,
-	opacity: 0.5,
-	noise: 0.5,
-	noiseScale: 0.5,
 
-	color: new three.Color( 0xC08000 ),
-	background: new three.Color( 0x000020 ),
+	color: new three.Color( 0x7080FF ),
+	background: new three.Color( 0x000050 ),
 
 	seed: 0,
-};
-
-var satin = tsl.Fn( ( params ) => {
+};
+
 
-	params = prepare( { ...satin.defaults, ...params } );
+
+var satin = TSLFn( ( params ) => {
+
+	params = prepare( params, defaults$d );
 
 	var pos = tsl.positionGeometry.toVar( );
 
@@ -1962,21 +2178,37 @@ var satin = tsl.Fn( ( params ) => {
 
 	return tsl.mix( params.background, params.color, k );
 
-} );
+}, defaults$d );
+
+
+
+satin.defaults = {
+	$name: 'Satin',
+
+	scale: 2,
+
+	color: new three.Color( 0x7080FF ),
+	background: new three.Color( 0x000050 ),
+
+	seed: 0,
+};
+
+var defaults$c = {
+	$name: 'Scaler',
+	$positionNode: true,
+	$selectorPlanar: true,
 
+	scales: new three.Vector3( 0.01, 0.9, 1.7 ),
+	center: new three.Vector3( 0, 0, 0 ),
 
+	selectorCenter: new three.Vector3( 0, 0, 0 ),
+	selectorAngles: new three.Vector2( 0, 0 ),
+	selectorWidth: 2,
 
-satin.defaults = {
-	$name: 'Satin',
+};
 
-	scale: 2,
 
-	color: new three.Color( 0x7080FF ),
-	background: new three.Color( 0x000050 ),
 
-	seed: 0,
-};
-
 var surfacePos$3 = tsl.Fn( ([ pos, params ])=>{
 
 	var zone = selectPlanar( pos, params.selectorAngles, params.selectorCenter, params.selectorWidth );
@@ -1991,19 +2223,19 @@ var surfacePos$3 = tsl.Fn( ([ pos, params ])=>{
 
 
 
-var scaler = tsl.Fn( ( params )=>{
+var scaler = TSLFn( ( params )=>{
 
-	params = prepare( { ...scaler.defaults, ...params } );
+	params = prepare( params, defaults$c );
 
 	return surfacePos$3( tsl.positionGeometry, params );
 
-} );
+}, defaults$c );
 
 
 
-scaler.normal = tsl.Fn( ( params ) => {
+scaler.normal = TSLFn( ( params ) => {
 
-	params = prepare( { ...scaler.defaults, ...params } );
+	params = prepare( params, defaults$c );
 
 	var eps = 0.01;
 
@@ -2021,27 +2253,25 @@ scaler.normal = tsl.Fn( ( params ) => {
 
 	return tsl.transformNormalToView( tsl.cross( dU, dV ).normalize() );
 
-} );
-
+}, defaults$c );
+
+var defaults$b = {
+	$name: 'Scepter head',
 
+	xFactor: 10,
+	yFactor: 22,
+	zFactor: 10,
 
-scaler.defaults = {
-	$name: 'Scaler',
-	$positionNode: true,
-	$selectorPlanar: true,
+	colorRim: new three.Color( 0xFFFFFF ),
+	colorA: new three.Color( 0x70E0FF ),
+	colorB: new three.Color( 0x3000FF ),
+};
 
-	scales: new three.Vector3( 0.01, 0.9, 1.7 ),
-	center: new three.Vector3( 0, 0, 0 ),
 
-	selectorCenter: new three.Vector3( 0, 0, 0 ),
-	selectorAngles: new three.Vector2( 0, 0 ),
-	selectorWidth: 2,
 
-};
-
-var scepterHead = tsl.Fn( ( params ) => {
+var scepterHead = TSLFn( ( params ) => {
 
-	params = prepare( { ...scepterHead.defaults, ...params } );
+	params = prepare( params, defaults$b );
 
 	var pos = tsl.positionGeometry;
 
@@ -2077,25 +2307,25 @@ var scepterHead = tsl.Fn( ( params ) => {
 
 	return tsl.mix( color1, color2, tsl.remapClamp( tsl.max( dx, tsl.max( dy, dz ) ), 55-10, 55+10 ) );
 
-} );
+}, defaults$b );
+
+var defaults$a = {
+	$name: 'Scream',
 
+	scale: 2,
+	variety: 1,
 
+	color: new three.Color( 0xF0F060 ),
+	background: new three.Color( 0xD09090 ),
 
-scepterHead.defaults = {
-	$name: 'Scepter head',
+	seed: 0,
+};
 
-	xFactor: 10,
-	yFactor: 22,
-	zFactor: 10,
 
-	colorRim: new three.Color( 0xFFFFFF ),
-	colorA: new three.Color( 0x70E0FF ),
-	colorB: new three.Color( 0x3000FF ),
-};
-
-var scream = tsl.Fn( ( params ) => {
 
-	params = prepare( { ...scream.defaults, ...params } );
+var scream = TSLFn( ( params ) => {
+
+	params = prepare( params, defaults$a );
 
 	var pos = tsl.positionGeometry.mul( tsl.exp( params.scale ) ).add( params.seed ).toVar( );
 
@@ -2111,7 +2341,7 @@ var scream = tsl.Fn( ( params ) => {
 
 	return hsl( tsl.add( HSL.x, params.variety.mul( tsl.sin( k.mul( Math.PI ) ) ).mul( 0.5 ) ), HSL.y, HSL.z );
 
-} );
+}, defaults$a );
 
 
 
@@ -2127,9 +2357,24 @@ scream.defaults = {
 	seed: 0,
 };
 
-var simplexNoise = tsl.Fn( ( params ) => {
+var defaults$9 = {
+	$name: 'Simplex noise',
+
+	scale: 2,
+	balance: 0,
+	contrast: 0,
+
+	color: new three.Color( 0xFFFFFF ),
+	background: new three.Color( 0x000000 ),
+
+	seed: 0,
+};
+
 
-	params = prepare( { ...simplexNoise.defaults, ...params } );
+
+var simplexNoise = TSLFn( ( params ) => {
+
+	params = prepare( params, defaults$9 );
 
 	var pos = tsl.positionGeometry.mul( tsl.exp( params.scale ) ).add( params.seed );
 
@@ -2137,7 +2382,7 @@ var simplexNoise = tsl.Fn( ( params ) => {
 
 	return tsl.mix( params.background, params.color, k );
 
-} );
+}, defaults$9 );
 
 
 
@@ -2154,9 +2399,24 @@ simplexNoise.defaults = {
 	seed: 0,
 };
 
-var stars = tsl.Fn( ( params ) => {
+var defaults$8 = {
+	$name: 'Stars',
+
+	scale: 2,
+	density: 2,
+	variation: 0,
+
+	color: new three.Color( 0xfff5f0 ),
+	background: new three.Color( 0x000060 ),
+
+	seed: 0,
+};
+
+
+
+var stars = TSLFn( ( params ) => {
 
-	params = prepare( { ...stars.defaults, ...params } );
+	params = prepare( params, defaults$8 );
 
 	var pos = tsl.positionGeometry.mul( tsl.exp( params.scale.div( 2 ).add( 3 ) ) ).add( params.seed ).toVar( );
 
@@ -2170,23 +2430,18 @@ var stars = tsl.Fn( ( params ) => {
 
 	return hsl( tsl.add( col.x, dS ), col.y, col.z );
 
-} );
-
+}, defaults$8 );
+
+var defaults$7 = {
+	$name: 'Supersphere',
+	$positionNode: true,
 
+	exponent: 3,
 
-stars.defaults = {
-	$name: 'Stars',
+};
 
-	scale: 2,
-	density: 2,
-	variation: 0,
 
-	color: new three.Color( 0xfff5f0 ),
-	background: new three.Color( 0x000060 ),
 
-	seed: 0,
-};
-
 var surfacePos$2 = tsl.Fn( ([ pos, params ])=>{
 
 	var exponent = tsl.float( 2 ).pow( params.exponent );
@@ -2203,19 +2458,19 @@ var surfacePos$2 = tsl.Fn( ([ pos, params ])=>{
 
 
 
-var supersphere = tsl.Fn( ( params )=>{
+var supersphere = TSLFn( ( params )=>{
 
-	params = prepare( { ...supersphere.defaults, ...params } );
+	params = prepare( params, defaults$7 );
 
 	return surfacePos$2( tsl.positionGeometry, params );
 
-} );
+}, defaults$7 );
 
 
 
-supersphere.normal = tsl.Fn( ( params ) => {
+supersphere.normal = TSLFn( ( params ) => {
 
-	params = prepare( { ...supersphere.defaults, ...params } );
+	params = prepare( params, defaults$7 );
 
 	var eps = 0.01;
 
@@ -2233,21 +2488,28 @@ supersphere.normal = tsl.Fn( ( params ) => {
 
 	return tsl.transformNormalToView( tsl.cross( dU, dV ).normalize() );
 
-} );
+}, defaults$7 );
+
+var defaults$6 = {
+	$name: 'Tiger fur',
 
+	scale: 2,
+	length: 4,
+	blur: 0.3,
+	strength: 0.3,
+	hairs: 0.5,
 
+	color: new three.Color( 0xFFAA00 ),
+	bottomColor: new three.Color( 0xFFFFEE ),
 
-supersphere.defaults = {
-	$name: 'Supersphere',
-	$positionNode: true,
+	seed: 0,
+};
 
-	exponent: 3,
 
-};
-
-var tigerFur = tsl.Fn( ( params )=>{
 
-	params = prepare( { ...tigerFur.defaults, ...params } );
+var tigerFur = TSLFn( ( params )=>{
+
+	params = prepare( params, defaults$6 );
 
 	var scale = params.scale.div( 2 ).add( 1 ).toVar();
 	var pos = tsl.positionGeometry.mul( tsl.exp( scale ) ).add( params.seed ).toVar( );
@@ -2262,7 +2524,7 @@ var tigerFur = tsl.Fn( ( params )=>{
 
 	return tsl.mix( params.bottomColor, params.color, n ).mul( k );
 
-} );
+}, defaults$6 );
 
 
 tigerFur.defaults = {
@@ -2280,6 +2542,21 @@ tigerFur.defaults = {
 	seed: 0,
 };
 
+var defaults$5 = {
+	$name: 'Translator',
+	$positionNode: true,
+	$selectorPlanar: true,
+
+	distance: new three.Vector3( -0.5, 0, 0.2 ),
+
+	selectorCenter: new three.Vector3( 0, 0, 0 ),
+	selectorAngles: new three.Vector2( 0, 0 ),
+	selectorWidth: 0.7,
+
+};
+
+
+
 var surfacePos$1 = tsl.Fn( ([ pos, params ])=>{
 
 	var zone = selectPlanar( pos, params.selectorAngles, params.selectorCenter, params.selectorWidth );
@@ -2292,19 +2569,19 @@ var surfacePos$1 = tsl.Fn( ([ pos, params ])=>{
 
 
 
-var translator = tsl.Fn( ( params )=>{
+var translator = TSLFn( ( params )=>{
 
-	params = prepare( { ...translator.defaults, ...params } );
+	params = prepare( params, defaults$5 );
 
 	return surfacePos$1( tsl.positionGeometry, params );
 
-} );
+}, defaults$5 );
 
 
 
-translator.normal = tsl.Fn( ( params ) => {
+translator.normal = TSLFn( ( params ) => {
 
-	params = prepare( { ...translator.defaults, ...params } );
+	params = prepare( params, defaults$5 );
 
 	var eps = 0.01;
 
@@ -2322,23 +2599,23 @@ translator.normal = tsl.Fn( ( params ) => {
 
 	return tsl.transformNormalToView( tsl.cross( dU, dV ).normalize() );
 
-} );
+}, defaults$5 );
+
+var defaults$4 = {
+	$name: 'Voronoi cells',
 
+	scale: 2,
+	variation: 0,
+	facet: 0,
 
+	color: new three.Color( 0 ),
+	background: new three.Color( 0xc0d0ff ),
 
-translator.defaults = {
-	$name: 'Translator',
-	$positionNode: true,
-	$selectorPlanar: true,
+	seed: 0,
+};
 
-	distance: new three.Vector3( -0.5, 0, 0.2 ),
 
-	selectorCenter: new three.Vector3( 0, 0, 0 ),
-	selectorAngles: new three.Vector2( 0, 0 ),
-	selectorWidth: 0.7,
 
-};
-
 var cellCenter = tsl.Fn( ([ cell ])=>{
 
 	return cell.add( tsl.mx_noise_float( cell.mul( Math.PI ) ) );
@@ -2346,9 +2623,9 @@ var cellCenter = tsl.Fn( ([ cell ])=>{
 } );
 
 
-var voronoiCells = tsl.Fn( ( params )=>{
+var voronoiCells = TSLFn( ( params )=>{
 
-	params = prepare( { ...voronoiCells.defaults, ...params } );
+	params = prepare( params, defaults$4 );
 
 	var pos = tsl.positionGeometry.mul( tsl.exp( params.scale.div( 2 ).add( 0.5 ) ) ).add( params.seed ).toVar( );
 
@@ -2389,23 +2666,21 @@ var voronoiCells = tsl.Fn( ( params )=>{
 
 	return tsl.mix( color, tsl.mix( color, randomColor, params.variation ), params.variation );
 
-} );
-
+}, defaults$4 );
+
+var defaults$3 = {
+	$name: 'Water Drops',
+	$normalNode: true,
 
+	scale: 1.4,
+	density: 0.5,
+	bump: 0.6,
 
-voronoiCells.defaults = {
-	$name: 'Voronoi cells',
+	seed: 0,
+};
 
-	scale: 2,
-	variation: 0,
-	facet: 0,
 
-	color: new three.Color( 0 ),
-	background: new three.Color( 0xc0d0ff ),
 
-	seed: 0,
-};
-
 var surfacePos = tsl.Fn( ([ pos, normal, bump, density, seed ]) => {
 
 	var k = tsl.mx_noise_float( pos.add( seed ) ).add( density ).clamp( 0, 1 );
@@ -2416,9 +2691,10 @@ var surfacePos = tsl.Fn( ([ pos, normal, bump, density, seed ]) => {
 } );
 
 
-var waterDrops = tsl.Fn( ( params ) => {
 
-	params = prepare( { ...waterDrops.defaults, ...params } );
+var waterDrops = TSLFn( ( params ) => {
+
+	params = prepare( params, defaults$3 );
 
 	var eps = 0.001;
 
@@ -2440,24 +2716,29 @@ var waterDrops = tsl.Fn( ( params ) => {
 
 	return tsl.transformNormalToView( tsl.cross( dU, dV ).normalize() );
 
-} );
-
+}, defaults$3 );
+
+var defaults$2 = {
+	$name: 'Watermelon',
 
+	scale: 2,
+	stripes: 12,
+	variation: 0.5,
+	noise: 0.25,
 
-waterDrops.defaults = {
-	$name: 'Water Drops',
-	$normalNode: true,
+	color: new three.Color( 'yellowgreen' ),
+	background: new three.Color( 'darkgreen' ),
 
-	scale: 1.4,
-	density: 0.5,
-	bump: 0.6,
+	flat: 0,
 
 	seed: 0,
-};
-
-var watermelon = tsl.Fn( ( params )=>{
+};
+
 
-	params = prepare( { ...watermelon.defaults, ...params } );
+
+var watermelon = TSLFn( ( params )=>{
+
+	params = prepare( params, defaults$2 );
 
 	var variation = tsl.select( params.flat, params.variation.mul( 0.85 ).add( 0.15 ), params.variation );
 
@@ -2483,29 +2764,26 @@ var watermelon = tsl.Fn( ( params )=>{
 
 	return color;
 
-} );
-
-
-
-watermelon.defaults = {
-	$name: 'Watermelon',
-
-	scale: 2,
-	stripes: 12,
-	variation: 0.5,
-	noise: 0.25,
+}, defaults$2 );
+
+var defaults$1 = {
+	$name: 'Wood',
+	scale: 2.5,
+	rings: 4.5,
+	length: 1,
+	angle: 0,
+	fibers: 0.3,
+	fibersDensity: 10,
+	color: new three.Color( 0.8, 0.4, 0 ),
+	background: new three.Color( 0.4, 0.1, 0 ),
+	seed: 0,
+};
 
-	color: new three.Color( 'yellowgreen' ),
-	background: new three.Color( 'darkgreen' ),
 
-	flat: 0,
 
-	seed: 0,
-};
-
-var wood = tsl.Fn( ( params ) => {
+var wood = TSLFn( ( params ) => {
 
-	params = prepare( { ...wood.defaults, ...params } );
+	params = prepare( params, defaults$1 );
 
 	var angle = tsl.radians( params.angle ).toVar();
 	var posLocal = tsl.vec3(
@@ -2538,26 +2816,28 @@ var wood = tsl.Fn( ( params ) => {
 
 	return tsl.mix( params.color, params.background, tsl.mix( k, kk, params.fibers ) );
 
-} );
+}, defaults$1 );
+
+var defaults = {
+	$name: 'Zebra lines',
 
+	scale: 2,
+	thinness: 0.5,
+	phi: 0,
+	theta: 0,
 
+	color: new three.Color( 0x0 ),
+	background: new three.Color( 0xFFFFFF ),
 
-wood.defaults = {
-	$name: 'Wood',
-	scale: 2.5,
-	rings: 4.5,
-	length: 1,
-	angle: 0,
-	fibers: 0.3,
-	fibersDensity: 10,
-	color: new three.Color( 0.8, 0.4, 0 ),
-	background: new three.Color( 0.4, 0.1, 0 ),
-	seed: 0,
-};
-
-var zebraLines = tsl.Fn( ( params ) => {
+	flat: 0,
+	// no seed for zebra lines
+};
 
-	params = prepare( { ...zebraLines.defaults, ...params } );
+
+
+var zebraLines = TSLFn( ( params ) => {
+
+	params = prepare( params, defaults );
 
 	var pos = tsl.select( params.flat, tsl.positionGeometry, tsl.positionGeometry.normalize() ).toVar( );
 
@@ -2573,29 +2853,13 @@ var zebraLines = tsl.Fn( ( params ) => {
 
 	return tsl.mix( params.background, params.color, k );
 
-} );
-
-
-
-zebraLines.defaults = {
-	$name: 'Zebra lines',
-
-	scale: 2,
-	thinness: 0.5,
-	phi: 0,
-	theta: 0,
-
-	color: new three.Color( 0x0 ),
-	background: new three.Color( 0xFFFFFF ),
-
-	flat: 0,
-	// no seed for zebra lines
-};
+}, defaults );
 
 Object.defineProperty(exports, "noise", {
 	enumerable: true,
 	get: function () { return tsl.mx_noise_float; }
 });
+exports.TSLFn = TSLFn;
 exports.applyEuler = applyEuler;
 exports.camouflage = camouflage;
 exports.caveArt = caveArt;