shaders 2.3.66 → 2.3.67

package/dist/core/{Aurora-CYCPE1wp.js → Aurora-NksIvzEl.js}

@@ -1,6 +1,6 @@
 import { a as transformColor, l as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-B5lM6fYX.js";
 import { t as createAnimatedTime } from "./time-BZqyVJXt.js";
-import { t as mixColors } from "./colorMixing-D_wMclqL.js";
+import { t as mixColors } from "./colorMixing-jSm3tbMv.js";
 import { Fn, clamp, exp, float, fract, mix, mx_noise_float, pow, screenUV, sin, smoothstep, step, vec2, vec3, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "Aurora",
@@ -40,6 +40,7 @@ const componentDefinition = {
 		colorSpace: {
 			default: "linear",
 			transform: transformColorSpace,
+			compileTime: true,
 			description: "Color space for color interpolation",
 			ui: {
 				type: "select",
@@ -163,7 +164,7 @@ const componentDefinition = {
 		const colorA = uniforms.colorA.uniform;
 		const colorB = uniforms.colorB.uniform;
 		const colorC = uniforms.colorC.uniform;
-		const csMode = uniforms.colorSpace.uniform;
+		const csMode = uniforms.colorSpace.uniform.value;
 		const balanceExp = mix(float(2.5), float(.4), uniforms.balance.uniform.mul(.01));
 		const intensity = uniforms.intensity.uniform.mul(.018);
 		const curtainCount = uniforms.curtainCount.uniform;

package/dist/core/{Beam-COjEb2JI.js → Beam-CprkmCUE.js}

@@ -1,5 +1,5 @@
 import { a as transformColor, l as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-B5lM6fYX.js";
-import { t as mixColors } from "./colorMixing-D_wMclqL.js";
+import { t as mixColors } from "./colorMixing-jSm3tbMv.js";
 import { clamp, float, max, mix, pow, screenUV, smoothstep, sqrt, vec2, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "Beam",
@@ -103,6 +103,7 @@ const componentDefinition = {
 		colorSpace: {
 			default: "linear",
 			transform: transformColorSpace,
+			compileTime: true,
 			description: "Color space for color interpolation",
 			ui: {
 				type: "select",
@@ -138,7 +139,7 @@ const componentDefinition = {
 		const colorT = smoothstep(float(1).sub(softness), float(1).add(softness), normalizedDist);
 		const insideCol = uniforms.insideColor.uniform;
 		const outsideCol = uniforms.outsideColor.uniform;
-		const beamColorRGB = mixColors(insideCol, outsideCol, colorT, uniforms.colorSpace.uniform).rgb;
+		const beamColorRGB = mixColors(insideCol, outsideCol, colorT, uniforms.colorSpace.uniform.value).rgb;
 		return vec4(beamColorRGB, insideCol.a.add(outsideCol.a).div(float(2)).mul(alpha));
 	}
 };

package/dist/core/{Blob-jHnoxt2N.js → Blob-Bbq8XbWa.js}

@@ -1,6 +1,6 @@
 import { a as transformColor, l as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-B5lM6fYX.js";
 import { t as createAnimatedTime } from "./time-BZqyVJXt.js";
-import { t as mixColors } from "./colorMixing-D_wMclqL.js";
+import { t as mixColors } from "./colorMixing-jSm3tbMv.js";
 import { dot, float, length, max, normalize, pow, reflect, screenUV, sin, smoothstep, vec2, vec3, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "Blob",
@@ -161,6 +161,7 @@ const componentDefinition = {
 		colorSpace: {
 			default: "linear",
 			transform: transformColorSpace,
+			compileTime: true,
 			description: "Color space for color interpolation",
 			ui: {
 				type: "select",
@@ -217,7 +218,7 @@ const componentDefinition = {
 		const colorNoise1 = sin(posX.add(animTime.mul(float(.4)))).mul(sin(posY.add(animTime.mul(float(.3))))).add(sin(posX.mul(float(.7)).add(posY.mul(float(.8))).add(animTime.mul(float(.2))))).mul(float(.5)).add(float(.5));
 		const colorNoise2 = sin(posX.mul(float(1.3)).sub(animTime.mul(float(.5)))).mul(sin(posY.mul(float(1.1)).add(animTime.mul(float(.6))))).add(sin(posX.mul(float(.5)).sub(posY.mul(float(.6)).sub(animTime.mul(float(.3)))))).mul(float(.5)).add(float(.5));
 		const combinedNoise = colorNoise1.mul(float(.6)).add(colorNoise2.mul(float(.4)));
-		const finalColorRGB = mixColors(colorA, colorB, smoothstep(float(.1), float(.9), combinedNoise), uniforms.colorSpace.uniform).rgb;
+		const finalColorRGB = mixColors(colorA, colorB, smoothstep(float(.1), float(.9), combinedNoise), uniforms.colorSpace.uniform.value).rgb;
 		const avgAlpha = colorA.a.add(colorB.a).div(float(2));
 		const highlightContribution = highlightColor.rgb.mul(finalHighlight);
 		return vec4(finalColorRGB.add(highlightContribution), avgAlpha.mul(blobMask));

package/dist/core/{Bulge-CsNj4Jew.js → Bulge-iv4gvOrb.js}

@@ -1,4 +1,4 @@
-import { t as applyEdgeHandling } from "./edges-Bd7GP4s2.js";
+import { t as applyEdgeHandling } from "./edges-CfGcQniB.js";
 import { c as transformEdges, l as transformPosition } from "./transformations-B5lM6fYX.js";
 import { t as unpremultiplyAlpha } from "./alpha-Byel9eTg.js";
 import { convertToTexture, float, length, max, screenUV, smoothstep, vec2, vec4, viewportSize } from "three/tsl";
@@ -62,6 +62,7 @@ const componentDefinition = {
 			default: "stretch",
 			description: "How to handle edges when distortion pushes content out of bounds",
 			transform: transformEdges,
+			compileTime: true,
 			ui: {
 				type: "select",
 				options: [
@@ -110,7 +111,7 @@ const componentDefinition = {
 		const bulgedDelta = delta.mul(scaleFactor);
 		const bulgedUV = centerPos.add(bulgedDelta);
 		const finalUV = vec2(bulgedUV.x.div(aspect), bulgedUV.y);
-		return unpremultiplyAlpha(applyEdgeHandling(finalUV, childTexture.sample(finalUV), childTexture, uniforms.edges.uniform));
+		return unpremultiplyAlpha(applyEdgeHandling(finalUV, childTexture.sample(finalUV), childTexture, uniforms.edges.uniform.value));
 	}
 };
 var Bulge_default = componentDefinition;

package/dist/core/{Checkerboard-DwiW08iJ.js → Checkerboard-DgAStqo1.js}

@@ -1,5 +1,5 @@
 import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-B5lM6fYX.js";
-import { t as mixColors } from "./colorMixing-D_wMclqL.js";
+import { t as mixColors } from "./colorMixing-jSm3tbMv.js";
 import { float, floor, fract, min, mod, screenUV, smoothstep, vec2, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "Checkerboard",
@@ -53,6 +53,7 @@ const componentDefinition = {
 		colorSpace: {
 			default: "linear",
 			transform: transformColorSpace,
+			compileTime: true,
 			description: "Color space for color interpolation",
 			ui: {
 				type: "select",
@@ -76,7 +77,7 @@ const componentDefinition = {
 		const softRange = softness.mul(.5).add(1e-4);
 		const edgeBlend = smoothstep(float(0), softRange, distToEdge);
 		const blendFactor = checkerValue.mul(edgeBlend).add(float(.5).mul(float(1).sub(edgeBlend)));
-		return mixColors(uniforms.colorA.uniform, uniforms.colorB.uniform, blendFactor, uniforms.colorSpace.uniform);
+		return mixColors(uniforms.colorA.uniform, uniforms.colorB.uniform, blendFactor, uniforms.colorSpace.uniform.value);
 	}
 };
 var Checkerboard_default = componentDefinition;

package/dist/core/{Circle-CUYMdgd5.js → Circle-CNU59YUv.js}

@@ -1,5 +1,5 @@
 import { a as transformColor, l as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-B5lM6fYX.js";
-import { t as mixColors } from "./colorMixing-D_wMclqL.js";
+import { t as mixColors } from "./colorMixing-jSm3tbMv.js";
 import { float, length, screenUV, smoothstep, vec2, vec4, viewportSize } from "three/tsl";
 var transformStrokePosition = (value) => {
 	const mode = {
@@ -114,6 +114,7 @@ const componentDefinition = {
 		colorSpace: {
 			default: "linear",
 			transform: transformColorSpace,
+			compileTime: true,
 			description: "Color space for blending fill and stroke colors in soft edges",
 			ui: {
 				type: "select",
@@ -140,7 +141,7 @@ const componentDefinition = {
 		const strokeOuter = isInside.select(circleEdge, isCenter.select(circleEdge.add(halfThickness), circleEdge.add(strokeThickness)));
 		const overallMask = smoothstep(strokeOuter.sub(edgeSoftness), strokeOuter, distanceFromCenter).oneMinus();
 		const strokeBlend = strokeThickness.greaterThan(float(0)).select(smoothstep(strokeInner.sub(edgeSoftness), strokeInner, distanceFromCenter), float(0));
-		const blendedColor = mixColors(vec4(uniforms.color.uniform.rgb, uniforms.color.uniform.a), vec4(uniforms.strokeColor.uniform.rgb, uniforms.strokeColor.uniform.a), strokeBlend, uniforms.colorSpace.uniform);
+		const blendedColor = mixColors(vec4(uniforms.color.uniform.rgb, uniforms.color.uniform.a), vec4(uniforms.strokeColor.uniform.rgb, uniforms.strokeColor.uniform.a), strokeBlend, uniforms.colorSpace.uniform.value);
 		return vec4(blendedColor.xyz, blendedColor.w.mul(overallMask));
 	}
 };

package/dist/core/{ConcentricSpin-DBqXmCjg.js → ConcentricSpin-Dq4fuhxf.js}

@@ -1,4 +1,4 @@
-import { t as applyEdgeHandling } from "./edges-Bd7GP4s2.js";
+import { t as applyEdgeHandling } from "./edges-CfGcQniB.js";
 import { c as transformEdges, l as transformPosition } from "./transformations-B5lM6fYX.js";
 import { t as createAnimatedTime } from "./time-BZqyVJXt.js";
 import { t as unpremultiplyAlpha } from "./alpha-Byel9eTg.js";
@@ -86,6 +86,7 @@ const componentDefinition = {
 			default: "mirror",
 			description: "How to handle edges when distortion pushes content out of bounds",
 			transform: transformEdges,
+			compileTime: true,
 			ui: {
 				type: "select",
 				options: [
@@ -166,7 +167,7 @@ const componentDefinition = {
 			const rotX = dx.mul(cosA).sub(dy.mul(sinA));
 			const rotY = dx.mul(sinA).add(dy.mul(cosA));
 			const distortedUV = vec2(rotX.div(aspect).add(center.x), rotY.add(center.y));
-			return unpremultiplyAlpha(applyEdgeHandling(distortedUV, childTexture.sample(distortedUV), childTexture, uniforms.edges.uniform));
+			return unpremultiplyAlpha(applyEdgeHandling(distortedUV, childTexture.sample(distortedUV), childTexture, uniforms.edges.uniform.value));
 		})();
 	}
 };

package/dist/core/{CursorRipples-JWrDL_dU.js → CursorRipples-CG13qsO5.js}

@@ -1,4 +1,4 @@
-import { t as applyEdgeHandling } from "./edges-Bd7GP4s2.js";
+import { t as applyEdgeHandling } from "./edges-CfGcQniB.js";
 import { c as transformEdges } from "./transformations-B5lM6fYX.js";
 import { t as unpremultiplyAlpha } from "./alpha-Byel9eTg.js";
 import { DataTexture, FloatType, LinearFilter, RGFormat } from "three";
@@ -63,6 +63,7 @@ const componentDefinition = {
 			default: "stretch",
 			description: "How to handle edges when distortion pushes content out of bounds",
 			transform: transformEdges,
+			compileTime: true,
 			ui: {
 				type: "select",
 				options: [
@@ -168,9 +169,9 @@ const componentDefinition = {
 		const rUV = screenUV.sub(clampedDisplacement.mul(float(1).add(chromaticScale)));
 		const gUV = screenUV.sub(clampedDisplacement);
 		const bUV = screenUV.sub(clampedDisplacement.mul(float(1).sub(chromaticScale)));
-		const rSample = applyEdgeHandling(rUV, childTexture.sample(rUV), childTexture, uniforms.edges.uniform);
-		const gSample = applyEdgeHandling(gUV, childTexture.sample(gUV), childTexture, uniforms.edges.uniform);
-		const bSample = applyEdgeHandling(bUV, childTexture.sample(bUV), childTexture, uniforms.edges.uniform);
+		const rSample = applyEdgeHandling(rUV, childTexture.sample(rUV), childTexture, uniforms.edges.uniform.value);
+		const gSample = applyEdgeHandling(gUV, childTexture.sample(gUV), childTexture, uniforms.edges.uniform.value);
+		const bSample = applyEdgeHandling(bUV, childTexture.sample(bUV), childTexture, uniforms.edges.uniform.value);
 		return unpremultiplyAlpha(vec4(rSample.r, gSample.g, bSample.b, gSample.a));
 	}
 };

package/dist/core/{CursorTrail-D2_14ZEz.js → CursorTrail-BBTqzAWC.js}

@@ -1,5 +1,5 @@
 import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-B5lM6fYX.js";
-import { t as mixColors } from "./colorMixing-D_wMclqL.js";
+import { t as mixColors } from "./colorMixing-jSm3tbMv.js";
 import { DataTexture, FloatType, LinearFilter, RGBAFormat } from "three";
 import { float, screenUV, step, texture, vec2, vec4 } from "three/tsl";
 const componentDefinition = {
@@ -66,6 +66,7 @@ const componentDefinition = {
 		colorSpace: {
 			default: "linear",
 			transform: transformColorSpace,
+			compileTime: true,
 			description: "Color space for color interpolation",
 			ui: {
 				type: "select",
@@ -143,7 +144,7 @@ const componentDefinition = {
 		const circleMask = step(float(.01), trailIntensity);
 		const colorA = uniforms.colorA.uniform;
 		const colorB = uniforms.colorB.uniform;
-		const trailColor = mixColors(colorA, colorB, trailAge, uniforms.colorSpace.uniform);
+		const trailColor = mixColors(colorA, colorB, trailAge, uniforms.colorSpace.uniform.value);
 		return vec4(trailColor.rgb, trailColor.a.mul(circleMask));
 	}
 };

package/dist/core/{DiffuseBlur-siJmc-84.js → DiffuseBlur-CpB0j4XW.js}

@@ -1,4 +1,4 @@
-import { t as applyEdgeHandling } from "./edges-Bd7GP4s2.js";
+import { t as applyEdgeHandling } from "./edges-CfGcQniB.js";
 import { c as transformEdges } from "./transformations-B5lM6fYX.js";
 import { t as unpremultiplyAlpha } from "./alpha-Byel9eTg.js";
 import { convertToTexture, dot, fract, screenUV, sin, vec2, vec4, viewportSize } from "three/tsl";
@@ -25,6 +25,7 @@ const componentDefinition = {
 			default: "stretch",
 			description: "How to handle edges when distortion pushes content out of bounds",
 			transform: transformEdges,
+			compileTime: true,
 			ui: {
 				type: "select",
 				options: [
@@ -60,7 +61,7 @@ const componentDefinition = {
 		const sinVal = sin(dot(uv$1.mul(1e3), vec2(25.9796, 156.466)));
 		const offset = fract(vec2(sinVal.mul(43758.5453), sinVal.mul(28461.7231))).mul(2).sub(1).mul(uniforms.intensity.uniform).div(viewportSize);
 		const displacedUV = uv$1.add(offset);
-		return unpremultiplyAlpha(applyEdgeHandling(displacedUV, childTexture.sample(displacedUV), childTexture, uniforms.edges.uniform));
+		return unpremultiplyAlpha(applyEdgeHandling(displacedUV, childTexture.sample(displacedUV), childTexture, uniforms.edges.uniform.value));
 	}
 };
 var DiffuseBlur_default = componentDefinition;

package/dist/core/{Dither-GoyNQ4_v.js → Dither-DO8Q9sfQ.js}

@@ -25,6 +25,7 @@ const componentDefinition = {
 		pattern: {
 			default: "bayer4",
 			transform: transformPattern,
+			compileTime: true,
 			description: "Dithering pattern algorithm",
 			ui: {
 				type: "select",
@@ -97,6 +98,7 @@ const componentDefinition = {
 		colorMode: {
 			default: "custom",
 			transform: transformColorMode,
+			compileTime: true,
 			description: "How colors are determined",
 			ui: {
 				type: "select",
@@ -192,19 +194,38 @@ const componentDefinition = {
 		const pixelatedUV = pixelCoord.add(.5).mul(pixelSize).div(viewportSize);
 		const sourceColor = unpremultiplyAlpha(childTexture.sample(pixelatedUV));
 		const luminance = dot(sourceColor.rgb, vec3(.299, .587, .114)).mul(sourceColor.a);
-		const patternSample = texture(ditherTex).sample(pixelCoord.div(float(DITHER_SIZE)));
-		const blueNoiseCoord = pixelCoord.add(.5);
-		const blueNoiseValue = fract(float(52.9829189).mul(fract(blueNoiseCoord.x.mul(.06711056).add(blueNoiseCoord.y.mul(.00583715)))));
-		const whiteNoiseValue = fract(sin(dot(pixelCoord, vec2(12.9898, 78.233))).mul(43758.5453));
-		const patternIndex = uniforms.pattern.uniform;
-		const ditherValue = patternIndex.equal(0).select(patternSample.r, patternIndex.equal(1).select(patternSample.g, patternIndex.equal(2).select(patternSample.b, patternIndex.equal(3).select(patternSample.a, patternIndex.equal(4).select(blueNoiseValue, whiteNoiseValue)))));
+		let ditherValue;
+		switch (uniforms.pattern.uniform.value) {
+			case 0:
+				ditherValue = texture(ditherTex).sample(pixelCoord.div(float(DITHER_SIZE))).r;
+				break;
+			case 1:
+				ditherValue = texture(ditherTex).sample(pixelCoord.div(float(DITHER_SIZE))).g;
+				break;
+			case 2:
+				ditherValue = texture(ditherTex).sample(pixelCoord.div(float(DITHER_SIZE))).b;
+				break;
+			case 3:
+				ditherValue = texture(ditherTex).sample(pixelCoord.div(float(DITHER_SIZE))).a;
+				break;
+			case 4: {
+				const blueNoiseCoord = pixelCoord.add(.5);
+				ditherValue = fract(float(52.9829189).mul(fract(blueNoiseCoord.x.mul(.06711056).add(blueNoiseCoord.y.mul(.00583715)))));
+				break;
+			}
+			default: ditherValue = fract(sin(dot(pixelCoord, vec2(12.9898, 78.233))).mul(43758.5453));
+		}
 		const ditherResult = step(float(.5).add(ditherValue.sub(.5).mul(spread)), luminance.add(threshold.sub(.5)));
-		const colorModeIndex = uniforms.colorMode.uniform;
-		const customFinalRGB = mix(uniforms.colorA.uniform.rgb, uniforms.colorB.uniform.rgb, ditherResult);
-		const customFinalAlpha = mix(uniforms.colorA.uniform.a, uniforms.colorB.uniform.a, ditherResult);
-		const sourceFinalRGB = mix(sourceColor.rgb.mul(.3), sourceColor.rgb.mul(1.3).min(vec3(1)), ditherResult);
-		const sourceFinalAlpha = sourceColor.a;
-		return vec4(colorModeIndex.equal(0).select(customFinalRGB, sourceFinalRGB), colorModeIndex.equal(0).select(customFinalAlpha, sourceFinalAlpha));
+		let finalRGB;
+		let finalAlpha;
+		if (uniforms.colorMode.uniform.value === 0) {
+			finalRGB = mix(uniforms.colorA.uniform.rgb, uniforms.colorB.uniform.rgb, ditherResult);
+			finalAlpha = mix(uniforms.colorA.uniform.a, uniforms.colorB.uniform.a, ditherResult);
+		} else {
+			finalRGB = mix(sourceColor.rgb.mul(.3), sourceColor.rgb.mul(1.3).min(vec3(1)), ditherResult);
+			finalAlpha = sourceColor.a;
+		}
+		return vec4(finalRGB, finalAlpha);
 	}
 };
 var Dither_default = componentDefinition;

package/dist/core/{Duotone-CRiDL3YN.js → Duotone-CyTYB0rJ.js}

@@ -1,6 +1,6 @@
 import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-B5lM6fYX.js";
 import { t as unpremultiplyAlpha } from "./alpha-Byel9eTg.js";
-import { t as mixColors } from "./colorMixing-D_wMclqL.js";
+import { t as mixColors } from "./colorMixing-jSm3tbMv.js";
 import { convertToTexture, dot, screenUV, smoothstep, vec3, vec4 } from "three/tsl";
 const componentDefinition = {
 	name: "Duotone",
@@ -44,6 +44,7 @@ const componentDefinition = {
 		colorSpace: {
 			default: "linear",
 			transform: transformColorSpace,
+			compileTime: true,
 			description: "Color space for color interpolation",
 			ui: {
 				type: "select",
@@ -62,7 +63,7 @@ const componentDefinition = {
 		const inputColor = unpremultiplyAlpha(childTexture.sample(screenUV));
 		const luminance = dot(inputColor.rgb, vec3(.299, .587, .114));
 		const adjustedLuminance = smoothstep(uniforms.blend.uniform.sub(.5), uniforms.blend.uniform.add(.5), luminance);
-		return vec4(mixColors(uniforms.colorA.uniform, uniforms.colorB.uniform, adjustedLuminance, uniforms.colorSpace.uniform).rgb, inputColor.a);
+		return vec4(mixColors(uniforms.colorA.uniform, uniforms.colorB.uniform, adjustedLuminance, uniforms.colorSpace.uniform.value).rgb, inputColor.a);
 	}
 };
 var Duotone_default = componentDefinition;

package/dist/core/{FlowField-B-sNApu9.js → FlowField-Ynwwfkic.js}

@@ -1,4 +1,4 @@
-import { t as applyEdgeHandling } from "./edges-Bd7GP4s2.js";
+import { t as applyEdgeHandling } from "./edges-CfGcQniB.js";
 import { c as transformEdges } from "./transformations-B5lM6fYX.js";
 import { t as createAnimatedTime } from "./time-BZqyVJXt.js";
 import { t as unpremultiplyAlpha } from "./alpha-Byel9eTg.js";
@@ -50,6 +50,7 @@ const componentDefinition = {
 			default: "mirror",
 			description: "How to handle edges when distortion pushes content out of bounds",
 			transform: transformEdges,
+			compileTime: true,
 			ui: {
 				type: "select",
 				options: [
@@ -101,7 +102,7 @@ const componentDefinition = {
 		const normalizedFlow = combinedFlow.div(flowLength);
 		const finalFlow = vec2(normalizedFlow.x.mul(strength).div(aspect), normalizedFlow.y.mul(strength));
 		const distortedUV = vec2(screenUV.x.add(finalFlow.x), screenUV.y.add(finalFlow.y));
-		return unpremultiplyAlpha(applyEdgeHandling(distortedUV, childTexture.sample(distortedUV), childTexture, uniforms.edges.uniform));
+		return unpremultiplyAlpha(applyEdgeHandling(distortedUV, childTexture.sample(distortedUV), childTexture, uniforms.edges.uniform.value));
 	}
 };
 var FlowField_default = componentDefinition;

package/dist/core/{GridDistortion-CKhOZRpM.js → GridDistortion-C_av0CL_.js}

@@ -1,4 +1,4 @@
-import { t as applyEdgeHandling } from "./edges-Bd7GP4s2.js";
+import { t as applyEdgeHandling } from "./edges-CfGcQniB.js";
 import { c as transformEdges } from "./transformations-B5lM6fYX.js";
 import { t as unpremultiplyAlpha } from "./alpha-Byel9eTg.js";
 import { DataTexture, FloatType, LinearFilter, RGFormat } from "three";
@@ -88,6 +88,7 @@ const componentDefinition = {
 			default: "stretch",
 			description: "How to handle edges when distortion pushes content out of bounds",
 			transform: transformEdges,
+			compileTime: true,
 			ui: {
 				type: "select",
 				options: [
@@ -175,7 +176,7 @@ const componentDefinition = {
 		const negMaxDisplacement = float(-.1);
 		const clampedDisplacement = displacement.clamp(vec2(negMaxDisplacement, negMaxDisplacement), vec2(maxDisplacement, maxDisplacement));
 		const distortedUV = screenUV.sub(clampedDisplacement);
-		return unpremultiplyAlpha(applyEdgeHandling(distortedUV, childTexture.sample(distortedUV), childTexture, uniforms.edges.uniform));
+		return unpremultiplyAlpha(applyEdgeHandling(distortedUV, childTexture.sample(distortedUV), childTexture, uniforms.edges.uniform.value));
 	}
 };
 var GridDistortion_default = componentDefinition;

package/dist/core/{Kaleidoscope-B1mL-Yj3.js → Kaleidoscope-BFoudqX3.js}

@@ -1,4 +1,4 @@
-import { t as applyEdgeHandling } from "./edges-Bd7GP4s2.js";
+import { t as applyEdgeHandling } from "./edges-CfGcQniB.js";
 import { c as transformEdges, l as transformPosition } from "./transformations-B5lM6fYX.js";
 import { t as unpremultiplyAlpha } from "./alpha-Byel9eTg.js";
 import { atan, convertToTexture, cos, float, length, mod, screenUV, sin, vec2, vec4, viewportSize } from "three/tsl";
@@ -50,6 +50,7 @@ const componentDefinition = {
 			default: "mirror",
 			description: "How to handle edges when distortion pushes content out of bounds",
 			transform: transformEdges,
+			compileTime: true,
 			ui: {
 				type: "select",
 				options: [
@@ -95,7 +96,7 @@ const componentDefinition = {
 		const kaleidoscopeDelta = vec2(cos(finalAngle).mul(radius), sin(finalAngle).mul(radius));
 		const kaleidoscopePos = centerPos.add(kaleidoscopeDelta);
 		const finalUV = vec2(kaleidoscopePos.x.div(aspect), kaleidoscopePos.y);
-		return unpremultiplyAlpha(applyEdgeHandling(finalUV, childTexture.sample(finalUV), childTexture, uniforms.edges.uniform));
+		return unpremultiplyAlpha(applyEdgeHandling(finalUV, childTexture.sample(finalUV), childTexture, uniforms.edges.uniform.value));
 	}
 };
 var Kaleidoscope_default = componentDefinition;

package/dist/core/{LinearGradient-BP91wtXm.js → LinearGradient-HhfaMKwI.js}

@@ -1,5 +1,5 @@
 import { a as transformColor, c as transformEdges, l as transformPosition, o as transformColorSpace, r as transformAngle, t as colorSpaceOptions } from "./transformations-B5lM6fYX.js";
-import { t as mixColors } from "./colorMixing-D_wMclqL.js";
+import { t as mixColors } from "./colorMixing-jSm3tbMv.js";
 import { abs, cos, dot, float, fract, length, mod, normalize, radians, screenUV, sin, vec2, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "LinearGradient",
@@ -68,6 +68,7 @@ const componentDefinition = {
 		edges: {
 			default: "stretch",
 			transform: transformEdges,
+			compileTime: true,
 			description: "How to handle areas beyond the gradient endpoints",
 			ui: {
 				type: "select",
@@ -96,6 +97,7 @@ const componentDefinition = {
 		colorSpace: {
 			default: "linear",
 			transform: transformColorSpace,
+			compileTime: true,
 			description: "Color space for color interpolation",
 			ui: {
 				type: "select",
@@ -122,19 +124,30 @@ const componentDefinition = {
 		const aspectCorrectedCentered = vec2(centeredUV.x.mul(aspect), centeredUV.y);
 		const rotatedCorrected = vec2(aspectCorrectedCentered.x.mul(cosAngle).sub(aspectCorrectedCentered.y.mul(sinAngle)), aspectCorrectedCentered.x.mul(sinAngle).add(aspectCorrectedCentered.y.mul(cosAngle)));
 		const t = dot(vec2(rotatedCorrected.x.div(aspect), rotatedCorrected.y).add(midpoint).sub(startPos), gradientDir).div(gradientLength.max(1e-6));
-		const edgeMode = uniforms.edges.uniform;
-		const stretchT = t.clamp(float(0), float(1));
-		const inBoundsX = t.greaterThanEqual(float(0)).select(float(1), float(0));
-		const inBoundsY = t.lessThanEqual(float(1)).select(float(1), float(0));
-		const inBounds = inBoundsX.mul(inBoundsY);
-		const mirrorT = mod(abs(t), float(2));
-		const finalMirrorT = mirrorT.greaterThan(float(1)).select(float(2).sub(mirrorT), mirrorT);
-		const wrapT = fract(t);
-		const isMode1OrHigher = edgeMode.greaterThanEqual(float(.5));
-		const isMode2OrHigher = edgeMode.greaterThanEqual(float(1.5));
-		const finalT = edgeMode.greaterThanEqual(float(2.5)).select(wrapT, isMode2OrHigher.select(finalMirrorT, isMode1OrHigher.select(t, stretchT)));
-		const mixedColor = mixColors(uniforms.colorA.uniform, uniforms.colorB.uniform, finalT.clamp(float(0), float(1)), uniforms.colorSpace.uniform);
-		const finalAlpha = isMode1OrHigher.and(edgeMode.lessThan(float(1.5))).select(mixedColor.w.mul(inBounds), mixedColor.w);
+		const edgeModeValue = uniforms.edges.uniform.value;
+		let finalT;
+		switch (edgeModeValue) {
+			case 1:
+				finalT = t;
+				break;
+			case 2: {
+				const mirrorT = mod(abs(t), float(2));
+				finalT = mirrorT.greaterThan(float(1)).select(float(2).sub(mirrorT), mirrorT);
+				break;
+			}
+			case 3:
+				finalT = fract(t);
+				break;
+			default: finalT = t.clamp(float(0), float(1));
+		}
+		const mixedColor = mixColors(uniforms.colorA.uniform, uniforms.colorB.uniform, finalT.clamp(float(0), float(1)), uniforms.colorSpace.uniform.value);
+		let finalAlpha;
+		if (edgeModeValue === 1) {
+			const inBoundsX = t.greaterThanEqual(float(0)).select(float(1), float(0));
+			const inBoundsY = t.lessThanEqual(float(1)).select(float(1), float(0));
+			const inBounds = inBoundsX.mul(inBoundsY);
+			finalAlpha = mixedColor.w.mul(inBounds);
+		} else finalAlpha = mixedColor.w;
 		return vec4(mixedColor.x, mixedColor.y, mixedColor.z, finalAlpha);
 	}
 };

package/dist/core/{Liquify-2u2lkBhB.js → Liquify-Ad7waFTE.js}

@@ -1,4 +1,4 @@
-import { t as applyEdgeHandling } from "./edges-Bd7GP4s2.js";
+import { t as applyEdgeHandling } from "./edges-CfGcQniB.js";
 import { c as transformEdges } from "./transformations-B5lM6fYX.js";
 import { t as unpremultiplyAlpha } from "./alpha-Byel9eTg.js";
 import { DataTexture, FloatType, LinearFilter, RGFormat } from "three";
@@ -70,6 +70,7 @@ const componentDefinition = {
 			default: "stretch",
 			description: "How to handle edges when distortion pushes content out of bounds",
 			transform: transformEdges,
+			compileTime: true,
 			ui: {
 				type: "select",
 				options: [
@@ -149,7 +150,7 @@ const componentDefinition = {
 		const negMaxDisplacement = float(-.2);
 		const clampedDisplacement = displacement.clamp(vec2(negMaxDisplacement, negMaxDisplacement), vec2(maxDisplacement, maxDisplacement));
 		const distortedUV = screenUV.sub(clampedDisplacement);
-		return unpremultiplyAlpha(applyEdgeHandling(distortedUV, childTexture.sample(distortedUV), childTexture, uniforms.edges.uniform));
+		return unpremultiplyAlpha(applyEdgeHandling(distortedUV, childTexture.sample(distortedUV), childTexture, uniforms.edges.uniform.value));
 	}
 };
 var Liquify_default = componentDefinition;

package/dist/core/{Mirror-BonA1elw.js → Mirror-BgbXJY0N.js}

@@ -1,4 +1,4 @@
-import { t as applyEdgeHandling } from "./edges-Bd7GP4s2.js";
+import { t as applyEdgeHandling } from "./edges-CfGcQniB.js";
 import { c as transformEdges, l as transformPosition } from "./transformations-B5lM6fYX.js";
 import { t as unpremultiplyAlpha } from "./alpha-Byel9eTg.js";
 import { convertToTexture, cos, mix, screenUV, sin, step, vec2, vec4, viewportSize } from "three/tsl";
@@ -38,6 +38,7 @@ const componentDefinition = {
 			default: "mirror",
 			description: "How to handle edges when distortion pushes content out of bounds",
 			transform: transformEdges,
+			compileTime: true,
 			ui: {
 				type: "select",
 				options: [
@@ -81,7 +82,7 @@ const componentDefinition = {
 		const mirroredUV = centerPos.add(reflectedDelta);
 		const finalMirroredUV = vec2(mirroredUV.x.div(aspect), mirroredUV.y);
 		const shouldMirror = step(0, signedDistance);
-		return unpremultiplyAlpha(mix(childTexture.sample(screenUV), applyEdgeHandling(finalMirroredUV, childTexture.sample(finalMirroredUV), childTexture, uniforms.edges.uniform), shouldMirror));
+		return unpremultiplyAlpha(mix(childTexture.sample(screenUV), applyEdgeHandling(finalMirroredUV, childTexture.sample(finalMirroredUV), childTexture, uniforms.edges.uniform.value), shouldMirror));
 	}
 };
 var Mirror_default = componentDefinition;

package/dist/core/{Perspective-Cwpv4683.js → Perspective-BZnZPXEf.js}

@@ -1,4 +1,4 @@
-import { t as applyEdgeHandling } from "./edges-Bd7GP4s2.js";
+import { t as applyEdgeHandling } from "./edges-CfGcQniB.js";
 import { c as transformEdges, l as transformPosition } from "./transformations-B5lM6fYX.js";
 import { t as unpremultiplyAlpha } from "./alpha-Byel9eTg.js";
 import { convertToTexture, cos, float, max, screenUV, sin, tan, vec2, vec4 } from "three/tsl";
@@ -87,6 +87,7 @@ const componentDefinition = {
 			default: "transparent",
 			description: "How to handle edges",
 			transform: transformEdges,
+			compileTime: true,
 			ui: {
 				type: "select",
 				options: [
@@ -138,7 +139,7 @@ const componentDefinition = {
 		const finalY = afterPanY.div(safeTiltDivisor);
 		const offsetPos = vec2(uniforms.offset.uniform.x, uniforms.offset.uniform.y.oneMinus());
 		const finalUV = vec2(finalX, finalY).add(centerPos).sub(offsetPos).add(vec2(.5, .5));
-		return unpremultiplyAlpha(applyEdgeHandling(finalUV, childTexture.sample(finalUV), childTexture, uniforms.edges.uniform));
+		return unpremultiplyAlpha(applyEdgeHandling(finalUV, childTexture.sample(finalUV), childTexture, uniforms.edges.uniform.value));
 	}
 };
 var Perspective_default = componentDefinition;

package/dist/core/{Plasma-BU4ujuLB.js → Plasma-BfyFnIWL.js}

@@ -1,6 +1,6 @@
 import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-B5lM6fYX.js";
 import { t as createAnimatedTime } from "./time-BZqyVJXt.js";
-import { t as mixColors } from "./colorMixing-D_wMclqL.js";
+import { t as mixColors } from "./colorMixing-jSm3tbMv.js";
 import { clamp, exp, float, mx_noise_float, pow, screenUV, vec3, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "Plasma",
@@ -102,6 +102,7 @@ const componentDefinition = {
 		colorSpace: {
 			default: "linear",
 			transform: transformColorSpace,
+			compileTime: true,
 			description: "Color space for color interpolation",
 			ui: {
 				type: "select",
@@ -128,7 +129,7 @@ const componentDefinition = {
 		const contrasted = clamp(pow(mx_noise_float(pos.add(vec3(rx, ry, float(0)).mul(warpAmount))).mul(.5).add(.5), float(5).div(intensity)).sub(.5).mul(uniforms.contrast.uniform).add(.5), 0, 1);
 		const balanceShift = uniforms.balance.uniform.div(100).sub(.5);
 		const balanced = clamp(contrasted.add(balanceShift), 0, 1);
-		return vec4(mixColors(uniforms.colorB.uniform, uniforms.colorA.uniform, balanced, uniforms.colorSpace.uniform), 1);
+		return vec4(mixColors(uniforms.colorB.uniform, uniforms.colorA.uniform, balanced, uniforms.colorSpace.uniform.value), 1);
 	}
 };
 var Plasma_default = componentDefinition;

package/dist/core/{PolarCoordinates-6BZYZFoj.js → PolarCoordinates-IItXQawD.js}

@@ -1,4 +1,4 @@
-import { t as applyEdgeHandling } from "./edges-Bd7GP4s2.js";
+import { t as applyEdgeHandling } from "./edges-CfGcQniB.js";
 import { c as transformEdges, l as transformPosition } from "./transformations-B5lM6fYX.js";
 import { t as unpremultiplyAlpha } from "./alpha-Byel9eTg.js";
 import { PI, atan, convertToTexture, length, mix, screenUV, vec2, vec4, viewportSize } from "three/tsl";
@@ -62,6 +62,7 @@ const componentDefinition = {
 			default: "transparent",
 			description: "How to handle edges when distortion pushes content out of bounds",
 			transform: transformEdges,
+			compileTime: true,
 			ui: {
 				type: "select",
 				options: [
@@ -100,7 +101,7 @@ const componentDefinition = {
 		const normalizedAngle = atan(delta.y, delta.x).add(PI).div(PI.mul(2));
 		const r = length(delta);
 		const blendedUV = mix(screenUV, vec2(normalizedAngle.mul(uniforms.wrap.uniform), r.mul(uniforms.radius.uniform)), uniforms.intensity.uniform);
-		return unpremultiplyAlpha(applyEdgeHandling(blendedUV, childTexture.sample(blendedUV), childTexture, uniforms.edges.uniform));
+		return unpremultiplyAlpha(applyEdgeHandling(blendedUV, childTexture.sample(blendedUV), childTexture, uniforms.edges.uniform.value));
 	}
 };
 var PolarCoordinates_default = componentDefinition;

package/dist/core/{RadialGradient-DauSwpwY.js → RadialGradient-BtLDAPYQ.js}

@@ -1,5 +1,5 @@
 import { a as transformColor, l as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-B5lM6fYX.js";
-import { t as mixColors } from "./colorMixing-D_wMclqL.js";
+import { t as mixColors } from "./colorMixing-jSm3tbMv.js";
 import { distance, float, screenUV, vec2, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "RadialGradient",
@@ -54,6 +54,7 @@ const componentDefinition = {
 		colorSpace: {
 			default: "linear",
 			transform: transformColorSpace,
+			compileTime: true,
 			description: "Color space for color interpolation",
 			ui: {
 				type: "select",
@@ -67,7 +68,7 @@ const componentDefinition = {
 		const uv$1 = screenUV;
 		const aspect = viewportSize.x.div(viewportSize.y);
 		const t = distance(vec2(uv$1.x.mul(aspect), uv$1.y), vec2(uniforms.center.uniform.x.mul(aspect), uniforms.center.uniform.y.oneMinus())).div(uniforms.radius.uniform).clamp(float(0), float(1));
-		return mixColors(uniforms.colorA.uniform, uniforms.colorB.uniform, t, uniforms.colorSpace.uniform);
+		return mixColors(uniforms.colorA.uniform, uniforms.colorB.uniform, t, uniforms.colorSpace.uniform.value);
 	}
 };
 var RadialGradient_default = componentDefinition;