shaders 3.2.475 → 4.0.0

package/dist/core/noisePaints-B_axPpuv.js

@@ -1,3619 +0,0 @@
-import { Cr as sin, Gn as typegpu_default, Jr as i32, Ln as PI, Mr as vec4f, Or as vec2f, Pn as DEG_TO_RAD, Sn as mxNoiseFloat2, Tn as paper12, Tr as sqrt, Yt as fbmGated, _r as mix, ar as clamp, cr as dot, er as select, fr as floor, gr as min, hr as max, in as aspectOf, jr as vec3f, lr as exp, mn as curl22z, mr as length, or as cos, pn as curl22, pr as fract, qr as f32, tr as abs, wr as smoothstep, xr as round, yr as pow, zn as TAU, zr as arrayOf } from "./lower-DtoDQ7hV.js";
-import { a as toneRemap } from "./tone-CsRho9qb.js";
-import { Et as gradientStopsInSpace, wt as MAX_COLOR_STOPS } from "./porters-CQwDd2t4.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 toneLift = 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 ribbonPathFrame = typegpu_default.fn([
-	vec2f,
-	vec2f,
-	vec2f,
-	vec2f,
-	f32
-], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, start, end, pinFlag) => {
-	"use gpu";
-	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 pinOn = pinFlag > 0;
-	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)));
-	return vec4f(progress, perpDist, pinch, select(f32(1), fade, pinOn));
-}), {
-	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": "pinFlag"
-			}
-		],
-		"body": [0, [
-			[
-				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,
-				"pinOn",
-				[
-					1,
-					"pinFlag",
-					">",
-					[5, "0"]
-				]
-			],
-			[
-				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"
-					]
-				]
-			],
-			[10, [
-				6,
-				"d.vec4f",
-				[
-					"progress",
-					"perpDist",
-					"pinch",
-					"edgeFade"
-				]
-			]]
-		]]
-	},
-	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.vec4f": () => vec4f
-	}
-}) && $.f)({}));
-const ribbonsField = 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 waveT = packed3.y;
-	const colorT = packed3.z;
-	const stopCount = packed3.w;
-	const frame = ribbonPathFrame(uv, viewport, start, end, packed3.x);
-	const progress = frame.x;
-	const perpDist = frame.y;
-	const pinch = frame.z;
-	const edgeFade = frame.w;
-	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,
-				"waveT",
-				[
-					7,
-					"packed3",
-					"y"
-				]
-			],
-			[
-				13,
-				"colorT",
-				[
-					7,
-					"packed3",
-					"z"
-				]
-			],
-			[
-				13,
-				"stopCount",
-				[
-					7,
-					"packed3",
-					"w"
-				]
-			],
-			[
-				13,
-				"frame",
-				[
-					6,
-					"ribbonPathFrame",
-					[
-						"uv",
-						"viewport",
-						"start",
-						"end",
-						[
-							7,
-							"packed3",
-							"x"
-						]
-					]
-				]
-			],
-			[
-				13,
-				"progress",
-				[
-					7,
-					"frame",
-					"x"
-				]
-			],
-			[
-				13,
-				"perpDist",
-				[
-					7,
-					"frame",
-					"y"
-				]
-			],
-			[
-				13,
-				"pinch",
-				[
-					7,
-					"frame",
-					"z"
-				]
-			],
-			[
-				13,
-				"edgeFade",
-				[
-					7,
-					"frame",
-					"w"
-				]
-			],
-			[
-				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: {
-		"ribbonPathFrame": () => ribbonPathFrame,
-		"std.max": () => max,
-		"d.vec3f": () => vec3f,
-		"d.f32": () => f32,
-		"TAU": () => TAU,
-		"d.i32": () => i32,
-		"std.round": () => round,
-		"std.sin": () => sin,
-		"std.abs": () => abs,
-		"std.smoothstep": () => smoothstep,
-		"std.fract": () => fract,
-		"gradientStopsInSpace": () => gradientStopsInSpace,
-		"std.clamp": () => clamp,
-		"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 { worleyHash as _, fbmNormalize as a, worleyNormalize as b, rawAspectScaledDomain as c, toneLift as d, transformWorleyDistance as f, worleyDistNum as g, worleyCells as h, curlMagnitude as i, ribbonsField as l, voronoiCells as m, cellBorders as n, fractalSum as o, transformWorleyMode as p, cellFill as r, paperSurface as s, aspectPlane as t, rotatedCenteredDomain as u, worleyModeNum as v, worleyTone as x, worleyModeScale as y };