shaders 3.2.474 → 4.0.0

package/dist/core/color-Do6tU0ry.js

@@ -1,3619 +0,0 @@
-import { Cr as sin, Ct as linearToSrgb, Gn as typegpu_default, It as mixColorsLinear, Lt as mixColorsVariants, Mr as vec4f, Or as vec2f, Pn as DEG_TO_RAD, Qn as fwidth, Rn as SQRT3, Tt as srgbToLinear, _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, gt as formatFloat, hr as max, i as resolveArg, jr as vec3f, mt as vec4, o as uniformOf, or as cos, pr as fract, qr as f32, r as pointwiseOp, tr as abs, vn as hash12, wr as smoothstep, yr as pow, zn as TAU } from "./lower-Bd2jez_2.js";
-import { n as luma709Dot } from "./tone-BKhfiOBn.js";
-var TWO_PI = TAU;
-const hueRotate$1 = typegpu_default.fn([vec4f, f32], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, shiftDeg) => {
-	"use gpu";
-	const angle = __tsover_mul(shiftDeg, DEG_TO_RAD);
-	const cosA = cos(angle);
-	const sinA = sin(angle);
-	const k = __tsover_div(1, 3);
-	const oneMinusCos = __tsover_sub(1, cosA);
-	const kOneMinusCos = __tsover_mul(oneMinusCos, k);
-	const sinOverSqrt3 = __tsover_div(sinA, SQRT3);
-	const m00 = __tsover_add(cosA, kOneMinusCos);
-	const m01 = __tsover_sub(kOneMinusCos, sinOverSqrt3);
-	const m02 = __tsover_add(kOneMinusCos, sinOverSqrt3);
-	const m10 = __tsover_add(kOneMinusCos, sinOverSqrt3);
-	const m11 = __tsover_add(cosA, kOneMinusCos);
-	const m12 = __tsover_sub(kOneMinusCos, sinOverSqrt3);
-	const m20 = __tsover_sub(kOneMinusCos, sinOverSqrt3);
-	const m21 = __tsover_add(kOneMinusCos, sinOverSqrt3);
-	const m22 = __tsover_add(cosA, kOneMinusCos);
-	const r = color.x;
-	const g = color.y;
-	const b = color.z;
-	return vec4f(__tsover_add(__tsover_add(__tsover_mul(r, m00), __tsover_mul(g, m01)), __tsover_mul(b, m02)), __tsover_add(__tsover_add(__tsover_mul(r, m10), __tsover_mul(g, m11)), __tsover_mul(b, m12)), __tsover_add(__tsover_add(__tsover_mul(r, m20), __tsover_mul(g, m21)), __tsover_mul(b, m22)), color.w);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "color"
-		}, {
-			"type": "i",
-			"name": "shiftDeg"
-		}],
-		"body": [0, [
-			[
-				13,
-				"angle",
-				[
-					1,
-					"shiftDeg",
-					"*",
-					"DEG_TO_RAD"
-				]
-			],
-			[
-				13,
-				"cosA",
-				[
-					6,
-					"std.cos",
-					["angle"]
-				]
-			],
-			[
-				13,
-				"sinA",
-				[
-					6,
-					"std.sin",
-					["angle"]
-				]
-			],
-			[
-				13,
-				"k",
-				[
-					1,
-					[5, "1"],
-					"/",
-					[5, "3"]
-				]
-			],
-			[
-				13,
-				"oneMinusCos",
-				[
-					1,
-					[5, "1"],
-					"-",
-					"cosA"
-				]
-			],
-			[
-				13,
-				"kOneMinusCos",
-				[
-					1,
-					"oneMinusCos",
-					"*",
-					"k"
-				]
-			],
-			[
-				13,
-				"sinOverSqrt3",
-				[
-					1,
-					"sinA",
-					"/",
-					"SQRT3"
-				]
-			],
-			[
-				13,
-				"m00",
-				[
-					1,
-					"cosA",
-					"+",
-					"kOneMinusCos"
-				]
-			],
-			[
-				13,
-				"m01",
-				[
-					1,
-					"kOneMinusCos",
-					"-",
-					"sinOverSqrt3"
-				]
-			],
-			[
-				13,
-				"m02",
-				[
-					1,
-					"kOneMinusCos",
-					"+",
-					"sinOverSqrt3"
-				]
-			],
-			[
-				13,
-				"m10",
-				[
-					1,
-					"kOneMinusCos",
-					"+",
-					"sinOverSqrt3"
-				]
-			],
-			[
-				13,
-				"m11",
-				[
-					1,
-					"cosA",
-					"+",
-					"kOneMinusCos"
-				]
-			],
-			[
-				13,
-				"m12",
-				[
-					1,
-					"kOneMinusCos",
-					"-",
-					"sinOverSqrt3"
-				]
-			],
-			[
-				13,
-				"m20",
-				[
-					1,
-					"kOneMinusCos",
-					"-",
-					"sinOverSqrt3"
-				]
-			],
-			[
-				13,
-				"m21",
-				[
-					1,
-					"kOneMinusCos",
-					"+",
-					"sinOverSqrt3"
-				]
-			],
-			[
-				13,
-				"m22",
-				[
-					1,
-					"cosA",
-					"+",
-					"kOneMinusCos"
-				]
-			],
-			[
-				13,
-				"r",
-				[
-					7,
-					"color",
-					"x"
-				]
-			],
-			[
-				13,
-				"g",
-				[
-					7,
-					"color",
-					"y"
-				]
-			],
-			[
-				13,
-				"b",
-				[
-					7,
-					"color",
-					"z"
-				]
-			],
-			[
-				13,
-				"newR",
-				[
-					1,
-					[
-						1,
-						[
-							1,
-							"r",
-							"*",
-							"m00"
-						],
-						"+",
-						[
-							1,
-							"g",
-							"*",
-							"m01"
-						]
-					],
-					"+",
-					[
-						1,
-						"b",
-						"*",
-						"m02"
-					]
-				]
-			],
-			[
-				13,
-				"newG",
-				[
-					1,
-					[
-						1,
-						[
-							1,
-							"r",
-							"*",
-							"m10"
-						],
-						"+",
-						[
-							1,
-							"g",
-							"*",
-							"m11"
-						]
-					],
-					"+",
-					[
-						1,
-						"b",
-						"*",
-						"m12"
-					]
-				]
-			],
-			[
-				13,
-				"newB",
-				[
-					1,
-					[
-						1,
-						[
-							1,
-							"r",
-							"*",
-							"m20"
-						],
-						"+",
-						[
-							1,
-							"g",
-							"*",
-							"m21"
-						]
-					],
-					"+",
-					[
-						1,
-						"b",
-						"*",
-						"m22"
-					]
-				]
-			],
-			[10, [
-				6,
-				"d.vec4f",
-				[
-					"newR",
-					"newG",
-					"newB",
-					[
-						7,
-						"color",
-						"w"
-					]
-				]
-			]]
-		]]
-	},
-	externals: {
-		"DEG_TO_RAD": () => DEG_TO_RAD,
-		"std.cos": () => cos,
-		"std.sin": () => sin,
-		"SQRT3": () => SQRT3,
-		"d.vec4f": () => vec4f
-	}
-}) && $.f)({}));
-const saturate$1 = typegpu_default.fn([vec4f, f32], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, intensity) => {
-	"use gpu";
-	const rgb = vec3f(color.x, color.y, color.z);
-	const luminance = dot(rgb, vec3f(.2126, .7152, .0722));
-	const saturated = mix(vec3f(luminance, luminance, luminance), rgb, vec3f(intensity));
-	return vec4f(saturated.x, saturated.y, saturated.z, color.w);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "color"
-		}, {
-			"type": "i",
-			"name": "intensity"
-		}],
-		"body": [0, [
-			[
-				13,
-				"rgb",
-				[
-					6,
-					"d.vec3f",
-					[
-						[
-							7,
-							"color",
-							"x"
-						],
-						[
-							7,
-							"color",
-							"y"
-						],
-						[
-							7,
-							"color",
-							"z"
-						]
-					]
-				]
-			],
-			[
-				13,
-				"luminance",
-				[
-					6,
-					"std.dot",
-					["rgb", [
-						6,
-						"d.vec3f",
-						[
-							[5, "0.2126"],
-							[5, "0.7152"],
-							[5, "0.0722"]
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"gray",
-				[
-					6,
-					"d.vec3f",
-					[
-						"luminance",
-						"luminance",
-						"luminance"
-					]
-				]
-			],
-			[
-				13,
-				"saturated",
-				[
-					6,
-					"std.mix",
-					[
-						"gray",
-						"rgb",
-						[
-							6,
-							"d.vec3f",
-							["intensity"]
-						]
-					]
-				]
-			],
-			[10, [
-				6,
-				"d.vec4f",
-				[
-					[
-						7,
-						"saturated",
-						"x"
-					],
-					[
-						7,
-						"saturated",
-						"y"
-					],
-					[
-						7,
-						"saturated",
-						"z"
-					],
-					[
-						7,
-						"color",
-						"w"
-					]
-				]
-			]]
-		]]
-	},
-	externals: {
-		"d.vec3f": () => vec3f,
-		"std.dot": () => dot,
-		"std.mix": () => mix,
-		"d.vec4f": () => vec4f
-	}
-}) && $.f)({}));
-const vibrance$1 = typegpu_default.fn([vec4f, f32], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, adjustment) => {
-	"use gpu";
-	const r = color.x;
-	const g = color.y;
-	const b = color.z;
-	const average = __tsover_div(__tsover_add(__tsover_add(r, g), b), 3);
-	const mx = max(r, max(g, b));
-	const amt = __tsover_mul(__tsover_mul(__tsover_sub(mx, average), adjustment), -3);
-	const vibrant = mix(vec3f(r, g, b), vec3f(mx, mx, mx), vec3f(amt));
-	return vec4f(vibrant.x, vibrant.y, vibrant.z, color.w);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "color"
-		}, {
-			"type": "i",
-			"name": "adjustment"
-		}],
-		"body": [0, [
-			[
-				13,
-				"r",
-				[
-					7,
-					"color",
-					"x"
-				]
-			],
-			[
-				13,
-				"g",
-				[
-					7,
-					"color",
-					"y"
-				]
-			],
-			[
-				13,
-				"b",
-				[
-					7,
-					"color",
-					"z"
-				]
-			],
-			[
-				13,
-				"average",
-				[
-					1,
-					[
-						1,
-						[
-							1,
-							"r",
-							"+",
-							"g"
-						],
-						"+",
-						"b"
-					],
-					"/",
-					[5, "3"]
-				]
-			],
-			[
-				13,
-				"mx",
-				[
-					6,
-					"std.max",
-					["r", [
-						6,
-						"std.max",
-						["g", "b"]
-					]]
-				]
-			],
-			[
-				13,
-				"amt",
-				[
-					1,
-					[
-						1,
-						[
-							1,
-							"mx",
-							"-",
-							"average"
-						],
-						"*",
-						"adjustment"
-					],
-					"*",
-					[
-						4,
-						"-",
-						[5, "3"]
-					]
-				]
-			],
-			[
-				13,
-				"rgb",
-				[
-					6,
-					"d.vec3f",
-					[
-						"r",
-						"g",
-						"b"
-					]
-				]
-			],
-			[
-				13,
-				"vibrant",
-				[
-					6,
-					"std.mix",
-					[
-						"rgb",
-						[
-							6,
-							"d.vec3f",
-							[
-								"mx",
-								"mx",
-								"mx"
-							]
-						],
-						[
-							6,
-							"d.vec3f",
-							["amt"]
-						]
-					]
-				]
-			],
-			[10, [
-				6,
-				"d.vec4f",
-				[
-					[
-						7,
-						"vibrant",
-						"x"
-					],
-					[
-						7,
-						"vibrant",
-						"y"
-					],
-					[
-						7,
-						"vibrant",
-						"z"
-					],
-					[
-						7,
-						"color",
-						"w"
-					]
-				]
-			]]
-		]]
-	},
-	externals: {
-		"std.max": () => max,
-		"d.vec3f": () => vec3f,
-		"std.mix": () => mix,
-		"d.vec4f": () => vec4f
-	}
-}) && $.f)({}));
-const brightnessContrast$1 = typegpu_default.fn([
-	vec4f,
-	f32,
-	f32
-], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, brightness, contrastRaw) => {
-	"use gpu";
-	const contrast = __tsover_add(contrastRaw, 1);
-	const half = vec3f(.5, .5, .5);
-	return vec4f(color.xyz.sub(half).mul(contrast).add(half).add(vec3f(brightness, brightness, brightness)), color.w);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "color"
-			},
-			{
-				"type": "i",
-				"name": "brightness"
-			},
-			{
-				"type": "i",
-				"name": "contrastRaw"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"contrast",
-				[
-					1,
-					"contrastRaw",
-					"+",
-					[5, "1"]
-				]
-			],
-			[
-				13,
-				"half",
-				[
-					6,
-					"d.vec3f",
-					[
-						[5, "0.5"],
-						[5, "0.5"],
-						[5, "0.5"]
-					]
-				]
-			],
-			[
-				13,
-				"contrasted",
-				[
-					6,
-					[
-						7,
-						[
-							6,
-							[
-								7,
-								[
-									6,
-									[
-										7,
-										[
-											7,
-											"color",
-											"xyz"
-										],
-										"sub"
-									],
-									["half"]
-								],
-								"mul"
-							],
-							["contrast"]
-						],
-						"add"
-					],
-					["half"]
-				]
-			],
-			[
-				13,
-				"result",
-				[
-					6,
-					[
-						7,
-						"contrasted",
-						"add"
-					],
-					[[
-						6,
-						"d.vec3f",
-						[
-							"brightness",
-							"brightness",
-							"brightness"
-						]
-					]]
-				]
-			],
-			[10, [
-				6,
-				"d.vec4f",
-				["result", [
-					7,
-					"color",
-					"w"
-				]]
-			]]
-		]]
-	},
-	externals: {
-		"d.vec3f": () => vec3f,
-		"d.vec4f": () => vec4f
-	}
-}) && $.f)({}));
-const exposure$1 = typegpu_default.fn([vec4f, f32], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, gain) => {
-	"use gpu";
-	return vec4f(color.xyz.mul(gain), color.w);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "color"
-		}, {
-			"type": "i",
-			"name": "gain"
-		}],
-		"body": [0, [[
-			13,
-			"rgb",
-			[
-				6,
-				[
-					7,
-					[
-						7,
-						"color",
-						"xyz"
-					],
-					"mul"
-				],
-				["gain"]
-			]
-		], [10, [
-			6,
-			"d.vec4f",
-			["rgb", [
-				7,
-				"color",
-				"w"
-			]]
-		]]]]
-	},
-	externals: { "d.vec4f": () => vec4f }
-}) && $.f)({}));
-const grayscale$1 = typegpu_default.fn([vec4f], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color) => {
-	"use gpu";
-	const luminance = dot(color.xyz, vec3f(.2126, .7152, .0722));
-	return vec4f(luminance, luminance, luminance, color.w);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "color"
-		}],
-		"body": [0, [[
-			13,
-			"luminance",
-			[
-				6,
-				"std.dot",
-				[[
-					7,
-					"color",
-					"xyz"
-				], [
-					6,
-					"d.vec3f",
-					[
-						[5, "0.2126"],
-						[5, "0.7152"],
-						[5, "0.0722"]
-					]
-				]]
-			]
-		], [10, [
-			6,
-			"d.vec4f",
-			[
-				"luminance",
-				"luminance",
-				"luminance",
-				[
-					7,
-					"color",
-					"w"
-				]
-			]
-		]]]]
-	},
-	externals: {
-		"std.dot": () => dot,
-		"d.vec3f": () => vec3f,
-		"d.vec4f": () => vec4f
-	}
-}) && $.f)({}));
-const invert$1 = typegpu_default.fn([vec4f], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color) => {
-	"use gpu";
-	return vec4f(__tsover_sub(1, color.x), __tsover_sub(1, color.y), __tsover_sub(1, color.z), color.w);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "color"
-		}],
-		"body": [0, [[10, [
-			6,
-			"d.vec4f",
-			[
-				[
-					1,
-					[5, "1"],
-					"-",
-					[
-						7,
-						"color",
-						"x"
-					]
-				],
-				[
-					1,
-					[5, "1"],
-					"-",
-					[
-						7,
-						"color",
-						"y"
-					]
-				],
-				[
-					1,
-					[5, "1"],
-					"-",
-					[
-						7,
-						"color",
-						"z"
-					]
-				],
-				[
-					7,
-					"color",
-					"w"
-				]
-			]
-		]]]]
-	},
-	externals: { "d.vec4f": () => vec4f }
-}) && $.f)({}));
-const solarize$1 = typegpu_default.fn([
-	vec4f,
-	f32,
-	f32
-], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, threshold, strength) => {
-	"use gpu";
-	const rgb = vec3f(color.x, color.y, color.z);
-	const luminance = dot(rgb, vec3f(.299, .587, .114));
-	const result = mix(rgb, select(rgb, vec3f(__tsover_sub(1, color.x), __tsover_sub(1, color.y), __tsover_sub(1, color.z)), luminance > threshold), vec3f(strength));
-	return vec4f(result.x, result.y, result.z, color.w);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "color"
-			},
-			{
-				"type": "i",
-				"name": "threshold"
-			},
-			{
-				"type": "i",
-				"name": "strength"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"rgb",
-				[
-					6,
-					"d.vec3f",
-					[
-						[
-							7,
-							"color",
-							"x"
-						],
-						[
-							7,
-							"color",
-							"y"
-						],
-						[
-							7,
-							"color",
-							"z"
-						]
-					]
-				]
-			],
-			[
-				13,
-				"luminance",
-				[
-					6,
-					"std.dot",
-					["rgb", [
-						6,
-						"d.vec3f",
-						[
-							[5, "0.299"],
-							[5, "0.587"],
-							[5, "0.114"]
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"inverted",
-				[
-					6,
-					"d.vec3f",
-					[
-						[
-							1,
-							[5, "1"],
-							"-",
-							[
-								7,
-								"color",
-								"x"
-							]
-						],
-						[
-							1,
-							[5, "1"],
-							"-",
-							[
-								7,
-								"color",
-								"y"
-							]
-						],
-						[
-							1,
-							[5, "1"],
-							"-",
-							[
-								7,
-								"color",
-								"z"
-							]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"solarized",
-				[
-					6,
-					"std.select",
-					[
-						"rgb",
-						"inverted",
-						[
-							1,
-							"luminance",
-							">",
-							"threshold"
-						]
-					]
-				]
-			],
-			[
-				13,
-				"result",
-				[
-					6,
-					"std.mix",
-					[
-						"rgb",
-						"solarized",
-						[
-							6,
-							"d.vec3f",
-							["strength"]
-						]
-					]
-				]
-			],
-			[10, [
-				6,
-				"d.vec4f",
-				[
-					[
-						7,
-						"result",
-						"x"
-					],
-					[
-						7,
-						"result",
-						"y"
-					],
-					[
-						7,
-						"result",
-						"z"
-					],
-					[
-						7,
-						"color",
-						"w"
-					]
-				]
-			]]
-		]]
-	},
-	externals: {
-		"d.vec3f": () => vec3f,
-		"std.dot": () => dot,
-		"std.select": () => select,
-		"std.mix": () => mix,
-		"d.vec4f": () => vec4f
-	}
-}) && $.f)({}));
-const posterize$1 = typegpu_default.fn([vec4f, f32], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, steps) => {
-	"use gpu";
-	const s = clamp(steps, f32(2), f32(20));
-	return vec4f(__tsover_div(floor(__tsover_mul(color.x, s)), s), __tsover_div(floor(__tsover_mul(color.y, s)), s), __tsover_div(floor(__tsover_mul(color.z, s)), s), color.w);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "color"
-		}, {
-			"type": "i",
-			"name": "steps"
-		}],
-		"body": [0, [
-			[
-				13,
-				"s",
-				[
-					6,
-					"std.clamp",
-					[
-						"steps",
-						[
-							6,
-							"d.f32",
-							[[5, "2"]]
-						],
-						[
-							6,
-							"d.f32",
-							[[5, "20"]]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"r",
-				[
-					1,
-					[
-						6,
-						"std.floor",
-						[[
-							1,
-							[
-								7,
-								"color",
-								"x"
-							],
-							"*",
-							"s"
-						]]
-					],
-					"/",
-					"s"
-				]
-			],
-			[
-				13,
-				"g",
-				[
-					1,
-					[
-						6,
-						"std.floor",
-						[[
-							1,
-							[
-								7,
-								"color",
-								"y"
-							],
-							"*",
-							"s"
-						]]
-					],
-					"/",
-					"s"
-				]
-			],
-			[
-				13,
-				"b",
-				[
-					1,
-					[
-						6,
-						"std.floor",
-						[[
-							1,
-							[
-								7,
-								"color",
-								"z"
-							],
-							"*",
-							"s"
-						]]
-					],
-					"/",
-					"s"
-				]
-			],
-			[10, [
-				6,
-				"d.vec4f",
-				[
-					"r",
-					"g",
-					"b",
-					[
-						7,
-						"color",
-						"w"
-					]
-				]
-			]]
-		]]
-	},
-	externals: {
-		"std.clamp": () => clamp,
-		"d.f32": () => f32,
-		"std.floor": () => floor,
-		"d.vec4f": () => vec4f
-	}
-}) && $.f)({}));
-const tintPlain = typegpu_default.fn([
-	vec4f,
-	vec4f,
-	f32
-], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, tintColor, amount) => {
-	"use gpu";
-	const tinted = mix(vec3f(color.x, color.y, color.z), vec3f(tintColor.x, tintColor.y, tintColor.z), vec3f(amount));
-	return vec4f(tinted.x, tinted.y, tinted.z, color.w);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "color"
-			},
-			{
-				"type": "i",
-				"name": "tintColor"
-			},
-			{
-				"type": "i",
-				"name": "amount"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"rgb",
-				[
-					6,
-					"d.vec3f",
-					[
-						[
-							7,
-							"color",
-							"x"
-						],
-						[
-							7,
-							"color",
-							"y"
-						],
-						[
-							7,
-							"color",
-							"z"
-						]
-					]
-				]
-			],
-			[
-				13,
-				"tinted",
-				[
-					6,
-					"std.mix",
-					[
-						"rgb",
-						[
-							6,
-							"d.vec3f",
-							[
-								[
-									7,
-									"tintColor",
-									"x"
-								],
-								[
-									7,
-									"tintColor",
-									"y"
-								],
-								[
-									7,
-									"tintColor",
-									"z"
-								]
-							]
-						],
-						[
-							6,
-							"d.vec3f",
-							["amount"]
-						]
-					]
-				]
-			],
-			[10, [
-				6,
-				"d.vec4f",
-				[
-					[
-						7,
-						"tinted",
-						"x"
-					],
-					[
-						7,
-						"tinted",
-						"y"
-					],
-					[
-						7,
-						"tinted",
-						"z"
-					],
-					[
-						7,
-						"color",
-						"w"
-					]
-				]
-			]]
-		]]
-	},
-	externals: {
-		"d.vec3f": () => vec3f,
-		"std.mix": () => mix,
-		"d.vec4f": () => vec4f
-	}
-}) && $.f)({}));
-const tintPreserveLuma = typegpu_default.fn([
-	vec4f,
-	vec4f,
-	f32
-], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, tintColor, amount) => {
-	"use gpu";
-	const rgb = vec3f(color.x, color.y, color.z);
-	const tinted = mix(rgb, vec3f(tintColor.x, tintColor.y, tintColor.z), vec3f(amount));
-	const luminanceWeights = vec3f(.299, .587, .114);
-	const originalLum = dot(rgb, luminanceWeights);
-	const tintedLum = dot(tinted, luminanceWeights);
-	const result = tinted.mul(__tsover_div(originalLum, max(tintedLum, 1e-4)));
-	return vec4f(result.x, result.y, result.z, color.w);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "color"
-			},
-			{
-				"type": "i",
-				"name": "tintColor"
-			},
-			{
-				"type": "i",
-				"name": "amount"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"rgb",
-				[
-					6,
-					"d.vec3f",
-					[
-						[
-							7,
-							"color",
-							"x"
-						],
-						[
-							7,
-							"color",
-							"y"
-						],
-						[
-							7,
-							"color",
-							"z"
-						]
-					]
-				]
-			],
-			[
-				13,
-				"tinted",
-				[
-					6,
-					"std.mix",
-					[
-						"rgb",
-						[
-							6,
-							"d.vec3f",
-							[
-								[
-									7,
-									"tintColor",
-									"x"
-								],
-								[
-									7,
-									"tintColor",
-									"y"
-								],
-								[
-									7,
-									"tintColor",
-									"z"
-								]
-							]
-						],
-						[
-							6,
-							"d.vec3f",
-							["amount"]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"luminanceWeights",
-				[
-					6,
-					"d.vec3f",
-					[
-						[5, "0.299"],
-						[5, "0.587"],
-						[5, "0.114"]
-					]
-				]
-			],
-			[
-				13,
-				"originalLum",
-				[
-					6,
-					"std.dot",
-					["rgb", "luminanceWeights"]
-				]
-			],
-			[
-				13,
-				"tintedLum",
-				[
-					6,
-					"std.dot",
-					["tinted", "luminanceWeights"]
-				]
-			],
-			[
-				13,
-				"result",
-				[
-					6,
-					[
-						7,
-						"tinted",
-						"mul"
-					],
-					[[
-						1,
-						"originalLum",
-						"/",
-						[
-							6,
-							"std.max",
-							["tintedLum", [5, "0.0001"]]
-						]
-					]]
-				]
-			],
-			[10, [
-				6,
-				"d.vec4f",
-				[
-					[
-						7,
-						"result",
-						"x"
-					],
-					[
-						7,
-						"result",
-						"y"
-					],
-					[
-						7,
-						"result",
-						"z"
-					],
-					[
-						7,
-						"color",
-						"w"
-					]
-				]
-			]]
-		]]
-	},
-	externals: {
-		"d.vec3f": () => vec3f,
-		"std.mix": () => mix,
-		"std.dot": () => dot,
-		"std.max": () => max,
-		"d.vec4f": () => vec4f
-	}
-}) && $.f)({}));
-const duotoneT = typegpu_default.fn([vec4f, f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, blend) => {
-	"use gpu";
-	const luminance = dot(color.xyz, vec3f(.299, .587, .114));
-	return smoothstep(__tsover_sub(blend, .5), __tsover_add(blend, .5), luminance);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "color"
-		}, {
-			"type": "i",
-			"name": "blend"
-		}],
-		"body": [0, [[
-			13,
-			"luminance",
-			[
-				6,
-				"std.dot",
-				[[
-					7,
-					"color",
-					"xyz"
-				], [
-					6,
-					"d.vec3f",
-					[
-						[5, "0.299"],
-						[5, "0.587"],
-						[5, "0.114"]
-					]
-				]]
-			]
-		], [10, [
-			6,
-			"std.smoothstep",
-			[
-				[
-					1,
-					"blend",
-					"-",
-					[5, "0.5"]
-				],
-				[
-					1,
-					"blend",
-					"+",
-					[5, "0.5"]
-				],
-				"luminance"
-			]
-		]]]]
-	},
-	externals: {
-		"std.dot": () => dot,
-		"d.vec3f": () => vec3f,
-		"std.smoothstep": () => smoothstep
-	}
-}) && $.f)({}));
-const tritoneFactors = typegpu_default.fn([vec4f, f32], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, blendMid) => {
-	"use gpu";
-	const luminance = dot(color.xyz, vec3f(.299, .587, .114));
-	return vec3f(smoothstep(__tsover_sub(blendMid, .25), blendMid, luminance), smoothstep(blendMid, __tsover_add(blendMid, .25), luminance), smoothstep(__tsover_sub(blendMid, .1), __tsover_add(blendMid, .1), luminance));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "color"
-		}, {
-			"type": "i",
-			"name": "blendMid"
-		}],
-		"body": [0, [
-			[
-				13,
-				"luminance",
-				[
-					6,
-					"std.dot",
-					[[
-						7,
-						"color",
-						"xyz"
-					], [
-						6,
-						"d.vec3f",
-						[
-							[5, "0.299"],
-							[5, "0.587"],
-							[5, "0.114"]
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"shadowToMid",
-				[
-					6,
-					"std.smoothstep",
-					[
-						[
-							1,
-							"blendMid",
-							"-",
-							[5, "0.25"]
-						],
-						"blendMid",
-						"luminance"
-					]
-				]
-			],
-			[
-				13,
-				"midToHighlight",
-				[
-					6,
-					"std.smoothstep",
-					[
-						"blendMid",
-						[
-							1,
-							"blendMid",
-							"+",
-							[5, "0.25"]
-						],
-						"luminance"
-					]
-				]
-			],
-			[
-				13,
-				"finalT",
-				[
-					6,
-					"std.smoothstep",
-					[
-						[
-							1,
-							"blendMid",
-							"-",
-							[5, "0.1"]
-						],
-						[
-							1,
-							"blendMid",
-							"+",
-							[5, "0.1"]
-						],
-						"luminance"
-					]
-				]
-			],
-			[10, [
-				6,
-				"d.vec3f",
-				[
-					"shadowToMid",
-					"midToHighlight",
-					"finalT"
-				]
-			]]
-		]]
-	},
-	externals: {
-		"std.dot": () => dot,
-		"d.vec3f": () => vec3f,
-		"std.smoothstep": () => smoothstep
-	}
-}) && $.f)({}));
-const gradientMapT = typegpu_default.fn([
-	vec4f,
-	f32,
-	f32,
-	f32
-], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, black, white, contrast) => {
-	"use gpu";
-	const luma = dot(color.xyz, vec3f(.2126, .7152, .0722));
-	const range = max(__tsover_sub(white, black), 1e-4);
-	let t = clamp(__tsover_div(__tsover_sub(luma, black), range), 0, 1);
-	t = clamp(__tsover_add(__tsover_mul(__tsover_sub(t, .5), contrast), .5), 0, 1);
-	return t;
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "color"
-			},
-			{
-				"type": "i",
-				"name": "black"
-			},
-			{
-				"type": "i",
-				"name": "white"
-			},
-			{
-				"type": "i",
-				"name": "contrast"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"luma",
-				[
-					6,
-					"std.dot",
-					[[
-						7,
-						"color",
-						"xyz"
-					], [
-						6,
-						"d.vec3f",
-						[
-							[5, "0.2126"],
-							[5, "0.7152"],
-							[5, "0.0722"]
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"range",
-				[
-					6,
-					"std.max",
-					[[
-						1,
-						"white",
-						"-",
-						"black"
-					], [5, "0.0001"]]
-				]
-			],
-			[
-				12,
-				"t",
-				[
-					6,
-					"std.clamp",
-					[
-						[
-							1,
-							[
-								1,
-								"luma",
-								"-",
-								"black"
-							],
-							"/",
-							"range"
-						],
-						[5, "0"],
-						[5, "1"]
-					]
-				]
-			],
-			[
-				2,
-				"t",
-				"=",
-				[
-					6,
-					"std.clamp",
-					[
-						[
-							1,
-							[
-								1,
-								[
-									1,
-									"t",
-									"-",
-									[5, "0.5"]
-								],
-								"*",
-								"contrast"
-							],
-							"+",
-							[5, "0.5"]
-						],
-						[5, "0"],
-						[5, "1"]
-					]
-				]
-			],
-			[10, "t"]
-		]]
-	},
-	externals: {
-		"std.dot": () => dot,
-		"d.vec3f": () => vec3f,
-		"std.max": () => max,
-		"std.clamp": () => clamp
-	}
-}) && $.f)({}));
-const gradientMapCosine = typegpu_default.fn([
-	f32,
-	f32,
-	vec3f,
-	vec3f,
-	vec3f,
-	vec3f
-], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((t, phase, pa, pb, pc, pd) => {
-	"use gpu";
-	const arg = pc.mul(t).add(pd).add(vec3f(phase, phase, phase)).mul(TWO_PI);
-	return clamp(pa.add(pb.mul(cos(arg))), vec3f(0, 0, 0), vec3f(1, 1, 1));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "t"
-			},
-			{
-				"type": "i",
-				"name": "phase"
-			},
-			{
-				"type": "i",
-				"name": "pa"
-			},
-			{
-				"type": "i",
-				"name": "pb"
-			},
-			{
-				"type": "i",
-				"name": "pc"
-			},
-			{
-				"type": "i",
-				"name": "pd"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"arg",
-				[
-					6,
-					[
-						7,
-						[
-							6,
-							[
-								7,
-								[
-									6,
-									[
-										7,
-										[
-											6,
-											[
-												7,
-												"pc",
-												"mul"
-											],
-											["t"]
-										],
-										"add"
-									],
-									["pd"]
-								],
-								"add"
-							],
-							[[
-								6,
-								"d.vec3f",
-								[
-									"phase",
-									"phase",
-									"phase"
-								]
-							]]
-						],
-						"mul"
-					],
-					["TWO_PI"]
-				]
-			],
-			[
-				13,
-				"mapped",
-				[
-					6,
-					[
-						7,
-						"pa",
-						"add"
-					],
-					[[
-						6,
-						[
-							7,
-							"pb",
-							"mul"
-						],
-						[[
-							6,
-							"std.cos",
-							["arg"]
-						]]
-					]]
-				]
-			],
-			[10, [
-				6,
-				"std.clamp",
-				[
-					"mapped",
-					[
-						6,
-						"d.vec3f",
-						[
-							[5, "0"],
-							[5, "0"],
-							[5, "0"]
-						]
-					],
-					[
-						6,
-						"d.vec3f",
-						[
-							[5, "1"],
-							[5, "1"],
-							[5, "1"]
-						]
-					]
-				]
-			]]
-		]]
-	},
-	externals: {
-		"d.vec3f": () => vec3f,
-		"TWO_PI": () => TWO_PI,
-		"std.cos": () => cos,
-		"std.clamp": () => clamp
-	}
-}) && $.f)({}));
-const gradientMapCustomPhase = typegpu_default.fn([f32, f32], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((t, phase) => {
-	"use gpu";
-	const t01 = fract(__tsover_add(t, phase));
-	const t3 = __tsover_mul(t01, 3);
-	return vec2f(fract(t3), floor(t3));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "t"
-		}, {
-			"type": "i",
-			"name": "phase"
-		}],
-		"body": [0, [
-			[
-				13,
-				"t01",
-				[
-					6,
-					"std.fract",
-					[[
-						1,
-						"t",
-						"+",
-						"phase"
-					]]
-				]
-			],
-			[
-				13,
-				"t3",
-				[
-					1,
-					"t01",
-					"*",
-					[5, "3"]
-				]
-			],
-			[10, [
-				6,
-				"d.vec2f",
-				[[
-					6,
-					"std.fract",
-					["t3"]
-				], [
-					6,
-					"std.floor",
-					["t3"]
-				]]
-			]]
-		]]
-	},
-	externals: {
-		"std.fract": () => fract,
-		"d.vec2f": () => vec2f,
-		"std.floor": () => floor
-	}
-}) && $.f)({}));
-const gradientMapSelect = typegpu_default.fn([
-	vec4f,
-	vec4f,
-	vec4f,
-	f32
-], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((seg0, seg1, seg2, i) => {
-	"use gpu";
-	return select(select(seg2, seg1, i < 2), seg0, i < 1);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "seg0"
-			},
-			{
-				"type": "i",
-				"name": "seg1"
-			},
-			{
-				"type": "i",
-				"name": "seg2"
-			},
-			{
-				"type": "i",
-				"name": "i"
-			}
-		],
-		"body": [0, [[
-			13,
-			"upper",
-			[
-				6,
-				"std.select",
-				[
-					"seg2",
-					"seg1",
-					[
-						1,
-						"i",
-						"<",
-						[5, "2"]
-					]
-				]
-			]
-		], [10, [
-			6,
-			"std.select",
-			[
-				"upper",
-				"seg0",
-				[
-					1,
-					"i",
-					"<",
-					[5, "1"]
-				]
-			]
-		]]]]
-	},
-	externals: { "std.select": () => select }
-}) && $.f)({}));
-const gradientMapCompose = typegpu_default.fn([
-	vec4f,
-	vec3f,
-	f32
-], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, mapped, strength) => {
-	"use gpu";
-	return vec4f(mix(color.xyz, mapped, vec3f(strength, strength, strength)), color.w);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "color"
-			},
-			{
-				"type": "i",
-				"name": "mapped"
-			},
-			{
-				"type": "i",
-				"name": "strength"
-			}
-		],
-		"body": [0, [[
-			13,
-			"outRgb",
-			[
-				6,
-				"std.mix",
-				[
-					[
-						7,
-						"color",
-						"xyz"
-					],
-					"mapped",
-					[
-						6,
-						"d.vec3f",
-						[
-							"strength",
-							"strength",
-							"strength"
-						]
-					]
-				]
-			]
-		], [10, [
-			6,
-			"d.vec4f",
-			["outRgb", [
-				7,
-				"color",
-				"w"
-			]]
-		]]]]
-	},
-	externals: {
-		"std.mix": () => mix,
-		"d.vec3f": () => vec3f,
-		"d.vec4f": () => vec4f
-	}
-}) && $.f)({}));
-const filmGrain$1 = typegpu_default.fn([
-	vec4f,
-	vec2f,
-	vec2f,
-	f32,
-	f32,
-	f32
-], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, uv, viewport, strength, bias, animTime) => {
-	"use gpu";
-	const noiseVal = hash12(uv.mul(viewport).add(vec2f(animTime, __tsover_mul(animTime, 1.6180339))));
-	const grain = __tsover_sub(__tsover_mul(noiseVal, 2), 1);
-	const brightness = clamp(dot(color.xyz, vec3f(.2126, .7152, .0722)), 0, 1);
-	const darkness = __tsover_sub(1, brightness);
-	const darkFactor = pow(__tsover_add(darkness, 1e-6), bias);
-	const grainIntensity = __tsover_mul(__tsover_mul(grain, darkFactor), __tsover_mul(strength, .1));
-	return vec4f(color.xyz.add(grainIntensity), color.w);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "color"
-			},
-			{
-				"type": "i",
-				"name": "uv"
-			},
-			{
-				"type": "i",
-				"name": "viewport"
-			},
-			{
-				"type": "i",
-				"name": "strength"
-			},
-			{
-				"type": "i",
-				"name": "bias"
-			},
-			{
-				"type": "i",
-				"name": "animTime"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"pixelCoord",
-				[
-					6,
-					[
-						7,
-						"uv",
-						"mul"
-					],
-					["viewport"]
-				]
-			],
-			[
-				13,
-				"noiseVal",
-				[
-					6,
-					"hash12",
-					[[
-						6,
-						[
-							7,
-							"pixelCoord",
-							"add"
-						],
-						[[
-							6,
-							"d.vec2f",
-							["animTime", [
-								1,
-								"animTime",
-								"*",
-								[5, "1.6180339"]
-							]]
-						]]
-					]]
-				]
-			],
-			[
-				13,
-				"grain",
-				[
-					1,
-					[
-						1,
-						"noiseVal",
-						"*",
-						[5, "2"]
-					],
-					"-",
-					[5, "1"]
-				]
-			],
-			[
-				13,
-				"brightness",
-				[
-					6,
-					"std.clamp",
-					[
-						[
-							6,
-							"std.dot",
-							[[
-								7,
-								"color",
-								"xyz"
-							], [
-								6,
-								"d.vec3f",
-								[
-									[5, "0.2126"],
-									[5, "0.7152"],
-									[5, "0.0722"]
-								]
-							]]
-						],
-						[5, "0"],
-						[5, "1"]
-					]
-				]
-			],
-			[
-				13,
-				"darkness",
-				[
-					1,
-					[5, "1"],
-					"-",
-					"brightness"
-				]
-			],
-			[
-				13,
-				"darkFactor",
-				[
-					6,
-					"std.pow",
-					[[
-						1,
-						"darkness",
-						"+",
-						[5, "0.000001"]
-					], "bias"]
-				]
-			],
-			[
-				13,
-				"grainIntensity",
-				[
-					1,
-					[
-						1,
-						"grain",
-						"*",
-						"darkFactor"
-					],
-					"*",
-					[
-						1,
-						"strength",
-						"*",
-						[5, "0.1"]
-					]
-				]
-			],
-			[
-				13,
-				"grainedColor",
-				[
-					6,
-					[
-						7,
-						[
-							7,
-							"color",
-							"xyz"
-						],
-						"add"
-					],
-					["grainIntensity"]
-				]
-			],
-			[10, [
-				6,
-				"d.vec4f",
-				["grainedColor", [
-					7,
-					"color",
-					"w"
-				]]
-			]]
-		]]
-	},
-	externals: {
-		"hash12": () => hash12,
-		"d.vec2f": () => vec2f,
-		"std.clamp": () => clamp,
-		"std.dot": () => dot,
-		"d.vec3f": () => vec3f,
-		"std.pow": () => pow,
-		"d.vec4f": () => vec4f
-	}
-}) && $.f)({}));
-const contourLineMask = typegpu_default.fn([
-	f32,
-	f32,
-	f32,
-	f32,
-	f32,
-	f32
-], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sourceValue, levels, lineWidth, softness, gamma, invert$2) => {
-	"use gpu";
-	const sv = pow(select(sourceValue, __tsover_sub(1, sourceValue), invert$2 > .5), gamma);
-	const scaledValue = __tsover_add(__tsover_mul(sv, levels), .5);
-	const fw = max(fwidth(scaledValue), 1e-4);
-	const distFromBoundary = abs(__tsover_sub(fract(__tsover_add(scaledValue, .5)), .5));
-	const normalizedDist = __tsover_div(distFromBoundary, fw);
-	const transitionFactor = __tsover_add(__tsover_mul(softness, .99), .01);
-	const innerEdge = __tsover_mul(lineWidth, __tsover_sub(1, transitionFactor));
-	return __tsover_sub(1, smoothstep(innerEdge, lineWidth, normalizedDist));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "sourceValue"
-			},
-			{
-				"type": "i",
-				"name": "levels"
-			},
-			{
-				"type": "i",
-				"name": "lineWidth"
-			},
-			{
-				"type": "i",
-				"name": "softness"
-			},
-			{
-				"type": "i",
-				"name": "gamma"
-			},
-			{
-				"type": "i",
-				"name": "invert"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"invertedValue",
-				[
-					6,
-					"std.select",
-					[
-						"sourceValue",
-						[
-							1,
-							[5, "1"],
-							"-",
-							"sourceValue"
-						],
-						[
-							1,
-							"invert",
-							">",
-							[5, "0.5"]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"sv",
-				[
-					6,
-					"std.pow",
-					["invertedValue", "gamma"]
-				]
-			],
-			[
-				13,
-				"scaledValue",
-				[
-					1,
-					[
-						1,
-						"sv",
-						"*",
-						"levels"
-					],
-					"+",
-					[5, "0.5"]
-				]
-			],
-			[
-				13,
-				"fw",
-				[
-					6,
-					"std.max",
-					[[
-						6,
-						"std.fwidth",
-						["scaledValue"]
-					], [5, "0.0001"]]
-				]
-			],
-			[
-				13,
-				"distFromBoundary",
-				[
-					6,
-					"std.abs",
-					[[
-						1,
-						[
-							6,
-							"std.fract",
-							[[
-								1,
-								"scaledValue",
-								"+",
-								[5, "0.5"]
-							]]
-						],
-						"-",
-						[5, "0.5"]
-					]]
-				]
-			],
-			[
-				13,
-				"normalizedDist",
-				[
-					1,
-					"distFromBoundary",
-					"/",
-					"fw"
-				]
-			],
-			[
-				13,
-				"transitionFactor",
-				[
-					1,
-					[
-						1,
-						"softness",
-						"*",
-						[5, "0.99"]
-					],
-					"+",
-					[5, "0.01"]
-				]
-			],
-			[
-				13,
-				"innerEdge",
-				[
-					1,
-					"lineWidth",
-					"*",
-					[
-						1,
-						[5, "1"],
-						"-",
-						"transitionFactor"
-					]
-				]
-			],
-			[10, [
-				1,
-				[5, "1"],
-				"-",
-				[
-					6,
-					"std.smoothstep",
-					[
-						"innerEdge",
-						"lineWidth",
-						"normalizedDist"
-					]
-				]
-			]]
-		]]
-	},
-	externals: {
-		"std.select": () => select,
-		"std.pow": () => pow,
-		"std.max": () => max,
-		"std.fwidth": () => fwidth,
-		"std.abs": () => abs,
-		"std.fract": () => fract,
-		"std.smoothstep": () => smoothstep
-	}
-}) && $.f)({}));
-const isolinesFromLuma = typegpu_default.fn([
-	vec4f,
-	f32,
-	f32,
-	f32,
-	f32,
-	f32
-], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, levels, lineWidth, softness, gamma, invert$2) => {
-	"use gpu";
-	return contourLineMask(luma709Dot(color.xyz), levels, lineWidth, softness, gamma, invert$2);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "color"
-			},
-			{
-				"type": "i",
-				"name": "levels"
-			},
-			{
-				"type": "i",
-				"name": "lineWidth"
-			},
-			{
-				"type": "i",
-				"name": "softness"
-			},
-			{
-				"type": "i",
-				"name": "gamma"
-			},
-			{
-				"type": "i",
-				"name": "invert"
-			}
-		],
-		"body": [0, [[10, [
-			6,
-			"contourLineMask",
-			[
-				[
-					6,
-					"luma709Dot",
-					[[
-						7,
-						"color",
-						"xyz"
-					]]
-				],
-				"levels",
-				"lineWidth",
-				"softness",
-				"gamma",
-				"invert"
-			]
-		]]]]
-	},
-	externals: {
-		"contourLineMask": () => contourLineMask,
-		"luma709Dot": () => luma709Dot
-	}
-}) && $.f)({}));
-const isolinesFromAlpha = typegpu_default.fn([
-	vec4f,
-	f32,
-	f32,
-	f32,
-	f32,
-	f32
-], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, levels, lineWidth, softness, gamma, invert$2) => {
-	"use gpu";
-	return contourLineMask(color.w, levels, lineWidth, softness, gamma, invert$2);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "color"
-			},
-			{
-				"type": "i",
-				"name": "levels"
-			},
-			{
-				"type": "i",
-				"name": "lineWidth"
-			},
-			{
-				"type": "i",
-				"name": "softness"
-			},
-			{
-				"type": "i",
-				"name": "gamma"
-			},
-			{
-				"type": "i",
-				"name": "invert"
-			}
-		],
-		"body": [0, [[10, [
-			6,
-			"contourLineMask",
-			[
-				[
-					7,
-					"color",
-					"w"
-				],
-				"levels",
-				"lineWidth",
-				"softness",
-				"gamma",
-				"invert"
-			]
-		]]]]
-	},
-	externals: { "contourLineMask": () => contourLineMask }
-}) && $.f)({}));
-const contourCompose = typegpu_default.fn([
-	vec4f,
-	vec4f,
-	f32
-], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((bg, line, mask) => {
-	"use gpu";
-	const rgb = mix(vec3f(bg.x, bg.y, bg.z), vec3f(line.x, line.y, line.z), vec3f(mask));
-	const alpha = mix(bg.w, line.w, mask);
-	return vec4f(rgb.x, rgb.y, rgb.z, alpha);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "bg"
-			},
-			{
-				"type": "i",
-				"name": "line"
-			},
-			{
-				"type": "i",
-				"name": "mask"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"rgb",
-				[
-					6,
-					"std.mix",
-					[
-						[
-							6,
-							"d.vec3f",
-							[
-								[
-									7,
-									"bg",
-									"x"
-								],
-								[
-									7,
-									"bg",
-									"y"
-								],
-								[
-									7,
-									"bg",
-									"z"
-								]
-							]
-						],
-						[
-							6,
-							"d.vec3f",
-							[
-								[
-									7,
-									"line",
-									"x"
-								],
-								[
-									7,
-									"line",
-									"y"
-								],
-								[
-									7,
-									"line",
-									"z"
-								]
-							]
-						],
-						[
-							6,
-							"d.vec3f",
-							["mask"]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"alpha",
-				[
-					6,
-					"std.mix",
-					[
-						[
-							7,
-							"bg",
-							"w"
-						],
-						[
-							7,
-							"line",
-							"w"
-						],
-						"mask"
-					]
-				]
-			],
-			[10, [
-				6,
-				"d.vec4f",
-				[
-					[
-						7,
-						"rgb",
-						"x"
-					],
-					[
-						7,
-						"rgb",
-						"y"
-					],
-					[
-						7,
-						"rgb",
-						"z"
-					],
-					"alpha"
-				]
-			]]
-		]]
-	},
-	externals: {
-		"std.mix": () => mix,
-		"d.vec3f": () => vec3f,
-		"d.vec4f": () => vec4f
-	}
-}) && $.f)({}));
-function hueRotate(shift) {
-	return pointwiseOp(hueRotate$1, "hueRotate", [shift]);
-}
-function saturate(intensity) {
-	return pointwiseOp(saturate$1, "saturate", [intensity]);
-}
-function vibrance(intensity) {
-	return pointwiseOp(vibrance$1, "vibrance", [intensity]);
-}
-function brightnessContrast(slots) {
-	return pointwiseOp(brightnessContrast$1, "brightnessContrast", [slots.brightness, slots.contrast]);
-}
-function exposure(gain) {
-	return pointwiseOp(exposure$1, "exposure", [gain]);
-}
-function grayscale() {
-	return pointwiseOp(grayscale$1, "grayscale", []);
-}
-function invert() {
-	return pointwiseOp(invert$1, "invert", []);
-}
-function solarize(slots) {
-	return pointwiseOp(solarize$1, "solarize", [slots.threshold, slots.strength]);
-}
-function posterize(steps) {
-	return pointwiseOp(posterize$1, "posterize", [steps]);
-}
-function tint(slots) {
-	return {
-		kind: "pointwise",
-		body: (propValues) => Number(propValues[slots.preserveLuminosity.name]) > 0 ? {
-			fn: tintPreserveLuma,
-			hint: "tintPreserveLuma"
-		} : {
-			fn: tintPlain,
-			hint: "tintPlain"
-		},
-		args: (params) => [resolveArg(slots.color, params), resolveArg(slots.amount, params)]
-	};
-}
-function filmGrain(slots) {
-	return {
-		kind: "pointwise",
-		body: {
-			fn: filmGrain$1,
-			hint: "filmGrain"
-		},
-		args: (params) => [
-			params.ctx.uv,
-			params.ctx.viewportSize,
-			resolveArg(slots.strength, params),
-			resolveArg(slots.bias, params),
-			params.uniforms.animTime
-		],
-		setup: (params) => {
-			let animTimeAcc = 0;
-			params.onBeforeRender(({ deltaTime }) => {
-				const on = params.getCpuValue(slots.animated.name) > 0 ? 1 : 0;
-				animTimeAcc += deltaTime * on * 10;
-				params.setExtraField("animTime", animTimeAcc);
-			});
-		}
-	};
-}
-var sourceModeOf = (raw) => typeof raw === "number" ? raw : raw === "alpha" ? 1 : 0;
-var colorModeOf = (raw) => typeof raw === "number" ? raw : raw === "custom" ? 1 : 0;
-function isolines(slots) {
-	return {
-		kind: "pointwise",
-		body: (propValues) => sourceModeOf(propValues[slots.source.name]) === 1 ? {
-			fn: isolinesFromAlpha,
-			hint: "isolinesFromAlpha"
-		} : {
-			fn: isolinesFromLuma,
-			hint: "isolinesFromLuma"
-		},
-		args: (params) => [
-			slots.levels,
-			slots.lineWidth,
-			slots.softness,
-			slots.gamma,
-			slots.invert
-		].map((s) => resolveArg(s, params)),
-		compose: (lineMask, params) => {
-			const custom = colorModeOf(params.propValues[slots.colorMode.name]) === 1;
-			return call(contourCompose, "contourCompose", [
-				custom ? uniformOf(slots.backgroundColor, params) : ZERO,
-				custom ? uniformOf(slots.lineColor, params) : vec4(params.childNode.member("rgb"), floatE(1)),
-				lineMask
-			]);
-		}
-	};
-}
-function mixVariantFor(colorSpace, params) {
-	return mixColorsVariants[params.propValues[colorSpace.name] ?? 0] ?? mixColorsLinear;
-}
-function duotone(slots) {
-	return pointwiseOp(duotoneT, "duotoneT", [slots.blend], { compose: (t, params) => {
-		return vec4(call(mixVariantFor(slots.colorSpace, params), "mixColors", [
-			uniformOf(slots.colorA, params),
-			uniformOf(slots.colorB, params),
-			t
-		]).member("rgb"), params.childNode.member("a"));
-	} });
-}
-function tritone(slots) {
-	return pointwiseOp(tritoneFactors, "tritoneFactors", [slots.blendMid], { compose: (factors, params) => {
-		const shadowToMid = factors.member("x");
-		const midToHighlight = factors.member("y");
-		const finalT = factors.member("z");
-		const variant = mixVariantFor(slots.colorSpace, params);
-		const colorA = uniformOf(slots.colorA, params);
-		const colorB = uniformOf(slots.colorB, params);
-		const colorC = uniformOf(slots.colorC, params);
-		return vec4(call(variant, "mixColors", [
-			call(variant, "mixColors", [
-				colorA,
-				colorB,
-				shadowToMid
-			]),
-			call(variant, "mixColors", [
-				colorB,
-				colorC,
-				midToHighlight
-			]),
-			finalT
-		]).member("rgb"), params.childNode.member("a"));
-	} });
-}
-var PALETTES = {
-	0: {
-		a: [
-			.5,
-			.5,
-			.5
-		],
-		b: [
-			.5,
-			.5,
-			.5
-		],
-		c: [
-			1,
-			1,
-			1
-		],
-		d: [
-			0,
-			.333,
-			.667
-		]
-	},
-	1: {
-		a: [
-			.5,
-			.5,
-			.5
-		],
-		b: [
-			.5,
-			.5,
-			.5
-		],
-		c: [
-			1,
-			1,
-			1
-		],
-		d: [
-			0,
-			.1,
-			.2
-		]
-	},
-	2: {
-		a: [
-			.5,
-			.5,
-			.5
-		],
-		b: [
-			.5,
-			.5,
-			.5
-		],
-		c: [
-			1,
-			1,
-			1
-		],
-		d: [
-			.3,
-			.2,
-			.2
-		]
-	},
-	3: {
-		a: [
-			.5,
-			.5,
-			.5
-		],
-		b: [
-			.5,
-			.5,
-			.5
-		],
-		c: [
-			1,
-			1,
-			1
-		],
-		d: [
-			.8,
-			.9,
-			.3
-		]
-	},
-	4: {
-		a: [
-			.5,
-			.5,
-			.5
-		],
-		b: [
-			.25,
-			.25,
-			.25
-		],
-		c: [
-			1,
-			1,
-			1
-		],
-		d: [
-			0,
-			.25,
-			.5
-		]
-	},
-	5: {
-		a: [
-			.5,
-			.5,
-			.5
-		],
-		b: [
-			.5,
-			.5,
-			.5
-		],
-		c: [
-			2,
-			1,
-			1
-		],
-		d: [
-			.5,
-			.2,
-			.25
-		]
-	}
-};
-var PALETTE_INDEX = {
-	rainbow: 0,
-	sunset: 1,
-	ocean: 2,
-	fire: 3,
-	pastel: 4,
-	neon: 5,
-	custom: 6
-};
-var vec3E = (v) => expr(`vec3f(${formatFloat(v[0])}, ${formatFloat(v[1])}, ${formatFloat(v[2])})`);
-function gradientMap(slots) {
-	return pointwiseOp(gradientMapT, "gradientMapT", [
-		slots.blackPoint,
-		slots.whitePoint,
-		slots.contrast
-	], { compose: (t, params) => {
-		const { childNode, propValues, ctx } = params;
-		const strength = uniformOf(slots.strength, params);
-		const phase = uniformOf(slots.speed, params).mul(ctx.time);
-		const paletteIdx = PALETTE_INDEX[propValues[slots.palette.name] ?? "rainbow"] ?? 0;
-		if (paletteIdx !== 6) {
-			const p = PALETTES[paletteIdx] ?? PALETTES[0];
-			return call(gradientMapCompose, "gradientMapCompose", [
-				childNode,
-				call(gradientMapCosine, "gradientMapCosine", [
-					t,
-					phase,
-					vec3E(p.a),
-					vec3E(p.b),
-					vec3E(p.c),
-					vec3E(p.d)
-				]),
-				strength
-			]);
-		}
-		const variant = mixVariantFor(slots.colorSpace, params);
-		const phaseData = call(gradientMapCustomPhase, "gradientMapCustomPhase", [t, phase]);
-		const fr = phaseData.member("x");
-		const i = phaseData.member("y");
-		const colorLow = uniformOf(slots.colorLow, params);
-		const colorMid = uniformOf(slots.colorMid, params);
-		const colorHigh = uniformOf(slots.colorHigh, params);
-		return call(gradientMapCompose, "gradientMapCompose", [
-			childNode,
-			call(gradientMapSelect, "gradientMapSelect", [
-				call(variant, "mixColors", [
-					colorLow,
-					colorMid,
-					fr
-				]),
-				call(variant, "mixColors", [
-					colorMid,
-					colorHigh,
-					fr
-				]),
-				call(variant, "mixColors", [
-					colorHigh,
-					colorLow,
-					fr
-				]),
-				i
-			]).member("rgb"),
-			strength
-		]);
-	} });
-}
-function makeLutAtlasUvFn(size) {
-	const LUT_MAX = size - 1;
-	const INV_ATLAS_W = 1 / (size * size);
-	const INV_LUT_N = 1 / size;
-	return typegpu_default.fn([vec4f, f32], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, hi) => {
-		"use gpu";
-		const enc = linearToSrgb(clamp(color.xyz, vec3f(0, 0, 0), vec3f(1, 1, 1)));
-		const slice = __tsover_mul(enc.z, f32(LUT_MAX));
-		const s = clamp(__tsover_add(floor(slice), hi), f32(0), f32(LUT_MAX));
-		return vec2f(__tsover_mul(__tsover_add(__tsover_add(__tsover_mul(s, f32(size)), .5), __tsover_mul(enc.x, f32(LUT_MAX))), f32(INV_ATLAS_W)), __tsover_mul(__tsover_add(.5, __tsover_mul(enc.y, f32(LUT_MAX))), f32(INV_LUT_N)));
-	}), {
-		v: 2,
-		name: void 0,
-		ast: {
-			"params": [{
-				"type": "i",
-				"name": "color"
-			}, {
-				"type": "i",
-				"name": "hi"
-			}],
-			"body": [0, [
-				[
-					13,
-					"enc",
-					[
-						6,
-						"tonemap.linearToSrgb",
-						[[
-							6,
-							"std.clamp",
-							[
-								[
-									7,
-									"color",
-									"xyz"
-								],
-								[
-									6,
-									"d.vec3f",
-									[
-										[5, "0"],
-										[5, "0"],
-										[5, "0"]
-									]
-								],
-								[
-									6,
-									"d.vec3f",
-									[
-										[5, "1"],
-										[5, "1"],
-										[5, "1"]
-									]
-								]
-							]
-						]]
-					]
-				],
-				[
-					13,
-					"slice",
-					[
-						1,
-						[
-							7,
-							"enc",
-							"z"
-						],
-						"*",
-						[
-							6,
-							"d.f32",
-							["LUT_MAX"]
-						]
-					]
-				],
-				[
-					13,
-					"s",
-					[
-						6,
-						"std.clamp",
-						[
-							[
-								1,
-								[
-									6,
-									"std.floor",
-									["slice"]
-								],
-								"+",
-								"hi"
-							],
-							[
-								6,
-								"d.f32",
-								[[5, "0"]]
-							],
-							[
-								6,
-								"d.f32",
-								["LUT_MAX"]
-							]
-						]
-					]
-				],
-				[
-					13,
-					"u",
-					[
-						1,
-						[
-							1,
-							[
-								1,
-								[
-									1,
-									"s",
-									"*",
-									[
-										6,
-										"d.f32",
-										["size"]
-									]
-								],
-								"+",
-								[5, "0.5"]
-							],
-							"+",
-							[
-								1,
-								[
-									7,
-									"enc",
-									"x"
-								],
-								"*",
-								[
-									6,
-									"d.f32",
-									["LUT_MAX"]
-								]
-							]
-						],
-						"*",
-						[
-							6,
-							"d.f32",
-							["INV_ATLAS_W"]
-						]
-					]
-				],
-				[
-					13,
-					"v",
-					[
-						1,
-						[
-							1,
-							[5, "0.5"],
-							"+",
-							[
-								1,
-								[
-									7,
-									"enc",
-									"y"
-								],
-								"*",
-								[
-									6,
-									"d.f32",
-									["LUT_MAX"]
-								]
-							]
-						],
-						"*",
-						[
-							6,
-							"d.f32",
-							["INV_LUT_N"]
-						]
-					]
-				],
-				[10, [
-					6,
-					"d.vec2f",
-					["u", "v"]
-				]]
-			]]
-		},
-		externals: {
-			"tonemap.linearToSrgb": () => linearToSrgb,
-			"std.clamp": () => clamp,
-			"d.vec3f": () => vec3f,
-			"d.f32": () => f32,
-			"LUT_MAX": () => LUT_MAX,
-			"std.floor": () => floor,
-			"size": () => size,
-			"INV_ATLAS_W": () => INV_ATLAS_W,
-			"INV_LUT_N": () => INV_LUT_N,
-			"d.vec2f": () => vec2f
-		}
-	}) && $.f)({})).$name("lutAtlasUv");
-}
-function makeLutAtlasApplyFn(size) {
-	const LUT_MAX = size - 1;
-	return typegpu_default.fn([
-		vec4f,
-		vec4f,
-		vec4f,
-		f32
-	], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, tapLo, tapHi, strength) => {
-		"use gpu";
-		const enc = linearToSrgb(clamp(color.xyz, vec3f(0, 0, 0), vec3f(1, 1, 1)));
-		const slice = __tsover_mul(enc.z, f32(LUT_MAX));
-		const f = __tsover_sub(slice, floor(slice));
-		const graded = srgbToLinear(mix(tapLo.xyz, tapHi.xyz, vec3f(f, f, f)));
-		const rgb = mix(color.xyz, graded, vec3f(strength, strength, strength));
-		return vec4f(rgb.x, rgb.y, rgb.z, color.w);
-	}), {
-		v: 2,
-		name: void 0,
-		ast: {
-			"params": [
-				{
-					"type": "i",
-					"name": "color"
-				},
-				{
-					"type": "i",
-					"name": "tapLo"
-				},
-				{
-					"type": "i",
-					"name": "tapHi"
-				},
-				{
-					"type": "i",
-					"name": "strength"
-				}
-			],
-			"body": [0, [
-				[
-					13,
-					"enc",
-					[
-						6,
-						"tonemap.linearToSrgb",
-						[[
-							6,
-							"std.clamp",
-							[
-								[
-									7,
-									"color",
-									"xyz"
-								],
-								[
-									6,
-									"d.vec3f",
-									[
-										[5, "0"],
-										[5, "0"],
-										[5, "0"]
-									]
-								],
-								[
-									6,
-									"d.vec3f",
-									[
-										[5, "1"],
-										[5, "1"],
-										[5, "1"]
-									]
-								]
-							]
-						]]
-					]
-				],
-				[
-					13,
-					"slice",
-					[
-						1,
-						[
-							7,
-							"enc",
-							"z"
-						],
-						"*",
-						[
-							6,
-							"d.f32",
-							["LUT_MAX"]
-						]
-					]
-				],
-				[
-					13,
-					"f",
-					[
-						1,
-						"slice",
-						"-",
-						[
-							6,
-							"std.floor",
-							["slice"]
-						]
-					]
-				],
-				[
-					13,
-					"graded",
-					[
-						6,
-						"tonemap.srgbToLinear",
-						[[
-							6,
-							"std.mix",
-							[
-								[
-									7,
-									"tapLo",
-									"xyz"
-								],
-								[
-									7,
-									"tapHi",
-									"xyz"
-								],
-								[
-									6,
-									"d.vec3f",
-									[
-										"f",
-										"f",
-										"f"
-									]
-								]
-							]
-						]]
-					]
-				],
-				[
-					13,
-					"rgb",
-					[
-						6,
-						"std.mix",
-						[
-							[
-								7,
-								"color",
-								"xyz"
-							],
-							"graded",
-							[
-								6,
-								"d.vec3f",
-								[
-									"strength",
-									"strength",
-									"strength"
-								]
-							]
-						]
-					]
-				],
-				[10, [
-					6,
-					"d.vec4f",
-					[
-						[
-							7,
-							"rgb",
-							"x"
-						],
-						[
-							7,
-							"rgb",
-							"y"
-						],
-						[
-							7,
-							"rgb",
-							"z"
-						],
-						[
-							7,
-							"color",
-							"w"
-						]
-					]
-				]]
-			]]
-		},
-		externals: {
-			"tonemap.linearToSrgb": () => linearToSrgb,
-			"std.clamp": () => clamp,
-			"d.vec3f": () => vec3f,
-			"d.f32": () => f32,
-			"LUT_MAX": () => LUT_MAX,
-			"std.floor": () => floor,
-			"tonemap.srgbToLinear": () => srgbToLinear,
-			"std.mix": () => mix,
-			"d.vec4f": () => vec4f
-		}
-	}) && $.f)({})).$name("lutAtlasApply");
-}
-var lutAtlasFnCache = /* @__PURE__ */ new Map();
-function lutAtlasFnsFor(size) {
-	let fns = lutAtlasFnCache.get(size);
-	if (!fns) {
-		fns = {
-			uv: makeLutAtlasUvFn(size),
-			apply: makeLutAtlasApplyFn(size)
-		};
-		lutAtlasFnCache.set(size, fns);
-	}
-	return fns;
-}
-function lutAtlasGrade(slots) {
-	const fns = lutAtlasFnsFor(slots.size);
-	return (color, params) => {
-		const { propValues, uniforms, createDataTexture, registerMediaTexture, onCleanup } = params;
-		const key = propValues[slots.select.name] ?? slots.fallback;
-		const lutTex = createDataTexture({
-			width: slots.size * slots.size,
-			height: slots.size,
-			format: "rgba8unorm",
-			data: slots.decode(key),
-			label: `${slots.label}-${key}`
-		});
-		onCleanup(() => lutTex.destroy());
-		const lutKit = registerMediaTexture(() => lutTex.texture);
-		const tapLo = lutKit.sample(call(fns.uv, "lutAtlasUvLo", [color, floatE(0)]), "linearClamp");
-		const tapHi = lutKit.sample(call(fns.uv, "lutAtlasUvHi", [color, floatE(1)]), "linearClamp");
-		return call(fns.apply, "lutAtlasApply", [
-			color,
-			tapLo,
-			tapHi,
-			uniforms[slots.strength.name]
-		]);
-	};
-}
-export { gradientMap as a, invert as c, posterize as d, saturate as f, vibrance as g, tritone as h, filmGrain as i, isolines as l, tint as m, duotone as n, grayscale as o, solarize as p, exposure as r, hueRotate as s, brightnessContrast as t, lutAtlasGrade as u };