material-designer-runtime 0.1.0

package/dist/index.js

@@ -0,0 +1,4437 @@
+import * as e from "three";
+import { NearestFilter as t, NoColorSpace as n, OrthographicCamera as r, RepeatWrapping as i, Scene as a, Vector3 as o } from "three";
+import { MeshBasicNodeMaterial as s, MeshPhysicalNodeMaterial as c, QuadMesh as l, RenderTarget as u } from "three/webgpu";
+import { Fn as d, abs as f, acos as p, asin as m, atan as h, attribute as g, bool as _, bumpMap as v, ceil as y, clamp as b, color as x, cos as S, cosh as C, cross as w, dFdx as T, dFdy as E, degrees as ee, dot as D, exp as O, exp2 as te, float as k, floatBitsToUint as ne, floor as A, fract as j, fwidth as re, int as M, inverseSqrt as ie, length as N, log as ae, luminance as oe, max as P, min as F, mix as I, mod as L, mx_noise_float as se, normalLocal as ce, normalMap as le, normalWorld as ue, normalize as de, parallaxDirection as fe, positionLocal as pe, positionWorld as me, pow as R, radians as he, reflect as ge, round as _e, sRGBTransferOETF as ve, saturate as ye, select as z, sign as be, sin as B, sinh as xe, smoothstep as V, sqrt as Se, step as Ce, tan as we, tanh as Te, texture as H, trunc as Ee, uint as U, uniform as W, uniformArray as De, uv as G, vec2 as K, vec3 as q, vec4 as Oe } from "three/tsl";
+var ke = {
+	version: 2,
+	nodes: [{
+		id: "pr",
+		type: "principled-bsdf",
+		params: {},
+		position: {
+			x: 420,
+			y: 160
+		},
+		enabled: !0
+	}, {
+		id: "out",
+		type: "material-output",
+		params: {},
+		position: {
+			x: 740,
+			y: 180
+		},
+		enabled: !0
+	}],
+	edges: [{
+		fromNode: "pr",
+		fromOutput: "bsdf",
+		toNode: "out",
+		toInput: "surface"
+	}]
+}, Ae = [
+	0,
+	.25,
+	.5,
+	.75,
+	1
+], je = [
+	"C",
+	"R",
+	"G",
+	"B"
+];
+function Me(e) {
+	let t = (e) => Array.from({ length: 5 }, (t, n) => e?.[n] ?? Ae[n]);
+	return [
+		...t(e?.C),
+		...t(e?.R),
+		...t(e?.G),
+		...t(e?.B)
+	];
+}
+var Ne = "group", Pe = "group-input", Fe = "group-output", Ie = "material-output", Le = [
+	"baseColor",
+	"normal",
+	"emission",
+	"roughness",
+	"metallic",
+	"ambientOcclusion"
+], Re = {
+	float: {
+		float: "identity",
+		vector: "float-to-vector",
+		color: "float-to-color"
+	},
+	vector: {
+		vector: "identity",
+		float: "vector-to-float",
+		color: "vector-to-color"
+	},
+	color: {
+		color: "identity",
+		float: "color-to-float",
+		vector: "color-to-vector"
+	},
+	shader: { shader: "identity" }
+};
+function ze(e, t) {
+	return Re[e]?.[t];
+}
+//#endregion
+//#region src/tsl/blender-noise.ts
+var J = (e, t) => e.shiftLeft(t).bitOr(e.shiftRight(32 - t));
+function Be(e, t, n) {
+	let r = 3735928584, i = U(r).toVar(), a = U(r).toVar(), o = U(r).toVar();
+	return o.assign(o.add(n)), a.assign(a.add(t)), i.assign(i.add(e)), o.assign(o.bitXor(a)), o.assign(o.sub(J(a, 14))), i.assign(i.bitXor(o)), i.assign(i.sub(J(o, 11))), a.assign(a.bitXor(i)), a.assign(a.sub(J(i, 25))), o.assign(o.bitXor(a)), o.assign(o.sub(J(a, 16))), i.assign(i.bitXor(o)), i.assign(i.sub(J(o, 4))), a.assign(a.bitXor(i)), a.assign(a.sub(J(i, 14))), o.assign(o.bitXor(a)), o.assign(o.sub(J(a, 24))), o;
+}
+var Ve = (e, t, n) => Be(U(e), U(t), U(n)), He = (e) => e.mul(e).mul(e).mul(e.mul(e.mul(6).sub(15)).add(10)), Ue = (e, t) => z(t.notEqual(U(0)), e.negate(), e);
+function We(e, t, n, r) {
+	let i = e.bitAnd(U(15)).toVar(), a = z(i.lessThan(U(8)), t, n), o = z(i.equal(U(12)).or(i.equal(U(14))), t, r), s = z(i.lessThan(U(4)), n, o);
+	return Ue(a, i.bitAnd(U(1))).add(Ue(s, i.bitAnd(U(2))));
+}
+function Ge(e, t, n, r) {
+	let i = k(1).sub(t), a = k(1).sub(n);
+	return k(1).sub(r).mul(a.mul(e[0].mul(i).add(e[1].mul(t))).add(n.mul(e[2].mul(i).add(e[3].mul(t))))).add(r.mul(a.mul(e[4].mul(i).add(e[5].mul(t))).add(n.mul(e[6].mul(i).add(e[7].mul(t))))));
+}
+function Ke(e) {
+	let t = A(e.x).toVar(), n = A(e.y).toVar(), r = A(e.z).toVar(), i = e.x.sub(t).toVar(), a = e.y.sub(n).toVar(), o = e.z.sub(r).toVar(), s = M(t), c = M(n), l = M(r), u = He(i), d = He(a), f = He(o), p = (e, t, n) => We(Ve(s.add(e), c.add(t), l.add(n)), i.sub(e), a.sub(t), o.sub(n));
+	return Ge([
+		p(0, 0, 0),
+		p(1, 0, 0),
+		p(0, 1, 0),
+		p(1, 1, 0),
+		p(0, 0, 1),
+		p(1, 0, 1),
+		p(0, 1, 1),
+		p(1, 1, 1)
+	], u, d, f);
+}
+var qe = (e) => Ke(e).mul(.982);
+function Je(e, t, n, r) {
+	let i = Math.max(0, Math.min(15, Math.floor(t)));
+	return d(() => {
+		let t = k(1).toVar(), a = k(1).toVar(), o = k(0).toVar(), s = k(0).toVar();
+		for (let c = 0; c <= i; c++) o.assign(o.add(qe(e.mul(a)).mul(t))), s.assign(s.add(t)), t.assign(t.mul(n)), a.assign(a.mul(r));
+		return o.div(s).mul(.5).add(.5);
+	})();
+}
+//#endregion
+//#region src/graph/nodes/texture/fbm.ts
+var Ye = {
+	type: "fbm",
+	nodeClass: "texture",
+	label: "Noise (FBM)",
+	inputs: [{
+		key: "coord",
+		kind: "vector"
+	}],
+	outputs: [{
+		key: "field",
+		kind: "float"
+	}],
+	params: [
+		{
+			key: "scale",
+			label: "scale",
+			type: "float",
+			min: .1,
+			max: 8,
+			step: .05,
+			default: 1.2
+		},
+		{
+			key: "octaves",
+			label: "detail",
+			type: "int",
+			min: 0,
+			max: 15,
+			step: 1,
+			default: 4
+		},
+		{
+			key: "lacunarity",
+			label: "lacunarity",
+			type: "float",
+			min: 1.5,
+			max: 3,
+			step: .05,
+			default: 2
+		},
+		{
+			key: "gain",
+			label: "roughness",
+			type: "float",
+			min: 0,
+			max: 1,
+			step: .01,
+			default: .5
+		}
+	],
+	build(e) {
+		return { field: Je((e.inputs.coord ?? e.coord).mul(e.uniforms.scale), e.params.octaves ?? 4, e.uniforms.gain, e.uniforms.lacunarity) };
+	}
+}, Xe = {
+	type: "domain-warp",
+	nodeClass: "vector",
+	label: "Domain Warp",
+	inputs: [{
+		key: "coord",
+		kind: "vector"
+	}],
+	outputs: [{
+		key: "coord",
+		kind: "vector"
+	}],
+	params: [{
+		key: "amount",
+		label: "amount",
+		type: "float",
+		min: 0,
+		max: 2,
+		step: .01,
+		default: .3
+	}, {
+		key: "scale",
+		label: "scale",
+		type: "float",
+		min: .1,
+		max: 8,
+		step: .05,
+		default: 1
+	}],
+	build(e) {
+		let t = e.inputs.coord ?? e.coord, n = t.div(e.uniforms.scale), r = se(n.add(q(11.3, 0, 0))), i = se(n.add(q(0, 47.7, 0))), a = se(n.add(q(0, 0, 93.1)));
+		return { coord: t.add(q(r, i, a).mul(e.uniforms.amount)) };
+	}
+}, Ze = (e) => L(e.mul(34).add(1).mul(e), 289), Qe = (e) => e.mul(e).mul(e).mul(e.mul(e.mul(6).sub(15)).add(10)), $e = d(([e, t]) => {
+	let n = A(e.xyxy).add(Oe(0, 0, 1, 1)), r = j(e.xyxy).sub(Oe(0, 0, 1, 1)), i = L(L(n, t.xyxy), 289), a = i.xzxz, o = i.yyww, s = r.xzxz, c = r.yyww, l = j(Ze(Ze(a).add(o)).mul(.0243902439)).mul(2).sub(1), u = f(l).sub(.5), d = l.sub(A(l.add(.5))), p = K(d.x, u.x), m = K(d.y, u.y), h = K(d.z, u.z), g = K(d.w, u.w), _ = k(1.79284291400159).sub(k(.85373472095314).mul(Oe(D(p, p), D(h, h), D(m, m), D(g, g))));
+	p = p.mul(_.x), h = h.mul(_.y), m = m.mul(_.z), g = g.mul(_.w);
+	let v = D(p, K(s.x, c.x)), y = D(m, K(s.y, c.y)), b = D(h, K(s.z, c.z)), x = D(g, K(s.w, c.w)), S = Qe(r.xy), C = I(K(v, b), K(y, x), S.x);
+	return I(C.x, C.y, S.y).mul(2.3);
+});
+function et(e, t, n, r, i, a, o = 2) {
+	let s = typeof t == "number" ? k(Math.max(1, Math.round(t))) : t, c = typeof n == "number" ? k(Math.max(1, Math.round(n))) : n, l = re(e), u = k(0), d = k(0), f = k(1), p = Math.max(2, Math.round(o));
+	for (let t = 0; t < Math.max(1, r); t++) {
+		let n = Math.round(p ** +t), r = K(s.mul(n), c.mul(n)), o = f;
+		if (a !== void 0) {
+			let e = P(r.x.mul(l.x), r.y.mul(l.y)), t = b(k(1).sub(V(.2, .5, e)), 0, 1);
+			o = f.mul(I(k(1), t, a));
+		}
+		u = u.add(o.mul($e(e.mul(r), r))), d = d.add(o), f = f.mul(i);
+	}
+	return I(k(0), u.div(d.max(1e-4)), F(d, 1));
+}
+//#endregion
+//#region src/tsl/noise/fbm.ts
+function tt(e, t, n, r, i, a, o, s = 2) {
+	let c = typeof t == "number" ? k(Math.max(1, Math.round(t))) : t, l = typeof n == "number" ? k(Math.max(1, Math.round(n))) : n, u = re(e), d = k(0), f = k(0), p = k(1), m = Math.max(2, Math.round(s));
+	for (let t = 0; t < Math.max(1, r); t++) {
+		let n = Math.round(m ** +t), r = c.mul(n), s = l.mul(n), h = e.mul(K(r, s)), g = p;
+		if (o !== void 0) {
+			let e = P(r.mul(u.x), s.mul(u.y)), t = b(k(1).sub(V(.2, .5, e)), 0, 1);
+			g = p.mul(I(k(1), t, o));
+		}
+		d = d.add(g.mul(a(h, r, s))), f = f.add(g), p = p.mul(i);
+	}
+	return I(k(.5), d.div(f.max(1e-4)), F(f, 1));
+}
+//#endregion
+//#region src/tsl/noise/hash.ts
+var nt = 1 / 2147483648, rt = d(([e, t, n]) => {
+	let r = e.mul(1664525).add(1013904223).toVar(), i = t.mul(1664525).add(1013904223).toVar(), a = n.mul(1664525).add(1013904223).toVar();
+	r.assign(r.add(i.mul(a))), i.assign(i.add(a.mul(r))), a.assign(a.add(r.mul(i))), r.assign(r.bitXor(r.shiftRight(16))), i.assign(i.bitXor(i.shiftRight(16))), a.assign(a.bitXor(a.shiftRight(16))), r.assign(r.add(i.mul(a))), i.assign(i.add(a.mul(r))), a.assign(a.add(r.mul(i)));
+	let o = M(2147483647);
+	return q(k(r.bitAnd(o)).mul(nt), k(i.bitAnd(o)).mul(nt), k(a.bitAnd(o)).mul(nt));
+});
+function it(e, t) {
+	return typeof t == "number" && t <= 0 ? e : e.sub(M(A(k(e).div(t))).mul(M(t)));
+}
+function at(e, t, n, r) {
+	return rt(it(e, n), it(t, r), M(0)).x;
+}
+function ot(e, t, n, r) {
+	return rt(it(e, n), it(t, r), M(0));
+}
+function st(e, t, n, r, i) {
+	return rt(it(e, r), it(t, i), M(n));
+}
+//#endregion
+//#region src/tsl/noise/value.ts
+function ct(e, t, n) {
+	let r = A(e), i = e.sub(r), a = i.mul(i).mul(k(3).sub(i.mul(2))), o = M(r.x), s = M(r.y), c = at(o, s, t, n), l = at(o.add(1), s, t, n), u = at(o, s.add(1), t, n), d = at(o.add(1), s.add(1), t, n);
+	return I(I(c, l, a.x), I(u, d, a.x), a.y);
+}
+//#endregion
+//#region src/tsl/noise/cellular.ts
+var lt = 2;
+function ut(e, t, n) {
+	let r = A(e), i = e.sub(r), a = M(r.x), o = M(r.y), s = q(i.x, i.y, k(0)), c = k(1e10);
+	for (let e = -1; e <= 1; e++) for (let r = -1; r <= 1; r++) {
+		let i = ot(a.add(e), o.add(r), t, n), l = q(k(e).add(i.x), k(r).add(i.y), i.z);
+		c = F(c, N(l.sub(s)));
+	}
+	return b(k(1).sub(c), 0, 1);
+}
+function dt(e, t, n) {
+	let r = A(e), i = e.sub(r), a = M(r.x), o = M(r.y), s = k(0), c = k(0);
+	for (let e = -1; e <= 1; e++) for (let r = -1; r <= 1; r++) {
+		let l = ot(a.add(e), o.add(r), t, n), u = R(V(1.414, 0, N(K(e, r).sub(i).add(K(l.x, l.y)))), lt);
+		s = s.add(l.z.mul(u)), c = c.add(u);
+	}
+	return s.div(c.max(1e-4));
+}
+//#endregion
+//#region src/tsl/noise/flow.ts
+var ft = (e, t) => $e(e, K(t, t)), pt = d(([e, t]) => {
+	let n = k(.1), r = ft(e.add(K(n, 0)), t), i = ft(e.add(K(0, n)), t), a = ft(e.sub(K(n, 0)), t), o = ft(e.sub(K(0, n)), t);
+	return K(r.sub(a), i.sub(o)).div(n).mul(.5);
+});
+function mt(e, t, n) {
+	let r = pt(e, t);
+	return q(r.x, r.y, k(0));
+}
+function ht(e, t, n) {
+	return b(pt(e, t).length().mul(.6).add(.2), 0, 1);
+}
+function gt(e, t, n) {
+	let r = pt(e, t);
+	return b(P(f(r.x), f(r.y)), 0, 1);
+}
+function _t(e, t, n) {
+	let r = pt(e, t).mul(.4);
+	return ft(e.add(r), t).mul(.5).add(.5);
+}
+//#endregion
+//#region src/tsl/noise/gabor.ts
+var vt = 6.283185307179586, yt = Math.PI, bt = 8, xt = d(([e, t, n, r, i]) => {
+	let a = e.mul(t), o = A(a), s = a.sub(o), c = k(0).toVar();
+	for (let e = -1; e <= 1; e++) for (let a = -1; a <= 1; a++) {
+		let l = M(o.x).add(a), u = M(o.y).add(e), d = s.sub(K(a, e));
+		for (let e = 0; e < bt; e++) {
+			let a = st(l, u, e * 2, t, t), o = st(l, u, e * 2 + 1, t, t), s = i.add(o.x.sub(.5).mul(yt).mul(r)), f = d.sub(K(a.x, a.y)), p = D(f, f), m = O(p.mul(-yt)).mul(k(.5).add(S(p.mul(yt)).mul(.5))), h = D(f, K(S(s), B(s)).mul(n)).mul(vt), g = I(k(-1), k(1), Ce(.5, a.z)), _ = k(1).sub(Ce(1, p));
+			c.addAssign(B(h).mul(m).mul(g).mul(_));
+		}
+	}
+	return c.div(6).mul(.5).add(.5);
+});
+//#endregion
+//#region src/tsl/noise/simplex.ts
+function St(e, t, n) {
+	let r = K(e.x.add(e.y.mul(.5)), e.y), i = A(r), a = r.sub(i), o = Ce(a.y, a.x), s = K(o, k(1).sub(o)), c = K(i.x.sub(i.y.mul(.5)), i.y), l = K(c.x.add(s.x).sub(s.y.mul(.5)), c.y.add(s.y)), u = K(c.x.add(.5), c.y.add(1)), d = e.sub(c), f = e.sub(l), p = e.sub(u), m = L(q(c.x, l.x, u.x), k(t)), h = L(q(c.y, l.y, u.y), k(n)), g = A(m.add(h.mul(.5)).add(.5)), _ = A(h.add(.5)), v = L(g, 289);
+	v = L(v.mul(51).add(2).mul(v).add(_), 289), v = L(v.mul(34).add(10).mul(v), 289);
+	let y = v.mul(.07482), x = S(y), C = B(y), w = K(x.x, C.x), T = K(x.y, C.y), E = K(x.z, C.z), ee = P(k(.8).sub(q(D(d, d), D(f, f), D(p, p))), 0), O = ee.mul(ee);
+	return b(D(O.mul(O), q(D(w, d), D(T, f), D(E, p))).mul(10.9).mul(.5).add(.5), 0, 1);
+}
+//#endregion
+//#region src/tsl/noise/wavelet.ts
+var Ct = 6.283185307179586;
+function wt(e, t, n) {
+	let r = A(e), i = j(e).sub(.5), a = at(M(r.x), M(r.y), t, n).mul(Ct), o = S(a), s = B(a), c = o.mul(i.x).sub(s.mul(i.y)), l = s.mul(i.x).add(o.mul(i.y)), u = V(.25, 0, D(K(c, l), K(c, l)));
+	return b(B(c.mul(10)).mul(u).mul(.5).add(.5), 0, 1);
+}
+//#endregion
+//#region src/tsl/noise/erosion.ts
+function Tt(e, t, n) {
+	let r = pt(e, t), i = $e(e.add(r.mul(.6)), K(t, t)).mul(.5).add(.5);
+	return b(k(1).sub(i.mul(2).sub(1).abs()), 0, 1);
+}
+//#endregion
+//#region src/graph/nodes/texture/tileable-noise.ts
+var Et = [
+	"perlin-fbm",
+	"value",
+	"worley",
+	"voronoi-smooth",
+	"gabor",
+	"stone",
+	"paper",
+	"wool",
+	"simplex",
+	"wavelet",
+	"erosion",
+	"curl"
+], Y = [
+	"octaves",
+	"gain",
+	"lacunarity",
+	"antialias",
+	"tileSize"
+], Dt = {
+	"perlin-fbm": ["aspect", ...Y],
+	value: ["aspect", ...Y],
+	worley: Y,
+	"voronoi-smooth": Y,
+	stone: Y,
+	paper: Y,
+	wool: Y,
+	simplex: Y,
+	wavelet: Y,
+	erosion: Y,
+	gabor: [
+		"gaborFreq",
+		"gaborAniso",
+		"gaborOrient",
+		"tileSize"
+	],
+	curl: []
+}, Ot = {
+	value: ct,
+	worley: ut,
+	"voronoi-smooth": dt,
+	stone: _t,
+	paper: ht,
+	wool: gt,
+	wavelet: wt,
+	erosion: Tt
+}, kt = [{
+	key: "field",
+	kind: "float"
+}], At = [{
+	key: "field",
+	kind: "float"
+}, {
+	key: "vector",
+	kind: "vector"
+}], jt = {
+	type: "tileable-noise",
+	nodeClass: "texture",
+	label: "Tileable Noise",
+	bakeTileable: !0,
+	inputs: [{
+		key: "coord",
+		kind: "vector"
+	}],
+	outputs: [{
+		key: "field",
+		kind: "float"
+	}],
+	params: [
+		{
+			key: "noiseType",
+			label: "type",
+			type: "select",
+			options: Et,
+			default: "perlin-fbm"
+		},
+		{
+			key: "scale",
+			label: "scale",
+			type: "float",
+			min: 1,
+			max: 128,
+			step: 1,
+			default: 5
+		},
+		{
+			key: "aspect",
+			label: "aspect",
+			type: "float",
+			min: 1,
+			max: 8,
+			step: .5,
+			default: 1
+		},
+		{
+			key: "octaves",
+			label: "detail",
+			type: "int",
+			min: 1,
+			max: 8,
+			step: 1,
+			default: 4
+		},
+		{
+			key: "gain",
+			label: "roughness",
+			type: "float",
+			min: 0,
+			max: 1,
+			step: .01,
+			default: .5
+		},
+		{
+			key: "lacunarity",
+			label: "lacunarity",
+			type: "float",
+			min: 2,
+			max: 8,
+			step: 1,
+			default: 2,
+			bakeStructural: !0
+		},
+		{
+			key: "antialias",
+			label: "anti-alias",
+			type: "float",
+			min: 0,
+			max: 1,
+			step: .01,
+			default: 1
+		},
+		{
+			key: "gaborFreq",
+			label: "gabor freq",
+			type: "float",
+			min: 0,
+			max: 16,
+			step: .1,
+			default: 2
+		},
+		{
+			key: "gaborAniso",
+			label: "gabor aniso",
+			type: "float",
+			min: 0,
+			max: 1,
+			step: .01,
+			default: 1
+		},
+		{
+			key: "gaborOrient",
+			label: "gabor angle",
+			type: "float",
+			min: 0,
+			max: 6.2832,
+			step: .01,
+			default: .785398
+		},
+		{
+			key: "tileSize",
+			label: "tile",
+			type: "select",
+			options: [
+				"off",
+				"64",
+				"128",
+				"256",
+				"512"
+			],
+			default: "off"
+		}
+	],
+	declare(e) {
+		return {
+			inputs: [{
+				key: "coord",
+				kind: "vector"
+			}],
+			outputs: e.noiseType === "curl" ? At : kt
+		};
+	},
+	paramsFor(e) {
+		let t = Dt[e.noiseType ?? "perlin-fbm"] ?? [], n = new Set([
+			"noiseType",
+			"scale",
+			...t
+		]);
+		return jt.params.filter((e) => n.has(e.key));
+	},
+	build(e) {
+		let t = e.inputs.coord ?? e.coord, n = Math.max(1, Math.round(Number.isFinite(Number(e.params.octaves)) ? Number(e.params.octaves) : 4)), r = Math.max(2, Math.round(Number.isFinite(Number(e.params.lacunarity)) ? Number(e.params.lacunarity) : 2)), i = e.params.noiseType ?? "perlin-fbm", a = e.uniforms.gain, o = e.uniforms.scale;
+		if (e.backend === "live") return { field: Je(t.mul(o), n, a, e.uniforms.lacunarity) };
+		let s = K(t.x, t.y), c = e.uniforms.antialias, l = Math.max(1, Math.round(e.tileRepeat ?? 1)), u = P(A((l > 1 ? o.div(k(l)) : o).add(.5)), k(1)), d = e.uniforms.aspect, f = P(A(u.mul(d).add(.5)), k(1));
+		if (i === "curl") {
+			let e = mt(s.mul(u), u, u);
+			return {
+				field: e.length(),
+				vector: e
+			};
+		}
+		if (i === "simplex") {
+			let e = u.add(L(u, k(2)));
+			return { field: tt(s, e, e, n, a, St, c, r) };
+		}
+		if (i === "gabor") {
+			let t = k(1).sub(e.uniforms.gaborAniso);
+			return { field: xt(s, u, e.uniforms.gaborFreq, t, e.uniforms.gaborOrient) };
+		}
+		let p = Ot[i];
+		return p ? { field: tt(s, i === "value" ? f : u, u, n, a, p, c, r) } : { field: et(s, f, u, n, a, c, r).mul(.5).add(.5) };
+	}
+}, Mt = 4294967295;
+function Nt(e) {
+	let t = ne(e.mul(K(141421356, 2718281828)));
+	return k(t.x.bitXor(t.y).mul(U(3141592653))).div(Mt);
+}
+function Pt(e) {
+	return j(k(52.9829189).mul(j(D(e, K(.06711056, .00583715)))));
+}
+function Ft(e) {
+	let t = U(e.x), n = U(e.y);
+	return k(t.mul(U(3242174889)).add(n.mul(U(2447445413)))).mul(te(-32));
+}
+function It(e) {
+	let t = k(0);
+	for (let n = 0; n < 9; n++) t = t.add(Nt(e.add(K(n % 3 - 1, Math.floor(n / 3) - 1))));
+	return k(.9).mul(k(1.125).mul(Nt(e)).sub(t.div(8))).add(.5);
+}
+var Lt = d(([e, t]) => {
+	let n = e.toVar(), r = t.toVar(), i = M(0).toVar();
+	for (let e = 256; e > 0; e >>= 1) {
+		let t = M(e), a = z(n.bitAnd(t).notEqual(M(0)), M(1), M(0)), o = z(r.bitAnd(t).notEqual(M(0)), M(1), M(0));
+		i.assign(i.add(t.mul(t).mul(a.shiftLeft(1).bitOr(a.bitXor(o)))));
+		let s = n.bitXor(r).mul(M(1).sub(o)).bitXor(M(e - 1).mul(a.bitAnd(M(1).sub(o))));
+		n.assign(n.bitXor(s)), r.assign(r.bitXor(s));
+	}
+	return i;
+});
+function Rt(e) {
+	let t = Lt(M(e.x), M(e.y));
+	return j(k(.6180339887498948).mul(k(t.mod(M(262144)))));
+}
+var zt = d(([e, t]) => {
+	let n = A(e).toVar(), r = e.sub(n);
+	n.x.assign(A(B(n.x.mul(51024)).mul(3104))), n.y.assign(A(B(n.y.mul(1324)).mul(554)));
+	let i = n.x.add(n.y);
+	r = r.mul(2).sub(1), r = r.mul(S(i)).add(K(r.y.negate(), r.x).mul(B(i))), r = r.add(B(n.x.sub(n.y))), r = r.mul(.5).add(.5);
+	let a = B(n.x.add(r.y.mul(3.1415))).add(B(n.y.add(r.y.mul(3.1415)))).mul(.2), o = f(r.x.sub(.5).add(a));
+	return o = k(.5).sub(o.mul(t)), o = V(-2, re(o).mul(1.5).add(16), o).mul(12), o.mul(r.y);
+});
+function Bt(e, t) {
+	let n = e, r = t, i = k(0);
+	for (let e = 0; e < 8; e++) i = P(i, zt(n, r)), n = K(n.x.sub(n.y.mul(.7)), n.x.mul(.7).add(n.y)).sub(12.31);
+	return i;
+}
+var Vt = {
+	type: "screen-noise",
+	nodeClass: "texture",
+	label: "Screen Noise",
+	inputs: [{
+		key: "coord",
+		kind: "vector"
+	}],
+	outputs: [{
+		key: "field",
+		kind: "float"
+	}],
+	params: [{
+		key: "noiseType",
+		label: "type",
+		type: "select",
+		options: [
+			"blue",
+			"hilbert-blue",
+			"ign",
+			"golden-ign",
+			"scratches"
+		],
+		default: "blue"
+	}, {
+		key: "resolution",
+		label: "resolution",
+		type: "float",
+		min: 16,
+		max: 2048,
+		step: 1,
+		default: 512
+	}],
+	build(e) {
+		let t = e.inputs.coord ?? e.coord, n = K(t.x, t.y), r = e.params.noiseType ?? "blue", i = n.mul(e.uniforms.resolution);
+		switch (r) {
+			case "hilbert-blue": return { field: Rt(A(i)) };
+			case "ign": return { field: Pt(A(i)) };
+			case "golden-ign": return { field: Ft(A(i)) };
+			case "scratches": return { field: Bt(n.mul(5), k(3)) };
+			default: return { field: It(A(i)) };
+		}
+	}
+}, Ht = {
+	type: "tileable-warp",
+	nodeClass: "vector",
+	label: "Tileable Warp",
+	inputs: [{
+		key: "coord",
+		kind: "vector"
+	}],
+	outputs: [{
+		key: "coord",
+		kind: "vector"
+	}],
+	params: [{
+		key: "amount",
+		label: "amount",
+		type: "float",
+		min: 0,
+		max: 1,
+		step: .01,
+		default: .15
+	}, {
+		key: "scale",
+		label: "scale",
+		type: "int",
+		min: 1,
+		max: 64,
+		step: 1,
+		default: 4
+	}],
+	build(e) {
+		let t = e.inputs.coord ?? e.coord, n = e.uniforms.amount;
+		if (e.backend === "live") {
+			let r = t.div(Math.max(1, Number(e.params.scale ?? 4))), i = se(r.add(q(11.3, 0, 0))), a = se(r.add(q(0, 47.7, 0))), o = se(r.add(q(0, 0, 93.1)));
+			return { coord: t.add(q(i, a, o).mul(n)) };
+		}
+		let r = Math.max(1, Math.round(Number(e.params.scale ?? 4))), i = K(t.x, t.y), a = K(r, r), o = $e(i.mul(r), a), s = $e(i.mul(r).add(K(5.2, 1.3)), a), c = i.add(K(o, s).mul(n));
+		return { coord: q(c.x, c.y, t.z) };
+	}
+}, Ut = 1 / 2147483648;
+function Wt(e, t, n) {
+	let r = e.mul(1664525).add(1013904223).toVar(), i = t.mul(1664525).add(1013904223).toVar(), a = n.mul(1664525).add(1013904223).toVar();
+	r.assign(r.add(i.mul(a))), i.assign(i.add(a.mul(r))), a.assign(a.add(r.mul(i))), r.assign(r.bitXor(r.shiftRight(16))), i.assign(i.bitXor(i.shiftRight(16))), a.assign(a.bitXor(a.shiftRight(16))), r.assign(r.add(i.mul(a))), i.assign(i.add(a.mul(r))), a.assign(a.add(r.mul(i)));
+	let o = M(2147483647);
+	return q(k(r.bitAnd(o)).mul(Ut), k(i.bitAnd(o)).mul(Ut), k(a.bitAnd(o)).mul(Ut));
+}
+function Gt(e, t) {
+	return e.sub(M(A(k(e).div(t))).mul(M(t)));
+}
+function Kt(e, t, n, r) {
+	return typeof r == "number" && r <= 0 ? Wt(e, t, n) : Wt(Gt(e, r), Gt(t, r), Gt(n, r));
+}
+function qt(e, t, n, r) {
+	let i = e.sub(t).abs();
+	if (n === 1) return i.x.add(i.y).add(i.z);
+	if (n === 2) return i.x.max(i.y.max(i.z));
+	if (n === 3) {
+		let e = r;
+		return R(R(i.x, e).add(R(i.y, e)).add(R(i.z, e)), k(1).div(e));
+	}
+	return e.sub(t).length();
+}
+function Jt(e, t, n, r, i, a) {
+	return d(() => {
+		let o = A(e), s = e.sub(o), c = M(o.x), l = M(o.y), u = M(o.z), d = k(1e10).toVar(), f = q(0, 0, 0).toVar(), p = q(0, 0, 0).toVar();
+		for (let e = -1; e <= 1; e++) for (let i = -1; i <= 1; i++) for (let o = -1; o <= 1; o++) {
+			let m = q(o, i, e), h = m.add(Kt(c.add(o), l.add(i), u.add(e), a).mul(t)), g = qt(h, s, n, r), _ = g.lessThan(d);
+			d.assign(_.select(g, d)), f.assign(_.select(m, f)), p.assign(_.select(h, p));
+		}
+		return i === "color" ? Kt(c.add(M(f.x)), l.add(M(f.y)), u.add(M(f.z)), a) : i === "position" ? p.add(o) : d;
+	})();
+}
+function Yt(e, t, n, r, i, a) {
+	return d(() => {
+		let o = A(e), s = e.sub(o), c = M(o.x), l = M(o.y), u = M(o.z), d = k(1e10).toVar(), f = k(1e10).toVar(), p = q(0, 0, 0).toVar(), m = q(0, 0, 0).toVar(), h = q(0, 0, 0).toVar(), g = q(0, 0, 0).toVar();
+		for (let e = -1; e <= 1; e++) for (let i = -1; i <= 1; i++) for (let o = -1; o <= 1; o++) {
+			let _ = q(o, i, e), v = _.add(Kt(c.add(o), l.add(i), u.add(e), a).mul(t)), y = qt(v, s, n, r), b = y.lessThan(d).toVar(), x = y.lessThan(f).toVar(), S = z(b, d, z(x, y, f)), C = z(b, p, z(x, _, m)), w = z(b, h, z(x, v, g)), T = z(b, y, d), E = z(b, _, p), ee = z(b, v, h);
+			f.assign(S), m.assign(C), g.assign(w), d.assign(T), p.assign(E), h.assign(ee);
+		}
+		return i === "color" ? Kt(c.add(M(m.x)), l.add(M(m.y)), u.add(M(m.z)), a) : i === "position" ? g.add(o) : f;
+	})();
+}
+var Xt = 1;
+function Zt(e, t, n, r, i, a, o) {
+	return d(() => {
+		let s = A(e), c = e.sub(s), l = M(s.x), u = M(s.y), d = M(s.z), f = P(i, k(1e-6)), p = k(0).toVar(), m = q(0, 0, 0).toVar(), h = q(0, 0, 0).toVar(), g = k(-1).toVar();
+		for (let e = -1; e <= Xt; e++) for (let i = -1; i <= Xt; i++) for (let a = -1; a <= Xt; a++) {
+			let s = q(a, i, e), _ = Kt(l.add(a), u.add(i), d.add(e), o), v = s.add(_.mul(t)), y = qt(v, c, n, r);
+			g.assign(z(g.equal(-1), k(1), V(0, 1, k(.5).add(p.sub(y).mul(.5).div(f)))));
+			let b = f.mul(g).mul(k(1).sub(g)).toVar();
+			p.assign(I(p, y, g).sub(b)), b.assign(b.div(k(1).add(f.mul(3)))), m.assign(I(m, _, g).sub(b)), h.assign(I(h, v, g).sub(b));
+		}
+		return a === "color" ? m : a === "position" ? h.add(s) : p;
+	})();
+}
+var Qt = (e, t, n, r, i = 0) => Jt(e, t, n, r, "distance", i), $t = (e, t, n, r, i = 0) => Jt(e, t, n, r, "color", i), en = (e, t, n, r, i = 0) => Jt(e, t, n, r, "position", i), tn = (e, t, n, r, i = 0) => Yt(e, t, n, r, "distance", i), nn = (e, t, n, r, i = 0) => Yt(e, t, n, r, "color", i), rn = (e, t, n, r, i = 0) => Yt(e, t, n, r, "position", i), an = (e, t, n, r, i, a = 0) => Zt(e, t, n, r, i, "distance", a), on = (e, t, n, r, i, a = 0) => Zt(e, t, n, r, i, "color", a), sn = (e, t, n, r, i, a = 0) => Zt(e, t, n, r, i, "position", a);
+function cn(e, t, n = 0) {
+	return d(() => {
+		let r = A(e), i = e.sub(r), a = M(r.x), o = M(r.y), s = M(r.z), c = (e, r, c) => q(e, r, c).add(Kt(a.add(e), o.add(r), s.add(c), n).mul(t)).sub(i), l = q(0, 0, 0).toVar(), u = k(1e10).toVar();
+		for (let e = -1; e <= 1; e++) for (let t = -1; t <= 1; t++) for (let n = -1; n <= 1; n++) {
+			let r = c(n, t, e), i = r.dot(r), a = i.lessThan(u);
+			u.assign(a.select(i, u)), l.assign(a.select(r, l));
+		}
+		let d = k(1e10).toVar();
+		for (let e = -1; e <= 1; e++) for (let t = -1; t <= 1; t++) for (let n = -1; n <= 1; n++) {
+			let r = c(n, t, e), i = r.sub(l), a = i.dot(i).greaterThan(1e-4), o = l.add(r).div(2).dot(i.normalize());
+			d.assign(a.select(d.min(o), d));
+		}
+		return d;
+	})();
+}
+//#endregion
+//#region src/tsl/lloyd-points.ts
+function ln(e, t, n) {
+	let r = Math.imul(e, 374761393) + Math.imul(t, 668265263) + Math.imul(n, 362437) >>> 0;
+	r = Math.imul(r ^ r >>> 13, 1274126177) >>> 0;
+	let i = (r & 65535) / 65536;
+	return r = Math.imul(r ^ r >>> 16, 2246822519) >>> 0, [i, (r >>> 8 & 65535) / 65536];
+}
+function un(e, t, n) {
+	let r = e - t;
+	return r -= n * Math.round(r / n), r;
+}
+function dn(e, t, n, r = 0) {
+	let i = e * e, a = new Float64Array(i), o = new Float64Array(i);
+	for (let n = 0; n < e; n++) for (let i = 0; i < e; i++) {
+		let [s, c] = ln(i, n, r), l = n * e + i;
+		a[l] = i + .5 + (s - .5) * t, o[l] = n + .5 + (c - .5) * t;
+	}
+	let s = Math.max(64, e * 24);
+	for (let t = 0; t < n; t++) {
+		let t = new Float64Array(i), n = new Float64Array(i), r = new Float64Array(i);
+		for (let i = 0; i < s; i++) {
+			let c = (i + .5) / s * e, l = Math.floor(c);
+			for (let i = 0; i < s; i++) {
+				let u = (i + .5) / s * e, d = Math.floor(u), f = Infinity, p = 0;
+				for (let t = -1; t <= 1; t++) for (let n = -1; n <= 1; n++) {
+					let r = ((d + n) % e + e) % e, i = ((l + t) % e + e) % e * e + r, s = un(a[i], u, e), m = un(o[i], c, e), h = s * s + m * m;
+					h < f && (f = h, p = i);
+				}
+				t[p] += a[p] + un(u, a[p], e), n[p] += o[p] + un(c, o[p], e), r[p]++;
+			}
+		}
+		for (let s = 0; s < i; s++) r[s] > 0 && (a[s] = (t[s] / r[s] % e + e) % e, o[s] = (n[s] / r[s] % e + e) % e);
+	}
+	let c = new Float32Array(i * 3);
+	for (let t = 0; t < e; t++) for (let n = 0; n < e; n++) {
+		let r = t * e + n, i = a[r] - n, s = o[r] - t;
+		i -= e * Math.round(i / e), s -= e * Math.round(s / e), c[r * 3 + 0] = i, c[r * 3 + 1] = s, c[r * 3 + 2] = 0;
+	}
+	return c;
+}
+//#endregion
+//#region src/tsl/relaxed-voronoi.ts
+function fn(e, t) {
+	return d(() => {
+		let n = A(e), r = e.sub(n), i = M(n.x), a = M(n.y), o = (e, n) => q(e, n, 0).add(t(i.add(e), a.add(n))).sub(r), s = q(0, 0, 0).toVar(), c = k(1e10).toVar();
+		for (let e = -1; e <= 1; e++) for (let t = -1; t <= 1; t++) {
+			let n = o(t, e), r = n.dot(n), i = r.lessThan(c);
+			c.assign(i.select(r, c)), s.assign(i.select(n, s));
+		}
+		let l = k(1e10).toVar();
+		for (let e = -1; e <= 1; e++) for (let t = -1; t <= 1; t++) {
+			let n = o(t, e), r = n.sub(s), i = r.dot(r).greaterThan(1e-4), a = s.add(n).div(2).dot(r.normalize());
+			l.assign(i.select(l.min(a), l));
+		}
+		return l;
+	})();
+}
+function pn(e, t, n) {
+	return d(() => {
+		let r = A(e), i = e.sub(r), a = M(r.x), o = M(r.y), s = (e, n) => q(e, n, 0).add(t(a.add(e), o.add(n))).sub(i), c = k(1e10).toVar(), l = M(0).toVar(), u = M(0).toVar();
+		for (let e = -1; e <= 1; e++) for (let t = -1; t <= 1; t++) {
+			let n = s(t, e), r = n.dot(n), i = r.lessThan(c);
+			c.assign(i.select(r, c)), l.assign(i.select(a.add(t), l)), u.assign(i.select(o.add(e), u));
+		}
+		return n(l, u);
+	})();
+}
+//#endregion
+//#region src/graph/nodes/texture/voronoi.ts
+var mn = [
+	"euclidean",
+	"manhattan",
+	"chebychev",
+	"minkowski"
+], hn = [
+	"f1",
+	"f2",
+	"smooth-f1",
+	"distance-to-edge"
+], gn = [
+	{
+		key: "distance",
+		label: "Distance",
+		kind: "float"
+	},
+	{
+		key: "color",
+		label: "Color",
+		kind: "color"
+	},
+	{
+		key: "position",
+		label: "Position",
+		kind: "vector"
+	}
+], _n = [{
+	key: "distance",
+	label: "Distance",
+	kind: "float"
+}, {
+	key: "random",
+	label: "Random",
+	kind: "float"
+}], vn = [{
+	key: "coord",
+	kind: "vector"
+}];
+function yn(e) {
+	let t = Array(e);
+	for (let n = 0; n < e; n++) {
+		let e = Math.sin(n * 12.9898 + 78.233) * 43758.5453;
+		t[n] = e - Math.floor(e);
+	}
+	return t;
+}
+var bn = {
+	type: "voronoi",
+	nodeClass: "texture",
+	label: "Voronoi",
+	inputs: vn,
+	outputs: gn,
+	params: [
+		{
+			key: "scale",
+			label: "scale",
+			type: "float",
+			min: .1,
+			max: 64,
+			step: .05,
+			default: 1
+		},
+		{
+			key: "randomness",
+			label: "randomness",
+			type: "float",
+			min: 0,
+			max: 1,
+			step: .01,
+			default: 1
+		},
+		{
+			key: "metric",
+			label: "metric",
+			type: "select",
+			options: mn,
+			default: "euclidean"
+		},
+		{
+			key: "feature",
+			label: "feature",
+			type: "select",
+			options: hn,
+			default: "f1"
+		},
+		{
+			key: "exponent",
+			label: "exponent",
+			type: "float",
+			min: .1,
+			max: 8,
+			step: .1,
+			default: 2
+		},
+		{
+			key: "smoothness",
+			label: "smoothness",
+			type: "float",
+			min: 0,
+			max: 1,
+			step: .01,
+			default: .25
+		},
+		{
+			key: "relax",
+			label: "relax",
+			type: "int",
+			min: 0,
+			max: 5,
+			step: 1,
+			default: 0
+		}
+	],
+	declare(e) {
+		return {
+			inputs: vn,
+			outputs: (e.feature ?? "f1") === "distance-to-edge" ? _n : gn
+		};
+	},
+	paramsFor(e) {
+		let t = e.metric ?? "euclidean", n = e.feature ?? "f1", r = new Set([
+			"scale",
+			"randomness",
+			"metric",
+			"feature"
+		]);
+		return t === "minkowski" && r.add("exponent"), n === "smooth-f1" && r.add("smoothness"), n === "distance-to-edge" && r.add("relax"), bn.params.filter((e) => r.has(e.key));
+	},
+	build(e) {
+		let t = e.backend === "offline", n = Math.max(0, mn.indexOf(e.params.metric)), r = e.uniforms.randomness, i = e.uniforms.exponent, a = e.uniforms.smoothness, s = e.params.feature ?? "f1", c = e.inputs.coord ?? e.coord, l = Math.max(0, Math.round(Number(e.params.relax ?? 0)));
+		if (s === "distance-to-edge" && t && l > 0) {
+			let t = Math.max(1, Math.round(Number(e.params.scale ?? 1))), n = c.mul(t), r = dn(t, Number(e.params.randomness ?? 1), l), i = [];
+			for (let e = 0; e < t * t; e++) i.push(new o(r[e * 3], r[e * 3 + 1], r[e * 3 + 2]));
+			let a = De(i), s = (e) => e.sub(M(A(k(e).div(t))).mul(M(t))), u = (e, n) => a.element(s(n).mul(t).add(s(e))), d = De(yn(t * t));
+			return {
+				distance: fn(n, u),
+				random: pn(n, u, (e, n) => d.element(s(n).mul(t).add(s(e))))
+			};
+		}
+		let u = e.uniforms.scale, d = P(A(u.add(.5)), k(1)), f = c.mul(t ? d : u), p = t ? d : 0;
+		switch (s) {
+			case "distance-to-edge": return {
+				distance: cn(f, r, p),
+				random: $t(f, r, n, i, p).x
+			};
+			case "f2": return {
+				distance: tn(f, r, n, i, p),
+				color: nn(f, r, n, i, p),
+				position: rn(f, r, n, i, p)
+			};
+			case "smooth-f1": return {
+				distance: an(f, r, n, i, a, p),
+				color: on(f, r, n, i, a, p),
+				position: sn(f, r, n, i, a, p)
+			};
+			default: return {
+				distance: Qt(f, r, n, i, p),
+				color: $t(f, r, n, i, p),
+				position: en(f, r, n, i, p)
+			};
+		}
+	}
+}, xn = {
+	type: "checker",
+	nodeClass: "texture",
+	label: "Checker",
+	inputs: [
+		{
+			key: "coord",
+			kind: "vector"
+		},
+		{
+			key: "color1",
+			label: "Color1",
+			kind: "color"
+		},
+		{
+			key: "color2",
+			label: "Color2",
+			kind: "color"
+		}
+	],
+	outputs: [{
+		key: "color",
+		kind: "color"
+	}, {
+		key: "fac",
+		label: "Fac",
+		kind: "float"
+	}],
+	params: [
+		{
+			key: "color1",
+			label: "color1",
+			type: "color",
+			default: "#c4201e"
+		},
+		{
+			key: "color2",
+			label: "color2",
+			type: "color",
+			default: "#18b6b6"
+		},
+		{
+			key: "scale",
+			label: "scale",
+			type: "float",
+			min: .5,
+			max: 32,
+			step: .5,
+			default: 4
+		}
+	],
+	build(e) {
+		let t = (e.inputs.coord ?? e.coord).mul(e.uniforms.scale), n = L(A(t.x).add(A(t.y)).add(A(t.z)), 2).lessThan(1);
+		return {
+			color: z(n, e.inputs.color1 ?? e.uniforms.color1, e.inputs.color2 ?? e.uniforms.color2),
+			fac: z(n, k(1), k(0))
+		};
+	}
+}, Sn = 6.283185307179586;
+function Cn(e, t, n) {
+	let { columns: r, rows: i, offsetFreq: a } = t, o = d(() => {
+		let t = K(e.x.mul(r), e.y.mul(i)), o = A(t.y), s = k(-1e9).toVar(), c = k(0).toVar();
+		for (let e = -1; e <= 1; e++) {
+			let l = o.add(e), u = M(l), d = z(L(l, k(a)).notEqual(0), n.rowOffset, k(0)), p = A(t.x.sub(d));
+			for (let e = -1; e <= 1; e++) {
+				let a = p.add(e), o = M(a), m = st(o, u, 0, r, i), h = st(o, u, 1, r, i), g = m.x.sub(.5).mul(n.posRandom), _ = m.y.sub(.5).mul(n.posRandom), v = a.add(.5).add(d).add(g), y = l.add(.5).add(_), b = t.x.sub(v).div(r), x = t.y.sub(y).div(i), C = h.x.sub(.5).mul(2).mul(n.rotRandom).mul(Sn * .5).negate(), w = S(C), T = B(C), E = w.mul(b).sub(T.mul(x)), ee = T.mul(b).add(w.mul(x)), D = k(1).add(m.z.sub(.5).mul(2).mul(n.sizeRandom)), O = k(.5).div(r).mul(D).sub(n.gap), te = k(.5).div(i).mul(D).sub(n.gap), ne = n.roundness.mul(F(O, te)), A = f(E).sub(O.sub(ne)), j = f(ee).sub(te.sub(ne)), re = N(K(P(A, 0), P(j, 0))), ie = F(P(A, j), 0), ae = re.add(ie).sub(ne).negate(), oe = ae.greaterThan(s);
+				c.assign(z(oe, h.y, c)), s.assign(z(oe, ae, s));
+			}
+		}
+		return K(V(0, n.edge.add(1e-5), s), c);
+	})();
+	return {
+		mask: o.x,
+		value: o.y
+	};
+}
+function wn(e, t, n, r, i) {
+	let a = t, o = n, s = d(() => {
+		let t = K(e.x.mul(a), e.y.mul(o)), n = A(t.y), s = k(1e9).toVar(), c = k(0).toVar(), l = k(0).toVar(), u = k(0).toVar();
+		for (let r = -1; r <= 1; r++) {
+			let i = n.add(r), d = z(L(i, k(2)).notEqual(0), k(.5), k(0)), f = A(t.x.sub(d));
+			for (let t = -1; t <= 1; t++) {
+				let n = f.add(t), r = n.add(.5).add(d).div(a), p = i.add(.5).div(o), m = N(K(e.x.sub(r), e.y.sub(p))), h = m.lessThan(s);
+				s.assign(z(h, m, s)), c.assign(z(h, r, c)), l.assign(z(h, p, l)), u.assign(z(h, at(M(n), M(i), a, o), u));
+			}
+		}
+		let d = k(1e9).toVar();
+		for (let r = -1; r <= 1; r++) {
+			let i = n.add(r), s = z(L(i, k(2)).notEqual(0), k(.5), k(0)), u = A(t.x.sub(s));
+			for (let t = -1; t <= 1; t++) {
+				let n = u.add(t).add(.5).add(s).div(a), r = i.add(.5).div(o), f = n.sub(c), p = r.sub(l), m = N(K(f, p)).add(1e-9), h = c.add(n).mul(.5), g = l.add(r).mul(.5), _ = h.sub(e.x).mul(f.div(m)).add(g.sub(e.y).mul(p.div(m))), v = m.lessThan(1e-4);
+				d.assign(F(d, z(v, k(1e9), _)));
+			}
+		}
+		return K(V(r, r.add(i).add(1e-5), d), u);
+	})();
+	return {
+		mask: s.x,
+		value: s.y
+	};
+}
+var Tn = {
+	type: "tile",
+	nodeClass: "texture",
+	label: "Tile Generator",
+	inputs: [{
+		key: "coord",
+		kind: "vector"
+	}],
+	outputs: [{
+		key: "mask",
+		label: "Mask",
+		kind: "float"
+	}, {
+		key: "value",
+		label: "Value",
+		kind: "float"
+	}],
+	params: [
+		{
+			key: "lattice",
+			label: "lattice",
+			type: "select",
+			options: ["square", "hex"],
+			default: "square"
+		},
+		{
+			key: "columns",
+			label: "columns",
+			type: "int",
+			min: 1,
+			max: 32,
+			step: 1,
+			default: 6
+		},
+		{
+			key: "rows",
+			label: "rows",
+			type: "int",
+			min: 1,
+			max: 64,
+			step: 1,
+			default: 12
+		},
+		{
+			key: "offset",
+			label: "row offset",
+			type: "float",
+			min: 0,
+			max: 1,
+			step: .01,
+			default: .5
+		},
+		{
+			key: "offsetFreq",
+			label: "offset every",
+			type: "int",
+			min: 1,
+			max: 6,
+			step: 1,
+			default: 2
+		},
+		{
+			key: "gap",
+			label: "gap",
+			type: "float",
+			min: 0,
+			max: .08,
+			step: .001,
+			default: .012
+		},
+		{
+			key: "roundness",
+			label: "roundness",
+			type: "float",
+			min: 0,
+			max: 1,
+			step: .01,
+			default: .05
+		},
+		{
+			key: "edge",
+			label: "edge soft",
+			type: "float",
+			min: 0,
+			max: .05,
+			step: .001,
+			default: .004
+		},
+		{
+			key: "sizeRandom",
+			label: "size rand",
+			type: "float",
+			min: 0,
+			max: 1,
+			step: .01,
+			default: 0
+		},
+		{
+			key: "posRandom",
+			label: "pos rand",
+			type: "float",
+			min: 0,
+			max: 1,
+			step: .01,
+			default: 0
+		},
+		{
+			key: "rotRandom",
+			label: "rot rand",
+			type: "float",
+			min: 0,
+			max: 1,
+			step: .01,
+			default: 0
+		}
+	],
+	build(e) {
+		let t = e.inputs.coord ?? e.coord, n = Math.max(1, Math.round(Number(e.params.columns ?? 6)));
+		if (e.params.lattice === "hex") {
+			let { mask: r, value: i } = wn(t, n, Math.max(2, Math.round(n * 2 / Math.sqrt(3) / 2) * 2), e.uniforms.gap, e.uniforms.edge);
+			return {
+				mask: r,
+				value: i
+			};
+		}
+		let r = Math.max(1, Math.round(Number(e.params.offsetFreq ?? 2))), i = Math.max(1, Math.round(Number(e.params.rows ?? 12))), { mask: a, value: o } = Cn(t, {
+			columns: n,
+			rows: Math.ceil(i / r) * r,
+			offsetFreq: r
+		}, {
+			rowOffset: e.uniforms.offset,
+			gap: e.uniforms.gap,
+			roundness: e.uniforms.roundness,
+			edge: e.uniforms.edge,
+			sizeRandom: e.uniforms.sizeRandom,
+			posRandom: e.uniforms.posRandom,
+			rotRandom: e.uniforms.rotRandom
+		});
+		return {
+			mask: a,
+			value: o
+		};
+	}
+}, En = Math.PI;
+function Dn(e, t, n) {
+	let r = t, i = d(() => {
+		let t = K(e.x.mul(r), e.y.mul(r)), i = A(t.x), a = A(t.y), o = k(1e9).toVar(), s = k(10).toVar(), c = k(10).toVar(), l = k(0).toVar(), u = k(1).toVar();
+		for (let e = -1; e <= 1; e++) {
+			let d = a.add(e), f = M(d);
+			for (let e = -1; e <= 1; e++) {
+				let a = i.add(e), p = M(a), m = st(p, f, 0, r, r), h = st(p, f, 1, r, r), g = h.z.lessThan(n.amount), _ = k(1).add(m.z.sub(.5).mul(2).mul(n.sizeRandom)), v = n.radius.div(r).mul(_), y = m.x.sub(.5).mul(n.posRandom), b = m.y.sub(.5).mul(n.posRandom), x = a.add(.5).add(y), C = d.add(.5).add(b), w = t.x.sub(x).div(r), T = t.y.sub(C).div(r), E = z(g, N(K(w, T)), k(1e9)), ee = h.x.sub(.5).mul(2).mul(n.rotRandom).mul(En).negate(), D = S(ee), O = B(ee), te = D.mul(w).sub(O.mul(T)).div(v.add(1e-9)), ne = O.mul(w).add(D.mul(T)).div(v.add(1e-9)), A = E.lessThan(o);
+				s.assign(z(A, te, s)), c.assign(z(A, ne, c)), l.assign(z(A, h.y, l)), u.assign(z(A, _, u)), o.assign(z(A, E, o));
+			}
+		}
+		return Oe(s, c, l, u);
+	})();
+	return {
+		coord: q(i.x, i.y, 0),
+		value: i.z,
+		size: i.w
+	};
+}
+//#endregion
+//#region src/graph/nodes/texture/scatter.ts
+var On = {
+	type: "scatter",
+	nodeClass: "texture",
+	label: "Scatter",
+	inputs: [{
+		key: "coord",
+		kind: "vector"
+	}],
+	outputs: [
+		{
+			key: "coord",
+			label: "Coord",
+			kind: "vector"
+		},
+		{
+			key: "value",
+			label: "Value",
+			kind: "float"
+		},
+		{
+			key: "size",
+			label: "Size",
+			kind: "float"
+		}
+	],
+	params: [
+		{
+			key: "density",
+			label: "density",
+			type: "int",
+			min: 1,
+			max: 48,
+			step: 1,
+			default: 10
+		},
+		{
+			key: "amount",
+			label: "amount",
+			type: "float",
+			min: 0,
+			max: 1,
+			step: .01,
+			default: .5
+		},
+		{
+			key: "radius",
+			label: "radius",
+			type: "float",
+			min: .05,
+			max: 1,
+			step: .01,
+			default: .4
+		},
+		{
+			key: "sizeRandom",
+			label: "size rand",
+			type: "float",
+			min: 0,
+			max: 1,
+			step: .01,
+			default: .6
+		},
+		{
+			key: "posRandom",
+			label: "pos rand",
+			type: "float",
+			min: 0,
+			max: 1,
+			step: .01,
+			default: .85
+		},
+		{
+			key: "rotRandom",
+			label: "rot rand",
+			type: "float",
+			min: 0,
+			max: 1,
+			step: .01,
+			default: 1
+		}
+	],
+	build(e) {
+		let t = e.inputs.coord ?? e.coord, n = Math.round(Number(e.params.density ?? 10)), { coord: r, value: i, size: a } = Dn(t, Number.isFinite(n) ? Math.max(1, n) : 10, {
+			amount: e.uniforms.amount,
+			radius: e.uniforms.radius,
+			sizeRandom: e.uniforms.sizeRandom,
+			posRandom: e.uniforms.posRandom,
+			rotRandom: e.uniforms.rotRandom
+		});
+		return {
+			coord: r,
+			value: i,
+			size: a
+		};
+	}
+}, kn = 6.283185307179586;
+function An(e, t, n, r, i) {
+	let a = r ?? k(0), o = d(() => {
+		let r = N(K(e.x, e.y)), o = h(e.y, e.x), s, c;
+		if (t === "polygon") {
+			let e = Math.max(3, Math.round(n)), t = kn / e, a = S(A(o.div(t).add(.5)).mul(t).sub(o)).mul(r), l = Math.cos(Math.PI / e), u = b(a.div(l), 0, 1);
+			s = V(0, i.edge.add(1e-4), u.oneMinus()), c = u.oneMinus();
+		} else {
+			let e = j(a.mul(13.13)).mul(kn), t = j(a.mul(27.71)).mul(kn), n = j(a.mul(51.37)).mul(kn), l = B(o.mul(2).add(e)).mul(.5).add(B(o.mul(3).add(t)).mul(.3)).add(B(o.mul(5).add(n)).mul(.2)), u = k(1).add(l.mul(i.irregularity.mul(.4))), d = b(r.div(u.add(1e-6)), 0, 1);
+			s = V(0, i.edge.add(1e-4), d.oneMinus()), c = d.oneMinus();
+		}
+		let l = b(r, 0, 1), u = R(b(l.mul(l).oneMinus(), 0, 1), i.dome), d = V(0, .3, c), f = u.mul(d);
+		return q(s, f, 0);
+	})();
+	return {
+		mask: o.x,
+		height: o.y
+	};
+}
+var jn = {
+	type: "shape",
+	nodeClass: "texture",
+	label: "Shape",
+	inputs: [{
+		key: "coord",
+		kind: "vector"
+	}, {
+		key: "seed",
+		label: "Seed",
+		kind: "float"
+	}],
+	outputs: [{
+		key: "mask",
+		label: "Mask",
+		kind: "float"
+	}, {
+		key: "height",
+		label: "Height",
+		kind: "float"
+	}],
+	params: [
+		{
+			key: "shape",
+			label: "shape",
+			type: "select",
+			options: ["blob", "polygon"],
+			default: "blob"
+		},
+		{
+			key: "sides",
+			label: "sides",
+			type: "int",
+			min: 3,
+			max: 12,
+			step: 1,
+			default: 6
+		},
+		{
+			key: "irregularity",
+			label: "irregularity",
+			type: "float",
+			min: 0,
+			max: 1,
+			step: .01,
+			default: .6
+		},
+		{
+			key: "dome",
+			label: "dome",
+			type: "float",
+			min: .2,
+			max: 3,
+			step: .05,
+			default: .6
+		},
+		{
+			key: "edge",
+			label: "edge soft",
+			type: "float",
+			min: .002,
+			max: .3,
+			step: .002,
+			default: .04
+		}
+	],
+	build(e) {
+		let t = e.inputs.coord ?? e.coord, n = e.inputs.seed, r = e.params.shape ?? "blob", i = Math.round(Number(e.params.sides ?? 6)), { mask: a, height: o } = An(t, r, Number.isFinite(i) ? Math.max(3, i) : 6, n ?? null, {
+			irregularity: e.uniforms.irregularity,
+			dome: e.uniforms.dome,
+			edge: e.uniforms.edge
+		});
+		return {
+			mask: a,
+			height: o
+		};
+	}
+}, Mn = Math.PI * 2;
+function Nn(e, t) {
+	let n = e.x, r = e.y, i = e.z, a;
+	switch (t) {
+		case 1: {
+			let e = n.max(0);
+			a = e.mul(e);
+			break;
+		}
+		case 2: {
+			let e = n.clamp(0, 1), t = e.mul(e);
+			a = t.mul(3).sub(t.mul(e).mul(2));
+			break;
+		}
+		case 3:
+			a = n.add(r).mul(.5);
+			break;
+		case 4:
+			a = h(r, n).div(Mn).add(.5);
+			break;
+		case 5: {
+			let e = k(.999999).sub(n.mul(n).add(r.mul(r)).add(i.mul(i)).sqrt()).max(0);
+			a = e.mul(e);
+			break;
+		}
+		case 6:
+			a = k(.999999).sub(n.mul(n).add(r.mul(r)).add(i.mul(i)).sqrt()).max(0);
+			break;
+		default: a = n;
+	}
+	return a.clamp(0, 1);
+}
+//#endregion
+//#region src/graph/nodes/texture/gradient.ts
+var Pn = [
+	"linear",
+	"quadratic",
+	"easing",
+	"diagonal",
+	"radial",
+	"quadratic-sphere",
+	"sphere"
+], Fn = {
+	type: "gradient",
+	nodeClass: "texture",
+	label: "Gradient",
+	inputs: [{
+		key: "coord",
+		kind: "vector"
+	}],
+	outputs: [{
+		key: "field",
+		kind: "float"
+	}],
+	params: [{
+		key: "scale",
+		label: "scale",
+		type: "float",
+		min: .1,
+		max: 8,
+		step: .05,
+		default: 1
+	}, {
+		key: "gradientType",
+		label: "type",
+		type: "select",
+		options: Pn,
+		default: "linear"
+	}],
+	build(e) {
+		return { field: Nn((e.inputs.coord ?? e.coord).mul(e.uniforms.scale), Math.max(0, Pn.indexOf(e.params.gradientType))) };
+	}
+}, X = Math.PI * 2, In = Math.PI / 2, Ln = 20, Rn = 10;
+function zn(e, t) {
+	if (t === 0) return k(.5).add(B(e.sub(In)).mul(.5));
+	if (t === 1) {
+		let t = e.div(X);
+		return t.sub(A(t));
+	}
+	let n = e.div(X);
+	return n.sub(A(n.add(.5))).abs().mul(2);
+}
+function Bn(e, t, n, r, i) {
+	let a = Math.max(1, Math.round(i.scaleNum * Ln / X)), o = Math.max(1, Math.round(i.scaleNum * Rn / X)), s;
+	if (s = i.dir === 0 ? e.x.mul(a * X) : i.dir === 1 ? e.y.mul(a * X) : i.dir === 2 ? e.z.mul(a * X) : e.x.add(e.y).add(e.z).mul(o * X), s = s.add(t), i.withDistortion) {
+		let t = Math.max(1, Math.round(i.scaleNum * i.detailScaleNum)), a = t, o = t;
+		i.dir === 0 ? o = 2 : i.dir === 1 && (a = 2);
+		let c = et(K(e.x, e.y), a, o, Math.max(1, i.detail), r);
+		s = s.add(n.mul(c));
+	}
+	return zn(s, i.profile);
+}
+function Vn(e, t, n, r, i, a) {
+	let o = (e) => e.sub(_e(e)), s;
+	s = a.dir === 0 ? q(k(0), o(e.y), o(e.z)) : a.dir === 1 ? q(o(e.x), k(0), o(e.z)) : a.dir === 2 ? q(o(e.x), o(e.y), k(0)) : q(o(e.x), o(e.y), o(e.z));
+	let c = s.length().mul(t).mul(Ln).add(n);
+	if (a.withDistortion) {
+		let t = Math.max(1, Math.round(a.scaleNum * a.detailScaleNum)), n = et(K(e.x, e.y), t, t, Math.max(1, a.detail), i);
+		c = c.add(r.mul(n));
+	}
+	return zn(c, a.profile);
+}
+function Hn(e, t, n, r, i, a, o) {
+	if (o.tileable) return o.waveType === 0 ? Bn(e, n, r, a, o) : Vn(e, t, n, r, a, o);
+	let s = e.mul(t).add(1e-6).mul(.999999), c;
+	if (o.waveType === 0) c = o.dir === 0 ? s.x.mul(Ln) : o.dir === 1 ? s.y.mul(Ln) : o.dir === 2 ? s.z.mul(Ln) : s.x.add(s.y).add(s.z).mul(Rn);
+	else {
+		let e = s;
+		o.dir === 0 ? e = s.mul(q(0, 1, 1)) : o.dir === 1 ? e = s.mul(q(1, 0, 1)) : o.dir === 2 && (e = s.mul(q(1, 1, 0))), c = e.length().mul(Ln);
+	}
+	if (c = c.add(n), o.withDistortion) {
+		let e = Je(s.mul(i), o.detail, a, k(2));
+		c = c.add(r.mul(e.mul(2).sub(1)));
+	}
+	return zn(c, o.profile);
+}
+//#endregion
+//#region src/graph/nodes/texture/wave.ts
+var Un = ["bands", "rings"], Wn = [
+	"x",
+	"y",
+	"z",
+	"diagonal"
+], Gn = [
+	"sine",
+	"saw",
+	"triangle"
+], Kn = {
+	type: "wave",
+	nodeClass: "texture",
+	label: "Wave",
+	inputs: [{
+		key: "coord",
+		kind: "vector"
+	}],
+	outputs: [{
+		key: "field",
+		kind: "float"
+	}],
+	params: [
+		{
+			key: "scale",
+			label: "scale",
+			type: "float",
+			min: .1,
+			max: 8,
+			step: .05,
+			default: 1,
+			bakeStructural: !0
+		},
+		{
+			key: "waveType",
+			label: "type",
+			type: "select",
+			options: Un,
+			default: "bands"
+		},
+		{
+			key: "direction",
+			label: "direction",
+			type: "select",
+			options: Wn,
+			default: "x"
+		},
+		{
+			key: "profile",
+			label: "profile",
+			type: "select",
+			options: Gn,
+			default: "sine"
+		},
+		{
+			key: "phase",
+			label: "phase",
+			type: "float",
+			min: 0,
+			max: 20,
+			step: .1,
+			default: 0
+		},
+		{
+			key: "distortion",
+			label: "distortion",
+			type: "float",
+			min: 0,
+			max: 10,
+			step: .1,
+			default: 0,
+			bakeStructural: !0
+		},
+		{
+			key: "detail",
+			label: "detail",
+			type: "int",
+			min: 0,
+			max: 8,
+			step: 1,
+			default: 2
+		},
+		{
+			key: "detailScale",
+			label: "detail scale",
+			type: "float",
+			min: 0,
+			max: 8,
+			step: .1,
+			default: 1,
+			bakeStructural: !0
+		},
+		{
+			key: "detailRoughness",
+			label: "detail rough",
+			type: "float",
+			min: 0,
+			max: 1,
+			step: .01,
+			default: .5
+		}
+	],
+	build(e) {
+		let t = e.inputs.coord ?? e.coord, n = {
+			waveType: Math.max(0, Un.indexOf(e.params.waveType)),
+			dir: Math.max(0, Wn.indexOf(e.params.direction)),
+			profile: Math.max(0, Gn.indexOf(e.params.profile)),
+			withDistortion: Number(e.params.distortion ?? 0) > 0,
+			detail: e.params.detail ?? 2,
+			tileable: e.backend === "offline",
+			scaleNum: Number(e.params.scale ?? 1),
+			detailScaleNum: Number(e.params.detailScale ?? 1)
+		};
+		return { field: Hn(t, e.uniforms.scale, e.uniforms.phase, e.uniforms.distortion, e.uniforms.detailScale, e.uniforms.detailRoughness, n) };
+	}
+}, qn = 6.283185307179586, Jn = {
+	type: "anisotropic-stripes",
+	nodeClass: "texture",
+	label: "Anisotropic Stripes",
+	inputs: [{
+		key: "coord",
+		kind: "vector"
+	}],
+	outputs: [{
+		key: "field",
+		kind: "float"
+	}],
+	params: [
+		{
+			key: "count",
+			label: "count",
+			type: "float",
+			min: 1,
+			max: 64,
+			step: 1,
+			default: 22
+		},
+		{
+			key: "sharpness",
+			label: "sharpness",
+			type: "float",
+			min: .2,
+			max: 8,
+			step: .1,
+			default: 2.2
+		},
+		{
+			key: "waviness",
+			label: "waviness",
+			type: "float",
+			min: 0,
+			max: 2,
+			step: .01,
+			default: .18
+		},
+		{
+			key: "contrast",
+			label: "contrast",
+			type: "float",
+			min: 0,
+			max: 1,
+			step: .01,
+			default: 1
+		}
+	],
+	build(e) {
+		let t = e.inputs.coord ?? e.coord, n = h(t.z, t.x).div(qn), r = se(q(t.y.mul(.6), n.mul(6), k(0))).mul(e.uniforms.waviness);
+		return { field: n.mul(e.uniforms.count).add(r).mul(qn).sin().mul(.5).add(.5).pow(e.uniforms.sharpness).mul(e.uniforms.contrast) };
+	}
+}, Yn = /* @__PURE__ */ "add.subtract.multiply.divide.multiply-add.power.logarithm.sqrt.inverse-sqrt.absolute.exponent.min.max.less-than.greater-than.sign.compare.smooth-min.smooth-max.round.floor.ceil.truncate.fraction.modulo.floored-modulo.wrap.snap.pingpong.sine.cosine.tangent.arcsine.arccosine.arctangent.arctan2.sinh.cosh.tanh.radians.degrees.mix".split("."), Xn = new Set([
+	"sqrt",
+	"inverse-sqrt",
+	"absolute",
+	"exponent",
+	"sign",
+	"round",
+	"floor",
+	"ceil",
+	"truncate",
+	"fraction",
+	"sine",
+	"cosine",
+	"tangent",
+	"arcsine",
+	"arccosine",
+	"arctangent",
+	"sinh",
+	"cosh",
+	"tanh",
+	"radians",
+	"degrees"
+]), Zn = new Set([
+	"multiply-add",
+	"compare",
+	"smooth-min",
+	"smooth-max",
+	"wrap"
+]), Qn = {
+	power: ["Base", "Exponent"],
+	logarithm: ["Value", "Base"],
+	"multiply-add": [
+		"Value",
+		"Multiplier",
+		"Addend"
+	],
+	compare: [
+		"A",
+		"B",
+		"Epsilon"
+	],
+	"smooth-min": [
+		"A",
+		"B",
+		"Distance"
+	],
+	"smooth-max": [
+		"A",
+		"B",
+		"Distance"
+	],
+	wrap: [
+		"Value",
+		"Max",
+		"Min"
+	],
+	snap: ["Value", "Increment"],
+	pingpong: ["Value", "Scale"],
+	radians: ["Degrees"],
+	degrees: ["Radians"]
+};
+function $n(e) {
+	let [t, n, r] = Qn[e] ?? [
+		"A",
+		"B",
+		"C"
+	], i = [{
+		key: "a",
+		label: t,
+		kind: "float"
+	}];
+	return Xn.has(e) || i.push({
+		key: "b",
+		label: n ?? "B",
+		kind: "float"
+	}), Zn.has(e) && i.push({
+		key: "c",
+		label: r ?? "C",
+		kind: "float"
+	}), i;
+}
+var er = {
+	type: "math",
+	nodeClass: "converter",
+	label: "Math",
+	inputs: [{
+		key: "a",
+		label: "A",
+		kind: "float"
+	}, {
+		key: "b",
+		label: "B",
+		kind: "float"
+	}],
+	outputs: [{
+		key: "field",
+		kind: "float"
+	}],
+	params: [
+		{
+			key: "op",
+			label: "op",
+			type: "select",
+			options: Yn,
+			default: "mix"
+		},
+		{
+			key: "factor",
+			label: "factor / B",
+			type: "float",
+			min: 0,
+			max: 1,
+			step: .01,
+			default: .5
+		},
+		{
+			key: "c",
+			label: "C",
+			type: "float",
+			min: 0,
+			max: 1,
+			step: .01,
+			default: .5
+		}
+	],
+	declare(e) {
+		return {
+			inputs: $n(e.op ?? "mix"),
+			outputs: [{
+				key: "field",
+				kind: "float"
+			}]
+		};
+	},
+	build(e) {
+		let t = e.inputs.a ?? k(0), n = e.inputs.b ?? e.uniforms.factor, r = e.inputs.c ?? e.uniforms.c;
+		switch (e.params.op) {
+			case "add": return { field: t.add(n) };
+			case "subtract": return { field: t.sub(n) };
+			case "multiply": return { field: t.mul(n) };
+			case "divide": return { field: z(n.equal(0), k(0), t.div(n)) };
+			case "multiply-add": return { field: t.mul(n).add(r) };
+			case "power": return { field: R(t, n) };
+			case "logarithm": return { field: z(t.greaterThan(0).and(n.greaterThan(0)), ae(t).div(ae(n)), k(0)) };
+			case "sqrt": return { field: Se(t) };
+			case "inverse-sqrt": return { field: z(t.greaterThan(0), ie(t), k(0)) };
+			case "absolute": return { field: f(t) };
+			case "exponent": return { field: O(t) };
+			case "min": return { field: F(t, n) };
+			case "max": return { field: P(t, n) };
+			case "less-than": return { field: z(t.lessThan(n), k(1), k(0)) };
+			case "greater-than": return { field: z(t.greaterThan(n), k(1), k(0)) };
+			case "sign": return { field: be(t) };
+			case "compare": return { field: z(t.sub(n).abs().lessThanEqual(P(r, k(1e-5))), k(1), k(0)) };
+			case "smooth-min": return { field: tr(t, n, r) };
+			case "smooth-max": return { field: tr(t.negate(), n.negate(), r).negate() };
+			case "round": return { field: _e(t) };
+			case "floor": return { field: A(t) };
+			case "ceil": return { field: y(t) };
+			case "truncate": return { field: Ee(t) };
+			case "fraction": return { field: j(t) };
+			case "modulo": return { field: z(n.equal(0), k(0), t.sub(n.mul(Ee(t.div(n))))) };
+			case "floored-modulo": return { field: z(n.equal(0), k(0), t.sub(n.mul(A(t.div(n))))) };
+			case "wrap": return { field: nr(t, n, r) };
+			case "snap": return { field: z(n.equal(0), k(0), A(t.div(n)).mul(n)) };
+			case "pingpong": return { field: rr(t, n) };
+			case "sine": return { field: B(t) };
+			case "cosine": return { field: S(t) };
+			case "tangent": return { field: we(t) };
+			case "arcsine": return { field: z(t.abs().lessThanEqual(1), m(t), k(0)) };
+			case "arccosine": return { field: z(t.abs().lessThanEqual(1), p(t), k(0)) };
+			case "arctangent": return { field: h(t) };
+			case "arctan2": return { field: h(t, n) };
+			case "sinh": return { field: xe(t) };
+			case "cosh": return { field: C(t) };
+			case "tanh": return { field: Te(t) };
+			case "radians": return { field: he(t) };
+			case "degrees": return { field: ee(t) };
+			default: return { field: I(t, n, e.uniforms.factor) };
+		}
+	}
+};
+function tr(e, t, n) {
+	let r = P(n.sub(e.sub(t).abs()), k(0)).div(n), i = F(e, t).sub(r.mul(r).mul(r).mul(n).div(6));
+	return z(n.equal(0), F(e, t), i);
+}
+function nr(e, t, n) {
+	let r = t.sub(n);
+	return z(r.equal(0), n, e.sub(r.mul(A(e.sub(n).div(r)))));
+}
+function rr(e, t) {
+	let n = t.mul(2);
+	return z(t.equal(0), k(0), j(e.sub(t).div(n)).mul(n).sub(t).abs());
+}
+//#endregion
+//#region src/graph/nodes/converter/levels.ts
+var ir = {
+	type: "levels",
+	nodeClass: "converter",
+	label: "Levels / Remap",
+	inputs: [{
+		key: "field",
+		kind: "float"
+	}],
+	outputs: [{
+		key: "field",
+		kind: "float"
+	}],
+	params: [
+		{
+			key: "min",
+			label: "out min",
+			type: "float",
+			min: 0,
+			max: 1,
+			step: .01,
+			default: 0
+		},
+		{
+			key: "max",
+			label: "out max",
+			type: "float",
+			min: 0,
+			max: 1,
+			step: .01,
+			default: 1
+		},
+		{
+			key: "invert",
+			label: "invert",
+			type: "bool",
+			default: !1
+		}
+	],
+	build(e) {
+		let t = e.inputs.field ?? k(.5), n = e.params.invert ? t.oneMinus() : t;
+		return { field: I(e.uniforms.min, e.uniforms.max, n) };
+	}
+}, ar = {
+	type: "color-ramp",
+	nodeClass: "converter",
+	label: "Color Ramp",
+	inputs: [{
+		key: "field",
+		kind: "float"
+	}],
+	outputs: [{
+		key: "color",
+		kind: "color"
+	}],
+	params: [
+		{
+			key: "colorA",
+			label: "low",
+			type: "color",
+			default: "#3f2d1e"
+		},
+		{
+			key: "colorB",
+			label: "high",
+			type: "color",
+			default: "#8a6a4a"
+		},
+		{
+			key: "low",
+			label: "low stop",
+			type: "float",
+			min: 0,
+			max: 1,
+			step: .01,
+			default: .3
+		},
+		{
+			key: "high",
+			label: "high stop",
+			type: "float",
+			min: 0,
+			max: 1,
+			step: .01,
+			default: .75
+		}
+	],
+	build(e) {
+		let t = e.inputs.field ?? k(.5), n = e.uniforms.low, r = e.uniforms.high, i = b(t.sub(n).div(r.sub(n).max(1e-5)), 0, 1);
+		return { color: I(e.uniforms.colorA, e.uniforms.colorB, i) };
+	}
+}, or = {
+	type: "height-blend",
+	nodeClass: "converter",
+	label: "Height Blend",
+	inputs: [
+		{
+			key: "heightA",
+			label: "Height A",
+			kind: "float"
+		},
+		{
+			key: "heightB",
+			label: "Height B",
+			kind: "float"
+		},
+		{
+			key: "breakup",
+			label: "Breakup",
+			kind: "float"
+		}
+	],
+	outputs: [{
+		key: "fac",
+		kind: "float"
+	}],
+	params: [
+		{
+			key: "transition",
+			label: "transition",
+			type: "float",
+			min: 0,
+			max: 1,
+			step: .01,
+			default: .5
+		},
+		{
+			key: "width",
+			label: "width",
+			type: "float",
+			min: .01,
+			max: 1,
+			step: .01,
+			default: .25
+		},
+		{
+			key: "breakup",
+			label: "breakup amt",
+			type: "float",
+			min: 0,
+			max: 1,
+			step: .01,
+			default: 0
+		}
+	],
+	build(e) {
+		let t = e.inputs.heightA ?? k(.5), n = e.inputs.heightB ?? k(.5), r = e.uniforms.transition, i = e.uniforms.width;
+		e.inputs.breakup !== void 0 && (n = n.add(e.inputs.breakup.sub(.5).mul(e.uniforms.breakup)));
+		let a = n.sub(t).add(r.mul(2).sub(1));
+		return { fac: V(i.negate(), i, a) };
+	}
+}, sr = {
+	type: "blend",
+	nodeClass: "color",
+	label: "Blend",
+	inputs: [
+		{
+			key: "a",
+			label: "base",
+			kind: "color"
+		},
+		{
+			key: "b",
+			label: "over",
+			kind: "color"
+		},
+		{
+			key: "mask",
+			kind: "float"
+		}
+	],
+	outputs: [{
+		key: "color",
+		kind: "color"
+	}],
+	params: [{
+		key: "mode",
+		label: "mode",
+		type: "select",
+		options: [
+			"mix",
+			"multiply",
+			"screen",
+			"add"
+		],
+		default: "mix"
+	}, {
+		key: "opacity",
+		label: "opacity",
+		type: "float",
+		min: 0,
+		max: 1,
+		step: .01,
+		default: 1
+	}],
+	build(e) {
+		let t = e.inputs.a ?? x(0), n = e.inputs.b ?? x(16777215), r;
+		switch (e.params.mode) {
+			case "multiply":
+				r = t.mul(n);
+				break;
+			case "screen":
+				r = t.oneMinus().mul(n.oneMinus()).oneMinus();
+				break;
+			case "add":
+				r = t.add(n);
+				break;
+			default:
+				r = n;
+				break;
+		}
+		let i = (e.inputs.mask ?? k(1)).mul(e.uniforms.opacity);
+		return { color: I(t, r, i) };
+	}
+}, cr = {
+	type: "invert",
+	nodeClass: "color",
+	label: "Invert Color",
+	inputs: [{
+		key: "fac",
+		label: "Fac",
+		kind: "float"
+	}, {
+		key: "color",
+		label: "Color",
+		kind: "color"
+	}],
+	outputs: [{
+		key: "color",
+		kind: "color"
+	}],
+	params: [{
+		key: "fac",
+		label: "fac",
+		type: "float",
+		min: 0,
+		max: 1,
+		step: .01,
+		default: 1
+	}],
+	build(e) {
+		let t = e.inputs.color ?? q(0, 0, 0), n = e.inputs.fac ?? e.uniforms.fac;
+		return { color: I(t, q(1, 1, 1).sub(t), n) };
+	}
+}, lr = {
+	type: "bright-contrast",
+	nodeClass: "color",
+	label: "Bright / Contrast",
+	inputs: [
+		{
+			key: "color",
+			label: "Color",
+			kind: "color"
+		},
+		{
+			key: "bright",
+			label: "Bright",
+			kind: "float"
+		},
+		{
+			key: "contrast",
+			label: "Contrast",
+			kind: "float"
+		}
+	],
+	outputs: [{
+		key: "color",
+		kind: "color"
+	}],
+	params: [{
+		key: "bright",
+		label: "bright",
+		type: "float",
+		min: -1,
+		max: 1,
+		step: .01,
+		default: 0
+	}, {
+		key: "contrast",
+		label: "contrast",
+		type: "float",
+		min: -1,
+		max: 1,
+		step: .01,
+		default: 0
+	}],
+	build(e) {
+		let t = e.inputs.color ?? q(0, 0, 0), n = e.inputs.contrast ?? e.uniforms.contrast, r = e.inputs.bright ?? e.uniforms.bright, i = k(1).add(n), a = r.sub(n.mul(.5));
+		return { color: t.mul(i).add(a).max(0) };
+	}
+}, ur = 1e-10;
+function dr(e) {
+	let t = e.x, n = e.y, r = e.z, i = P(t, P(n, r)), a = F(t, F(n, r)), o = i.sub(a), s = i, c = z(i.equal(0), k(0), o.div(P(i, k(ur)))), l = q(i, i, i).sub(e).div(P(o, k(ur))), u = l.z.sub(l.y), d = k(2).add(l.x).sub(l.z), f = k(4).add(l.y).sub(l.x), p = z(n.equal(i), d, f);
+	return p = z(t.equal(i), u, p), p = p.div(6), p = z(p.lessThan(0), p.add(1), p), p = z(c.equal(0), k(0), p), q(p, c, s);
+}
+function fr(e) {
+	let t = e.x, n = e.y, r = e.z, i = z(t.equal(1), k(0), t).mul(6), a = A(i), o = i.sub(a), s = r.mul(k(1).sub(n)), c = r.mul(k(1).sub(n.mul(o))), l = r.mul(k(1).sub(n.mul(k(1).sub(o)))), u = q(r, s, c);
+	return u = z(a.equal(4), q(l, s, r), u), u = z(a.equal(3), q(s, c, r), u), u = z(a.equal(2), q(s, r, l), u), u = z(a.equal(1), q(c, r, s), u), u = z(a.equal(0), q(r, l, s), u), z(n.equal(0), q(r, r, r), u);
+}
+//#endregion
+//#region src/graph/nodes/color/hue-sat-val.ts
+var pr = {
+	type: "hue-sat-val",
+	nodeClass: "color",
+	label: "Hue / Saturation",
+	inputs: [{
+		key: "color",
+		label: "Color",
+		kind: "color"
+	}],
+	outputs: [{
+		key: "color",
+		kind: "color"
+	}],
+	params: [
+		{
+			key: "hue",
+			label: "hue",
+			type: "float",
+			min: 0,
+			max: 1,
+			step: .001,
+			default: .5
+		},
+		{
+			key: "saturation",
+			label: "saturation",
+			type: "float",
+			min: 0,
+			max: 2,
+			step: .01,
+			default: 1
+		},
+		{
+			key: "value",
+			label: "value",
+			type: "float",
+			min: 0,
+			max: 2,
+			step: .01,
+			default: 1
+		},
+		{
+			key: "fac",
+			label: "fac",
+			type: "float",
+			min: 0,
+			max: 1,
+			step: .01,
+			default: 1
+		}
+	],
+	build(e) {
+		let t = e.inputs.color ?? q(.8, .8, .8), n = dr(t);
+		return { color: I(t, fr(q(j(n.x.add(e.uniforms.hue).add(.5)), n.y.mul(e.uniforms.saturation).clamp(0, 1), n.z.mul(e.uniforms.value))), e.uniforms.fac) };
+	}
+}, mr = (e, t, n, r, i) => z(e.equal(0), t, z(e.equal(1), n, z(e.equal(2), r, i)));
+function hr(e, t) {
+	let n = e.clamp(0, 1).mul(4), r = A(n).clamp(0, 3), i = n.sub(r), a = mr(r, t[0], t[0], t[1], t[2]), o = mr(r, t[0], t[1], t[2], t[3]), s = mr(r, t[1], t[2], t[3], t[4]), c = mr(r, t[2], t[3], t[4], t[4]), l = i.mul(i), u = l.mul(i);
+	return o.mul(2).add(s.sub(a).mul(i)).add(a.mul(2).sub(o.mul(5)).add(s.mul(4)).sub(c).mul(l)).add(o.mul(3).sub(s.mul(3)).add(c).sub(a).mul(u)).mul(.5);
+}
+//#endregion
+//#region src/graph/nodes/color/rgb-curves.ts
+var gr = () => [...Ae], _r = {
+	type: "rgb-curves",
+	nodeClass: "color",
+	label: "RGB Curves",
+	inputs: [{
+		key: "fac",
+		label: "Fac",
+		kind: "float"
+	}, {
+		key: "color",
+		label: "Color",
+		kind: "color"
+	}],
+	outputs: [{
+		key: "color",
+		kind: "color"
+	}],
+	params: [{
+		key: "fac",
+		label: "fac",
+		type: "float",
+		min: 0,
+		max: 1,
+		step: .01,
+		default: 1
+	}, {
+		key: "curves",
+		label: "curves",
+		type: "curve",
+		default: {
+			C: gr(),
+			R: gr(),
+			G: gr(),
+			B: gr()
+		}
+	}],
+	build(e) {
+		let t = e.inputs.color ?? q(0, 0, 0), n = e.uniforms.curves, r = (e) => [
+			0,
+			1,
+			2,
+			3,
+			4
+		].map((t) => n.element(e + t)), [i, a, o, s] = [
+			r(0),
+			r(5),
+			r(10),
+			r(15)
+		], c = hr(hr(t.x, i), a), l = hr(hr(t.y, i), o), u = hr(hr(t.z, i), s), d = e.inputs.fac ?? e.uniforms.fac;
+		return { color: I(t, q(c, l, u), d) };
+	}
+}, vr = {
+	type: "luminance",
+	nodeClass: "converter",
+	label: "Luminance",
+	inputs: [{
+		key: "color",
+		kind: "color"
+	}],
+	outputs: [{
+		key: "field",
+		kind: "float"
+	}],
+	params: [],
+	build(e) {
+		let t = e.inputs.color;
+		return { field: t ? oe(t) : k(0) };
+	}
+}, yr = {
+	type: "split-channels",
+	nodeClass: "converter",
+	label: "Split Channels",
+	inputs: [{
+		key: "color",
+		kind: "color"
+	}],
+	outputs: [
+		{
+			key: "r",
+			kind: "float"
+		},
+		{
+			key: "g",
+			kind: "float"
+		},
+		{
+			key: "b",
+			kind: "float"
+		}
+	],
+	params: [],
+	build(e) {
+		let t = e.inputs.color;
+		return t ? {
+			r: t.x,
+			g: t.y,
+			b: t.z
+		} : {
+			r: k(0),
+			g: k(0),
+			b: k(0)
+		};
+	}
+}, br = {
+	type: "combine-channels",
+	nodeClass: "converter",
+	label: "Combine Channels",
+	inputs: [
+		{
+			key: "r",
+			kind: "float"
+		},
+		{
+			key: "g",
+			kind: "float"
+		},
+		{
+			key: "b",
+			kind: "float"
+		}
+	],
+	outputs: [{
+		key: "color",
+		kind: "color"
+	}],
+	params: [],
+	build(e) {
+		return { color: q(e.inputs.r ?? k(0), e.inputs.g ?? k(0), e.inputs.b ?? k(0)) };
+	}
+}, xr = {
+	type: "clamp",
+	nodeClass: "converter",
+	label: "Clamp",
+	inputs: [
+		{
+			key: "value",
+			label: "Value",
+			kind: "float"
+		},
+		{
+			key: "min",
+			label: "Min",
+			kind: "float"
+		},
+		{
+			key: "max",
+			label: "Max",
+			kind: "float"
+		}
+	],
+	outputs: [{
+		key: "field",
+		kind: "float"
+	}],
+	params: [
+		{
+			key: "mode",
+			label: "mode",
+			type: "select",
+			options: ["minmax", "range"],
+			default: "minmax"
+		},
+		{
+			key: "min",
+			label: "min",
+			type: "float",
+			min: -10,
+			max: 10,
+			step: .01,
+			default: 0
+		},
+		{
+			key: "max",
+			label: "max",
+			type: "float",
+			min: -10,
+			max: 10,
+			step: .01,
+			default: 1
+		}
+	],
+	build(e) {
+		let t = e.inputs.value ?? k(0), n = e.inputs.min ?? e.uniforms.min, r = e.inputs.max ?? e.uniforms.max;
+		return e.params.mode === "range" ? { field: t.clamp(F(n, r), P(n, r)) } : { field: b(t, n, r) };
+	}
+}, Sr = {
+	type: "separate-xyz",
+	nodeClass: "converter",
+	label: "Separate XYZ",
+	inputs: [{
+		key: "vector",
+		kind: "vector"
+	}],
+	outputs: [
+		{
+			key: "x",
+			kind: "float"
+		},
+		{
+			key: "y",
+			kind: "float"
+		},
+		{
+			key: "z",
+			kind: "float"
+		}
+	],
+	params: [],
+	build(e) {
+		let t = e.inputs.vector ?? q(0, 0, 0);
+		return {
+			x: t.x,
+			y: t.y,
+			z: t.z
+		};
+	}
+}, Cr = {
+	type: "combine-xyz",
+	nodeClass: "converter",
+	label: "Combine XYZ",
+	inputs: [
+		{
+			key: "x",
+			kind: "float"
+		},
+		{
+			key: "y",
+			kind: "float"
+		},
+		{
+			key: "z",
+			kind: "float"
+		}
+	],
+	outputs: [{
+		key: "vector",
+		kind: "vector"
+	}],
+	params: [
+		{
+			key: "x",
+			label: "x",
+			type: "float",
+			min: -10,
+			max: 10,
+			step: .01,
+			default: 0
+		},
+		{
+			key: "y",
+			label: "y",
+			type: "float",
+			min: -10,
+			max: 10,
+			step: .01,
+			default: 0
+		},
+		{
+			key: "z",
+			label: "z",
+			type: "float",
+			min: -10,
+			max: 10,
+			step: .01,
+			default: 0
+		}
+	],
+	build(e) {
+		return { vector: q(e.inputs.x ?? e.uniforms.x, e.inputs.y ?? e.uniforms.y, e.inputs.z ?? e.uniforms.z) };
+	}
+}, wr = {
+	type: "constant-field",
+	nodeClass: "input",
+	label: "Constant (Field)",
+	inputs: [],
+	outputs: [{
+		key: "field",
+		kind: "float"
+	}],
+	params: [{
+		key: "value",
+		label: "value",
+		type: "float",
+		min: 0,
+		max: 1,
+		step: .01,
+		default: .5
+	}],
+	build(e) {
+		return { field: e.uniforms.value };
+	}
+}, Tr = {
+	type: "constant-color",
+	nodeClass: "input",
+	label: "Constant (Color)",
+	inputs: [],
+	outputs: [{
+		key: "color",
+		kind: "color"
+	}],
+	params: [{
+		key: "color",
+		label: "color",
+		type: "color",
+		default: "#808080"
+	}],
+	build(e) {
+		return { color: e.uniforms.color };
+	}
+}, Er = {
+	type: "tex-coordinate",
+	nodeClass: "input",
+	label: "Texture Coordinate",
+	inputs: [],
+	outputs: [
+		{
+			key: "generated",
+			label: "Generated",
+			kind: "vector"
+		},
+		{
+			key: "uv",
+			label: "UV",
+			kind: "vector"
+		},
+		{
+			key: "object",
+			label: "Object",
+			kind: "vector"
+		},
+		{
+			key: "normal",
+			label: "Normal",
+			kind: "vector"
+		}
+	],
+	params: [],
+	build(e) {
+		let t = q(G().x, G().y, k(0));
+		return e.backend === "offline" ? {
+			generated: t,
+			uv: t,
+			object: t,
+			normal: t
+		} : {
+			generated: pe,
+			uv: t,
+			object: pe,
+			normal: ce
+		};
+	}
+}, Dr = [
+	"add",
+	"subtract",
+	"multiply",
+	"divide",
+	"cross",
+	"project",
+	"reflect",
+	"dot",
+	"distance",
+	"length",
+	"scale",
+	"normalize",
+	"snap",
+	"floor",
+	"ceil",
+	"fraction",
+	"absolute",
+	"minimum",
+	"maximum",
+	"sine",
+	"cosine",
+	"tangent"
+], Or = new Set([
+	"dot",
+	"distance",
+	"length"
+]), kr = [{
+	key: "vector1",
+	label: "A",
+	kind: "vector"
+}, {
+	key: "vector2",
+	label: "B",
+	kind: "vector"
+}], Ar = {
+	type: "vector-math",
+	nodeClass: "vector",
+	label: "Vector Math",
+	inputs: kr,
+	outputs: [{
+		key: "vector",
+		label: "Vector",
+		kind: "vector"
+	}],
+	params: [{
+		key: "operation",
+		label: "op",
+		type: "select",
+		options: Dr,
+		default: "add"
+	}, {
+		key: "scale",
+		label: "scale",
+		type: "float",
+		min: -8,
+		max: 8,
+		step: .01,
+		default: 1
+	}],
+	declare(e) {
+		let t = e.operation ?? "add";
+		return {
+			inputs: kr,
+			outputs: Or.has(t) ? [{
+				key: "value",
+				label: "Value",
+				kind: "float"
+			}] : [{
+				key: "vector",
+				label: "Vector",
+				kind: "vector"
+			}]
+		};
+	},
+	build(e) {
+		let t = e.inputs.vector1 ?? e.coord, n = e.inputs.vector2 ?? q(0, 0, 0), r = e.uniforms.scale;
+		switch (e.params.operation ?? "add") {
+			case "subtract": return { vector: t.sub(n) };
+			case "multiply": return { vector: t.mul(n) };
+			case "divide": return { vector: t.div(n) };
+			case "cross": return { vector: w(t, n) };
+			case "project": return { vector: n.mul(D(t, n).div(D(n, n))) };
+			case "reflect": return { vector: ge(t, n.normalize()) };
+			case "dot": return { value: D(t, n) };
+			case "distance": return { value: t.sub(n).length() };
+			case "length": return { value: t.length() };
+			case "scale": return { vector: t.mul(r) };
+			case "normalize": return { vector: t.normalize() };
+			case "snap": return { vector: A(t.div(n)).mul(n) };
+			case "floor": return { vector: A(t) };
+			case "ceil": return { vector: y(t) };
+			case "fraction": return { vector: j(t) };
+			case "absolute": return { vector: t.abs() };
+			case "minimum": return { vector: F(t, n) };
+			case "maximum": return { vector: P(t, n) };
+			case "sine": return { vector: B(t) };
+			case "cosine": return { vector: S(t) };
+			case "tangent": return { vector: we(t) };
+			default: return { vector: t.add(n) };
+		}
+	}
+}, jr = 1, Mr = {
+	type: "normal-from-height",
+	nodeClass: "vector",
+	label: "Normal From Height",
+	bakeDerivative: !0,
+	inputs: [{
+		key: "height",
+		kind: "float"
+	}],
+	outputs: [{
+		key: "normal",
+		kind: "vector"
+	}],
+	params: [{
+		key: "strength",
+		label: "strength",
+		type: "float",
+		min: 0,
+		max: 2,
+		step: .01,
+		default: .2
+	}],
+	build(e) {
+		let t = e.inputs.height ?? k(.5);
+		if (e.backend === "live") return { normal: v(t, e.uniforms.strength) };
+		let n = t, r = G(), i = T(n).div(T(r.x)), a = E(n).div(E(r.y)), o = e.uniforms.strength, s = K(i, a).mul(o), c = k(jr), l = s.mul(c.div(s.length().max(c)));
+		return { normal: de(q(l.x.negate(), l.y.negate(), k(1))).mul(.5).add(.5) };
+	}
+}, Nr = {
+	type: "normal-map",
+	nodeClass: "vector",
+	label: "Normal Map",
+	inputs: [{
+		key: "color",
+		label: "Color",
+		kind: "color"
+	}, {
+		key: "strength",
+		label: "Strength",
+		kind: "float"
+	}],
+	outputs: [{
+		key: "normal",
+		kind: "vector"
+	}],
+	params: [{
+		key: "strength",
+		label: "strength",
+		type: "float",
+		min: 0,
+		max: 4,
+		step: .05,
+		default: 1
+	}],
+	build(e) {
+		return { normal: le(e.inputs.color ?? q(.5, .5, 1), e.inputs.strength ?? e.uniforms.strength) };
+	}
+};
+//#endregion
+//#region src/tsl/blender-mapping.ts
+function Pr(e) {
+	let t = S(e.x), n = S(e.y), r = S(e.z), i = B(e.x), a = B(e.y), o = B(e.z), s = t.mul(r), c = t.mul(o), l = i.mul(r), u = i.mul(o);
+	return {
+		m00: n.mul(r),
+		m10: a.mul(l).sub(c),
+		m20: a.mul(s).add(u),
+		m01: n.mul(o),
+		m11: a.mul(u).add(s),
+		m21: a.mul(c).sub(l),
+		m02: a.negate(),
+		m12: n.mul(i),
+		m22: n.mul(t)
+	};
+}
+function Fr(e, t) {
+	return q(e.m00.mul(t.x).add(e.m10.mul(t.y)).add(e.m20.mul(t.z)), e.m01.mul(t.x).add(e.m11.mul(t.y)).add(e.m21.mul(t.z)), e.m02.mul(t.x).add(e.m12.mul(t.y)).add(e.m22.mul(t.z)));
+}
+function Ir(e, t) {
+	return q(e.m00.mul(t.x).add(e.m01.mul(t.y)).add(e.m02.mul(t.z)), e.m10.mul(t.x).add(e.m11.mul(t.y)).add(e.m12.mul(t.z)), e.m20.mul(t.x).add(e.m21.mul(t.y)).add(e.m22.mul(t.z)));
+}
+function Lr(e, t, n, r, i) {
+	let a = Pr(n);
+	return i === 1 ? Ir(a, e.sub(t)).div(r) : i === 2 ? Fr(a, e.mul(r)) : i === 3 ? Fr(a, e.div(r)).normalize() : Fr(a, e.mul(r)).add(t);
+}
+//#endregion
+//#region src/graph/nodes/vector/mapping.ts
+var Rr = [
+	"point",
+	"texture",
+	"vector",
+	"normal"
+], zr = {
+	type: "mapping",
+	nodeClass: "vector",
+	label: "Mapping",
+	inputs: [{
+		key: "vector",
+		kind: "vector"
+	}],
+	outputs: [{
+		key: "vector",
+		kind: "vector"
+	}],
+	params: [
+		{
+			key: "mappingType",
+			label: "type",
+			type: "select",
+			options: Rr,
+			default: "point"
+		},
+		{
+			key: "location",
+			label: "location",
+			type: "vec3",
+			default: {
+				x: 0,
+				y: 0,
+				z: 0
+			}
+		},
+		{
+			key: "rotation",
+			label: "rotation",
+			type: "vec3",
+			default: {
+				x: 0,
+				y: 0,
+				z: 0
+			}
+		},
+		{
+			key: "scale",
+			label: "scale",
+			type: "vec3",
+			default: {
+				x: 1,
+				y: 1,
+				z: 1
+			}
+		}
+	],
+	build(e) {
+		let t = e.inputs.vector ?? e.coord, n = Math.max(0, Rr.indexOf(e.params.mappingType));
+		return { vector: Lr(t, e.uniforms.location, e.uniforms.rotation, e.uniforms.scale, n) };
+	}
+}, Br = [
+	{
+		key: "baseColor",
+		label: "base color",
+		type: "color",
+		default: "#cccccc"
+	},
+	{
+		key: "metallic",
+		label: "metallic",
+		type: "float",
+		min: 0,
+		max: 1,
+		step: .01,
+		default: 0
+	},
+	{
+		key: "roughness",
+		label: "roughness",
+		type: "float",
+		min: 0,
+		max: 1,
+		step: .01,
+		default: .5
+	},
+	{
+		key: "ior",
+		label: "IOR",
+		type: "float",
+		min: 1,
+		max: 2.5,
+		step: .01,
+		default: 1.5
+	},
+	{
+		key: "alpha",
+		label: "alpha",
+		type: "float",
+		min: 0,
+		max: 1,
+		step: .01,
+		default: 1,
+		bakeStructural: !0
+	},
+	{
+		key: "coat",
+		label: "coat weight",
+		type: "float",
+		min: 0,
+		max: 1,
+		step: .01,
+		default: 0
+	},
+	{
+		key: "coatRoughness",
+		label: "coat rough",
+		type: "float",
+		min: 0,
+		max: 1,
+		step: .01,
+		default: .03
+	},
+	{
+		key: "sheen",
+		label: "sheen weight",
+		type: "float",
+		min: 0,
+		max: 1,
+		step: .01,
+		default: 0
+	},
+	{
+		key: "sheenRoughness",
+		label: "sheen rough",
+		type: "float",
+		min: 0,
+		max: 1,
+		step: .01,
+		default: .3
+	},
+	{
+		key: "transmission",
+		label: "transmission",
+		type: "float",
+		min: 0,
+		max: 1,
+		step: .01,
+		default: 0
+	},
+	{
+		key: "emission",
+		label: "emission",
+		type: "color",
+		default: "#000000",
+		bakeStructural: !0
+	},
+	{
+		key: "emissionStrength",
+		label: "emission str",
+		type: "float",
+		min: 0,
+		max: 10,
+		step: .1,
+		default: 1
+	}
+], Vr = Object.fromEntries(Br.filter((e) => e.type === "float" || e.type === "int").map((e) => [e.key, e.default])), Hr = {
+	type: "principled-bsdf",
+	nodeClass: "shader",
+	label: "Principled BSDF",
+	inputs: [
+		{
+			key: "baseColor",
+			label: "Base Color",
+			kind: "color"
+		},
+		{
+			key: "metallic",
+			label: "Metallic",
+			kind: "float"
+		},
+		{
+			key: "roughness",
+			label: "Roughness",
+			kind: "float"
+		},
+		{
+			key: "ior",
+			label: "IOR",
+			kind: "float"
+		},
+		{
+			key: "alpha",
+			label: "Alpha",
+			kind: "float"
+		},
+		{
+			key: "normal",
+			label: "Normal",
+			kind: "vector"
+		},
+		{
+			key: "height",
+			label: "Height",
+			kind: "float"
+		},
+		{
+			key: "ambientOcclusion",
+			label: "Ambient Occlusion",
+			kind: "float"
+		},
+		{
+			key: "coat",
+			label: "Coat Weight",
+			kind: "float"
+		},
+		{
+			key: "coatRoughness",
+			label: "Coat Roughness",
+			kind: "float"
+		},
+		{
+			key: "sheen",
+			label: "Sheen Weight",
+			kind: "float"
+		},
+		{
+			key: "sheenRoughness",
+			label: "Sheen Roughness",
+			kind: "float"
+		},
+		{
+			key: "transmission",
+			label: "Transmission",
+			kind: "float"
+		},
+		{
+			key: "emission",
+			label: "Emission Color",
+			kind: "color"
+		},
+		{
+			key: "emissionStrength",
+			label: "Emission Strength",
+			kind: "float"
+		}
+	],
+	outputs: [{
+		key: "bsdf",
+		kind: "shader"
+	}],
+	params: Br,
+	build(e) {
+		let t = e.uniforms, n = (n) => e.inputs[n] ?? t[n], r = (t) => Number(e.params[t] ?? Vr[t] ?? 0), i = (n) => e.inputs[n] === void 0 ? r(n) > 0 ? t[n] : void 0 : e.inputs[n], a = e.inputs.emission !== void 0 || e.inputs.emissionStrength !== void 0 || (e.params.emission ?? "#000000") !== "#000000" ? (e.inputs.emission ?? t.emission).mul(e.inputs.emissionStrength ?? t.emissionStrength) : void 0, o = i("coat"), s = i("sheen");
+		return { bsdf: {
+			baseColor: n("baseColor"),
+			metallic: n("metallic"),
+			roughness: n("roughness"),
+			ior: n("ior"),
+			normal: e.inputs.normal,
+			height: e.inputs.height,
+			ambientOcclusion: e.inputs.ambientOcclusion,
+			alpha: e.inputs.alpha === void 0 ? r("alpha") < 1 ? t.alpha : void 0 : e.inputs.alpha,
+			emission: a,
+			coat: o,
+			coatRoughness: o === void 0 ? void 0 : n("coatRoughness"),
+			sheen: s,
+			sheenRoughness: s === void 0 ? void 0 : n("sheenRoughness"),
+			transmission: i("transmission")
+		} };
+	}
+}, Ur = {
+	type: "emission",
+	nodeClass: "shader",
+	label: "Emission",
+	inputs: [{
+		key: "color",
+		label: "Color",
+		kind: "color"
+	}, {
+		key: "strength",
+		label: "Strength",
+		kind: "float"
+	}],
+	outputs: [{
+		key: "bsdf",
+		kind: "shader"
+	}],
+	params: [{
+		key: "color",
+		label: "color",
+		type: "color",
+		default: "#ffffff"
+	}, {
+		key: "strength",
+		label: "strength",
+		type: "float",
+		min: 0,
+		max: 10,
+		step: .1,
+		default: 1
+	}],
+	build(e) {
+		let t = e.inputs.color ?? e.uniforms.color, n = e.inputs.strength ?? e.uniforms.strength;
+		return { bsdf: {
+			baseColor: q(0),
+			roughness: k(1),
+			metallic: k(0),
+			emission: t.mul(n)
+		} };
+	}
+}, Wr = {
+	emission: q(0, 0, 0),
+	ambientOcclusion: k(1),
+	alpha: k(1),
+	coat: k(0),
+	sheen: k(0),
+	transmission: k(0)
+}, Gr = [
+	"baseColor",
+	"metallic",
+	"roughness",
+	"ior",
+	"alpha",
+	"ambientOcclusion",
+	"emission",
+	"normal",
+	"coat",
+	"coatRoughness",
+	"sheen",
+	"sheenRoughness",
+	"transmission"
+];
+function Kr(e, t, n) {
+	let r = {};
+	for (let i of Gr) {
+		let a = e[i], o = t[i];
+		if (a === void 0 && o === void 0) continue;
+		if (a !== void 0 && o !== void 0) {
+			r[i] = I(a, o, n);
+			continue;
+		}
+		let s = Wr[i];
+		s === void 0 ? r[i] = a ?? o : r[i] = a === void 0 ? I(s, o, n) : I(a, s, n);
+	}
+	return r;
+}
+var qr = {
+	type: "mix-shader",
+	nodeClass: "shader",
+	label: "Mix Shader",
+	inputs: [
+		{
+			key: "shaderA",
+			label: "Shader A",
+			kind: "shader"
+		},
+		{
+			key: "shaderB",
+			label: "Shader B",
+			kind: "shader"
+		},
+		{
+			key: "fac",
+			label: "Fac",
+			kind: "float"
+		}
+	],
+	outputs: [{
+		key: "shader",
+		kind: "shader"
+	}],
+	params: [{
+		key: "fac",
+		label: "fac",
+		type: "float",
+		min: 0,
+		max: 1,
+		step: .01,
+		default: .5
+	}],
+	build(e) {
+		return { shader: Kr(e.inputs.shaderA ?? {}, e.inputs.shaderB ?? {}, e.inputs.fac ?? e.uniforms.fac) };
+	}
+}, Jr = {
+	type: "material-output",
+	nodeClass: "output",
+	label: "Material Output",
+	inputs: [{
+		key: "surface",
+		label: "Surface",
+		kind: "shader"
+	}],
+	outputs: [],
+	params: [{
+		key: "outputResolution",
+		label: "output res",
+		type: "select",
+		options: [
+			"128",
+			"256",
+			"512",
+			"1024",
+			"2048",
+			"4096"
+		],
+		default: "1024"
+	}],
+	build() {
+		return {};
+	}
+}, Yr = {
+	type: "group",
+	nodeClass: "group",
+	label: "Group",
+	inputs: [],
+	outputs: [],
+	params: [],
+	build() {
+		return {};
+	}
+}, Xr = {
+	type: "group-input",
+	nodeClass: "input",
+	label: "Group Input",
+	inputs: [],
+	outputs: [],
+	params: [],
+	build() {
+		return {};
+	}
+}, Zr = {
+	type: "group-output",
+	nodeClass: "output",
+	label: "Group Output",
+	inputs: [],
+	outputs: [],
+	params: [],
+	build() {
+		return {};
+	}
+};
+//#endregion
+//#region src/graph/registry.ts
+function Z(e, t) {
+	if (e.ports) return e.ports;
+	let n = t.get(e.type);
+	return n.declare ? n.declare(e.params) : {
+		inputs: n.inputs,
+		outputs: n.outputs
+	};
+}
+function Qr(e, t) {
+	let n = t.get(e.type);
+	return n.paramsFor ? n.paramsFor(e.params) : n.params;
+}
+var $r = class {
+	defs = /* @__PURE__ */ new Map();
+	register(e) {
+		if (this.defs.has(e.type)) throw Error(`Duplicate node type: ${e.type}`);
+		return this.defs.set(e.type, e), this;
+	}
+	get(e) {
+		let t = this.defs.get(e);
+		if (!t) throw Error(`Unknown node type: ${e}`);
+		return t;
+	}
+	has(e) {
+		return this.defs.has(e);
+	}
+	all() {
+		return [...this.defs.values()];
+	}
+};
+function ei() {
+	return new $r().register(Ye).register(Xe).register(jt).register(Vt).register(Ht).register(bn).register(xn).register(Tn).register(On).register(jn).register(Fn).register(Kn).register(Jn).register(er).register(ir).register(ar).register(or).register(sr).register(cr).register(lr).register(pr).register(_r).register(vr).register(yr).register(br).register(xr).register(Sr).register(Cr).register(wr).register(Tr).register(Er).register(Ar).register(Mr).register(Nr).register(zr).register(Hr).register(Ur).register(qr).register(Jr).register(Yr).register(Xr).register(Zr);
+}
+var ti = ei(), ni = 2048;
+function ri(e, t, n) {
+	let r = new Map(t.nodes.map((e) => [e.id, e])), i = /* @__PURE__ */ new Set(), a = [e];
+	for (; a.length;) {
+		let e = a.pop();
+		if (i.has(e)) continue;
+		i.add(e);
+		let o = r.get(e);
+		if (o) {
+			if (n.get(o.type).bakeDerivative) return !0;
+			for (let n of t.edges) n.toNode === e && a.push(n.fromNode);
+		}
+	}
+	return !1;
+}
+function ii(e, t) {
+	let n = /* @__PURE__ */ new Set(), r = /* @__PURE__ */ new Set(), i = /* @__PURE__ */ new Set(), a = /* @__PURE__ */ new Map(), o = (e) => {
+		let t = a.get(e);
+		return t || (t = new Map(e.nodes.map((e) => [e.id, e])), a.set(e, t)), t;
+	}, s = (e) => e.nodes.find((e) => e.type === Pe)?.id, c = (e, t, r, i) => {
+		if (t === s(e)) {
+			i(r);
+			return;
+		}
+		let a = o(e).get(t);
+		if (a) {
+			if (a.type === "group" && a.subgraph) {
+				n.add(`${a.id}/${r}`), u(a, r, e, i);
+				return;
+			}
+			l(e, t, i);
+		}
+	}, l = (e, t, n) => {
+		if (!r.has(t)) {
+			r.add(t);
+			for (let r of e.edges) r.toNode === t && c(e, r.fromNode, r.fromOutput, n);
+		}
+	}, u = (e, t, n, r) => {
+		let a = `${e.id}/${t}`;
+		if (i.has(a)) return;
+		i.add(a);
+		let o = e.subgraph;
+		if (!o) return;
+		let s = o.nodes.find((e) => e.type === Fe), l = s && o.edges.find((e) => e.toNode === s.id && e.toInput === t);
+		l && c(o, l.fromNode, l.fromOutput, (t) => {
+			for (let i of n.edges) i.toNode === e.id && i.toInput === t && c(n, i.fromNode, i.fromOutput, r);
+		});
+	}, d = (e, n) => {
+		for (let r of e.nodes) t.get(r.type).bakeDerivative && l(e, r.id, n), r.type === "group" && r.subgraph && d(r.subgraph, (t) => {
+			for (let i of e.edges) i.toNode === r.id && i.toInput === t && c(e, i.fromNode, i.fromOutput, n);
+		});
+	};
+	return d(e, () => {}), n;
+}
+function ai(e, t) {
+	return t === "float" ? q(e) : e;
+}
+function oi(e, t) {
+	let n = H(e, G());
+	return t === "float" ? n.r : n.xyz;
+}
+function si(e) {
+	let t = e.nodes.find((e) => e.type === Ie)?.params?.outputResolution, n = typeof t == "string" ? Number(t) : typeof t == "number" ? t : NaN;
+	return Number.isFinite(n) && n > 0 ? n : 1024;
+}
+function ci(e, t, n) {
+	if (n.backend === "live" || !n.allocCache || !t.bakeTileable) return 1;
+	let r = e.params.tileSize, i = typeof r == "string" && r !== "off" ? Number(r) : NaN;
+	if (!Number.isFinite(i) || i <= 0) return 1;
+	let a = n.outputResolution ?? 1024, o = Math.max(1, Math.round(Number(e.params.scale) || 1));
+	return Math.max(1, Math.min(Math.round(a / i), o));
+}
+function li(e, t, n, r, i, a) {
+	if (r.backend === "live" || !r.allocCache || !t.bakeTileable || n.vector !== void 0 || n.field === void 0) return;
+	let o = e.params.tileSize, s = typeof o == "string" && o !== "off" ? Number(o) : NaN;
+	if (!Number.isFinite(s) || s <= 0) return;
+	let c = `${e.id}/field`, l = r.allocCache(c, "float", { size: s });
+	return i.push({
+		cacheId: c,
+		kind: "float",
+		colorNode: ai(n.field, "float"),
+		sizing: { size: s }
+	}), { field: H(l, G().mul(k(a))).r };
+}
+function ui(e) {
+	let t = 0;
+	for (let n of e.nodes) t += 1, n.type === "group" && n.subgraph && (t += ui(n.subgraph));
+	return t;
+}
+function di(e, t, n) {
+	let r = {
+		...n,
+		outputResolution: n.outputResolution ?? si(e)
+	}, i = r.backend === "live" ? me : q(G().x, G().y, k(0)), a = r.soloNodeId ? { id: r.soloNodeId } : void 0, o = [], { outputs: s, uniforms: c } = pi(e, t, r, i, o, r.allocCache ? ii(e, t) : /* @__PURE__ */ new Set(), void 0, a);
+	return {
+		bundle: a && a.value !== void 0 && a.kind && a.kind !== "shader" ? fi(a.value, a.kind) : Si(e, t, s),
+		uniforms: c,
+		cachePlan: o
+	};
+}
+function fi(e, t) {
+	return {
+		baseColor: t === "float" ? q(e) : e,
+		roughness: k(1),
+		metallic: k(0)
+	};
+}
+function pi(e, t, n, r, i, a, o, s) {
+	wi(e, t, o !== void 0);
+	let c = Ci(e), l = new Map(e.nodes.map((e) => [e.id, e])), u = /* @__PURE__ */ new Map(), d = /* @__PURE__ */ new Map();
+	for (let f of c) {
+		let c = l.get(f);
+		if (!c) continue;
+		let p = Z(c, t);
+		if (c.type === "group-input") {
+			let e = {};
+			for (let t of p.outputs) e[t.key] = o?.[t.key];
+			u.set(f, e);
+			continue;
+		}
+		if (c.type === "group") {
+			let o = mi(c, t, n, r, i, a, vi(c, e, u, l, t), s);
+			u.set(f, o.outputs);
+			for (let [e, t] of o.uniforms) d.set(e, t);
+			continue;
+		}
+		let m = vi(c, e, u, l, t), h = t.get(c.type), g = xi(h, c);
+		d.set(f, g);
+		let _ = ci(c, h, n), v = {
+			inputs: m,
+			uniforms: g,
+			params: c.params,
+			coord: r,
+			backend: n.backend,
+			tileRepeat: _
+		}, y = h.build(v);
+		u.set(f, li(c, h, y, n, i, _) ?? y);
+	}
+	if (s && s.value === void 0) {
+		let e = l.get(s.id), n = e ? Z(e, t).outputs[0] : void 0;
+		e && n && (s.value = u.get(s.id)?.[n.key], s.kind = n.kind);
+	}
+	return {
+		outputs: u,
+		uniforms: d
+	};
+}
+function mi(e, t, n, r, i, a, o, s) {
+	let c = e.subgraph;
+	if (!c) return {
+		outputs: {},
+		uniforms: /* @__PURE__ */ new Map()
+	};
+	let { outputs: l, uniforms: u } = pi(c, t, n, r, i, a, o, s), d = c.nodes.find((e) => e.type === Fe), f = {};
+	if (!d) return {
+		outputs: f,
+		uniforms: u
+	};
+	let p = new Map(c.nodes.map((e) => [e.id, e]));
+	for (let r of Z(d, t).inputs) {
+		let o = c.edges.find((e) => e.toNode === d.id && e.toInput === r.key), u = o ? yi(o, r.kind, l, p, t) : void 0;
+		if (n.allocCache && u !== void 0 && r.kind !== "shader" && !s) {
+			let s = `${e.id}/${r.key}`, l = o && ri(o.fromNode, c, t) || a.has(s) ? { minSize: ni } : void 0, d = n.allocCache(s, r.kind, l);
+			i.push({
+				cacheId: s,
+				kind: r.kind,
+				colorNode: ai(u, r.kind),
+				sizing: l
+			}), f[r.key] = oi(d, r.kind);
+		} else f[r.key] = u;
+	}
+	return {
+		outputs: f,
+		uniforms: u
+	};
+}
+function hi() {
+	return new c({
+		metalness: 0,
+		roughness: .9,
+		side: e.DoubleSide,
+		polygonOffset: !0,
+		polygonOffsetFactor: 1,
+		polygonOffsetUnits: 1
+	});
+}
+function gi(e, t) {
+	let n = g("vertexAo", "float");
+	e.aoNode = t.ambientOcclusion ? t.ambientOcclusion.mul(n) : n, t.baseColor && (e.colorNode = t.baseColor), t.emission && (e.emissiveNode = t.emission), t.roughness && (e.roughnessNode = t.roughness), t.metallic && (e.metalnessNode = t.metallic), t.normal && (e.normalNode = t.normal), t.ior && (e.iorNode = t.ior), t.alpha && (e.opacityNode = t.alpha, e.transparent = !0), t.coat && (e.clearcoatNode = t.coat), t.coatRoughness && (e.clearcoatRoughnessNode = t.coatRoughness), t.sheen && (e.sheenNode = t.sheen), t.sheenRoughness && (e.sheenRoughnessNode = t.sheenRoughness), t.transmission && (e.transmissionNode = t.transmission);
+}
+function _i(e, t, n) {
+	let { bundle: r, uniforms: i } = di(e, t, n), a = hi();
+	return gi(a, r), {
+		material: a,
+		uniforms: i
+	};
+}
+function vi(e, t, n, r, i) {
+	let a = {};
+	for (let o of Z(e, i).inputs) {
+		let s = t.edges.find((t) => t.toNode === e.id && t.toInput === o.key);
+		a[o.key] = s ? yi(s, o.kind, n, r, i) : void 0;
+	}
+	return a;
+}
+function yi(e, t, n, r, i) {
+	let a = n.get(e.fromNode)?.[e.fromOutput];
+	if (a === void 0) return;
+	let o = r.get(e.fromNode), s = o ? Z(o, i).outputs.find((t) => t.key === e.fromOutput)?.kind : void 0;
+	if (s && s !== t) {
+		let e = ze(s, t);
+		e && (a = bi(a, e));
+	}
+	return a;
+}
+function bi(e, t) {
+	switch (t) {
+		case "float-to-vector":
+		case "float-to-color": return q(e);
+		case "vector-to-float": return e.x.add(e.y).add(e.z).div(3);
+		case "color-to-float": return oe(e);
+		case "identity":
+		case "vector-to-color":
+		case "color-to-vector": return e;
+	}
+}
+function xi(t, n) {
+	let r = {};
+	for (let i of t.params) {
+		let t = n.params[i.key] ?? i.default;
+		if (i.type === "color") r[i.key] = W(new e.Color(t));
+		else if (i.type === "vec3") {
+			let n = t ?? {
+				x: 0,
+				y: 0,
+				z: 0
+			};
+			r[i.key] = W(new e.Vector3(n.x, n.y, n.z));
+		} else if (i.type === "float" || i.type === "int") {
+			let e = Number(t);
+			r[i.key] = W(Number.isFinite(e) ? e : Number(i.default) || 0);
+		} else i.type === "curve" && (r[i.key] = De(Me(t), "float"));
+	}
+	return r;
+}
+function Si(e, t, n) {
+	let r = e.nodes.find((e) => e.type === Ie);
+	if (!r) return {};
+	let i = e.edges.find((e) => e.toNode === r.id && e.toInput === "surface");
+	return i ? yi(i, "shader", n, new Map(e.nodes.map((e) => [e.id, e])), t) ?? {} : {};
+}
+function Ci(e) {
+	let t = /* @__PURE__ */ new Map();
+	for (let n of e.nodes) t.set(n.id, 0);
+	let n = /* @__PURE__ */ new Map();
+	for (let r of e.edges) !t.has(r.fromNode) || !t.has(r.toNode) || (n.set(r.fromNode, [...n.get(r.fromNode) ?? [], r.toNode]), t.set(r.toNode, (t.get(r.toNode) ?? 0) + 1));
+	let r = e.nodes.filter((e) => (t.get(e.id) ?? 0) === 0).map((e) => e.id), i = [];
+	for (; r.length > 0;) {
+		let e = r.shift();
+		i.push(e);
+		for (let i of n.get(e) ?? []) {
+			let e = (t.get(i) ?? 0) - 1;
+			t.set(i, e), e === 0 && r.push(i);
+		}
+	}
+	if (i.length !== e.nodes.length) throw Error("Material graph has a cycle");
+	return i;
+}
+function wi(e, t, n = !1) {
+	let r = n ? Fe : Ie, i = e.nodes.filter((e) => e.type === r);
+	if (i.length !== 1) throw Error(`Expected exactly one ${r} node, found ${i.length}`);
+	let a = new Map(e.nodes.map((e) => [e.id, e])), o = /* @__PURE__ */ new Set();
+	for (let n of e.edges) {
+		let e = a.get(n.fromNode), r = a.get(n.toNode);
+		if (!e) throw Error(`Edge from unknown node '${n.fromNode}'`);
+		if (!r) throw Error(`Edge to unknown node '${n.toNode}'`);
+		let i = Z(e, t).outputs.find((e) => e.key === n.fromOutput), s = Z(r, t).inputs.find((e) => e.key === n.toInput);
+		if (!i) throw Error(`Node '${e.type}' has no output '${n.fromOutput}'`);
+		if (!s) throw Error(`Node '${r.type}' has no input '${n.toInput}'`);
+		if (i.kind !== s.kind && !ze(i.kind, s.kind)) throw Error(`Type mismatch (no coercion): ${e.type}.${n.fromOutput} (${i.kind}) -> ${r.type}.${n.toInput} (${s.kind})`);
+		let c = `${n.toNode}/${n.toInput}`;
+		if (o.has(c)) throw Error(`Multiple connections into ${r.type}.${n.toInput}`);
+		o.add(c);
+	}
+}
+//#endregion
+//#region src/document.ts
+var Ti = 2;
+function Ei(e) {
+	return structuredClone(e);
+}
+function Di() {
+	return Ei(ke);
+}
+function Oi(e) {
+	return {
+		...Ei(e),
+		version: e.version ?? 2
+	};
+}
+function ki(e, t) {
+	return e.nodes.find((e) => e.id === t);
+}
+function Ai(e, t) {
+	return e.find((e) => e.key === t);
+}
+function ji(e) {
+	return e.type === "float" || e.type === "color" || e.type === "vec3" || e.type === "curve" ? "param" : "structural";
+}
+var Mi = class {
+	registry;
+	doc;
+	listeners = /* @__PURE__ */ new Set();
+	lastError_ = null;
+	soloNode_ = null;
+	constructor(e = Di(), t = ti) {
+		this.registry = t, this.doc = Oi(e), this.validate(this.doc);
+	}
+	get document() {
+		return this.doc;
+	}
+	get lastError() {
+		return this.lastError_;
+	}
+	get soloNode() {
+		return this.soloNode_;
+	}
+	getRegistry() {
+		return this.registry;
+	}
+	compileBundle(e) {
+		try {
+			let t = di(this.doc, this.registry, e);
+			return this.lastError_ = null, t;
+		} catch (e) {
+			throw this.lastError_ = e instanceof Error ? e.message : String(e), e;
+		}
+	}
+	onChange(e) {
+		return this.listeners.add(e), () => this.listeners.delete(e);
+	}
+	setDocument(e) {
+		let t = Oi(e);
+		this.validate(t), this.doc = t, this.emit({ kind: "structural" });
+	}
+	getDocument() {
+		return Ei(this.doc);
+	}
+	setSoloNode(e) {
+		e !== this.soloNode_ && (this.soloNode_ = e, this.emit({ kind: "structural" }));
+	}
+	setOutputResolution(e) {
+		let t = this.doc.nodes.find((e) => e.type === Ie);
+		if (!t) return;
+		let n = String(e);
+		t.params.outputResolution !== n && (t.params.outputResolution = n, this.emit({ kind: "structural" }));
+	}
+	setOutputTargets(e) {
+		this.setOutputResolution(e.resolution ?? e.size ?? 1024);
+	}
+	setNodeParam(e, t, n) {
+		let r = ki(this.doc, e);
+		if (!r) return !1;
+		let i = this.registry.get(r.type), a = Ai(Qr(r, this.registry), t) ?? Ai(i.params, t);
+		return a ? Object.is(r.params[t], n) ? !0 : (r.params[t] = n, ji(a) === "param" ? this.emit({
+			kind: "param",
+			nodeId: e,
+			key: t,
+			paramType: a.type,
+			value: n,
+			bakeStructural: a.bakeStructural
+		}) : this.emit({ kind: "structural" }), !0) : !1;
+	}
+	updateNodeParams(e, t) {
+		let n = !1;
+		for (let [r, i] of Object.entries(t)) n = this.setNodeParam(e, r, i) || n;
+		return n;
+	}
+	validate(e) {
+		di(e, this.registry, { backend: "live" }), this.lastError_ = null;
+	}
+	emit(e) {
+		for (let t of this.listeners) t(e);
+	}
+}, Ni = [
+	"roughness",
+	"metallic",
+	"ambientOcclusion"
+], Pi = ["baseColor", "emission"];
+function Fi(e, t) {
+	return Ni.includes(t) ? q(e) : Pi.includes(t) ? ve(e) : e;
+}
+var Q = 2, Ii = new l(new s()), Li = new s(), $ = new u(Q, Q);
+$.texture.colorSpace = n, $.texture.minFilter = $.texture.magFilter = t, $.texture.wrapS = $.texture.wrapT = i;
+var Ri = W(K(1 / Q, 1 / Q));
+function zi(e) {
+	let t = (Q - 1) / 2, n = q(0, 0, 0);
+	for (let r = 0; r < Q; r++) for (let i = 0; i < Q; i++) {
+		let a = K(i - t, r - t).mul(Ri), o = H($.texture, G().add(a)).xyz;
+		e && (o = o.mul(2).sub(1)), n = n.add(o);
+	}
+	return n = n.div(Q * Q), e ? de(n).mul(.5).add(.5) : n;
+}
+var Bi = new s();
+Bi.colorNode = zi(!1);
+var Vi = new s();
+Vi.colorNode = zi(!0);
+var Hi = new l(Bi), Ui = new l(Vi);
+function Wi() {
+	return new s();
+}
+var Gi = new a(), Ki = new r(-1, 1, 1, -1, 0, 1), qi = [];
+async function Ji(e, t) {
+	for (; qi.length < t.length;) qi.push(new l());
+	Gi.clear();
+	for (let e = 0; e < t.length; e++) qi[e].material = t[e], Gi.add(qi[e]);
+	let n = e.getRenderTarget();
+	e.setRenderTarget($), await e.compileAsync(Gi, Ki), e.setRenderTarget(n);
+}
+function Yi(e, t, n) {
+	Ii.material = t;
+	let r = e.getRenderTarget();
+	e.setRenderTarget(n), Ii.render(e), e.setRenderTarget(r);
+}
+function Xi(e, t, n, r = !1) {
+	let i = n.width, a = n.height;
+	($.width !== i * Q || $.height !== a * Q) && $.setSize(i * Q, a * Q), Ri.value.set(1 / (i * Q), 1 / (a * Q)), Ii.material = t;
+	let o = e.getRenderTarget();
+	e.setRenderTarget($), Ii.render(e), e.setRenderTarget(n), (r ? Ui : Hi).render(e), e.setRenderTarget(o);
+}
+function Zi(e, t, n, r = !1) {
+	Li.colorNode = t, Li.needsUpdate = !0, Xi(e, Li, n, r);
+}
+//#endregion
+//#region src/graph/bake-service.ts
+var Qi = 1024, $i = 8, ea = 4096;
+function ta(e, t) {
+	let n = t?.size ?? Math.max(e, t?.minSize ?? 0);
+	return Math.min(n, ea);
+}
+function na(e) {
+	return e?.minSize != null;
+}
+var ra = typeof navigator < "u" && /chrome|chromium|crios|edg\//i.test(navigator.userAgent) && !/firefox|fxios/i.test(navigator.userAgent), ia = [
+	"baseColor",
+	"roughness",
+	"metallic",
+	"ambientOcclusion",
+	"normal",
+	"emission"
+];
+function aa(t, n) {
+	let r = new u(n, n), i = r.texture;
+	return i.colorSpace = t !== "height" && Pi.includes(t) ? e.SRGBColorSpace : e.NoColorSpace, i.wrapS = i.wrapT = e.RepeatWrapping, i.generateMipmaps = !0, i.minFilter = e.LinearMipmapLinearFilter, i.magFilter = e.LinearFilter, i.anisotropy = $i, r;
+}
+function oa(t, n = !1) {
+	let r = new u(t, t, { type: e.HalfFloatType }), i = r.texture;
+	return i.colorSpace = e.NoColorSpace, i.wrapS = i.wrapT = e.RepeatWrapping, i.generateMipmaps = n, i.minFilter = n ? e.LinearMipmapLinearFilter : e.LinearFilter, i.magFilter = e.LinearFilter, r;
+}
+var sa = class {
+	channels;
+	targets = /* @__PURE__ */ new Map();
+	mats = /* @__PURE__ */ new Map();
+	cacheTargets = /* @__PURE__ */ new Map();
+	cacheMats = /* @__PURE__ */ new Map();
+	cachePlan = [];
+	uniforms = /* @__PURE__ */ new Map();
+	heightTarget = null;
+	hasHeight = !1;
+	present = /* @__PURE__ */ new Set();
+	signature = "";
+	size;
+	constructor(e, t) {
+		this.channels = t, this.size = e;
+	}
+	resize(e) {
+		if (e !== this.size) {
+			this.size = e;
+			for (let t of this.targets.values()) t.setSize(e, e);
+			this.heightTarget?.setSize(e, e), this.flushCaches();
+		}
+	}
+	target(e) {
+		let t = this.targets.get(e);
+		return t || (t = aa(e, this.size), this.targets.set(e, t)), t;
+	}
+	channelMaterial(e) {
+		let t = this.mats.get(e);
+		return t || (t = Wi(), this.mats.set(e, t)), t;
+	}
+	cacheTarget(e, t = this.size, n = !1) {
+		let r = this.cacheTargets.get(e);
+		return r && r.texture.generateMipmaps !== n && (r.dispose(), this.cacheTargets.delete(e), r = void 0), r ? (r.width !== t || r.height !== t) && r.setSize(t, t) : (r = oa(t, n), this.cacheTargets.set(e, r)), r;
+	}
+	cacheMaterial(e) {
+		let t = this.cacheMats.get(e);
+		return t || (t = Wi(), this.cacheMats.set(e, t)), t;
+	}
+	cacheTexture(e, t, n = !1) {
+		return this.cacheTarget(e, t, n).texture;
+	}
+	firstTarget() {
+		for (let e of this.targets.values()) return e;
+		return this.heightTarget;
+	}
+	ensureHeightTarget() {
+		return this.heightTarget ||= aa("height", this.size), this.heightTarget;
+	}
+	texture(e) {
+		return this.targets.get(e)?.texture ?? null;
+	}
+	flushCaches() {
+		for (let e of this.mats.values()) e.dispose();
+		this.mats.clear();
+		for (let e of this.cacheTargets.values()) e.dispose();
+		this.cacheTargets.clear();
+		for (let e of this.cacheMats.values()) e.dispose();
+		this.cacheMats.clear(), this.cachePlan = [], this.uniforms = /* @__PURE__ */ new Map();
+	}
+	dispose() {
+		for (let e of this.targets.values()) e.dispose();
+		this.targets.clear();
+		for (let e of this.mats.values()) e.dispose();
+		this.mats.clear();
+		for (let e of this.cacheTargets.values()) e.dispose();
+		this.cacheTargets.clear();
+		for (let e of this.cacheMats.values()) e.dispose();
+		this.cacheMats.clear(), this.cachePlan = [], this.heightTarget?.dispose(), this.heightTarget = null;
+	}
+}, ca = class {
+	renderer = null;
+	compileGateDepth = 0;
+	get rendererBusy() {
+		return this.compileGateDepth > 0;
+	}
+	queue = Promise.resolve();
+	completed = 0;
+	total = 0;
+	active = null;
+	progressListeners = /* @__PURE__ */ new Set();
+	reportListeners = /* @__PURE__ */ new Set();
+	bakeRunId = 0;
+	scratch = null;
+	scratchSize = 0;
+	scratchCaches = /* @__PURE__ */ new Map();
+	scratchCacheSize = 0;
+	attachRenderer(e) {
+		this.renderer = e;
+	}
+	get hasRenderer() {
+		return this.renderer !== null;
+	}
+	onProgress(e) {
+		return this.progressListeners.add(e), () => this.progressListeners.delete(e);
+	}
+	emitProgress() {
+		let e = {
+			completed: this.completed,
+			total: this.total,
+			active: this.active
+		};
+		for (let t of this.progressListeners) t(e);
+	}
+	onBakeReport(e) {
+		return this.reportListeners.add(e), () => this.reportListeners.delete(e);
+	}
+	emitReport(e) {
+		for (let t of this.reportListeners) t(e);
+	}
+	enqueue(e, t) {
+		this.total += 1, this.emitProgress();
+		let n = this.queue.then(async () => {
+			this.active = e, this.emitProgress();
+			try {
+				return await t();
+			} finally {
+				this.completed += 1, this.active = null, console.log(`[bake] ${this.completed}/${this.total} ${e}`), this.completed >= this.total && (this.completed = 0, this.total = 0), this.emitProgress();
+			}
+		});
+		return this.queue = n.then(() => void 0, () => void 0), n;
+	}
+	createTextureSet(e = ia, t = Qi) {
+		return new sa(t, e);
+	}
+	bakeInto(e, t, n = {}) {
+		return this.enqueue(n.label ?? "surface", async () => {
+			let r = this.renderer;
+			if (!r) return !1;
+			let i = performance.now(), { bundle: a, uniforms: o, cachePlan: s } = t.compileBundle({
+				backend: "offline",
+				soloNodeId: n.soloNodeId,
+				allocCache: (t, n, r) => e.cacheTexture(t, ta(e.size, r), na(r))
+			}), c = performance.now() - i, l = ui(t.document);
+			e.uniforms = o, e.cachePlan = s;
+			let u = n.channels ?? e.channels, d = /* @__PURE__ */ new Set(), f = [];
+			for (let t of u) {
+				let n = a[t];
+				if (!n) continue;
+				let r = e.channelMaterial(t);
+				r.colorNode = Fi(n, t), r.needsUpdate = !0, f.push({
+					mat: r,
+					target: e.target(t),
+					isNormal: t === "normal"
+				}), d.add(t);
+			}
+			if (e.hasHeight = a.height !== void 0, e.hasHeight) {
+				let t = e.channelMaterial("height");
+				t.colorNode = q(a.height), t.needsUpdate = !0, f.push({
+					mat: t,
+					target: e.ensureHeightTarget(),
+					isNormal: !1
+				});
+			}
+			let p = {
+				runId: ++this.bakeRunId,
+				source: n.source,
+				phase: "nodes",
+				nodeCount: l,
+				compileMs: c,
+				texturesTotal: f.length,
+				totalMs: 0
+			};
+			this.emitReport(p);
+			for (let t of s) {
+				let n = e.cacheMaterial(t.cacheId);
+				n.colorNode = t.colorNode, n.needsUpdate = !0, Yi(r, n, e.cacheTarget(t.cacheId, ta(e.size, t.sizing), na(t.sizing)));
+			}
+			let m = 0;
+			if (ra) {
+				this.emitReport({
+					...p,
+					phase: "shaders"
+				});
+				let e = performance.now();
+				this.compileGateDepth += 1;
+				try {
+					await Ji(r, f.map((e) => e.mat));
+				} finally {
+					--this.compileGateDepth;
+				}
+				m = performance.now() - e;
+			}
+			let h = performance.now();
+			for (let e of f) Xi(r, e.mat, e.target, e.isNormal);
+			let g = performance.now() - h, _ = [...d].sort().join(",") + (e.hasHeight ? "|h" : ""), v = _ !== e.signature;
+			e.present = d, e.signature = _;
+			let y = performance.now();
+			await this.gpuSync(e);
+			let b = performance.now() - y, x = c + m + g + b;
+			return this.emitReport({
+				...p,
+				phase: "done",
+				totalMs: x
+			}), console.log(`[bake-prof] rebuild compile=${c.toFixed(1)} precompile=${m.toFixed(1)} dispatch=${g.toFixed(1)} gpuWait=${b.toFixed(1)} total=${x.toFixed(1)}ms`), v;
+		});
+	}
+	async gpuSync(e) {
+		let t = this.renderer;
+		if (!t) return;
+		let n = t.backend?.device?.queue;
+		if (n?.onSubmittedWorkDone) {
+			await n.onSubmittedWorkDone();
+			return;
+		}
+		let r = e.firstTarget();
+		r && await t.readRenderTargetPixelsAsync(r, 0, 0, 1, 1);
+	}
+	rerenderInto(e, t) {
+		let n = this.queue.then(async () => {
+			let n = this.renderer;
+			if (!n) return;
+			let r = e.present.size + (e.hasHeight && e.heightTarget ? 1 : 0), i = {
+				runId: ++this.bakeRunId,
+				source: t,
+				phase: "render",
+				nodeCount: 0,
+				compileMs: 0,
+				texturesTotal: r,
+				totalMs: 0
+			};
+			this.emitReport(i);
+			let a = performance.now();
+			for (let t of e.cachePlan) Yi(n, e.cacheMaterial(t.cacheId), e.cacheTarget(t.cacheId, ta(e.size, t.sizing), na(t.sizing)));
+			for (let t of e.present) Xi(n, e.channelMaterial(t), e.target(t), t === "normal");
+			e.hasHeight && e.heightTarget && Xi(n, e.channelMaterial("height"), e.heightTarget, !1);
+			let o = performance.now() - a, s = performance.now();
+			await this.gpuSync(e);
+			let c = performance.now() - s;
+			this.emitReport({
+				...i,
+				phase: "done",
+				totalMs: o + c
+			}), console.log(`[bake-prof] rerender dispatch=${o.toFixed(1)} gpuWait=${c.toFixed(1)}ms`);
+		});
+		return this.queue = n.then(() => void 0, () => void 0), n;
+	}
+	async bake(e, t = {}) {
+		let n = this.createTextureSet(t.channels, t.size);
+		return await this.bakeInto(n, e, t), n;
+	}
+	readImage(e, t, n = 512) {
+		return this.enqueue(`read:${t}`, async () => {
+			let r = this.renderer;
+			if (!r) return null;
+			let { bundle: i, cachePlan: a } = e.compileBundle({
+				backend: "offline",
+				allocCache: (e, t, r) => this.scratchCache(e, n, ta(n, r), na(r)).rt.texture
+			}), o = i[t];
+			if (!o) return null;
+			for (let e of a) {
+				let t = this.scratchCache(e.cacheId, n, ta(n, e.sizing), na(e.sizing));
+				t.mat.colorNode = e.colorNode, t.mat.needsUpdate = !0, Yi(r, t.mat, t.rt);
+			}
+			let s = this.scratchTarget(n);
+			Zi(r, Fi(o, t), s, t === "normal");
+			let c = await r.readRenderTargetPixelsAsync(s, 0, 0, n, n), l = new Uint8ClampedArray(n * n * 4), u = n * 4;
+			for (let e = 0; e < n; e++) {
+				let t = (n - 1 - e) * u;
+				l.set(c.subarray(t, t + u), e * u);
+			}
+			return new ImageData(l, n, n);
+		});
+	}
+	scratchTarget(e) {
+		return (!this.scratch || this.scratchSize !== e) && (this.scratch?.dispose(), this.scratch = new u(e, e), this.scratchSize = e), this.scratch;
+	}
+	scratchCache(e, t, n, r = !1) {
+		if (this.scratchCacheSize !== t) {
+			for (let e of this.scratchCaches.values()) e.rt.dispose(), e.mat.dispose();
+			this.scratchCaches.clear(), this.scratchCacheSize = t;
+		}
+		let i = this.scratchCaches.get(e);
+		return i && i.rt.texture.generateMipmaps !== r && (i.rt.dispose(), i.mat.dispose(), this.scratchCaches.delete(e), i = void 0), i ? (i.rt.width !== n || i.rt.height !== n) && i.rt.setSize(n, n) : (i = {
+			rt: oa(n, r),
+			mat: Wi()
+		}, this.scratchCaches.set(e, i)), i;
+	}
+}, la = new ca();
+//#endregion
+//#region src/tsl/triplanar.ts
+function ua(e) {
+	let t = R(ue.abs(), e);
+	return t.div(t.dot(q(1, 1, 1)).max(1e-4));
+}
+function da(e, t, n) {
+	return d(() => {
+		let r = me.mul(t), i = ua(n), a = H(e, r.yz).mul(i.x), o = H(e, r.zx).mul(i.y), s = H(e, r.xy).mul(i.z);
+		return a.add(o).add(s);
+	})();
+}
+//#endregion
+//#region src/tsl/triplanar-normal.ts
+function fa(e, t, n) {
+	return d(() => {
+		let r = me.mul(t), i = ua(n), a = ue.sign(), o = H(e, r.yz).xyz.mul(2).sub(1), s = H(e, r.zx).xyz.mul(2).sub(1), c = H(e, r.xy).xyz.mul(2).sub(1), l = q(o.x, o.y, o.z.mul(a.x)), u = q(s.x, s.y, s.z.mul(a.y)), d = q(c.x, c.y, c.z.mul(a.z));
+		return l.zxy.mul(i.x).add(u.yzx.mul(i.y)).add(d.xyz.mul(i.z)).normalize();
+	})();
+}
+//#endregion
+//#region src/tsl/parallax.ts
+var pa = .3;
+function ma(e, t, n, r) {
+	return d(() => {
+		let i = fe.normalize(), a = (t) => H(e, t).x, o = 1 / r, s = i.xy.div(i.z.abs().max(pa)).mul(n).mul(o), c = t.toVar(), l = _(!1).toVar(), u = t, d = k(1).sub(a(u));
+		for (let e = 0; e < r; e++) {
+			let t = u.sub(s), n = k(1).sub(a(t)), r = (e + 1) * o, i = k(r).greaterThanEqual(n), f = n.sub(r), p = d.sub(e * o), m = ye(f.div(f.sub(p).max(1e-5))), h = I(t, u, m);
+			c.assign(z(l.not().and(i), h, c)), l.assign(l.or(i)), u = t, d = n;
+		}
+		return c;
+	})();
+}
+//#endregion
+//#region src/graph/textured-surface.ts
+var ha = 12, ga = class {
+	graph;
+	service;
+	source;
+	offlineMat = hi();
+	liveUniforms = /* @__PURE__ */ new Map();
+	material_;
+	scaleUniform = W(1.2);
+	sharpnessUniform = W(8);
+	roughnessFactor = W(1);
+	metalnessFactor = W(1);
+	colorTint = W(new e.Color(1, 1, 1));
+	parallaxScale = W(0);
+	lastBakeMs = 0;
+	set;
+	backend = "offline";
+	debugNormals = !1;
+	triplanar = !1;
+	wiredOnce = !1;
+	lastPresent = /* @__PURE__ */ new Set();
+	updateInFlight = !1;
+	pendingKind = "none";
+	flushRequested = !1;
+	listeners = /* @__PURE__ */ new Set();
+	lastError_ = null;
+	constructor(e, t, n) {
+		this.graph = e, this.service = t, this.source = n, this.set = t.createTextureSet(ia, this.surfaceBakeSize()), this.material_ = this.buildLive(), this.graph.onChange((e) => this.onGraphChange(e));
+	}
+	get material() {
+		return this.material_;
+	}
+	get lastError() {
+		return this.lastError_;
+	}
+	getLastBakeMs() {
+		return this.backend === "offline" ? this.lastBakeMs : 0;
+	}
+	onRebuilt(e) {
+		return this.listeners.add(e), () => this.listeners.delete(e);
+	}
+	notify() {
+		for (let e of this.listeners) e();
+	}
+	refresh() {
+		return this.rebuild();
+	}
+	regenerate() {
+		this.flushRequested = !0, this.requestUpdate("rebuild");
+	}
+	setScale(e) {
+		this.scaleUniform.value = e;
+	}
+	setSharpness(e) {
+		this.sharpnessUniform.value = e;
+	}
+	setRoughnessFactor(e) {
+		this.roughnessFactor.value = e;
+	}
+	setMetalnessFactor(e) {
+		this.metalnessFactor.value = e;
+	}
+	setColorTint(e) {
+		this.colorTint.value.set(e);
+	}
+	setParallaxScale(e) {
+		let t = this.parallaxScale.value > 0;
+		this.parallaxScale.value = e, e > 0 !== t && this.wire(this.lastPresent);
+	}
+	setTriplanar(e) {
+		e !== this.triplanar && (this.triplanar = e, this.wire(this.lastPresent));
+	}
+	setNormalDebug(e) {
+		e !== this.debugNormals && (this.debugNormals = e, this.wire(this.lastPresent));
+	}
+	setBackend(e) {
+		e !== this.backend && (this.backend = e, this.rebuild());
+	}
+	getBackend() {
+		return this.backend;
+	}
+	onGraphChange(e) {
+		if (e.kind !== "layout") {
+			if (e.kind === "param") {
+				if (this.backend === "live") {
+					if (this.updateLiveUniform(e)) return;
+					this.requestUpdate("rebuild");
+					return;
+				}
+				if (this.updateOfflineUniform(e)) {
+					this.requestUpdate("rerender");
+					return;
+				}
+				this.requestUpdate("rebuild");
+				return;
+			}
+			this.requestUpdate("rebuild");
+		}
+	}
+	applyUniformValue(t, n) {
+		if (n.paramType === "color") t.value = new e.Color(n.value);
+		else if (n.paramType === "vec3") {
+			let e = n.value;
+			t.value.set(e.x, e.y, e.z);
+		} else if (n.paramType === "curve") {
+			let e = Me(n.value), r = t.array;
+			for (let t = 0; t < e.length; t++) r[t] = e[t];
+		} else t.value = Number(n.value);
+	}
+	updateLiveUniform(e) {
+		let t = this.liveUniforms.get(e.nodeId)?.[e.key];
+		return t ? (this.applyUniformValue(t, e), !0) : !1;
+	}
+	updateOfflineUniform(e) {
+		if (e.bakeStructural) return !1;
+		let t = this.set.uniforms.get(e.nodeId)?.[e.key];
+		return t ? (this.applyUniformValue(t, e), !0) : !1;
+	}
+	requestUpdate(e) {
+		(e === "rebuild" || this.pendingKind === "none") && (this.pendingKind = e), this.pump();
+	}
+	async pump() {
+		if (!this.updateInFlight) {
+			this.updateInFlight = !0;
+			try {
+				for (; this.pendingKind !== "none";) {
+					let e = this.pendingKind;
+					this.pendingKind = "none", e === "rebuild" ? await this.rebuild() : await this.rerenderOffline();
+				}
+			} finally {
+				this.updateInFlight = !1;
+			}
+		}
+	}
+	async rerenderOffline() {
+		if (!(this.backend !== "offline" || !this.service.hasRenderer)) try {
+			await this.service.rerenderInto(this.set, this.source), this.lastError_ = this.graph.lastError;
+		} catch (e) {
+			this.lastError_ = e instanceof Error ? e.message : String(e), console.warn("[textured-surface] re-render failed:", this.lastError_);
+		}
+	}
+	surfaceBakeSize() {
+		return Math.max(64, Math.round(si(this.graph.document) / 64) * 64);
+	}
+	async rebuild() {
+		try {
+			if (this.backend === "offline" && this.service.hasRenderer) {
+				let e = this.surfaceBakeSize();
+				this.flushRequested && (this.flushRequested = !1, this.set.flushCaches()), this.set.resize(e);
+				let t = this.graph.soloNode ?? void 0, n = performance.now(), r = await this.service.bakeInto(this.set, this.graph, {
+					soloNodeId: t,
+					label: "surface",
+					source: this.source
+				});
+				this.lastBakeMs = performance.now() - n, (r || !this.wiredOnce) && (this.wire(this.set.present), this.wiredOnce = !0), this.material_ = this.offlineMat;
+			} else this.material_ = this.buildLive();
+			this.lastError_ = this.graph.lastError;
+		} catch (e) {
+			this.lastError_ = e instanceof Error ? e.message : String(e), console.warn("[textured-surface] rebuild failed:", this.lastError_);
+		}
+		this.notify();
+	}
+	buildLive() {
+		let e = this.graph.soloNode ?? void 0, { material: t, uniforms: n } = _i(this.graph.document, this.graph.getRegistry(), {
+			backend: "live",
+			soloNodeId: e
+		});
+		return this.liveUniforms = n, t;
+	}
+	wire(e) {
+		this.lastPresent = e;
+		let t = this.offlineMat, n = this.scaleUniform, r = this.sharpnessUniform, i = this.set.hasHeight && !this.triplanar && this.parallaxScale.value > 0, a = G(), o = i ? ma(this.set.heightTarget.texture, a, this.parallaxScale, ha) : void 0, s = a.dFdx(), c = a.dFdy(), l = (e) => i ? H(e, o).grad(s, c) : H(e), u = (e) => this.triplanar ? da(this.set.texture(e), n, r) : l(this.set.texture(e)), d = e.has("normal") ? this.triplanar ? fa(this.set.texture("normal"), n, r) : le(l(this.set.texture("normal")).xyz, k(1)) : ue;
+		if (this.debugNormals) {
+			t.colorNode = q(0, 0, 0), t.emissiveNode = d.normalize().mul(.5).add(.5), t.roughnessNode = t.metalnessNode = t.aoNode = t.normalNode = null, t.needsUpdate = !0;
+			return;
+		}
+		t.colorNode = e.has("baseColor") ? u("baseColor").mul(this.colorTint) : null, t.roughnessNode = e.has("roughness") ? u("roughness").r.mul(this.roughnessFactor) : null, t.metalnessNode = e.has("metallic") ? u("metallic").r.mul(this.metalnessFactor) : null;
+		let f = g("vertexAo", "float");
+		t.aoNode = e.has("ambientOcclusion") ? u("ambientOcclusion").r.mul(f) : f, t.normalNode = e.has("normal") ? d : null, t.emissiveNode = e.has("emission") ? u("emission") : null, t.needsUpdate = !0;
+	}
+	dispose() {
+		this.set.dispose(), this.offlineMat.dispose();
+	}
+}, _a = class {
+	graph;
+	surface;
+	service;
+	constructor(e = {}) {
+		this.service = e.bakeService ?? la, this.graph = new Mi(e.document, e.registry ?? ti), this.surface = new ga(this.graph, this.service, e.source);
+	}
+	get material() {
+		return this.surface.material;
+	}
+	get lastError() {
+		return this.surface.lastError ?? this.graph.lastError;
+	}
+	setRenderer(e) {
+		return this.service.attachRenderer(e), this;
+	}
+	setBackend(e) {
+		return this.surface.setBackend(e), this;
+	}
+	getBackend() {
+		return this.surface.getBackend();
+	}
+	fromDocument(e) {
+		return this.setDocument(e);
+	}
+	setDocument(e) {
+		return this.graph.setDocument(e), this;
+	}
+	getDocument() {
+		return this.graph.getDocument();
+	}
+	setOutputResolution(e) {
+		return this.graph.setOutputResolution(e), this;
+	}
+	setOutputTargets(e) {
+		return this.graph.setOutputTargets(e), this;
+	}
+	setNodeParam(e, t, n) {
+		return this.graph.setNodeParam(e, t, n), this;
+	}
+	updateNodeParams(e, t) {
+		return this.graph.updateNodeParams(e, t), this;
+	}
+	refresh() {
+		return this.surface.refresh();
+	}
+	regenerate() {
+		return this.surface.regenerate(), this;
+	}
+	dispose() {
+		this.surface.dispose();
+	}
+};
+//#endregion
+//#region src/topology.ts
+function va(e) {
+	return Array.isArray(e) ? `[${e.map(va).join(",")}]` : e && typeof e == "object" ? `{${Object.entries(e).sort(([e], [t]) => e.localeCompare(t)).map(([e, t]) => `${e}:${va(t)}`).join(",")}}` : JSON.stringify(e);
+}
+function ya(e, t) {
+	let n = t.get(e.type), r = n.paramsFor ? n.paramsFor(e.params) : n.params, i = {};
+	for (let t of r) (t.type === "int" || t.type === "bool" || t.type === "select" || t.bakeStructural) && (i[t.key] = e.params[t.key]);
+	return i;
+}
+function ba(e, t) {
+	return {
+		id: e.id,
+		type: e.type,
+		enabled: e.enabled,
+		ports: Z(e, t),
+		params: ya(e, t),
+		subgraph: e.subgraph ? xa(e.subgraph, t) : null
+	};
+}
+function xa(e, t) {
+	return {
+		version: e.version,
+		nodes: e.nodes.map((e) => ba(e, t)).sort((e, t) => String(e.id).localeCompare(String(t.id))),
+		edges: [...e.edges].sort((e, t) => va(e).localeCompare(va(t)))
+	};
+}
+function Sa(e, t) {
+	return va(xa(e, t));
+}
+//#endregion
+//#region src/graph/tiling-test.ts
+function Ca(e) {
+	return {
+		version: 2,
+		nodes: [
+			{
+				id: "n",
+				type: "tileable-noise",
+				params: {
+					noiseType: e,
+					scale: 5,
+					octaves: 4,
+					gain: .5
+				},
+				position: {
+					x: 0,
+					y: 0
+				},
+				enabled: !0
+			},
+			{
+				id: "pr",
+				type: "principled-bsdf",
+				params: {},
+				position: {
+					x: 300,
+					y: 0
+				},
+				enabled: !0
+			},
+			{
+				id: "out",
+				type: "material-output",
+				params: {},
+				position: {
+					x: 600,
+					y: 0
+				},
+				enabled: !0
+			}
+		],
+		edges: [{
+			fromNode: "n",
+			fromOutput: "field",
+			toNode: "pr",
+			toInput: "baseColor"
+		}, {
+			fromNode: "pr",
+			fromOutput: "bsdf",
+			toNode: "out",
+			toInput: "surface"
+		}]
+	};
+}
+function wa(e, t) {
+	let n = (n, r) => e.data[(r * t + n) * 4], r = 0, i = 0;
+	for (let e = 0; e < t; e++) {
+		r += Math.abs(n(t - 1, e) - n(0, e));
+		for (let r = 1; r < t; r++) i += Math.abs(n(r, e) - n(r - 1, e));
+	}
+	let a = 0, o = 0;
+	for (let e = 0; e < t; e++) {
+		a += Math.abs(n(e, t - 1) - n(e, 0));
+		for (let r = 1; r < t; r++) o += Math.abs(n(e, r) - n(e, r - 1));
+	}
+	return r /= t, a /= t, i /= t * (t - 1), o /= t * (t - 1), {
+		wrapH: r,
+		wrapV: a,
+		interiorH: i,
+		interiorV: o,
+		ratioH: r / Math.max(i, .001),
+		ratioV: a / Math.max(o, .001)
+	};
+}
+async function Ta(e, t, n = {}) {
+	let r = n.size ?? 256, i = n.threshold ?? 3, a = n.channel ?? "baseColor", o = t.get("tileable-noise").params.find((e) => e.key === "noiseType"), s = n.types ?? o?.options ?? [], c = [];
+	for (let o of s) {
+		let s = new Mi(Ca(o), t), l = await e.readImage(s, a, r);
+		if (!l) {
+			c.push({
+				type: o,
+				ratioH: NaN,
+				ratioV: NaN,
+				wrapH: NaN,
+				wrapV: NaN,
+				interiorH: NaN,
+				interiorV: NaN,
+				pass: !1
+			});
+			continue;
+		}
+		n.onTile && await n.onTile(o, l);
+		let u = wa(l, r);
+		c.push({
+			type: o,
+			...u,
+			pass: u.ratioH <= i && u.ratioV <= i
+		});
+	}
+	return c;
+}
+//#endregion
+export { sa as BakedTextureSet, Re as COERCION_MATRIX, je as CURVE_CHANNELS, Ae as CURVE_IDENTITY, Pe as GROUP_INPUT_TYPE, Fe as GROUP_OUTPUT_TYPE, Ne as GROUP_TYPE, Ti as MATERIAL_DOCUMENT_VERSION, Ie as MATERIAL_OUTPUT_TYPE, ca as MaterialBakeService, _a as MaterialGraphRuntime, Mi as MaterialGraphSession, $r as NodeRegistry, Le as PBR_SOCKETS, ia as SURFACE_CHANNELS, ga as TexturedSurface, la as bakeService, Ei as cloneMaterialDocument, ze as coercionFor, _i as compileGraph, di as compileSockets, ui as countGraphNodes, Di as createDefaultMaterialDocument, ei as createDefaultRegistry, Sa as createMaterialTopologyKey, Me as curveToArray, ti as defaultRegistry, Oi as migrateMaterialDocument, hi as newSurfaceMaterial, Qr as nodeParamDefs, Z as nodePorts, si as readOutputResolution, Ta as runTilingTest };