shaders 3.0.447 → 3.0.449

package/dist/core/{LensFlare-DHGNEDIX.js → LensFlare-ChQK_hJN.js}

@@ -1,10 +1,10 @@
-import { Ht as call, J as std, Jt as vec4, Tn as d, n as tgpu } from "./coords-BkIjixe_.js";
-import { c as transformPosition } from "./transformations-t0d2-uSX.js";
-import { t as animatedTime } from "./porters-BmU6G9TR.js";
+import { $t as vec2f, At as pow, Et as max, It as sin, Lt as smoothstep, Ot as mix, Tt as length, Vt as data_exports, _t as clamp, an as f32, bt as dot, et as src_default, gt as atan2, in as vec4f, mt as abs, nn as vec3f, nt as std_exports, p as call, vt as cos, xt as exp, y as vec4 } from "./edges-BXNBKxSN.js";
+import { t as animatedTime } from "./porters-DBK1Aipq.js";
+import { c as transformPosition } from "./transformations-CsPUHppB.js";
 var TAU = 6.2831853;
-var lensFlareSpectral = tgpu.fn([d.f32], d.vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((t) => {
+var lensFlareSpectral = src_default.fn([f32], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((t) => {
 	"use gpu";
-	return d.vec3f(__tsover_add(__tsover_mul(std.cos(__tsover_mul(TAU, t)), .5), .5), __tsover_add(__tsover_mul(std.cos(__tsover_mul(TAU, __tsover_sub(t, .333))), .5), .5), __tsover_add(__tsover_mul(std.cos(__tsover_mul(TAU, __tsover_sub(t, .666))), .5), .5));
+	return vec3f(__tsover_add(__tsover_mul(cos(__tsover_mul(TAU, t)), .5), .5), __tsover_add(__tsover_mul(cos(__tsover_mul(TAU, __tsover_sub(t, .333))), .5), .5), __tsover_add(__tsover_mul(cos(__tsover_mul(TAU, __tsover_sub(t, .666))), .5), .5));
 }), {
 	v: 1,
 	name: void 0,
@@ -112,21 +112,21 @@ var lensFlareSpectral = tgpu.fn([d.f32], d.vec3f)(/* @__PURE__ */ (($) => (globa
 		]
 	},
 	externals: () => ({
-		d,
-		std,
+		d: data_exports,
+		std: std_exports,
 		TAU
 	})
 }) && $.f)({}));
-var lensFlareGhost = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.vec2f,
-	d.vec2f,
-	d.f32,
-	d.vec3f,
-	d.vec4f,
-	d.vec4f
-], d.vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, lightPos, flareAxis, t, shared, disc, tint) => {
+var lensFlareGhost = src_default.fn([
+	vec2f,
+	f32,
+	vec2f,
+	vec2f,
+	f32,
+	vec3f,
+	vec4f,
+	vec4f
+], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, lightPos, flareAxis, t, shared, disc, tint) => {
 	"use gpu";
 	const ghostSpread = shared.x;
 	const ghostChroma = shared.y;
@@ -140,21 +140,20 @@ var lensFlareGhost = tgpu.fn([
 	const b = tint.z;
 	const gPhase = tint.w;
 	const ghostPos = lightPos.add(flareAxis.mul(__tsover_mul(__tsover_mul(offset, ghostSpread), 2)));
-	const toGhost = d.vec2f(__tsover_mul(__tsover_sub(uv.x, ghostPos.x), aspect), __tsover_sub(uv.y, ghostPos.y));
-	const dist = std.length(toGhost);
+	const dist = length(vec2f(__tsover_mul(__tsover_sub(uv.x, ghostPos.x), aspect), __tsover_sub(uv.y, ghostPos.y)));
 	const sz = size;
-	const discShape = __tsover_sub(1, std.smoothstep(__tsover_mul(sz, .12), sz, dist));
-	const innerFade = __tsover_sub(1, std.smoothstep(__tsover_mul(sz, .05), __tsover_mul(sz, .45), dist));
+	const discShape = __tsover_sub(1, smoothstep(__tsover_mul(sz, .12), sz, dist));
+	const innerFade = __tsover_sub(1, smoothstep(__tsover_mul(sz, .05), __tsover_mul(sz, .45), dist));
 	const shape = __tsover_mul(discShape, __tsover_sub(1, __tsover_mul(innerFade, hollow)));
-	const gShimmer = __tsover_add(__tsover_add(__tsover_mul(std.sin(__tsover_add(__tsover_mul(t, 4.3), gPhase)), .08), __tsover_mul(std.sin(__tsover_add(__tsover_mul(t, 9.1), __tsover_mul(gPhase, 1.7))), .05)), .95);
+	const gShimmer = __tsover_add(__tsover_add(__tsover_mul(sin(__tsover_add(__tsover_mul(t, 4.3), gPhase)), .08), __tsover_mul(sin(__tsover_add(__tsover_mul(t, 9.1), __tsover_mul(gPhase, 1.7))), .05)), .95);
 	const ringCenter = __tsover_mul(sz, .78);
 	const chromaSpread = __tsover_mul(__tsover_mul(sz, ghostChroma), .14);
 	const ringWidth = __tsover_mul(sz, .1);
-	const rRing = __tsover_sub(1, std.smoothstep(0, ringWidth, std.abs(__tsover_sub(dist, __tsover_add(ringCenter, chromaSpread)))));
-	const gRing = __tsover_sub(1, std.smoothstep(0, ringWidth, std.abs(__tsover_sub(dist, ringCenter))));
-	const bRing = __tsover_sub(1, std.smoothstep(0, ringWidth, std.abs(__tsover_sub(dist, __tsover_sub(ringCenter, chromaSpread)))));
+	const rRing = __tsover_sub(1, smoothstep(0, ringWidth, abs(__tsover_sub(dist, __tsover_add(ringCenter, chromaSpread)))));
+	const gRing = __tsover_sub(1, smoothstep(0, ringWidth, abs(__tsover_sub(dist, ringCenter))));
+	const bRing = __tsover_sub(1, smoothstep(0, ringWidth, abs(__tsover_sub(dist, __tsover_sub(ringCenter, chromaSpread)))));
 	const brightness = __tsover_mul(__tsover_mul(bright, ghostInt), gShimmer);
-	return d.vec3f(__tsover_mul(__tsover_add(__tsover_mul(shape, r), __tsover_mul(rRing, ghostChroma)), brightness), __tsover_mul(__tsover_add(__tsover_mul(shape, g), __tsover_mul(gRing, ghostChroma)), brightness), __tsover_mul(__tsover_add(__tsover_mul(shape, b), __tsover_mul(bRing, ghostChroma)), brightness));
+	return vec3f(__tsover_mul(__tsover_add(__tsover_mul(shape, r), __tsover_mul(rRing, ghostChroma)), brightness), __tsover_mul(__tsover_add(__tsover_mul(shape, g), __tsover_mul(gRing, ghostChroma)), brightness), __tsover_mul(__tsover_add(__tsover_mul(shape, b), __tsover_mul(bRing, ghostChroma)), brightness));
 }), {
 	v: 1,
 	name: void 0,
@@ -773,20 +772,20 @@ var lensFlareGhost = tgpu.fn([
 		"externalNames": ["d", "std"]
 	},
 	externals: () => ({
-		d,
-		std
+		d: data_exports,
+		std: std_exports
 	})
 }) && $.f)({}));
-const lensFlareColor = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	d.f32,
-	d.vec2f,
-	d.vec4f,
-	d.vec4f,
-	d.vec4f,
-	d.vec4f
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, animTime, lightPosRaw, p1, p2, p3, p4) => {
+const lensFlareColor = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	vec2f,
+	vec4f,
+	vec4f,
+	vec4f,
+	vec4f
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, animTime, lightPosRaw, p1, p2, p3, p4) => {
 	"use gpu";
 	const intensity = p1.x;
 	const ghostInt = p1.y;
@@ -804,62 +803,61 @@ const lensFlareColor = tgpu.fn([
 	const glareSz = p4.y;
 	const edgeFade = p4.z;
 	const aspect = __tsover_div(viewport.x, viewport.y);
-	const lightPos = d.vec2f(lightPosRaw.x, __tsover_sub(1, lightPosRaw.y));
-	const flareAxis = d.vec2f(__tsover_sub(.5, lightPos.x), __tsover_sub(.5, lightPos.y));
+	const lightPos = vec2f(lightPosRaw.x, __tsover_sub(1, lightPosRaw.y));
+	const flareAxis = vec2f(__tsover_sub(.5, lightPos.x), __tsover_sub(.5, lightPos.y));
 	const t = animTime;
-	const shimmer = __tsover_add(__tsover_add(__tsover_add(__tsover_mul(std.sin(__tsover_mul(t, 3.7)), .04), __tsover_mul(std.sin(__tsover_mul(t, 7.3)), .03)), __tsover_mul(std.sin(__tsover_mul(t, 13.1)), .02)), .97);
-	const edgeDist = std.max(__tsover_mul(std.abs(__tsover_sub(lightPos.x, .5)), 2), __tsover_mul(std.abs(__tsover_sub(lightPos.y, .5)), 2));
+	const shimmer = __tsover_add(__tsover_add(__tsover_add(__tsover_mul(sin(__tsover_mul(t, 3.7)), .04), __tsover_mul(sin(__tsover_mul(t, 7.3)), .03)), __tsover_mul(sin(__tsover_mul(t, 13.1)), .02)), .97);
+	const edgeDist = max(__tsover_mul(abs(__tsover_sub(lightPos.x, .5)), 2), __tsover_mul(abs(__tsover_sub(lightPos.y, .5)), 2));
 	const fadeStart = __tsover_sub(1, __tsover_mul(edgeFade, .5));
-	const edgeFadeV = std.mix(1, __tsover_sub(1, std.smoothstep(fadeStart, 1, edgeDist)), edgeFade);
+	const edgeFadeV = mix(1, __tsover_sub(1, smoothstep(fadeStart, 1, edgeDist)), edgeFade);
 	const masterFade = __tsover_mul(__tsover_mul(intensity, edgeFadeV), shimmer);
-	const toLightAR = d.vec2f(__tsover_mul(__tsover_sub(uv.x, lightPos.x), aspect), __tsover_sub(uv.y, lightPos.y));
-	const lightDist = std.length(toLightAR);
-	const gShared = d.vec3f(ghostSpread, ghostChroma, ghostInt);
-	let ghostAccum = d.vec3f(0, 0, 0);
-	ghostAccum = ghostAccum.add(lensFlareGhost(uv, aspect, lightPos, flareAxis, t, gShared, d.vec4f(.15, .2, .3, .1), d.vec4f(1, .95, .9, 0)));
-	ghostAccum = ghostAccum.add(lensFlareGhost(uv, aspect, lightPos, flareAxis, t, gShared, d.vec4f(.3, .12, .25, .65), d.vec4f(1, .85, .55, 2.17)));
-	ghostAccum = ghostAccum.add(lensFlareGhost(uv, aspect, lightPos, flareAxis, t, gShared, d.vec4f(.5, .08, .35, .15), d.vec4f(.62, .82, 1, 4.34)));
-	ghostAccum = ghostAccum.add(lensFlareGhost(uv, aspect, lightPos, flareAxis, t, gShared, d.vec4f(.72, .14, .18, .75), d.vec4f(.75, 1, .7, 6.51)));
-	ghostAccum = ghostAccum.add(lensFlareGhost(uv, aspect, lightPos, flareAxis, t, gShared, d.vec4f(.95, .06, .3, 0), d.vec4f(1, .6, .85, 8.68)));
-	ghostAccum = ghostAccum.add(lensFlareGhost(uv, aspect, lightPos, flareAxis, t, gShared, d.vec4f(1.25, .1, .15, .8), d.vec4f(.55, .88, 1, 10.85)));
-	ghostAccum = ghostAccum.add(lensFlareGhost(uv, aspect, lightPos, flareAxis, t, gShared, d.vec4f(1.55, .07, .2, .25), d.vec4f(1, .92, .6, 13.02)));
-	const antiLight = d.vec2f(__tsover_sub(1, lightPos.x), __tsover_sub(1, lightPos.y));
-	const toAntiLight = d.vec2f(__tsover_mul(__tsover_sub(uv.x, antiLight.x), aspect), __tsover_sub(uv.y, antiLight.y));
-	const antiLightDist = std.length(toAntiLight);
+	const toLightAR = vec2f(__tsover_mul(__tsover_sub(uv.x, lightPos.x), aspect), __tsover_sub(uv.y, lightPos.y));
+	const lightDist = length(toLightAR);
+	const gShared = vec3f(ghostSpread, ghostChroma, ghostInt);
+	let ghostAccum = vec3f(0, 0, 0);
+	ghostAccum = ghostAccum.add(lensFlareGhost(uv, aspect, lightPos, flareAxis, t, gShared, vec4f(.15, .2, .3, .1), vec4f(1, .95, .9, 0)));
+	ghostAccum = ghostAccum.add(lensFlareGhost(uv, aspect, lightPos, flareAxis, t, gShared, vec4f(.3, .12, .25, .65), vec4f(1, .85, .55, 2.17)));
+	ghostAccum = ghostAccum.add(lensFlareGhost(uv, aspect, lightPos, flareAxis, t, gShared, vec4f(.5, .08, .35, .15), vec4f(.62, .82, 1, 4.34)));
+	ghostAccum = ghostAccum.add(lensFlareGhost(uv, aspect, lightPos, flareAxis, t, gShared, vec4f(.72, .14, .18, .75), vec4f(.75, 1, .7, 6.51)));
+	ghostAccum = ghostAccum.add(lensFlareGhost(uv, aspect, lightPos, flareAxis, t, gShared, vec4f(.95, .06, .3, 0), vec4f(1, .6, .85, 8.68)));
+	ghostAccum = ghostAccum.add(lensFlareGhost(uv, aspect, lightPos, flareAxis, t, gShared, vec4f(1.25, .1, .15, .8), vec4f(.55, .88, 1, 10.85)));
+	ghostAccum = ghostAccum.add(lensFlareGhost(uv, aspect, lightPos, flareAxis, t, gShared, vec4f(1.55, .07, .2, .25), vec4f(1, .92, .6, 13.02)));
+	const antiLight = vec2f(__tsover_sub(1, lightPos.x), __tsover_sub(1, lightPos.y));
+	const toAntiLight = vec2f(__tsover_mul(__tsover_sub(uv.x, antiLight.x), aspect), __tsover_sub(uv.y, antiLight.y));
+	const antiLightDist = length(toAntiLight);
 	const haloChromaSpread = __tsover_mul(__tsover_mul(haloRad, haloChroma), .06);
 	const haloWidth = __tsover_add(__tsover_mul(haloSoft, .12), .005);
-	const rHalo = __tsover_sub(1, std.smoothstep(0, haloWidth, std.abs(__tsover_sub(antiLightDist, __tsover_add(haloRad, haloChromaSpread)))));
-	const gHalo = __tsover_sub(1, std.smoothstep(0, haloWidth, std.abs(__tsover_sub(antiLightDist, haloRad))));
-	const bHalo = __tsover_sub(1, std.smoothstep(0, haloWidth, std.abs(__tsover_sub(antiLightDist, __tsover_sub(haloRad, haloChromaSpread)))));
-	const haloAngle = std.atan2(toAntiLight.y, toAntiLight.x);
-	const haloAngVar = __tsover_add(__tsover_mul(std.sin(__tsover_add(__tsover_mul(haloAngle, 3), __tsover_mul(t, .5))), .12), .88);
-	const haloColor = d.vec3f(rHalo, gHalo, bHalo).mul(haloInt).mul(haloAngVar);
-	const lightAngle = std.atan2(toLightAR.y, toLightAR.x);
-	const axisAng = std.atan2(flareAxis.y, __tsover_mul(flareAxis.x, aspect));
+	const rHalo = __tsover_sub(1, smoothstep(0, haloWidth, abs(__tsover_sub(antiLightDist, __tsover_add(haloRad, haloChromaSpread)))));
+	const gHalo = __tsover_sub(1, smoothstep(0, haloWidth, abs(__tsover_sub(antiLightDist, haloRad))));
+	const bHalo = __tsover_sub(1, smoothstep(0, haloWidth, abs(__tsover_sub(antiLightDist, __tsover_sub(haloRad, haloChromaSpread)))));
+	const haloAngle = atan2(toAntiLight.y, toAntiLight.x);
+	const haloAngVar = __tsover_add(__tsover_mul(sin(__tsover_add(__tsover_mul(haloAngle, 3), __tsover_mul(t, .5))), .12), .88);
+	const haloColor = vec3f(rHalo, gHalo, bHalo).mul(haloInt).mul(haloAngVar);
+	const lightAngle = atan2(toLightAR.y, toLightAR.x);
+	const axisAng = atan2(flareAxis.y, __tsover_mul(flareAxis.x, aspect));
 	const rotation = __tsover_add(__tsover_mul(axisAng, .5), __tsover_mul(t, .06));
 	const spikeAngle = __tsover_add(lightAngle, rotation);
-	const primarySpikes = std.pow(std.abs(std.cos(__tsover_mul(spikeAngle, __tsover_div(starburstPts, 2)))), 3.5);
-	const secondarySpikes = __tsover_mul(std.pow(std.abs(std.cos(__tsover_mul(__tsover_add(spikeAngle, .25), __tsover_div(starburstPts, 2)))), 7), .4);
+	const primarySpikes = pow(abs(cos(__tsover_mul(spikeAngle, __tsover_div(starburstPts, 2)))), 3.5);
+	const secondarySpikes = __tsover_mul(pow(abs(cos(__tsover_mul(__tsover_add(spikeAngle, .25), __tsover_div(starburstPts, 2)))), 7), .4);
 	const radialFall = __tsover_div(1, __tsover_add(1, __tsover_mul(__tsover_mul(lightDist, lightDist), 60)));
 	const starSpectral = lensFlareSpectral(__tsover_add(__tsover_div(spikeAngle, TAU), .5));
-	const starburstColor = std.mix(d.vec3f(1, .97, .92), starSpectral, .12).mul(__tsover_mul(__tsover_mul(__tsover_add(primarySpikes, secondarySpikes), radialFall), starburstInt));
-	const dy = std.abs(__tsover_sub(uv.y, lightPos.y));
-	const dx = std.abs(__tsover_sub(uv.x, lightPos.x));
-	const vertFall = std.exp(__tsover_mul(__tsover_mul(-800, dy), dy));
+	const starburstColor = mix(vec3f(1, .97, .92), starSpectral, .12).mul(__tsover_mul(__tsover_mul(__tsover_add(primarySpikes, secondarySpikes), radialFall), starburstInt));
+	const dy = abs(__tsover_sub(uv.y, lightPos.y));
+	const dx = abs(__tsover_sub(uv.x, lightPos.x));
+	const vertFall = exp(__tsover_mul(__tsover_mul(-800, dy), dy));
 	const lenSq = __tsover_add(__tsover_mul(__tsover_mul(streakLen, streakLen), .25), .001);
-	const rStreak = std.exp(__tsover_div(__tsover_mul(__tsover_mul(-1, dx), dx), __tsover_mul(lenSq, .7)));
-	const gStreak = std.exp(__tsover_div(__tsover_mul(__tsover_mul(-1, dx), dx), lenSq));
-	const bStreak = std.exp(__tsover_div(__tsover_mul(__tsover_mul(-1, dx), dx), __tsover_mul(lenSq, 1.4)));
-	const streakColor = d.vec3f(__tsover_mul(__tsover_mul(vertFall, rStreak), .5), __tsover_mul(__tsover_mul(vertFall, gStreak), .65), __tsover_mul(__tsover_mul(vertFall, bStreak), .9)).mul(streakInt);
+	const rStreak = exp(__tsover_div(__tsover_mul(__tsover_mul(-1, dx), dx), __tsover_mul(lenSq, .7)));
+	const gStreak = exp(__tsover_div(__tsover_mul(__tsover_mul(-1, dx), dx), lenSq));
+	const bStreak = exp(__tsover_div(__tsover_mul(__tsover_mul(-1, dx), dx), __tsover_mul(lenSq, 1.4)));
+	const streakColor = vec3f(__tsover_mul(__tsover_mul(vertFall, rStreak), .5), __tsover_mul(__tsover_mul(vertFall, gStreak), .65), __tsover_mul(__tsover_mul(vertFall, bStreak), .9)).mul(streakInt);
 	const glareSharpness = __tsover_div(1, __tsover_add(__tsover_mul(glareSz, glareSz), .01));
-	const glareFalloff = std.exp(__tsover_mul(__tsover_mul(__tsover_mul(-1, lightDist), lightDist), glareSharpness));
-	const glareColor = d.vec3f(1, .98, .95).mul(__tsover_mul(glareFalloff, glareInt));
-	const coreSoft = std.exp(__tsover_mul(__tsover_mul(-500, lightDist), lightDist));
-	const coreSharp = __tsover_sub(1, std.smoothstep(0, .025, lightDist));
-	const coreColor = d.vec3f(1, .98, .96).mul(__tsover_mul(__tsover_add(coreSoft, __tsover_mul(coreSharp, 1.5)), intensity));
+	const glareFalloff = exp(__tsover_mul(__tsover_mul(__tsover_mul(-1, lightDist), lightDist), glareSharpness));
+	const glareColor = vec3f(1, .98, .95).mul(__tsover_mul(glareFalloff, glareInt));
+	const coreSoft = exp(__tsover_mul(__tsover_mul(-500, lightDist), lightDist));
+	const coreSharp = __tsover_sub(1, smoothstep(0, .025, lightDist));
+	const coreColor = vec3f(1, .98, .96).mul(__tsover_mul(__tsover_add(coreSoft, __tsover_mul(coreSharp, 1.5)), intensity));
 	const finalColor = ghostAccum.add(haloColor).add(starburstColor).add(streakColor).add(glareColor).add(coreColor).mul(masterFade);
-	const flareAlpha = std.clamp(__tsover_mul(std.dot(finalColor, d.vec3f(.299, .587, .114)), 2), 0, 1);
-	return d.vec4f(finalColor, flareAlpha);
+	return vec4f(finalColor, clamp(__tsover_mul(dot(finalColor, vec3f(.299, .587, .114)), 2), 0, 1));
 }), {
 	v: 1,
 	name: void 0,
@@ -2912,8 +2910,8 @@ const lensFlareColor = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		d,
-		std,
+		d: data_exports,
+		std: std_exports,
 		lensFlareGhost,
 		lensFlareSpectral,
 		TAU

package/dist/core/{LightEdge-DYfhB3-7.js → LightEdge-Rg-zMpGb.js}

@@ -1,8 +1,10 @@
-import { F as sdf_exports, Ht as call, J as std, Kt as floatE, Tn as d, ct as hash22, gn as mixColorsVariants, hn as mixColorsLinear, n as tgpu, pt as noise_exports, v as VOLUMETRIC_FIELD_EXTRA_FIELDS$1, y as sdf3d_exports, yt as value12 } from "./coords-BkIjixe_.js";
-import { n as glass_exports } from "./glass-sOqjtPJD.js";
-import { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-t0d2-uSX.js";
-import { h as colorStopsPropConfig, m as MAX_COLOR_STOPS, t as animatedTime } from "./porters-BmU6G9TR.js";
-import { n as shapeEffectBoundingBoxDeclaration, t as resolveShapeType } from "./shapeEffectBounds-PQqKLQXO.js";
+import { $t as vec2f, At as pow, Ct as floor, Dt as min, Et as max, H as mixColorsLinear, It as sin, Lt as smoothstep, Ot as mix, U as mixColorsVariants, Ut as arrayOf, Vt as data_exports, Xt as struct, _ as floatE, _t as clamp, an as f32, et as src_default, gt as atan2, in as vec4f, mt as abs, nn as vec3f, nt as std_exports, on as i32, p as call, pt as select, vt as cos, wt as fract } from "./edges-BXNBKxSN.js";
+import { h as colorStopsPropConfig, m as MAX_COLOR_STOPS, t as animatedTime } from "./porters-DBK1Aipq.js";
+import { c as hash22, p as noise_exports, y as value12 } from "./noise-wTSHXgFz.js";
+import { h as sdf_exports } from "./sdf-R0EN3EvS.js";
+import { d as VOLUMETRIC_FIELD_EXTRA_FIELDS$1, f as sdf3d_exports, n as shapeEffectBoundingBoxDeclaration, t as resolveShapeType } from "./shapeEffectBounds-CtKwBX8c.js";
+import { n as glass_exports } from "./glass-IfoQ8Prf.js";
+import { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
 var { sdfSpaceUV } = glass_exports;
 var { createSvgSdfSampler, createAnalyticSdfSampler, driveAnalyticSubProps, ANALYTIC_SDF_EXTRA_FIELDS } = sdf_exports;
 var { createVolumetricFieldComputeNode, buildVolumetricFieldSampler } = sdf3d_exports;
@@ -27,12 +29,12 @@ var DEFAULT_STOPS = [
 		position: 1
 	}
 ];
-const lightEdgeBeat = tgpu.fn([d.f32], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((animTime) => {
+const lightEdgeBeat = src_default.fn([f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((animTime) => {
 	"use gpu";
 	const time = __tsover_mul(.18, animTime);
-	const first = std.pow(std.abs(std.sin(__tsover_mul(time, TWO_PI))), 10);
-	const second = std.pow(std.abs(std.sin(__tsover_mul(__tsover_sub(time, .15), TWO_PI))), 10);
-	return std.clamp(__tsover_add(first, __tsover_mul(.6, second)), 0, 1);
+	const first = pow(abs(sin(__tsover_mul(time, TWO_PI))), 10);
+	const second = pow(abs(sin(__tsover_mul(__tsover_sub(time, .15), TWO_PI))), 10);
+	return clamp(__tsover_add(first, __tsover_mul(.6, second)), 0, 1);
 }), {
 	v: 1,
 	name: void 0,
@@ -152,46 +154,45 @@ const lightEdgeBeat = tgpu.fn([d.f32], d.f32)(/* @__PURE__ */ (($) => (globalThi
 		"externalNames": ["std", "TWO_PI"]
 	},
 	externals: () => ({
-		std,
+		std: std_exports,
 		TWO_PI
 	})
 }) && $.f)({}));
-const lightEdgeBorder = tgpu.fn([
-	d.f32,
-	d.vec2f,
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((fieldRaw, sdfUV, viewport, scale, thickness, softness, smokeSize, smokeAmt, animTime, pulse) => {
+const lightEdgeBorder = src_default.fn([
+	f32,
+	vec2f,
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((fieldRaw, sdfUV, viewport, scale, thickness, softness, smokeSize, smokeAmt, animTime, pulse) => {
 	"use gpu";
 	const t = __tsover_add(__tsover_mul(animTime, 1.2), 131);
-	const th = std.max(__tsover_mul(__tsover_mul(.5, thickness), THICKNESS_REF), .002);
-	const f = __tsover_add(__tsover_div(fieldRaw, std.max(scale, .001)), std.mix(th, 0, softness));
-	const bd = std.abs(f);
-	const borderTh = std.mix(th, __tsover_mul(3, th), softness);
-	const aa = __tsover_div(2, __tsover_mul(viewport.y, std.max(scale, .001)));
-	const e0 = std.min(std.mix(borderTh, __tsover_mul(borderTh, -1), softness), __tsover_add(borderTh, aa));
-	const e1 = std.max(std.mix(borderTh, __tsover_mul(borderTh, -1), softness), __tsover_add(borderTh, aa));
-	let border = __tsover_sub(1, std.smoothstep(e0, e1, bd));
-	border = std.pow(std.clamp(border, 0, 1), __tsover_add(1, softness));
-	const suv = d.vec2f(__tsover_sub(sdfUV.x, .5), __tsover_sub(sdfUV.y, .5)).mul(__tsover_add(.5, __tsover_mul(2.5, smokeSize)));
+	const th = max(__tsover_mul(__tsover_mul(.5, thickness), THICKNESS_REF), .002);
+	const bd = abs(__tsover_add(__tsover_div(fieldRaw, max(scale, .001)), mix(th, 0, softness)));
+	const borderTh = mix(th, __tsover_mul(3, th), softness);
+	const aa = __tsover_div(2, __tsover_mul(viewport.y, max(scale, .001)));
+	const e0 = min(mix(borderTh, __tsover_mul(borderTh, -1), softness), __tsover_add(borderTh, aa));
+	const e1 = max(mix(borderTh, __tsover_mul(borderTh, -1), softness), __tsover_add(borderTh, aa));
+	let border = __tsover_sub(1, smoothstep(e0, e1, bd));
+	border = pow(clamp(border, 0, 1), __tsover_add(1, softness));
+	const suv = vec2f(__tsover_sub(sdfUV.x, .5), __tsover_sub(sdfUV.y, .5)).mul(__tsover_add(.5, __tsover_mul(2.5, smokeSize)));
 	const drift = __tsover_mul(.5, t);
-	const n1 = value12(d.vec2f(__tsover_add(__tsover_mul(suv.x, 2.7), drift), __tsover_add(__tsover_mul(suv.y, 2.7), drift)));
-	const n2 = value12(d.vec2f(__tsover_sub(__tsover_mul(suv.x, 3.4), drift), __tsover_sub(__tsover_mul(suv.y, 3.4), drift)));
-	let smoke = __tsover_sub(std.clamp(__tsover_mul(3, n1), 0, 1), n2);
-	const smokeTh = std.clamp(__tsover_add(th, .2), .1, .4);
-	const smokeBand = std.pow(std.clamp(__tsover_sub(1, std.smoothstep(__tsover_mul(smokeTh, -1), __tsover_add(smokeTh, aa), bd)), 0, 1), 2);
+	const n1 = value12(vec2f(__tsover_add(__tsover_mul(suv.x, 2.7), drift), __tsover_add(__tsover_mul(suv.y, 2.7), drift)));
+	const n2 = value12(vec2f(__tsover_sub(__tsover_mul(suv.x, 3.4), drift), __tsover_sub(__tsover_mul(suv.y, 3.4), drift)));
+	let smoke = __tsover_sub(clamp(__tsover_mul(3, n1), 0, 1), n2);
+	const smokeTh = clamp(__tsover_add(th, .2), .1, .4);
+	const smokeBand = pow(clamp(__tsover_sub(1, smoothstep(__tsover_mul(smokeTh, -1), __tsover_add(smokeTh, aa), bd)), 0, 1), 2);
 	smoke = __tsover_mul(smoke, smokeBand);
 	smoke = __tsover_mul(__tsover_mul(__tsover_mul(30, smoke), smoke), __tsover_mul(__tsover_mul(.5, smokeAmt), smokeAmt));
-	smoke = __tsover_mul(smoke, std.mix(1, lightEdgeBeat(animTime), pulse));
-	border = std.clamp(__tsover_add(border, std.clamp(smoke, 0, 1)), 0, 1);
-	const angle01 = __tsover_div(std.atan2(__tsover_sub(sdfUV.y, .5), __tsover_sub(sdfUV.x, .5)), TWO_PI);
-	return d.vec2f(border, angle01);
+	smoke = __tsover_mul(smoke, mix(1, lightEdgeBeat(animTime), pulse));
+	border = clamp(__tsover_add(border, clamp(smoke, 0, 1)), 0, 1);
+	const angle01 = __tsover_div(atan2(__tsover_sub(sdfUV.y, .5), __tsover_sub(sdfUV.x, .5)), TWO_PI);
+	return vec2f(border, angle01);
 }), {
 	v: 1,
 	name: void 0,
@@ -927,54 +928,54 @@ const lightEdgeBorder = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		std,
+		std: std_exports,
 		THICKNESS_REF,
-		d,
+		d: data_exports,
 		noise: noise_exports,
 		lightEdgeBeat,
 		TWO_PI
 	})
 }) && $.f)({}));
-const lightEdgeColorAccum = tgpu.fn([
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((angle01, border, animTime, spotsF, spotSize, pulse, intensity, softness, seed, colorIdxF) => {
+const lightEdgeColorAccum = src_default.fn([
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((angle01, border, animTime, spotsF, spotSize, pulse, intensity, softness, seed, colorIdxF) => {
 	"use gpu";
 	const t = __tsover_add(__tsover_mul(animTime, 1.2), 131);
 	const beat = lightEdgeBeat(animTime);
 	const intensityEff = __tsover_add(1, __tsover_mul(__tsover_add(1, __tsover_mul(4, softness)), intensity));
-	let overAcc = d.f32(0);
-	let addAcc = d.f32(0);
+	let overAcc = f32(0);
+	let addAcc = f32(0);
 	for (let s = 0; s < 5; s++) {
-		const sF = d.f32(s);
-		const gate = std.select(d.f32(0), d.f32(1), sF < spotsF);
-		const randVal = hash22(d.vec2f(__tsover_add(__tsover_add(__tsover_mul(sF, 10), 2), __tsover_mul(seed, 7.31)), __tsover_add(__tsover_add(40, colorIdxF), __tsover_mul(seed, 3.17))));
-		const speedFactor = __tsover_add(.1, __tsover_mul(.15, std.abs(__tsover_mul(std.sin(__tsover_mul(sF, __tsover_add(2, colorIdxF))), std.cos(__tsover_mul(sF, __tsover_add(2, __tsover_mul(2.5, colorIdxF))))))));
-		const dir = std.select(d.f32(1), d.f32(-1), randVal.y < .5);
+		const sF = f32(s);
+		const gate = select(f32(0), f32(1), sF < spotsF);
+		const randVal = hash22(vec2f(__tsover_add(__tsover_add(__tsover_mul(sF, 10), 2), __tsover_mul(seed, 7.31)), __tsover_add(__tsover_add(40, colorIdxF), __tsover_mul(seed, 3.17))));
+		const speedFactor = __tsover_add(.1, __tsover_mul(.15, abs(__tsover_mul(sin(__tsover_mul(sF, __tsover_add(2, colorIdxF))), cos(__tsover_mul(sF, __tsover_add(2, __tsover_mul(2.5, colorIdxF))))))));
+		const dir = select(f32(1), f32(-1), randVal.y < .5);
 		const sTime = __tsover_mul(__tsover_add(__tsover_mul(speedFactor, t), __tsover_mul(randVal.x, 3)), dir);
-		const evenCond = std.abs(__tsover_sub(colorIdxF, __tsover_mul(2, std.floor(__tsover_mul(colorIdxF, .5))))) < .5;
-		const sinVal = std.sin(__tsover_add(t, __tsover_mul(sF, __tsover_sub(5, __tsover_mul(1.5, colorIdxF)))));
-		const cosVal = std.cos(__tsover_add(t, __tsover_mul(sF, __tsover_add(3, __tsover_mul(1.3, colorIdxF)))));
-		let mask = __tsover_add(.5, __tsover_mul(.5, std.select(cosVal, sinVal, evenCond)));
-		const pWeight = std.clamp(__tsover_sub(__tsover_mul(2, pulse), randVal.x), 0, 1);
-		mask = std.mix(mask, beat, pWeight);
-		const atg = std.fract(__tsover_add(angle01, sTime));
+		const evenCond = abs(__tsover_sub(colorIdxF, __tsover_mul(2, floor(__tsover_mul(colorIdxF, .5))))) < .5;
+		const sinVal = sin(__tsover_add(t, __tsover_mul(sF, __tsover_sub(5, __tsover_mul(1.5, colorIdxF)))));
+		const cosVal = cos(__tsover_add(t, __tsover_mul(sF, __tsover_add(3, __tsover_mul(1.3, colorIdxF)))));
+		let mask = __tsover_add(.5, __tsover_mul(.5, select(cosVal, sinVal, evenCond)));
+		const pWeight = clamp(__tsover_sub(__tsover_mul(2, pulse), randVal.x), 0, 1);
+		mask = mix(mask, beat, pWeight);
+		const atg = fract(__tsover_add(angle01, sTime));
 		let ss = __tsover_add(__tsover_add(.05, __tsover_mul(__tsover_mul(.6, spotSize), spotSize)), __tsover_mul(.05, randVal.x));
-		ss = std.mix(ss, .1, pWeight);
-		let sector = __tsover_mul(std.smoothstep(__tsover_sub(.5, ss), .5, atg), __tsover_sub(1, std.smoothstep(.5, __tsover_add(.5, ss), atg)));
-		sector = __tsover_mul(std.clamp(__tsover_mul(__tsover_mul(__tsover_mul(sector, mask), border), intensityEff), 0, 1), gate);
+		ss = mix(ss, .1, pWeight);
+		let sector = __tsover_mul(smoothstep(__tsover_sub(.5, ss), .5, atg), __tsover_sub(1, smoothstep(.5, __tsover_add(.5, ss), atg)));
+		sector = __tsover_mul(clamp(__tsover_mul(__tsover_mul(__tsover_mul(sector, mask), border), intensityEff), 0, 1), gate);
 		overAcc = __tsover_add(overAcc, __tsover_mul(__tsover_sub(1, overAcc), sector));
 		addAcc = __tsover_add(addAcc, sector);
 	}
-	return d.vec2f(overAcc, addAcc);
+	return vec2f(overAcc, addAcc);
 }), {
 	v: 1,
 	name: void 0,
@@ -1760,26 +1761,26 @@ const lightEdgeColorAccum = tgpu.fn([
 	},
 	externals: () => ({
 		lightEdgeBeat,
-		d,
-		std,
+		d: data_exports,
+		std: std_exports,
 		noise: noise_exports
 	})
 }) && $.f)({}));
-const LightEdgeAccum = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(d.struct({
-	rgb: d.vec3f,
-	w: d.f32,
-	ba: d.f32,
-	ac: d.vec3f,
-	aa: d.f32
+const LightEdgeAccum = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
+	rgb: vec3f,
+	w: f32,
+	ba: f32,
+	ac: vec3f,
+	aa: f32
 }), "LightEdgeAccum");
-const lightEdgeAccumZero = tgpu.fn([], LightEdgeAccum)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = (() => {
+const lightEdgeAccumZero = src_default.fn([], LightEdgeAccum)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = (() => {
 	"use gpu";
 	return LightEdgeAccum({
-		rgb: d.vec3f(0, 0, 0),
-		w: d.f32(0),
-		ba: d.f32(0),
-		ac: d.vec3f(0, 0, 0),
-		aa: d.f32(0)
+		rgb: vec3f(0, 0, 0),
+		w: f32(0),
+		ba: f32(0),
+		ac: vec3f(0, 0, 0),
+		aa: f32(0)
 	});
 }), {
 	v: 1,
@@ -1849,21 +1850,21 @@ const lightEdgeAccumZero = tgpu.fn([], LightEdgeAccum)(/* @__PURE__ */ (($) => (
 	},
 	externals: () => ({
 		LightEdgeAccum,
-		d
+		d: data_exports
 	})
 }) && $.f)({}));
 var accumFnByMode = /* @__PURE__ */ new Map();
 function makeAccumFn(mode) {
 	const variant = mixColorsVariants[mode] ?? mixColorsLinear;
-	return tgpu.fn([
+	return src_default.fn([
 		LightEdgeAccum,
-		d.vec4f,
-		d.vec2f
+		vec4f,
+		vec2f
 	], LightEdgeAccum)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((st, color, sectors) => {
 		"use gpu";
 		const wNew = __tsover_mul(color.w, sectors.x);
-		const t = __tsover_div(wNew, std.max(__tsover_add(st.w, wNew), 1e-5));
-		const mixed = variant(d.vec4f(st.rgb, 1), d.vec4f(color.xyz, 1), t);
+		const t = __tsover_div(wNew, max(__tsover_add(st.w, wNew), 1e-5));
+		const mixed = variant(vec4f(st.rgb, 1), vec4f(color.xyz, 1), t);
 		const ba = __tsover_add(st.ba, __tsover_mul(__tsover_sub(1, st.ba), wNew));
 		const ac = st.ac.add(color.xyz.mul(__tsover_mul(color.w, sectors.y)));
 		const aa = __tsover_add(st.aa, __tsover_mul(color.w, sectors.y));
@@ -2105,9 +2106,9 @@ function makeAccumFn(mode) {
 			]
 		},
 		externals: () => ({
-			std,
+			std: std_exports,
 			variant,
-			d,
+			d: data_exports,
 			LightEdgeAccum
 		})
 	}) && $.f)({})).$name(`lightEdgeAccumColor_${mode}`);
@@ -2120,10 +2121,10 @@ function lightEdgeAccumColorFor(mode) {
 	}
 	return fn;
 }
-const lightEdgePickColor = tgpu.fn([d.arrayOf(d.vec4f, 8), d.f32], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((colors, idx) => {
+const lightEdgePickColor = src_default.fn([arrayOf(vec4f, 8), f32], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((colors, idx) => {
 	"use gpu";
-	const c = colors[d.i32(idx)];
-	return d.vec4f(c.x, c.y, c.z, c.w);
+	const c = colors[i32(idx)];
+	return vec4f(c.x, c.y, c.z, c.w);
 }), {
 	v: 1,
 	name: void 0,
@@ -2183,16 +2184,14 @@ const lightEdgePickColor = tgpu.fn([d.arrayOf(d.vec4f, 8), d.f32], d.vec4f)(/* @
 		]]]],
 		"externalNames": ["d"]
 	},
-	externals: () => ({ d })
+	externals: () => ({ d: data_exports })
 }) && $.f)({}));
-const lightEdgeCompose = tgpu.fn([LightEdgeAccum, d.f32], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((st, bloom) => {
+const lightEdgeCompose = src_default.fn([LightEdgeAccum, f32], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((st, bloom) => {
 	"use gpu";
 	const k = __tsover_mul(bloom, 4);
-	const blendPremult = st.rgb.mul(st.ba);
-	const accumC = std.mix(blendPremult, st.ac, d.vec3f(k));
-	const accumA = std.clamp(std.mix(st.ba, st.aa, k), 0, 1);
-	const straight = std.clamp(accumC.div(std.max(accumA, 1e-4)), d.vec3f(0), d.vec3f(1));
-	return d.vec4f(straight, accumA);
+	const accumC = mix(st.rgb.mul(st.ba), st.ac, vec3f(k));
+	const accumA = clamp(mix(st.ba, st.aa, k), 0, 1);
+	return vec4f(clamp(accumC.div(max(accumA, 1e-4)), vec3f(0), vec3f(1)), accumA);
 }), {
 	v: 1,
 	name: void 0,
@@ -2364,8 +2363,8 @@ const lightEdgeCompose = tgpu.fn([LightEdgeAccum, d.f32], d.vec4f)(/* @__PURE__
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {