shaders 3.1.462 → 3.2.464

package/dist/core/noisePaints-Cs2Q1Xk9.js

@@ -0,0 +1,3890 @@
+import { $n as vec4f, En as cos, Fn as min, Gn as sqrt, In as mix, Jn as vec2f, Mn as fract, Nn as length, On as dot, Pn as max, Rn as pow, Tn as clamp, Un as sin, Vn as round, Wn as smoothstep, Wt as fbmGated, Xt as aspectOf, Zn as vec3f, bn as select, gr as i32, hr as f32, in as DEG_TO_RAD, jn as floor, kn as exp, ln as TAU, mn as typegpu_default, or as arrayOf, sn as PI, xn as abs } from "./lower-z2vuXP8M.js";
+import { d as mxNoiseFloat2, m as paper12, n as curl22, r as curl22z } from "./noise-B3Oq1k3_.js";
+import { i as toneRemap } from "./tone-BA0D_veZ.js";
+import { ht as gradientStopsInSpace, mt as MAX_COLOR_STOPS } from "./porters-B1UjrM1y.js";
+const cellHash2 = typegpu_default.fn([vec2f], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p) => {
+	"use gpu";
+	return fract(sin(vec2f(dot(p, vec2f(127.1, 311.7)), dot(p, vec2f(269.5, 183.3)))).mul(43758.5453));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "p"
+		}],
+		"body": [0, [[
+			13,
+			"h",
+			[
+				6,
+				"d.vec2f",
+				[[
+					6,
+					"std.dot",
+					["p", [
+						6,
+						"d.vec2f",
+						[[5, "127.1"], [5, "311.7"]]
+					]]
+				], [
+					6,
+					"std.dot",
+					["p", [
+						6,
+						"d.vec2f",
+						[[5, "269.5"], [5, "183.3"]]
+					]]
+				]]
+			]
+		], [10, [
+			6,
+			"std.fract",
+			[[
+				6,
+				[
+					7,
+					[
+						6,
+						"std.sin",
+						["h"]
+					],
+					"mul"
+				],
+				[[5, "43758.5453"]]
+			]]
+		]]]]
+	},
+	externals: {
+		"d.vec2f": () => vec2f,
+		"std.dot": () => dot,
+		"std.fract": () => fract,
+		"std.sin": () => sin
+	}
+}) && $.f)({}));
+function nearest2Cells(options) {
+	const { distance, jitter, name = "nearest2Cells" } = options;
+	const key = `${name}|${distance}|${jitter}`;
+	const cached = nearest2Cache.get(key);
+	if (cached) return cached;
+	const suffix = `${distance === "length" ? "Len" : "Sel"}${jitter === "mix" ? "Jit" : ""}`;
+	let built;
+	if (distance === "length" && jitter === "none") built = typegpu_default.fn([
+		vec2f,
+		f32,
+		f32
+	], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((scaledUV, animT, seed) => {
+		"use gpu";
+		const cell = floor(scaledUV);
+		const localUV = fract(scaledUV);
+		let d1 = f32(10);
+		let d2 = f32(10);
+		for (let ny = -1; ny <= 1; ny++) for (let nx = -1; nx <= 1; nx++) {
+			const offset = vec2f(f32(nx), f32(ny));
+			const h = cellHash2(vec2f(__tsover_add(__tsover_add(cell.x, offset.x), seed), __tsover_add(__tsover_add(cell.y, offset.y), seed)));
+			const pointX = clamp(__tsover_add(h.x, __tsover_mul(sin(__tsover_add(animT, __tsover_mul(h.x, TAU))), .15)), .05, .95);
+			const pointY = clamp(__tsover_add(h.y, __tsover_mul(cos(__tsover_add(__tsover_mul(animT, .7), __tsover_mul(h.y, TAU))), .15)), .05, .95);
+			const dd = length(vec2f(__tsover_sub(localUV.x, __tsover_add(offset.x, pointX)), __tsover_sub(localUV.y, __tsover_add(offset.y, pointY))));
+			d2 = min(d2, max(dd, d1));
+			d1 = min(d1, dd);
+		}
+		return vec2f(d1, d2);
+	}), {
+		v: 2,
+		name: void 0,
+		ast: {
+			"params": [
+				{
+					"type": "i",
+					"name": "scaledUV"
+				},
+				{
+					"type": "i",
+					"name": "animT"
+				},
+				{
+					"type": "i",
+					"name": "seed"
+				}
+			],
+			"body": [0, [
+				[
+					13,
+					"cell",
+					[
+						6,
+						"std.floor",
+						["scaledUV"]
+					]
+				],
+				[
+					13,
+					"localUV",
+					[
+						6,
+						"std.fract",
+						["scaledUV"]
+					]
+				],
+				[
+					12,
+					"d1",
+					[
+						6,
+						"d.f32",
+						[[5, "10"]]
+					]
+				],
+				[
+					12,
+					"d2",
+					[
+						6,
+						"d.f32",
+						[[5, "10"]]
+					]
+				],
+				[
+					14,
+					[
+						12,
+						"ny",
+						[
+							4,
+							"-",
+							[5, "1"]
+						]
+					],
+					[
+						1,
+						"ny",
+						"<=",
+						[5, "1"]
+					],
+					[
+						102,
+						"++",
+						"ny"
+					],
+					[0, [[
+						14,
+						[
+							12,
+							"nx",
+							[
+								4,
+								"-",
+								[5, "1"]
+							]
+						],
+						[
+							1,
+							"nx",
+							"<=",
+							[5, "1"]
+						],
+						[
+							102,
+							"++",
+							"nx"
+						],
+						[0, [
+							[
+								13,
+								"offset",
+								[
+									6,
+									"d.vec2f",
+									[[
+										6,
+										"d.f32",
+										["nx"]
+									], [
+										6,
+										"d.f32",
+										["ny"]
+									]]
+								]
+							],
+							[
+								13,
+								"h",
+								[
+									6,
+									"cellHash2",
+									[[
+										6,
+										"d.vec2f",
+										[[
+											1,
+											[
+												1,
+												[
+													7,
+													"cell",
+													"x"
+												],
+												"+",
+												[
+													7,
+													"offset",
+													"x"
+												]
+											],
+											"+",
+											"seed"
+										], [
+											1,
+											[
+												1,
+												[
+													7,
+													"cell",
+													"y"
+												],
+												"+",
+												[
+													7,
+													"offset",
+													"y"
+												]
+											],
+											"+",
+											"seed"
+										]]
+									]]
+								]
+							],
+							[
+								13,
+								"pointX",
+								[
+									6,
+									"std.clamp",
+									[
+										[
+											1,
+											[
+												7,
+												"h",
+												"x"
+											],
+											"+",
+											[
+												1,
+												[
+													6,
+													"std.sin",
+													[[
+														1,
+														"animT",
+														"+",
+														[
+															1,
+															[
+																7,
+																"h",
+																"x"
+															],
+															"*",
+															"TAU"
+														]
+													]]
+												],
+												"*",
+												[5, "0.15"]
+											]
+										],
+										[5, "0.05"],
+										[5, "0.95"]
+									]
+								]
+							],
+							[
+								13,
+								"pointY",
+								[
+									6,
+									"std.clamp",
+									[
+										[
+											1,
+											[
+												7,
+												"h",
+												"y"
+											],
+											"+",
+											[
+												1,
+												[
+													6,
+													"std.cos",
+													[[
+														1,
+														[
+															1,
+															"animT",
+															"*",
+															[5, "0.7"]
+														],
+														"+",
+														[
+															1,
+															[
+																7,
+																"h",
+																"y"
+															],
+															"*",
+															"TAU"
+														]
+													]]
+												],
+												"*",
+												[5, "0.15"]
+											]
+										],
+										[5, "0.05"],
+										[5, "0.95"]
+									]
+								]
+							],
+							[
+								13,
+								"dd",
+								[
+									6,
+									"std.length",
+									[[
+										6,
+										"d.vec2f",
+										[[
+											1,
+											[
+												7,
+												"localUV",
+												"x"
+											],
+											"-",
+											[
+												1,
+												[
+													7,
+													"offset",
+													"x"
+												],
+												"+",
+												"pointX"
+											]
+										], [
+											1,
+											[
+												7,
+												"localUV",
+												"y"
+											],
+											"-",
+											[
+												1,
+												[
+													7,
+													"offset",
+													"y"
+												],
+												"+",
+												"pointY"
+											]
+										]]
+									]]
+								]
+							],
+							[
+								2,
+								"d2",
+								"=",
+								[
+									6,
+									"std.min",
+									["d2", [
+										6,
+										"std.max",
+										["dd", "d1"]
+									]]
+								]
+							],
+							[
+								2,
+								"d1",
+								"=",
+								[
+									6,
+									"std.min",
+									["d1", "dd"]
+								]
+							]
+						]]
+					]]]
+				],
+				[10, [
+					6,
+					"d.vec2f",
+					["d1", "d2"]
+				]]
+			]]
+		},
+		externals: {
+			"std.floor": () => floor,
+			"std.fract": () => fract,
+			"d.f32": () => f32,
+			"d.vec2f": () => vec2f,
+			"cellHash2": () => cellHash2,
+			"std.clamp": () => clamp,
+			"std.sin": () => sin,
+			"TAU": () => TAU,
+			"std.cos": () => cos,
+			"std.length": () => length,
+			"std.min": () => min,
+			"std.max": () => max
+		}
+	}) && $.f)({})).$name(`${name}${suffix}`);
+	else built = typegpu_default.fn([
+		vec2f,
+		f32,
+		f32,
+		f32,
+		f32
+	], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((scaledUV, animT, seed, jitterAmount, metric) => {
+		"use gpu";
+		const animTSlow = __tsover_mul(animT, .7);
+		const cell = floor(scaledUV);
+		const localUV = fract(scaledUV);
+		let d1 = f32(10);
+		let d2 = f32(10);
+		for (let ny = -1; ny <= 1; ny++) for (let nx = -1; nx <= 1; nx++) {
+			const offset = vec2f(f32(nx), f32(ny));
+			const h = cellHash2(vec2f(__tsover_add(__tsover_add(cell.x, offset.x), seed), __tsover_add(__tsover_add(cell.y, offset.y), seed)));
+			const px = __tsover_add(h.x, __tsover_mul(sin(__tsover_add(animT, __tsover_mul(h.x, TAU))), .15));
+			const py = __tsover_add(h.y, __tsover_mul(cos(__tsover_add(animTSlow, __tsover_mul(h.y, TAU))), .15));
+			const jx = mix(.5, clamp(px, .05, .95), jitterAmount);
+			const jy = mix(.5, clamp(py, .05, .95), jitterAmount);
+			const deltaX = __tsover_sub(localUV.x, __tsover_add(offset.x, jx));
+			const deltaY = __tsover_sub(localUV.y, __tsover_add(offset.y, jy));
+			const dEuclid = __tsover_add(__tsover_mul(deltaX, deltaX), __tsover_mul(deltaY, deltaY));
+			const dManhattan = __tsover_add(abs(deltaX), abs(deltaY));
+			const dChebyshev = max(abs(deltaX), abs(deltaY));
+			let dd = dEuclid;
+			dd = select(dd, dManhattan, metric === 1);
+			dd = select(dd, dChebyshev, metric === 2);
+			d2 = min(d2, max(dd, d1));
+			d1 = min(d1, dd);
+		}
+		return vec2f(d1, d2);
+	}), {
+		v: 2,
+		name: void 0,
+		ast: {
+			"params": [
+				{
+					"type": "i",
+					"name": "scaledUV"
+				},
+				{
+					"type": "i",
+					"name": "animT"
+				},
+				{
+					"type": "i",
+					"name": "seed"
+				},
+				{
+					"type": "i",
+					"name": "jitterAmount"
+				},
+				{
+					"type": "i",
+					"name": "metric"
+				}
+			],
+			"body": [0, [
+				[
+					13,
+					"animTSlow",
+					[
+						1,
+						"animT",
+						"*",
+						[5, "0.7"]
+					]
+				],
+				[
+					13,
+					"cell",
+					[
+						6,
+						"std.floor",
+						["scaledUV"]
+					]
+				],
+				[
+					13,
+					"localUV",
+					[
+						6,
+						"std.fract",
+						["scaledUV"]
+					]
+				],
+				[
+					12,
+					"d1",
+					[
+						6,
+						"d.f32",
+						[[5, "10"]]
+					]
+				],
+				[
+					12,
+					"d2",
+					[
+						6,
+						"d.f32",
+						[[5, "10"]]
+					]
+				],
+				[
+					14,
+					[
+						12,
+						"ny",
+						[
+							4,
+							"-",
+							[5, "1"]
+						]
+					],
+					[
+						1,
+						"ny",
+						"<=",
+						[5, "1"]
+					],
+					[
+						102,
+						"++",
+						"ny"
+					],
+					[0, [[
+						14,
+						[
+							12,
+							"nx",
+							[
+								4,
+								"-",
+								[5, "1"]
+							]
+						],
+						[
+							1,
+							"nx",
+							"<=",
+							[5, "1"]
+						],
+						[
+							102,
+							"++",
+							"nx"
+						],
+						[0, [
+							[
+								13,
+								"offset",
+								[
+									6,
+									"d.vec2f",
+									[[
+										6,
+										"d.f32",
+										["nx"]
+									], [
+										6,
+										"d.f32",
+										["ny"]
+									]]
+								]
+							],
+							[
+								13,
+								"h",
+								[
+									6,
+									"cellHash2",
+									[[
+										6,
+										"d.vec2f",
+										[[
+											1,
+											[
+												1,
+												[
+													7,
+													"cell",
+													"x"
+												],
+												"+",
+												[
+													7,
+													"offset",
+													"x"
+												]
+											],
+											"+",
+											"seed"
+										], [
+											1,
+											[
+												1,
+												[
+													7,
+													"cell",
+													"y"
+												],
+												"+",
+												[
+													7,
+													"offset",
+													"y"
+												]
+											],
+											"+",
+											"seed"
+										]]
+									]]
+								]
+							],
+							[
+								13,
+								"px",
+								[
+									1,
+									[
+										7,
+										"h",
+										"x"
+									],
+									"+",
+									[
+										1,
+										[
+											6,
+											"std.sin",
+											[[
+												1,
+												"animT",
+												"+",
+												[
+													1,
+													[
+														7,
+														"h",
+														"x"
+													],
+													"*",
+													"TAU"
+												]
+											]]
+										],
+										"*",
+										[5, "0.15"]
+									]
+								]
+							],
+							[
+								13,
+								"py",
+								[
+									1,
+									[
+										7,
+										"h",
+										"y"
+									],
+									"+",
+									[
+										1,
+										[
+											6,
+											"std.cos",
+											[[
+												1,
+												"animTSlow",
+												"+",
+												[
+													1,
+													[
+														7,
+														"h",
+														"y"
+													],
+													"*",
+													"TAU"
+												]
+											]]
+										],
+										"*",
+										[5, "0.15"]
+									]
+								]
+							],
+							[
+								13,
+								"jx",
+								[
+									6,
+									"std.mix",
+									[
+										[5, "0.5"],
+										[
+											6,
+											"std.clamp",
+											[
+												"px",
+												[5, "0.05"],
+												[5, "0.95"]
+											]
+										],
+										"jitterAmount"
+									]
+								]
+							],
+							[
+								13,
+								"jy",
+								[
+									6,
+									"std.mix",
+									[
+										[5, "0.5"],
+										[
+											6,
+											"std.clamp",
+											[
+												"py",
+												[5, "0.05"],
+												[5, "0.95"]
+											]
+										],
+										"jitterAmount"
+									]
+								]
+							],
+							[
+								13,
+								"deltaX",
+								[
+									1,
+									[
+										7,
+										"localUV",
+										"x"
+									],
+									"-",
+									[
+										1,
+										[
+											7,
+											"offset",
+											"x"
+										],
+										"+",
+										"jx"
+									]
+								]
+							],
+							[
+								13,
+								"deltaY",
+								[
+									1,
+									[
+										7,
+										"localUV",
+										"y"
+									],
+									"-",
+									[
+										1,
+										[
+											7,
+											"offset",
+											"y"
+										],
+										"+",
+										"jy"
+									]
+								]
+							],
+							[
+								13,
+								"dEuclid",
+								[
+									1,
+									[
+										1,
+										"deltaX",
+										"*",
+										"deltaX"
+									],
+									"+",
+									[
+										1,
+										"deltaY",
+										"*",
+										"deltaY"
+									]
+								]
+							],
+							[
+								13,
+								"dManhattan",
+								[
+									1,
+									[
+										6,
+										"std.abs",
+										["deltaX"]
+									],
+									"+",
+									[
+										6,
+										"std.abs",
+										["deltaY"]
+									]
+								]
+							],
+							[
+								13,
+								"dChebyshev",
+								[
+									6,
+									"std.max",
+									[[
+										6,
+										"std.abs",
+										["deltaX"]
+									], [
+										6,
+										"std.abs",
+										["deltaY"]
+									]]
+								]
+							],
+							[
+								12,
+								"dd",
+								"dEuclid"
+							],
+							[
+								2,
+								"dd",
+								"=",
+								[
+									6,
+									"std.select",
+									[
+										"dd",
+										"dManhattan",
+										[
+											1,
+											"metric",
+											"===",
+											[5, "1"]
+										]
+									]
+								]
+							],
+							[
+								2,
+								"dd",
+								"=",
+								[
+									6,
+									"std.select",
+									[
+										"dd",
+										"dChebyshev",
+										[
+											1,
+											"metric",
+											"===",
+											[5, "2"]
+										]
+									]
+								]
+							],
+							[
+								2,
+								"d2",
+								"=",
+								[
+									6,
+									"std.min",
+									["d2", [
+										6,
+										"std.max",
+										["dd", "d1"]
+									]]
+								]
+							],
+							[
+								2,
+								"d1",
+								"=",
+								[
+									6,
+									"std.min",
+									["d1", "dd"]
+								]
+							]
+						]]
+					]]]
+				],
+				[10, [
+					6,
+					"d.vec2f",
+					["d1", "d2"]
+				]]
+			]]
+		},
+		externals: {
+			"std.floor": () => floor,
+			"std.fract": () => fract,
+			"d.f32": () => f32,
+			"d.vec2f": () => vec2f,
+			"cellHash2": () => cellHash2,
+			"std.sin": () => sin,
+			"TAU": () => TAU,
+			"std.cos": () => cos,
+			"std.mix": () => mix,
+			"std.clamp": () => clamp,
+			"std.abs": () => abs,
+			"std.max": () => max,
+			"std.select": () => select,
+			"std.min": () => min
+		}
+	}) && $.f)({})).$name(`${name}${suffix}`);
+	nearest2Cache.set(key, built);
+	return built;
+}
+var nearest2Cache = /* @__PURE__ */ new Map();
+const CELL_MODES = {
+	f1: 0,
+	f2: 1,
+	f2MinusF1: 2,
+	f1PlusF2: 3,
+	f1TimesF2: 4
+};
+const CELL_METRICS = {
+	euclidean: 0,
+	manhattan: 1,
+	chebyshev: 2
+};
+const cellReduceSelectable = typegpu_default.fn([
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((d1, d2, metric, mode) => {
+	"use gpu";
+	const isEuclid = metric === 0;
+	const sd1 = select(d1, sqrt(d1), isEuclid);
+	const sd2 = select(d2, sqrt(d2), isEuclid);
+	let raw = sd1;
+	raw = select(raw, sd2, mode === 1);
+	raw = select(raw, __tsover_sub(sd2, sd1), mode === 2);
+	raw = select(raw, __tsover_add(sd1, sd2), mode === 3);
+	raw = select(raw, __tsover_mul(sd1, sd2), mode === 4);
+	return raw;
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "d1"
+			},
+			{
+				"type": "i",
+				"name": "d2"
+			},
+			{
+				"type": "i",
+				"name": "metric"
+			},
+			{
+				"type": "i",
+				"name": "mode"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"isEuclid",
+				[
+					1,
+					"metric",
+					"===",
+					[5, "0"]
+				]
+			],
+			[
+				13,
+				"sd1",
+				[
+					6,
+					"std.select",
+					[
+						"d1",
+						[
+							6,
+							"std.sqrt",
+							["d1"]
+						],
+						"isEuclid"
+					]
+				]
+			],
+			[
+				13,
+				"sd2",
+				[
+					6,
+					"std.select",
+					[
+						"d2",
+						[
+							6,
+							"std.sqrt",
+							["d2"]
+						],
+						"isEuclid"
+					]
+				]
+			],
+			[
+				12,
+				"raw",
+				"sd1"
+			],
+			[
+				2,
+				"raw",
+				"=",
+				[
+					6,
+					"std.select",
+					[
+						"raw",
+						"sd2",
+						[
+							1,
+							"mode",
+							"===",
+							[5, "1"]
+						]
+					]
+				]
+			],
+			[
+				2,
+				"raw",
+				"=",
+				[
+					6,
+					"std.select",
+					[
+						"raw",
+						[
+							1,
+							"sd2",
+							"-",
+							"sd1"
+						],
+						[
+							1,
+							"mode",
+							"===",
+							[5, "2"]
+						]
+					]
+				]
+			],
+			[
+				2,
+				"raw",
+				"=",
+				[
+					6,
+					"std.select",
+					[
+						"raw",
+						[
+							1,
+							"sd1",
+							"+",
+							"sd2"
+						],
+						[
+							1,
+							"mode",
+							"===",
+							[5, "3"]
+						]
+					]
+				]
+			],
+			[
+				2,
+				"raw",
+				"=",
+				[
+					6,
+					"std.select",
+					[
+						"raw",
+						[
+							1,
+							"sd1",
+							"*",
+							"sd2"
+						],
+						[
+							1,
+							"mode",
+							"===",
+							[5, "4"]
+						]
+					]
+				]
+			],
+			[10, "raw"]
+		]]
+	},
+	externals: {
+		"std.select": () => select,
+		"std.sqrt": () => sqrt
+	}
+}) && $.f)({}));
+const cellRatio = typegpu_default.fn([
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((d1, d2, power) => {
+	"use gpu";
+	const safeSum = max(__tsover_add(d1, d2), 1e-4);
+	return clamp(pow(clamp(__tsover_div(__tsover_mul(d1, 2), safeSum), 0, 1), power), 0, 1);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "d1"
+			},
+			{
+				"type": "i",
+				"name": "d2"
+			},
+			{
+				"type": "i",
+				"name": "power"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"safeSum",
+				[
+					6,
+					"std.max",
+					[[
+						1,
+						"d1",
+						"+",
+						"d2"
+					], [5, "0.0001"]]
+				]
+			],
+			[
+				13,
+				"normalizedDist",
+				[
+					6,
+					"std.clamp",
+					[
+						[
+							1,
+							[
+								1,
+								"d1",
+								"*",
+								[5, "2"]
+							],
+							"/",
+							"safeSum"
+						],
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[10, [
+				6,
+				"std.clamp",
+				[
+					[
+						6,
+						"std.pow",
+						["normalizedDist", "power"]
+					],
+					[5, "0"],
+					[5, "1"]
+				]
+			]]
+		]]
+	},
+	externals: {
+		"std.max": () => max,
+		"std.clamp": () => clamp,
+		"std.pow": () => pow
+	}
+}) && $.f)({}));
+const cellEdgeMask = typegpu_default.fn([
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((d1, d2, softness) => {
+	"use gpu";
+	const safeSum = max(__tsover_add(d1, d2), 1e-4);
+	const edgeMetric = __tsover_div(__tsover_sub(d2, d1), safeSum);
+	return smoothstep(0, __tsover_add(softness, .001), edgeMetric);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "d1"
+			},
+			{
+				"type": "i",
+				"name": "d2"
+			},
+			{
+				"type": "i",
+				"name": "softness"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"safeSum",
+				[
+					6,
+					"std.max",
+					[[
+						1,
+						"d1",
+						"+",
+						"d2"
+					], [5, "0.0001"]]
+				]
+			],
+			[
+				13,
+				"edgeMetric",
+				[
+					1,
+					[
+						1,
+						"d2",
+						"-",
+						"d1"
+					],
+					"/",
+					"safeSum"
+				]
+			],
+			[10, [
+				6,
+				"std.smoothstep",
+				[
+					[5, "0"],
+					[
+						1,
+						"softness",
+						"+",
+						[5, "0.001"]
+					],
+					"edgeMetric"
+				]
+			]]
+		]]
+	},
+	externals: {
+		"std.max": () => max,
+		"std.smoothstep": () => smoothstep
+	}
+}) && $.f)({}));
+const aspectPlane = typegpu_default.fn([vec2f, vec2f], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport) => {
+	"use gpu";
+	const aspect = aspectOf(viewport);
+	return vec2f(__tsover_mul(uv.x, aspect), uv.y);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "uv"
+		}, {
+			"type": "i",
+			"name": "viewport"
+		}],
+		"body": [0, [[
+			13,
+			"aspect",
+			[
+				6,
+				"aspectOf",
+				["viewport"]
+			]
+		], [10, [
+			6,
+			"d.vec2f",
+			[[
+				1,
+				[
+					7,
+					"uv",
+					"x"
+				],
+				"*",
+				"aspect"
+			], [
+				7,
+				"uv",
+				"y"
+			]]
+		]]]]
+	},
+	externals: {
+		"aspectOf": () => aspectOf,
+		"d.vec2f": () => vec2f
+	}
+}) && $.f)({}));
+const rawAspectScaledDomain = typegpu_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, scale, seed) => {
+	"use gpu";
+	const aspect = __tsover_div(viewport.x, viewport.y);
+	return vec2f(__tsover_mul(uv.x, aspect), uv.y).mul(exp(scale)).add(seed);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "uv"
+			},
+			{
+				"type": "i",
+				"name": "viewport"
+			},
+			{
+				"type": "i",
+				"name": "scale"
+			},
+			{
+				"type": "i",
+				"name": "seed"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"aspect",
+				[
+					1,
+					[
+						7,
+						"viewport",
+						"x"
+					],
+					"/",
+					[
+						7,
+						"viewport",
+						"y"
+					]
+				]
+			],
+			[
+				13,
+				"aspectUV",
+				[
+					6,
+					"d.vec2f",
+					[[
+						1,
+						[
+							7,
+							"uv",
+							"x"
+						],
+						"*",
+						"aspect"
+					], [
+						7,
+						"uv",
+						"y"
+					]]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					[
+						6,
+						[
+							7,
+							"aspectUV",
+							"mul"
+						],
+						[[
+							6,
+							"std.exp",
+							["scale"]
+						]]
+					],
+					"add"
+				],
+				["seed"]
+			]]
+		]]
+	},
+	externals: {
+		"d.vec2f": () => vec2f,
+		"std.exp": () => exp
+	}
+}) && $.f)({}));
+const rotatedCenteredDomain = typegpu_default.fn([
+	vec2f,
+	vec2f,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, angle) => {
+	"use gpu";
+	const aspect = aspectOf(viewport);
+	const angleRad = __tsover_mul(angle, DEG_TO_RAD);
+	const cosA = cos(angleRad);
+	const sinA = sin(angleRad);
+	const au = __tsover_sub(__tsover_mul(uv.x, aspect), __tsover_mul(aspect, .5));
+	const av = __tsover_sub(uv.y, .5);
+	return vec2f(__tsover_add(__tsover_mul(au, cosA), __tsover_mul(av, sinA)), __tsover_add(__tsover_mul(au, -sinA), __tsover_mul(av, cosA)));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "uv"
+			},
+			{
+				"type": "i",
+				"name": "viewport"
+			},
+			{
+				"type": "i",
+				"name": "angle"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"aspect",
+				[
+					6,
+					"aspectOf",
+					["viewport"]
+				]
+			],
+			[
+				13,
+				"angleRad",
+				[
+					1,
+					"angle",
+					"*",
+					"DEG_TO_RAD"
+				]
+			],
+			[
+				13,
+				"cosA",
+				[
+					6,
+					"std.cos",
+					["angleRad"]
+				]
+			],
+			[
+				13,
+				"sinA",
+				[
+					6,
+					"std.sin",
+					["angleRad"]
+				]
+			],
+			[
+				13,
+				"au",
+				[
+					1,
+					[
+						1,
+						[
+							7,
+							"uv",
+							"x"
+						],
+						"*",
+						"aspect"
+					],
+					"-",
+					[
+						1,
+						"aspect",
+						"*",
+						[5, "0.5"]
+					]
+				]
+			],
+			[
+				13,
+				"av",
+				[
+					1,
+					[
+						7,
+						"uv",
+						"y"
+					],
+					"-",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"ru",
+				[
+					1,
+					[
+						1,
+						"au",
+						"*",
+						"cosA"
+					],
+					"+",
+					[
+						1,
+						"av",
+						"*",
+						"sinA"
+					]
+				]
+			],
+			[
+				13,
+				"rv",
+				[
+					1,
+					[
+						1,
+						"au",
+						"*",
+						[
+							4,
+							"-",
+							"sinA"
+						]
+					],
+					"+",
+					[
+						1,
+						"av",
+						"*",
+						"cosA"
+					]
+				]
+			],
+			[10, [
+				6,
+				"d.vec2f",
+				["ru", "rv"]
+			]]
+		]]
+	},
+	externals: {
+		"aspectOf": () => aspectOf,
+		"DEG_TO_RAD": () => DEG_TO_RAD,
+		"std.cos": () => cos,
+		"std.sin": () => sin,
+		"d.vec2f": () => vec2f
+	}
+}) && $.f)({}));
+const curlMagnitude = typegpu_default.fn([vec2f, f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((pos, z) => {
+	"use gpu";
+	return __tsover_div(length(curl22z(pos, z)), 1.414);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "pos"
+		}, {
+			"type": "i",
+			"name": "z"
+		}],
+		"body": [0, [[10, [
+			1,
+			[
+				6,
+				"std.length",
+				[[
+					6,
+					"curl22z",
+					["pos", "z"]
+				]]
+			],
+			"/",
+			[5, "1.414"]
+		]]]]
+	},
+	externals: {
+		"std.length": () => length,
+		"curl22z": () => curl22z
+	}
+}) && $.f)({}));
+var fractalOctaveSum = fbmGated(mxNoiseFloat2, {
+	maxOctaves: 8,
+	drift: "goldenAngle",
+	name: "fractalOctaveSum"
+});
+const fractalSum = typegpu_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((pos, detail, contrast, animTime, seed, octaveCount) => {
+	"use gpu";
+	return fractalOctaveSum(pos, 2, detail, contrast, animTime, vec2f(seed, __tsover_mul(seed, .7)), octaveCount);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "pos"
+			},
+			{
+				"type": "i",
+				"name": "detail"
+			},
+			{
+				"type": "i",
+				"name": "contrast"
+			},
+			{
+				"type": "i",
+				"name": "animTime"
+			},
+			{
+				"type": "i",
+				"name": "seed"
+			},
+			{
+				"type": "i",
+				"name": "octaveCount"
+			}
+		],
+		"body": [0, [[10, [
+			6,
+			"fractalOctaveSum",
+			[
+				"pos",
+				[5, "2"],
+				"detail",
+				"contrast",
+				"animTime",
+				[
+					6,
+					"d.vec2f",
+					["seed", [
+						1,
+						"seed",
+						"*",
+						[5, "0.7"]
+					]]
+				],
+				"octaveCount"
+			]
+		]]]]
+	},
+	externals: {
+		"fractalOctaveSum": () => fractalOctaveSum,
+		"d.vec2f": () => vec2f
+	}
+}) && $.f)({}));
+const fbmNormalize = typegpu_default.fn([vec2f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sum) => {
+	"use gpu";
+	return clamp(__tsover_add(__tsover_mul(__tsover_div(sum.x, sum.y), .5), .5), 0, 1);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "sum"
+		}],
+		"body": [0, [[10, [
+			6,
+			"std.clamp",
+			[
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								7,
+								"sum",
+								"x"
+							],
+							"/",
+							[
+								7,
+								"sum",
+								"y"
+							]
+						],
+						"*",
+						[5, "0.5"]
+					],
+					"+",
+					[5, "0.5"]
+				],
+				[5, "0"],
+				[5, "1"]
+			]
+		]]]]
+	},
+	externals: { "std.clamp": () => clamp }
+}) && $.f)({}));
+const worleyHash = cellHash2;
+var worleyNearest2 = nearest2Cells({
+	distance: "selectableSquared",
+	jitter: "mix",
+	name: "worleyNearest2"
+});
+var worleyOctaveSum = fbmGated(typegpu_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((oUV, animT, seedOff, jitter, distNum, modeNum) => {
+	"use gpu";
+	const dd = worleyNearest2(oUV, animT, seedOff, jitter, distNum);
+	return cellReduceSelectable(dd.x, dd.y, distNum, modeNum);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "oUV"
+			},
+			{
+				"type": "i",
+				"name": "animT"
+			},
+			{
+				"type": "i",
+				"name": "seedOff"
+			},
+			{
+				"type": "i",
+				"name": "jitter"
+			},
+			{
+				"type": "i",
+				"name": "distNum"
+			},
+			{
+				"type": "i",
+				"name": "modeNum"
+			}
+		],
+		"body": [0, [[
+			13,
+			"dd",
+			[
+				6,
+				"worleyNearest2",
+				[
+					"oUV",
+					"animT",
+					"seedOff",
+					"jitter",
+					"distNum"
+				]
+			]
+		], [10, [
+			6,
+			"cellReduceSelectable",
+			[
+				[
+					7,
+					"dd",
+					"x"
+				],
+				[
+					7,
+					"dd",
+					"y"
+				],
+				"distNum",
+				"modeNum"
+			]
+		]]]]
+	},
+	externals: {
+		"worleyNearest2": () => worleyNearest2,
+		"cellReduceSelectable": () => cellReduceSelectable
+	}
+}) && $.f)({})), {
+	maxOctaves: 4,
+	drift: "timeSeed",
+	name: "worleyOctaveSum"
+});
+const worleyCells = typegpu_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((pos, scale, seed, jitter, lacunarity, persistence, animTime, octaves, distNum, modeNum) => {
+	"use gpu";
+	return worleyOctaveSum(pos, scale, lacunarity, persistence, animTime, seed, vec3f(jitter, distNum, modeNum), octaves);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "pos"
+			},
+			{
+				"type": "i",
+				"name": "scale"
+			},
+			{
+				"type": "i",
+				"name": "seed"
+			},
+			{
+				"type": "i",
+				"name": "jitter"
+			},
+			{
+				"type": "i",
+				"name": "lacunarity"
+			},
+			{
+				"type": "i",
+				"name": "persistence"
+			},
+			{
+				"type": "i",
+				"name": "animTime"
+			},
+			{
+				"type": "i",
+				"name": "octaves"
+			},
+			{
+				"type": "i",
+				"name": "distNum"
+			},
+			{
+				"type": "i",
+				"name": "modeNum"
+			}
+		],
+		"body": [0, [[10, [
+			6,
+			"worleyOctaveSum",
+			[
+				"pos",
+				"scale",
+				"lacunarity",
+				"persistence",
+				"animTime",
+				"seed",
+				[
+					6,
+					"d.vec3f",
+					[
+						"jitter",
+						"distNum",
+						"modeNum"
+					]
+				],
+				"octaves"
+			]
+		]]]]
+	},
+	externals: {
+		"worleyOctaveSum": () => worleyOctaveSum,
+		"d.vec3f": () => vec3f
+	}
+}) && $.f)({}));
+const worleyNormalize = typegpu_default.fn([vec2f, f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sum, modeScale) => {
+	"use gpu";
+	return __tsover_mul(__tsover_div(sum.x, max(sum.y, 1e-4)), modeScale);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "sum"
+		}, {
+			"type": "i",
+			"name": "modeScale"
+		}],
+		"body": [0, [[10, [
+			1,
+			[
+				1,
+				[
+					7,
+					"sum",
+					"x"
+				],
+				"/",
+				[
+					6,
+					"std.max",
+					[[
+						7,
+						"sum",
+						"y"
+					], [5, "0.0001"]]
+				]
+			],
+			"*",
+			"modeScale"
+		]]]]
+	},
+	externals: { "std.max": () => max }
+}) && $.f)({}));
+const worleyTone = toneRemap({
+	domain: "unit",
+	contrastMode: "multiplicative",
+	invert: false
+});
+const transformWorleyMode = (value) => CELL_MODES[value] ?? 0;
+const transformWorleyDistance = (value) => CELL_METRICS[value] ?? 0;
+function worleyModeNum(raw) {
+	return typeof raw === "number" ? raw : transformWorleyMode(raw);
+}
+function worleyDistNum(raw) {
+	return typeof raw === "number" ? raw : transformWorleyDistance(raw);
+}
+function worleyModeScale(modeNum, distNum) {
+	let modeScale = 1.5;
+	if (modeNum === 1) modeScale = 1;
+	else if (modeNum === 2) modeScale = 2.5;
+	else if (modeNum === 3) modeScale = .6;
+	else if (modeNum === 4) modeScale = 2;
+	if (distNum === 1) modeScale *= .7;
+	else if (distNum === 2) modeScale *= 1.4;
+	return modeScale;
+}
+const voronoiCells = nearest2Cells({
+	distance: "length",
+	jitter: "none",
+	name: "voronoiNearest2"
+});
+const cellFill = typegpu_default.fn([vec2f, f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((dd, edgeIntensity) => {
+	"use gpu";
+	const gradientPower = __tsover_sub(4, __tsover_mul(edgeIntensity, 3));
+	return cellRatio(dd.x, dd.y, gradientPower);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "dd"
+		}, {
+			"type": "i",
+			"name": "edgeIntensity"
+		}],
+		"body": [0, [[
+			13,
+			"gradientPower",
+			[
+				1,
+				[5, "4"],
+				"-",
+				[
+					1,
+					"edgeIntensity",
+					"*",
+					[5, "3"]
+				]
+			]
+		], [10, [
+			6,
+			"cellRatio",
+			[
+				[
+					7,
+					"dd",
+					"x"
+				],
+				[
+					7,
+					"dd",
+					"y"
+				],
+				"gradientPower"
+			]
+		]]]]
+	},
+	externals: { "cellRatio": () => cellRatio }
+}) && $.f)({}));
+const cellBorders = typegpu_default.fn([
+	vec2f,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((dd, softness, scale) => {
+	"use gpu";
+	const scaledEdgeSoftness = __tsover_div(__tsover_mul(softness, scale), 6);
+	return cellEdgeMask(dd.x, dd.y, scaledEdgeSoftness);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "dd"
+			},
+			{
+				"type": "i",
+				"name": "softness"
+			},
+			{
+				"type": "i",
+				"name": "scale"
+			}
+		],
+		"body": [0, [[
+			13,
+			"scaledEdgeSoftness",
+			[
+				1,
+				[
+					1,
+					"softness",
+					"*",
+					"scale"
+				],
+				"/",
+				[5, "6"]
+			]
+		], [10, [
+			6,
+			"cellEdgeMask",
+			[
+				[
+					7,
+					"dd",
+					"x"
+				],
+				[
+					7,
+					"dd",
+					"y"
+				],
+				"scaledEdgeSoftness"
+			]
+		]]]]
+	},
+	externals: { "cellEdgeMask": () => cellEdgeMask }
+}) && $.f)({}));
+const marbleTurbulence = typegpu_default.fn([
+	vec2f,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((pos, seed, animTime) => {
+	"use gpu";
+	const n1 = mxNoiseFloat2(vec2f(__tsover_add(pos.x, seed), __tsover_add(pos.y, animTime)));
+	const n2 = __tsover_mul(mxNoiseFloat2(vec2f(__tsover_add(__tsover_mul(pos.x, 2), __tsover_mul(seed, 1.7)), __tsover_add(__tsover_mul(pos.y, 2), __tsover_mul(animTime, .7)))), .5);
+	const n3 = __tsover_mul(mxNoiseFloat2(vec2f(__tsover_add(__tsover_mul(pos.x, 4), __tsover_mul(seed, 3.1)), __tsover_add(__tsover_mul(pos.y, 4), __tsover_mul(animTime, 1.3)))), .25);
+	return __tsover_add(__tsover_add(n1, n2), n3);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "pos"
+			},
+			{
+				"type": "i",
+				"name": "seed"
+			},
+			{
+				"type": "i",
+				"name": "animTime"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"n1",
+				[
+					6,
+					"mxNoiseFloat2",
+					[[
+						6,
+						"d.vec2f",
+						[[
+							1,
+							[
+								7,
+								"pos",
+								"x"
+							],
+							"+",
+							"seed"
+						], [
+							1,
+							[
+								7,
+								"pos",
+								"y"
+							],
+							"+",
+							"animTime"
+						]]
+					]]
+				]
+			],
+			[
+				13,
+				"n2",
+				[
+					1,
+					[
+						6,
+						"mxNoiseFloat2",
+						[[
+							6,
+							"d.vec2f",
+							[[
+								1,
+								[
+									1,
+									[
+										7,
+										"pos",
+										"x"
+									],
+									"*",
+									[5, "2"]
+								],
+								"+",
+								[
+									1,
+									"seed",
+									"*",
+									[5, "1.7"]
+								]
+							], [
+								1,
+								[
+									1,
+									[
+										7,
+										"pos",
+										"y"
+									],
+									"*",
+									[5, "2"]
+								],
+								"+",
+								[
+									1,
+									"animTime",
+									"*",
+									[5, "0.7"]
+								]
+							]]
+						]]
+					],
+					"*",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"n3",
+				[
+					1,
+					[
+						6,
+						"mxNoiseFloat2",
+						[[
+							6,
+							"d.vec2f",
+							[[
+								1,
+								[
+									1,
+									[
+										7,
+										"pos",
+										"x"
+									],
+									"*",
+									[5, "4"]
+								],
+								"+",
+								[
+									1,
+									"seed",
+									"*",
+									[5, "3.1"]
+								]
+							], [
+								1,
+								[
+									1,
+									[
+										7,
+										"pos",
+										"y"
+									],
+									"*",
+									[5, "4"]
+								],
+								"+",
+								[
+									1,
+									"animTime",
+									"*",
+									[5, "1.3"]
+								]
+							]]
+						]]
+					],
+					"*",
+					[5, "0.25"]
+				]
+			],
+			[10, [
+				1,
+				[
+					1,
+					"n1",
+					"+",
+					"n2"
+				],
+				"+",
+				"n3"
+			]]
+		]]
+	},
+	externals: {
+		"mxNoiseFloat2": () => mxNoiseFloat2,
+		"d.vec2f": () => vec2f
+	}
+}) && $.f)({}));
+const veinWave = typegpu_default.fn([
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((x, turb, turbulence) => {
+	"use gpu";
+	const marbleCoord = __tsover_add(__tsover_mul(x, PI), __tsover_mul(turb, turbulence));
+	return __tsover_add(__tsover_mul(sin(marbleCoord), .5), .5);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "x"
+			},
+			{
+				"type": "i",
+				"name": "turb"
+			},
+			{
+				"type": "i",
+				"name": "turbulence"
+			}
+		],
+		"body": [0, [[
+			13,
+			"marbleCoord",
+			[
+				1,
+				[
+					1,
+					"x",
+					"*",
+					"PI"
+				],
+				"+",
+				[
+					1,
+					"turb",
+					"*",
+					"turbulence"
+				]
+			]
+		], [10, [
+			1,
+			[
+				1,
+				[
+					6,
+					"std.sin",
+					["marbleCoord"]
+				],
+				"*",
+				[5, "0.5"]
+			],
+			"+",
+			[5, "0.5"]
+		]]]]
+	},
+	externals: {
+		"PI": () => PI,
+		"std.sin": () => sin
+	}
+}) && $.f)({}));
+const veinDepth = typegpu_default.fn([vec2f, f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((pos, seed) => {
+	"use gpu";
+	return __tsover_add(__tsover_mul(mxNoiseFloat2(vec2f(__tsover_add(__tsover_mul(pos.y, 1.5), __tsover_mul(seed, 2)), __tsover_mul(pos.x, 1.2))), .3), .5);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "pos"
+		}, {
+			"type": "i",
+			"name": "seed"
+		}],
+		"body": [0, [[10, [
+			1,
+			[
+				1,
+				[
+					6,
+					"mxNoiseFloat2",
+					[[
+						6,
+						"d.vec2f",
+						[[
+							1,
+							[
+								1,
+								[
+									7,
+									"pos",
+									"y"
+								],
+								"*",
+								[5, "1.5"]
+							],
+							"+",
+							[
+								1,
+								"seed",
+								"*",
+								[5, "2"]
+							]
+						], [
+							1,
+							[
+								7,
+								"pos",
+								"x"
+							],
+							"*",
+							[5, "1.2"]
+						]]
+					]]
+				],
+				"*",
+				[5, "0.3"]
+			],
+			"+",
+			[5, "0.5"]
+		]]]]
+	},
+	externals: {
+		"mxNoiseFloat2": () => mxNoiseFloat2,
+		"d.vec2f": () => vec2f
+	}
+}) && $.f)({}));
+const veinLadder = typegpu_default.fn([f32, f32], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((marbleT, depthVar) => {
+	"use gpu";
+	const t1 = smoothstep(.3, .6, marbleT);
+	const t2 = smoothstep(.6, .9, marbleT);
+	return vec2f(t1, __tsover_mul(t2, depthVar));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "marbleT"
+		}, {
+			"type": "i",
+			"name": "depthVar"
+		}],
+		"body": [0, [
+			[
+				13,
+				"t1",
+				[
+					6,
+					"std.smoothstep",
+					[
+						[5, "0.3"],
+						[5, "0.6"],
+						"marbleT"
+					]
+				]
+			],
+			[
+				13,
+				"t2",
+				[
+					6,
+					"std.smoothstep",
+					[
+						[5, "0.6"],
+						[5, "0.9"],
+						"marbleT"
+					]
+				]
+			],
+			[10, [
+				6,
+				"d.vec2f",
+				["t1", [
+					1,
+					"t2",
+					"*",
+					"depthVar"
+				]]
+			]]
+		]]
+	},
+	externals: {
+		"std.smoothstep": () => smoothstep,
+		"d.vec2f": () => vec2f
+	}
+}) && $.f)({}));
+const strandsTonePow = typegpu_default.fn([vec3f], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((rgb) => {
+	"use gpu";
+	return pow(rgb, vec3f(.85, .85, .85));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "rgb"
+		}],
+		"body": [0, [[10, [
+			6,
+			"std.pow",
+			["rgb", [
+				6,
+				"d.vec3f",
+				[
+					[5, "0.85"],
+					[5, "0.85"],
+					[5, "0.85"]
+				]
+			]]
+		]]]]
+	},
+	externals: {
+		"std.pow": () => pow,
+		"d.vec3f": () => vec3f
+	}
+}) && $.f)({}));
+var MAX = 8;
+if (8 !== MAX) throw new Error(`noisePaints: MAX (${MAX}) out of sync with MAX_COLOR_STOPS (8)`);
+const strandsField = typegpu_default.fn([
+	vec2f,
+	vec2f,
+	vec2f,
+	vec2f,
+	vec4f,
+	vec4f,
+	vec4f,
+	arrayOf(vec4f, MAX),
+	arrayOf(vec4f, MAX / 4),
+	arrayOf(vec3f, MAX)
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, start, end, packed1, packed2, packed3, colors, positions, converted) => {
+	"use gpu";
+	const amplitude = packed1.x;
+	const frequency = packed1.y;
+	const lineCount = packed1.z;
+	const lineWidth = packed1.w;
+	const softnessP = packed2.x;
+	const spread = packed2.y;
+	const colorScale = packed2.z;
+	const colorVariance = packed2.w;
+	const pinOn = packed3.x > 0;
+	const waveT = packed3.y;
+	const colorT = packed3.z;
+	const stopCount = packed3.w;
+	const aspectRatio = __tsover_div(viewport.x, max(viewport.y, 1e-6));
+	const startPos = vec2f(__tsover_mul(start.x, aspectRatio), __tsover_sub(1, start.y));
+	const endPos = vec2f(__tsover_mul(end.x, aspectRatio), __tsover_sub(1, end.y));
+	const aspectUV = vec2f(__tsover_mul(uv.x, aspectRatio), uv.y);
+	const direction = vec2f(__tsover_sub(endPos.x, startPos.x), __tsover_sub(endPos.y, startPos.y));
+	const len = max(length(direction), 1e-6);
+	const normalizedDir = vec2f(__tsover_div(direction.x, len), __tsover_div(direction.y, len));
+	const perpDir = vec2f(-normalizedDir.y, normalizedDir.x);
+	const relativePos = vec2f(__tsover_sub(aspectUV.x, startPos.x), __tsover_sub(aspectUV.y, startPos.y));
+	const progress = __tsover_div(dot(relativePos, normalizedDir), len);
+	const perpDist = dot(relativePos, perpDir);
+	const clampedProg = clamp(progress, 0, 1);
+	const pinch = select(f32(1), sin(__tsover_mul(clampedProg, PI)), pinOn);
+	const fade = __tsover_mul(smoothstep(0, .06, progress), __tsover_sub(1, smoothstep(.94, 1, progress)));
+	const edgeFade = select(f32(1), fade, pinOn);
+	const thickness = __tsover_mul(lineWidth, .07);
+	const softness = __tsover_add(__tsover_mul(softnessP, .08), 8e-4);
+	const denom = max(__tsover_sub(lineCount, 1), 1);
+	let accumColor = vec3f(0, 0, 0);
+	let accumWeight = f32(0);
+	const waveBase = __tsover_mul(__tsover_mul(progress, TAU), frequency);
+	const shimmerBase = __tsover_add(__tsover_mul(progress, 8), __tsover_mul(waveT, 2));
+	const colorBase = __tsover_add(__tsover_mul(progress, colorScale), colorT);
+	const n = i32(round(lineCount));
+	for (let idx = 0; idx < n; idx++) {
+		const fi = f32(idx);
+		const norm = __tsover_div(fi, denom);
+		const phase = __tsover_mul(fi, .9);
+		const strandT = __tsover_mul(waveT, __tsover_add(__tsover_mul(norm, .6), .7));
+		const wave = __tsover_add(sin(__tsover_add(__tsover_add(waveBase, strandT), phase)), __tsover_mul(sin(__tsover_add(__tsover_sub(__tsover_mul(waveBase, 2.1), __tsover_mul(strandT, .7)), phase)), .5));
+		const displacement = __tsover_mul(__tsover_mul(wave, amplitude), .06);
+		const baseline = __tsover_mul(__tsover_sub(norm, .5), spread);
+		const centre = __tsover_mul(__tsover_add(baseline, displacement), pinch);
+		const dd = abs(__tsover_sub(perpDist, centre));
+		const line = __tsover_sub(1, smoothstep(thickness, __tsover_add(thickness, softness), dd));
+		const shimmer = __tsover_add(__tsover_mul(sin(__tsover_add(shimmerBase, fi)), .15), .85);
+		const cc = __tsover_add(colorBase, __tsover_mul(norm, colorVariance));
+		const strandColor = gradientStopsInSpace(__tsover_sub(1, abs(__tsover_sub(__tsover_mul(fract(__tsover_mul(cc, .5)), 2), 1))), colors, positions, converted, stopCount).conv;
+		const weight = __tsover_mul(line, shimmer);
+		accumColor = accumColor.add(strandColor.mul(weight));
+		accumWeight = __tsover_add(accumWeight, weight);
+	}
+	return vec4f(accumColor.div(max(accumWeight, 1e-4)), clamp(__tsover_mul(accumWeight, edgeFade), 0, 1));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "uv"
+			},
+			{
+				"type": "i",
+				"name": "viewport"
+			},
+			{
+				"type": "i",
+				"name": "start"
+			},
+			{
+				"type": "i",
+				"name": "end"
+			},
+			{
+				"type": "i",
+				"name": "packed1"
+			},
+			{
+				"type": "i",
+				"name": "packed2"
+			},
+			{
+				"type": "i",
+				"name": "packed3"
+			},
+			{
+				"type": "i",
+				"name": "colors"
+			},
+			{
+				"type": "i",
+				"name": "positions"
+			},
+			{
+				"type": "i",
+				"name": "converted"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"amplitude",
+				[
+					7,
+					"packed1",
+					"x"
+				]
+			],
+			[
+				13,
+				"frequency",
+				[
+					7,
+					"packed1",
+					"y"
+				]
+			],
+			[
+				13,
+				"lineCount",
+				[
+					7,
+					"packed1",
+					"z"
+				]
+			],
+			[
+				13,
+				"lineWidth",
+				[
+					7,
+					"packed1",
+					"w"
+				]
+			],
+			[
+				13,
+				"softnessP",
+				[
+					7,
+					"packed2",
+					"x"
+				]
+			],
+			[
+				13,
+				"spread",
+				[
+					7,
+					"packed2",
+					"y"
+				]
+			],
+			[
+				13,
+				"colorScale",
+				[
+					7,
+					"packed2",
+					"z"
+				]
+			],
+			[
+				13,
+				"colorVariance",
+				[
+					7,
+					"packed2",
+					"w"
+				]
+			],
+			[
+				13,
+				"pinOn",
+				[
+					1,
+					[
+						7,
+						"packed3",
+						"x"
+					],
+					">",
+					[5, "0"]
+				]
+			],
+			[
+				13,
+				"waveT",
+				[
+					7,
+					"packed3",
+					"y"
+				]
+			],
+			[
+				13,
+				"colorT",
+				[
+					7,
+					"packed3",
+					"z"
+				]
+			],
+			[
+				13,
+				"stopCount",
+				[
+					7,
+					"packed3",
+					"w"
+				]
+			],
+			[
+				13,
+				"aspectRatio",
+				[
+					1,
+					[
+						7,
+						"viewport",
+						"x"
+					],
+					"/",
+					[
+						6,
+						"std.max",
+						[[
+							7,
+							"viewport",
+							"y"
+						], [5, "0.000001"]]
+					]
+				]
+			],
+			[
+				13,
+				"startPos",
+				[
+					6,
+					"d.vec2f",
+					[[
+						1,
+						[
+							7,
+							"start",
+							"x"
+						],
+						"*",
+						"aspectRatio"
+					], [
+						1,
+						[5, "1"],
+						"-",
+						[
+							7,
+							"start",
+							"y"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"endPos",
+				[
+					6,
+					"d.vec2f",
+					[[
+						1,
+						[
+							7,
+							"end",
+							"x"
+						],
+						"*",
+						"aspectRatio"
+					], [
+						1,
+						[5, "1"],
+						"-",
+						[
+							7,
+							"end",
+							"y"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"aspectUV",
+				[
+					6,
+					"d.vec2f",
+					[[
+						1,
+						[
+							7,
+							"uv",
+							"x"
+						],
+						"*",
+						"aspectRatio"
+					], [
+						7,
+						"uv",
+						"y"
+					]]
+				]
+			],
+			[
+				13,
+				"direction",
+				[
+					6,
+					"d.vec2f",
+					[[
+						1,
+						[
+							7,
+							"endPos",
+							"x"
+						],
+						"-",
+						[
+							7,
+							"startPos",
+							"x"
+						]
+					], [
+						1,
+						[
+							7,
+							"endPos",
+							"y"
+						],
+						"-",
+						[
+							7,
+							"startPos",
+							"y"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"len",
+				[
+					6,
+					"std.max",
+					[[
+						6,
+						"std.length",
+						["direction"]
+					], [5, "0.000001"]]
+				]
+			],
+			[
+				13,
+				"normalizedDir",
+				[
+					6,
+					"d.vec2f",
+					[[
+						1,
+						[
+							7,
+							"direction",
+							"x"
+						],
+						"/",
+						"len"
+					], [
+						1,
+						[
+							7,
+							"direction",
+							"y"
+						],
+						"/",
+						"len"
+					]]
+				]
+			],
+			[
+				13,
+				"perpDir",
+				[
+					6,
+					"d.vec2f",
+					[[
+						4,
+						"-",
+						[
+							7,
+							"normalizedDir",
+							"y"
+						]
+					], [
+						7,
+						"normalizedDir",
+						"x"
+					]]
+				]
+			],
+			[
+				13,
+				"relativePos",
+				[
+					6,
+					"d.vec2f",
+					[[
+						1,
+						[
+							7,
+							"aspectUV",
+							"x"
+						],
+						"-",
+						[
+							7,
+							"startPos",
+							"x"
+						]
+					], [
+						1,
+						[
+							7,
+							"aspectUV",
+							"y"
+						],
+						"-",
+						[
+							7,
+							"startPos",
+							"y"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"progress",
+				[
+					1,
+					[
+						6,
+						"std.dot",
+						["relativePos", "normalizedDir"]
+					],
+					"/",
+					"len"
+				]
+			],
+			[
+				13,
+				"perpDist",
+				[
+					6,
+					"std.dot",
+					["relativePos", "perpDir"]
+				]
+			],
+			[
+				13,
+				"clampedProg",
+				[
+					6,
+					"std.clamp",
+					[
+						"progress",
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"pinch",
+				[
+					6,
+					"std.select",
+					[
+						[
+							6,
+							"d.f32",
+							[[5, "1"]]
+						],
+						[
+							6,
+							"std.sin",
+							[[
+								1,
+								"clampedProg",
+								"*",
+								"PI"
+							]]
+						],
+						"pinOn"
+					]
+				]
+			],
+			[
+				13,
+				"fade",
+				[
+					1,
+					[
+						6,
+						"std.smoothstep",
+						[
+							[5, "0"],
+							[5, "0.06"],
+							"progress"
+						]
+					],
+					"*",
+					[
+						1,
+						[5, "1"],
+						"-",
+						[
+							6,
+							"std.smoothstep",
+							[
+								[5, "0.94"],
+								[5, "1"],
+								"progress"
+							]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"edgeFade",
+				[
+					6,
+					"std.select",
+					[
+						[
+							6,
+							"d.f32",
+							[[5, "1"]]
+						],
+						"fade",
+						"pinOn"
+					]
+				]
+			],
+			[
+				13,
+				"thickness",
+				[
+					1,
+					"lineWidth",
+					"*",
+					[5, "0.07"]
+				]
+			],
+			[
+				13,
+				"softness",
+				[
+					1,
+					[
+						1,
+						"softnessP",
+						"*",
+						[5, "0.08"]
+					],
+					"+",
+					[5, "0.0008"]
+				]
+			],
+			[
+				13,
+				"denom",
+				[
+					6,
+					"std.max",
+					[[
+						1,
+						"lineCount",
+						"-",
+						[5, "1"]
+					], [5, "1"]]
+				]
+			],
+			[
+				12,
+				"accumColor",
+				[
+					6,
+					"d.vec3f",
+					[
+						[5, "0"],
+						[5, "0"],
+						[5, "0"]
+					]
+				]
+			],
+			[
+				12,
+				"accumWeight",
+				[
+					6,
+					"d.f32",
+					[[5, "0"]]
+				]
+			],
+			[
+				13,
+				"waveBase",
+				[
+					1,
+					[
+						1,
+						"progress",
+						"*",
+						"TAU"
+					],
+					"*",
+					"frequency"
+				]
+			],
+			[
+				13,
+				"shimmerBase",
+				[
+					1,
+					[
+						1,
+						"progress",
+						"*",
+						[5, "8"]
+					],
+					"+",
+					[
+						1,
+						"waveT",
+						"*",
+						[5, "2"]
+					]
+				]
+			],
+			[
+				13,
+				"colorBase",
+				[
+					1,
+					[
+						1,
+						"progress",
+						"*",
+						"colorScale"
+					],
+					"+",
+					"colorT"
+				]
+			],
+			[
+				13,
+				"n",
+				[
+					6,
+					"d.i32",
+					[[
+						6,
+						"std.round",
+						["lineCount"]
+					]]
+				]
+			],
+			[
+				14,
+				[
+					12,
+					"idx",
+					[5, "0"]
+				],
+				[
+					1,
+					"idx",
+					"<",
+					"n"
+				],
+				[
+					102,
+					"++",
+					"idx"
+				],
+				[0, [
+					[
+						13,
+						"fi",
+						[
+							6,
+							"d.f32",
+							["idx"]
+						]
+					],
+					[
+						13,
+						"norm",
+						[
+							1,
+							"fi",
+							"/",
+							"denom"
+						]
+					],
+					[
+						13,
+						"phase",
+						[
+							1,
+							"fi",
+							"*",
+							[5, "0.9"]
+						]
+					],
+					[
+						13,
+						"strandT",
+						[
+							1,
+							"waveT",
+							"*",
+							[
+								1,
+								[
+									1,
+									"norm",
+									"*",
+									[5, "0.6"]
+								],
+								"+",
+								[5, "0.7"]
+							]
+						]
+					],
+					[
+						13,
+						"wave",
+						[
+							1,
+							[
+								6,
+								"std.sin",
+								[[
+									1,
+									[
+										1,
+										"waveBase",
+										"+",
+										"strandT"
+									],
+									"+",
+									"phase"
+								]]
+							],
+							"+",
+							[
+								1,
+								[
+									6,
+									"std.sin",
+									[[
+										1,
+										[
+											1,
+											[
+												1,
+												"waveBase",
+												"*",
+												[5, "2.1"]
+											],
+											"-",
+											[
+												1,
+												"strandT",
+												"*",
+												[5, "0.7"]
+											]
+										],
+										"+",
+										"phase"
+									]]
+								],
+								"*",
+								[5, "0.5"]
+							]
+						]
+					],
+					[
+						13,
+						"displacement",
+						[
+							1,
+							[
+								1,
+								"wave",
+								"*",
+								"amplitude"
+							],
+							"*",
+							[5, "0.06"]
+						]
+					],
+					[
+						13,
+						"baseline",
+						[
+							1,
+							[
+								1,
+								"norm",
+								"-",
+								[5, "0.5"]
+							],
+							"*",
+							"spread"
+						]
+					],
+					[
+						13,
+						"centre",
+						[
+							1,
+							[
+								1,
+								"baseline",
+								"+",
+								"displacement"
+							],
+							"*",
+							"pinch"
+						]
+					],
+					[
+						13,
+						"dd",
+						[
+							6,
+							"std.abs",
+							[[
+								1,
+								"perpDist",
+								"-",
+								"centre"
+							]]
+						]
+					],
+					[
+						13,
+						"line",
+						[
+							1,
+							[5, "1"],
+							"-",
+							[
+								6,
+								"std.smoothstep",
+								[
+									"thickness",
+									[
+										1,
+										"thickness",
+										"+",
+										"softness"
+									],
+									"dd"
+								]
+							]
+						]
+					],
+					[
+						13,
+						"shimmer",
+						[
+							1,
+							[
+								1,
+								[
+									6,
+									"std.sin",
+									[[
+										1,
+										"shimmerBase",
+										"+",
+										"fi"
+									]]
+								],
+								"*",
+								[5, "0.15"]
+							],
+							"+",
+							[5, "0.85"]
+						]
+					],
+					[
+						13,
+						"cc",
+						[
+							1,
+							"colorBase",
+							"+",
+							[
+								1,
+								"norm",
+								"*",
+								"colorVariance"
+							]
+						]
+					],
+					[
+						13,
+						"colorCoord",
+						[
+							1,
+							[5, "1"],
+							"-",
+							[
+								6,
+								"std.abs",
+								[[
+									1,
+									[
+										1,
+										[
+											6,
+											"std.fract",
+											[[
+												1,
+												"cc",
+												"*",
+												[5, "0.5"]
+											]]
+										],
+										"*",
+										[5, "2"]
+									],
+									"-",
+									[5, "1"]
+								]]
+							]
+						]
+					],
+					[
+						13,
+						"stepRes",
+						[
+							6,
+							"gradientStopsInSpace",
+							[
+								"colorCoord",
+								"colors",
+								"positions",
+								"converted",
+								"stopCount"
+							]
+						]
+					],
+					[
+						13,
+						"strandColor",
+						[
+							7,
+							"stepRes",
+							"conv"
+						]
+					],
+					[
+						13,
+						"weight",
+						[
+							1,
+							"line",
+							"*",
+							"shimmer"
+						]
+					],
+					[
+						2,
+						"accumColor",
+						"=",
+						[
+							6,
+							[
+								7,
+								"accumColor",
+								"add"
+							],
+							[[
+								6,
+								[
+									7,
+									"strandColor",
+									"mul"
+								],
+								["weight"]
+							]]
+						]
+					],
+					[
+						2,
+						"accumWeight",
+						"=",
+						[
+							1,
+							"accumWeight",
+							"+",
+							"weight"
+						]
+					]
+				]]
+			],
+			[
+				13,
+				"workingColor",
+				[
+					6,
+					[
+						7,
+						"accumColor",
+						"div"
+					],
+					[[
+						6,
+						"std.max",
+						["accumWeight", [5, "0.0001"]]
+					]]
+				]
+			],
+			[
+				13,
+				"alpha",
+				[
+					6,
+					"std.clamp",
+					[
+						[
+							1,
+							"accumWeight",
+							"*",
+							"edgeFade"
+						],
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[10, [
+				6,
+				"d.vec4f",
+				["workingColor", "alpha"]
+			]]
+		]]
+	},
+	externals: {
+		"std.max": () => max,
+		"d.vec2f": () => vec2f,
+		"std.length": () => length,
+		"std.dot": () => dot,
+		"std.clamp": () => clamp,
+		"std.select": () => select,
+		"d.f32": () => f32,
+		"std.sin": () => sin,
+		"PI": () => PI,
+		"std.smoothstep": () => smoothstep,
+		"d.vec3f": () => vec3f,
+		"TAU": () => TAU,
+		"d.i32": () => i32,
+		"std.round": () => round,
+		"std.abs": () => abs,
+		"std.fract": () => fract,
+		"gradientStopsInSpace": () => gradientStopsInSpace,
+		"d.vec4f": () => vec4f
+	}
+}) && $.f)({}));
+const paperSurface = typegpu_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, grainScale, seed, displacement, roughness) => {
+	"use gpu";
+	const aspectUV = vec2f(__tsover_mul(uv.x, aspect), uv.y);
+	const grainFreq = __tsover_mul(grainScale, 6);
+	const grainUV = aspectUV.mul(grainFreq).add(seed);
+	const disp = curl22(grainUV).mul(displacement).mul(.0025);
+	const displacedUV = uv.add(disp);
+	const grain = paper12(grainUV, i32(6));
+	const brightness = clamp(__tsover_add(1, __tsover_mul(__tsover_sub(grain, .7), __tsover_mul(roughness, 1.2))), 0, 1.5);
+	return vec3f(displacedUV.x, displacedUV.y, brightness);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "uv"
+			},
+			{
+				"type": "i",
+				"name": "aspect"
+			},
+			{
+				"type": "i",
+				"name": "grainScale"
+			},
+			{
+				"type": "i",
+				"name": "seed"
+			},
+			{
+				"type": "i",
+				"name": "displacement"
+			},
+			{
+				"type": "i",
+				"name": "roughness"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"aspectUV",
+				[
+					6,
+					"d.vec2f",
+					[[
+						1,
+						[
+							7,
+							"uv",
+							"x"
+						],
+						"*",
+						"aspect"
+					], [
+						7,
+						"uv",
+						"y"
+					]]
+				]
+			],
+			[
+				13,
+				"grainFreq",
+				[
+					1,
+					"grainScale",
+					"*",
+					[5, "6"]
+				]
+			],
+			[
+				13,
+				"grainUV",
+				[
+					6,
+					[
+						7,
+						[
+							6,
+							[
+								7,
+								"aspectUV",
+								"mul"
+							],
+							["grainFreq"]
+						],
+						"add"
+					],
+					["seed"]
+				]
+			],
+			[
+				13,
+				"disp",
+				[
+					6,
+					[
+						7,
+						[
+							6,
+							[
+								7,
+								[
+									6,
+									"curl22",
+									["grainUV"]
+								],
+								"mul"
+							],
+							["displacement"]
+						],
+						"mul"
+					],
+					[[5, "0.0025"]]
+				]
+			],
+			[
+				13,
+				"displacedUV",
+				[
+					6,
+					[
+						7,
+						"uv",
+						"add"
+					],
+					["disp"]
+				]
+			],
+			[
+				13,
+				"grain",
+				[
+					6,
+					"paper12",
+					["grainUV", [
+						6,
+						"d.i32",
+						[[5, "6"]]
+					]]
+				]
+			],
+			[
+				13,
+				"brightness",
+				[
+					6,
+					"std.clamp",
+					[
+						[
+							1,
+							[5, "1"],
+							"+",
+							[
+								1,
+								[
+									1,
+									"grain",
+									"-",
+									[5, "0.7"]
+								],
+								"*",
+								[
+									1,
+									"roughness",
+									"*",
+									[5, "1.2"]
+								]
+							]
+						],
+						[5, "0"],
+						[5, "1.5"]
+					]
+				]
+			],
+			[10, [
+				6,
+				"d.vec3f",
+				[
+					[
+						7,
+						"displacedUV",
+						"x"
+					],
+					[
+						7,
+						"displacedUV",
+						"y"
+					],
+					"brightness"
+				]
+			]]
+		]]
+	},
+	externals: {
+		"d.vec2f": () => vec2f,
+		"curl22": () => curl22,
+		"paper12": () => paper12,
+		"d.i32": () => i32,
+		"std.clamp": () => clamp,
+		"d.vec3f": () => vec3f
+	}
+}) && $.f)({}));
+export { worleyModeScale as C, worleyModeNum as S, worleyTone as T, veinWave as _, fbmNormalize as a, worleyDistNum as b, paperSurface as c, strandsField as d, strandsTonePow as f, veinLadder as g, veinDepth as h, curlMagnitude as i, rawAspectScaledDomain as l, transformWorleyMode as m, cellBorders as n, fractalSum as o, transformWorleyDistance as p, cellFill as r, marbleTurbulence as s, aspectPlane as t, rotatedCenteredDomain as u, voronoiCells as v, worleyNormalize as w, worleyHash as x, worleyCells as y };