shaders 2.5.135 → 3.0.436

package/dist/core/CompressionArtifacts-QK7Dgm-z.js

@@ -0,0 +1,2289 @@
+import { At as call, B as createGuardedCompute, It as vec4, Ot as ZERO, R as std, Ut as blend_exports, Wt as unpremultiplyAlpha, n as tgpu, on as d } from "./coords-BxHv8WrA.js";
+var LUMA_QUANT = [
+	16,
+	11,
+	10,
+	16,
+	24,
+	40,
+	51,
+	61,
+	12,
+	12,
+	14,
+	19,
+	26,
+	58,
+	60,
+	55,
+	14,
+	13,
+	16,
+	24,
+	40,
+	57,
+	69,
+	56,
+	14,
+	17,
+	22,
+	29,
+	51,
+	87,
+	80,
+	62,
+	18,
+	22,
+	37,
+	56,
+	68,
+	109,
+	103,
+	77,
+	24,
+	35,
+	55,
+	64,
+	81,
+	104,
+	113,
+	92,
+	49,
+	64,
+	78,
+	87,
+	103,
+	121,
+	120,
+	101,
+	72,
+	92,
+	95,
+	98,
+	112,
+	100,
+	103,
+	99
+];
+var CHROMA_QUANT = [
+	17,
+	18,
+	24,
+	47,
+	99,
+	99,
+	99,
+	99,
+	18,
+	21,
+	26,
+	66,
+	99,
+	99,
+	99,
+	99,
+	24,
+	26,
+	56,
+	99,
+	99,
+	99,
+	99,
+	99,
+	47,
+	66,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99
+];
+var COS_LUT_FLAT = [];
+for (let k = 0; k < 8; k++) for (let u = 0; u < 8; u++) COS_LUT_FLAT[k * 8 + u] = Math.cos((2 * k + 1) * u * Math.PI / 16);
+var SQRT1_2 = Math.SQRT1_2;
+var PI_OVER_16 = Math.PI / 16;
+var COS_LUT = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.const(d.arrayOf(d.f32, 64), COS_LUT_FLAT), "COS_LUT");
+var LUMA_QUANT_C = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.const(d.arrayOf(d.f32, 64), LUMA_QUANT), "LUMA_QUANT_C");
+var CHROMA_QUANT_C = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.const(d.arrayOf(d.f32, 64), CHROMA_QUANT), "CHROMA_QUANT_C");
+var N_LUMA = 6;
+var SCALE_N = 4;
+var BLOCK_PX = 8 * SCALE_N;
+var STRIDE = SCALE_N;
+var MAX_CELLS = 1024;
+var CELL_FORMAT = "rgba16float";
+const jpegBlockRgb = tgpu.fn([
+	d.arrayOf(d.vec3f, 64),
+	d.f32,
+	d.f32,
+	d.f32
+], d.vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((block, localX, localY, quality) => {
+	"use gpu";
+	const qualityC = std.clamp(quality, 1, 100);
+	const qScale = std.select(__tsover_sub(200, __tsover_mul(qualityC, 2)), __tsover_div(5e3, qualityC), qualityC < 50);
+	const Yv = d.arrayOf(d.f32, 64)();
+	const Cbv = d.arrayOf(d.f32, 64)();
+	const Crv = d.arrayOf(d.f32, 64)();
+	for (let i = 0; i < 64; i++) {
+		const c = block[i];
+		Yv[i] = __tsover_sub(__tsover_add(__tsover_add(__tsover_mul(c.x, .299), __tsover_mul(c.y, .587)), __tsover_mul(c.z, .114)), .5);
+		Cbv[i] = __tsover_add(__tsover_add(__tsover_mul(c.x, -.168736), __tsover_mul(c.y, -.331264)), __tsover_mul(c.z, .5));
+		Crv[i] = __tsover_add(__tsover_add(__tsover_mul(c.x, .5), __tsover_mul(c.y, -.418688)), __tsover_mul(c.z, -.081312));
+	}
+	const rowCoef = d.arrayOf(d.f32, __tsover_mul(8, N_LUMA))();
+	for (let y = 0; y < 8; y++) for (let u = 0; u < N_LUMA; u++) {
+		let sum = d.f32(0);
+		for (let x = 0; x < 8; x++) sum = __tsover_add(sum, __tsover_mul(Yv[__tsover_add(__tsover_mul(y, 8), x)], COS_LUT.$[__tsover_add(__tsover_mul(x, 8), u)]));
+		rowCoef[__tsover_add(__tsover_mul(y, N_LUMA), u)] = sum;
+	}
+	let acc = d.f32(0);
+	for (let v = 0; v < N_LUMA; v++) {
+		const av = std.select(1, SQRT1_2, v === 0);
+		const cy = std.cos(__tsover_mul(__tsover_add(__tsover_mul(localY, 2), 1), __tsover_mul(d.f32(v), PI_OVER_16)));
+		for (let u = 0; u < N_LUMA; u++) {
+			const au = std.select(1, SQRT1_2, u === 0);
+			let colSum = d.f32(0);
+			for (let y = 0; y < 8; y++) colSum = __tsover_add(colSum, __tsover_mul(rowCoef[__tsover_add(__tsover_mul(y, N_LUMA), u)], COS_LUT.$[__tsover_add(__tsover_mul(y, 8), v)]));
+			const G = __tsover_mul(colSum, __tsover_mul(__tsover_mul(.25, au), av));
+			const q = __tsover_div(std.clamp(std.floor(__tsover_div(__tsover_add(__tsover_mul(qScale, LUMA_QUANT_C.$[__tsover_add(__tsover_mul(v, 8), u)]), 50), 100)), 1, 255), 255);
+			const Gq = __tsover_mul(std.floor(__tsover_add(__tsover_div(G, q), .5)), q);
+			const cx = std.cos(__tsover_mul(__tsover_add(__tsover_mul(localX, 2), 1), __tsover_mul(d.f32(u), PI_OVER_16)));
+			acc = __tsover_add(acc, __tsover_mul(__tsover_mul(__tsover_mul(Gq, __tsover_mul(au, av)), cx), cy));
+		}
+	}
+	const Y = __tsover_add(__tsover_mul(acc, .25), .5);
+	let sumCb = d.f32(0);
+	let sumCr = d.f32(0);
+	for (let i = 0; i < 64; i++) {
+		sumCb = __tsover_add(sumCb, Cbv[i]);
+		sumCr = __tsover_add(sumCr, Crv[i]);
+	}
+	const qChroma = __tsover_div(std.clamp(std.floor(__tsover_div(__tsover_add(__tsover_mul(qScale, CHROMA_QUANT_C.$[0]), 50), 100)), 1, 255), 255);
+	const GdcCb = __tsover_div(sumCb, 8);
+	const GdcCr = __tsover_div(sumCr, 8);
+	const Cb = __tsover_div(__tsover_mul(std.floor(__tsover_add(__tsover_div(GdcCb, qChroma), .5)), qChroma), 8);
+	const Cr = __tsover_div(__tsover_mul(std.floor(__tsover_add(__tsover_div(GdcCr, qChroma), .5)), qChroma), 8);
+	const r = __tsover_add(Y, __tsover_mul(Cr, 1.402));
+	const g = __tsover_sub(__tsover_sub(Y, __tsover_mul(Cb, .344136)), __tsover_mul(Cr, .714136));
+	const b = __tsover_add(Y, __tsover_mul(Cb, 1.772));
+	return std.clamp(d.vec3f(r, g, b), d.vec3f(0, 0, 0), d.vec3f(1, 1, 1));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "block"
+			},
+			{
+				"type": "i",
+				"name": "localX"
+			},
+			{
+				"type": "i",
+				"name": "localY"
+			},
+			{
+				"type": "i",
+				"name": "quality"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"qualityC",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						"quality",
+						[5, "1"],
+						[5, "100"]
+					]
+				]
+			],
+			[
+				13,
+				"qScale",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						[
+							1,
+							[5, "200"],
+							"-",
+							[
+								1,
+								"qualityC",
+								"*",
+								[5, "2"]
+							]
+						],
+						[
+							1,
+							[5, "5000"],
+							"/",
+							"qualityC"
+						],
+						[
+							1,
+							"qualityC",
+							"<",
+							[5, "50"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"Yv",
+				[
+					6,
+					[
+						6,
+						[
+							7,
+							"d",
+							"arrayOf"
+						],
+						[[
+							7,
+							"d",
+							"f32"
+						], [5, "64"]]
+					],
+					[]
+				]
+			],
+			[
+				13,
+				"Cbv",
+				[
+					6,
+					[
+						6,
+						[
+							7,
+							"d",
+							"arrayOf"
+						],
+						[[
+							7,
+							"d",
+							"f32"
+						], [5, "64"]]
+					],
+					[]
+				]
+			],
+			[
+				13,
+				"Crv",
+				[
+					6,
+					[
+						6,
+						[
+							7,
+							"d",
+							"arrayOf"
+						],
+						[[
+							7,
+							"d",
+							"f32"
+						], [5, "64"]]
+					],
+					[]
+				]
+			],
+			[
+				14,
+				[
+					12,
+					"i",
+					[5, "0"]
+				],
+				[
+					1,
+					"i",
+					"<",
+					[5, "64"]
+				],
+				[
+					102,
+					"++",
+					"i"
+				],
+				[0, [
+					[
+						13,
+						"c",
+						[
+							8,
+							"block",
+							"i"
+						]
+					],
+					[
+						2,
+						[
+							8,
+							"Yv",
+							"i"
+						],
+						"=",
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									[
+										1,
+										[
+											7,
+											"c",
+											"x"
+										],
+										"*",
+										[5, "0.299"]
+									],
+									"+",
+									[
+										1,
+										[
+											7,
+											"c",
+											"y"
+										],
+										"*",
+										[5, "0.587"]
+									]
+								],
+								"+",
+								[
+									1,
+									[
+										7,
+										"c",
+										"z"
+									],
+									"*",
+									[5, "0.114"]
+								]
+							],
+							"-",
+							[5, "0.5"]
+						]
+					],
+					[
+						2,
+						[
+							8,
+							"Cbv",
+							"i"
+						],
+						"=",
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									[
+										7,
+										"c",
+										"x"
+									],
+									"*",
+									[
+										4,
+										"-",
+										[5, "0.168736"]
+									]
+								],
+								"+",
+								[
+									1,
+									[
+										7,
+										"c",
+										"y"
+									],
+									"*",
+									[
+										4,
+										"-",
+										[5, "0.331264"]
+									]
+								]
+							],
+							"+",
+							[
+								1,
+								[
+									7,
+									"c",
+									"z"
+								],
+								"*",
+								[5, "0.5"]
+							]
+						]
+					],
+					[
+						2,
+						[
+							8,
+							"Crv",
+							"i"
+						],
+						"=",
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									[
+										7,
+										"c",
+										"x"
+									],
+									"*",
+									[5, "0.5"]
+								],
+								"+",
+								[
+									1,
+									[
+										7,
+										"c",
+										"y"
+									],
+									"*",
+									[
+										4,
+										"-",
+										[5, "0.418688"]
+									]
+								]
+							],
+							"+",
+							[
+								1,
+								[
+									7,
+									"c",
+									"z"
+								],
+								"*",
+								[
+									4,
+									"-",
+									[5, "0.081312"]
+								]
+							]
+						]
+					]
+				]]
+			],
+			[
+				13,
+				"rowCoef",
+				[
+					6,
+					[
+						6,
+						[
+							7,
+							"d",
+							"arrayOf"
+						],
+						[[
+							7,
+							"d",
+							"f32"
+						], [
+							1,
+							[5, "8"],
+							"*",
+							"N_LUMA"
+						]]
+					],
+					[]
+				]
+			],
+			[
+				14,
+				[
+					12,
+					"y",
+					[5, "0"]
+				],
+				[
+					1,
+					"y",
+					"<",
+					[5, "8"]
+				],
+				[
+					102,
+					"++",
+					"y"
+				],
+				[0, [[
+					14,
+					[
+						12,
+						"u",
+						[5, "0"]
+					],
+					[
+						1,
+						"u",
+						"<",
+						"N_LUMA"
+					],
+					[
+						102,
+						"++",
+						"u"
+					],
+					[0, [
+						[
+							12,
+							"sum",
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								[[5, "0"]]
+							]
+						],
+						[
+							14,
+							[
+								12,
+								"x",
+								[5, "0"]
+							],
+							[
+								1,
+								"x",
+								"<",
+								[5, "8"]
+							],
+							[
+								102,
+								"++",
+								"x"
+							],
+							[
+								2,
+								"sum",
+								"=",
+								[
+									1,
+									"sum",
+									"+",
+									[
+										1,
+										[
+											8,
+											"Yv",
+											[
+												1,
+												[
+													1,
+													"y",
+													"*",
+													[5, "8"]
+												],
+												"+",
+												"x"
+											]
+										],
+										"*",
+										[
+											8,
+											[
+												7,
+												"COS_LUT",
+												"$"
+											],
+											[
+												1,
+												[
+													1,
+													"x",
+													"*",
+													[5, "8"]
+												],
+												"+",
+												"u"
+											]
+										]
+									]
+								]
+							]
+						],
+						[
+							2,
+							[
+								8,
+								"rowCoef",
+								[
+									1,
+									[
+										1,
+										"y",
+										"*",
+										"N_LUMA"
+									],
+									"+",
+									"u"
+								]
+							],
+							"=",
+							"sum"
+						]
+					]]
+				]]]
+			],
+			[
+				12,
+				"acc",
+				[
+					6,
+					[
+						7,
+						"d",
+						"f32"
+					],
+					[[5, "0"]]
+				]
+			],
+			[
+				14,
+				[
+					12,
+					"v",
+					[5, "0"]
+				],
+				[
+					1,
+					"v",
+					"<",
+					"N_LUMA"
+				],
+				[
+					102,
+					"++",
+					"v"
+				],
+				[0, [
+					[
+						13,
+						"av",
+						[
+							6,
+							[
+								7,
+								"std",
+								"select"
+							],
+							[
+								[5, "1"],
+								"SQRT1_2",
+								[
+									1,
+									"v",
+									"===",
+									[5, "0"]
+								]
+							]
+						]
+					],
+					[
+						13,
+						"cy",
+						[
+							6,
+							[
+								7,
+								"std",
+								"cos"
+							],
+							[[
+								1,
+								[
+									1,
+									[
+										1,
+										"localY",
+										"*",
+										[5, "2"]
+									],
+									"+",
+									[5, "1"]
+								],
+								"*",
+								[
+									1,
+									[
+										6,
+										[
+											7,
+											"d",
+											"f32"
+										],
+										["v"]
+									],
+									"*",
+									"PI_OVER_16"
+								]
+							]]
+						]
+					],
+					[
+						14,
+						[
+							12,
+							"u",
+							[5, "0"]
+						],
+						[
+							1,
+							"u",
+							"<",
+							"N_LUMA"
+						],
+						[
+							102,
+							"++",
+							"u"
+						],
+						[0, [
+							[
+								13,
+								"au",
+								[
+									6,
+									[
+										7,
+										"std",
+										"select"
+									],
+									[
+										[5, "1"],
+										"SQRT1_2",
+										[
+											1,
+											"u",
+											"===",
+											[5, "0"]
+										]
+									]
+								]
+							],
+							[
+								12,
+								"colSum",
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									[[5, "0"]]
+								]
+							],
+							[
+								14,
+								[
+									12,
+									"y",
+									[5, "0"]
+								],
+								[
+									1,
+									"y",
+									"<",
+									[5, "8"]
+								],
+								[
+									102,
+									"++",
+									"y"
+								],
+								[
+									2,
+									"colSum",
+									"=",
+									[
+										1,
+										"colSum",
+										"+",
+										[
+											1,
+											[
+												8,
+												"rowCoef",
+												[
+													1,
+													[
+														1,
+														"y",
+														"*",
+														"N_LUMA"
+													],
+													"+",
+													"u"
+												]
+											],
+											"*",
+											[
+												8,
+												[
+													7,
+													"COS_LUT",
+													"$"
+												],
+												[
+													1,
+													[
+														1,
+														"y",
+														"*",
+														[5, "8"]
+													],
+													"+",
+													"v"
+												]
+											]
+										]
+									]
+								]
+							],
+							[
+								13,
+								"G",
+								[
+									1,
+									"colSum",
+									"*",
+									[
+										1,
+										[
+											1,
+											[5, "0.25"],
+											"*",
+											"au"
+										],
+										"*",
+										"av"
+									]
+								]
+							],
+							[
+								13,
+								"q",
+								[
+									1,
+									[
+										6,
+										[
+											7,
+											"std",
+											"clamp"
+										],
+										[
+											[
+												6,
+												[
+													7,
+													"std",
+													"floor"
+												],
+												[[
+													1,
+													[
+														1,
+														[
+															1,
+															"qScale",
+															"*",
+															[
+																8,
+																[
+																	7,
+																	"LUMA_QUANT_C",
+																	"$"
+																],
+																[
+																	1,
+																	[
+																		1,
+																		"v",
+																		"*",
+																		[5, "8"]
+																	],
+																	"+",
+																	"u"
+																]
+															]
+														],
+														"+",
+														[5, "50"]
+													],
+													"/",
+													[5, "100"]
+												]]
+											],
+											[5, "1"],
+											[5, "255"]
+										]
+									],
+									"/",
+									[5, "255"]
+								]
+							],
+							[
+								13,
+								"Gq",
+								[
+									1,
+									[
+										6,
+										[
+											7,
+											"std",
+											"floor"
+										],
+										[[
+											1,
+											[
+												1,
+												"G",
+												"/",
+												"q"
+											],
+											"+",
+											[5, "0.5"]
+										]]
+									],
+									"*",
+									"q"
+								]
+							],
+							[
+								13,
+								"cx",
+								[
+									6,
+									[
+										7,
+										"std",
+										"cos"
+									],
+									[[
+										1,
+										[
+											1,
+											[
+												1,
+												"localX",
+												"*",
+												[5, "2"]
+											],
+											"+",
+											[5, "1"]
+										],
+										"*",
+										[
+											1,
+											[
+												6,
+												[
+													7,
+													"d",
+													"f32"
+												],
+												["u"]
+											],
+											"*",
+											"PI_OVER_16"
+										]
+									]]
+								]
+							],
+							[
+								2,
+								"acc",
+								"=",
+								[
+									1,
+									"acc",
+									"+",
+									[
+										1,
+										[
+											1,
+											[
+												1,
+												"Gq",
+												"*",
+												[
+													1,
+													"au",
+													"*",
+													"av"
+												]
+											],
+											"*",
+											"cx"
+										],
+										"*",
+										"cy"
+									]
+								]
+							]
+						]]
+					]
+				]]
+			],
+			[
+				13,
+				"Y",
+				[
+					1,
+					[
+						1,
+						"acc",
+						"*",
+						[5, "0.25"]
+					],
+					"+",
+					[5, "0.5"]
+				]
+			],
+			[
+				12,
+				"sumCb",
+				[
+					6,
+					[
+						7,
+						"d",
+						"f32"
+					],
+					[[5, "0"]]
+				]
+			],
+			[
+				12,
+				"sumCr",
+				[
+					6,
+					[
+						7,
+						"d",
+						"f32"
+					],
+					[[5, "0"]]
+				]
+			],
+			[
+				14,
+				[
+					12,
+					"i",
+					[5, "0"]
+				],
+				[
+					1,
+					"i",
+					"<",
+					[5, "64"]
+				],
+				[
+					102,
+					"++",
+					"i"
+				],
+				[0, [[
+					2,
+					"sumCb",
+					"=",
+					[
+						1,
+						"sumCb",
+						"+",
+						[
+							8,
+							"Cbv",
+							"i"
+						]
+					]
+				], [
+					2,
+					"sumCr",
+					"=",
+					[
+						1,
+						"sumCr",
+						"+",
+						[
+							8,
+							"Crv",
+							"i"
+						]
+					]
+				]]]
+			],
+			[
+				13,
+				"qChroma",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"std",
+							"clamp"
+						],
+						[
+							[
+								6,
+								[
+									7,
+									"std",
+									"floor"
+								],
+								[[
+									1,
+									[
+										1,
+										[
+											1,
+											"qScale",
+											"*",
+											[
+												8,
+												[
+													7,
+													"CHROMA_QUANT_C",
+													"$"
+												],
+												[5, "0"]
+											]
+										],
+										"+",
+										[5, "50"]
+									],
+									"/",
+									[5, "100"]
+								]]
+							],
+							[5, "1"],
+							[5, "255"]
+						]
+					],
+					"/",
+					[5, "255"]
+				]
+			],
+			[
+				13,
+				"GdcCb",
+				[
+					1,
+					"sumCb",
+					"/",
+					[5, "8"]
+				]
+			],
+			[
+				13,
+				"GdcCr",
+				[
+					1,
+					"sumCr",
+					"/",
+					[5, "8"]
+				]
+			],
+			[
+				13,
+				"Cb",
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"std",
+								"floor"
+							],
+							[[
+								1,
+								[
+									1,
+									"GdcCb",
+									"/",
+									"qChroma"
+								],
+								"+",
+								[5, "0.5"]
+							]]
+						],
+						"*",
+						"qChroma"
+					],
+					"/",
+					[5, "8"]
+				]
+			],
+			[
+				13,
+				"Cr",
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"std",
+								"floor"
+							],
+							[[
+								1,
+								[
+									1,
+									"GdcCr",
+									"/",
+									"qChroma"
+								],
+								"+",
+								[5, "0.5"]
+							]]
+						],
+						"*",
+						"qChroma"
+					],
+					"/",
+					[5, "8"]
+				]
+			],
+			[
+				13,
+				"r",
+				[
+					1,
+					"Y",
+					"+",
+					[
+						1,
+						"Cr",
+						"*",
+						[5, "1.402"]
+					]
+				]
+			],
+			[
+				13,
+				"g",
+				[
+					1,
+					[
+						1,
+						"Y",
+						"-",
+						[
+							1,
+							"Cb",
+							"*",
+							[5, "0.344136"]
+						]
+					],
+					"-",
+					[
+						1,
+						"Cr",
+						"*",
+						[5, "0.714136"]
+					]
+				]
+			],
+			[
+				13,
+				"b",
+				[
+					1,
+					"Y",
+					"+",
+					[
+						1,
+						"Cb",
+						"*",
+						[5, "1.772"]
+					]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"std",
+					"clamp"
+				],
+				[
+					[
+						6,
+						[
+							7,
+							"d",
+							"vec3f"
+						],
+						[
+							"r",
+							"g",
+							"b"
+						]
+					],
+					[
+						6,
+						[
+							7,
+							"d",
+							"vec3f"
+						],
+						[
+							[5, "0"],
+							[5, "0"],
+							[5, "0"]
+						]
+					],
+					[
+						6,
+						[
+							7,
+							"d",
+							"vec3f"
+						],
+						[
+							[5, "1"],
+							[5, "1"],
+							[5, "1"]
+						]
+					]
+				]
+			]]
+		]],
+		"externalNames": [
+			"std",
+			"d",
+			"N_LUMA",
+			"COS_LUT",
+			"SQRT1_2",
+			"PI_OVER_16",
+			"LUMA_QUANT_C",
+			"CHROMA_QUANT_C"
+		]
+	},
+	externals: () => ({
+		std,
+		d,
+		N_LUMA,
+		COS_LUT,
+		SQRT1_2,
+		PI_OVER_16,
+		LUMA_QUANT_C,
+		CHROMA_QUANT_C
+	})
+}) && $.f)({}));
+const compressionCellUV = tgpu.fn([d.vec2f, d.vec2f], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport) => {
+	"use gpu";
+	const pPix = std.floor(uv.mul(viewport));
+	const cellX = std.clamp(std.floor(__tsover_div(pPix.x, STRIDE)), 0, __tsover_sub(MAX_CELLS, 1));
+	const cellY = std.clamp(std.floor(__tsover_div(pPix.y, STRIDE)), 0, __tsover_sub(MAX_CELLS, 1));
+	return d.vec2f(__tsover_div(__tsover_add(cellX, .5), MAX_CELLS), __tsover_div(__tsover_add(cellY, .5), MAX_CELLS));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "uv"
+		}, {
+			"type": "i",
+			"name": "viewport"
+		}],
+		"body": [0, [
+			[
+				13,
+				"pPix",
+				[
+					6,
+					[
+						7,
+						"std",
+						"floor"
+					],
+					[[
+						6,
+						[
+							7,
+							"uv",
+							"mul"
+						],
+						["viewport"]
+					]]
+				]
+			],
+			[
+				13,
+				"cellX",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							6,
+							[
+								7,
+								"std",
+								"floor"
+							],
+							[[
+								1,
+								[
+									7,
+									"pPix",
+									"x"
+								],
+								"/",
+								"STRIDE"
+							]]
+						],
+						[5, "0"],
+						[
+							1,
+							"MAX_CELLS",
+							"-",
+							[5, "1"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"cellY",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							6,
+							[
+								7,
+								"std",
+								"floor"
+							],
+							[[
+								1,
+								[
+									7,
+									"pPix",
+									"y"
+								],
+								"/",
+								"STRIDE"
+							]]
+						],
+						[5, "0"],
+						[
+							1,
+							"MAX_CELLS",
+							"-",
+							[5, "1"]
+						]
+					]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"d",
+					"vec2f"
+				],
+				[[
+					1,
+					[
+						1,
+						"cellX",
+						"+",
+						[5, "0.5"]
+					],
+					"/",
+					"MAX_CELLS"
+				], [
+					1,
+					[
+						1,
+						"cellY",
+						"+",
+						[5, "0.5"]
+					],
+					"/",
+					"MAX_CELLS"
+				]]
+			]]
+		]],
+		"externalNames": [
+			"std",
+			"STRIDE",
+			"MAX_CELLS",
+			"d"
+		]
+	},
+	externals: () => ({
+		std,
+		STRIDE,
+		MAX_CELLS,
+		d
+	})
+}) && $.f)({}));
+function compressionParams() {
+	return d.struct({
+		inputWidth: d.f32,
+		inputHeight: d.f32,
+		quality: d.f32
+	});
+}
+function buildCompressionGraph() {
+	const Params = compressionParams();
+	const layout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
+		input: { texture: d.texture2d(d.f32) },
+		cellTex: { storageTexture: d.textureStorage2d(CELL_FORMAT, "write-only") },
+		params: { uniform: Params }
+	}), "layout");
+	return {
+		layout,
+		kernel: tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+			"use gpu";
+			const p = layout.$.params;
+			const cellXf = d.f32(cx);
+			const cellYf = d.f32(cy);
+			const blockCol = std.floor(__tsover_div(cellXf, 8));
+			const blockRow = std.floor(__tsover_div(cellYf, 8));
+			const localX = __tsover_sub(cellXf, __tsover_mul(blockCol, 8));
+			const localY = __tsover_sub(cellYf, __tsover_mul(blockRow, 8));
+			const originX = __tsover_mul(blockCol, BLOCK_PX);
+			const originY = __tsover_mul(blockRow, BLOCK_PX);
+			const block = d.arrayOf(d.vec3f, 64)();
+			const wm1 = d.i32(__tsover_sub(p.inputWidth, 1));
+			const hm1 = d.i32(__tsover_sub(p.inputHeight, 1));
+			for (let y = 0; y < 8; y++) for (let x = 0; x < 8; x++) {
+				const px = __tsover_add(__tsover_add(originX, __tsover_mul(d.f32(x), STRIDE)), __tsover_mul(STRIDE, .5));
+				const py = __tsover_add(__tsover_add(originY, __tsover_mul(d.f32(y), STRIDE)), __tsover_mul(STRIDE, .5));
+				const ix = std.clamp(d.i32(px), 0, wm1);
+				const iy = std.clamp(d.i32(py), 0, hm1);
+				const texel = std.textureLoad(layout.$.input, d.vec2u(d.u32(ix), d.u32(iy)), 0);
+				block[__tsover_add(__tsover_mul(y, 8), x)] = unpremultiplyAlpha(texel).xyz;
+			}
+			const rgb = jpegBlockRgb(block, localX, localY, p.quality);
+			std.textureStore(layout.$.cellTex, d.vec2u(cx, cy), d.vec4f(rgb, 1));
+		}), {
+			v: 1,
+			name: void 0,
+			ast: {
+				"params": [{
+					"type": "i",
+					"name": "cx"
+				}, {
+					"type": "i",
+					"name": "cy"
+				}],
+				"body": [0, [
+					[
+						13,
+						"p",
+						[
+							7,
+							[
+								7,
+								"layout",
+								"$"
+							],
+							"params"
+						]
+					],
+					[
+						13,
+						"cellXf",
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							["cx"]
+						]
+					],
+					[
+						13,
+						"cellYf",
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							["cy"]
+						]
+					],
+					[
+						13,
+						"blockCol",
+						[
+							6,
+							[
+								7,
+								"std",
+								"floor"
+							],
+							[[
+								1,
+								"cellXf",
+								"/",
+								[5, "8"]
+							]]
+						]
+					],
+					[
+						13,
+						"blockRow",
+						[
+							6,
+							[
+								7,
+								"std",
+								"floor"
+							],
+							[[
+								1,
+								"cellYf",
+								"/",
+								[5, "8"]
+							]]
+						]
+					],
+					[
+						13,
+						"localX",
+						[
+							1,
+							"cellXf",
+							"-",
+							[
+								1,
+								"blockCol",
+								"*",
+								[5, "8"]
+							]
+						]
+					],
+					[
+						13,
+						"localY",
+						[
+							1,
+							"cellYf",
+							"-",
+							[
+								1,
+								"blockRow",
+								"*",
+								[5, "8"]
+							]
+						]
+					],
+					[
+						13,
+						"originX",
+						[
+							1,
+							"blockCol",
+							"*",
+							"BLOCK_PX"
+						]
+					],
+					[
+						13,
+						"originY",
+						[
+							1,
+							"blockRow",
+							"*",
+							"BLOCK_PX"
+						]
+					],
+					[
+						13,
+						"block",
+						[
+							6,
+							[
+								6,
+								[
+									7,
+									"d",
+									"arrayOf"
+								],
+								[[
+									7,
+									"d",
+									"vec3f"
+								], [5, "64"]]
+							],
+							[]
+						]
+					],
+					[
+						13,
+						"wm1",
+						[
+							6,
+							[
+								7,
+								"d",
+								"i32"
+							],
+							[[
+								1,
+								[
+									7,
+									"p",
+									"inputWidth"
+								],
+								"-",
+								[5, "1"]
+							]]
+						]
+					],
+					[
+						13,
+						"hm1",
+						[
+							6,
+							[
+								7,
+								"d",
+								"i32"
+							],
+							[[
+								1,
+								[
+									7,
+									"p",
+									"inputHeight"
+								],
+								"-",
+								[5, "1"]
+							]]
+						]
+					],
+					[
+						14,
+						[
+							12,
+							"y",
+							[5, "0"]
+						],
+						[
+							1,
+							"y",
+							"<",
+							[5, "8"]
+						],
+						[
+							102,
+							"++",
+							"y"
+						],
+						[0, [[
+							14,
+							[
+								12,
+								"x",
+								[5, "0"]
+							],
+							[
+								1,
+								"x",
+								"<",
+								[5, "8"]
+							],
+							[
+								102,
+								"++",
+								"x"
+							],
+							[0, [
+								[
+									13,
+									"px",
+									[
+										1,
+										[
+											1,
+											"originX",
+											"+",
+											[
+												1,
+												[
+													6,
+													[
+														7,
+														"d",
+														"f32"
+													],
+													["x"]
+												],
+												"*",
+												"STRIDE"
+											]
+										],
+										"+",
+										[
+											1,
+											"STRIDE",
+											"*",
+											[5, "0.5"]
+										]
+									]
+								],
+								[
+									13,
+									"py",
+									[
+										1,
+										[
+											1,
+											"originY",
+											"+",
+											[
+												1,
+												[
+													6,
+													[
+														7,
+														"d",
+														"f32"
+													],
+													["y"]
+												],
+												"*",
+												"STRIDE"
+											]
+										],
+										"+",
+										[
+											1,
+											"STRIDE",
+											"*",
+											[5, "0.5"]
+										]
+									]
+								],
+								[
+									13,
+									"ix",
+									[
+										6,
+										[
+											7,
+											"std",
+											"clamp"
+										],
+										[
+											[
+												6,
+												[
+													7,
+													"d",
+													"i32"
+												],
+												["px"]
+											],
+											[5, "0"],
+											"wm1"
+										]
+									]
+								],
+								[
+									13,
+									"iy",
+									[
+										6,
+										[
+											7,
+											"std",
+											"clamp"
+										],
+										[
+											[
+												6,
+												[
+													7,
+													"d",
+													"i32"
+												],
+												["py"]
+											],
+											[5, "0"],
+											"hm1"
+										]
+									]
+								],
+								[
+									13,
+									"texel",
+									[
+										6,
+										[
+											7,
+											"std",
+											"textureLoad"
+										],
+										[
+											[
+												7,
+												[
+													7,
+													"layout",
+													"$"
+												],
+												"input"
+											],
+											[
+												6,
+												[
+													7,
+													"d",
+													"vec2u"
+												],
+												[[
+													6,
+													[
+														7,
+														"d",
+														"u32"
+													],
+													["ix"]
+												], [
+													6,
+													[
+														7,
+														"d",
+														"u32"
+													],
+													["iy"]
+												]]
+											],
+											[5, "0"]
+										]
+									]
+								],
+								[
+									2,
+									[
+										8,
+										"block",
+										[
+											1,
+											[
+												1,
+												"y",
+												"*",
+												[5, "8"]
+											],
+											"+",
+											"x"
+										]
+									],
+									"=",
+									[
+										7,
+										[
+											6,
+											[
+												7,
+												"blend",
+												"unpremultiplyAlpha"
+											],
+											["texel"]
+										],
+										"xyz"
+									]
+								]
+							]]
+						]]]
+					],
+					[
+						13,
+						"rgb",
+						[
+							6,
+							"jpegBlockRgb",
+							[
+								"block",
+								"localX",
+								"localY",
+								[
+									7,
+									"p",
+									"quality"
+								]
+							]
+						]
+					],
+					[
+						6,
+						[
+							7,
+							"std",
+							"textureStore"
+						],
+						[
+							[
+								7,
+								[
+									7,
+									"layout",
+									"$"
+								],
+								"cellTex"
+							],
+							[
+								6,
+								[
+									7,
+									"d",
+									"vec2u"
+								],
+								["cx", "cy"]
+							],
+							[
+								6,
+								[
+									7,
+									"d",
+									"vec4f"
+								],
+								["rgb", [5, "1"]]
+							]
+						]
+					]
+				]],
+				"externalNames": [
+					"layout",
+					"d",
+					"std",
+					"BLOCK_PX",
+					"STRIDE",
+					"blend",
+					"jpegBlockRgb"
+				]
+			},
+			externals: () => ({
+				layout,
+				d,
+				std,
+				BLOCK_PX,
+				STRIDE,
+				blend: blend_exports,
+				jpegBlockRgb
+			})
+		}) && $.f)({})).$name("compressionCell"),
+		Params
+	};
+}
+const componentDefinition = {
+	name: "CompressionArtifacts",
+	boundingBoxDeclaration: { aspectRatio: null },
+	category: "Stylize",
+	description: "Simulates lossy JPEG compression — 8×8 DCT block quantization, blockiness, ringing and color bleed",
+	requiresRTT: true,
+	requiresChild: true,
+	props: { quality: {
+		default: 12,
+		description: "JPEG quality (1 = heavily destroyed, 100 = near lossless)",
+		ui: {
+			type: ["range", "map"],
+			min: 1,
+			max: 100,
+			step: 1,
+			label: "Quality",
+			group: "Effect"
+		}
+	} },
+	compute: (params) => {
+		const { childNode, gpu, convertToTexture, registerComputeTexture, getCpuValue, onCleanup, onResize, dimensions } = params;
+		if (!childNode) return null;
+		const root = gpu?.root;
+		if (!root) return null;
+		const childTexture = convertToTexture(childNode);
+		const cellTex = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
+			size: [MAX_CELLS, MAX_CELLS],
+			format: CELL_FORMAT
+		}).$usage("storage", "sampled"), "cellTex");
+		onCleanup(() => cellTex.destroy());
+		const jpegCellTexture = registerComputeTexture(cellTex);
+		const graph = buildCompressionGraph();
+		const compParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(graph.Params), "compParams");
+		let curW = Math.max(1, Math.round(dimensions.width));
+		let curH = Math.max(1, Math.round(dimensions.height));
+		const cellsFor = (w, h) => [Math.min(Math.ceil(w / STRIDE), MAX_CELLS), Math.min(Math.ceil(h / STRIDE), MAX_CELLS)];
+		let [cellsX, cellsY] = cellsFor(curW, curH);
+		const pipeline = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+			"use gpu";
+			graph.kernel(cx, cy);
+		}), {
+			v: 1,
+			name: void 0,
+			ast: {
+				"params": [{
+					"type": "i",
+					"name": "cx"
+				}, {
+					"type": "i",
+					"name": "cy"
+				}],
+				"body": [0, [[
+					6,
+					[
+						7,
+						"graph",
+						"kernel"
+					],
+					["cx", "cy"]
+				]]],
+				"externalNames": ["graph"]
+			},
+			externals: () => ({ graph })
+		}) && $.f)({}), {});
+		let bound = pipeline;
+		let inputBound = false;
+		onResize(({ width, height }) => {
+			curW = Math.max(1, Math.round(width));
+			curH = Math.max(1, Math.round(height));
+			[cellsX, cellsY] = cellsFor(curW, curH);
+		});
+		return {
+			outputs: {
+				childTexture,
+				jpegCellTexture
+			},
+			bindInputs: (resolve) => {
+				const src = resolve(childTexture.key);
+				if (src) {
+					const bg = root.createBindGroup(graph.layout, {
+						input: src.texture,
+						cellTex,
+						params: compParams.buffer
+					});
+					bound = pipeline.with(bg);
+					inputBound = true;
+				}
+			},
+			getComputeNodes: () => {
+				const q = getCpuValue("quality");
+				compParams.write({
+					inputWidth: curW,
+					inputHeight: curH,
+					quality: typeof q === "number" ? q : 12
+				});
+				return [() => {
+					if (inputBound) bound.dispatchThreads(cellsX, cellsY);
+				}];
+			}
+		};
+	},
+	fragment: ({ childNode, ctx, computeOutputs, convertToTexture }) => {
+		if (!childNode) return ZERO;
+		const cellTex = computeOutputs?.jpegCellTexture;
+		const sharp = computeOutputs?.childTexture;
+		if (!cellTex || !sharp) return call(unpremultiplyAlpha, "unpremultiplyAlpha", [convertToTexture(childNode).sample(ctx.uv)]);
+		const center = call(unpremultiplyAlpha, "unpremultiplyAlpha", [sharp.sample(ctx.uv)]);
+		const cellUV = call(compressionCellUV, "compressionCellUV", [ctx.uv, ctx.viewportSize]);
+		return vec4(cellTex.sample(cellUV, "nearestClamp").member("rgb"), center.member("a"));
+	}
+};
+var CompressionArtifacts_default = componentDefinition;
+export { jpegBlockRgb as a, compressionCellUV as i, buildCompressionGraph as n, componentDefinition as r, CompressionArtifacts_default as t };