shaders 3.1.463 → 3.2.465

package/dist/core/reveal-s6xWR757.js

@@ -0,0 +1,1688 @@
+import { $n as clamp, An as DEG_TO_RAD, Br as f32, Fn as TWO_PI, Jn as select, Nr as struct, Tr as vec4f, Yn as abs, Zn as atan2, _r as smoothstep, ar as floor, cr as max, er as cos, gr as sin, i as resolveArg, lr as min, mn as hash12, nr as dot, or as fract, ot as call, pn as hash11, sr as length, ut as floatE, vn as mxNoiseFloat2, xr as vec2f, zn as typegpu_default } from "./lower-DSk_KxOY.js";
+const revealMask = typegpu_default.fn([
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((coord, progress, feather, invert) => {
+	"use gpu";
+	const c = select(coord, __tsover_sub(1, coord), invert > 0);
+	const f = max(feather, 1e-4);
+	const front = __tsover_sub(__tsover_mul(progress, __tsover_add(1, __tsover_mul(2, f))), f);
+	return smoothstep(__tsover_sub(front, f), __tsover_add(front, f), c);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "coord"
+			},
+			{
+				"type": "i",
+				"name": "progress"
+			},
+			{
+				"type": "i",
+				"name": "feather"
+			},
+			{
+				"type": "i",
+				"name": "invert"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"c",
+				[
+					6,
+					"std.select",
+					[
+						"coord",
+						[
+							1,
+							[5, "1"],
+							"-",
+							"coord"
+						],
+						[
+							1,
+							"invert",
+							">",
+							[5, "0"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"f",
+				[
+					6,
+					"std.max",
+					["feather", [5, "0.0001"]]
+				]
+			],
+			[
+				13,
+				"front",
+				[
+					1,
+					[
+						1,
+						"progress",
+						"*",
+						[
+							1,
+							[5, "1"],
+							"+",
+							[
+								1,
+								[5, "2"],
+								"*",
+								"f"
+							]
+						]
+					],
+					"-",
+					"f"
+				]
+			],
+			[10, [
+				6,
+				"std.smoothstep",
+				[
+					[
+						1,
+						"front",
+						"-",
+						"f"
+					],
+					[
+						1,
+						"front",
+						"+",
+						"f"
+					],
+					"c"
+				]
+			]]
+		]]
+	},
+	externals: {
+		"std.select": () => select,
+		"std.max": () => max,
+		"std.smoothstep": () => smoothstep
+	}
+}) && $.f)({}));
+const applyReveal = typegpu_default.fn([vec4f, f32], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, reveal$1) => {
+	"use gpu";
+	return vec4f(color.x, color.y, color.z, __tsover_mul(color.w, reveal$1));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "color"
+		}, {
+			"type": "i",
+			"name": "reveal"
+		}],
+		"body": [0, [[10, [
+			6,
+			"d.vec4f",
+			[
+				[
+					7,
+					"color",
+					"x"
+				],
+				[
+					7,
+					"color",
+					"y"
+				],
+				[
+					7,
+					"color",
+					"z"
+				],
+				[
+					1,
+					[
+						7,
+						"color",
+						"w"
+					],
+					"*",
+					"reveal"
+				]
+			]
+		]]]]
+	},
+	externals: { "d.vec4f": () => vec4f }
+}) && $.f)({}));
+const directionalCoord = typegpu_default.fn([
+	vec2f,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, angleDeg) => {
+	"use gpu";
+	const a = __tsover_mul(angleDeg, DEG_TO_RAD);
+	const dir = vec2f(cos(a), sin(a));
+	const grad = dot(vec2f(__tsover_mul(__tsover_sub(uv.x, .5), aspect), __tsover_sub(uv.y, .5)), dir);
+	const ext = __tsover_mul(.5, __tsover_add(__tsover_mul(aspect, abs(dir.x)), abs(dir.y)));
+	return __tsover_add(__tsover_div(grad, __tsover_mul(2, ext)), .5);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "uv"
+			},
+			{
+				"type": "i",
+				"name": "aspect"
+			},
+			{
+				"type": "i",
+				"name": "angleDeg"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"a",
+				[
+					1,
+					"angleDeg",
+					"*",
+					"DEG_TO_RAD"
+				]
+			],
+			[
+				13,
+				"dir",
+				[
+					6,
+					"d.vec2f",
+					[[
+						6,
+						"std.cos",
+						["a"]
+					], [
+						6,
+						"std.sin",
+						["a"]
+					]]
+				]
+			],
+			[
+				13,
+				"p",
+				[
+					6,
+					"d.vec2f",
+					[[
+						1,
+						[
+							1,
+							[
+								7,
+								"uv",
+								"x"
+							],
+							"-",
+							[5, "0.5"]
+						],
+						"*",
+						"aspect"
+					], [
+						1,
+						[
+							7,
+							"uv",
+							"y"
+						],
+						"-",
+						[5, "0.5"]
+					]]
+				]
+			],
+			[
+				13,
+				"grad",
+				[
+					6,
+					"std.dot",
+					["p", "dir"]
+				]
+			],
+			[
+				13,
+				"ext",
+				[
+					1,
+					[5, "0.5"],
+					"*",
+					[
+						1,
+						[
+							1,
+							"aspect",
+							"*",
+							[
+								6,
+								"std.abs",
+								[[
+									7,
+									"dir",
+									"x"
+								]]
+							]
+						],
+						"+",
+						[
+							6,
+							"std.abs",
+							[[
+								7,
+								"dir",
+								"y"
+							]]
+						]
+					]
+				]
+			],
+			[10, [
+				1,
+				[
+					1,
+					"grad",
+					"/",
+					[
+						1,
+						[5, "2"],
+						"*",
+						"ext"
+					]
+				],
+				"+",
+				[5, "0.5"]
+			]]
+		]]
+	},
+	externals: {
+		"DEG_TO_RAD": () => DEG_TO_RAD,
+		"d.vec2f": () => vec2f,
+		"std.cos": () => cos,
+		"std.sin": () => sin,
+		"std.dot": () => dot,
+		"std.abs": () => abs
+	}
+}) && $.f)({}));
+const radialCornerNormCoord = typegpu_default.fn([
+	vec2f,
+	f32,
+	vec2f
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, center) => {
+	"use gpu";
+	const cx = __tsover_mul(center.x, aspect);
+	const cy = __tsover_sub(1, center.y);
+	const dist = length(vec2f(__tsover_sub(__tsover_mul(uv.x, aspect), cx), __tsover_sub(uv.y, cy)));
+	const maxDist = length(vec2f(max(cx, __tsover_sub(aspect, cx)), max(cy, __tsover_sub(1, cy))));
+	return __tsover_div(dist, max(maxDist, 1e-4));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "uv"
+			},
+			{
+				"type": "i",
+				"name": "aspect"
+			},
+			{
+				"type": "i",
+				"name": "center"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"cx",
+				[
+					1,
+					[
+						7,
+						"center",
+						"x"
+					],
+					"*",
+					"aspect"
+				]
+			],
+			[
+				13,
+				"cy",
+				[
+					1,
+					[5, "1"],
+					"-",
+					[
+						7,
+						"center",
+						"y"
+					]
+				]
+			],
+			[
+				13,
+				"rel",
+				[
+					6,
+					"d.vec2f",
+					[[
+						1,
+						[
+							1,
+							[
+								7,
+								"uv",
+								"x"
+							],
+							"*",
+							"aspect"
+						],
+						"-",
+						"cx"
+					], [
+						1,
+						[
+							7,
+							"uv",
+							"y"
+						],
+						"-",
+						"cy"
+					]]
+				]
+			],
+			[
+				13,
+				"dist",
+				[
+					6,
+					"std.length",
+					["rel"]
+				]
+			],
+			[
+				13,
+				"dx",
+				[
+					6,
+					"std.max",
+					["cx", [
+						1,
+						"aspect",
+						"-",
+						"cx"
+					]]
+				]
+			],
+			[
+				13,
+				"dy",
+				[
+					6,
+					"std.max",
+					["cy", [
+						1,
+						[5, "1"],
+						"-",
+						"cy"
+					]]
+				]
+			],
+			[
+				13,
+				"maxDist",
+				[
+					6,
+					"std.length",
+					[[
+						6,
+						"d.vec2f",
+						["dx", "dy"]
+					]]
+				]
+			],
+			[10, [
+				1,
+				"dist",
+				"/",
+				[
+					6,
+					"std.max",
+					["maxDist", [5, "0.0001"]]
+				]
+			]]
+		]]
+	},
+	externals: {
+		"d.vec2f": () => vec2f,
+		"std.length": () => length,
+		"std.max": () => max
+	}
+}) && $.f)({}));
+const angularCoord = typegpu_default.fn([
+	vec2f,
+	f32,
+	vec2f,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, center, startDeg, mode) => {
+	"use gpu";
+	const rel = vec2f(__tsover_mul(__tsover_sub(uv.x, center.x), aspect), __tsover_sub(uv.y, __tsover_sub(1, center.y)));
+	const ang = atan2(rel.y, rel.x);
+	const start = __tsover_mul(startDeg, DEG_TO_RAD);
+	let frac = __tsover_div(__tsover_sub(ang, start), TWO_PI);
+	frac = __tsover_sub(frac, floor(frac));
+	const ccwCoord = __tsover_sub(1, frac);
+	const bothCoord = __tsover_mul(min(frac, __tsover_sub(1, frac)), 2);
+	let coord = select(frac, ccwCoord, mode > .5);
+	coord = select(coord, bothCoord, mode > 1.5);
+	return coord;
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "uv"
+			},
+			{
+				"type": "i",
+				"name": "aspect"
+			},
+			{
+				"type": "i",
+				"name": "center"
+			},
+			{
+				"type": "i",
+				"name": "startDeg"
+			},
+			{
+				"type": "i",
+				"name": "mode"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"rel",
+				[
+					6,
+					"d.vec2f",
+					[[
+						1,
+						[
+							1,
+							[
+								7,
+								"uv",
+								"x"
+							],
+							"-",
+							[
+								7,
+								"center",
+								"x"
+							]
+						],
+						"*",
+						"aspect"
+					], [
+						1,
+						[
+							7,
+							"uv",
+							"y"
+						],
+						"-",
+						[
+							1,
+							[5, "1"],
+							"-",
+							[
+								7,
+								"center",
+								"y"
+							]
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"ang",
+				[
+					6,
+					"std.atan2",
+					[[
+						7,
+						"rel",
+						"y"
+					], [
+						7,
+						"rel",
+						"x"
+					]]
+				]
+			],
+			[
+				13,
+				"start",
+				[
+					1,
+					"startDeg",
+					"*",
+					"DEG_TO_RAD"
+				]
+			],
+			[
+				12,
+				"frac",
+				[
+					1,
+					[
+						1,
+						"ang",
+						"-",
+						"start"
+					],
+					"/",
+					"TWO_PI"
+				]
+			],
+			[
+				2,
+				"frac",
+				"=",
+				[
+					1,
+					"frac",
+					"-",
+					[
+						6,
+						"std.floor",
+						["frac"]
+					]
+				]
+			],
+			[
+				13,
+				"ccwCoord",
+				[
+					1,
+					[5, "1"],
+					"-",
+					"frac"
+				]
+			],
+			[
+				13,
+				"bothCoord",
+				[
+					1,
+					[
+						6,
+						"std.min",
+						["frac", [
+							1,
+							[5, "1"],
+							"-",
+							"frac"
+						]]
+					],
+					"*",
+					[5, "2"]
+				]
+			],
+			[
+				12,
+				"coord",
+				[
+					6,
+					"std.select",
+					[
+						"frac",
+						"ccwCoord",
+						[
+							1,
+							"mode",
+							">",
+							[5, "0.5"]
+						]
+					]
+				]
+			],
+			[
+				2,
+				"coord",
+				"=",
+				[
+					6,
+					"std.select",
+					[
+						"coord",
+						"bothCoord",
+						[
+							1,
+							"mode",
+							">",
+							[5, "1.5"]
+						]
+					]
+				]
+			],
+			[10, "coord"]
+		]]
+	},
+	externals: {
+		"d.vec2f": () => vec2f,
+		"std.atan2": () => atan2,
+		"DEG_TO_RAD": () => DEG_TO_RAD,
+		"TWO_PI": () => TWO_PI,
+		"std.floor": () => floor,
+		"std.min": () => min,
+		"std.select": () => select
+	}
+}) && $.f)({}));
+const CellGrid = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
+	cell: vec2f,
+	local: vec2f,
+	grid: vec2f
+}), "CellGrid");
+const cellGrid = typegpu_default.fn([
+	vec2f,
+	f32,
+	f32
+], CellGrid)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, size) => {
+	"use gpu";
+	const gridX = __tsover_div(1, max(size, .001));
+	const gridY = max(__tsover_div(gridX, aspect), 1);
+	const sx = __tsover_mul(uv.x, gridX);
+	const sy = __tsover_mul(uv.y, gridY);
+	return CellGrid({
+		cell: vec2f(floor(sx), floor(sy)),
+		local: vec2f(fract(sx), fract(sy)),
+		grid: vec2f(gridX, gridY)
+	});
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "uv"
+			},
+			{
+				"type": "i",
+				"name": "aspect"
+			},
+			{
+				"type": "i",
+				"name": "size"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"gridX",
+				[
+					1,
+					[5, "1"],
+					"/",
+					[
+						6,
+						"std.max",
+						["size", [5, "0.001"]]
+					]
+				]
+			],
+			[
+				13,
+				"gridY",
+				[
+					6,
+					"std.max",
+					[[
+						1,
+						"gridX",
+						"/",
+						"aspect"
+					], [5, "1"]]
+				]
+			],
+			[
+				13,
+				"sx",
+				[
+					1,
+					[
+						7,
+						"uv",
+						"x"
+					],
+					"*",
+					"gridX"
+				]
+			],
+			[
+				13,
+				"sy",
+				[
+					1,
+					[
+						7,
+						"uv",
+						"y"
+					],
+					"*",
+					"gridY"
+				]
+			],
+			[10, [
+				6,
+				"CellGrid",
+				[[104, {
+					"cell": [
+						6,
+						"d.vec2f",
+						[[
+							6,
+							"std.floor",
+							["sx"]
+						], [
+							6,
+							"std.floor",
+							["sy"]
+						]]
+					],
+					"local": [
+						6,
+						"d.vec2f",
+						[[
+							6,
+							"std.fract",
+							["sx"]
+						], [
+							6,
+							"std.fract",
+							["sy"]
+						]]
+					],
+					"grid": [
+						6,
+						"d.vec2f",
+						["gridX", "gridY"]
+					]
+				}]]
+			]]
+		]]
+	},
+	externals: {
+		"std.max": () => max,
+		"CellGrid": () => CellGrid,
+		"d.vec2f": () => vec2f,
+		"std.floor": () => floor,
+		"std.fract": () => fract
+	}
+}) && $.f)({}));
+const foldAboutCenter = typegpu_default.fn([f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((t) => {
+	"use gpu";
+	return __tsover_mul(abs(__tsover_sub(t, .5)), 2);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "t"
+		}],
+		"body": [0, [[10, [
+			1,
+			[
+				6,
+				"std.abs",
+				[[
+					1,
+					"t",
+					"-",
+					[5, "0.5"]
+				]]
+			],
+			"*",
+			[5, "2"]
+		]]]]
+	},
+	externals: { "std.abs": () => abs }
+}) && $.f)({}));
+const tilePhase = typegpu_default.fn([f32, f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((t, count) => {
+	"use gpu";
+	return fract(__tsover_mul(t, count));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "t"
+		}, {
+			"type": "i",
+			"name": "count"
+		}],
+		"body": [0, [[10, [
+			6,
+			"std.fract",
+			[[
+				1,
+				"t",
+				"*",
+				"count"
+			]]
+		]]]]
+	},
+	externals: { "std.fract": () => fract }
+}) && $.f)({}));
+const bandMidpointCoord = typegpu_default.fn([f32, f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((t, count) => {
+	"use gpu";
+	const n = max(count, 1);
+	return clamp(__tsover_div(__tsover_add(floor(__tsover_mul(t, n)), .5), n), 0, 1);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "t"
+		}, {
+			"type": "i",
+			"name": "count"
+		}],
+		"body": [0, [[
+			13,
+			"n",
+			[
+				6,
+				"std.max",
+				["count", [5, "1"]]
+			]
+		], [10, [
+			6,
+			"std.clamp",
+			[
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							"std.floor",
+							[[
+								1,
+								"t",
+								"*",
+								"n"
+							]]
+						],
+						"+",
+						[5, "0.5"]
+					],
+					"/",
+					"n"
+				],
+				[5, "0"],
+				[5, "1"]
+			]
+		]]]]
+	},
+	externals: {
+		"std.max": () => max,
+		"std.clamp": () => clamp,
+		"std.floor": () => floor
+	}
+}) && $.f)({}));
+const bandShuffleCoord = typegpu_default.fn([f32, f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((t, count) => {
+	"use gpu";
+	const idx = floor(__tsover_mul(t, max(count, 1)));
+	return hash11(__tsover_add(idx, .5));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "t"
+		}, {
+			"type": "i",
+			"name": "count"
+		}],
+		"body": [0, [[
+			13,
+			"idx",
+			[
+				6,
+				"std.floor",
+				[[
+					1,
+					"t",
+					"*",
+					[
+						6,
+						"std.max",
+						["count", [5, "1"]]
+					]
+				]]
+			]
+		], [10, [
+			6,
+			"hash11",
+			[[
+				1,
+				"idx",
+				"+",
+				[5, "0.5"]
+			]]
+		]]]]
+	},
+	externals: {
+		"std.floor": () => floor,
+		"std.max": () => max,
+		"hash11": () => hash11
+	}
+}) && $.f)({}));
+const cellDiamondCoord = typegpu_default.fn([
+	vec2f,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, size) => {
+	"use gpu";
+	const g = cellGrid(uv, aspect, size);
+	return __tsover_add(abs(__tsover_sub(g.local.x, .5)), abs(__tsover_sub(g.local.y, .5)));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "uv"
+			},
+			{
+				"type": "i",
+				"name": "aspect"
+			},
+			{
+				"type": "i",
+				"name": "size"
+			}
+		],
+		"body": [0, [[
+			13,
+			"g",
+			[
+				6,
+				"cellGrid",
+				[
+					"uv",
+					"aspect",
+					"size"
+				]
+			]
+		], [10, [
+			1,
+			[
+				6,
+				"std.abs",
+				[[
+					1,
+					[
+						7,
+						[
+							7,
+							"g",
+							"local"
+						],
+						"x"
+					],
+					"-",
+					[5, "0.5"]
+				]]
+			],
+			"+",
+			[
+				6,
+				"std.abs",
+				[[
+					1,
+					[
+						7,
+						[
+							7,
+							"g",
+							"local"
+						],
+						"y"
+					],
+					"-",
+					[5, "0.5"]
+				]]
+			]
+		]]]]
+	},
+	externals: {
+		"cellGrid": () => cellGrid,
+		"std.abs": () => abs
+	}
+}) && $.f)({}));
+const cellCheckerCoord = typegpu_default.fn([
+	vec2f,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, size) => {
+	"use gpu";
+	const g = cellGrid(uv, aspect, size);
+	const parity = __tsover_mul(fract(__tsover_mul(__tsover_add(g.cell.x, g.cell.y), .5)), 2);
+	const diag = __tsover_mul(__tsover_add(__tsover_div(g.cell.x, g.grid.x), __tsover_div(g.cell.y, g.grid.y)), .5);
+	return clamp(__tsover_add(__tsover_mul(.5, parity), __tsover_mul(.5, diag)), 0, 1);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "uv"
+			},
+			{
+				"type": "i",
+				"name": "aspect"
+			},
+			{
+				"type": "i",
+				"name": "size"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"g",
+				[
+					6,
+					"cellGrid",
+					[
+						"uv",
+						"aspect",
+						"size"
+					]
+				]
+			],
+			[
+				13,
+				"parity",
+				[
+					1,
+					[
+						6,
+						"std.fract",
+						[[
+							1,
+							[
+								1,
+								[
+									7,
+									[
+										7,
+										"g",
+										"cell"
+									],
+									"x"
+								],
+								"+",
+								[
+									7,
+									[
+										7,
+										"g",
+										"cell"
+									],
+									"y"
+								]
+							],
+							"*",
+							[5, "0.5"]
+						]]
+					],
+					"*",
+					[5, "2"]
+				]
+			],
+			[
+				13,
+				"diag",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								7,
+								[
+									7,
+									"g",
+									"cell"
+								],
+								"x"
+							],
+							"/",
+							[
+								7,
+								[
+									7,
+									"g",
+									"grid"
+								],
+								"x"
+							]
+						],
+						"+",
+						[
+							1,
+							[
+								7,
+								[
+									7,
+									"g",
+									"cell"
+								],
+								"y"
+							],
+							"/",
+							[
+								7,
+								[
+									7,
+									"g",
+									"grid"
+								],
+								"y"
+							]
+						]
+					],
+					"*",
+					[5, "0.5"]
+				]
+			],
+			[10, [
+				6,
+				"std.clamp",
+				[
+					[
+						1,
+						[
+							1,
+							[5, "0.5"],
+							"*",
+							"parity"
+						],
+						"+",
+						[
+							1,
+							[5, "0.5"],
+							"*",
+							"diag"
+						]
+					],
+					[5, "0"],
+					[5, "1"]
+				]
+			]]
+		]]
+	},
+	externals: {
+		"cellGrid": () => cellGrid,
+		"std.fract": () => fract,
+		"std.clamp": () => clamp
+	}
+}) && $.f)({}));
+const cellShuffleCoord = typegpu_default.fn([
+	vec2f,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, size) => {
+	"use gpu";
+	return hash12(cellGrid(uv, aspect, size).cell);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "uv"
+			},
+			{
+				"type": "i",
+				"name": "aspect"
+			},
+			{
+				"type": "i",
+				"name": "size"
+			}
+		],
+		"body": [0, [[10, [
+			6,
+			"hash12",
+			[[
+				7,
+				[
+					6,
+					"cellGrid",
+					[
+						"uv",
+						"aspect",
+						"size"
+					]
+				],
+				"cell"
+			]]
+		]]]]
+	},
+	externals: {
+		"hash12": () => hash12,
+		"cellGrid": () => cellGrid
+	}
+}) && $.f)({}));
+const fbmCoverageCoord = typegpu_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, scale, seed) => {
+	"use gpu";
+	const p = vec2f(__tsover_add(__tsover_mul(__tsover_mul(uv.x, aspect), scale), __tsover_mul(seed, 13.7)), __tsover_add(__tsover_mul(uv.y, scale), __tsover_mul(seed, 7.9)));
+	const n1 = mxNoiseFloat2(p);
+	const n2 = __tsover_mul(mxNoiseFloat2(vec2f(__tsover_add(__tsover_add(__tsover_mul(p.x, 2), 17.3), __tsover_mul(seed, 3.1)), __tsover_add(__tsover_mul(p.y, 2), 9.1))), .5);
+	const n3 = __tsover_mul(mxNoiseFloat2(vec2f(__tsover_add(__tsover_mul(p.x, 4), 41.7), __tsover_add(__tsover_add(__tsover_mul(p.y, 4), 27.9), __tsover_mul(seed, 5.3)))), .25);
+	const n = __tsover_div(__tsover_add(__tsover_add(n1, n2), n3), 1.75);
+	return clamp(__tsover_add(.5, __tsover_mul(n, .9)), 0, 1);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "uv"
+			},
+			{
+				"type": "i",
+				"name": "aspect"
+			},
+			{
+				"type": "i",
+				"name": "scale"
+			},
+			{
+				"type": "i",
+				"name": "seed"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"p",
+				[
+					6,
+					"d.vec2f",
+					[[
+						1,
+						[
+							1,
+							[
+								1,
+								[
+									7,
+									"uv",
+									"x"
+								],
+								"*",
+								"aspect"
+							],
+							"*",
+							"scale"
+						],
+						"+",
+						[
+							1,
+							"seed",
+							"*",
+							[5, "13.7"]
+						]
+					], [
+						1,
+						[
+							1,
+							[
+								7,
+								"uv",
+								"y"
+							],
+							"*",
+							"scale"
+						],
+						"+",
+						[
+							1,
+							"seed",
+							"*",
+							[5, "7.9"]
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"n1",
+				[
+					6,
+					"mxNoiseFloat2",
+					["p"]
+				]
+			],
+			[
+				13,
+				"n2",
+				[
+					1,
+					[
+						6,
+						"mxNoiseFloat2",
+						[[
+							6,
+							"d.vec2f",
+							[[
+								1,
+								[
+									1,
+									[
+										1,
+										[
+											7,
+											"p",
+											"x"
+										],
+										"*",
+										[5, "2"]
+									],
+									"+",
+									[5, "17.3"]
+								],
+								"+",
+								[
+									1,
+									"seed",
+									"*",
+									[5, "3.1"]
+								]
+							], [
+								1,
+								[
+									1,
+									[
+										7,
+										"p",
+										"y"
+									],
+									"*",
+									[5, "2"]
+								],
+								"+",
+								[5, "9.1"]
+							]]
+						]]
+					],
+					"*",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"n3",
+				[
+					1,
+					[
+						6,
+						"mxNoiseFloat2",
+						[[
+							6,
+							"d.vec2f",
+							[[
+								1,
+								[
+									1,
+									[
+										7,
+										"p",
+										"x"
+									],
+									"*",
+									[5, "4"]
+								],
+								"+",
+								[5, "41.7"]
+							], [
+								1,
+								[
+									1,
+									[
+										1,
+										[
+											7,
+											"p",
+											"y"
+										],
+										"*",
+										[5, "4"]
+									],
+									"+",
+									[5, "27.9"]
+								],
+								"+",
+								[
+									1,
+									"seed",
+									"*",
+									[5, "5.3"]
+								]
+							]]
+						]]
+					],
+					"*",
+					[5, "0.25"]
+				]
+			],
+			[
+				13,
+				"n",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							"n1",
+							"+",
+							"n2"
+						],
+						"+",
+						"n3"
+					],
+					"/",
+					[5, "1.75"]
+				]
+			],
+			[10, [
+				6,
+				"std.clamp",
+				[
+					[
+						1,
+						[5, "0.5"],
+						"+",
+						[
+							1,
+							"n",
+							"*",
+							[5, "0.9"]
+						]
+					],
+					[5, "0"],
+					[5, "1"]
+				]
+			]]
+		]]
+	},
+	externals: {
+		"d.vec2f": () => vec2f,
+		"mxNoiseFloat2": () => mxNoiseFloat2,
+		"std.clamp": () => clamp
+	}
+}) && $.f)({}));
+var Coverage = class Coverage {
+	constructor(build) {
+		this.build = build;
+	}
+	folded() {
+		return new Coverage((params) => call(foldAboutCenter, "foldAboutCenter", [this.build(params)]));
+	}
+	tiled(count) {
+		return new Coverage((params) => call(tilePhase, "tilePhase", [this.build(params), resolveArg(count, params)]));
+	}
+	bands(count) {
+		return new BandedCoverage(this, count);
+	}
+};
+var BandedCoverage = class extends Coverage {
+	constructor(base, count) {
+		super((params) => call(bandMidpointCoord, "bandMidpointCoord", [base.build(params), resolveArg(count, params)]));
+		this.base = base;
+		this.count = count;
+	}
+	base;
+	count;
+	shuffled() {
+		return new Coverage((params) => call(bandShuffleCoord, "bandShuffleCoord", [this.base.build(params), resolveArg(this.count, params)]));
+	}
+};
+var CellCoverage = class {
+	constructor(size) {
+		this.size = size;
+	}
+	diamond() {
+		return new Coverage((params) => call(cellDiamondCoord, "cellDiamondCoord", [
+			params.ctx.uv,
+			params.ctx.aspect,
+			resolveArg(this.size, params)
+		]));
+	}
+	checker() {
+		return new Coverage((params) => call(cellCheckerCoord, "cellCheckerCoord", [
+			params.ctx.uv,
+			params.ctx.aspect,
+			resolveArg(this.size, params)
+		]));
+	}
+	shuffled() {
+		return new Coverage((params) => call(cellShuffleCoord, "cellShuffleCoord", [
+			params.ctx.uv,
+			params.ctx.aspect,
+			resolveArg(this.size, params)
+		]));
+	}
+};
+var ANGULAR_MODES = {
+	cw: 0,
+	ccw: 1,
+	both: 2
+};
+const coverage = {
+	directional(angleDeg) {
+		return new Coverage((params) => call(directionalCoord, "directionalCoord", [
+			params.ctx.uv,
+			params.ctx.aspect,
+			resolveArg(angleDeg, params)
+		]));
+	},
+	radial(center) {
+		return new Coverage((params) => call(radialCornerNormCoord, "radialCornerNormCoord", [
+			params.ctx.uv,
+			params.ctx.aspect,
+			resolveArg(center, params)
+		]));
+	},
+	angular(center, startDeg, direction) {
+		return new Coverage((params) => {
+			const mode = ANGULAR_MODES[typeof direction === "string" ? direction : params.propValues[direction.name] ?? "cw"] ?? 0;
+			return call(angularCoord, "angularCoord", [
+				params.ctx.uv,
+				params.ctx.aspect,
+				resolveArg(center, params),
+				resolveArg(startDeg, params),
+				floatE(mode)
+			]);
+		});
+	},
+	cells(size) {
+		return new CellCoverage(size);
+	},
+	noise(scale, seed) {
+		return new Coverage((params) => call(fbmCoverageCoord, "fbmCoverageCoord", [
+			params.ctx.uv,
+			params.ctx.aspect,
+			resolveArg(scale, params),
+			resolveArg(seed, params)
+		]));
+	}
+};
+function reveal(slots) {
+	return {
+		kind: "pointwise",
+		body: {
+			fn: applyReveal,
+			hint: "applyReveal"
+		},
+		args: (params) => [call(revealMask, "revealMask", [
+			slots.coverage.build(params),
+			resolveArg(slots.progress, params),
+			resolveArg(slots.feather, params),
+			resolveArg(slots.invert, params)
+		])]
+	};
+}
+export { reveal as n, coverage as t };