shaders 3.0.453 → 3.1.455

package/dist/core/cellular-qYnxKdPx.js

@@ -0,0 +1,1593 @@
+import { At as max, Bt as sin, Dt as floor, Gt as data_exports, Ht as sqrt, Mt as mix, Ot as fract, Pt as pow, St as cos, Vt as smoothstep, _t as abs, at as std_exports, gt as select, jt as min, kt as length, pn as __export, rn as vec2f, rt as src_default, un as f32, wt as dot, xt as clamp } from "./edges-CD7gCAto.js";
+import { o as TAU } from "./constants-DoOzbl5b.js";
+var cellular_exports = /* @__PURE__ */ __export({
+	CELL_METRICS: () => CELL_METRICS,
+	CELL_MODES: () => CELL_MODES,
+	cellEdgeMask: () => cellEdgeMask,
+	cellHash2: () => cellHash2,
+	cellRatio: () => cellRatio,
+	cellReduceSelectable: () => cellReduceSelectable,
+	nearest2Cells: () => nearest2Cells
+});
+const cellHash2 = src_default.fn([vec2f], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p) => {
+	"use gpu";
+	return fract(sin(vec2f(dot(p, vec2f(127.1, 311.7)), dot(p, vec2f(269.5, 183.3)))).mul(43758.5453));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "p"
+		}],
+		"body": [0, [[
+			13,
+			"h",
+			[
+				6,
+				[
+					7,
+					"d",
+					"vec2f"
+				],
+				[[
+					6,
+					[
+						7,
+						"std",
+						"dot"
+					],
+					["p", [
+						6,
+						[
+							7,
+							"d",
+							"vec2f"
+						],
+						[[5, "127.1"], [5, "311.7"]]
+					]]
+				], [
+					6,
+					[
+						7,
+						"std",
+						"dot"
+					],
+					["p", [
+						6,
+						[
+							7,
+							"d",
+							"vec2f"
+						],
+						[[5, "269.5"], [5, "183.3"]]
+					]]
+				]]
+			]
+		], [10, [
+			6,
+			[
+				7,
+				"std",
+				"fract"
+			],
+			[[
+				6,
+				[
+					7,
+					[
+						6,
+						[
+							7,
+							"std",
+							"sin"
+						],
+						["h"]
+					],
+					"mul"
+				],
+				[[5, "43758.5453"]]
+			]]
+		]]]],
+		"externalNames": ["d", "std"]
+	},
+	externals: () => ({
+		d: data_exports,
+		std: std_exports
+	})
+}) && $.f)({}));
+function nearest2Cells(options) {
+	const { distance, jitter, name = "nearest2Cells" } = options;
+	const key = `${name}|${distance}|${jitter}`;
+	const cached = nearest2Cache.get(key);
+	if (cached) return cached;
+	const suffix = `${distance === "length" ? "Len" : "Sel"}${jitter === "mix" ? "Jit" : ""}`;
+	let built;
+	if (distance === "length" && jitter === "none") built = src_default.fn([
+		vec2f,
+		f32,
+		f32
+	], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((scaledUV, animT, seed) => {
+		"use gpu";
+		const cell = floor(scaledUV);
+		const localUV = fract(scaledUV);
+		let d1 = f32(10);
+		let d2 = f32(10);
+		for (let ny = -1; ny <= 1; ny++) for (let nx = -1; nx <= 1; nx++) {
+			const offset = vec2f(f32(nx), f32(ny));
+			const h = cellHash2(vec2f(__tsover_add(__tsover_add(cell.x, offset.x), seed), __tsover_add(__tsover_add(cell.y, offset.y), seed)));
+			const pointX = clamp(__tsover_add(h.x, __tsover_mul(sin(__tsover_add(animT, __tsover_mul(h.x, TAU))), .15)), .05, .95);
+			const pointY = clamp(__tsover_add(h.y, __tsover_mul(cos(__tsover_add(__tsover_mul(animT, .7), __tsover_mul(h.y, TAU))), .15)), .05, .95);
+			const dd = length(vec2f(__tsover_sub(localUV.x, __tsover_add(offset.x, pointX)), __tsover_sub(localUV.y, __tsover_add(offset.y, pointY))));
+			d2 = min(d2, max(dd, d1));
+			d1 = min(d1, dd);
+		}
+		return vec2f(d1, d2);
+	}), {
+		v: 1,
+		name: void 0,
+		ast: {
+			"params": [
+				{
+					"type": "i",
+					"name": "scaledUV"
+				},
+				{
+					"type": "i",
+					"name": "animT"
+				},
+				{
+					"type": "i",
+					"name": "seed"
+				}
+			],
+			"body": [0, [
+				[
+					13,
+					"cell",
+					[
+						6,
+						[
+							7,
+							"std",
+							"floor"
+						],
+						["scaledUV"]
+					]
+				],
+				[
+					13,
+					"localUV",
+					[
+						6,
+						[
+							7,
+							"std",
+							"fract"
+						],
+						["scaledUV"]
+					]
+				],
+				[
+					12,
+					"d1",
+					[
+						6,
+						[
+							7,
+							"d",
+							"f32"
+						],
+						[[5, "10"]]
+					]
+				],
+				[
+					12,
+					"d2",
+					[
+						6,
+						[
+							7,
+							"d",
+							"f32"
+						],
+						[[5, "10"]]
+					]
+				],
+				[
+					14,
+					[
+						12,
+						"ny",
+						[
+							4,
+							"-",
+							[5, "1"]
+						]
+					],
+					[
+						1,
+						"ny",
+						"<=",
+						[5, "1"]
+					],
+					[
+						102,
+						"++",
+						"ny"
+					],
+					[0, [[
+						14,
+						[
+							12,
+							"nx",
+							[
+								4,
+								"-",
+								[5, "1"]
+							]
+						],
+						[
+							1,
+							"nx",
+							"<=",
+							[5, "1"]
+						],
+						[
+							102,
+							"++",
+							"nx"
+						],
+						[0, [
+							[
+								13,
+								"offset",
+								[
+									6,
+									[
+										7,
+										"d",
+										"vec2f"
+									],
+									[[
+										6,
+										[
+											7,
+											"d",
+											"f32"
+										],
+										["nx"]
+									], [
+										6,
+										[
+											7,
+											"d",
+											"f32"
+										],
+										["ny"]
+									]]
+								]
+							],
+							[
+								13,
+								"h",
+								[
+									6,
+									"cellHash2",
+									[[
+										6,
+										[
+											7,
+											"d",
+											"vec2f"
+										],
+										[[
+											1,
+											[
+												1,
+												[
+													7,
+													"cell",
+													"x"
+												],
+												"+",
+												[
+													7,
+													"offset",
+													"x"
+												]
+											],
+											"+",
+											"seed"
+										], [
+											1,
+											[
+												1,
+												[
+													7,
+													"cell",
+													"y"
+												],
+												"+",
+												[
+													7,
+													"offset",
+													"y"
+												]
+											],
+											"+",
+											"seed"
+										]]
+									]]
+								]
+							],
+							[
+								13,
+								"pointX",
+								[
+									6,
+									[
+										7,
+										"std",
+										"clamp"
+									],
+									[
+										[
+											1,
+											[
+												7,
+												"h",
+												"x"
+											],
+											"+",
+											[
+												1,
+												[
+													6,
+													[
+														7,
+														"std",
+														"sin"
+													],
+													[[
+														1,
+														"animT",
+														"+",
+														[
+															1,
+															[
+																7,
+																"h",
+																"x"
+															],
+															"*",
+															"TAU"
+														]
+													]]
+												],
+												"*",
+												[5, "0.15"]
+											]
+										],
+										[5, "0.05"],
+										[5, "0.95"]
+									]
+								]
+							],
+							[
+								13,
+								"pointY",
+								[
+									6,
+									[
+										7,
+										"std",
+										"clamp"
+									],
+									[
+										[
+											1,
+											[
+												7,
+												"h",
+												"y"
+											],
+											"+",
+											[
+												1,
+												[
+													6,
+													[
+														7,
+														"std",
+														"cos"
+													],
+													[[
+														1,
+														[
+															1,
+															"animT",
+															"*",
+															[5, "0.7"]
+														],
+														"+",
+														[
+															1,
+															[
+																7,
+																"h",
+																"y"
+															],
+															"*",
+															"TAU"
+														]
+													]]
+												],
+												"*",
+												[5, "0.15"]
+											]
+										],
+										[5, "0.05"],
+										[5, "0.95"]
+									]
+								]
+							],
+							[
+								13,
+								"dd",
+								[
+									6,
+									[
+										7,
+										"std",
+										"length"
+									],
+									[[
+										6,
+										[
+											7,
+											"d",
+											"vec2f"
+										],
+										[[
+											1,
+											[
+												7,
+												"localUV",
+												"x"
+											],
+											"-",
+											[
+												1,
+												[
+													7,
+													"offset",
+													"x"
+												],
+												"+",
+												"pointX"
+											]
+										], [
+											1,
+											[
+												7,
+												"localUV",
+												"y"
+											],
+											"-",
+											[
+												1,
+												[
+													7,
+													"offset",
+													"y"
+												],
+												"+",
+												"pointY"
+											]
+										]]
+									]]
+								]
+							],
+							[
+								2,
+								"d2",
+								"=",
+								[
+									6,
+									[
+										7,
+										"std",
+										"min"
+									],
+									["d2", [
+										6,
+										[
+											7,
+											"std",
+											"max"
+										],
+										["dd", "d1"]
+									]]
+								]
+							],
+							[
+								2,
+								"d1",
+								"=",
+								[
+									6,
+									[
+										7,
+										"std",
+										"min"
+									],
+									["d1", "dd"]
+								]
+							]
+						]]
+					]]]
+				],
+				[10, [
+					6,
+					[
+						7,
+						"d",
+						"vec2f"
+					],
+					["d1", "d2"]
+				]]
+			]],
+			"externalNames": [
+				"std",
+				"d",
+				"cellHash2",
+				"TAU"
+			]
+		},
+		externals: () => ({
+			std: std_exports,
+			d: data_exports,
+			cellHash2,
+			TAU
+		})
+	}) && $.f)({})).$name(`${name}${suffix}`);
+	else built = src_default.fn([
+		vec2f,
+		f32,
+		f32,
+		f32,
+		f32
+	], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((scaledUV, animT, seed, jitterAmount, metric) => {
+		"use gpu";
+		const animTSlow = __tsover_mul(animT, .7);
+		const cell = floor(scaledUV);
+		const localUV = fract(scaledUV);
+		let d1 = f32(10);
+		let d2 = f32(10);
+		for (let ny = -1; ny <= 1; ny++) for (let nx = -1; nx <= 1; nx++) {
+			const offset = vec2f(f32(nx), f32(ny));
+			const h = cellHash2(vec2f(__tsover_add(__tsover_add(cell.x, offset.x), seed), __tsover_add(__tsover_add(cell.y, offset.y), seed)));
+			const px = __tsover_add(h.x, __tsover_mul(sin(__tsover_add(animT, __tsover_mul(h.x, TAU))), .15));
+			const py = __tsover_add(h.y, __tsover_mul(cos(__tsover_add(animTSlow, __tsover_mul(h.y, TAU))), .15));
+			const jx = mix(.5, clamp(px, .05, .95), jitterAmount);
+			const jy = mix(.5, clamp(py, .05, .95), jitterAmount);
+			const deltaX = __tsover_sub(localUV.x, __tsover_add(offset.x, jx));
+			const deltaY = __tsover_sub(localUV.y, __tsover_add(offset.y, jy));
+			const dEuclid = __tsover_add(__tsover_mul(deltaX, deltaX), __tsover_mul(deltaY, deltaY));
+			const dManhattan = __tsover_add(abs(deltaX), abs(deltaY));
+			const dChebyshev = max(abs(deltaX), abs(deltaY));
+			let dd = dEuclid;
+			dd = select(dd, dManhattan, metric === 1);
+			dd = select(dd, dChebyshev, metric === 2);
+			d2 = min(d2, max(dd, d1));
+			d1 = min(d1, dd);
+		}
+		return vec2f(d1, d2);
+	}), {
+		v: 1,
+		name: void 0,
+		ast: {
+			"params": [
+				{
+					"type": "i",
+					"name": "scaledUV"
+				},
+				{
+					"type": "i",
+					"name": "animT"
+				},
+				{
+					"type": "i",
+					"name": "seed"
+				},
+				{
+					"type": "i",
+					"name": "jitterAmount"
+				},
+				{
+					"type": "i",
+					"name": "metric"
+				}
+			],
+			"body": [0, [
+				[
+					13,
+					"animTSlow",
+					[
+						1,
+						"animT",
+						"*",
+						[5, "0.7"]
+					]
+				],
+				[
+					13,
+					"cell",
+					[
+						6,
+						[
+							7,
+							"std",
+							"floor"
+						],
+						["scaledUV"]
+					]
+				],
+				[
+					13,
+					"localUV",
+					[
+						6,
+						[
+							7,
+							"std",
+							"fract"
+						],
+						["scaledUV"]
+					]
+				],
+				[
+					12,
+					"d1",
+					[
+						6,
+						[
+							7,
+							"d",
+							"f32"
+						],
+						[[5, "10"]]
+					]
+				],
+				[
+					12,
+					"d2",
+					[
+						6,
+						[
+							7,
+							"d",
+							"f32"
+						],
+						[[5, "10"]]
+					]
+				],
+				[
+					14,
+					[
+						12,
+						"ny",
+						[
+							4,
+							"-",
+							[5, "1"]
+						]
+					],
+					[
+						1,
+						"ny",
+						"<=",
+						[5, "1"]
+					],
+					[
+						102,
+						"++",
+						"ny"
+					],
+					[0, [[
+						14,
+						[
+							12,
+							"nx",
+							[
+								4,
+								"-",
+								[5, "1"]
+							]
+						],
+						[
+							1,
+							"nx",
+							"<=",
+							[5, "1"]
+						],
+						[
+							102,
+							"++",
+							"nx"
+						],
+						[0, [
+							[
+								13,
+								"offset",
+								[
+									6,
+									[
+										7,
+										"d",
+										"vec2f"
+									],
+									[[
+										6,
+										[
+											7,
+											"d",
+											"f32"
+										],
+										["nx"]
+									], [
+										6,
+										[
+											7,
+											"d",
+											"f32"
+										],
+										["ny"]
+									]]
+								]
+							],
+							[
+								13,
+								"h",
+								[
+									6,
+									"cellHash2",
+									[[
+										6,
+										[
+											7,
+											"d",
+											"vec2f"
+										],
+										[[
+											1,
+											[
+												1,
+												[
+													7,
+													"cell",
+													"x"
+												],
+												"+",
+												[
+													7,
+													"offset",
+													"x"
+												]
+											],
+											"+",
+											"seed"
+										], [
+											1,
+											[
+												1,
+												[
+													7,
+													"cell",
+													"y"
+												],
+												"+",
+												[
+													7,
+													"offset",
+													"y"
+												]
+											],
+											"+",
+											"seed"
+										]]
+									]]
+								]
+							],
+							[
+								13,
+								"px",
+								[
+									1,
+									[
+										7,
+										"h",
+										"x"
+									],
+									"+",
+									[
+										1,
+										[
+											6,
+											[
+												7,
+												"std",
+												"sin"
+											],
+											[[
+												1,
+												"animT",
+												"+",
+												[
+													1,
+													[
+														7,
+														"h",
+														"x"
+													],
+													"*",
+													"TAU"
+												]
+											]]
+										],
+										"*",
+										[5, "0.15"]
+									]
+								]
+							],
+							[
+								13,
+								"py",
+								[
+									1,
+									[
+										7,
+										"h",
+										"y"
+									],
+									"+",
+									[
+										1,
+										[
+											6,
+											[
+												7,
+												"std",
+												"cos"
+											],
+											[[
+												1,
+												"animTSlow",
+												"+",
+												[
+													1,
+													[
+														7,
+														"h",
+														"y"
+													],
+													"*",
+													"TAU"
+												]
+											]]
+										],
+										"*",
+										[5, "0.15"]
+									]
+								]
+							],
+							[
+								13,
+								"jx",
+								[
+									6,
+									[
+										7,
+										"std",
+										"mix"
+									],
+									[
+										[5, "0.5"],
+										[
+											6,
+											[
+												7,
+												"std",
+												"clamp"
+											],
+											[
+												"px",
+												[5, "0.05"],
+												[5, "0.95"]
+											]
+										],
+										"jitterAmount"
+									]
+								]
+							],
+							[
+								13,
+								"jy",
+								[
+									6,
+									[
+										7,
+										"std",
+										"mix"
+									],
+									[
+										[5, "0.5"],
+										[
+											6,
+											[
+												7,
+												"std",
+												"clamp"
+											],
+											[
+												"py",
+												[5, "0.05"],
+												[5, "0.95"]
+											]
+										],
+										"jitterAmount"
+									]
+								]
+							],
+							[
+								13,
+								"deltaX",
+								[
+									1,
+									[
+										7,
+										"localUV",
+										"x"
+									],
+									"-",
+									[
+										1,
+										[
+											7,
+											"offset",
+											"x"
+										],
+										"+",
+										"jx"
+									]
+								]
+							],
+							[
+								13,
+								"deltaY",
+								[
+									1,
+									[
+										7,
+										"localUV",
+										"y"
+									],
+									"-",
+									[
+										1,
+										[
+											7,
+											"offset",
+											"y"
+										],
+										"+",
+										"jy"
+									]
+								]
+							],
+							[
+								13,
+								"dEuclid",
+								[
+									1,
+									[
+										1,
+										"deltaX",
+										"*",
+										"deltaX"
+									],
+									"+",
+									[
+										1,
+										"deltaY",
+										"*",
+										"deltaY"
+									]
+								]
+							],
+							[
+								13,
+								"dManhattan",
+								[
+									1,
+									[
+										6,
+										[
+											7,
+											"std",
+											"abs"
+										],
+										["deltaX"]
+									],
+									"+",
+									[
+										6,
+										[
+											7,
+											"std",
+											"abs"
+										],
+										["deltaY"]
+									]
+								]
+							],
+							[
+								13,
+								"dChebyshev",
+								[
+									6,
+									[
+										7,
+										"std",
+										"max"
+									],
+									[[
+										6,
+										[
+											7,
+											"std",
+											"abs"
+										],
+										["deltaX"]
+									], [
+										6,
+										[
+											7,
+											"std",
+											"abs"
+										],
+										["deltaY"]
+									]]
+								]
+							],
+							[
+								12,
+								"dd",
+								"dEuclid"
+							],
+							[
+								2,
+								"dd",
+								"=",
+								[
+									6,
+									[
+										7,
+										"std",
+										"select"
+									],
+									[
+										"dd",
+										"dManhattan",
+										[
+											1,
+											"metric",
+											"===",
+											[5, "1"]
+										]
+									]
+								]
+							],
+							[
+								2,
+								"dd",
+								"=",
+								[
+									6,
+									[
+										7,
+										"std",
+										"select"
+									],
+									[
+										"dd",
+										"dChebyshev",
+										[
+											1,
+											"metric",
+											"===",
+											[5, "2"]
+										]
+									]
+								]
+							],
+							[
+								2,
+								"d2",
+								"=",
+								[
+									6,
+									[
+										7,
+										"std",
+										"min"
+									],
+									["d2", [
+										6,
+										[
+											7,
+											"std",
+											"max"
+										],
+										["dd", "d1"]
+									]]
+								]
+							],
+							[
+								2,
+								"d1",
+								"=",
+								[
+									6,
+									[
+										7,
+										"std",
+										"min"
+									],
+									["d1", "dd"]
+								]
+							]
+						]]
+					]]]
+				],
+				[10, [
+					6,
+					[
+						7,
+						"d",
+						"vec2f"
+					],
+					["d1", "d2"]
+				]]
+			]],
+			"externalNames": [
+				"std",
+				"d",
+				"cellHash2",
+				"TAU"
+			]
+		},
+		externals: () => ({
+			std: std_exports,
+			d: data_exports,
+			cellHash2,
+			TAU
+		})
+	}) && $.f)({})).$name(`${name}${suffix}`);
+	nearest2Cache.set(key, built);
+	return built;
+}
+var nearest2Cache = /* @__PURE__ */ new Map();
+const CELL_MODES = {
+	f1: 0,
+	f2: 1,
+	f2MinusF1: 2,
+	f1PlusF2: 3,
+	f1TimesF2: 4
+};
+const CELL_METRICS = {
+	euclidean: 0,
+	manhattan: 1,
+	chebyshev: 2
+};
+const cellReduceSelectable = src_default.fn([
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((d1, d2, metric, mode) => {
+	"use gpu";
+	const isEuclid = metric === 0;
+	const sd1 = select(d1, sqrt(d1), isEuclid);
+	const sd2 = select(d2, sqrt(d2), isEuclid);
+	let raw = sd1;
+	raw = select(raw, sd2, mode === 1);
+	raw = select(raw, __tsover_sub(sd2, sd1), mode === 2);
+	raw = select(raw, __tsover_add(sd1, sd2), mode === 3);
+	raw = select(raw, __tsover_mul(sd1, sd2), mode === 4);
+	return raw;
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "d1"
+			},
+			{
+				"type": "i",
+				"name": "d2"
+			},
+			{
+				"type": "i",
+				"name": "metric"
+			},
+			{
+				"type": "i",
+				"name": "mode"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"isEuclid",
+				[
+					1,
+					"metric",
+					"===",
+					[5, "0"]
+				]
+			],
+			[
+				13,
+				"sd1",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"d1",
+						[
+							6,
+							[
+								7,
+								"std",
+								"sqrt"
+							],
+							["d1"]
+						],
+						"isEuclid"
+					]
+				]
+			],
+			[
+				13,
+				"sd2",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"d2",
+						[
+							6,
+							[
+								7,
+								"std",
+								"sqrt"
+							],
+							["d2"]
+						],
+						"isEuclid"
+					]
+				]
+			],
+			[
+				12,
+				"raw",
+				"sd1"
+			],
+			[
+				2,
+				"raw",
+				"=",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"raw",
+						"sd2",
+						[
+							1,
+							"mode",
+							"===",
+							[5, "1"]
+						]
+					]
+				]
+			],
+			[
+				2,
+				"raw",
+				"=",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"raw",
+						[
+							1,
+							"sd2",
+							"-",
+							"sd1"
+						],
+						[
+							1,
+							"mode",
+							"===",
+							[5, "2"]
+						]
+					]
+				]
+			],
+			[
+				2,
+				"raw",
+				"=",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"raw",
+						[
+							1,
+							"sd1",
+							"+",
+							"sd2"
+						],
+						[
+							1,
+							"mode",
+							"===",
+							[5, "3"]
+						]
+					]
+				]
+			],
+			[
+				2,
+				"raw",
+				"=",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"raw",
+						[
+							1,
+							"sd1",
+							"*",
+							"sd2"
+						],
+						[
+							1,
+							"mode",
+							"===",
+							[5, "4"]
+						]
+					]
+				]
+			],
+			[10, "raw"]
+		]],
+		"externalNames": ["std"]
+	},
+	externals: () => ({ std: std_exports })
+}) && $.f)({}));
+const cellRatio = src_default.fn([
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((d1, d2, power) => {
+	"use gpu";
+	const safeSum = max(__tsover_add(d1, d2), 1e-4);
+	return clamp(pow(clamp(__tsover_div(__tsover_mul(d1, 2), safeSum), 0, 1), power), 0, 1);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "d1"
+			},
+			{
+				"type": "i",
+				"name": "d2"
+			},
+			{
+				"type": "i",
+				"name": "power"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"safeSum",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					[[
+						1,
+						"d1",
+						"+",
+						"d2"
+					], [5, "0.0001"]]
+				]
+			],
+			[
+				13,
+				"normalizedDist",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[
+								1,
+								"d1",
+								"*",
+								[5, "2"]
+							],
+							"/",
+							"safeSum"
+						],
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"std",
+					"clamp"
+				],
+				[
+					[
+						6,
+						[
+							7,
+							"std",
+							"pow"
+						],
+						["normalizedDist", "power"]
+					],
+					[5, "0"],
+					[5, "1"]
+				]
+			]]
+		]],
+		"externalNames": ["std"]
+	},
+	externals: () => ({ std: std_exports })
+}) && $.f)({}));
+const cellEdgeMask = src_default.fn([
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((d1, d2, softness) => {
+	"use gpu";
+	const safeSum = max(__tsover_add(d1, d2), 1e-4);
+	const edgeMetric = __tsover_div(__tsover_sub(d2, d1), safeSum);
+	return smoothstep(0, __tsover_add(softness, .001), edgeMetric);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "d1"
+			},
+			{
+				"type": "i",
+				"name": "d2"
+			},
+			{
+				"type": "i",
+				"name": "softness"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"safeSum",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					[[
+						1,
+						"d1",
+						"+",
+						"d2"
+					], [5, "0.0001"]]
+				]
+			],
+			[
+				13,
+				"edgeMetric",
+				[
+					1,
+					[
+						1,
+						"d2",
+						"-",
+						"d1"
+					],
+					"/",
+					"safeSum"
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"std",
+					"smoothstep"
+				],
+				[
+					[5, "0"],
+					[
+						1,
+						"softness",
+						"+",
+						[5, "0.001"]
+					],
+					"edgeMetric"
+				]
+			]]
+		]],
+		"externalNames": ["std"]
+	},
+	externals: () => ({ std: std_exports })
+}) && $.f)({}));
+export { cellRatio as a, nearest2Cells as c, cellHash2 as i, CELL_MODES as n, cellReduceSelectable as o, cellEdgeMask as r, cellular_exports as s, CELL_METRICS as t };