shaders 3.1.462 → 3.2.464

package/dist/core/CursorTrail-Dk3-1Y0B.js

@@ -1,1224 +0,0 @@
-import { At as step, Gt as textureStorage2d, I as colorMixing_exports, Kt as arrayOf, Lt as vec4f, Mt as vec2f, Pt as vec2u, b as vec4, d as ZERO, et as typegpu_default, ft as exp, ln as u32, m as call, qt as struct, rt as select, sn as f32, v as floatE, vt as min } from "./edges-CV-BHMpI.js";
-import { M as createGuardedCompute, P as createStateBuffer, R as textureStore } from "./device-DKcu50_C.js";
-import { V as colorStopsPropConfig, q as mixColorStopsRuntime } from "./porters-j7yWJYy2.js";
-import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-u-UZrXjj.js";
-import { i as pathStampRibbon, n as createPointerVelocityTracker } from "./pointer-DKBz1Qcc.js";
-var GRID_SIZE = 128;
-var CELL_COUNT = GRID_SIZE * GRID_SIZE;
-var STATE_FORMAT = "rgba16float";
-var cm = colorMixing_exports;
-var BRUSH_EDGE = Math.exp(-9);
-var BRUSH_EDGE_GAIN = 1 / (1 - BRUSH_EDGE);
-var decayLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(typegpu_default.bindGroupLayout({
-	trailBuf: {
-		storage: arrayOf(vec4f, CELL_COUNT),
-		access: "mutable"
-	},
-	params: { uniform: /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
-		fadeRate: f32,
-		ageRate: f32,
-		shrink: f32
-	}), "uniform") }
-}), "decayLayout");
-var stampLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(typegpu_default.bindGroupLayout({
-	trailBuf: {
-		storage: arrayOf(vec4f, CELL_COUNT),
-		access: "mutable"
-	},
-	params: { uniform: /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
-		cursorX: f32,
-		cursorY: f32,
-		radius: f32,
-		amount: f32,
-		aspect: f32
-	}), "uniform") }
-}), "stampLayout");
-var outputLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(typegpu_default.bindGroupLayout({
-	trailBuf: {
-		storage: arrayOf(vec4f, CELL_COUNT),
-		access: "readonly"
-	},
-	trailTex: { storageTexture: textureStorage2d(STATE_FORMAT, "write-only") }
-}), "outputLayout");
-const decayKernel = typegpu_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
-	"use gpu";
-	const p = decayLayout.$.params;
-	const idx = __tsover_add(__tsover_mul(cy, u32(GRID_SIZE)), cx);
-	const cell = decayLayout.$.trailBuf[idx];
-	const intensity = __tsover_mul(cell.x, p.fadeRate);
-	const size = __tsover_sub(1, __tsover_mul(__tsover_sub(1, intensity), p.shrink));
-	const age = min(__tsover_add(cell.z, p.ageRate), 1);
-	decayLayout.$.trailBuf[idx] = vec4f(intensity, size, age, 0);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "cx"
-		}, {
-			"type": "i",
-			"name": "cy"
-		}],
-		"body": [0, [
-			[
-				13,
-				"p",
-				[
-					7,
-					[
-						7,
-						"decayLayout",
-						"$"
-					],
-					"params"
-				]
-			],
-			[
-				13,
-				"idx",
-				[
-					1,
-					[
-						1,
-						"cy",
-						"*",
-						[
-							6,
-							"d.u32",
-							["GRID_SIZE"]
-						]
-					],
-					"+",
-					"cx"
-				]
-			],
-			[
-				13,
-				"cell",
-				[
-					8,
-					[
-						7,
-						[
-							7,
-							"decayLayout",
-							"$"
-						],
-						"trailBuf"
-					],
-					"idx"
-				]
-			],
-			[
-				13,
-				"intensity",
-				[
-					1,
-					[
-						7,
-						"cell",
-						"x"
-					],
-					"*",
-					[
-						7,
-						"p",
-						"fadeRate"
-					]
-				]
-			],
-			[
-				13,
-				"size",
-				[
-					1,
-					[5, "1"],
-					"-",
-					[
-						1,
-						[
-							1,
-							[5, "1"],
-							"-",
-							"intensity"
-						],
-						"*",
-						[
-							7,
-							"p",
-							"shrink"
-						]
-					]
-				]
-			],
-			[
-				13,
-				"age",
-				[
-					6,
-					"std.min",
-					[[
-						1,
-						[
-							7,
-							"cell",
-							"z"
-						],
-						"+",
-						[
-							7,
-							"p",
-							"ageRate"
-						]
-					], [5, "1"]]
-				]
-			],
-			[
-				2,
-				[
-					8,
-					[
-						7,
-						[
-							7,
-							"decayLayout",
-							"$"
-						],
-						"trailBuf"
-					],
-					"idx"
-				],
-				"=",
-				[
-					6,
-					"d.vec4f",
-					[
-						"intensity",
-						"size",
-						"age",
-						[5, "0"]
-					]
-				]
-			]
-		]]
-	},
-	externals: {
-		"decayLayout": () => decayLayout,
-		"d.u32": () => u32,
-		"GRID_SIZE": () => GRID_SIZE,
-		"std.min": () => min,
-		"d.vec4f": () => vec4f
-	}
-}) && $.f)({})).$name("cursorTrailDecay");
-const stampKernel = typegpu_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
-	"use gpu";
-	const p = stampLayout.$.params;
-	const cellX = __tsover_div(__tsover_add(f32(cx), .5), f32(GRID_SIZE));
-	const cellY = __tsover_div(__tsover_add(f32(cy), .5), f32(GRID_SIZE));
-	const ddx = select(__tsover_sub(cellX, p.cursorX), __tsover_mul(__tsover_sub(cellX, p.cursorX), p.aspect), p.aspect >= 1);
-	const ddy = select(__tsover_div(__tsover_sub(cellY, p.cursorY), p.aspect), __tsover_sub(cellY, p.cursorY), p.aspect >= 1);
-	const distSq = __tsover_add(__tsover_mul(ddx, ddx), __tsover_mul(ddy, ddy));
-	const influenceRadius = __tsover_mul(p.radius, 3);
-	if (distSq < __tsover_mul(influenceRadius, influenceRadius)) {
-		const idx = __tsover_add(__tsover_mul(cy, u32(GRID_SIZE)), cx);
-		const influence = __tsover_mul(__tsover_sub(exp(__tsover_mul(__tsover_div(distSq, __tsover_mul(p.radius, p.radius)), -1)), BRUSH_EDGE), BRUSH_EDGE_GAIN);
-		const cell = stampLayout.$.trailBuf[idx];
-		const newIntensity = min(__tsover_add(cell.x, __tsover_mul(influence, p.amount)), 1);
-		stampLayout.$.trailBuf[idx] = vec4f(newIntensity, 1, 0, 0);
-	}
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "cx"
-		}, {
-			"type": "i",
-			"name": "cy"
-		}],
-		"body": [0, [
-			[
-				13,
-				"p",
-				[
-					7,
-					[
-						7,
-						"stampLayout",
-						"$"
-					],
-					"params"
-				]
-			],
-			[
-				13,
-				"cellX",
-				[
-					1,
-					[
-						1,
-						[
-							6,
-							"d.f32",
-							["cx"]
-						],
-						"+",
-						[5, "0.5"]
-					],
-					"/",
-					[
-						6,
-						"d.f32",
-						["GRID_SIZE"]
-					]
-				]
-			],
-			[
-				13,
-				"cellY",
-				[
-					1,
-					[
-						1,
-						[
-							6,
-							"d.f32",
-							["cy"]
-						],
-						"+",
-						[5, "0.5"]
-					],
-					"/",
-					[
-						6,
-						"d.f32",
-						["GRID_SIZE"]
-					]
-				]
-			],
-			[
-				13,
-				"ddx",
-				[
-					6,
-					"std.select",
-					[
-						[
-							1,
-							"cellX",
-							"-",
-							[
-								7,
-								"p",
-								"cursorX"
-							]
-						],
-						[
-							1,
-							[
-								1,
-								"cellX",
-								"-",
-								[
-									7,
-									"p",
-									"cursorX"
-								]
-							],
-							"*",
-							[
-								7,
-								"p",
-								"aspect"
-							]
-						],
-						[
-							1,
-							[
-								7,
-								"p",
-								"aspect"
-							],
-							">=",
-							[5, "1"]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"ddy",
-				[
-					6,
-					"std.select",
-					[
-						[
-							1,
-							[
-								1,
-								"cellY",
-								"-",
-								[
-									7,
-									"p",
-									"cursorY"
-								]
-							],
-							"/",
-							[
-								7,
-								"p",
-								"aspect"
-							]
-						],
-						[
-							1,
-							"cellY",
-							"-",
-							[
-								7,
-								"p",
-								"cursorY"
-							]
-						],
-						[
-							1,
-							[
-								7,
-								"p",
-								"aspect"
-							],
-							">=",
-							[5, "1"]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"distSq",
-				[
-					1,
-					[
-						1,
-						"ddx",
-						"*",
-						"ddx"
-					],
-					"+",
-					[
-						1,
-						"ddy",
-						"*",
-						"ddy"
-					]
-				]
-			],
-			[
-				13,
-				"influenceRadius",
-				[
-					1,
-					[
-						7,
-						"p",
-						"radius"
-					],
-					"*",
-					[5, "3"]
-				]
-			],
-			[
-				11,
-				[
-					1,
-					"distSq",
-					"<",
-					[
-						1,
-						"influenceRadius",
-						"*",
-						"influenceRadius"
-					]
-				],
-				[0, [
-					[
-						13,
-						"idx",
-						[
-							1,
-							[
-								1,
-								"cy",
-								"*",
-								[
-									6,
-									"d.u32",
-									["GRID_SIZE"]
-								]
-							],
-							"+",
-							"cx"
-						]
-					],
-					[
-						13,
-						"influence",
-						[
-							1,
-							[
-								1,
-								[
-									6,
-									"std.exp",
-									[[
-										1,
-										[
-											1,
-											"distSq",
-											"/",
-											[
-												1,
-												[
-													7,
-													"p",
-													"radius"
-												],
-												"*",
-												[
-													7,
-													"p",
-													"radius"
-												]
-											]
-										],
-										"*",
-										[
-											4,
-											"-",
-											[5, "1"]
-										]
-									]]
-								],
-								"-",
-								"BRUSH_EDGE"
-							],
-							"*",
-							"BRUSH_EDGE_GAIN"
-						]
-					],
-					[
-						13,
-						"cell",
-						[
-							8,
-							[
-								7,
-								[
-									7,
-									"stampLayout",
-									"$"
-								],
-								"trailBuf"
-							],
-							"idx"
-						]
-					],
-					[
-						13,
-						"newIntensity",
-						[
-							6,
-							"std.min",
-							[[
-								1,
-								[
-									7,
-									"cell",
-									"x"
-								],
-								"+",
-								[
-									1,
-									"influence",
-									"*",
-									[
-										7,
-										"p",
-										"amount"
-									]
-								]
-							], [5, "1"]]
-						]
-					],
-					[
-						2,
-						[
-							8,
-							[
-								7,
-								[
-									7,
-									"stampLayout",
-									"$"
-								],
-								"trailBuf"
-							],
-							"idx"
-						],
-						"=",
-						[
-							6,
-							"d.vec4f",
-							[
-								"newIntensity",
-								[5, "1"],
-								[5, "0"],
-								[5, "0"]
-							]
-						]
-					]
-				]]
-			]
-		]]
-	},
-	externals: {
-		"stampLayout": () => stampLayout,
-		"d.f32": () => f32,
-		"GRID_SIZE": () => GRID_SIZE,
-		"std.select": () => select,
-		"d.u32": () => u32,
-		"std.exp": () => exp,
-		"BRUSH_EDGE": () => BRUSH_EDGE,
-		"BRUSH_EDGE_GAIN": () => BRUSH_EDGE_GAIN,
-		"std.min": () => min,
-		"d.vec4f": () => vec4f
-	}
-}) && $.f)({})).$name("cursorTrailStamp");
-const outputKernel = typegpu_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
-	"use gpu";
-	const idx = __tsover_add(__tsover_mul(cy, u32(GRID_SIZE)), cx);
-	const cell = outputLayout.$.trailBuf[idx];
-	textureStore(outputLayout.$.trailTex, vec2u(cx, cy), cell);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "cx"
-		}, {
-			"type": "i",
-			"name": "cy"
-		}],
-		"body": [0, [
-			[
-				13,
-				"idx",
-				[
-					1,
-					[
-						1,
-						"cy",
-						"*",
-						[
-							6,
-							"d.u32",
-							["GRID_SIZE"]
-						]
-					],
-					"+",
-					"cx"
-				]
-			],
-			[
-				13,
-				"cell",
-				[
-					8,
-					[
-						7,
-						[
-							7,
-							"outputLayout",
-							"$"
-						],
-						"trailBuf"
-					],
-					"idx"
-				]
-			],
-			[
-				6,
-				"std.textureStore",
-				[
-					[
-						7,
-						[
-							7,
-							"outputLayout",
-							"$"
-						],
-						"trailTex"
-					],
-					[
-						6,
-						"d.vec2u",
-						["cx", "cy"]
-					],
-					"cell"
-				]
-			]
-		]]
-	},
-	externals: {
-		"d.u32": () => u32,
-		"GRID_SIZE": () => GRID_SIZE,
-		"outputLayout": () => outputLayout,
-		"std.textureStore": () => textureStore,
-		"d.vec2u": () => vec2u
-	}
-}) && $.f)({})).$name("cursorTrailOutput");
-const cursorTrailTapUV = typegpu_default.fn([
-	vec2f,
-	f32,
-	f32
-], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, ox, oy) => {
-	"use gpu";
-	return vec2f(__tsover_add(uv.x, ox), __tsover_add(uv.y, oy));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "uv"
-			},
-			{
-				"type": "i",
-				"name": "ox"
-			},
-			{
-				"type": "i",
-				"name": "oy"
-			}
-		],
-		"body": [0, [[10, [
-			6,
-			"d.vec2f",
-			[[
-				1,
-				[
-					7,
-					"uv",
-					"x"
-				],
-				"+",
-				"ox"
-			], [
-				1,
-				[
-					7,
-					"uv",
-					"y"
-				],
-				"+",
-				"oy"
-			]]
-		]]]]
-	},
-	externals: { "d.vec2f": () => vec2f }
-}) && $.f)({}));
-var TrailField = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
-	age: f32,
-	mask: f32
-}), "TrailField");
-const cursorTrailField = typegpu_default.fn([
-	vec4f,
-	vec4f,
-	vec4f,
-	vec4f,
-	vec4f
-], TrailField)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((c, s1, s2, s3, s4) => {
-	"use gpu";
-	const intensity = __tsover_add(__tsover_add(__tsover_add(__tsover_add(__tsover_mul(c.x, .5), __tsover_mul(s1.x, .125)), __tsover_mul(s2.x, .125)), __tsover_mul(s3.x, .125)), __tsover_mul(s4.x, .125));
-	return TrailField({
-		age: __tsover_add(__tsover_add(__tsover_add(__tsover_add(__tsover_mul(c.z, .5), __tsover_mul(s1.z, .125)), __tsover_mul(s2.z, .125)), __tsover_mul(s3.z, .125)), __tsover_mul(s4.z, .125)),
-		mask: step(.01, intensity)
-	});
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "c"
-			},
-			{
-				"type": "i",
-				"name": "s1"
-			},
-			{
-				"type": "i",
-				"name": "s2"
-			},
-			{
-				"type": "i",
-				"name": "s3"
-			},
-			{
-				"type": "i",
-				"name": "s4"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"intensity",
-				[
-					1,
-					[
-						1,
-						[
-							1,
-							[
-								1,
-								[
-									1,
-									[
-										7,
-										"c",
-										"x"
-									],
-									"*",
-									[5, "0.5"]
-								],
-								"+",
-								[
-									1,
-									[
-										7,
-										"s1",
-										"x"
-									],
-									"*",
-									[5, "0.125"]
-								]
-							],
-							"+",
-							[
-								1,
-								[
-									7,
-									"s2",
-									"x"
-								],
-								"*",
-								[5, "0.125"]
-							]
-						],
-						"+",
-						[
-							1,
-							[
-								7,
-								"s3",
-								"x"
-							],
-							"*",
-							[5, "0.125"]
-						]
-					],
-					"+",
-					[
-						1,
-						[
-							7,
-							"s4",
-							"x"
-						],
-						"*",
-						[5, "0.125"]
-					]
-				]
-			],
-			[
-				13,
-				"age",
-				[
-					1,
-					[
-						1,
-						[
-							1,
-							[
-								1,
-								[
-									1,
-									[
-										7,
-										"c",
-										"z"
-									],
-									"*",
-									[5, "0.5"]
-								],
-								"+",
-								[
-									1,
-									[
-										7,
-										"s1",
-										"z"
-									],
-									"*",
-									[5, "0.125"]
-								]
-							],
-							"+",
-							[
-								1,
-								[
-									7,
-									"s2",
-									"z"
-								],
-								"*",
-								[5, "0.125"]
-							]
-						],
-						"+",
-						[
-							1,
-							[
-								7,
-								"s3",
-								"z"
-							],
-							"*",
-							[5, "0.125"]
-						]
-					],
-					"+",
-					[
-						1,
-						[
-							7,
-							"s4",
-							"z"
-						],
-						"*",
-						[5, "0.125"]
-					]
-				]
-			],
-			[
-				13,
-				"mask",
-				[
-					6,
-					"std.step",
-					[[5, "0.01"], "intensity"]
-				]
-			],
-			[10, [
-				6,
-				"TrailField",
-				[[104, {
-					"age": "age",
-					"mask": "mask"
-				}]]
-			]]
-		]]
-	},
-	externals: {
-		"std.step": () => step,
-		"TrailField": () => TrailField
-	}
-}) && $.f)({}));
-const componentDefinition = {
-	name: "CursorTrail",
-	boundingBoxDeclaration: { aspectRatio: null },
-	category: "Interactive",
-	description: "Animated trail effect that tracks cursor movement",
-	usesPointer: true,
-	props: {
-		colorA: {
-			default: "#00aaff",
-			transform: transformColor,
-			description: "Color of fresh trails",
-			ui: {
-				type: "color",
-				label: "Start Color",
-				group: "Colors"
-			}
-		},
-		colorB: {
-			default: "#ff00aa",
-			transform: transformColor,
-			description: "Color trails transition to as they fade",
-			ui: {
-				type: "color",
-				label: "End Color",
-				group: "Colors"
-			}
-		},
-		stops: colorStopsPropConfig(),
-		radius: {
-			default: .5,
-			description: "Base radius of trail circles",
-			ui: {
-				type: "range",
-				min: .5,
-				max: 2,
-				step: .1,
-				label: "Radius",
-				group: "Effect"
-			}
-		},
-		length: {
-			default: .5,
-			description: "How long trail circles persist (in seconds)",
-			ui: {
-				type: "range",
-				min: .1,
-				max: 2,
-				step: .1,
-				label: "Trail Length",
-				group: "Animation"
-			}
-		},
-		shrink: {
-			default: 1,
-			description: "How much circles shrink as they fade out (0 = no shrink, 1 = full shrink)",
-			ui: {
-				type: "range",
-				min: 0,
-				max: 1,
-				step: .1,
-				label: "Shrink Amount",
-				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"
-			}
-		}
-	},
-	compute: (params) => {
-		const { gpu, registerComputeTexture, getCpuValue, onCleanup, onResize, dimensions } = params;
-		const root = gpu?.root;
-		if (!root) return null;
-		const trailBuf = createStateBuffer(root, vec4f, CELL_COUNT);
-		const trailTex = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
-			size: [GRID_SIZE, GRID_SIZE],
-			format: STATE_FORMAT
-		}).$usage("storage", "sampled"), "trailTex");
-		onCleanup(() => trailTex.destroy());
-		const trailTexture = registerComputeTexture(trailTex);
-		const decayParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(struct({
-			fadeRate: f32,
-			ageRate: f32,
-			shrink: f32
-		})), "decayParams");
-		const stampParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(struct({
-			cursorX: f32,
-			cursorY: f32,
-			radius: f32,
-			amount: f32,
-			aspect: f32
-		})), "stampParams");
-		let curW = Math.max(1, Math.round(dimensions.width));
-		let curH = Math.max(1, Math.round(dimensions.height));
-		onResize(({ width, height }) => {
-			curW = Math.max(1, Math.round(width));
-			curH = Math.max(1, Math.round(height));
-		});
-		const size = [GRID_SIZE, GRID_SIZE];
-		const decayBg = root.createBindGroup(decayLayout, {
-			trailBuf,
-			params: decayParams.buffer
-		});
-		const stampBg = root.createBindGroup(stampLayout, {
-			trailBuf,
-			params: stampParams.buffer
-		});
-		const outputBg = root.createBindGroup(outputLayout, {
-			trailBuf,
-			trailTex
-		});
-		const decay = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
-			"use gpu";
-			decayKernel(cx, cy);
-		}), {
-			v: 2,
-			name: void 0,
-			ast: {
-				"params": [{
-					"type": "i",
-					"name": "cx"
-				}, {
-					"type": "i",
-					"name": "cy"
-				}],
-				"body": [0, [[
-					6,
-					"decayKernel",
-					["cx", "cy"]
-				]]]
-			},
-			externals: { "decayKernel": () => decayKernel }
-		}) && $.f)({}), {
-			size,
-			bindGroup: decayBg
-		});
-		const stamp = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
-			"use gpu";
-			stampKernel(cx, cy);
-		}), {
-			v: 2,
-			name: void 0,
-			ast: {
-				"params": [{
-					"type": "i",
-					"name": "cx"
-				}, {
-					"type": "i",
-					"name": "cy"
-				}],
-				"body": [0, [[
-					6,
-					"stampKernel",
-					["cx", "cy"]
-				]]]
-			},
-			externals: { "stampKernel": () => stampKernel }
-		}) && $.f)({}), {
-			size,
-			bindGroup: stampBg
-		});
-		const output = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
-			"use gpu";
-			outputKernel(cx, cy);
-		}), {
-			v: 2,
-			name: void 0,
-			ast: {
-				"params": [{
-					"type": "i",
-					"name": "cx"
-				}, {
-					"type": "i",
-					"name": "cy"
-				}],
-				"body": [0, [[
-					6,
-					"outputKernel",
-					["cx", "cy"]
-				]]]
-			},
-			externals: { "outputKernel": () => outputKernel }
-		}) && $.f)({}), {
-			size,
-			bindGroup: outputBg
-		});
-		const pointer = createPointerVelocityTracker({
-			minDrag: .001,
-			teleportGuard: Number.POSITIVE_INFINITY
-		});
-		let lastActiveTime = Date.now();
-		return {
-			outputs: { trailTexture },
-			getComputeNodes: (frameParams) => {
-				const fp = frameParams;
-				const currentTime = Date.now();
-				const dt = Math.min(fp.deltaTime ?? 0, .016);
-				const aspect = Math.max(1, fp.dimensions?.width ?? curW) / Math.max(1, fp.dimensions?.height ?? curH);
-				const radius = (getCpuValue("radius") ?? .5) * .1;
-				const length = getCpuValue("length") ?? .5;
-				const shrink = getCpuValue("shrink") ?? 1;
-				const move = pointer.update(fp.pointer, dt);
-				const speed = Math.sqrt(move.dx * move.dx + move.dy * move.dy);
-				if (speed > .001) lastActiveTime = currentTime;
-				const settleMs = Math.min(3e4, Math.max(3e3, length * 5e3));
-				if (currentTime - lastActiveTime > settleMs) return null;
-				decayParams.write({
-					fadeRate: 1 - dt / Math.max(.1, length),
-					ageRate: dt / Math.max(.1, length),
-					shrink
-				});
-				const nodes = [decay];
-				if (speed > .001) {
-					let amountPerStep = 0;
-					amountPerStep = speed / pathStampRibbon(nodes, {
-						fromX: move.prevX,
-						fromY: move.prevY,
-						dx: move.dx,
-						dy: move.dy,
-						dragDist: speed,
-						stepSize: Math.max(.005, radius * .5),
-						maxSteps: 20,
-						write: (cursorX, cursorY) => stampParams.write({
-							cursorX,
-							cursorY,
-							radius,
-							amount: amountPerStep,
-							aspect
-						}),
-						pass: stamp
-					}) * 50 * dt;
-				}
-				nodes.push(output);
-				return nodes;
-			}
-		};
-	},
-	fragment: ({ ctx, computeOutputs, propValues, uniforms }) => {
-		const trailTex = computeOutputs?.trailTexture;
-		if (!trailTex) return ZERO;
-		const px = 1 / GRID_SIZE;
-		const tap = (ox, oy) => trailTex.sample(call(cursorTrailTapUV, "cursorTrailTapUV", [
-			ctx.uv,
-			floatE(ox),
-			floatE(oy)
-		]), "linearClamp");
-		const field = call(cursorTrailField, "cursorTrailField", [
-			trailTex.sample(ctx.uv, "linearClamp"),
-			tap(px, 0),
-			tap(0, px),
-			tap(-px, 0),
-			tap(0, -px)
-		]);
-		const trailAge = field.member("age");
-		const circleMask = field.member("mask");
-		const colorSpaceMode = propValues.colorSpace ?? 0;
-		const stopCount = propValues.stopCount ?? 0;
-		let trailColor;
-		if (stopCount > 1) trailColor = mixColorStopsRuntime(trailAge, {
-			colorsArray: uniforms.colorsArray,
-			positionsArray: uniforms.positionsArray,
-			convertedColorsArray: uniforms.convertedColorsArray,
-			stopCount: uniforms.stopCount
-		}, colorSpaceMode);
-		else trailColor = call(cm.mixColorsVariants[colorSpaceMode] ?? cm.mixColorsLinear, "mixColors", [
-			uniforms.colorA,
-			uniforms.colorB,
-			trailAge
-		]);
-		return vec4(trailColor.member("rgb"), trailColor.member("a").mul(circleMask));
-	}
-};
-var CursorTrail_default = componentDefinition;
-export { decayKernel as a, cursorTrailTapUV as i, componentDefinition as n, outputKernel as o, cursorTrailField as r, stampKernel as s, CursorTrail_default as t };