@lampdotdev/lamp 0.0.0-stage → 0.35.0

package/Resources/WebLibraries/three/addons/tsl/lighting/data/PointLightDataNode.js

@@ -0,0 +1,140 @@
+import { Color, Node, Vector3, Vector4 } from 'three/webgpu';
+import { Loop, NodeUpdateType, getDistanceAttenuation, positionView, renderGroup, uniform, uniformArray, vec3 } from 'three/tsl';
+
+const _position = /*@__PURE__*/ new Vector3();
+
+const warn = ( message ) => {
+
+	console.warn( `THREE.PointLightDataNode: ${ message }` );
+
+};
+
+/**
+ * Batched data node for point lights in dynamic lighting mode.
+ *
+ * @augments Node
+ */
+class PointLightDataNode extends Node {
+
+	static get type() {
+
+		return 'PointLightDataNode';
+
+	}
+
+	constructor( maxCount = 16 ) {
+
+		super();
+
+		this.maxCount = maxCount;
+		this._lights = [];
+		this._colors = [];
+		this._positionsAndCutoff = [];
+		this._decays = [];
+
+		for ( let i = 0; i < maxCount; i ++ ) {
+
+			this._colors.push( new Color() );
+			this._positionsAndCutoff.push( new Vector4() );
+			this._decays.push( new Vector4() );
+
+		}
+
+		this.colorsNode = uniformArray( this._colors, 'color' ).setGroup( renderGroup );
+		this.positionsAndCutoffNode = uniformArray( this._positionsAndCutoff, 'vec4' ).setGroup( renderGroup );
+		this.decaysNode = uniformArray( this._decays, 'vec4' ).setGroup( renderGroup );
+		this.countNode = uniform( 0, 'int' ).setGroup( renderGroup );
+		this.updateType = NodeUpdateType.RENDER;
+
+	}
+
+	isCacheable( /*builder*/ ) {
+
+		return false;
+
+	}
+
+	setLights( lights ) {
+
+		if ( lights.length > this.maxCount ) {
+
+			warn( `${ lights.length } lights exceed the configured max of ${ this.maxCount }. Excess lights are ignored.` );
+
+		}
+
+		this._lights = lights;
+
+		return this;
+
+	}
+
+	update( { camera } ) {
+
+		const count = Math.min( this._lights.length, this.maxCount );
+
+		this.countNode.value = count;
+
+		for ( let i = 0; i < count; i ++ ) {
+
+			const light = this._lights[ i ];
+
+			this._colors[ i ].copy( light.color ).multiplyScalar( light.intensity );
+
+			_position.setFromMatrixPosition( light.matrixWorld );
+			_position.applyMatrix4( camera.matrixWorldInverse );
+
+			const positionAndCutoff = this._positionsAndCutoff[ i ];
+			positionAndCutoff.x = _position.x;
+			positionAndCutoff.y = _position.y;
+			positionAndCutoff.z = _position.z;
+			positionAndCutoff.w = light.distance;
+
+			this._decays[ i ].x = light.decay;
+
+		}
+
+	}
+
+	setup( builder ) {
+
+		const surfacePosition = builder.context.positionView || positionView;
+		const { lightingModel, reflectedLight } = builder.context;
+		const dynDiffuse = vec3( 0 ).toVar( 'dynPointDiffuse' );
+		const dynSpecular = vec3( 0 ).toVar( 'dynPointSpecular' );
+
+		Loop( this.countNode, ( { i } ) => {
+
+			const positionAndCutoff = this.positionsAndCutoffNode.element( i );
+			const lightViewPosition = positionAndCutoff.xyz;
+			const cutoffDistance = positionAndCutoff.w;
+			const decayExponent = this.decaysNode.element( i ).x;
+
+			const lightVector = lightViewPosition.sub( surfacePosition ).toVar();
+			const lightDirection = lightVector.normalize().toVar();
+			const lightDistance = lightVector.length();
+
+			const attenuation = getDistanceAttenuation( {
+				lightDistance,
+				cutoffDistance,
+				decayExponent
+			} );
+
+			const lightColor = this.colorsNode.element( i ).mul( attenuation ).toVar();
+
+			lightingModel.direct( {
+				lightDirection,
+				lightColor,
+				lightNode: { light: {}, shadowNode: null },
+				reflectedLight: { directDiffuse: dynDiffuse, directSpecular: dynSpecular }
+			}, builder );
+
+		} );
+
+		reflectedLight.directDiffuse.addAssign( dynDiffuse );
+		reflectedLight.directSpecular.addAssign( dynSpecular );
+
+	}
+
+}
+
+export default PointLightDataNode;

package/Resources/WebLibraries/three/addons/tsl/lighting/data/SpotLightDataNode.js

@@ -0,0 +1,167 @@
+import { Color, Node, Vector3, Vector4 } from 'three/webgpu';
+import { Loop, NodeUpdateType, getDistanceAttenuation, positionView, renderGroup, smoothstep, uniform, uniformArray, vec3 } from 'three/tsl';
+
+const _lightPosition = /*@__PURE__*/ new Vector3();
+const _targetPosition = /*@__PURE__*/ new Vector3();
+
+const warn = ( message ) => {
+
+	console.warn( `THREE.SpotLightDataNode: ${ message }` );
+
+};
+
+/**
+ * Batched data node for simple spot lights in dynamic lighting mode.
+ *
+ * Projected spot lights keep the default per-light path.
+ *
+ * @augments Node
+ */
+class SpotLightDataNode extends Node {
+
+	static get type() {
+
+		return 'SpotLightDataNode';
+
+	}
+
+	constructor( maxCount = 16 ) {
+
+		super();
+
+		this.maxCount = maxCount;
+		this._lights = [];
+		this._colors = [];
+		this._positionsAndCutoff = [];
+		this._directionsAndDecay = [];
+		this._cones = [];
+
+		for ( let i = 0; i < maxCount; i ++ ) {
+
+			this._colors.push( new Color() );
+			this._positionsAndCutoff.push( new Vector4() );
+			this._directionsAndDecay.push( new Vector4() );
+			this._cones.push( new Vector4() );
+
+		}
+
+		this.colorsNode = uniformArray( this._colors, 'color' ).setGroup( renderGroup );
+		this.positionsAndCutoffNode = uniformArray( this._positionsAndCutoff, 'vec4' ).setGroup( renderGroup );
+		this.directionsAndDecayNode = uniformArray( this._directionsAndDecay, 'vec4' ).setGroup( renderGroup );
+		this.conesNode = uniformArray( this._cones, 'vec4' ).setGroup( renderGroup );
+		this.countNode = uniform( 0, 'int' ).setGroup( renderGroup );
+		this.updateType = NodeUpdateType.RENDER;
+
+	}
+
+	isCacheable( /*builder*/ ) {
+
+		return false;
+
+	}
+
+	setLights( lights ) {
+
+		if ( lights.length > this.maxCount ) {
+
+			warn( `${ lights.length } lights exceed the configured max of ${ this.maxCount }. Excess lights are ignored.` );
+
+		}
+
+		this._lights = lights;
+
+		return this;
+
+	}
+
+	update( { camera } ) {
+
+		const count = Math.min( this._lights.length, this.maxCount );
+
+		this.countNode.value = count;
+
+		for ( let i = 0; i < count; i ++ ) {
+
+			const light = this._lights[ i ];
+
+			this._colors[ i ].copy( light.color ).multiplyScalar( light.intensity );
+
+			_lightPosition.setFromMatrixPosition( light.matrixWorld );
+			_lightPosition.applyMatrix4( camera.matrixWorldInverse );
+
+			const positionAndCutoff = this._positionsAndCutoff[ i ];
+			positionAndCutoff.x = _lightPosition.x;
+			positionAndCutoff.y = _lightPosition.y;
+			positionAndCutoff.z = _lightPosition.z;
+			positionAndCutoff.w = light.distance;
+
+			_lightPosition.setFromMatrixPosition( light.matrixWorld );
+			_targetPosition.setFromMatrixPosition( light.target.matrixWorld );
+			_lightPosition.sub( _targetPosition ).transformDirection( camera.matrixWorldInverse );
+
+			const directionAndDecay = this._directionsAndDecay[ i ];
+			directionAndDecay.x = _lightPosition.x;
+			directionAndDecay.y = _lightPosition.y;
+			directionAndDecay.z = _lightPosition.z;
+			directionAndDecay.w = light.decay;
+
+			const cone = this._cones[ i ];
+			cone.x = Math.cos( light.angle );
+			cone.y = Math.cos( light.angle * ( 1 - light.penumbra ) );
+
+		}
+
+	}
+
+	setup( builder ) {
+
+		const surfacePosition = builder.context.positionView || positionView;
+		const { lightingModel, reflectedLight } = builder.context;
+		const dynDiffuse = vec3( 0 ).toVar( 'dynSpotDiffuse' );
+		const dynSpecular = vec3( 0 ).toVar( 'dynSpotSpecular' );
+
+		Loop( this.countNode, ( { i } ) => {
+
+			const positionAndCutoff = this.positionsAndCutoffNode.element( i );
+			const lightViewPosition = positionAndCutoff.xyz;
+			const cutoffDistance = positionAndCutoff.w;
+
+			const directionAndDecay = this.directionsAndDecayNode.element( i );
+			const spotDirection = directionAndDecay.xyz;
+			const decayExponent = directionAndDecay.w;
+
+			const cone = this.conesNode.element( i );
+			const coneCos = cone.x;
+			const penumbraCos = cone.y;
+
+			const lightVector = lightViewPosition.sub( surfacePosition ).toVar();
+			const lightDirection = lightVector.normalize().toVar();
+			const lightDistance = lightVector.length();
+
+			const angleCos = lightDirection.dot( spotDirection );
+			const spotAttenuation = smoothstep( coneCos, penumbraCos, angleCos );
+			const distanceAttenuation = getDistanceAttenuation( {
+				lightDistance,
+				cutoffDistance,
+				decayExponent
+			} );
+
+			const lightColor = this.colorsNode.element( i ).mul( spotAttenuation ).mul( distanceAttenuation ).toVar();
+
+			lightingModel.direct( {
+				lightDirection,
+				lightColor,
+				lightNode: { light: {}, shadowNode: null },
+				reflectedLight: { directDiffuse: dynDiffuse, directSpecular: dynSpecular }
+			}, builder );
+
+		} );
+
+		reflectedLight.directDiffuse.addAssign( dynDiffuse );
+		reflectedLight.directSpecular.addAssign( dynSpecular );
+
+	}
+
+}
+
+export default SpotLightDataNode;

package/Resources/WebLibraries/three/addons/tsl/math/Bayer.js

@@ -0,0 +1,84 @@
+import { ImageBitmapLoader, Texture } from 'three';
+import { Fn, int, ivec2, textureLoad, screenUV, screenSize, mod, floor, float, vec3 } from 'three/tsl';
+
+/**
+ * @module Bayer
+ * @three_import import { bayer16 } from 'three/addons/tsl/math/Bayer.js';
+ */
+
+let bayer16Texture = null;
+
+/**
+ * This TSL function can be used to sample a Bayer16 texture which is a 16x16 texture with a Bayer Matrix pattern.
+ * It can be used for dithering effects but also as an alternative to blue-noise. When used with Ray Marching
+ * specifically in {@link VolumeNodeMaterial#offsetNode}, it reduces banding problem, thus being able to use
+ * fewer steps without affecting the visuals as much.
+ *
+ * @tsl
+ * @function
+ * @param {Node<vec2>} uv - The uv to sample the bayer16 texture.
+ * @return {Node<vec4>} The sampled bayer value.
+ */
+export const bayer16 = Fn( ( [ uv ] ) => {
+
+	if ( bayer16Texture === null ) {
+
+		const bayer16Base64 = 'data:image/png;base64,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';
+
+		bayer16Texture = new Texture();
+		const loader = new ImageBitmapLoader();
+
+		loader.setOptions( { imageOrientation: 'flipY', premultiplyAlpha: 'none' } );
+
+		loader.load( bayer16Base64, ( imageBitmap ) => {
+
+			bayer16Texture.image = imageBitmap;
+			bayer16Texture.flipY = false;
+			bayer16Texture.needsUpdate = true;
+
+		} );
+
+	}
+
+	return textureLoad( bayer16Texture, ivec2( uv ).mod( int( 16 ) ) );
+
+} );
+
+/**
+ * This TSL function applies Bayer dithering to a color input. It uses a 4x4 Bayer matrix
+ * pattern to add structured noise before color quantization, which helps reduce visible
+ * color banding when limiting color depth.
+ *
+ * @tsl
+ * @function
+ * @param {Node<vec3>} color - The input color to apply dithering to.
+ * @param {Node<float>} [steps=32] - The number of color steps per channel.
+ * @return {Node<vec3>} The dithered color ready for quantization.
+ *
+ * @example
+ * // Apply dithering with posterize
+ * const ditheredColor = bayerDither( inputColor, 32 );
+ * const finalColor = posterize( ditheredColor, 32 );
+ */
+export const bayerDither = Fn( ( [ color, steps = float( 32.0 ) ] ) => {
+
+	const screenPos = screenUV.mul( screenSize );
+	const x = mod( floor( screenPos.x ), float( 4.0 ) );
+	const y = mod( floor( screenPos.y ), float( 4.0 ) );
+
+	// Simplified Bayer matrix approximation
+	const bayer = mod(
+		floor( x.add( 1.0 ) ).mul( floor( y.add( 1.0 ) ) ).mul( 17.0 ),
+		16.0
+	).div( 16.0 ).sub( 0.5 );
+
+	// Apply dither offset before quantization
+	const ditherOffset = bayer.div( steps );
+
+	return vec3(
+		color.r.add( ditherOffset ),
+		color.g.add( ditherOffset ),
+		color.b.add( ditherOffset )
+	);
+
+} );

package/Resources/WebLibraries/three/addons/tsl/math/curlNoise.js

@@ -0,0 +1,107 @@
+import { mod, Fn, vec2, div, vec4, dot, floor, step, sub, min, max, mul, abs, vec3, inverseSqrt, add, float } from 'three/tsl';
+
+/**
+ * Permutation polynomial for noise generation.
+ *
+ * @tsl
+ * @function
+ * @param {Node<vec4>} x - Input vector.
+ * @return {Node<vec4>} Permuted vector.
+ */
+export const permute = /*@__PURE__*/ Fn( ( [ x ] ) => {
+
+	return mod( x.mul( x ).mul( 34. ).add( x ), 289. );
+
+}, { x: 'vec4', return: 'vec4' } );
+
+/**
+ * 3D Simplex noise implementation in TSL.
+ *
+ * @tsl
+ * @function
+ * @param {Node<vec3>} v - Input coordinate vector.
+ * @return {Node<float>} Simplex noise value.
+ */
+export const snoise = /*@__PURE__*/ Fn( ( [ v ] ) => {
+
+	const C = div( 1., vec2( 6, 3 ) );
+	const D = vec4( 0, .5, 1, 2 );
+	const i = floor( v.add( dot( v, C.yyy ) ) );
+	const x0 = v.sub( i ).add( dot( i, C.xxx ) );
+	const g = step( x0.yzx, x0.xyz );
+	const l = sub( 1., g );
+	const i1 = min( g.xyz, l.zxy );
+	const i2 = max( g.xyz, l.zxy );
+	const x1 = x0.sub( i1 ).add( C.x );
+	const x2 = x0.sub( i2 ).add( C.y );
+	const x3 = x0.sub( D.yyy );
+	i.assign( mod( i, 289. ) );
+	const p = permute( permute( permute( i.z.add( vec4( 0., i1.z, i2.z, 1. ) ) ).add( i.y ).add( vec4( 0., i1.y, i2.y, 1. ) ) ).add( i.x ).add( vec4( 0., i1.x, i2.x, 1. ) ) );
+	const ns = mul( .142857142857, D.wyz ).sub( D.xzx );
+	const j = p.sub( mul( 49., floor( p.mul( ns.z ).mul( ns.z ) ) ) );
+	const x_ = floor( j.mul( ns.z ) );
+	const x = x_.mul( ns.x ).add( ns.yyyy );
+	const y = floor( j.sub( mul( 7., x_ ) ) ).mul( ns.x ).add( ns.yyyy );
+	const h = sub( 1., abs( x ) ).sub( abs( y ) );
+	const b0 = vec4( x.xy, y.xy );
+	const b1 = vec4( x.zw, y.zw );
+	const sh = step( h, vec4( 0 ) ).negate();
+	const a0 = b0.xzyw.add( floor( b0 ).mul( 2. ).add( 1. ).xzyw.mul( sh.xxyy ) );
+	const a1 = b1.xzyw.add( floor( b1 ).mul( 2. ).add( 1. ).xzyw.mul( sh.zzww ) );
+	const p0 = vec3( a0.xy, h.x );
+	const p1 = vec3( a0.zw, h.y );
+	const p2 = vec3( a1.xy, h.z );
+	const p3 = vec3( a1.zw, h.w );
+	const norm = inverseSqrt( vec4( dot( p0, p0 ), dot( p1, p1 ), dot( p2, p2 ), dot( p3, p3 ) ) );
+	p0.mulAssign( norm.x );
+	p1.mulAssign( norm.y );
+	p2.mulAssign( norm.z );
+	p3.mulAssign( norm.w );
+	const m = max( sub( .6, vec4( dot( x0, x0 ), dot( x1, x1 ), dot( x2, x2 ), dot( x3, x3 ) ) ), 0. );
+
+	return add( .5, mul( 12., dot( m.mul( m ).mul( m ), vec4( dot( p0, x0 ), dot( p1, x1 ), dot( p2, x2 ), dot( p3, x3 ) ) ) ) );
+
+}, { v: 'vec3', return: 'float' } );
+
+/**
+ * 3D Simplex noise vector. Returns a vec3 containing three independent noise samples.
+ *
+ * @tsl
+ * @function
+ * @param {Node<vec3>} x - Input coordinate vector.
+ * @return {Node<vec3>} Vector of three noise values.
+ */
+export const snoiseVec3 = /*@__PURE__*/ Fn( ( [ x ] ) => {
+
+	return vec3( snoise( vec3( x ).mul( 2. ).sub( 1. ) ), snoise( vec3( x.y.sub( 19.1 ), x.z.add( 33.4 ), x.x.add( 47.2 ) ) ).mul( 2. ).sub( 1. ), snoise( vec3( x.z.add( 74.2 ), x.x.sub( 124.5 ), x.y.add( 99.4 ) ).mul( 2. ).sub( 1. ) ) );
+
+}, { x: 'vec3', return: 'vec3' } );
+
+/**
+ * 3D Curl noise in TSL. Generates a divergence-free vector field from simplex noise.
+ *
+ * @tsl
+ * @function
+ * @param {Node<vec3>} p - Input coordinate vector.
+ * @return {Node<vec3>} Curl noise vector.
+ */
+export const curlNoise = /*@__PURE__*/ Fn( ( [ p ] ) => {
+
+	const e = float( .1 );
+	const dx = vec3( e, 0.0, 0.0 );
+	const dy = vec3( 0.0, e, 0.0 );
+	const dz = vec3( 0.0, 0.0, e );
+	const p_x0 = snoiseVec3( p.sub( dx ) );
+	const p_x1 = snoiseVec3( p.add( dx ) );
+	const p_y0 = snoiseVec3( p.sub( dy ) );
+	const p_y1 = snoiseVec3( p.add( dy ) );
+	const p_z0 = snoiseVec3( p.sub( dz ) );
+	const p_z1 = snoiseVec3( p.add( dz ) );
+	const x = p_y1.z.sub( p_y0.z ).sub( p_z1.y ).add( p_z0.y );
+	const y = p_z1.x.sub( p_z0.x ).sub( p_x1.z ).add( p_x0.z );
+	const z = p_x1.y.sub( p_x0.y ).sub( p_y1.x ).add( p_y0.x );
+	const divisor = div( 1.0, mul( 2.0, e ) );
+
+	return vec3( x, y, z ).mul( divisor );
+
+}, { p: 'vec3', return: 'vec3' } );

package/Resources/WebLibraries/three/addons/tsl/math/voronoiNoise.js

@@ -0,0 +1,112 @@
+import { Fn, Loop, dot, float, fract, int, min, sin, vec2, vec3, TWO_PI } from 'three/tsl';
+
+/**
+ * @module VoronoiNoise
+ * @three_import import { voronoi2d, voronoi3d } from 'three/addons/tsl/math/voronoiNoise.js';
+ */
+
+/**
+ * Generates a pseudo-random vec2 from the given coordinate.
+ *
+ * Reference: {@link https://www.shadertoy.com/view/MslGD8}.
+ *
+ * @tsl
+ * @function
+ * @param {Node<vec2>} p - The input coordinate.
+ * @return {Node<vec2>} A pseudo-random value in the range `[0, 1]`.
+ */
+export const hash2d = /*@__PURE__*/ Fn( ( [ p ] ) => {
+
+	return fract( sin( vec2( dot( p, vec2( 127.1, 311.7 ) ), dot( p, vec2( 269.5, 183.3 ) ) ) ).mul( 18.5453 ) );
+
+}, { p: 'vec2', return: 'vec2' } );
+
+/**
+ * Animated 2D Voronoi noise. The feature points orbit inside their cells so the
+ * resulting pattern morphs over time.
+ *
+ * Reference: {@link https://www.shadertoy.com/view/MslGD8}.
+ *
+ * @tsl
+ * @function
+ * @param {Node<vec2>} p - The input coordinate.
+ * @param {Node<float>} time - The animation time.
+ * @return {Node<float>} The squared distance to the closest feature point, roughly in the range `[0, 1]`.
+ */
+export const voronoi2d = /*@__PURE__*/ Fn( ( [ p, time ] ) => {
+
+	const n = p.floor().toConst();
+	const f = p.fract().toConst();
+	const minDist = float( 8 ).toVar();
+
+	Loop( { start: int( - 1 ), end: int( 1 ), name: 'x', condition: '<=' }, ( { x } ) => {
+
+		Loop( { start: int( - 1 ), end: int( 1 ), name: 'y', condition: '<=' }, ( { y } ) => {
+
+			const g = vec2( float( x ), float( y ) ).toConst();
+			const o = hash2d( n.add( g ) ).toConst();
+			const r = g.sub( f ).add( sin( time.add( o.mul( TWO_PI ) ) ).mul( 0.5 ).add( 0.5 ) );
+
+			minDist.assign( min( minDist, dot( r, r ) ) );
+
+		} );
+
+	} );
+
+	return minDist;
+
+}, { p: 'vec2', time: 'float', return: 'float' } );
+
+/**
+ * Generates a pseudo-random vec3 from the given coordinate.
+ *
+ * @tsl
+ * @function
+ * @param {Node<vec3>} p - The input coordinate.
+ * @return {Node<vec3>} A pseudo-random value in the range `[0, 1]`.
+ */
+export const hash3d = /*@__PURE__*/ Fn( ( [ p ] ) => {
+
+	return fract( sin( vec3( dot( p, vec3( 127.1, 311.7, 74.7 ) ), dot( p, vec3( 269.5, 183.3, 246.1 ) ), dot( p, vec3( 113.5, 271.9, 124.6 ) ) ) ).mul( 18.5453 ) );
+
+}, { p: 'vec3', return: 'vec3' } );
+
+/**
+ * Animated 3D Voronoi noise. Like {@link voronoi2d} but with a volumetric input
+ * coordinate so the pattern can be applied to arbitrary surfaces without
+ * projection artifacts. Evaluates 27 cells instead of 9 and is therefore
+ * considerably more expensive than the 2D version.
+ *
+ * @tsl
+ * @function
+ * @param {Node<vec3>} p - The input coordinate.
+ * @param {Node<float>} time - The animation time.
+ * @return {Node<float>} The squared distance to the closest feature point, roughly in the range `[0, 1]`.
+ */
+export const voronoi3d = /*@__PURE__*/ Fn( ( [ p, time ] ) => {
+
+	const n = p.floor().toConst();
+	const f = p.fract().toConst();
+	const minDist = float( 8 ).toVar();
+
+	Loop( { start: int( - 1 ), end: int( 1 ), name: 'x', condition: '<=' }, ( { x } ) => {
+
+		Loop( { start: int( - 1 ), end: int( 1 ), name: 'y', condition: '<=' }, ( { y } ) => {
+
+			Loop( { start: int( - 1 ), end: int( 1 ), name: 'z', condition: '<=' }, ( { z } ) => {
+
+				const g = vec3( float( x ), float( y ), float( z ) ).toConst();
+				const o = hash3d( n.add( g ) ).toConst();
+				const r = g.sub( f ).add( sin( time.add( o.mul( TWO_PI ) ) ).mul( 0.5 ).add( 0.5 ) );
+
+				minDist.assign( min( minDist, dot( r, r ) ) );
+
+			} );
+
+		} );
+
+	} );
+
+	return minDist;
+
+}, { p: 'vec3', time: 'float', return: 'float' } );