shaders 3.1.463 → 3.2.465

package/dist/core/cellular-DoC-O8KM.js

@@ -1,1342 +0,0 @@
-import { Dt as sin, Mt as vec2f, Ot as smoothstep, _t as max, ct as clamp, dt as dot, et as typegpu_default, gt as length, ht as fract, it as abs, kt as sqrt, lt as cos, mt as floor, rt as select, sn as f32, vt as min, xt as pow, yt as mix } from "./edges-CV-BHMpI.js";
-import { o as TAU } from "./constants-BKlzQFdJ.js";
-const cellHash2 = typegpu_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: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "p"
-		}],
-		"body": [0, [[
-			13,
-			"h",
-			[
-				6,
-				"d.vec2f",
-				[[
-					6,
-					"std.dot",
-					["p", [
-						6,
-						"d.vec2f",
-						[[5, "127.1"], [5, "311.7"]]
-					]]
-				], [
-					6,
-					"std.dot",
-					["p", [
-						6,
-						"d.vec2f",
-						[[5, "269.5"], [5, "183.3"]]
-					]]
-				]]
-			]
-		], [10, [
-			6,
-			"std.fract",
-			[[
-				6,
-				[
-					7,
-					[
-						6,
-						"std.sin",
-						["h"]
-					],
-					"mul"
-				],
-				[[5, "43758.5453"]]
-			]]
-		]]]]
-	},
-	externals: {
-		"d.vec2f": () => vec2f,
-		"std.dot": () => dot,
-		"std.fract": () => fract,
-		"std.sin": () => sin
-	}
-}) && $.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 = typegpu_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: 2,
-		name: void 0,
-		ast: {
-			"params": [
-				{
-					"type": "i",
-					"name": "scaledUV"
-				},
-				{
-					"type": "i",
-					"name": "animT"
-				},
-				{
-					"type": "i",
-					"name": "seed"
-				}
-			],
-			"body": [0, [
-				[
-					13,
-					"cell",
-					[
-						6,
-						"std.floor",
-						["scaledUV"]
-					]
-				],
-				[
-					13,
-					"localUV",
-					[
-						6,
-						"std.fract",
-						["scaledUV"]
-					]
-				],
-				[
-					12,
-					"d1",
-					[
-						6,
-						"d.f32",
-						[[5, "10"]]
-					]
-				],
-				[
-					12,
-					"d2",
-					[
-						6,
-						"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,
-									"d.vec2f",
-									[[
-										6,
-										"d.f32",
-										["nx"]
-									], [
-										6,
-										"d.f32",
-										["ny"]
-									]]
-								]
-							],
-							[
-								13,
-								"h",
-								[
-									6,
-									"cellHash2",
-									[[
-										6,
-										"d.vec2f",
-										[[
-											1,
-											[
-												1,
-												[
-													7,
-													"cell",
-													"x"
-												],
-												"+",
-												[
-													7,
-													"offset",
-													"x"
-												]
-											],
-											"+",
-											"seed"
-										], [
-											1,
-											[
-												1,
-												[
-													7,
-													"cell",
-													"y"
-												],
-												"+",
-												[
-													7,
-													"offset",
-													"y"
-												]
-											],
-											"+",
-											"seed"
-										]]
-									]]
-								]
-							],
-							[
-								13,
-								"pointX",
-								[
-									6,
-									"std.clamp",
-									[
-										[
-											1,
-											[
-												7,
-												"h",
-												"x"
-											],
-											"+",
-											[
-												1,
-												[
-													6,
-													"std.sin",
-													[[
-														1,
-														"animT",
-														"+",
-														[
-															1,
-															[
-																7,
-																"h",
-																"x"
-															],
-															"*",
-															"TAU"
-														]
-													]]
-												],
-												"*",
-												[5, "0.15"]
-											]
-										],
-										[5, "0.05"],
-										[5, "0.95"]
-									]
-								]
-							],
-							[
-								13,
-								"pointY",
-								[
-									6,
-									"std.clamp",
-									[
-										[
-											1,
-											[
-												7,
-												"h",
-												"y"
-											],
-											"+",
-											[
-												1,
-												[
-													6,
-													"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,
-									"std.length",
-									[[
-										6,
-										"d.vec2f",
-										[[
-											1,
-											[
-												7,
-												"localUV",
-												"x"
-											],
-											"-",
-											[
-												1,
-												[
-													7,
-													"offset",
-													"x"
-												],
-												"+",
-												"pointX"
-											]
-										], [
-											1,
-											[
-												7,
-												"localUV",
-												"y"
-											],
-											"-",
-											[
-												1,
-												[
-													7,
-													"offset",
-													"y"
-												],
-												"+",
-												"pointY"
-											]
-										]]
-									]]
-								]
-							],
-							[
-								2,
-								"d2",
-								"=",
-								[
-									6,
-									"std.min",
-									["d2", [
-										6,
-										"std.max",
-										["dd", "d1"]
-									]]
-								]
-							],
-							[
-								2,
-								"d1",
-								"=",
-								[
-									6,
-									"std.min",
-									["d1", "dd"]
-								]
-							]
-						]]
-					]]]
-				],
-				[10, [
-					6,
-					"d.vec2f",
-					["d1", "d2"]
-				]]
-			]]
-		},
-		externals: {
-			"std.floor": () => floor,
-			"std.fract": () => fract,
-			"d.f32": () => f32,
-			"d.vec2f": () => vec2f,
-			"cellHash2": () => cellHash2,
-			"std.clamp": () => clamp,
-			"std.sin": () => sin,
-			"TAU": () => TAU,
-			"std.cos": () => cos,
-			"std.length": () => length,
-			"std.min": () => min,
-			"std.max": () => max
-		}
-	}) && $.f)({})).$name(`${name}${suffix}`);
-	else built = typegpu_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: 2,
-		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,
-						"std.floor",
-						["scaledUV"]
-					]
-				],
-				[
-					13,
-					"localUV",
-					[
-						6,
-						"std.fract",
-						["scaledUV"]
-					]
-				],
-				[
-					12,
-					"d1",
-					[
-						6,
-						"d.f32",
-						[[5, "10"]]
-					]
-				],
-				[
-					12,
-					"d2",
-					[
-						6,
-						"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,
-									"d.vec2f",
-									[[
-										6,
-										"d.f32",
-										["nx"]
-									], [
-										6,
-										"d.f32",
-										["ny"]
-									]]
-								]
-							],
-							[
-								13,
-								"h",
-								[
-									6,
-									"cellHash2",
-									[[
-										6,
-										"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,
-											"std.sin",
-											[[
-												1,
-												"animT",
-												"+",
-												[
-													1,
-													[
-														7,
-														"h",
-														"x"
-													],
-													"*",
-													"TAU"
-												]
-											]]
-										],
-										"*",
-										[5, "0.15"]
-									]
-								]
-							],
-							[
-								13,
-								"py",
-								[
-									1,
-									[
-										7,
-										"h",
-										"y"
-									],
-									"+",
-									[
-										1,
-										[
-											6,
-											"std.cos",
-											[[
-												1,
-												"animTSlow",
-												"+",
-												[
-													1,
-													[
-														7,
-														"h",
-														"y"
-													],
-													"*",
-													"TAU"
-												]
-											]]
-										],
-										"*",
-										[5, "0.15"]
-									]
-								]
-							],
-							[
-								13,
-								"jx",
-								[
-									6,
-									"std.mix",
-									[
-										[5, "0.5"],
-										[
-											6,
-											"std.clamp",
-											[
-												"px",
-												[5, "0.05"],
-												[5, "0.95"]
-											]
-										],
-										"jitterAmount"
-									]
-								]
-							],
-							[
-								13,
-								"jy",
-								[
-									6,
-									"std.mix",
-									[
-										[5, "0.5"],
-										[
-											6,
-											"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,
-										"std.abs",
-										["deltaX"]
-									],
-									"+",
-									[
-										6,
-										"std.abs",
-										["deltaY"]
-									]
-								]
-							],
-							[
-								13,
-								"dChebyshev",
-								[
-									6,
-									"std.max",
-									[[
-										6,
-										"std.abs",
-										["deltaX"]
-									], [
-										6,
-										"std.abs",
-										["deltaY"]
-									]]
-								]
-							],
-							[
-								12,
-								"dd",
-								"dEuclid"
-							],
-							[
-								2,
-								"dd",
-								"=",
-								[
-									6,
-									"std.select",
-									[
-										"dd",
-										"dManhattan",
-										[
-											1,
-											"metric",
-											"===",
-											[5, "1"]
-										]
-									]
-								]
-							],
-							[
-								2,
-								"dd",
-								"=",
-								[
-									6,
-									"std.select",
-									[
-										"dd",
-										"dChebyshev",
-										[
-											1,
-											"metric",
-											"===",
-											[5, "2"]
-										]
-									]
-								]
-							],
-							[
-								2,
-								"d2",
-								"=",
-								[
-									6,
-									"std.min",
-									["d2", [
-										6,
-										"std.max",
-										["dd", "d1"]
-									]]
-								]
-							],
-							[
-								2,
-								"d1",
-								"=",
-								[
-									6,
-									"std.min",
-									["d1", "dd"]
-								]
-							]
-						]]
-					]]]
-				],
-				[10, [
-					6,
-					"d.vec2f",
-					["d1", "d2"]
-				]]
-			]]
-		},
-		externals: {
-			"std.floor": () => floor,
-			"std.fract": () => fract,
-			"d.f32": () => f32,
-			"d.vec2f": () => vec2f,
-			"cellHash2": () => cellHash2,
-			"std.sin": () => sin,
-			"TAU": () => TAU,
-			"std.cos": () => cos,
-			"std.mix": () => mix,
-			"std.clamp": () => clamp,
-			"std.abs": () => abs,
-			"std.max": () => max,
-			"std.select": () => select,
-			"std.min": () => min
-		}
-	}) && $.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 = typegpu_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: 2,
-	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,
-					"std.select",
-					[
-						"d1",
-						[
-							6,
-							"std.sqrt",
-							["d1"]
-						],
-						"isEuclid"
-					]
-				]
-			],
-			[
-				13,
-				"sd2",
-				[
-					6,
-					"std.select",
-					[
-						"d2",
-						[
-							6,
-							"std.sqrt",
-							["d2"]
-						],
-						"isEuclid"
-					]
-				]
-			],
-			[
-				12,
-				"raw",
-				"sd1"
-			],
-			[
-				2,
-				"raw",
-				"=",
-				[
-					6,
-					"std.select",
-					[
-						"raw",
-						"sd2",
-						[
-							1,
-							"mode",
-							"===",
-							[5, "1"]
-						]
-					]
-				]
-			],
-			[
-				2,
-				"raw",
-				"=",
-				[
-					6,
-					"std.select",
-					[
-						"raw",
-						[
-							1,
-							"sd2",
-							"-",
-							"sd1"
-						],
-						[
-							1,
-							"mode",
-							"===",
-							[5, "2"]
-						]
-					]
-				]
-			],
-			[
-				2,
-				"raw",
-				"=",
-				[
-					6,
-					"std.select",
-					[
-						"raw",
-						[
-							1,
-							"sd1",
-							"+",
-							"sd2"
-						],
-						[
-							1,
-							"mode",
-							"===",
-							[5, "3"]
-						]
-					]
-				]
-			],
-			[
-				2,
-				"raw",
-				"=",
-				[
-					6,
-					"std.select",
-					[
-						"raw",
-						[
-							1,
-							"sd1",
-							"*",
-							"sd2"
-						],
-						[
-							1,
-							"mode",
-							"===",
-							[5, "4"]
-						]
-					]
-				]
-			],
-			[10, "raw"]
-		]]
-	},
-	externals: {
-		"std.select": () => select,
-		"std.sqrt": () => sqrt
-	}
-}) && $.f)({}));
-const cellRatio = typegpu_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: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "d1"
-			},
-			{
-				"type": "i",
-				"name": "d2"
-			},
-			{
-				"type": "i",
-				"name": "power"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"safeSum",
-				[
-					6,
-					"std.max",
-					[[
-						1,
-						"d1",
-						"+",
-						"d2"
-					], [5, "0.0001"]]
-				]
-			],
-			[
-				13,
-				"normalizedDist",
-				[
-					6,
-					"std.clamp",
-					[
-						[
-							1,
-							[
-								1,
-								"d1",
-								"*",
-								[5, "2"]
-							],
-							"/",
-							"safeSum"
-						],
-						[5, "0"],
-						[5, "1"]
-					]
-				]
-			],
-			[10, [
-				6,
-				"std.clamp",
-				[
-					[
-						6,
-						"std.pow",
-						["normalizedDist", "power"]
-					],
-					[5, "0"],
-					[5, "1"]
-				]
-			]]
-		]]
-	},
-	externals: {
-		"std.max": () => max,
-		"std.clamp": () => clamp,
-		"std.pow": () => pow
-	}
-}) && $.f)({}));
-const cellEdgeMask = typegpu_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: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "d1"
-			},
-			{
-				"type": "i",
-				"name": "d2"
-			},
-			{
-				"type": "i",
-				"name": "softness"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"safeSum",
-				[
-					6,
-					"std.max",
-					[[
-						1,
-						"d1",
-						"+",
-						"d2"
-					], [5, "0.0001"]]
-				]
-			],
-			[
-				13,
-				"edgeMetric",
-				[
-					1,
-					[
-						1,
-						"d2",
-						"-",
-						"d1"
-					],
-					"/",
-					"safeSum"
-				]
-			],
-			[10, [
-				6,
-				"std.smoothstep",
-				[
-					[5, "0"],
-					[
-						1,
-						"softness",
-						"+",
-						[5, "0.001"]
-					],
-					"edgeMetric"
-				]
-			]]
-		]]
-	},
-	externals: {
-		"std.max": () => max,
-		"std.smoothstep": () => smoothstep
-	}
-}) && $.f)({}));
-export { cellRatio as a, cellHash2 as i, CELL_MODES as n, cellReduceSelectable as o, cellEdgeMask as r, nearest2Cells as s, CELL_METRICS as t };