shaders 3.2.475 → 4.0.0

package/dist/core/LightEdge-BV9bO8YB.js

@@ -1,2339 +0,0 @@
-import { An as value12, Bn as TWO_PI$1, Br as struct, Cr as sin, Gn as typegpu_default, It as mixColorsLinear, Jr as i32, Lt as mixColorsVariants, Mr as vec4f, Or as vec2f, _r as mix, ar as clamp, bn as hash22, ct as call, er as select, fr as floor, ft as floatE, gr as min, hr as max, jr as vec3f, or as cos, pr as fract, qr as f32, rr as atan2, st as asLocal, t as defineStd, tr as abs, wr as smoothstep, yr as pow, zr as arrayOf } from "./lower-DtoDQ7hV.js";
-import { _t as MAX_COLOR_STOPS, t as animatedTime, vt as colorStopsPropConfig } from "./porters-CQwDd2t4.js";
-import { F as shapedSurface } from "./materials-BjsiWqS0.js";
-import { k as shapeEffectBoundingBoxDeclaration } from "./sdf3d-BMqCSSPB.js";
-import { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CzFmhZww.js";
-var TWO_PI = TWO_PI$1;
-var BAND_THICKNESS_REF = .35;
-const heartbeatPulse = typegpu_default.fn([f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((animTime) => {
-	"use gpu";
-	const time = __tsover_mul(.18, animTime);
-	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: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "animTime"
-		}],
-		"body": [0, [
-			[
-				13,
-				"time",
-				[
-					1,
-					[5, "0.18"],
-					"*",
-					"animTime"
-				]
-			],
-			[
-				13,
-				"first",
-				[
-					6,
-					"std.pow",
-					[[
-						6,
-						"std.abs",
-						[[
-							6,
-							"std.sin",
-							[[
-								1,
-								"time",
-								"*",
-								"TWO_PI"
-							]]
-						]]
-					], [5, "10"]]
-				]
-			],
-			[
-				13,
-				"second",
-				[
-					6,
-					"std.pow",
-					[[
-						6,
-						"std.abs",
-						[[
-							6,
-							"std.sin",
-							[[
-								1,
-								[
-									1,
-									"time",
-									"-",
-									[5, "0.15"]
-								],
-								"*",
-								"TWO_PI"
-							]]
-						]]
-					], [5, "10"]]
-				]
-			],
-			[10, [
-				6,
-				"std.clamp",
-				[
-					[
-						1,
-						"first",
-						"+",
-						[
-							1,
-							[5, "0.6"],
-							"*",
-							"second"
-						]
-					],
-					[5, "0"],
-					[5, "1"]
-				]
-			]]
-		]]
-	},
-	externals: {
-		"std.pow": () => pow,
-		"std.abs": () => abs,
-		"std.sin": () => sin,
-		"TWO_PI": () => TWO_PI,
-		"std.clamp": () => clamp
-	}
-}) && $.f)({}));
-const edgeGlowBand = typegpu_default.fn([
-	f32,
-	vec2f,
-	vec2f,
-	f32,
-	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, beat) => {
-	"use gpu";
-	const t = __tsover_add(__tsover_mul(animTime, 1.2), 131);
-	const th = max(__tsover_mul(__tsover_mul(.5, thickness), BAND_THICKNESS_REF), .002);
-	const bd = abs(__tsover_add(__tsover_div(fieldRaw, max(scale, .001)), mix(th, f32(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(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, mix(f32(1), beat, 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: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "fieldRaw"
-			},
-			{
-				"type": "i",
-				"name": "sdfUV"
-			},
-			{
-				"type": "i",
-				"name": "viewport"
-			},
-			{
-				"type": "i",
-				"name": "scale"
-			},
-			{
-				"type": "i",
-				"name": "thickness"
-			},
-			{
-				"type": "i",
-				"name": "softness"
-			},
-			{
-				"type": "i",
-				"name": "smokeSize"
-			},
-			{
-				"type": "i",
-				"name": "smokeAmt"
-			},
-			{
-				"type": "i",
-				"name": "animTime"
-			},
-			{
-				"type": "i",
-				"name": "pulse"
-			},
-			{
-				"type": "i",
-				"name": "beat"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"t",
-				[
-					1,
-					[
-						1,
-						"animTime",
-						"*",
-						[5, "1.2"]
-					],
-					"+",
-					[5, "131"]
-				]
-			],
-			[
-				13,
-				"th",
-				[
-					6,
-					"std.max",
-					[[
-						1,
-						[
-							1,
-							[5, "0.5"],
-							"*",
-							"thickness"
-						],
-						"*",
-						"BAND_THICKNESS_REF"
-					], [5, "0.002"]]
-				]
-			],
-			[
-				13,
-				"f",
-				[
-					1,
-					[
-						1,
-						"fieldRaw",
-						"/",
-						[
-							6,
-							"std.max",
-							["scale", [5, "0.001"]]
-						]
-					],
-					"+",
-					[
-						6,
-						"std.mix",
-						[
-							"th",
-							[
-								6,
-								"d.f32",
-								[[5, "0"]]
-							],
-							"softness"
-						]
-					]
-				]
-			],
-			[
-				13,
-				"bd",
-				[
-					6,
-					"std.abs",
-					["f"]
-				]
-			],
-			[
-				13,
-				"borderTh",
-				[
-					6,
-					"std.mix",
-					[
-						"th",
-						[
-							1,
-							[5, "3"],
-							"*",
-							"th"
-						],
-						"softness"
-					]
-				]
-			],
-			[
-				13,
-				"aa",
-				[
-					1,
-					[5, "2"],
-					"/",
-					[
-						1,
-						[
-							7,
-							"viewport",
-							"y"
-						],
-						"*",
-						[
-							6,
-							"std.max",
-							["scale", [5, "0.001"]]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"e0",
-				[
-					6,
-					"std.min",
-					[[
-						6,
-						"std.mix",
-						[
-							"borderTh",
-							[
-								1,
-								"borderTh",
-								"*",
-								[
-									4,
-									"-",
-									[5, "1"]
-								]
-							],
-							"softness"
-						]
-					], [
-						1,
-						"borderTh",
-						"+",
-						"aa"
-					]]
-				]
-			],
-			[
-				13,
-				"e1",
-				[
-					6,
-					"std.max",
-					[[
-						6,
-						"std.mix",
-						[
-							"borderTh",
-							[
-								1,
-								"borderTh",
-								"*",
-								[
-									4,
-									"-",
-									[5, "1"]
-								]
-							],
-							"softness"
-						]
-					], [
-						1,
-						"borderTh",
-						"+",
-						"aa"
-					]]
-				]
-			],
-			[
-				12,
-				"border",
-				[
-					1,
-					[5, "1"],
-					"-",
-					[
-						6,
-						"std.smoothstep",
-						[
-							"e0",
-							"e1",
-							"bd"
-						]
-					]
-				]
-			],
-			[
-				2,
-				"border",
-				"=",
-				[
-					6,
-					"std.pow",
-					[[
-						6,
-						"std.clamp",
-						[
-							"border",
-							[5, "0"],
-							[5, "1"]
-						]
-					], [
-						1,
-						[5, "1"],
-						"+",
-						"softness"
-					]]
-				]
-			],
-			[
-				13,
-				"suv",
-				[
-					6,
-					[
-						7,
-						[
-							6,
-							"d.vec2f",
-							[[
-								1,
-								[
-									7,
-									"sdfUV",
-									"x"
-								],
-								"-",
-								[5, "0.5"]
-							], [
-								1,
-								[
-									7,
-									"sdfUV",
-									"y"
-								],
-								"-",
-								[5, "0.5"]
-							]]
-						],
-						"mul"
-					],
-					[[
-						1,
-						[5, "0.5"],
-						"+",
-						[
-							1,
-							[5, "2.5"],
-							"*",
-							"smokeSize"
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"drift",
-				[
-					1,
-					[5, "0.5"],
-					"*",
-					"t"
-				]
-			],
-			[
-				13,
-				"n1",
-				[
-					6,
-					"noise.value12",
-					[[
-						6,
-						"d.vec2f",
-						[[
-							1,
-							[
-								1,
-								[
-									7,
-									"suv",
-									"x"
-								],
-								"*",
-								[5, "2.7"]
-							],
-							"+",
-							"drift"
-						], [
-							1,
-							[
-								1,
-								[
-									7,
-									"suv",
-									"y"
-								],
-								"*",
-								[5, "2.7"]
-							],
-							"+",
-							"drift"
-						]]
-					]]
-				]
-			],
-			[
-				13,
-				"n2",
-				[
-					6,
-					"noise.value12",
-					[[
-						6,
-						"d.vec2f",
-						[[
-							1,
-							[
-								1,
-								[
-									7,
-									"suv",
-									"x"
-								],
-								"*",
-								[5, "3.4"]
-							],
-							"-",
-							"drift"
-						], [
-							1,
-							[
-								1,
-								[
-									7,
-									"suv",
-									"y"
-								],
-								"*",
-								[5, "3.4"]
-							],
-							"-",
-							"drift"
-						]]
-					]]
-				]
-			],
-			[
-				12,
-				"smoke",
-				[
-					1,
-					[
-						6,
-						"std.clamp",
-						[
-							[
-								1,
-								[5, "3"],
-								"*",
-								"n1"
-							],
-							[5, "0"],
-							[5, "1"]
-						]
-					],
-					"-",
-					"n2"
-				]
-			],
-			[
-				13,
-				"smokeTh",
-				[
-					6,
-					"std.clamp",
-					[
-						[
-							1,
-							"th",
-							"+",
-							[5, "0.2"]
-						],
-						[5, "0.1"],
-						[5, "0.4"]
-					]
-				]
-			],
-			[
-				13,
-				"smokeBand",
-				[
-					6,
-					"std.pow",
-					[[
-						6,
-						"std.clamp",
-						[
-							[
-								1,
-								[5, "1"],
-								"-",
-								[
-									6,
-									"std.smoothstep",
-									[
-										[
-											1,
-											"smokeTh",
-											"*",
-											[
-												4,
-												"-",
-												[5, "1"]
-											]
-										],
-										[
-											1,
-											"smokeTh",
-											"+",
-											"aa"
-										],
-										"bd"
-									]
-								]
-							],
-							[5, "0"],
-							[5, "1"]
-						]
-					], [5, "2"]]
-				]
-			],
-			[
-				2,
-				"smoke",
-				"=",
-				[
-					1,
-					"smoke",
-					"*",
-					"smokeBand"
-				]
-			],
-			[
-				2,
-				"smoke",
-				"=",
-				[
-					1,
-					[
-						1,
-						[
-							1,
-							[5, "30"],
-							"*",
-							"smoke"
-						],
-						"*",
-						"smoke"
-					],
-					"*",
-					[
-						1,
-						[
-							1,
-							[5, "0.5"],
-							"*",
-							"smokeAmt"
-						],
-						"*",
-						"smokeAmt"
-					]
-				]
-			],
-			[
-				2,
-				"smoke",
-				"=",
-				[
-					1,
-					"smoke",
-					"*",
-					[
-						6,
-						"std.mix",
-						[
-							[
-								6,
-								"d.f32",
-								[[5, "1"]]
-							],
-							"beat",
-							"pulse"
-						]
-					]
-				]
-			],
-			[
-				2,
-				"border",
-				"=",
-				[
-					6,
-					"std.clamp",
-					[
-						[
-							1,
-							"border",
-							"+",
-							[
-								6,
-								"std.clamp",
-								[
-									"smoke",
-									[5, "0"],
-									[5, "1"]
-								]
-							]
-						],
-						[5, "0"],
-						[5, "1"]
-					]
-				]
-			],
-			[
-				13,
-				"angle01",
-				[
-					1,
-					[
-						6,
-						"std.atan2",
-						[[
-							1,
-							[
-								7,
-								"sdfUV",
-								"y"
-							],
-							"-",
-							[5, "0.5"]
-						], [
-							1,
-							[
-								7,
-								"sdfUV",
-								"x"
-							],
-							"-",
-							[5, "0.5"]
-						]]
-					],
-					"/",
-					"TWO_PI"
-				]
-			],
-			[10, [
-				6,
-				"d.vec2f",
-				["border", "angle01"]
-			]]
-		]]
-	},
-	externals: {
-		"std.max": () => max,
-		"BAND_THICKNESS_REF": () => BAND_THICKNESS_REF,
-		"std.mix": () => mix,
-		"d.f32": () => f32,
-		"std.abs": () => abs,
-		"std.min": () => min,
-		"std.smoothstep": () => smoothstep,
-		"std.pow": () => pow,
-		"std.clamp": () => clamp,
-		"d.vec2f": () => vec2f,
-		"noise.value12": () => value12,
-		"std.atan2": () => atan2,
-		"TWO_PI": () => TWO_PI
-	}
-}) && $.f)({}));
-const orbitSpotsAccum = typegpu_default.fn([
-	f32,
-	f32,
-	f32,
-	f32,
-	f32,
-	f32,
-	f32,
-	f32,
-	f32,
-	f32,
-	f32
-], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((angle01, border, animTime, beat, spotsF, spotSize, pulse, intensity, softness, seed, colorIdxF) => {
-	"use gpu";
-	const t = __tsover_add(__tsover_mul(animTime, 1.2), 131);
-	const intensityEff = __tsover_add(1, __tsover_mul(__tsover_add(1, __tsover_mul(4, softness)), intensity));
-	let overAcc = f32(0);
-	let addAcc = f32(0);
-	for (let s = 0; s < 5; s++) {
-		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 = 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 = 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 vec2f(overAcc, addAcc);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "angle01"
-			},
-			{
-				"type": "i",
-				"name": "border"
-			},
-			{
-				"type": "i",
-				"name": "animTime"
-			},
-			{
-				"type": "i",
-				"name": "beat"
-			},
-			{
-				"type": "i",
-				"name": "spotsF"
-			},
-			{
-				"type": "i",
-				"name": "spotSize"
-			},
-			{
-				"type": "i",
-				"name": "pulse"
-			},
-			{
-				"type": "i",
-				"name": "intensity"
-			},
-			{
-				"type": "i",
-				"name": "softness"
-			},
-			{
-				"type": "i",
-				"name": "seed"
-			},
-			{
-				"type": "i",
-				"name": "colorIdxF"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"t",
-				[
-					1,
-					[
-						1,
-						"animTime",
-						"*",
-						[5, "1.2"]
-					],
-					"+",
-					[5, "131"]
-				]
-			],
-			[
-				13,
-				"intensityEff",
-				[
-					1,
-					[5, "1"],
-					"+",
-					[
-						1,
-						[
-							1,
-							[5, "1"],
-							"+",
-							[
-								1,
-								[5, "4"],
-								"*",
-								"softness"
-							]
-						],
-						"*",
-						"intensity"
-					]
-				]
-			],
-			[
-				12,
-				"overAcc",
-				[
-					6,
-					"d.f32",
-					[[5, "0"]]
-				]
-			],
-			[
-				12,
-				"addAcc",
-				[
-					6,
-					"d.f32",
-					[[5, "0"]]
-				]
-			],
-			[
-				14,
-				[
-					12,
-					"s",
-					[5, "0"]
-				],
-				[
-					1,
-					"s",
-					"<",
-					[5, "5"]
-				],
-				[
-					102,
-					"++",
-					"s"
-				],
-				[0, [
-					[
-						13,
-						"sF",
-						[
-							6,
-							"d.f32",
-							["s"]
-						]
-					],
-					[
-						13,
-						"gate",
-						[
-							6,
-							"std.select",
-							[
-								[
-									6,
-									"d.f32",
-									[[5, "0"]]
-								],
-								[
-									6,
-									"d.f32",
-									[[5, "1"]]
-								],
-								[
-									1,
-									"sF",
-									"<",
-									"spotsF"
-								]
-							]
-						]
-					],
-					[
-						13,
-						"randVal",
-						[
-							6,
-							"noise.hash22",
-							[[
-								6,
-								"d.vec2f",
-								[[
-									1,
-									[
-										1,
-										[
-											1,
-											"sF",
-											"*",
-											[5, "10"]
-										],
-										"+",
-										[5, "2"]
-									],
-									"+",
-									[
-										1,
-										"seed",
-										"*",
-										[5, "7.31"]
-									]
-								], [
-									1,
-									[
-										1,
-										[5, "40"],
-										"+",
-										"colorIdxF"
-									],
-									"+",
-									[
-										1,
-										"seed",
-										"*",
-										[5, "3.17"]
-									]
-								]]
-							]]
-						]
-					],
-					[
-						13,
-						"speedFactor",
-						[
-							1,
-							[5, "0.1"],
-							"+",
-							[
-								1,
-								[5, "0.15"],
-								"*",
-								[
-									6,
-									"std.abs",
-									[[
-										1,
-										[
-											6,
-											"std.sin",
-											[[
-												1,
-												"sF",
-												"*",
-												[
-													1,
-													[5, "2"],
-													"+",
-													"colorIdxF"
-												]
-											]]
-										],
-										"*",
-										[
-											6,
-											"std.cos",
-											[[
-												1,
-												"sF",
-												"*",
-												[
-													1,
-													[5, "2"],
-													"+",
-													[
-														1,
-														[5, "2.5"],
-														"*",
-														"colorIdxF"
-													]
-												]
-											]]
-										]
-									]]
-								]
-							]
-						]
-					],
-					[
-						13,
-						"dir",
-						[
-							6,
-							"std.select",
-							[
-								[
-									6,
-									"d.f32",
-									[[5, "1"]]
-								],
-								[
-									6,
-									"d.f32",
-									[[
-										4,
-										"-",
-										[5, "1"]
-									]]
-								],
-								[
-									1,
-									[
-										7,
-										"randVal",
-										"y"
-									],
-									"<",
-									[5, "0.5"]
-								]
-							]
-						]
-					],
-					[
-						13,
-						"sTime",
-						[
-							1,
-							[
-								1,
-								[
-									1,
-									"speedFactor",
-									"*",
-									"t"
-								],
-								"+",
-								[
-									1,
-									[
-										7,
-										"randVal",
-										"x"
-									],
-									"*",
-									[5, "3"]
-								]
-							],
-							"*",
-							"dir"
-						]
-					],
-					[
-						13,
-						"evenCond",
-						[
-							1,
-							[
-								6,
-								"std.abs",
-								[[
-									1,
-									"colorIdxF",
-									"-",
-									[
-										1,
-										[5, "2"],
-										"*",
-										[
-											6,
-											"std.floor",
-											[[
-												1,
-												"colorIdxF",
-												"*",
-												[5, "0.5"]
-											]]
-										]
-									]
-								]]
-							],
-							"<",
-							[5, "0.5"]
-						]
-					],
-					[
-						13,
-						"sinVal",
-						[
-							6,
-							"std.sin",
-							[[
-								1,
-								"t",
-								"+",
-								[
-									1,
-									"sF",
-									"*",
-									[
-										1,
-										[5, "5"],
-										"-",
-										[
-											1,
-											[5, "1.5"],
-											"*",
-											"colorIdxF"
-										]
-									]
-								]
-							]]
-						]
-					],
-					[
-						13,
-						"cosVal",
-						[
-							6,
-							"std.cos",
-							[[
-								1,
-								"t",
-								"+",
-								[
-									1,
-									"sF",
-									"*",
-									[
-										1,
-										[5, "3"],
-										"+",
-										[
-											1,
-											[5, "1.3"],
-											"*",
-											"colorIdxF"
-										]
-									]
-								]
-							]]
-						]
-					],
-					[
-						12,
-						"mask",
-						[
-							1,
-							[5, "0.5"],
-							"+",
-							[
-								1,
-								[5, "0.5"],
-								"*",
-								[
-									6,
-									"std.select",
-									[
-										"cosVal",
-										"sinVal",
-										"evenCond"
-									]
-								]
-							]
-						]
-					],
-					[
-						13,
-						"pWeight",
-						[
-							6,
-							"std.clamp",
-							[
-								[
-									1,
-									[
-										1,
-										[5, "2"],
-										"*",
-										"pulse"
-									],
-									"-",
-									[
-										7,
-										"randVal",
-										"x"
-									]
-								],
-								[5, "0"],
-								[5, "1"]
-							]
-						]
-					],
-					[
-						2,
-						"mask",
-						"=",
-						[
-							6,
-							"std.mix",
-							[
-								"mask",
-								"beat",
-								"pWeight"
-							]
-						]
-					],
-					[
-						13,
-						"atg",
-						[
-							6,
-							"std.fract",
-							[[
-								1,
-								"angle01",
-								"+",
-								"sTime"
-							]]
-						]
-					],
-					[
-						12,
-						"ss",
-						[
-							1,
-							[
-								1,
-								[5, "0.05"],
-								"+",
-								[
-									1,
-									[
-										1,
-										[5, "0.6"],
-										"*",
-										"spotSize"
-									],
-									"*",
-									"spotSize"
-								]
-							],
-							"+",
-							[
-								1,
-								[5, "0.05"],
-								"*",
-								[
-									7,
-									"randVal",
-									"x"
-								]
-							]
-						]
-					],
-					[
-						2,
-						"ss",
-						"=",
-						[
-							6,
-							"std.mix",
-							[
-								"ss",
-								[5, "0.1"],
-								"pWeight"
-							]
-						]
-					],
-					[
-						12,
-						"sector",
-						[
-							1,
-							[
-								6,
-								"std.smoothstep",
-								[
-									[
-										1,
-										[5, "0.5"],
-										"-",
-										"ss"
-									],
-									[5, "0.5"],
-									"atg"
-								]
-							],
-							"*",
-							[
-								1,
-								[5, "1"],
-								"-",
-								[
-									6,
-									"std.smoothstep",
-									[
-										[5, "0.5"],
-										[
-											1,
-											[5, "0.5"],
-											"+",
-											"ss"
-										],
-										"atg"
-									]
-								]
-							]
-						]
-					],
-					[
-						2,
-						"sector",
-						"=",
-						[
-							1,
-							[
-								6,
-								"std.clamp",
-								[
-									[
-										1,
-										[
-											1,
-											[
-												1,
-												"sector",
-												"*",
-												"mask"
-											],
-											"*",
-											"border"
-										],
-										"*",
-										"intensityEff"
-									],
-									[5, "0"],
-									[5, "1"]
-								]
-							],
-							"*",
-							"gate"
-						]
-					],
-					[
-						2,
-						"overAcc",
-						"=",
-						[
-							1,
-							"overAcc",
-							"+",
-							[
-								1,
-								[
-									1,
-									[5, "1"],
-									"-",
-									"overAcc"
-								],
-								"*",
-								"sector"
-							]
-						]
-					],
-					[
-						2,
-						"addAcc",
-						"=",
-						[
-							1,
-							"addAcc",
-							"+",
-							"sector"
-						]
-					]
-				]]
-			],
-			[10, [
-				6,
-				"d.vec2f",
-				["overAcc", "addAcc"]
-			]]
-		]]
-	},
-	externals: {
-		"d.f32": () => f32,
-		"std.select": () => select,
-		"noise.hash22": () => hash22,
-		"d.vec2f": () => vec2f,
-		"std.abs": () => abs,
-		"std.sin": () => sin,
-		"std.cos": () => cos,
-		"std.floor": () => floor,
-		"std.clamp": () => clamp,
-		"std.mix": () => mix,
-		"std.fract": () => fract,
-		"std.smoothstep": () => smoothstep
-	}
-}) && $.f)({}));
-const EdgeGlowAccum = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
-	rgb: vec3f,
-	w: f32,
-	ba: f32,
-	ac: vec3f,
-	aa: f32
-}), "EdgeGlowAccum");
-const edgeGlowAccumZero = typegpu_default.fn([], EdgeGlowAccum)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = (() => {
-	"use gpu";
-	return EdgeGlowAccum({
-		rgb: vec3f(0, 0, 0),
-		w: f32(0),
-		ba: f32(0),
-		ac: vec3f(0, 0, 0),
-		aa: f32(0)
-	});
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [],
-		"body": [0, [[10, [
-			6,
-			"EdgeGlowAccum",
-			[[104, {
-				"rgb": [
-					6,
-					"d.vec3f",
-					[
-						[5, "0"],
-						[5, "0"],
-						[5, "0"]
-					]
-				],
-				"w": [
-					6,
-					"d.f32",
-					[[5, "0"]]
-				],
-				"ba": [
-					6,
-					"d.f32",
-					[[5, "0"]]
-				],
-				"ac": [
-					6,
-					"d.vec3f",
-					[
-						[5, "0"],
-						[5, "0"],
-						[5, "0"]
-					]
-				],
-				"aa": [
-					6,
-					"d.f32",
-					[[5, "0"]]
-				]
-			}]]
-		]]]]
-	},
-	externals: {
-		"EdgeGlowAccum": () => EdgeGlowAccum,
-		"d.vec3f": () => vec3f,
-		"d.f32": () => f32
-	}
-}) && $.f)({}));
-var accumFnByMode = /* @__PURE__ */ new Map();
-function makeAccumFn(mode) {
-	const variant = mixColorsVariants[mode] ?? mixColorsLinear;
-	return typegpu_default.fn([
-		EdgeGlowAccum,
-		vec4f,
-		vec2f
-	], EdgeGlowAccum)(/* @__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, 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));
-		return EdgeGlowAccum({
-			rgb: mixed.xyz,
-			w: __tsover_add(st.w, wNew),
-			ba,
-			ac,
-			aa
-		});
-	}), {
-		v: 2,
-		name: void 0,
-		ast: {
-			"params": [
-				{
-					"type": "i",
-					"name": "st"
-				},
-				{
-					"type": "i",
-					"name": "color"
-				},
-				{
-					"type": "i",
-					"name": "sectors"
-				}
-			],
-			"body": [0, [
-				[
-					13,
-					"wNew",
-					[
-						1,
-						[
-							7,
-							"color",
-							"w"
-						],
-						"*",
-						[
-							7,
-							"sectors",
-							"x"
-						]
-					]
-				],
-				[
-					13,
-					"t",
-					[
-						1,
-						"wNew",
-						"/",
-						[
-							6,
-							"std.max",
-							[[
-								1,
-								[
-									7,
-									"st",
-									"w"
-								],
-								"+",
-								"wNew"
-							], [5, "0.00001"]]
-						]
-					]
-				],
-				[
-					13,
-					"mixed",
-					[
-						6,
-						"variant",
-						[
-							[
-								6,
-								"d.vec4f",
-								[[
-									7,
-									"st",
-									"rgb"
-								], [5, "1"]]
-							],
-							[
-								6,
-								"d.vec4f",
-								[[
-									7,
-									"color",
-									"xyz"
-								], [5, "1"]]
-							],
-							"t"
-						]
-					]
-				],
-				[
-					13,
-					"ba",
-					[
-						1,
-						[
-							7,
-							"st",
-							"ba"
-						],
-						"+",
-						[
-							1,
-							[
-								1,
-								[5, "1"],
-								"-",
-								[
-									7,
-									"st",
-									"ba"
-								]
-							],
-							"*",
-							"wNew"
-						]
-					]
-				],
-				[
-					13,
-					"ac",
-					[
-						6,
-						[
-							7,
-							[
-								7,
-								"st",
-								"ac"
-							],
-							"add"
-						],
-						[[
-							6,
-							[
-								7,
-								[
-									7,
-									"color",
-									"xyz"
-								],
-								"mul"
-							],
-							[[
-								1,
-								[
-									7,
-									"color",
-									"w"
-								],
-								"*",
-								[
-									7,
-									"sectors",
-									"y"
-								]
-							]]
-						]]
-					]
-				],
-				[
-					13,
-					"aa",
-					[
-						1,
-						[
-							7,
-							"st",
-							"aa"
-						],
-						"+",
-						[
-							1,
-							[
-								7,
-								"color",
-								"w"
-							],
-							"*",
-							[
-								7,
-								"sectors",
-								"y"
-							]
-						]
-					]
-				],
-				[10, [
-					6,
-					"EdgeGlowAccum",
-					[[104, {
-						"rgb": [
-							7,
-							"mixed",
-							"xyz"
-						],
-						"w": [
-							1,
-							[
-								7,
-								"st",
-								"w"
-							],
-							"+",
-							"wNew"
-						],
-						"ba": "ba",
-						"ac": "ac",
-						"aa": "aa"
-					}]]
-				]]
-			]]
-		},
-		externals: {
-			"std.max": () => max,
-			"variant": () => variant,
-			"d.vec4f": () => vec4f,
-			"EdgeGlowAccum": () => EdgeGlowAccum
-		}
-	}) && $.f)({})).$name(`edgeGlowAccumColor_${mode}`);
-}
-function edgeGlowAccumColorFor(mode) {
-	let fn = accumFnByMode.get(mode);
-	if (!fn) {
-		fn = makeAccumFn(mode);
-		accumFnByMode.set(mode, fn);
-	}
-	return fn;
-}
-const colorAtIndex = typegpu_default.fn([arrayOf(vec4f, 8), f32], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((colors, idx) => {
-	"use gpu";
-	const c = colors[i32(idx)];
-	return vec4f(c.x, c.y, c.z, c.w);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "colors"
-		}, {
-			"type": "i",
-			"name": "idx"
-		}],
-		"body": [0, [[
-			13,
-			"c",
-			[
-				8,
-				"colors",
-				[
-					6,
-					"d.i32",
-					["idx"]
-				]
-			]
-		], [10, [
-			6,
-			"d.vec4f",
-			[
-				[
-					7,
-					"c",
-					"x"
-				],
-				[
-					7,
-					"c",
-					"y"
-				],
-				[
-					7,
-					"c",
-					"z"
-				],
-				[
-					7,
-					"c",
-					"w"
-				]
-			]
-		]]]]
-	},
-	externals: {
-		"d.i32": () => i32,
-		"d.vec4f": () => vec4f
-	}
-}) && $.f)({}));
-const edgeGlowCompose = typegpu_default.fn([EdgeGlowAccum, f32], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((st, bloom) => {
-	"use gpu";
-	const k = __tsover_mul(bloom, 4);
-	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: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "st"
-		}, {
-			"type": "i",
-			"name": "bloom"
-		}],
-		"body": [0, [
-			[
-				13,
-				"k",
-				[
-					1,
-					"bloom",
-					"*",
-					[5, "4"]
-				]
-			],
-			[
-				13,
-				"blendPremult",
-				[
-					6,
-					[
-						7,
-						[
-							7,
-							"st",
-							"rgb"
-						],
-						"mul"
-					],
-					[[
-						7,
-						"st",
-						"ba"
-					]]
-				]
-			],
-			[
-				13,
-				"accumC",
-				[
-					6,
-					"std.mix",
-					[
-						"blendPremult",
-						[
-							7,
-							"st",
-							"ac"
-						],
-						[
-							6,
-							"d.vec3f",
-							["k"]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"accumA",
-				[
-					6,
-					"std.clamp",
-					[
-						[
-							6,
-							"std.mix",
-							[
-								[
-									7,
-									"st",
-									"ba"
-								],
-								[
-									7,
-									"st",
-									"aa"
-								],
-								"k"
-							]
-						],
-						[5, "0"],
-						[5, "1"]
-					]
-				]
-			],
-			[
-				13,
-				"straight",
-				[
-					6,
-					"std.clamp",
-					[
-						[
-							6,
-							[
-								7,
-								"accumC",
-								"div"
-							],
-							[[
-								6,
-								"std.max",
-								["accumA", [5, "0.0001"]]
-							]]
-						],
-						[
-							6,
-							"d.vec3f",
-							[[5, "0"]]
-						],
-						[
-							6,
-							"d.vec3f",
-							[[5, "1"]]
-						]
-					]
-				]
-			],
-			[10, [
-				6,
-				"d.vec4f",
-				["straight", "accumA"]
-			]]
-		]]
-	},
-	externals: {
-		"std.mix": () => mix,
-		"d.vec3f": () => vec3f,
-		"std.clamp": () => clamp,
-		"std.max": () => max,
-		"d.vec4f": () => vec4f
-	}
-}) && $.f)({}));
-var DEFAULT_SHAPE_CONFIG = JSON.stringify({
-	type: "circleSDF",
-	radius: .35
-});
-var DEFAULT_STOPS = [
-	{
-		color: "#7b2ff7",
-		position: 0
-	},
-	{
-		color: "#00e0ff",
-		position: .5
-	},
-	{
-		color: "#ff3d81",
-		position: 1
-	}
-];
-const componentDefinition = defineStd({
-	name: "LightEdge",
-	role: "shapeEffect",
-	species: "custom",
-	boundingBoxDeclaration: shapeEffectBoundingBoxDeclaration,
-	category: "Shape Effects",
-	description: "Glowing, pulsing light racing around the edge of any 2D, SVG, or 3D shape. Powered by Paper Shaders.",
-	animatedTime: { speed: "speed" },
-	...shapedSurface({
-		chord: "firstLobe",
-		stencil: "centre",
-		surface: (frame, params) => {
-			const { uniforms, propValues } = params;
-			const t = animatedTime(params);
-			const beat = asLocal(call(heartbeatPulse, "heartbeatPulse", [t]), "beat");
-			const bAndA = call(edgeGlowBand, "edgeGlowBand", [
-				frame.surf0.member("r"),
-				frame.sdfUV,
-				params.ctx.viewportSize,
-				uniforms.scale,
-				uniforms.thickness,
-				uniforms.softness,
-				uniforms.smokeSize,
-				uniforms.smoke,
-				t,
-				uniforms.pulse,
-				beat
-			]);
-			const border = bAndA.member("x");
-			const angle01 = bAndA.member("y");
-			const stopCount = propValues.stopCount ?? 0;
-			const colorCount = stopCount > 1 ? Math.min(stopCount, 8) : 2;
-			const accumColorFn = edgeGlowAccumColorFor(propValues.colorSpace ?? 0);
-			const accumFor = (idx) => call(orbitSpotsAccum, "orbitSpotsAccum", [
-				angle01,
-				border,
-				t,
-				beat,
-				uniforms.spots,
-				uniforms.spotSize,
-				uniforms.pulse,
-				uniforms.intensity,
-				uniforms.softness,
-				uniforms.seed,
-				floatE(idx)
-			]);
-			const colorFor = (idx) => stopCount > 1 ? call(colorAtIndex, "colorAtIndex", [uniforms.colorsArray, floatE(idx)]) : idx === 0 ? uniforms.colorA : uniforms.colorB;
-			let state = call(edgeGlowAccumZero, "edgeGlowAccumZero", []);
-			for (let i = 0; i < colorCount; i++) state = call(accumColorFn, "edgeGlowAccumColor", [
-				state,
-				colorFor(i),
-				accumFor(i)
-			]);
-			return call(edgeGlowCompose, "edgeGlowCompose", [state, uniforms.bloom]);
-		}
-	}),
-	props: {
-		origin: {
-			default: "center",
-			description: "Reference edge the center position is measured from (center default). Lets you pin the shape relative to a corner or the canvas centre.",
-			ui: {
-				type: "origin",
-				label: "Origin",
-				group: "Position"
-			}
-		},
-		center: {
-			default: {
-				x: .5,
-				y: .5
-			},
-			transform: transformPosition,
-			description: "Center position of the shape",
-			ui: {
-				type: "position",
-				label: "Center",
-				group: "Position",
-				units: ["%", "px"]
-			}
-		},
-		scale: {
-			default: 1,
-			description: "Scale of the shape (1 = default size)",
-			ui: {
-				type: "range",
-				min: .1,
-				max: 3,
-				step: .01,
-				label: "Scale",
-				group: "Position"
-			}
-		},
-		rotation: {
-			default: 0,
-			description: "Rotation of the shape in degrees",
-			ui: {
-				type: "range",
-				min: 0,
-				max: 360,
-				step: 1,
-				label: "Rotation",
-				group: "Position"
-			}
-		},
-		colorA: {
-			default: "#7b2ff7",
-			transform: transformColor,
-			description: "First border light color (used when no gradient stops are set)",
-			ui: {
-				type: "color",
-				label: "Color A",
-				group: "Colors"
-			}
-		},
-		colorB: {
-			default: "#00e0ff",
-			transform: transformColor,
-			description: "Second border light color (used when no gradient stops are set)",
-			ui: {
-				type: "color",
-				label: "Color B",
-				group: "Colors"
-			}
-		},
-		stops: {
-			...colorStopsPropConfig(),
-			default: DEFAULT_STOPS
-		},
-		colorSpace: {
-			default: "linear",
-			transform: transformColorSpace,
-			compileTime: true,
-			description: "Color space overlapping lights blend in",
-			ui: {
-				type: "select",
-				options: colorSpaceOptions,
-				label: "Color Space",
-				group: "Colors"
-			}
-		},
-		thickness: {
-			default: .25,
-			description: "Width of the border band",
-			ui: {
-				type: ["range", "map"],
-				min: .01,
-				max: 1,
-				step: .01,
-				label: "Thickness",
-				group: "Border"
-			}
-		},
-		softness: {
-			default: .5,
-			description: "Edge softness — 0 = crisp band, 1 = wide smooth gradient",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .01,
-				label: "Softness",
-				group: "Border"
-			}
-		},
-		intensity: {
-			default: .6,
-			description: "Brightness of the individual light spots",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .01,
-				label: "Intensity",
-				group: "Light"
-			}
-		},
-		bloom: {
-			default: .3,
-			description: "How additively overlapping lights pile up — high values overdrive to white",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .01,
-				label: "Bloom",
-				group: "Light"
-			}
-		},
-		spots: {
-			default: 3,
-			description: "Number of light spots orbiting per color",
-			ui: {
-				type: "range",
-				min: 1,
-				max: 5,
-				step: 1,
-				label: "Spots",
-				group: "Light"
-			}
-		},
-		spotSize: {
-			default: .5,
-			description: "Angular size of each light spot",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .01,
-				label: "Spot Size",
-				group: "Light"
-			}
-		},
-		pulse: {
-			default: 0,
-			description: "Heartbeat pulsing — synchronizes the lights to a double-beat rhythm",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .01,
-				label: "Pulse",
-				group: "Animation"
-			}
-		},
-		smoke: {
-			default: .3,
-			description: "Noisy luminous smoke drifting along the border",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .01,
-				label: "Smoke",
-				group: "Smoke"
-			}
-		},
-		smokeSize: {
-			default: .5,
-			description: "Scale of the smoke billows",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .01,
-				label: "Smoke Size",
-				group: "Smoke"
-			}
-		},
-		speed: {
-			default: 1,
-			description: "Animation speed. 0 pauses.",
-			ui: {
-				type: "range",
-				min: 0,
-				max: 4,
-				step: .1,
-				label: "Speed",
-				group: "Animation"
-			}
-		},
-		seed: {
-			default: 0,
-			description: "Random seed — re-rolls spot speeds, directions and phases",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 100,
-				step: 1,
-				label: "Seed",
-				group: "Animation"
-			}
-		},
-		shape: {
-			default: DEFAULT_SHAPE_CONFIG,
-			description: "Serialized shape configuration (JSON)",
-			ui: {
-				type: "shape",
-				label: "Shape",
-				group: "Shape"
-			}
-		},
-		shapeSdfUrl: {
-			default: "",
-			compileTime: true,
-			description: "URL to a pre-generated SDF .bin file"
-		},
-		shapeType: {
-			default: "",
-			compileTime: true,
-			description: "Active SDF shape type"
-		}
-	}
-});
-var LightEdge_default = componentDefinition;
-export { componentDefinition as n, LightEdge_default as t };