shaders 2.2.25 → 2.2.27

package/dist/core/{LinearGradient-xbloQjzt.js → LinearGradient-DV6UkhZk.js}

@@ -1,6 +1,6 @@
-import { a as transformEdges, i as transformColorSpace, n as transformAngle, o as transformPosition, 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 { a as transformEdges, i as transformColorSpace, n as transformAngle, o as transformPosition, r as transformColor, t as colorSpaceOptions } from "./transformations-Dv5JW9ck.js";
+import { t as mixColors } from "./colorMixing-CZPFmiT4.js";
+import { abs, cos, dot, float, fract, length, mod, normalize, radians, screenUV, sin, vec2, vec4 } from "three/tsl";
 const componentDefinition = {
 	name: "LinearGradient",
 	category: "Base Layers",
@@ -100,33 +100,32 @@ const componentDefinition = {
 		}
 	},
 	fragmentNode: ({ uniforms, uvContext }) => {
-		const { vec2: vec2$1, vec4: vec4$1, float: float$1, cos: cos$1, sin: sin$1, dot: dot$1, radians, screenUV: screenUV$1, length, normalize, abs: abs$1, mod, fract } = TSL;
-		const uv = uvContext ?? screenUV$1;
-		const startPos = vec2$1(uniforms.start.uniform[0], uniforms.start.uniform[1].oneMinus());
-		const endPos = vec2$1(uniforms.end.uniform[0], uniforms.end.uniform[1].oneMinus());
+		const uv$1 = uvContext ?? screenUV;
+		const startPos = vec2(uniforms.start.uniform[0], uniforms.start.uniform[1].oneMinus());
+		const endPos = vec2(uniforms.end.uniform[0], uniforms.end.uniform[1].oneMinus());
 		const gradientVector = endPos.sub(startPos);
 		const gradientLength = length(gradientVector);
 		const gradientDir = normalize(gradientVector);
 		const angleRad = radians(uniforms.angle.uniform).negate();
-		const cosAngle = cos$1(angleRad);
-		const sinAngle = sin$1(angleRad);
+		const cosAngle = cos(angleRad);
+		const sinAngle = sin(angleRad);
 		const midpoint = startPos.add(endPos).mul(.5);
-		const centeredUV = uv.sub(midpoint);
-		const t = dot$1(vec2$1(centeredUV.x.mul(cosAngle).sub(centeredUV.y.mul(sinAngle)), centeredUV.x.mul(sinAngle).add(centeredUV.y.mul(cosAngle))).add(midpoint).sub(startPos), gradientDir).div(gradientLength.max(1e-6));
+		const centeredUV = uv$1.sub(midpoint);
+		const t = dot(vec2(centeredUV.x.mul(cosAngle).sub(centeredUV.y.mul(sinAngle)), centeredUV.x.mul(sinAngle).add(centeredUV.y.mul(cosAngle))).add(midpoint).sub(startPos), gradientDir).div(gradientLength.max(1e-6));
 		const edgeMode = uniforms.edges.uniform;
-		const stretchT = t.clamp(float$1(0), float$1(1));
-		const inBoundsX = t.greaterThanEqual(float$1(0)).select(float$1(1), float$1(0));
-		const inBoundsY = t.lessThanEqual(float$1(1)).select(float$1(1), float$1(0));
+		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$1(t), float$1(2));
-		const finalMirrorT = mirrorT.greaterThan(float$1(1)).select(float$1(2).sub(mirrorT), mirrorT);
+		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$1(.5));
-		const isMode2OrHigher = edgeMode.greaterThanEqual(float$1(1.5));
-		const finalT = edgeMode.greaterThanEqual(float$1(2.5)).select(wrapT, isMode2OrHigher.select(finalMirrorT, isMode1OrHigher.select(t, stretchT)));
-		const mixedColor = mixColors(uniforms.colorA.uniform, uniforms.colorB.uniform, finalT.clamp(float$1(0), float$1(1)), uniforms.colorSpace.uniform);
-		const finalAlpha = isMode1OrHigher.and(edgeMode.lessThan(float$1(1.5))).select(mixedColor.w.mul(inBounds), mixedColor.w);
-		return vec4$1(mixedColor.x, mixedColor.y, mixedColor.z, finalAlpha);
+		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);
+		return vec4(mixedColor.x, mixedColor.y, mixedColor.z, finalAlpha);
 	}
 };
 var LinearGradient_default = componentDefinition;

package/dist/core/{Liquify-DMe1V5-O.js → Liquify-W8UQNeEM.js}

@@ -1,21 +1,21 @@
-import { t as applyEdgeHandling } from "./edges-Bn_OIa_h.js";
-import { a as transformEdges } from "./transformations-DxfQXZWi.js";
+import { t as applyEdgeHandling } from "./edges-Djr_12SL.js";
+import { a as transformEdges } from "./transformations-Dv5JW9ck.js";
 import { DataTexture, FloatType, LinearFilter, RGFormat } from "three";
-import * as TSL from "three/tsl";
+import { convertToTexture, float, screenUV, texture, uniform, vec2, vec4 } from "three/tsl";
 var GRID_SIZE = 32;
 var displacementStateCache = /* @__PURE__ */ new WeakMap();
 var getOrCreateDisplacementState = (uniforms) => {
 	let state = displacementStateCache.get(uniforms);
 	if (!state) {
 		const data = new Float32Array(GRID_SIZE * GRID_SIZE * 2);
-		const texture = new DataTexture(data, GRID_SIZE, GRID_SIZE, RGFormat, FloatType);
-		texture.magFilter = LinearFilter;
-		texture.minFilter = LinearFilter;
-		texture.needsUpdate = true;
+		const dataTexture = new DataTexture(data, GRID_SIZE, GRID_SIZE, RGFormat, FloatType);
+		dataTexture.magFilter = LinearFilter;
+		dataTexture.minFilter = LinearFilter;
+		dataTexture.needsUpdate = true;
 		state = {
-			texture,
+			dataTexture,
 			data,
-			tslNode: TSL.texture(texture),
+			tslNode: texture(dataTexture),
 			initialized: false
 		};
 		displacementStateCache.set(uniforms, state);
@@ -101,18 +101,16 @@ const componentDefinition = {
 			}
 		}
 	},
-	uvTransformNode: ({ uv, uniforms }) => {
-		const { vec2: vec2$1, float: float$1 } = TSL;
-		const displacement = getOrCreateDisplacementState(uniforms).tslNode.sample(uv).xy;
-		const maxDisplacement = float$1(.2);
-		const clampedDisplacement = displacement.clamp(vec2$1(maxDisplacement.negate(), maxDisplacement.negate()), vec2$1(maxDisplacement, maxDisplacement));
-		return uv.sub(clampedDisplacement);
+	uvTransformNode: ({ uv: uv$1, uniforms }) => {
+		const displacement = getOrCreateDisplacementState(uniforms).tslNode.sample(uv$1).xy;
+		const maxDisplacement = float(.2);
+		const clampedDisplacement = displacement.clamp(vec2(maxDisplacement.negate(), maxDisplacement.negate()), vec2(maxDisplacement, maxDisplacement));
+		return uv$1.sub(clampedDisplacement);
 	},
 	fragmentNode: ({ uniforms, onBeforeRender, childNode, onCleanup }) => {
-		const { vec2: vec2$1, vec4: vec4$1, float: float$1, uniform: uniform$1, screenUV: screenUV$1, convertToTexture: convertToTexture$1 } = TSL;
-		const { texture: displacementTexture, data: displacementData, tslNode: displacementField } = getOrCreateDisplacementState(uniforms);
-		const mouseVelX = uniform$1(0);
-		const mouseVelY = uniform$1(0);
+		const { dataTexture: displacementTexture, data: displacementData, tslNode: displacementField } = getOrCreateDisplacementState(uniforms);
+		const mouseVelX = uniform(0);
+		const mouseVelY = uniform(0);
 		let prevX = .5;
 		let prevY = .5;
 		let lastTime = Date.now();
@@ -158,16 +156,16 @@ const componentDefinition = {
 			displacementTexture.dispose();
 			displacementStateCache.delete(uniforms);
 		});
-		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 displacement = displacementField.sample(screenUV$1).xy;
-		const maxDisplacement = float$1(.2);
-		const negMaxDisplacement = float$1(-.2);
-		const clampedDisplacement = displacement.clamp(vec2$1(negMaxDisplacement, negMaxDisplacement), vec2$1(maxDisplacement, maxDisplacement));
-		const distortedUV = screenUV$1.sub(clampedDisplacement);
+		const displacement = displacementField.sample(screenUV).xy;
+		const maxDisplacement = float(.2);
+		const negMaxDisplacement = float(-.2);
+		const clampedDisplacement = displacement.clamp(vec2(negMaxDisplacement, negMaxDisplacement), vec2(maxDisplacement, maxDisplacement));
+		const distortedUV = screenUV.sub(clampedDisplacement);
 		return applyEdgeHandling(distortedUV, childTexture.sample(distortedUV), childTexture, uniforms.edges.uniform);
 	}
 };

package/dist/core/{Pixelate-Cv8537Pj.js → Pixelate-_pyYeLRP.js}

@@ -1,4 +1,4 @@
-import * as TSL from "three/tsl";
+import { convertToTexture, floor, screenUV, vec4 } from "three/tsl";
 const componentDefinition = {
 	name: "Pixelate",
 	category: "Stylize",
@@ -16,20 +16,18 @@ const componentDefinition = {
 			label: "Scale"
 		}
 	} },
-	uvTransformNode: ({ uv, uniforms }) => {
-		const { floor } = TSL;
+	uvTransformNode: ({ uv: uv$1, uniforms }) => {
 		const pixelSize = uniforms.scale.uniform;
-		return floor(uv.mul(pixelSize)).div(pixelSize);
+		return floor(uv$1.mul(pixelSize)).div(pixelSize);
 	},
 	fragmentNode: ({ uniforms, childNode, onCleanup }) => {
-		const { vec4: vec4$1, floor, 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 pixelSize = uniforms.scale.uniform;
-		const pixelatedUV = floor(screenUV$1.mul(pixelSize)).div(pixelSize);
+		const pixelatedUV = floor(screenUV.mul(pixelSize)).div(pixelSize);
 		return childTexture.sample(pixelatedUV);
 	}
 };

package/dist/core/{PolarCoordinates-DDvDhBE-.js → PolarCoordinates-D63xm0oJ.js}

@@ -1,6 +1,6 @@
-import { t as applyEdgeHandling } from "./edges-Bn_OIa_h.js";
-import { a as transformEdges, o as transformPosition } from "./transformations-DxfQXZWi.js";
-import * as TSL from "three/tsl";
+import { t as applyEdgeHandling } from "./edges-Djr_12SL.js";
+import { a as transformEdges, o as transformPosition } from "./transformations-Dv5JW9ck.js";
+import { PI, atan, convertToTexture, length, mix, screenUV, vec2, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "PolarCoordinates",
 	category: "Distortions",
@@ -81,30 +81,28 @@ const componentDefinition = {
 			}
 		}
 	},
-	uvTransformNode: ({ uv, uniforms, viewportSize: viewportSize$1 }) => {
-		const { vec2: vec2$1, length, atan: atan$1, PI, mix: mix$1 } = TSL;
+	uvTransformNode: ({ uv: uv$1, uniforms, viewportSize: viewportSize$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 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 delta = aspectCorrectedUV.sub(centerPos);
-		const normalizedAngle = atan$1(delta.y, delta.x).add(PI).div(PI.mul(2));
+		const normalizedAngle = atan(delta.y, delta.x).add(PI).div(PI.mul(2));
 		const r = length(delta);
-		return mix$1(uv, vec2$1(normalizedAngle.mul(uniforms.wrap.uniform), r.mul(uniforms.radius.uniform)), uniforms.intensity.uniform);
+		return mix(uv$1, vec2(normalizedAngle.mul(uniforms.wrap.uniform), r.mul(uniforms.radius.uniform)), uniforms.intensity.uniform);
 	},
 	fragmentNode: ({ uniforms, childNode, onCleanup }) => {
-		const { vec2: vec2$1, vec4: vec4$1, length, atan: atan$1, screenUV: screenUV$1, viewportSize: viewportSize$1, convertToTexture: convertToTexture$1, PI, mix: mix$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 aspect = viewportSize$1.x.div(viewportSize$1.y);
-		const aspectCorrectedUV = vec2$1(screenUV$1.x.mul(aspect), screenUV$1.y);
-		const centerPos = vec2$1(uniforms.center.uniform.x.mul(aspect), uniforms.center.uniform.y.oneMinus());
+		const aspect = viewportSize.x.div(viewportSize.y);
+		const aspectCorrectedUV = vec2(screenUV.x.mul(aspect), screenUV.y);
+		const centerPos = vec2(uniforms.center.uniform.x.mul(aspect), uniforms.center.uniform.y.oneMinus());
 		const delta = aspectCorrectedUV.sub(centerPos);
-		const normalizedAngle = atan$1(delta.y, delta.x).add(PI).div(PI.mul(2));
+		const normalizedAngle = atan(delta.y, delta.x).add(PI).div(PI.mul(2));
 		const r = length(delta);
-		const blendedUV = mix$1(screenUV$1, vec2$1(normalizedAngle.mul(uniforms.wrap.uniform), r.mul(uniforms.radius.uniform)), uniforms.intensity.uniform);
+		const blendedUV = mix(screenUV, vec2(normalizedAngle.mul(uniforms.wrap.uniform), r.mul(uniforms.radius.uniform)), uniforms.intensity.uniform);
 		return applyEdgeHandling(blendedUV, childTexture.sample(blendedUV), childTexture, uniforms.edges.uniform);
 	}
 };

package/dist/core/{Posterize-3m3xkWOz.js → Posterize-DIjjPS72.js}

@@ -1,5 +1,4 @@
-import * as TSL from "three/tsl";
-import { posterize } from "three/src/nodes/display/PosterizeNode";
+import { float, floor, vec4 } from "three/tsl";
 const componentDefinition = {
 	name: "Posterize",
 	category: "Adjustments",
@@ -17,12 +16,12 @@ const componentDefinition = {
 		}
 	} },
 	fragmentNode: ({ uniforms, childNode }) => {
-		const { vec4: vec4$1, int } = TSL;
 		if (!childNode) {
 			console.error("You must pass a child component into the Posterize shader.");
-			return vec4$1(0);
+			return vec4(0);
 		}
-		return posterize(childNode || vec4$1(0, 0, 0, 0), int(uniforms.intensity.uniform));
+		const steps = float(uniforms.intensity.uniform);
+		return vec4(floor(childNode.r.mul(steps)).div(steps), floor(childNode.g.mul(steps)).div(steps), floor(childNode.b.mul(steps)).div(steps), childNode.a);
 	}
 };
 var Posterize_default = componentDefinition;

package/dist/core/{ProgressiveBlur-EGkevObV.js → ProgressiveBlur-G-s-o9ic.js}

@@ -1,5 +1,5 @@
-import { n as transformAngle, o as transformPosition } from "./transformations-DxfQXZWi.js";
-import * as TSL from "three/tsl";
+import { n as transformAngle, o as transformPosition } from "./transformations-Dv5JW9ck.js";
+import { Fn, convertToTexture, cos, float, max, radians, screenUV, sin, smoothstep, vec2, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "ProgressiveBlur",
 	category: "Blurs",
@@ -55,19 +55,18 @@ const componentDefinition = {
 		}
 	},
 	fragmentNode: ({ uniforms, childNode, onCleanup }) => {
-		const { vec2: vec2$1, vec4: vec4$1, float: float$1, screenUV: screenUV$1, viewportSize: viewportSize$1, sin: sin$1, cos: cos$1, radians, max: max$1, smoothstep, Fn, 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 centerPosition = vec2$1(uniforms.center.uniform[0], uniforms.center.uniform[1].oneMinus());
-		const centeredUV = screenUV$1.sub(centerPosition);
-		const directionalDist = max$1(float$1(0), centeredUV.dot(direction));
-		const falloff = max$1(float$1(.001), uniforms.falloff.uniform);
-		const blurAmount = smoothstep(float$1(0), falloff, directionalDist);
+		const direction = vec2(cos(angleRad), sin(angleRad));
+		const centerPosition = vec2(uniforms.center.uniform[0], uniforms.center.uniform[1].oneMinus());
+		const centeredUV = screenUV.sub(centerPosition);
+		const directionalDist = max(float(0), centeredUV.dot(direction));
+		const falloff = max(float(.001), uniforms.falloff.uniform);
+		const blurAmount = smoothstep(float(0), falloff, directionalDist);
 		const scaledIntensity = uniforms.intensity.uniform.mul(.06);
 		const blurRadius = blurAmount.mul(scaledIntensity);
 		const weights = [
@@ -86,14 +85,14 @@ const componentDefinition = {
 			.056
 		];
 		const weightSum = 6.214;
-		const horizontalTexture = convertToTexture$1(Fn(() => {
-			const uv = screenUV$1;
-			const pixelSize = vec2$1(1).div(viewportSize$1);
-			const total = vec4$1(0).toVar();
+		const horizontalTexture = convertToTexture(Fn(() => {
+			const uv$1 = screenUV;
+			const pixelSize = vec2(1).div(viewportSize);
+			const total = vec4(0).toVar();
 			for (let x = -6; x <= 6; x++) {
-				const weight = float$1(weights[x + 6] / weightSum);
-				const offset = vec2$1(float$1(x), float$1(0)).mul(blurRadius).mul(pixelSize);
-				const sampleCoord = uv.add(offset);
+				const weight = float(weights[x + 6] / weightSum);
+				const offset = vec2(float(x), float(0)).mul(blurRadius).mul(pixelSize);
+				const sampleCoord = uv$1.add(offset);
 				const sample = childTexture.sample(sampleCoord).mul(weight);
 				total.assign(total.add(sample));
 			}
@@ -103,13 +102,13 @@ const componentDefinition = {
 			if (horizontalTexture?.renderTarget?.dispose) horizontalTexture.renderTarget.dispose();
 		});
 		return Fn(() => {
-			const uv = screenUV$1;
-			const pixelSize = vec2$1(1).div(viewportSize$1);
-			const total = vec4$1(0).toVar();
+			const uv$1 = screenUV;
+			const pixelSize = vec2(1).div(viewportSize);
+			const total = vec4(0).toVar();
 			for (let y = -6; y <= 6; y++) {
-				const weight = float$1(weights[y + 6] / weightSum);
-				const offset = vec2$1(float$1(0), float$1(y)).mul(blurRadius).mul(pixelSize);
-				const sampleCoord = uv.add(offset);
+				const weight = float(weights[y + 6] / weightSum);
+				const offset = vec2(float(0), float(y)).mul(blurRadius).mul(pixelSize);
+				const sampleCoord = uv$1.add(offset);
 				const sample = horizontalTexture.sample(sampleCoord).mul(weight);
 				total.assign(total.add(sample));
 			}

package/dist/core/{RadialGradient-B7ZZB_VJ.js → RadialGradient-BGVqSwh0.js}

@@ -1,6 +1,6 @@
-import { i as transformColorSpace, o as transformPosition, 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, o as transformPosition, r as transformColor, t as colorSpaceOptions } from "./transformations-Dv5JW9ck.js";
+import { t as mixColors } from "./colorMixing-CZPFmiT4.js";
+import { distance, float, screenUV, vec2, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "RadialGradient",
 	category: "Base Layers",
@@ -60,10 +60,9 @@ const componentDefinition = {
 		}
 	},
 	fragmentNode: ({ uniforms, uvContext }) => {
-		const { vec2: vec2$1, float: float$1, distance, screenUV: screenUV$1, viewportSize: viewportSize$1 } = TSL;
-		const uv = uvContext ?? screenUV$1;
-		const aspect = viewportSize$1.x.div(viewportSize$1.y);
-		const t = distance(vec2$1(uv.x.mul(aspect), uv.y), vec2$1(uniforms.center.uniform.x.mul(aspect), uniforms.center.uniform.y.oneMinus())).div(uniforms.radius.uniform).clamp(float$1(0), float$1(1));
+		const uv$1 = uvContext ?? 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);
 	}
 };

package/dist/core/{RectangularCoordinates-muWR8mZS.js → RectangularCoordinates-DyHBo456.js}

@@ -1,6 +1,6 @@
-import { t as applyEdgeHandling } from "./edges-Bn_OIa_h.js";
-import { a as transformEdges, o as transformPosition } from "./transformations-DxfQXZWi.js";
-import * as TSL from "three/tsl";
+import { t as applyEdgeHandling } from "./edges-Djr_12SL.js";
+import { a as transformEdges, o as transformPosition } from "./transformations-Dv5JW9ck.js";
+import { PI, convertToTexture, cos, mix, screenUV, sin, vec2, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "RectangularCoordinates",
 	category: "Distortions",
@@ -70,30 +70,28 @@ const componentDefinition = {
 			}
 		}
 	},
-	uvTransformNode: ({ uv, uniforms, viewportSize: viewportSize$1 }) => {
-		const { vec2: vec2$1, cos: cos$1, sin: sin$1, PI, mix: mix$1 } = TSL;
-		const theta = uv.x.mul(PI.mul(2)).sub(PI);
-		const r = uv.y.mul(uniforms.scale.uniform);
-		const rectX = r.mul(cos$1(theta));
-		const rectY = r.mul(sin$1(theta));
+	uvTransformNode: ({ uv: uv$1, uniforms, viewportSize: viewportSize$1 }) => {
+		const theta = uv$1.x.mul(PI.mul(2)).sub(PI);
+		const r = uv$1.y.mul(uniforms.scale.uniform);
+		const rectX = r.mul(cos(theta));
+		const rectY = r.mul(sin(theta));
 		const aspect = viewportSize$1.x.div(viewportSize$1.y);
-		const centerPos = vec2$1(uniforms.center.uniform.x, uniforms.center.uniform.y.oneMinus());
-		return mix$1(uv, vec2$1(rectX.div(aspect).add(centerPos.x), rectY.add(centerPos.y)), uniforms.intensity.uniform);
+		const centerPos = vec2(uniforms.center.uniform.x, uniforms.center.uniform.y.oneMinus());
+		return mix(uv$1, vec2(rectX.div(aspect).add(centerPos.x), rectY.add(centerPos.y)), uniforms.intensity.uniform);
 	},
 	fragmentNode: ({ uniforms, childNode, onCleanup }) => {
-		const { vec2: vec2$1, vec4: vec4$1, cos: cos$1, sin: sin$1, screenUV: screenUV$1, viewportSize: viewportSize$1, convertToTexture: convertToTexture$1, PI, mix: mix$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 theta = screenUV$1.x.mul(PI.mul(2)).sub(PI);
-		const r = screenUV$1.y.mul(uniforms.scale.uniform);
-		const rectX = r.mul(cos$1(theta));
-		const rectY = r.mul(sin$1(theta));
-		const aspect = viewportSize$1.x.div(viewportSize$1.y);
-		const centerPos = vec2$1(uniforms.center.uniform.x, uniforms.center.uniform.y.oneMinus());
-		const blendedUV = mix$1(screenUV$1, vec2$1(rectX.div(aspect).add(centerPos.x), rectY.add(centerPos.y)), uniforms.intensity.uniform);
+		const theta = screenUV.x.mul(PI.mul(2)).sub(PI);
+		const r = screenUV.y.mul(uniforms.scale.uniform);
+		const rectX = r.mul(cos(theta));
+		const rectY = r.mul(sin(theta));
+		const aspect = viewportSize.x.div(viewportSize.y);
+		const centerPos = vec2(uniforms.center.uniform.x, uniforms.center.uniform.y.oneMinus());
+		const blendedUV = mix(screenUV, vec2(rectX.div(aspect).add(centerPos.x), rectY.add(centerPos.y)), uniforms.intensity.uniform);
 		return applyEdgeHandling(blendedUV, childTexture.sample(blendedUV), childTexture, uniforms.edges.uniform);
 	}
 };

package/dist/core/{Ripples-8XaZaXQF.js → Ripples-2FGWCZlp.js}

@@ -1,7 +1,7 @@
 import { t as createAnimatedTime } from "./time-CTJvRUZ4.js";
-import { o as transformPosition, r as transformColor } from "./transformations-DxfQXZWi.js";
-import { t as mixColors } from "./colorMixing-BXiTAqJU.js";
-import * as TSL from "three/tsl";
+import { o as transformPosition, r as transformColor } from "./transformations-Dv5JW9ck.js";
+import { t as mixColors } from "./colorMixing-CZPFmiT4.js";
+import { distance, float, screenUV, sin, smoothstep, vec2, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "Ripples",
 	category: "Base Layers",
@@ -96,8 +96,7 @@ const componentDefinition = {
 	},
 	fragmentNode: (params) => {
 		const { uniforms, uvContext } = params;
-		const { vec2: vec2$1, float: float$1, screenUV: screenUV$1, sin: sin$1, distance, viewportSize: viewportSize$1, smoothstep } = TSL;
-		const uv = uvContext ?? screenUV$1;
+		const uv$1 = uvContext ?? screenUV;
 		const center = uniforms.center.uniform;
 		const colorA = uniforms.colorA.uniform;
 		const colorB = uniforms.colorB.uniform;
@@ -105,12 +104,12 @@ const componentDefinition = {
 		const softness = uniforms.softness.uniform;
 		const thickness = uniforms.thickness.uniform;
 		const phase = uniforms.phase.uniform;
-		const aspect = viewportSize$1.x.div(viewportSize$1.y);
-		const dist = distance(vec2$1(uv.x.mul(aspect), uv.y), vec2$1(center.x.mul(aspect), center.y.oneMinus()));
+		const aspect = viewportSize.x.div(viewportSize.y);
+		const dist = distance(vec2(uv$1.x.mul(aspect), uv$1.y), vec2(center.x.mul(aspect), center.y.oneMinus()));
 		const animTime = createAnimatedTime(params, uniforms.speed);
-		const baseWave = sin$1(dist.mul(frequency).sub(animTime).add(phase));
-		const thicknessThreshold = thickness.mul(float$1(2)).sub(float$1(1));
-		return mixColors(colorB, colorA, smoothstep(thicknessThreshold.add(softness), thicknessThreshold.sub(softness), baseWave), TSL.float(0));
+		const baseWave = sin(dist.mul(frequency).sub(animTime).add(phase));
+		const thicknessThreshold = thickness.mul(float(2)).sub(float(1));
+		return mixColors(colorB, colorA, smoothstep(thicknessThreshold.add(softness), thicknessThreshold.sub(softness), baseWave), float(0));
 	}
 };
 var Ripples_default = componentDefinition;

package/dist/core/{Saturation-CYFI1jzN.js → Saturation-J0nI4hmh.js}

@@ -1,5 +1,4 @@
-import * as TSL from "three/tsl";
-import { saturation } from "three/src/nodes/display/ColorAdjustment";
+import { dot, mix, vec3, vec4 } from "three/tsl";
 const componentDefinition = {
 	name: "Saturation",
 	category: "Adjustments",
@@ -17,13 +16,12 @@ const componentDefinition = {
 		}
 	} },
 	fragmentNode: ({ uniforms, childNode }) => {
-		const { vec4: vec4$1 } = TSL;
 		if (!childNode) {
 			console.error("You must pass a child component into the Saturation shader.");
-			return vec4$1(0);
+			return vec4(0);
 		}
-		const sourceColor = childNode || vec4$1(0, 0, 0, 0);
-		return vec4$1(saturation(sourceColor.rgb, uniforms.intensity.uniform).rgb, sourceColor.a);
+		const luminance = dot(childNode.rgb, vec3(.2126, .7152, .0722));
+		return vec4(mix(vec3(luminance, luminance, luminance), childNode.rgb, uniforms.intensity.uniform), childNode.a);
 	}
 };
 var Saturation_default = componentDefinition;

package/dist/core/{SimplexNoise-DJUe0wz_.js → SimplexNoise-B6dtUCmn.js}

@@ -1,6 +1,6 @@
 import { t as createAnimatedTime } from "./time-CTJvRUZ4.js";
-import { r as transformColor } from "./transformations-DxfQXZWi.js";
-import { t as mixColors } from "./colorMixing-BXiTAqJU.js";
+import { r as transformColor } from "./transformations-Dv5JW9ck.js";
+import { t as mixColors } from "./colorMixing-CZPFmiT4.js";
 import { clamp, exp, float, mx_noise_float, screenUV, vec2, vec3, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "SimplexNoise",
@@ -84,9 +84,9 @@ const componentDefinition = {
 	},
 	fragmentNode: (params) => {
 		const { uniforms, uvContext } = params;
-		const uv = uvContext ?? screenUV;
+		const uv$1 = uvContext ?? screenUV;
 		const aspect = viewportSize.x.div(viewportSize.y);
-		const aspectCorrectedUV = vec2(uv.x.mul(aspect), uv.y);
+		const aspectCorrectedUV = vec2(uv$1.x.mul(aspect), uv$1.y);
 		const animTime = createAnimatedTime(params, uniforms.speed);
 		const pos = aspectCorrectedUV.mul(exp(uniforms.scale.uniform)).add(uniforms.seed.uniform);
 		const noise = mx_noise_float(vec3(pos.x, pos.y, animTime.mul(.5)));

package/dist/core/{SineWave-Dl3nFO1W.js → SineWave-BtPf6-2H.js}

@@ -1,5 +1,5 @@
-import { n as transformAngle, o as transformPosition, r as transformColor } from "./transformations-DxfQXZWi.js";
-import * as TSL from "three/tsl";
+import { n as transformAngle, o as transformPosition, r as transformColor } from "./transformations-Dv5JW9ck.js";
+import { PI, abs, cos, radians, screenUV, sin, smoothstep, time, vec2, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "SineWave",
 	category: "Base Layers",
@@ -96,24 +96,23 @@ const componentDefinition = {
 		}
 	},
 	fragmentNode: ({ uniforms, uvContext }) => {
-		const { vec2: vec2$1, vec4: vec4$1, sin: sin$1, cos: cos$1, abs: abs$1, smoothstep, screenUV: screenUV$1, viewportSize: viewportSize$1, time, radians, PI } = 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.position.uniform.x.mul(aspect), uniforms.position.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.position.uniform.x.mul(aspect), uniforms.position.uniform.y.oneMinus());
 		const centeredUV = aspectCorrectedUV.sub(centerPos);
 		const angleRad = radians(uniforms.angle.uniform);
-		const cosAngle = cos$1(angleRad);
-		const sinAngle = sin$1(angleRad);
+		const cosAngle = cos(angleRad);
+		const sinAngle = sin(angleRad);
 		const rotatedX = centeredUV.x.mul(cosAngle).sub(centeredUV.y.mul(sinAngle));
 		const rotatedY = centeredUV.x.mul(sinAngle).add(centeredUV.y.mul(cosAngle));
 		const animatedTime = time.mul(uniforms.speed.uniform);
-		const sineWave = sin$1(rotatedX.mul(uniforms.frequency.uniform).mul(PI.mul(2)).add(animatedTime)).mul(uniforms.amplitude.uniform);
-		const distanceFromWave = abs$1(rotatedY.sub(sineWave));
+		const sineWave = sin(rotatedX.mul(uniforms.frequency.uniform).mul(PI.mul(2)).add(animatedTime)).mul(uniforms.amplitude.uniform);
+		const distanceFromWave = abs(rotatedY.sub(sineWave));
 		const halfThickness = uniforms.thickness.uniform.mul(.5);
 		const halfSoftness = uniforms.softness.uniform.mul(.5);
 		const waveMask = smoothstep(halfThickness.add(halfSoftness), halfThickness.sub(halfSoftness), distanceFromWave);
-		return vec4$1(uniforms.color.uniform.rgb, uniforms.color.uniform.a.mul(waveMask));
+		return vec4(uniforms.color.uniform.rgb, uniforms.color.uniform.a.mul(waveMask));
 	}
 };
 var SineWave_default = componentDefinition;

package/dist/core/{SolidColor-CWGq_Bjq.js → SolidColor-CETl1cEr.js}

@@ -1,4 +1,4 @@
-import { r as transformColor } from "./transformations-DxfQXZWi.js";
+import { r as transformColor } from "./transformations-Dv5JW9ck.js";
 const componentDefinition = {
 	name: "SolidColor",
 	category: "Base Layers",

package/dist/core/{Spherize-C-jZEUsN.js → Spherize-BwvUcorJ.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 { convertToTexture, dot, float, max, normalize, pow, screenUV, smoothstep, sqrt, vec2, vec3, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "Spherize",
 	category: "Distortions",
@@ -86,42 +86,41 @@ const componentDefinition = {
 		}
 	},
 	fragmentNode: ({ uniforms, childNode, onCleanup }) => {
-		const { vec2: vec2$1, vec3: vec3$1, vec4: vec4$1, float: float$1, screenUV: screenUV$1, convertToTexture: convertToTexture$1, viewportSize: viewportSize$1, sqrt: sqrt$1, max: max$1, smoothstep, pow: pow$1, normalize, 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 uv = screenUV$1;
-		const aspect = viewportSize$1.x.div(viewportSize$1.y);
-		const centerPos = vec2$1(uniforms.center.uniform.x, uniforms.center.uniform.y.oneMinus());
+		const uv$1 = screenUV;
+		const aspect = viewportSize.x.div(viewportSize.y);
+		const centerPos = vec2(uniforms.center.uniform.x, uniforms.center.uniform.y.oneMinus());
 		const radius = uniforms.radius.uniform;
-		const sphereUV = vec2$1(uv.x.sub(centerPos.x).mul(aspect), uv.y.sub(centerPos.y)).mul(2).div(radius);
+		const sphereUV = vec2(uv$1.x.sub(centerPos.x).mul(aspect), uv$1.y.sub(centerPos.y)).mul(2).div(radius);
 		const radiusSq = sphereUV.x.mul(sphereUV.x).add(sphereUV.y.mul(sphereUV.y));
-		const sphereAlpha = float$1(1).sub(smoothstep(float$1(.98), float$1(1), radiusSq));
-		const z = sqrt$1(max$1(float$1(0), float$1(1).sub(radiusSq)));
-		const depthFactor = float$1(1).add(z.mul(uniforms.depth.uniform));
+		const sphereAlpha = float(1).sub(smoothstep(float(.98), float(1), radiusSq));
+		const z = sqrt(max(float(0), float(1).sub(radiusSq)));
+		const depthFactor = float(1).add(z.mul(uniforms.depth.uniform));
 		const finalUV = sphereUV.div(depthFactor).mul(radius).div(2);
-		const transformedUV = vec2$1(finalUV.x.div(aspect).add(centerPos.x), finalUV.y.add(centerPos.y));
+		const transformedUV = vec2(finalUV.x.div(aspect).add(centerPos.x), finalUV.y.add(centerPos.y));
 		const sampledColor = childTexture.sample(transformedUV);
-		const lightPos = vec2$1(uniforms.lightPosition.uniform.x, uniforms.lightPosition.uniform.y.oneMinus());
+		const lightPos = vec2(uniforms.lightPosition.uniform.x, uniforms.lightPosition.uniform.y.oneMinus());
 		const lightIntensity = uniforms.lightIntensity.uniform;
 		const lightSoftness = uniforms.lightSoftness.uniform;
-		const lightColor = vec3$1(uniforms.lightColor.uniform.x, uniforms.lightColor.uniform.y, uniforms.lightColor.uniform.z);
-		const normal = normalize(vec3$1(sphereUV.x, sphereUV.y, z));
-		const viewDir = vec3$1(0, 0, 1);
-		const fresnelPower = float$1(1).add(float$1(4).mul(float$1(1).sub(lightSoftness)));
-		const fresnel = pow$1(float$1(1).sub(max$1(dot$1(normal, viewDir), float$1(0))), fresnelPower);
-		const lightDir2D = vec2$1(lightPos.x.sub(float$1(.5)).mul(2), lightPos.y.sub(float$1(.5)).mul(2));
-		const normalDir = normalize(vec2$1(normal.x, normal.y).add(vec2$1(1e-4, 1e-4)));
-		const lightDirNorm = normalize(lightDir2D.add(vec2$1(1e-4, 1e-4)));
-		const directionalBias = pow$1(max$1(float$1(0), dot$1(normalDir, lightDirNorm)), float$1(2));
-		const rimLight = fresnel.mul(directionalBias).mul(lightIntensity).mul(float$1(2));
+		const lightColor = vec3(uniforms.lightColor.uniform.x, uniforms.lightColor.uniform.y, uniforms.lightColor.uniform.z);
+		const normal = normalize(vec3(sphereUV.x, sphereUV.y, z));
+		const viewDir = vec3(0, 0, 1);
+		const fresnelPower = float(1).add(float(4).mul(float(1).sub(lightSoftness)));
+		const fresnel = pow(float(1).sub(max(dot(normal, viewDir), float(0))), fresnelPower);
+		const lightDir2D = vec2(lightPos.x.sub(float(.5)).mul(2), lightPos.y.sub(float(.5)).mul(2));
+		const normalDir = normalize(vec2(normal.x, normal.y).add(vec2(1e-4, 1e-4)));
+		const lightDirNorm = normalize(lightDir2D.add(vec2(1e-4, 1e-4)));
+		const directionalBias = pow(max(float(0), dot(normalDir, lightDirNorm)), float(2));
+		const rimLight = fresnel.mul(directionalBias).mul(lightIntensity).mul(float(2));
 		const finalR = sampledColor.x.add(lightColor.x.mul(rimLight));
 		const finalG = sampledColor.y.add(lightColor.y.mul(rimLight));
 		const finalB = sampledColor.z.add(lightColor.z.mul(rimLight));
 		const finalA = sampledColor.w.mul(sphereAlpha);
-		return vec4$1(finalR.mul(finalA), finalG.mul(finalA), finalB.mul(finalA), finalA);
+		return vec4(finalR.mul(finalA), finalG.mul(finalA), finalB.mul(finalA), finalA);
 	}
 };
 var Spherize_default = componentDefinition;