shaders 2.3.56 → 2.3.59

package/dist/core/{Sharpness-C5h9h3NY.js → Sharpness-DAu01Qy4.js}

@@ -1,3 +1,4 @@
+import { t as unpremultiplyAlpha } from "./alpha-Byel9eTg.js";
 import { Fn, clamp, convertToTexture, float, screenUV, vec2, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "Sharpness",
@@ -34,7 +35,7 @@ const componentDefinition = {
 			const right = childTexture.sample(uv$1.add(vec2(pixelSize.x, 0)));
 			const centerWeight = float(1).add(amount.mul(4));
 			const neighborWeight = amount.negate();
-			return vec4(clamp(center.mul(centerWeight).add(top.mul(neighborWeight)).add(bottom.mul(neighborWeight)).add(left.mul(neighborWeight)).add(right.mul(neighborWeight)).rgb, 0, 1), center.a);
+			return unpremultiplyAlpha(vec4(clamp(center.mul(centerWeight).add(top.mul(neighborWeight)).add(bottom.mul(neighborWeight)).add(left.mul(neighborWeight)).add(right.mul(neighborWeight)).rgb, 0, 1), center.a));
 		})();
 	}
 };

package/dist/core/{Shatter-BDTHZrbz.js → Shatter-CYHavYlJ.js}

@@ -1,5 +1,6 @@
 import { t as applyEdgeHandling } from "./edges-Bd7GP4s2.js";
-import { o as transformEdges } from "./transformations-CC_c-QAT.js";
+import { o as transformEdges } from "./transformations-DM6huB9g.js";
+import { t as unpremultiplyAlpha } from "./alpha-Byel9eTg.js";
 import { DataTexture, FloatType, LinearFilter, NearestFilter, RGBAFormat } from "three";
 import { convertToTexture, float, screenUV, smoothstep, texture, vec2, vec4 } from "three/tsl";
 var seededRandom = (seed) => {
@@ -319,7 +320,7 @@ const componentDefinition = {
 		const lightingFactor = float(1).add(normalDot.mul(uniforms.shardLighting.uniform));
 		const lightingIntensity = smoothstep(float(0), float(.02), displacementLength);
 		const finalLighting = float(1).add(lightingFactor.sub(1).mul(lightingIntensity));
-		return vec4(shadedRGB.mul(finalLighting), normalColor.a);
+		return unpremultiplyAlpha(vec4(shadedRGB.mul(finalLighting), normalColor.a));
 	}
 };
 var Shatter_default = componentDefinition;

package/dist/core/{SimplexNoise-DU-QPbwp.js → SimplexNoise-VmkKWJJ_.js}

@@ -1,6 +1,6 @@
-import { r as transformColor } from "./transformations-CC_c-QAT.js";
+import { r as transformColor } from "./transformations-DM6huB9g.js";
 import { t as createAnimatedTime } from "./time-BZqyVJXt.js";
-import { t as mixColors } from "./colorMixing-Ehw-Hfs_.js";
+import { t as mixColors } from "./colorMixing-D_wMclqL.js";
 import { clamp, exp, float, mx_noise_float, screenUV, vec2, vec3, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "SimplexNoise",

package/dist/core/{SineWave-CsoVJf9C.js → SineWave-BJiQQ5mH.js}

@@ -1,4 +1,4 @@
-import { n as transformAngle, r as transformColor, s as transformPosition } from "./transformations-CC_c-QAT.js";
+import { n as transformAngle, r as transformColor, s as transformPosition } from "./transformations-DM6huB9g.js";
 import { t as createAnimatedTime } from "./time-BZqyVJXt.js";
 import { PI, abs, cos, radians, screenUV, sin, smoothstep, vec2, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {

package/dist/core/{SolidColor-BOK2t0JT.js → SolidColor-Dym-TMi_.js}

@@ -1,4 +1,4 @@
-import { r as transformColor } from "./transformations-CC_c-QAT.js";
+import { r as transformColor } from "./transformations-DM6huB9g.js";
 const componentDefinition = {
 	name: "SolidColor",
 	category: "Textures",

package/dist/core/{Spherize-BxUTtFAg.js → Spherize-tGTqCifk.js}

@@ -1,4 +1,5 @@
-import { r as transformColor, s as transformPosition } from "./transformations-CC_c-QAT.js";
+import { r as transformColor, s as transformPosition } from "./transformations-DM6huB9g.js";
+import { t as unpremultiplyAlpha } from "./alpha-Byel9eTg.js";
 import { convertToTexture, dot, float, max, normalize, pow, screenUV, smoothstep, sqrt, vec2, vec3, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "Spherize",
@@ -109,7 +110,7 @@ const componentDefinition = {
 		const depthFactor = float(1).add(z.mul(uniforms.depth.uniform));
 		const finalUV = sphereUV.div(depthFactor).mul(radius).div(2);
 		const transformedUV = vec2(finalUV.x.div(aspect).add(centerPos.x), finalUV.y.add(centerPos.y));
-		const sampledColor = childTexture.sample(transformedUV);
+		const straightColor = unpremultiplyAlpha(childTexture.sample(transformedUV));
 		const lightPos = vec2(uniforms.lightPosition.uniform.x, uniforms.lightPosition.uniform.y.oneMinus());
 		const lightIntensity = uniforms.lightIntensity.uniform;
 		const lightSoftness = uniforms.lightSoftness.uniform;
@@ -123,11 +124,7 @@ const componentDefinition = {
 		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(finalR.mul(finalA), finalG.mul(finalA), finalB.mul(finalA), finalA);
+		return vec4(straightColor.x.add(lightColor.x.mul(rimLight)), straightColor.y.add(lightColor.y.mul(rimLight)), straightColor.z.add(lightColor.z.mul(rimLight)), straightColor.w.mul(sphereAlpha));
 	}
 };
 var Spherize_default = componentDefinition;

package/dist/core/{Spiral-DVURsiiQ.js → Spiral-q4HnjiwB.js}

@@ -1,6 +1,6 @@
-import { i as transformColorSpace, r as transformColor, s as transformPosition, t as colorSpaceOptions } from "./transformations-CC_c-QAT.js";
+import { i as transformColorSpace, r as transformColor, s as transformPosition, t as colorSpaceOptions } from "./transformations-DM6huB9g.js";
 import { t as createAnimatedTime } from "./time-BZqyVJXt.js";
-import { t as mixColors } from "./colorMixing-Ehw-Hfs_.js";
+import { t as mixColors } from "./colorMixing-D_wMclqL.js";
 import { abs, atan, clamp, float, fract, fwidth, length, mix, screenUV, smoothstep, vec2, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "Spiral",

package/dist/core/{Strands-C2l4JaUt.js → Strands-BPQ8qqBR.js}

@@ -1,4 +1,4 @@
-import { r as transformColor, s as transformPosition } from "./transformations-CC_c-QAT.js";
+import { r as transformColor, s as transformPosition } from "./transformations-DM6huB9g.js";
 import { t as createAnimatedTime } from "./time-BZqyVJXt.js";
 import { Fn, abs, cos, float, max, mix, screenUV, smoothstep, vec2, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {

package/dist/core/{Stretch-uSJDtqi2.js → Stretch-DnMB46Ey.js}

@@ -1,5 +1,6 @@
 import { t as applyEdgeHandling } from "./edges-Bd7GP4s2.js";
-import { o as transformEdges, s as transformPosition } from "./transformations-CC_c-QAT.js";
+import { o as transformEdges, s as transformPosition } from "./transformations-DM6huB9g.js";
+import { t as unpremultiplyAlpha } from "./alpha-Byel9eTg.js";
 import { clamp, convertToTexture, cos, float, mix, screenUV, sin, vec2, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "Stretch",
@@ -110,7 +111,7 @@ const componentDefinition = {
 		const stretchedDelta = directionVector.mul(finalProjection).add(perpendicular);
 		const stretchedUV = centerPos.add(stretchedDelta);
 		const finalUV = vec2(stretchedUV.x.div(aspect), stretchedUV.y);
-		return applyEdgeHandling(finalUV, childTexture.sample(finalUV), childTexture, uniforms.edges.uniform);
+		return unpremultiplyAlpha(applyEdgeHandling(finalUV, childTexture.sample(finalUV), childTexture, uniforms.edges.uniform));
 	}
 };
 var Stretch_default = componentDefinition;

package/dist/core/{Stripes-IFl3of9w.js → Stripes-Bb3sqRlB.js}

@@ -1,6 +1,6 @@
-import { i as transformColorSpace, n as transformAngle, r as transformColor, t as colorSpaceOptions } from "./transformations-CC_c-QAT.js";
+import { i as transformColorSpace, n as transformAngle, r as transformColor, t as colorSpaceOptions } from "./transformations-DM6huB9g.js";
 import { t as createAnimatedTime } from "./time-BZqyVJXt.js";
-import { t as mixColors } from "./colorMixing-Ehw-Hfs_.js";
+import { t as mixColors } from "./colorMixing-D_wMclqL.js";
 import { cos, fract, fwidth, screenUV, sin, smoothstep, vec2, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "Stripes",

package/dist/core/{StudioBackground-DbBGv5fk.js → StudioBackground-DNezGoE_.js}

@@ -1,4 +1,4 @@
-import { r as transformColor, s as transformPosition } from "./transformations-CC_c-QAT.js";
+import { r as transformColor, s as transformPosition } from "./transformations-DM6huB9g.js";
 import { t as createAnimatedTime } from "./time-BZqyVJXt.js";
 import { Fn, clamp, cos, exp, float, fract, mix, screenUV, sin, smoothstep, vec3, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {

package/dist/core/{Swirl-C16tmwEg.js → Swirl-BnoTw2v_.js}

@@ -1,6 +1,6 @@
-import { i as transformColorSpace, r as transformColor, t as colorSpaceOptions } from "./transformations-CC_c-QAT.js";
+import { i as transformColorSpace, r as transformColor, t as colorSpaceOptions } from "./transformations-DM6huB9g.js";
 import { t as createAnimatedTime } from "./time-BZqyVJXt.js";
-import { t as mixColors } from "./colorMixing-Ehw-Hfs_.js";
+import { t as mixColors } from "./colorMixing-D_wMclqL.js";
 import { cos, screenUV, sin, smoothstep, vec2, vec4 } from "three/tsl";
 const componentDefinition = {
 	name: "Swirl",

package/dist/core/{TiltShift-C5t3YMVT.js → TiltShift-B35F5fNx.js}

@@ -1,4 +1,5 @@
-import { n as transformAngle, s as transformPosition } from "./transformations-CC_c-QAT.js";
+import { n as transformAngle, s as transformPosition } from "./transformations-DM6huB9g.js";
+import { t as unpremultiplyAlpha } from "./alpha-Byel9eTg.js";
 import { Fn, abs, convertToTexture, cos, dot, float, mix, radians, screenUV, sin, smoothstep, vec2, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "TiltShift",
@@ -132,7 +133,7 @@ const componentDefinition = {
 				total.assign(total.add(sample));
 			}
 			const blurred = total;
-			return mix(childTexture.sample(uv$1), blurred, blurAmount);
+			return unpremultiplyAlpha(mix(childTexture.sample(uv$1), blurred, blurAmount));
 		})();
 	}
 };

package/dist/core/{Tint-VTnDmiKF.js → Tint-BmwtUjg4.js}

@@ -1,4 +1,4 @@
-import { r as transformColor } from "./transformations-CC_c-QAT.js";
+import { r as transformColor } from "./transformations-DM6huB9g.js";
 import { dot, max, mix, vec3, vec4 } from "three/tsl";
 const componentDefinition = {
 	name: "Tint",

package/dist/core/{Tritone-v6z_O967.js → Tritone-BplKm991.js}

@@ -1,5 +1,6 @@
-import { i as transformColorSpace, r as transformColor, t as colorSpaceOptions } from "./transformations-CC_c-QAT.js";
-import { t as mixColors } from "./colorMixing-Ehw-Hfs_.js";
+import { i as transformColorSpace, r as transformColor, t as colorSpaceOptions } from "./transformations-DM6huB9g.js";
+import { t as unpremultiplyAlpha } from "./alpha-Byel9eTg.js";
+import { t as mixColors } from "./colorMixing-D_wMclqL.js";
 import { convertToTexture, dot, screenUV, smoothstep, vec3, vec4 } from "three/tsl";
 const componentDefinition = {
 	name: "Tritone",
@@ -68,7 +69,7 @@ const componentDefinition = {
 		onCleanup(() => {
 			if (childTexture?.renderTarget?.dispose) childTexture.renderTarget.dispose();
 		});
-		const inputColor = childTexture.sample(screenUV);
+		const inputColor = unpremultiplyAlpha(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);

package/dist/core/{Twirl-BWpsT8iI.js → Twirl-Dn5j12Yk.js}

@@ -1,5 +1,6 @@
 import { t as applyEdgeHandling } from "./edges-Bd7GP4s2.js";
-import { o as transformEdges, s as transformPosition } from "./transformations-CC_c-QAT.js";
+import { o as transformEdges, s as transformPosition } from "./transformations-DM6huB9g.js";
+import { t as unpremultiplyAlpha } from "./alpha-Byel9eTg.js";
 import { convertToTexture, cos, length, screenUV, sin, vec2, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "Twirl",
@@ -82,7 +83,7 @@ const componentDefinition = {
 		const rotatedX = cosAngle.mul(aspectCorrectedDelta.x).sub(sinAngle.mul(aspectCorrectedDelta.y));
 		const rotatedY = sinAngle.mul(aspectCorrectedDelta.x).add(cosAngle.mul(aspectCorrectedDelta.y));
 		const twistedUV = vec2(rotatedX.div(aspect).add(centerPos.x), rotatedY.add(centerPos.y));
-		return applyEdgeHandling(twistedUV, texture$1.sample(twistedUV), texture$1, uniforms.edges.uniform);
+		return unpremultiplyAlpha(applyEdgeHandling(twistedUV, texture$1.sample(twistedUV), texture$1, uniforms.edges.uniform));
 	}
 };
 var Twirl_default = componentDefinition;

package/dist/core/{VideoTexture-DfsNWCXk.js → VideoTexture-DUk9pA_6.js}

@@ -1,4 +1,4 @@
-import { t as needsVideoCanvasWorkaround } from "./browser-Dcr7w1AA.js";
+import { t as needsVideoCanvasWorkaround } from "./browser-C7ZSkE-t.js";
 import { CanvasTexture, SRGBColorSpace, VideoTexture } from "three/webgpu";
 import { float, max, min, or, screenUV, select, step, texture, uniform, vec2, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {

package/dist/core/{WaveDistortion-xj8fjAf_.js → WaveDistortion-Dv8k3RMK.js}

@@ -1,6 +1,7 @@
 import { t as applyEdgeHandling } from "./edges-Bd7GP4s2.js";
-import { o as transformEdges } from "./transformations-CC_c-QAT.js";
+import { o as transformEdges } from "./transformations-DM6huB9g.js";
 import { t as createAnimatedTime } from "./time-BZqyVJXt.js";
+import { t as unpremultiplyAlpha } from "./alpha-Byel9eTg.js";
 import { PI, abs, convertToTexture, cos, float, fract, screenUV, sin, step, vec2, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "WaveDistortion",
@@ -151,7 +152,7 @@ const componentDefinition = {
 		onCleanup(() => {
 			if (childTexture?.renderTarget?.dispose) childTexture.renderTarget.dispose();
 		});
-		return applyEdgeHandling(distortedUV, childTexture.sample(distortedUV), childTexture, uniforms.edges.uniform);
+		return unpremultiplyAlpha(applyEdgeHandling(distortedUV, childTexture.sample(distortedUV), childTexture, uniforms.edges.uniform));
 	}
 };
 var WaveDistortion_default = componentDefinition;

package/dist/core/{WebcamTexture-Cxppkhiu.js → WebcamTexture-BmeO4qY-.js}

@@ -1,4 +1,4 @@
-import { t as needsVideoCanvasWorkaround } from "./browser-Dcr7w1AA.js";
+import { t as needsVideoCanvasWorkaround } from "./browser-C7ZSkE-t.js";
 import { CanvasTexture, SRGBColorSpace, VideoTexture } from "three/webgpu";
 import { float, max, min, or, screenUV, select, step, texture, uniform, vec2, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {

package/dist/core/{ZoomBlur-BePhHTgF.js → ZoomBlur-CCSC20me.js}

@@ -1,4 +1,5 @@
-import { s as transformPosition } from "./transformations-CC_c-QAT.js";
+import { s as transformPosition } from "./transformations-DM6huB9g.js";
+import { t as unpremultiplyAlpha } from "./alpha-Byel9eTg.js";
 import { Fn, convertToTexture, float, screenUV, vec2, vec4, viewportSize } from "three/tsl";
 var rawWeights = Array.from({ length: 32 }, (_, i) => {
 	const t = (i / 31 - .5) * 2;
@@ -59,7 +60,7 @@ const componentDefinition = {
 				const scaledCoord = vec2(scaledDelta.x.div(aspect), scaledDelta.y).add(center);
 				total.assign(total.add(childTexture.sample(scaledCoord).mul(float(blurWeights[i]))));
 			}
-			return total;
+			return unpremultiplyAlpha(total);
 		})();
 	}
 };

package/dist/core/alpha-Byel9eTg.js

@@ -0,0 +1,6 @@
+import { vec3, vec4 } from "three/tsl";
+const unpremultiplyAlpha = (color) => {
+	const alpha = color.a;
+	return vec4(alpha.greaterThan(.001).select(color.rgb.div(alpha), vec3(0, 0, 0)), alpha);
+};
+export { unpremultiplyAlpha as t };

package/dist/core/colorMixing-D_wMclqL.js

@@ -0,0 +1,196 @@
+import { abs, atan, cos, float, max, min, mod, pow, sign, sin, sqrt, vec3, vec4 } from "three/tsl";
+var EPSILON = float(1e-4);
+var PI_OVER_3 = 1.0471975512;
+var LAB_DELTA = float(6 / 29);
+var LAB_KAPPA = float(500);
+var LAB_LAMBDA = float(200);
+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_ = sign(l).mul(pow(abs(l), float(1 / 3)));
+	const m_ = sign(m).mul(pow(abs(m), float(1 / 3)));
+	const s_ = sign(s).mul(pow(abs(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)));
+};
+var selectRGBBySector = (c, x, sector) => {
+	const isSector0 = sector.lessThan(float(1));
+	const isSector1 = sector.greaterThanEqual(float(1)).and(sector.lessThan(float(2)));
+	const isSector2 = sector.greaterThanEqual(float(2)).and(sector.lessThan(float(3)));
+	const isSector3 = sector.greaterThanEqual(float(3)).and(sector.lessThan(float(4)));
+	const isSector4 = sector.greaterThanEqual(float(4)).and(sector.lessThan(float(5)));
+	return {
+		r: isSector0.select(c, isSector1.select(x, isSector2.select(float(0), isSector3.select(float(0), isSector4.select(x, c))))),
+		g: isSector0.select(x, isSector1.select(c, isSector2.select(c, isSector3.select(x, isSector4.select(float(0), float(0)))))),
+		b: isSector0.select(float(0), isSector1.select(float(0), isSector2.select(x, isSector3.select(c, isSector4.select(c, x)))))
+	};
+};
+var rgbToHsl = (rgb) => {
+	const r = rgb.x;
+	const g = rgb.y;
+	const b = rgb.z;
+	const maxVal = max(max(r, g), b);
+	const minVal = min(min(r, g), b);
+	const delta = maxVal.sub(minVal);
+	const l = maxVal.add(minVal).mul(.5);
+	const satDenom = float(1).sub(abs(l.mul(2).sub(1))).max(EPSILON);
+	const s = delta.div(satDenom);
+	const isRMax = maxVal.equal(r);
+	const isGMax = maxVal.equal(g);
+	const hueR = g.sub(b).div(delta.max(EPSILON));
+	const hueG = float(2).add(b.sub(r).div(delta.max(EPSILON)));
+	const hueB = float(4).add(r.sub(g).div(delta.max(EPSILON)));
+	return vec3(isRMax.select(hueR, isGMax.select(hueG, hueB)).mul(PI_OVER_3), s, l);
+};
+var hslToRgb = (hsl) => {
+	const h = hsl.x;
+	const s = hsl.y;
+	const l = hsl.z;
+	const c = s.mul(float(1).sub(abs(l.mul(2).sub(1))));
+	const hPrime = h.div(PI_OVER_3);
+	const x = c.mul(float(1).sub(abs(mod(hPrime, float(2)).sub(1))));
+	const m = l.sub(c.mul(.5));
+	const rgb = selectRGBBySector(c, x, hPrime.floor());
+	return vec3(rgb.r.add(m), rgb.g.add(m), rgb.b.add(m));
+};
+var rgbToHsv = (rgb) => {
+	const r = rgb.x;
+	const g = rgb.y;
+	const b = rgb.z;
+	const maxVal = max(max(r, g), b);
+	const minVal = min(min(r, g), b);
+	const delta = maxVal.sub(minVal);
+	const v = maxVal;
+	const s = delta.div(maxVal.max(EPSILON));
+	const isRMax = maxVal.equal(r);
+	const isGMax = maxVal.equal(g);
+	const hueR = g.sub(b).div(delta.max(EPSILON));
+	const hueG = float(2).add(b.sub(r).div(delta.max(EPSILON)));
+	const hueB = float(4).add(r.sub(g).div(delta.max(EPSILON)));
+	return vec3(isRMax.select(hueR, isGMax.select(hueG, hueB)).mul(PI_OVER_3), s, v);
+};
+var hsvToRgb = (hsv) => {
+	const h = hsv.x;
+	const s = hsv.y;
+	const v = hsv.z;
+	const c = v.mul(s);
+	const hPrime = h.div(PI_OVER_3);
+	const x = c.mul(float(1).sub(abs(mod(hPrime, float(2)).sub(1))));
+	const m = v.sub(c);
+	const rgb = selectRGBBySector(c, x, hPrime.floor());
+	return vec3(rgb.r.add(m), rgb.g.add(m), rgb.b.add(m));
+};
+var rgbToLab = (rgb) => {
+	const r = rgb.x;
+	const g = rgb.y;
+	const b = rgb.z;
+	const x = r.mul(.4124564).add(g.mul(.3575761)).add(b.mul(.1804375));
+	const y = r.mul(.2126729).add(g.mul(.7151522)).add(b.mul(.072175));
+	const z = r.mul(.0193339).add(g.mul(.119192)).add(b.mul(.9503041));
+	const xn = x.div(.95047);
+	const yn = y.div(1);
+	const zn = z.div(1.08883);
+	const delta3 = LAB_DELTA.mul(LAB_DELTA).mul(LAB_DELTA);
+	const slope = float(1).div(float(3).mul(LAB_DELTA).mul(LAB_DELTA));
+	const offset = float(4 / 29);
+	const fx = xn.greaterThan(delta3).select(pow(xn, float(1 / 3)), xn.mul(slope).add(offset));
+	const fy = yn.greaterThan(delta3).select(pow(yn, float(1 / 3)), yn.mul(slope).add(offset));
+	const fz = zn.greaterThan(delta3).select(pow(zn, float(1 / 3)), zn.mul(slope).add(offset));
+	return vec3(fy.mul(116).sub(16), fx.sub(fy).mul(LAB_KAPPA), fy.sub(fz).mul(LAB_LAMBDA));
+};
+var labToRgb = (lab) => {
+	const L = lab.x;
+	const a = lab.y;
+	const b = lab.z;
+	const fy = L.add(16).div(116);
+	const fx = a.div(LAB_KAPPA).add(fy);
+	const fz = fy.sub(b.div(LAB_LAMBDA));
+	const slope = float(3).mul(LAB_DELTA).mul(LAB_DELTA);
+	const offset = float(4 / 29);
+	const xn = fx.greaterThan(LAB_DELTA).select(pow(fx, float(3)), fx.sub(offset).mul(slope));
+	const yn = fy.greaterThan(LAB_DELTA).select(pow(fy, float(3)), fy.sub(offset).mul(slope));
+	const zn = fz.greaterThan(LAB_DELTA).select(pow(fz, float(3)), fz.sub(offset).mul(slope));
+	const x = xn.mul(.95047);
+	const y = yn.mul(1);
+	const z = zn.mul(1.08883);
+	return vec3(x.mul(3.2404542).sub(y.mul(1.5371385)).sub(z.mul(.4985314)), x.mul(-.969266).add(y.mul(1.8760108)).add(z.mul(.041556)), x.mul(.0556434).sub(y.mul(.2040259)).add(z.mul(1.0572252)));
+};
+var labToLch = (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 lchToLab = (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 hslResult = sRGBToP3(hslToRgb(alphaWeightedMix(rgbToHsl(srgbA), rgbToHsl(srgbB))));
+	const hsvResult = sRGBToP3(hsvToRgb(alphaWeightedMix(rgbToHsv(srgbA), rgbToHsv(srgbB))));
+	const labA = rgbToLab(srgbA);
+	const labB = rgbToLab(srgbB);
+	const lchResult = sRGBToP3(labToRgb(lchToLab(alphaWeightedMix(labToLch(labA), labToLch(labB)))));
+	const isMode1OrHigher = colorSpaceMode.greaterThanEqual(float(.5));
+	const isMode2OrHigher = colorSpaceMode.greaterThanEqual(float(1.5));
+	const isMode3OrHigher = colorSpaceMode.greaterThanEqual(float(2.5));
+	const isMode4OrHigher = colorSpaceMode.greaterThanEqual(float(3.5));
+	const isMode5 = colorSpaceMode.greaterThanEqual(float(4.5));
+	const rgb = isMode1OrHigher.select(isMode2OrHigher.select(isMode3OrHigher.select(isMode4OrHigher.select(isMode5.select(lchResult, hsvResult), hslResult), oklabResult), oklchResult), linearMix);
+	const alpha = totalWeight;
+	return vec4(rgb.x, rgb.y, rgb.z, alpha);
+};
+export { mixColors as t };

package/dist/core/index.js

@@ -1,5 +1,5 @@
 import { t as applyEdgeHandling } from "./edges-Bd7GP4s2.js";
-import { a as transformColorUpdate, c as transformPositionUpdate, r as transformColor, s as transformPosition } from "./transformations-CC_c-QAT.js";
+import { a as transformColorUpdate, c as transformPositionUpdate, r as transformColor, s as transformPosition } from "./transformations-DM6huB9g.js";
 import { t as createAnimatedTime } from "./time-BZqyVJXt.js";
 import { Material, Mesh, MeshBasicNodeMaterial, OrthographicCamera, PlaneGeometry, SRGBColorSpace, Scene, WebGPURenderer } from "three/webgpu";
 import { WebGLRenderer } from "three";