shaders 3.1.462 → 3.2.464

package/dist/core/color-C9iR6boM.js

@@ -0,0 +1,3620 @@
+import { $n as vec4f, En as cos, In as mix, Jn as vec2f, Mn as fract, Nt as mixColorsLinear, On as dot, Pn as max, Pt as mixColorsVariants, Rn as pow, St as srgbToLinear, Tn as clamp, Un as sin, Wn as smoothstep, Zn as vec3f, a as uniformOf, at as call, bn as select, bt as linearToSrgb, cn as SQRT3, ct as expr, dt as vec4, hr as f32, in as DEG_TO_RAD, jn as floor, ln as TAU, lt as floatE, mn as typegpu_default, n as pointwiseOp, nt as ZERO, pt as formatFloat, r as resolveArg, xn as abs } from "./lower-z2vuXP8M.js";
+import { T as fwidth, s as hash12 } from "./noise-B3Oq1k3_.js";
+import { n as luma709Dot } from "./tone-BA0D_veZ.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 };