shaders 2.5.135 → 3.0.437

package/dist/core/Dither-B3ulhQOh.js

@@ -0,0 +1,2648 @@
+import { At as call, Ot as ZERO, Pt as floatE, R as std, Wt as unpremultiplyAlpha, kt as arrayExpr, n as tgpu, on as d } from "./coords-BlwgBpJf.js";
+import { a as transformColor } from "./transformations-fqzznt4g.js";
+var transformPattern = (value) => {
+	return {
+		bayer2: 0,
+		bayer4: 1,
+		bayer8: 2,
+		clusteredDot: 3,
+		blueNoise: 4,
+		whiteNoise: 5,
+		floydSteinberg: 6
+	}[value] ?? 1;
+};
+var transformColorMode = (value) => value === "source" ? 1 : 0;
+var patternModeOf = (raw) => typeof raw === "number" ? raw : transformPattern(raw);
+var colorModeOf = (raw) => typeof raw === "number" ? raw : raw === "source" ? 1 : 0;
+const ditherCoord = tgpu.fn([
+	d.vec2f,
+	d.vec2f,
+	d.f32
+], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, gridRes, pixelSize) => {
+	"use gpu";
+	return std.floor(d.vec2f(__tsover_div(__tsover_mul(uv.x, gridRes.x), pixelSize), __tsover_div(__tsover_mul(uv.y, gridRes.y), pixelSize)));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "uv"
+			},
+			{
+				"type": "i",
+				"name": "gridRes"
+			},
+			{
+				"type": "i",
+				"name": "pixelSize"
+			}
+		],
+		"body": [0, [[10, [
+			6,
+			[
+				7,
+				"std",
+				"floor"
+			],
+			[[
+				6,
+				[
+					7,
+					"d",
+					"vec2f"
+				],
+				[[
+					1,
+					[
+						1,
+						[
+							7,
+							"uv",
+							"x"
+						],
+						"*",
+						[
+							7,
+							"gridRes",
+							"x"
+						]
+					],
+					"/",
+					"pixelSize"
+				], [
+					1,
+					[
+						1,
+						[
+							7,
+							"uv",
+							"y"
+						],
+						"*",
+						[
+							7,
+							"gridRes",
+							"y"
+						]
+					],
+					"/",
+					"pixelSize"
+				]]
+			]]
+		]]]],
+		"externalNames": ["std", "d"]
+	},
+	externals: () => ({
+		std,
+		d
+	})
+}) && $.f)({}));
+const ditherPixUV = tgpu.fn([
+	d.vec2f,
+	d.f32,
+	d.vec2f
+], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((coord, pixelSize, gridRes) => {
+	"use gpu";
+	return d.vec2f(__tsover_div(__tsover_mul(__tsover_add(coord.x, .5), pixelSize), gridRes.x), __tsover_div(__tsover_mul(__tsover_add(coord.y, .5), pixelSize), gridRes.y));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "coord"
+			},
+			{
+				"type": "i",
+				"name": "pixelSize"
+			},
+			{
+				"type": "i",
+				"name": "gridRes"
+			}
+		],
+		"body": [0, [[10, [
+			6,
+			[
+				7,
+				"d",
+				"vec2f"
+			],
+			[[
+				1,
+				[
+					1,
+					[
+						1,
+						[
+							7,
+							"coord",
+							"x"
+						],
+						"+",
+						[5, "0.5"]
+					],
+					"*",
+					"pixelSize"
+				],
+				"/",
+				[
+					7,
+					"gridRes",
+					"x"
+				]
+			], [
+				1,
+				[
+					1,
+					[
+						1,
+						[
+							7,
+							"coord",
+							"y"
+						],
+						"+",
+						[5, "0.5"]
+					],
+					"*",
+					"pixelSize"
+				],
+				"/",
+				[
+					7,
+					"gridRes",
+					"y"
+				]
+			]]
+		]]]],
+		"externalNames": ["d"]
+	},
+	externals: () => ({ d })
+}) && $.f)({}));
+const ditherLuma = tgpu.fn([d.vec4f], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((c) => {
+	"use gpu";
+	return __tsover_mul(std.dot(d.vec3f(c.x, c.y, c.z), d.vec3f(.299, .587, .114)), c.w);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "c"
+		}],
+		"body": [0, [[10, [
+			1,
+			[
+				6,
+				[
+					7,
+					"std",
+					"dot"
+				],
+				[[
+					6,
+					[
+						7,
+						"d",
+						"vec3f"
+					],
+					[
+						[
+							7,
+							"c",
+							"x"
+						],
+						[
+							7,
+							"c",
+							"y"
+						],
+						[
+							7,
+							"c",
+							"z"
+						]
+					]
+				], [
+					6,
+					[
+						7,
+						"d",
+						"vec3f"
+					],
+					[
+						[5, "0.299"],
+						[5, "0.587"],
+						[5, "0.114"]
+					]
+				]]
+			],
+			"*",
+			[
+				7,
+				"c",
+				"w"
+			]
+		]]]],
+		"externalNames": ["std", "d"]
+	},
+	externals: () => ({
+		std,
+		d
+	})
+}) && $.f)({}));
+const ditherBayerQuad = tgpu.fn([d.f32, d.f32], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((a, b) => {
+	"use gpu";
+	return __tsover_sub(__tsover_add(__tsover_mul(b, 3), __tsover_mul(a, 2)), __tsover_mul(__tsover_mul(a, b), 4));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "a"
+		}, {
+			"type": "i",
+			"name": "b"
+		}],
+		"body": [0, [[10, [
+			1,
+			[
+				1,
+				[
+					1,
+					"b",
+					"*",
+					[5, "3"]
+				],
+				"+",
+				[
+					1,
+					"a",
+					"*",
+					[5, "2"]
+				]
+			],
+			"-",
+			[
+				1,
+				[
+					1,
+					"a",
+					"*",
+					"b"
+				],
+				"*",
+				[5, "4"]
+			]
+		]]]],
+		"externalNames": []
+	},
+	externals: () => ({})
+}) && $.f)({}));
+const ditherPeriodic = tgpu.fn([d.vec2f], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((coord) => {
+	"use gpu";
+	const tx = __tsover_sub(coord.x, __tsover_mul(8, std.floor(__tsover_div(coord.x, 8))));
+	const ty = __tsover_sub(coord.y, __tsover_mul(8, std.floor(__tsover_div(coord.y, 8))));
+	const x2 = __tsover_sub(tx, __tsover_mul(2, std.floor(__tsover_div(tx, 2))));
+	const y2 = __tsover_sub(ty, __tsover_mul(2, std.floor(__tsover_div(ty, 2))));
+	const x4 = __tsover_sub(tx, __tsover_mul(4, std.floor(__tsover_div(tx, 4))));
+	const y4 = __tsover_sub(ty, __tsover_mul(4, std.floor(__tsover_div(ty, 4))));
+	const x4h = std.floor(__tsover_div(x4, 2));
+	const y4h = std.floor(__tsover_div(y4, 2));
+	const x8h = std.floor(__tsover_div(tx, 4));
+	const y8h = std.floor(__tsover_div(ty, 4));
+	const b00 = ditherBayerQuad(x2, y2);
+	const b11 = ditherBayerQuad(x4h, y4h);
+	const b22 = ditherBayerQuad(x8h, y8h);
+	const bayer2 = __tsover_div(b00, 4);
+	const bayer4 = __tsover_div(__tsover_add(__tsover_mul(b00, 4), b11), 16);
+	const bayer8 = __tsover_div(__tsover_add(__tsover_add(__tsover_mul(b00, 16), __tsover_mul(b11, 4)), b22), 64);
+	const idx = __tsover_add(__tsover_mul(d.i32(y4), 4), d.i32(x4));
+	let cd = .75;
+	cd = std.select(cd, .3125, idx === 1);
+	cd = std.select(cd, .375, idx === 2);
+	cd = std.select(cd, .8125, idx === 3);
+	cd = std.select(cd, .25, idx === 4);
+	cd = std.select(cd, d.f32(0), idx === 5);
+	cd = std.select(cd, .0625, idx === 6);
+	cd = std.select(cd, .4375, idx === 7);
+	cd = std.select(cd, .6875, idx === 8);
+	cd = std.select(cd, .1875, idx === 9);
+	cd = std.select(cd, .125, idx === 10);
+	cd = std.select(cd, .5, idx === 11);
+	cd = std.select(cd, .9375, idx === 12);
+	cd = std.select(cd, .625, idx === 13);
+	cd = std.select(cd, .5625, idx === 14);
+	cd = std.select(cd, .875, idx === 15);
+	return d.vec4f(bayer2, bayer4, bayer8, cd);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "coord"
+		}],
+		"body": [0, [
+			[
+				13,
+				"tx",
+				[
+					1,
+					[
+						7,
+						"coord",
+						"x"
+					],
+					"-",
+					[
+						1,
+						[5, "8"],
+						"*",
+						[
+							6,
+							[
+								7,
+								"std",
+								"floor"
+							],
+							[[
+								1,
+								[
+									7,
+									"coord",
+									"x"
+								],
+								"/",
+								[5, "8"]
+							]]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"ty",
+				[
+					1,
+					[
+						7,
+						"coord",
+						"y"
+					],
+					"-",
+					[
+						1,
+						[5, "8"],
+						"*",
+						[
+							6,
+							[
+								7,
+								"std",
+								"floor"
+							],
+							[[
+								1,
+								[
+									7,
+									"coord",
+									"y"
+								],
+								"/",
+								[5, "8"]
+							]]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"x2",
+				[
+					1,
+					"tx",
+					"-",
+					[
+						1,
+						[5, "2"],
+						"*",
+						[
+							6,
+							[
+								7,
+								"std",
+								"floor"
+							],
+							[[
+								1,
+								"tx",
+								"/",
+								[5, "2"]
+							]]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"y2",
+				[
+					1,
+					"ty",
+					"-",
+					[
+						1,
+						[5, "2"],
+						"*",
+						[
+							6,
+							[
+								7,
+								"std",
+								"floor"
+							],
+							[[
+								1,
+								"ty",
+								"/",
+								[5, "2"]
+							]]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"x4",
+				[
+					1,
+					"tx",
+					"-",
+					[
+						1,
+						[5, "4"],
+						"*",
+						[
+							6,
+							[
+								7,
+								"std",
+								"floor"
+							],
+							[[
+								1,
+								"tx",
+								"/",
+								[5, "4"]
+							]]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"y4",
+				[
+					1,
+					"ty",
+					"-",
+					[
+						1,
+						[5, "4"],
+						"*",
+						[
+							6,
+							[
+								7,
+								"std",
+								"floor"
+							],
+							[[
+								1,
+								"ty",
+								"/",
+								[5, "4"]
+							]]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"x4h",
+				[
+					6,
+					[
+						7,
+						"std",
+						"floor"
+					],
+					[[
+						1,
+						"x4",
+						"/",
+						[5, "2"]
+					]]
+				]
+			],
+			[
+				13,
+				"y4h",
+				[
+					6,
+					[
+						7,
+						"std",
+						"floor"
+					],
+					[[
+						1,
+						"y4",
+						"/",
+						[5, "2"]
+					]]
+				]
+			],
+			[
+				13,
+				"x8h",
+				[
+					6,
+					[
+						7,
+						"std",
+						"floor"
+					],
+					[[
+						1,
+						"tx",
+						"/",
+						[5, "4"]
+					]]
+				]
+			],
+			[
+				13,
+				"y8h",
+				[
+					6,
+					[
+						7,
+						"std",
+						"floor"
+					],
+					[[
+						1,
+						"ty",
+						"/",
+						[5, "4"]
+					]]
+				]
+			],
+			[
+				13,
+				"b00",
+				[
+					6,
+					"ditherBayerQuad",
+					["x2", "y2"]
+				]
+			],
+			[
+				13,
+				"b11",
+				[
+					6,
+					"ditherBayerQuad",
+					["x4h", "y4h"]
+				]
+			],
+			[
+				13,
+				"b22",
+				[
+					6,
+					"ditherBayerQuad",
+					["x8h", "y8h"]
+				]
+			],
+			[
+				13,
+				"bayer2",
+				[
+					1,
+					"b00",
+					"/",
+					[5, "4"]
+				]
+			],
+			[
+				13,
+				"bayer4",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							"b00",
+							"*",
+							[5, "4"]
+						],
+						"+",
+						"b11"
+					],
+					"/",
+					[5, "16"]
+				]
+			],
+			[
+				13,
+				"bayer8",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								"b00",
+								"*",
+								[5, "16"]
+							],
+							"+",
+							[
+								1,
+								"b11",
+								"*",
+								[5, "4"]
+							]
+						],
+						"+",
+						"b22"
+					],
+					"/",
+					[5, "64"]
+				]
+			],
+			[
+				13,
+				"idx",
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"d",
+								"i32"
+							],
+							["y4"]
+						],
+						"*",
+						[5, "4"]
+					],
+					"+",
+					[
+						6,
+						[
+							7,
+							"d",
+							"i32"
+						],
+						["x4"]
+					]
+				]
+			],
+			[
+				12,
+				"cd",
+				[5, "0.75"]
+			],
+			[
+				2,
+				"cd",
+				"=",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"cd",
+						[5, "0.3125"],
+						[
+							1,
+							"idx",
+							"===",
+							[5, "1"]
+						]
+					]
+				]
+			],
+			[
+				2,
+				"cd",
+				"=",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"cd",
+						[5, "0.375"],
+						[
+							1,
+							"idx",
+							"===",
+							[5, "2"]
+						]
+					]
+				]
+			],
+			[
+				2,
+				"cd",
+				"=",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"cd",
+						[5, "0.8125"],
+						[
+							1,
+							"idx",
+							"===",
+							[5, "3"]
+						]
+					]
+				]
+			],
+			[
+				2,
+				"cd",
+				"=",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"cd",
+						[5, "0.25"],
+						[
+							1,
+							"idx",
+							"===",
+							[5, "4"]
+						]
+					]
+				]
+			],
+			[
+				2,
+				"cd",
+				"=",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"cd",
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "0"]]
+						],
+						[
+							1,
+							"idx",
+							"===",
+							[5, "5"]
+						]
+					]
+				]
+			],
+			[
+				2,
+				"cd",
+				"=",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"cd",
+						[5, "0.0625"],
+						[
+							1,
+							"idx",
+							"===",
+							[5, "6"]
+						]
+					]
+				]
+			],
+			[
+				2,
+				"cd",
+				"=",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"cd",
+						[5, "0.4375"],
+						[
+							1,
+							"idx",
+							"===",
+							[5, "7"]
+						]
+					]
+				]
+			],
+			[
+				2,
+				"cd",
+				"=",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"cd",
+						[5, "0.6875"],
+						[
+							1,
+							"idx",
+							"===",
+							[5, "8"]
+						]
+					]
+				]
+			],
+			[
+				2,
+				"cd",
+				"=",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"cd",
+						[5, "0.1875"],
+						[
+							1,
+							"idx",
+							"===",
+							[5, "9"]
+						]
+					]
+				]
+			],
+			[
+				2,
+				"cd",
+				"=",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"cd",
+						[5, "0.125"],
+						[
+							1,
+							"idx",
+							"===",
+							[5, "10"]
+						]
+					]
+				]
+			],
+			[
+				2,
+				"cd",
+				"=",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"cd",
+						[5, "0.5"],
+						[
+							1,
+							"idx",
+							"===",
+							[5, "11"]
+						]
+					]
+				]
+			],
+			[
+				2,
+				"cd",
+				"=",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"cd",
+						[5, "0.9375"],
+						[
+							1,
+							"idx",
+							"===",
+							[5, "12"]
+						]
+					]
+				]
+			],
+			[
+				2,
+				"cd",
+				"=",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"cd",
+						[5, "0.625"],
+						[
+							1,
+							"idx",
+							"===",
+							[5, "13"]
+						]
+					]
+				]
+			],
+			[
+				2,
+				"cd",
+				"=",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"cd",
+						[5, "0.5625"],
+						[
+							1,
+							"idx",
+							"===",
+							[5, "14"]
+						]
+					]
+				]
+			],
+			[
+				2,
+				"cd",
+				"=",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"cd",
+						[5, "0.875"],
+						[
+							1,
+							"idx",
+							"===",
+							[5, "15"]
+						]
+					]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"d",
+					"vec4f"
+				],
+				[
+					"bayer2",
+					"bayer4",
+					"bayer8",
+					"cd"
+				]
+			]]
+		]],
+		"externalNames": [
+			"std",
+			"ditherBayerQuad",
+			"d"
+		]
+	},
+	externals: () => ({
+		std,
+		ditherBayerQuad,
+		d
+	})
+}) && $.f)({}));
+const ditherBlueNoise = tgpu.fn([d.vec2f], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((coord) => {
+	"use gpu";
+	const c = coord.add(d.vec2f(.5, .5));
+	return std.fract(__tsover_mul(52.9829189, std.fract(__tsover_add(__tsover_mul(c.x, .06711056), __tsover_mul(c.y, .00583715)))));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "coord"
+		}],
+		"body": [0, [[
+			13,
+			"c",
+			[
+				6,
+				[
+					7,
+					"coord",
+					"add"
+				],
+				[[
+					6,
+					[
+						7,
+						"d",
+						"vec2f"
+					],
+					[[5, "0.5"], [5, "0.5"]]
+				]]
+			]
+		], [10, [
+			6,
+			[
+				7,
+				"std",
+				"fract"
+			],
+			[[
+				1,
+				[5, "52.9829189"],
+				"*",
+				[
+					6,
+					[
+						7,
+						"std",
+						"fract"
+					],
+					[[
+						1,
+						[
+							1,
+							[
+								7,
+								"c",
+								"x"
+							],
+							"*",
+							[5, "0.06711056"]
+						],
+						"+",
+						[
+							1,
+							[
+								7,
+								"c",
+								"y"
+							],
+							"*",
+							[5, "0.00583715"]
+						]
+					]]
+				]
+			]]
+		]]]],
+		"externalNames": ["d", "std"]
+	},
+	externals: () => ({
+		d,
+		std
+	})
+}) && $.f)({}));
+const ditherWhiteNoise = tgpu.fn([d.vec2f], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((coord) => {
+	"use gpu";
+	return std.fract(__tsover_mul(std.sin(std.dot(coord, d.vec2f(12.9898, 78.233))), 43758.5453));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "coord"
+		}],
+		"body": [0, [[10, [
+			6,
+			[
+				7,
+				"std",
+				"fract"
+			],
+			[[
+				1,
+				[
+					6,
+					[
+						7,
+						"std",
+						"sin"
+					],
+					[[
+						6,
+						[
+							7,
+							"std",
+							"dot"
+						],
+						["coord", [
+							6,
+							[
+								7,
+								"d",
+								"vec2f"
+							],
+							[[5, "12.9898"], [5, "78.233"]]
+						]]
+					]]
+				],
+				"*",
+				[5, "43758.5453"]
+			]]
+		]]]],
+		"externalNames": ["std", "d"]
+	},
+	externals: () => ({
+		std,
+		d
+	})
+}) && $.f)({}));
+const ditherOrderedResult = tgpu.fn([
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32
+], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((ditherValue, luminance, threshold, spread) => {
+	"use gpu";
+	const adjustedDither = __tsover_add(.5, __tsover_mul(__tsover_sub(ditherValue, .5), spread));
+	return std.step(adjustedDither, __tsover_add(luminance, __tsover_sub(threshold, .5)));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "ditherValue"
+			},
+			{
+				"type": "i",
+				"name": "luminance"
+			},
+			{
+				"type": "i",
+				"name": "threshold"
+			},
+			{
+				"type": "i",
+				"name": "spread"
+			}
+		],
+		"body": [0, [[
+			13,
+			"adjustedDither",
+			[
+				1,
+				[5, "0.5"],
+				"+",
+				[
+					1,
+					[
+						1,
+						"ditherValue",
+						"-",
+						[5, "0.5"]
+					],
+					"*",
+					"spread"
+				]
+			]
+		], [10, [
+			6,
+			[
+				7,
+				"std",
+				"step"
+			],
+			["adjustedDither", [
+				1,
+				"luminance",
+				"+",
+				[
+					1,
+					"threshold",
+					"-",
+					[5, "0.5"]
+				]
+			]]
+		]]]],
+		"externalNames": ["std"]
+	},
+	externals: () => ({ std })
+}) && $.f)({}));
+const ditherBlockOrigin = tgpu.fn([d.vec2f], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((coord) => {
+	"use gpu";
+	return std.floor(coord.div(d.vec2f(8, 8))).mul(d.vec2f(8, 8));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "coord"
+		}],
+		"body": [0, [[10, [
+			6,
+			[
+				7,
+				[
+					6,
+					[
+						7,
+						"std",
+						"floor"
+					],
+					[[
+						6,
+						[
+							7,
+							"coord",
+							"div"
+						],
+						[[
+							6,
+							[
+								7,
+								"d",
+								"vec2f"
+							],
+							[[5, "8"], [5, "8"]]
+						]]
+					]]
+				],
+				"mul"
+			],
+			[[
+				6,
+				[
+					7,
+					"d",
+					"vec2f"
+				],
+				[[5, "8"], [5, "8"]]
+			]]
+		]]]],
+		"externalNames": ["std", "d"]
+	},
+	externals: () => ({
+		std,
+		d
+	})
+}) && $.f)({}));
+const ditherLocalCellIndex = tgpu.fn([d.vec2f, d.vec2f], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((coord, blockOrigin) => {
+	"use gpu";
+	return __tsover_add(__tsover_mul(__tsover_sub(coord.y, blockOrigin.y), 8), __tsover_sub(coord.x, blockOrigin.x));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "coord"
+		}, {
+			"type": "i",
+			"name": "blockOrigin"
+		}],
+		"body": [0, [[10, [
+			1,
+			[
+				1,
+				[
+					1,
+					[
+						7,
+						"coord",
+						"y"
+					],
+					"-",
+					[
+						7,
+						"blockOrigin",
+						"y"
+					]
+				],
+				"*",
+				[5, "8"]
+			],
+			"+",
+			[
+				1,
+				[
+					7,
+					"coord",
+					"x"
+				],
+				"-",
+				[
+					7,
+					"blockOrigin",
+					"x"
+				]
+			]
+		]]]],
+		"externalNames": []
+	},
+	externals: () => ({})
+}) && $.f)({}));
+const ditherCellUV = tgpu.fn([
+	d.vec2f,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.vec2f
+], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((blockOrigin, lx, ly, pixelSize, gridRes) => {
+	"use gpu";
+	return d.vec2f(__tsover_div(__tsover_mul(__tsover_add(__tsover_add(blockOrigin.x, lx), .5), pixelSize), gridRes.x), __tsover_div(__tsover_mul(__tsover_add(__tsover_add(blockOrigin.y, ly), .5), pixelSize), gridRes.y));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "blockOrigin"
+			},
+			{
+				"type": "i",
+				"name": "lx"
+			},
+			{
+				"type": "i",
+				"name": "ly"
+			},
+			{
+				"type": "i",
+				"name": "pixelSize"
+			},
+			{
+				"type": "i",
+				"name": "gridRes"
+			}
+		],
+		"body": [0, [[10, [
+			6,
+			[
+				7,
+				"d",
+				"vec2f"
+			],
+			[[
+				1,
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								7,
+								"blockOrigin",
+								"x"
+							],
+							"+",
+							"lx"
+						],
+						"+",
+						[5, "0.5"]
+					],
+					"*",
+					"pixelSize"
+				],
+				"/",
+				[
+					7,
+					"gridRes",
+					"x"
+				]
+			], [
+				1,
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								7,
+								"blockOrigin",
+								"y"
+							],
+							"+",
+							"ly"
+						],
+						"+",
+						[5, "0.5"]
+					],
+					"*",
+					"pixelSize"
+				],
+				"/",
+				[
+					7,
+					"gridRes",
+					"y"
+				]
+			]]
+		]]]],
+		"externalNames": ["d"]
+	},
+	externals: () => ({ d })
+}) && $.f)({}));
+const ditherFloydSteinberg = tgpu.fn([
+	d.arrayOf(d.f32, 64),
+	d.f32,
+	d.f32,
+	d.f32
+], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((lum, lic, threshold, spread) => {
+	"use gpu";
+	const thr = __tsover_sub(.5, __tsover_sub(threshold, .5));
+	const ecur = d.arrayOf(d.f32, 8)();
+	const enext = d.arrayOf(d.f32, 8)();
+	const licInt = d.i32(lic);
+	let result = d.f32(0);
+	for (let y = 0; y < 8; y++) {
+		const ltr = (y & 1) === 0;
+		for (let xi = 0; xi < 8; xi++) {
+			const x = std.select(__tsover_sub(7, xi), xi, ltr);
+			const idx = __tsover_add(__tsover_mul(y, 8), x);
+			const val = __tsover_add(lum[idx], ecur[x]);
+			const qv = std.step(thr, val);
+			result = std.select(result, qv, idx === licInt);
+			const e = __tsover_mul(__tsover_sub(val, qv), spread);
+			const dir = std.select(-1, 1, ltr);
+			const xr = __tsover_add(x, dir);
+			if (xr >= 0) {
+				if (xr < 8) ecur[xr] = __tsover_add(ecur[xr], __tsover_mul(e, .4375));
+			}
+			if (y < 7) {
+				const xbl = __tsover_sub(x, dir);
+				const xbr = __tsover_add(x, dir);
+				if (xbl >= 0) {
+					if (xbl < 8) enext[xbl] = __tsover_add(enext[xbl], __tsover_mul(e, .1875));
+				}
+				enext[x] = __tsover_add(enext[x], __tsover_mul(e, .3125));
+				if (xbr >= 0) {
+					if (xbr < 8) enext[xbr] = __tsover_add(enext[xbr], __tsover_mul(e, .0625));
+				}
+			}
+		}
+		for (let k = 0; k < 8; k++) {
+			ecur[k] = enext[k];
+			enext[k] = d.f32(0);
+		}
+	}
+	return result;
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "lum"
+			},
+			{
+				"type": "i",
+				"name": "lic"
+			},
+			{
+				"type": "i",
+				"name": "threshold"
+			},
+			{
+				"type": "i",
+				"name": "spread"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"thr",
+				[
+					1,
+					[5, "0.5"],
+					"-",
+					[
+						1,
+						"threshold",
+						"-",
+						[5, "0.5"]
+					]
+				]
+			],
+			[
+				13,
+				"ecur",
+				[
+					6,
+					[
+						6,
+						[
+							7,
+							"d",
+							"arrayOf"
+						],
+						[[
+							7,
+							"d",
+							"f32"
+						], [5, "8"]]
+					],
+					[]
+				]
+			],
+			[
+				13,
+				"enext",
+				[
+					6,
+					[
+						6,
+						[
+							7,
+							"d",
+							"arrayOf"
+						],
+						[[
+							7,
+							"d",
+							"f32"
+						], [5, "8"]]
+					],
+					[]
+				]
+			],
+			[
+				13,
+				"licInt",
+				[
+					6,
+					[
+						7,
+						"d",
+						"i32"
+					],
+					["lic"]
+				]
+			],
+			[
+				12,
+				"result",
+				[
+					6,
+					[
+						7,
+						"d",
+						"f32"
+					],
+					[[5, "0"]]
+				]
+			],
+			[
+				14,
+				[
+					12,
+					"y",
+					[5, "0"]
+				],
+				[
+					1,
+					"y",
+					"<",
+					[5, "8"]
+				],
+				[
+					102,
+					"++",
+					"y"
+				],
+				[0, [
+					[
+						13,
+						"ltr",
+						[
+							1,
+							[
+								1,
+								"y",
+								"&",
+								[5, "1"]
+							],
+							"===",
+							[5, "0"]
+						]
+					],
+					[
+						14,
+						[
+							12,
+							"xi",
+							[5, "0"]
+						],
+						[
+							1,
+							"xi",
+							"<",
+							[5, "8"]
+						],
+						[
+							102,
+							"++",
+							"xi"
+						],
+						[0, [
+							[
+								13,
+								"x",
+								[
+									6,
+									[
+										7,
+										"std",
+										"select"
+									],
+									[
+										[
+											1,
+											[5, "7"],
+											"-",
+											"xi"
+										],
+										"xi",
+										"ltr"
+									]
+								]
+							],
+							[
+								13,
+								"idx",
+								[
+									1,
+									[
+										1,
+										"y",
+										"*",
+										[5, "8"]
+									],
+									"+",
+									"x"
+								]
+							],
+							[
+								13,
+								"val",
+								[
+									1,
+									[
+										8,
+										"lum",
+										"idx"
+									],
+									"+",
+									[
+										8,
+										"ecur",
+										"x"
+									]
+								]
+							],
+							[
+								13,
+								"qv",
+								[
+									6,
+									[
+										7,
+										"std",
+										"step"
+									],
+									["thr", "val"]
+								]
+							],
+							[
+								2,
+								"result",
+								"=",
+								[
+									6,
+									[
+										7,
+										"std",
+										"select"
+									],
+									[
+										"result",
+										"qv",
+										[
+											1,
+											"idx",
+											"===",
+											"licInt"
+										]
+									]
+								]
+							],
+							[
+								13,
+								"e",
+								[
+									1,
+									[
+										1,
+										"val",
+										"-",
+										"qv"
+									],
+									"*",
+									"spread"
+								]
+							],
+							[
+								13,
+								"dir",
+								[
+									6,
+									[
+										7,
+										"std",
+										"select"
+									],
+									[
+										[
+											4,
+											"-",
+											[5, "1"]
+										],
+										[5, "1"],
+										"ltr"
+									]
+								]
+							],
+							[
+								13,
+								"xr",
+								[
+									1,
+									"x",
+									"+",
+									"dir"
+								]
+							],
+							[
+								11,
+								[
+									1,
+									"xr",
+									">=",
+									[5, "0"]
+								],
+								[0, [[
+									11,
+									[
+										1,
+										"xr",
+										"<",
+										[5, "8"]
+									],
+									[0, [[
+										2,
+										[
+											8,
+											"ecur",
+											"xr"
+										],
+										"=",
+										[
+											1,
+											[
+												8,
+												"ecur",
+												"xr"
+											],
+											"+",
+											[
+												1,
+												"e",
+												"*",
+												[5, "0.4375"]
+											]
+										]
+									]]]
+								]]]
+							],
+							[
+								11,
+								[
+									1,
+									"y",
+									"<",
+									[5, "7"]
+								],
+								[0, [
+									[
+										13,
+										"xbl",
+										[
+											1,
+											"x",
+											"-",
+											"dir"
+										]
+									],
+									[
+										13,
+										"xbr",
+										[
+											1,
+											"x",
+											"+",
+											"dir"
+										]
+									],
+									[
+										11,
+										[
+											1,
+											"xbl",
+											">=",
+											[5, "0"]
+										],
+										[0, [[
+											11,
+											[
+												1,
+												"xbl",
+												"<",
+												[5, "8"]
+											],
+											[0, [[
+												2,
+												[
+													8,
+													"enext",
+													"xbl"
+												],
+												"=",
+												[
+													1,
+													[
+														8,
+														"enext",
+														"xbl"
+													],
+													"+",
+													[
+														1,
+														"e",
+														"*",
+														[5, "0.1875"]
+													]
+												]
+											]]]
+										]]]
+									],
+									[
+										2,
+										[
+											8,
+											"enext",
+											"x"
+										],
+										"=",
+										[
+											1,
+											[
+												8,
+												"enext",
+												"x"
+											],
+											"+",
+											[
+												1,
+												"e",
+												"*",
+												[5, "0.3125"]
+											]
+										]
+									],
+									[
+										11,
+										[
+											1,
+											"xbr",
+											">=",
+											[5, "0"]
+										],
+										[0, [[
+											11,
+											[
+												1,
+												"xbr",
+												"<",
+												[5, "8"]
+											],
+											[0, [[
+												2,
+												[
+													8,
+													"enext",
+													"xbr"
+												],
+												"=",
+												[
+													1,
+													[
+														8,
+														"enext",
+														"xbr"
+													],
+													"+",
+													[
+														1,
+														"e",
+														"*",
+														[5, "0.0625"]
+													]
+												]
+											]]]
+										]]]
+									]
+								]]
+							]
+						]]
+					],
+					[
+						14,
+						[
+							12,
+							"k",
+							[5, "0"]
+						],
+						[
+							1,
+							"k",
+							"<",
+							[5, "8"]
+						],
+						[
+							102,
+							"++",
+							"k"
+						],
+						[0, [[
+							2,
+							[
+								8,
+								"ecur",
+								"k"
+							],
+							"=",
+							[
+								8,
+								"enext",
+								"k"
+							]
+						], [
+							2,
+							[
+								8,
+								"enext",
+								"k"
+							],
+							"=",
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								[[5, "0"]]
+							]
+						]]]
+					]
+				]]
+			],
+			[10, "result"]
+		]],
+		"externalNames": ["d", "std"]
+	},
+	externals: () => ({
+		d,
+		std
+	})
+}) && $.f)({}));
+const ditherComposeCustom = tgpu.fn([
+	d.vec4f,
+	d.vec4f,
+	d.f32
+], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((colorA, colorB, ditherResult) => {
+	"use gpu";
+	const rgb = std.mix(d.vec3f(colorA.x, colorA.y, colorA.z), d.vec3f(colorB.x, colorB.y, colorB.z), d.vec3f(ditherResult));
+	const a = std.mix(colorA.w, colorB.w, ditherResult);
+	return d.vec4f(rgb.x, rgb.y, rgb.z, a);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "colorA"
+			},
+			{
+				"type": "i",
+				"name": "colorB"
+			},
+			{
+				"type": "i",
+				"name": "ditherResult"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"rgb",
+				[
+					6,
+					[
+						7,
+						"std",
+						"mix"
+					],
+					[
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec3f"
+							],
+							[
+								[
+									7,
+									"colorA",
+									"x"
+								],
+								[
+									7,
+									"colorA",
+									"y"
+								],
+								[
+									7,
+									"colorA",
+									"z"
+								]
+							]
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec3f"
+							],
+							[
+								[
+									7,
+									"colorB",
+									"x"
+								],
+								[
+									7,
+									"colorB",
+									"y"
+								],
+								[
+									7,
+									"colorB",
+									"z"
+								]
+							]
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec3f"
+							],
+							["ditherResult"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"a",
+				[
+					6,
+					[
+						7,
+						"std",
+						"mix"
+					],
+					[
+						[
+							7,
+							"colorA",
+							"w"
+						],
+						[
+							7,
+							"colorB",
+							"w"
+						],
+						"ditherResult"
+					]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"d",
+					"vec4f"
+				],
+				[
+					[
+						7,
+						"rgb",
+						"x"
+					],
+					[
+						7,
+						"rgb",
+						"y"
+					],
+					[
+						7,
+						"rgb",
+						"z"
+					],
+					"a"
+				]
+			]]
+		]],
+		"externalNames": ["std", "d"]
+	},
+	externals: () => ({
+		std,
+		d
+	})
+}) && $.f)({}));
+const ditherComposeSource = tgpu.fn([d.vec4f, d.f32], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sourceColor, ditherResult) => {
+	"use gpu";
+	const rgb = d.vec3f(sourceColor.x, sourceColor.y, sourceColor.z);
+	const dark = rgb.mul(.3);
+	const bright = std.min(rgb.mul(1.3), d.vec3f(1, 1, 1));
+	const out = std.mix(dark, bright, d.vec3f(ditherResult));
+	return d.vec4f(out.x, out.y, out.z, sourceColor.w);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "sourceColor"
+		}, {
+			"type": "i",
+			"name": "ditherResult"
+		}],
+		"body": [0, [
+			[
+				13,
+				"rgb",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec3f"
+					],
+					[
+						[
+							7,
+							"sourceColor",
+							"x"
+						],
+						[
+							7,
+							"sourceColor",
+							"y"
+						],
+						[
+							7,
+							"sourceColor",
+							"z"
+						]
+					]
+				]
+			],
+			[
+				13,
+				"dark",
+				[
+					6,
+					[
+						7,
+						"rgb",
+						"mul"
+					],
+					[[5, "0.3"]]
+				]
+			],
+			[
+				13,
+				"bright",
+				[
+					6,
+					[
+						7,
+						"std",
+						"min"
+					],
+					[[
+						6,
+						[
+							7,
+							"rgb",
+							"mul"
+						],
+						[[5, "1.3"]]
+					], [
+						6,
+						[
+							7,
+							"d",
+							"vec3f"
+						],
+						[
+							[5, "1"],
+							[5, "1"],
+							[5, "1"]
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"out",
+				[
+					6,
+					[
+						7,
+						"std",
+						"mix"
+					],
+					[
+						"dark",
+						"bright",
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec3f"
+							],
+							["ditherResult"]
+						]
+					]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"d",
+					"vec4f"
+				],
+				[
+					[
+						7,
+						"out",
+						"x"
+					],
+					[
+						7,
+						"out",
+						"y"
+					],
+					[
+						7,
+						"out",
+						"z"
+					],
+					[
+						7,
+						"sourceColor",
+						"w"
+					]
+				]
+			]]
+		]],
+		"externalNames": ["d", "std"]
+	},
+	externals: () => ({
+		d,
+		std
+	})
+}) && $.f)({}));
+const componentDefinition = {
+	name: "Dither",
+	category: "Stylize",
+	description: "Dithering effect with multiple pattern options",
+	requiresRTT: true,
+	requiresChild: true,
+	blendWithChildren: false,
+	boundingBoxDeclaration: { aspectRatio: null },
+	props: {
+		pattern: {
+			default: "bayer4",
+			transform: transformPattern,
+			compileTime: true,
+			description: "Dithering pattern algorithm",
+			ui: {
+				type: "select",
+				options: [
+					{
+						label: "Bayer 2x2",
+						value: "bayer2"
+					},
+					{
+						label: "Bayer 4x4",
+						value: "bayer4"
+					},
+					{
+						label: "Bayer 8x8",
+						value: "bayer8"
+					},
+					{
+						label: "Clustered Dot",
+						value: "clusteredDot"
+					},
+					{
+						label: "Blue Noise",
+						value: "blueNoise"
+					},
+					{
+						label: "White Noise",
+						value: "whiteNoise"
+					},
+					{
+						label: "Floyd-Steinberg",
+						value: "floydSteinberg"
+					}
+				],
+				label: "Pattern",
+				group: "Effect"
+			}
+		},
+		pixelSize: {
+			default: 4,
+			description: "Size of dithering pixels",
+			ui: {
+				type: "range",
+				min: 1,
+				max: 20,
+				step: 1,
+				label: "Pixel Size",
+				group: "Effect"
+			}
+		},
+		threshold: {
+			default: .5,
+			description: "Luminance threshold for dithering",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Threshold",
+				group: "Effect"
+			}
+		},
+		spread: {
+			default: 1,
+			description: "How much of the luminance range participates in dithering (lower = more solid areas)",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Spread",
+				group: "Effect"
+			}
+		},
+		colorMode: {
+			default: "custom",
+			transform: transformColorMode,
+			compileTime: true,
+			description: "How colors are determined",
+			ui: {
+				type: "select",
+				options: [{
+					label: "Custom Colors",
+					value: "custom"
+				}, {
+					label: "Source Colors",
+					value: "source"
+				}],
+				label: "Color Mode",
+				group: "Colors"
+			}
+		},
+		colorA: {
+			default: "transparent",
+			transform: transformColor,
+			description: "Dark color for dithering",
+			ui: {
+				type: "color",
+				label: "Dark Color",
+				condition: { colorMode: "custom" },
+				group: "Colors"
+			}
+		},
+		colorB: {
+			default: "#ffffff",
+			transform: transformColor,
+			description: "Light color for dithering",
+			ui: {
+				type: "color",
+				label: "Light Color",
+				condition: { colorMode: "custom" },
+				group: "Colors"
+			}
+		}
+	},
+	fragment: ({ childNode, ctx, uniforms, propValues, convertToTexture }) => {
+		if (!childNode) return ZERO;
+		const texture = convertToTexture(childNode);
+		const unpremult = (uv) => call(unpremultiplyAlpha, "unpremultiplyAlpha", [texture.sample(uv)]);
+		const gridRes = ctx.logicalViewportSize;
+		const pixelSize = uniforms.pixelSize;
+		const threshold = uniforms.threshold;
+		const spread = uniforms.spread;
+		const coord = call(ditherCoord, "ditherCoord", [
+			ctx.uv,
+			gridRes,
+			pixelSize
+		]);
+		const sourceColor = unpremult(call(ditherPixUV, "ditherPixUV", [
+			coord,
+			pixelSize,
+			gridRes
+		]));
+		const luminance = call(ditherLuma, "ditherLuma", [sourceColor]);
+		const pattern = patternModeOf(propValues.pattern);
+		let ditherResult;
+		if (pattern === 6) {
+			const blockOrigin = call(ditherBlockOrigin, "ditherBlockOrigin", [coord]);
+			const lic = call(ditherLocalCellIndex, "ditherLocalCellIndex", [coord, blockOrigin]);
+			const lums = [];
+			for (let ly = 0; ly < 8; ly++) for (let lx = 0; lx < 8; lx++) {
+				const cellUV = call(ditherCellUV, "ditherCellUV", [
+					blockOrigin,
+					floatE(lx),
+					floatE(ly),
+					pixelSize,
+					gridRes
+				]);
+				lums.push(call(ditherLuma, "ditherLuma", [unpremult(cellUV)]));
+			}
+			ditherResult = call(ditherFloydSteinberg, "ditherFloydSteinberg", [
+				arrayExpr("f32", lums),
+				lic,
+				threshold,
+				spread
+			]);
+		} else {
+			const periodic = call(ditherPeriodic, "ditherPeriodic", [coord]);
+			let ditherValue;
+			switch (pattern) {
+				case 0:
+					ditherValue = periodic.member("x");
+					break;
+				case 1:
+					ditherValue = periodic.member("y");
+					break;
+				case 2:
+					ditherValue = periodic.member("z");
+					break;
+				case 3:
+					ditherValue = periodic.member("w");
+					break;
+				case 4:
+					ditherValue = call(ditherBlueNoise, "ditherBlueNoise", [coord]);
+					break;
+				default: ditherValue = call(ditherWhiteNoise, "ditherWhiteNoise", [coord]);
+			}
+			ditherResult = call(ditherOrderedResult, "ditherOrderedResult", [
+				ditherValue,
+				luminance,
+				threshold,
+				spread
+			]);
+		}
+		if (colorModeOf(propValues.colorMode) === 0) return call(ditherComposeCustom, "ditherComposeCustom", [
+			uniforms.colorA,
+			uniforms.colorB,
+			ditherResult
+		]);
+		return call(ditherComposeSource, "ditherComposeSource", [sourceColor, ditherResult]);
+	}
+};
+var Dither_default = componentDefinition;
+export { ditherBlueNoise as a, ditherComposeSource as c, ditherLocalCellIndex as d, ditherLuma as f, ditherWhiteNoise as g, ditherPixUV as h, ditherBlockOrigin as i, ditherCoord as l, ditherPeriodic as m, componentDefinition as n, ditherCellUV as o, ditherOrderedResult as p, ditherBayerQuad as r, ditherComposeCustom as s, Dither_default as t, ditherFloydSteinberg as u };