shaders 2.5.117 → 2.5.119

package/dist/core/FractalNoise-Ccufnbw6.js

@@ -0,0 +1,184 @@
+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, mx_noise_float, screenUV, sin, vec2, vec4, viewportSize } from "three/tsl";
+var GOLDEN = 2.39996;
+const componentDefinition = {
+	name: "FractalNoise",
+	category: "Textures",
+	description: "Multi-octave fractal Brownian motion noise texture with true noise evolution",
+	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"
+			}
+		},
+		octaves: {
+			default: 4,
+			compileTime: true,
+			description: "Number of noise octaves (more = more detail)",
+			ui: {
+				type: "range",
+				min: 1,
+				max: 8,
+				step: 1,
+				label: "Octaves",
+				group: "Effect"
+			}
+		},
+		detail: {
+			default: 2,
+			description: "How much finer each successive octave becomes",
+			ui: {
+				type: ["range", "map"],
+				min: 1,
+				max: 4,
+				step: .1,
+				label: "Detail",
+				group: "Effect"
+			}
+		},
+		contrast: {
+			default: .5,
+			description: "How strongly finer octaves contribute — higher values create more texture contrast",
+			ui: {
+				type: ["range", "map"],
+				min: .1,
+				max: 1,
+				step: .05,
+				label: "Contrast",
+				group: "Effect"
+			}
+		},
+		speed: {
+			default: .15,
+			description: "Speed at which the noise pattern evolves in place",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Speed",
+				group: "Animation"
+			}
+		},
+		angle: {
+			default: 0,
+			transform: transformAngle,
+			description: "Rotation angle in degrees",
+			ui: {
+				type: ["range", "map"],
+				min: -180,
+				max: 180,
+				step: 1,
+				label: "Angle",
+				group: "Effect"
+			}
+		},
+		seed: {
+			default: 0,
+			description: "Random seed for pattern variation",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 100,
+				step: 1,
+				label: "Seed",
+				group: "Effect"
+			}
+		},
+		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 angleRad = uniforms.angle.uniform.mul(.0174533);
+		const cosA = cos(angleRad);
+		const sinA = sin(angleRad);
+		const au = uv$1.x.mul(aspect).sub(aspect.mul(.5));
+		const av = uv$1.y.sub(.5);
+		const ru = au.mul(cosA).add(av.mul(sinA));
+		const rv = au.mul(sinA).negate().add(av.mul(cosA));
+		const animTime = createAnimatedTime(params, uniforms.speed);
+		const scale = float(2);
+		const seedVal = uniforms.seed.uniform;
+		const l = uniforms.detail.uniform;
+		const p = uniforms.contrast.uniform;
+		const d = (i) => ({
+			x: Math.cos(i * GOLDEN),
+			y: Math.sin(i * GOLDEN)
+		});
+		const coord = (octaveScale, i) => vec2(ru.mul(octaveScale).add(animTime.mul(float(d(i).x))).add(seedVal), rv.mul(octaveScale).add(animTime.mul(float(d(i).y))).add(seedVal.mul(.7)));
+		const n1 = mx_noise_float(coord(scale, 0));
+		const n2 = mx_noise_float(coord(scale.mul(l), 1)).mul(p);
+		const n3 = mx_noise_float(coord(scale.mul(l).mul(l), 2)).mul(p).mul(p);
+		const n4 = mx_noise_float(coord(scale.mul(l).mul(l).mul(l), 3)).mul(p).mul(p).mul(p);
+		const n5 = mx_noise_float(coord(scale.mul(l).mul(l).mul(l).mul(l), 4)).mul(p).mul(p).mul(p).mul(p);
+		const n6 = mx_noise_float(coord(scale.mul(l).mul(l).mul(l).mul(l).mul(l), 5)).mul(p).mul(p).mul(p).mul(p).mul(p);
+		const n7 = mx_noise_float(coord(scale.mul(l).mul(l).mul(l).mul(l).mul(l).mul(l), 6)).mul(p).mul(p).mul(p).mul(p).mul(p).mul(p);
+		const n8 = mx_noise_float(coord(scale.mul(l).mul(l).mul(l).mul(l).mul(l).mul(l).mul(l), 7)).mul(p).mul(p).mul(p).mul(p).mul(p).mul(p).mul(p);
+		const octaveCount = uniforms.octaves.uniform.value;
+		let accumulated = n1;
+		let totalWeight = float(1);
+		if (octaveCount >= 2) {
+			accumulated = accumulated.add(n2);
+			totalWeight = totalWeight.add(p);
+		}
+		if (octaveCount >= 3) {
+			accumulated = accumulated.add(n3);
+			totalWeight = totalWeight.add(p.mul(p));
+		}
+		if (octaveCount >= 4) {
+			accumulated = accumulated.add(n4);
+			totalWeight = totalWeight.add(p.mul(p).mul(p));
+		}
+		if (octaveCount >= 5) {
+			accumulated = accumulated.add(n5);
+			totalWeight = totalWeight.add(p.mul(p).mul(p).mul(p));
+		}
+		if (octaveCount >= 6) {
+			accumulated = accumulated.add(n6);
+			totalWeight = totalWeight.add(p.mul(p).mul(p).mul(p).mul(p));
+		}
+		if (octaveCount >= 7) {
+			accumulated = accumulated.add(n7);
+			totalWeight = totalWeight.add(p.mul(p).mul(p).mul(p).mul(p).mul(p));
+		}
+		if (octaveCount >= 8) {
+			accumulated = accumulated.add(n8);
+			totalWeight = totalWeight.add(p.mul(p).mul(p).mul(p).mul(p).mul(p).mul(p));
+		}
+		const normalized = clamp(accumulated.div(totalWeight).mul(.5).add(.5), float(0), float(1));
+		const result = mixColors(uniforms.colorA.uniform, uniforms.colorB.uniform, normalized, uniforms.colorSpace.uniform.value);
+		return vec4(result.rgb, result.a);
+	}
+};
+var FractalNoise_default = componentDefinition;
+export { componentDefinition as n, FractalNoise_default as t };

package/dist/core/{Glass-B19xsZLn.js → Glass-CXT1jdLw.js}

@@ -1,6 +1,6 @@
 import { a as transformColor, l as transformPosition } from "./transformations-CJcUeZIC.js";
-import { r as createGaussianBlurCompute } from "./computeBlur-DCRhuYEi.js";
-import { n as createAnalyticSdfSampler, r as createSvgSdfSampler } from "./sdf-DyC2H_qS.js";
+import { r as createGaussianBlurCompute } from "./computeBlur-CprKe0xa.js";
+import { n as createAnalyticSdfSampler, r as createSvgSdfSampler } from "./sdf-D_EAGXhN.js";
 import { Fn, If, clamp, convertToTexture, dot, exp2, float, max, mix, pow, screenUV, smoothstep, sqrt, texture, uniform, vec2, vec3, vec4, viewportSize } from "three/tsl";
 var GOLDEN_ANGLE = 2.3999632297286535;
 var BLUR_SAMPLE_COUNT = 9;

package/dist/core/{Glow-CsTZA75y.js → Glow-5PP4-rM9.js}

@@ -1,5 +1,5 @@
 import { t as unpremultiplyAlpha } from "./alpha-C4ptedXe.js";
-import { i as createVariableGaussianBlurCompute, n as DEFAULT_COMPUTE_WIDTH, t as DEFAULT_COMPUTE_HEIGHT } from "./computeBlur-DCRhuYEi.js";
+import { i as createVariableGaussianBlurCompute, n as DEFAULT_COMPUTE_WIDTH, t as DEFAULT_COMPUTE_HEIGHT } from "./computeBlur-CprKe0xa.js";
 import { StorageTexture } from "three/webgpu";
 import { FloatType } from "three";
 import { Fn, If, clamp, convertToTexture, dot, float, instanceIndex, int, max, mix, pow, screenUV, storageTexture, texture, textureLoad, textureStore, uint, uniform, uvec2, vec2, vec3, vec4, viewportSize } from "three/tsl";

package/dist/core/Marble-DkHLcqFD.js

@@ -0,0 +1,124 @@
+import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CJcUeZIC.js";
+import { t as mixColors } from "./colorMixing-BPpDnR5I.js";
+import { t as createAnimatedTime } from "./time-DUqSFWvT.js";
+import { float, mx_noise_float, screenUV, sin, smoothstep, vec2, vec4, viewportSize } from "three/tsl";
+const componentDefinition = {
+	name: "Marble",
+	category: "Textures",
+	description: "Classic marble swirl and vein texture using noise-warped sine waves",
+	props: {
+		colorA: {
+			default: "#ffffff",
+			transform: transformColor,
+			description: "Base background color of the marble",
+			ui: {
+				type: "color",
+				label: "Base",
+				group: "Colors"
+			}
+		},
+		colorB: {
+			default: "#3a2d54",
+			transform: transformColor,
+			description: "Secondary marble tone",
+			ui: {
+				type: "color",
+				label: "Tone",
+				group: "Colors"
+			}
+		},
+		colorC: {
+			default: "#0f0f0f",
+			transform: transformColor,
+			description: "Deepest marble color",
+			ui: {
+				type: "color",
+				label: "Depth",
+				group: "Colors"
+			}
+		},
+		scale: {
+			default: 2,
+			description: "Scale and density of the marble vein pattern",
+			ui: {
+				type: ["range", "map"],
+				min: .1,
+				max: 10,
+				step: .1,
+				label: "Scale",
+				group: "Effect"
+			}
+		},
+		turbulence: {
+			default: 10,
+			description: "Amount of noise-driven distortion applied to the veins",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 50,
+				step: .5,
+				label: "Turbulence",
+				group: "Effect"
+			}
+		},
+		speed: {
+			default: .05,
+			description: "Animation speed",
+			ui: {
+				type: "range",
+				min: 0,
+				max: .25,
+				step: .005,
+				label: "Speed",
+				group: "Animation"
+			}
+		},
+		seed: {
+			default: 0,
+			description: "Random seed for pattern variation",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 100,
+				step: 1,
+				label: "Seed",
+				group: "Effect"
+			}
+		},
+		colorSpace: {
+			default: "linear",
+			transform: transformColorSpace,
+			compileTime: true,
+			description: "Color space for color 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 animTime = createAnimatedTime(params, uniforms.speed);
+		const scale = uniforms.scale.uniform;
+		const seedVal = uniforms.seed.uniform;
+		const n1 = mx_noise_float(vec2(au.mul(scale).add(seedVal), av.mul(scale).add(animTime)));
+		const n2 = mx_noise_float(vec2(au.mul(scale).mul(2).add(seedVal.mul(1.7)), av.mul(scale).mul(2).add(animTime.mul(.7)))).mul(.5);
+		const n3 = mx_noise_float(vec2(au.mul(scale).mul(4).add(seedVal.mul(3.1)), av.mul(scale).mul(4).add(animTime.mul(1.3)))).mul(.25);
+		const totalNoise = n1.add(n2).add(n3);
+		const turbulence = uniforms.turbulence.uniform;
+		const marbleT = sin(au.mul(scale).mul(float(Math.PI)).add(totalNoise.mul(turbulence))).mul(.5).add(.5);
+		const n4 = mx_noise_float(vec2(av.mul(scale).mul(1.5).add(seedVal.mul(2)), au.mul(scale).mul(1.2))).mul(.3).add(.5);
+		const t1 = smoothstep(float(.3), float(.6), marbleT);
+		const t2 = smoothstep(float(.6), float(.9), marbleT);
+		const colABC = mixColors(mixColors(uniforms.colorA.uniform, uniforms.colorB.uniform, t1, uniforms.colorSpace.uniform.value), uniforms.colorC.uniform, t2.mul(n4), uniforms.colorSpace.uniform.value);
+		return vec4(colABC.rgb, colABC.a);
+	}
+};
+var Marble_default = componentDefinition;
+export { componentDefinition as n, Marble_default as t };

package/dist/core/{Neon-BeGABHrs.js → Neon-DQDB7hAE.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, cos, exp, exp2, float, max, mix, pow, screenUV, sin, smoothstep, sqrt, uniform, vec2, vec3, vec4, viewportSize } from "three/tsl";
 var _LZ = .7;
 var _INV_LIGHT_LEN = 1 / Math.sqrt(1 + _LZ * _LZ);

package/dist/core/{Polygon-_3DSqSBg.js → Polygon-C6_siOs0.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 { c as polygonSdf, t as circleSdf } from "./sdf-DyC2H_qS.js";
+import { c as polygonSdf, t as circleSdf } from "./sdf-D_EAGXhN.js";
 import { cos, float, mix, screenUV, sin, smoothstep, vec2, vec4, viewportSize } from "three/tsl";
 var transformStrokePosition = (value) => {
 	return {

package/dist/core/{ProgressiveBlur-Dh8W2bZ3.js → ProgressiveBlur-BJwJ5mE0.js}

@@ -1,6 +1,6 @@
 import { l as transformPosition, r as transformAngle } from "./transformations-CJcUeZIC.js";
 import { t as unpremultiplyAlpha } from "./alpha-C4ptedXe.js";
-import { i as createVariableGaussianBlurCompute } from "./computeBlur-DCRhuYEi.js";
+import { i as createVariableGaussianBlurCompute } from "./computeBlur-CprKe0xa.js";
 import { Fn, If, clamp, convertToTexture, cos, dot, float, instanceIndex, int, max, mix, pow, radians, screenUV, sin, smoothstep, texture, textureLoad, textureStore, uint, uniform, uvec2, vec2, vec3, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "ProgressiveBlur",

package/dist/core/{Ring-4J6h5Iof.js → Ring-CtnDtTY8.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 { l as ringSdf } from "./sdf-DyC2H_qS.js";
+import { l as ringSdf } from "./sdf-D_EAGXhN.js";
 import { float, screenUV, smoothstep, vec2, vec4, viewportSize } from "three/tsl";
 var transformStrokePosition = (value) => {
 	return {

package/dist/core/{RoundedRect-Dj-gqOc0.js → RoundedRect-tnt7Jr5b.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 { u as roundedRectSdf } from "./sdf-DyC2H_qS.js";
+import { u as roundedRectSdf } from "./sdf-D_EAGXhN.js";
 import { cos, float, screenUV, sin, smoothstep, vec2, vec4, viewportSize } from "three/tsl";
 var transformStrokePosition = (value) => {
 	return {

package/dist/core/{SmokeFill-rM9vUIm4.js → SmokeFill-DzEtYeKN.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 { n as createAnalyticSdfSampler, r as createSvgSdfSampler } from "./sdf-DyC2H_qS.js";
+import { n as createAnalyticSdfSampler, r as createSvgSdfSampler } from "./sdf-D_EAGXhN.js";
 import { StorageTexture } from "three/webgpu";
 import { DataTexture, FloatType, LinearFilter as LinearFilter$1, RGBAFormat } from "three";
 import { Fn, attributeArray, float, floor, instanceIndex, int, mix, screenUV, storageTexture, texture, textureStore, uint, uniform, uvec2, vec2, vec4, viewportSize } from "three/tsl";

package/dist/core/{Star-CJ4mkBZg.js → Star-0Flymgm9.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 { d as starSdf } from "./sdf-DyC2H_qS.js";
+import { d as starSdf } from "./sdf-D_EAGXhN.js";
 import { cos, float, screenUV, sin, smoothstep, vec2, vec4, viewportSize } from "three/tsl";
 var transformStrokePosition = (value) => {
 	return {

package/dist/core/SunBurst-D9X1-buZ.js

@@ -0,0 +1,127 @@
+import { a as transformColor, l as transformPosition } from "./transformations-CJcUeZIC.js";
+import { t as createAnimatedTime } from "./time-DUqSFWvT.js";
+import { atan, float, mix, pow, screenUV, sin, smoothstep, sqrt, vec4, viewportSize } from "three/tsl";
+const componentDefinition = {
+	name: "SunBurst",
+	category: "Textures",
+	description: "Radial sunburst rays emanating from a center point",
+	props: {
+		color: {
+			default: "#ffdd88",
+			transform: transformColor,
+			description: "Ray color",
+			ui: {
+				type: "color",
+				label: "Color",
+				group: "Colors"
+			}
+		},
+		background: {
+			default: "#000000",
+			transform: transformColor,
+			description: "Background color",
+			ui: {
+				type: "color",
+				label: "Background",
+				group: "Colors"
+			}
+		},
+		center: {
+			default: {
+				x: .5,
+				y: .5
+			},
+			transform: transformPosition,
+			description: "Center point of the sunburst",
+			ui: {
+				type: "position",
+				label: "Center",
+				group: "Position"
+			}
+		},
+		rayCount: {
+			default: 12,
+			description: "Number of rays",
+			ui: {
+				type: "range",
+				min: 3,
+				max: 64,
+				step: 1,
+				label: "Ray Count",
+				group: "Effect"
+			}
+		},
+		softness: {
+			default: .3,
+			description: "Softness of ray edges",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Softness",
+				group: "Effect"
+			}
+		},
+		radius: {
+			default: .8,
+			description: "How far the rays extend from the center",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1.2,
+				step: .01,
+				label: "Radius",
+				group: "Effect"
+			}
+		},
+		feather: {
+			default: .5,
+			description: "How gradually the rays fade at their outer edge",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 5,
+				step: .01,
+				label: "Feather",
+				group: "Effect"
+			}
+		},
+		speed: {
+			default: .2,
+			description: "Rotation speed — positive values rotate clockwise",
+			ui: {
+				type: "range",
+				min: -2,
+				max: 2,
+				step: .1,
+				label: "Speed",
+				group: "Animation"
+			}
+		}
+	},
+	fragmentNode: (params) => {
+		const { uniforms } = params;
+		const uv$1 = screenUV;
+		const aspect = viewportSize.x.div(viewportSize.y);
+		const cx = uniforms.center.uniform.x;
+		const cy = uniforms.center.uniform.y.oneMinus();
+		const dx = uv$1.x.mul(aspect).sub(cx.mul(aspect));
+		const dy = uv$1.y.sub(cy);
+		const dist = sqrt(dx.mul(dx).add(dy.mul(dy)));
+		const angle = atan(dy, dx);
+		const animTime = createAnimatedTime(params, uniforms.speed);
+		const rayCount = uniforms.rayCount.uniform;
+		const rayMask = pow(sin(angle.mul(rayCount).sub(animTime)).mul(.5).add(.5), float(1).div(uniforms.softness.uniform.add(float(.05))).mul(float(.3)));
+		const radius = uniforms.radius.uniform;
+		const feather = uniforms.feather.uniform;
+		const falloffStart = radius.mul(float(1).sub(feather));
+		const outerMask = float(1).sub(smoothstep(falloffStart, radius, dist));
+		const alpha = rayMask.mul(outerMask);
+		const col = uniforms.color.uniform;
+		const bg = uniforms.background.uniform;
+		return vec4(mix(bg.rgb, col.rgb, alpha), mix(bg.a, col.a, alpha));
+	}
+};
+var SunBurst_default = componentDefinition;
+export { componentDefinition as n, SunBurst_default as t };

package/dist/core/{TiltShift-DSQ-CsXz.js → TiltShift-r4qzPb2k.js}

@@ -1,6 +1,6 @@
 import { l as transformPosition, r as transformAngle } from "./transformations-CJcUeZIC.js";
 import { t as unpremultiplyAlpha } from "./alpha-C4ptedXe.js";
-import { i as createVariableGaussianBlurCompute } from "./computeBlur-DCRhuYEi.js";
+import { i as createVariableGaussianBlurCompute } from "./computeBlur-CprKe0xa.js";
 import { Fn, If, abs, clamp, convertToTexture, cos, dot, float, instanceIndex, int, mix, pow, radians, screenUV, sin, smoothstep, texture, textureLoad, textureStore, uint, uniform, uvec2, vec2, vec3, vec4, viewportSize } from "three/tsl";
 const componentDefinition = {
 	name: "TiltShift",

package/dist/core/{Trapezoid-P9gXhH9a.js → Trapezoid-JmybJMUr.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 { f as trapezoidSdf } from "./sdf-DyC2H_qS.js";
+import { f as trapezoidSdf } from "./sdf-D_EAGXhN.js";
 import { cos, float, screenUV, sin, smoothstep, vec2, vec4, viewportSize } from "three/tsl";
 var transformStrokePosition = (value) => {
 	return {

package/dist/core/{Vesica-DYov_i53.js → Vesica-D7iqgpJg.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 { p as vesicaSdf } from "./sdf-DyC2H_qS.js";
+import { p as vesicaSdf } from "./sdf-D_EAGXhN.js";
 import { cos, float, screenUV, sin, smoothstep, vec2, vec4, viewportSize } from "three/tsl";
 var transformStrokePosition = (value) => {
 	return {

package/dist/core/{VideoTexture-Cr1f0IOE.js → VideoTexture-D9XxE1Hw.js}

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

package/dist/core/{WebcamTexture-BQJpZvC5.js → WebcamTexture-9Td8qQWm.js}

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