shaders 3.2.475 → 4.0.0

package/dist/core/stylize-CiN0ZaMu.js

@@ -1,4541 +0,0 @@
-import { An as value12, Br as struct, Cr as sin, Er as step, Gn as typegpu_default, Mr as vec4f, Or as vec2f, Ot as unpremultiplyAlpha, Pn as DEG_TO_RAD, Sn as mxNoiseFloat2, Tr as sqrt, _r as mix, ar as clamp, at as ZERO, cr as dot, ct as call, dt as expr, er as select, fr as floor, ft as floatE, gr as min, hr as max, jr as vec3f, mr as length, mt as vec4, o as uniformOf, or as cos, pr as fract, qr as f32, rr as atan2, st as asLocal, tr as abs, vn as hash12, wr as smoothstep, yr as pow, zn as TAU } from "./lower-DtoDQ7hV.js";
-import { n as gather } from "./filter-BrhpSs3Z.js";
-const watercolorUvBase = typegpu_default.fn([
-	vec2f,
-	vec2f,
-	f32,
-	f32
-], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, bleed, time) => {
-	"use gpu";
-	const t = __tsover_mul(time, .03);
-	const wob = vec2f(value12(uv.mul(5).add(vec2f(t, t))), value12(uv.mul(5).add(vec2f(31.4, 31.4)).add(vec2f(t, t)))).sub(vec2f(.5, .5));
-	const texel = vec2f(__tsover_div(1, viewport.x), __tsover_div(1, viewport.y));
-	return uv.add(wob.mul(bleed).mul(texel).mul(8));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "uv"
-			},
-			{
-				"type": "i",
-				"name": "viewport"
-			},
-			{
-				"type": "i",
-				"name": "bleed"
-			},
-			{
-				"type": "i",
-				"name": "time"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"t",
-				[
-					1,
-					"time",
-					"*",
-					[5, "0.03"]
-				]
-			],
-			[
-				13,
-				"wob",
-				[
-					6,
-					[
-						7,
-						[
-							6,
-							"d.vec2f",
-							[[
-								6,
-								"noise.value12",
-								[[
-									6,
-									[
-										7,
-										[
-											6,
-											[
-												7,
-												"uv",
-												"mul"
-											],
-											[[5, "5"]]
-										],
-										"add"
-									],
-									[[
-										6,
-										"d.vec2f",
-										["t", "t"]
-									]]
-								]]
-							], [
-								6,
-								"noise.value12",
-								[[
-									6,
-									[
-										7,
-										[
-											6,
-											[
-												7,
-												[
-													6,
-													[
-														7,
-														"uv",
-														"mul"
-													],
-													[[5, "5"]]
-												],
-												"add"
-											],
-											[[
-												6,
-												"d.vec2f",
-												[[5, "31.4"], [5, "31.4"]]
-											]]
-										],
-										"add"
-									],
-									[[
-										6,
-										"d.vec2f",
-										["t", "t"]
-									]]
-								]]
-							]]
-						],
-						"sub"
-					],
-					[[
-						6,
-						"d.vec2f",
-						[[5, "0.5"], [5, "0.5"]]
-					]]
-				]
-			],
-			[
-				13,
-				"texel",
-				[
-					6,
-					"d.vec2f",
-					[[
-						1,
-						[5, "1"],
-						"/",
-						[
-							7,
-							"viewport",
-							"x"
-						]
-					], [
-						1,
-						[5, "1"],
-						"/",
-						[
-							7,
-							"viewport",
-							"y"
-						]
-					]]
-				]
-			],
-			[10, [
-				6,
-				[
-					7,
-					"uv",
-					"add"
-				],
-				[[
-					6,
-					[
-						7,
-						[
-							6,
-							[
-								7,
-								[
-									6,
-									[
-										7,
-										"wob",
-										"mul"
-									],
-									["bleed"]
-								],
-								"mul"
-							],
-							["texel"]
-						],
-						"mul"
-					],
-					[[5, "8"]]
-				]]
-			]]
-		]]
-	},
-	externals: {
-		"d.vec2f": () => vec2f,
-		"noise.value12": () => value12
-	}
-}) && $.f)({}));
-const watercolorTapUV = typegpu_default.fn([
-	vec2f,
-	vec2f,
-	f32,
-	f32
-], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uvBase, viewport, ox, oy) => {
-	"use gpu";
-	return vec2f(__tsover_add(uvBase.x, __tsover_div(ox, viewport.x)), __tsover_add(uvBase.y, __tsover_div(oy, viewport.y)));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "uvBase"
-			},
-			{
-				"type": "i",
-				"name": "viewport"
-			},
-			{
-				"type": "i",
-				"name": "ox"
-			},
-			{
-				"type": "i",
-				"name": "oy"
-			}
-		],
-		"body": [0, [[10, [
-			6,
-			"d.vec2f",
-			[[
-				1,
-				[
-					7,
-					"uvBase",
-					"x"
-				],
-				"+",
-				[
-					1,
-					"ox",
-					"/",
-					[
-						7,
-						"viewport",
-						"x"
-					]
-				]
-			], [
-				1,
-				[
-					7,
-					"uvBase",
-					"y"
-				],
-				"+",
-				[
-					1,
-					"oy",
-					"/",
-					[
-						7,
-						"viewport",
-						"y"
-					]
-				]
-			]]
-		]]]]
-	},
-	externals: { "d.vec2f": () => vec2f }
-}) && $.f)({}));
-const watercolorGrain = typegpu_default.fn([vec2f, vec2f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport) => {
-	"use gpu";
-	return value12(uv.mul(viewport).mul(.5));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "uv"
-		}, {
-			"type": "i",
-			"name": "viewport"
-		}],
-		"body": [0, [[10, [
-			6,
-			"noise.value12",
-			[[
-				6,
-				[
-					7,
-					[
-						6,
-						[
-							7,
-							"uv",
-							"mul"
-						],
-						["viewport"]
-					],
-					"mul"
-				],
-				[[5, "0.5"]]
-			]]
-		]]]]
-	},
-	externals: { "noise.value12": () => value12 }
-}) && $.f)({}));
-const watercolorCompose = typegpu_default.fn([
-	vec4f,
-	vec4f,
-	vec4f,
-	vec4f,
-	vec3f,
-	vec3f,
-	vec3f,
-	vec3f,
-	f32,
-	vec4f,
-	vec4f,
-	f32,
-	f32,
-	f32
-], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sum0, sum1, sum2, sum3, sq0, sq1, sq2, sq3, invN, originalBleed, paperColor, paper, strength, grain) => {
-	"use gpu";
-	const mean0 = sum0.mul(invN);
-	const mean1 = sum1.mul(invN);
-	const mean2 = sum2.mul(invN);
-	const mean3 = sum3.mul(invN);
-	const rgb0 = vec3f(mean0.x, mean0.y, mean0.z);
-	const rgb1 = vec3f(mean1.x, mean1.y, mean1.z);
-	const rgb2 = vec3f(mean2.x, mean2.y, mean2.z);
-	const rgb3 = vec3f(mean3.x, mean3.y, mean3.z);
-	const var0 = sq0.mul(invN).sub(rgb0.mul(rgb0));
-	const var1 = sq1.mul(invN).sub(rgb1.mul(rgb1));
-	const var2 = sq2.mul(invN).sub(rgb2.mul(rgb2));
-	const var3 = sq3.mul(invN).sub(rgb3.mul(rgb3));
-	const sigma0 = __tsover_add(__tsover_add(var0.x, var0.y), var0.z);
-	const sigma1 = __tsover_add(__tsover_add(var1.x, var1.y), var1.z);
-	const sigma2 = __tsover_add(__tsover_add(var2.x, var2.y), var2.z);
-	const sigma3 = __tsover_add(__tsover_add(var3.x, var3.y), var3.z);
-	let picked = vec4f(mean0.x, mean0.y, mean0.z, mean0.w);
-	let best = sigma0;
-	picked = select(picked, mean1, sigma1 < best);
-	best = min(best, sigma1);
-	picked = select(picked, mean2, sigma2 < best);
-	best = min(best, sigma2);
-	picked = select(picked, mean3, sigma3 < best);
-	best = min(best, sigma3);
-	const straight = unpremultiplyAlpha(picked);
-	let result = vec3f(straight.x, straight.y, straight.z);
-	const paperMul = mix(1, grain, paper);
-	const paperTint = vec3f(paperColor.x, paperColor.y, paperColor.z);
-	result = mix(result.mul(paperMul), result.mul(paperTint), vec3f(__tsover_mul(paper, .4)));
-	return mix(vec3f(originalBleed.x, originalBleed.y, originalBleed.z), result, vec3f(strength));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "sum0"
-			},
-			{
-				"type": "i",
-				"name": "sum1"
-			},
-			{
-				"type": "i",
-				"name": "sum2"
-			},
-			{
-				"type": "i",
-				"name": "sum3"
-			},
-			{
-				"type": "i",
-				"name": "sq0"
-			},
-			{
-				"type": "i",
-				"name": "sq1"
-			},
-			{
-				"type": "i",
-				"name": "sq2"
-			},
-			{
-				"type": "i",
-				"name": "sq3"
-			},
-			{
-				"type": "i",
-				"name": "invN"
-			},
-			{
-				"type": "i",
-				"name": "originalBleed"
-			},
-			{
-				"type": "i",
-				"name": "paperColor"
-			},
-			{
-				"type": "i",
-				"name": "paper"
-			},
-			{
-				"type": "i",
-				"name": "strength"
-			},
-			{
-				"type": "i",
-				"name": "grain"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"mean0",
-				[
-					6,
-					[
-						7,
-						"sum0",
-						"mul"
-					],
-					["invN"]
-				]
-			],
-			[
-				13,
-				"mean1",
-				[
-					6,
-					[
-						7,
-						"sum1",
-						"mul"
-					],
-					["invN"]
-				]
-			],
-			[
-				13,
-				"mean2",
-				[
-					6,
-					[
-						7,
-						"sum2",
-						"mul"
-					],
-					["invN"]
-				]
-			],
-			[
-				13,
-				"mean3",
-				[
-					6,
-					[
-						7,
-						"sum3",
-						"mul"
-					],
-					["invN"]
-				]
-			],
-			[
-				13,
-				"rgb0",
-				[
-					6,
-					"d.vec3f",
-					[
-						[
-							7,
-							"mean0",
-							"x"
-						],
-						[
-							7,
-							"mean0",
-							"y"
-						],
-						[
-							7,
-							"mean0",
-							"z"
-						]
-					]
-				]
-			],
-			[
-				13,
-				"rgb1",
-				[
-					6,
-					"d.vec3f",
-					[
-						[
-							7,
-							"mean1",
-							"x"
-						],
-						[
-							7,
-							"mean1",
-							"y"
-						],
-						[
-							7,
-							"mean1",
-							"z"
-						]
-					]
-				]
-			],
-			[
-				13,
-				"rgb2",
-				[
-					6,
-					"d.vec3f",
-					[
-						[
-							7,
-							"mean2",
-							"x"
-						],
-						[
-							7,
-							"mean2",
-							"y"
-						],
-						[
-							7,
-							"mean2",
-							"z"
-						]
-					]
-				]
-			],
-			[
-				13,
-				"rgb3",
-				[
-					6,
-					"d.vec3f",
-					[
-						[
-							7,
-							"mean3",
-							"x"
-						],
-						[
-							7,
-							"mean3",
-							"y"
-						],
-						[
-							7,
-							"mean3",
-							"z"
-						]
-					]
-				]
-			],
-			[
-				13,
-				"var0",
-				[
-					6,
-					[
-						7,
-						[
-							6,
-							[
-								7,
-								"sq0",
-								"mul"
-							],
-							["invN"]
-						],
-						"sub"
-					],
-					[[
-						6,
-						[
-							7,
-							"rgb0",
-							"mul"
-						],
-						["rgb0"]
-					]]
-				]
-			],
-			[
-				13,
-				"var1",
-				[
-					6,
-					[
-						7,
-						[
-							6,
-							[
-								7,
-								"sq1",
-								"mul"
-							],
-							["invN"]
-						],
-						"sub"
-					],
-					[[
-						6,
-						[
-							7,
-							"rgb1",
-							"mul"
-						],
-						["rgb1"]
-					]]
-				]
-			],
-			[
-				13,
-				"var2",
-				[
-					6,
-					[
-						7,
-						[
-							6,
-							[
-								7,
-								"sq2",
-								"mul"
-							],
-							["invN"]
-						],
-						"sub"
-					],
-					[[
-						6,
-						[
-							7,
-							"rgb2",
-							"mul"
-						],
-						["rgb2"]
-					]]
-				]
-			],
-			[
-				13,
-				"var3",
-				[
-					6,
-					[
-						7,
-						[
-							6,
-							[
-								7,
-								"sq3",
-								"mul"
-							],
-							["invN"]
-						],
-						"sub"
-					],
-					[[
-						6,
-						[
-							7,
-							"rgb3",
-							"mul"
-						],
-						["rgb3"]
-					]]
-				]
-			],
-			[
-				13,
-				"sigma0",
-				[
-					1,
-					[
-						1,
-						[
-							7,
-							"var0",
-							"x"
-						],
-						"+",
-						[
-							7,
-							"var0",
-							"y"
-						]
-					],
-					"+",
-					[
-						7,
-						"var0",
-						"z"
-					]
-				]
-			],
-			[
-				13,
-				"sigma1",
-				[
-					1,
-					[
-						1,
-						[
-							7,
-							"var1",
-							"x"
-						],
-						"+",
-						[
-							7,
-							"var1",
-							"y"
-						]
-					],
-					"+",
-					[
-						7,
-						"var1",
-						"z"
-					]
-				]
-			],
-			[
-				13,
-				"sigma2",
-				[
-					1,
-					[
-						1,
-						[
-							7,
-							"var2",
-							"x"
-						],
-						"+",
-						[
-							7,
-							"var2",
-							"y"
-						]
-					],
-					"+",
-					[
-						7,
-						"var2",
-						"z"
-					]
-				]
-			],
-			[
-				13,
-				"sigma3",
-				[
-					1,
-					[
-						1,
-						[
-							7,
-							"var3",
-							"x"
-						],
-						"+",
-						[
-							7,
-							"var3",
-							"y"
-						]
-					],
-					"+",
-					[
-						7,
-						"var3",
-						"z"
-					]
-				]
-			],
-			[
-				12,
-				"picked",
-				[
-					6,
-					"d.vec4f",
-					[
-						[
-							7,
-							"mean0",
-							"x"
-						],
-						[
-							7,
-							"mean0",
-							"y"
-						],
-						[
-							7,
-							"mean0",
-							"z"
-						],
-						[
-							7,
-							"mean0",
-							"w"
-						]
-					]
-				]
-			],
-			[
-				12,
-				"best",
-				"sigma0"
-			],
-			[
-				2,
-				"picked",
-				"=",
-				[
-					6,
-					"std.select",
-					[
-						"picked",
-						"mean1",
-						[
-							1,
-							"sigma1",
-							"<",
-							"best"
-						]
-					]
-				]
-			],
-			[
-				2,
-				"best",
-				"=",
-				[
-					6,
-					"std.min",
-					["best", "sigma1"]
-				]
-			],
-			[
-				2,
-				"picked",
-				"=",
-				[
-					6,
-					"std.select",
-					[
-						"picked",
-						"mean2",
-						[
-							1,
-							"sigma2",
-							"<",
-							"best"
-						]
-					]
-				]
-			],
-			[
-				2,
-				"best",
-				"=",
-				[
-					6,
-					"std.min",
-					["best", "sigma2"]
-				]
-			],
-			[
-				2,
-				"picked",
-				"=",
-				[
-					6,
-					"std.select",
-					[
-						"picked",
-						"mean3",
-						[
-							1,
-							"sigma3",
-							"<",
-							"best"
-						]
-					]
-				]
-			],
-			[
-				2,
-				"best",
-				"=",
-				[
-					6,
-					"std.min",
-					["best", "sigma3"]
-				]
-			],
-			[
-				13,
-				"straight",
-				[
-					6,
-					"blend.unpremultiplyAlpha",
-					["picked"]
-				]
-			],
-			[
-				12,
-				"result",
-				[
-					6,
-					"d.vec3f",
-					[
-						[
-							7,
-							"straight",
-							"x"
-						],
-						[
-							7,
-							"straight",
-							"y"
-						],
-						[
-							7,
-							"straight",
-							"z"
-						]
-					]
-				]
-			],
-			[
-				13,
-				"paperMul",
-				[
-					6,
-					"std.mix",
-					[
-						[5, "1"],
-						"grain",
-						"paper"
-					]
-				]
-			],
-			[
-				13,
-				"paperTint",
-				[
-					6,
-					"d.vec3f",
-					[
-						[
-							7,
-							"paperColor",
-							"x"
-						],
-						[
-							7,
-							"paperColor",
-							"y"
-						],
-						[
-							7,
-							"paperColor",
-							"z"
-						]
-					]
-				]
-			],
-			[
-				2,
-				"result",
-				"=",
-				[
-					6,
-					"std.mix",
-					[
-						[
-							6,
-							[
-								7,
-								"result",
-								"mul"
-							],
-							["paperMul"]
-						],
-						[
-							6,
-							[
-								7,
-								"result",
-								"mul"
-							],
-							["paperTint"]
-						],
-						[
-							6,
-							"d.vec3f",
-							[[
-								1,
-								"paper",
-								"*",
-								[5, "0.4"]
-							]]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"origRgb",
-				[
-					6,
-					"d.vec3f",
-					[
-						[
-							7,
-							"originalBleed",
-							"x"
-						],
-						[
-							7,
-							"originalBleed",
-							"y"
-						],
-						[
-							7,
-							"originalBleed",
-							"z"
-						]
-					]
-				]
-			],
-			[
-				13,
-				"finalRGB",
-				[
-					6,
-					"std.mix",
-					[
-						"origRgb",
-						"result",
-						[
-							6,
-							"d.vec3f",
-							["strength"]
-						]
-					]
-				]
-			],
-			[10, "finalRGB"]
-		]]
-	},
-	externals: {
-		"d.vec3f": () => vec3f,
-		"d.vec4f": () => vec4f,
-		"std.select": () => select,
-		"std.min": () => min,
-		"blend.unpremultiplyAlpha": () => unpremultiplyAlpha,
-		"std.mix": () => mix
-	}
-}) && $.f)({}));
-var SIN_045 = Math.sin(.785);
-var COS_045 = Math.cos(.785);
-var SIN_N45 = Math.sin(-.785);
-var COS_N45 = Math.cos(-.785);
-var chalkHash21 = typegpu_default.fn([vec2f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p) => {
-	"use gpu";
-	return hash12(p);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "p"
-		}],
-		"body": [0, [[10, [
-			6,
-			"noise.hash12",
-			["p"]
-		]]]]
-	},
-	externals: { "noise.hash12": () => hash12 }
-}) && $.f)({}));
-var chalkVnoise = typegpu_default.fn([vec2f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p) => {
-	"use gpu";
-	const i = floor(p);
-	const f = fract(p);
-	const u = f.mul(f).mul(f.mul(-2).add(3));
-	const a = chalkHash21(i);
-	const b = chalkHash21(vec2f(__tsover_add(i.x, 1), i.y));
-	const c = chalkHash21(vec2f(i.x, __tsover_add(i.y, 1)));
-	const dd = chalkHash21(vec2f(__tsover_add(i.x, 1), __tsover_add(i.y, 1)));
-	return mix(mix(a, b, u.x), mix(c, dd, u.x), u.y);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "p"
-		}],
-		"body": [0, [
-			[
-				13,
-				"i",
-				[
-					6,
-					"std.floor",
-					["p"]
-				]
-			],
-			[
-				13,
-				"f",
-				[
-					6,
-					"std.fract",
-					["p"]
-				]
-			],
-			[
-				13,
-				"u",
-				[
-					6,
-					[
-						7,
-						[
-							6,
-							[
-								7,
-								"f",
-								"mul"
-							],
-							["f"]
-						],
-						"mul"
-					],
-					[[
-						6,
-						[
-							7,
-							[
-								6,
-								[
-									7,
-									"f",
-									"mul"
-								],
-								[[
-									4,
-									"-",
-									[5, "2"]
-								]]
-							],
-							"add"
-						],
-						[[5, "3"]]
-					]]
-				]
-			],
-			[
-				13,
-				"a",
-				[
-					6,
-					"chalkHash21",
-					["i"]
-				]
-			],
-			[
-				13,
-				"b",
-				[
-					6,
-					"chalkHash21",
-					[[
-						6,
-						"d.vec2f",
-						[[
-							1,
-							[
-								7,
-								"i",
-								"x"
-							],
-							"+",
-							[5, "1"]
-						], [
-							7,
-							"i",
-							"y"
-						]]
-					]]
-				]
-			],
-			[
-				13,
-				"c",
-				[
-					6,
-					"chalkHash21",
-					[[
-						6,
-						"d.vec2f",
-						[[
-							7,
-							"i",
-							"x"
-						], [
-							1,
-							[
-								7,
-								"i",
-								"y"
-							],
-							"+",
-							[5, "1"]
-						]]
-					]]
-				]
-			],
-			[
-				13,
-				"dd",
-				[
-					6,
-					"chalkHash21",
-					[[
-						6,
-						"d.vec2f",
-						[[
-							1,
-							[
-								7,
-								"i",
-								"x"
-							],
-							"+",
-							[5, "1"]
-						], [
-							1,
-							[
-								7,
-								"i",
-								"y"
-							],
-							"+",
-							[5, "1"]
-						]]
-					]]
-				]
-			],
-			[10, [
-				6,
-				"std.mix",
-				[
-					[
-						6,
-						"std.mix",
-						[
-							"a",
-							"b",
-							[
-								7,
-								"u",
-								"x"
-							]
-						]
-					],
-					[
-						6,
-						"std.mix",
-						[
-							"c",
-							"dd",
-							[
-								7,
-								"u",
-								"x"
-							]
-						]
-					],
-					[
-						7,
-						"u",
-						"y"
-					]
-				]
-			]]
-		]]
-	},
-	externals: {
-		"std.floor": () => floor,
-		"std.fract": () => fract,
-		"chalkHash21": () => chalkHash21,
-		"d.vec2f": () => vec2f,
-		"std.mix": () => mix
-	}
-}) && $.f)({}));
-const chalkLuma = typegpu_default.fn([vec4f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color) => {
-	"use gpu";
-	return dot(vec3f(color.x, color.y, color.z), vec3f(.299, .587, .114));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "color"
-		}],
-		"body": [0, [[10, [
-			6,
-			"std.dot",
-			[[
-				6,
-				"d.vec3f",
-				[
-					[
-						7,
-						"color",
-						"x"
-					],
-					[
-						7,
-						"color",
-						"y"
-					],
-					[
-						7,
-						"color",
-						"z"
-					]
-				]
-			], [
-				6,
-				"d.vec3f",
-				[
-					[5, "0.299"],
-					[5, "0.587"],
-					[5, "0.114"]
-				]
-			]]
-		]]]]
-	},
-	externals: {
-		"std.dot": () => dot,
-		"d.vec3f": () => vec3f
-	}
-}) && $.f)({}));
-const chalkOffsetUV = typegpu_default.fn([
-	vec2f,
-	vec2f,
-	f32,
-	f32,
-	f32
-], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, edgeThickness, ox, oy) => {
-	"use gpu";
-	const texelX = __tsover_div(1, viewport.x);
-	const texelY = __tsover_div(1, viewport.y);
-	return vec2f(__tsover_add(uv.x, __tsover_mul(__tsover_mul(texelX, edgeThickness), ox)), __tsover_add(uv.y, __tsover_mul(__tsover_mul(texelY, edgeThickness), oy)));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "uv"
-			},
-			{
-				"type": "i",
-				"name": "viewport"
-			},
-			{
-				"type": "i",
-				"name": "edgeThickness"
-			},
-			{
-				"type": "i",
-				"name": "ox"
-			},
-			{
-				"type": "i",
-				"name": "oy"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"texelX",
-				[
-					1,
-					[5, "1"],
-					"/",
-					[
-						7,
-						"viewport",
-						"x"
-					]
-				]
-			],
-			[
-				13,
-				"texelY",
-				[
-					1,
-					[5, "1"],
-					"/",
-					[
-						7,
-						"viewport",
-						"y"
-					]
-				]
-			],
-			[10, [
-				6,
-				"d.vec2f",
-				[[
-					1,
-					[
-						7,
-						"uv",
-						"x"
-					],
-					"+",
-					[
-						1,
-						[
-							1,
-							"texelX",
-							"*",
-							"edgeThickness"
-						],
-						"*",
-						"ox"
-					]
-				], [
-					1,
-					[
-						7,
-						"uv",
-						"y"
-					],
-					"+",
-					[
-						1,
-						[
-							1,
-							"texelY",
-							"*",
-							"edgeThickness"
-						],
-						"*",
-						"oy"
-					]
-				]]
-			]]
-		]]
-	},
-	externals: { "d.vec2f": () => vec2f }
-}) && $.f)({}));
-var chalkHatchLine = typegpu_default.fn([
-	vec2f,
-	f32,
-	f32,
-	f32,
-	f32,
-	f32
-], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((P, hatchScale, shade, sa, ca, thr) => {
-	"use gpu";
-	const ry = __tsover_add(__tsover_mul(P.x, sa), __tsover_mul(P.y, ca));
-	const hl = __tsover_mul(abs(__tsover_sub(fract(__tsover_div(ry, hatchScale)), .5)), 2);
-	const line = __tsover_sub(1, smoothstep(0, .35, hl));
-	return __tsover_mul(line, step(thr, shade));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "P"
-			},
-			{
-				"type": "i",
-				"name": "hatchScale"
-			},
-			{
-				"type": "i",
-				"name": "shade"
-			},
-			{
-				"type": "i",
-				"name": "sa"
-			},
-			{
-				"type": "i",
-				"name": "ca"
-			},
-			{
-				"type": "i",
-				"name": "thr"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"ry",
-				[
-					1,
-					[
-						1,
-						[
-							7,
-							"P",
-							"x"
-						],
-						"*",
-						"sa"
-					],
-					"+",
-					[
-						1,
-						[
-							7,
-							"P",
-							"y"
-						],
-						"*",
-						"ca"
-					]
-				]
-			],
-			[
-				13,
-				"hl",
-				[
-					1,
-					[
-						6,
-						"std.abs",
-						[[
-							1,
-							[
-								6,
-								"std.fract",
-								[[
-									1,
-									"ry",
-									"/",
-									"hatchScale"
-								]]
-							],
-							"-",
-							[5, "0.5"]
-						]]
-					],
-					"*",
-					[5, "2"]
-				]
-			],
-			[
-				13,
-				"line",
-				[
-					1,
-					[5, "1"],
-					"-",
-					[
-						6,
-						"std.smoothstep",
-						[
-							[5, "0"],
-							[5, "0.35"],
-							"hl"
-						]
-					]
-				]
-			],
-			[10, [
-				1,
-				"line",
-				"*",
-				[
-					6,
-					"std.step",
-					["thr", "shade"]
-				]
-			]]
-		]]
-	},
-	externals: {
-		"std.abs": () => abs,
-		"std.fract": () => fract,
-		"std.smoothstep": () => smoothstep,
-		"std.step": () => step
-	}
-}) && $.f)({}));
-const chalkboardCompose = typegpu_default.fn([
-	vec4f,
-	vec4f,
-	vec2f,
-	vec2f,
-	vec4f,
-	vec4f,
-	vec4f,
-	vec4f
-], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sobelA, sobelB, uv, viewport, misc, params, boardColor, chalkColor) => {
-	"use gpu";
-	const tl = sobelA.x;
-	const t = sobelA.y;
-	const tr = sobelA.z;
-	const l = sobelA.w;
-	const r = sobelB.x;
-	const bl = sobelB.y;
-	const bo = sobelB.z;
-	const br = sobelB.w;
-	const centerLum = misc.x;
-	const centerAlpha = misc.y;
-	const edgeSensitivity = params.x;
-	const hatchScale = params.y;
-	const shading = params.z;
-	const grain = params.w;
-	const gx = __tsover_add(__tsover_add(__tsover_add(__tsover_sub(__tsover_sub(-tl, __tsover_mul(l, 2)), bl), tr), __tsover_mul(r, 2)), br);
-	const gy = __tsover_add(__tsover_add(__tsover_add(__tsover_sub(__tsover_sub(-tl, __tsover_mul(t, 2)), tr), bl), __tsover_mul(bo, 2)), br);
-	const edgeMag = sqrt(__tsover_add(__tsover_mul(gx, gx), __tsover_mul(gy, gy)));
-	const edgeHigh = mix(f32(1), .08, edgeSensitivity);
-	const edge = smoothstep(__tsover_mul(edgeHigh, .4), edgeHigh, edgeMag);
-	const shade = __tsover_sub(1, centerLum);
-	const P = uv.mul(viewport);
-	const hatch = __tsover_mul(max(max(chalkHatchLine(P, hatchScale, shade, SIN_045, COS_045, .22), chalkHatchLine(P, hatchScale, shade, SIN_N45, COS_N45, .5)), chalkHatchLine(P, hatchScale, shade, 0, 1, .78)), shading);
-	const dust = mix(__tsover_sub(1, grain), f32(1), chalkVnoise(P.mul(.5)));
-	const chalkMask = clamp(__tsover_mul(max(edge, hatch), dust), 0, 1);
-	const boardGrain = __tsover_mul(__tsover_sub(chalkVnoise(P.mul(.9)), .5), .04);
-	return vec4f(mix(boardColor.xyz.add(boardGrain), chalkColor.xyz, vec3f(chalkMask)), centerAlpha);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "sobelA"
-			},
-			{
-				"type": "i",
-				"name": "sobelB"
-			},
-			{
-				"type": "i",
-				"name": "uv"
-			},
-			{
-				"type": "i",
-				"name": "viewport"
-			},
-			{
-				"type": "i",
-				"name": "misc"
-			},
-			{
-				"type": "i",
-				"name": "params"
-			},
-			{
-				"type": "i",
-				"name": "boardColor"
-			},
-			{
-				"type": "i",
-				"name": "chalkColor"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"tl",
-				[
-					7,
-					"sobelA",
-					"x"
-				]
-			],
-			[
-				13,
-				"t",
-				[
-					7,
-					"sobelA",
-					"y"
-				]
-			],
-			[
-				13,
-				"tr",
-				[
-					7,
-					"sobelA",
-					"z"
-				]
-			],
-			[
-				13,
-				"l",
-				[
-					7,
-					"sobelA",
-					"w"
-				]
-			],
-			[
-				13,
-				"r",
-				[
-					7,
-					"sobelB",
-					"x"
-				]
-			],
-			[
-				13,
-				"bl",
-				[
-					7,
-					"sobelB",
-					"y"
-				]
-			],
-			[
-				13,
-				"bo",
-				[
-					7,
-					"sobelB",
-					"z"
-				]
-			],
-			[
-				13,
-				"br",
-				[
-					7,
-					"sobelB",
-					"w"
-				]
-			],
-			[
-				13,
-				"centerLum",
-				[
-					7,
-					"misc",
-					"x"
-				]
-			],
-			[
-				13,
-				"centerAlpha",
-				[
-					7,
-					"misc",
-					"y"
-				]
-			],
-			[
-				13,
-				"edgeSensitivity",
-				[
-					7,
-					"params",
-					"x"
-				]
-			],
-			[
-				13,
-				"hatchScale",
-				[
-					7,
-					"params",
-					"y"
-				]
-			],
-			[
-				13,
-				"shading",
-				[
-					7,
-					"params",
-					"z"
-				]
-			],
-			[
-				13,
-				"grain",
-				[
-					7,
-					"params",
-					"w"
-				]
-			],
-			[
-				13,
-				"gx",
-				[
-					1,
-					[
-						1,
-						[
-							1,
-							[
-								1,
-								[
-									1,
-									[
-										4,
-										"-",
-										"tl"
-									],
-									"-",
-									[
-										1,
-										"l",
-										"*",
-										[5, "2"]
-									]
-								],
-								"-",
-								"bl"
-							],
-							"+",
-							"tr"
-						],
-						"+",
-						[
-							1,
-							"r",
-							"*",
-							[5, "2"]
-						]
-					],
-					"+",
-					"br"
-				]
-			],
-			[
-				13,
-				"gy",
-				[
-					1,
-					[
-						1,
-						[
-							1,
-							[
-								1,
-								[
-									1,
-									[
-										4,
-										"-",
-										"tl"
-									],
-									"-",
-									[
-										1,
-										"t",
-										"*",
-										[5, "2"]
-									]
-								],
-								"-",
-								"tr"
-							],
-							"+",
-							"bl"
-						],
-						"+",
-						[
-							1,
-							"bo",
-							"*",
-							[5, "2"]
-						]
-					],
-					"+",
-					"br"
-				]
-			],
-			[
-				13,
-				"edgeMag",
-				[
-					6,
-					"std.sqrt",
-					[[
-						1,
-						[
-							1,
-							"gx",
-							"*",
-							"gx"
-						],
-						"+",
-						[
-							1,
-							"gy",
-							"*",
-							"gy"
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"edgeHigh",
-				[
-					6,
-					"std.mix",
-					[
-						[
-							6,
-							"d.f32",
-							[[5, "1"]]
-						],
-						[5, "0.08"],
-						"edgeSensitivity"
-					]
-				]
-			],
-			[
-				13,
-				"edge",
-				[
-					6,
-					"std.smoothstep",
-					[
-						[
-							1,
-							"edgeHigh",
-							"*",
-							[5, "0.4"]
-						],
-						"edgeHigh",
-						"edgeMag"
-					]
-				]
-			],
-			[
-				13,
-				"shade",
-				[
-					1,
-					[5, "1"],
-					"-",
-					"centerLum"
-				]
-			],
-			[
-				13,
-				"P",
-				[
-					6,
-					[
-						7,
-						"uv",
-						"mul"
-					],
-					["viewport"]
-				]
-			],
-			[
-				13,
-				"hatch",
-				[
-					1,
-					[
-						6,
-						"std.max",
-						[[
-							6,
-							"std.max",
-							[[
-								6,
-								"chalkHatchLine",
-								[
-									"P",
-									"hatchScale",
-									"shade",
-									"SIN_045",
-									"COS_045",
-									[5, "0.22"]
-								]
-							], [
-								6,
-								"chalkHatchLine",
-								[
-									"P",
-									"hatchScale",
-									"shade",
-									"SIN_N45",
-									"COS_N45",
-									[5, "0.5"]
-								]
-							]]
-						], [
-							6,
-							"chalkHatchLine",
-							[
-								"P",
-								"hatchScale",
-								"shade",
-								[5, "0"],
-								[5, "1"],
-								[5, "0.78"]
-							]
-						]]
-					],
-					"*",
-					"shading"
-				]
-			],
-			[
-				13,
-				"dust",
-				[
-					6,
-					"std.mix",
-					[
-						[
-							1,
-							[5, "1"],
-							"-",
-							"grain"
-						],
-						[
-							6,
-							"d.f32",
-							[[5, "1"]]
-						],
-						[
-							6,
-							"chalkVnoise",
-							[[
-								6,
-								[
-									7,
-									"P",
-									"mul"
-								],
-								[[5, "0.5"]]
-							]]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"chalkMask",
-				[
-					6,
-					"std.clamp",
-					[
-						[
-							1,
-							[
-								6,
-								"std.max",
-								["edge", "hatch"]
-							],
-							"*",
-							"dust"
-						],
-						[5, "0"],
-						[5, "1"]
-					]
-				]
-			],
-			[
-				13,
-				"boardGrain",
-				[
-					1,
-					[
-						1,
-						[
-							6,
-							"chalkVnoise",
-							[[
-								6,
-								[
-									7,
-									"P",
-									"mul"
-								],
-								[[5, "0.9"]]
-							]]
-						],
-						"-",
-						[5, "0.5"]
-					],
-					"*",
-					[5, "0.04"]
-				]
-			],
-			[
-				13,
-				"boardRGB",
-				[
-					6,
-					[
-						7,
-						[
-							7,
-							"boardColor",
-							"xyz"
-						],
-						"add"
-					],
-					["boardGrain"]
-				]
-			],
-			[
-				13,
-				"col",
-				[
-					6,
-					"std.mix",
-					[
-						"boardRGB",
-						[
-							7,
-							"chalkColor",
-							"xyz"
-						],
-						[
-							6,
-							"d.vec3f",
-							["chalkMask"]
-						]
-					]
-				]
-			],
-			[10, [
-				6,
-				"d.vec4f",
-				["col", "centerAlpha"]
-			]]
-		]]
-	},
-	externals: {
-		"std.sqrt": () => sqrt,
-		"std.mix": () => mix,
-		"d.f32": () => f32,
-		"std.smoothstep": () => smoothstep,
-		"std.max": () => max,
-		"chalkHatchLine": () => chalkHatchLine,
-		"SIN_045": () => SIN_045,
-		"COS_045": () => COS_045,
-		"SIN_N45": () => SIN_N45,
-		"COS_N45": () => COS_N45,
-		"chalkVnoise": () => chalkVnoise,
-		"std.clamp": () => clamp,
-		"d.vec3f": () => vec3f,
-		"d.vec4f": () => vec4f
-	}
-}) && $.f)({}));
-var REFERENCE_HEIGHT = 1080;
-var AsciiGrid = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
-	cellCenter: vec2f,
-	cellUV: vec2f,
-	isOutside: f32
-}), "AsciiGrid");
-const asciiGrid = typegpu_default.fn([
-	vec2f,
-	vec2f,
-	f32,
-	f32
-], AsciiGrid)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, cellSize, spacing) => {
-	"use gpu";
-	const scaleFactor = __tsover_div(viewport.y, REFERENCE_HEIGHT);
-	const effectiveCellSize = __tsover_mul(cellSize, scaleFactor);
-	const mainGridSize = vec2f(__tsover_div(viewport.x, effectiveCellSize), __tsover_div(viewport.y, effectiveCellSize));
-	const gridCoords = vec2f(__tsover_mul(uv.x, mainGridSize.x), __tsover_mul(uv.y, mainGridSize.y));
-	const cellCoords = floor(gridCoords);
-	const rawCellUV = fract(gridCoords);
-	const centeredU = __tsover_sub(rawCellUV.x, .5);
-	const centeredV = __tsover_sub(rawCellUV.y, .5);
-	const cellUV = vec2f(__tsover_add(__tsover_div(centeredU, spacing), .5), __tsover_add(__tsover_div(centeredV, spacing), .5));
-	const half = __tsover_mul(spacing, .5);
-	const isOutside = select(f32(0), f32(1), abs(centeredU) > half || abs(centeredV) > half);
-	return AsciiGrid({
-		cellCenter: vec2f(__tsover_div(__tsover_add(cellCoords.x, .5), mainGridSize.x), __tsover_div(__tsover_add(cellCoords.y, .5), mainGridSize.y)),
-		cellUV,
-		isOutside
-	});
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "uv"
-			},
-			{
-				"type": "i",
-				"name": "viewport"
-			},
-			{
-				"type": "i",
-				"name": "cellSize"
-			},
-			{
-				"type": "i",
-				"name": "spacing"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"scaleFactor",
-				[
-					1,
-					[
-						7,
-						"viewport",
-						"y"
-					],
-					"/",
-					"REFERENCE_HEIGHT"
-				]
-			],
-			[
-				13,
-				"effectiveCellSize",
-				[
-					1,
-					"cellSize",
-					"*",
-					"scaleFactor"
-				]
-			],
-			[
-				13,
-				"mainGridSize",
-				[
-					6,
-					"d.vec2f",
-					[[
-						1,
-						[
-							7,
-							"viewport",
-							"x"
-						],
-						"/",
-						"effectiveCellSize"
-					], [
-						1,
-						[
-							7,
-							"viewport",
-							"y"
-						],
-						"/",
-						"effectiveCellSize"
-					]]
-				]
-			],
-			[
-				13,
-				"gridCoords",
-				[
-					6,
-					"d.vec2f",
-					[[
-						1,
-						[
-							7,
-							"uv",
-							"x"
-						],
-						"*",
-						[
-							7,
-							"mainGridSize",
-							"x"
-						]
-					], [
-						1,
-						[
-							7,
-							"uv",
-							"y"
-						],
-						"*",
-						[
-							7,
-							"mainGridSize",
-							"y"
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"cellCoords",
-				[
-					6,
-					"std.floor",
-					["gridCoords"]
-				]
-			],
-			[
-				13,
-				"rawCellUV",
-				[
-					6,
-					"std.fract",
-					["gridCoords"]
-				]
-			],
-			[
-				13,
-				"centeredU",
-				[
-					1,
-					[
-						7,
-						"rawCellUV",
-						"x"
-					],
-					"-",
-					[5, "0.5"]
-				]
-			],
-			[
-				13,
-				"centeredV",
-				[
-					1,
-					[
-						7,
-						"rawCellUV",
-						"y"
-					],
-					"-",
-					[5, "0.5"]
-				]
-			],
-			[
-				13,
-				"cellUV",
-				[
-					6,
-					"d.vec2f",
-					[[
-						1,
-						[
-							1,
-							"centeredU",
-							"/",
-							"spacing"
-						],
-						"+",
-						[5, "0.5"]
-					], [
-						1,
-						[
-							1,
-							"centeredV",
-							"/",
-							"spacing"
-						],
-						"+",
-						[5, "0.5"]
-					]]
-				]
-			],
-			[
-				13,
-				"half",
-				[
-					1,
-					"spacing",
-					"*",
-					[5, "0.5"]
-				]
-			],
-			[
-				13,
-				"isOutside",
-				[
-					6,
-					"std.select",
-					[
-						[
-							6,
-							"d.f32",
-							[[5, "0"]]
-						],
-						[
-							6,
-							"d.f32",
-							[[5, "1"]]
-						],
-						[
-							3,
-							[
-								1,
-								[
-									6,
-									"std.abs",
-									["centeredU"]
-								],
-								">",
-								"half"
-							],
-							"||",
-							[
-								1,
-								[
-									6,
-									"std.abs",
-									["centeredV"]
-								],
-								">",
-								"half"
-							]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"cellCenter",
-				[
-					6,
-					"d.vec2f",
-					[[
-						1,
-						[
-							1,
-							[
-								7,
-								"cellCoords",
-								"x"
-							],
-							"+",
-							[5, "0.5"]
-						],
-						"/",
-						[
-							7,
-							"mainGridSize",
-							"x"
-						]
-					], [
-						1,
-						[
-							1,
-							[
-								7,
-								"cellCoords",
-								"y"
-							],
-							"+",
-							[5, "0.5"]
-						],
-						"/",
-						[
-							7,
-							"mainGridSize",
-							"y"
-						]
-					]]
-				]
-			],
-			[10, [
-				6,
-				"AsciiGrid",
-				[[104, {
-					"cellCenter": "cellCenter",
-					"cellUV": "cellUV",
-					"isOutside": "isOutside"
-				}]]
-			]]
-		]]
-	},
-	externals: {
-		"REFERENCE_HEIGHT": () => REFERENCE_HEIGHT,
-		"d.vec2f": () => vec2f,
-		"std.floor": () => floor,
-		"std.fract": () => fract,
-		"std.select": () => select,
-		"d.f32": () => f32,
-		"std.abs": () => abs,
-		"AsciiGrid": () => AsciiGrid
-	}
-}) && $.f)({})).$name("asciiGrid");
-const asciiAtlasUV = typegpu_default.fn([
-	vec3f,
-	f32,
-	f32,
-	f32,
-	f32,
-	vec2f
-], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cellRgb, gamma, charCount, atlasSize, atlasScale, cellUV) => {
-	"use gpu";
-	const adjustedBrightness = pow(dot(cellRgb, vec3f(.299, .587, .114)), gamma);
-	const invertedBrightness = __tsover_sub(1, adjustedBrightness);
-	const charIndex = clamp(floor(__tsover_mul(invertedBrightness, charCount)), 0, __tsover_sub(charCount, 1));
-	const atlasCol = __tsover_sub(charIndex, __tsover_mul(atlasSize, floor(__tsover_div(charIndex, atlasSize))));
-	const atlasRow = floor(__tsover_div(charIndex, atlasSize));
-	const atlasCellSize = __tsover_mul(__tsover_div(1, atlasSize), atlasScale);
-	const baseU = __tsover_mul(atlasCol, atlasCellSize);
-	const baseV = __tsover_mul(atlasRow, atlasCellSize);
-	return vec2f(__tsover_add(baseU, __tsover_mul(cellUV.x, atlasCellSize)), __tsover_add(baseV, __tsover_mul(cellUV.y, atlasCellSize)));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "cellRgb"
-			},
-			{
-				"type": "i",
-				"name": "gamma"
-			},
-			{
-				"type": "i",
-				"name": "charCount"
-			},
-			{
-				"type": "i",
-				"name": "atlasSize"
-			},
-			{
-				"type": "i",
-				"name": "atlasScale"
-			},
-			{
-				"type": "i",
-				"name": "cellUV"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"rawBrightness",
-				[
-					6,
-					"std.dot",
-					["cellRgb", [
-						6,
-						"d.vec3f",
-						[
-							[5, "0.299"],
-							[5, "0.587"],
-							[5, "0.114"]
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"adjustedBrightness",
-				[
-					6,
-					"std.pow",
-					["rawBrightness", "gamma"]
-				]
-			],
-			[
-				13,
-				"invertedBrightness",
-				[
-					1,
-					[5, "1"],
-					"-",
-					"adjustedBrightness"
-				]
-			],
-			[
-				13,
-				"scaledBrightness",
-				[
-					1,
-					"invertedBrightness",
-					"*",
-					"charCount"
-				]
-			],
-			[
-				13,
-				"charIndex",
-				[
-					6,
-					"std.clamp",
-					[
-						[
-							6,
-							"std.floor",
-							["scaledBrightness"]
-						],
-						[5, "0"],
-						[
-							1,
-							"charCount",
-							"-",
-							[5, "1"]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"atlasCol",
-				[
-					1,
-					"charIndex",
-					"-",
-					[
-						1,
-						"atlasSize",
-						"*",
-						[
-							6,
-							"std.floor",
-							[[
-								1,
-								"charIndex",
-								"/",
-								"atlasSize"
-							]]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"atlasRow",
-				[
-					6,
-					"std.floor",
-					[[
-						1,
-						"charIndex",
-						"/",
-						"atlasSize"
-					]]
-				]
-			],
-			[
-				13,
-				"atlasCellSize",
-				[
-					1,
-					[
-						1,
-						[5, "1"],
-						"/",
-						"atlasSize"
-					],
-					"*",
-					"atlasScale"
-				]
-			],
-			[
-				13,
-				"baseU",
-				[
-					1,
-					"atlasCol",
-					"*",
-					"atlasCellSize"
-				]
-			],
-			[
-				13,
-				"baseV",
-				[
-					1,
-					"atlasRow",
-					"*",
-					"atlasCellSize"
-				]
-			],
-			[10, [
-				6,
-				"d.vec2f",
-				[[
-					1,
-					"baseU",
-					"+",
-					[
-						1,
-						[
-							7,
-							"cellUV",
-							"x"
-						],
-						"*",
-						"atlasCellSize"
-					]
-				], [
-					1,
-					"baseV",
-					"+",
-					[
-						1,
-						[
-							7,
-							"cellUV",
-							"y"
-						],
-						"*",
-						"atlasCellSize"
-					]
-				]]
-			]]
-		]]
-	},
-	externals: {
-		"std.dot": () => dot,
-		"d.vec3f": () => vec3f,
-		"std.pow": () => pow,
-		"std.clamp": () => clamp,
-		"std.floor": () => floor,
-		"d.vec2f": () => vec2f
-	}
-}) && $.f)({})).$name("asciiAtlasUV");
-const asciiCompose = typegpu_default.fn([
-	vec3f,
-	vec4f,
-	f32,
-	f32,
-	f32
-], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((asciiRgb, cellColor, isOutside, alphaThreshold, preserveAlpha) => {
-	"use gpu";
-	const isBackground = dot(asciiRgb, vec3f(.299, .587, .114)) < .1;
-	const sourceAlpha = cellColor.w;
-	const isBelowThreshold = sourceAlpha < alphaThreshold;
-	const outputAlpha = select(f32(1), sourceAlpha, preserveAlpha > .5);
-	const hide = isBackground || isOutside > .5 || isBelowThreshold;
-	const finalAlpha = select(outputAlpha, f32(0), hide);
-	return vec4f(__tsover_mul(asciiRgb.x, cellColor.x), __tsover_mul(asciiRgb.y, cellColor.y), __tsover_mul(asciiRgb.z, cellColor.z), finalAlpha);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "asciiRgb"
-			},
-			{
-				"type": "i",
-				"name": "cellColor"
-			},
-			{
-				"type": "i",
-				"name": "isOutside"
-			},
-			{
-				"type": "i",
-				"name": "alphaThreshold"
-			},
-			{
-				"type": "i",
-				"name": "preserveAlpha"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"charBrightness",
-				[
-					6,
-					"std.dot",
-					["asciiRgb", [
-						6,
-						"d.vec3f",
-						[
-							[5, "0.299"],
-							[5, "0.587"],
-							[5, "0.114"]
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"isBackground",
-				[
-					1,
-					"charBrightness",
-					"<",
-					[5, "0.1"]
-				]
-			],
-			[
-				13,
-				"sourceAlpha",
-				[
-					7,
-					"cellColor",
-					"w"
-				]
-			],
-			[
-				13,
-				"isBelowThreshold",
-				[
-					1,
-					"sourceAlpha",
-					"<",
-					"alphaThreshold"
-				]
-			],
-			[
-				13,
-				"outputAlpha",
-				[
-					6,
-					"std.select",
-					[
-						[
-							6,
-							"d.f32",
-							[[5, "1"]]
-						],
-						"sourceAlpha",
-						[
-							1,
-							"preserveAlpha",
-							">",
-							[5, "0.5"]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"hide",
-				[
-					3,
-					[
-						3,
-						"isBackground",
-						"||",
-						[
-							1,
-							"isOutside",
-							">",
-							[5, "0.5"]
-						]
-					],
-					"||",
-					"isBelowThreshold"
-				]
-			],
-			[
-				13,
-				"finalAlpha",
-				[
-					6,
-					"std.select",
-					[
-						"outputAlpha",
-						[
-							6,
-							"d.f32",
-							[[5, "0"]]
-						],
-						"hide"
-					]
-				]
-			],
-			[10, [
-				6,
-				"d.vec4f",
-				[
-					[
-						1,
-						[
-							7,
-							"asciiRgb",
-							"x"
-						],
-						"*",
-						[
-							7,
-							"cellColor",
-							"x"
-						]
-					],
-					[
-						1,
-						[
-							7,
-							"asciiRgb",
-							"y"
-						],
-						"*",
-						[
-							7,
-							"cellColor",
-							"y"
-						]
-					],
-					[
-						1,
-						[
-							7,
-							"asciiRgb",
-							"z"
-						],
-						"*",
-						[
-							7,
-							"cellColor",
-							"z"
-						]
-					],
-					"finalAlpha"
-				]
-			]]
-		]]
-	},
-	externals: {
-		"std.dot": () => dot,
-		"d.vec3f": () => vec3f,
-		"std.select": () => select,
-		"d.f32": () => f32,
-		"d.vec4f": () => vec4f
-	}
-}) && $.f)({})).$name("asciiCompose");
-function shared(build) {
-	const cache = /* @__PURE__ */ new WeakMap();
-	return (params) => {
-		const hit = cache.get(params);
-		if (hit !== void 0) return hit;
-		const v = build(params);
-		cache.set(params, v);
-		return v;
-	};
-}
-function bleedWarp(slots) {
-	return shared((params) => {
-		if ((params.propValues[slots.amount.name] ?? 0) === 0) return params.ctx.uv;
-		return asLocal(call(watercolorUvBase, "watercolorUvBase", [
-			params.ctx.uv,
-			params.ctx.logicalViewportSize,
-			uniformOf(slots.amount, params),
-			params.ctx.time
-		]), "wcUvBase");
-	});
-}
-function kuwahara(slots) {
-	return shared((params) => {
-		const R = Math.max(1, Math.min(8, Math.round(params.propValues[slots.radius.name] ?? 4)));
-		const taps = Math.max(2, Math.ceil((R + 1) / 2));
-		const invN = 1 / (taps * taps);
-		const uvBase = slots.at(params);
-		const lvp = params.ctx.logicalViewportSize;
-		const quadrant = (dx, dy) => {
-			let sum = expr("vec4f(0.0, 0.0, 0.0, 0.0)");
-			let sq = expr("vec3f(0.0, 0.0, 0.0)");
-			for (let j = 0; j < taps; j++) for (let i = 0; i < taps; i++) {
-				const uv = call(watercolorTapUV, "watercolorTapUV", [
-					uvBase,
-					lvp,
-					floatE((2 * i + .5) * dx),
-					floatE((2 * j + .5) * dy)
-				]);
-				const c = asLocal(params.texture.sample(uv), "wcTap");
-				const rgb = c.member("rgb");
-				sum = sum.add(c);
-				sq = sq.add(rgb.mul(rgb));
-			}
-			return {
-				sum,
-				sq
-			};
-		};
-		return {
-			quadrants: [
-				quadrant(-1, -1),
-				quadrant(1, -1),
-				quadrant(-1, 1),
-				quadrant(1, 1)
-			],
-			invN
-		};
-	});
-}
-function paperGrain(slots) {
-	return (params) => {
-		return (params.propValues[slots.amount.name] ?? 0) === 0 ? floatE(0) : call(watercolorGrain, "watercolorGrain", [params.ctx.uv, params.ctx.viewportSize]);
-	};
-}
-function wash(slots) {
-	return gather({
-		resultAlpha: "straight",
-		build: (params) => {
-			const u = (ref) => uniformOf(ref, params);
-			const original = asLocal(params.sampleStraight(slots.at(params)), "wcOriginal");
-			if ((params.propValues[slots.strength.name] ?? 1) === 0) return original;
-			const { quadrants: [q0, q1, q2, q3], invN } = slots.brush(params);
-			const grain = slots.grain(params);
-			return vec4(call(watercolorCompose, "watercolorCompose", [
-				q0.sum,
-				q1.sum,
-				q2.sum,
-				q3.sum,
-				q0.sq,
-				q1.sq,
-				q2.sq,
-				q3.sq,
-				floatE(invN),
-				original,
-				u(slots.paperColor),
-				u(slots.paper),
-				u(slots.strength),
-				grain
-			]), original.member("a"));
-		}
-	});
-}
-function sobelTaps(slots) {
-	return shared((params) => {
-		const { sampleStraight, ctx } = params;
-		const viewport = ctx.viewportSize;
-		const lumAt = (ox, oy) => {
-			return call(chalkLuma, "chalkLuma", [sampleStraight(call(chalkOffsetUV, "chalkOffsetUV", [
-				ctx.uv,
-				viewport,
-				uniformOf(slots.spacing, params),
-				floatE(ox),
-				floatE(oy)
-			]))]);
-		};
-		const tl = lumAt(-1, -1);
-		const t = lumAt(0, -1);
-		const tr = lumAt(1, -1);
-		const l = lumAt(-1, 0);
-		const r = lumAt(1, 0);
-		const bl = lumAt(-1, 1);
-		const bo = lumAt(0, 1);
-		const br = lumAt(1, 1);
-		const centre = sampleStraight(ctx.uv);
-		const centreLum = call(chalkLuma, "chalkLuma", [centre]);
-		return {
-			sobelA: vec4(tl, t, tr, l),
-			sobelB: vec4(r, bl, bo, br),
-			centre,
-			centreLum
-		};
-	});
-}
-function chalkSketch(slots) {
-	return gather({
-		resultAlpha: "straight",
-		build: (params) => {
-			const u = (ref) => uniformOf(ref, params);
-			const { sobelA, sobelB, centre, centreLum } = slots.edges(params);
-			const misc = vec4(centreLum, centre.member("a"), 0, 0);
-			const tuning = vec4(u(slots.sensitivity), u(slots.hatchScale), u(slots.shading), u(slots.grain));
-			return call(chalkboardCompose, "chalkboardCompose", [
-				sobelA,
-				sobelB,
-				params.ctx.uv,
-				params.ctx.viewportSize,
-				misc,
-				tuning,
-				u(slots.board),
-				u(slots.chalk)
-			]);
-		}
-	});
-}
-function charGrid(slots) {
-	return shared((params) => call(asciiGrid, "asciiGrid", [
-		params.ctx.uv,
-		params.ctx.viewportSize,
-		uniformOf(slots.cellSize, params),
-		uniformOf(slots.spacing, params)
-	]));
-}
-function cellSample(slots) {
-	return shared((params) => {
-		return call(unpremultiplyAlpha, "unpremultiplyAlpha", [params.convertToTexture(params.childNode).sample(slots.grid(params).member("cellCenter"))]);
-	});
-}
-function glyphFor(slots) {
-	return (params) => {
-		const atlasKit = slots.atlas(params);
-		const atlasUV = call(asciiAtlasUV, "asciiAtlasUV", [
-			slots.cell(params).member("rgb"),
-			uniformOf(slots.gamma, params),
-			params.uniforms._charCount,
-			params.uniforms._atlasSize,
-			params.uniforms._atlasScale,
-			slots.grid(params).member("cellUV")
-		]);
-		return atlasKit.sample(atlasUV, "nearestClamp");
-	};
-}
-function glyphTint(slots) {
-	return (params) => {
-		if (!params.childNode) return ZERO;
-		const cellColor = slots.cell(params);
-		return call(asciiCompose, "asciiCompose", [
-			slots.glyph(params).member("rgb"),
-			cellColor,
-			slots.grid(params).member("isOutside"),
-			uniformOf(slots.alphaThreshold, params),
-			uniformOf(slots.preserveAlpha, params)
-		]);
-	};
-}
-var OBF_DEG_TO_RAD = DEG_TO_RAD;
-const orientedBoxField = typegpu_default.fn([
-	vec2f,
-	f32,
-	vec2f,
-	f32,
-	f32,
-	f32
-], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, center, rotationDeg, halfW, halfH) => {
-	"use gpu";
-	const aspectUV = vec2f(__tsover_mul(uv.x, aspect), uv.y);
-	const centerPos = vec2f(__tsover_mul(center.x, aspect), __tsover_sub(1, center.y));
-	const dx = __tsover_sub(aspectUV.x, centerPos.x);
-	const dy = __tsover_sub(aspectUV.y, centerPos.y);
-	const rotRad = __tsover_mul(rotationDeg, OBF_DEG_TO_RAD);
-	const cosR = cos(rotRad);
-	const sinR = sin(rotRad);
-	const rdx = __tsover_add(__tsover_mul(dx, cosR), __tsover_mul(dy, sinR));
-	const rdy = __tsover_sub(__tsover_mul(dy, cosR), __tsover_mul(dx, sinR));
-	const localU = __tsover_add(__tsover_div(rdx, __tsover_mul(halfW, 2)), .5);
-	const localV = __tsover_add(__tsover_div(rdy, __tsover_mul(halfH, 2)), .5);
-	return vec3f(localU, localV, __tsover_mul(__tsover_mul(__tsover_mul(step(0, localU), step(localU, 1)), step(0, localV)), step(localV, 1)));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "uv"
-			},
-			{
-				"type": "i",
-				"name": "aspect"
-			},
-			{
-				"type": "i",
-				"name": "center"
-			},
-			{
-				"type": "i",
-				"name": "rotationDeg"
-			},
-			{
-				"type": "i",
-				"name": "halfW"
-			},
-			{
-				"type": "i",
-				"name": "halfH"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"aspectUV",
-				[
-					6,
-					"d.vec2f",
-					[[
-						1,
-						[
-							7,
-							"uv",
-							"x"
-						],
-						"*",
-						"aspect"
-					], [
-						7,
-						"uv",
-						"y"
-					]]
-				]
-			],
-			[
-				13,
-				"centerPos",
-				[
-					6,
-					"d.vec2f",
-					[[
-						1,
-						[
-							7,
-							"center",
-							"x"
-						],
-						"*",
-						"aspect"
-					], [
-						1,
-						[5, "1"],
-						"-",
-						[
-							7,
-							"center",
-							"y"
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"dx",
-				[
-					1,
-					[
-						7,
-						"aspectUV",
-						"x"
-					],
-					"-",
-					[
-						7,
-						"centerPos",
-						"x"
-					]
-				]
-			],
-			[
-				13,
-				"dy",
-				[
-					1,
-					[
-						7,
-						"aspectUV",
-						"y"
-					],
-					"-",
-					[
-						7,
-						"centerPos",
-						"y"
-					]
-				]
-			],
-			[
-				13,
-				"rotRad",
-				[
-					1,
-					"rotationDeg",
-					"*",
-					"OBF_DEG_TO_RAD"
-				]
-			],
-			[
-				13,
-				"cosR",
-				[
-					6,
-					"std.cos",
-					["rotRad"]
-				]
-			],
-			[
-				13,
-				"sinR",
-				[
-					6,
-					"std.sin",
-					["rotRad"]
-				]
-			],
-			[
-				13,
-				"rdx",
-				[
-					1,
-					[
-						1,
-						"dx",
-						"*",
-						"cosR"
-					],
-					"+",
-					[
-						1,
-						"dy",
-						"*",
-						"sinR"
-					]
-				]
-			],
-			[
-				13,
-				"rdy",
-				[
-					1,
-					[
-						1,
-						"dy",
-						"*",
-						"cosR"
-					],
-					"-",
-					[
-						1,
-						"dx",
-						"*",
-						"sinR"
-					]
-				]
-			],
-			[
-				13,
-				"localU",
-				[
-					1,
-					[
-						1,
-						"rdx",
-						"/",
-						[
-							1,
-							"halfW",
-							"*",
-							[5, "2"]
-						]
-					],
-					"+",
-					[5, "0.5"]
-				]
-			],
-			[
-				13,
-				"localV",
-				[
-					1,
-					[
-						1,
-						"rdy",
-						"/",
-						[
-							1,
-							"halfH",
-							"*",
-							[5, "2"]
-						]
-					],
-					"+",
-					[5, "0.5"]
-				]
-			],
-			[
-				13,
-				"insideMask",
-				[
-					1,
-					[
-						1,
-						[
-							1,
-							[
-								6,
-								"std.step",
-								[[5, "0"], "localU"]
-							],
-							"*",
-							[
-								6,
-								"std.step",
-								["localU", [5, "1"]]
-							]
-						],
-						"*",
-						[
-							6,
-							"std.step",
-							[[5, "0"], "localV"]
-						]
-					],
-					"*",
-					[
-						6,
-						"std.step",
-						["localV", [5, "1"]]
-					]
-				]
-			],
-			[10, [
-				6,
-				"d.vec3f",
-				[
-					"localU",
-					"localV",
-					"insideMask"
-				]
-			]]
-		]]
-	},
-	externals: {
-		"d.vec2f": () => vec2f,
-		"OBF_DEG_TO_RAD": () => OBF_DEG_TO_RAD,
-		"std.cos": () => cos,
-		"std.sin": () => sin,
-		"std.step": () => step,
-		"d.vec3f": () => vec3f
-	}
-}) && $.f)({}));
-var HP_TAU = TAU;
-var HP_DEG_TO_RAD = DEG_TO_RAD;
-const hatchPlate = typegpu_default.fn([
-	vec2f,
-	f32,
-	f32,
-	f32,
-	f32,
-	f32
-], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p, angleDeg, frequency, reliefPhase, level, aa) => {
-	"use gpu";
-	const angleRad = __tsover_mul(angleDeg, HP_DEG_TO_RAD);
-	const c = cos(angleRad);
-	const s = sin(angleRad);
-	const w = __tsover_add(__tsover_mul(p.x, __tsover_mul(s, -1)), __tsover_mul(p.y, c));
-	const v = cos(__tsover_add(__tsover_mul(__tsover_mul(w, frequency), HP_TAU), reliefPhase));
-	const thr = mix(-1.15, 1.15, clamp(level, 0, 1));
-	return smoothstep(__tsover_sub(thr, aa), __tsover_add(thr, aa), v);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "p"
-			},
-			{
-				"type": "i",
-				"name": "angleDeg"
-			},
-			{
-				"type": "i",
-				"name": "frequency"
-			},
-			{
-				"type": "i",
-				"name": "reliefPhase"
-			},
-			{
-				"type": "i",
-				"name": "level"
-			},
-			{
-				"type": "i",
-				"name": "aa"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"angleRad",
-				[
-					1,
-					"angleDeg",
-					"*",
-					"HP_DEG_TO_RAD"
-				]
-			],
-			[
-				13,
-				"c",
-				[
-					6,
-					"std.cos",
-					["angleRad"]
-				]
-			],
-			[
-				13,
-				"s",
-				[
-					6,
-					"std.sin",
-					["angleRad"]
-				]
-			],
-			[
-				13,
-				"w",
-				[
-					1,
-					[
-						1,
-						[
-							7,
-							"p",
-							"x"
-						],
-						"*",
-						[
-							1,
-							"s",
-							"*",
-							[
-								4,
-								"-",
-								[5, "1"]
-							]
-						]
-					],
-					"+",
-					[
-						1,
-						[
-							7,
-							"p",
-							"y"
-						],
-						"*",
-						"c"
-					]
-				]
-			],
-			[
-				13,
-				"phase",
-				[
-					1,
-					[
-						1,
-						[
-							1,
-							"w",
-							"*",
-							"frequency"
-						],
-						"*",
-						"HP_TAU"
-					],
-					"+",
-					"reliefPhase"
-				]
-			],
-			[
-				13,
-				"v",
-				[
-					6,
-					"std.cos",
-					["phase"]
-				]
-			],
-			[
-				13,
-				"thr",
-				[
-					6,
-					"std.mix",
-					[
-						[
-							4,
-							"-",
-							[5, "1.15"]
-						],
-						[5, "1.15"],
-						[
-							6,
-							"std.clamp",
-							[
-								"level",
-								[5, "0"],
-								[5, "1"]
-							]
-						]
-					]
-				]
-			],
-			[10, [
-				6,
-				"std.smoothstep",
-				[
-					[
-						1,
-						"thr",
-						"-",
-						"aa"
-					],
-					[
-						1,
-						"thr",
-						"+",
-						"aa"
-					],
-					"v"
-				]
-			]]
-		]]
-	},
-	externals: {
-		"HP_DEG_TO_RAD": () => HP_DEG_TO_RAD,
-		"std.cos": () => cos,
-		"std.sin": () => sin,
-		"HP_TAU": () => HP_TAU,
-		"std.mix": () => mix,
-		"std.clamp": () => clamp,
-		"std.smoothstep": () => smoothstep
-	}
-}) && $.f)({}));
-const spiralPlate = typegpu_default.fn([
-	vec2f,
-	vec2f,
-	f32,
-	f32,
-	f32,
-	f32
-], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p, c, frequency, reliefPhase, level, aa) => {
-	"use gpu";
-	const dv = p.sub(c);
-	const r = length(dv);
-	const theta = atan2(dv.y, dv.x);
-	const v = cos(__tsover_add(__tsover_mul(__tsover_sub(__tsover_mul(r, frequency), __tsover_mul(theta, __tsover_div(1, HP_TAU))), HP_TAU), reliefPhase));
-	const thr = mix(-1.15, 1.15, clamp(level, 0, 1));
-	return smoothstep(__tsover_sub(thr, aa), __tsover_add(thr, aa), v);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "p"
-			},
-			{
-				"type": "i",
-				"name": "c"
-			},
-			{
-				"type": "i",
-				"name": "frequency"
-			},
-			{
-				"type": "i",
-				"name": "reliefPhase"
-			},
-			{
-				"type": "i",
-				"name": "level"
-			},
-			{
-				"type": "i",
-				"name": "aa"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"dv",
-				[
-					6,
-					[
-						7,
-						"p",
-						"sub"
-					],
-					["c"]
-				]
-			],
-			[
-				13,
-				"r",
-				[
-					6,
-					"std.length",
-					["dv"]
-				]
-			],
-			[
-				13,
-				"theta",
-				[
-					6,
-					"std.atan2",
-					[[
-						7,
-						"dv",
-						"y"
-					], [
-						7,
-						"dv",
-						"x"
-					]]
-				]
-			],
-			[
-				13,
-				"phase",
-				[
-					1,
-					[
-						1,
-						[
-							1,
-							[
-								1,
-								"r",
-								"*",
-								"frequency"
-							],
-							"-",
-							[
-								1,
-								"theta",
-								"*",
-								[
-									1,
-									[5, "1"],
-									"/",
-									"HP_TAU"
-								]
-							]
-						],
-						"*",
-						"HP_TAU"
-					],
-					"+",
-					"reliefPhase"
-				]
-			],
-			[
-				13,
-				"v",
-				[
-					6,
-					"std.cos",
-					["phase"]
-				]
-			],
-			[
-				13,
-				"thr",
-				[
-					6,
-					"std.mix",
-					[
-						[
-							4,
-							"-",
-							[5, "1.15"]
-						],
-						[5, "1.15"],
-						[
-							6,
-							"std.clamp",
-							[
-								"level",
-								[5, "0"],
-								[5, "1"]
-							]
-						]
-					]
-				]
-			],
-			[10, [
-				6,
-				"std.smoothstep",
-				[
-					[
-						1,
-						"thr",
-						"-",
-						"aa"
-					],
-					[
-						1,
-						"thr",
-						"+",
-						"aa"
-					],
-					"v"
-				]
-			]]
-		]]
-	},
-	externals: {
-		"std.length": () => length,
-		"std.atan2": () => atan2,
-		"HP_TAU": () => HP_TAU,
-		"std.cos": () => cos,
-		"std.mix": () => mix,
-		"std.clamp": () => clamp,
-		"std.smoothstep": () => smoothstep
-	}
-}) && $.f)({}));
-function makeLineworkComposite(style) {
-	return typegpu_default.fn([
-		vec4f,
-		vec2f,
-		f32,
-		vec4f,
-		vec4f,
-		vec2f,
-		vec4f,
-		vec4f
-	], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((childColor, uv, aspect, paper, ink, center, p0, p1) => {
-		"use gpu";
-		const angleDeg = p0.x;
-		const frequency = p0.y;
-		const relief = p0.z;
-		const waviness = p0.w;
-		const contrast = p1.x;
-		const viewportY = p1.y;
-		const lum = dot(vec3f(childColor.x, childColor.y, childColor.z), vec3f(.299, .587, .114));
-		const level = clamp(__tsover_add(.5, __tsover_mul(__tsover_sub(lum, .5), contrast)), 0, 1);
-		const pa = vec2f(__tsover_mul(uv.x, aspect), uv.y);
-		const nx = mxNoiseFloat2(pa.mul(3.1));
-		const ny = mxNoiseFloat2(pa.mul(3.1).add(vec2f(7.31, 3.77)));
-		const p = pa.add(vec2f(nx, ny).mul(__tsover_mul(waviness, .06)));
-		const aa = clamp(__tsover_div(__tsover_mul(frequency, HP_TAU), max(viewportY, 1)), .02, 1);
-		const reliefPhase = __tsover_mul(__tsover_mul(relief, level), 9.42);
-		let cover = f32(0);
-		if (style === 2) cover = spiralPlate(p, vec2f(__tsover_mul(center.x, aspect), __tsover_sub(1, center.y)), frequency, reliefPhase, level, aa);
-		else if (style === 1) {
-			const ink1 = hatchPlate(p, angleDeg, frequency, reliefPhase, level, aa);
-			const level2 = clamp(__tsover_div(level, .55), 0, 1);
-			const ink2 = hatchPlate(p, __tsover_add(angleDeg, 72), __tsover_mul(frequency, .92), __tsover_mul(reliefPhase, .7), level2, aa);
-			const level3 = clamp(__tsover_div(level, .28), 0, 1);
-			cover = max(ink1, max(ink2, hatchPlate(p, __tsover_sub(angleDeg, 38), __tsover_mul(frequency, 1.13), __tsover_mul(reliefPhase, .5), level3, aa)));
-		} else cover = hatchPlate(p, angleDeg, frequency, reliefPhase, level, aa);
-		const rgb = mix(vec3f(paper.x, paper.y, paper.z), vec3f(ink.x, ink.y, ink.z), vec3f(cover));
-		const alpha = __tsover_mul(childColor.w, mix(paper.w, ink.w, cover));
-		return vec4f(rgb.x, rgb.y, rgb.z, alpha);
-	}), {
-		v: 2,
-		name: void 0,
-		ast: {
-			"params": [
-				{
-					"type": "i",
-					"name": "childColor"
-				},
-				{
-					"type": "i",
-					"name": "uv"
-				},
-				{
-					"type": "i",
-					"name": "aspect"
-				},
-				{
-					"type": "i",
-					"name": "paper"
-				},
-				{
-					"type": "i",
-					"name": "ink"
-				},
-				{
-					"type": "i",
-					"name": "center"
-				},
-				{
-					"type": "i",
-					"name": "p0"
-				},
-				{
-					"type": "i",
-					"name": "p1"
-				}
-			],
-			"body": [0, [
-				[
-					13,
-					"angleDeg",
-					[
-						7,
-						"p0",
-						"x"
-					]
-				],
-				[
-					13,
-					"frequency",
-					[
-						7,
-						"p0",
-						"y"
-					]
-				],
-				[
-					13,
-					"relief",
-					[
-						7,
-						"p0",
-						"z"
-					]
-				],
-				[
-					13,
-					"waviness",
-					[
-						7,
-						"p0",
-						"w"
-					]
-				],
-				[
-					13,
-					"contrast",
-					[
-						7,
-						"p1",
-						"x"
-					]
-				],
-				[
-					13,
-					"viewportY",
-					[
-						7,
-						"p1",
-						"y"
-					]
-				],
-				[
-					13,
-					"lum",
-					[
-						6,
-						"std.dot",
-						[[
-							6,
-							"d.vec3f",
-							[
-								[
-									7,
-									"childColor",
-									"x"
-								],
-								[
-									7,
-									"childColor",
-									"y"
-								],
-								[
-									7,
-									"childColor",
-									"z"
-								]
-							]
-						], [
-							6,
-							"d.vec3f",
-							[
-								[5, "0.299"],
-								[5, "0.587"],
-								[5, "0.114"]
-							]
-						]]
-					]
-				],
-				[
-					13,
-					"level",
-					[
-						6,
-						"std.clamp",
-						[
-							[
-								1,
-								[5, "0.5"],
-								"+",
-								[
-									1,
-									[
-										1,
-										"lum",
-										"-",
-										[5, "0.5"]
-									],
-									"*",
-									"contrast"
-								]
-							],
-							[5, "0"],
-							[5, "1"]
-						]
-					]
-				],
-				[
-					13,
-					"pa",
-					[
-						6,
-						"d.vec2f",
-						[[
-							1,
-							[
-								7,
-								"uv",
-								"x"
-							],
-							"*",
-							"aspect"
-						], [
-							7,
-							"uv",
-							"y"
-						]]
-					]
-				],
-				[
-					13,
-					"nx",
-					[
-						6,
-						"noise.mxNoiseFloat2",
-						[[
-							6,
-							[
-								7,
-								"pa",
-								"mul"
-							],
-							[[5, "3.1"]]
-						]]
-					]
-				],
-				[
-					13,
-					"ny",
-					[
-						6,
-						"noise.mxNoiseFloat2",
-						[[
-							6,
-							[
-								7,
-								[
-									6,
-									[
-										7,
-										"pa",
-										"mul"
-									],
-									[[5, "3.1"]]
-								],
-								"add"
-							],
-							[[
-								6,
-								"d.vec2f",
-								[[5, "7.31"], [5, "3.77"]]
-							]]
-						]]
-					]
-				],
-				[
-					13,
-					"p",
-					[
-						6,
-						[
-							7,
-							"pa",
-							"add"
-						],
-						[[
-							6,
-							[
-								7,
-								[
-									6,
-									"d.vec2f",
-									["nx", "ny"]
-								],
-								"mul"
-							],
-							[[
-								1,
-								"waviness",
-								"*",
-								[5, "0.06"]
-							]]
-						]]
-					]
-				],
-				[
-					13,
-					"aa",
-					[
-						6,
-						"std.clamp",
-						[
-							[
-								1,
-								[
-									1,
-									"frequency",
-									"*",
-									"HP_TAU"
-								],
-								"/",
-								[
-									6,
-									"std.max",
-									["viewportY", [5, "1"]]
-								]
-							],
-							[5, "0.02"],
-							[5, "1"]
-						]
-					]
-				],
-				[
-					13,
-					"reliefPhase",
-					[
-						1,
-						[
-							1,
-							"relief",
-							"*",
-							"level"
-						],
-						"*",
-						[5, "9.42"]
-					]
-				],
-				[
-					12,
-					"cover",
-					[
-						6,
-						"d.f32",
-						[[5, "0"]]
-					]
-				],
-				[
-					11,
-					[
-						1,
-						"style",
-						"===",
-						[5, "2"]
-					],
-					[0, [[
-						13,
-						"sc",
-						[
-							6,
-							"d.vec2f",
-							[[
-								1,
-								[
-									7,
-									"center",
-									"x"
-								],
-								"*",
-								"aspect"
-							], [
-								1,
-								[5, "1"],
-								"-",
-								[
-									7,
-									"center",
-									"y"
-								]
-							]]
-						]
-					], [
-						2,
-						"cover",
-						"=",
-						[
-							6,
-							"spiralPlate",
-							[
-								"p",
-								"sc",
-								"frequency",
-								"reliefPhase",
-								"level",
-								"aa"
-							]
-						]
-					]]],
-					[
-						11,
-						[
-							1,
-							"style",
-							"===",
-							[5, "1"]
-						],
-						[0, [
-							[
-								13,
-								"ink1",
-								[
-									6,
-									"hatchPlate",
-									[
-										"p",
-										"angleDeg",
-										"frequency",
-										"reliefPhase",
-										"level",
-										"aa"
-									]
-								]
-							],
-							[
-								13,
-								"level2",
-								[
-									6,
-									"std.clamp",
-									[
-										[
-											1,
-											"level",
-											"/",
-											[5, "0.55"]
-										],
-										[5, "0"],
-										[5, "1"]
-									]
-								]
-							],
-							[
-								13,
-								"ink2",
-								[
-									6,
-									"hatchPlate",
-									[
-										"p",
-										[
-											1,
-											"angleDeg",
-											"+",
-											[5, "72"]
-										],
-										[
-											1,
-											"frequency",
-											"*",
-											[5, "0.92"]
-										],
-										[
-											1,
-											"reliefPhase",
-											"*",
-											[5, "0.7"]
-										],
-										"level2",
-										"aa"
-									]
-								]
-							],
-							[
-								13,
-								"level3",
-								[
-									6,
-									"std.clamp",
-									[
-										[
-											1,
-											"level",
-											"/",
-											[5, "0.28"]
-										],
-										[5, "0"],
-										[5, "1"]
-									]
-								]
-							],
-							[
-								13,
-								"ink3",
-								[
-									6,
-									"hatchPlate",
-									[
-										"p",
-										[
-											1,
-											"angleDeg",
-											"-",
-											[5, "38"]
-										],
-										[
-											1,
-											"frequency",
-											"*",
-											[5, "1.13"]
-										],
-										[
-											1,
-											"reliefPhase",
-											"*",
-											[5, "0.5"]
-										],
-										"level3",
-										"aa"
-									]
-								]
-							],
-							[
-								2,
-								"cover",
-								"=",
-								[
-									6,
-									"std.max",
-									["ink1", [
-										6,
-										"std.max",
-										["ink2", "ink3"]
-									]]
-								]
-							]
-						]],
-						[0, [[
-							2,
-							"cover",
-							"=",
-							[
-								6,
-								"hatchPlate",
-								[
-									"p",
-									"angleDeg",
-									"frequency",
-									"reliefPhase",
-									"level",
-									"aa"
-								]
-							]
-						]]]
-					]
-				],
-				[
-					13,
-					"rgb",
-					[
-						6,
-						"std.mix",
-						[
-							[
-								6,
-								"d.vec3f",
-								[
-									[
-										7,
-										"paper",
-										"x"
-									],
-									[
-										7,
-										"paper",
-										"y"
-									],
-									[
-										7,
-										"paper",
-										"z"
-									]
-								]
-							],
-							[
-								6,
-								"d.vec3f",
-								[
-									[
-										7,
-										"ink",
-										"x"
-									],
-									[
-										7,
-										"ink",
-										"y"
-									],
-									[
-										7,
-										"ink",
-										"z"
-									]
-								]
-							],
-							[
-								6,
-								"d.vec3f",
-								["cover"]
-							]
-						]
-					]
-				],
-				[
-					13,
-					"alpha",
-					[
-						1,
-						[
-							7,
-							"childColor",
-							"w"
-						],
-						"*",
-						[
-							6,
-							"std.mix",
-							[
-								[
-									7,
-									"paper",
-									"w"
-								],
-								[
-									7,
-									"ink",
-									"w"
-								],
-								"cover"
-							]
-						]
-					]
-				],
-				[10, [
-					6,
-					"d.vec4f",
-					[
-						[
-							7,
-							"rgb",
-							"x"
-						],
-						[
-							7,
-							"rgb",
-							"y"
-						],
-						[
-							7,
-							"rgb",
-							"z"
-						],
-						"alpha"
-					]
-				]]
-			]]
-		},
-		externals: {
-			"std.dot": () => dot,
-			"d.vec3f": () => vec3f,
-			"std.clamp": () => clamp,
-			"d.vec2f": () => vec2f,
-			"noise.mxNoiseFloat2": () => mxNoiseFloat2,
-			"HP_TAU": () => HP_TAU,
-			"std.max": () => max,
-			"d.f32": () => f32,
-			"style": () => style,
-			"spiralPlate": () => spiralPlate,
-			"hatchPlate": () => hatchPlate,
-			"std.mix": () => mix,
-			"d.vec4f": () => vec4f
-		}
-	}) && $.f)({})).$name(`lineworkComposite_${style}`);
-}
-var LINEWORK_MODES = {
-	line: 0,
-	crosshatch: 1,
-	spiral: 2
-};
-function linework(slots) {
-	return gather({
-		resultAlpha: "straight",
-		build: ({ sampleStraight, ctx, uniforms, propValues }) => {
-			const childColor = sampleStraight(ctx.uv);
-			const raw = propValues[slots.style.name];
-			const style = typeof raw === "number" ? raw : LINEWORK_MODES[String(raw)] ?? 1;
-			const composite = makeLineworkComposite(style);
-			const p0 = vec4(uniforms[slots.angle.name], uniforms[slots.frequency.name], uniforms[slots.relief.name], uniforms[slots.waviness.name]);
-			const p1 = vec4(uniforms[slots.contrast.name], ctx.viewportSize.member("y"), floatE(0), floatE(0));
-			return call(composite, `lineworkComposite_${style}`, [
-				childColor,
-				ctx.uv,
-				ctx.aspect,
-				uniforms[slots.paper.name],
-				uniforms[slots.ink.name],
-				uniforms[slots.center.name],
-				p0,
-				p1
-			]);
-		}
-	});
-}
-export { glyphFor as a, linework as c, sobelTaps as d, wash as f, charGrid as i, orientedBoxField as l, cellSample as n, glyphTint as o, chalkSketch as r, kuwahara as s, bleedWarp as t, paperGrain as u };