@openmockup-studio/player 0.0.0-stage → 0.2.0

package/dist/runtime-RiyRiexX.js

@@ -0,0 +1,1956 @@
+import { t as e } from "./rolldown-runtime-CGnMp29N.js";
+import { A as t, B as n, D as r, E as i, F as a, G as o, J as s, K as c, N as l, O as u, P as d, Q as f, R as p, S as m, T as h, V as g, X as _, Y as v, Z as y, _ as b, a as x, b as S, c as C, g as w, j as T, l as E, m as D, o as O, q as k, s as A, t as j, u as M, w as N, x as P, y as F, z as I } from "./three-o_76Nw0r.js";
+import { C as L, S as R, T as z, _ as B, b as V, g as H, h as U, v as W, w as G, x as K, y as q } from "./device-phone-DxWL5LkW.js";
+// ../engine/src/backdrop-math.ts
+var ee = "#f6f6f4";
+function te(e, t) {
+	let n = e.color ?? e.inner ?? e.outer ?? ee;
+	if (e.kind === "image") return t ? {
+		kind: "image",
+		fallback: n
+	} : {
+		kind: "flat",
+		color: n
+	};
+	if (e.kind === "gradient") {
+		let { inner: t, outer: n, angle: r } = e;
+		return t && n ? r !== void 0 && Number.isFinite(r) ? {
+			kind: "linear",
+			inner: t,
+			outer: n,
+			angle: r
+		} : {
+			kind: "radial",
+			inner: t,
+			outer: n
+		} : {
+			kind: "flat",
+			color: t ?? n ?? e.color ?? ee
+		};
+	}
+	return {
+		kind: "flat",
+		color: n
+	};
+}
+function ne(e, t) {
+	let n = e * Math.PI / 180, r = Math.sin(n), i = Math.cos(n);
+	return {
+		x: r,
+		y: i,
+		length: Math.abs(t * r) + Math.abs(i)
+	};
+}
+function re(e, t) {
+	return G(e, t, "cover");
+}
+// ../engine/src/backdrop.ts
+function ie() {
+	let e = new n({
+		depthTest: !1,
+		depthWrite: !1,
+		toneMapped: !1,
+		uniforms: {
+			inner: { value: new D("#f6f6f4") },
+			outer: { value: new D("#d5d5d1") },
+			center: { value: new v(.5, .4) },
+			aspect: { value: 1 },
+			mode: { value: 0 },
+			axis: { value: new _(0, -1, 1) },
+			map: { value: null },
+			uvRepeat: { value: new v(1, 1) },
+			uvOffset: { value: new v(0, 0) }
+		},
+		vertexShader: "\n      varying vec2 vUv;\n      void main() {\n        vUv = uv;\n        gl_Position = vec4(position.xy, 0.0, 1.0);\n      }\n    ",
+		fragmentShader: "\n      #include <common>\n      uniform vec3 inner;\n      uniform vec3 outer;\n      uniform vec2 center;\n      uniform float aspect;\n      uniform int mode;\n      uniform vec3 axis;\n      uniform sampler2D map;\n      uniform vec2 uvRepeat;\n      uniform vec2 uvOffset;\n      varying vec2 vUv;\n      vec3 srgbToLinear(vec3 c) {\n        return mix(pow((c + 0.055) / 1.055, vec3(2.4)), c / 12.92, vec3(lessThanEqual(c, vec3(0.04045))));\n      }\n      void main() {\n        vec3 rgb;\n        if (mode == 3) {\n          // Image: the sRGB texture is already decoded to linear by the GPU.\n          rgb = texture2D(map, vUv * uvRepeat + uvOffset).rgb;\n        } else {\n          vec3 srgb = inner;\n          if (mode == 2) {\n            // CSS linear-gradient(<angle>, inner, outer): project onto the gradient line.\n            vec2 p = (vUv - 0.5) * vec2(aspect, 1.0);\n            float t = clamp(dot(p, axis.xy) / axis.z + 0.5, 0.0, 1.0);\n            srgb = mix(inner, outer, t);\n          } else if (mode == 1) {\n            // CSS radial-gradient(circle ...): radius reaches the farthest corner.\n            vec2 d = (vUv - center) * vec2(aspect, 1.0);\n            vec2 far = max(center, 1.0 - center) * vec2(aspect, 1.0);\n            float t = clamp(length(d) / length(far), 0.0, 1.0);\n            srgb = mix(inner, outer, t);\n          }\n          rgb = srgbToLinear(srgb);\n        }\n        gl_FragColor = vec4(rgb, 1.0);\n        #include <colorspace_fragment>\n      }\n    "
+	}), t = new r(new d(2, 2), e);
+	t.frustumCulled = !1;
+	let i = new I();
+	i.add(t);
+	let a = new T(-1, 1, 1, -1, 0, 1), o = new v(), s = (e, t) => e.setStyle(t, N), c = null, l = 1;
+	return {
+		setImage(e, t = 1) {
+			c = e, l = t;
+		},
+		render(t, n) {
+			if (n.kind === "transparent") return;
+			let r = e.uniforms;
+			t.getDrawingBufferSize(o);
+			let u = t.getRenderTarget(), d = u ? u.width / u.height : o.x / o.y;
+			r.aspect.value = d;
+			let f = te(n, c !== null);
+			if (f.kind === "image") {
+				let { repeat: e, offset: t } = re(l, d);
+				r.uvRepeat.value.set(e[0], e[1]), r.uvOffset.value.set(t[0], t[1]), r.map.value = c, r.mode.value = 3;
+			} else if (f.kind === "flat") s(r.inner.value, f.color), r.mode.value = 0;
+			else if (s(r.inner.value, f.inner), s(r.outer.value, f.outer), f.kind === "linear") {
+				let e = ne(f.angle, d);
+				r.axis.value.set(e.x, e.y, e.length), r.mode.value = 2;
+			} else r.mode.value = 1;
+			t.render(i, a);
+		},
+		dispose() {
+			t.geometry.dispose(), e.dispose();
+		}
+	};
+}
+// ../engine/src/camera.ts
+var ae = Math.PI / 180, oe = new _(), se = new _();
+function ce(e, t) {
+	e.position.set(t.position[0], t.position[1], t.position[2]), oe.set(t.target[0], t.target[1], t.target[2]).sub(e.position).normalize(), se.set(0, 1, 0).applyAxisAngle(oe, t.roll * ae), e.up.copy(se), e.lookAt(t.target[0], t.target[1], t.target[2]), e.fov !== t.fov && (e.fov = t.fov, e.updateProjectionMatrix());
+}
+// ../engine/src/environment/recipes.ts
+var le = {
+	studio: {
+		room: [
+			[0, "#55555a"],
+			[.38, "#3a3a3e"],
+			[.5, "#262629"],
+			[.62, "#323236"],
+			[1, "#4a4a4e"]
+		],
+		feather: .15,
+		keySize: 1,
+		gain: {
+			key: 1,
+			overhead: 1,
+			strip: 1,
+			rim: 1,
+			rear: 1,
+			fill: 1,
+			bounce: 1,
+			sweep: 1
+		},
+		shadow: {
+			opacity: 1,
+			radius: 28
+		}
+	},
+	soft: {
+		room: [
+			[0, "#5e5e63"],
+			[.38, "#4c4c51"],
+			[.5, "#3e3e43"],
+			[.62, "#47474b"],
+			[1, "#55555a"]
+		],
+		feather: .3,
+		keySize: 1.5,
+		gain: {
+			key: .72,
+			overhead: 1.25,
+			strip: .55,
+			rim: .5,
+			rear: .6,
+			fill: 1.25,
+			bounce: 1.2,
+			sweep: 1
+		},
+		shadow: {
+			opacity: .75,
+			radius: 40
+		}
+	},
+	contrast: {
+		room: [
+			[0, "#46464c"],
+			[.38, "#27272b"],
+			[.5, "#111113"],
+			[.62, "#1b1b1e"],
+			[1, "#35353a"]
+		],
+		feather: .1,
+		keySize: .85,
+		gain: {
+			key: 1.45,
+			overhead: .8,
+			strip: 1.5,
+			rim: 1.5,
+			rear: 1.3,
+			fill: .45,
+			bounce: .4,
+			sweep: .35
+		},
+		shadow: {
+			opacity: 1.25,
+			radius: 20
+		}
+	},
+	night: {
+		room: [
+			[0, "#17181e"],
+			[.38, "#0b0c10"],
+			[.5, "#050506"],
+			[.62, "#08080a"],
+			[1, "#0f1014"]
+		],
+		feather: .22,
+		keySize: .9,
+		gain: {
+			key: .55,
+			overhead: .7,
+			strip: .9,
+			rim: 1.1,
+			rear: .8,
+			fill: .18,
+			bounce: .15,
+			sweep: .1
+		},
+		shadow: {
+			opacity: .6,
+			radius: 30
+		}
+	}
+};
+function ue(e) {
+	return e !== void 0 && Object.hasOwn(le, e) ? e : "studio";
+}
+// ../engine/src/environment/studio.ts
+function de(e, t = "studio") {
+	let n = le[t], i = new I(), a = [], s = pe(1, 256, n.room), c = new o(60, 48, 24), l = new u({
+		map: s,
+		side: 1
+	});
+	i.add(new r(c, l)), a.push(s, c, l);
+	let f = me("none", n.feather), p = me("top", n.feather), m = me("left", n.feather);
+	a.push(f, p, m);
+	let h = (e, t, o, s, c, l) => {
+		let f = new d(t, o), p = new u({
+			side: 2,
+			map: l,
+			transparent: !0,
+			blending: 2,
+			depthWrite: !1
+		});
+		p.color.setScalar(s * n.gain[e]);
+		let m = new r(f, p);
+		m.position.set(...c), m.lookAt(0, 0, 0), i.add(m), a.push(f, p);
+	};
+	h("key", 22 * n.keySize, 16 * n.keySize, 3.2, [
+		-11,
+		8,
+		12
+	], p), h("overhead", 30, 20, 1.3, [
+		0,
+		18,
+		2
+	], f), h("strip", 5, 26, 6.5, [
+		16,
+		2,
+		4
+	], f), h("rim", 5, 26, 4.5, [
+		-16,
+		1,
+		-5
+	], f), h("rear", 20, 12, 2, [
+		4,
+		7,
+		-16
+	], p), h("fill", 30, 18, .85, [
+		-4,
+		4,
+		26
+	], m), h("bounce", 26, 8, .6, [
+		3,
+		-6,
+		18
+	], f), h("sweep", 56, 56, .55, [
+		0,
+		-14,
+		3
+	], f);
+	let g = new x(e), _ = g.fromScene(i, .035).texture;
+	g.dispose();
+	for (let e of a) e.dispose();
+	return _;
+}
+function fe(e, t) {
+	let n = document.createElement("canvas");
+	return n.width = e, n.height = t, [n, n.getContext("2d")];
+}
+function pe(e, t, n) {
+	let [r, i] = fe(e, t);
+	if (i) {
+		let r = i.createLinearGradient(0, 0, 0, t);
+		for (let [e, t] of n) r.addColorStop(e, t);
+		i.fillStyle = r, i.fillRect(0, 0, e, t);
+	}
+	let a = new M(r);
+	return a.colorSpace = p, a;
+}
+function me(e, t) {
+	let [n, r] = fe(128, 128);
+	if (r) {
+		let n = r.createImageData(128, 128), i = (e, t, n) => {
+			let r = Math.min(1, Math.max(0, (n - e) / (t - e)));
+			return r * r * (3 - 2 * r);
+		};
+		for (let r = 0; r < 128; r++) for (let a = 0; a < 128; a++) {
+			let o = (a + .5) / 128, s = (r + .5) / 128, c = i(0, t, Math.min(o, 1 - o, s, 1 - s));
+			e === "top" && (c *= .35 + .65 * (1 - s)), e === "left" && (c *= .3 + .7 * (1 - o));
+			let l = Math.round(c * 255), u = (r * 128 + a) * 4;
+			n.data[u] = n.data[u + 1] = n.data[u + 2] = l, n.data[u + 3] = 255;
+		}
+		r.putImageData(n, 0, 0);
+	}
+	return new M(n);
+}
+// ../engine/src/floor.ts
+function he(e, t) {
+	let n = new b(16777215, .6);
+	n.position.set(.6, 30, 1.2), n.castShadow = !0, n.shadow.mapSize.set(512, 512), Object.assign(n.shadow.camera, {
+		left: -12,
+		right: 12,
+		top: 12,
+		bottom: -12,
+		near: 1,
+		far: 60
+	}), n.shadow.radius = 28, n.shadow.blurSamples = 25, n.shadow.bias = -5e-4, e.add(n, n.target);
+	let i = new g({ opacity: .22 }), a = new r(new d(80, 80), i);
+	return a.rotation.x = -Math.PI / 2, a.position.y = t, a.receiveShadow = !0, e.add(a), {
+		light: n,
+		ground: a,
+		setY(e) {
+			a.position.y = e;
+		},
+		setOpacity(e) {
+			i.opacity = e;
+		},
+		setVisible(e) {
+			a.visible = e;
+		},
+		fit(e) {
+			let t = Math.max(4, e * 1.3), r = n.shadow.camera;
+			r.right !== t && (Object.assign(r, {
+				left: -t,
+				right: t,
+				top: t,
+				bottom: -t,
+				far: Math.max(60, t * 6)
+			}), n.position.set(.6, Math.max(30, t * 2.5), 1.2), r.updateProjectionMatrix(), a.scale.setScalar(Math.max(1, t / 10)));
+		},
+		dispose() {
+			e.remove(n, n.target, a), a.geometry.dispose(), i.dispose(), n.dispose();
+		}
+	};
+}
+// ../engine/src/glow.ts
+var J = 4;
+function ge(e) {
+	let t = /* @__PURE__ */ new Map(), i = new f(J, J, { type: s }), a = /* @__PURE__ */ new Uint8Array(64), o = new n({
+		uniforms: { map: { value: null } },
+		vertexShader: "\n      varying vec2 vUv;\n      void main() { vUv = uv; gl_Position = vec4(position.xy, 0.0, 1.0); }\n    ",
+		fragmentShader: `
+      uniform sampler2D map;
+      varying vec2 vUv;
+      void main() {
+        vec2 cell = vec2(${(1 / J).toFixed(4)});
+        vec2 origin = floor(vUv * ${J.toFixed(1)}) * cell;
+        vec3 sum = vec3(0.0);
+        for (int y = 0; y < 4; y++) for (int x = 0; x < 4; x++) {
+          sum += texture2D(map, origin + (vec2(x, y) + 0.5) * cell / 4.0).rgb;
+        }
+        // sqrt keeps precision in the darks through the 8-bit target.
+        gl_FragColor = vec4(sqrt(sum / 16.0), 1.0);
+      }
+    `,
+		depthTest: !1,
+		depthWrite: !1
+	}), l = new r(new d(2, 2), o);
+	l.frustumCulled = !1;
+	let u = new I();
+	u.add(l);
+	let p = new T(-1, 1, 1, -1, 0, 1);
+	function m(t, n) {
+		o.uniforms.map.value = t;
+		let r = e.getRenderTarget();
+		e.setRenderTarget(i), e.render(u, p), e.readRenderTargetPixels(i, 0, 0, J, J, a), e.setRenderTarget(r);
+		let s = 0, c = 0, l = 0;
+		for (let e = 0; e < a.length; e += 4) s += (a[e] / 255) ** 2, c += (a[e + 1] / 255) ** 2, l += (a[e + 2] / 255) ** 2;
+		n.setRGB(s / 16, c / 16, l / 16, N);
+	}
+	function g(e) {
+		let n = t.get(e);
+		if (n) return n;
+		let r = e.mesh.geometry;
+		r.computeBoundingBox();
+		let i = r.boundingBox, a = i.max.x - i.min.x, o = i.max.y - i.min.y, s = (i.max.x + i.min.x) / 2, l = (i.max.y + i.min.y) / 2, u = i.max.z + .05, d = [];
+		for (let t of [-o / 4, o / 4]) {
+			let n = new c(16777215, 0, 0, h.degToRad(88), 1, 2);
+			n.position.set(s, l + t, u), n.target.position.set(s, l + t, u + 10), e.mesh.add(n, n.target), d.push(n);
+		}
+		return n = {
+			surface: e,
+			lights: d,
+			area: a * o,
+			color: new D(0, 0, 0),
+			measured: ""
+		}, t.set(e, n), n;
+	}
+	function _(e) {
+		for (let t of e.lights) t.parent?.remove(t, t.target), t.dispose();
+	}
+	return {
+		update(e, n) {
+			let r = new Set(e.map((e) => e.surface));
+			for (let [e, n] of t) r.has(e) || (_(n), t.delete(e));
+			if (!(n <= 0 && t.size === 0)) for (let { surface: t, texture: r } of e) {
+				let e = g(t), i = r ? `${r.uuid}:${r.version}` : "";
+				i !== e.measured && (e.measured = i, r ? m(r, e.color) : e.color.setRGB(0, 0, 0));
+				let a = n * e.area * 1.2;
+				for (let t of e.lights) t.color.copy(e.color), t.intensity = a, t.visible = n > 0;
+			}
+		},
+		dispose() {
+			for (let e of t.values()) _(e);
+			t.clear(), i.dispose(), o.dispose(), l.geometry.dispose();
+		}
+	};
+}
+var _e = Math.PI / 180, ve = .25, ye = .012, be = .016, xe = .7, Se = .3, Ce = .9, we = 5, Te = 24, Ee = 12, De = 24, Y = (e) => typeof e == "number" && e > 0 ? e : 0;
+function Oe(e) {
+	return Y(e.fisheye) > 0 || Y(e.chromatic) > 0 || Y(e.vignette) > 0 || Y(e.bloom) > 0 || Y(e.grain) > 0 || Y(e.blur) > 0 || Y(e.fade) > 0;
+}
+var X = "\n  varying vec2 vUv;\n  void main() {\n    vUv = uv;\n    gl_Position = vec4(position.xy, 0.0, 1.0);\n  }\n", ke = "\n  uniform float camNear;\n  uniform float camFar;\n  uniform float focus;\n  uniform float maxCoc; // blur * MAX_COC * frame height, in pixels\n\n  float viewZ(float d) {\n    if (d >= 0.99999) return camFar;\n    float z = d * 2.0 - 1.0;\n    return 2.0 * camNear * camFar / (camFar + camNear - z * (camFar - camNear));\n  }\n  float cocOf(float d) {\n    return maxCoc * clamp(abs(1.0 - focus / viewZ(d)), 0.0, 1.0);\n  }\n";
+function Ae(e, t = 4) {
+	let i = 1, a = 1, o = 1, c = new w(1, 1, F), l = new f(1, 1, {
+		type: m,
+		colorSpace: N,
+		samples: t,
+		depthBuffer: !0,
+		depthTexture: c
+	}), p = new f(1, 1, {
+		type: s,
+		samples: t,
+		depthBuffer: !0
+	}), h = new u({ color: 0 }), g = new u({ color: 16777215 }), _ = new f(1, 1, {
+		type: m,
+		colorSpace: N,
+		depthBuffer: !1,
+		count: 2
+	}), y = [];
+	for (let e = 0; e < we; e++) y.push(new f(1, 1, {
+		type: m,
+		colorSpace: N,
+		depthBuffer: !1
+	}));
+	let b = new n({
+		glslVersion: S,
+		depthTest: !1,
+		depthWrite: !1,
+		toneMapped: !1,
+		uniforms: {
+			tColor: { value: l.texture },
+			tMask: { value: p.texture },
+			tDepth: { value: c },
+			texel: { value: new v(1, 1) },
+			camNear: { value: 1 },
+			camFar: { value: 100 },
+			focus: { value: 1 },
+			maxCoc: { value: 0 }
+		},
+		vertexShader: X,
+		fragmentShader: `
+      uniform sampler2D tColor;
+      uniform sampler2D tMask;
+      uniform sampler2D tDepth;
+      uniform vec2 texel; // 1 / full-resolution size
+      ${ke}
+      varying vec2 vUv;
+      layout(location = 0) out highp vec4 outColor;
+      layout(location = 1) out highp vec4 outMask;
+
+      float ign(vec2 p) {
+        return fract(52.9829189 * fract(dot(p, vec2(0.06711056, 0.00583715))));
+      }
+
+      void main() {
+        float d0 = texture2D(tDepth, vUv).x;
+        float c0 = cocOf(d0);
+        vec4 col0 = texture2D(tColor, vUv);
+        vec2 m0 = texture2D(tMask, vUv).rg;
+        if (c0 < 0.5) {
+          outColor = col0;
+          outMask = vec4(m0, 0.0, 1.0);
+          return;
+        }
+        float z0 = viewZ(d0);
+        float turn = 6.2831853 * ign(gl_FragCoord.xy);
+        vec4 acc = col0;
+        vec2 macc = m0;
+        float wsum = 1.0;
+        // Small blurs need few taps; only wide ones pay for the full disc.
+        float taps = clamp(8.0 + c0 * 0.7, 8.0, float(${Te}));
+        const int N = ${Te};
+        for (int i = 0; i < N; i++) {
+          if (float(i) >= taps) break;
+          float r = sqrt((float(i) + 0.5) / taps);
+          float a = float(i) * 2.39996323 + turn;
+          float dist = r * c0;
+          vec2 uv = vUv + vec2(cos(a), sin(a)) * dist * texel;
+          float d = texture2D(tDepth, uv).x;
+          float cs = cocOf(d);
+          // A sample behind the centre can't blur over it more than the centre itself blurs.
+          if (viewZ(d) > z0) cs = min(cs, c0);
+          float w = clamp(cs - dist + 1.0, 0.0, 1.0);
+          acc += texture2D(tColor, uv) * w;
+          macc += texture2D(tMask, uv).rg * w;
+          wsum += w;
+        }
+        outColor = acc / wsum;
+        outMask = vec4(macc / wsum, 0.0, 1.0);
+      }
+    `
+	}), x = new n({
+		depthTest: !1,
+		depthWrite: !1,
+		toneMapped: !1,
+		uniforms: {
+			tSrc: { value: l.texture },
+			tSrcMask: { value: p.texture },
+			texel: { value: new v(1, 1) },
+			threshold: { value: xe },
+			knee: { value: Se }
+		},
+		vertexShader: X,
+		fragmentShader: "\n      uniform sampler2D tSrc;\n      uniform sampler2D tSrcMask; // r: exact pixel, g: display\n      uniform vec2 texel; // of the source\n      uniform float threshold;\n      uniform float knee;\n      varying vec2 vUv;\n\n      vec3 bright(vec2 uv) {\n        vec3 c = min(texture2D(tSrc, uv).rgb, vec3(8.0));\n        vec2 m = texture2D(tSrcMask, uv).rg;\n        float geometry = 1.0 - m.r * (1.0 - m.g); // 0 on the bare backdrop\n        float l = dot(c, vec3(0.2126, 0.7152, 0.0722));\n        float rq = clamp(l - threshold + knee, 0.0, 2.0 * knee);\n        rq = rq * rq / (4.0 * knee + 1e-4);\n        float w = max(rq, l - threshold) / max(l, 1e-4);\n        return c * w * geometry;\n      }\n\n      void main() {\n        vec3 s = bright(vUv + texel * vec2(-1.0, -1.0))\n               + bright(vUv + texel * vec2( 1.0, -1.0))\n               + bright(vUv + texel * vec2(-1.0,  1.0))\n               + bright(vUv + texel * vec2( 1.0,  1.0));\n        gl_FragColor = vec4(s * 0.25, 1.0);\n      }\n    "
+	}), C = new n({
+		depthTest: !1,
+		depthWrite: !1,
+		toneMapped: !1,
+		uniforms: {
+			tSrc: { value: null },
+			texel: { value: new v(1, 1) }
+		},
+		vertexShader: X,
+		fragmentShader: "\n      uniform sampler2D tSrc;\n      uniform vec2 texel; // of the source\n      varying vec2 vUv;\n      void main() {\n        vec3 s = texture2D(tSrc, vUv).rgb * 4.0;\n        s += texture2D(tSrc, vUv + texel * vec2(-1.0, -1.0)).rgb;\n        s += texture2D(tSrc, vUv + texel * vec2( 1.0, -1.0)).rgb;\n        s += texture2D(tSrc, vUv + texel * vec2(-1.0,  1.0)).rgb;\n        s += texture2D(tSrc, vUv + texel * vec2( 1.0,  1.0)).rgb;\n        gl_FragColor = vec4(s * 0.125, 1.0);\n      }\n    "
+	}), E = new n({
+		depthTest: !1,
+		depthWrite: !1,
+		toneMapped: !1,
+		blending: 5,
+		blendEquation: 100,
+		blendSrc: 201,
+		blendDst: 201,
+		blendSrcAlpha: 200,
+		blendDstAlpha: 201,
+		uniforms: {
+			tSrc: { value: null },
+			texel: { value: new v(1, 1) }
+		},
+		vertexShader: X,
+		fragmentShader: "\n      uniform sampler2D tSrc;\n      uniform vec2 texel; // of the (smaller) source\n      varying vec2 vUv;\n      void main() {\n        vec2 h = texel * 0.5;\n        vec3 s = texture2D(tSrc, vUv + vec2(-2.0 * h.x, 0.0)).rgb;\n        s += texture2D(tSrc, vUv + vec2( 2.0 * h.x, 0.0)).rgb;\n        s += texture2D(tSrc, vUv + vec2(0.0, -2.0 * h.y)).rgb;\n        s += texture2D(tSrc, vUv + vec2(0.0,  2.0 * h.y)).rgb;\n        s += texture2D(tSrc, vUv + vec2(-h.x, -h.y)).rgb * 2.0;\n        s += texture2D(tSrc, vUv + vec2( h.x, -h.y)).rgb * 2.0;\n        s += texture2D(tSrc, vUv + vec2(-h.x,  h.y)).rgb * 2.0;\n        s += texture2D(tSrc, vUv + vec2( h.x,  h.y)).rgb * 2.0;\n        gl_FragColor = vec4(s / 12.0, 1.0);\n      }\n    "
+	}), D = new n({
+		depthTest: !1,
+		depthWrite: !1,
+		uniforms: {
+			tColor: { value: l.texture },
+			tMask: { value: p.texture },
+			tDepth: { value: c },
+			tDofColor: { value: _.textures[0] },
+			tDofMask: { value: _.textures[1] },
+			tBloom: { value: y[0].texture },
+			overscan: { value: 1 },
+			aspect: { value: 1 },
+			barrel: { value: 0 },
+			chromatic: { value: 0 },
+			vignette: { value: 0 },
+			dofOn: { value: 0 },
+			bloomAmount: { value: 0 },
+			grain: { value: 0 },
+			frame: { value: 0 },
+			fade: { value: 0 },
+			camNear: { value: 1 },
+			camFar: { value: 100 },
+			focus: { value: 1 },
+			maxCoc: { value: 0 }
+		},
+		vertexShader: X,
+		fragmentShader: `
+      // three injects <common> and the tone-mapping functions into every program prefix.
+      uniform sampler2D tColor;
+      uniform sampler2D tMask;
+      uniform sampler2D tDepth;
+      uniform sampler2D tDofColor;
+      uniform sampler2D tDofMask;
+      uniform sampler2D tBloom;
+      uniform float overscan;
+      uniform float aspect;
+      uniform float barrel;
+      uniform float chromatic;
+      uniform float vignette;
+      uniform float dofOn;
+      uniform float bloomAmount;
+      uniform float grain;
+      uniform float frame;
+      uniform float fade;
+      ${ke}
+      varying vec2 vUv;
+
+      // Normalised so r = 1 at the frame corners.
+      vec2 toP(vec2 uv) { return (uv - 0.5) * 2.0 * vec2(aspect, 1.0) / sqrt(aspect * aspect + 1.0); }
+      vec2 toUv(vec2 p) { return p * sqrt(aspect * aspect + 1.0) / vec2(aspect, 1.0) * 0.5 / overscan + 0.5; }
+
+      vec2 warp(vec2 p, float scale) {
+        float r2 = dot(p, p);
+        return p * (1.0 + barrel * r2) * scale;
+      }
+
+      uint pcg(uint v) {
+        uint s = v * 747796405u + 2891336453u;
+        uint w = ((s >> ((s >> 28u) + 4u)) ^ s) * 277803737u;
+        return (w >> 22u) ^ w;
+      }
+
+      void main() {
+        vec2 p = toP(vUv);
+        float r2 = dot(p, p);
+        vec2 uvG = toUv(warp(p, 1.0));
+        vec4 g0 = texture2D(tColor, uvG);
+        vec4 g = g0;
+        float m = texture2D(tMask, uvG).r;
+
+        if (dofOn > 0.5) {
+          // Sharp where the pixel is in focus, the half-resolution gather elsewhere.
+          float w = smoothstep(0.5, 2.0, cocOf(texture2D(tDepth, uvG).x));
+          if (w > 0.0) {
+            g = mix(g0, texture2D(tDofColor, uvG), w);
+            m = mix(m, texture2D(tDofMask, uvG).r, w);
+          }
+        }
+
+        vec3 rgb = g.rgb;
+        if (chromatic > 0.0) {
+          // Fringe from the sharp image, applied on top of the (possibly blurred) base.
+          vec2 uvR = toUv(warp(p, 1.0 + chromatic * r2));
+          vec2 uvB = toUv(warp(p, 1.0 - chromatic * r2));
+          rgb.r += texture2D(tColor, uvR).r - g0.r;
+          rgb.b += texture2D(tColor, uvB).b - g0.b;
+        }
+        rgb = max(rgb, 0.0);
+        float alpha = g.a;
+
+        if (bloomAmount > 0.0) rgb += texture2D(tBloom, uvG).rgb * bloomAmount;
+
+        vec3 mapped = rgb;
+        #ifdef TONE_MAPPING
+          mapped = toneMapping(rgb);
+        #endif
+        rgb = mix(mapped, rgb, m);
+        rgb *= 1.0 - vignette * smoothstep(0.35, 1.25, sqrt(r2));
+
+        if (grain > 0.0) {
+          // Noise lives in a perceptual space so it reads evenly; highlights get less.
+          uvec2 px = uvec2(gl_FragCoord.xy);
+          uint h1 = pcg(px.x + pcg(px.y + pcg(uint(frame))));
+          uint h2 = pcg(h1 ^ 2654435769u);
+          float n = (float(h1) + float(h2)) * (1.0 / 4294967295.0) - 1.0; // triangular, -1..1
+          vec3 e = pow(rgb, vec3(1.0 / 2.2));
+          float l = dot(e, vec3(0.299, 0.587, 0.114));
+          float shade = 1.0 - 0.5 * smoothstep(0.5, 0.95, l);
+          e += n * grain * 0.16 * shade * alpha;
+          rgb = pow(max(e, 0.0), vec3(2.2));
+        }
+
+        rgb *= 1.0 - fade;
+        alpha = mix(alpha, 1.0, fade);
+        gl_FragColor = vec4(rgb, alpha);
+        #include <colorspace_fragment>
+      }
+    `
+	}), O = new r(new d(2, 2), D);
+	O.frustumCulled = !1;
+	let k = new I();
+	k.add(O);
+	let A = new T(-1, 1, 1, -1, 0, 1);
+	function j(t, n) {
+		O.material = t, e.setRenderTarget(n), e.render(k, A);
+	}
+	let M = 2;
+	function P() {
+		_.setSize(Math.max(1, Math.ceil(l.width / M)), Math.max(1, Math.ceil(l.height / M)));
+	}
+	function L(e) {
+		let t = Math.ceil(e / .04) * .04, n = Math.max(1, Math.round(i * t)), r = Math.max(1, Math.round(a * t));
+		(t !== o || l.width !== n || l.height !== r) && (o = t, l.setSize(n, r), p.setSize(n, r), P(), y.forEach((e, t) => {
+			let i = 2 ** (t + 1);
+			e.setSize(Math.max(1, Math.ceil(n / i)), Math.max(1, Math.ceil(r / i)));
+		}));
+	}
+	let R = new v();
+	return {
+		setSize(e, t) {
+			i = e, a = t, L(o);
+		},
+		render(t, n, r, s, c, u = [], d = 0) {
+			let f = Y(c.fisheye), m = Y(c.chromatic), v = Y(c.vignette), S = Math.min(1, Y(c.bloom)), w = Math.min(1, Y(c.grain)), T = Math.min(1, Y(c.blur)), O = Math.min(1, Y(c.fade)), k = Y(c.focus), A = T > 0 && k > 0, N = ve * f;
+			L(1 + N + ye * m + .005);
+			let F = n.fov;
+			n.fov = 2 * Math.atan(Math.tan(F * _e / 2) * o) / _e, n.updateProjectionMatrix(), l.resolveDepthBuffer = A, e.setRenderTarget(l), e.clear(), r.render(e, s), e.render(t, n);
+			let I = e.shadowMap.autoUpdate;
+			e.shadowMap.autoUpdate = !1, e.setRenderTarget(p), e.setClearColor(16711680, 1), e.clear();
+			let z = u.filter((e) => e.visible);
+			for (let e of z) e.visible = !1;
+			t.overrideMaterial = h, e.render(t, n), n.layers.set(1), t.overrideMaterial = g, e.render(t, n), n.layers.set(0), t.overrideMaterial = null;
+			for (let e of z) e.visible = !0;
+			e.setClearColor(0, 0), e.shadowMap.autoUpdate = I, n.fov = F, n.updateProjectionMatrix();
+			let B = T * be * a;
+			if (A) {
+				let e = B >= Ee ? 4 : 2;
+				e !== M && (M = e, P());
+				let t = b.uniforms;
+				R.set(1 / l.width, 1 / l.height), t.texel.value.copy(R), t.camNear.value = n.near, t.camFar.value = n.far, t.focus.value = k, t.maxCoc.value = B, j(b, _);
+			}
+			if (S > 0) {
+				let e = x.uniforms;
+				e.tSrc.value = A ? _.textures[0] : l.texture, e.tSrcMask.value = A ? _.textures[1] : p.texture;
+				let t = A ? _ : l;
+				e.texel.value.set(1 / t.width, 1 / t.height), j(x, y[0]);
+				for (let e = 1; e < we; e++) {
+					let t = y[e - 1];
+					C.uniforms.tSrc.value = t.texture, C.uniforms.texel.value.set(1 / t.width, 1 / t.height), j(C, y[e]);
+				}
+				for (let e = 3; e >= 0; e--) {
+					let t = y[e + 1];
+					E.uniforms.tSrc.value = t.texture, E.uniforms.texel.value.set(1 / t.width, 1 / t.height), j(E, y[e]);
+				}
+			}
+			let V = D.uniforms;
+			V.overscan.value = o, V.aspect.value = i / a, V.barrel.value = N, V.chromatic.value = ye * m, V.vignette.value = v, V.dofOn.value = +!!A, V.camNear.value = n.near, V.camFar.value = n.far, V.focus.value = k, V.maxCoc.value = B, V.bloomAmount.value = S * Ce, V.grain.value = w, V.frame.value = Math.floor(Math.max(0, d) * De + 1e-6), V.fade.value = O, e.setRenderTarget(null), e.clear(), j(D, null);
+		},
+		dispose() {
+			l.dispose(), c.dispose(), p.dispose(), _.dispose();
+			for (let e of y) e.dispose();
+			h.dispose(), g.dispose(), O.geometry.dispose(), D.dispose(), b.dispose(), x.dispose(), C.dispose(), E.dispose();
+		}
+	};
+}
+// ../engine/src/set/stone.ts
+function je(e) {
+	let n = new t({
+		color: e,
+		roughness: .72,
+		metalness: 0
+	});
+	return n.onBeforeCompile = (e) => {
+		e.vertexShader = e.vertexShader.replace("#include <common>", "#include <common>\n        attribute float aCavity;\n        varying float vCavity;\n        varying vec3 vStonePos;").replace("#include <begin_vertex>", "#include <begin_vertex>\n        vCavity = aCavity;\n        vStonePos = position;"), e.fragmentShader = e.fragmentShader.replace("#include <common>", `#include <common>
+        varying float vCavity;
+        varying vec3 vStonePos;
+        ${Me}
+        vec3 hash3(vec3 p) {
+          p = vec3(dot(p, vec3(127.1, 311.7, 74.7)), dot(p, vec3(269.5, 183.3, 246.1)), dot(p, vec3(113.5, 271.9, 124.6)));
+          return fract(sin(p) * 43758.5453123);
+        }
+        // Lumps: one tilted paraboloid per cell; x is the lowest (the dome this point
+        // belongs to), y the next lowest. Negated, x is a field of domes that is continuous
+        // across cells, and y - x falls to zero along the crack where two domes meet.
+        vec2 lumpField(vec3 p) {
+          vec3 base = floor(p);
+          vec2 h = vec2(8.0);
+          for (int z = -1; z <= 1; z++) for (int y = -1; y <= 1; y++) for (int x = -1; x <= 1; x++) {
+            vec3 cell = base + vec3(x, y, z);
+            vec3 d = p - (cell + hash3(cell));
+            float v = dot(d, d) + dot(d, (hash3(cell + 31.7) - 0.5) * 1.2);
+            if (v < h.x) h = vec2(v, h.x);
+            else if (v < h.y) h.y = v;
+          }
+          return h;
+        }
+        // Fades a detail layer out as its wavelength (cm) nears the pixel footprint, so
+        // distant stone stays crisp instead of turning to fuzz.
+        float lod(float wavelength, float footprint) {
+          return 1.0 - smoothstep(wavelength * 0.12, wavelength * 0.45, footprint);
+        }
+        // Relief detail shared by the height, albedo and roughness: x = height,
+        // y = hollow (1 in the low ground between lumps and in cracks), z = crown (1 on top
+        // of a lump).
+        vec3 stoneDetail(vec3 p, float footprint) {
+          // Warped so cells never line up into a visible tiling.
+          vec3 q = p + vec3(snoise(p * 0.11), snoise(p * 0.11 + 17.0), snoise(p * 0.11 - 9.0)) * 3.0;
+          // Lump size drifts across the stone (~1.8–3.5 cm) and fades out in patches, so
+          // the cells never read as a repeating skin.
+          float sizeDrift = 0.4 * exp2(snoise(p * 0.03 + 2.0) * 0.5);
+          vec2 small = lumpField(q * sizeDrift);
+          vec2 large = lumpField(q * 0.14 + 5.0);
+          float near = lod(2.5, footprint) * smoothstep(-0.6, 0.3, snoise(p * 0.06 - 4.0));
+          // Lumps sink into soft hollows rather than outlined cells; only a few of the
+          // large cell boundaries open into real cracks.
+          float hollow = smoothstep(0.17, 0.3, small.x) * near;
+          float crack = (1.0 - smoothstep(0.0, 0.035, large.y - large.x)) * smoothstep(0.35, 0.65, snoise(p * 0.045 + 8.0));
+          crack *= lod(4.0, footprint);
+          float crown = smoothstep(0.2, 0.0, small.x) * near;
+          float pits = -pow(max(0.0, snoise(p * 0.9 + 3.0)), 3.0);
+          float tooth = snoise(p * 2.6 - 7.3);
+          // Ridged grit at ~8 mm: crisp little edges that catch the key light.
+          float grit = 1.0 - abs(snoise(p * 1.25 + 2.0));
+          float h = snoise(p * 0.07) * 0.6
+            - small.x * 1.3 * near
+            - large.x * 1.4 * lod(7.0, footprint)
+            - crack * 0.3
+            + pits * 0.5 * lod(1.1, footprint)
+            + grit * grit * 0.4 * lod(0.8, footprint)
+            + tooth * 0.14 * lod(0.4, footprint);
+          return vec3(h, max(hollow * 0.45, crack), crown);
+        }
+        vec3 stonePerturb(vec3 surfPos, vec3 surfNorm, float h, float faceDirection) {
+          vec2 dHdxy = vec2(dFdx(h), dFdy(h));
+          vec3 vSigmaX = normalize(dFdx(surfPos));
+          vec3 vSigmaY = normalize(dFdy(surfPos));
+          vec3 vN = surfNorm;
+          vec3 R1 = cross(vSigmaY, vN);
+          vec3 R2 = cross(vN, vSigmaX);
+          float fDet = dot(vSigmaX, R1) * faceDirection;
+          vec3 vGrad = sign(fDet) * (dHdxy.x * R1 + dHdxy.y * R2);
+          return normalize(abs(fDet) * surfNorm - vGrad);
+        }`).replace("#include <color_fragment>", "#include <color_fragment>\n        float stoneFootprint = length(fwidth(vStonePos));\n        vec3 stoneD = stoneDetail(vStonePos, stoneFootprint);\n        float stoneH = stoneD.x;\n        float mottle = snoise(vStonePos * 0.04 + 3.0) * 0.6 + snoise(vStonePos * 0.17) * 0.3;\n        // Mineral speckle: scattered dark grains (light ones bloom into droplets).\n        float speck = snoise(vStonePos * 1.7 + 21.0) * lod(0.6, stoneFootprint);\n        mottle -= smoothstep(0.55, 0.85, -speck) * 0.3;\n        float wear = smoothstep(0.42, 0.15, vCavity);\n        float crease = smoothstep(0.55, 0.9, vCavity);\n        diffuseColor.rgb *= (0.82 + 0.22 * mottle) * (1.0 + 0.35 * wear) * (1.0 - 0.45 * crease);\n        // Millimetre grain in the colour, as any photographed stone has; it is what makes\n        // a surface read sharp at a glance.\n        float grain = snoise(vStonePos * 3.6 + 40.0) * 0.6 + snoise(vStonePos * 7.5 - 13.0) * 0.4;\n        diffuseColor.rgb *= 1.0 + 0.22 * grain * lod(0.3, stoneFootprint);\n        // Small-scale contrast: dark hollows and cracks, lighter crowns.\n        diffuseColor.rgb *= (1.0 - 0.4 * stoneD.y) * (0.92 + 0.18 * stoneD.z);").replace("#include <roughnessmap_fragment>", "#include <roughnessmap_fragment>\n        // Crowns are polished a little by weather; cracks and creases hold dust.\n        roughnessFactor = clamp(roughnessFactor - 0.17 * stoneD.z + 0.12 * max(crease, stoneD.y), 0.45, 1.0);").replace("#include <normal_fragment_maps>", "#include <normal_fragment_maps>\n        // Height in cm-ish units; the gain sets how deep the grain reads.\n        normal = stonePerturb(-vViewPosition, normal, stoneH * 0.5, faceDirection);").replace("#include <aomap_fragment>", "#include <aomap_fragment>\n        float stoneAO = mix(1.0, 0.35, crease) * (1.0 - 0.4 * stoneD.y);\n        reflectedLight.indirectDiffuse *= stoneAO;\n        reflectedLight.indirectSpecular *= stoneAO;");
+	}, n.customProgramCacheKey = () => "openmockup-stone-13", n;
+}
+var Me = "\nvec3 mod289(vec3 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }\nvec4 mod289(vec4 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }\nvec4 permute(vec4 x) { return mod289(((x * 34.0) + 10.0) * x); }\nvec4 taylorInvSqrt(vec4 r) { return 1.79284291400159 - 0.85373472095314 * r; }\nfloat snoise(vec3 v) {\n  const vec2 C = vec2(1.0 / 6.0, 1.0 / 3.0);\n  const vec4 D = vec4(0.0, 0.5, 1.0, 2.0);\n  vec3 i = floor(v + dot(v, C.yyy));\n  vec3 x0 = v - i + dot(i, C.xxx);\n  vec3 g = step(x0.yzx, x0.xyz);\n  vec3 l = 1.0 - g;\n  vec3 i1 = min(g.xyz, l.zxy);\n  vec3 i2 = max(g.xyz, l.zxy);\n  vec3 x1 = x0 - i1 + C.xxx;\n  vec3 x2 = x0 - i2 + C.yyy;\n  vec3 x3 = x0 - D.yyy;\n  i = mod289(i);\n  vec4 p = permute(permute(permute(i.z + vec4(0.0, i1.z, i2.z, 1.0)) + i.y + vec4(0.0, i1.y, i2.y, 1.0)) + i.x + vec4(0.0, i1.x, i2.x, 1.0));\n  float n_ = 0.142857142857;\n  vec3 ns = n_ * D.wyz - D.xzx;\n  vec4 j = p - 49.0 * floor(p * ns.z * ns.z);\n  vec4 x_ = floor(j * ns.z);\n  vec4 y_ = floor(j - 7.0 * x_);\n  vec4 x = x_ * ns.x + ns.yyyy;\n  vec4 y = y_ * ns.x + ns.yyyy;\n  vec4 h = 1.0 - abs(x) - abs(y);\n  vec4 b0 = vec4(x.xy, y.xy);\n  vec4 b1 = vec4(x.zw, y.zw);\n  vec4 s0 = floor(b0) * 2.0 + 1.0;\n  vec4 s1 = floor(b1) * 2.0 + 1.0;\n  vec4 sh = -step(h, vec4(0.0));\n  vec4 a0 = b0.xzyw + s0.xzyw * sh.xxyy;\n  vec4 a1 = b1.xzyw + s1.xzyw * sh.zzww;\n  vec3 p0 = vec3(a0.xy, h.x);\n  vec3 p1 = vec3(a0.zw, h.y);\n  vec3 p2 = vec3(a1.xy, h.z);\n  vec3 p3 = vec3(a1.zw, h.w);\n  vec4 norm = taylorInvSqrt(vec4(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)));\n  p0 *= norm.x;\n  p1 *= norm.y;\n  p2 *= norm.z;\n  p3 *= norm.w;\n  vec4 m = max(0.5 - vec4(dot(x0, x0), dot(x1, x1), dot(x2, x2), dot(x3, x3)), 0.0);\n  m = m * m;\n  return 105.0 * dot(m * m, vec4(dot(p0, x0), dot(p1, x1), dot(p2, x2), dot(p3, x3)));\n}\n";
+// ../engine/src/set/concrete.ts
+function Ne(e) {
+	let n = new t({
+		color: e,
+		roughness: .9,
+		metalness: 0
+	});
+	return n.onBeforeCompile = (e) => {
+		e.vertexShader = e.vertexShader.replace("#include <common>", "#include <common>\n        varying vec3 vConcretePos;").replace("#include <begin_vertex>", "#include <begin_vertex>\n        vConcretePos = position;"), e.fragmentShader = e.fragmentShader.replace("#include <common>", `#include <common>
+        varying vec3 vConcretePos;
+        ${Me}
+        float lod(float wavelength, float footprint) {
+          return 1.0 - smoothstep(wavelength * 0.12, wavelength * 0.45, footprint);
+        }
+        // Bug holes: sparse round voids a few millimetres across. x = depth (0..1), so the
+        // pit both darkens and dents.
+        float bugHoles(vec3 p, float footprint) {
+          float holes = smoothstep(0.78, 0.92, snoise(p * 2.6 + 11.0)) * smoothstep(0.1, 0.7, snoise(p * 0.12 - 6.0));
+          return holes * lod(0.5, footprint);
+        }
+        vec3 concretePerturb(vec3 surfPos, vec3 surfNorm, float h, float faceDirection) {
+          vec2 dHdxy = vec2(dFdx(h), dFdy(h));
+          vec3 vSigmaX = normalize(dFdx(surfPos));
+          vec3 vSigmaY = normalize(dFdy(surfPos));
+          vec3 R1 = cross(vSigmaY, surfNorm);
+          vec3 R2 = cross(surfNorm, vSigmaX);
+          float fDet = dot(vSigmaX, R1) * faceDirection;
+          vec3 vGrad = sign(fDet) * (dHdxy.x * R1 + dHdxy.y * R2);
+          return normalize(abs(fDet) * surfNorm - vGrad);
+        }`).replace("#include <color_fragment>", "#include <color_fragment>\n        float concreteFootprint = length(fwidth(vConcretePos));\n        vec3 cp = vConcretePos;\n        // Pour mottling: big soft clouds with a smaller layer riding on them.\n        float clouds = snoise(cp * 0.018) * 0.6 + snoise(cp * 0.06 + 4.0) * 0.4;\n        // Formwork stains: faint horizontal bands where each lift of the pour set.\n        float bands = snoise(vec3(cp.x * 0.01, cp.y * 0.22, cp.z * 0.01) + 9.0);\n        float sand = (snoise(cp * 4.2 + 30.0) * 0.6 + snoise(cp * 9.0 - 3.0) * 0.4) * lod(0.25, concreteFootprint);\n        float concreteHoles = bugHoles(cp, concreteFootprint);\n        diffuseColor.rgb *= (0.88 + 0.24 * clouds) * (1.0 - 0.08 * smoothstep(0.2, 0.8, bands)) * (1.0 + 0.14 * sand);\n        diffuseColor.rgb *= 1.0 - 0.4 * concreteHoles;").replace("#include <roughnessmap_fragment>", "#include <roughnessmap_fragment>\n        roughnessFactor = clamp(roughnessFactor - 0.06 * clouds + 0.08 * concreteHoles, 0.7, 1.0);").replace("#include <normal_fragment_maps>", "#include <normal_fragment_maps>\n        float concreteH = -concreteHoles * 0.15 + sand * 0.05 + snoise(cp * 0.4 + 2.0) * 0.06 * lod(2.0, concreteFootprint);\n        normal = concretePerturb(-vViewPosition, normal, concreteH, faceDirection);").replace("#include <aomap_fragment>", "#include <aomap_fragment>\n        float concreteRoom = 0.1 * (1.0 - 0.5 * concreteHoles);\n        reflectedLight.indirectDiffuse *= concreteRoom;\n        reflectedLight.indirectSpecular *= concreteRoom;");
+	}, n.customProgramCacheKey = () => "openmockup-concrete-4", n;
+}
+// ../engine/src/set/block.ts
+function Pe({ color: e, subject: t }) {
+	let n = new P();
+	n.name = "set:block";
+	let i = Ne(e), a = t.getCenter(new _()), o = t.getSize(new _()), s = Math.max(o.x * 3, 90), l = Math.max(o.z * 2.4, 60), u = Math.max(o.y * 6, s), d = t.min.x + o.x * .3, f = t.max.z + .6, p = t.min.y, m = new j(s, u, l, 3, .35), h = new r(m, i);
+	h.position.set(d + s / 2, p - u / 2, f - l / 2), h.castShadow = !1, h.receiveShadow = !0, n.add(h);
+	let g = Math.max(o.length() * 3.2, 110), v = new c(16184818, 1, g * 4, .62, .85, 2);
+	v.position.set(a.x - g, a.y + g * .25, f - g * .12), v.target.position.set(d, p - o.y, f), v.castShadow = !0, v.shadow.mapSize.set(2048, 2048), v.shadow.camera.near = g * .3, v.shadow.camera.far = g * 3, v.shadow.radius = 6, v.shadow.blurSamples = 16, v.shadow.bias = -2e-4, v.shadow.normalBias = .3;
+	let y = new c(14673134, 1, g * 4, .8, 1, 2);
+	y.position.set(a.x - g * .3, a.y - g * .2, a.z + g * 1.2), y.target.position.set(d, p - o.y, f), n.add(v, v.target, y, y.target);
+	let b = v.position.distanceTo(v.target.position), x = y.position.distanceTo(y.target.position);
+	return {
+		group: n,
+		update(e, t) {
+			i.color.set(e.color), v.intensity = 4 * b * b * t, y.intensity = .12 * x * x * t;
+		},
+		dispose() {
+			m.dispose(), i.dispose(), v.shadow.map?.dispose(), v.dispose(), y.dispose();
+		}
+	};
+}
+// ../engine/src/set/noise.ts
+function Fe(e) {
+	let t = e * 2654435761 >>> 0 || 1;
+	return () => {
+		t = t + 1831565813 >>> 0;
+		let e = t;
+		return e = Math.imul(e ^ e >>> 15, e | 1), e ^= e + Math.imul(e ^ e >>> 7, e | 61), ((e ^ e >>> 14) >>> 0) / 4294967296;
+	};
+}
+var Ie = new Float32Array([
+	1,
+	1,
+	0,
+	-1,
+	1,
+	0,
+	1,
+	-1,
+	0,
+	-1,
+	-1,
+	0,
+	1,
+	0,
+	1,
+	-1,
+	0,
+	1,
+	1,
+	0,
+	-1,
+	-1,
+	0,
+	-1,
+	0,
+	1,
+	1,
+	0,
+	-1,
+	1,
+	0,
+	1,
+	-1,
+	0,
+	-1,
+	-1
+]), Le = 1 / 3, Z = 1 / 6;
+function Re(e) {
+	let t = Fe(e), n = /* @__PURE__ */ new Uint8Array(256);
+	for (let e = 0; e < 256; e++) n[e] = e;
+	for (let e = 255; e > 0; e--) {
+		let r = Math.floor(t() * (e + 1)), i = n[e];
+		n[e] = n[r], n[r] = i;
+	}
+	let r = /* @__PURE__ */ new Uint8Array(512), i = /* @__PURE__ */ new Uint8Array(512);
+	for (let e = 0; e < 512; e++) r[e] = n[e & 255], i[e] = r[e] % 12;
+	return (e, t, n) => {
+		let a = (e + t + n) * Le, o = Math.floor(e + a), s = Math.floor(t + a), c = Math.floor(n + a), l = (o + s + c) * Z, u = e - (o - l), d = t - (s - l), f = n - (c - l), p = 0, m = 0, h = 0, g = 0, _ = 0, v = 0;
+		u >= d ? d >= f ? (p = 1, g = 1, _ = 1) : u >= f ? (p = 1, g = 1, v = 1) : (h = 1, g = 1, v = 1) : d < f ? (h = 1, _ = 1, v = 1) : u < f ? (m = 1, _ = 1, v = 1) : (m = 1, g = 1, _ = 1);
+		let y = u - p + Z, b = d - m + Z, x = f - h + Z, S = u - g + 2 * Z, C = d - _ + 2 * Z, w = f - v + 2 * Z, T = u - 1 + 3 * Z, E = d - 1 + 3 * Z, D = f - 1 + 3 * Z, O = o & 255, k = s & 255, A = c & 255, j = ze(i[O + r[k + r[A]]], u, d, f), M = ze(i[O + p + r[k + m + r[A + h]]], y, b, x), N = ze(i[O + g + r[k + _ + r[A + v]]], S, C, w), P = ze(i[O + 1 + r[k + 1 + r[A + 1]]], T, E, D);
+		return 32 * (j + M + N + P);
+	};
+}
+function ze(e, t, n, r) {
+	let i = .6 - t * t - n * n - r * r;
+	if (i < 0) return 0;
+	i *= i;
+	let a = e * 3;
+	return i * i * (Ie[a] * t + Ie[a + 1] * n + Ie[a + 2] * r);
+}
+function Be(e, t, n, r, i, a = .5) {
+	let o = 0, s = 1, c = 1, l = 0;
+	for (let u = 0; u < i; u++) o += s * e(t * c, n * c, r * c), l += s, s *= a, c *= 2;
+	return o / l;
+}
+// ../engine/src/set/rock.ts
+function Ve({ seed: e, size: t, detail: n = 5, sides: i = 6, notches: a, relief: o = 1, shape: s = "pillar", color: c }) {
+	let l = Fe(e), u = Re(e), d = new _(t[0] / 2, t[1] / 2, t[2] / 2), f = Math.hypot(...t), p = Math.min(d.x, d.z) * .03 + .12, m = [], h = l() * Math.PI * 2;
+	for (let e = 0; e < i; e++) {
+		let t = h + (e + (l() - .5) * .5) / i * Math.PI * 2, n = s === "boulder" ? (l() - .5) * 1.6 : (l() - .5) * .08, r = new _(Math.cos(t), n, Math.sin(t)).normalize(), a = Math.hypot(r.x * d.x, r.z * d.z);
+		m.push({
+			n: r,
+			d: a * (.86 + l() * .1)
+		});
+	}
+	let g = Array.from({ length: 2 + Math.floor(l() * 3) }, () => (l() * 1.5 - .75) * d.y).sort((e, t) => e - t), v = m.map(() => g.map(() => l() < .65 ? -(l() * .16) : l() * .06)), y = l() * Math.PI, b = new _(Math.cos(y), 0, Math.sin(y)), x = (l() - .5) * Math.min(d.x, d.z) * .6, S = m.map(() => -(l() * .12)), w = m.length;
+	m.push({
+		n: new _(l() - .5, 2.2, l() - .5).normalize(),
+		d: d.y * .92
+	}), m.push({
+		n: new _((l() - .5) * .3, -1, (l() - .5) * .3).normalize(),
+		d: d.y
+	});
+	let T = 1 + Math.floor(l() * 2);
+	for (let e = 0; e < T; e++) {
+		let e = l() * Math.PI * 2, t = new _(Math.cos(e) * .55, -.85, Math.sin(e) * .55).normalize();
+		m.push({
+			n: t,
+			d: Math.hypot(t.x * d.x, t.y * d.y, t.z * d.z) * .72
+		});
+	}
+	let D = 16 + Math.floor(l() * 8);
+	for (let e = 0; e < D; e++) {
+		let e = new _(l() * 2 - 1, l() * 2 - 1, l() * 2 - 1).normalize(), t = Math.abs(e.x) * d.x + Math.abs(e.y) * d.y + Math.abs(e.z) * d.z;
+		m.push({
+			n: e,
+			d: t * (.78 + l() * .12)
+		});
+	}
+	let O = [], k = a ?? Math.round(t[1] / 18 + l() * 3);
+	for (let e = 0; e < k; e++) {
+		let e = m[Math.floor(l() * i)], t = (l() * 1.6 - .8) * d.y, n = l() < .5 ? -1 : 1, r = new _(-e.n.z, 0, e.n.x).multiplyScalar(n * (.45 + l() * .4) * Math.min(d.x, d.z)), a = e.n.clone().setY(0).normalize().multiplyScalar(e.d).add(r).setY(t), o = Math.min(d.x, d.z) * (.12 + l() * .18);
+		O.push({
+			center: a,
+			half: new _(Math.min(d.x, d.z) * (.25 + l() * .45), d.y * (.04 + l() * .12), o),
+			yaw: Math.atan2(e.n.x, e.n.z) + (l() - .5) * .2
+		});
+	}
+	let A = new Float64Array(m.length * 4);
+	m.forEach((e, t) => A.set([
+		e.n.x,
+		e.n.y,
+		e.n.z,
+		e.d
+	], t * 4));
+	let j = new Float64Array(w * g.length);
+	for (let e = 0; e < w; e++) for (let t = 0; t < g.length; t++) j[e * g.length + t] = v[e][t] * m[e].d;
+	let M = Float64Array.from(S, (e, t) => e * m[t].d), N = new Float64Array(O.length * 8);
+	O.forEach((e, t) => N.set([
+		e.center.x,
+		e.center.y,
+		e.center.z,
+		Math.cos(-e.yaw),
+		Math.sin(-e.yaw),
+		e.half.x,
+		e.half.y,
+		e.half.z
+	], t * 8));
+	let P = new Float64Array(g.length), F = b.x, I = b.z, L = (e, t, n) => {
+		let r = He(-p * .4, p * .4, e * F + n * I - x);
+		for (let e = 0; e < g.length; e++) P[e] = He(-p * .3, p * .3, t - g[e]);
+		let i = -Infinity;
+		for (let a = 0; a < m.length; a++) {
+			let o = a * 4, s = 0;
+			if (a < w) {
+				for (let e = 0; e < g.length; e++) s += j[a * g.length + e] * P[e];
+				s += M[a] * r;
+			}
+			i = Ue(i, e * A[o] + t * A[o + 1] + n * A[o + 2] - (A[o + 3] + s), p);
+		}
+		for (let r = 0; r < O.length; r++) {
+			let a = r * 8, o = e - N[a], s = t - N[a + 1], c = n - N[a + 2], l = N[a + 3], u = N[a + 4], d = Math.abs(o * l + c * u) - N[a + 5], f = Math.abs(s) - N[a + 6], m = Math.abs(-o * u + c * l) - N[a + 7], h = d > 0 ? d : 0, g = f > 0 ? f : 0, _ = m > 0 ? m : 0, v = Math.min(Math.max(d, f, m), 0) + Math.sqrt(h * h + g * g + _ * _);
+			i = Ue(i, -v, p * .6);
+		}
+		let a = e / f, s = t / f, c = n / f;
+		return i -= Be(u, a * 2.2, s * 2.2, c * 2.2, 3, .5) * f * .007 * o, i -= Be(u, a * 9 + 7.1, s * 9 + 3.3, c * 9 - 2.2, 2, .5) * f * .004 * o, i;
+	}, R = (e) => L(e.x, e.y, e.z), { positions: z, indices: B } = Ge(n), V = z.length / 3, H = new _(), U = new _(), W = d.length() * 1.5;
+	for (let e = 0; e < V; e++) {
+		H.fromArray(z, e * 3).multiply(d).normalize();
+		let t = W, n = W;
+		for (let e = 0; e < 200 && t > 0; e++) {
+			let e = R(U.copy(H).multiplyScalar(t));
+			if (e < 0) break;
+			n = t, t -= Math.max(e * .8, .3);
+		}
+		let r = Math.max(t, 0), i = n;
+		for (let e = 0; e < 9; e++) {
+			let e = (r + i) / 2;
+			R(U.copy(H).multiplyScalar(e)) < 0 ? r = e : i = e;
+		}
+		U.copy(H).multiplyScalar((r + i) / 2).toArray(z, e * 3);
+	}
+	We(z, B, R, 4);
+	let G = new E();
+	G.setAttribute("position", new C(z, 3)), G.setIndex(new C(B, 1)), G.computeVertexNormals(), G.setAttribute("aCavity", new C(Ke(G), 1)), G.computeBoundingBox(), G.computeBoundingSphere();
+	let K = c === void 0 ? null : je(c), q = new r(G, K ?? void 0);
+	return q.castShadow = !0, q.receiveShadow = !0, {
+		mesh: q,
+		dispose() {
+			G.dispose(), K?.dispose();
+		}
+	};
+}
+function He(e, t, n) {
+	let r = Math.min(1, Math.max(0, (n - e) / (t - e)));
+	return r * r * (3 - 2 * r);
+}
+function Ue(e, t, n) {
+	if (e === -Infinity) return t;
+	let r = Math.min(1, Math.max(0, .5 - .5 * (t - e) / n));
+	return t + (e - t) * r + n * r * (1 - r);
+}
+function We(e, t, n, r) {
+	let i = e.length / 3, a = Array.from({ length: i }, () => []);
+	for (let e = 0; e < t.length; e += 3) for (let n = 0; n < 3; n++) {
+		let r = t[e + n], i = t[e + (n + 1) % 3];
+		a[r].includes(i) || a[r].push(i), a[i].includes(r) || a[i].push(r);
+	}
+	let o = new _(), s = new _(), c = new _(), l = .05, u = new Float32Array(e.length);
+	for (let t = 0; t < r; t++) {
+		for (let t = 0; t < i; t++) {
+			let r = 0, i = 0, d = 0;
+			for (let n of a[t]) r += e[n * 3], i += e[n * 3 + 1], d += e[n * 3 + 2];
+			let f = a[t].length;
+			o.set(e[t * 3] * .4 + r / f * .6, e[t * 3 + 1] * .4 + i / f * .6, e[t * 3 + 2] * .4 + d / f * .6);
+			for (let e = 0; e < 2; e++) {
+				let e = n(o);
+				s.set(n(c.set(o.x + l, o.y, o.z)) - e, n(c.set(o.x, o.y + l, o.z)) - e, n(c.set(o.x, o.y, o.z + l)) - e).divideScalar(l);
+				let t = s.lengthSq();
+				if (t < 1e-8) break;
+				o.addScaledVector(s, -e / t);
+			}
+			o.toArray(u, t * 3);
+		}
+		e.set(u);
+	}
+}
+function Ge(e) {
+	let t = (1 + Math.sqrt(5)) / 2, n = [
+		-1,
+		t,
+		0,
+		1,
+		t,
+		0,
+		-1,
+		-t,
+		0,
+		1,
+		-t,
+		0,
+		0,
+		-1,
+		t,
+		0,
+		1,
+		t,
+		0,
+		-1,
+		-t,
+		0,
+		1,
+		-t,
+		t,
+		0,
+		-1,
+		t,
+		0,
+		1,
+		-t,
+		0,
+		-1,
+		-t,
+		0,
+		1
+	], r = [
+		0,
+		11,
+		5,
+		0,
+		5,
+		1,
+		0,
+		1,
+		7,
+		0,
+		7,
+		10,
+		0,
+		10,
+		11,
+		1,
+		5,
+		9,
+		5,
+		11,
+		4,
+		11,
+		10,
+		2,
+		10,
+		7,
+		6,
+		7,
+		1,
+		8,
+		3,
+		9,
+		4,
+		3,
+		4,
+		2,
+		3,
+		2,
+		6,
+		3,
+		6,
+		8,
+		3,
+		8,
+		9,
+		4,
+		9,
+		5,
+		2,
+		4,
+		11,
+		6,
+		2,
+		10,
+		8,
+		6,
+		7,
+		9,
+		8,
+		1
+	];
+	for (let e = 0; e < n.length; e += 3) {
+		let t = Math.hypot(n[e], n[e + 1], n[e + 2]);
+		n[e] /= t, n[e + 1] /= t, n[e + 2] /= t;
+	}
+	for (let t = 0; t < e; t++) {
+		let e = /* @__PURE__ */ new Map(), t = (t, r) => {
+			let i = t < r ? t * 1e7 + r : r * 1e7 + t, a = e.get(i);
+			if (a !== void 0) return a;
+			let o = n[t * 3] + n[r * 3], s = n[t * 3 + 1] + n[r * 3 + 1], c = n[t * 3 + 2] + n[r * 3 + 2], l = Math.hypot(o, s, c);
+			n.push(o / l, s / l, c / l);
+			let u = n.length / 3 - 1;
+			return e.set(i, u), u;
+		}, i = [];
+		for (let e = 0; e < r.length; e += 3) {
+			let n = r[e], a = r[e + 1], o = r[e + 2], s = t(n, a), c = t(a, o), l = t(o, n);
+			i.push(n, s, l, a, c, s, o, l, c, s, c, l);
+		}
+		r = i;
+	}
+	return {
+		positions: new Float32Array(n),
+		indices: new Uint32Array(r)
+	};
+}
+function Ke(e) {
+	let t = e.getAttribute("position"), n = e.getAttribute("normal"), r = e.getIndex(), i = t.count, a = Array.from({ length: i }, () => /* @__PURE__ */ new Set());
+	for (let e = 0; e < r.count; e += 3) {
+		let t = r.getX(e), n = r.getX(e + 1), i = r.getX(e + 2);
+		a[t].add(n).add(i), a[n].add(t).add(i), a[i].add(t).add(n);
+	}
+	let o = new Float32Array(i);
+	for (let e = 0; e < i; e++) {
+		let r = 0, i = 0, s = 0, c = 0, l = t.getX(e), u = t.getY(e), d = t.getZ(e);
+		for (let n of a[e]) r += t.getX(n), i += t.getY(n), s += t.getZ(n), c += Math.hypot(t.getX(n) - l, t.getY(n) - u, t.getZ(n) - d);
+		let f = a[e].size || 1, p = ((r / f - l) * n.getX(e) + (i / f - u) * n.getY(e) + (s / f - d) * n.getZ(e)) / (c / f || 1);
+		o[e] = p;
+	}
+	for (let e = 0; e < 2; e++) {
+		let e = new Float32Array(i);
+		for (let t = 0; t < i; t++) {
+			let n = o[t];
+			for (let e of a[t]) n += o[e];
+			e[t] = n / (a[t].size + 1);
+		}
+		o = e;
+	}
+	for (let e = 0; e < i; e++) o[e] = Math.min(1, Math.max(0, .5 + o[e] * 4));
+	return o;
+}
+// ../engine/src/set/crevice.ts
+function qe({ seed: e, color: t, subject: n }) {
+	let r = Fe(e * 7919 + 13), i = new P();
+	i.name = "set:crevice";
+	let a = je(t), o = [], s = n.getCenter(new _()), l = n.getSize(new _()), u = l.x + Math.max(1.2, l.x * .18) * 2, d = Math.max(l.y * 4.2, u * 6.3), f = u * 3.1, p = Math.max(u * 3, l.z * 6), m = s.y - d * .3;
+	for (let t of [-1, 1]) {
+		let n = Ve({
+			seed: e * 31 + (t < 0 ? 1 : 2),
+			size: [
+				f * (.9 + r() * .2),
+				d * (.94 + r() * .08),
+				p * (.9 + r() * .15)
+			]
+		});
+		n.mesh.material = a;
+		let c = n.mesh;
+		c.rotation.set((r() - .5) * .06, (r() - .5) * .5, -t * (.05 + r() * .04)), c.position.set(s.x + t * (u / 2 + f / 2), m + d / 2, s.z - p * .28), c.updateMatrixWorld(!0);
+		let h = Je(c, t, s, l);
+		h !== null && (c.position.x += s.x + u / 2 * t - h), i.add(c), o.push(n);
+	}
+	let h = u * .9;
+	for (let [t, c] of [[-1, -.3], [1, .35]]) {
+		let d = Ve({
+			seed: e * 31 + (t < 0 ? 4 : 5),
+			size: [
+				u * 1.5,
+				l.y * 1.3,
+				h
+			],
+			sides: 6,
+			notches: 1,
+			relief: 1.5,
+			detail: 4
+		});
+		d.mesh.material = a, d.mesh.rotation.set((r() - .5) * .1, (r() - .5) * .5, -t * (.04 + r() * .06)), d.mesh.position.set(s.x + t * (l.x / 2 + u * .75 - .5), s.y + c * l.y, n.max.z + h * .5 + .8), d.mesh.updateMatrixWorld(!0);
+		let f = Ye(d.mesh);
+		f !== null && f < n.max.z + .4 && (d.mesh.position.z += n.max.z + .4 - f), i.add(d.mesh), o.push(d);
+	}
+	let g = Ve({
+		seed: e * 31 + 3,
+		size: [
+			u * 2.2,
+			l.y * .45,
+			p * .55
+		],
+		sides: 8,
+		notches: 1,
+		relief: 2,
+		shape: "boulder",
+		detail: 4
+	});
+	g.mesh.material = a, g.mesh.rotation.set(0, (r() - .5) * .6, (r() - .5) * .15), g.mesh.position.set(s.x, n.min.y, s.z - p * .08), g.mesh.updateMatrixWorld(!0);
+	let v = Xe(g.mesh, s, l);
+	v !== null && (g.mesh.position.y += n.min.y - .15 - v), i.add(g.mesh), o.push(g);
+	let y = d, b = new c(15001584, 1, y * 4, .36, .95, 2);
+	b.position.set(s.x - y * .7, s.y + y * 1.15, s.z + y * .4), b.target.position.copy(s), b.castShadow = !0, b.shadow.mapSize.set(2048, 2048), b.shadow.camera.near = y * .3, b.shadow.camera.far = y * 3, b.shadow.radius = 3, b.shadow.blurSamples = 12, b.shadow.bias = -2e-4, b.shadow.normalBias = .6;
+	let x = new c(3364351, 1, y * 4, .45, .9, 2);
+	x.position.set(s.x + y * .7, s.y + y * .35, s.z - y * .55), x.target.position.set(s.x - u, s.y, s.z);
+	let S = new c(11122406, 1, y * 4, .9, 1, 2);
+	S.position.set(s.x + y * .4, s.y - y * .1, s.z + y * 1.1), S.target.position.copy(s), i.add(b, b.target, x, x.target, S, S.target);
+	let C = b.position.distanceTo(s), w = x.position.distanceTo(s), T = S.position.distanceTo(s);
+	return {
+		group: i,
+		update(e, t) {
+			a.color.set(e.color), b.intensity = 5 * C * C * t, x.intensity = .6 * w * w * t, S.intensity = .45 * T * T * t;
+		},
+		dispose() {
+			for (let e of o) e.dispose();
+			a.dispose(), b.shadow.map?.dispose(), b.dispose(), x.dispose(), S.dispose();
+		}
+	};
+}
+var Q = new _();
+function Je(e, t, n, r) {
+	let i = e.geometry.getAttribute("position"), a = null;
+	for (let o = 0; o < i.count; o++) Q.fromBufferAttribute(i, o).applyMatrix4(e.matrixWorld), !(Math.abs(Q.y - n.y) > r.y * .6 || Math.abs(Q.z - n.z) > Math.max(r.z * 2, 3)) && (a === null || (t < 0 ? Q.x > a : Q.x < a)) && (a = Q.x);
+	return a;
+}
+function Ye(e) {
+	let t = e.geometry.getAttribute("position"), n = null;
+	for (let r = 0; r < t.count; r++) Q.fromBufferAttribute(t, r).applyMatrix4(e.matrixWorld), (n === null || Q.z < n) && (n = Q.z);
+	return n;
+}
+function Xe(e, t, n) {
+	let r = e.geometry.getAttribute("position"), i = null;
+	for (let a = 0; a < r.count; a++) Q.fromBufferAttribute(r, a).applyMatrix4(e.matrixWorld), !(Math.abs(Q.x - t.x) > n.x * .5 || Math.abs(Q.z - t.z) > Math.max(n.z, 1)) && (i === null || Q.y > i) && (i = Q.y);
+	return i;
+}
+// ../engine/src/set/index.ts
+var Ze = {
+	crevice: qe,
+	block: Pe
+};
+function Qe(e, t) {
+	let n = Ze[e];
+	return n ? n(t) : null;
+}
+// ../engine/src/engine.ts
+var $e = 2.35, et = Math.PI / 180, tt = {
+	kind: "gradient",
+	inner: "#f6f6f4",
+	outer: "#d5d5d1",
+	tone: "light"
+}, nt = {
+	fisheye: 0,
+	chromatic: 0,
+	vignette: 0,
+	bloom: 0,
+	grain: 0,
+	blur: 0,
+	focus: 0,
+	fade: 0
+};
+function rt(e) {
+	return e.kind === "image" && e.image ? JSON.stringify(e.image) : null;
+}
+function it({ canvas: e, alpha: t = !0, quality: n = "preview" }) {
+	let r = new O({
+		canvas: e,
+		antialias: !0,
+		alpha: t
+	}), o = typeof window < "u" ? window.devicePixelRatio : 1;
+	r.setPixelRatio(n === "export" ? 1 : Math.min(o, 2)), r.setClearColor(0, 0), r.autoClear = !1, r.toneMapping = 7, r.shadowMap.enabled = !0, r.shadowMap.type = 3;
+	let s = new I(), c = "studio", u = de(r, c);
+	s.environment = u;
+	let d = new l(28, 1, 5, 300);
+	d.position.set(0, 1.5, 48);
+	let f = he(s, -10.5), p = ie(), m = Ae(r, n === "export" ? 8 : 4), h = /* @__PURE__ */ new Map(), g = /* @__PURE__ */ new Map(), y = 0, b = tt, x = nt, S = null, C = null, w = 0, T = new v(), E = 0, D = null, k = "", j = new _(), M = new _(), N = ge(r), F = [], L = new _();
+	function R(e) {
+		let t = u;
+		c = e, u = de(r, e), s.environment = u, t.dispose(), f.light.shadow.radius = le[e].shadow.radius;
+	}
+	async function B(e, t) {
+		let n = rt(e);
+		if (n === S) return null;
+		let i = ++w, a = null;
+		return e.image && n && t.resolveBackdrop && (a = await Promise.resolve(t.resolveBackdrop(e.image, { maxAnisotropy: r.capabilities.getMaxAnisotropy() })).catch(() => null)), () => {
+			if (i !== w) return a?.dispose();
+			C?.dispose(), C = a, S = n, p.setImage(a?.texture ?? null, a?.aspect);
+		};
+	}
+	function V() {
+		let e = Infinity;
+		for (let { build: t, root: n } of h.values()) {
+			let r = t.bounds.min.y * n.scale.y + n.position.y;
+			e = Math.min(e, r - (t.restsOnFloor ? 0 : $e));
+		}
+		return Number.isFinite(e) ? e : null;
+	}
+	function H() {
+		let e = V();
+		e !== null && f.setY(e);
+		let t = 0;
+		for (let { build: e, root: n } of h.values()) {
+			let r = new _();
+			e.bounds.getSize(r), t = Math.max(t, Math.max(r.x, r.y, r.z) / 2 * n.scale.x + n.position.length());
+		}
+		t > 0 && f.fit(t);
+	}
+	function U() {
+		te.forceLensPath || Oe(x) ? m.render(s, d, p, b, x, [f.ground], E) : (r.setRenderTarget(null), r.clear(), p.render(r, b), r.render(s, d));
+	}
+	function W(e, t = `device-${++y}`) {
+		let n = new P(), r = new P();
+		n.add(r), r.add(e.group);
+		for (let t of e.screens) t.mesh.layers.enable(1);
+		s.add(n);
+		let i = {
+			id: t,
+			root: n,
+			offset: r,
+			build: e
+		};
+		return h.set(t, i), H(), i;
+	}
+	function G(e) {
+		let t = h.get(e);
+		t && (s.remove(t.root), t.build.dispose(), h.delete(e), H());
+	}
+	function K() {
+		let e = new A();
+		for (let { build: t, root: n } of h.values()) n.visible && e.union(t.bounds.clone().applyMatrix4(new i().compose(n.position, new a(), n.scale)));
+		return e.isEmpty() ? null : e;
+	}
+	function q(e) {
+		let t = e.set?.kind ?? "none", n = t === "none" ? null : K();
+		if (t !== "none" && !n) return;
+		let r = n ? n.getSize(M).toArray().map((e) => e.toFixed(1)).join(",") : "", i = `${t}:${e.set?.seed}:${r}`;
+		i === k ? D && n && D.group.position.copy(n.getCenter(M)).sub(j) : (k = i, D && (s.remove(D.group), D.dispose()), D = n ? Qe(t, {
+			seed: e.set.seed,
+			color: e.set.color,
+			subject: n
+		}) : null, n && n.getCenter(j), D && s.add(D.group));
+	}
+	function ee(e, { skipCamera: t = !1 } = {}) {
+		E = e.time;
+		for (let [t, n] of h) {
+			let r = e.devices[t];
+			if (!r) n.root.visible = !1;
+			else {
+				n.root.visible = r.visible, n.root.position.set(r.position[0], r.position[1], r.position[2]), n.root.rotation.set(r.rotation[0] * et, r.rotation[1] * et, r.rotation[2] * et), n.root.scale.setScalar(r.scale);
+				for (let [e, t] of Object.entries(r.params)) n.build.setParam(e, t);
+				n.build.setGlare(r.glare, r.screenFinish);
+			}
+		}
+		if (t || ce(d, e.camera), x = e.camera.lens, x.blur > 0 && !(x.focus > 0)) {
+			let t = L.set(e.camera.target[0], e.camera.target[1], e.camera.target[2]).distanceTo(d.position);
+			x = {
+				...x,
+				focus: t
+			};
+		}
+		b = e.backdrop;
+		let n = ue(e.environment.preset);
+		n !== c && R(n), s.environmentIntensity = e.environment.intensity, s.environmentRotation.y = e.environment.rotation * et;
+		let r = Math.min(1, e.floor.shadow * le[c].shadow.opacity);
+		f.setOpacity(r), f.setY(e.floor.y ?? V() ?? f.ground.position.y), q(e), f.setVisible(!D && r > 0), D?.update(e.set, e.environment.intensity), N.update(F, e.environment.glow ?? 0);
+	}
+	let te = {
+		renderer: r,
+		scene: s,
+		camera: d,
+		floor: f,
+		devices: h,
+		screenSources: g,
+		maxAnisotropy: r.capabilities.getMaxAnisotropy(),
+		forceLensPath: !1,
+		addDevice: W,
+		removeDevice: G,
+		async loadScene(e, t) {
+			let n = new Map(e.screens.map((e) => [e.id, e])), i = [];
+			for (let a of e.devices) {
+				let e = await t.buildDevice(a), o = [];
+				for (let i = 0; i < e.screens.length; i++) {
+					let s = e.screens[i], c = a.screens[i], l = c ? n.get(c) : void 0;
+					if (!s || !l) continue;
+					let u = await t.resolveScreen(l, a, {
+						maxAnisotropy: r.capabilities.getMaxAnisotropy(),
+						screenAspect: s.aspect
+					});
+					u && o.push({
+						screenId: l.id,
+						source: u,
+						surface: s,
+						fit: l.fit,
+						pan: z(l.offset)
+					});
+				}
+				i.push({
+					deviceDoc: a,
+					build: e,
+					sources: o
+				});
+			}
+			let a = await B(e.backdrop, t);
+			for (let e of [...h.keys()]) G(e);
+			for (let e of g.values()) e.dispose();
+			g.clear(), F = [];
+			for (let { deviceDoc: e, build: t, sources: n } of i) {
+				W(t, e.id);
+				for (let { screenId: e, source: t, surface: r, fit: i, pan: a } of n) g.set(e, t), r.setTexture(t.texture, t.aspect, i, a);
+				for (let e of t.screens) F.push({
+					surface: e,
+					texture: n.find((t) => t.surface === e)?.source.texture ?? null
+				});
+			}
+			a?.();
+		},
+		async loadBackdrop(e, t) {
+			(await B(e, t))?.();
+		},
+		setSize(e, t) {
+			r.setSize(e, t, !1), r.getDrawingBufferSize(T), m.setSize(T.x, T.y), d.aspect = e / t, d.updateProjectionMatrix();
+		},
+		applyState: ee,
+		async prepareFrame(e) {
+			let t = [];
+			for (let [n, r] of g) {
+				let i = e.screens[n];
+				r.seek && i && t.push(r.seek(i.mediaTime));
+			}
+			await Promise.all(t);
+		},
+		render: U,
+		renderFrame(e, t) {
+			ee(e, t), U();
+		},
+		start(e) {
+			let t = performance.now();
+			r.setAnimationLoop((n) => {
+				let r = Math.min((n - t) / 1e3, .05);
+				t = n, e?.(n, r), U();
+			});
+		},
+		stop() {
+			r.setAnimationLoop(null);
+		},
+		renderToCanvas(e) {
+			let t = r.getPixelRatio();
+			r.setPixelRatio(t * e), r.getDrawingBufferSize(T), m.setSize(T.x, T.y), U();
+			let n = document.createElement("canvas");
+			return n.width = r.domElement.width, n.height = r.domElement.height, n.getContext("2d")?.drawImage(r.domElement, 0, 0), r.setPixelRatio(t), r.getDrawingBufferSize(T), m.setSize(T.x, T.y), U(), n;
+		},
+		dispose() {
+			r.setAnimationLoop(null);
+			for (let e of [...h.keys()]) G(e);
+			for (let e of g.values()) e.dispose();
+			g.clear(), C?.dispose(), D?.dispose(), N.dispose(), f.dispose(), p.dispose(), m.dispose(), u.dispose(), r.dispose();
+		}
+	};
+	return te;
+}
+// ../engine/src/media/video.ts
+var at = .0625, ot = 16;
+function st(e) {
+	return {
+		start: e?.start,
+		playbackRate: e?.playbackRate,
+		loop: e?.loop
+	};
+}
+function ct({ start: e = 0, playbackRate: t = 1, loop: n = !0 } = {}) {
+	let r = Number.isFinite(t) && t > 0 ? Math.min(ot, Math.max(at, t)) : 1;
+	return {
+		delayMs: Number.isFinite(e) && e > 0 ? e * 1e3 : 0,
+		rate: r,
+		loop: n
+	};
+}
+function lt(e, t = {}) {
+	let { delayMs: n, rate: r, loop: i } = ct(t);
+	e.loop = i, e.defaultPlaybackRate = r, e.playbackRate = r;
+	let a, o, s = () => {
+		a = void 0, e.play().catch(() => {
+			typeof window < "u" && (o = () => void e.play().catch(() => void 0), window.addEventListener("pointerdown", o, { once: !0 }));
+		});
+	};
+	return n > 0 ? (e.pause(), e.currentTime = 0, a = setTimeout(s, n)) : s(), () => {
+		a !== void 0 && clearTimeout(a), o && typeof window < "u" && window.removeEventListener("pointerdown", o);
+	};
+}
+// ../engine/src/media/file.ts
+function ut(e, t) {
+	return e.colorSpace = p, e.anisotropy = t, e;
+}
+// ../engine/src/media/sample.ts
+function dt(e, t) {
+	let n = e > 1, r = n ? 2048 : 1179, i = Math.round(r / e), a = document.createElement("canvas");
+	a.width = r, a.height = i;
+	let o = a.getContext("2d");
+	o && (n ? ft : pt)(o, r, i);
+	let s = ut(new M(a), t);
+	return {
+		texture: s,
+		aspect: r / i,
+		dispose: () => s.dispose()
+	};
+}
+function ft(e, t, n) {
+	let r = (e, t) => `${e} ${t}px ui-sans-serif, system-ui, -apple-system, "Segoe UI", sans-serif`;
+	e.textBaseline = "middle";
+	let i = e.createLinearGradient(0, 0, t, n);
+	i.addColorStop(0, "#15171f"), i.addColorStop(1, "#0a0b0f"), e.fillStyle = i, e.fillRect(0, 0, t, n);
+	let a = e.createRadialGradient(t * .8, n * .2, 0, t * .8, n * .2, t * .6);
+	a.addColorStop(0, "rgba(124, 92, 255, 0.28)"), a.addColorStop(1, "rgba(124, 92, 255, 0)"), e.fillStyle = a, e.fillRect(0, 0, t, n);
+	let o = Math.round(n * .035);
+	e.fillStyle = "rgba(255,255,255,0.06)", e.fillRect(0, 0, t, o), e.fillStyle = "#f2f3f5", e.font = r(600, o * .5), e.fillText("Focus", o * .9, o / 2), e.fillStyle = "rgba(242,243,245,0.6)", e.font = r(500, o * .45), e.fillText("Tue 21 Oct  10:08", t - o * 7.2, o / 2);
+	let s = Math.round(t * .17), c = Math.round(t * .018);
+	e.fillStyle = "rgba(255,255,255,0.045)", e.fillRect(0, o, s, n - o), [
+		"Overview",
+		"Projects",
+		"Timeline",
+		"Exports",
+		"Settings"
+	].forEach((t, n) => {
+		let i = o + c * 1.6 + n * c * 2.2;
+		n === 0 && (e.fillStyle = "rgba(124, 92, 255, 0.35)", e.beginPath(), e.roundRect(c * .6, i - c * .8, s - c * 1.2, c * 1.6, c * .4), e.fill()), e.fillStyle = n === 0 ? "#ffffff" : "rgba(242,243,245,0.6)", e.font = r(n === 0 ? 650 : 500, c * .78), e.fillText(t, c * 1.3, i);
+	});
+	let l = s + c * 1.5, u = t - l - c * 1.5;
+	e.fillStyle = "rgba(242,243,245,0.55)", e.font = r(500, c * .8), e.fillText("Tuesday, 21 October", l, o + c * 1.6), e.fillStyle = "#f2f3f5", e.font = r(700, c * 1.7), e.fillText("Good morning", l, o + c * 3.2);
+	let d = o + c * 4.6, f = Math.round((n - d - c * 1.5) * .52), p = e.createLinearGradient(l, d, l + u, d + f);
+	p.addColorStop(0, "#6d5dfc"), p.addColorStop(.55, "#c14dd6"), p.addColorStop(1, "#ff8a5c"), e.fillStyle = p, e.beginPath(), e.roundRect(l, d, u, f, c * 1.1), e.fill(), e.fillStyle = "rgba(255,255,255,0.8)", e.font = r(600, c * .85), e.fillText("Focus time this week", l + c * 1.4, d + c * 1.8), e.fillStyle = "#fff", e.font = r(700, c * 3.2), e.fillText("26h 40m", l + c * 1.3, d + c * 4.2);
+	let m = [
+		.35,
+		.55,
+		.42,
+		.7,
+		.5,
+		.92,
+		.64,
+		.58,
+		.77,
+		.48,
+		.86,
+		.6
+	], h = l + u * .46, g = u * .5 / m.length, _ = d + f - c * 1.2;
+	m.forEach((t, n) => {
+		let r = t * (f - c * 2.6);
+		e.fillStyle = n === 5 ? "#fff" : "rgba(255,255,255,0.34)", e.beginPath(), e.roundRect(h + n * g + g * .22, _ - r, g * .56, r, c * .25), e.fill();
+	});
+	let v = d + f + c, y = n - v - c * 1.5, b = c, x = (u - b * 2) / 3;
+	[
+		[
+			"Steps",
+			"8,240",
+			.82,
+			"#3ddc97"
+		],
+		[
+			"Sleep",
+			"7h 40m",
+			.64,
+			"#5ab0ff"
+		],
+		[
+			"Sessions",
+			"14",
+			.47,
+			"#ffb23f"
+		]
+	].forEach(([t, n, i, a], o) => {
+		let s = l + o * (x + b);
+		e.fillStyle = "#171a22", e.beginPath(), e.roundRect(s, v, x, y, c * .9), e.fill(), e.fillStyle = "rgba(242,243,245,0.55)", e.font = r(600, c * .8), e.fillText(t, s + c, v + c * 1.4), e.fillStyle = "#f2f3f5", e.font = r(700, c * 1.6), e.fillText(n, s + c, v + c * 3.2);
+		let u = s + x - c * 1.9, d = v + y / 2, f = Math.min(y * .28, c * 1.4);
+		e.lineWidth = f * .32, e.lineCap = "round", e.strokeStyle = "rgba(255,255,255,0.1)", e.beginPath(), e.arc(u, d, f, 0, Math.PI * 2), e.stroke(), e.strokeStyle = a, e.beginPath(), e.arc(u, d, f, -Math.PI / 2, -Math.PI / 2 + Math.PI * 2 * i), e.stroke();
+	});
+}
+function pt(e, t, n) {
+	let r = (e, t) => `${e} ${t}px ui-sans-serif, system-ui, -apple-system, "Segoe UI", sans-serif`;
+	e.textBaseline = "middle";
+	let i = e.createLinearGradient(0, 0, 0, n);
+	i.addColorStop(0, "#12141b"), i.addColorStop(1, "#07080b"), e.fillStyle = i, e.fillRect(0, 0, t, n);
+	let a = e.createRadialGradient(t * .85, n * .12, 0, t * .85, n * .12, t);
+	a.addColorStop(0, "rgba(124, 92, 255, 0.32)"), a.addColorStop(1, "rgba(124, 92, 255, 0)"), e.fillStyle = a, e.fillRect(0, 0, t, n), e.fillStyle = "#f2f3f5", e.font = r(600, 46), e.fillText("10:08", 108, 92);
+	for (let n = 0; n < 4; n++) {
+		let r = 12 + n * 8;
+		e.fillRect(t - 84 - 250 + n * 22, 108 - r, 14, r);
+	}
+	e.strokeStyle = "rgba(242, 243, 245, 0.5)", e.lineWidth = 3, e.beginPath(), e.roundRect(t - 84 - 140, 76, 84, 34, 10), e.stroke(), e.beginPath(), e.roundRect(t - 84 - 134, 82, 60, 22, 5), e.fill(), e.fillRect(t - 84 - 52, 86, 5, 14), e.fillStyle = "rgba(242, 243, 245, 0.55)", e.font = r(500, 40), e.fillText("Tuesday, 21 October", 84, 262), e.fillStyle = "#f2f3f5", e.font = r(700, 92), e.fillText("Good morning", 84, 360);
+	let o = t - 168, s = e.createLinearGradient(84, 450, 84 + o, 1090);
+	s.addColorStop(0, "#6d5dfc"), s.addColorStop(.55, "#c14dd6"), s.addColorStop(1, "#ff8a5c"), e.fillStyle = s, e.beginPath(), e.roundRect(84, 450, o, 640, 64), e.fill(), e.fillStyle = "rgba(255, 255, 255, 0.8)", e.font = r(600, 40), e.fillText("Focus time today", 148, 550), e.fillStyle = "#fff", e.font = r(700, 140), e.fillText("4h 12m", 140, 675), e.fillStyle = "rgba(255, 255, 255, 0.8)", e.font = r(500, 38), e.fillText("+38 min vs. last week", 148, 770);
+	let c = [
+		.35,
+		.55,
+		.42,
+		.7,
+		.5,
+		.92,
+		.64
+	], l = (o - 128) / c.length;
+	c.forEach((t, n) => {
+		let r = t * 190;
+		e.fillStyle = n === 5 ? "#fff" : "rgba(255, 255, 255, 0.34)", e.beginPath(), e.roundRect(148 + n * l + l * .2, 1026 - r, l * .6, r, 14), e.fill();
+	});
+	let u = (o - 40) / 2;
+	[{
+		label: "Steps",
+		value: "8,240",
+		progress: .82,
+		color: "#3ddc97"
+	}, {
+		label: "Sleep",
+		value: "7h 40m",
+		progress: .64,
+		color: "#5ab0ff"
+	}].forEach((t, n) => {
+		let i = 84 + n * (u + 40);
+		e.fillStyle = "#171a22", e.beginPath(), e.roundRect(i, 1134, u, 300, 48), e.fill(), e.fillStyle = "rgba(242, 243, 245, 0.55)", e.font = r(600, 38), e.fillText(t.label, i + 48, 1216), e.fillStyle = "#f2f3f5", e.font = r(700, 70), e.fillText(t.value, i + 48, 1330);
+		let a = i + u - 96, o = 1220;
+		e.lineWidth = 16, e.lineCap = "round", e.strokeStyle = "rgba(255, 255, 255, 0.1)", e.beginPath(), e.arc(a, o, 42, 0, Math.PI * 2), e.stroke(), e.strokeStyle = t.color, e.beginPath(), e.arc(a, o, 42, -Math.PI / 2, -Math.PI / 2 + Math.PI * 2 * t.progress), e.stroke();
+	});
+	let d = 1530;
+	e.fillStyle = "#f2f3f5", e.font = r(700, 50), e.fillText("Up next", 84, d), d += 64;
+	for (let [t, n, i] of [
+		[
+			"Design review",
+			"11:00 · Studio B",
+			"#ffb23f"
+		],
+		[
+			"Team lunch",
+			"13:30 · Rooftop",
+			"#3ddc97"
+		],
+		[
+			"Ship v0.2",
+			"17:00 · Release",
+			"#ff5c7a"
+		]
+	]) e.fillStyle = i + "33", e.beginPath(), e.arc(124, d + 68, 40, 0, Math.PI * 2), e.fill(), e.fillStyle = i, e.beginPath(), e.arc(124, d + 68, 14, 0, Math.PI * 2), e.fill(), e.fillStyle = "#f2f3f5", e.font = r(600, 46), e.fillText(t, 196, d + 46), e.fillStyle = "rgba(242, 243, 245, 0.5)", e.font = r(500, 36), e.fillText(n, 196, d + 96), e.fillStyle = "rgba(255, 255, 255, 0.07)", e.fillRect(196, d + 140, o - 112, 2), d += 146;
+	let f = n - 262;
+	e.fillStyle = "rgba(28, 31, 40, 0.95)", e.beginPath(), e.roundRect(84, f, o, 150, 75), e.fill();
+	for (let t = 0; t < 4; t++) {
+		let n = 84 + o * ((t + .5) / 4);
+		e.fillStyle = t === 0 ? "#f2f3f5" : "rgba(242, 243, 245, 0.32)", e.beginPath(), e.roundRect(n - 24, f + 51, 48, 48, 14), e.fill();
+	}
+	e.fillStyle = "rgba(255, 255, 255, 0.85)", e.beginPath(), e.roundRect(t / 2 - 140, n - 46, 280, 12, 6), e.fill();
+}
+// ../engine/src/interaction.ts
+function mt({ engine: e, element: t, getDoc: n, overrides: r, onTime: i }) {
+	let a = 0, o = 0, s = 0, c = !1, l = 1, u = !1, d = 0, f = 0, p = B, m = B, h = null, g = null, _ = null, v = () => ({
+		...n().interaction,
+		...r,
+		cursor: {
+			...n().interaction.cursor,
+			...r?.cursor
+		}
+	});
+	function y(e) {
+		return g && g.timeline === e.timeline || (g = {
+			timeline: e.timeline,
+			compiled: L(e.timeline)
+		}), g.compiled;
+	}
+	function b(e, t, n) {
+		if (n === "loop") return (e % t + t) % t;
+		if (n === "pingpong") {
+			let n = e % (t * 2);
+			return n <= t ? n : t * 2 - n;
+		}
+		return Math.max(0, Math.min(t, e));
+	}
+	function x(e, t, n) {
+		let r = t.timeline.duration;
+		switch (n.trigger) {
+			case "none": return 0;
+			case "load":
+			case "in-view":
+			case "click": return c && (s += e * n.speed * l), n.loop === "none" && s >= r && (s = r, c = !1), b(Math.max(0, s - n.delay), r, n.loop);
+			case "hover": return c && (s += e * n.speed * l, s >= r && (s = r, n.loop === "none" ? c = !1 : n.loop === "pingpong" ? l = -1 : s = 0), s <= 0 && (s = 0, l === -1 && (c = !1))), Math.max(0, Math.min(r, s));
+			case "scroll": {
+				let t = n.scroll?.smoothing ?? 6;
+				return f += (d - f) * (1 - Math.exp(-e * t)), f * r;
+			}
+			case "cursor-move": return (m.x + 1) / 2 * r;
+		}
+	}
+	function S() {
+		let e = t.getBoundingClientRect(), n = window.innerHeight || 1, r = v(), i = r.scroll?.start === "top" ? n - e.height : n, a = i - (r.scroll?.end === "bottom" ? n - e.height : -e.height) || 1;
+		d = Math.max(0, Math.min(1, (i - e.top) / a));
+	}
+	function C(t) {
+		a = requestAnimationFrame(C);
+		let s = Math.min((t - o) / 1e3, .05) || 0;
+		o = t;
+		let c = n(), l = v();
+		m = V(m, p, s, l.cursor.smoothing), p = {
+			...p,
+			speed: p.speed * Math.exp(-s * 6)
+		};
+		let u = x(s, c, l);
+		i?.(u);
+		let d = c.scene.devices.map((e) => e.id), f = [];
+		c.interaction.idle.float > 0 && f.push(K(t / 1e3, c.interaction.idle.float, d));
+		let h = R(c, u, [], y(c));
+		f.push(q(m, l.cursor, t / 1e3, d, h.camera)), r?.cameraZoom && f.push(W(r.cameraZoom, h.camera)), e.renderFrame(R(c, u, f, y(c)));
+	}
+	let w = (e) => {
+		let n = t.getBoundingClientRect(), r = (e.clientX - n.left) / n.width * 2 - 1, i = -((e.clientY - n.top) / n.height * 2 - 1), a = performance.now(), o = p.speed;
+		if (h) {
+			let e = Math.max(1, a - h.time) / 1e3;
+			o = Math.min(1, Math.hypot(r - h.x, i - h.y) / e / 6);
+		}
+		h = {
+			x: r,
+			y: i,
+			time: a
+		}, p = {
+			x: Math.max(-1, Math.min(1, r)),
+			y: Math.max(-1, Math.min(1, i)),
+			speed: o
+		};
+	}, T = () => {
+		p = B, h = null, u = !1;
+		let e = v();
+		e.trigger === "hover" && (e.hover?.reverseOnLeave ?? !0 ? (l = -1, c = !0) : c = !1);
+	}, E = () => {
+		u = !0, v().trigger === "hover" && (l = 1, c = !0);
+	}, D = () => {
+		v().trigger === "click" && (!c || s >= n().timeline.duration ? (s >= n().timeline.duration && (s = 0), c = !0) : c = !1);
+	}, O = () => S();
+	return {
+		start() {
+			if (a) return;
+			let e = v();
+			t.addEventListener("pointermove", w), t.addEventListener("pointerleave", T), t.addEventListener("pointerenter", E), t.addEventListener("click", D), window.addEventListener("scroll", O, { passive: !0 }), window.addEventListener("resize", O), S(), s = 0, l = 1, c = e.trigger === "load", e.trigger === "in-view" && (_ = new IntersectionObserver((e) => {
+				e.some((e) => e.isIntersecting) && (c = !0, _?.disconnect());
+			}, { threshold: .5 }), _.observe(t)), o = performance.now(), a = requestAnimationFrame(C);
+		},
+		stop() {
+			cancelAnimationFrame(a), a = 0, t.removeEventListener("pointermove", w), t.removeEventListener("pointerleave", T), t.removeEventListener("pointerenter", E), t.removeEventListener("click", D), window.removeEventListener("scroll", O), window.removeEventListener("resize", O), _?.disconnect(), _ = null;
+		},
+		restart() {
+			s = 0, l = 1, c = v().trigger !== "none" && v().trigger !== "scroll" && v().trigger !== "cursor-move" && (v().trigger !== "hover" || u);
+		},
+		dispose() {
+			this.stop();
+		}
+	};
+}
+// ../devices/src/registry.ts
+var ht = {
+	phone: () => import("./device-phone-DxWL5LkW.js").then((e) => e.t).then((e) => e.phone),
+	tablet: () => import("./device-tablet-B1JOR7Rf.js").then((e) => e.t).then((e) => e.tablet),
+	laptop: () => import("./device-laptop-DlKLhrO9.js").then((e) => e.t).then((e) => e.laptop),
+	monitor: () => import("./device-monitor-BkXp8a-n.js").then((e) => e.t).then((e) => e.monitor),
+	watch: () => import("./device-watch-9Y7wuyPn.js").then((e) => e.t).then((e) => e.watch)
+}, gt = /* @__PURE__ */ new Map();
+function _t(e) {
+	let t = gt.get(e);
+	return t || (t = ht[e](), gt.set(e, t)), t;
+}
+function vt(e) {
+	let t = e.split(".")[0];
+	if (!(t in ht)) throw Error(`Unknown device spec '${e}'`);
+	return t;
+}
+function yt(e, t, n) {
+	if (typeof n != "string") return n;
+	let r = e.finishes[n] ?? e.finishes[t.finishes[0] ?? ""];
+	if (!r) throw Error(`Device '${t.id}' has no finishes`);
+	return r;
+}
+async function bt(e, t, n = "high") {
+	let r = await _t(vt(e)), i = r.specs[e];
+	if (!i) throw Error(`Unknown device spec '${e}'`);
+	return U(r.build(i, yt(r, i, t), n));
+}
+// src/media.ts
+function xt(e, t) {
+	try {
+		return new URL(e, t).href;
+	} catch {
+		return e;
+	}
+}
+async function $(e, t) {
+	let n = new Image();
+	n.crossOrigin = "anonymous", n.src = e, await n.decode();
+	let r = ut(new k(n), t);
+	return r.needsUpdate = !0, {
+		texture: r,
+		aspect: n.naturalWidth / n.naturalHeight,
+		dispose: () => r.dispose()
+	};
+}
+async function St(e, t, n) {
+	let r = document.createElement("video");
+	r.crossOrigin = "anonymous", r.muted = !0, r.playsInline = !0, r.preload = "auto", r.src = e, await new Promise((t, n) => {
+		r.addEventListener("loadedmetadata", () => t(), { once: !0 }), r.addEventListener("error", () => n(/* @__PURE__ */ Error(`Video failed: ${e}`)), { once: !0 });
+	});
+	let i = lt(r, st(n.video)), a = ut(new y(r), t);
+	return {
+		texture: a,
+		aspect: r.videoWidth / r.videoHeight,
+		duration: r.duration,
+		dispose() {
+			i(), r.pause(), r.removeAttribute("src"), r.load(), a.dispose();
+		}
+	};
+}
+function Ct(e, t, n) {
+	return {
+		buildDevice: (e) => bt(e.spec, e.finish, t),
+		async resolveScreen(t, r, { maxAnisotropy: i, screenAspect: a }) {
+			let o = t.media;
+			if (n) return t.poster ? $(t.poster, i).catch(() => dt(a, i)) : o?.source === "url" && o.kind === "image" ? $(xt(o.url, e), i).catch(() => null) : dt(a, i);
+			if (!o) return dt(a, i);
+			if (o.source === "data") return $(o.dataUrl, i);
+			if (o.source === "url") {
+				let n = xt(o.url, e);
+				return o.kind === "video" ? St(n, i, t) : $(n, i);
+			}
+			return dt(a, i);
+		},
+		async resolveBackdrop(t, { maxAnisotropy: r }) {
+			return n || t.kind !== "image" || t.source === "idb" ? null : $(t.source === "data" ? t.dataUrl : xt(t.url, e), r);
+		}
+	};
+}
+// src/runtime.ts
+var wt = /* @__PURE__ */ e({ mount: () => Dt }), Tt = (e) => {
+	let t = window;
+	t.requestIdleCallback ? t.requestIdleCallback(e, { timeout: 2e3 }) : setTimeout(e, 300);
+};
+function Et(e, t) {
+	let n = document.createElement("div"), r = e === "dark" ? "#f1f1f3" : "#17181b";
+	return n.style.cssText = `position:absolute;inset:0;display:grid;place-items:center;background:${t && t !== "transparent" ? t : e === "dark" ? "#0d0e11" : "#f4f4f2"};transition:opacity .3s`, n.innerHTML = `<div style="width:28px;height:28px;border-radius:50%;border:2px solid ${r}33;border-top-color:${r};animation:om-spin .8s linear infinite"></div><style>@keyframes om-spin{to{transform:rotate(360deg)}}</style>`, n;
+}
+async function Dt(e, t, n) {
+	let r = await fetch(n, { credentials: "omit" });
+	if (!r.ok) throw Error(`Could not load ${n} (${r.status})`);
+	let i = H(await r.json()), a = t.backgroundColor;
+	a && (i.scene.backdrop = a === "transparent" ? {
+		...i.scene.backdrop,
+		kind: "transparent"
+	} : {
+		...i.scene.backdrop,
+		kind: "solid",
+		color: a
+	});
+	let o = document.createElement("div");
+	o.style.cssText = "position:absolute;inset:0;";
+	let s = document.createElement("canvas");
+	s.style.cssText = "display:block;width:100%;height:100%;", s.setAttribute("aria-label", i.name), o.append(s), e.append(o);
+	let c = t.loader ? Et(t.theme, a) : null;
+	c && e.append(c);
+	let l = it({
+		canvas: s,
+		quality: "embed"
+	}), u = () => l.setSize(e.clientWidth || 1, e.clientHeight || 1), d = new ResizeObserver(u);
+	d.observe(e);
+	let f = t.progressive ? Ct(n, "low", !0) : Ct(n, "high", !1);
+	await l.loadScene(i.scene, f), u();
+	let p = mt({
+		engine: l,
+		element: e,
+		getDoc: () => i,
+		overrides: t.overrides
+	});
+	p.start(), c && (c.style.opacity = "0", setTimeout(() => c.remove(), 350));
+	let m = !1;
+	return t.progressive && Tt(() => {
+		m || l.loadScene(i.scene, Ct(n, "high", !1));
+	}), { dispose() {
+		m = !0, d.disconnect(), p.dispose(), l.dispose(), o.remove(), c?.remove();
+	} };
+}
+export { wt as t };