shaders 3.0.447 → 3.0.449

package/dist/core/sdf-R0EN3EvS.js

@@ -0,0 +1,5174 @@
+import { $t as vec2f, Ct as floor, Dt as min, Et as max, Ft as sign, It as sin, Lt as smoothstep, Ot as mix, Rt as sqrt, Vt as data_exports, Xt as struct, _ as floatE, _t as clamp, an as f32, cn as __export, et as src_default, gt as atan2, in as vec4f, mt as abs, nt as std_exports, p as call, pt as select, vt as cos } from "./edges-BXNBKxSN.js";
+import { r as debugWarn } from "./support-6QRFK3xB.js";
+import { t as toHalfFloat } from "./dataEncoding-CEmpiitu.js";
+var sdf_exports = /* @__PURE__ */ __export({
+	ANALYTIC_SDF_EXTRA_FIELDS: () => ANALYTIC_SDF_EXTRA_FIELDS,
+	SVG_SDF_SIZE: () => 512,
+	ShapeMask: () => ShapeMask,
+	arcSdf: () => arcSdf,
+	buildAnalyticSdfFn: () => buildAnalyticSdfFn,
+	circleSdf: () => circleSdf,
+	createAnalyticSdfSampler: () => createAnalyticSdfSampler,
+	createSdfDataTexture: () => createSdfDataTexture,
+	createSvgSdfSampler: () => createSvgSdfSampler,
+	createSvgSdfSamplerWithGradients: () => createSvgSdfSamplerWithGradients,
+	crescentSdf: () => crescentSdf,
+	crossSdf: () => crossSdf,
+	driveAnalyticSubProps: () => driveAnalyticSubProps,
+	ellipseSdf: () => ellipseSdf,
+	flowerSdf: () => flowerSdf,
+	heartSdf: () => heartSdf,
+	loadSdfFromUrl: () => loadSdfFromUrl,
+	parallelogramSdf: () => parallelogramSdf,
+	polygonSdf: () => polygonSdf,
+	ringSdf: () => ringSdf,
+	roundedRectSdf: () => roundedRectSdf,
+	shapeLocalCoords: () => shapeLocalCoords,
+	starSdf: () => starSdf,
+	strokeMaskFromSdf: () => strokeMaskFromSdf,
+	teardropSdf: () => teardropSdf,
+	trapezoidSdf: () => trapezoidSdf,
+	vesicaSdf: () => vesicaSdf
+});
+const SVG_SDF_SIZE = 512;
+var PI = 3.141592653589793;
+var TWO_PI = 6.283185307179586;
+var SQRT2_OVER_4 = .35355339059327373;
+var DEG_TO_RAD = .017453292519943295;
+const circleSdf = src_default.fn([
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((dx, dy, radius) => {
+	"use gpu";
+	return __tsover_sub(sqrt(__tsover_add(__tsover_mul(dx, dx), __tsover_mul(dy, dy))), radius);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "dx"
+			},
+			{
+				"type": "i",
+				"name": "dy"
+			},
+			{
+				"type": "i",
+				"name": "radius"
+			}
+		],
+		"body": [0, [[10, [
+			1,
+			[
+				6,
+				[
+					7,
+					"std",
+					"sqrt"
+				],
+				[[
+					1,
+					[
+						1,
+						"dx",
+						"*",
+						"dx"
+					],
+					"+",
+					[
+						1,
+						"dy",
+						"*",
+						"dy"
+					]
+				]]
+			],
+			"-",
+			"radius"
+		]]]],
+		"externalNames": ["std"]
+	},
+	externals: () => ({ std: std_exports })
+}) && $.f)({}));
+const polygonSdf = src_default.fn([
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((dx, dy, radius, sides) => {
+	"use gpu";
+	const len = sqrt(__tsover_add(__tsover_mul(dx, dx), __tsover_mul(dy, dy)));
+	const angle = atan2(dy, dx);
+	const sectorAngle = __tsover_div(TWO_PI, sides);
+	const sectorIdx = floor(__tsover_add(__tsover_div(angle, sectorAngle), .5));
+	const canonicalAngle = __tsover_sub(angle, __tsover_mul(sectorIdx, sectorAngle));
+	return __tsover_sub(__tsover_mul(len, cos(canonicalAngle)), radius);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "dx"
+			},
+			{
+				"type": "i",
+				"name": "dy"
+			},
+			{
+				"type": "i",
+				"name": "radius"
+			},
+			{
+				"type": "i",
+				"name": "sides"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"len",
+				[
+					6,
+					[
+						7,
+						"std",
+						"sqrt"
+					],
+					[[
+						1,
+						[
+							1,
+							"dx",
+							"*",
+							"dx"
+						],
+						"+",
+						[
+							1,
+							"dy",
+							"*",
+							"dy"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"angle",
+				[
+					6,
+					[
+						7,
+						"std",
+						"atan2"
+					],
+					["dy", "dx"]
+				]
+			],
+			[
+				13,
+				"sectorAngle",
+				[
+					1,
+					"TWO_PI",
+					"/",
+					"sides"
+				]
+			],
+			[
+				13,
+				"sectorIdx",
+				[
+					6,
+					[
+						7,
+						"std",
+						"floor"
+					],
+					[[
+						1,
+						[
+							1,
+							"angle",
+							"/",
+							"sectorAngle"
+						],
+						"+",
+						[5, "0.5"]
+					]]
+				]
+			],
+			[
+				13,
+				"canonicalAngle",
+				[
+					1,
+					"angle",
+					"-",
+					[
+						1,
+						"sectorIdx",
+						"*",
+						"sectorAngle"
+					]
+				]
+			],
+			[10, [
+				1,
+				[
+					1,
+					"len",
+					"*",
+					[
+						6,
+						[
+							7,
+							"std",
+							"cos"
+						],
+						["canonicalAngle"]
+					]
+				],
+				"-",
+				"radius"
+			]]
+		]],
+		"externalNames": ["std", "TWO_PI"]
+	},
+	externals: () => ({
+		std: std_exports,
+		TWO_PI
+	})
+}) && $.f)({}));
+const flowerSdf = src_default.fn([
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((dx, dy, outerRadius, sides, innerRatio) => {
+	"use gpu";
+	const angle = atan2(dy, dx);
+	const len = sqrt(__tsover_add(__tsover_mul(dx, dx), __tsover_mul(dy, dy)));
+	const innerRadius = __tsover_mul(outerRadius, innerRatio);
+	const tAngle = __tsover_div(__tsover_mul(angle, sides), TWO_PI);
+	const tFrac = __tsover_sub(tAngle, floor(tAngle));
+	const t = abs(__tsover_sub(__tsover_mul(tFrac, 2), 1));
+	const boundaryR = __tsover_add(innerRadius, __tsover_mul(__tsover_sub(outerRadius, innerRadius), t));
+	return __tsover_sub(len, boundaryR);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "dx"
+			},
+			{
+				"type": "i",
+				"name": "dy"
+			},
+			{
+				"type": "i",
+				"name": "outerRadius"
+			},
+			{
+				"type": "i",
+				"name": "sides"
+			},
+			{
+				"type": "i",
+				"name": "innerRatio"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"angle",
+				[
+					6,
+					[
+						7,
+						"std",
+						"atan2"
+					],
+					["dy", "dx"]
+				]
+			],
+			[
+				13,
+				"len",
+				[
+					6,
+					[
+						7,
+						"std",
+						"sqrt"
+					],
+					[[
+						1,
+						[
+							1,
+							"dx",
+							"*",
+							"dx"
+						],
+						"+",
+						[
+							1,
+							"dy",
+							"*",
+							"dy"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"innerRadius",
+				[
+					1,
+					"outerRadius",
+					"*",
+					"innerRatio"
+				]
+			],
+			[
+				13,
+				"tAngle",
+				[
+					1,
+					[
+						1,
+						"angle",
+						"*",
+						"sides"
+					],
+					"/",
+					"TWO_PI"
+				]
+			],
+			[
+				13,
+				"tFrac",
+				[
+					1,
+					"tAngle",
+					"-",
+					[
+						6,
+						[
+							7,
+							"std",
+							"floor"
+						],
+						["tAngle"]
+					]
+				]
+			],
+			[
+				13,
+				"t",
+				[
+					6,
+					[
+						7,
+						"std",
+						"abs"
+					],
+					[[
+						1,
+						[
+							1,
+							"tFrac",
+							"*",
+							[5, "2"]
+						],
+						"-",
+						[5, "1"]
+					]]
+				]
+			],
+			[
+				13,
+				"boundaryR",
+				[
+					1,
+					"innerRadius",
+					"+",
+					[
+						1,
+						[
+							1,
+							"outerRadius",
+							"-",
+							"innerRadius"
+						],
+						"*",
+						"t"
+					]
+				]
+			],
+			[10, [
+				1,
+				"len",
+				"-",
+				"boundaryR"
+			]]
+		]],
+		"externalNames": ["std", "TWO_PI"]
+	},
+	externals: () => ({
+		std: std_exports,
+		TWO_PI
+	})
+}) && $.f)({}));
+const starSdf = src_default.fn([
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((dx, dy, outerRadius, sides, innerRatio) => {
+	"use gpu";
+	const innerRadius = __tsover_mul(outerRadius, innerRatio);
+	const len = sqrt(__tsover_add(__tsover_mul(dx, dx), __tsover_mul(dy, dy)));
+	const angle = atan2(dy, dx);
+	const sectorAngle = __tsover_div(TWO_PI, sides);
+	const sectorIdx = floor(__tsover_add(__tsover_div(angle, sectorAngle), .5));
+	const bn = __tsover_sub(angle, __tsover_mul(sectorIdx, sectorAngle));
+	const fpx = abs(__tsover_mul(len, sin(bn)));
+	const fpy = __tsover_mul(len, cos(bn));
+	const an = __tsover_div(PI, sides);
+	const sinAn = sin(an);
+	const cosAn = cos(an);
+	const ex = __tsover_mul(innerRadius, sinAn);
+	const ey = __tsover_sub(__tsover_mul(innerRadius, cosAn), outerRadius);
+	const qx = fpx;
+	const qy = __tsover_sub(fpy, outerRadius);
+	const dotQE = __tsover_add(__tsover_mul(qx, ex), __tsover_mul(qy, ey));
+	const dotEE = __tsover_add(__tsover_mul(ex, ex), __tsover_mul(ey, ey));
+	const t = clamp(__tsover_div(dotQE, dotEE), 0, 1);
+	const nx = __tsover_sub(fpx, __tsover_mul(ex, t));
+	const ny = __tsover_sub(fpy, __tsover_add(outerRadius, __tsover_mul(ey, t)));
+	const dist = sqrt(__tsover_add(__tsover_mul(nx, nx), __tsover_mul(ny, ny)));
+	const cross = __tsover_sub(__tsover_mul(ex, qy), __tsover_mul(ey, qx));
+	return __tsover_mul(dist, sign(cross));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "dx"
+			},
+			{
+				"type": "i",
+				"name": "dy"
+			},
+			{
+				"type": "i",
+				"name": "outerRadius"
+			},
+			{
+				"type": "i",
+				"name": "sides"
+			},
+			{
+				"type": "i",
+				"name": "innerRatio"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"innerRadius",
+				[
+					1,
+					"outerRadius",
+					"*",
+					"innerRatio"
+				]
+			],
+			[
+				13,
+				"len",
+				[
+					6,
+					[
+						7,
+						"std",
+						"sqrt"
+					],
+					[[
+						1,
+						[
+							1,
+							"dx",
+							"*",
+							"dx"
+						],
+						"+",
+						[
+							1,
+							"dy",
+							"*",
+							"dy"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"angle",
+				[
+					6,
+					[
+						7,
+						"std",
+						"atan2"
+					],
+					["dy", "dx"]
+				]
+			],
+			[
+				13,
+				"sectorAngle",
+				[
+					1,
+					"TWO_PI",
+					"/",
+					"sides"
+				]
+			],
+			[
+				13,
+				"sectorIdx",
+				[
+					6,
+					[
+						7,
+						"std",
+						"floor"
+					],
+					[[
+						1,
+						[
+							1,
+							"angle",
+							"/",
+							"sectorAngle"
+						],
+						"+",
+						[5, "0.5"]
+					]]
+				]
+			],
+			[
+				13,
+				"bn",
+				[
+					1,
+					"angle",
+					"-",
+					[
+						1,
+						"sectorIdx",
+						"*",
+						"sectorAngle"
+					]
+				]
+			],
+			[
+				13,
+				"fpx",
+				[
+					6,
+					[
+						7,
+						"std",
+						"abs"
+					],
+					[[
+						1,
+						"len",
+						"*",
+						[
+							6,
+							[
+								7,
+								"std",
+								"sin"
+							],
+							["bn"]
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"fpy",
+				[
+					1,
+					"len",
+					"*",
+					[
+						6,
+						[
+							7,
+							"std",
+							"cos"
+						],
+						["bn"]
+					]
+				]
+			],
+			[
+				13,
+				"an",
+				[
+					1,
+					"PI",
+					"/",
+					"sides"
+				]
+			],
+			[
+				13,
+				"sinAn",
+				[
+					6,
+					[
+						7,
+						"std",
+						"sin"
+					],
+					["an"]
+				]
+			],
+			[
+				13,
+				"cosAn",
+				[
+					6,
+					[
+						7,
+						"std",
+						"cos"
+					],
+					["an"]
+				]
+			],
+			[
+				13,
+				"ex",
+				[
+					1,
+					"innerRadius",
+					"*",
+					"sinAn"
+				]
+			],
+			[
+				13,
+				"ey",
+				[
+					1,
+					[
+						1,
+						"innerRadius",
+						"*",
+						"cosAn"
+					],
+					"-",
+					"outerRadius"
+				]
+			],
+			[
+				13,
+				"qx",
+				"fpx"
+			],
+			[
+				13,
+				"qy",
+				[
+					1,
+					"fpy",
+					"-",
+					"outerRadius"
+				]
+			],
+			[
+				13,
+				"dotQE",
+				[
+					1,
+					[
+						1,
+						"qx",
+						"*",
+						"ex"
+					],
+					"+",
+					[
+						1,
+						"qy",
+						"*",
+						"ey"
+					]
+				]
+			],
+			[
+				13,
+				"dotEE",
+				[
+					1,
+					[
+						1,
+						"ex",
+						"*",
+						"ex"
+					],
+					"+",
+					[
+						1,
+						"ey",
+						"*",
+						"ey"
+					]
+				]
+			],
+			[
+				13,
+				"t",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							"dotQE",
+							"/",
+							"dotEE"
+						],
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"nx",
+				[
+					1,
+					"fpx",
+					"-",
+					[
+						1,
+						"ex",
+						"*",
+						"t"
+					]
+				]
+			],
+			[
+				13,
+				"ny",
+				[
+					1,
+					"fpy",
+					"-",
+					[
+						1,
+						"outerRadius",
+						"+",
+						[
+							1,
+							"ey",
+							"*",
+							"t"
+						]
+					]
+				]
+			],
+			[
+				13,
+				"dist",
+				[
+					6,
+					[
+						7,
+						"std",
+						"sqrt"
+					],
+					[[
+						1,
+						[
+							1,
+							"nx",
+							"*",
+							"nx"
+						],
+						"+",
+						[
+							1,
+							"ny",
+							"*",
+							"ny"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"cross",
+				[
+					1,
+					[
+						1,
+						"ex",
+						"*",
+						"qy"
+					],
+					"-",
+					[
+						1,
+						"ey",
+						"*",
+						"qx"
+					]
+				]
+			],
+			[10, [
+				1,
+				"dist",
+				"*",
+				[
+					6,
+					[
+						7,
+						"std",
+						"sign"
+					],
+					["cross"]
+				]
+			]]
+		]],
+		"externalNames": [
+			"std",
+			"TWO_PI",
+			"PI"
+		]
+	},
+	externals: () => ({
+		std: std_exports,
+		TWO_PI,
+		PI
+	})
+}) && $.f)({}));
+const ringSdf = src_default.fn([
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((dx, dy, radius, thickness) => {
+	"use gpu";
+	const len = sqrt(__tsover_add(__tsover_mul(dx, dx), __tsover_mul(dy, dy)));
+	return __tsover_sub(abs(__tsover_sub(len, radius)), thickness);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "dx"
+			},
+			{
+				"type": "i",
+				"name": "dy"
+			},
+			{
+				"type": "i",
+				"name": "radius"
+			},
+			{
+				"type": "i",
+				"name": "thickness"
+			}
+		],
+		"body": [0, [[
+			13,
+			"len",
+			[
+				6,
+				[
+					7,
+					"std",
+					"sqrt"
+				],
+				[[
+					1,
+					[
+						1,
+						"dx",
+						"*",
+						"dx"
+					],
+					"+",
+					[
+						1,
+						"dy",
+						"*",
+						"dy"
+					]
+				]]
+			]
+		], [10, [
+			1,
+			[
+				6,
+				[
+					7,
+					"std",
+					"abs"
+				],
+				[[
+					1,
+					"len",
+					"-",
+					"radius"
+				]]
+			],
+			"-",
+			"thickness"
+		]]]],
+		"externalNames": ["std"]
+	},
+	externals: () => ({ std: std_exports })
+}) && $.f)({}));
+const crossSdf = src_default.fn([
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((dx, dy, size, thickness, rounding) => {
+	"use gpu";
+	const px = abs(dx);
+	const py = abs(dy);
+	const dHoriz = max(__tsover_sub(px, size), __tsover_sub(py, thickness));
+	const dVert = max(__tsover_sub(py, size), __tsover_sub(px, thickness));
+	return __tsover_sub(min(dHoriz, dVert), rounding);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "dx"
+			},
+			{
+				"type": "i",
+				"name": "dy"
+			},
+			{
+				"type": "i",
+				"name": "size"
+			},
+			{
+				"type": "i",
+				"name": "thickness"
+			},
+			{
+				"type": "i",
+				"name": "rounding"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"px",
+				[
+					6,
+					[
+						7,
+						"std",
+						"abs"
+					],
+					["dx"]
+				]
+			],
+			[
+				13,
+				"py",
+				[
+					6,
+					[
+						7,
+						"std",
+						"abs"
+					],
+					["dy"]
+				]
+			],
+			[
+				13,
+				"dHoriz",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					[[
+						1,
+						"px",
+						"-",
+						"size"
+					], [
+						1,
+						"py",
+						"-",
+						"thickness"
+					]]
+				]
+			],
+			[
+				13,
+				"dVert",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					[[
+						1,
+						"py",
+						"-",
+						"size"
+					], [
+						1,
+						"px",
+						"-",
+						"thickness"
+					]]
+				]
+			],
+			[10, [
+				1,
+				[
+					6,
+					[
+						7,
+						"std",
+						"min"
+					],
+					["dHoriz", "dVert"]
+				],
+				"-",
+				"rounding"
+			]]
+		]],
+		"externalNames": ["std"]
+	},
+	externals: () => ({ std: std_exports })
+}) && $.f)({}));
+const roundedRectSdf = src_default.fn([
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((dx, dy, width, height, rounding) => {
+	"use gpu";
+	const qx = __tsover_add(__tsover_sub(abs(dx), width), rounding);
+	const qy = __tsover_add(__tsover_sub(abs(dy), height), rounding);
+	const mqx = max(qx, 0);
+	const mqy = max(qy, 0);
+	const outerDist = sqrt(__tsover_add(__tsover_mul(mqx, mqx), __tsover_mul(mqy, mqy)));
+	const innerDist = min(max(qx, qy), 0);
+	return __tsover_sub(__tsover_add(outerDist, innerDist), rounding);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "dx"
+			},
+			{
+				"type": "i",
+				"name": "dy"
+			},
+			{
+				"type": "i",
+				"name": "width"
+			},
+			{
+				"type": "i",
+				"name": "height"
+			},
+			{
+				"type": "i",
+				"name": "rounding"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"qx",
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"std",
+								"abs"
+							],
+							["dx"]
+						],
+						"-",
+						"width"
+					],
+					"+",
+					"rounding"
+				]
+			],
+			[
+				13,
+				"qy",
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"std",
+								"abs"
+							],
+							["dy"]
+						],
+						"-",
+						"height"
+					],
+					"+",
+					"rounding"
+				]
+			],
+			[
+				13,
+				"mqx",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					["qx", [5, "0"]]
+				]
+			],
+			[
+				13,
+				"mqy",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					["qy", [5, "0"]]
+				]
+			],
+			[
+				13,
+				"outerDist",
+				[
+					6,
+					[
+						7,
+						"std",
+						"sqrt"
+					],
+					[[
+						1,
+						[
+							1,
+							"mqx",
+							"*",
+							"mqx"
+						],
+						"+",
+						[
+							1,
+							"mqy",
+							"*",
+							"mqy"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"innerDist",
+				[
+					6,
+					[
+						7,
+						"std",
+						"min"
+					],
+					[[
+						6,
+						[
+							7,
+							"std",
+							"max"
+						],
+						["qx", "qy"]
+					], [5, "0"]]
+				]
+			],
+			[10, [
+				1,
+				[
+					1,
+					"outerDist",
+					"+",
+					"innerDist"
+				],
+				"-",
+				"rounding"
+			]]
+		]],
+		"externalNames": ["std"]
+	},
+	externals: () => ({ std: std_exports })
+}) && $.f)({}));
+const ellipseSdf = src_default.fn([
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((dx, dy, radiusX, radiusY) => {
+	"use gpu";
+	const nx = __tsover_div(dx, radiusX);
+	const ny = __tsover_div(dy, radiusY);
+	const k = sqrt(__tsover_add(__tsover_mul(nx, nx), __tsover_mul(ny, ny)));
+	return __tsover_mul(__tsover_sub(k, 1), min(radiusX, radiusY));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "dx"
+			},
+			{
+				"type": "i",
+				"name": "dy"
+			},
+			{
+				"type": "i",
+				"name": "radiusX"
+			},
+			{
+				"type": "i",
+				"name": "radiusY"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"nx",
+				[
+					1,
+					"dx",
+					"/",
+					"radiusX"
+				]
+			],
+			[
+				13,
+				"ny",
+				[
+					1,
+					"dy",
+					"/",
+					"radiusY"
+				]
+			],
+			[
+				13,
+				"k",
+				[
+					6,
+					[
+						7,
+						"std",
+						"sqrt"
+					],
+					[[
+						1,
+						[
+							1,
+							"nx",
+							"*",
+							"nx"
+						],
+						"+",
+						[
+							1,
+							"ny",
+							"*",
+							"ny"
+						]
+					]]
+				]
+			],
+			[10, [
+				1,
+				[
+					1,
+					"k",
+					"-",
+					[5, "1"]
+				],
+				"*",
+				[
+					6,
+					[
+						7,
+						"std",
+						"min"
+					],
+					["radiusX", "radiusY"]
+				]
+			]]
+		]],
+		"externalNames": ["std"]
+	},
+	externals: () => ({ std: std_exports })
+}) && $.f)({}));
+const vesicaSdf = src_default.fn([
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((dx, dy, radius, spread) => {
+	"use gpu";
+	const px = abs(dx);
+	const py = abs(dy);
+	const dd = __tsover_mul(radius, spread);
+	const b = sqrt(max(__tsover_sub(__tsover_mul(radius, radius), __tsover_mul(dd, dd)), 0));
+	const cond = __tsover_mul(__tsover_sub(py, b), dd) > __tsover_mul(px, b);
+	const dist1 = sqrt(__tsover_add(__tsover_mul(px, px), __tsover_mul(__tsover_sub(py, b), __tsover_sub(py, b))));
+	return select(__tsover_sub(sqrt(__tsover_add(__tsover_mul(__tsover_add(px, dd), __tsover_add(px, dd)), __tsover_mul(py, py))), radius), dist1, cond);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "dx"
+			},
+			{
+				"type": "i",
+				"name": "dy"
+			},
+			{
+				"type": "i",
+				"name": "radius"
+			},
+			{
+				"type": "i",
+				"name": "spread"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"px",
+				[
+					6,
+					[
+						7,
+						"std",
+						"abs"
+					],
+					["dx"]
+				]
+			],
+			[
+				13,
+				"py",
+				[
+					6,
+					[
+						7,
+						"std",
+						"abs"
+					],
+					["dy"]
+				]
+			],
+			[
+				13,
+				"dd",
+				[
+					1,
+					"radius",
+					"*",
+					"spread"
+				]
+			],
+			[
+				13,
+				"b",
+				[
+					6,
+					[
+						7,
+						"std",
+						"sqrt"
+					],
+					[[
+						6,
+						[
+							7,
+							"std",
+							"max"
+						],
+						[[
+							1,
+							[
+								1,
+								"radius",
+								"*",
+								"radius"
+							],
+							"-",
+							[
+								1,
+								"dd",
+								"*",
+								"dd"
+							]
+						], [5, "0"]]
+					]]
+				]
+			],
+			[
+				13,
+				"cond",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							"py",
+							"-",
+							"b"
+						],
+						"*",
+						"dd"
+					],
+					">",
+					[
+						1,
+						"px",
+						"*",
+						"b"
+					]
+				]
+			],
+			[
+				13,
+				"dist1",
+				[
+					6,
+					[
+						7,
+						"std",
+						"sqrt"
+					],
+					[[
+						1,
+						[
+							1,
+							"px",
+							"*",
+							"px"
+						],
+						"+",
+						[
+							1,
+							[
+								1,
+								"py",
+								"-",
+								"b"
+							],
+							"*",
+							[
+								1,
+								"py",
+								"-",
+								"b"
+							]
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"dist2",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"std",
+							"sqrt"
+						],
+						[[
+							1,
+							[
+								1,
+								[
+									1,
+									"px",
+									"+",
+									"dd"
+								],
+								"*",
+								[
+									1,
+									"px",
+									"+",
+									"dd"
+								]
+							],
+							"+",
+							[
+								1,
+								"py",
+								"*",
+								"py"
+							]
+						]]
+					],
+					"-",
+					"radius"
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"std",
+					"select"
+				],
+				[
+					"dist2",
+					"dist1",
+					"cond"
+				]
+			]]
+		]],
+		"externalNames": ["std"]
+	},
+	externals: () => ({ std: std_exports })
+}) && $.f)({}));
+const crescentSdf = src_default.fn([
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((dx, dy, outerRadius, innerRatio, offset) => {
+	"use gpu";
+	const py = abs(dy);
+	const ra = outerRadius;
+	const rb = __tsover_mul(outerRadius, innerRatio);
+	const off = offset;
+	const a = __tsover_div(__tsover_add(__tsover_sub(__tsover_mul(ra, ra), __tsover_mul(rb, rb)), __tsover_mul(off, off)), max(__tsover_mul(off, 2), .001));
+	const b = sqrt(max(__tsover_sub(__tsover_mul(ra, ra), __tsover_mul(a, a)), 0));
+	const lhs = __tsover_mul(off, __tsover_sub(__tsover_mul(dx, b), __tsover_mul(py, a)));
+	const rhs = __tsover_mul(__tsover_mul(off, off), max(__tsover_sub(b, py), 0));
+	const d1x = __tsover_sub(dx, a);
+	const d1y = __tsover_sub(py, b);
+	const dist1 = sqrt(__tsover_add(__tsover_mul(d1x, d1x), __tsover_mul(d1y, d1y)));
+	const lenP = sqrt(__tsover_add(__tsover_mul(dx, dx), __tsover_mul(py, py)));
+	const innerX = __tsover_sub(dx, off);
+	const lenInner = sqrt(__tsover_add(__tsover_mul(innerX, innerX), __tsover_mul(py, py)));
+	return select(max(__tsover_sub(lenP, ra), __tsover_mul(__tsover_sub(lenInner, rb), -1)), dist1, lhs > rhs);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "dx"
+			},
+			{
+				"type": "i",
+				"name": "dy"
+			},
+			{
+				"type": "i",
+				"name": "outerRadius"
+			},
+			{
+				"type": "i",
+				"name": "innerRatio"
+			},
+			{
+				"type": "i",
+				"name": "offset"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"py",
+				[
+					6,
+					[
+						7,
+						"std",
+						"abs"
+					],
+					["dy"]
+				]
+			],
+			[
+				13,
+				"ra",
+				"outerRadius"
+			],
+			[
+				13,
+				"rb",
+				[
+					1,
+					"outerRadius",
+					"*",
+					"innerRatio"
+				]
+			],
+			[
+				13,
+				"off",
+				"offset"
+			],
+			[
+				13,
+				"a",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								"ra",
+								"*",
+								"ra"
+							],
+							"-",
+							[
+								1,
+								"rb",
+								"*",
+								"rb"
+							]
+						],
+						"+",
+						[
+							1,
+							"off",
+							"*",
+							"off"
+						]
+					],
+					"/",
+					[
+						6,
+						[
+							7,
+							"std",
+							"max"
+						],
+						[[
+							1,
+							"off",
+							"*",
+							[5, "2"]
+						], [5, "0.001"]]
+					]
+				]
+			],
+			[
+				13,
+				"bSq",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					[[
+						1,
+						[
+							1,
+							"ra",
+							"*",
+							"ra"
+						],
+						"-",
+						[
+							1,
+							"a",
+							"*",
+							"a"
+						]
+					], [5, "0"]]
+				]
+			],
+			[
+				13,
+				"b",
+				[
+					6,
+					[
+						7,
+						"std",
+						"sqrt"
+					],
+					["bSq"]
+				]
+			],
+			[
+				13,
+				"lhs",
+				[
+					1,
+					"off",
+					"*",
+					[
+						1,
+						[
+							1,
+							"dx",
+							"*",
+							"b"
+						],
+						"-",
+						[
+							1,
+							"py",
+							"*",
+							"a"
+						]
+					]
+				]
+			],
+			[
+				13,
+				"rhs",
+				[
+					1,
+					[
+						1,
+						"off",
+						"*",
+						"off"
+					],
+					"*",
+					[
+						6,
+						[
+							7,
+							"std",
+							"max"
+						],
+						[[
+							1,
+							"b",
+							"-",
+							"py"
+						], [5, "0"]]
+					]
+				]
+			],
+			[
+				13,
+				"d1x",
+				[
+					1,
+					"dx",
+					"-",
+					"a"
+				]
+			],
+			[
+				13,
+				"d1y",
+				[
+					1,
+					"py",
+					"-",
+					"b"
+				]
+			],
+			[
+				13,
+				"dist1",
+				[
+					6,
+					[
+						7,
+						"std",
+						"sqrt"
+					],
+					[[
+						1,
+						[
+							1,
+							"d1x",
+							"*",
+							"d1x"
+						],
+						"+",
+						[
+							1,
+							"d1y",
+							"*",
+							"d1y"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"lenP",
+				[
+					6,
+					[
+						7,
+						"std",
+						"sqrt"
+					],
+					[[
+						1,
+						[
+							1,
+							"dx",
+							"*",
+							"dx"
+						],
+						"+",
+						[
+							1,
+							"py",
+							"*",
+							"py"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"innerX",
+				[
+					1,
+					"dx",
+					"-",
+					"off"
+				]
+			],
+			[
+				13,
+				"lenInner",
+				[
+					6,
+					[
+						7,
+						"std",
+						"sqrt"
+					],
+					[[
+						1,
+						[
+							1,
+							"innerX",
+							"*",
+							"innerX"
+						],
+						"+",
+						[
+							1,
+							"py",
+							"*",
+							"py"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"dist2",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					[[
+						1,
+						"lenP",
+						"-",
+						"ra"
+					], [
+						1,
+						[
+							1,
+							"lenInner",
+							"-",
+							"rb"
+						],
+						"*",
+						[
+							4,
+							"-",
+							[5, "1"]
+						]
+					]]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"std",
+					"select"
+				],
+				[
+					"dist2",
+					"dist1",
+					[
+						1,
+						"lhs",
+						">",
+						"rhs"
+					]
+				]
+			]]
+		]],
+		"externalNames": ["std"]
+	},
+	externals: () => ({ std: std_exports })
+}) && $.f)({}));
+const trapezoidSdf = src_default.fn([
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((dx, dy, r1, r2, he) => {
+	"use gpu";
+	const px = abs(dx);
+	const k1x = r2;
+	const k1y = he;
+	const k2x = __tsover_sub(r2, r1);
+	const k2y = __tsover_mul(he, 2);
+	const clampWidth = select(r2, r1, dy < 0);
+	const cax = __tsover_sub(px, min(px, clampWidth));
+	const cay = __tsover_sub(abs(dy), he);
+	const diffX = __tsover_sub(k1x, px);
+	const diffY = __tsover_sub(k1y, dy);
+	const dotNum = __tsover_add(__tsover_mul(diffX, k2x), __tsover_mul(diffY, k2y));
+	const dotDen = max(__tsover_add(__tsover_mul(k2x, k2x), __tsover_mul(k2y, k2y)), 1e-4);
+	const t = clamp(__tsover_div(dotNum, dotDen), 0, 1);
+	const cbx = __tsover_add(__tsover_sub(px, k1x), __tsover_mul(k2x, t));
+	const cby = __tsover_add(__tsover_sub(dy, k1y), __tsover_mul(k2y, t));
+	const sInner = select(f32(1), f32(-1), cay < 0);
+	const s = select(f32(1), sInner, cbx < 0);
+	const dca = __tsover_add(__tsover_mul(cax, cax), __tsover_mul(cay, cay));
+	const dcb = __tsover_add(__tsover_mul(cbx, cbx), __tsover_mul(cby, cby));
+	return __tsover_mul(s, sqrt(min(dca, dcb)));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "dx"
+			},
+			{
+				"type": "i",
+				"name": "dy"
+			},
+			{
+				"type": "i",
+				"name": "r1"
+			},
+			{
+				"type": "i",
+				"name": "r2"
+			},
+			{
+				"type": "i",
+				"name": "he"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"px",
+				[
+					6,
+					[
+						7,
+						"std",
+						"abs"
+					],
+					["dx"]
+				]
+			],
+			[
+				13,
+				"k1x",
+				"r2"
+			],
+			[
+				13,
+				"k1y",
+				"he"
+			],
+			[
+				13,
+				"k2x",
+				[
+					1,
+					"r2",
+					"-",
+					"r1"
+				]
+			],
+			[
+				13,
+				"k2y",
+				[
+					1,
+					"he",
+					"*",
+					[5, "2"]
+				]
+			],
+			[
+				13,
+				"clampWidth",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"r2",
+						"r1",
+						[
+							1,
+							"dy",
+							"<",
+							[5, "0"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"cax",
+				[
+					1,
+					"px",
+					"-",
+					[
+						6,
+						[
+							7,
+							"std",
+							"min"
+						],
+						["px", "clampWidth"]
+					]
+				]
+			],
+			[
+				13,
+				"cay",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"std",
+							"abs"
+						],
+						["dy"]
+					],
+					"-",
+					"he"
+				]
+			],
+			[
+				13,
+				"diffX",
+				[
+					1,
+					"k1x",
+					"-",
+					"px"
+				]
+			],
+			[
+				13,
+				"diffY",
+				[
+					1,
+					"k1y",
+					"-",
+					"dy"
+				]
+			],
+			[
+				13,
+				"dotNum",
+				[
+					1,
+					[
+						1,
+						"diffX",
+						"*",
+						"k2x"
+					],
+					"+",
+					[
+						1,
+						"diffY",
+						"*",
+						"k2y"
+					]
+				]
+			],
+			[
+				13,
+				"dotDen",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					[[
+						1,
+						[
+							1,
+							"k2x",
+							"*",
+							"k2x"
+						],
+						"+",
+						[
+							1,
+							"k2y",
+							"*",
+							"k2y"
+						]
+					], [5, "0.0001"]]
+				]
+			],
+			[
+				13,
+				"t",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							"dotNum",
+							"/",
+							"dotDen"
+						],
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"cbx",
+				[
+					1,
+					[
+						1,
+						"px",
+						"-",
+						"k1x"
+					],
+					"+",
+					[
+						1,
+						"k2x",
+						"*",
+						"t"
+					]
+				]
+			],
+			[
+				13,
+				"cby",
+				[
+					1,
+					[
+						1,
+						"dy",
+						"-",
+						"k1y"
+					],
+					"+",
+					[
+						1,
+						"k2y",
+						"*",
+						"t"
+					]
+				]
+			],
+			[
+				13,
+				"sInner",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "1"]]
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[
+								4,
+								"-",
+								[5, "1"]
+							]]
+						],
+						[
+							1,
+							"cay",
+							"<",
+							[5, "0"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"s",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "1"]]
+						],
+						"sInner",
+						[
+							1,
+							"cbx",
+							"<",
+							[5, "0"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"dca",
+				[
+					1,
+					[
+						1,
+						"cax",
+						"*",
+						"cax"
+					],
+					"+",
+					[
+						1,
+						"cay",
+						"*",
+						"cay"
+					]
+				]
+			],
+			[
+				13,
+				"dcb",
+				[
+					1,
+					[
+						1,
+						"cbx",
+						"*",
+						"cbx"
+					],
+					"+",
+					[
+						1,
+						"cby",
+						"*",
+						"cby"
+					]
+				]
+			],
+			[10, [
+				1,
+				"s",
+				"*",
+				[
+					6,
+					[
+						7,
+						"std",
+						"sqrt"
+					],
+					[[
+						6,
+						[
+							7,
+							"std",
+							"min"
+						],
+						["dca", "dcb"]
+					]]
+				]
+			]]
+		]],
+		"externalNames": ["std", "d"]
+	},
+	externals: () => ({
+		std: std_exports,
+		d: data_exports
+	})
+}) && $.f)({}));
+const heartSdf = src_default.fn([
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((dx, dy, radius) => {
+	"use gpu";
+	const S = __tsover_div(radius, .75);
+	const px = __tsover_div(abs(dx), S);
+	const py = __tsover_add(__tsover_div(__tsover_mul(dy, -1), S), .6);
+	const ax = __tsover_sub(px, .25);
+	const ay = __tsover_sub(py, .75);
+	const distA = __tsover_sub(sqrt(__tsover_add(__tsover_mul(ax, ax), __tsover_mul(ay, ay))), SQRT2_OVER_4);
+	const b1y = __tsover_sub(py, 1);
+	const dot1 = __tsover_add(__tsover_mul(px, px), __tsover_mul(b1y, b1y));
+	const m = __tsover_mul(max(__tsover_add(px, py), 0), .5);
+	const b2x = __tsover_sub(px, m);
+	const b2y = __tsover_sub(py, m);
+	const dot2v = __tsover_add(__tsover_mul(b2x, b2x), __tsover_mul(b2y, b2y));
+	const distB = __tsover_mul(sqrt(min(dot1, dot2v)), sign(__tsover_sub(px, py)));
+	return __tsover_mul(select(distB, distA, __tsover_add(px, py) > 1), S);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "dx"
+			},
+			{
+				"type": "i",
+				"name": "dy"
+			},
+			{
+				"type": "i",
+				"name": "radius"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"S",
+				[
+					1,
+					"radius",
+					"/",
+					[5, "0.75"]
+				]
+			],
+			[
+				13,
+				"px",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"std",
+							"abs"
+						],
+						["dx"]
+					],
+					"/",
+					"S"
+				]
+			],
+			[
+				13,
+				"py",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							"dy",
+							"*",
+							[
+								4,
+								"-",
+								[5, "1"]
+							]
+						],
+						"/",
+						"S"
+					],
+					"+",
+					[5, "0.6"]
+				]
+			],
+			[
+				13,
+				"ax",
+				[
+					1,
+					"px",
+					"-",
+					[5, "0.25"]
+				]
+			],
+			[
+				13,
+				"ay",
+				[
+					1,
+					"py",
+					"-",
+					[5, "0.75"]
+				]
+			],
+			[
+				13,
+				"distA",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"std",
+							"sqrt"
+						],
+						[[
+							1,
+							[
+								1,
+								"ax",
+								"*",
+								"ax"
+							],
+							"+",
+							[
+								1,
+								"ay",
+								"*",
+								"ay"
+							]
+						]]
+					],
+					"-",
+					"SQRT2_OVER_4"
+				]
+			],
+			[
+				13,
+				"b1y",
+				[
+					1,
+					"py",
+					"-",
+					[5, "1"]
+				]
+			],
+			[
+				13,
+				"dot1",
+				[
+					1,
+					[
+						1,
+						"px",
+						"*",
+						"px"
+					],
+					"+",
+					[
+						1,
+						"b1y",
+						"*",
+						"b1y"
+					]
+				]
+			],
+			[
+				13,
+				"m",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"std",
+							"max"
+						],
+						[[
+							1,
+							"px",
+							"+",
+							"py"
+						], [5, "0"]]
+					],
+					"*",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"b2x",
+				[
+					1,
+					"px",
+					"-",
+					"m"
+				]
+			],
+			[
+				13,
+				"b2y",
+				[
+					1,
+					"py",
+					"-",
+					"m"
+				]
+			],
+			[
+				13,
+				"dot2v",
+				[
+					1,
+					[
+						1,
+						"b2x",
+						"*",
+						"b2x"
+					],
+					"+",
+					[
+						1,
+						"b2y",
+						"*",
+						"b2y"
+					]
+				]
+			],
+			[
+				13,
+				"distB",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"std",
+							"sqrt"
+						],
+						[[
+							6,
+							[
+								7,
+								"std",
+								"min"
+							],
+							["dot1", "dot2v"]
+						]]
+					],
+					"*",
+					[
+						6,
+						[
+							7,
+							"std",
+							"sign"
+						],
+						[[
+							1,
+							"px",
+							"-",
+							"py"
+						]]
+					]
+				]
+			],
+			[10, [
+				1,
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"distB",
+						"distA",
+						[
+							1,
+							[
+								1,
+								"px",
+								"+",
+								"py"
+							],
+							">",
+							[5, "1"]
+						]
+					]
+				],
+				"*",
+				"S"
+			]]
+		]],
+		"externalNames": ["std", "SQRT2_OVER_4"]
+	},
+	externals: () => ({
+		std: std_exports,
+		SQRT2_OVER_4
+	})
+}) && $.f)({}));
+const arcSdf = src_default.fn([
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((dx, dy, radius, halfAngle) => {
+	"use gpu";
+	const px = abs(dx);
+	const cx = sin(halfAngle);
+	const cy = cos(halfAngle);
+	const l = __tsover_sub(sqrt(__tsover_add(__tsover_mul(px, px), __tsover_mul(dy, dy))), radius);
+	const clamped = clamp(__tsover_add(__tsover_mul(px, cx), __tsover_mul(dy, cy)), 0, radius);
+	const mx = __tsover_sub(px, __tsover_mul(cx, clamped));
+	const my = __tsover_sub(dy, __tsover_mul(cy, clamped));
+	const m = sqrt(__tsover_add(__tsover_mul(mx, mx), __tsover_mul(my, my)));
+	return max(l, __tsover_mul(m, sign(__tsover_sub(__tsover_mul(cy, px), __tsover_mul(cx, dy)))));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "dx"
+			},
+			{
+				"type": "i",
+				"name": "dy"
+			},
+			{
+				"type": "i",
+				"name": "radius"
+			},
+			{
+				"type": "i",
+				"name": "halfAngle"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"px",
+				[
+					6,
+					[
+						7,
+						"std",
+						"abs"
+					],
+					["dx"]
+				]
+			],
+			[
+				13,
+				"cx",
+				[
+					6,
+					[
+						7,
+						"std",
+						"sin"
+					],
+					["halfAngle"]
+				]
+			],
+			[
+				13,
+				"cy",
+				[
+					6,
+					[
+						7,
+						"std",
+						"cos"
+					],
+					["halfAngle"]
+				]
+			],
+			[
+				13,
+				"l",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"std",
+							"sqrt"
+						],
+						[[
+							1,
+							[
+								1,
+								"px",
+								"*",
+								"px"
+							],
+							"+",
+							[
+								1,
+								"dy",
+								"*",
+								"dy"
+							]
+						]]
+					],
+					"-",
+					"radius"
+				]
+			],
+			[
+				13,
+				"clamped",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[
+								1,
+								"px",
+								"*",
+								"cx"
+							],
+							"+",
+							[
+								1,
+								"dy",
+								"*",
+								"cy"
+							]
+						],
+						[5, "0"],
+						"radius"
+					]
+				]
+			],
+			[
+				13,
+				"mx",
+				[
+					1,
+					"px",
+					"-",
+					[
+						1,
+						"cx",
+						"*",
+						"clamped"
+					]
+				]
+			],
+			[
+				13,
+				"my",
+				[
+					1,
+					"dy",
+					"-",
+					[
+						1,
+						"cy",
+						"*",
+						"clamped"
+					]
+				]
+			],
+			[
+				13,
+				"m",
+				[
+					6,
+					[
+						7,
+						"std",
+						"sqrt"
+					],
+					[[
+						1,
+						[
+							1,
+							"mx",
+							"*",
+							"mx"
+						],
+						"+",
+						[
+							1,
+							"my",
+							"*",
+							"my"
+						]
+					]]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"std",
+					"max"
+				],
+				["l", [
+					1,
+					"m",
+					"*",
+					[
+						6,
+						[
+							7,
+							"std",
+							"sign"
+						],
+						[[
+							1,
+							[
+								1,
+								"cy",
+								"*",
+								"px"
+							],
+							"-",
+							[
+								1,
+								"cx",
+								"*",
+								"dy"
+							]
+						]]
+					]
+				]]
+			]]
+		]],
+		"externalNames": ["std"]
+	},
+	externals: () => ({ std: std_exports })
+}) && $.f)({}));
+const teardropSdf = src_default.fn([
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((dx, dy, radius, h) => {
+	"use gpu";
+	const mid = __tsover_mul(__tsover_sub(h, radius), .5);
+	const qx = abs(dx);
+	const qy = __tsover_add(__tsover_mul(dy, -1), mid);
+	const hSafe = max(h, 1e-4);
+	const b = __tsover_div(radius, hSafe);
+	const a = sqrt(max(__tsover_sub(1, __tsover_mul(b, b)), 0));
+	const k = __tsover_add(__tsover_mul(qx, __tsover_mul(b, -1)), __tsover_mul(qy, a));
+	const cap0 = __tsover_sub(sqrt(__tsover_add(__tsover_mul(qx, qx), __tsover_mul(qy, qy))), radius);
+	const qyTip = __tsover_sub(qy, h);
+	const cap1 = sqrt(__tsover_add(__tsover_mul(qx, qx), __tsover_mul(qyTip, qyTip)));
+	return select(select(__tsover_sub(__tsover_add(__tsover_mul(qx, a), __tsover_mul(qy, b)), radius), cap1, k > __tsover_mul(a, h)), cap0, k < 0);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "dx"
+			},
+			{
+				"type": "i",
+				"name": "dy"
+			},
+			{
+				"type": "i",
+				"name": "radius"
+			},
+			{
+				"type": "i",
+				"name": "h"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"mid",
+				[
+					1,
+					[
+						1,
+						"h",
+						"-",
+						"radius"
+					],
+					"*",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"qx",
+				[
+					6,
+					[
+						7,
+						"std",
+						"abs"
+					],
+					["dx"]
+				]
+			],
+			[
+				13,
+				"qy",
+				[
+					1,
+					[
+						1,
+						"dy",
+						"*",
+						[
+							4,
+							"-",
+							[5, "1"]
+						]
+					],
+					"+",
+					"mid"
+				]
+			],
+			[
+				13,
+				"hSafe",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					["h", [5, "0.0001"]]
+				]
+			],
+			[
+				13,
+				"b",
+				[
+					1,
+					"radius",
+					"/",
+					"hSafe"
+				]
+			],
+			[
+				13,
+				"a",
+				[
+					6,
+					[
+						7,
+						"std",
+						"sqrt"
+					],
+					[[
+						6,
+						[
+							7,
+							"std",
+							"max"
+						],
+						[[
+							1,
+							[5, "1"],
+							"-",
+							[
+								1,
+								"b",
+								"*",
+								"b"
+							]
+						], [5, "0"]]
+					]]
+				]
+			],
+			[
+				13,
+				"k",
+				[
+					1,
+					[
+						1,
+						"qx",
+						"*",
+						[
+							1,
+							"b",
+							"*",
+							[
+								4,
+								"-",
+								[5, "1"]
+							]
+						]
+					],
+					"+",
+					[
+						1,
+						"qy",
+						"*",
+						"a"
+					]
+				]
+			],
+			[
+				13,
+				"cap0",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"std",
+							"sqrt"
+						],
+						[[
+							1,
+							[
+								1,
+								"qx",
+								"*",
+								"qx"
+							],
+							"+",
+							[
+								1,
+								"qy",
+								"*",
+								"qy"
+							]
+						]]
+					],
+					"-",
+					"radius"
+				]
+			],
+			[
+				13,
+				"qyTip",
+				[
+					1,
+					"qy",
+					"-",
+					"h"
+				]
+			],
+			[
+				13,
+				"cap1",
+				[
+					6,
+					[
+						7,
+						"std",
+						"sqrt"
+					],
+					[[
+						1,
+						[
+							1,
+							"qx",
+							"*",
+							"qx"
+						],
+						"+",
+						[
+							1,
+							"qyTip",
+							"*",
+							"qyTip"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"body",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							"qx",
+							"*",
+							"a"
+						],
+						"+",
+						[
+							1,
+							"qy",
+							"*",
+							"b"
+						]
+					],
+					"-",
+					"radius"
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"std",
+					"select"
+				],
+				[
+					[
+						6,
+						[
+							7,
+							"std",
+							"select"
+						],
+						[
+							"body",
+							"cap1",
+							[
+								1,
+								"k",
+								">",
+								[
+									1,
+									"a",
+									"*",
+									"h"
+								]
+							]
+						]
+					],
+					"cap0",
+					[
+						1,
+						"k",
+						"<",
+						[5, "0"]
+					]
+				]
+			]]
+		]],
+		"externalNames": ["std"]
+	},
+	externals: () => ({ std: std_exports })
+}) && $.f)({}));
+const parallelogramSdf = src_default.fn([
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((dx, dy, wi, he, sk) => {
+	"use gpu";
+	const ex = sk;
+	const ey = he;
+	const flip1 = dy < 0;
+	const px0 = select(dx, __tsover_mul(dx, -1), flip1);
+	const py0 = select(dy, __tsover_mul(dy, -1), flip1);
+	const wx0 = __tsover_sub(px0, ex);
+	const wy = __tsover_sub(py0, ey);
+	const wx = __tsover_sub(wx0, clamp(wx0, __tsover_mul(wi, -1), wi));
+	const dX = __tsover_add(__tsover_mul(wx, wx), __tsover_mul(wy, wy));
+	const dY = __tsover_mul(wy, -1);
+	const s = __tsover_sub(__tsover_mul(px0, ey), __tsover_mul(py0, ex));
+	const flip2 = s < 0;
+	const px = select(px0, __tsover_mul(px0, -1), flip2);
+	const py = select(py0, __tsover_mul(py0, -1), flip2);
+	const vx0 = __tsover_sub(px, wi);
+	const dotve = __tsover_add(__tsover_mul(vx0, ex), __tsover_mul(py, ey));
+	const dotee = max(__tsover_add(__tsover_mul(ex, ex), __tsover_mul(ey, ey)), 1e-4);
+	const tt = clamp(__tsover_div(dotve, dotee), -1, 1);
+	const vx = __tsover_sub(vx0, __tsover_mul(ex, tt));
+	const vy = __tsover_sub(py, __tsover_mul(ey, tt));
+	const finalX = min(dX, __tsover_add(__tsover_mul(vx, vx), __tsover_mul(vy, vy)));
+	const finalY = min(dY, __tsover_sub(__tsover_mul(wi, he), abs(s)));
+	return __tsover_mul(sqrt(finalX), sign(__tsover_mul(finalY, -1)));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "dx"
+			},
+			{
+				"type": "i",
+				"name": "dy"
+			},
+			{
+				"type": "i",
+				"name": "wi"
+			},
+			{
+				"type": "i",
+				"name": "he"
+			},
+			{
+				"type": "i",
+				"name": "sk"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"ex",
+				"sk"
+			],
+			[
+				13,
+				"ey",
+				"he"
+			],
+			[
+				13,
+				"flip1",
+				[
+					1,
+					"dy",
+					"<",
+					[5, "0"]
+				]
+			],
+			[
+				13,
+				"px0",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"dx",
+						[
+							1,
+							"dx",
+							"*",
+							[
+								4,
+								"-",
+								[5, "1"]
+							]
+						],
+						"flip1"
+					]
+				]
+			],
+			[
+				13,
+				"py0",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"dy",
+						[
+							1,
+							"dy",
+							"*",
+							[
+								4,
+								"-",
+								[5, "1"]
+							]
+						],
+						"flip1"
+					]
+				]
+			],
+			[
+				13,
+				"wx0",
+				[
+					1,
+					"px0",
+					"-",
+					"ex"
+				]
+			],
+			[
+				13,
+				"wy",
+				[
+					1,
+					"py0",
+					"-",
+					"ey"
+				]
+			],
+			[
+				13,
+				"wx",
+				[
+					1,
+					"wx0",
+					"-",
+					[
+						6,
+						[
+							7,
+							"std",
+							"clamp"
+						],
+						[
+							"wx0",
+							[
+								1,
+								"wi",
+								"*",
+								[
+									4,
+									"-",
+									[5, "1"]
+								]
+							],
+							"wi"
+						]
+					]
+				]
+			],
+			[
+				13,
+				"dX",
+				[
+					1,
+					[
+						1,
+						"wx",
+						"*",
+						"wx"
+					],
+					"+",
+					[
+						1,
+						"wy",
+						"*",
+						"wy"
+					]
+				]
+			],
+			[
+				13,
+				"dY",
+				[
+					1,
+					"wy",
+					"*",
+					[
+						4,
+						"-",
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"s",
+				[
+					1,
+					[
+						1,
+						"px0",
+						"*",
+						"ey"
+					],
+					"-",
+					[
+						1,
+						"py0",
+						"*",
+						"ex"
+					]
+				]
+			],
+			[
+				13,
+				"flip2",
+				[
+					1,
+					"s",
+					"<",
+					[5, "0"]
+				]
+			],
+			[
+				13,
+				"px",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"px0",
+						[
+							1,
+							"px0",
+							"*",
+							[
+								4,
+								"-",
+								[5, "1"]
+							]
+						],
+						"flip2"
+					]
+				]
+			],
+			[
+				13,
+				"py",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"py0",
+						[
+							1,
+							"py0",
+							"*",
+							[
+								4,
+								"-",
+								[5, "1"]
+							]
+						],
+						"flip2"
+					]
+				]
+			],
+			[
+				13,
+				"vx0",
+				[
+					1,
+					"px",
+					"-",
+					"wi"
+				]
+			],
+			[
+				13,
+				"dotve",
+				[
+					1,
+					[
+						1,
+						"vx0",
+						"*",
+						"ex"
+					],
+					"+",
+					[
+						1,
+						"py",
+						"*",
+						"ey"
+					]
+				]
+			],
+			[
+				13,
+				"dotee",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					[[
+						1,
+						[
+							1,
+							"ex",
+							"*",
+							"ex"
+						],
+						"+",
+						[
+							1,
+							"ey",
+							"*",
+							"ey"
+						]
+					], [5, "0.0001"]]
+				]
+			],
+			[
+				13,
+				"tt",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							"dotve",
+							"/",
+							"dotee"
+						],
+						[
+							4,
+							"-",
+							[5, "1"]
+						],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"vx",
+				[
+					1,
+					"vx0",
+					"-",
+					[
+						1,
+						"ex",
+						"*",
+						"tt"
+					]
+				]
+			],
+			[
+				13,
+				"vy",
+				[
+					1,
+					"py",
+					"-",
+					[
+						1,
+						"ey",
+						"*",
+						"tt"
+					]
+				]
+			],
+			[
+				13,
+				"finalX",
+				[
+					6,
+					[
+						7,
+						"std",
+						"min"
+					],
+					["dX", [
+						1,
+						[
+							1,
+							"vx",
+							"*",
+							"vx"
+						],
+						"+",
+						[
+							1,
+							"vy",
+							"*",
+							"vy"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"finalY",
+				[
+					6,
+					[
+						7,
+						"std",
+						"min"
+					],
+					["dY", [
+						1,
+						[
+							1,
+							"wi",
+							"*",
+							"he"
+						],
+						"-",
+						[
+							6,
+							[
+								7,
+								"std",
+								"abs"
+							],
+							["s"]
+						]
+					]]
+				]
+			],
+			[10, [
+				1,
+				[
+					6,
+					[
+						7,
+						"std",
+						"sqrt"
+					],
+					["finalX"]
+				],
+				"*",
+				[
+					6,
+					[
+						7,
+						"std",
+						"sign"
+					],
+					[[
+						1,
+						"finalY",
+						"*",
+						[
+							4,
+							"-",
+							[5, "1"]
+						]
+					]]
+				]
+			]]
+		]],
+		"externalNames": ["std"]
+	},
+	externals: () => ({ std: std_exports })
+}) && $.f)({}));
+const shapeLocalCoords = src_default.fn([
+	vec2f,
+	f32,
+	vec2f,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((center, rotation, uv, aspect) => {
+	"use gpu";
+	const aspectUV = vec2f(__tsover_mul(uv.x, aspect), uv.y);
+	const centerPos = vec2f(__tsover_mul(center.x, aspect), __tsover_sub(1, center.y));
+	const dx = __tsover_sub(aspectUV.x, centerPos.x);
+	const dy = __tsover_sub(aspectUV.y, centerPos.y);
+	const rotRad = __tsover_mul(rotation, DEG_TO_RAD);
+	const cosR = cos(rotRad);
+	const sinR = sin(rotRad);
+	return vec2f(__tsover_add(__tsover_mul(dx, cosR), __tsover_mul(dy, sinR)), __tsover_sub(__tsover_mul(dy, cosR), __tsover_mul(dx, sinR)));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "center"
+			},
+			{
+				"type": "i",
+				"name": "rotation"
+			},
+			{
+				"type": "i",
+				"name": "uv"
+			},
+			{
+				"type": "i",
+				"name": "aspect"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"aspectUV",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec2f"
+					],
+					[[
+						1,
+						[
+							7,
+							"uv",
+							"x"
+						],
+						"*",
+						"aspect"
+					], [
+						7,
+						"uv",
+						"y"
+					]]
+				]
+			],
+			[
+				13,
+				"centerPos",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec2f"
+					],
+					[[
+						1,
+						[
+							7,
+							"center",
+							"x"
+						],
+						"*",
+						"aspect"
+					], [
+						1,
+						[5, "1"],
+						"-",
+						[
+							7,
+							"center",
+							"y"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"dx",
+				[
+					1,
+					[
+						7,
+						"aspectUV",
+						"x"
+					],
+					"-",
+					[
+						7,
+						"centerPos",
+						"x"
+					]
+				]
+			],
+			[
+				13,
+				"dy",
+				[
+					1,
+					[
+						7,
+						"aspectUV",
+						"y"
+					],
+					"-",
+					[
+						7,
+						"centerPos",
+						"y"
+					]
+				]
+			],
+			[
+				13,
+				"rotRad",
+				[
+					1,
+					"rotation",
+					"*",
+					"DEG_TO_RAD"
+				]
+			],
+			[
+				13,
+				"cosR",
+				[
+					6,
+					[
+						7,
+						"std",
+						"cos"
+					],
+					["rotRad"]
+				]
+			],
+			[
+				13,
+				"sinR",
+				[
+					6,
+					[
+						7,
+						"std",
+						"sin"
+					],
+					["rotRad"]
+				]
+			],
+			[
+				13,
+				"rdx",
+				[
+					1,
+					[
+						1,
+						"dx",
+						"*",
+						"cosR"
+					],
+					"+",
+					[
+						1,
+						"dy",
+						"*",
+						"sinR"
+					]
+				]
+			],
+			[
+				13,
+				"rdy",
+				[
+					1,
+					[
+						1,
+						"dy",
+						"*",
+						"cosR"
+					],
+					"-",
+					[
+						1,
+						"dx",
+						"*",
+						"sinR"
+					]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"d",
+					"vec2f"
+				],
+				["rdx", "rdy"]
+			]]
+		]],
+		"externalNames": [
+			"d",
+			"DEG_TO_RAD",
+			"std"
+		]
+	},
+	externals: () => ({
+		d: data_exports,
+		DEG_TO_RAD,
+		std: std_exports
+	})
+}) && $.f)({}));
+const ShapeMask = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
+	overallMask: f32,
+	strokeBlend: f32
+}), "ShapeMask");
+const strokeMaskFromSdf = src_default.fn([
+	f32,
+	f32,
+	f32,
+	f32
+], ShapeMask)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((dist, softness, strokeThickness, strokePosition) => {
+	"use gpu";
+	const hasStroke = strokeThickness > 0;
+	const isInside = strokePosition >= 1.5;
+	const isCenterOrAbove = strokePosition >= .5;
+	const halfThickness = __tsover_mul(strokeThickness, .5);
+	const negThickness = __tsover_mul(strokeThickness, -1);
+	const negHalf = __tsover_mul(halfThickness, -1);
+	const strokeInner = select(select(f32(0), negHalf, isCenterOrAbove), negThickness, isInside);
+	const strokeOuter = select(select(strokeThickness, halfThickness, isCenterOrAbove), f32(0), isInside);
+	const overallMask = __tsover_sub(1, smoothstep(__tsover_sub(strokeOuter, softness), strokeOuter, dist));
+	const blend = smoothstep(__tsover_sub(strokeInner, softness), strokeInner, dist);
+	return ShapeMask({
+		overallMask,
+		strokeBlend: select(f32(0), blend, hasStroke)
+	});
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "dist"
+			},
+			{
+				"type": "i",
+				"name": "softness"
+			},
+			{
+				"type": "i",
+				"name": "strokeThickness"
+			},
+			{
+				"type": "i",
+				"name": "strokePosition"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"hasStroke",
+				[
+					1,
+					"strokeThickness",
+					">",
+					[5, "0"]
+				]
+			],
+			[
+				13,
+				"isInside",
+				[
+					1,
+					"strokePosition",
+					">=",
+					[5, "1.5"]
+				]
+			],
+			[
+				13,
+				"isCenterOrAbove",
+				[
+					1,
+					"strokePosition",
+					">=",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"halfThickness",
+				[
+					1,
+					"strokeThickness",
+					"*",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"negThickness",
+				[
+					1,
+					"strokeThickness",
+					"*",
+					[
+						4,
+						"-",
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"negHalf",
+				[
+					1,
+					"halfThickness",
+					"*",
+					[
+						4,
+						"-",
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"strokeInner",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						[
+							6,
+							[
+								7,
+								"std",
+								"select"
+							],
+							[
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									[[5, "0"]]
+								],
+								"negHalf",
+								"isCenterOrAbove"
+							]
+						],
+						"negThickness",
+						"isInside"
+					]
+				]
+			],
+			[
+				13,
+				"strokeOuter",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						[
+							6,
+							[
+								7,
+								"std",
+								"select"
+							],
+							[
+								"strokeThickness",
+								"halfThickness",
+								"isCenterOrAbove"
+							]
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "0"]]
+						],
+						"isInside"
+					]
+				]
+			],
+			[
+				13,
+				"overallMask",
+				[
+					1,
+					[5, "1"],
+					"-",
+					[
+						6,
+						[
+							7,
+							"std",
+							"smoothstep"
+						],
+						[
+							[
+								1,
+								"strokeOuter",
+								"-",
+								"softness"
+							],
+							"strokeOuter",
+							"dist"
+						]
+					]
+				]
+			],
+			[
+				13,
+				"blend",
+				[
+					6,
+					[
+						7,
+						"std",
+						"smoothstep"
+					],
+					[
+						[
+							1,
+							"strokeInner",
+							"-",
+							"softness"
+						],
+						"strokeInner",
+						"dist"
+					]
+				]
+			],
+			[
+				13,
+				"strokeBlend",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "0"]]
+						],
+						"blend",
+						"hasStroke"
+					]
+				]
+			],
+			[10, [
+				6,
+				"ShapeMask",
+				[[104, {
+					"overallMask": "overallMask",
+					"strokeBlend": "strokeBlend"
+				}]]
+			]]
+		]],
+		"externalNames": [
+			"std",
+			"d",
+			"ShapeMask"
+		]
+	},
+	externals: () => ({
+		std: std_exports,
+		d: data_exports,
+		ShapeMask
+	})
+}) && $.f)({}));
+async function loadSdfFromUrl(url, sdfData) {
+	const response = await fetch(url, { mode: "cors" });
+	if (!response.ok) throw new Error(`SDF fetch failed: HTTP ${response.status}`);
+	const buffer = await response.arrayBuffer();
+	const pixelCount = 512 * 512;
+	if (buffer.byteLength === pixelCount * 2) {
+		const uint16 = new Uint16Array(buffer);
+		const n = Math.min(uint16.length, sdfData.length);
+		for (let i = 0; i < n; i++) sdfData[i] = uint16[i] / 32767.5 - 1;
+	} else if (buffer.byteLength === pixelCount * 4) {
+		const floats = new Float32Array(buffer);
+		const n = Math.min(floats.length, sdfData.length);
+		for (let i = 0; i < n; i++) sdfData[i] = floats[i];
+	} else throw new Error(`SDF binary has unexpected size (${buffer.byteLength} bytes); expected ${pixelCount * 2} (compact) or ${pixelCount * 4} (legacy). The URL may point to a non-SDF file (e.g. the raw SVG).`);
+}
+function createSdfDataTexture(params, shapeSdfUrl) {
+	const count = 512 * 512;
+	const sdfData = new Float32Array(count).fill(.5);
+	const texData = new Uint16Array(count);
+	const halfHalf = toHalfFloat(.5);
+	for (let i = 0; i < count; i++) texData[i] = halfHalf;
+	const texture = params.createDataTexture({
+		width: 512,
+		height: 512,
+		format: "r16float",
+		data: texData,
+		label: "svg-sdf"
+	});
+	params.onCleanup(() => texture.destroy());
+	let needsUpload = false;
+	let version = 0;
+	if (shapeSdfUrl) loadSdfFromUrl(shapeSdfUrl, sdfData).then(() => {
+		for (let i = 0; i < count; i++) texData[i] = toHalfFloat(sdfData[i]);
+		needsUpload = true;
+	}).catch((err) => debugWarn("[SDF] Failed to load SDF texture:", err));
+	params.onBeforeRender(() => {
+		if (needsUpload) {
+			needsUpload = false;
+			texture.write(texData);
+			version++;
+		}
+	});
+	return {
+		kitTexture: params.registerMediaTexture(() => texture.texture),
+		texture,
+		getVersion: () => version
+	};
+}
+function createSvgSdfSampler(params, shapeSdfUrl) {
+	const { kitTexture } = createSdfDataTexture(params, shapeSdfUrl);
+	return (uv) => kitTexture.sample(uv);
+}
+function createSvgSdfSamplerWithGradients(params, shapeSdfUrl) {
+	const size = 512;
+	const count = size * size;
+	const sdfData = new Float32Array(count).fill(.5);
+	const texData = new Uint16Array(count * 4);
+	const halfHalf = toHalfFloat(.5);
+	const halfOne = toHalfFloat(1);
+	for (let i = 0; i < count; i++) {
+		texData[i * 4] = halfHalf;
+		texData[i * 4 + 3] = halfOne;
+	}
+	const texture = params.createMediaTexture({
+		width: size,
+		height: size,
+		format: "rgba16float",
+		label: "svg-sdf-grad"
+	});
+	params.onCleanup(() => texture.destroy());
+	const sampleField = (tx, ty) => {
+		const x0 = Math.floor(tx);
+		const y0 = Math.floor(ty);
+		const fx = tx - x0;
+		const fy = ty - y0;
+		const cl = (v) => Math.min(Math.max(v, 0), size - 1);
+		const x0c = cl(x0), x1c = cl(x0 + 1), y0c = cl(y0), y1c = cl(y0 + 1);
+		return sdfData[y0c * size + x0c] * (1 - fx) * (1 - fy) + sdfData[y0c * size + x1c] * fx * (1 - fy) + sdfData[y1c * size + x0c] * (1 - fx) * fy + sdfData[y1c * size + x1c] * fx * fy;
+	};
+	const EPS_UV = .01;
+	const epsTexels = EPS_UV * size;
+	const bake = () => {
+		for (let y = 0; y < size; y++) for (let x = 0; x < size; x++) {
+			const i = y * size + x;
+			const f0 = sdfData[i];
+			const gx = (sampleField(x + epsTexels, y) - f0) / EPS_UV;
+			const gy = (sampleField(x, y + epsTexels) - f0) / EPS_UV;
+			texData[i * 4] = toHalfFloat(f0);
+			texData[i * 4 + 1] = toHalfFloat(gx);
+			texData[i * 4 + 2] = toHalfFloat(gy);
+		}
+	};
+	let needsUpload = false;
+	if (shapeSdfUrl) loadSdfFromUrl(shapeSdfUrl, sdfData).then(() => {
+		bake();
+		needsUpload = true;
+	}).catch((err) => debugWarn("[SDF] Failed to load SDF texture:", err));
+	params.onBeforeRender(() => {
+		if (needsUpload) {
+			needsUpload = false;
+			texture.write(texData);
+		}
+	});
+	const kitTexture = params.registerMediaTexture(() => texture.texture);
+	return (uv) => kitTexture.sample(uv);
+}
+var APERTURE_TO_HALFANGLE = .008726646259971648;
+function buildAnalyticSdfFn(shapeType) {
+	return src_default.fn([
+		vec2f,
+		f32,
+		f32,
+		f32,
+		f32,
+		f32,
+		f32,
+		f32,
+		f32
+	], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, r, n, round, inner, rot, h, off, ap) => {
+		"use gpu";
+		const dx = __tsover_sub(uv.x, .5);
+		const dy = __tsover_sub(uv.y, .5);
+		const rotRad = __tsover_mul(rot, DEG_TO_RAD);
+		const cosR = cos(rotRad);
+		const sinR = sin(rotRad);
+		const rdx = __tsover_add(__tsover_mul(dx, cosR), __tsover_mul(dy, sinR));
+		const rdy = __tsover_sub(__tsover_mul(dy, cosR), __tsover_mul(dx, sinR));
+		let dist = f32(0);
+		if (shapeType === "polygonSDF") dist = mix(polygonSdf(rdx, rdy, r, n), circleSdf(rdx, rdy, r), round);
+		else if (shapeType === "flowerSDF") dist = flowerSdf(rdx, rdy, r, n, inner);
+		else if (shapeType === "ringSDF") dist = ringSdf(rdx, rdy, r, inner);
+		else if (shapeType === "crossSDF") dist = crossSdf(rdx, rdy, r, inner, round);
+		else if (shapeType === "starSDF") dist = starSdf(rdx, rdy, r, n, inner);
+		else if (shapeType === "roundedRectSDF") dist = roundedRectSdf(rdx, rdy, r, h, round);
+		else if (shapeType === "ellipseSDF") dist = ellipseSdf(rdx, rdy, r, h);
+		else if (shapeType === "vesicaSDF") dist = vesicaSdf(rdx, rdy, r, inner);
+		else if (shapeType === "crescentSDF") dist = crescentSdf(rdx, rdy, r, inner, off);
+		else if (shapeType === "trapezoidSDF") dist = trapezoidSdf(rdx, rdy, inner, r, h);
+		else if (shapeType === "heartSDF") dist = heartSdf(rdx, rdy, r);
+		else if (shapeType === "arcSDF") dist = arcSdf(rdx, rdy, r, __tsover_mul(ap, APERTURE_TO_HALFANGLE));
+		else if (shapeType === "teardropSDF") dist = teardropSdf(rdx, rdy, r, h);
+		else if (shapeType === "parallelogramSDF") dist = parallelogramSdf(rdx, rdy, r, h, off);
+		else dist = circleSdf(rdx, rdy, r);
+		return vec4f(dist, 0, 0, 1);
+	}), {
+		v: 1,
+		name: void 0,
+		ast: {
+			"params": [
+				{
+					"type": "i",
+					"name": "uv"
+				},
+				{
+					"type": "i",
+					"name": "r"
+				},
+				{
+					"type": "i",
+					"name": "n"
+				},
+				{
+					"type": "i",
+					"name": "round"
+				},
+				{
+					"type": "i",
+					"name": "inner"
+				},
+				{
+					"type": "i",
+					"name": "rot"
+				},
+				{
+					"type": "i",
+					"name": "h"
+				},
+				{
+					"type": "i",
+					"name": "off"
+				},
+				{
+					"type": "i",
+					"name": "ap"
+				}
+			],
+			"body": [0, [
+				[
+					13,
+					"dx",
+					[
+						1,
+						[
+							7,
+							"uv",
+							"x"
+						],
+						"-",
+						[5, "0.5"]
+					]
+				],
+				[
+					13,
+					"dy",
+					[
+						1,
+						[
+							7,
+							"uv",
+							"y"
+						],
+						"-",
+						[5, "0.5"]
+					]
+				],
+				[
+					13,
+					"rotRad",
+					[
+						1,
+						"rot",
+						"*",
+						"DEG_TO_RAD"
+					]
+				],
+				[
+					13,
+					"cosR",
+					[
+						6,
+						[
+							7,
+							"std",
+							"cos"
+						],
+						["rotRad"]
+					]
+				],
+				[
+					13,
+					"sinR",
+					[
+						6,
+						[
+							7,
+							"std",
+							"sin"
+						],
+						["rotRad"]
+					]
+				],
+				[
+					13,
+					"rdx",
+					[
+						1,
+						[
+							1,
+							"dx",
+							"*",
+							"cosR"
+						],
+						"+",
+						[
+							1,
+							"dy",
+							"*",
+							"sinR"
+						]
+					]
+				],
+				[
+					13,
+					"rdy",
+					[
+						1,
+						[
+							1,
+							"dy",
+							"*",
+							"cosR"
+						],
+						"-",
+						[
+							1,
+							"dx",
+							"*",
+							"sinR"
+						]
+					]
+				],
+				[
+					12,
+					"dist",
+					[
+						6,
+						[
+							7,
+							"d",
+							"f32"
+						],
+						[[5, "0"]]
+					]
+				],
+				[
+					11,
+					[
+						1,
+						"shapeType",
+						"===",
+						[103, "polygonSDF"]
+					],
+					[
+						2,
+						"dist",
+						"=",
+						[
+							6,
+							[
+								7,
+								"std",
+								"mix"
+							],
+							[
+								[
+									6,
+									"polygonSdf",
+									[
+										"rdx",
+										"rdy",
+										"r",
+										"n"
+									]
+								],
+								[
+									6,
+									"circleSdf",
+									[
+										"rdx",
+										"rdy",
+										"r"
+									]
+								],
+								"round"
+							]
+						]
+					],
+					[
+						11,
+						[
+							1,
+							"shapeType",
+							"===",
+							[103, "flowerSDF"]
+						],
+						[
+							2,
+							"dist",
+							"=",
+							[
+								6,
+								"flowerSdf",
+								[
+									"rdx",
+									"rdy",
+									"r",
+									"n",
+									"inner"
+								]
+							]
+						],
+						[
+							11,
+							[
+								1,
+								"shapeType",
+								"===",
+								[103, "ringSDF"]
+							],
+							[
+								2,
+								"dist",
+								"=",
+								[
+									6,
+									"ringSdf",
+									[
+										"rdx",
+										"rdy",
+										"r",
+										"inner"
+									]
+								]
+							],
+							[
+								11,
+								[
+									1,
+									"shapeType",
+									"===",
+									[103, "crossSDF"]
+								],
+								[
+									2,
+									"dist",
+									"=",
+									[
+										6,
+										"crossSdf",
+										[
+											"rdx",
+											"rdy",
+											"r",
+											"inner",
+											"round"
+										]
+									]
+								],
+								[
+									11,
+									[
+										1,
+										"shapeType",
+										"===",
+										[103, "starSDF"]
+									],
+									[
+										2,
+										"dist",
+										"=",
+										[
+											6,
+											"starSdf",
+											[
+												"rdx",
+												"rdy",
+												"r",
+												"n",
+												"inner"
+											]
+										]
+									],
+									[
+										11,
+										[
+											1,
+											"shapeType",
+											"===",
+											[103, "roundedRectSDF"]
+										],
+										[
+											2,
+											"dist",
+											"=",
+											[
+												6,
+												"roundedRectSdf",
+												[
+													"rdx",
+													"rdy",
+													"r",
+													"h",
+													"round"
+												]
+											]
+										],
+										[
+											11,
+											[
+												1,
+												"shapeType",
+												"===",
+												[103, "ellipseSDF"]
+											],
+											[
+												2,
+												"dist",
+												"=",
+												[
+													6,
+													"ellipseSdf",
+													[
+														"rdx",
+														"rdy",
+														"r",
+														"h"
+													]
+												]
+											],
+											[
+												11,
+												[
+													1,
+													"shapeType",
+													"===",
+													[103, "vesicaSDF"]
+												],
+												[
+													2,
+													"dist",
+													"=",
+													[
+														6,
+														"vesicaSdf",
+														[
+															"rdx",
+															"rdy",
+															"r",
+															"inner"
+														]
+													]
+												],
+												[
+													11,
+													[
+														1,
+														"shapeType",
+														"===",
+														[103, "crescentSDF"]
+													],
+													[
+														2,
+														"dist",
+														"=",
+														[
+															6,
+															"crescentSdf",
+															[
+																"rdx",
+																"rdy",
+																"r",
+																"inner",
+																"off"
+															]
+														]
+													],
+													[
+														11,
+														[
+															1,
+															"shapeType",
+															"===",
+															[103, "trapezoidSDF"]
+														],
+														[
+															2,
+															"dist",
+															"=",
+															[
+																6,
+																"trapezoidSdf",
+																[
+																	"rdx",
+																	"rdy",
+																	"inner",
+																	"r",
+																	"h"
+																]
+															]
+														],
+														[
+															11,
+															[
+																1,
+																"shapeType",
+																"===",
+																[103, "heartSDF"]
+															],
+															[
+																2,
+																"dist",
+																"=",
+																[
+																	6,
+																	"heartSdf",
+																	[
+																		"rdx",
+																		"rdy",
+																		"r"
+																	]
+																]
+															],
+															[
+																11,
+																[
+																	1,
+																	"shapeType",
+																	"===",
+																	[103, "arcSDF"]
+																],
+																[
+																	2,
+																	"dist",
+																	"=",
+																	[
+																		6,
+																		"arcSdf",
+																		[
+																			"rdx",
+																			"rdy",
+																			"r",
+																			[
+																				1,
+																				"ap",
+																				"*",
+																				"APERTURE_TO_HALFANGLE"
+																			]
+																		]
+																	]
+																],
+																[
+																	11,
+																	[
+																		1,
+																		"shapeType",
+																		"===",
+																		[103, "teardropSDF"]
+																	],
+																	[
+																		2,
+																		"dist",
+																		"=",
+																		[
+																			6,
+																			"teardropSdf",
+																			[
+																				"rdx",
+																				"rdy",
+																				"r",
+																				"h"
+																			]
+																		]
+																	],
+																	[
+																		11,
+																		[
+																			1,
+																			"shapeType",
+																			"===",
+																			[103, "parallelogramSDF"]
+																		],
+																		[
+																			2,
+																			"dist",
+																			"=",
+																			[
+																				6,
+																				"parallelogramSdf",
+																				[
+																					"rdx",
+																					"rdy",
+																					"r",
+																					"h",
+																					"off"
+																				]
+																			]
+																		],
+																		[
+																			2,
+																			"dist",
+																			"=",
+																			[
+																				6,
+																				"circleSdf",
+																				[
+																					"rdx",
+																					"rdy",
+																					"r"
+																				]
+																			]
+																		]
+																	]
+																]
+															]
+														]
+													]
+												]
+											]
+										]
+									]
+								]
+							]
+						]
+					]
+				],
+				[10, [
+					6,
+					[
+						7,
+						"d",
+						"vec4f"
+					],
+					[
+						"dist",
+						[5, "0"],
+						[5, "0"],
+						[5, "1"]
+					]
+				]]
+			]],
+			"externalNames": [
+				"DEG_TO_RAD",
+				"std",
+				"d",
+				"shapeType",
+				"polygonSdf",
+				"circleSdf",
+				"flowerSdf",
+				"ringSdf",
+				"crossSdf",
+				"starSdf",
+				"roundedRectSdf",
+				"ellipseSdf",
+				"vesicaSdf",
+				"crescentSdf",
+				"trapezoidSdf",
+				"heartSdf",
+				"arcSdf",
+				"APERTURE_TO_HALFANGLE",
+				"teardropSdf",
+				"parallelogramSdf"
+			]
+		},
+		externals: () => ({
+			DEG_TO_RAD,
+			std: std_exports,
+			d: data_exports,
+			shapeType,
+			polygonSdf,
+			circleSdf,
+			flowerSdf,
+			ringSdf,
+			crossSdf,
+			starSdf,
+			roundedRectSdf,
+			ellipseSdf,
+			vesicaSdf,
+			crescentSdf,
+			trapezoidSdf,
+			heartSdf,
+			arcSdf,
+			APERTURE_TO_HALFANGLE,
+			teardropSdf,
+			parallelogramSdf
+		})
+	}) && $.f)({})).$name(`analyticSdf_${shapeType}`);
+}
+function createAnalyticSdfSampler(shapeType, sub, _patternMode = "none") {
+	const radius = sub.radius ?? floatE(0);
+	const sides = sub.sides ?? floatE(0);
+	const rounding = sub.rounding ?? floatE(0);
+	const innerRatio = sub.innerRatio ?? floatE(0);
+	const rotation = sub.rotation ?? floatE(0);
+	const height = sub.height ?? floatE(0);
+	const offset = sub.offset ?? floatE(0);
+	const aperture = sub.aperture ?? floatE(0);
+	const fn = buildAnalyticSdfFn(shapeType);
+	return (uv) => call(fn, `analyticSdf_${shapeType}`, [
+		uv,
+		radius,
+		sides,
+		rounding,
+		innerRatio,
+		rotation,
+		height,
+		offset,
+		aperture
+	]);
+}
+const ANALYTIC_SDF_EXTRA_FIELDS = {
+	_saRadius: {
+		schema: f32,
+		initial: .35
+	},
+	_saSides: {
+		schema: f32,
+		initial: 6
+	},
+	_saRounding: {
+		schema: f32,
+		initial: 0
+	},
+	_saInnerRatio: {
+		schema: f32,
+		initial: .4
+	},
+	_saRotation: {
+		schema: f32,
+		initial: 0
+	},
+	_saHeight: {
+		schema: f32,
+		initial: .25
+	},
+	_saOffset: {
+		schema: f32,
+		initial: .2
+	},
+	_saAperture: {
+		schema: f32,
+		initial: 270
+	}
+};
+function driveAnalyticSubProps(params, getShapeConfig) {
+	let lastShapeJson = "";
+	let lastCfg = (() => {
+		const raw = getShapeConfig();
+		if (raw && typeof raw === "object") return raw;
+		if (typeof raw === "string") try {
+			return JSON.parse(raw);
+		} catch {
+			return {};
+		}
+		return {};
+	})();
+	const num = (v, f) => typeof v === "number" ? v : f;
+	const write = () => {
+		const c = lastCfg;
+		params.setExtraField("_saRadius", num(c.radius, num(c.width, num(c.bottomWidth, .35))));
+		params.setExtraField("_saSides", num(c.sides, 6));
+		params.setExtraField("_saRounding", num(c.rounding, 0));
+		params.setExtraField("_saInnerRatio", num(c.innerRatio, num(c.thickness, num(c.spread, num(c.topWidth, num(c.topRatio, .4))))));
+		params.setExtraField("_saRotation", num(c.rotation, 0));
+		params.setExtraField("_saHeight", num(c.height, .25));
+		params.setExtraField("_saOffset", num(c.offset, num(c.skew, .2)));
+		params.setExtraField("_saAperture", num(c.aperture, 270));
+	};
+	params.onBeforeRender(() => {
+		const raw = getShapeConfig();
+		if (raw && typeof raw === "object") lastCfg = raw;
+		else if (typeof raw === "string") {
+			if (raw !== lastShapeJson) {
+				lastShapeJson = raw;
+				try {
+					lastCfg = JSON.parse(raw);
+				} catch {
+					return;
+				}
+			}
+		}
+		write();
+	});
+	const u = params.uniforms;
+	return {
+		radius: u._saRadius,
+		sides: u._saSides,
+		rounding: u._saRounding,
+		innerRatio: u._saInnerRatio,
+		rotation: u._saRotation,
+		height: u._saHeight,
+		offset: u._saOffset,
+		aperture: u._saAperture
+	};
+}
+export { starSdf as _, createSdfDataTexture as a, trapezoidSdf as b, ellipseSdf as c, parallelogramSdf as d, polygonSdf as f, shapeLocalCoords as g, sdf_exports as h, circleSdf as i, flowerSdf as l, roundedRectSdf as m, ShapeMask as n, crescentSdf as o, ringSdf as p, arcSdf as r, crossSdf as s, SVG_SDF_SIZE as t, heartSdf as u, strokeMaskFromSdf as v, vesicaSdf as x, teardropSdf as y };