@selvajs/selva 4.7.0-beta.6 → 4.7.0

package/build/server/chunks/chunks/chunk-N2WCSETE.js-CK2Q00_P.js

@@ -0,0 +1,2953 @@
+import { _ as _e$1, m, h, p, l, a as x } from './chunk-Y3M7P3BW.js-qwxSY5dh.js';
+import { i as inflateSync } from './esm2.js-C_Dsvb5P.js';
+import * as z from 'three';
+import { ViewHelper } from 'three/addons/helpers/ViewHelper.js';
+import { LineSegmentsGeometry } from 'three/addons/lines/LineSegmentsGeometry.js';
+import { LineSegments2 } from 'three/addons/lines/LineSegments2.js';
+import { LineMaterial } from 'three/addons/lines/LineMaterial.js';
+import { Pass, FullScreenQuad } from 'three/addons/postprocessing/Pass.js';
+import { EffectComposer } from 'three/addons/postprocessing/EffectComposer.js';
+import { RenderPass } from 'three/addons/postprocessing/RenderPass.js';
+import { GTAOPass } from 'three/addons/postprocessing/GTAOPass.js';
+import { SMAAPass } from 'three/addons/postprocessing/SMAAPass.js';
+import { OutputPass } from 'three/addons/postprocessing/OutputPass.js';
+import { CSS2DRenderer, CSS2DObject } from 'three/addons/renderers/CSS2DRenderer.js';
+import { Line2 } from 'three/addons/lines/Line2.js';
+import { LineGeometry } from 'three/addons/lines/LineGeometry.js';
+import { OrbitControls } from 'three/addons/controls/OrbitControls.js';
+import { HDRLoader } from 'three/addons/loaders/HDRLoader.js';
+
+//#region ../compute/dist/chunk-N2WCSETE.js
+var Vn = {};
+_e$1(Vn, {
+	CONCRETE_MATERIAL: () => xt,
+	EMISSIVE_MATERIAL: () => Tt,
+	GLASS_MATERIAL: () => wt,
+	METAL_MATERIAL: () => Rt,
+	PLASTIC_MATERIAL: () => vt,
+	RUBBER_MATERIAL: () => Mt,
+	SHARED_MATERIALS: () => Ye,
+	WOOD_MATERIAL: () => Ht
+});
+var Tt = new z.MeshPhysicalMaterial({
+	color: 0,
+	emissive: new z.Color(16777215),
+	emissiveIntensity: 5,
+	metalness: 0,
+	roughness: .2,
+	clearcoat: .3,
+	clearcoatRoughness: .2,
+	depthWrite: true,
+	depthTest: true,
+	transparent: false,
+	alphaTest: 0,
+	polygonOffset: true,
+	polygonOffsetFactor: 1,
+	polygonOffsetUnits: 1,
+	side: z.FrontSide,
+	dithering: true
+});
+var Rt = new z.MeshPhysicalMaterial({
+	color: new z.Color(0),
+	metalness: .9,
+	roughness: .3,
+	envMapIntensity: 1.2,
+	clearcoat: .3,
+	clearcoatRoughness: .2,
+	reflectivity: 1,
+	ior: 2.5,
+	thickness: 1,
+	depthWrite: true,
+	transparent: false,
+	alphaTest: 0,
+	depthTest: true,
+	polygonOffset: true,
+	polygonOffsetFactor: 1,
+	polygonOffsetUnits: 1,
+	side: z.FrontSide,
+	dithering: true
+});
+var xt = new z.MeshPhysicalMaterial({
+	color: new z.Color(13421772),
+	metalness: 0,
+	roughness: .92,
+	envMapIntensity: .15,
+	clearcoat: .05,
+	clearcoatRoughness: .9,
+	reflectivity: .15,
+	transmission: 0,
+	ior: 1.45,
+	thickness: 0,
+	depthWrite: true,
+	transparent: false,
+	alphaTest: 0,
+	depthTest: true,
+	polygonOffset: true,
+	polygonOffsetFactor: 1,
+	polygonOffsetUnits: 1,
+	side: z.FrontSide,
+	dithering: true
+});
+var vt = new z.MeshPhysicalMaterial({
+	color: new z.Color(16777215),
+	metalness: 0,
+	roughness: .3,
+	envMapIntensity: .5,
+	clearcoat: .5,
+	clearcoatRoughness: .1,
+	reflectivity: .5,
+	ior: 1.4,
+	transmission: 0,
+	transparent: false,
+	depthWrite: true,
+	side: z.FrontSide,
+	dithering: true,
+	polygonOffset: true,
+	polygonOffsetFactor: 1,
+	polygonOffsetUnits: 1
+});
+var wt = new z.MeshPhysicalMaterial({
+	color: new z.Color(16777215),
+	metalness: 0,
+	roughness: 0,
+	transmission: .95,
+	transparent: true,
+	depthWrite: false,
+	envMapIntensity: 1,
+	clearcoat: 1,
+	clearcoatRoughness: 0,
+	ior: 1.52,
+	reflectivity: .9,
+	thickness: 1,
+	side: z.DoubleSide,
+	polygonOffset: true,
+	polygonOffsetFactor: 1,
+	polygonOffsetUnits: 1
+});
+var Mt = new z.MeshPhysicalMaterial({
+	color: new z.Color(1710618),
+	metalness: 0,
+	roughness: .9,
+	envMapIntensity: .2,
+	clearcoat: .1,
+	clearcoatRoughness: .8,
+	reflectivity: .2,
+	ior: 1.3,
+	transmission: 0,
+	depthWrite: true,
+	side: z.FrontSide,
+	polygonOffset: true,
+	polygonOffsetFactor: 1,
+	polygonOffsetUnits: 1
+});
+var Ht = new z.MeshPhysicalMaterial({
+	color: new z.Color(8934707),
+	metalness: 0,
+	roughness: .7,
+	envMapIntensity: .3,
+	clearcoat: .3,
+	clearcoatRoughness: .4,
+	reflectivity: .3,
+	ior: 1.3,
+	transmission: 0,
+	depthWrite: true,
+	side: z.FrontSide,
+	dithering: true,
+	polygonOffset: true,
+	polygonOffsetFactor: 1,
+	polygonOffsetUnits: 1
+});
+var Ye = /* @__PURE__ */ new Set([
+	Tt,
+	Rt,
+	xt,
+	vt,
+	wt,
+	Mt,
+	Ht
+]);
+function we(e) {
+	let n = e.clone().normalize(), t = new z.Vector3(0, 0, 1), r = new z.Vector3(0, 1, 0), a = Math.abs(n.dot(t)) > .9 ? r : t, o = new z.Vector3().crossVectors(a, n).normalize();
+	return {
+		up: n,
+		forward: new z.Vector3().crossVectors(n, o).normalize(),
+		right: o
+	};
+}
+function Oe(e, n) {
+	let { forward: t, right: r, up: a } = we(e);
+	return t.clone().multiplyScalar(-1).add(r.clone().multiplyScalar(-1)).add(a).normalize().multiplyScalar(n);
+}
+function Ct(e, n, t) {
+	let { forward: r, right: a, up: o } = we(e);
+	return a.clone().multiplyScalar(n).add(r.clone().multiplyScalar(n)).add(o.clone().multiplyScalar(t));
+}
+function At(e) {
+	let n = e.clone().normalize(), t = new z.Vector3(0, 1, 0);
+	if (n.dot(t) > .9999) return new z.Euler();
+	if (n.dot(t) < -0.9999) return new z.Euler(Math.PI, 0, 0);
+	let r = new z.Quaternion().setFromUnitVectors(t, n);
+	return new z.Euler().setFromQuaternion(r);
+}
+function Xe(e) {
+	let n = Math.abs(e.x), t = Math.abs(e.y), r = Math.abs(e.z);
+	return n >= t && n >= r ? "x" : t >= r ? "y" : "z";
+}
+var se = {
+	HUGE_THRESHOLD: 1e4,
+	LARGE_THRESHOLD: 1e3,
+	SCALE_RATIO_THRESHOLD: 100,
+	NEAR_PLANE_FACTOR: {
+		TINY: 1e-4,
+		SMALL: .001,
+		NORMAL: .01
+	},
+	FAR_PLANE_FACTOR: {
+		HUGE: 100,
+		LARGE: 50,
+		NORMAL: 20
+	},
+	INITIAL_DISTANCE_MULTIPLIER: 4
+};
+function Ia(e, n, t, r, a) {
+	if (jn(e), n.length === 0) return;
+	n.forEach((u) => {
+		e.add(u);
+	});
+	let o = Ke(n), i = o.getCenter(new z.Vector3()), l = o.getSize(new z.Vector3()), s = Math.max(l.x, l.y, l.z);
+	if (s / Math.min(l.x || 1, l.y || 1, l.z || 1) > se.SCALE_RATIO_THRESHOLD || s > se.HUGE_THRESHOLD ? (t.near = s * se.NEAR_PLANE_FACTOR.TINY, t.far = s * se.FAR_PLANE_FACTOR.HUGE) : s > se.LARGE_THRESHOLD ? (t.near = s * se.NEAR_PLANE_FACTOR.SMALL, t.far = s * se.FAR_PLANE_FACTOR.LARGE) : (t.near = Math.max(.01, s * se.NEAR_PLANE_FACTOR.NORMAL), t.far = Math.max(2e3, s * se.FAR_PLANE_FACTOR.NORMAL)), t.updateProjectionMatrix(), !a) {
+		let u = s * se.INITIAL_DISTANCE_MULTIPLIER;
+		t.position.copy(i).add(Oe(t.up, u)), r.target.copy(i), r.update();
+	}
+}
+function St(e) {
+	if (!e || typeof e != "string") return m().warn(`Invalid color input: ${e}, using white`), new z.Color(16777215);
+	let n = e.trim();
+	if (/^#?[0-9A-Fa-f]{6}$/.test(n)) try {
+		let r = n.startsWith("#") ? n : `#${n}`;
+		return new z.Color(r);
+	} catch {
+		return m().warn(`Invalid hex color: ${e}, using white`), new z.Color(16777215);
+	}
+	if (n.includes(",")) {
+		let r = n.split(",").map((a) => parseInt(a.trim(), 10));
+		if (r.length === 3 && r.every((a) => !isNaN(a) && a >= 0 && a <= 255)) return new z.Color(r[0] / 255, r[1] / 255, r[2] / 255);
+	}
+	let t = n.toLowerCase();
+	return t in z.Color.NAMES ? new z.Color(z.Color.NAMES[t]) : (m().warn(`Invalid color string: ${e}, using white`), new z.Color(16777215));
+}
+function Dt(e, n, t = "z") {
+	e.forEach((r) => {
+		r.position[t] -= n;
+	});
+}
+function Ke(e) {
+	let n = new z.Box3();
+	return e.length === 0 || e.forEach((t) => {
+		t.updateMatrixWorld(true);
+		let r = new z.Box3().setFromObject(t);
+		n.union(r);
+	}), n;
+}
+var zn = /* @__PURE__ */ new Set([
+	"grid",
+	"floor",
+	"label-layer",
+	"measure"
+]);
+function Gn(e) {
+	let n = e;
+	for (; n;) {
+		if (typeof n.userData.id == "string" && zn.has(n.userData.id)) return true;
+		n = n.parent;
+	}
+	return false;
+}
+function ce(e) {
+	e.updateMatrixWorld(true);
+	let n = new z.Box3();
+	return e.traverse((t) => {
+		let r = t;
+		t.visible && !Gn(t) && r.geometry && n.expandByObject(t);
+	}), n;
+}
+var Nn = /* @__PURE__ */ new Set([
+	"floor",
+	"grid",
+	"label-layer"
+]);
+var Ie = "selvaGeometryCache";
+function jn(e) {
+	[...e.children].forEach((t) => {
+		Nn.has(t.userData.id) || t.userData.source !== "user" && (t.traverse((r) => {
+			let a = r;
+			if (!a.geometry && !a.material) return;
+			a.geometry?.userData?.[Ie] || a.geometry?.dispose();
+			let o = a.material;
+			if (!o) return;
+			(Array.isArray(o) ? o : [o]).forEach((l) => {
+				if (!Ye.has(l)) {
+					for (let s of Object.values(l)) s instanceof z.Texture && s.dispose();
+					l.dispose();
+				}
+			});
+		}), t.removeFromParent());
+	});
+}
+function Wn(e) {
+	let { up: n, forward: t, right: r } = we(e), a = t.clone().negate(), o = r.clone();
+	return {
+		top: n.clone(),
+		bottom: n.clone().negate(),
+		front: a.clone(),
+		back: a.clone().negate(),
+		right: o.clone(),
+		left: o.clone().negate(),
+		iso: a.clone().multiplyScalar(1.2).add(o.clone()).add(n.clone()).normalize()
+	};
+}
+function Lt(e) {
+	let { scene: n, perspective: t, controls: r, onActiveCameraChange: a } = e, o = (e.up ?? t.up).clone().normalize(), i = Wn(o), l = new z.OrthographicCamera(-1, 1, 1, -1, t.near, t.far);
+	l.up.copy(o);
+	let s = "perspective", c = t.aspect, u = () => s === "perspective" ? t : l, d = null, p = () => {
+		d?.cancel(), d = null;
+	}, T = () => {
+		let h = (s === "orthographic" ? l : t).position.distanceTo(r.target) * Math.tan(t.fov * Math.PI / 360), y = h * c;
+		l.left = -y, l.right = y, l.top = h, l.bottom = -h, l.near = t.near, l.far = t.far, l.updateProjectionMatrix();
+	}, v = (E) => {
+		if (E !== s) {
+			if (p(), E === "orthographic") l.position.copy(t.position), l.up.copy(t.up), l.lookAt(r.target), l.zoom = 1, T();
+			else {
+				let h = (l.top - l.bottom) / (2 * l.zoom) / Math.tan(t.fov * Math.PI / 360), y = l.position.clone().sub(r.target);
+				y.lengthSq() < 1e-12 && y.copy(o), y.normalize(), t.position.copy(r.target).add(y.multiplyScalar(h));
+			}
+			s = E, r.object = u(), r.update(), a(u());
+		}
+	}, R = (E, f, h, y) => {
+		let C = t.fov * (Math.PI / 180), M = f / (2 * Math.tan(C / 2)) * 1.5, L = $n(h, o), I = E.clone().add(L.clone().multiplyScalar(M)), k = u();
+		s === "orthographic" && (l.zoom = 1), p(), y ? d = Yn(k, r, I, E, () => {
+			s === "orthographic" && T();
+		}) : (k.position.copy(I), r.target.copy(E), s === "orthographic" && T(), r.update());
+	}, m = (E, f = true) => {
+		let h = ce(n), y = h.isEmpty() ? r.target.clone() : h.getCenter(new z.Vector3()), C = h.isEmpty() ? new z.Vector3(1, 1, 1) : h.getSize(new z.Vector3()), M = Math.max(C.x, C.y, C.z) || 1;
+		R(y, M, E, f);
+	};
+	return {
+		getActiveCamera: u,
+		getProjection: () => s,
+		setProjection: v,
+		toggleProjection: () => (v(s === "perspective" ? "orthographic" : "perspective"), s),
+		setView: (E, f = true) => {
+			m(i[E], f);
+		},
+		setViewDirection: m,
+		frameBounds: (E, f = true) => {
+			if (E.isEmpty()) return;
+			let h = E.getCenter(new z.Vector3()), y = E.getSize(new z.Vector3()), C = Math.max(y.x, y.y, y.z) || 1, M = u().position.clone().sub(r.target);
+			M.lengthSq() < 1e-12 && M.copy(i.iso), R(h, C, M.normalize(), f);
+		},
+		setRotateEnabled: (E) => {
+			r.enableRotate = E;
+		},
+		isRotateEnabled: () => r.enableRotate,
+		updateAspect: (E, f) => {
+			c = f === 0 ? c : E / f, s === "orthographic" && T();
+		},
+		dispose: p
+	};
+}
+function $n(e, n) {
+	let { up: t, forward: r } = we(n), a = e.clone().normalize();
+	if (Math.abs(a.dot(t)) < .9999) return e;
+	let o = r.clone().negate(), i = .5 * Math.PI / 180;
+	return a.multiplyScalar(Math.cos(i)).add(o.multiplyScalar(Math.sin(i))).normalize();
+}
+var qn = (e) => 1 - Math.pow(1 - e, 3);
+function Yn(e, n, t, r, a, o = 250) {
+	let i = e.position.clone(), l = n.target.clone(), s = performance.now(), c = null, u = () => {
+		c = null;
+		let d = qn(Math.min((performance.now() - s) / o, 1));
+		e.position.lerpVectors(i, t, d), n.target.lerpVectors(l, r, d), a(), n.update(), d < 1 && (c = requestAnimationFrame(u));
+	};
+	return c = requestAnimationFrame(u), { cancel: () => {
+		c !== null && (cancelAnimationFrame(c), c = null);
+	} };
+}
+function Xn(e) {
+	if (!(e > 0) || !Number.isFinite(e)) return 1;
+	let t = Math.pow(10, Math.floor(Math.log10(e))), r = e / t;
+	return (r >= 5 ? 5 : r >= 2 ? 2 : 1) * t;
+}
+var Kn = `
+	varying vec3 vWorldPos;
+	void main() {
+		vec4 world = modelMatrix * vec4(position, 1.0);
+		vWorldPos = world.xyz;
+		gl_Position = projectionMatrix * viewMatrix * world;
+	}
+`;
+var Zn = `
+	precision highp float;
+	varying vec3 vWorldPos;
+
+	uniform vec2 uAxes;         // indices (0=x,1=y,2=z) of the two in-plane world axes
+	uniform float uCell;
+	uniform float uMajor;
+	uniform vec3 uCellColor;
+	uniform vec3 uMajorColor;
+	uniform vec3 uCenter;       // fade center (camera position), projected onto plane
+	uniform float uFade;
+
+	// Antialiased grid line intensity for a given spacing, using screen-space derivatives so lines
+	// stay ~1px regardless of zoom (the standard "pristine grid" technique).
+	float gridLine(vec2 coord, float spacing) {
+		vec2 c = coord / spacing;
+		vec2 d = fwidth(c);
+		vec2 g = abs(fract(c - 0.5) - 0.5) / max(d, 1e-6);
+		float line = min(g.x, g.y);
+		return 1.0 - clamp(line, 0.0, 1.0);
+	}
+
+	// Index a vec3 by a float axis id (0/1/2) without dynamic indexing (WebGL1-safe).
+	float axis(vec3 v, float i) {
+		return i < 0.5 ? v.x : (i < 1.5 ? v.y : v.z);
+	}
+
+	void main() {
+		// Pick the two in-plane world coordinates.
+		vec2 coord = vec2(axis(vWorldPos, uAxes.x), axis(vWorldPos, uAxes.y));
+
+		float minor = gridLine(coord, uCell);
+		float major = gridLine(coord, uCell * uMajor);
+
+		vec3 color = mix(uCellColor, uMajorColor, major);
+		float alpha = max(minor, major);
+
+		// Radial fade from the camera-projected center.
+		float dist = distance(vWorldPos, uCenter);
+		float fade = 1.0 - clamp(dist / uFade, 0.0, 1.0);
+		alpha *= fade * fade;
+
+		if (alpha < 0.001) discard;
+		gl_FragColor = vec4(color, alpha);
+	}
+`;
+function Ot(e = {}) {
+	let { cellSize: n = 1, majorEvery: t = 10, cellColor: r = 8947848, majorColor: a = 4473924, fadeDistance: o = 100, plane: i = "y" } = e, l = i === "y" ? new z.Vector2(0, 2) : i === "z" ? new z.Vector2(0, 1) : new z.Vector2(1, 2), s = 2.5, c = new z.PlaneGeometry(1, 1);
+	i === "y" ? c.rotateX(-Math.PI / 2) : i === "x" && c.rotateY(Math.PI / 2);
+	let u = new z.ShaderMaterial({
+		vertexShader: Kn,
+		fragmentShader: Zn,
+		transparent: true,
+		depthWrite: false,
+		side: z.DoubleSide,
+		uniforms: {
+			uAxes: { value: l },
+			uCell: { value: n },
+			uMajor: { value: t },
+			uCellColor: { value: new z.Color(r) },
+			uMajorColor: { value: new z.Color(a) },
+			uCenter: { value: new z.Vector3() },
+			uFade: { value: o }
+		}
+	}), d = new z.Mesh(c, u);
+	d.name = "grid", d.userData.id = "grid", d.renderOrder = -1;
+	let p = o, T = o * s, v = new z.Vector3();
+	return {
+		object: d,
+		update: (R) => {
+			i === "y" ? (d.position.set(R.x, 0, R.z), v.set(R.x, 0, R.z)) : i === "z" ? (d.position.set(R.x, R.y, 0), v.set(R.x, R.y, 0)) : (d.position.set(0, R.y, R.z), v.set(0, R.y, R.z)), u.uniforms.uCenter.value.copy(v), d.scale.setScalar(T);
+		},
+		fitToContent: (R) => {
+			if (R.isEmpty()) return;
+			let m = R.getSize(new z.Vector3()), g = (H, E) => E === 0 ? H.x : E === 1 ? H.y : H.z, b = Math.max(g(m, l.x), g(m, l.y));
+			if (!(b > 0) || !Number.isFinite(b)) return;
+			let x = 20;
+			u.uniforms.uCell.value = Xn(b / x), p = b * 2, u.uniforms.uFade.value = p, T = p * s;
+		},
+		setVisible: (R) => {
+			d.visible = R;
+		},
+		dispose: () => {
+			d.removeFromParent(), c.dispose(), u.dispose();
+		}
+	};
+}
+function It(e) {
+	let { camera: n, domElement: t, controller: r } = e, a = new ViewHelper(n, t);
+	a.setLabels("X", "Y", "Z");
+	let o = true, i = 128, l = new z.Raycaster(), s = new z.OrthographicCamera(-2, 2, 2, -2, 0, 4);
+	s.position.set(0, 0, 2), s.updateMatrixWorld();
+	let c = {
+		posX: new z.Vector3(1, 0, 0),
+		negX: new z.Vector3(-1, 0, 0),
+		posY: new z.Vector3(0, 1, 0),
+		negY: new z.Vector3(0, -1, 0),
+		posZ: new z.Vector3(0, 0, 1),
+		negZ: new z.Vector3(0, 0, -1)
+	}, u = (p) => {
+		let T = t.getBoundingClientRect(), v = T.left + t.offsetWidth - i - a.location.right, R = T.top + t.offsetHeight - i - a.location.bottom, m = new z.Vector2((p.clientX - v) / i * 2 - 1, -((p.clientY - R) / i) * 2 + 1);
+		if (Math.abs(m.x) > 1 || Math.abs(m.y) > 1) return null;
+		a.quaternion.copy(n.quaternion).invert(), a.updateMatrixWorld(), l.setFromCamera(m, s);
+		let g = l.intersectObjects(a.children, false);
+		for (let b of g) {
+			let x = b.object.userData?.type;
+			if (typeof x == "string" && x in c) return x;
+		}
+		return null;
+	};
+	return {
+		render: (p) => {
+			if (!o) return;
+			let T = p.autoClear;
+			p.autoClear = false, a.render(p), p.autoClear = T;
+		},
+		update: () => {},
+		handleClick: (p) => {
+			if (!o) return false;
+			let T = u(p);
+			return T ? (r.getProjection() === "orthographic" && r.setProjection("perspective"), r.setViewDirection(c[T], false), true) : false;
+		},
+		isAnimating: false,
+		setVisible: (p) => {
+			o = p;
+		},
+		isVisible: () => o,
+		dispose: () => a.dispose()
+	};
+}
+function Pe(e, n, t) {
+	let o = Math.cos(Math.PI / 180 * t), i = e.length / 3;
+	if (i >= 67108864) throw new Error(`extractEdgeSegments: ${i} vertices exceeds 2^26 limit`);
+	let l = new Float64Array(i), s = new Float64Array(i), c = new Float64Array(i);
+	for (let f = 0; f < i; f++) l[f] = Math.round(e[3 * f] * 1e4), s[f] = Math.round(e[3 * f + 1] * 1e4), c[f] = Math.round(e[3 * f + 2] * 1e4);
+	let u = 16;
+	for (; u < i * 2;) u <<= 1;
+	let d = u - 1, p = new Int32Array(u).fill(-1), T = new Int32Array(i);
+	for (let f = 0; f < i; f++) {
+		let h = (Math.imul(l[f] | 0, 73856093) ^ Math.imul(s[f] | 0, 19349663) ^ Math.imul(c[f] | 0, 83492791)) & d;
+		for (;;) {
+			let y = p[h];
+			if (y === -1) {
+				p[h] = f, T[f] = f;
+				break;
+			}
+			if (l[y] === l[f] && s[y] === s[f] && c[y] === c[f]) {
+				T[f] = y;
+				break;
+			}
+			h = h + 1 & d;
+		}
+	}
+	let v = /* @__PURE__ */ new Float32Array(4096), R = 0, m = (f, h) => {
+		if (R + 6 > v.length) {
+			let y = new Float32Array(v.length * 2);
+			y.set(v), v = y;
+		}
+		v[R++] = e[3 * f], v[R++] = e[3 * f + 1], v[R++] = e[3 * f + 2], v[R++] = e[3 * h], v[R++] = e[3 * h + 1], v[R++] = e[3 * h + 2];
+	}, g = /* @__PURE__ */ new Map(), b = [], x = [], H = [], E = (n ? n.length : i) / 3;
+	for (let f = 0; f < E; f++) {
+		let h = n ? n[3 * f] : 3 * f, y = n ? n[3 * f + 1] : 3 * f + 1, C = n ? n[3 * f + 2] : 3 * f + 2, M = T[h], L = T[y], I = T[C];
+		if (M === L || L === I || I === M) continue;
+		let k = e[3 * C] - e[3 * y], O = e[3 * C + 1] - e[3 * y + 1], F = e[3 * C + 2] - e[3 * y + 2], S = e[3 * h] - e[3 * y], D = e[3 * h + 1] - e[3 * y + 1], G = e[3 * h + 2] - e[3 * y + 2], V = O * G - F * D, q = F * S - k * G, Y = k * D - O * S, fe = V * V + q * q + Y * Y;
+		if (fe > 0) {
+			let ee = 1 / Math.sqrt(fe);
+			V *= ee, q *= ee, Y *= ee;
+		} else V = 0, q = 0, Y = 0;
+		for (let ee = 0; ee < 3; ee++) {
+			let pe, j, te, ne;
+			ee === 0 ? (pe = h, j = y, te = M, ne = L) : ee === 1 ? (pe = y, j = C, te = L, ne = I) : (pe = C, j = h, te = I, ne = M);
+			let xe = ne * 67108864 + te, he = g.get(xe);
+			if (he !== void 0 && he !== -1) V * H[3 * he] + q * H[3 * he + 1] + Y * H[3 * he + 2] <= o && m(pe, j), g.set(xe, -1);
+			else {
+				let ie = te * 67108864 + ne;
+				if (!g.has(ie)) {
+					let ve = b.length;
+					g.set(ie, ve), b.push(pe), x.push(j), H.push(V, q, Y);
+				}
+			}
+		}
+	}
+	for (let f of g.values()) f !== -1 && m(b[f], x[f]);
+	return v.slice(0, R);
+}
+function Pt() {
+	return [
+		`const extract = ${Pe.toString()};`,
+		"self.onmessage = (event) => {",
+		"  const { id, positions, index, thresholdAngle } = event.data;",
+		"  try {",
+		"    const segments = extract(positions, index, thresholdAngle);",
+		"    self.postMessage({ id, segments }, [segments.buffer]);",
+		"  } catch (error) {",
+		"    self.postMessage({ id, error: String((error && error.message) || error) });",
+		"  }",
+		"};"
+	].join(`
+`);
+}
+var He = "edge-overlay";
+var rt = "triangle-cap";
+var nr = 2236962;
+var rr = 1.5;
+var or = 44;
+var ar = .75;
+var ir = 4e6;
+var sr = 2e6;
+var lr = 25e3;
+var Ft = 128 * 1024 * 1024;
+var cr = 4;
+var Bt = 1;
+var ur = 0;
+var dr = -1;
+function Je(e) {
+	let n = e.getAttribute("position");
+	return n ? (e.index ? e.index.count : n.count) / 3 : 0;
+}
+function Ut(e) {
+	let n = e.getAttribute("position");
+	if (!n || n.isInterleavedBufferAttribute || n.itemSize !== 3 || !(n.array instanceof Float32Array) || n.count >= 67108864) return null;
+	let t = e.index;
+	return t && !(t.array instanceof Uint32Array) && !(t.array instanceof Uint16Array) ? null : {
+		positions: n.array,
+		index: t ? t.array : null
+	};
+}
+function _t(e, n) {
+	let r = 2166136261, a = (s) => {
+		r ^= s, r = Math.imul(r, 16777619);
+	}, o = new Uint32Array(e.positions.buffer, e.positions.byteOffset, e.positions.length), i = Math.min(4096, o.length);
+	for (let s = 0; s < i; s++) a(o[s]);
+	for (let s = Math.max(i, o.length - 4096); s < o.length; s++) a(o[s]);
+	let l = 0;
+	if (e.index) {
+		l = e.index.length;
+		let s = Math.min(4096, l);
+		for (let c = 0; c < s; c++) a(e.index[c]);
+		for (let c = Math.max(s, l - 4096); c < l; c++) a(e.index[c]);
+	}
+	return `${n}:${e.positions.length}:${l}:${r >>> 0}`;
+}
+var ue = /* @__PURE__ */ new Map();
+var Fe = 0;
+function Vt(e) {
+	let n = ue.get(e);
+	return n && (ue.delete(e), ue.set(e, n)), n;
+}
+function zt(e, n) {
+	if (n.byteLength > Ft) return;
+	let t = ue.get(e);
+	for (t && (Fe -= t.byteLength, ue.delete(e)), ue.set(e, n), Fe += n.byteLength; Fe > Ft;) {
+		let r = ue.keys().next().value;
+		Fe -= ue.get(r).byteLength, ue.delete(r);
+	}
+}
+function mr(e, n) {
+	let t = new z.EdgesGeometry(e, n), r = t.attributes.position ? t.attributes.position.array : /* @__PURE__ */ new Float32Array(0);
+	return t.dispose(), r;
+}
+function Qe(e, n) {
+	let t = Ut(e);
+	if (!t) return mr(e, n);
+	let r = _t(t, n), a = Vt(r);
+	if (a) return a;
+	let o = Pe(t.positions, t.index, n);
+	return zt(r, o), o;
+}
+var ye;
+var Me = /* @__PURE__ */ new Map();
+var fr = 1;
+function pr() {
+	if (ye !== void 0) return ye;
+	if (typeof Worker > "u" || typeof Blob > "u" || typeof URL > "u" || typeof URL.createObjectURL != "function") return ye = null, null;
+	try {
+		let e = URL.createObjectURL(new Blob([Pt()], { type: "text/javascript" })), n = new Worker(e);
+		n.onmessage = (t) => {
+			let { id: r, segments: a, error: o } = t.data, i = Me.get(r);
+			i && (Me.delete(r), a ? i.resolve(a) : i.reject(new Error(o ?? "edge extraction failed in worker")));
+		}, n.onerror = () => {
+			for (let t of Me.values()) t.reject(/* @__PURE__ */ new Error("edge extraction worker crashed"));
+			Me.clear(), n.terminate(), ye = null;
+		}, ye = n;
+	} catch {
+		ye = null;
+	}
+	return ye;
+}
+function Er(e, n, t) {
+	return new Promise((r, a) => {
+		let o = fr++;
+		Me.set(o, {
+			resolve: r,
+			reject: a
+		});
+		let i = n.positions.slice(), l = n.index ? n.index.slice() : null, s = [i.buffer];
+		l && s.push(l.buffer), e.postMessage({
+			id: o,
+			positions: i,
+			index: l,
+			thresholdAngle: t
+		}, s);
+	});
+}
+var Ze = /* @__PURE__ */ new Map();
+function hr(e, n) {
+	let t = Ut(e);
+	if (!t || Je(e) < lr) return Promise.resolve(Qe(e, n));
+	let r = _t(t, n), a = Vt(r);
+	if (a) return Promise.resolve(a);
+	let o = Ze.get(r);
+	if (o) return o;
+	let i = pr();
+	if (!i) return Promise.resolve(Qe(e, n));
+	let l = Er(i, t, n).catch(() => Pe(t.positions, t.index, n)).then((s) => (zt(r, s), s)).finally(() => {
+		Ze.delete(r);
+	});
+	return Ze.set(r, l), l;
+}
+var gr = .15;
+var yr = 4096;
+function br(e) {
+	let n = Math.floor(e.length / 6);
+	if (n === 0) return Infinity;
+	let t = Math.max(1, Math.ceil(n / yr)), r = [];
+	for (let a = 0; a < n; a += t) {
+		let o = a * 6, i = Math.hypot(e[o + 3] - e[o], e[o + 4] - e[o + 1], e[o + 5] - e[o + 2]);
+		i > 0 && r.push(i);
+	}
+	return r.length === 0 ? Infinity : (r.sort((a, o) => a - o), r[Math.min(r.length - 1, Math.floor(r.length * gr))]);
+}
+var Be = /* @__PURE__ */ new WeakMap();
+function et(e, n) {
+	return Be.get(e)?.get(n);
+}
+function Gt(e, n, t) {
+	let r = Be.get(e);
+	r || (r = /* @__PURE__ */ new Map(), Be.set(e, r));
+	let a = new LineSegmentsGeometry();
+	a.setPositions(t);
+	let o = {
+		geometry: a,
+		refCount: 0,
+		segmentCount: t.length / 6,
+		edgeSpacing: br(t)
+	};
+	return r.set(n, o), o;
+}
+function Tr(e) {
+	let n = e.userData, t = n.edgeSource && Be.get(n.edgeSource), r = n.edgeThresholdAngle != null ? t?.get(n.edgeThresholdAngle) : void 0;
+	if (!r || r.geometry !== e.geometry) {
+		e.geometry.dispose();
+		return;
+	}
+	r.refCount -= 1, r.refCount <= 0 && (r.geometry.dispose(), t.delete(n.edgeThresholdAngle));
+}
+function Nt(e) {
+	return {
+		forcedColor: e.color != null ? new z.Color(e.color) : null,
+		darken: z.MathUtils.clamp(e.darken ?? ar, 0, 1),
+		width: e.width ?? rr,
+		thresholdAngle: e.thresholdAngle ?? or,
+		distanceFade: e.distanceFade ?? true,
+		maxTriangles: e.maxTriangles ?? ir,
+		maxSegments: e.maxSegments ?? sr
+	};
+}
+function Rr(e, n) {
+	let r = (Array.isArray(e.material) ? e.material[0] : e.material)?.color;
+	return r ? r.clone().multiplyScalar(1 - n) : new z.Color(nr);
+}
+var ke = class {
+	constructor(n) {
+		h(this, "options", n);
+		h(this, "byKey", /* @__PURE__ */ new Map());
+	}
+	for(n, t) {
+		let r = this.options.forcedColor ?? Rr(n, this.options.darken), a = r.getHex() * 2 + (t ? 1 : 0), o = this.byKey.get(a);
+		return o || (o = xr(r, this.options.width, t), this.byKey.set(a, o)), o;
+	}
+	disposeUnused(n) {
+		let t = new Set(n.map((r) => r.material));
+		for (let r of this.byKey.values()) t.has(r) || r.dispose();
+	}
+};
+function xr(e, n, t) {
+	let r = new LineMaterial({ color: e });
+	return r.linewidth = n, r.polygonOffset = true, r.polygonOffsetFactor = ur, r.polygonOffsetUnits = dr, t && (r.transparent = true), r;
+}
+function vr(e, n, t, r, a) {
+	n.refCount += 1;
+	let o = new LineSegments2(n.geometry, t);
+	return o.userData.kind = He, o.userData.edgeSource = e, o.userData.edgeThresholdAngle = r, o.raycast = () => {}, a && Hr(o, n.edgeSpacing), o;
+}
+var kt = new z.Vector3();
+var wr = new z.Vector3();
+function Mr(e, n, t) {
+	e.geometry.boundingSphere || e.geometry.computeBoundingSphere();
+	let r = e.geometry.boundingSphere;
+	if (!r) return Infinity;
+	if (n.isPerspectiveCamera) {
+		let a = n;
+		kt.copy(r.center).applyMatrix4(e.matrixWorld);
+		let o = wr.setFromMatrixPosition(n.matrixWorld).distanceTo(kt);
+		if (o <= r.radius * e.matrixWorld.getMaxScaleOnAxis()) return Infinity;
+		let l = Math.tan(z.MathUtils.degToRad(a.fov) * .5), s = 2 * o * l;
+		return s > 0 ? t / s : Infinity;
+	}
+	if (n.isOrthographicCamera) {
+		let a = n, o = (a.top - a.bottom) / a.zoom;
+		return o > 0 ? t / o : Infinity;
+	}
+	return Infinity;
+}
+function Hr(e, n) {
+	e.onBeforeRender = (t, r, a) => {
+		LineSegments2.prototype.onBeforeRender.call(e, t);
+		let o = e.material, l = n * Mr(e, a, o.resolution.y);
+		o.opacity = z.MathUtils.clamp((l - Bt) / (cr - Bt), 0, 1);
+	};
+}
+function Cr(e) {
+	return e.userData?.kind === He;
+}
+function jt(e, n) {
+	let t = [];
+	return e.traverse((r) => {
+		if (r instanceof z.Mesh && !(r.userData.id === "floor" || r.userData.id === "grid") && r.userData.kind !== "edge-overlay" && !r.children.some((a) => a.userData?.kind === "edge-overlay") && r.geometry) {
+			if (Je(r.geometry) > n) {
+				r.userData.edgesSkipped = rt, console.debug(`[edges] skipping mesh over triangle cap (${Je(r.geometry)} > ${n})`);
+				return;
+			}
+			delete r.userData.edgesSkipped, t.push(r);
+		}
+	}), t;
+}
+function Wt(e, n, t, r) {
+	let a = r.distanceFade && n.segmentCount <= r.maxSegments, o = vr(e.geometry, n, t.for(e, a), r.thresholdAngle, a);
+	return e.add(o), o;
+}
+function $a(e, n = {}) {
+	let t = Nt(n), r = new ke(t), a = [];
+	for (let o of jt(e, t.maxTriangles)) {
+		let i = et(o.geometry, t.thresholdAngle) ?? Gt(o.geometry, t.thresholdAngle, Qe(o.geometry, t.thresholdAngle));
+		a.push(Wt(o, i, r, t));
+	}
+	return r.disposeUnused(a), a;
+}
+var $t = /* @__PURE__ */ new WeakMap();
+function tt(e) {
+	return $t.get(e) ?? 0;
+}
+function Ar(e, n) {
+	for (let t = e; t; t = t.parent) if (t === n) return true;
+	return false;
+}
+async function qt(e, n = {}) {
+	let t = Nt(n), r = new ke(t), a = tt(e), o = [], i = jt(e, t.maxTriangles).map(async (l) => {
+		let s = et(l.geometry, t.thresholdAngle);
+		if (!s) {
+			let c = await hr(l.geometry, t.thresholdAngle);
+			if (tt(e) !== a || !Ar(l, e) || l.children.some((u) => u.userData?.kind === "edge-overlay")) return;
+			s = et(l.geometry, t.thresholdAngle), s || (s = Gt(l.geometry, t.thresholdAngle, c));
+		}
+		o.push(Wt(l, s, r, t));
+	});
+	return await Promise.all(i), r.disposeUnused(o), o;
+}
+function Yt(e) {
+	$t.set(e, tt(e) + 1);
+	let n = [];
+	e.traverse((r) => {
+		r instanceof LineSegments2 && Cr(r) && n.push(r);
+	});
+	let t = /* @__PURE__ */ new Set();
+	for (let r of n) Tr(r), t.add(r.material), r.removeFromParent();
+	return t.forEach((r) => r.dispose()), n.length;
+}
+var ot = {
+	uniforms: {
+		tDiffuse: { value: null },
+		tNormal: { value: null },
+		tDepth: { value: null },
+		uResolution: { value: new z.Vector2(1, 1) },
+		uColor: { value: new z.Color(2236962) },
+		uOpacity: { value: 1 },
+		uNormalThreshold: { value: .4 },
+		uDepthThreshold: { value: .02 },
+		uThickness: { value: 1 },
+		uNear: { value: .1 },
+		uFar: { value: 1e3 },
+		uPerspective: { value: 1 }
+	},
+	vertexShader: `
+		varying vec2 vUv;
+		void main() {
+			vUv = uv;
+			gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+		}
+	`,
+	fragmentShader: `
+		uniform sampler2D tDiffuse;
+		uniform sampler2D tNormal;
+		uniform sampler2D tDepth;
+		uniform vec2 uResolution;
+		uniform vec3 uColor;
+		uniform float uOpacity;
+		uniform float uNormalThreshold;
+		uniform float uDepthThreshold;
+		uniform float uThickness;
+		uniform float uNear;
+		uniform float uFar;
+		uniform float uPerspective;
+		varying vec2 vUv;
+
+		float viewZOf(const in float depth) {
+			float perspective = (uNear * uFar) / ((uFar - uNear) * depth - uFar);
+			float orthographic = -(depth * (uFar - uNear) + uNear);
+			return mix(orthographic, perspective, uPerspective);
+		}
+
+		void main() {
+			vec4 color = texture2D(tDiffuse, vUv);
+			vec2 texel = uThickness / uResolution;
+
+			// Roberts cross over the two diagonal pairs.
+			vec2 offsetA = vec2(texel.x, texel.y);
+			vec2 offsetB = vec2(texel.x, -texel.y);
+
+			float z0 = viewZOf(texture2D(tDepth, vUv + offsetA).x);
+			float z1 = viewZOf(texture2D(tDepth, vUv - offsetA).x);
+			float z2 = viewZOf(texture2D(tDepth, vUv + offsetB).x);
+			float z3 = viewZOf(texture2D(tDepth, vUv - offsetB).x);
+			float zCenter = viewZOf(texture2D(tDepth, vUv).x);
+			// Relative difference: a constant threshold in absolute Z turns distant geometry into
+			// noise (depth precision) and near geometry blind; normalizing by the center depth keeps
+			// the response scale-invariant across the viewer's mm\u2192m scenes.
+			float depthDelta = (abs(z0 - z1) + abs(z2 - z3)) / max(abs(zCenter), 1e-6);
+			float depthEdge = step(uDepthThreshold, depthDelta);
+
+			vec3 n0 = texture2D(tNormal, vUv + offsetA).rgb * 2.0 - 1.0;
+			vec3 n1 = texture2D(tNormal, vUv - offsetA).rgb * 2.0 - 1.0;
+			vec3 n2 = texture2D(tNormal, vUv + offsetB).rgb * 2.0 - 1.0;
+			vec3 n3 = texture2D(tNormal, vUv - offsetB).rgb * 2.0 - 1.0;
+			float normalDelta = (1.0 - dot(n0, n1)) + (1.0 - dot(n2, n3));
+			float normalEdge = step(uNormalThreshold, normalDelta);
+
+			float edge = max(depthEdge, normalEdge) * uOpacity;
+			gl_FragColor = vec4(mix(color.rgb, uColor, edge), color.a);
+		}
+	`
+};
+var Ue = class extends Pass {
+	constructor(t, r, a, o, i = {}) {
+		super();
+		h(this, "camera");
+		h(this, "scene");
+		h(this, "normalMaterial");
+		h(this, "edgeMaterial");
+		h(this, "fsQuad");
+		h(this, "normalTarget", null);
+		h(this, "width");
+		h(this, "height");
+		this.scene = t, this.camera = r, this.width = Math.max(1, a), this.height = Math.max(1, o), this.normalMaterial = new z.MeshNormalMaterial(), this.normalMaterial.blending = z.NoBlending, this.edgeMaterial = new z.ShaderMaterial({
+			uniforms: z.UniformsUtils.clone(ot.uniforms),
+			vertexShader: ot.vertexShader,
+			fragmentShader: ot.fragmentShader
+		});
+		let l = this.edgeMaterial.uniforms;
+		l.uColor.value = new z.Color(i.color ?? 2236962), l.uOpacity.value = i.opacity ?? 1, l.uNormalThreshold.value = i.normalThreshold ?? .4, l.uDepthThreshold.value = i.depthThreshold ?? .02, l.uThickness.value = i.thickness ?? 1, this.fsQuad = new FullScreenQuad(this.edgeMaterial), this.needsSwap = true;
+	}
+	acquireNormalTarget() {
+		if (!this.normalTarget) {
+			let t = new z.DepthTexture(this.width, this.height);
+			this.normalTarget = new z.WebGLRenderTarget(this.width, this.height, {
+				minFilter: z.NearestFilter,
+				magFilter: z.NearestFilter,
+				depthTexture: t
+			});
+		}
+		return this.normalTarget;
+	}
+	setSize(t, r) {
+		this.width = Math.max(1, t), this.height = Math.max(1, r), this.normalTarget?.setSize(this.width, this.height);
+	}
+	render(t, r, a) {
+		let o = this.acquireNormalTarget(), i = t.getRenderTarget(), l = t.autoClear, s = t.getClearColor(new z.Color()), c = t.getClearAlpha(), u = this.scene.overrideMaterial;
+		t.setRenderTarget(o), t.setClearColor(7829503, 1), t.autoClear = true, this.scene.overrideMaterial = this.normalMaterial, t.render(this.scene, this.camera), this.scene.overrideMaterial = u, t.setClearColor(s, c), t.autoClear = l;
+		let d = this.edgeMaterial.uniforms;
+		d.tDiffuse.value = a.texture, d.tNormal.value = o.texture, d.tDepth.value = o.depthTexture, d.uResolution.value.set(this.width, this.height);
+		let p = this.camera;
+		d.uPerspective.value = p.isPerspectiveCamera ? 1 : 0, d.uNear.value = this.camera.near ?? .1, d.uFar.value = this.camera.far ?? 1e3, t.setRenderTarget(this.renderToScreen ? null : r), this.fsQuad.render(t), t.setRenderTarget(i);
+	}
+	dispose() {
+		this.normalTarget?.dispose(), this.normalMaterial.dispose(), this.edgeMaterial.dispose(), this.fsQuad.dispose();
+	}
+};
+function Xt(e, n, t, r, a, o) {
+	let i = new EffectComposer(e), l = new RenderPass(n, t);
+	i.addPass(l);
+	let s = null;
+	(o.ambientOcclusion ?? true) && (s = new GTAOPass(n, t, r, a), s.blendIntensity = o.aoIntensity ?? 1, s.updateGtaoMaterial({ screenSpaceRadius: true }), i.addPass(s));
+	let u = new Ue(n, t, r, a, typeof o.edgeDetection == "object" ? o.edgeDetection : {});
+	u.enabled = !!o.edgeDetection, i.addPass(u);
+	let d = new SMAAPass();
+	i.addPass(d);
+	let p = new OutputPass();
+	i.addPass(p), e.toneMapping = o.toneMapping, e.toneMappingExposure = o.toneMappingExposure;
+	let T = o.aoPixelRatio ?? 1;
+	return i.setSize(r, a), {
+		render: (v) => i.render(v),
+		setSize: (v, R, m) => {
+			i.setPixelRatio(Math.min(m, T)), i.setSize(v, R);
+		},
+		setCamera: (v) => {
+			if (l.camera = v, u.camera = v, !s) return;
+			s.camera = v;
+			let R = v.isPerspectiveCamera ? 1 : 0;
+			s.gtaoMaterial.defines.PERSPECTIVE_CAMERA !== R && (s.gtaoMaterial.defines.PERSPECTIVE_CAMERA = R, s.gtaoMaterial.needsUpdate = true);
+		},
+		setEdgeDetection: (v) => {
+			u.enabled = v;
+		},
+		edgeDetectionEnabled: () => u.enabled,
+		dispose: () => {
+			i.dispose(), s?.dispose(), u.dispose(), d.dispose(), p.dispose();
+		}
+	};
+}
+function Zt(e, n) {
+	let t = new CSS2DRenderer(), r = t.domElement;
+	r.style.position = "absolute", r.style.top = "0", r.style.left = "0", r.style.overflow = "hidden", r.style.pointerEvents = "none", r.style.zIndex = "30", getComputedStyle(e).position === "static" && (e.style.position = "relative"), e.appendChild(r);
+	let a = {
+		width: e.clientWidth || 1,
+		height: e.clientHeight || 1
+	};
+	t.setSize(a.width, a.height);
+	let o = new z.Group();
+	o.name = "label-layer", o.userData.id = "label-layer", n.add(o);
+	let i = /* @__PURE__ */ new Set();
+	return {
+		addLabel: (s, c, u) => {
+			let d = document.createElement("div");
+			d.textContent = s, u ? d.className = u : Object.assign(d.style, {
+				padding: "2px 6px",
+				borderRadius: "4px",
+				background: "rgba(20, 20, 20, 0.78)",
+				color: "#fff",
+				font: "12px/1.3 system-ui, sans-serif",
+				whiteSpace: "pre",
+				textAlign: "center",
+				userSelect: "none"
+			}), d.style.pointerEvents = "none";
+			let p = new CSS2DObject(d);
+			return p.position.copy(c), o.add(p), i.add(p), {
+				object: p,
+				setPosition: (T) => p.position.copy(T),
+				setText: (T) => {
+					d.textContent = T;
+				},
+				remove: () => {
+					p.removeFromParent(), d.remove(), i.delete(p);
+				}
+			};
+		},
+		render: (s, c) => t.render(s, c),
+		setSize: (s, c) => t.setSize(s, c),
+		dispose: () => {
+			i.forEach((s) => {
+				s.removeFromParent(), s.element.remove();
+			}), i.clear(), o.removeFromParent(), r.remove();
+		}
+	};
+}
+var zr = 12;
+var Gr = 16763904;
+var Jt = .015;
+var Qt = {
+	Millimeters: {
+		metersPerUnit: 1 / 1e3,
+		suffix: "mm"
+	},
+	Centimeters: {
+		metersPerUnit: 1 / 100,
+		suffix: "cm"
+	},
+	Meters: {
+		metersPerUnit: 1,
+		suffix: "m"
+	},
+	Inches: {
+		metersPerUnit: 1 / 39.37,
+		suffix: "in"
+	},
+	Feet: {
+		metersPerUnit: 1 / 3.28084,
+		suffix: "ft"
+	}
+};
+function Nr(e) {
+	let n = e && Qt[e] || Qt.Meters;
+	return (t) => `${(t / n.metersPerUnit).toPrecision(3)} ${n.suffix}`;
+}
+function jr(e, n) {
+	if (e.isOrthographicCamera) {
+		let r = e;
+		return Math.abs(r.top - r.bottom) / (r.zoom || 1) * Jt;
+	}
+	return ((n ? e.position.distanceTo(n) : e.position.length()) || 1) * Jt;
+}
+function Wr(e) {
+	let n = e.object;
+	if (n instanceof z.Mesh) return e.face ? [
+		e.face.a,
+		e.face.b,
+		e.face.c
+	] : null;
+	if (n instanceof z.Points) return e.index != null ? [e.index] : null;
+	if (n instanceof z.Line) {
+		if (e.index == null) return null;
+		let t = n.geometry.index;
+		return t ? e.index + 1 >= t.count ? null : [t.getX(e.index), t.getX(e.index + 1)] : [e.index, e.index + 1];
+	}
+	return null;
+}
+function $r(e, n, t, r) {
+	let a = e.point.clone(), o = e.object, i = Wr(e);
+	if (!i || !o.geometry) return a;
+	let l = o.geometry.attributes.position;
+	if (!l) return a;
+	let s = (p) => {
+		let T = p.clone().project(n);
+		return new z.Vector2((T.x + 1) / 2 * t.width, (1 - T.y) / 2 * t.height);
+	}, c = s(a), u = a, d = r;
+	for (let p of i) {
+		if (p >= l.count) continue;
+		let v = new z.Vector3().fromBufferAttribute(l, p).applyMatrix4(o.matrixWorld), R = s(v).distanceTo(c);
+		R < d && (d = R, u = v);
+	}
+	return u;
+}
+function en(e) {
+	let { canvas: n, scene: t, getActiveCamera: r, getViewTarget: a, labelLayer: o, options: i = {} } = e, l = i.snapPixels ?? zr, s = new z.Color(i.color ?? Gr), c = Nr(i.displayUnit), u = (S, D) => `${c(S)}
+\u0394x ${c(D.x)}  \u0394y ${c(D.y)}  \u0394z ${c(D.z)}`, d = i.format ?? u, p = new z.Raycaster(), T = new z.Vector2(), v = false, R = [], m = [], g = null, b = null, x = new z.PointsMaterial({
+		color: s,
+		size: 8,
+		sizeAttenuation: false,
+		depthTest: false
+	}), H = new z.PointsMaterial({
+		color: s,
+		size: 11,
+		sizeAttenuation: false,
+		depthTest: false,
+		transparent: true,
+		opacity: .5
+	}), E = null, f = (S) => {
+		if (!S) {
+			E && (E.visible = false);
+			return;
+		}
+		if (!E) {
+			let D = new z.BufferGeometry();
+			D.setAttribute("position", new z.Float32BufferAttribute([
+				0,
+				0,
+				0
+			], 3)), E = new z.Points(D, H), E.renderOrder = 1e3, E.userData.id = "measure", E.raycast = () => {}, t.add(E);
+		}
+		E.position.copy(S), E.visible = true;
+	}, h = (S) => {
+		let D = new z.BufferGeometry();
+		D.setAttribute("position", new z.Float32BufferAttribute([
+			S.x,
+			S.y,
+			S.z
+		], 3));
+		let G = new z.Points(D, x);
+		return G.renderOrder = 999, G.userData.id = "measure", G.raycast = () => {}, t.add(G), G;
+	}, y = () => {
+		R.length = 0, m.forEach((S) => {
+			S.geometry.dispose(), S.removeFromParent();
+		}), m.length = 0, g && (g.geometry.dispose(), g.material.dispose(), g.removeFromParent(), g = null), b?.remove(), b = null;
+	}, C = () => {
+		if (R.length !== 2) return;
+		let [S, D] = R, G = new LineGeometry();
+		G.setPositions([
+			S.x,
+			S.y,
+			S.z,
+			D.x,
+			D.y,
+			D.z
+		]);
+		let V = new LineMaterial({ color: s });
+		V.linewidth = 2, V.depthTest = false, g = new Line2(G, V), g.renderOrder = 998, g.userData.id = "measure", g.raycast = () => {}, t.add(g);
+		let q = S.clone().add(D).multiplyScalar(.5), Y = new z.Vector3(Math.abs(D.x - S.x), Math.abs(D.y - S.y), Math.abs(D.z - S.z));
+		b = o.addLabel(d(S.distanceTo(D), Y), q, i.labelClassName);
+	}, M = (S) => {
+		let D = n.getBoundingClientRect();
+		T.x = (S.clientX - D.left) / D.width * 2 - 1, T.y = -((S.clientY - D.top) / D.height) * 2 + 1;
+		let G = r();
+		p.setFromCamera(T, G);
+		let V = jr(G, a?.());
+		p.params.Line.threshold = V, p.params.Points.threshold = V;
+		let q = p.intersectObjects(t.children, true).filter((Y) => Y.object.userData.id !== "measure" && Y.object.userData.id !== "grid");
+		return q.length === 0 ? null : $r(q[0], G, {
+			width: D.width,
+			height: D.height
+		}, l);
+	}, L = null, I = 0, k = () => {
+		I && (cancelAnimationFrame(I), I = 0), L = null;
+	};
+	return {
+		setEnabled: (S) => {
+			v = S, S || (k(), y(), f(null));
+		},
+		isEnabled: () => v,
+		handleClick: (S) => {
+			if (!v) return false;
+			R.length === 2 && y();
+			let D = M(S);
+			return D === null || (R.push(D), m.push(h(D)), R.length === 2 && C()), true;
+		},
+		handleMove: (S) => {
+			v && (L = S, !I && (I = requestAnimationFrame(() => {
+				I = 0;
+				let D = L;
+				L = null, !(!v || !D) && f(M(D));
+			})));
+		},
+		clear: y,
+		dispose: () => {
+			k(), y(), E && (E.geometry.dispose(), E.removeFromParent(), E = null), x.dispose(), H.dispose();
+		}
+	};
+}
+var qr = 64;
+var Yr = 256;
+var ae = /* @__PURE__ */ new Map();
+var Ce = /* @__PURE__ */ new Map();
+var _e = 0;
+var ze = class extends Error {
+	constructor(n) {
+		super(`Texture load for ${n} resolved after clearTextureCache(); texture disposed.`), this.name = "StaleTextureLoadError";
+	}
+};
+var Ve = 1;
+function tn(e) {
+	Ve = Math.max(1, e);
+	for (let n of ae.values()) n.anisotropy !== Ve && (n.anisotropy = Ve, n.needsUpdate = true);
+}
+function nn(e, n) {
+	let t = Xr(n), r = ae.get(t);
+	if (r) {
+		ae.delete(t), ae.set(t, r), e.map = r, e.needsUpdate = true;
+		return;
+	}
+	typeof document > "u" || Jr(n, t).then((a) => {
+		e.map = a, e.needsUpdate = true;
+	}).catch((a) => {
+		a instanceof ze || m().warn(`Failed to load material texture ${n}:`, a);
+	});
+}
+function mi() {
+	_e++;
+	for (let e of ae.values()) e.dispose();
+	ae.clear(), Ce.clear();
+}
+function Xr(e) {
+	return e.length <= Yr ? e : `data-uri:${Kr(e).toString(16)}:${e.length}`;
+}
+function Kr(e) {
+	let n = 2166136261;
+	for (let t = 0; t < e.length; t++) n ^= e.charCodeAt(t), n = Math.imul(n, 16777619);
+	return n >>> 0;
+}
+function Zr(e, n) {
+	for (ae.set(e, n); ae.size > 64;) {
+		let t = ae.keys().next().value, r = ae.get(t);
+		ae.delete(t), r.dispose();
+	}
+}
+function Jr(e, n) {
+	let t = Ce.get(n);
+	if (!t) {
+		let r = _e;
+		t = new Promise((a, o) => {
+			new z.TextureLoader().load(e, (i) => {
+				if (r !== _e) {
+					i.dispose(), o(new ze(e));
+					return;
+				}
+				i.colorSpace = z.SRGBColorSpace, i.anisotropy = Ve, Zr(n, i), Ce.delete(n), a(i);
+			}, void 0, (i) => {
+				r === _e && Ce.delete(n), o(i);
+			});
+		}), Ce.set(n, t);
+	}
+	return t;
+}
+var Qr = .5;
+var eo = .01;
+var to = .05;
+var no = [];
+function rn({ camera: e, scene: n, groundNormals: t = () => no }) {
+	let r = e.near, a = e.near, o = new z.Vector3(), i = new z.Vector3();
+	return { update: () => {
+		e.near !== a && (r = e.near);
+		let s = ce(n), c = r;
+		if (!s.isEmpty()) {
+			let u = s.getSize(i).length() * .5, d = e.position.distanceTo(s.getCenter(o)) - u;
+			for (let p of t()) d = Math.min(d, Math.abs(e.position.dot(p)));
+			c = z.MathUtils.clamp(d * Qr, r, e.far * eo);
+		}
+		Math.abs(c - a) > a * to && (e.near = c, e.updateProjectionMatrix(), a = c);
+	} };
+}
+var de = new z.Vector3(0, 0, 1);
+var ao = "technical";
+var at = {
+	studio: {
+		toneMapping: z.ACESFilmicToneMapping,
+		toneMappingExposure: 1,
+		envMapIntensity: 1,
+		environmentIntensity: 1,
+		hemisphereIntensity: .75,
+		ambientIntensity: .4,
+		cullBackfaces: false,
+		ambientOcclusion: false
+	},
+	technical: {
+		toneMapping: z.NeutralToneMapping,
+		toneMappingExposure: 1,
+		envMapIntensity: .9,
+		environmentIntensity: 1,
+		hemisphereIntensity: .35,
+		ambientIntensity: .25,
+		cullBackfaces: false,
+		ambientOcclusion: false
+	},
+	showcase: {
+		toneMapping: z.ACESFilmicToneMapping,
+		toneMappingExposure: 1.15,
+		envMapIntensity: 1.4,
+		environmentIntensity: 1.25,
+		hemisphereIntensity: .35,
+		ambientIntensity: .15,
+		cullBackfaces: false,
+		ambientOcclusion: false
+	}
+};
+function io(e) {
+	let n = at[e];
+	return {
+		envMapIntensity: n.envMapIntensity,
+		cullBackfaces: n.cullBackfaces
+	};
+}
+var Di = function(e, n) {
+	let t = so(n || {}), r = t.environment?.sceneUp || de, a = t.render.pixelRatio ?? Math.min(window.devicePixelRatio, 2), o = co(t), i = Eo(t, e);
+	i.up.copy(r);
+	let l = ho(e, t, a);
+	tn(l.capabilities.getMaxAnisotropy());
+	let s = yo(i, e, t), c = Lt({
+		scene: o,
+		perspective: i,
+		controls: s,
+		onActiveCameraChange: () => {},
+		up: r
+	}), u = () => c.getActiveCamera(), d = false;
+	mo(o, l, t, () => d);
+	let p = fo(o, t), T = p.sun, v = () => {
+		T && lo(T, ce(o));
+	};
+	t.floor?.enabled && po(o, t);
+	let R = t.floor?.enabled ? o.children.find((A) => A.userData.id === "floor") ?? null : null, m = t.grid.enabled ? Ot({
+		cellSize: t.grid.cellSize,
+		majorEvery: t.grid.majorEvery,
+		cellColor: t.grid.cellColor,
+		majorColor: t.grid.majorColor,
+		fadeDistance: t.grid.fadeDistance,
+		plane: t.grid.plane
+	}) : null;
+	m && o.add(m.object);
+	let g = () => {
+		m && m.fitToContent(ce(o));
+	}, b = t.gizmo.enabled ? It({
+		camera: i,
+		domElement: e,
+		controller: c
+	}) : null, x = t.grid.plane ?? Xe(r), H = new z.Vector3(x === "x" ? 1 : 0, x === "y" ? 1 : 0, x === "z" ? 1 : 0), E = r.clone().normalize(), f = () => {
+		let A = [];
+		return m?.object.visible && A.push(H), t.floor.enabled && R?.visible && A.push(E), A;
+	}, h = t.camera.dynamicNear ? rn({
+		camera: i,
+		scene: o,
+		groundNormals: f
+	}) : null, y = e.parentElement ?? e, C = t.measure.enabled ? Zt(y, o) : null, M = t.measure.enabled && C ? en({
+		canvas: e,
+		scene: o,
+		getActiveCamera: u,
+		labelLayer: C,
+		options: {
+			snapPixels: t.measure.snapPixels,
+			color: t.measure.color,
+			labelClassName: t.measure.labelClassName,
+			displayUnit: t.measure.displayUnit,
+			format: t.measure.format
+		}
+	}) : null, L = t.events.enableEventHandlers !== false ? go(e, o, c, t) : {
+		dispose: () => {},
+		fitToView: () => {},
+		clearSelection: () => {}
+	}, I = 5, k = 0, O = 0, F = (A) => {
+		k = A.clientX, O = A.clientY;
+	}, S = (A) => Math.hypot(A.clientX - k, A.clientY - O) > I, D = (A) => {
+		if (!S(A)) {
+			if (M?.handleClick(A)) {
+				A.stopImmediatePropagation();
+				return;
+			}
+			b?.handleClick(A) && A.stopImmediatePropagation();
+		}
+	};
+	(b || M) && (e.addEventListener("mousedown", F, { capture: true }), e.addEventListener("click", D, { capture: true }));
+	let G = (A) => M?.handleMove(A);
+	M && e.addEventListener("mousemove", G, { passive: true });
+	let V = () => {}, q = (A) => {
+		qt(A, {
+			color: t.edges.color,
+			darken: t.edges.darken,
+			width: t.edges.width,
+			thresholdAngle: t.edges.thresholdAngle,
+			distanceFade: t.edges.distanceFade,
+			maxTriangles: t.edges.maxTriangles,
+			maxSegments: t.edges.maxSegments
+		}).then(() => {
+			Y(A), V();
+		});
+	}, Y = (A) => {
+		if (t.edges.screenSpaceFallback === false) return;
+		let B = false;
+		A.traverse((K) => {
+			K.userData?.edgesSkipped === "triangle-cap" && (B = true);
+		}), B !== ne && (ne = B, ie());
+	}, fe = (A) => {
+		Yt(A), ne && (ne = false, ie()), V();
+	}, ee = e.parentElement, pe = () => ee ? {
+		width: ee.clientWidth,
+		height: ee.clientHeight
+	} : {
+		width: window.innerWidth,
+		height: window.innerHeight
+	}, j = null, te = !!t.render.ambientOcclusion, ne = false, xe = false, he = (A) => {
+		let { width: B, height: K } = pe(), ge = Xt(l, o, u(), Math.max(1, B), Math.max(1, K), {
+			toneMapping: t.render.toneMapping ?? z.NeutralToneMapping,
+			toneMappingExposure: t.render.toneMappingExposure ?? 1,
+			ambientOcclusion: A,
+			aoIntensity: t.render.aoIntensity,
+			aoPixelRatio: t.render.aoPixelRatio,
+			edgeDetection: false
+		});
+		return ge.setSize(Math.max(1, B), Math.max(1, K), a), ge;
+	}, ie = () => {
+		if (!(te || ne)) {
+			j?.dispose(), j = null, V();
+			return;
+		}
+		(!j || xe !== te) && (j?.dispose(), j = he(te), xe = te), j.setEdgeDetection(ne), V();
+	}, ve = () => {
+		j?.dispose(), j = null, ie();
+	}, An = (A) => {
+		te = A, ie();
+	};
+	ie();
+	let ft = (A) => {
+		A.ambientIntensity !== void 0 && (p.ambient.intensity = A.ambientIntensity), A.hemisphereIntensity !== void 0 && !p.hemisphere && A.hemisphereIntensity > 0 && (p.hemisphere = new z.HemisphereLight(A.hemisphereSkyColor ?? t.lighting.hemisphereSkyColor, A.hemisphereGroundColor ?? t.lighting.hemisphereGroundColor, A.hemisphereIntensity), p.hemisphere.position.copy(t.environment.sceneUp ?? de), o.add(p.hemisphere)), p.hemisphere && (A.hemisphereIntensity !== void 0 && (p.hemisphere.intensity = A.hemisphereIntensity), A.hemisphereSkyColor !== void 0 && p.hemisphere.color.set(A.hemisphereSkyColor), A.hemisphereGroundColor !== void 0 && p.hemisphere.groundColor.set(A.hemisphereGroundColor)), V();
+	}, pt = (A) => {
+		t.environment.environmentIntensity = A, o.environmentIntensity = A, V();
+	}, Sn = (A) => {
+		t.render.toneMappingExposure = A, l.toneMappingExposure = A, j && ve();
+	}, Dn = (A) => {
+		t.render.aoIntensity = A, j && ve();
+	}, Ln = (A) => {
+		let B = at[A];
+		Et = A, l.toneMapping = B.toneMapping, l.toneMappingExposure = B.toneMappingExposure, t.render.toneMapping = B.toneMapping, t.render.toneMappingExposure = B.toneMappingExposure, ft({
+			hemisphereIntensity: B.hemisphereIntensity,
+			ambientIntensity: B.ambientIntensity
+		}), pt(B.environmentIntensity), te = B.ambientOcclusion, j ? ve() : ie(), o.traverse((K) => {
+			if (K.userData.source !== "compute") return;
+			let ge = K, Un = Array.isArray(ge.material) ? ge.material : ge.material ? [ge.material] : [];
+			for (let yt of Un) "envMapIntensity" in yt && (yt.envMapIntensity = B.envMapIntensity);
+		}), V();
+	}, Et = t.look, On = () => io(Et), { animate: In, dispose: Pn, invalidate: ht } = uo(l, o, i, u, c, s, pe, a, t.events.onFrame, m, b, () => j, C, h, t.render.onDemand ?? true);
+	V = ht, In(), o.up.set(r.x, r.y, r.z), v(), g();
+	let gt = (A) => {
+		A.traverse((B) => {
+			let K = B;
+			!K.geometry && !K.material || (K.geometry?.dispose(), Array.isArray(K.material) ? K.material.forEach(Ne) : K.material && Ne(K.material));
+		});
+	}, Fn = (A) => {
+		A.userData.source = "user", o.add(A);
+	}, Bn = (A) => {
+		A.removeFromParent(), gt(A);
+	}, kn = () => {
+		o.children.filter((B) => B.userData.source === "user").forEach((B) => {
+			B.removeFromParent(), gt(B);
+		});
+	};
+	return {
+		scene: o,
+		camera: i,
+		controls: s,
+		renderer: l,
+		cameraController: c,
+		grid: m,
+		gizmo: b,
+		measureTool: M,
+		applyEdges: q,
+		clearEdges: fe,
+		invalidate: ht,
+		setAmbientOcclusion: An,
+		setLook: Ln,
+		setFillLights: ft,
+		setEnvironmentIntensity: pt,
+		setToneMappingExposure: Sn,
+		setAoIntensity: Dn,
+		getMaterialAppearance: On,
+		updateShadowBounds: v,
+		updateGridScale: g,
+		dispose: () => {
+			d || (d = true, Pn(), L.dispose(), (b || M) && (e.removeEventListener("mousedown", F, { capture: true }), e.removeEventListener("click", D, { capture: true })), M && e.removeEventListener("mousemove", G), M?.dispose(), C?.dispose(), b?.dispose(), m?.dispose(), j?.dispose(), c.dispose(), s.dispose(), l.dispose(), l.forceContextLoss(), o.traverse((A) => {
+				let B = A;
+				!B.geometry && !B.material || (B.geometry?.dispose(), Array.isArray(B.material) ? B.material.forEach(Ne) : B.material && Ne(B.material));
+			}), o.environment?.dispose(), o.background instanceof z.Texture && o.background.dispose());
+		},
+		fitToView: L.fitToView,
+		clearSelection: L.clearSelection,
+		addUserGeometry: Fn,
+		removeUserGeometry: Bn,
+		clearUserGeometry: kn
+	};
+};
+function so(e) {
+	let n = e.sceneScale || "m", r = {
+		mm: {
+			cameraDistance: 20,
+			near: .1,
+			far: 2e3,
+			floorSize: 100,
+			lightDistance: 10,
+			lightHeight: 20,
+			minDistance: .1,
+			shadowSize: 100,
+			scaleFactor: 1e3
+		},
+		cm: {
+			cameraDistance: 20,
+			near: .1,
+			far: 2e3,
+			floorSize: 100,
+			lightDistance: 25,
+			lightHeight: 50,
+			minDistance: .1,
+			shadowSize: 100,
+			scaleFactor: 100
+		},
+		m: {
+			cameraDistance: 10,
+			near: .01,
+			far: 2e3,
+			floorSize: 50,
+			lightDistance: 25,
+			lightHeight: 50,
+			minDistance: .001,
+			shadowSize: 100,
+			scaleFactor: 1
+		},
+		inches: {
+			cameraDistance: 15,
+			near: .1,
+			far: 2e3,
+			floorSize: 80,
+			lightDistance: 20,
+			lightHeight: 40,
+			minDistance: .1,
+			shadowSize: 80,
+			scaleFactor: 39.37
+		},
+		feet: {
+			cameraDistance: 8,
+			near: .1,
+			far: 2e3,
+			floorSize: 40,
+			lightDistance: 15,
+			lightHeight: 30,
+			minDistance: .1,
+			shadowSize: 60,
+			scaleFactor: 3.28084
+		}
+	}[n], a = e.look ?? ao, o = at[a];
+	return {
+		sceneScale: n,
+		look: a,
+		camera: {
+			position: e.camera?.position || Oe(e.environment?.sceneUp ?? de, r.cameraDistance * Math.sqrt(3)),
+			fov: e.camera?.fov || 20,
+			near: e.camera?.near || r.near,
+			far: e.camera?.far || r.far,
+			target: e.camera?.target || new z.Vector3(0, 0, 0),
+			dynamicNear: e.camera?.dynamicNear ?? true
+		},
+		lighting: {
+			enableSunlight: e.lighting?.enableSunlight ?? true,
+			sunlightIntensity: e.lighting?.sunlightIntensity ?? 1,
+			sunlightPosition: e.lighting?.sunlightPosition || Ct(e.environment?.sceneUp ?? de, r.lightDistance, r.lightHeight),
+			ambientLightColor: e.lighting?.ambientLightColor || new z.Color(4210752),
+			ambientLightIntensity: e.lighting?.ambientLightIntensity ?? o.ambientIntensity,
+			sunlightColor: e.lighting?.sunlightColor || 16777215,
+			enableHemisphereLight: e.lighting?.enableHemisphereLight ?? o.hemisphereIntensity > 0,
+			hemisphereSkyColor: e.lighting?.hemisphereSkyColor ?? 14673663,
+			hemisphereGroundColor: e.lighting?.hemisphereGroundColor ?? 7036754,
+			hemisphereIntensity: e.lighting?.hemisphereIntensity ?? o.hemisphereIntensity
+		},
+		environment: {
+			hdrPath: e.environment?.hdrPath || "/baseHDR.hdr",
+			backgroundColor: e.environment?.backgroundColor || new z.Color(15790320),
+			enableEnvironmentLighting: e.environment?.enableEnvironmentLighting ?? true,
+			sceneUp: e.environment?.sceneUp || de,
+			showEnvironment: e.environment?.showEnvironment ?? false,
+			environmentIntensity: e.environment?.environmentIntensity ?? o.environmentIntensity
+		},
+		floor: {
+			enabled: e.floor?.enabled ?? false,
+			size: e.floor?.size || r.floorSize,
+			color: e.floor?.color || new z.Color(8421504),
+			roughness: e.floor?.roughness ?? .7,
+			metalness: e.floor?.metalness ?? 0,
+			receiveShadow: e.floor?.receiveShadow ?? true
+		},
+		render: {
+			enableShadows: e.render?.enableShadows ?? true,
+			shadowMapSize: e.render?.shadowMapSize || 2048,
+			antialias: e.render?.antialias ?? true,
+			pixelRatio: e.render?.pixelRatio || Math.min(window.devicePixelRatio, 2),
+			toneMapping: e.render?.toneMapping ?? o.toneMapping,
+			toneMappingExposure: e.render?.toneMappingExposure ?? o.toneMappingExposure,
+			preserveDrawingBuffer: e.render?.preserveDrawingBuffer ?? false,
+			ambientOcclusion: e.render?.ambientOcclusion ?? o.ambientOcclusion,
+			aoIntensity: e.render?.aoIntensity ?? 1,
+			aoPixelRatio: e.render?.aoPixelRatio ?? 1,
+			onDemand: e.render?.onDemand ?? true
+		},
+		controls: {
+			enableDamping: e.controls?.enableDamping ?? false,
+			dampingFactor: e.controls?.dampingFactor || .05,
+			autoRotate: e.controls?.autoRotate ?? false,
+			autoRotateSpeed: e.controls?.autoRotateSpeed || .5,
+			enableZoom: e.controls?.enableZoom ?? true,
+			enablePan: e.controls?.enablePan ?? true,
+			minDistance: e.controls?.minDistance || r.minDistance,
+			maxDistance: e.controls?.maxDistance || Infinity
+		},
+		grid: {
+			enabled: e.grid?.enabled ?? false,
+			cellSize: e.grid?.cellSize ?? 1,
+			majorEvery: e.grid?.majorEvery ?? 10,
+			cellColor: e.grid?.cellColor ?? 8947848,
+			majorColor: e.grid?.majorColor ?? 4473924,
+			fadeDistance: e.grid?.fadeDistance ?? 100,
+			plane: e.grid?.plane ?? Xe(e.environment?.sceneUp ?? de)
+		},
+		gizmo: { enabled: e.gizmo?.enabled ?? false },
+		edges: {
+			enabled: e.edges?.enabled ?? false,
+			color: e.edges?.color,
+			darken: e.edges?.darken,
+			width: e.edges?.width ?? 1.5,
+			thresholdAngle: e.edges?.thresholdAngle ?? 44,
+			distanceFade: e.edges?.distanceFade ?? true
+		},
+		measure: {
+			enabled: e.measure?.enabled ?? false,
+			snapPixels: e.measure?.snapPixels,
+			color: e.measure?.color,
+			labelClassName: e.measure?.labelClassName,
+			displayUnit: e.measure?.displayUnit,
+			format: e.measure?.format
+		},
+		events: {
+			onBackgroundClicked: e.events?.onBackgroundClicked,
+			onObjectSelected: e.events?.onObjectSelected,
+			onMeshMetadataClicked: e.events?.onMeshMetadataClicked,
+			onMeshDoubleClicked: e.events?.onMeshDoubleClicked,
+			selectionColor: e.events?.selectionColor || "#ff0000",
+			enableEventHandlers: e.events?.enableEventHandlers ?? true,
+			enableKeyboardControls: e.events?.enableKeyboardControls ?? true,
+			enableClickToFocus: e.events?.enableClickToFocus ?? true,
+			enableDoubleClickZoom: e.events?.enableDoubleClickZoom ?? true,
+			onReady: e.events?.onReady,
+			onFrame: e.events?.onFrame
+		}
+	};
+}
+function Ne(e) {
+	for (let n of Object.values(e)) n instanceof z.Texture && n.dispose();
+	e.dispose();
+}
+function lo(e, n) {
+	if (n.isEmpty()) return;
+	let t = n.getCenter(new z.Vector3()), r = n.getSize(new z.Vector3()).length() * .5 * 1.2, a = e.shadow.camera;
+	a.left = -r, a.right = r, a.top = r, a.bottom = -r, e.target.position.copy(t), e.target.updateMatrixWorld();
+	let o = e.position.distanceTo(t);
+	a.near = Math.max(r * .01, o - r), a.far = o + r, a.updateProjectionMatrix();
+}
+function co(e) {
+	let n = new z.Scene();
+	return n.background = (typeof e.environment.backgroundColor == "string" ? new z.Color(e.environment.backgroundColor) : e.environment.backgroundColor) || null, n;
+}
+function uo(e, n, t, r, a, o, i, l, s, c, u, d, p, T, v = true) {
+	let R = null, m = performance.now(), g = true, b = 0, x = 500, H = new z.Matrix4(), E = new z.Matrix4(), f = null, h = () => {
+		g = true;
+	}, y = (O) => {
+		O.updateMatrixWorld();
+		let F = f !== O || !H.equals(O.matrixWorld) || !E.equals(O.projectionMatrix);
+		return F && (f = O, H.copy(O.matrixWorld), E.copy(O.projectionMatrix)), F;
+	}, C = e.domElement, M = [
+		"pointerdown",
+		"pointerup",
+		"wheel"
+	];
+	if (v) for (let O of M) C.addEventListener(O, h, { passive: true });
+	let L = () => {
+		let { width: O, height: F } = i();
+		if (O === 0 || F === 0) return;
+		let S = Math.floor(O * l), D = Math.floor(F * l);
+		(e.domElement.width !== S || e.domElement.height !== D) && (e.setPixelRatio(l), e.setSize(O, F, false), t.aspect = O / F, t.updateProjectionMatrix(), a.updateAspect(O, F), d?.()?.setSize(O, F, l), p?.setSize(O, F), h());
+	}, I = function() {
+		R = requestAnimationFrame(I);
+		let O = performance.now(), F = (O - m) / 1e3;
+		m = O, L(), (o.enableDamping || o.autoRotate) && o.update(), c && c.update(r().position), u && u.update(F), T && T.update(), s?.(F);
+		let S = r();
+		if (v) {
+			if (!(g || y(S) || O - b >= x)) return;
+			g = false, b = O;
+		}
+		let D = d?.();
+		D ? (D.setCamera(S), D.render(F)) : e.render(n, S), p && p.render(n, S), u && u.render(e);
+	};
+	return {
+		animate: I,
+		dispose: () => {
+			if (R !== null && (cancelAnimationFrame(R), R = null), v) for (let O of M) C.removeEventListener(O, h);
+		},
+		invalidate: h
+	};
+}
+function mo(e, n, t, r) {
+	t.environment.enableEnvironmentLighting ? new HDRLoader().load(t.environment.hdrPath || "/baseHDR.hdr", function(a) {
+		if (r()) {
+			a.dispose();
+			return;
+		}
+		if (!a?.image) {
+			m().warn("HDR loaded without image data; skipping environment map."), a?.dispose(), t.events.onReady?.();
+			return;
+		}
+		a.mapping = z.EquirectangularReflectionMapping;
+		let o = new z.PMREMGenerator(n);
+		o.compileEquirectangularShader();
+		let i = o.fromEquirectangular(a).texture;
+		o.dispose(), e.environment = i, e.environmentIntensity = t.environment.environmentIntensity ?? 1;
+		let l = At(t.environment.sceneUp ?? de);
+		e.environmentRotation.copy(l), t.environment.showEnvironment ? (e.background = a, e.backgroundRotation.copy(l)) : a.dispose(), t.events.onReady?.();
+	}, void 0, function(a) {
+		r() || (m().warn("HDR texture could not be loaded, falling back to basic lighting:", a), t.events.onReady?.());
+	}) : t.events.onReady?.();
+}
+function fo(e, n) {
+	let t = new z.AmbientLight(n.lighting.ambientLightColor, n.lighting.ambientLightIntensity);
+	e.add(t);
+	let r = null;
+	if (n.lighting.enableHemisphereLight) {
+		r = new z.HemisphereLight(n.lighting.hemisphereSkyColor, n.lighting.hemisphereGroundColor, n.lighting.hemisphereIntensity);
+		let i = n.environment.sceneUp ?? de;
+		r.position.copy(i), e.add(r);
+	}
+	if (!n.lighting.enableSunlight) return {
+		ambient: t,
+		hemisphere: r,
+		sun: null
+	};
+	let a = new z.DirectionalLight(n.lighting.sunlightColor ?? 16777215, n.lighting.sunlightIntensity), o = n.lighting.sunlightPosition;
+	return o && a.position.set(o.x, o.y, o.z), n.render.enableShadows ? (a.castShadow = true, a.shadow.mapSize.width = n.render.shadowMapSize || 2048, a.shadow.mapSize.height = n.render.shadowMapSize || 2048, a.shadow.bias = -1e-4, a.shadow.normalBias = .02, a.shadow.radius = 4, e.add(a), e.add(a.target), {
+		ambient: t,
+		hemisphere: r,
+		sun: a
+	}) : (e.add(a), {
+		ambient: t,
+		hemisphere: r,
+		sun: null
+	});
+}
+function po(e, n) {
+	let t = n.floor.size, r = new z.PlaneGeometry(t, t), a = typeof n.floor.color == "string" ? new z.Color(n.floor.color) : n.floor.color, o = new z.MeshStandardMaterial({
+		color: a,
+		roughness: n.floor.roughness,
+		metalness: n.floor.metalness,
+		side: z.DoubleSide
+	}), i = new z.Mesh(r, o);
+	i.userData.id = "floor", i.name = "floor";
+	let l = (n.environment?.sceneUp || de).clone().normalize();
+	i.quaternion.setFromUnitVectors(new z.Vector3(0, 0, 1), l), i.position.set(0, 0, 0), n.floor.receiveShadow && n.render.enableShadows && (i.receiveShadow = true), e.add(i);
+}
+function Eo(e, n) {
+	let t = n.parentElement, r = t ? t.clientWidth : window.innerWidth, a = t ? t.clientHeight : window.innerHeight, o = new z.PerspectiveCamera(e.camera.fov, r / a, e.camera.near, e.camera.far), i = e.camera.position;
+	return i && o.position.set(i.x, i.y, i.z), o;
+}
+function ho(e, n, t) {
+	let r = new z.WebGLRenderer({
+		antialias: n.render.antialias,
+		canvas: e,
+		alpha: true,
+		powerPreference: "high-performance",
+		preserveDrawingBuffer: n.render.preserveDrawingBuffer,
+		logarithmicDepthBuffer: false
+	}), a = e.parentElement, o = a ? a.clientWidth : window.innerWidth, i = a ? a.clientHeight : window.innerHeight;
+	return a && (e.style.width = "100%", e.style.height = "100%", e.style.display = "block"), r.setSize(o, i, false), r.setPixelRatio(t), n.render.enableShadows && (r.shadowMap.enabled = true, r.shadowMap.type = z.VSMShadowMap), r.toneMapping = n.render.toneMapping, r.toneMappingExposure = n.render.toneMappingExposure ?? 1, r.outputColorSpace = z.SRGBColorSpace, r.sortObjects = true, r;
+}
+function go(e, n, t, r) {
+	let a = /* @__PURE__ */ new Set(), o = /* @__PURE__ */ new Map(), i = new z.Raycaster(), l = new z.Vector2(), s = new z.Vector2(), c = () => t.getActiveCamera(), u = (E) => {
+		let f = E;
+		for (; f;) {
+			if (!f.visible) return false;
+			f = f.parent;
+		}
+		return true;
+	}, d = () => {
+		let E = ce(n);
+		if (E.isEmpty()) {
+			m().warn("No objects to fit to view");
+			return;
+		}
+		t.frameBounds(E, false);
+	}, p = typeof r.events.selectionColor == "string" ? new z.Color(r.events.selectionColor) : r.events.selectionColor instanceof z.Color ? r.events.selectionColor : new z.Color("#ff0000"), T = () => {
+		a.forEach((E) => {
+			let f = E;
+			if (o.has(E)) {
+				let h = o.get(E), y = f.material;
+				y instanceof z.Material ? y.dispose() : Array.isArray(y) && y.forEach((M) => M.dispose()), f.material = h, o.delete(E);
+				let C = E;
+				for (; C.parent;) C = C.parent;
+				C !== n && (h instanceof z.Material ? h.dispose() : h.forEach((M) => M.dispose()));
+			}
+		}), a.clear();
+	}, v = (E) => {
+		let f = E;
+		if (!(f.material instanceof z.Material)) return false;
+		o.set(E, f.material);
+		let h = f.material.clone();
+		return E instanceof z.Mesh && "emissive" in h ? h.emissive = p.clone() : "color" in h && (h.color = p.clone()), f.material = h, true;
+	}, R = () => {
+		let E = ce(n), f = E.isEmpty() ? 1 : E.getSize(new z.Vector3()).length();
+		i.params.Points.threshold = f * .01;
+	}, m$1 = (E) => {
+		s.set(E.clientX, E.clientY);
+	}, g = (E) => {
+		let f = new z.Vector2(E.clientX, E.clientY);
+		if (s.distanceTo(f) > 5) return;
+		let h = e.getBoundingClientRect();
+		l.x = (E.clientX - h.left) / h.width * 2 - 1, l.y = -((E.clientY - h.top) / h.height) * 2 + 1, R(), i.setFromCamera(l, c());
+		let y = i.intersectObjects(n.children, true).filter((C) => u(C.object));
+		if (y.length > 0) {
+			let C = y[0].object;
+			a.has(C) || (T(), a.add(C), v(C), r.events?.onObjectSelected?.(C), C instanceof z.Mesh && Object.keys(C.userData).length > 0 && r.events?.onMeshMetadataClicked?.(C.userData));
+		} else T(), r.events?.onBackgroundClicked?.({
+			x: l.x,
+			y: l.y
+		});
+	}, b = (E) => {
+		let f = e.getBoundingClientRect();
+		l.x = (E.clientX - f.left) / f.width * 2 - 1, l.y = -((E.clientY - f.top) / f.height) * 2 + 1, R(), i.setFromCamera(l, c());
+		let h = i.intersectObjects(n.children, true).filter((M) => u(M.object));
+		if (h.length === 0) return;
+		let y = h[0].object;
+		if (r.events?.onMeshDoubleClicked?.(y), !r.events?.enableDoubleClickZoom) return;
+		let C = new z.Box3().setFromObject(y);
+		C.isEmpty() || t.frameBounds(C, true);
+	}, x = (E) => {
+		if (r.events?.enableKeyboardControls) switch (E.key.toLowerCase()) {
+			case "f":
+				E.preventDefault(), d();
+				break;
+			case "escape":
+				E.preventDefault(), T();
+				break;
+			case " ":
+				E.preventDefault(), d();
+				break;
+		}
+	};
+	return r.events?.enableClickToFocus && (e.addEventListener("mousedown", m$1), e.addEventListener("click", g), e.addEventListener("dblclick", b)), r.events?.enableKeyboardControls && (e.setAttribute("tabindex", "0"), e.addEventListener("keydown", x)), {
+		dispose: () => {
+			e.removeEventListener("mousedown", m$1), e.removeEventListener("click", g), e.removeEventListener("dblclick", b), e.removeEventListener("keydown", x), T();
+		},
+		fitToView: d,
+		clearSelection: T
+	};
+}
+function yo(e, n, t) {
+	let r = new OrbitControls(e, n), a = t.camera.target;
+	return a && r.target.set(a.x, a.y, a.z), r.enableDamping = t.controls.enableDamping || false, r.dampingFactor = t.controls.dampingFactor || .05, r.autoRotate = t.controls.autoRotate || false, r.autoRotateSpeed = t.controls.autoRotateSpeed || .5, r.enableZoom = t.controls.enableZoom ?? true, r.enablePan = t.controls.enablePan ?? true, r.minDistance = t.controls.minDistance || .001, r.maxDistance = t.controls.maxDistance || Infinity, r.screenSpacePanning = false, r.maxPolarAngle = Math.PI, r.update(), r;
+}
+var Oi = [
+	"technical",
+	"studio",
+	"showcase"
+];
+function je(e, n, t, r = true) {
+	return {
+		x: e,
+		y: n,
+		z: t
+	};
+}
+var xo = "#ffffff";
+var on = 12;
+var vo = 4e-4;
+var wo = 12;
+var Mo = .05;
+function an(e, n = {}) {
+	if (!e || e.length === 0) return [];
+	let { rhino: t, applyTransforms: r = true } = n, a = [];
+	for (let o of e) switch (o.kind) {
+		case "curve": {
+			let i = Co(o, t, r);
+			i && a.push(i);
+			break;
+		}
+		case "point": {
+			let i = Ao(o, r);
+			i && a.push(i);
+			break;
+		}
+		default: {
+			let l = o;
+			m().warn(`Skipping unknown display item kind: ${String(l.kind)}`);
+			break;
+		}
+	}
+	return a;
+}
+var Ho = 2;
+function Co(e, n, t) {
+	if (!n) return m().warn("No rhino3dm instance provided; skipping curve display item."), null;
+	let r = So(e.json, n);
+	if (!r) return null;
+	let a;
+	try {
+		a = Do(r, t);
+	} catch (d) {
+		return m().warn("Failed to tessellate curve display item; skipping.", d), null;
+	} finally {
+		Se(r);
+	}
+	if (a.length < 2) return null;
+	let o = [];
+	for (let d of a) o.push(d.x, d.y, d.z);
+	let i = new LineGeometry();
+	i.setPositions(o);
+	let l = sn(e.color, e.opacity), s = new LineMaterial({ color: l.color }), c = s;
+	c.linewidth = e.width ?? Ho, c.transparent = l.transparent, c.opacity = l.opacity;
+	let u = new Line2(i, s);
+	return u.computeLineDistances(), u.name = e.name, u.userData = {
+		source: "compute",
+		id: e.id,
+		layer: e.layer,
+		kind: "curve",
+		metadata: e.metadata
+	}, u;
+}
+function Ao(e, n) {
+	let { position: t } = e;
+	if (!t || typeof t.X != "number" || !Number.isFinite(t.X) || typeof t.Y != "number" || !Number.isFinite(t.Y) || typeof t.Z != "number" || !Number.isFinite(t.Z)) return m().warn(`Skipping point display item with missing or non-finite position (id: ${String(e.id)}).`), null;
+	let { x: r, y: a, z: o } = je(t.X, t.Y, t.Z, n), i = new z.BufferGeometry();
+	i.setAttribute("position", new z.Float32BufferAttribute([
+		r,
+		a,
+		o
+	], 3));
+	let l = new z.PointsMaterial({
+		...sn(e.color, e.opacity),
+		size: 6,
+		sizeAttenuation: false
+	}), s = new z.Points(i, l);
+	return s.name = e.name, s.userData = {
+		source: "compute",
+		id: e.id,
+		layer: e.layer,
+		kind: "point",
+		metadata: e.metadata
+	}, s;
+}
+function Se(e) {
+	e?.delete?.();
+}
+function So(e, n) {
+	try {
+		let t = JSON.parse(e), r = n.CommonObject.decode(t);
+		return r && typeof r.pointAt == "function" ? r : (Se(r), m().warn("Decoded display-item JSON is not a curve; skipping."), null);
+	} catch (t) {
+		return m().warn("Failed to decode curve display item JSON:", t), null;
+	}
+}
+function Do(e, n) {
+	return Lo(e, n) || Oo(e, n);
+}
+function Lo(e, n) {
+	if (!e.isPolyline()) return null;
+	let t = e.tryGetPolyline(), r = Array.isArray(t) ? t[1] : t;
+	if (!r || typeof r.count != "number" || r.count < 2) return Se(r), null;
+	let a = [];
+	for (let o = 0; o < r.count; o++) {
+		let i = r.get(o), { x: l, y: s, z: c } = je(i[0], i[1], i[2], n);
+		a.push(new z.Vector3(l, s, c));
+	}
+	return Se(r), a;
+}
+function Oo(e, n) {
+	let t = e.domain, r = t[0], o = t[1] - r, i = (d) => {
+		let p = e.pointAt(d), { x: T, y: v, z: R } = je(p[0], p[1], p[2], n);
+		return new z.Vector3(T, v, R);
+	}, l = Io(e), s = r, c = i(r), u = [c];
+	for (let d = 0; d < on; d++) {
+		let p = r + o * (d + 1) / on, T = i(p);
+		it(s, c, p, T, i, l, wo, u), u.push(T), s = p, c = T;
+	}
+	return u;
+}
+function it(e, n, t, r, a, o, i, l) {
+	if (i <= 0) return;
+	let s = (e + t) / 2, c = a(s), u = Fo(c, n, r), d = Po(n, c, r);
+	u <= o && d <= Mo || (it(e, n, s, c, a, o, i - 1, l), l.push(c), it(s, c, t, r, a, o, i - 1, l));
+}
+function Io(e) {
+	let n = e.getBoundingBox(), t = n.min, r = n.max;
+	Se(n);
+	let a = Math.hypot(r[0] - t[0], r[1] - t[1], r[2] - t[2]);
+	return Math.max(a * vo, 1e-6);
+}
+function Po(e, n, t) {
+	let r = n.x - e.x, a = n.y - e.y, o = n.z - e.z, i = t.x - n.x, l = t.y - n.y, s = t.z - n.z, c = Math.sqrt(r * r + a * a + o * o), u = Math.sqrt(i * i + l * l + s * s);
+	if (c === 0 || u === 0) return 0;
+	let d = r * i + a * l + o * s, p = Math.max(-1, Math.min(1, d / (c * u)));
+	return Math.acos(p);
+}
+function Fo(e, n, t) {
+	let r = t.x - n.x, a = t.y - n.y, o = t.z - n.z, i = r * r + a * a + o * o;
+	if (i === 0) return e.distanceTo(n);
+	let l = e.x - n.x, s = e.y - n.y, c = e.z - n.z, u = Math.max(0, Math.min(1, (l * r + s * a + c * o) / i)), d = l - r * u, p = s - a * u, T = c - o * u;
+	return Math.sqrt(d * d + p * p + T * T);
+}
+function sn(e, n) {
+	let t = n ?? 1;
+	return {
+		color: new z.Color(e ?? xo),
+		transparent: t < 1,
+		opacity: t
+	};
+}
+var ln = 1096174675;
+var ko = 1515605075;
+var cn = 3;
+var un = 1;
+var lt = 1;
+var Uo = 2;
+var _o = 4;
+var Vo = 8;
+var zo = 16;
+var ji = 0;
+var Go = 1;
+var dn = 12;
+var mn = 56;
+var No = new Uint16Array(new Uint8Array([1, 0]).buffer)[0] === 1;
+function ct(e) {
+	let n = ut(e), t;
+	n.isFloat32 ? t = n.vertexData : n.deltaEncoded ? t = Jo(n.vertexData) : t = n.vertexData;
+	let r = n.indexData;
+	return n.deltaEncoded && (r = r instanceof Uint16Array ? Qo(r) : ea(r)), Zo(r, n.vertexCount), {
+		metadata: n.metadata,
+		flags: n.flags,
+		vertices: t,
+		indices: r,
+		origin: n.origin,
+		scale: n.scale,
+		uvs: n.uvs,
+		colors: n.colors
+	};
+}
+function ut(e) {
+	if (!No) throw new p("SLVA parsing requires a little-endian host: the zero-copy geometry readers view the wire bytes in host byte order.", l.ENVIRONMENT_ERROR);
+	let n = qo($o(e)), t = new DataView(n.buffer, n.byteOffset, n.byteLength);
+	if (n.byteLength < dn) throw X("Blob too small to contain SLVA header.", {
+		expectedBytes: dn,
+		availableBytes: n.byteLength
+	});
+	let r = 0, a = t.getUint32(r, true);
+	if (r += 4, a !== 1096174675) throw X(`Invalid SLVA magic: 0x${a.toString(16)}`, {
+		expectedMagic: `0x${ln.toString(16)}`,
+		actualMagic: `0x${a.toString(16)}`
+	});
+	let o = t.getUint32(r, true);
+	if (r += 4, o < 1 || o > 3) throw X(`Unsupported SLVA version: ${o}`, {
+		minSupportedVersion: 1,
+		maxSupportedVersion: 3,
+		actualVersion: o
+	});
+	let i = t.getUint32(r, true);
+	if (r += 4, r + i > n.byteLength) throw X("Insufficient data to read metadata JSON.", {
+		expectedBytes: i,
+		availableBytes: n.byteLength - r,
+		offset: r
+	});
+	let l$1 = n.subarray(r, r + i);
+	r += i;
+	let s;
+	try {
+		s = JSON.parse(Yo(l$1));
+	} catch (F) {
+		throw X(`Failed to parse metadata JSON: ${F instanceof Error ? F.message : String(F)}`, { metadataLen: i });
+	}
+	if (r + mn > n.byteLength) throw X("Insufficient data to read geometry header.", {
+		expectedBytes: mn,
+		availableBytes: n.byteLength - r,
+		offset: r
+	});
+	let c = t.getUint32(r, true);
+	r += 4;
+	let u = t.getFloat64(r, true);
+	r += 8;
+	let d = t.getFloat64(r, true);
+	r += 8;
+	let p$1 = t.getFloat64(r, true);
+	r += 8;
+	let T = t.getFloat64(r, true);
+	r += 8;
+	let v = t.getFloat64(r, true);
+	r += 8;
+	let R = t.getFloat64(r, true);
+	r += 8;
+	let m = t.getUint32(r, true);
+	r += 4;
+	let g = (c & 1) !== 0, b = (c & 4) !== 0, x = m * 3, E = x * (g ? 4 : 2);
+	if (r + E > n.byteLength) throw X("Insufficient data to read vertices.", {
+		expectedBytes: E,
+		availableBytes: n.byteLength - r,
+		offset: r,
+		useFloat32: g,
+		vertexCount: m
+	});
+	let f = n.byteOffset + r, h;
+	if (g ? h = pn(n.buffer, f, x) : b ? h = st(n.buffer, f, x) : h = Xo(n.buffer, f, x), r += E, r + 4 > n.byteLength) throw X("Insufficient data to read index count.", {
+		expectedBytes: 4,
+		availableBytes: n.byteLength - r,
+		offset: r
+	});
+	let y = t.getUint32(r, true);
+	r += 4;
+	let C = (c & 2) !== 0, L = y * (C ? 2 : 4);
+	if (r + L > n.byteLength) throw X("Insufficient data to read indices.", {
+		expectedBytes: L,
+		availableBytes: n.byteLength - r,
+		offset: r,
+		indexCount: y,
+		useUint16Indices: C
+	});
+	let I = C ? st(n.buffer, n.byteOffset + r, y) : Ko(n.buffer, n.byteOffset + r, y);
+	r += L;
+	let k = null;
+	if ((c & 8) !== 0) {
+		let F = jo(n, t, r, m, b);
+		k = F.uvs, r = F.offset;
+	}
+	let O = null;
+	return c & 16 && (O = Wo(n, r, m, b)), {
+		metadata: s,
+		flags: c,
+		vertexData: h,
+		indexData: I,
+		isFloat32: g,
+		deltaEncoded: b,
+		vertexCount: m,
+		origin: [
+			u,
+			d,
+			p$1
+		],
+		scale: [
+			T,
+			v,
+			R
+		],
+		uvs: k,
+		colors: O
+	};
+}
+var fn = 36;
+function jo(e, n, t, r, a) {
+	if (t + fn > e.byteLength) throw X("Insufficient data to read UV chunk header.", {
+		expectedBytes: fn,
+		availableBytes: e.byteLength - t,
+		offset: t
+	});
+	let o = n.getUint32(t, true);
+	t += 4;
+	let i = n.getFloat64(t, true);
+	t += 8;
+	let l = n.getFloat64(t, true);
+	t += 8;
+	let s = n.getFloat64(t, true);
+	t += 8;
+	let c = n.getFloat64(t, true);
+	t += 8;
+	let u = r * 2, d = o === 1, p = u * (d ? 4 : 2);
+	if (t + p > e.byteLength) throw X("Insufficient data to read UV chunk.", {
+		expectedBytes: p,
+		availableBytes: e.byteLength - t,
+		offset: t,
+		uvFormat: o,
+		vertexCount: r
+	});
+	let T = e.byteOffset + t, v;
+	if (d) v = pn(e.buffer, T, u).slice();
+	else {
+		let R = st(e.buffer, T, u);
+		v = new Float32Array(u);
+		let m = 0, g = 0;
+		for (let b = 0; b < u; b += 2) a ? (m = m + le(R[b]) & 65535, g = g + le(R[b + 1]) & 65535) : (m = R[b], g = R[b + 1]), v[b] = i + m * s, v[b + 1] = l + g * c;
+	}
+	return {
+		uvs: v,
+		offset: t + p
+	};
+}
+function Wo(e, n, t, r) {
+	let a = t * 3;
+	if (n + a > e.byteLength) throw X("Insufficient data to read vertex-color chunk.", {
+		expectedBytes: a,
+		availableBytes: e.byteLength - n,
+		offset: n,
+		vertexCount: t
+	});
+	let o = e.subarray(n, n + a);
+	if (!r) return o.slice();
+	let i = new Uint8Array(a), l = 0, s = 0, c = 0;
+	for (let u = 0; u < a; u += 3) l = l + le(o[u]) & 255, s = s + le(o[u + 1]) & 255, c = c + le(o[u + 2]) & 255, i[u] = l, i[u + 1] = s, i[u + 2] = c;
+	return i;
+}
+function $o(e) {
+	return typeof e == "string" ? x(e) : e instanceof Uint8Array ? e : new Uint8Array(e);
+}
+function qo(e) {
+	if (e.byteLength < 8) return e;
+	let n = new DataView(e.buffer, e.byteOffset, e.byteLength);
+	if (n.getUint32(0, true) !== 1515605075) return e;
+	let t = n.getUint32(4, true), r = e.subarray(8), a = Math.max(r.byteLength * 1032 + 1024, 1 << 20);
+	if (t > a) throw X("SLVZ header declares an implausible uncompressed length", {
+		uncompressedLen: t,
+		deflatedBytes: r.byteLength,
+		maxPlausibleLen: a
+	});
+	let o;
+	try {
+		o = inflateSync(r, { out: new Uint8Array(t + 1) });
+	} catch (i) {
+		throw X(`Failed to inflate SLVZ blob: ${i instanceof Error ? i.message : String(i)}`, {
+			uncompressedLen: t,
+			deflatedBytes: r.byteLength
+		});
+	}
+	if (o.byteLength !== t) throw X("SLVZ payload inflated to a different size than the header declares.", {
+		declaredLen: t,
+		actualLen: o.byteLength,
+		deflatedBytes: r.byteLength
+	});
+	return o;
+}
+function Yo(e) {
+	if (typeof TextDecoder < "u") return new TextDecoder("utf-8").decode(e);
+	if (typeof globalThis.Buffer < "u") return globalThis.Buffer.from(e).toString("utf-8");
+	throw new p("No UTF-8 decoder available in this environment.", l.INVALID_STATE);
+}
+function Xo(e, n, t) {
+	if (t === 0) return /* @__PURE__ */ new Int16Array(0);
+	if (n % 2 === 0) return new Int16Array(e, n, t);
+	let r = new Uint8Array(t * 2);
+	return r.set(new Uint8Array(e, n, t * 2)), new Int16Array(r.buffer);
+}
+function pn(e, n, t) {
+	if (t === 0) return /* @__PURE__ */ new Float32Array(0);
+	if (n % 4 === 0) return new Float32Array(e, n, t);
+	let r = new Uint8Array(t * 4);
+	return r.set(new Uint8Array(e, n, t * 4)), new Float32Array(r.buffer);
+}
+function st(e, n, t) {
+	if (t === 0) return /* @__PURE__ */ new Uint16Array(0);
+	if (n % 2 === 0) return new Uint16Array(e, n, t);
+	let r = new Uint8Array(t * 2);
+	return r.set(new Uint8Array(e, n, t * 2)), new Uint16Array(r.buffer);
+}
+function Ko(e, n, t) {
+	if (t === 0) return /* @__PURE__ */ new Uint32Array(0);
+	if (n % 4 === 0) return new Uint32Array(e, n, t);
+	let r = new Uint8Array(t * 4);
+	return r.set(new Uint8Array(e, n, t * 4)), new Uint32Array(r.buffer);
+}
+function Zo(e, n) {
+	if (e.length !== 0 && !(e instanceof Uint16Array && n > 65535)) {
+		for (let t = 0; t < e.length; t++) if (e[t] >= n) throw X("Index out of range of vertexCount.", {
+			indexPosition: t,
+			indexValue: e[t],
+			vertexCount: n
+		});
+	}
+}
+function le(e) {
+	return e >>> 1 ^ -(e & 1);
+}
+function Jo(e) {
+	let n = new Int16Array(e.length), t = 0, r = 0, a = 0;
+	for (let o = 0; o < e.length; o += 3) t = t + le(e[o]) << 16 >> 16, r = r + le(e[o + 1]) << 16 >> 16, a = a + le(e[o + 2]) << 16 >> 16, n[o] = t, n[o + 1] = r, n[o + 2] = a;
+	return n;
+}
+function Qo(e) {
+	let n = new Uint16Array(e.length), t = 0;
+	for (let r = 0; r < e.length; r++) t = t + le(e[r]) & 65535, n[r] = t;
+	return n;
+}
+function ea(e) {
+	let n = new Uint32Array(e.length), t = 0;
+	for (let r = 0; r < e.length; r++) t = t + le(e[r]) >>> 0, n[r] = t;
+	return n;
+}
+function X(e, n) {
+	return new p(e, l.VALIDATION_ERROR, { context: n });
+}
+var En = 256 * 1024 * 1024;
+var We = 1024;
+var me = /* @__PURE__ */ new Map();
+var dt = 0;
+function hn(e, n) {
+	let t = 2166136261, r = (a) => {
+		t ^= a, t = Math.imul(t, 16777619);
+	};
+	for (let a = 0; a < n.length; a++) r(n.charCodeAt(a));
+	for (let a of e) {
+		if (!a) {
+			r(57005);
+			continue;
+		}
+		let o = a.byteLength;
+		if (r(o), (a.byteOffset & 3) === 0 && (o & 3) === 0) {
+			let i = new Uint32Array(a.buffer, a.byteOffset, o >> 2), l = Math.min(We, i.length);
+			for (let s = 0; s < l; s++) r(i[s]);
+			for (let s = Math.max(l, i.length - We); s < i.length; s++) r(i[s]);
+		} else {
+			let i = new Uint8Array(a.buffer, a.byteOffset, o), l = Math.min(We * 4, i.length);
+			for (let s = 0; s < l; s++) r(i[s]);
+			for (let s = Math.max(l, i.length - We * 4); s < i.length; s++) r(i[s]);
+		}
+	}
+	return `${(t >>> 0).toString(36)}:${e.length}`;
+}
+function ta(e) {
+	let n = e.index?.array.byteLength ?? 0;
+	for (let t of Object.values(e.attributes)) n += t.array.byteLength;
+	return n;
+}
+function $e(e) {
+	let n = me.get(e);
+	if (n) return me.delete(e), me.set(e, n), n.geometry;
+}
+function qe(e, n) {
+	let t = ta(n);
+	if (!(t > En || (n.userData[Ie] = true, me.get(e)))) for (me.set(e, {
+		geometry: n,
+		bytes: t
+	}), dt += t; dt > En && me.size > 1;) {
+		let a = me.keys().next().value, o = me.get(a);
+		me.delete(a), dt -= o.bytes, delete o.geometry.userData[Ie], o.geometry.dispose();
+	}
+}
+function na(e) {
+	let { isFloat32: n, deltaEncoded: t, origin: r, scale: a, uvs: o, colors: i, jobs: l } = e, s = (m) => m >>> 1 ^ -(m & 1), c;
+	if (n) c = e.vertexData;
+	else {
+		let m;
+		if (t) {
+			let h = e.vertexData;
+			m = new Int16Array(h.length);
+			let y = 0, C = 0, M = 0;
+			for (let L = 0; L < h.length; L += 3) y = y + s(h[L]) << 16 >> 16, C = C + s(h[L + 1]) << 16 >> 16, M = M + s(h[L + 2]) << 16 >> 16, m[L] = y, m[L + 1] = C, m[L + 2] = M;
+		} else m = e.vertexData;
+		c = new Float32Array(m.length);
+		let g = r[0], b = r[1], x = r[2], H = a[0], E = a[1], f = a[2];
+		for (let h = 0; h < m.length; h += 3) c[h] = g + (m[h] + 32767) * H, c[h + 1] = b + (m[h + 1] + 32767) * E, c[h + 2] = x + (m[h + 2] + 32767) * f;
+	}
+	let u;
+	if (t) {
+		let m = e.indexData;
+		if (m instanceof Uint16Array) {
+			let g = new Uint16Array(m.length), b = 0;
+			for (let x = 0; x < m.length; x++) b = b + s(m[x]) & 65535, g[x] = b;
+			u = g;
+		} else {
+			let g = new Uint32Array(m.length), b = 0;
+			for (let x = 0; x < m.length; x++) b = b + s(m[x]) >>> 0, g[x] = b;
+			u = g;
+		}
+	} else u = e.indexData;
+	let d = c.length / 3;
+	for (let m = 0; m < u.length; m++) if (u[m] >= d) throw new Error(`Index ${u[m]} out of range of vertexCount ${d}`);
+	let p = 1024, T = (m, g) => {
+		let b = 2166136261, x = (H) => {
+			b ^= H, b = Math.imul(b, 16777619);
+		};
+		for (let H = 0; H < g.length; H++) x(g.charCodeAt(H));
+		for (let H of m) {
+			if (!H) {
+				x(57005);
+				continue;
+			}
+			let E = H.byteLength;
+			if (x(E), (H.byteOffset & 3) === 0 && (E & 3) === 0) {
+				let f = new Uint32Array(H.buffer, H.byteOffset, E >> 2), h = Math.min(p, f.length);
+				for (let y = 0; y < h; y++) x(f[y]);
+				for (let y = Math.max(h, f.length - p); y < f.length; y++) x(f[y]);
+			} else {
+				let f = new Uint8Array(H.buffer, H.byteOffset, E), h = Math.min(p * 4, f.length);
+				for (let y = 0; y < h; y++) x(f[y]);
+				for (let y = Math.max(h, f.length - p * 4); y < f.length; y++) x(f[y]);
+			}
+		}
+		return `${(b >>> 0).toString(36)}:${m.length}`;
+	}, v = (m, g) => {
+		let b = [], x = m;
+		for (let H of g) {
+			x += `|${H.vertexStart},${H.vertexCount},${H.indexStart},${H.indexCount}`;
+			let E = H.vertexStart * 3, f = E + H.vertexCount * 3;
+			b.push(c.subarray(E, f)), b.push(u.subarray(H.indexStart, H.indexStart + H.indexCount)), b.push(o ? o.subarray(H.vertexStart * 2, (H.vertexStart + H.vertexCount) * 2) : null), b.push(i ? i.subarray(E, f) : null);
+		}
+		return T(b, x);
+	}, R = [];
+	for (let m of l) {
+		let g = 0, b = 0;
+		for (let M of m.windows) g += M.vertexCount, b += M.indexCount;
+		let x = new Float32Array(g * 3), H = new Uint32Array(b), E = o ? new Float32Array(g * 2) : null, f = i ? new Uint8Array(g * 3) : null, h = 0, y = 0;
+		for (let M of m.windows) {
+			let L = M.vertexStart * 3;
+			x.set(c.subarray(L, L + M.vertexCount * 3), h * 3), E && o && E.set(o.subarray(M.vertexStart * 2, (M.vertexStart + M.vertexCount) * 2), h * 2), f && i && f.set(i.subarray(L, L + M.vertexCount * 3), h * 3);
+			let I = M.vertexStart, k = M.vertexStart + M.vertexCount, O = h - M.vertexStart;
+			for (let F = 0; F < M.indexCount; F++) {
+				let S = u[M.indexStart + F];
+				if (S < I || S >= k) throw new Error(`Index ${S} outside vertex window [${I}, ${k})`);
+				H[y + F] = S + O;
+			}
+			h += M.vertexCount, y += M.indexCount;
+		}
+		let C = new Float32Array(g * 3);
+		for (let M = 0; M < H.length; M += 3) {
+			let L = H[M] * 3, I = H[M + 1] * 3, k = H[M + 2] * 3, O = x[k] - x[I], F = x[k + 1] - x[I + 1], S = x[k + 2] - x[I + 2], D = x[L] - x[I], G = x[L + 1] - x[I + 1], V = x[L + 2] - x[I + 2], q = F * V - S * G, Y = S * D - O * V, fe = O * G - F * D;
+			C[L] += q, C[L + 1] += Y, C[L + 2] += fe, C[I] += q, C[I + 1] += Y, C[I + 2] += fe, C[k] += q, C[k + 1] += Y, C[k + 2] += fe;
+		}
+		for (let M = 0; M < C.length; M += 3) {
+			let L = C[M], I = C[M + 1], k = C[M + 2], O = Math.sqrt(L * L + I * I + k * k) || 1;
+			C[M] = L / O, C[M + 1] = I / O, C[M + 2] = k / O;
+		}
+		R.push({
+			key: v(m.kind, m.windows),
+			positions: x,
+			normals: C,
+			indices: H,
+			uvs: E,
+			colors: f
+		});
+	}
+	return R;
+}
+function gn() {
+	return [
+		`const assemble = ${na.toString()};`,
+		"self.onmessage = (event) => {",
+		"  const { id, input } = event.data;",
+		"  try {",
+		"    const geometries = assemble(input);",
+		"    const transfer = [];",
+		"    for (const g of geometries) {",
+		"      transfer.push(g.positions.buffer, g.normals.buffer, g.indices.buffer);",
+		"      if (g.uvs) transfer.push(g.uvs.buffer);",
+		"      if (g.colors) transfer.push(g.colors.buffer);",
+		"    }",
+		"    self.postMessage({ id, geometries }, transfer);",
+		"  } catch (error) {",
+		"    self.postMessage({ id, error: String((error && error.message) || error) });",
+		"  }",
+		"};"
+	].join(`
+`);
+}
+async function ns(e, n) {
+	let { debug: t = false } = n ?? {}, r = t ? performance.now() : 0, a, o = performance.now();
+	try {
+		a = JSON.parse(e);
+	} catch (l) {
+		return m().error("Error parsing mesh batch envelope JSON:", l), [];
+	}
+	let i = performance.now() - o;
+	return await mt(a, n, {
+		parseTime: i,
+		perfStart: r
+	});
+}
+async function mt(e, n, t) {
+	let { mergeByMaterial: r = true, applyTransforms: a = true, debug: o = false, material: i } = n ?? {}, { parseTime: l = 0, perfStart: s = o ? performance.now() : 0 } = t ?? {};
+	if (!e.compressedData) return [];
+	let c = await xn(e.compressedData, {
+		mergeByMaterial: r,
+		debug: o,
+		material: i,
+		fallback: {
+			materials: e.materials,
+			groups: e.groups,
+			sourceComponentId: e.sourceComponentId
+		}
+	});
+	if (c) return c;
+	let u = performance.now();
+	return yn(ct(e.compressedData), {
+		mergeByMaterial: r,
+		applyTransforms: a,
+		debug: o,
+		material: i,
+		parseTime: l,
+		decodeTime: performance.now() - u,
+		perfStart: s,
+		blobBytes: o ? Ea(e.compressedData) : 0,
+		fallback: {
+			materials: e.materials,
+			groups: e.groups,
+			sourceComponentId: e.sourceComponentId
+		}
+	});
+}
+async function rs(e, n) {
+	let { mergeByMaterial: t = true, applyTransforms: r = true, debug: a = false, material: o } = n ?? {}, i = a ? performance.now() : 0, l = await xn(e, {
+		mergeByMaterial: t,
+		debug: a,
+		material: o
+	});
+	if (l) return l;
+	let s = performance.now(), c = ct(e), u = performance.now() - s, d = e.byteLength;
+	return yn(c, {
+		mergeByMaterial: t,
+		applyTransforms: r,
+		debug: a,
+		material: o,
+		parseTime: 0,
+		decodeTime: u,
+		perfStart: i,
+		blobBytes: d
+	});
+}
+function yn(e, n) {
+	let { mergeByMaterial: t, applyTransforms: r, debug: a, material: o, parseTime: i, decodeTime: l, perfStart: s, blobBytes: c, fallback: u } = n, d = e.metadata.materials ?? u?.materials ?? [], p = e.metadata.groups ?? u?.groups ?? [], T = u?.sourceComponentId ?? e.metadata.sourceComponentId, v = (e.flags & 1) !== 0;
+	bn(p, d.length, e.vertices.length / 3, e.indices.length);
+	let R = v ? oa(e.vertices) : ra(e.vertices, e.origin, e.scale);
+	if (a) {
+		let H = e.vertices.byteLength + e.indices.byteLength;
+		m().debug("Mesh Batch Stats:"), m().debug(`  Materials: ${d.length} | Groups: ${p.length}`), m().debug(`  Vertices: ${e.vertices.length / 3} | Indices: ${e.indices.length}`), m().debug(`  Format: ${v ? "float32" : "int16 quantized"}`), m().debug(`  Blob: ${(c / 1024 / 1024).toFixed(2)} MB | Geometry on wire: ${(H / 1024 / 1024).toFixed(2)} MB`);
+	}
+	let m$2 = performance.now(), g = d.map((H) => vn(H, {
+		vertexColors: e.colors != null,
+		appearance: o
+	})), b = [];
+	for (let H of p) if (t && H.meshes.length > 1) {
+		let E = fa(H, R, e.indices, g, e.uvs, e.colors);
+		E.userData.sourceComponentId = T ?? null, b.push(E);
+	} else {
+		let E = pa(H, R, e.indices, g, e.uvs, e.colors);
+		for (let f of E) f.userData.sourceComponentId = T ?? null;
+		b.push(...E);
+	}
+	let x = performance.now() - m$2;
+	if (a) {
+		let H = performance.now() - s;
+		m().debug("Performance:"), i > 0 && m().debug(`  Parse JSON: ${i.toFixed(2)}ms`), m().debug(`  Decode binary: ${l.toFixed(2)}ms`), m().debug(`  Create Meshes: ${x.toFixed(2)}ms`), m().debug(`  Total: ${H.toFixed(2)}ms`);
+	}
+	return Promise.resolve(b);
+}
+function De(e, n) {
+	return new p(e, l.VALIDATION_ERROR, { context: n });
+}
+function bn(e, n, t, r) {
+	for (let a of e) {
+		if (!Number.isInteger(a.materialId) || a.materialId < 0 || a.materialId >= n) throw De("Group materialId out of range of the materials array.", {
+			materialId: a.materialId,
+			materialCount: n
+		});
+		for (let o of a.meshes) {
+			let i = {
+				vertexStart: o.vertexStart,
+				vertexCount: o.vertexCount,
+				indexStart: o.indexStart,
+				indexCount: o.indexCount
+			};
+			for (let [l, s] of Object.entries(i)) if (!Number.isInteger(s) || s < 0) throw De(`Mesh metadata field "${l}" must be a non-negative integer.`, {
+				meshName: o.name,
+				field: l,
+				value: s
+			});
+			if (o.vertexStart + o.vertexCount > t) throw De("Mesh vertex window exceeds the batch vertex buffer.", {
+				meshName: o.name,
+				vertexStart: o.vertexStart,
+				vertexCount: o.vertexCount,
+				totalVertexCount: t
+			});
+			if (o.indexStart + o.indexCount > r) throw De("Mesh index window exceeds the batch index buffer.", {
+				meshName: o.name,
+				indexStart: o.indexStart,
+				indexCount: o.indexCount,
+				totalIndexCount: r
+			});
+		}
+	}
+}
+function Tn(e, n) {
+	return De("Index references a vertex outside its mesh's vertex window.", {
+		meshName: n.name,
+		indexValue: e,
+		vertexStart: n.vertexStart,
+		vertexCount: n.vertexCount
+	});
+}
+function Rn(e, n, t, r, a, o) {
+	let i = [], l = e;
+	for (let s of n) {
+		l += `|${s.vertexStart},${s.vertexCount},${s.indexStart},${s.indexCount}`;
+		let c = s.vertexStart * 3, u = c + s.vertexCount * 3;
+		i.push(t.subarray(c, u)), i.push(r.subarray(s.indexStart, s.indexStart + s.indexCount)), i.push(a ? a.subarray(s.vertexStart * 2, (s.vertexStart + s.vertexCount) * 2) : null), i.push(o ? o.subarray(c, u) : null);
+	}
+	return hn(i, l);
+}
+function ra(e, n, t, r) {
+	let a = new Float32Array(e.length), o = n[0], i = n[1], l = n[2], s = t[0], c = t[1], u = t[2];
+	for (let d = 0; d < e.length; d += 3) a[d] = o + (e[d] + 32767) * s, a[d + 1] = i + (e[d + 1] + 32767) * c, a[d + 2] = l + (e[d + 2] + 32767) * u;
+	return a;
+}
+function oa(e, n) {
+	return e;
+}
+var aa = 5e4;
+var be;
+var Le = /* @__PURE__ */ new Map();
+var ia = 1;
+function sa() {
+	if (be !== void 0) return be;
+	if (typeof Worker > "u" || typeof Blob > "u" || typeof URL > "u" || typeof URL.createObjectURL != "function") return be = null, null;
+	try {
+		let e = URL.createObjectURL(new Blob([gn()], { type: "text/javascript" })), n = new Worker(e);
+		n.onmessage = (t) => {
+			let { id: r, geometries: a, error: o } = t.data, i = Le.get(r);
+			i && (Le.delete(r), a ? i.resolve(a) : i.reject(new Error(o ?? "mesh assembly failed in worker")));
+		}, n.onerror = () => {
+			for (let t of Le.values()) t.reject(/* @__PURE__ */ new Error("mesh assembly worker crashed"));
+			Le.clear(), n.terminate(), be = null;
+		}, be = n;
+	} catch {
+		be = null;
+	}
+	return be;
+}
+function la(e, n, t) {
+	return new Promise((r, a) => {
+		let o = ia++;
+		Le.set(o, {
+			resolve: r,
+			reject: a
+		}), e.postMessage({
+			id: o,
+			input: n
+		}, t);
+	});
+}
+async function xn(e, n) {
+	if (typeof Worker > "u") return null;
+	let t = ut(e);
+	if (t.indexData.length / 3 < aa) return null;
+	let r = sa();
+	if (!r) return null;
+	let a = t.metadata.materials ?? n.fallback?.materials ?? [], o = t.metadata.groups ?? n.fallback?.groups ?? [], i = n.fallback?.sourceComponentId ?? t.metadata.sourceComponentId;
+	bn(o, a.length, t.vertexCount, t.indexData.length);
+	let l = (m) => ({
+		vertexStart: m.vertexStart,
+		vertexCount: m.vertexCount,
+		indexStart: m.indexStart,
+		indexCount: m.indexCount
+	}), s = [], c = [];
+	for (let m of o) if (n.mergeByMaterial && m.meshes.length > 1) s.push({
+		kind: "merged",
+		windows: m.meshes.map(l)
+	}), c.push({
+		kind: "merged",
+		group: m
+	});
+	else for (let g of m.meshes) s.push({
+		kind: "single",
+		windows: [l(g)]
+	}), c.push({
+		kind: "single",
+		group: m,
+		meshMeta: g
+	});
+	let u = t.vertexData.slice(), d = t.indexData.slice(), p = [u.buffer, d.buffer];
+	t.uvs && p.push(t.uvs.buffer), t.colors && p.push(t.colors.buffer);
+	let T;
+	try {
+		T = await la(r, {
+			vertexData: u,
+			isFloat32: t.isFloat32,
+			deltaEncoded: t.deltaEncoded,
+			origin: t.origin,
+			scale: t.scale,
+			indexData: d,
+			uvs: t.uvs,
+			colors: t.colors,
+			jobs: s
+		}, p);
+	} catch (m$3) {
+		return m().warn("Mesh assembly worker failed; falling back to main-thread parse.", m$3), null;
+	}
+	if (T.length !== s.length) return null;
+	let v = a.map((m) => vn(m, {
+		vertexColors: t.colors != null,
+		appearance: n.material
+	})), R = [];
+	for (let m = 0; m < T.length; m++) {
+		let g = T[m], b = c[m], x = $e(g.key);
+		x || (x = new z.BufferGeometry(), x.setAttribute("position", new z.BufferAttribute(g.positions, 3)), x.setAttribute("normal", new z.BufferAttribute(g.normals, 3)), x.setIndex(new z.BufferAttribute(g.indices, 1)), g.uvs && x.setAttribute("uv", new z.BufferAttribute(g.uvs, 2)), g.colors && x.setAttribute("color", new z.BufferAttribute(g.colors, 3, true)), qe(g.key, x));
+		let H = b.kind === "merged" ? wn(x, b.group, v) : Mn(x, b.meshMeta, b.group, v);
+		H.userData.sourceComponentId = i ?? null, R.push(H);
+	}
+	return n.debug && m().debug(`Mesh batch assembled off-thread: ${R.length} meshes, ${t.indexData.length / 3} triangles`), R;
+}
+var ca = .5;
+var ua = .5;
+var da = .3;
+function vn(e, n) {
+	let t = St(e.color), r = n?.vertexColors ?? false, a = n?.appearance, o = new z.MeshPhysicalMaterial({
+		color: t,
+		metalness: e.metalness,
+		roughness: e.roughness,
+		opacity: e.opacity,
+		transparent: e.transparent,
+		vertexColors: r,
+		side: a?.cullBackfaces ? z.FrontSide : z.DoubleSide,
+		polygonOffset: true,
+		polygonOffsetFactor: .5,
+		polygonOffsetUnits: .5,
+		depthWrite: true,
+		depthTest: true
+	});
+	return a?.envMapIntensity != null && (o.envMapIntensity = a.envMapIntensity), e.metalness > ca && (o.clearcoat = ua, o.clearcoatRoughness = da), r && ma(o), e.map && nn(o, e.map), o;
+}
+function ma(e) {
+	e.onBeforeCompile = (n) => {
+		n.vertexShader = n.vertexShader.replace("#include <color_vertex>", `#include <color_vertex>
+			#if defined( USE_COLOR ) || defined( USE_COLOR_ALPHA )
+				vColor.rgb = mix(
+					vColor.rgb / 12.92,
+					pow( ( vColor.rgb + 0.055 ) / 1.055, vec3( 2.4 ) ),
+					step( vec3( 0.04045 ), vColor.rgb )
+				);
+			#endif`);
+	};
+}
+function fa(e, n, t, r, a = null, o = null) {
+	let i = Rn("merged", e.meshes, n, t, a, o), l = $e(i);
+	if (!l) {
+		let s = 0, c = 0;
+		for (let m of e.meshes) s += m.vertexCount, c += m.indexCount;
+		let u = new Float32Array(s * 3), d = new Uint32Array(c), p = a ? new Float32Array(s * 2) : null, T = o ? new Uint8Array(s * 3) : null, v = 0, R = 0;
+		for (let m of e.meshes) {
+			let g = m.vertexStart * 3, b = m.vertexCount * 3;
+			if (u.set(n.subarray(g, g + b), v * 3), p && a) {
+				let h = m.vertexStart * 2;
+				p.set(a.subarray(h, h + m.vertexCount * 2), v * 2);
+			}
+			T && o && T.set(o.subarray(g, g + b), v * 3);
+			let x = t.subarray(m.indexStart, m.indexStart + m.indexCount), H = v - m.vertexStart, E = m.vertexStart, f = m.vertexStart + m.vertexCount;
+			for (let h = 0; h < x.length; h++) {
+				let y = x[h];
+				if (y < E || y >= f) throw Tn(y, m);
+				d[R + h] = y + H;
+			}
+			v += m.vertexCount, R += m.indexCount;
+		}
+		l = new z.BufferGeometry(), l.setAttribute("position", new z.BufferAttribute(u, 3)), l.setIndex(new z.BufferAttribute(d, 1)), p && l.setAttribute("uv", new z.BufferAttribute(p, 2)), T && l.setAttribute("color", new z.BufferAttribute(T, 3, true)), l.computeVertexNormals(), qe(i, l);
+	}
+	return wn(l, e, r);
+}
+function wn(e, n, t) {
+	let r = new z.Mesh(e, t[n.materialId]), a = n.meshes[0], o = n.meshes.map((i) => i.name).filter((i) => i && i.length > 0);
+	return r.name = o.length > 0 ? o[0] : `merged_material_${n.materialId}`, r.castShadow = true, r.receiveShadow = true, r.userData = {
+		source: "compute",
+		name: r.name,
+		layer: a?.layer ?? "",
+		originalIndex: a?.originalIndex ?? 0,
+		metadata: a?.metadata ?? {},
+		mergedFrom: n.meshes.slice(1).map((i) => ({
+			name: i.name,
+			layer: i.layer,
+			originalIndex: i.originalIndex
+		}))
+	}, r;
+}
+function pa(e, n, t, r, a = null, o = null) {
+	let i = [];
+	for (let l of e.meshes) {
+		let s = l.vertexStart * 3, c = l.vertexCount * 3, u = Rn("single", [l], n, t, a, o), d = $e(u);
+		if (!d) {
+			let p = n.slice(s, s + c), T = t.subarray(l.indexStart, l.indexStart + l.indexCount), v = new Uint32Array(T.length), R = l.vertexStart, m = l.vertexStart + l.vertexCount;
+			for (let g = 0; g < T.length; g++) {
+				let b = T[g];
+				if (b < R || b >= m) throw Tn(b, l);
+				v[g] = b - R;
+			}
+			if (d = new z.BufferGeometry(), d.setAttribute("position", new z.BufferAttribute(p, 3)), d.setIndex(new z.BufferAttribute(v, 1)), a) {
+				let g = l.vertexStart * 2, b = a.slice(g, g + l.vertexCount * 2);
+				d.setAttribute("uv", new z.BufferAttribute(b, 2));
+			}
+			if (o) {
+				let g = o.slice(s, s + c);
+				d.setAttribute("color", new z.BufferAttribute(g, 3, true));
+			}
+			d.computeVertexNormals(), qe(u, d);
+		}
+		i.push(Mn(d, l, e, r));
+	}
+	return i;
+}
+function Mn(e, n, t, r) {
+	let a = new z.Mesh(e, r[t.materialId]);
+	return a.name = n.name, a.userData = {
+		source: "compute",
+		name: n.name,
+		layer: n.layer ?? "",
+		originalIndex: n.originalIndex,
+		metadata: n.metadata ?? {}
+	}, a.castShadow = true, a.receiveShadow = true, a;
+}
+function Ea(e) {
+	return Math.floor(e.length * 3 / 4);
+}
+var Hn = {
+	Angstroms: 1e-10,
+	Nanometers: 1e-9,
+	Microns: 1e-6,
+	Millimeters: .001,
+	Centimeters: .01,
+	Decimeters: .1,
+	Meters: 1,
+	Dekameters: 10,
+	Hectometers: 100,
+	Kilometers: 1e3,
+	Megameters: 1e6,
+	Gigameters: 1e9,
+	Microinches: 2.54e-8,
+	Mils: 254e-7,
+	Inches: .0254,
+	Feet: .3048,
+	Yards: .9144,
+	Miles: 1609.344,
+	NauticalMiles: 1852
+};
+var ha = "Display";
+var ga = "DisplayBatch";
+function ya(e) {
+	let n = e.split(".");
+	return n.includes(ha) || n.includes(ga);
+}
+var Cn = /* @__PURE__ */ new Set();
+async function cs(e, n) {
+	let t = performance.now(), r = [], { allowScaling: a = true, allowAutoPosition: o = false, groundAxis: i = "z", rhino: l, debug: s = false, parsing: c = {} } = n ?? {};
+	try {
+		return await Ta(e, r, a ? ba(e.modelunits) : 1, c, l, s), o && wa(r, i), r;
+	} catch (u) {
+		throw Ma(u, r), u;
+	} finally {
+		s && Ca(t);
+	}
+}
+function ba(e) {
+	let n = Hn[e];
+	return n !== void 0 ? n : (Cn.has(e) || (Cn.add(e), m().warn(`Unknown Rhino model unit "${e}" \u2014 geometry will not be scaled (factor 1). Known units: ${Object.keys(Hn).join(", ")}.`)), 1);
+}
+async function Ta(e, n, t, r, a, o) {
+	for (let i of e.values) {
+		let l = i.InnerTree;
+		for (let s in l) {
+			let c = l[s];
+			c && await Ra(c, n, t, r, a, o);
+		}
+	}
+}
+async function Ra(e, n, t, r, a, o) {
+	for (let i of e) {
+		if (!ya(i.type)) continue;
+		let l = {
+			mergeByMaterial: true,
+			applyTransforms: true,
+			debug: false,
+			...r
+		}, s = xa(i.data);
+		if (!s) {
+			m().error("Error parsing display batch envelope: invalid JSON");
+			continue;
+		}
+		let c = await mt(s, l), u = an(s.items, {
+			rhino: a,
+			applyTransforms: l.applyTransforms
+		}), d = [...c, ...u];
+		if (t !== 1) for (let p of d) p.scale.set(t, t, t);
+		n.push(...d), o && m().debug(`Extracted ${c.length} meshes and ${u.length} items from batch`);
+	}
+}
+function xa(e) {
+	return typeof e == "string" ? va(e) : e;
+}
+function va(e) {
+	try {
+		return JSON.parse(e);
+	} catch {
+		return;
+	}
+}
+function wa(e, n) {
+	if (e.length === 0) return;
+	Dt(e, Ke(e).min[n], n);
+}
+function Ma(e, n) {
+	m().error("An unexpected error occurred:", e), Ha(n);
+}
+function Ha(e) {
+	for (let n of e) {
+		let t = n;
+		t.geometry && t.geometry.dispose(), t.material && (Array.isArray(t.material) ? t.material.forEach((r) => r.dispose()) : t.material.dispose());
+	}
+}
+function Ca(e) {
+	let n = performance.now() - e;
+	m().info("Time to process meshes:", `${n.toFixed(2)}ms`);
+}
+
+export { $a as $, At as A, $r as B, Cr as C, Dt as D, Ct as E, Xe as F, Go as G, He as H, It as I, Ia as J, Ke as K, Lt as L, Oi as O, St as S, Uo as U, Vo as V, Xt as X, Yt as Y, Zt as Z, _o as _, lt as a, Vn as b, cn as c, Hn as d, qt as e, Ot as f, en as g, cs as h, Di as i, ji as j, ko as k, ln as l, mi as m, Oe as n, io as o, ct as p, qr as q, rt as r, an as s, ns as t, un as u, rs as v, we as w, mt as x, tn as y, zo as z };
+//# sourceMappingURL=chunk-N2WCSETE.js-CK2Q00_P.js.map