shaders 3.1.462 → 3.2.464

package/dist/core/device-DKcu50_C.js

@@ -1,5025 +0,0 @@
-import { $t as vec2u, Dt as sin, Et as sign, H as mixColorsLinear, Ht as isWgslExternalTexture, Kt as arrayOf, Lt as vec4f$1, Mt as vec2f, Ot as smoothstep, U as mixColorsVariants, Ut as isWgslTexture, _t as max, an as dualImpl, b as vec4, cn as i32, ct as clamp, en as vec3u, et as typegpu_default, hn as __export, in as MissingCpuImplError, it as abs, kt as sqrt, ln as u32, lt as cos, m as call, mt as floor, nn as vec4i, nt as getTextureFormatInfo, ot as atan2, pn as Void, qt as struct, rn as vec4u, rt as select, sn as f32, tn as vec4f, un as stitch, v as floatE, vt as min, yt as mix } from "./edges-CV-BHMpI.js";
-import { r as debugWarn } from "./support-DVuLvN48.js";
-function compactSnippetArgs(args) {
-	return args.filter((arg) => arg !== void 0);
-}
-function sampleCpu(_texture, _sampler, _coords, _offsetOrArrayIndex, _maybeOffset) {
-	throw new MissingCpuImplError("Texture sampling relies on GPU resources and cannot be executed outside of a draw call");
-}
-dualImpl({
-	name: "textureSample",
-	normalImpl: sampleCpu,
-	codegenImpl: (ctx, args) => ctx.gen.emitCall("textureSample", [], compactSnippetArgs(args)),
-	signature: (...args) => {
-		return {
-			argTypes: args,
-			returnType: args[0].type.startsWith("texture_depth") ? f32 : vec4f
-		};
-	},
-	sideEffects: false
-});
-function sampleBiasCpu(_texture, _sampler, _coords, _biasOrArrayIndex, _biasOrOffset, _maybeOffset) {
-	throw new MissingCpuImplError("Texture sampling with bias relies on GPU resources and cannot be executed outside of a draw call");
-}
-dualImpl({
-	name: "textureSampleBias",
-	normalImpl: sampleBiasCpu,
-	codegenImpl: (ctx, args) => ctx.gen.emitCall("textureSampleBias", [], compactSnippetArgs(args)),
-	signature: (...args) => ({
-		argTypes: args,
-		returnType: vec4f
-	}),
-	sideEffects: false
-});
-function sampleLevelCpu(_texture, _sampler, _coords, _level, _offsetOrArrayIndex, _maybeOffset) {
-	throw new MissingCpuImplError("Texture sampling relies on GPU resources and cannot be executed outside of a draw call");
-}
-const textureSampleLevel = dualImpl({
-	name: "textureSampleLevel",
-	normalImpl: sampleLevelCpu,
-	codegenImpl: (ctx, args) => ctx.gen.emitCall("textureSampleLevel", [], compactSnippetArgs(args)),
-	signature: (...args) => {
-		return {
-			argTypes: args,
-			returnType: args[0].type.startsWith("texture_depth") ? f32 : vec4f
-		};
-	},
-	sideEffects: false
-});
-function textureLoadCpu(_texture, _coords, _levelOrArrayIndex) {
-	throw new MissingCpuImplError("`textureLoad` relies on GPU resources and cannot be executed outside of a draw call");
-}
-const textureLoad = dualImpl({
-	name: "textureLoad",
-	normalImpl: textureLoadCpu,
-	codegenImpl: (ctx, args) => ctx.gen.emitCall("textureLoad", [], compactSnippetArgs(args)),
-	signature: (...args) => {
-		const texture = args[0];
-		if (isWgslTexture(texture)) {
-			const isDepth = texture.type.startsWith("texture_depth");
-			const sampleType = texture.sampleType;
-			return {
-				argTypes: args,
-				returnType: isDepth ? f32 : sampleType.type === "f32" ? vec4f : sampleType.type === "u32" ? vec4u : vec4i
-			};
-		}
-		if (isWgslExternalTexture(texture)) return {
-			argTypes: args,
-			returnType: vec4f
-		};
-		const format = texture.format;
-		return {
-			argTypes: args,
-			returnType: getTextureFormatInfo(format).vectorType
-		};
-	},
-	sideEffects: false
-});
-function textureStoreCpu(_texture, _coords, _arrayIndexOrValue, _maybeValue) {
-	throw new MissingCpuImplError("`textureStore` relies on GPU resources and cannot be executed outside of a draw call");
-}
-const textureStore = dualImpl({
-	name: "textureStore",
-	normalImpl: textureStoreCpu,
-	codegenImpl: (_ctx, args) => stitch`textureStore(${args})`,
-	signature: (...args) => ({
-		argTypes: args,
-		returnType: Void
-	}),
-	sideEffects: true
-});
-function textureDimensionsCpu(_texture, _level) {
-	throw new MissingCpuImplError("`textureDimensions` relies on GPU resources and cannot be executed outside of a draw call");
-}
-const textureDimensions = dualImpl({
-	name: "textureDimensions",
-	normalImpl: textureDimensionsCpu,
-	codegenImpl: (ctx, args) => ctx.gen.emitCall("textureDimensions", [], compactSnippetArgs(args)),
-	signature: (...args) => {
-		const dim = args[0].dimension;
-		if (dim === "1d") return {
-			argTypes: args,
-			returnType: u32
-		};
-		if (dim === "3d") return {
-			argTypes: args,
-			returnType: vec3u
-		};
-		return {
-			argTypes: args,
-			returnType: vec2u
-		};
-	},
-	sideEffects: false
-});
-const textureGatherCpu = (..._args) => {
-	throw new Error("Texture gather relies on GPU resources and cannot be executed outside of a draw call");
-};
-var sampleTypeToVecType = {
-	f32: vec4f,
-	i32: vec4i,
-	u32: vec4u
-};
-dualImpl({
-	name: "textureGather",
-	normalImpl: textureGatherCpu,
-	codegenImpl: (_ctx, args) => stitch`textureGather(${args})`,
-	signature: (...args) => {
-		if (args[0].type.startsWith("texture")) {
-			const [texture$1, sampler$1, coords$1, _$1, ...rest$1] = args;
-			return {
-				argTypes: texture$1.type === "texture_depth_2d_array" || texture$1.type === "texture_depth_cube_array" ? [
-					texture$1,
-					sampler$1,
-					coords$1,
-					[u32, i32],
-					...rest$1
-				] : args,
-				returnType: vec4f
-			};
-		}
-		const [_, texture, sampler, coords, ...rest] = args;
-		return {
-			argTypes: texture.type === "texture_2d_array" || texture.type === "texture_cube_array" ? [
-				[u32, i32],
-				texture,
-				sampler,
-				coords,
-				[u32, i32],
-				...rest
-			] : [
-				[u32, i32],
-				texture,
-				sampler,
-				coords,
-				...rest
-			],
-			returnType: sampleTypeToVecType[texture.sampleType.type]
-		};
-	},
-	sideEffects: false
-});
-function textureSampleCompareCpu(_texture, _sampler, _coords, _depthRefOrArrayIndex, _depthRefOrOffset, _maybeOffset) {
-	throw new MissingCpuImplError("Texture comparison sampling relies on GPU resources and cannot be executed outside of a draw call");
-}
-dualImpl({
-	name: "textureSampleCompare",
-	normalImpl: textureSampleCompareCpu,
-	codegenImpl: (_ctx, args) => stitch`textureSampleCompare(${args})`,
-	signature: (...args) => ({
-		argTypes: args,
-		returnType: f32
-	}),
-	sideEffects: false
-});
-function textureSampleCompareLevelCpu(_texture, _sampler, _coords, _depthRefOrArrayIndex, _depthRefOrOffset, _maybeOffset) {
-	throw new MissingCpuImplError("Texture comparison sampling with level relies on GPU resources and cannot be executed outside of a draw call");
-}
-dualImpl({
-	name: "textureSampleCompareLevel",
-	normalImpl: textureSampleCompareLevelCpu,
-	codegenImpl: (ctx, args) => stitch`textureSampleCompareLevel(${args})`,
-	signature: (...args) => ({
-		argTypes: args,
-		returnType: f32
-	}),
-	sideEffects: false
-});
-function textureSampleBaseClampToEdgeCpu(_texture, _sampler, _coords) {
-	throw new MissingCpuImplError("Texture sampling with base clamp to edge is not supported outside of GPU mode.");
-}
-function sampleGradCpu(_texture, _sampler, _coords, _ddxOrArrayIndex, _ddyOrDdx, _offsetOrDdy, _maybeOffset) {
-	throw new MissingCpuImplError("Texture sampling with gradients relies on GPU resources and cannot be executed outside of a draw call");
-}
-dualImpl({
-	name: "textureSampleGrad",
-	normalImpl: sampleGradCpu,
-	codegenImpl: (_ctx, args) => stitch`textureSampleGrad(${args})`,
-	signature: (...args) => ({
-		argTypes: args,
-		returnType: vec4f
-	}),
-	sideEffects: false
-});
-dualImpl({
-	name: "textureSampleBaseClampToEdge",
-	normalImpl: textureSampleBaseClampToEdgeCpu,
-	codegenImpl: (_ctx, args) => stitch`textureSampleBaseClampToEdge(${args})`,
-	signature: (...args) => ({
-		argTypes: args,
-		returnType: vec4f
-	}),
-	sideEffects: false
-});
-function wrapGuarded(guarded, size) {
-	return {
-		guarded,
-		with(bindGroup) {
-			return wrapGuarded(guarded.with(bindGroup), size);
-		},
-		dispatch() {
-			if (!size) throw new Error("[gpu] KitComputePipeline.dispatch(): no pre-bound size — pass opts.size to createGuardedCompute or call dispatchThreads(...) directly");
-			guarded.dispatchThreads(...size);
-		},
-		dispatchThreads(...threads) {
-			guarded.dispatchThreads(...threads);
-		}
-	};
-}
-function createGuardedCompute(root, callback, opts = {}) {
-	let guarded = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createGuardedComputePipeline(callback), "guarded");
-	if (opts.bindGroup) guarded = guarded.with(opts.bindGroup);
-	return wrapGuarded(guarded, opts.size);
-}
-function createComputeDispatcher(root) {
-	return { dispatch(steps) {
-		for (const step of steps) if (typeof step === "function") step();
-		else step.dispatch();
-	} };
-}
-function createPingPongPair(a, b) {
-	let flipped = false;
-	const read = () => flipped ? b : a;
-	const write = () => flipped ? a : b;
-	return {
-		a,
-		b,
-		orientation: () => flipped ? 1 : 0,
-		readSource: read,
-		writeTarget: write,
-		swap() {
-			flipped = !flipped;
-		},
-		reset() {
-			flipped = false;
-		},
-		groups(make) {
-			const ab = make(a, b);
-			const ba = make(b, a);
-			return () => flipped ? ba : ab;
-		},
-		perSide(make) {
-			const forA = make(a);
-			const forB = make(b);
-			return {
-				read: () => flipped ? forB : forA,
-				written: () => flipped ? forA : forB
-			};
-		}
-	};
-}
-function createStateBuffer(root, schema, count) {
-	return (/* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createBuffer(arrayOf(schema, count)), "buffer")).$usage("storage");
-}
-var _f32Scratch = new Float32Array(1);
-var _i32Scratch = new Int32Array(_f32Scratch.buffer);
-function toHalfFloat(val) {
-	_f32Scratch[0] = Math.max(-65504, Math.min(65504, val));
-	const x = _i32Scratch[0];
-	let bits = x >> 16 & 32768;
-	let m = x >> 12 & 2047;
-	const e = x >> 23 & 255;
-	if (e < 103) return bits;
-	if (e > 142) {
-		bits |= 31744;
-		bits |= (e === 255 ? 0 : 1) && x & 8388607;
-		return bits;
-	}
-	if (e < 113) {
-		m |= 2048;
-		bits |= (m >> 114 - e) + (m >> 113 - e & 1);
-		return bits;
-	}
-	bits |= e - 112 << 10 | m >> 1;
-	bits += m & 1;
-	return bits;
-}
-var sdf_exports = /* @__PURE__ */ __export({
-	ANALYTIC_SDF_EXTRA_FIELDS: () => ANALYTIC_SDF_EXTRA_FIELDS,
-	APERTURE_TO_HALFANGLE: () => APERTURE_TO_HALFANGLE,
-	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,
-	fillStrokeColor: () => fillStrokeColor,
-	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 = typegpu_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: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "dx"
-			},
-			{
-				"type": "i",
-				"name": "dy"
-			},
-			{
-				"type": "i",
-				"name": "radius"
-			}
-		],
-		"body": [0, [[10, [
-			1,
-			[
-				6,
-				"std.sqrt",
-				[[
-					1,
-					[
-						1,
-						"dx",
-						"*",
-						"dx"
-					],
-					"+",
-					[
-						1,
-						"dy",
-						"*",
-						"dy"
-					]
-				]]
-			],
-			"-",
-			"radius"
-		]]]]
-	},
-	externals: { "std.sqrt": () => sqrt }
-}) && $.f)({}));
-const polygonSdf = typegpu_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: 2,
-	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,
-					"std.sqrt",
-					[[
-						1,
-						[
-							1,
-							"dx",
-							"*",
-							"dx"
-						],
-						"+",
-						[
-							1,
-							"dy",
-							"*",
-							"dy"
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"angle",
-				[
-					6,
-					"std.atan2",
-					["dy", "dx"]
-				]
-			],
-			[
-				13,
-				"sectorAngle",
-				[
-					1,
-					"TWO_PI",
-					"/",
-					"sides"
-				]
-			],
-			[
-				13,
-				"sectorIdx",
-				[
-					6,
-					"std.floor",
-					[[
-						1,
-						[
-							1,
-							"angle",
-							"/",
-							"sectorAngle"
-						],
-						"+",
-						[5, "0.5"]
-					]]
-				]
-			],
-			[
-				13,
-				"canonicalAngle",
-				[
-					1,
-					"angle",
-					"-",
-					[
-						1,
-						"sectorIdx",
-						"*",
-						"sectorAngle"
-					]
-				]
-			],
-			[10, [
-				1,
-				[
-					1,
-					"len",
-					"*",
-					[
-						6,
-						"std.cos",
-						["canonicalAngle"]
-					]
-				],
-				"-",
-				"radius"
-			]]
-		]]
-	},
-	externals: {
-		"std.sqrt": () => sqrt,
-		"std.atan2": () => atan2,
-		"TWO_PI": () => TWO_PI,
-		"std.floor": () => floor,
-		"std.cos": () => cos
-	}
-}) && $.f)({}));
-const flowerSdf = typegpu_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: 2,
-	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,
-					"std.atan2",
-					["dy", "dx"]
-				]
-			],
-			[
-				13,
-				"len",
-				[
-					6,
-					"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,
-						"std.floor",
-						["tAngle"]
-					]
-				]
-			],
-			[
-				13,
-				"t",
-				[
-					6,
-					"std.abs",
-					[[
-						1,
-						[
-							1,
-							"tFrac",
-							"*",
-							[5, "2"]
-						],
-						"-",
-						[5, "1"]
-					]]
-				]
-			],
-			[
-				13,
-				"boundaryR",
-				[
-					1,
-					"innerRadius",
-					"+",
-					[
-						1,
-						[
-							1,
-							"outerRadius",
-							"-",
-							"innerRadius"
-						],
-						"*",
-						"t"
-					]
-				]
-			],
-			[10, [
-				1,
-				"len",
-				"-",
-				"boundaryR"
-			]]
-		]]
-	},
-	externals: {
-		"std.atan2": () => atan2,
-		"std.sqrt": () => sqrt,
-		"TWO_PI": () => TWO_PI,
-		"std.floor": () => floor,
-		"std.abs": () => abs
-	}
-}) && $.f)({}));
-const starSdf = typegpu_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: 2,
-	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,
-					"std.sqrt",
-					[[
-						1,
-						[
-							1,
-							"dx",
-							"*",
-							"dx"
-						],
-						"+",
-						[
-							1,
-							"dy",
-							"*",
-							"dy"
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"angle",
-				[
-					6,
-					"std.atan2",
-					["dy", "dx"]
-				]
-			],
-			[
-				13,
-				"sectorAngle",
-				[
-					1,
-					"TWO_PI",
-					"/",
-					"sides"
-				]
-			],
-			[
-				13,
-				"sectorIdx",
-				[
-					6,
-					"std.floor",
-					[[
-						1,
-						[
-							1,
-							"angle",
-							"/",
-							"sectorAngle"
-						],
-						"+",
-						[5, "0.5"]
-					]]
-				]
-			],
-			[
-				13,
-				"bn",
-				[
-					1,
-					"angle",
-					"-",
-					[
-						1,
-						"sectorIdx",
-						"*",
-						"sectorAngle"
-					]
-				]
-			],
-			[
-				13,
-				"fpx",
-				[
-					6,
-					"std.abs",
-					[[
-						1,
-						"len",
-						"*",
-						[
-							6,
-							"std.sin",
-							["bn"]
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"fpy",
-				[
-					1,
-					"len",
-					"*",
-					[
-						6,
-						"std.cos",
-						["bn"]
-					]
-				]
-			],
-			[
-				13,
-				"an",
-				[
-					1,
-					"PI",
-					"/",
-					"sides"
-				]
-			],
-			[
-				13,
-				"sinAn",
-				[
-					6,
-					"std.sin",
-					["an"]
-				]
-			],
-			[
-				13,
-				"cosAn",
-				[
-					6,
-					"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,
-					"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,
-					"std.sqrt",
-					[[
-						1,
-						[
-							1,
-							"nx",
-							"*",
-							"nx"
-						],
-						"+",
-						[
-							1,
-							"ny",
-							"*",
-							"ny"
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"cross",
-				[
-					1,
-					[
-						1,
-						"ex",
-						"*",
-						"qy"
-					],
-					"-",
-					[
-						1,
-						"ey",
-						"*",
-						"qx"
-					]
-				]
-			],
-			[10, [
-				1,
-				"dist",
-				"*",
-				[
-					6,
-					"std.sign",
-					["cross"]
-				]
-			]]
-		]]
-	},
-	externals: {
-		"std.sqrt": () => sqrt,
-		"std.atan2": () => atan2,
-		"TWO_PI": () => TWO_PI,
-		"std.floor": () => floor,
-		"std.abs": () => abs,
-		"std.sin": () => sin,
-		"std.cos": () => cos,
-		"PI": () => PI,
-		"std.clamp": () => clamp,
-		"std.sign": () => sign
-	}
-}) && $.f)({}));
-const ringSdf = typegpu_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: 2,
-	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,
-				"std.sqrt",
-				[[
-					1,
-					[
-						1,
-						"dx",
-						"*",
-						"dx"
-					],
-					"+",
-					[
-						1,
-						"dy",
-						"*",
-						"dy"
-					]
-				]]
-			]
-		], [10, [
-			1,
-			[
-				6,
-				"std.abs",
-				[[
-					1,
-					"len",
-					"-",
-					"radius"
-				]]
-			],
-			"-",
-			"thickness"
-		]]]]
-	},
-	externals: {
-		"std.sqrt": () => sqrt,
-		"std.abs": () => abs
-	}
-}) && $.f)({}));
-const crossSdf = typegpu_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: 2,
-	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,
-					"std.abs",
-					["dx"]
-				]
-			],
-			[
-				13,
-				"py",
-				[
-					6,
-					"std.abs",
-					["dy"]
-				]
-			],
-			[
-				13,
-				"dHoriz",
-				[
-					6,
-					"std.max",
-					[[
-						1,
-						"px",
-						"-",
-						"size"
-					], [
-						1,
-						"py",
-						"-",
-						"thickness"
-					]]
-				]
-			],
-			[
-				13,
-				"dVert",
-				[
-					6,
-					"std.max",
-					[[
-						1,
-						"py",
-						"-",
-						"size"
-					], [
-						1,
-						"px",
-						"-",
-						"thickness"
-					]]
-				]
-			],
-			[10, [
-				1,
-				[
-					6,
-					"std.min",
-					["dHoriz", "dVert"]
-				],
-				"-",
-				"rounding"
-			]]
-		]]
-	},
-	externals: {
-		"std.abs": () => abs,
-		"std.max": () => max,
-		"std.min": () => min
-	}
-}) && $.f)({}));
-const roundedRectSdf = typegpu_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: 2,
-	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,
-							"std.abs",
-							["dx"]
-						],
-						"-",
-						"width"
-					],
-					"+",
-					"rounding"
-				]
-			],
-			[
-				13,
-				"qy",
-				[
-					1,
-					[
-						1,
-						[
-							6,
-							"std.abs",
-							["dy"]
-						],
-						"-",
-						"height"
-					],
-					"+",
-					"rounding"
-				]
-			],
-			[
-				13,
-				"mqx",
-				[
-					6,
-					"std.max",
-					["qx", [5, "0"]]
-				]
-			],
-			[
-				13,
-				"mqy",
-				[
-					6,
-					"std.max",
-					["qy", [5, "0"]]
-				]
-			],
-			[
-				13,
-				"outerDist",
-				[
-					6,
-					"std.sqrt",
-					[[
-						1,
-						[
-							1,
-							"mqx",
-							"*",
-							"mqx"
-						],
-						"+",
-						[
-							1,
-							"mqy",
-							"*",
-							"mqy"
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"innerDist",
-				[
-					6,
-					"std.min",
-					[[
-						6,
-						"std.max",
-						["qx", "qy"]
-					], [5, "0"]]
-				]
-			],
-			[10, [
-				1,
-				[
-					1,
-					"outerDist",
-					"+",
-					"innerDist"
-				],
-				"-",
-				"rounding"
-			]]
-		]]
-	},
-	externals: {
-		"std.abs": () => abs,
-		"std.max": () => max,
-		"std.sqrt": () => sqrt,
-		"std.min": () => min
-	}
-}) && $.f)({}));
-const ellipseSdf = typegpu_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: 2,
-	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,
-					"std.sqrt",
-					[[
-						1,
-						[
-							1,
-							"nx",
-							"*",
-							"nx"
-						],
-						"+",
-						[
-							1,
-							"ny",
-							"*",
-							"ny"
-						]
-					]]
-				]
-			],
-			[10, [
-				1,
-				[
-					1,
-					"k",
-					"-",
-					[5, "1"]
-				],
-				"*",
-				[
-					6,
-					"std.min",
-					["radiusX", "radiusY"]
-				]
-			]]
-		]]
-	},
-	externals: {
-		"std.sqrt": () => sqrt,
-		"std.min": () => min
-	}
-}) && $.f)({}));
-const vesicaSdf = typegpu_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: 2,
-	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,
-					"std.abs",
-					["dx"]
-				]
-			],
-			[
-				13,
-				"py",
-				[
-					6,
-					"std.abs",
-					["dy"]
-				]
-			],
-			[
-				13,
-				"dd",
-				[
-					1,
-					"radius",
-					"*",
-					"spread"
-				]
-			],
-			[
-				13,
-				"b",
-				[
-					6,
-					"std.sqrt",
-					[[
-						6,
-						"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,
-					"std.sqrt",
-					[[
-						1,
-						[
-							1,
-							"px",
-							"*",
-							"px"
-						],
-						"+",
-						[
-							1,
-							[
-								1,
-								"py",
-								"-",
-								"b"
-							],
-							"*",
-							[
-								1,
-								"py",
-								"-",
-								"b"
-							]
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"dist2",
-				[
-					1,
-					[
-						6,
-						"std.sqrt",
-						[[
-							1,
-							[
-								1,
-								[
-									1,
-									"px",
-									"+",
-									"dd"
-								],
-								"*",
-								[
-									1,
-									"px",
-									"+",
-									"dd"
-								]
-							],
-							"+",
-							[
-								1,
-								"py",
-								"*",
-								"py"
-							]
-						]]
-					],
-					"-",
-					"radius"
-				]
-			],
-			[10, [
-				6,
-				"std.select",
-				[
-					"dist2",
-					"dist1",
-					"cond"
-				]
-			]]
-		]]
-	},
-	externals: {
-		"std.abs": () => abs,
-		"std.sqrt": () => sqrt,
-		"std.max": () => max,
-		"std.select": () => select
-	}
-}) && $.f)({}));
-const crescentSdf = typegpu_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: 2,
-	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,
-					"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,
-						"std.max",
-						[[
-							1,
-							"off",
-							"*",
-							[5, "2"]
-						], [5, "0.001"]]
-					]
-				]
-			],
-			[
-				13,
-				"bSq",
-				[
-					6,
-					"std.max",
-					[[
-						1,
-						[
-							1,
-							"ra",
-							"*",
-							"ra"
-						],
-						"-",
-						[
-							1,
-							"a",
-							"*",
-							"a"
-						]
-					], [5, "0"]]
-				]
-			],
-			[
-				13,
-				"b",
-				[
-					6,
-					"std.sqrt",
-					["bSq"]
-				]
-			],
-			[
-				13,
-				"lhs",
-				[
-					1,
-					"off",
-					"*",
-					[
-						1,
-						[
-							1,
-							"dx",
-							"*",
-							"b"
-						],
-						"-",
-						[
-							1,
-							"py",
-							"*",
-							"a"
-						]
-					]
-				]
-			],
-			[
-				13,
-				"rhs",
-				[
-					1,
-					[
-						1,
-						"off",
-						"*",
-						"off"
-					],
-					"*",
-					[
-						6,
-						"std.max",
-						[[
-							1,
-							"b",
-							"-",
-							"py"
-						], [5, "0"]]
-					]
-				]
-			],
-			[
-				13,
-				"d1x",
-				[
-					1,
-					"dx",
-					"-",
-					"a"
-				]
-			],
-			[
-				13,
-				"d1y",
-				[
-					1,
-					"py",
-					"-",
-					"b"
-				]
-			],
-			[
-				13,
-				"dist1",
-				[
-					6,
-					"std.sqrt",
-					[[
-						1,
-						[
-							1,
-							"d1x",
-							"*",
-							"d1x"
-						],
-						"+",
-						[
-							1,
-							"d1y",
-							"*",
-							"d1y"
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"lenP",
-				[
-					6,
-					"std.sqrt",
-					[[
-						1,
-						[
-							1,
-							"dx",
-							"*",
-							"dx"
-						],
-						"+",
-						[
-							1,
-							"py",
-							"*",
-							"py"
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"innerX",
-				[
-					1,
-					"dx",
-					"-",
-					"off"
-				]
-			],
-			[
-				13,
-				"lenInner",
-				[
-					6,
-					"std.sqrt",
-					[[
-						1,
-						[
-							1,
-							"innerX",
-							"*",
-							"innerX"
-						],
-						"+",
-						[
-							1,
-							"py",
-							"*",
-							"py"
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"dist2",
-				[
-					6,
-					"std.max",
-					[[
-						1,
-						"lenP",
-						"-",
-						"ra"
-					], [
-						1,
-						[
-							1,
-							"lenInner",
-							"-",
-							"rb"
-						],
-						"*",
-						[
-							4,
-							"-",
-							[5, "1"]
-						]
-					]]
-				]
-			],
-			[10, [
-				6,
-				"std.select",
-				[
-					"dist2",
-					"dist1",
-					[
-						1,
-						"lhs",
-						">",
-						"rhs"
-					]
-				]
-			]]
-		]]
-	},
-	externals: {
-		"std.abs": () => abs,
-		"std.max": () => max,
-		"std.sqrt": () => sqrt,
-		"std.select": () => select
-	}
-}) && $.f)({}));
-const trapezoidSdf = typegpu_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: 2,
-	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,
-					"std.abs",
-					["dx"]
-				]
-			],
-			[
-				13,
-				"k1x",
-				"r2"
-			],
-			[
-				13,
-				"k1y",
-				"he"
-			],
-			[
-				13,
-				"k2x",
-				[
-					1,
-					"r2",
-					"-",
-					"r1"
-				]
-			],
-			[
-				13,
-				"k2y",
-				[
-					1,
-					"he",
-					"*",
-					[5, "2"]
-				]
-			],
-			[
-				13,
-				"clampWidth",
-				[
-					6,
-					"std.select",
-					[
-						"r2",
-						"r1",
-						[
-							1,
-							"dy",
-							"<",
-							[5, "0"]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"cax",
-				[
-					1,
-					"px",
-					"-",
-					[
-						6,
-						"std.min",
-						["px", "clampWidth"]
-					]
-				]
-			],
-			[
-				13,
-				"cay",
-				[
-					1,
-					[
-						6,
-						"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,
-					"std.max",
-					[[
-						1,
-						[
-							1,
-							"k2x",
-							"*",
-							"k2x"
-						],
-						"+",
-						[
-							1,
-							"k2y",
-							"*",
-							"k2y"
-						]
-					], [5, "0.0001"]]
-				]
-			],
-			[
-				13,
-				"t",
-				[
-					6,
-					"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,
-					"std.select",
-					[
-						[
-							6,
-							"d.f32",
-							[[5, "1"]]
-						],
-						[
-							6,
-							"d.f32",
-							[[
-								4,
-								"-",
-								[5, "1"]
-							]]
-						],
-						[
-							1,
-							"cay",
-							"<",
-							[5, "0"]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"s",
-				[
-					6,
-					"std.select",
-					[
-						[
-							6,
-							"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,
-					"std.sqrt",
-					[[
-						6,
-						"std.min",
-						["dca", "dcb"]
-					]]
-				]
-			]]
-		]]
-	},
-	externals: {
-		"std.abs": () => abs,
-		"std.select": () => select,
-		"std.min": () => min,
-		"std.max": () => max,
-		"std.clamp": () => clamp,
-		"d.f32": () => f32,
-		"std.sqrt": () => sqrt
-	}
-}) && $.f)({}));
-const heartSdf = typegpu_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: 2,
-	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,
-						"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,
-						"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,
-						"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,
-						"std.sqrt",
-						[[
-							6,
-							"std.min",
-							["dot1", "dot2v"]
-						]]
-					],
-					"*",
-					[
-						6,
-						"std.sign",
-						[[
-							1,
-							"px",
-							"-",
-							"py"
-						]]
-					]
-				]
-			],
-			[10, [
-				1,
-				[
-					6,
-					"std.select",
-					[
-						"distB",
-						"distA",
-						[
-							1,
-							[
-								1,
-								"px",
-								"+",
-								"py"
-							],
-							">",
-							[5, "1"]
-						]
-					]
-				],
-				"*",
-				"S"
-			]]
-		]]
-	},
-	externals: {
-		"std.abs": () => abs,
-		"std.sqrt": () => sqrt,
-		"SQRT2_OVER_4": () => SQRT2_OVER_4,
-		"std.max": () => max,
-		"std.min": () => min,
-		"std.sign": () => sign,
-		"std.select": () => select
-	}
-}) && $.f)({}));
-const arcSdf = typegpu_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: 2,
-	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,
-					"std.abs",
-					["dx"]
-				]
-			],
-			[
-				13,
-				"cx",
-				[
-					6,
-					"std.sin",
-					["halfAngle"]
-				]
-			],
-			[
-				13,
-				"cy",
-				[
-					6,
-					"std.cos",
-					["halfAngle"]
-				]
-			],
-			[
-				13,
-				"l",
-				[
-					1,
-					[
-						6,
-						"std.sqrt",
-						[[
-							1,
-							[
-								1,
-								"px",
-								"*",
-								"px"
-							],
-							"+",
-							[
-								1,
-								"dy",
-								"*",
-								"dy"
-							]
-						]]
-					],
-					"-",
-					"radius"
-				]
-			],
-			[
-				13,
-				"clamped",
-				[
-					6,
-					"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,
-					"std.sqrt",
-					[[
-						1,
-						[
-							1,
-							"mx",
-							"*",
-							"mx"
-						],
-						"+",
-						[
-							1,
-							"my",
-							"*",
-							"my"
-						]
-					]]
-				]
-			],
-			[10, [
-				6,
-				"std.max",
-				["l", [
-					1,
-					"m",
-					"*",
-					[
-						6,
-						"std.sign",
-						[[
-							1,
-							[
-								1,
-								"cy",
-								"*",
-								"px"
-							],
-							"-",
-							[
-								1,
-								"cx",
-								"*",
-								"dy"
-							]
-						]]
-					]
-				]]
-			]]
-		]]
-	},
-	externals: {
-		"std.abs": () => abs,
-		"std.sin": () => sin,
-		"std.cos": () => cos,
-		"std.sqrt": () => sqrt,
-		"std.clamp": () => clamp,
-		"std.max": () => max,
-		"std.sign": () => sign
-	}
-}) && $.f)({}));
-const teardropSdf = typegpu_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: 2,
-	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,
-					"std.abs",
-					["dx"]
-				]
-			],
-			[
-				13,
-				"qy",
-				[
-					1,
-					[
-						1,
-						"dy",
-						"*",
-						[
-							4,
-							"-",
-							[5, "1"]
-						]
-					],
-					"+",
-					"mid"
-				]
-			],
-			[
-				13,
-				"hSafe",
-				[
-					6,
-					"std.max",
-					["h", [5, "0.0001"]]
-				]
-			],
-			[
-				13,
-				"b",
-				[
-					1,
-					"radius",
-					"/",
-					"hSafe"
-				]
-			],
-			[
-				13,
-				"a",
-				[
-					6,
-					"std.sqrt",
-					[[
-						6,
-						"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,
-						"std.sqrt",
-						[[
-							1,
-							[
-								1,
-								"qx",
-								"*",
-								"qx"
-							],
-							"+",
-							[
-								1,
-								"qy",
-								"*",
-								"qy"
-							]
-						]]
-					],
-					"-",
-					"radius"
-				]
-			],
-			[
-				13,
-				"qyTip",
-				[
-					1,
-					"qy",
-					"-",
-					"h"
-				]
-			],
-			[
-				13,
-				"cap1",
-				[
-					6,
-					"std.sqrt",
-					[[
-						1,
-						[
-							1,
-							"qx",
-							"*",
-							"qx"
-						],
-						"+",
-						[
-							1,
-							"qyTip",
-							"*",
-							"qyTip"
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"body",
-				[
-					1,
-					[
-						1,
-						[
-							1,
-							"qx",
-							"*",
-							"a"
-						],
-						"+",
-						[
-							1,
-							"qy",
-							"*",
-							"b"
-						]
-					],
-					"-",
-					"radius"
-				]
-			],
-			[10, [
-				6,
-				"std.select",
-				[
-					[
-						6,
-						"std.select",
-						[
-							"body",
-							"cap1",
-							[
-								1,
-								"k",
-								">",
-								[
-									1,
-									"a",
-									"*",
-									"h"
-								]
-							]
-						]
-					],
-					"cap0",
-					[
-						1,
-						"k",
-						"<",
-						[5, "0"]
-					]
-				]
-			]]
-		]]
-	},
-	externals: {
-		"std.abs": () => abs,
-		"std.max": () => max,
-		"std.sqrt": () => sqrt,
-		"std.select": () => select
-	}
-}) && $.f)({}));
-const parallelogramSdf = typegpu_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: 2,
-	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,
-					"std.select",
-					[
-						"dx",
-						[
-							1,
-							"dx",
-							"*",
-							[
-								4,
-								"-",
-								[5, "1"]
-							]
-						],
-						"flip1"
-					]
-				]
-			],
-			[
-				13,
-				"py0",
-				[
-					6,
-					"std.select",
-					[
-						"dy",
-						[
-							1,
-							"dy",
-							"*",
-							[
-								4,
-								"-",
-								[5, "1"]
-							]
-						],
-						"flip1"
-					]
-				]
-			],
-			[
-				13,
-				"wx0",
-				[
-					1,
-					"px0",
-					"-",
-					"ex"
-				]
-			],
-			[
-				13,
-				"wy",
-				[
-					1,
-					"py0",
-					"-",
-					"ey"
-				]
-			],
-			[
-				13,
-				"wx",
-				[
-					1,
-					"wx0",
-					"-",
-					[
-						6,
-						"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,
-					"std.select",
-					[
-						"px0",
-						[
-							1,
-							"px0",
-							"*",
-							[
-								4,
-								"-",
-								[5, "1"]
-							]
-						],
-						"flip2"
-					]
-				]
-			],
-			[
-				13,
-				"py",
-				[
-					6,
-					"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,
-					"std.max",
-					[[
-						1,
-						[
-							1,
-							"ex",
-							"*",
-							"ex"
-						],
-						"+",
-						[
-							1,
-							"ey",
-							"*",
-							"ey"
-						]
-					], [5, "0.0001"]]
-				]
-			],
-			[
-				13,
-				"tt",
-				[
-					6,
-					"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,
-					"std.min",
-					["dX", [
-						1,
-						[
-							1,
-							"vx",
-							"*",
-							"vx"
-						],
-						"+",
-						[
-							1,
-							"vy",
-							"*",
-							"vy"
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"finalY",
-				[
-					6,
-					"std.min",
-					["dY", [
-						1,
-						[
-							1,
-							"wi",
-							"*",
-							"he"
-						],
-						"-",
-						[
-							6,
-							"std.abs",
-							["s"]
-						]
-					]]
-				]
-			],
-			[10, [
-				1,
-				[
-					6,
-					"std.sqrt",
-					["finalX"]
-				],
-				"*",
-				[
-					6,
-					"std.sign",
-					[[
-						1,
-						"finalY",
-						"*",
-						[
-							4,
-							"-",
-							[5, "1"]
-						]
-					]]
-				]
-			]]
-		]]
-	},
-	externals: {
-		"std.select": () => select,
-		"std.clamp": () => clamp,
-		"std.max": () => max,
-		"std.min": () => min,
-		"std.abs": () => abs,
-		"std.sqrt": () => sqrt,
-		"std.sign": () => sign
-	}
-}) && $.f)({}));
-const shapeLocalCoords = typegpu_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: 2,
-	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,
-					"d.vec2f",
-					[[
-						1,
-						[
-							7,
-							"uv",
-							"x"
-						],
-						"*",
-						"aspect"
-					], [
-						7,
-						"uv",
-						"y"
-					]]
-				]
-			],
-			[
-				13,
-				"centerPos",
-				[
-					6,
-					"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,
-					"std.cos",
-					["rotRad"]
-				]
-			],
-			[
-				13,
-				"sinR",
-				[
-					6,
-					"std.sin",
-					["rotRad"]
-				]
-			],
-			[
-				13,
-				"rdx",
-				[
-					1,
-					[
-						1,
-						"dx",
-						"*",
-						"cosR"
-					],
-					"+",
-					[
-						1,
-						"dy",
-						"*",
-						"sinR"
-					]
-				]
-			],
-			[
-				13,
-				"rdy",
-				[
-					1,
-					[
-						1,
-						"dy",
-						"*",
-						"cosR"
-					],
-					"-",
-					[
-						1,
-						"dx",
-						"*",
-						"sinR"
-					]
-				]
-			],
-			[10, [
-				6,
-				"d.vec2f",
-				["rdx", "rdy"]
-			]]
-		]]
-	},
-	externals: {
-		"d.vec2f": () => vec2f,
-		"DEG_TO_RAD": () => DEG_TO_RAD,
-		"std.cos": () => cos,
-		"std.sin": () => sin
-	}
-}) && $.f)({}));
-const ShapeMask = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
-	overallMask: f32,
-	strokeBlend: f32
-}), "ShapeMask");
-const strokeMaskFromSdf = typegpu_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: 2,
-	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,
-					"std.select",
-					[
-						[
-							6,
-							"std.select",
-							[
-								[
-									6,
-									"d.f32",
-									[[5, "0"]]
-								],
-								"negHalf",
-								"isCenterOrAbove"
-							]
-						],
-						"negThickness",
-						"isInside"
-					]
-				]
-			],
-			[
-				13,
-				"strokeOuter",
-				[
-					6,
-					"std.select",
-					[
-						[
-							6,
-							"std.select",
-							[
-								"strokeThickness",
-								"halfThickness",
-								"isCenterOrAbove"
-							]
-						],
-						[
-							6,
-							"d.f32",
-							[[5, "0"]]
-						],
-						"isInside"
-					]
-				]
-			],
-			[
-				13,
-				"overallMask",
-				[
-					1,
-					[5, "1"],
-					"-",
-					[
-						6,
-						"std.smoothstep",
-						[
-							[
-								1,
-								"strokeOuter",
-								"-",
-								"softness"
-							],
-							"strokeOuter",
-							"dist"
-						]
-					]
-				]
-			],
-			[
-				13,
-				"blend",
-				[
-					6,
-					"std.smoothstep",
-					[
-						[
-							1,
-							"strokeInner",
-							"-",
-							"softness"
-						],
-						"strokeInner",
-						"dist"
-					]
-				]
-			],
-			[
-				13,
-				"strokeBlend",
-				[
-					6,
-					"std.select",
-					[
-						[
-							6,
-							"d.f32",
-							[[5, "0"]]
-						],
-						"blend",
-						"hasStroke"
-					]
-				]
-			],
-			[10, [
-				6,
-				"ShapeMask",
-				[[104, {
-					"overallMask": "overallMask",
-					"strokeBlend": "strokeBlend"
-				}]]
-			]]
-		]]
-	},
-	externals: {
-		"std.select": () => select,
-		"d.f32": () => f32,
-		"std.smoothstep": () => smoothstep,
-		"ShapeMask": () => ShapeMask
-	}
-}) && $.f)({}));
-function fillStrokeColor(mask, fill, stroke, colorSpaceMode) {
-	const blended = call(mixColorsVariants[colorSpaceMode] ?? mixColorsLinear, "mixColors", [
-		fill,
-		stroke,
-		mask.member("strokeBlend")
-	]);
-	return vec4(blended.member("rgb"), blended.member("a").mul(mask.member("overallMask")));
-}
-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);
-}
-const APERTURE_TO_HALFANGLE = .008726646259971648;
-function buildAnalyticSdfFn(shapeType) {
-	return typegpu_default.fn([
-		vec2f,
-		f32,
-		f32,
-		f32,
-		f32,
-		f32,
-		f32,
-		f32,
-		f32
-	], vec4f$1)(/* @__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, .008726646259971648));
-		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$1(dist, 0, 0, 1);
-	}), {
-		v: 2,
-		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,
-						"std.cos",
-						["rotRad"]
-					]
-				],
-				[
-					13,
-					"sinR",
-					[
-						6,
-						"std.sin",
-						["rotRad"]
-					]
-				],
-				[
-					13,
-					"rdx",
-					[
-						1,
-						[
-							1,
-							"dx",
-							"*",
-							"cosR"
-						],
-						"+",
-						[
-							1,
-							"dy",
-							"*",
-							"sinR"
-						]
-					]
-				],
-				[
-					13,
-					"rdy",
-					[
-						1,
-						[
-							1,
-							"dy",
-							"*",
-							"cosR"
-						],
-						"-",
-						[
-							1,
-							"dx",
-							"*",
-							"sinR"
-						]
-					]
-				],
-				[
-					12,
-					"dist",
-					[
-						6,
-						"d.f32",
-						[[5, "0"]]
-					]
-				],
-				[
-					11,
-					[
-						1,
-						"shapeType",
-						"===",
-						[103, "polygonSDF"]
-					],
-					[
-						2,
-						"dist",
-						"=",
-						[
-							6,
-							"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,
-					"d.vec4f",
-					[
-						"dist",
-						[5, "0"],
-						[5, "0"],
-						[5, "1"]
-					]
-				]]
-			]]
-		},
-		externals: {
-			"DEG_TO_RAD": () => DEG_TO_RAD,
-			"std.cos": () => cos,
-			"std.sin": () => sin,
-			"d.f32": () => f32,
-			"shapeType": () => shapeType,
-			"std.mix": () => mix,
-			"polygonSdf": () => polygonSdf,
-			"circleSdf": () => circleSdf,
-			"flowerSdf": () => flowerSdf,
-			"ringSdf": () => ringSdf,
-			"crossSdf": () => crossSdf,
-			"starSdf": () => starSdf,
-			"roundedRectSdf": () => roundedRectSdf,
-			"ellipseSdf": () => ellipseSdf,
-			"vesicaSdf": () => vesicaSdf,
-			"crescentSdf": () => crescentSdf,
-			"trapezoidSdf": () => trapezoidSdf,
-			"heartSdf": () => heartSdf,
-			"arcSdf": () => arcSdf,
-			"APERTURE_TO_HALFANGLE": () => .008726646259971648,
-			"teardropSdf": () => teardropSdf,
-			"parallelogramSdf": () => parallelogramSdf,
-			"d.vec4f": () => vec4f$1
-		}
-	}) && $.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
-	};
-}
-function isMobileGpuViewport() {
-	if (typeof window === "undefined") return false;
-	const coarse = !!(window.matchMedia && window.matchMedia("(pointer: coarse)").matches);
-	const cssLong = Math.max(window.innerWidth || 0, window.innerHeight || 0);
-	return coarse && cssLong > 0 && cssLong <= 1366;
-}
-function maxPixelRatioForDevice() {
-	return isMobileGpuViewport() ? 1.5 : 2;
-}
-export { toHalfFloat as A, sdf_exports as C, teardropSdf as D, strokeMaskFromSdf as E, textureDimensions as F, textureLoad as I, textureSampleLevel as L, createGuardedCompute as M, createPingPongPair as N, trapezoidSdf as O, createStateBuffer as P, textureStore as R, roundedRectSdf as S, starSdf as T, flowerSdf as _, ShapeMask as a, polygonSdf as b, createAnalyticSdfSampler as c, createSvgSdfSamplerWithGradients as d, crescentSdf as f, fillStrokeColor as g, ellipseSdf as h, SVG_SDF_SIZE as i, createComputeDispatcher as j, vesicaSdf as k, createSdfDataTexture as l, driveAnalyticSubProps as m, maxPixelRatioForDevice as n, arcSdf as o, crossSdf as p, APERTURE_TO_HALFANGLE as r, circleSdf as s, isMobileGpuViewport as t, createSvgSdfSampler as u, heartSdf as v, shapeLocalCoords as w, ringSdf as x, parallelogramSdf as y };