shaders 2.5.116 → 2.5.118

package/dist/core/BarShift-2XBhva1A.js

@@ -0,0 +1,141 @@
+import { t as applyEdgeHandling } from "./edges-CX_lJB9R.js";
+import { c as transformEdges, r as transformAngle } from "./transformations-CJcUeZIC.js";
+import { t as unpremultiplyAlpha } from "./alpha-C4ptedXe.js";
+import { t as createAnimatedTime } from "./time-DUqSFWvT.js";
+import { Fn, convertToTexture, cos, float, floor, fract, screenUV, sin, vec2, vec4, viewportSize } from "three/tsl";
+const componentDefinition = {
+	name: "BarShift",
+	category: "Distortions",
+	description: "Slices content into parallel bars, each offset independently for a fractured or glitch-like effect",
+	requiresRTT: true,
+	requiresChild: true,
+	props: {
+		count: {
+			default: 6,
+			description: "Number of bars across the longest viewport dimension",
+			ui: {
+				type: ["range", "map"],
+				min: 1,
+				max: 30,
+				step: 1,
+				label: "Count",
+				group: "Effect"
+			}
+		},
+		angle: {
+			default: 0,
+			transform: transformAngle,
+			description: "Angle of bar orientation in degrees (0 = vertical bars, 90 = horizontal bars)",
+			ui: {
+				type: ["range", "map"],
+				min: -180,
+				max: 180,
+				step: 1,
+				label: "Angle",
+				group: "Effect"
+			}
+		},
+		intensity: {
+			default: .15,
+			description: "Maximum displacement per bar",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Intensity",
+				group: "Effect"
+			}
+		},
+		seed: {
+			default: 0,
+			description: "Randomization seed for per-bar offset variation",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 100,
+				step: 1,
+				label: "Seed",
+				group: "Effect"
+			}
+		},
+		speed: {
+			default: 0,
+			description: "Animation speed — each bar drifts at its own rate and direction",
+			ui: {
+				type: "range",
+				min: -2,
+				max: 2,
+				step: .1,
+				label: "Speed",
+				group: "Animation"
+			}
+		},
+		edges: {
+			default: "mirror",
+			description: "How to handle edges when distortion pushes content out of bounds",
+			transform: transformEdges,
+			compileTime: true,
+			ui: {
+				type: "select",
+				options: [
+					{
+						label: "Stretch",
+						value: "stretch"
+					},
+					{
+						label: "Transparent",
+						value: "transparent"
+					},
+					{
+						label: "Mirror",
+						value: "mirror"
+					},
+					{
+						label: "Wrap",
+						value: "wrap"
+					}
+				],
+				label: "Edges",
+				group: "Effect"
+			}
+		}
+	},
+	fragmentNode: (params) => {
+		const { uniforms, childNode, onCleanup } = params;
+		if (!childNode) return vec4(0, 0, 0, 0);
+		const childTexture = convertToTexture(childNode);
+		onCleanup(() => {
+			if (childTexture?.renderTarget?.dispose) childTexture.renderTarget.dispose();
+		});
+		const aspect = viewportSize.x.div(viewportSize.y);
+		const animTime = createAnimatedTime(params, uniforms.speed);
+		const hash = (x) => fract(sin(x.mul(12.9898)).mul(43758.5453)).sub(.5).mul(2);
+		const angleRad = uniforms.angle.uniform.mul(.0174533);
+		const cosA = cos(angleRad);
+		const sinA = sin(angleRad);
+		const longestAxis = aspect.max(float(1));
+		return Fn(() => {
+			const uv$1 = screenUV;
+			const au = uv$1.x.mul(aspect);
+			const av = uv$1.y;
+			const cu = au.sub(aspect.mul(.5));
+			const cv = av.sub(.5);
+			const projectedU = cu.mul(cosA).add(cv.mul(sinA));
+			const projectedV = cu.mul(sinA).negate().add(cv.mul(cosA));
+			const barIndex = floor(projectedU.mul(uniforms.count.uniform).div(longestAxis));
+			const seedOffset = uniforms.seed.uniform.mul(.137);
+			const staticOffset = hash(barIndex.add(seedOffset));
+			const barSpeed = hash(barIndex.add(seedOffset).add(float(42.7)));
+			const animOffset = animTime.mul(barSpeed).mul(.2);
+			const offset = staticOffset.add(animOffset).mul(uniforms.intensity.uniform);
+			const distPV = projectedV.add(offset);
+			const dcu = projectedU.mul(cosA).sub(distPV.mul(sinA));
+			const dcv = projectedU.mul(sinA).add(distPV.mul(cosA));
+			const sampleUV = vec2(dcu.div(aspect).add(.5), dcv.add(.5));
+			return unpremultiplyAlpha(applyEdgeHandling(sampleUV, childTexture.sample(sampleUV), childTexture, uniforms.edges.uniform.value));
+		})();
+	}
+};
+var BarShift_default = componentDefinition;
+export { componentDefinition as n, BarShift_default as t };

package/dist/core/{Blur-DG7lJKPo.js → Blur-5_t3tR_g.js}

@@ -1,5 +1,5 @@
 import { t as unpremultiplyAlpha } from "./alpha-C4ptedXe.js";
-import { i as createVariableGaussianBlurCompute, r as createGaussianBlurCompute } from "./computeBlur-DCRhuYEi.js";
+import { i as createVariableGaussianBlurCompute, r as createGaussianBlurCompute } from "./computeBlur-CprKe0xa.js";
 import { Fn, If, clamp, convertToTexture, dot, float, instanceIndex, int, mix, pow, screenUV, texture, textureLoad, textureStore, uint, uniform, uvec2, vec2, vec3, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "Blur",

package/dist/core/BrickPattern-BfTsjp4I.js

@@ -0,0 +1,175 @@
+import { a as transformColor, o as transformColorSpace, r as transformAngle, t as colorSpaceOptions } from "./transformations-CJcUeZIC.js";
+import { t as mixColors } from "./colorMixing-BPpDnR5I.js";
+import { t as createAnimatedTime } from "./time-DUqSFWvT.js";
+import { cos, float, floor, fract, mix, mod, screenUV, sin, step, vec4, viewportSize } from "three/tsl";
+const componentDefinition = {
+	name: "BrickPattern",
+	category: "Textures",
+	description: "Classic brick wall pattern with alternating rows and mortar gaps",
+	props: {
+		colorBrick: {
+			default: "#000000",
+			transform: transformColor,
+			description: "Brick color",
+			ui: {
+				type: "color",
+				label: "Brick Color",
+				group: "Colors"
+			}
+		},
+		colorMortar: {
+			default: "#ffffff",
+			transform: transformColor,
+			description: "Mortar / gap color",
+			ui: {
+				type: "color",
+				label: "Mortar Color",
+				group: "Colors"
+			}
+		},
+		cellsX: {
+			default: 8,
+			description: "Number of bricks per row",
+			ui: {
+				type: ["range", "map"],
+				min: 1,
+				max: 30,
+				step: 1,
+				label: "Bricks per Row",
+				group: "Effect"
+			}
+		},
+		cellsY: {
+			default: 10,
+			description: "Number of brick rows",
+			ui: {
+				type: ["range", "map"],
+				min: 1,
+				max: 30,
+				step: 1,
+				label: "Rows",
+				group: "Effect"
+			}
+		},
+		mortar: {
+			default: .05,
+			description: "Width of mortar gaps — equal pixel thickness in both directions",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Mortar Gap",
+				group: "Effect"
+			}
+		},
+		angle: {
+			default: 0,
+			transform: transformAngle,
+			description: "Rotation angle in degrees",
+			ui: {
+				type: ["range", "map"],
+				min: -180,
+				max: 180,
+				step: 1,
+				label: "Angle",
+				group: "Effect"
+			}
+		},
+		speed: {
+			default: 0,
+			description: "Animation speed",
+			ui: {
+				type: "range",
+				min: -2,
+				max: 2,
+				step: .1,
+				label: "Speed",
+				group: "Animation"
+			}
+		},
+		offset: {
+			default: 0,
+			description: "Static horizontal offset — shifts the brick pattern without animating",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Offset",
+				group: "Animation"
+			}
+		},
+		speedVariance: {
+			default: 0,
+			description: "How much each row's speed varies — at high values rows move at different speeds and directions",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Speed Variance",
+				group: "Animation"
+			}
+		},
+		seed: {
+			default: 0,
+			description: "Random seed for per-row speed variation",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 100,
+				step: 1,
+				label: "Seed",
+				group: "Animation"
+			}
+		},
+		colorSpace: {
+			default: "linear",
+			transform: transformColorSpace,
+			compileTime: true,
+			description: "Color space for interpolation",
+			ui: {
+				type: "select",
+				options: colorSpaceOptions,
+				label: "Color Space",
+				group: "Colors"
+			}
+		}
+	},
+	fragmentNode: (params) => {
+		const { uniforms } = params;
+		const uv$1 = screenUV;
+		const aspect = viewportSize.x.div(viewportSize.y);
+		const au = uv$1.x.mul(aspect);
+		const av = uv$1.y;
+		const cu = au.sub(aspect.mul(.5));
+		const cv = av.sub(float(.5));
+		const rotRad = uniforms.angle.uniform.mul(float(.0174533));
+		const cosR = cos(rotRad);
+		const sinR = sin(rotRad);
+		const ru = cu.mul(cosR).add(cv.mul(sinR));
+		const rv = cu.mul(sinR).negate().add(cv.mul(cosR));
+		const u = ru.div(aspect).add(float(.5));
+		const v = rv.add(float(.5));
+		const cellsX = uniforms.cellsX.uniform;
+		const cellsY = uniforms.cellsY.uniform;
+		const animTime = createAnimatedTime(params, uniforms.speed);
+		const mortarU = uniforms.mortar.uniform.mul(float(.3));
+		const mortarV = mortarU.mul(aspect).mul(cellsY).div(cellsX);
+		const row = floor(v.mul(cellsY));
+		const rowOffset = mod(row, float(2)).mul(.5);
+		const rowDir = mod(row, float(2)).mul(2).sub(1);
+		const seedVal = uniforms.seed.uniform;
+		const rowSpeedMult = mix(rowDir, fract(sin(row.add(seedVal.mul(.137))).mul(43758.5453)).sub(.5).mul(2), uniforms.speedVariance.uniform);
+		const cellU = fract(u.mul(cellsX).add(rowOffset).add(animTime.mul(rowSpeedMult)).add(uniforms.offset.uniform));
+		const cellV = fract(v.mul(cellsY));
+		const brickU = step(mortarU, cellU).mul(step(mortarU, float(1).sub(cellU)));
+		const brickV = step(mortarV, cellV).mul(step(mortarV, float(1).sub(cellV)));
+		const brickMask = brickU.mul(brickV);
+		const result = mixColors(uniforms.colorMortar.uniform, uniforms.colorBrick.uniform, brickMask, uniforms.colorSpace.uniform.value);
+		return vec4(result.rgb, result.a);
+	}
+};
+var BrickPattern_default = componentDefinition;
+export { componentDefinition as n, BrickPattern_default as t };

package/dist/core/{ChannelBlur-BhcCkwcO.js → ChannelBlur-DWgS3nhn.js}

@@ -1,5 +1,5 @@
 import { t as unpremultiplyAlpha } from "./alpha-C4ptedXe.js";
-import { r as createGaussianBlurCompute } from "./computeBlur-DCRhuYEi.js";
+import { r as createGaussianBlurCompute } from "./computeBlur-CprKe0xa.js";
 import { Fn, convertToTexture, float, mix, screenUV, texture, vec2, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "ChannelBlur",

package/dist/core/Chevron-BKZjAXR_.js

@@ -0,0 +1,142 @@
+import { a as transformColor, o as transformColorSpace, r as transformAngle, t as colorSpaceOptions } from "./transformations-CJcUeZIC.js";
+import { t as mixColors } from "./colorMixing-BPpDnR5I.js";
+import { t as createAnimatedTime } from "./time-DUqSFWvT.js";
+import { cos, fract, fwidth, mix, screenUV, sin, smoothstep, vec4, viewportSize } from "three/tsl";
+const componentDefinition = {
+	name: "Chevron",
+	category: "Textures",
+	description: "Animated chevron / zigzag stripe pattern",
+	props: {
+		colorA: {
+			default: "#000000",
+			transform: transformColor,
+			description: "First color",
+			ui: {
+				type: "color",
+				label: "Color A",
+				group: "Colors"
+			}
+		},
+		colorB: {
+			default: "#ffffff",
+			transform: transformColor,
+			description: "Second color",
+			ui: {
+				type: "color",
+				label: "Color B",
+				group: "Colors"
+			}
+		},
+		count: {
+			default: 5,
+			description: "Number of chevron pairs visible",
+			ui: {
+				type: ["range", "map"],
+				min: 1,
+				max: 30,
+				step: 1,
+				label: "Count",
+				group: "Effect"
+			}
+		},
+		angle: {
+			default: 0,
+			transform: transformAngle,
+			description: "Rotation angle of the chevrons",
+			ui: {
+				type: ["range", "map"],
+				min: -180,
+				max: 180,
+				step: 1,
+				label: "Angle",
+				group: "Effect"
+			}
+		},
+		balance: {
+			default: .5,
+			description: "Ratio of the two colors",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Balance",
+				group: "Effect"
+			}
+		},
+		softness: {
+			default: 0,
+			description: "Edge softness",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Softness",
+				group: "Effect"
+			}
+		},
+		speed: {
+			default: 0,
+			description: "Animation speed",
+			ui: {
+				type: "range",
+				min: -2,
+				max: 2,
+				step: .1,
+				label: "Speed",
+				group: "Animation"
+			}
+		},
+		offset: {
+			default: 0,
+			description: "Phase offset for pattern positioning",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Offset",
+				group: "Animation"
+			}
+		},
+		colorSpace: {
+			default: "linear",
+			transform: transformColorSpace,
+			compileTime: true,
+			description: "Color space for interpolation",
+			ui: {
+				type: "select",
+				options: colorSpaceOptions,
+				label: "Color Space",
+				group: "Colors"
+			}
+		}
+	},
+	fragmentNode: (params) => {
+		const { uniforms } = params;
+		const uv$1 = screenUV;
+		const aspect = viewportSize.x.div(viewportSize.y);
+		const au = uv$1.x.mul(aspect);
+		const av = uv$1.y;
+		const angleRad = uniforms.angle.uniform.mul(.0174533);
+		const cosA = cos(angleRad);
+		const sinA = sin(angleRad);
+		const cu = au.sub(aspect.mul(.5));
+		const cv = av.sub(.5);
+		const rotU = cu.mul(cosA).add(cv.mul(sinA));
+		const rotV = cu.mul(sinA).negate().add(cv.mul(cosA));
+		const count = uniforms.count.uniform;
+		const animTime = createAnimatedTime(params, uniforms.speed);
+		const zigzag = fract(rotV.mul(count)).sub(.5).abs().mul(2);
+		const stripeCoord = rotU.mul(count).add(zigzag.mul(.5)).add(animTime).add(uniforms.offset.uniform);
+		const pattern = fract(stripeCoord);
+		const fw = fwidth(stripeCoord);
+		const balance = uniforms.balance.uniform;
+		const soft = uniforms.softness.uniform;
+		const mask = smoothstep(balance.sub(soft).sub(fw), balance.add(soft).add(fw), pattern);
+		return vec4(mixColors(uniforms.colorA.uniform, uniforms.colorB.uniform, mask, uniforms.colorSpace.uniform.value).rgb, mix(uniforms.colorA.uniform.a, uniforms.colorB.uniform.a, mask));
+	}
+};
+var Chevron_default = componentDefinition;
+export { componentDefinition as n, Chevron_default as t };

package/dist/core/ColorWheel-BQUKQPM-.js

@@ -0,0 +1,140 @@
+import { a as transformColor, o as transformColorSpace, r as transformAngle, t as colorSpaceOptions } from "./transformations-CJcUeZIC.js";
+import { t as mixColors } from "./colorMixing-BPpDnR5I.js";
+import { t as createAnimatedTime } from "./time-DUqSFWvT.js";
+import { clamp, cos, float, floor, fract, mix, screenUV, sin, step, vec4, viewportSize } from "three/tsl";
+const componentDefinition = {
+	name: "ColorWheel",
+	category: "Textures",
+	description: "A directional gradient that smoothly cycles through rainbow colors or a custom set of three colors",
+	props: {
+		mode: {
+			default: "rainbow",
+			compileTime: true,
+			description: "Rainbow cycles through the full spectrum; Custom loops through your three chosen colors",
+			ui: {
+				type: "select",
+				options: [{
+					label: "Rainbow",
+					value: "rainbow"
+				}, {
+					label: "Custom",
+					value: "custom"
+				}],
+				label: "Mode",
+				group: "Colors"
+			}
+		},
+		colorA: {
+			default: "#ff0000",
+			transform: transformColor,
+			description: "First color in the cycle",
+			ui: {
+				type: "color",
+				label: "Color 1",
+				group: "Colors",
+				condition: { mode: "custom" }
+			}
+		},
+		colorB: {
+			default: "#00ff88",
+			transform: transformColor,
+			description: "Second color in the cycle",
+			ui: {
+				type: "color",
+				label: "Color 2",
+				group: "Colors",
+				condition: { mode: "custom" }
+			}
+		},
+		colorC: {
+			default: "#0066ff",
+			transform: transformColor,
+			description: "Third color in the cycle",
+			ui: {
+				type: "color",
+				label: "Color 3",
+				group: "Colors",
+				condition: { mode: "custom" }
+			}
+		},
+		scale: {
+			default: 1,
+			description: "Number of color cycles across the viewport",
+			ui: {
+				type: ["range", "map"],
+				min: .1,
+				max: 10,
+				step: .1,
+				label: "Scale",
+				group: "Effect"
+			}
+		},
+		angle: {
+			default: 0,
+			transform: transformAngle,
+			description: "Direction the gradient flows",
+			ui: {
+				type: ["range", "map"],
+				min: -180,
+				max: 180,
+				step: 1,
+				label: "Angle",
+				group: "Effect"
+			}
+		},
+		speed: {
+			default: .05,
+			description: "Speed at which the gradient cycles",
+			ui: {
+				type: "range",
+				min: -1,
+				max: 1,
+				step: .01,
+				label: "Speed",
+				group: "Animation"
+			}
+		},
+		colorSpace: {
+			default: "oklch",
+			transform: transformColorSpace,
+			compileTime: true,
+			description: "Color space for blending between custom colors",
+			ui: {
+				type: "select",
+				options: colorSpaceOptions,
+				label: "Color Space",
+				group: "Colors",
+				condition: { mode: "custom" }
+			}
+		}
+	},
+	fragmentNode: (params) => {
+		const { uniforms } = params;
+		const uv$1 = screenUV;
+		const aspect = viewportSize.x.div(viewportSize.y);
+		const angleRad = uniforms.angle.uniform.mul(.0174533);
+		const cosA = cos(angleRad);
+		const sinA = sin(angleRad);
+		const au = uv$1.x.mul(aspect);
+		const av = uv$1.y;
+		const projectedCoord = au.mul(cosA).add(av.mul(sinA));
+		const animTime = createAnimatedTime(params, uniforms.speed);
+		const t = fract(projectedCoord.mul(uniforms.scale.uniform).mul(float(.2)).add(animTime));
+		if (uniforms.mode.uniform.value === "rainbow") {
+			const h6 = t.mul(float(6));
+			return vec4(clamp(h6.sub(float(3)).abs().sub(float(1)), float(0), float(1)), clamp(float(2).sub(h6.sub(float(2)).abs()), float(0), float(1)), clamp(float(2).sub(h6.sub(float(4)).abs()), float(0), float(1)), float(1));
+		} else {
+			const t3 = t.mul(float(3));
+			const si = fract(t3);
+			const floorT3 = floor(t3);
+			const c01 = mixColors(uniforms.colorA.uniform, uniforms.colorB.uniform, si, uniforms.colorSpace.uniform.value);
+			const c12 = mixColors(uniforms.colorB.uniform, uniforms.colorC.uniform, si, uniforms.colorSpace.uniform.value);
+			let result = mixColors(uniforms.colorC.uniform, uniforms.colorA.uniform, si, uniforms.colorSpace.uniform.value);
+			result = mix(result, c12, step(floorT3, float(1.5)));
+			result = mix(result, c01, step(floorT3, float(.5)));
+			return vec4(result.rgb, result.a);
+		}
+	}
+};
+var ColorWheel_default = componentDefinition;
+export { componentDefinition as n, ColorWheel_default as t };

package/dist/core/{Crescent-DiioCL2k.js → Crescent-ppz7W7eM.js}

@@ -1,6 +1,6 @@
 import { a as transformColor, l as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CJcUeZIC.js";
 import { t as mixColors } from "./colorMixing-BPpDnR5I.js";
-import { i as crescentSdf } from "./sdf-DyC2H_qS.js";
+import { i as crescentSdf } from "./sdf-D_EAGXhN.js";
 import { cos, float, screenUV, sin, smoothstep, vec2, vec4, viewportSize } from "three/tsl";
 var transformStrokePosition = (value) => {
 	return {

package/dist/core/{Cross-CxQTHuxC.js → Cross-BfNOtQ6s.js}

@@ -1,6 +1,6 @@
 import { a as transformColor, l as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CJcUeZIC.js";
 import { t as mixColors } from "./colorMixing-BPpDnR5I.js";
-import { a as crossSdf } from "./sdf-DyC2H_qS.js";
+import { a as crossSdf } from "./sdf-D_EAGXhN.js";
 import { cos, float, screenUV, sin, smoothstep, vec2, vec4, viewportSize } from "three/tsl";
 var transformStrokePosition = (value) => {
 	return {

package/dist/core/{Crystal-B3iO7o_n.js → Crystal-QsQoy8fZ.js}

@@ -1,5 +1,5 @@
 import { a as transformColor, l as transformPosition } from "./transformations-CJcUeZIC.js";
-import { n as createAnalyticSdfSampler, r as createSvgSdfSampler } from "./sdf-DyC2H_qS.js";
+import { n as createAnalyticSdfSampler, r as createSvgSdfSampler } from "./sdf-D_EAGXhN.js";
 import { Fn, If, atan, clamp, convertToTexture, cos, dot, float, fract, max, min, mix, mx_worley_noise_float, pow, screenUV, sin, smoothstep, sqrt, vec2, vec3, vec4, viewportSize } from "three/tsl";
 var transformBoolean = (value) => value ? 1 : 0;
 var DEFAULT_SHAPE_CONFIG = JSON.stringify({

package/dist/core/{Ellipse-iwH-zEvD.js → Ellipse-sWhNvW9-.js}

@@ -1,6 +1,6 @@
 import { a as transformColor, l as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CJcUeZIC.js";
 import { t as mixColors } from "./colorMixing-BPpDnR5I.js";
-import { o as ellipseSdf } from "./sdf-DyC2H_qS.js";
+import { o as ellipseSdf } from "./sdf-D_EAGXhN.js";
 import { cos, float, screenUV, sin, smoothstep, vec2, vec4, viewportSize } from "three/tsl";
 var transformStrokePosition = (value) => {
 	return {

package/dist/core/{Emboss-B4i61QDT.js → Emboss-DGaubb9x.js}

@@ -1,5 +1,5 @@
 import { l as transformPosition } from "./transformations-CJcUeZIC.js";
-import { n as createAnalyticSdfSampler, r as createSvgSdfSampler } from "./sdf-DyC2H_qS.js";
+import { n as createAnalyticSdfSampler, r as createSvgSdfSampler } from "./sdf-D_EAGXhN.js";
 import { Fn, If, abs, clamp, convertToTexture, cos, float, max, screenUV, sin, smoothstep, sqrt, vec2, vec3, vec4, viewportSize } from "three/tsl";
 var _INV_LIGHT_LEN = 1 / Math.sqrt(1.49);
 var _LZN = .7 * _INV_LIGHT_LEN;

package/dist/core/{Flower-CdHVKJKu.js → Flower-BbRNrXIa.js}

@@ -1,6 +1,6 @@
 import { a as transformColor, l as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CJcUeZIC.js";
 import { t as mixColors } from "./colorMixing-BPpDnR5I.js";
-import { s as flowerSdf } from "./sdf-DyC2H_qS.js";
+import { s as flowerSdf } from "./sdf-D_EAGXhN.js";
 import { cos, float, screenUV, sin, smoothstep, vec2, vec4, viewportSize } from "three/tsl";
 var transformStrokePosition = (value) => {
 	return {