shaders 3.2.474 → 4.0.0

package/dist/core/reveal-CfaAg-rg.js

@@ -1,1688 +0,0 @@
-import { Bn as TWO_PI, Br as struct, Cr as sin, Gn as typegpu_default, Mr as vec4f, Or as vec2f, Pn as DEG_TO_RAD, Sn as mxNoiseFloat2, _n as hash11, ar as clamp, cr as dot, ct as call, er as select, fr as floor, ft as floatE, gr as min, hr as max, i as resolveArg, mr as length, or as cos, pr as fract, qr as f32, rr as atan2, tr as abs, vn as hash12, wr as smoothstep } from "./lower-Bd2jez_2.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 };