shaders 2.2.26 → 2.2.28

package/dist/core/{Strands-0stO5BMy.js → Strands-CV1oCmHx.js}

@@ -1,6 +1,6 @@
 import { t as createAnimatedTime } from "./time-CTJvRUZ4.js";
-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 { Fn, abs, cos, float, max, mix, screenUV, smoothstep, vec2, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "Strands",
 	category: "Base Layers",
@@ -108,52 +108,51 @@ const componentDefinition = {
 	},
 	fragmentNode: (params) => {
 		const { uniforms, uvContext } = params;
-		const { vec2: vec2$1, vec4: vec4$1, cos: cos$1, abs: abs$1, smoothstep, mix: mix$1, max: max$1, screenUV: screenUV$1, viewportSize: viewportSize$1, float: float$1, Fn } = TSL;
-		const baseUV = uvContext ?? screenUV$1;
+		const baseUV = uvContext ?? screenUV;
 		const t = createAnimatedTime(params, uniforms.speed);
-		const random = Fn(([time]) => {
-			return cos$1(time).add(cos$1(time.mul(1.2).add(1.6))).add(cos$1(time.mul(1.4).add(1.5))).div(3);
+		const random = Fn(([time$1]) => {
+			return cos(time$1).add(cos(time$1.mul(1.2).add(1.6))).add(cos(time$1.mul(1.4).add(1.5))).div(3);
 		});
-		return Fn(([uv]) => {
-			const aspectRatio = viewportSize$1.x.div(viewportSize$1.y);
-			const startPos = vec2$1(uniforms.start.uniform.x.mul(aspectRatio), uniforms.start.uniform.y.oneMinus());
-			const endPos = vec2$1(uniforms.end.uniform.x.mul(aspectRatio), uniforms.end.uniform.y.oneMinus());
-			const aspectUV = vec2$1(uv.x.mul(aspectRatio), uv.y);
+		return Fn(([uv$1]) => {
+			const aspectRatio = viewportSize.x.div(viewportSize.y);
+			const startPos = vec2(uniforms.start.uniform.x.mul(aspectRatio), uniforms.start.uniform.y.oneMinus());
+			const endPos = vec2(uniforms.end.uniform.x.mul(aspectRatio), uniforms.end.uniform.y.oneMinus());
+			const aspectUV = vec2(uv$1.x.mul(aspectRatio), uv$1.y);
 			const direction = endPos.sub(startPos);
-			const length = direction.length();
-			const normalizedDir = direction.div(length);
-			const perpDir = vec2$1(normalizedDir.y.negate(), normalizedDir.x);
+			const length$1 = direction.length();
+			const normalizedDir = direction.div(length$1);
+			const perpDir = vec2(normalizedDir.y.negate(), normalizedDir.x);
 			const relativePos = aspectUV.sub(startPos);
-			const progress = relativePos.dot(normalizedDir).div(length);
+			const progress = relativePos.dot(normalizedDir).div(length$1);
 			const distFromLine = relativePos.dot(perpDir);
 			const waveCoord = progress.mul(10);
 			const perpCoord = distFromLine.mul(10);
-			const edgeFade = uniforms.pinEdges.uniform.select(smoothstep(float$1(0), float$1(.1), progress).mul(smoothstep(float$1(1), float$1(.9), progress)), float$1(1));
-			const horizontalFade = uniforms.pinEdges.uniform.select(cos$1(progress.mul(6.28)).mul(.5).add(.5).oneMinus(), float$1(1));
-			const verticalFade = cos$1(progress.mul(6.28)).mul(.5).add(.5).oneMinus();
-			const linesColor = vec4$1(0, 0, 0, 0).toVar();
+			const edgeFade = uniforms.pinEdges.uniform.select(smoothstep(float(0), float(.1), progress).mul(smoothstep(float(1), float(.9), progress)), float(1));
+			const horizontalFade = uniforms.pinEdges.uniform.select(cos(progress.mul(6.28)).mul(.5).add(.5).oneMinus(), float(1));
+			const verticalFade = cos(progress.mul(6.28)).mul(.5).add(.5).oneMinus();
+			const linesColor = vec4(0, 0, 0, 0).toVar();
 			const maxLines = uniforms.lineCount.uniform;
 			for (let i = 0; i < 32; i++) {
-				const lineActive = float$1(i).lessThan(maxLines);
-				const lineIndex = float$1(i);
+				const lineActive = float(i).lessThan(maxLines);
+				const lineIndex = float(i);
 				const normalizedIndex = lineIndex.div(maxLines);
-				const offsetFreq = float$1(.5);
-				const offsetSpeed = float$1(1.33);
+				const offsetFreq = float(.5);
+				const offsetSpeed = float(1.33);
 				const offsetTime = t.mul(offsetSpeed);
 				const offsetPosition = lineIndex.add(waveCoord.mul(offsetFreq));
 				const rand = random(offsetPosition.add(offsetTime)).mul(.5).add(.5);
-				const halfWidth = mix$1(float$1(.01), uniforms.lineWidth.uniform, rand.mul(horizontalFade)).mul(.5);
-				const minSpread = float$1(.6);
-				const maxSpread = float$1(2);
-				const offset = random(offsetPosition.add(offsetTime.mul(normalizedIndex.add(1)))).mul(mix$1(minSpread, maxSpread, horizontalFade)).mul(uniforms.amplitude.uniform);
+				const halfWidth = mix(float(.01), uniforms.lineWidth.uniform, rand.mul(horizontalFade)).mul(.5);
+				const minSpread = float(.6);
+				const maxSpread = float(2);
+				const offset = random(offsetPosition.add(offsetTime.mul(normalizedIndex.add(1)))).mul(mix(minSpread, maxSpread, horizontalFade)).mul(uniforms.amplitude.uniform);
 				const linePosition = random(waveCoord.mul(uniforms.frequency.uniform).add(t)).mul(horizontalFade).mul(uniforms.amplitude.uniform).add(offset);
-				const dist = abs$1(perpCoord.sub(linePosition));
-				const lineEdgeSoftness = float$1(.01);
+				const dist = abs(perpCoord.sub(linePosition));
+				const lineEdgeSoftness = float(.01);
 				const line = smoothstep(halfWidth.add(lineEdgeSoftness), halfWidth.sub(lineEdgeSoftness), dist);
-				const lineContribution = vec4$1(uniforms.waveColor.uniform.r, uniforms.waveColor.uniform.g, uniforms.waveColor.uniform.b, line).mul(rand);
-				linesColor.assign(max$1(linesColor, lineActive.select(lineContribution, vec4$1(0, 0, 0, 0))));
+				const lineContribution = vec4(uniforms.waveColor.uniform.r, uniforms.waveColor.uniform.g, uniforms.waveColor.uniform.b, line).mul(rand);
+				linesColor.assign(max(linesColor, lineActive.select(lineContribution, vec4(0, 0, 0, 0))));
 			}
-			return linesColor.mul(vec4$1(1, 1, 1, verticalFade.mul(edgeFade)));
+			return linesColor.mul(vec4(1, 1, 1, verticalFade.mul(edgeFade)));
 		})(baseUV);
 	}
 };

package/dist/core/{Stretch-B645paha.js → Stretch-pl-Cn2F8.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 { clamp, convertToTexture, cos, float, mix, screenUV, sin, vec2, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "Stretch",
 	category: "Distortions",
@@ -81,51 +81,49 @@ const componentDefinition = {
 			}
 		}
 	},
-	uvTransformNode: ({ uv, uniforms, viewportSize: viewportSize$1 }) => {
-		const { vec2: vec2$1, float: float$1, sin: sin$1, cos: cos$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 angleRad = uniforms.angle.uniform.mul(Math.PI / 180);
-		const directionVector = vec2$1(cos$1(angleRad), sin$1(angleRad));
+		const directionVector = vec2(cos(angleRad), sin(angleRad));
 		const projection = delta.dot(directionVector);
 		const perpendicular = delta.sub(directionVector.mul(projection));
 		const falloffAmount = uniforms.falloff.uniform;
-		const transitionWidth = TSL.mix(float$1(.001), float$1(75), falloffAmount);
-		const effectMask = TSL.clamp(projection.div(transitionWidth), float$1(0), float$1(1));
-		const scaledStrength = uniforms.strength.uniform.mul(float$1(100));
-		const stretchFactor = float$1(1).add(scaledStrength.mul(effectMask));
+		const transitionWidth = mix(float(.001), float(75), falloffAmount);
+		const effectMask = clamp(projection.div(transitionWidth), float(0), float(1));
+		const scaledStrength = uniforms.strength.uniform.mul(float(100));
+		const stretchFactor = float(1).add(scaledStrength.mul(effectMask));
 		const finalProjection = projection.div(stretchFactor);
 		const stretchedDelta = directionVector.mul(finalProjection).add(perpendicular);
 		const stretchedUV = centerPos.add(stretchedDelta);
-		return vec2$1(stretchedUV.x.div(aspect), stretchedUV.y);
+		return vec2(stretchedUV.x.div(aspect), stretchedUV.y);
 	},
 	fragmentNode: ({ uniforms, childNode, onCleanup }) => {
-		const { vec2: vec2$1, vec4: vec4$1, screenUV: screenUV$1, viewportSize: viewportSize$1, convertToTexture: convertToTexture$1, float: float$1, sin: sin$1, cos: cos$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 angleRad = uniforms.angle.uniform.mul(Math.PI / 180);
-		const directionVector = vec2$1(cos$1(angleRad), sin$1(angleRad));
+		const directionVector = vec2(cos(angleRad), sin(angleRad));
 		const projection = delta.dot(directionVector);
 		const parallel = directionVector.mul(projection);
 		const perpendicular = delta.sub(parallel);
 		const falloffAmount = uniforms.falloff.uniform;
-		const transitionWidth = TSL.mix(float$1(.001), float$1(75), falloffAmount);
-		const effectMask = TSL.clamp(projection.div(transitionWidth), float$1(0), float$1(1));
-		const scaledStrength = uniforms.strength.uniform.mul(float$1(100));
-		const stretchFactor = float$1(1).add(scaledStrength.mul(effectMask));
+		const transitionWidth = mix(float(.001), float(75), falloffAmount);
+		const effectMask = clamp(projection.div(transitionWidth), float(0), float(1));
+		const scaledStrength = uniforms.strength.uniform.mul(float(100));
+		const stretchFactor = float(1).add(scaledStrength.mul(effectMask));
 		const finalProjection = projection.div(stretchFactor);
 		const stretchedDelta = directionVector.mul(finalProjection).add(perpendicular);
 		const stretchedUV = centerPos.add(stretchedDelta);
-		const finalUV = vec2$1(stretchedUV.x.div(aspect), stretchedUV.y);
+		const finalUV = vec2(stretchedUV.x.div(aspect), stretchedUV.y);
 		return applyEdgeHandling(finalUV, childTexture.sample(finalUV), childTexture, uniforms.edges.uniform);
 	}
 };

package/dist/core/{Swirl-CVnbawit.js → Swirl-D65vXLDw.js}

@@ -1,7 +1,7 @@
 import { t as createAnimatedTime } from "./time-CTJvRUZ4.js";
-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 { cos, float, screenUV, sin, smoothstep, vec2, vec4 } from "three/tsl";
 const componentDefinition = {
 	name: "Swirl",
 	category: "Base Layers",
@@ -138,35 +138,34 @@ const componentDefinition = {
 	},
 	fragmentNode: (params) => {
 		const { uniforms, uvContext } = params;
-		const { vec2: vec2$1, vec4: vec4$1, float: float$1, screenUV: screenUV$1, sin: sin$1, cos: cos$1, smoothstep } = TSL;
-		const uvCoords = uvContext ?? screenUV$1;
+		const uvCoords = uvContext ?? screenUV;
 		const t = createAnimatedTime(params, uniforms.speed);
 		const detail = uniforms.detail.uniform;
-		const scaleCoarse = float$1(.02);
-		const scaleMedium = float$1(.028);
-		const scaleFine = float$1(.056);
+		const scaleCoarse = float(.02);
+		const scaleMedium = float(.028);
+		const scaleFine = float(.056);
 		const freq1 = detail;
 		const coarseScaleX = uniforms.coarseX.uniform.mul(scaleCoarse);
 		const coarseScaleY = uniforms.coarseY.uniform.mul(scaleCoarse);
-		const distort1 = vec2$1(uvCoords.x.add(sin$1(uvCoords.y.mul(freq1.mul(coarseScaleY).mul(1.7)).add(t.mul(.8))).mul(.12)), uvCoords.y.add(cos$1(uvCoords.x.mul(freq1.mul(coarseScaleX).mul(1.3)).sub(t.mul(.6))).mul(.12)));
-		const pattern1 = sin$1(distort1.x.mul(freq1.mul(coarseScaleX).mul(2.1)).add(distort1.y.mul(freq1.mul(coarseScaleY).mul(1.8))).add(t.mul(.4)));
+		const distort1 = vec2(uvCoords.x.add(sin(uvCoords.y.mul(freq1.mul(coarseScaleY).mul(1.7)).add(t.mul(.8))).mul(.12)), uvCoords.y.add(cos(uvCoords.x.mul(freq1.mul(coarseScaleX).mul(1.3)).sub(t.mul(.6))).mul(.12)));
+		const pattern1 = sin(distort1.x.mul(freq1.mul(coarseScaleX).mul(2.1)).add(distort1.y.mul(freq1.mul(coarseScaleY).mul(1.8))).add(t.mul(.4)));
 		const freq2 = detail.mul(1.4);
 		const mediumScaleX = uniforms.mediumX.uniform.mul(scaleMedium);
 		const mediumScaleY = uniforms.mediumY.uniform.mul(scaleMedium);
-		const distort2 = vec2$1(distort1.x.add(cos$1(distort1.y.mul(freq2.mul(mediumScaleY).mul(1.9)).sub(t.mul(.5))).mul(.06)), distort1.y.add(sin$1(distort1.x.mul(freq2.mul(mediumScaleX).mul(2.3)).add(t.mul(.7))).mul(.06)));
-		const pattern2 = cos$1(distort2.x.mul(freq2.mul(mediumScaleX).mul(1.6)).sub(distort2.y.mul(freq2.mul(mediumScaleY).mul(2.4))).add(t.mul(.3)));
+		const distort2 = vec2(distort1.x.add(cos(distort1.y.mul(freq2.mul(mediumScaleY).mul(1.9)).sub(t.mul(.5))).mul(.06)), distort1.y.add(sin(distort1.x.mul(freq2.mul(mediumScaleX).mul(2.3)).add(t.mul(.7))).mul(.06)));
+		const pattern2 = cos(distort2.x.mul(freq2.mul(mediumScaleX).mul(1.6)).sub(distort2.y.mul(freq2.mul(mediumScaleY).mul(2.4))).add(t.mul(.3)));
 		const freq3 = detail.mul(2.8);
 		const fineScaleX = uniforms.fineX.uniform.mul(scaleFine);
 		const fineScaleY = uniforms.fineY.uniform.mul(scaleFine);
-		const distort3 = vec2$1(distort2.x.add(sin$1(distort2.y.mul(freq3.mul(fineScaleY).mul(1.1)).add(t.mul(.9))).mul(.03)), distort2.y.add(cos$1(distort2.x.mul(freq3.mul(fineScaleX).mul(.9)).sub(t.mul(.4))).mul(.03)));
-		const pattern3 = sin$1(distort3.x.mul(freq3.mul(fineScaleX).mul(1.3)).add(distort3.y.mul(freq3.mul(fineScaleY).mul(1.7))).sub(t.mul(.6)));
+		const distort3 = vec2(distort2.x.add(sin(distort2.y.mul(freq3.mul(fineScaleY).mul(1.1)).add(t.mul(.9))).mul(.03)), distort2.y.add(cos(distort2.x.mul(freq3.mul(fineScaleX).mul(.9)).sub(t.mul(.4))).mul(.03)));
+		const pattern3 = sin(distort3.x.mul(freq3.mul(fineScaleX).mul(1.3)).add(distort3.y.mul(freq3.mul(fineScaleY).mul(1.7))).sub(t.mul(.6)));
 		const combinedPattern = pattern1.mul(.5).add(pattern2.mul(.3)).add(pattern3.mul(.2));
 		const blendBias = uniforms.blend.uniform.sub(50).mul(.006);
 		const blendFactor = smoothstep(.3, .7, combinedPattern.mul(.5).add(.5).add(blendBias));
 		const colorMix = mixColors(uniforms.colorA.uniform, uniforms.colorB.uniform, blendFactor, uniforms.colorSpace.uniform);
-		const shimmer = sin$1(t.mul(2.5).add(combinedPattern.mul(8))).mul(.015).add(1);
+		const shimmer = sin(t.mul(2.5).add(combinedPattern.mul(8))).mul(.015).add(1);
 		const finalColor = colorMix.mul(shimmer);
-		return vec4$1(finalColor.rgb, finalColor.a);
+		return vec4(finalColor.rgb, finalColor.a);
 	}
 };
 var Swirl_default = componentDefinition;

package/dist/core/{TiltShift-0CxNRI6L.js → TiltShift-CFcK6Hzg.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, abs, convertToTexture, cos, dot, float, mix, radians, screenUV, sin, smoothstep, vec2, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "TiltShift",
 	category: "Blurs",
@@ -66,17 +66,16 @@ const componentDefinition = {
 		}
 	},
 	fragmentNode: ({ uniforms, childNode, onCleanup }) => {
-		const { vec2: vec2$1, vec4: vec4$1, float: float$1, screenUV: screenUV$1, convertToTexture: convertToTexture$1, viewportSize: viewportSize$1, radians, cos: cos$1, sin: sin$1, dot: dot$1, abs: abs$1, smoothstep, mix: mix$1, Fn } = 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 cosAngle = cos$1(angleRad);
-		const perpVector = vec2$1(sin$1(angleRad).negate(), cosAngle);
-		const centerPosition = vec2$1(uniforms.center.uniform[0], uniforms.center.uniform[1].oneMinus());
-		const distFromLine = abs$1(dot$1(screenUV$1.sub(centerPosition), perpVector));
+		const cosAngle = cos(angleRad);
+		const perpVector = vec2(sin(angleRad).negate(), cosAngle);
+		const centerPosition = vec2(uniforms.center.uniform[0], uniforms.center.uniform[1].oneMinus());
+		const distFromLine = abs(dot(screenUV.sub(centerPosition), perpVector));
 		const focusWidth = uniforms.width.uniform.mul(.5);
 		const falloff = uniforms.falloff.uniform;
 		const blurAmount = smoothstep(focusWidth, focusWidth.add(falloff), distFromLine);
@@ -98,14 +97,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));
 			}
@@ -115,18 +114,18 @@ 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));
 			}
 			const blurred = total;
-			return mix$1(childTexture.sample(uv), blurred, blurAmount);
+			return mix(childTexture.sample(uv$1), blurred, blurAmount);
 		})();
 	}
 };

package/dist/core/{Tritone-Daa-I5UD.js → Tritone-EmnjV2rX.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: "Tritone",
 	category: "Adjustments",
@@ -58,18 +58,17 @@ 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 shadowToMid = smoothstep(uniforms.blendMid.uniform.sub(.25), uniforms.blendMid.uniform, luminance);
 		const lowerBlend = mixColors(uniforms.colorA.uniform, uniforms.colorB.uniform, shadowToMid, uniforms.colorSpace.uniform);
 		const midToHighlight = smoothstep(uniforms.blendMid.uniform, uniforms.blendMid.uniform.add(.25), luminance);
-		return vec4$1(mixColors(lowerBlend, mixColors(uniforms.colorB.uniform, uniforms.colorC.uniform, midToHighlight, uniforms.colorSpace.uniform), smoothstep(uniforms.blendMid.uniform.sub(.1), uniforms.blendMid.uniform.add(.1), luminance), uniforms.colorSpace.uniform).rgb, inputColor.a);
+		return vec4(mixColors(lowerBlend, mixColors(uniforms.colorB.uniform, uniforms.colorC.uniform, midToHighlight, uniforms.colorSpace.uniform), smoothstep(uniforms.blendMid.uniform.sub(.1), uniforms.blendMid.uniform.add(.1), luminance), uniforms.colorSpace.uniform).rgb, inputColor.a);
 	}
 };
 var Tritone_default = componentDefinition;

package/dist/core/{Twirl-2CJVZEtk.js → Twirl-HSMyRx5I.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 { convertToTexture, cos, length, screenUV, sin, vec2, vec4 } from "three/tsl";
 const componentDefinition = {
 	name: "Twirl",
 	category: "Distortions",
@@ -59,37 +59,35 @@ const componentDefinition = {
 			}
 		}
 	},
-	uvTransformNode: ({ uv, uniforms }) => {
-		const { vec2: vec2$1, cos: cos$1, sin: sin$1, length } = TSL;
-		const centerPos = vec2$1(uniforms.center.uniform.x, uniforms.center.uniform.y.oneMinus());
-		const delta = uv.sub(centerPos);
+	uvTransformNode: ({ uv: uv$1, uniforms }) => {
+		const centerPos = vec2(uniforms.center.uniform.x, uniforms.center.uniform.y.oneMinus());
+		const delta = uv$1.sub(centerPos);
 		const angle = uniforms.intensity.uniform.mul(length(delta));
-		const cosAngle = cos$1(angle);
-		const sinAngle = sin$1(angle);
+		const cosAngle = cos(angle);
+		const sinAngle = sin(angle);
 		const rotatedX = cosAngle.mul(delta.x).sub(sinAngle.mul(delta.y));
 		const rotatedY = sinAngle.mul(delta.x).add(cosAngle.mul(delta.y));
-		return vec2$1(rotatedX.add(centerPos.x), rotatedY.add(centerPos.y));
+		return vec2(rotatedX.add(centerPos.x), rotatedY.add(centerPos.y));
 	},
 	fragmentNode: ({ uniforms, childNode, onCleanup }) => {
-		const { vec2: vec2$1, vec4: vec4$1, cos: cos$1, sin: sin$1, length, screenUV: screenUV$1, convertToTexture: convertToTexture$1 } = TSL;
 		if (!childNode) {
 			console.error("You must pass a child component into the Twirl shader.");
-			return vec4$1(0);
+			return vec4(0);
 		}
-		const texture = convertToTexture$1(childNode);
+		const texture$1 = convertToTexture(childNode);
 		onCleanup(() => {
-			if (texture?.renderTarget?.dispose) texture.renderTarget.dispose();
+			if (texture$1?.renderTarget?.dispose) texture$1.renderTarget.dispose();
 		});
-		const uvNode = screenUV$1;
-		const centerPos = vec2$1(uniforms.center.uniform.x, uniforms.center.uniform.y.oneMinus());
+		const uvNode = screenUV;
+		const centerPos = vec2(uniforms.center.uniform.x, uniforms.center.uniform.y.oneMinus());
 		const delta = uvNode.sub(centerPos);
 		const angle = uniforms.intensity.uniform.mul(length(delta));
-		const cosAngle = cos$1(angle);
-		const sinAngle = sin$1(angle);
+		const cosAngle = cos(angle);
+		const sinAngle = sin(angle);
 		const rotatedX = cosAngle.mul(delta.x).sub(sinAngle.mul(delta.y));
 		const rotatedY = sinAngle.mul(delta.x).add(cosAngle.mul(delta.y));
-		const twistedUV = vec2$1(rotatedX.add(centerPos.x), rotatedY.add(centerPos.y));
-		return applyEdgeHandling(twistedUV, texture.sample(twistedUV), texture, uniforms.edges.uniform);
+		const twistedUV = vec2(rotatedX.add(centerPos.x), rotatedY.add(centerPos.y));
+		return applyEdgeHandling(twistedUV, texture$1.sample(twistedUV), texture$1, uniforms.edges.uniform);
 	}
 };
 var Twirl_default = componentDefinition;

package/dist/core/{WaveDistortion-BscXN2rs.js → WaveDistortion-DG8GO_l8.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 { PI, abs, convertToTexture, cos, float, fract, screenUV, sin, step, time, vec2, vec4 } from "three/tsl";
 const componentDefinition = {
 	name: "WaveDistortion",
 	category: "Distortions",
@@ -114,55 +114,53 @@ const componentDefinition = {
 			}
 		}
 	},
-	uvTransformNode: ({ uv, uniforms }) => {
-		const { vec2: vec2$1, sin: sin$1, cos: cos$1, abs: abs$1, fract, step: step$1, float: float$1, PI, time } = TSL;
+	uvTransformNode: ({ uv: uv$1, uniforms }) => {
 		const t = time.mul(uniforms.speed.uniform).mul(.5);
 		const angleRad = uniforms.angle.uniform.mul(PI).div(180);
-		const cosAngle = cos$1(angleRad);
-		const sinAngle = sin$1(angleRad);
-		const centeredUV = uv.sub(vec2$1(.5, .5));
-		const phase = vec2$1(centeredUV.x.mul(cosAngle).sub(centeredUV.y.mul(sinAngle)), centeredUV.x.mul(sinAngle).add(centeredUV.y.mul(cosAngle))).add(vec2$1(.5, .5)).y.mul(uniforms.frequency.uniform).mul(PI.mul(2)).add(t);
+		const cosAngle = cos(angleRad);
+		const sinAngle = sin(angleRad);
+		const centeredUV = uv$1.sub(vec2(.5, .5));
+		const phase = vec2(centeredUV.x.mul(cosAngle).sub(centeredUV.y.mul(sinAngle)), centeredUV.x.mul(sinAngle).add(centeredUV.y.mul(cosAngle))).add(vec2(.5, .5)).y.mul(uniforms.frequency.uniform).mul(PI.mul(2)).add(t);
 		const normalizedPhase = fract(phase.div(PI.mul(2)));
-		const sineWave = sin$1(phase);
-		const triangleWave = abs$1(normalizedPhase.mul(2).sub(1)).mul(2).sub(1);
-		const squareWave = step$1(float$1(.5), normalizedPhase).mul(2).sub(1);
+		const sineWave = sin(phase);
+		const triangleWave = abs(normalizedPhase.mul(2).sub(1)).mul(2).sub(1);
+		const squareWave = step(float(.5), normalizedPhase).mul(2).sub(1);
 		const sawtoothWave = normalizedPhase.mul(2).sub(1);
 		const waveTypeValue = uniforms.waveType.uniform;
-		const isSine = step$1(waveTypeValue, float$1(.5));
-		const isTriangle = step$1(float$1(.5), waveTypeValue).mul(step$1(waveTypeValue, float$1(1.5)));
-		const isSquare = step$1(float$1(1.5), waveTypeValue).mul(step$1(waveTypeValue, float$1(2.5)));
-		const isSawtooth = step$1(float$1(2.5), waveTypeValue);
+		const isSine = step(waveTypeValue, float(.5));
+		const isTriangle = step(float(.5), waveTypeValue).mul(step(waveTypeValue, float(1.5)));
+		const isSquare = step(float(1.5), waveTypeValue).mul(step(waveTypeValue, float(2.5)));
+		const isSawtooth = step(float(2.5), waveTypeValue);
 		const displacement = sineWave.mul(isSine).add(triangleWave.mul(isTriangle)).add(squareWave.mul(isSquare)).add(sawtoothWave.mul(isSawtooth)).mul(uniforms.strength.uniform).mul(.5);
 		const displacementX = displacement.mul(cosAngle);
 		const displacementY = displacement.mul(sinAngle);
-		return vec2$1(uv.x.add(displacementX), uv.y.add(displacementY));
+		return vec2(uv$1.x.add(displacementX), uv$1.y.add(displacementY));
 	},
 	fragmentNode: (params) => {
 		const { uniforms, childNode, onCleanup } = params;
-		const { vec2: vec2$1, vec4: vec4$1, sin: sin$1, cos: cos$1, abs: abs$1, fract, step: step$1, convertToTexture: convertToTexture$1, screenUV: screenUV$1, float: float$1, PI, time } = TSL;
-		if (!childNode) return vec4$1(0, 0, 0, 0);
-		const uvCoord = screenUV$1;
+		if (!childNode) return vec4(0, 0, 0, 0);
+		const uvCoord = screenUV;
 		const t = time.mul(uniforms.speed.uniform).mul(.5);
 		const angleRad = uniforms.angle.uniform.mul(PI).div(180);
-		const cosAngle = cos$1(angleRad);
-		const sinAngle = sin$1(angleRad);
-		const centeredUV = uvCoord.sub(vec2$1(.5, .5));
-		const phase = vec2$1(centeredUV.x.mul(cosAngle).sub(centeredUV.y.mul(sinAngle)), centeredUV.x.mul(sinAngle).add(centeredUV.y.mul(cosAngle))).add(vec2$1(.5, .5)).y.mul(uniforms.frequency.uniform).mul(PI.mul(2)).add(t);
+		const cosAngle = cos(angleRad);
+		const sinAngle = sin(angleRad);
+		const centeredUV = uvCoord.sub(vec2(.5, .5));
+		const phase = vec2(centeredUV.x.mul(cosAngle).sub(centeredUV.y.mul(sinAngle)), centeredUV.x.mul(sinAngle).add(centeredUV.y.mul(cosAngle))).add(vec2(.5, .5)).y.mul(uniforms.frequency.uniform).mul(PI.mul(2)).add(t);
 		const normalizedPhase = fract(phase.div(PI.mul(2)));
-		const sineWave = sin$1(phase);
-		const triangleWave = abs$1(normalizedPhase.mul(2).sub(1)).mul(2).sub(1);
-		const squareWave = step$1(float$1(.5), normalizedPhase).mul(2).sub(1);
+		const sineWave = sin(phase);
+		const triangleWave = abs(normalizedPhase.mul(2).sub(1)).mul(2).sub(1);
+		const squareWave = step(float(.5), normalizedPhase).mul(2).sub(1);
 		const sawtoothWave = normalizedPhase.mul(2).sub(1);
 		const waveTypeValue = uniforms.waveType.uniform;
-		const isSine = step$1(waveTypeValue, float$1(.5));
-		const isTriangle = step$1(float$1(.5), waveTypeValue).mul(step$1(waveTypeValue, float$1(1.5)));
-		const isSquare = step$1(float$1(1.5), waveTypeValue).mul(step$1(waveTypeValue, float$1(2.5)));
-		const isSawtooth = step$1(float$1(2.5), waveTypeValue);
+		const isSine = step(waveTypeValue, float(.5));
+		const isTriangle = step(float(.5), waveTypeValue).mul(step(waveTypeValue, float(1.5)));
+		const isSquare = step(float(1.5), waveTypeValue).mul(step(waveTypeValue, float(2.5)));
+		const isSawtooth = step(float(2.5), waveTypeValue);
 		const displacement = sineWave.mul(isSine).add(triangleWave.mul(isTriangle)).add(squareWave.mul(isSquare)).add(sawtoothWave.mul(isSawtooth)).mul(uniforms.strength.uniform).mul(.5);
 		const displacementX = displacement.mul(cosAngle);
 		const displacementY = displacement.mul(sinAngle);
-		const distortedUV = vec2$1(uvCoord.x.add(displacementX), uvCoord.y.add(displacementY));
-		const childTexture = convertToTexture$1(childNode);
+		const distortedUV = vec2(uvCoord.x.add(displacementX), uvCoord.y.add(displacementY));
+		const childTexture = convertToTexture(childNode);
 		onCleanup(() => {
 			if (childTexture?.renderTarget?.dispose) childTexture.renderTarget.dispose();
 		});

package/dist/core/{ZoomBlur-CAqK0Kju.js → ZoomBlur-C01oGwwG.js}

@@ -1,5 +1,5 @@
-import { o as transformPosition } from "./transformations-DxfQXZWi.js";
-import * as TSL from "three/tsl";
+import { o as transformPosition } from "./transformations-Dv5JW9ck.js";
+import { Fn, convertToTexture, float, screenUV, vec2, vec4 } from "three/tsl";
 const componentDefinition = {
 	name: "ZoomBlur",
 	category: "Blurs",
@@ -32,24 +32,23 @@ const componentDefinition = {
 		}
 	},
 	fragmentNode: ({ uniforms, childNode, onCleanup }) => {
-		const { vec2: vec2$1, vec4: vec4$1, float: float$1, screenUV: screenUV$1, 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 center = vec2$1(uniforms.center.uniform.x, uniforms.center.uniform.y.oneMinus());
+		const center = vec2(uniforms.center.uniform.x, uniforms.center.uniform.y.oneMinus());
 		const radius = uniforms.intensity.uniform.mul(.01);
 		return Fn(() => {
-			const uv = screenUV$1;
-			const total = vec4$1(0).toVar();
-			const totalWeight = float$1(0).toVar();
+			const uv$1 = screenUV;
+			const total = vec4(0).toVar();
+			const totalWeight = float(0).toVar();
 			for (let i = 0; i < 32; i++) {
-				const t = float$1(i).div(float$1(31));
+				const t = float(i).div(float(31));
 				const weightT = t.sub(.5).mul(2);
-				const weight = float$1(1).div(float$1(2.506628)).mul(float$1(-.5).mul(weightT).mul(weightT).div(float$1(.64)).exp());
-				const scale = float$1(1).add(radius.mul(t));
-				const scaledCoord = uv.sub(center).div(scale).add(center);
+				const weight = float(1).div(float(2.506628)).mul(float(-.5).mul(weightT).mul(weightT).div(float(.64)).exp());
+				const scale = float(1).add(radius.mul(t));
+				const scaledCoord = uv$1.sub(center).div(scale).add(center);
 				const sample = childTexture.sample(scaledCoord).mul(weight);
 				total.assign(total.add(sample));
 				totalWeight.assign(totalWeight.add(weight));

package/dist/core/colorMixing-CZPFmiT4.js

@@ -0,0 +1,68 @@
+import { atan, cos, float, max, pow, sin, sqrt, vec3, vec4 } from "three/tsl";
+var p3ToSRGB = (p3) => {
+	return vec3(p3.x.mul(1.2249401).sub(p3.y.mul(.2249404)).sub(p3.z.mul(0)), p3.x.mul(-.0420569).add(p3.y.mul(1.0420571)).add(p3.z.mul(0)), p3.x.mul(-.0196376).sub(p3.y.mul(.0786361)).add(p3.z.mul(1.0982735)));
+};
+var sRGBToP3 = (srgb) => {
+	return vec3(srgb.x.mul(.8224621).add(srgb.y.mul(.177538)).add(srgb.z.mul(0)), srgb.x.mul(.0331941).add(srgb.y.mul(.9668058)).add(srgb.z.mul(0)), srgb.x.mul(.0170826).add(srgb.y.mul(.0723974)).add(srgb.z.mul(.9105199)));
+};
+var rgbToOklab = (rgb) => {
+	const r = rgb.x;
+	const g = rgb.y;
+	const b = rgb.z;
+	const l = r.mul(.4122214708).add(g.mul(.5363325363)).add(b.mul(.0514459929));
+	const m = r.mul(.2119034982).add(g.mul(.6806995451).add(b.mul(.1073969566)));
+	const s = r.mul(.0883024619).add(g.mul(.2817188376)).add(b.mul(.6299787005));
+	const l_ = pow(l, float(1 / 3));
+	const m_ = pow(m, float(1 / 3));
+	const s_ = pow(s, float(1 / 3));
+	return vec3(l_.mul(.2104542553).add(m_.mul(.793617785)).sub(s_.mul(.0040720468)), l_.mul(1.9779984951).sub(m_.mul(2.428592205)).add(s_.mul(.4505937099)), l_.mul(.0259040371).add(m_.mul(.7827717662)).sub(s_.mul(.808675766)));
+};
+var oklabToRgb = (lab) => {
+	const L = lab.x;
+	const a = lab.y;
+	const b = lab.z;
+	const l_ = L.add(a.mul(.3963377774)).add(b.mul(.2158037573));
+	const m_ = L.sub(a.mul(.1055613458)).sub(b.mul(.0638541728));
+	const s_ = L.sub(a.mul(.0894841775)).sub(b.mul(1.291485548));
+	const l = pow(l_, float(3));
+	const m = pow(m_, float(3));
+	const s = pow(s_, float(3));
+	return vec3(l.mul(4.0767416621).sub(m.mul(3.3077115913)).add(s.mul(.2309699292)), l.mul(-1.2684380046).add(m.mul(2.6097574011)).sub(s.mul(.3413193965)), l.mul(-.0041960863).sub(m.mul(.7034186147)).add(s.mul(1.707614701)));
+};
+var oklabToOklch = (lab) => {
+	const L = lab.x;
+	const a = lab.y;
+	const b = lab.z;
+	return vec3(L, sqrt(a.mul(a).add(b.mul(b))), atan(b, a));
+};
+var oklchToOklab = (lch) => {
+	const L = lch.x;
+	const C = lch.y;
+	const h = lch.z;
+	return vec3(L, C.mul(cos(h)), C.mul(sin(h)));
+};
+const mixColors = (colorA, colorB, t, colorSpaceMode) => {
+	const p3A = vec3(colorA.x, colorA.y, colorA.z);
+	const p3B = vec3(colorB.x, colorB.y, colorB.z);
+	const alphaA = colorA.w;
+	const alphaB = colorB.w;
+	const weightA = alphaA.mul(float(1).sub(t));
+	const weightB = alphaB.mul(t);
+	const totalWeight = weightA.add(weightB);
+	const safeWeight = max(totalWeight, float(.001));
+	const alphaWeightedMix = (rgbA, rgbB) => {
+		return rgbA.mul(weightA).add(rgbB.mul(weightB)).div(safeWeight);
+	};
+	const linearMix = alphaWeightedMix(p3A, p3B);
+	const srgbA = p3ToSRGB(p3A);
+	const srgbB = p3ToSRGB(p3B);
+	const oklabA = rgbToOklab(srgbA);
+	const oklabB = rgbToOklab(srgbB);
+	const oklchResult = sRGBToP3(oklabToRgb(oklchToOklab(alphaWeightedMix(oklabToOklch(oklabA), oklabToOklch(oklabB)))));
+	const oklabResult = sRGBToP3(oklabToRgb(alphaWeightedMix(oklabA, oklabB)));
+	const isMode1OrHigher = colorSpaceMode.greaterThanEqual(float(.5));
+	const rgb = colorSpaceMode.greaterThanEqual(float(1.5)).select(oklabResult, isMode1OrHigher.select(oklchResult, linearMix));
+	const alpha = totalWeight;
+	return vec4(rgb.x, rgb.y, rgb.z, alpha);
+};
+export { mixColors as t };