shaders 2.2.26 → 2.2.28

package/dist/core/{Checkerboard-BIFNsUYG.js → Checkerboard-SKsXoUXE.js}

@@ -1,6 +1,6 @@
-import { i as transformColorSpace, r as transformColor, t as colorSpaceOptions } from "./transformations-DxfQXZWi.js";
-import { t as mixColors } from "./colorMixing-BXiTAqJU.js";
-import * as TSL from "three/tsl";
+import { i as transformColorSpace, r as transformColor, t as colorSpaceOptions } from "./transformations-Dv5JW9ck.js";
+import { t as mixColors } from "./colorMixing-CZPFmiT4.js";
+import { float, floor, fract, min, mod, screenUV, smoothstep, vec2, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "Checkerboard",
 	category: "Base Layers",
@@ -59,22 +59,21 @@ const componentDefinition = {
 		}
 	},
 	fragmentNode: ({ uniforms, uvContext }) => {
-		const { vec2: vec2$1, float: float$1, floor: floor$1, mod, fract, smoothstep, min: min$1, screenUV: screenUV$1, viewportSize: viewportSize$1 } = TSL;
-		const uv = uvContext ?? screenUV$1;
-		const aspect = viewportSize$1.x.div(viewportSize$1.y);
-		const correctedUV = vec2$1(uv.x.mul(aspect), uv.y.oneMinus());
+		const uv$1 = uvContext ?? screenUV;
+		const aspect = viewportSize.x.div(viewportSize.y);
+		const correctedUV = vec2(uv$1.x.mul(aspect), uv$1.y.oneMinus());
 		const cells = uniforms.cells.uniform;
 		const softness = uniforms.softness.uniform;
 		const gridUV = correctedUV.mul(cells);
-		const gridCoords = floor$1(gridUV);
+		const gridCoords = floor(gridUV);
 		const checkerValue = mod(gridCoords.x.add(gridCoords.y), 2);
 		let blendFactor = checkerValue;
 		if (softness) {
 			const cellUV = fract(gridUV);
-			const distToEdge = min$1(min$1(cellUV.x, float$1(1).sub(cellUV.x)), min$1(cellUV.y, float$1(1).sub(cellUV.y)));
+			const distToEdge = min(min(cellUV.x, float(1).sub(cellUV.x)), min(cellUV.y, float(1).sub(cellUV.y)));
 			const softRange = softness.mul(.5);
-			const edgeBlend = smoothstep(float$1(0), softRange, distToEdge);
-			blendFactor = checkerValue.mul(edgeBlend).add(float$1(.5).mul(float$1(1).sub(edgeBlend)));
+			const edgeBlend = smoothstep(float(0), softRange, distToEdge);
+			blendFactor = checkerValue.mul(edgeBlend).add(float(.5).mul(float(1).sub(edgeBlend)));
 		}
 		return mixColors(uniforms.colorA.uniform, uniforms.colorB.uniform, blendFactor, uniforms.colorSpace.uniform);
 	}

package/dist/core/{ChromaFlow-vRCwhQpN.js → ChromaFlow-VpfgLFbs.js}

@@ -1,6 +1,6 @@
-import { r as transformColor } from "./transformations-DxfQXZWi.js";
+import { r as transformColor } from "./transformations-Dv5JW9ck.js";
 import { DataTexture, FloatType, LinearFilter, RGFormat } from "three";
-import * as TSL from "three/tsl";
+import { float, mix, screenUV, smoothstep, texture, uniform, vec2, vec4 } from "three/tsl";
 const componentDefinition = {
 	name: "ChromaFlow",
 	category: "Interactive",
@@ -86,7 +86,6 @@ const componentDefinition = {
 		}
 	},
 	fragmentNode: ({ uniforms, onBeforeRender, onCleanup }) => {
-		const { vec2: vec2$1, vec4: vec4$1, float: float$1, uniform: uniform$1, screenUV: screenUV$1, texture, smoothstep, mix: mix$1 } = TSL;
 		const GRID_SIZE = 128;
 		const displacementData = new Float32Array(GRID_SIZE * GRID_SIZE * 2);
 		const liquidData = new Float32Array(GRID_SIZE * GRID_SIZE * 2);
@@ -100,10 +99,10 @@ const componentDefinition = {
 		liquidTexture.needsUpdate = true;
 		const displacementField = texture(displacementTexture);
 		const liquidField = texture(liquidTexture);
-		const mouseX = uniform$1(.5);
-		const mouseY = uniform$1(.5);
-		const mouseVelX = uniform$1(0);
-		const mouseVelY = uniform$1(0);
+		const mouseX = uniform(.5);
+		const mouseY = uniform(.5);
+		const mouseVelX = uniform(0);
+		const mouseVelY = uniform(0);
 		let prevX = .5;
 		let prevY = .5;
 		let lastTime = Date.now();
@@ -181,41 +180,41 @@ const componentDefinition = {
 			displacementTexture.dispose();
 			liquidTexture.dispose();
 		});
-		const liquidDensity = liquidField.sample(screenUV$1).x;
-		const pixelSize = vec2$1(float$1(1 / 128), float$1(1 / 128));
-		const sample1 = liquidField.sample(screenUV$1.add(vec2$1(pixelSize.x, float$1(0)))).x;
-		const sample2 = liquidField.sample(screenUV$1.add(vec2$1(float$1(0), pixelSize.y))).x;
-		const sample3 = liquidField.sample(screenUV$1.add(vec2$1(pixelSize.x.negate(), float$1(0)))).x;
-		const sample4 = liquidField.sample(screenUV$1.add(vec2$1(float$1(0), pixelSize.y.negate()))).x;
-		const smoothedLiquid = liquidDensity.add(sample1).add(sample2).add(sample3).add(sample4).mul(float$1(.2));
-		const liquidIntensity = smoothstep(float$1(0), float$1(.1), smoothedLiquid);
-		const flowPixelSize = vec2$1(float$1(1 / 128), float$1(1 / 128));
-		const centerFlow = displacementField.sample(screenUV$1).xy;
-		const flowSample1 = displacementField.sample(screenUV$1.add(vec2$1(flowPixelSize.x, float$1(0)))).xy;
-		const flowSample2 = displacementField.sample(screenUV$1.add(vec2$1(float$1(0), flowPixelSize.y))).xy;
-		const flowSample3 = displacementField.sample(screenUV$1.add(vec2$1(flowPixelSize.x.negate(), float$1(0)))).xy;
-		const flowSample4 = displacementField.sample(screenUV$1.add(vec2$1(float$1(0), flowPixelSize.y.negate()))).xy;
-		const flowVectors = centerFlow.add(flowSample1).add(flowSample2).add(flowSample3).add(flowSample4).mul(float$1(.2));
+		const liquidDensity = liquidField.sample(screenUV).x;
+		const pixelSize = vec2(float(1 / 128), float(1 / 128));
+		const sample1 = liquidField.sample(screenUV.add(vec2(pixelSize.x, float(0)))).x;
+		const sample2 = liquidField.sample(screenUV.add(vec2(float(0), pixelSize.y))).x;
+		const sample3 = liquidField.sample(screenUV.add(vec2(pixelSize.x.negate(), float(0)))).x;
+		const sample4 = liquidField.sample(screenUV.add(vec2(float(0), pixelSize.y.negate()))).x;
+		const smoothedLiquid = liquidDensity.add(sample1).add(sample2).add(sample3).add(sample4).mul(float(.2));
+		const liquidIntensity = smoothstep(float(0), float(.1), smoothedLiquid);
+		const flowPixelSize = vec2(float(1 / 128), float(1 / 128));
+		const centerFlow = displacementField.sample(screenUV).xy;
+		const flowSample1 = displacementField.sample(screenUV.add(vec2(flowPixelSize.x, float(0)))).xy;
+		const flowSample2 = displacementField.sample(screenUV.add(vec2(float(0), flowPixelSize.y))).xy;
+		const flowSample3 = displacementField.sample(screenUV.add(vec2(flowPixelSize.x.negate(), float(0)))).xy;
+		const flowSample4 = displacementField.sample(screenUV.add(vec2(float(0), flowPixelSize.y.negate()))).xy;
+		const flowVectors = centerFlow.add(flowSample1).add(flowSample2).add(flowSample3).add(flowSample4).mul(float(.2));
 		const baseColor = uniforms.baseColor.uniform;
 		const upColor = uniforms.upColor.uniform;
 		const downColor = uniforms.downColor.uniform;
 		const leftColor = uniforms.leftColor.uniform;
 		const rightColor = uniforms.rightColor.uniform;
 		const flowMagnitude = flowVectors.x.mul(flowVectors.x).add(flowVectors.y.mul(flowVectors.y)).sqrt();
-		const hasFlow = smoothstep(float$1(.01), float$1(.1), flowMagnitude);
-		const normalizedX = flowVectors.x.div(flowMagnitude.add(float$1(.001)));
-		const normalizedY = flowVectors.y.div(flowMagnitude.add(float$1(.001)));
-		const rightAmount = smoothstep(float$1(0), float$1(.7), normalizedX.max(float$1(0)));
-		const leftAmount = smoothstep(float$1(0), float$1(.7), normalizedX.negate().max(float$1(0)));
-		const upAmount = smoothstep(float$1(0), float$1(.7), normalizedY.max(float$1(0)));
-		const downAmount = smoothstep(float$1(0), float$1(.7), normalizedY.negate().max(float$1(0)));
+		const hasFlow = smoothstep(float(.01), float(.1), flowMagnitude);
+		const normalizedX = flowVectors.x.div(flowMagnitude.add(float(.001)));
+		const normalizedY = flowVectors.y.div(flowMagnitude.add(float(.001)));
+		const rightAmount = smoothstep(float(0), float(.7), normalizedX.max(float(0)));
+		const leftAmount = smoothstep(float(0), float(.7), normalizedX.negate().max(float(0)));
+		const upAmount = smoothstep(float(0), float(.7), normalizedY.max(float(0)));
+		const downAmount = smoothstep(float(0), float(.7), normalizedY.negate().max(float(0)));
 		const horizontalColor = leftColor.mul(leftAmount).add(rightColor.mul(rightAmount));
 		const verticalColor = downColor.mul(downAmount).add(upColor.mul(upAmount));
 		const horizontalWeight = leftAmount.add(rightAmount);
 		const verticalWeight = upAmount.add(downAmount);
-		const totalWeight = horizontalWeight.add(verticalWeight).add(float$1(.001));
-		const finalColor = mix$1(baseColor, horizontalColor.mul(horizontalWeight.div(totalWeight)).add(verticalColor.mul(verticalWeight.div(totalWeight))), hasFlow);
-		return vec4$1(finalColor.rgb.mul(liquidIntensity), finalColor.a.mul(liquidIntensity));
+		const totalWeight = horizontalWeight.add(verticalWeight).add(float(.001));
+		const finalColor = mix(baseColor, horizontalColor.mul(horizontalWeight.div(totalWeight)).add(verticalColor.mul(verticalWeight.div(totalWeight))), hasFlow);
+		return vec4(finalColor.rgb.mul(liquidIntensity), finalColor.a.mul(liquidIntensity));
 	}
 };
 var ChromaFlow_default = componentDefinition;

package/dist/core/{ChromaticAberration-FTquTQIL.js → ChromaticAberration-CaCyXMyE.js}

@@ -1,5 +1,5 @@
-import { n as transformAngle } from "./transformations-DxfQXZWi.js";
-import * as TSL from "three/tsl";
+import { n as transformAngle } from "./transformations-Dv5JW9ck.js";
+import { convertToTexture, cos, radians, screenUV, sin, vec2, vec4 } from "three/tsl";
 const componentDefinition = {
 	name: "ChromaticAberration",
 	category: "Stylize",
@@ -65,23 +65,22 @@ const componentDefinition = {
 		}
 	},
 	fragmentNode: ({ uniforms, childNode, onCleanup }) => {
-		const { vec2: vec2$1, vec4: vec4$1, cos: cos$1, sin: sin$1, radians, screenUV: screenUV$1, convertToTexture: convertToTexture$1 } = TSL;
-		if (!childNode) return vec4$1(0, 0, 0, 0);
-		const childTexture = convertToTexture$1(childNode);
+		if (!childNode) return vec4(0, 0, 0, 0);
+		const childTexture = convertToTexture(childNode);
 		onCleanup(() => {
 			if (childTexture?.renderTarget?.dispose) childTexture.renderTarget.dispose();
 		});
 		const angleRad = radians(uniforms.angle.uniform);
-		const direction = vec2$1(cos$1(angleRad), sin$1(angleRad));
+		const direction = vec2(cos(angleRad), sin(angleRad));
 		const scaledStrength = uniforms.strength.uniform.mul(.1);
-		const redUV = screenUV$1.add(direction.mul(scaledStrength).mul(uniforms.redOffset.uniform));
-		const greenUV = screenUV$1.add(direction.mul(scaledStrength).mul(uniforms.greenOffset.uniform));
-		const blueUV = screenUV$1.add(direction.mul(scaledStrength).mul(uniforms.blueOffset.uniform));
+		const redUV = screenUV.add(direction.mul(scaledStrength).mul(uniforms.redOffset.uniform));
+		const greenUV = screenUV.add(direction.mul(scaledStrength).mul(uniforms.greenOffset.uniform));
+		const blueUV = screenUV.add(direction.mul(scaledStrength).mul(uniforms.blueOffset.uniform));
 		const redChannel = childTexture.sample(redUV).r;
 		const greenChannel = childTexture.sample(greenUV).g;
 		const blueChannel = childTexture.sample(blueUV).b;
-		const alpha = childTexture.sample(screenUV$1).a;
-		return vec4$1(redChannel, greenChannel, blueChannel, alpha);
+		const alpha = childTexture.sample(screenUV).a;
+		return vec4(redChannel, greenChannel, blueChannel, alpha);
 	}
 };
 var ChromaticAberration_default = componentDefinition;

package/dist/core/{Circle-Daziv5d7.js → Circle-BHnAmzVb.js}

@@ -1,5 +1,5 @@
-import { o as transformPosition, r as transformColor } from "./transformations-DxfQXZWi.js";
-import * as TSL from "three/tsl";
+import { o as transformPosition, r as transformColor } from "./transformations-Dv5JW9ck.js";
+import { length, screenUV, smoothstep, vec2, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "Circle",
 	category: "Base Layers",
@@ -51,16 +51,15 @@ const componentDefinition = {
 		}
 	},
 	fragmentNode: ({ uniforms, uvContext }) => {
-		const { vec2: vec2$1, vec4: vec4$1, length, smoothstep, screenUV: screenUV$1, viewportSize: viewportSize$1 } = TSL;
-		const uv = uvContext ?? screenUV$1;
-		const aspect = viewportSize$1.x.div(viewportSize$1.y);
-		const aspectCorrectedUV = vec2$1(uv.x.mul(aspect), uv.y);
-		const centerPos = vec2$1(uniforms.center.uniform.x.mul(aspect), uniforms.center.uniform.y.oneMinus());
+		const uv$1 = uvContext ?? screenUV;
+		const aspect = viewportSize.x.div(viewportSize.y);
+		const aspectCorrectedUV = vec2(uv$1.x.mul(aspect), uv$1.y);
+		const centerPos = vec2(uniforms.center.uniform.x.mul(aspect), uniforms.center.uniform.y.oneMinus());
 		const distanceFromCenter = length(aspectCorrectedUV.sub(centerPos));
 		const edgeSoftness = uniforms.softness.uniform;
 		const circleEdge = uniforms.radius.uniform.mul(.5);
 		const circleMask = smoothstep(circleEdge, circleEdge.sub(edgeSoftness), distanceFromCenter);
-		return vec4$1(uniforms.color.uniform.rgb, uniforms.color.uniform.a.mul(circleMask));
+		return vec4(uniforms.color.uniform.rgb, uniforms.color.uniform.a.mul(circleMask));
 	}
 };
 var Circle_default = componentDefinition;

package/dist/core/{CursorTrail-Bsz9e6Fn.js → CursorTrail-CfVWIKok.js}

@@ -1,7 +1,7 @@
-import { i as transformColorSpace, r as transformColor, t as colorSpaceOptions } from "./transformations-DxfQXZWi.js";
-import { t as mixColors } from "./colorMixing-BXiTAqJU.js";
+import { i as transformColorSpace, r as transformColor, t as colorSpaceOptions } from "./transformations-Dv5JW9ck.js";
+import { t as mixColors } from "./colorMixing-CZPFmiT4.js";
 import { DataTexture, FloatType, LinearFilter, RGBAFormat } from "three";
-import * as TSL from "three/tsl";
+import { float, screenUV, step, texture, vec2, vec4 } from "three/tsl";
 const componentDefinition = {
 	name: "CursorTrail",
 	category: "Interactive",
@@ -70,7 +70,6 @@ const componentDefinition = {
 		}
 	},
 	fragmentNode: ({ uniforms, onBeforeRender, onCleanup }) => {
-		const { vec4: vec4$1, float: float$1, texture, step: step$1, screenUV: screenUV$1 } = TSL;
 		const GRID_SIZE = 128;
 		const trailData = new Float32Array(GRID_SIZE * GRID_SIZE * 4);
 		const trailTexture = new DataTexture(trailData, GRID_SIZE, GRID_SIZE, RGBAFormat, FloatType);
@@ -86,13 +85,13 @@ const componentDefinition = {
 			const dt = Math.min((currentTime - lastTime) / 1e3, .016);
 			lastTime = currentTime;
 			const radius = uniforms.radius.uniform.value * .1;
-			const length = uniforms.length.uniform.value;
+			const length$1 = uniforms.length.uniform.value;
 			const shrink = uniforms.shrink.uniform.value;
 			const dx = pointer.x - prevX;
 			const dy = pointer.y - prevY;
 			const speed = Math.sqrt(dx * dx + dy * dy);
-			const fadeRate = 1 - dt / Math.max(.1, length);
-			const ageRate = dt / Math.max(.1, length);
+			const fadeRate = 1 - dt / Math.max(.1, length$1);
+			const ageRate = dt / Math.max(.1, length$1);
 			for (let i = 0; i < GRID_SIZE * GRID_SIZE * 4; i += 4) {
 				trailData[i] *= fadeRate;
 				trailData[i + 1] = 1 - (1 - trailData[i]) * shrink;
@@ -126,19 +125,19 @@ const componentDefinition = {
 		onCleanup(() => {
 			trailTexture.dispose();
 		});
-		const pixelSize = float$1(1 / GRID_SIZE);
-		const centerSample = trailField.sample(screenUV$1);
-		const sample1 = trailField.sample(screenUV$1.add(TSL.vec2(pixelSize, float$1(0))));
-		const sample2 = trailField.sample(screenUV$1.add(TSL.vec2(float$1(0), pixelSize)));
-		const sample3 = trailField.sample(screenUV$1.add(TSL.vec2(pixelSize.negate(), float$1(0))));
-		const sample4 = trailField.sample(screenUV$1.add(TSL.vec2(float$1(0), pixelSize.negate())));
-		const trailIntensity = centerSample.x.mul(float$1(.5)).add(sample1.x.mul(float$1(.125))).add(sample2.x.mul(float$1(.125))).add(sample3.x.mul(float$1(.125))).add(sample4.x.mul(float$1(.125)));
-		const trailAge = centerSample.z.mul(float$1(.5)).add(sample1.z.mul(float$1(.125))).add(sample2.z.mul(float$1(.125))).add(sample3.z.mul(float$1(.125))).add(sample4.z.mul(float$1(.125)));
-		const circleMask = step$1(float$1(.01), trailIntensity);
+		const pixelSize = float(1 / GRID_SIZE);
+		const centerSample = trailField.sample(screenUV);
+		const sample1 = trailField.sample(screenUV.add(vec2(pixelSize, float(0))));
+		const sample2 = trailField.sample(screenUV.add(vec2(float(0), pixelSize)));
+		const sample3 = trailField.sample(screenUV.add(vec2(pixelSize.negate(), float(0))));
+		const sample4 = trailField.sample(screenUV.add(vec2(float(0), pixelSize.negate())));
+		const trailIntensity = centerSample.x.mul(float(.5)).add(sample1.x.mul(float(.125))).add(sample2.x.mul(float(.125))).add(sample3.x.mul(float(.125))).add(sample4.x.mul(float(.125)));
+		const trailAge = centerSample.z.mul(float(.5)).add(sample1.z.mul(float(.125))).add(sample2.z.mul(float(.125))).add(sample3.z.mul(float(.125))).add(sample4.z.mul(float(.125)));
+		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);
-		return vec4$1(trailColor.rgb, trailColor.a.mul(circleMask));
+		return vec4(trailColor.rgb, trailColor.a.mul(circleMask));
 	}
 };
 var CursorTrail_default = componentDefinition;

package/dist/core/{DiffuseBlur-Cj2PtRNd.js → DiffuseBlur-GWPb8Zht.js}

@@ -1,6 +1,6 @@
-import { t as applyEdgeHandling } from "./edges-Bn_OIa_h.js";
-import { a as transformEdges } from "./transformations-DxfQXZWi.js";
-import * as TSL from "three/tsl";
+import { t as applyEdgeHandling } from "./edges-Djr_12SL.js";
+import { a as transformEdges } from "./transformations-Dv5JW9ck.js";
+import { convertToTexture, dot, fract, screenUV, sin, vec2, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "DiffuseBlur",
 	category: "Blurs",
@@ -47,35 +47,33 @@ const componentDefinition = {
 			}
 		}
 	},
-	uvTransformNode: ({ uv, uniforms, viewportSize: viewportSize$1 }) => {
-		const { vec2: vec2$1, fract, sin: sin$1, dot: dot$1 } = TSL;
+	uvTransformNode: ({ uv: uv$1, uniforms, viewportSize: viewportSize$1 }) => {
 		const hash = (p) => {
-			return fract(sin$1(dot$1(p, vec2$1(12.9898, 78.233).mul(2))).mul(43758.5453));
+			return fract(sin(dot(p, vec2(12.9898, 78.233).mul(2))).mul(43758.5453));
 		};
-		const pixelSize = vec2$1(1).div(viewportSize$1);
-		const seed = uv.mul(1e3);
+		const pixelSize = vec2(1).div(viewportSize$1);
+		const seed = uv$1.mul(1e3);
 		const rand1 = hash(seed);
-		const rand2 = hash(seed.add(vec2$1(73.2, 41.9)));
-		const offset = vec2$1(rand1.mul(2).sub(1), rand2.mul(2).sub(1)).mul(uniforms.intensity.uniform).mul(pixelSize);
-		return uv.add(offset);
+		const rand2 = hash(seed.add(vec2(73.2, 41.9)));
+		const offset = vec2(rand1.mul(2).sub(1), rand2.mul(2).sub(1)).mul(uniforms.intensity.uniform).mul(pixelSize);
+		return uv$1.add(offset);
 	},
 	fragmentNode: ({ uniforms, childNode, onCleanup }) => {
-		const { vec2: vec2$1, vec4: vec4$1, screenUV: screenUV$1, convertToTexture: convertToTexture$1, viewportSize: viewportSize$1, fract, sin: sin$1, dot: dot$1 } = TSL;
-		if (!childNode) return vec4$1(0, 0, 0, 0);
-		const childTexture = convertToTexture$1(childNode);
+		if (!childNode) return vec4(0, 0, 0, 0);
+		const childTexture = convertToTexture(childNode);
 		onCleanup(() => {
 			if (childTexture?.renderTarget?.dispose) childTexture.renderTarget.dispose();
 		});
 		const hash = (p) => {
-			return fract(sin$1(dot$1(p, vec2$1(12.9898, 78.233).mul(2))).mul(43758.5453));
+			return fract(sin(dot(p, vec2(12.9898, 78.233).mul(2))).mul(43758.5453));
 		};
-		const uv = screenUV$1;
-		const pixelSize = vec2$1(1).div(viewportSize$1);
-		const seed = uv.mul(1e3);
+		const uv$1 = screenUV;
+		const pixelSize = vec2(1).div(viewportSize);
+		const seed = uv$1.mul(1e3);
 		const rand1 = hash(seed);
-		const rand2 = hash(seed.add(vec2$1(73.2, 41.9)));
-		const offset = vec2$1(rand1.mul(2).sub(1), rand2.mul(2).sub(1)).mul(uniforms.intensity.uniform).mul(pixelSize);
-		const displacedUV = uv.add(offset);
+		const rand2 = hash(seed.add(vec2(73.2, 41.9)));
+		const offset = vec2(rand1.mul(2).sub(1), rand2.mul(2).sub(1)).mul(uniforms.intensity.uniform).mul(pixelSize);
+		const displacedUV = uv$1.add(offset);
 		return applyEdgeHandling(displacedUV, childTexture.sample(displacedUV), childTexture, uniforms.edges.uniform);
 	}
 };

package/dist/core/{Dither-Cq8j0QIU.js → Dither-BNEeyo0u.js}

@@ -1,5 +1,5 @@
-import { r as transformColor } from "./transformations-DxfQXZWi.js";
-import * as TSL from "three/tsl";
+import { r as transformColor } from "./transformations-Dv5JW9ck.js";
+import { dot, floor, mix, screenUV, step, vec2, vec3, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "Dither",
 	category: "Stylize",
@@ -48,18 +48,17 @@ const componentDefinition = {
 		}
 	},
 	fragmentNode: ({ uniforms, childNode }) => {
-		const { vec2: vec2$1, vec3: vec3$1, vec4: vec4$1, floor: floor$1, screenUV: screenUV$1, viewportSize: viewportSize$1, dot: dot$1, step: step$1, mix: mix$1 } = TSL;
-		if (!childNode) return vec4$1(0, 0, 0, 0);
+		if (!childNode) return vec4(0, 0, 0, 0);
 		const sourceColor = childNode;
-		const luminance = dot$1(sourceColor.rgb, vec3$1(.299, .587, .114)).mul(sourceColor.a);
+		const luminance = dot(sourceColor.rgb, vec3(.299, .587, .114)).mul(sourceColor.a);
 		const pixelSize = uniforms.pixelSize.uniform;
-		const bayerPos = floor$1(screenUV$1.mul(viewportSize$1).div(pixelSize)).mod(vec2$1(4));
+		const bayerPos = floor(screenUV.mul(viewportSize).div(pixelSize)).mod(vec2(4));
 		const x = bayerPos.x;
 		const y = bayerPos.y;
 		const bayerValue = y.equal(0).select(x.equal(0).select(0 / 16, x.equal(1).select(8 / 16, x.equal(2).select(2 / 16, 10 / 16))), y.equal(1).select(x.equal(0).select(12 / 16, x.equal(1).select(4 / 16, x.equal(2).select(14 / 16, 6 / 16))), y.equal(2).select(x.equal(0).select(3 / 16, x.equal(1).select(11 / 16, x.equal(2).select(1 / 16, 9 / 16))), x.equal(0).select(15 / 16, x.equal(1).select(7 / 16, x.equal(2).select(13 / 16, 5 / 16))))));
 		const threshold = uniforms.threshold.uniform;
-		const ditherResult = step$1(bayerValue, luminance.add(threshold.sub(.5)));
-		return vec4$1(mix$1(uniforms.colorA.uniform.rgb, uniforms.colorB.uniform.rgb, ditherResult), mix$1(uniforms.colorA.uniform.a, uniforms.colorB.uniform.a, ditherResult));
+		const ditherResult = step(bayerValue, luminance.add(threshold.sub(.5)));
+		return vec4(mix(uniforms.colorA.uniform.rgb, uniforms.colorB.uniform.rgb, ditherResult), mix(uniforms.colorA.uniform.a, uniforms.colorB.uniform.a, ditherResult));
 	}
 };
 var Dither_default = componentDefinition;

package/dist/core/{DotGrid-BHfQ3hcI.js → DotGrid-CRRS6nbt.js}

@@ -1,5 +1,5 @@
-import { r as transformColor } from "./transformations-DxfQXZWi.js";
-import * as TSL from "three/tsl";
+import { r as transformColor } from "./transformations-Dv5JW9ck.js";
+import { float, floor, fwidth, length, mix, screenUV, sin, smoothstep, time, vec2, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "DotGrid",
 	category: "Base Layers",
@@ -50,25 +50,24 @@ const componentDefinition = {
 		}
 	},
 	fragmentNode: ({ uniforms, uvContext }) => {
-		const { screenUV: screenUV$1, vec4: vec4$1, vec2: vec2$1, smoothstep, length, floor: floor$1, float: float$1, viewportSize: viewportSize$1, time, sin: sin$1, mix: mix$1 } = TSL;
-		const uvCoords = uvContext ?? screenUV$1;
+		const uvCoords = uvContext ?? screenUV;
 		const density = uniforms.density.uniform;
 		const dotSize = uniforms.dotSize.uniform;
 		const dotColor = uniforms.color.uniform;
 		const twinkleIntensity = uniforms.twinkle.uniform;
-		const resolution = viewportSize$1;
+		const resolution = viewportSize;
 		const aspect = resolution.x.div(resolution.y);
-		const correctedUV = vec2$1(uvCoords.x.mul(aspect), uvCoords.y.oneMinus());
+		const correctedUV = vec2(uvCoords.x.mul(aspect), uvCoords.y.oneMinus());
 		const gridUV = correctedUV.mul(density);
-		const centerDistance = length(gridUV.sub(floor$1(gridUV)).sub(.5));
-		const pixelSize = length(TSL.fwidth(correctedUV.mul(density)));
-		const dot$1 = float$1(1).sub(smoothstep(dotSize.mul(.5), dotSize.mul(.5).add(pixelSize.mul(.5)), centerDistance));
-		const gridPosition = floor$1(gridUV);
+		const centerDistance = length(gridUV.sub(floor(gridUV)).sub(.5));
+		const pixelSize = length(fwidth(correctedUV.mul(density)));
+		const dot$1 = float(1).sub(smoothstep(dotSize.mul(.5), dotSize.mul(.5).add(pixelSize.mul(.5)), centerDistance));
+		const gridPosition = floor(gridUV);
 		const dotPhase = gridPosition.x.mul(12.9898).add(gridPosition.y.mul(78.233)).sin().mul(43758.5453).fract();
-		const twinkleValue = sin$1(time.mul(2).add(dotPhase.mul(6.28318))).mul(.5).add(.5);
-		const twinkleModifier = mix$1(float$1(1), twinkleValue, twinkleIntensity);
+		const twinkleValue = sin(time.mul(2).add(dotPhase.mul(6.28318))).mul(.5).add(.5);
+		const twinkleModifier = mix(float(1), twinkleValue, twinkleIntensity);
 		const twinkledAlpha = dot$1.mul(twinkleModifier);
-		return vec4$1(dotColor.rgb, twinkledAlpha);
+		return vec4(dotColor.rgb, twinkledAlpha);
 	}
 };
 var DotGrid_default = componentDefinition;

package/dist/core/{Duotone-XuTN9tI7.js → Duotone-5gKND3an.js}

@@ -1,6 +1,6 @@
-import { i as transformColorSpace, r as transformColor, t as colorSpaceOptions } from "./transformations-DxfQXZWi.js";
-import { t as mixColors } from "./colorMixing-BXiTAqJU.js";
-import * as TSL from "three/tsl";
+import { i as transformColorSpace, r as transformColor, t as colorSpaceOptions } from "./transformations-Dv5JW9ck.js";
+import { t as mixColors } from "./colorMixing-CZPFmiT4.js";
+import { convertToTexture, dot, screenUV, smoothstep, vec3, vec4 } from "three/tsl";
 const componentDefinition = {
 	name: "Duotone",
 	category: "Adjustments",
@@ -49,16 +49,15 @@ const componentDefinition = {
 		}
 	},
 	fragmentNode: ({ uniforms, childNode, onCleanup }) => {
-		const { vec3: vec3$1, vec4: vec4$1, dot: dot$1, smoothstep, screenUV: screenUV$1, convertToTexture: convertToTexture$1 } = TSL;
-		if (!childNode) return vec4$1(0, 0, 0, 0);
-		const childTexture = convertToTexture$1(childNode);
+		if (!childNode) return vec4(0, 0, 0, 0);
+		const childTexture = convertToTexture(childNode);
 		onCleanup(() => {
 			if (childTexture?.renderTarget?.dispose) childTexture.renderTarget.dispose();
 		});
-		const inputColor = childTexture.sample(screenUV$1);
-		const luminance = dot$1(inputColor.rgb, vec3$1(.299, .587, .114));
+		const inputColor = 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$1(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).rgb, inputColor.a);
 	}
 };
 var Duotone_default = componentDefinition;

package/dist/core/{FilmGrain-D3-nbi12.js → FilmGrain-osBGk_b9.js}

@@ -1,4 +1,4 @@
-import * as TSL from "three/tsl";
+import { dot, float, fract, screenUV, sin, vec2, vec4 } from "three/tsl";
 const componentDefinition = {
 	name: "FilmGrain",
 	category: "Stylize",
@@ -17,11 +17,10 @@ const componentDefinition = {
 		}
 	} },
 	fragmentNode: ({ uniforms, childNode, uvContext }) => {
-		const { vec2: vec2$1, vec4: vec4$1, float: float$1, screenUV: screenUV$1, sin: sin$1, dot: dot$1, fract } = TSL;
 		const strength = uniforms.strength.uniform;
-		const sourceColor = childNode || vec4$1(0, 0, 0, 0);
-		const grainIntensity = fract(sin$1(dot$1(uvContext ?? screenUV$1, vec2$1(float$1(12.9898), float$1(78.233)).mul(float$1(2)))).mul(float$1(43758.5453))).mul(float$1(2)).sub(float$1(1)).mul(strength.mul(float$1(.1)));
-		return vec4$1(sourceColor.rgb.add(grainIntensity), sourceColor.a);
+		const sourceColor = childNode || vec4(0, 0, 0, 0);
+		const grainIntensity = fract(sin(dot(uvContext ?? screenUV, vec2(float(12.9898), float(78.233)).mul(float(2)))).mul(float(43758.5453))).mul(float(2)).sub(float(1)).mul(strength.mul(float(.1)));
+		return vec4(sourceColor.rgb.add(grainIntensity), sourceColor.a);
 	}
 };
 var FilmGrain_default = componentDefinition;

package/dist/core/{FloatingParticles-CP6GqC3k.js → FloatingParticles-CULOurGT.js}

@@ -1,24 +1,23 @@
-import { r as transformColor } from "./transformations-DxfQXZWi.js";
-import * as TSL from "three/tsl";
-var { vec2: vec2$1, vec3: vec3$1, vec4: vec4$1, float: float$1, sin: sin$1, cos: cos$1, smoothstep, mix: mix$1, min: min$1, floor: floor$1, fract, length, dot: dot$1, screenUV: screenUV$1, viewportSize: viewportSize$1, time, Fn } = TSL;
+import { r as transformColor } from "./transformations-Dv5JW9ck.js";
+import { Fn, cos, dot, float, floor, fract, length, min, mix, screenUV, sin, smoothstep, time, vec2, vec3, vec4, viewportSize } from "three/tsl";
 var hash1_2 = Fn(([p]) => {
-	return fract(sin$1(dot$1(p, vec2$1(127.1, 311.7))).mul(43758.5453123));
+	return fract(sin(dot(p, vec2(127.1, 311.7))).mul(43758.5453123));
 });
 var hash2_2 = Fn(([p]) => {
-	return fract(sin$1(vec2$1(dot$1(p, vec2$1(127.1, 311.7)), dot$1(p, vec2$1(269.5, 183.3)))).mul(43758.5453));
+	return fract(sin(vec2(dot(p, vec2(127.1, 311.7)), dot(p, vec2(269.5, 183.3)))).mul(43758.5453));
 });
 var voronoiPointFromRoot = Fn(([root, deg]) => {
 	const point = hash2_2(root).sub(.5);
-	const s = sin$1(deg);
-	const c = cos$1(deg);
-	return vec2$1(c.mul(point.x).sub(s.mul(point.y)).mul(.66), s.mul(point.x).add(c.mul(point.y)).mul(.66)).add(root).add(.5);
+	const s = sin(deg);
+	const c = cos(deg);
+	return vec2(c.mul(point.x).sub(s.mul(point.y)).mul(.66), s.mul(point.x).add(c.mul(point.y)).mul(.66)).add(root).add(.5);
 });
-var degFromRootUV = Fn(([uv, randomness]) => {
-	return time.mul(randomness).mul(hash1_2(uv).sub(.5)).mul(2);
+var degFromRootUV = Fn(([uv$1, randomness]) => {
+	return time.mul(randomness).mul(hash1_2(uv$1).sub(.5)).mul(2);
 });
-var getParticleDistance = Fn(([uv, cellUV, randomness]) => {
+var getParticleDistance = Fn(([uv$1, cellUV, randomness]) => {
 	const pointUV = voronoiPointFromRoot(cellUV, degFromRootUV(cellUV, randomness));
-	return length(uv.sub(pointUV));
+	return length(uv$1.sub(pointUV));
 });
 const componentDefinition = {
 	name: "FloatingParticles",
@@ -148,11 +147,11 @@ const componentDefinition = {
 		}
 	},
 	fragmentNode: ({ uniforms, childNode, uvContext }) => {
-		const baseUV = uvContext ?? screenUV$1;
-		const renderParticle = Fn(([uv$1]) => {
-			const rootUV = floor$1(uv$1);
-			const localPos = fract(uv$1);
-			let minDist = getParticleDistance(uv$1, rootUV, uniforms.randomness.uniform);
+		const baseUV = uvContext ?? screenUV;
+		const renderParticle = Fn(([uv$2]) => {
+			const rootUV = floor(uv$2);
+			const localPos = fract(uv$2);
+			let minDist = getParticleDistance(uv$2, rootUV, uniforms.randomness.uniform);
 			const softness = uniforms.particleSoftness.uniform;
 			const scaledSize = uniforms.particleSize.uniform.mul(.01);
 			const outerRadius = scaledSize.mul(.6).add(softness.mul(scaledSize.mul(2.4)));
@@ -165,52 +164,52 @@ const componentDefinition = {
 			const checkRight = needsNeighbors.and(nearRight);
 			const checkTop = needsNeighbors.and(nearTop);
 			const checkBottom = needsNeighbors.and(nearBottom);
-			minDist = checkLeft.select(min$1(minDist, getParticleDistance(uv$1, rootUV.add(vec2$1(-1, 0)), uniforms.randomness.uniform)), minDist);
-			minDist = checkRight.select(min$1(minDist, getParticleDistance(uv$1, rootUV.add(vec2$1(1, 0)), uniforms.randomness.uniform)), minDist);
-			minDist = checkTop.select(min$1(minDist, getParticleDistance(uv$1, rootUV.add(vec2$1(0, -1)), uniforms.randomness.uniform)), minDist);
-			minDist = checkBottom.select(min$1(minDist, getParticleDistance(uv$1, rootUV.add(vec2$1(0, 1)), uniforms.randomness.uniform)), minDist);
+			minDist = checkLeft.select(min(minDist, getParticleDistance(uv$2, rootUV.add(vec2(-1, 0)), uniforms.randomness.uniform)), minDist);
+			minDist = checkRight.select(min(minDist, getParticleDistance(uv$2, rootUV.add(vec2(1, 0)), uniforms.randomness.uniform)), minDist);
+			minDist = checkTop.select(min(minDist, getParticleDistance(uv$2, rootUV.add(vec2(0, -1)), uniforms.randomness.uniform)), minDist);
+			minDist = checkBottom.select(min(minDist, getParticleDistance(uv$2, rootUV.add(vec2(0, 1)), uniforms.randomness.uniform)), minDist);
 			const baseIntensity = smoothstep(outerRadius, scaledSize.mul(.6), minDist);
 			const twinkleIntensity = uniforms.twinkle.uniform;
 			const particlePhase = rootUV.x.mul(12.9898).add(rootUV.y.mul(78.233)).sin().mul(43758.5453).fract();
-			const twinkleValue = sin$1(time.mul(2).add(particlePhase.mul(6.28318))).mul(.5).add(.5);
-			const twinkleModifier = mix$1(float$1(1), twinkleValue, twinkleIntensity);
+			const twinkleValue = sin(time.mul(2).add(particlePhase.mul(6.28318))).mul(.5).add(.5);
+			const twinkleModifier = mix(float(1), twinkleValue, twinkleIntensity);
 			return baseIntensity.mul(twinkleModifier).mul(uniforms.particleColor.uniform.rgb);
 		});
-		const layeredParticles = Fn(([uv$1]) => {
-			const sizeMod = float$1(1.05);
-			const alphaMod = float$1(.9);
+		const layeredParticles = Fn(([uv$2]) => {
+			const sizeMod = float(1.05);
+			const alphaMod = float(.9);
 			const layers = uniforms.count.uniform;
-			const particles$1 = vec3$1(0).toVar();
-			const size = float$1(1).toVar();
-			const alpha = float$1(1).toVar();
-			const offset = vec2$1(0).toVar();
+			const particles$1 = vec3(0).toVar();
+			const size = float(1).toVar();
+			const alpha = float(1).toVar();
+			const offset = vec2(0).toVar();
 			const angleRad = uniforms.angle.uniform.mul(3.14159).div(180);
-			const baseMovementDir = vec2$1(cos$1(angleRad), sin$1(angleRad));
+			const baseMovementDir = vec2(cos(angleRad), sin(angleRad));
 			const baseMovement = time.mul(baseMovementDir).mul(uniforms.speed.uniform);
 			const speedVar = uniforms.speedVariance.uniform;
 			const angleVar = uniforms.angleVariance.uniform.mul(3.14159).div(180);
 			for (let i = 0; i < 4; i++) {
-				const layerActive = float$1(i).lessThan(layers).and(alpha.greaterThan(.02));
-				const layerHash = hash2_2(vec2$1(alpha, float$1(i).mul(7.919)));
-				const speedMod = float$1(1).add(layerHash.x.sub(.5).mul(speedVar));
+				const layerActive = float(i).lessThan(layers).and(alpha.greaterThan(.02));
+				const layerHash = hash2_2(vec2(alpha, float(i).mul(7.919)));
+				const speedMod = float(1).add(layerHash.x.sub(.5).mul(speedVar));
 				const angleDelta = layerHash.y.sub(.5).mul(angleVar).mul(2);
 				const variedAngle = angleRad.add(angleDelta);
-				const variedDir = vec2$1(cos$1(variedAngle), sin$1(variedAngle));
+				const variedDir = vec2(cos(variedAngle), sin(variedAngle));
 				const movement = baseMovement.mul(speedMod).add(variedDir.sub(baseMovementDir).mul(time).mul(uniforms.speed.uniform));
-				const layerParticles = renderParticle(uv$1.mul(size).add(movement).add(offset)).mul(alpha);
-				particles$1.assign(particles$1.add(layerActive.select(layerParticles, vec3$1(0))));
+				const layerParticles = renderParticle(uv$2.mul(size).add(movement).add(offset)).mul(alpha);
+				particles$1.assign(particles$1.add(layerActive.select(layerParticles, vec3(0))));
 				offset.assign(offset.add(layerHash.mul(10)));
 				alpha.assign(alpha.mul(alphaMod));
 				size.assign(size.mul(sizeMod));
 			}
 			return particles$1;
 		});
-		const uv = baseUV.mul(2).sub(1);
-		const aspectRatio = viewportSize$1.x.div(viewportSize$1.y);
-		const particles = layeredParticles(vec2$1(uv.x.mul(aspectRatio), uv.y).mul(uniforms.particleDensity.uniform));
+		const uv$1 = baseUV.mul(2).sub(1);
+		const aspectRatio = viewportSize.x.div(viewportSize.y);
+		const particles = layeredParticles(vec2(uv$1.x.mul(aspectRatio), uv$1.y).mul(uniforms.particleDensity.uniform));
 		const particleAlpha = length(particles);
-		if (childNode) return vec4$1(mix$1(childNode.xyz, particles, particleAlpha.greaterThan(.01).select(particleAlpha, 0)), childNode.w);
-		return vec4$1(particles, particleAlpha);
+		if (childNode) return vec4(mix(childNode.xyz, particles, particleAlpha.greaterThan(.01).select(particleAlpha, 0)), childNode.w);
+		return vec4(particles, particleAlpha);
 	}
 };
 var FloatingParticles_default = componentDefinition;