rayzee 9.4.1 → 9.5.0

package/dist/ArchiveImporter-xuUJiklP.js

@@ -0,0 +1,4301 @@
+import { n as e } from "./BidirectionalIntegrator-C5PKjJoT.js";
+import { g as t, n, o as r, r as i } from "./sceneCachePolicy-BmwYOYDu.js";
+import "./EngineDefaults-DH3bI5t-.js";
+import { n as a, r as o } from "./EngineIssues-CIZnXHsF.js";
+import { r as s } from "./shared-BGBcSxBQ.js";
+import { a as c, n as l, r as u } from "./identity-DrQsGT2o.js";
+import { n as d, t as f } from "./archiveFormats-BZw7TiDp.js";
+import { n as p, t as m } from "./ZipReader-gDSWr0I5.js";
+import { AnimationClip as h, BooleanKeyframeTrack as g, BufferAttribute as _, BufferGeometry as v, Color as y, DataTexture as b, DirectionalLight as x, DoubleSide as S, EquirectangularReflectionMapping as C, Float32BufferAttribute as w, FloatType as T, FrontSide as E, Group as D, InstancedBufferAttribute as O, InstancedMesh as k, LinearFilter as A, LoadingManager as j, MaterialLoader as M, Matrix4 as N, Mesh as ee, MeshPhysicalMaterial as te, NoColorSpace as ne, NumberKeyframeTrack as re, Object3D as ie, OrthographicCamera as ae, PerspectiveCamera as oe, PointLight as se, Quaternion as ce, QuaternionKeyframeTrack as le, RGBAFormat as P, RepeatWrapping as ue, SRGBColorSpace as F, SphereGeometry as de, SpotLight as fe, Texture as pe, Uint32BufferAttribute as I, Vector3 as L, VectorKeyframeTrack as me } from "three";
+import { HDRLoader as he } from "three/addons/loaders/HDRLoader.js";
+import { Gunzip as ge, strFromU8 as R, zipSync as _e } from "three/addons/libs/fflate.module.js";
+import { EXRLoader as ve } from "three/addons/loaders/EXRLoader.js";
+//#region src/Processor/ArchiveReader.js
+var z = 512, ye = 4 << 20, be = 15e8, xe = new TextDecoder();
+function Se(e) {
+	return e.length >= 2 && e[0] === 31 && e[1] === 139;
+}
+function Ce(e) {
+	return e.length >= 4 && e[0] === 80 && e[1] === 75 && (e[2] === 3 || e[2] === 5 || e[2] === 7);
+}
+function we(e) {
+	return e.length >= 263 && String.fromCharCode(...e.subarray(257, 262)) === "ustar";
+}
+function Te(e) {
+	return Se(e) ? "gzip" : Ce(e) ? "zip" : we(e) ? "tar" : null;
+}
+function B(e, t, n) {
+	let r = t, i = t + n;
+	for (; r < i && e[r] !== 0;) r++;
+	return xe.decode(e.subarray(t, r));
+}
+function Ee(e, t, n) {
+	if (e[t] & 128) {
+		let r = e[t] & 127;
+		for (let i = t + 1; i < t + n; i++) r = r * 256 + e[i];
+		return r;
+	}
+	let r = B(e, t, n).trim();
+	if (!r) return 0;
+	let i = parseInt(r, 8);
+	return Number.isFinite(i) ? i : 0;
+}
+function De(e) {
+	let t = [];
+	for (let n of e.replace(/\\/g, "/").split("/")) n === "" || n === "." || (n === ".." ? t.pop() : t.push(n));
+	return t.join("/");
+}
+function Oe(e) {
+	let t = xe.decode(e).match(/^\d+ path=(.*)$/m);
+	return t ? t[1] : null;
+}
+var ke = (e) => e + (z - e % z) % z, Ae = (e) => e === "L" || e === "x" || e === "X";
+function je(e) {
+	let t = B(e, 345, 155), n = B(e, 0, 100);
+	return {
+		type: String.fromCharCode(e[156] || 48),
+		size: Ee(e, 124, 12),
+		name: t ? `${t}/${n}` : n
+	};
+}
+function Me(e, t) {
+	return e === "5" || e === "g" || e === "K" || t.endsWith("/") || e !== "0" && e !== " " ? null : De(t) || null;
+}
+function Ne(e) {
+	for (let t = 0; t < z; t++) if (e[t] !== 0) return !1;
+	return !0;
+}
+var Pe = class {
+	constructor({ filter: e = null, retain: t = null, byteBudget: n = be, onEntry: r = null } = {}) {
+		this.filter = e, this.retain = t, this.byteBudget = n, this.onEntry = r, this.entries = Object.create(null), this.listing = [], this.retainedBytes = 0, this.truncated = !1, this.finished = !1, this._header = new Uint8Array(z), this._headerLen = 0, this._state = "header", this._remaining = 0, this._size = 0, this._copied = 0, this._dst = null, this._special = null, this._pendingName = null, this._abs = 0;
+	}
+	push(e) {
+		let t = this._abs;
+		this._abs += e.length;
+		let n = 0;
+		for (; n < e.length && !this.finished;) if (this._state === "header") {
+			let r = Math.min(z - this._headerLen, e.length - n);
+			this._header.set(e.subarray(n, n + r), this._headerLen), this._headerLen += r, n += r, this._headerLen === z && (this._headerLen = 0, this._bodyStart = t + n, this._readHeader());
+		} else {
+			let t = Math.min(this._remaining, e.length - n);
+			if (this._dst && this._copied < this._size) {
+				let r = Math.min(t, this._size - this._copied);
+				this._dst.set(e.subarray(n, n + r), this._copied), this._copied += r;
+			}
+			this._remaining -= t, n += t, this._remaining === 0 && this._endBody();
+		}
+	}
+	end() {
+		this.finished = !0;
+	}
+	result() {
+		return {
+			entries: this.entries,
+			listing: this.listing,
+			retainedBytes: this.retainedBytes,
+			truncated: this.truncated
+		};
+	}
+	_readHeader() {
+		let e = this._header, t = !0;
+		for (let n = 0; n < z; n++) if (e[n] !== 0) {
+			t = !1;
+			break;
+		}
+		if (t) {
+			this.finished = !0;
+			return;
+		}
+		let { type: n, size: r, name: i } = je(e), a = this._pendingName ?? i;
+		if (this._pendingName = null, this._size = r, this._copied = 0, this._remaining = ke(r), this._dst = null, this._special = null, this._indexed = !1, this._state = this._remaining > 0 ? "body" : "header", Ae(n)) {
+			this._special = n === "L" ? "longname" : "pax", this._dst = new Uint8Array(r);
+			return;
+		}
+		let o = Me(n, a);
+		o && (this.listing.push({
+			path: o,
+			size: r
+		}), this._indexed = this.filter ? this.filter(o, r) : !0, this._indexed && !(this.retain && !this.retain(o, r)) && (this.retainedBytes + r > this.byteBudget ? this.truncated = !0 : (this._dst = new Uint8Array(r), this.retainedBytes += r)), this._remaining === 0 && this._endBody());
+	}
+	_endBody() {
+		if (this._state = "header", this._special === "longname") {
+			this._pendingName = B(this._dst, 0, this._dst.length), this._dst = null;
+			return;
+		}
+		if (this._special === "pax") {
+			let e = Oe(this._dst);
+			e && (this._pendingName = e), this._dst = null;
+			return;
+		}
+		let e = this.listing[this.listing.length - 1];
+		this._indexed && e && (e.offset = this._bodyStart, this._indexed = !1), this._dst &&= (this.entries[e.path] = this._dst, this.onEntry?.(e.path, this._dst), null);
+	}
+};
+async function Fe(e, t) {
+	if (typeof DecompressionStream < "u" && typeof e?.stream == "function") {
+		let n = e.stream().pipeThrough(new DecompressionStream("gzip")).getReader();
+		for (;;) {
+			let { done: e, value: r } = await n.read();
+			if (e) break;
+			t(r);
+		}
+		return;
+	}
+	let n = null, r = new ge((e, r) => {
+		e instanceof Error ? n = e : e && e.length && t(e);
+	});
+	await Ie(e, (e, t) => {
+		if (r.push(e, t), n) throw n;
+	});
+}
+async function Ie(e, t) {
+	if (e instanceof Uint8Array) {
+		for (let n = 0; n < e.length; n += ye) {
+			let r = Math.min(n + ye, e.length);
+			t(e.subarray(n, r), r === e.length);
+		}
+		e.length === 0 && t(e, !0);
+		return;
+	}
+	let n = e.size;
+	for (let r = 0; r < n; r += ye) {
+		let i = Math.min(r + ye, n);
+		t(new Uint8Array(await e.slice(r, i).arrayBuffer()), i === n);
+	}
+	n === 0 && t(new Uint8Array(), !0);
+}
+async function Le(e, t = {}) {
+	let { onProgress: n, ...r } = t, i = new Pe(r), a = 0, o = 0;
+	return await Fe(e, (e) => {
+		i.push(e), a += e.length, n && a >= o && (o = a + (64 << 20), n({
+			entries: i.listing.length,
+			bytes: a
+		}));
+	}), i.end(), i.result();
+}
+var Re = 1 << 20;
+async function ze(e, { onProgress: t = null } = {}) {
+	let n = e.size, r = [], i = null, a = 0, o = null, s = 0, c = 0, l = async (t, r) => {
+		if (i && t >= a && t + r <= a + i.length) return i.subarray(t - a, t - a + r);
+		let o = Math.min(n, t + Math.max(r, Re));
+		return i = new Uint8Array(await e.slice(t, o).arrayBuffer()), a = t, i.subarray(0, r);
+	};
+	for (; s + z <= n;) {
+		let e = await l(s, z);
+		if (Ne(e)) break;
+		let { type: n, size: i, name: a } = je(e), u = o ?? a;
+		o = null;
+		let d = s + z;
+		if (Ae(n)) {
+			let e = await l(d, i);
+			o = n === "L" ? B(e, 0, e.length) : Oe(e);
+		} else {
+			let e = Me(n, u);
+			e && r.push({
+				path: e,
+				size: i,
+				offset: d
+			});
+		}
+		s = d + ke(i), t && s >= c && (c = s + (256 << 20), t({
+			entries: r.length,
+			bytes: s
+		}));
+	}
+	return r;
+}
+function Be() {
+	let e = new Pe({ retain: () => !1 });
+	return {
+		push: (t) => e.push(t),
+		finish: () => (e.end(), e.listing.filter((e) => e.offset !== void 0))
+	};
+}
+async function Ve(e, t = {}) {
+	let { index: n = null, headersOnly: r = !1, onProgress: i = null, ...a } = t, o, s, c, l, u = null;
+	if (n || r) {
+		u = n?.listing ?? await ze(e, { onProgress: i });
+		let { filter: t } = a;
+		s = u.map((e) => !t || t(e.path, e.size) ? { ...e } : {
+			path: e.path,
+			size: e.size
+		}), o = Object.create(null), c = 0, l = !1;
+	} else {
+		let t = new Pe({ ...a });
+		await Ie(e, (e) => t.push(e)), t.end(), {entries: o, listing: s, retainedBytes: c, truncated: l} = t.result();
+	}
+	let d = /* @__PURE__ */ new Map();
+	for (let e of s) e.offset !== void 0 && d.set(e.path, e);
+	return {
+		entries: o,
+		listing: s,
+		read: async (t) => {
+			if (o[t]) return o[t];
+			let n = d.get(t);
+			return n ? new Uint8Array(await e.slice(n.offset, n.offset + n.size).arrayBuffer()) : null;
+		},
+		readHead: async (t, n) => {
+			if (o[t]) return o[t].subarray(0, n);
+			let r = d.get(t);
+			return r ? new Uint8Array(await e.slice(r.offset, r.offset + Math.min(r.size, n)).arrayBuffer()) : null;
+		},
+		retainedBytes: c,
+		truncated: l,
+		indexed: d.size,
+		index: u ? {
+			v: 1,
+			listing: u
+		} : null
+	};
+}
+function He(e) {
+	let t = (Array.isArray(e) ? e : [e]).filter(Boolean).map((e) => {
+		let t = De(e);
+		return {
+			p: t,
+			inside: t + "/"
+		};
+	});
+	return t.length === 0 ? () => !0 : (e) => {
+		let n = e.lastIndexOf("/"), r = n < 0 ? "" : e.slice(0, n);
+		if (r === "") return !0;
+		let i = r.lastIndexOf("/textures"), a = i >= 0 && i === r.length - 9 ? r.slice(0, i) + "/" : null;
+		for (let { p: n, inside: i } of t) if (e === n || e.startsWith(i) || i.startsWith(r + "/") || a !== null && i.startsWith(a)) return !0;
+		return !1;
+	};
+}
+function Ue(e) {
+	let t = e.filter((e) => e.path.toLowerCase().endsWith(".pbrt")).sort((e, t) => e.path.split("/").length - t.path.split("/").length || e.path.length - t.path.length || (e.path < t.path ? -1 : 1));
+	if (!t.length) return {
+		root: null,
+		elements: []
+	};
+	let n = t[0].path, r = n.lastIndexOf("/"), i = r < 0 ? "" : n.slice(0, r), a = i ? i + "/" : "", o = /* @__PURE__ */ new Map();
+	for (let t of e) {
+		if (!t.path.startsWith(a)) continue;
+		let e = t.path.slice(a.length), n = e.indexOf("/");
+		if (n < 0) continue;
+		let r = e.slice(0, n), i = o.get(r);
+		i || o.set(r, i = {
+			name: r,
+			prefix: a + r,
+			files: 0,
+			bytes: 0,
+			scenes: 0
+		}), i.files++, i.bytes += t.size, t.path.toLowerCase().endsWith(".pbrt") && i.scenes++;
+	}
+	return {
+		root: i,
+		elements: [...o.values()].filter((e) => e.scenes > 0).sort((e, t) => e.bytes - t.bytes)
+	};
+}
+//#endregion
+//#region src/Processor/ArchiveCache.js
+var We = 1, Ge = 3;
+async function Ke(e, t) {
+	return `${e}:${u(await l(t))}`;
+}
+async function qe(e, { storage: t, label: n = e.name, onProgress: r = null }) {
+	if (!t || typeof DecompressionStream > "u") return null;
+	let i = t.area(s.ARCHIVES), o = await Ke("gunzip", e), c = await i.open(o), l = !!c;
+	if (!c) {
+		let l = await i.create(o, {
+			label: n,
+			expectedBytes: e.size * Ge
+		});
+		if (!l) return null;
+		let u = Be(), d = new TransformStream({ transform(e, t) {
+			u.push(e), t.enqueue(e);
+		} });
+		try {
+			let t = e.stream().pipeThrough(new DecompressionStream("gzip")).pipeThrough(d), n = await l.writeStream("data.tar", t, { onProgress: r });
+			await l.writeJSON("index.json", {
+				v: We,
+				listing: u.finish()
+			}), await l.commit({
+				compressedBytes: e.size,
+				tarBytes: n
+			});
+		} catch (e) {
+			if (await l.abort(), e?.name !== "QuotaExceededError") throw e;
+			return t._issue(a.STORAGE_QUOTA_EXCEEDED, `ran out of room unpacking ${n}; reading it in memory instead`, { area: s.ARCHIVES }), null;
+		}
+		if (c = await i.open(o, { wait: !0 }), !c) return null;
+	}
+	let u = await c.file("data.tar"), d = await c.json("index.json");
+	return !u || d?.v !== We ? (c.release(), null) : {
+		file: u,
+		index: d,
+		release: () => c.release(),
+		cached: l
+	};
+}
+async function Je(e, t) {
+	if (!t) return null;
+	let n = await t.area(s.ARCHIVES).open(await Ke("tarindex", e));
+	if (!n) return null;
+	try {
+		let e = await n.json("index.json");
+		return e?.v === We ? e : null;
+	} finally {
+		n.release();
+	}
+}
+async function Ye(e, t, n) {
+	if (!t || !n) return !1;
+	let r = await t.area(s.ARCHIVES).create(await Ke("tarindex", e), { label: `${e.name} (index)` });
+	if (!r) return !1;
+	try {
+		return await r.writeJSON("index.json", n), await r.commit(), !0;
+	} catch {
+		return await r.abort(), !1;
+	}
+}
+var Xe = ["diffuseTransmissionMap", "diffuseTransmissionColorMap"], Ze = "__rayzeeArchivePath", Qe = "__rayzeeArchiveLoader", $e = 64, et = 32 << 20, tt = 64 << 20, nt = {
+	Float32Array,
+	Float64Array,
+	Int8Array,
+	Int16Array,
+	Int32Array,
+	Uint8Array,
+	Uint16Array,
+	Uint32Array,
+	Uint8ClampedArray
+}, rt = [
+	"name",
+	"mapping",
+	"channel",
+	"wrapS",
+	"wrapT",
+	"magFilter",
+	"minFilter",
+	"anisotropy",
+	"format",
+	"type",
+	"flipY",
+	"generateMipmaps",
+	"premultiplyAlpha",
+	"unpackAlignment",
+	"colorSpace"
+], it = [
+	"intensity",
+	"distance",
+	"decay",
+	"angle",
+	"penumbra"
+], at = [
+	"name",
+	"visible",
+	"castShadow",
+	"receiveShadow",
+	"frustumCulled",
+	"renderOrder",
+	"matrixAutoUpdate"
+], V = class extends Error {
+	constructor(e) {
+		super(e), this.name = "SceneGraphUnsupported";
+	}
+};
+function ot(e) {
+	return e.isInstancedMesh ? "InstancedMesh" : e.isSkinnedMesh || e.isBatchedMesh ? null : e.isMesh ? "Mesh" : e.isPerspectiveCamera ? "PerspectiveCamera" : e.isOrthographicCamera ? "OrthographicCamera" : e.isDirectionalLight ? "DirectionalLight" : e.isPointLight ? "PointLight" : e.isSpotLight ? "SpotLight" : e.isLight || e.isPoints || e.isLine || e.isSprite || e.isLOD ? null : e.isGroup ? "Group" : e.constructor === ie ? "Object3D" : null;
+}
+function st(e, t) {
+	try {
+		let t = JSON.parse(JSON.stringify(e ?? {}));
+		return delete t[Ze], delete t[Qe], t;
+	} catch {
+		throw new V(`${t}: userData is not plain JSON`);
+	}
+}
+var ct = class {
+	constructor() {
+		this.sections = [], this.length = 0;
+	}
+	add(e) {
+		let t = Math.ceil(this.length / $e) * $e;
+		return this.sections.push({
+			offset: t,
+			array: e
+		}), this.length = t + e.byteLength, {
+			offset: t,
+			byteLength: e.byteLength,
+			type: e.constructor.name,
+			length: e.length
+		};
+	}
+};
+function lt(e, t, n) {
+	if (e.isInterleavedBufferAttribute || !ArrayBuffer.isView(e.array)) throw new V(`${n}: interleaved or non-typed attribute`);
+	return {
+		section: t.add(e.array),
+		itemSize: e.itemSize,
+		normalized: e.normalized === !0,
+		name: e.name ?? ""
+	};
+}
+function ut(e, t) {
+	let n = `geometry ${e.name || e.uuid}`;
+	if (Object.keys(e.morphAttributes ?? {}).length) throw new V(`${n}: morph targets`);
+	let r = {};
+	for (let [i, a] of Object.entries(e.attributes)) r[i] = lt(a, t, n);
+	return {
+		uuid: e.uuid,
+		name: e.name,
+		attributes: r,
+		index: e.index ? lt(e.index, t, n) : null,
+		groups: e.groups.map((e) => ({ ...e })),
+		drawRange: { ...e.drawRange },
+		userData: st(e.userData, n)
+	};
+}
+function dt(e, t) {
+	let n = {
+		uuid: e.uuid,
+		userData: st(e.userData, `texture ${e.uuid}`)
+	};
+	for (let t of rt) n[t] = e[t];
+	for (let t of [
+		"repeat",
+		"offset",
+		"center"
+	]) n[t] = e[t].toArray();
+	n.rotation = e.rotation;
+	let r = e.userData?.[Ze];
+	if (r) n.path = r, n.loader = e.userData.__rayzeeArchiveLoader ?? "image";
+	else if (e.isDataTexture && ArrayBuffer.isView(e.image?.data)) n.data = {
+		section: t.add(e.image.data),
+		width: e.image.width,
+		height: e.image.height
+	};
+	else throw new V(`texture ${e.name || e.uuid}: no archive path and no pixel data to keep`);
+	return n;
+}
+function ft(e, t) {
+	let n = e.toJSON(t);
+	n.exactColors = {};
+	for (let [t, r] of Object.entries(e)) r?.isColor && (n.exactColors[t] = [
+		r.r,
+		r.g,
+		r.b
+	]);
+	e.ior !== void 0 && (n.exactIor = e.ior), e.diffuseTransmission !== void 0 && (n.diffuseTransmission = e.diffuseTransmission);
+	for (let t of Xe) e[t]?.isTexture && ((n.engineTextures ??= {})[t] = e[t].uuid);
+	return n;
+}
+function pt(e, t) {
+	for (let n of Object.values(e)) n?.isTexture && t.set(n.uuid, n);
+}
+function mt(e, { environment: t = null, animations: n = [], stats: r = {} } = {}) {
+	let i = new ct(), a = [], o = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Map(), c = /* @__PURE__ */ new Map(), l = (e, t) => {
+		let n = ot(e);
+		if (!n) throw new V(`${e.type} "${e.name}" cannot be cached`);
+		let r = {
+			type: n,
+			uuid: e.uuid,
+			parent: t,
+			userData: st(e.userData, `${n} "${e.name}"`)
+		};
+		for (let t of at) r[t] = e[t];
+		if (r.position = e.position.toArray(), r.quaternion = e.quaternion.toArray(), r.scale = e.scale.toArray(), r.layers = e.layers.mask, e.matrixAutoUpdate || (r.matrix = e.matrix.toArray()), e.isMesh) {
+			o.set(e.geometry.uuid, e.geometry);
+			let t = Array.isArray(e.material) ? e.material : [e.material];
+			for (let e of t) s.set(e.uuid, e), pt(e, c);
+			r.geometry = e.geometry.uuid, r.material = Array.isArray(e.material) ? t.map((e) => e.uuid) : e.material.uuid;
+		}
+		if (e.isInstancedMesh && (r.count = e.count, r.instanceMatrix = i.add(e.instanceMatrix.array), r.instanceColor = e.instanceColor ? i.add(e.instanceColor.array) : null), e.isCamera) for (let t of [
+			"fov",
+			"aspect",
+			"near",
+			"far",
+			"zoom",
+			"focus",
+			"filmGauge",
+			"filmOffset",
+			"left",
+			"right",
+			"top",
+			"bottom"
+		]) e[t] !== void 0 && (r[t] = e[t]);
+		if (e.isLight) {
+			r.color = e.color.toArray();
+			for (let t of it) e[t] !== void 0 && (r[t] = e[t]);
+			e.target && (r.target = e.target.uuid);
+		}
+		let u = a.push(r) - 1;
+		for (let t of e.children) l(t, u);
+	};
+	l(e, -1), t && c.set(t.uuid, t);
+	let u = {
+		textures: {},
+		images: {}
+	};
+	for (let e of c.keys()) u.textures[e] = { uuid: e };
+	return {
+		manifest: {
+			v: 2,
+			nodes: a,
+			geometries: [...o.values()].map((e) => ut(e, i)),
+			textures: [...c.values()].map((e) => dt(e, i)),
+			materials: [...s.values()].map((e) => ft(e, u)),
+			animations: n.map((e) => h.toJSON(e)),
+			environment: t ? t.uuid : null,
+			stats: r
+		},
+		sections: i.sections,
+		byteLength: i.length
+	};
+}
+async function ht(e, { manifest: t, sections: n }, { release: r = !1 } = {}) {
+	for (let t of n) {
+		let { offset: n, array: i } = t, a = new Uint8Array(i.buffer, i.byteOffset, i.byteLength);
+		for (let t = 0; t < a.length; t += et) await e.write("data.bin", a.subarray(t, Math.min(a.length, t + et)), { at: n + t });
+		r && (t.array = null);
+	}
+	n.length === 0 && await e.write("data.bin", new Uint8Array()), await e.writeJSON("graph.json", t);
+}
+function gt(e) {
+	let t = nt[e];
+	if (!t) throw Error(`scene graph: unknown array type ${e}`);
+	return t;
+}
+async function _t(e, t) {
+	let n = /* @__PURE__ */ new Map(), r = [...t].sort((e, t) => e.offset - t.offset), i = null, a = 0;
+	for (let t of r) {
+		let { offset: r, byteLength: o, type: s } = t, c = gt(s), l = r + o;
+		if (o > tt) {
+			n.set(r, new c(await e.slice(r, l).arrayBuffer()));
+			continue;
+		}
+		(!i || r < a || l > a + i.byteLength) && (a = r, i = await e.slice(r, Math.min(e.size, r + tt)).arrayBuffer()), n.set(r, new c(i.slice(r - a, l - a)));
+	}
+	return n;
+}
+function vt(e) {
+	let t = [];
+	for (let n of e.nodes) n.instanceMatrix && t.push(n.instanceMatrix), n.instanceColor && t.push(n.instanceColor);
+	for (let n of e.geometries) {
+		for (let e of Object.values(n.attributes)) t.push(e.section);
+		n.index && t.push(n.index.section);
+	}
+	for (let n of e.textures) n.data && t.push(n.data.section);
+	return t;
+}
+function yt(e, t) {
+	let n = new _(e.get(t.section.offset), t.itemSize, t.normalized);
+	return n.name = t.name, n;
+}
+function bt(e, t) {
+	for (let n of rt) t[n] !== void 0 && (e[n] = t[n]);
+	e.repeat.fromArray(t.repeat), e.offset.fromArray(t.offset), e.center.fromArray(t.center), e.rotation = t.rotation, e.uuid = t.uuid, Object.assign(e.userData, t.userData), e.needsUpdate = !0;
+}
+async function xt(e, t, { loadTexture: n }) {
+	if (e?.v !== 2) throw Error("scene graph: unknown format");
+	let r = await _t(t, vt(e)), i = (e) => r.get(e.offset), a = {};
+	for (let t of e.textures) {
+		let e;
+		if (t.path) {
+			if (e = await n(t.path, t.loader), !e) throw Error(`scene graph: "${t.path}" is missing from the archive`);
+			e.userData[Ze] = t.path, e.userData[Qe] = t.loader;
+		} else e = new b(i(t.data.section), t.data.width, t.data.height);
+		bt(e, t), a[t.uuid] = e;
+	}
+	let o = new M().setTextures(a), s = {};
+	for (let t of e.materials) {
+		let e = o.parse(t);
+		for (let [n, r] of Object.entries(t.exactColors ?? {})) n === "diffuseTransmissionColor" && (e[n] = new y()), e[n]?.setRGB(r[0], r[1], r[2]);
+		t.exactIor !== void 0 && (e.ior = t.exactIor), t.diffuseTransmission !== void 0 && (e.diffuseTransmission = t.diffuseTransmission);
+		for (let [n, r] of Object.entries(t.engineTextures ?? {})) a[r] && (e[n] = a[r]);
+		s[t.uuid] = e;
+	}
+	let c = {};
+	for (let t of e.geometries) {
+		let e = new v();
+		e.uuid = t.uuid, e.name = t.name;
+		for (let [n, i] of Object.entries(t.attributes)) e.setAttribute(n, yt(r, i));
+		t.index && e.setIndex(yt(r, t.index));
+		for (let n of t.groups) e.addGroup(n.start, n.count, n.materialIndex);
+		e.setDrawRange(t.drawRange.start, t.drawRange.count), e.userData = t.userData, c[t.uuid] = e;
+	}
+	let l = [];
+	for (let t of e.nodes) {
+		let e = Array.isArray(t.material) ? t.material.map((e) => s[e]) : s[t.material], n;
+		switch (t.type) {
+			case "InstancedMesh":
+				n = new k(c[t.geometry], e, 1), n.instanceMatrix = new O(i(t.instanceMatrix), 16), n.count = t.count, t.instanceColor && (n.instanceColor = new O(i(t.instanceColor), 3));
+				break;
+			case "Mesh":
+				n = new ee(c[t.geometry], e);
+				break;
+			case "PerspectiveCamera":
+				n = new oe();
+				break;
+			case "OrthographicCamera":
+				n = new ae();
+				break;
+			case "Group":
+				n = new D();
+				break;
+			case "DirectionalLight":
+				n = new x();
+				break;
+			case "PointLight":
+				n = new se();
+				break;
+			case "SpotLight":
+				n = new fe();
+				break;
+			default: n = new ie();
+		}
+		n.uuid = t.uuid;
+		for (let e of at) n[e] = t[e];
+		if (n.position.fromArray(t.position), n.quaternion.fromArray(t.quaternion), n.scale.fromArray(t.scale), n.layers.mask = t.layers, n.userData = t.userData, t.matrix && n.matrix.fromArray(t.matrix), n.isCamera) {
+			for (let e of [
+				"fov",
+				"aspect",
+				"near",
+				"far",
+				"zoom",
+				"focus",
+				"filmGauge",
+				"filmOffset",
+				"left",
+				"right",
+				"top",
+				"bottom"
+			]) t[e] !== void 0 && (n[e] = t[e]);
+			n.updateProjectionMatrix();
+		}
+		if (n.isLight) {
+			n.color.fromArray(t.color);
+			for (let e of it) t[e] !== void 0 && (n[e] = t[e]);
+		}
+		l.push(n), t.parent >= 0 && l[t.parent].add(n);
+	}
+	let u = new Map(l.map((e) => [e.uuid, e]));
+	return e.nodes.forEach((e, t) => {
+		e.target && u.has(e.target) && (l[t].target = u.get(e.target));
+	}), {
+		root: l[0],
+		environment: e.environment ? a[e.environment] : null,
+		animations: e.animations.map((e) => h.parse(e)),
+		stats: e.stats
+	};
+}
+//#endregion
+//#region src/Processor/PBRT/buffers.js
+var St = (e) => e.byteOffset === 0 && e.byteLength === e.buffer.byteLength && typeof e.buffer.transfer == "function" && !(typeof SharedArrayBuffer < "u" && e.buffer instanceof SharedArrayBuffer);
+function H(e) {
+	e && St(e) && e.buffer.transfer(0);
+}
+function U(e, t) {
+	let n = e.constructor;
+	if (St(e)) return new n(e.buffer.transfer(t * n.BYTES_PER_ELEMENT));
+	let r = new n(t);
+	return r.set(t < e.length ? e.subarray(0, t) : e), r;
+}
+//#endregion
+//#region src/Processor/PBRT/PBRTTokenizer.js
+var W = {
+	STRING: "string",
+	NUMBER: "number",
+	WORD: "word",
+	LBRACKET: "[",
+	RBRACKET: "]"
+}, Ct = 9, wt = 10, Tt = 12, Et = 13, Dt = 32, Ot = 34, kt = 35, At = 43, jt = 45, Mt = 46, Nt = 48, Pt = 57, Ft = 91, It = 93, Lt = 69, Rt = 101, zt = (e) => e === Dt || e === Ct || e === wt || e === Et || e === Tt, G = (e) => e >= Nt && e <= Pt, Bt = 15, Vt = 22, Ht = (() => {
+	let e = new Float64Array(Vt + 1);
+	for (let t = 0; t < e.length; t++) e[t] = 10 ** t;
+	return e;
+})(), Ut = new TextDecoder();
+function K(e, t, n) {
+	if (n - t === 0) return "";
+	let r = !0;
+	for (let i = t; i < n; i++) if (e[i] > 127) {
+		r = !1;
+		break;
+	}
+	if (!r) return Ut.decode(e.subarray(t, n));
+	let i = "";
+	for (let r = t; r < n; r++) i += String.fromCharCode(e[r]);
+	return i;
+}
+var Wt = class {
+	constructor(e) {
+		this.bytes = typeof e == "string" ? new TextEncoder().encode(e) : e, this.i = 0, this.n = this.bytes.length, this._ahead = null;
+	}
+	peek() {
+		return this._ahead === null && (this._ahead = this._scan()), this._ahead;
+	}
+	next() {
+		let e = this.peek();
+		return this._ahead = null, e;
+	}
+	_scan() {
+		let e = this.bytes, t = this.i, n = this.n;
+		for (;;) {
+			for (; t < n && zt(e[t]);) t++;
+			if (t < n && e[t] === kt) {
+				for (; t < n && e[t] !== wt;) t++;
+				continue;
+			}
+			break;
+		}
+		if (t >= n) return this.i = t, null;
+		let r = e[t];
+		if (r === Ft) return this.i = t + 1, { type: W.LBRACKET };
+		if (r === It) return this.i = t + 1, { type: W.RBRACKET };
+		if (r === Ot) {
+			let r = ++t;
+			for (; t < n && e[t] !== Ot;) t++;
+			if (t >= n) throw Error("PBRT tokenizer: unterminated string literal");
+			return this.i = t + 1, {
+				type: W.STRING,
+				value: K(e, r, t)
+			};
+		}
+		if (G(r) || r === Mt && G(e[t + 1]) || (r === jt || r === At) && (G(e[t + 1]) || e[t + 1] === Mt && G(e[t + 2]))) return this._scanNumber(t);
+		let i = t;
+		for (; t < n;) {
+			let n = e[t];
+			if (zt(n) || n === Ot || n === Ft || n === It || n === kt) break;
+			t++;
+		}
+		return this.i = t, {
+			type: W.WORD,
+			value: K(e, i, t)
+		};
+	}
+	_scanNumber(e) {
+		let t = this.bytes, n = this.n, r = e, i = !1;
+		t[r] === jt ? (i = !0, r++) : t[r] === At && r++;
+		let a = 0, o = 0, s = 0;
+		for (; r < n && G(t[r]);) a = a * 10 + (t[r] - Nt), o++, r++;
+		if (r < n && t[r] === Mt) for (r++; r < n && G(t[r]);) a = a * 10 + (t[r] - Nt), o++, s++, r++;
+		let c = 0;
+		if (r < n && (t[r] === Rt || t[r] === Lt)) {
+			let e = r + 1, i = !1;
+			if (e < n && (t[e] === jt || t[e] === At) && (i = t[e] === jt, e++), e < n && G(t[e])) {
+				let a = 0;
+				for (; e < n && G(t[e]);) a = a * 10 + (t[e] - Nt), e++;
+				c = i ? -a : a, r = e;
+			}
+		}
+		if (this.i = r, o === 0) throw Error(`PBRT tokenizer: invalid number "${K(t, e, r)}"`);
+		let l = c - s;
+		if (!(o <= Bt && l >= -Vt && l <= Vt)) {
+			let n = Number(K(t, e, r));
+			if (Number.isNaN(n)) throw Error(`PBRT tokenizer: invalid number "${K(t, e, r)}"`);
+			return {
+				type: W.NUMBER,
+				value: n
+			};
+		}
+		let u = l === 0 ? a : l > 0 ? a * Ht[l] : a / Ht[-l];
+		return i && (u = -u), {
+			type: W.NUMBER,
+			value: u
+		};
+	}
+};
+//#endregion
+//#region src/Processor/PBRT/PBRTMath.js
+function Gt() {
+	return [
+		1,
+		0,
+		0,
+		0,
+		0,
+		1,
+		0,
+		0,
+		0,
+		0,
+		1,
+		0,
+		0,
+		0,
+		0,
+		1
+	];
+}
+function Kt(e) {
+	return e[0] * (e[5] * e[10] - e[6] * e[9]) - e[4] * (e[1] * e[10] - e[2] * e[9]) + e[8] * (e[1] * e[6] - e[2] * e[5]);
+}
+function qt(e, t, n, r) {
+	for (let i = 0; i < 4; i++) {
+		let a = r[i * 4], o = r[i * 4 + 1], s = r[i * 4 + 2], c = r[i * 4 + 3];
+		for (let r = 0; r < 4; r++) e[i * 4 + r] = t[n + r] * a + t[n + 4 + r] * o + t[n + 8 + r] * s + t[n + 12 + r] * c;
+	}
+	return e;
+}
+function q(e, t) {
+	let n = e[0], r = e[1], i = e[2], a = e[3], o = e[4], s = e[5], c = e[6], l = e[7], u = e[8], d = e[9], f = e[10], p = e[11], m = e[12], h = e[13], g = e[14], _ = e[15], v = t[0], y = t[1], b = t[2], x = t[3], S = t[4], C = t[5], w = t[6], T = t[7], E = t[8], D = t[9], O = t[10], k = t[11], A = t[12], j = t[13], M = t[14], N = t[15];
+	return [
+		n * v + o * y + u * b + m * x,
+		r * v + s * y + d * b + h * x,
+		i * v + c * y + f * b + g * x,
+		a * v + l * y + p * b + _ * x,
+		n * S + o * C + u * w + m * T,
+		r * S + s * C + d * w + h * T,
+		i * S + c * C + f * w + g * T,
+		a * S + l * C + p * w + _ * T,
+		n * E + o * D + u * O + m * k,
+		r * E + s * D + d * O + h * k,
+		i * E + c * D + f * O + g * k,
+		a * E + l * D + p * O + _ * k,
+		n * A + o * j + u * M + m * N,
+		r * A + s * j + d * M + h * N,
+		i * A + c * j + f * M + g * N,
+		a * A + l * j + p * M + _ * N
+	];
+}
+function Jt(e, t, n) {
+	return [
+		1,
+		0,
+		0,
+		0,
+		0,
+		1,
+		0,
+		0,
+		0,
+		0,
+		1,
+		0,
+		e,
+		t,
+		n,
+		1
+	];
+}
+function Yt(e, t, n) {
+	return [
+		e,
+		0,
+		0,
+		0,
+		0,
+		t,
+		0,
+		0,
+		0,
+		0,
+		n,
+		0,
+		0,
+		0,
+		0,
+		1
+	];
+}
+function Xt(e, t, n, r) {
+	let i = Math.hypot(t, n, r) || 1;
+	t /= i, n /= i, r /= i;
+	let a = e * Math.PI / 180, o = Math.cos(a), s = Math.sin(a), c = 1 - o, l = c * t * t + o, u = c * t * n - s * r, d = c * t * r + s * n, f = c * t * n + s * r, p = c * n * n + o, m = c * n * r - s * t;
+	return [
+		l,
+		f,
+		c * t * r - s * n,
+		0,
+		u,
+		p,
+		c * n * r + s * t,
+		0,
+		d,
+		m,
+		c * r * r + o,
+		0,
+		0,
+		0,
+		0,
+		1
+	];
+}
+function Zt(e, t) {
+	return [
+		e[0] - t[0],
+		e[1] - t[1],
+		e[2] - t[2]
+	];
+}
+function Qt(e, t) {
+	return [
+		e[1] * t[2] - e[2] * t[1],
+		e[2] * t[0] - e[0] * t[2],
+		e[0] * t[1] - e[1] * t[0]
+	];
+}
+function $t(e) {
+	let t = Math.hypot(e[0], e[1], e[2]) || 1;
+	return [
+		e[0] / t,
+		e[1] / t,
+		e[2] / t
+	];
+}
+function en(e, t, n) {
+	let r = $t(Zt(t, e)), i = $t(Qt($t(n), r)), a = Qt(r, i);
+	return [
+		i[0],
+		i[1],
+		i[2],
+		0,
+		a[0],
+		a[1],
+		a[2],
+		0,
+		r[0],
+		r[1],
+		r[2],
+		0,
+		e[0],
+		e[1],
+		e[2],
+		1
+	];
+}
+function J(e) {
+	let t = e[0], n = e[1], r = e[2], i = e[3], a = e[4], o = e[5], s = e[6], c = e[7], l = e[8], u = e[9], d = e[10], f = e[11], p = e[12], m = e[13], h = e[14], g = e[15], _ = u * h * c - m * d * c + m * s * f - o * h * f - u * s * g + o * d * g, v = p * d * c - l * h * c - p * s * f + a * h * f + l * s * g - a * d * g, y = l * m * c - p * u * c + p * o * f - a * m * f - l * o * g + a * u * g, b = p * u * s - l * m * s - p * o * d + a * m * d + l * o * h - a * u * h, x = t * _ + n * v + r * y + i * b;
+	if (x === 0) return Gt();
+	let S = 1 / x;
+	return [
+		_ * S,
+		(m * d * i - u * h * i - m * r * f + n * h * f + u * r * g - n * d * g) * S,
+		(o * h * i - m * s * i + m * r * c - n * h * c - o * r * g + n * s * g) * S,
+		(u * s * i - o * d * i - u * r * c + n * d * c + o * r * f - n * s * f) * S,
+		v * S,
+		(l * h * i - p * d * i + p * r * f - t * h * f - l * r * g + t * d * g) * S,
+		(p * s * i - a * h * i - p * r * c + t * h * c + a * r * g - t * s * g) * S,
+		(a * d * i - l * s * i + l * r * c - t * d * c - a * r * f + t * s * f) * S,
+		y * S,
+		(p * u * i - l * m * i - p * n * f + t * m * f + l * n * g - t * u * g) * S,
+		(a * m * i - p * o * i + p * n * c - t * m * c - a * n * g + t * o * g) * S,
+		(l * o * i - a * u * i - l * n * c + t * u * c + a * n * f - t * o * f) * S,
+		b * S,
+		(l * m * r - p * u * r + p * n * d - t * m * d - l * n * h + t * u * h) * S,
+		(p * o * r - a * m * r - p * n * s + t * m * s + a * n * h - t * o * h) * S,
+		(a * u * r - l * o * r + l * n * s - t * u * s - a * n * d + t * o * d) * S
+	];
+}
+//#endregion
+//#region src/Processor/PBRT/PBRTParser.js
+var tn = 8, nn = 1, rn = 2, Y = 3, an = new Set([
+	"Identity",
+	"Transform",
+	"CoordinateSystem",
+	"CoordSysTransform",
+	"ActiveTransform",
+	"TransformTimes",
+	"Camera",
+	"Film",
+	"WorldBegin",
+	"MakeNamedMaterial",
+	"Texture",
+	"MakeNamedMedium",
+	"LightSource",
+	"AreaLightSource",
+	"ObjectBegin",
+	"ObjectEnd",
+	"ObjectInstance"
+]);
+function on(e, t) {
+	if (e === t) return !0;
+	for (let n = 0; n < 16; n++) if (e[n] !== t[n]) return !1;
+	return !0;
+}
+var sn = {
+	integer: Int32Array,
+	point3: Float32Array,
+	point2: Float32Array,
+	vector3: Float32Array,
+	vector2: Float32Array,
+	vector: Float32Array,
+	normal: Float32Array,
+	rgb: Float32Array
+}, cn = class {
+	constructor(e = {}) {
+		this.releaseInclude = e.releaseInclude || null, this.resolveInclude = e.resolveInclude || (() => {
+			throw Error("PBRTParser: Include used but no resolveInclude provided");
+		}), this.maxPlacements = e.maxPlacements ?? Infinity, this.instanceIncludes = e.instanceIncludes !== !1, this._includes = /* @__PURE__ */ new Map(), this._stateIds = /* @__PURE__ */ new WeakMap(), this._nextStateId = 1, this._effects = 0, this._movedShapes = !1, this.ir = {
+			film: null,
+			camera: null,
+			namedMaterials: /* @__PURE__ */ new Map(),
+			namedTextures: /* @__PURE__ */ new Map(),
+			shapes: [],
+			lights: [],
+			instances: /* @__PURE__ */ new Map(),
+			instanceCount: 0,
+			skippedInstances: 0,
+			objects: /* @__PURE__ */ new Map(),
+			media: /* @__PURE__ */ new Map(),
+			transformTimes: {
+				start: 0,
+				end: 1
+			},
+			hasMotion: !1,
+			warnings: []
+		}, this.ctm = Gt(), this.ctmEnd = null, this.activeTransform = Y, this._ctmSource = null, this._ctmValue = null, this.state = {
+			material: null,
+			areaLight: null,
+			reverseOrientation: !1,
+			interior: null
+		}, this.attributeStack = [], this.transformStack = [], this.coordSystems = /* @__PURE__ */ new Map(), this.currentObject = null, this.dirStack = [""], this.stream = null, this._warnedUnknown = /* @__PURE__ */ new Set();
+	}
+	async parse(e, t = "") {
+		this.dirStack = [t], await this._run(new Wt(e)), this._movedShapes && (this.ir.shapes = this.ir.shapes.filter(Boolean));
+		for (let e of this.ir.instances.values()) e.matrices = U(e.matrices, e.count * 16), e.matricesEnd &&= U(e.matricesEnd, e.count * 16);
+		return this.ir;
+	}
+	_addInstance(e, t = this.ctm) {
+		if (this.ir.instanceCount >= this.maxPlacements) {
+			this.ir.skippedInstances++;
+			return;
+		}
+		let n = this.ir.instances.get(e);
+		n || this.ir.instances.set(e, n = {
+			name: e,
+			count: 0,
+			matrices: new Float32Array(512),
+			matricesEnd: null
+		});
+		let r = (n.count + 1) * 16;
+		if (r > n.matrices.length) {
+			let e = Math.max(r, n.matrices.length * 2);
+			n.matrices = U(n.matrices, e), n.matricesEnd &&= U(n.matricesEnd, e);
+		}
+		let i = n.count * 16;
+		for (let e = 0; e < 16; e++) n.matrices[i + e] = t[e];
+		let a = this._ctmEndSnapshot();
+		if (a && !n.matricesEnd && (n.matricesEnd = n.matrices.slice()), n.matricesEnd) {
+			let e = a || t;
+			for (let t = 0; t < 16; t++) n.matricesEnd[i + t] = e[t];
+		}
+		n.count++, this.ir.instanceCount++;
+	}
+	_ctmSnapshot() {
+		return this._ctmSource !== this.ctm && (this._ctmSource = this.ctm, this._ctmValue = this.ctm.slice()), this._ctmValue;
+	}
+	_ctmEndSnapshot() {
+		return this.ctmEnd === null || on(this.ctmEnd, this.ctm) ? null : (this.ir.hasMotion = !0, this.ctmEnd.slice());
+	}
+	_concat(e) {
+		if (this.activeTransform === Y && this.ctmEnd === null) {
+			this.ctm = q(this.ctm, e);
+			return;
+		}
+		let t = this.ctmEnd ?? this.ctm;
+		this.ctmEnd = this.activeTransform & rn ? q(t, e) : t, this.activeTransform & nn && (this.ctm = q(this.ctm, e));
+	}
+	_setCTM(e) {
+		if (this.activeTransform === Y) {
+			this.ctm = e, this.ctmEnd = null;
+			return;
+		}
+		let t = this.ctmEnd ?? this.ctm;
+		this.ctmEnd = this.activeTransform & rn ? e : t, this.activeTransform & nn && (this.ctm = e);
+	}
+	_pushGraphicsState() {
+		this.attributeStack.push({
+			ctm: this.ctm,
+			ctmEnd: this.ctmEnd,
+			activeTransform: this.activeTransform,
+			material: this.state.material,
+			areaLight: this.state.areaLight,
+			reverseOrientation: this.state.reverseOrientation,
+			interior: this.state.interior
+		});
+	}
+	_popGraphicsState() {
+		let e = this.attributeStack.pop();
+		e && (this.ctm = e.ctm, this.ctmEnd = e.ctmEnd, this.activeTransform = e.activeTransform, this.state = {
+			material: e.material,
+			areaLight: e.areaLight,
+			reverseOrientation: e.reverseOrientation,
+			interior: e.interior
+		});
+	}
+	_peek() {
+		return this.stream.peek();
+	}
+	_next() {
+		return this.stream.next();
+	}
+	_expectNumber(e) {
+		let t = this._next();
+		if (!t || t.type !== W.NUMBER) throw Error(`PBRT parser: expected number for ${e}, got ${t ? t.value : "EOF"}`);
+		return t.value;
+	}
+	_expectString(e) {
+		let t = this._next();
+		if (!t || t.type !== W.STRING) throw Error(`PBRT parser: expected string for ${e}, got ${t ? t.value : "EOF"}`);
+		return t.value;
+	}
+	_readNumbers(e) {
+		let t = [];
+		for (let n = 0; n < e; n++) t.push(this._expectNumber("matrix/transform"));
+		return t;
+	}
+	_readBracketedOrBareNumbers(e) {
+		if (this._peek() && this._peek().type === W.LBRACKET) {
+			this._next();
+			let e = [];
+			for (; this._peek() && this._peek().type !== W.RBRACKET;) e.push(this._expectNumber("transform element"));
+			return this._next(), e;
+		}
+		return this._readNumbers(e);
+	}
+	_parseParams() {
+		let e = {};
+		for (; this._peek() && this._peek().type === W.STRING;) {
+			let t = this._next().value.trim().split(/\s+/), n = t[0], r = t[1] === void 0 ? t[0] : t[1];
+			e[r] = {
+				type: n,
+				value: this._parseParamValue(n)
+			};
+		}
+		return e;
+	}
+	_parseParamValue(e) {
+		let t = this._peek() && this._peek().type === W.LBRACKET;
+		t && this._next();
+		let n = () => {
+			let e = this._peek();
+			return t ? e && e.type !== W.RBRACKET : !1;
+		};
+		if (!t) return [this._coerceValueToken(this._next())];
+		if (this._peek() && this._peek().type === W.NUMBER) {
+			let t = [];
+			for (; n() && t.length < tn;) {
+				let e = this._next();
+				if (e.type !== W.NUMBER) return this._finishMixedValue(t, t.length, e);
+				t.push(e.value);
+			}
+			if (!n()) return this._next(), t;
+			let r = new (sn[e] || Float64Array)(tn * 4);
+			r.set(t);
+			let i = t.length;
+			for (; n();) {
+				let e = this._next();
+				if (e.type !== W.NUMBER) return this._finishMixedValue(r, i, e);
+				i === r.length && (r = U(r, r.length * 2)), r[i++] = e.value;
+			}
+			return this._next(), i === r.length ? r : U(r, i);
+		}
+		let r = [];
+		for (; n();) r.push(this._coerceValueToken(this._next()));
+		return this._next(), r;
+	}
+	_finishMixedValue(e, t, n) {
+		let r = [];
+		for (let n = 0; n < t; n++) r.push(e[n]);
+		for (r.push(this._coerceValueToken(n)); this._peek() && this._peek().type !== W.RBRACKET;) r.push(this._coerceValueToken(this._next()));
+		return this._next(), r;
+	}
+	_coerceValueToken(e) {
+		if (!e) throw Error("PBRT parser: unexpected EOF in parameter value");
+		if (e.type === W.NUMBER || e.type === W.STRING) return e.value;
+		if (e.type === W.WORD) return e.value === "true" ? !0 : e.value === "false" ? !1 : e.value;
+		throw Error(`PBRT parser: unexpected token in parameter value: ${e.type}`);
+	}
+	async _run(e) {
+		let t = this.stream;
+		this.stream = e;
+		for (let e = this._next(); e !== null; e = this._next()) {
+			if (e.type !== W.WORD) throw Error(`PBRT parser: expected directive, got ${e.type} ${e.value ?? ""}`);
+			an.has(e.value) && this._effects++;
+			let t = this._directive(e.value);
+			t !== void 0 && await t;
+		}
+		this.stream = t;
+	}
+	_directive(e) {
+		switch (e) {
+			case "Identity":
+				this._setCTM(Gt());
+				break;
+			case "Translate": {
+				let [e, t, n] = this._readNumbers(3);
+				this._concat(Jt(e, t, n));
+				break;
+			}
+			case "Scale": {
+				let [e, t, n] = this._readNumbers(3);
+				this._concat(Yt(e, t, n));
+				break;
+			}
+			case "Rotate": {
+				let [e, t, n, r] = this._readNumbers(4);
+				this._concat(Xt(e, t, n, r));
+				break;
+			}
+			case "LookAt": {
+				let e = this._readNumbers(9), t = en([
+					e[0],
+					e[1],
+					e[2]
+				], [
+					e[3],
+					e[4],
+					e[5]
+				], [
+					e[6],
+					e[7],
+					e[8]
+				]);
+				this._concat(J(t));
+				break;
+			}
+			case "Transform":
+				this._setCTM(this._readBracketedOrBareNumbers(16));
+				break;
+			case "ConcatTransform":
+				this._concat(this._readBracketedOrBareNumbers(16));
+				break;
+			case "CoordinateSystem":
+				this.coordSystems.set(this._expectString("CoordinateSystem"), {
+					ctm: this.ctm,
+					ctmEnd: this.ctmEnd
+				});
+				break;
+			case "CoordSysTransform": {
+				let e = this.coordSystems.get(this._expectString("CoordSysTransform"));
+				e && (this.ctm = e.ctm, this.ctmEnd = e.ctmEnd);
+				break;
+			}
+			case "Camera": {
+				let e = this._expectString("Camera type"), t = this._parseParams();
+				this.ir.camera = {
+					type: e,
+					params: t,
+					cameraToWorld: J(this.ctm)
+				};
+				let n = this._ctmEndSnapshot();
+				n && (this.ir.camera.cameraToWorldEnd = J(n));
+				break;
+			}
+			case "Film": {
+				this._expectString("Film type");
+				let e = this._parseParams();
+				this.ir.film = {
+					xresolution: this._num(e.xresolution, 1280),
+					yresolution: this._num(e.yresolution, 720),
+					filename: this._str(e.filename, null)
+				};
+				break;
+			}
+			case "Integrator":
+			case "Sampler":
+			case "PixelFilter":
+			case "Filter":
+			case "Accelerator":
+			case "ColorSpace":
+			case "Option":
+				this._skipTypeAndParams();
+				break;
+			case "WorldBegin":
+				this.ctm = Gt(), this.ctmEnd = null, this.activeTransform = Y, this.state = {
+					material: null,
+					areaLight: null,
+					reverseOrientation: !1,
+					interior: null
+				};
+				break;
+			case "WorldEnd": break;
+			case "AttributeBegin":
+				this._pushGraphicsState();
+				break;
+			case "AttributeEnd":
+				this._popGraphicsState();
+				break;
+			case "TransformBegin":
+				this.transformStack.push({
+					ctm: this.ctm,
+					ctmEnd: this.ctmEnd,
+					activeTransform: this.activeTransform
+				});
+				break;
+			case "TransformEnd": {
+				let e = this.transformStack.pop();
+				e && (this.ctm = e.ctm, this.ctmEnd = e.ctmEnd, this.activeTransform = e.activeTransform);
+				break;
+			}
+			case "ReverseOrientation":
+				this.state.reverseOrientation = !this.state.reverseOrientation;
+				break;
+			case "Attribute":
+				this._expectString("Attribute target"), this._parseParams();
+				break;
+			case "ActiveTransform": {
+				let e = this._next()?.value;
+				e === "StartTime" ? this.activeTransform = nn : e === "EndTime" ? this.activeTransform = rn : e === "All" ? this.activeTransform = Y : this._warn(`ActiveTransform "${e}" not recognised`);
+				break;
+			}
+			case "TransformTimes": {
+				let [e, t] = this._readNumbers(2);
+				this.ir.transformTimes = {
+					start: e,
+					end: t
+				};
+				break;
+			}
+			case "MediumInterface": {
+				let e = this._peek()?.type === W.STRING ? this._next().value : "";
+				this._peek()?.type === W.STRING && this._next(), this.state.interior = e || null;
+				break;
+			}
+			case "MakeNamedMedium": {
+				let e = this._expectString("MakeNamedMedium name");
+				this.ir.media.set(e, this._parseParams());
+				break;
+			}
+			case "Material": {
+				let e = this._expectString("Material type"), t = this._parseParams();
+				this.state.material = {
+					type: e,
+					params: t
+				};
+				break;
+			}
+			case "MakeNamedMaterial": {
+				let e = this._expectString("MakeNamedMaterial name"), t = this._parseParams(), n = this._str(t.type, "diffuse");
+				this.ir.namedMaterials.set(e, {
+					type: n,
+					params: t
+				});
+				break;
+			}
+			case "NamedMaterial": {
+				let e = this._expectString("NamedMaterial name"), t = this.ir.namedMaterials.get(e);
+				this.state.material = t || {
+					type: "diffuse",
+					params: {},
+					_missingRef: e
+				}, t || this._warn(`NamedMaterial "${e}" referenced before definition`);
+				break;
+			}
+			case "Texture": {
+				let e = this._expectString("Texture name"), t = this._expectString("Texture data type"), n = this._expectString("Texture class"), r = this._parseParams();
+				this.ir.namedTextures.set(e, {
+					dataType: t,
+					class: n,
+					params: r
+				});
+				break;
+			}
+			case "AreaLightSource": {
+				let e = this._expectString("AreaLightSource type"), t = this._parseParams();
+				this.state.areaLight = {
+					type: e,
+					params: t
+				};
+				break;
+			}
+			case "LightSource": {
+				let e = this._expectString("LightSource type"), t = this._parseParams();
+				this.ctmEnd !== null && !on(this.ctmEnd, this.ctm) && this._warnOnce("animated-light", "animated LightSource transforms are not supported — using the start transform"), this.ir.lights.push({
+					type: e,
+					params: t,
+					ctm: this._ctmSnapshot()
+				});
+				break;
+			}
+			case "Shape": {
+				let e = this._expectString("Shape type"), t = this._parseParams(), n = t.alpha;
+				if (n?.type === "float" && n.value[0] <= 0) break;
+				n && !(n.type === "float" && n.value[0] >= 1) && this._warnOnce("alpha", "shape \"alpha\" between 0 and 1, or as a texture, is not supported — drawn opaque");
+				let r = {
+					type: e,
+					params: t,
+					ctm: this._ctmSnapshot(),
+					material: this.state.material,
+					areaLight: this.state.areaLight,
+					reverseOrientation: this.state.reverseOrientation,
+					interior: this.state.interior
+				}, i = this.currentObject === null ? this._ctmEndSnapshot() : null;
+				i ? r.ctmEnd = i : this.currentObject !== null && this.ctmEnd !== null && !on(this.ctmEnd, this.ctm) && this._warnOnce("animated-template", "animated transforms inside ObjectBegin are not supported — using the start transform"), this._emitShape(r);
+				break;
+			}
+			case "ObjectBegin": {
+				let e = this._expectString("ObjectBegin name");
+				this._pushGraphicsState(), this.currentObject = e, this.ir.objects.has(e) || this.ir.objects.set(e, []);
+				break;
+			}
+			case "ObjectEnd":
+				this.currentObject = null, this._popGraphicsState();
+				break;
+			case "ObjectInstance": {
+				let e = this._expectString("ObjectInstance name");
+				this._addInstance(e);
+				break;
+			}
+			case "Include":
+			case "Import": {
+				let t = this._expectString(e);
+				return this._include(t);
+			}
+			default:
+				this._warnUnknown(e), this._parseParams();
+				break;
+		}
+	}
+	_emitShape(e) {
+		this.currentObject === null ? this.ir.shapes.push(e) : this.ir.objects.get(this.currentObject).push(e);
+	}
+	async _include(e) {
+		let t = this.dirStack[this.dirStack.length - 1], n = this._includeKey(e, t);
+		if (n !== null && this._placeRepeat(n, e)) return;
+		let r = await this.resolveInclude(e, t);
+		if (r == null) {
+			this._warn(`Include target not found: ${e}`);
+			return;
+		}
+		let i = n === null ? null : this._includeState(), a = e.includes("/") ? e.slice(0, e.lastIndexOf("/")) : "";
+		this.dirStack.push(a);
+		try {
+			await this._run(new Wt(r));
+		} finally {
+			this.dirStack.pop(), this.releaseInclude?.(e, t, r);
+		}
+		i && this._sameIncludeState(i) && !this._includes.has(n) && this._includes.set(n, {
+			start: i.shapes,
+			end: this.ir.shapes.length,
+			ctm: i.ctm.slice(),
+			template: null
+		});
+	}
+	_includeKey(e, t) {
+		return !this.instanceIncludes || this.currentObject !== null || this.ctmEnd !== null || this.activeTransform !== Y || this.state.areaLight ? null : `${t}\0${e}\0${this._stateId(this.state.material)}\0${this.state.reverseOrientation}\0${this.state.interior}`;
+	}
+	_stateId(e) {
+		if (!e) return 0;
+		let t = this._stateIds.get(e);
+		return t === void 0 && this._stateIds.set(e, t = this._nextStateId++), t;
+	}
+	_includeState() {
+		return {
+			shapes: this.ir.shapes.length,
+			effects: this._effects,
+			ctm: this.ctm,
+			attributes: this.attributeStack.length,
+			transforms: this.transformStack.length,
+			material: this.state.material,
+			reverseOrientation: this.state.reverseOrientation,
+			interior: this.state.interior
+		};
+	}
+	_sameIncludeState(e) {
+		return this._effects === e.effects && this.ctmEnd === null && this.activeTransform === Y && on(this.ctm, e.ctm) && this.attributeStack.length === e.attributes && this.transformStack.length === e.transforms && this.state.material === e.material && this.state.areaLight === null && this.state.reverseOrientation === e.reverseOrientation && this.state.interior === e.interior;
+	}
+	_placeRepeat(e, t) {
+		let n = this._includes.get(e);
+		if (!n) return !1;
+		if (n.template === null) {
+			let { start: r, end: i } = n;
+			if (i === r || this.ir.instanceCount + 2 > this.maxPlacements) return !1;
+			for (let t = r; t < i; t++) if (!this.ir.shapes[t]) return this._includes.delete(e), !1;
+			let a = `${t}#${this.ir.objects.size}`, o = J(n.ctm), s = [], c = null, l = null;
+			for (let e = r; e < i; e++) {
+				let t = this.ir.shapes[e];
+				t.ctm !== c && (l = q(o, c = t.ctm)), t.relativeCTM = l, s.push(t), this.ir.shapes[e] = null;
+			}
+			this.ir.objects.set(a, s), this._addInstance(a, n.ctm), n.template = a, this._movedShapes = !0;
+		}
+		return this._addInstance(n.template), !0;
+	}
+	_skipTypeAndParams() {
+		this._peek() && this._peek().type === W.STRING && this._next(), this._parseParams();
+	}
+	_skipNamedAndParams() {
+		this._peek() && this._peek().type === W.STRING && this._next(), this._parseParams();
+	}
+	_num(e, t) {
+		return e && e.value.length ? e.value[0] : t;
+	}
+	_str(e, t) {
+		return e && e.value.length ? e.value[0] : t;
+	}
+	_warn(e) {
+		this.ir.warnings.push(e);
+	}
+	_warnOnce(e, t) {
+		this._warnedUnknown.has(e) || (this._warnedUnknown.add(e), this._warn(t));
+	}
+	_warnUnknown(e) {
+		this._warnedUnknown.has(e) || (this._warnedUnknown.add(e), this._warn(`Unsupported directive ignored: ${e}`));
+	}
+}, ln = {
+	au: [
+		1,
+		.78,
+		.34
+	],
+	gold: [
+		1,
+		.78,
+		.34
+	],
+	cu: [
+		.95,
+		.64,
+		.54
+	],
+	copper: [
+		.95,
+		.64,
+		.54
+	],
+	ag: [
+		.97,
+		.96,
+		.91
+	],
+	silver: [
+		.97,
+		.96,
+		.91
+	],
+	al: [
+		.91,
+		.92,
+		.92
+	],
+	aluminium: [
+		.91,
+		.92,
+		.92
+	],
+	aluminum: [
+		.91,
+		.92,
+		.92
+	],
+	mgo: [
+		.9,
+		.9,
+		.9
+	],
+	tio2: [
+		.9,
+		.9,
+		.9
+	]
+}, un = [
+	.92,
+	.92,
+	.92
+];
+function dn(e) {
+	let t = Math.max(1e3, Math.min(4e4, e)) / 100, n, r, i;
+	t <= 66 ? (n = 255, r = 99.47 * Math.log(t) - 161.12) : (n = 329.7 * (t - 60) ** -.1332, r = 288.12 * (t - 60) ** -.0755), i = t >= 66 ? 255 : t <= 19 ? 0 : 138.52 * Math.log(t - 10) - 305.04;
+	let a = (e) => Math.max(0, Math.min(255, e)) / 255;
+	return [
+		a(n) ** 2.2,
+		a(r) ** 2.2,
+		a(i) ** 2.2
+	];
+}
+function X(e, t, n) {
+	let r = e[t];
+	return r && typeof r.value[0] == "number" ? r.value[0] : n;
+}
+function Z(e, t, n) {
+	let r = e[t];
+	return r && typeof r.value[0] == "string" ? r.value[0] : n;
+}
+function fn(e, t, n) {
+	let r = e[t]?.value?.[0];
+	return r === void 0 ? n : r === !0 || r === "true";
+}
+async function Q(e, t, n, r = null) {
+	let i = e[t];
+	if (!i) return {
+		rgb: r,
+		texture: null
+	};
+	if (i.type === "texture") {
+		let e = i.value[0], t = await n.resolveNamedTexture(e);
+		return t && t.texture ? {
+			rgb: t.constant ?? null,
+			texture: t.texture
+		} : t && t.constant ? {
+			rgb: t.constant,
+			texture: null
+		} : (n.warn(`texture "${e}" could not be resolved`), {
+			rgb: r,
+			texture: null
+		});
+	}
+	if (i.type === "rgb" || i.type === "color") return {
+		rgb: [
+			i.value[0],
+			i.value[1],
+			i.value[2]
+		],
+		texture: null
+	};
+	if (i.type === "float") {
+		let e = i.value[0];
+		return {
+			rgb: [
+				e,
+				e,
+				e
+			],
+			texture: null
+		};
+	}
+	if (i.type === "blackbody") return {
+		rgb: dn(i.value[0]),
+		texture: null
+	};
+	if (i.type === "spectrum") {
+		if (typeof i.value[0] == "string") {
+			let e = pn(i.value[0]);
+			return e && ln[e] ? {
+				rgb: ln[e].slice(),
+				texture: null
+			} : (n.warn(`named spectrum "${i.value[0]}" approximated to gray`), {
+				rgb: [
+					.5,
+					.5,
+					.5
+				],
+				texture: null
+			});
+		}
+		let e = 0, t = 0;
+		for (let n = 1; n < i.value.length; n += 2) e += i.value[n], t++;
+		let r = t ? e / t : .5;
+		return {
+			rgb: [
+				r,
+				r,
+				r
+			],
+			texture: null
+		};
+	}
+	return {
+		rgb: r,
+		texture: null
+	};
+}
+function pn(e) {
+	let t = e.toLowerCase().match(/metal-([a-z]+)/);
+	if (t) return t[1];
+	for (let t of Object.keys(ln)) if (e.toLowerCase().includes(t)) return t;
+	return null;
+}
+async function mn(e, t, n) {
+	let r = e[t];
+	return r ? typeof r.value[0] == "number" ? r.value[0] : r.type === "texture" ? await n.floatTextureMean?.(r.value[0]) ?? null : null : null;
+}
+async function hn(e, t, n, r = "") {
+	let i = e.remaproughness?.value?.[0], a = (e) => i === !1 || i === "false" ? e : Math.sqrt(Math.max(e, 0)), o = null, s = await mn(e, `${r}roughness`, n);
+	if (s !== null) o = a(s);
+	else {
+		let t = await mn(e, `${r}uroughness`, n), i = await mn(e, `${r}vroughness`, n);
+		t !== null && (o = i === null ? a(t) : (a(t) + a(i)) / 2);
+	}
+	return o === null ? t : Math.sqrt(Math.max(o, 0));
+}
+async function gn(e, t, n, r, i, a) {
+	let o = await Q(t, "reflectance", n, null), s = t[`${r}eta`], c = t[`${r}k`], l = s && s.type === "spectrum" && typeof s.value[0] == "string";
+	if (o.rgb || o.texture) i(o);
+	else if (s && c && !l) {
+		let e = (await Q(t, `${r}eta`, n, [
+			.2,
+			.92,
+			1.1
+		])).rgb, i = (await Q(t, `${r}k`, n, [
+			3.9,
+			2.45,
+			2.14
+		])).rgb, o = (e, t) => ((e - 1) ** 2 + t ** 2) / ((e + 1) ** 2 + t ** 2);
+		a([
+			o(e[0], i[0]),
+			o(e[1], i[1]),
+			o(e[2], i[2])
+		]);
+	} else a(s ? (await Q(t, `${r}eta`, n, un)).rgb || un : ln.cu);
+	e.metalness = 1;
+}
+async function _n(e, t) {
+	let n = e?.type || "diffuse", r = e?.params || {}, i = new te({
+		side: S,
+		roughness: 1,
+		metalness: 0
+	}), a = (e) => {
+		e && i.color.setRGB(e[0], e[1], e[2]);
+	}, o = (e) => {
+		a(e.rgb), e.texture && (i.map = e.texture, e.rgb || i.color.setRGB(1, 1, 1));
+	};
+	switch (n) {
+		case "diffuse":
+			o(await Q(r, "reflectance", t, [
+				.5,
+				.5,
+				.5
+			])), i.roughness = 1, i.metalness = 0, i.specularIntensity = 0;
+			break;
+		case "conductor":
+		case "metal":
+			await gn(i, r, t, "", o, a), i.roughness = await hn(r, .1, t);
+			break;
+		case "coatedconductor":
+			await gn(i, r, t, "conductor.", o, a), i.roughness = await hn(r, 0, t, "conductor."), i.clearcoat = 1, i.clearcoatRoughness = await hn(r, 0, t, "interface.");
+			break;
+		case "dielectric":
+		case "thindielectric":
+			i.transmission = 1, i.metalness = 0, i.color.setRGB(1, 1, 1), i.ior = X(r, "eta", 1.5), i.roughness = await hn(r, 0, t), i.thickness = n === "thindielectric" ? 0 : X(r, "thickness", 0);
+			break;
+		case "coateddiffuse":
+			o(await Q(r, "reflectance", t, [
+				.5,
+				.5,
+				.5
+			])), i.roughness = .6, i.metalness = 0, i.clearcoat = 1, i.clearcoatRoughness = await hn(r, 0, t);
+			break;
+		case "diffusetransmission": {
+			let e = X(r, "scale", 1), n = (t) => Math.min(1, Math.max(0, e * t)), a = await Q(r, "transmittance", t, [
+				.25,
+				.25,
+				.25
+			]), s = a.rgb ? a.rgb.map(n) : [
+				.5,
+				.5,
+				.5
+			], c = Math.min(.99, Math.max(...s)), l = await Q(r, "reflectance", t, [
+				.25,
+				.25,
+				.25
+			]), u = (e) => Math.min(1, n(e) / (1 - c));
+			o({
+				texture: l.texture,
+				rgb: l.rgb ? l.rgb.map(u) : l.texture ? [
+					1,
+					1,
+					1
+				].map(u) : null
+			}), a.texture && t.warn("diffusetransmission: a textured \"transmittance\" is not supported — using 0.5"), i.diffuseTransmission = c, i.diffuseTransmissionColor = new y().setRGB(...s.map((e) => c > 0 ? Math.min(1, e / c) : 1)), i.roughness = 1, i.metalness = 0, i.specularIntensity = 0;
+			break;
+		}
+		case "interface":
+		case "none":
+		case "":
+			i.transmission = 1, i.ior = 1, i.roughness = 0, i.color.setRGB(1, 1, 1);
+			break;
+		case "mix": {
+			let e = r.materials?.value || [], n = Math.max(0, Math.min(1, X(r, "amount", .5))), a = e[0] ? t.namedMaterials?.get(e[0]) : null, o = e[1] ? t.namedMaterials?.get(e[1]) : null;
+			if (a && o) {
+				let [e, s] = await Promise.all([_n(a, t), _n(o, t)]), c = r.amount, l = c?.type === "texture" ? await t.bakeMaterialMix?.(e, s, c.value[0]) : null;
+				l && (n = l.mean);
+				let u = (e, t) => e * (1 - n) + t * n;
+				i.color.lerpColors(e.color, s.color, n), i.roughness = u(e.roughness, s.roughness), i.metalness = u(e.metalness, s.metalness), i.ior = u(e.ior ?? 1.5, s.ior ?? 1.5), i.transmission = u(e.transmission ?? 0, s.transmission ?? 0), i.thickness = u(e.thickness ?? 0, s.thickness ?? 0), i.clearcoat = u(e.clearcoat ?? 0, s.clearcoat ?? 0), i.clearcoatRoughness = u(e.clearcoatRoughness ?? 0, s.clearcoatRoughness ?? 0), i.emissive.lerpColors(e.emissive, s.emissive, n);
+				let d = e.diffuseTransmission ?? 0, f = s.diffuseTransmission ?? 0;
+				(d > 0 || f > 0) && (i.diffuseTransmission = u(d, f), i.diffuseTransmissionColor = new y().lerpColors(e.diffuseTransmissionColor ?? new y(1, 1, 1), s.diffuseTransmissionColor ?? new y(1, 1, 1), n)), i.emissiveIntensity = u(e.emissiveIntensity ?? 0, s.emissiveIntensity ?? 0), i.map = (n < .5 ? e.map : s.map) || null, i.normalMap = (n < .5 ? e.normalMap : s.normalMap) || null, l?.texture && (i.map = l.texture, i.color.setRGB(1, 1, 1));
+				break;
+			}
+			t.warn(`material "mix" — could not resolve inner materials [${e.join(", ")}], falling back to diffuse`), i.color.set(new y(.6, .6, .6));
+			break;
+		}
+		case "subsurface":
+		case "hair":
+		case "measured":
+			t.warn(`material "${n}" not supported — using diffuse approximation`), a((await Q(r, "reflectance", t, [
+				.5,
+				.5,
+				.5
+			])).rgb), i.roughness = 1;
+			break;
+		default:
+			t.warn(`unknown material "${n}" — using neutral diffuse`), i.color.set(new y(.6, .6, .6));
+			break;
+	}
+	let s = Z(r, "normalmap", null);
+	return s && t.resolveNormalMap && (i.normalMap = await t.resolveNormalMap(s)), i.roughness = Math.max(0, Math.min(1, i.roughness)), i;
+}
+//#endregion
+//#region src/Processor/PBRT/PBRTTextureBake.js
+var vn = 4096, yn = (e) => e <= .04045 ? e / 12.92 : ((e + .055) / 1.055) ** 2.4, bn = (e) => e <= .0031308 ? e * 12.92 : 1.055 * e ** (1 / 2.4) - .055;
+function xn(e, { channels: t, decode: n = null, scale: r = 1, invert: i = !1, mapping: a = null }) {
+	let { width: o, height: s } = e, c = e.channels ?? 4, l = new Float32Array(o * s * t), u = e.topDown !== !1;
+	for (let a = 0; a < s; a++) {
+		let d = u ? a : s - 1 - a;
+		for (let s = 0; s < o; s++) {
+			let u = (d * o + s) * c, f = (a * o + s) * t;
+			for (let a = 0; a < t; a++) {
+				let t = e.data[u + Math.min(a, c - 1)], o = r * (n ? n(t / 255) : t);
+				l[f + a] = i ? Math.max(0, 1 - o) : o;
+			}
+		}
+	}
+	return {
+		width: o,
+		height: s,
+		channels: t,
+		data: l,
+		su: 1,
+		sv: 1,
+		du: 0,
+		dv: 0,
+		...a
+	};
+}
+function Sn(e) {
+	let t = 0;
+	for (let n = 0; n < e.data.length; n++) t += e.data[n];
+	return e.data.length ? t / e.data.length : 0;
+}
+function Cn(e, t, n, r) {
+	let { width: i, height: a, channels: o, data: s } = e, c = t * i - .5, l = (1 - n) * a - .5, u = Math.floor(c), d = Math.floor(l), f = c - u, p = l - d, m = (e, t) => (e % t + t) % t, h = m(u, i), g = m(u + 1, i), _ = m(d, a), v = m(d + 1, a);
+	for (let e = 0; e < 3; e++) {
+		let t = Math.min(e, o - 1), n = s[(_ * i + h) * o + t] * (1 - f) + s[(_ * i + g) * o + t] * f, a = s[(v * i + h) * o + t] * (1 - f) + s[(v * i + g) * o + t] * f;
+		r[e] = n * (1 - p) + a * p;
+	}
+	return r;
+}
+function wn(e, t) {
+	let n = null;
+	for (let t of e) t.layer && (!n || t.layer.width * t.layer.height > n.width * n.height) && (n = t.layer);
+	if (!n) return null;
+	let r = Math.min(n.width, vn), i = Math.min(n.height, vn), a = new Uint8Array(r * i * 4), o = e.map(() => [
+		0,
+		0,
+		0
+	]);
+	for (let s = 0; s < i; s++) {
+		let c = (s + .5) / i, l = (c - n.dv) / n.sv;
+		for (let i = 0; i < r; i++) {
+			let u = (i + .5) / r, d = (u - n.du) / n.su;
+			for (let t = 0; t < e.length; t++) {
+				let r = e[t], i = o[t];
+				if (r.layer) {
+					let e = r.layer;
+					if (Cn(e, e === n ? u : e.su * d + e.du, e === n ? c : e.sv * l + e.dv, i), r.tint) for (let e = 0; e < 3; e++) i[e] *= r.tint[e];
+				} else i[0] = r.rgb[0], i[1] = r.rgb[1], i[2] = r.rgb[2];
+				if (r.clamp) for (let e = 0; e < 3; e++) i[e] = Math.min(1, Math.max(0, i[e]));
+			}
+			let f = t(o), p = (s * r + i) * 4;
+			for (let e = 0; e < 3; e++) a[p + e] = Math.round(255 * bn(Math.min(1, Math.max(0, f[e]))));
+			a[p + 3] = 255;
+		}
+	}
+	return {
+		data: a,
+		width: r,
+		height: i,
+		mapping: {
+			su: n.su,
+			sv: n.sv,
+			du: n.du,
+			dv: n.dv
+		}
+	};
+}
+var Tn = ([e, t, n]) => {
+	let r = n[0];
+	return [
+		e[0] + (t[0] - e[0]) * r,
+		e[1] + (t[1] - e[1]) * r,
+		e[2] + (t[2] - e[2]) * r
+	];
+};
+//#endregion
+//#region src/Processor/PBRT/LoopSubdivision.js
+function En(e) {
+	return e === 3 ? 3 / 16 : 3 / (8 * e);
+}
+function Dn(e) {
+	return 1 / (e + 3 / (8 * En(e)));
+}
+function On(e, t) {
+	let n = /* @__PURE__ */ new Map(), r = [], i = [], a = [], o = [], s = [], c = t.length / 3;
+	for (let l = 0; l < c; l++) for (let c = 0; c < 3; c++) {
+		let u = t[l * 3 + c], d = t[l * 3 + (c + 1) % 3], f = t[l * 3 + (c + 2) % 3], p = u < d ? u : d, m = u < d ? d : u, h = p * e + m, g = n.get(h);
+		g === void 0 ? (n.set(h, r.length), r.push(p), i.push(m), a.push(f), o.push(-1), s.push(1)) : (o[g] < 0 && (o[g] = f), s[g]++);
+	}
+	let l = Array.from({ length: e }, () => []), u = Array.from({ length: e }, () => []);
+	for (let e = 0; e < r.length; e++) {
+		let t = r[e], n = i[e];
+		l[t].push(n), l[n].push(t), s[e] === 1 && (u[t].push(n), u[n].push(t));
+	}
+	return {
+		edgeIndex: n,
+		edgeV0: r,
+		edgeV1: i,
+		edgeOpp0: a,
+		edgeOpp1: o,
+		edgeFaces: s,
+		ring: l,
+		boundaryRing: u
+	};
+}
+function kn(e, t, n, r, i) {
+	let a = new Float64Array(e.length);
+	for (let o = 0; o < n; o++) {
+		let n = o * 3, s = t.boundaryRing[o];
+		if (s.length === 2) {
+			let t = s[0] * 3, r = s[1] * 3, o = 1 - 2 * i;
+			for (let s = 0; s < 3; s++) a[n + s] = o * e[n + s] + i * (e[t + s] + e[r + s]);
+			continue;
+		}
+		let c = t.ring[o], l = c.length;
+		if (l === 0 || s.length > 0) {
+			for (let t = 0; t < 3; t++) a[n + t] = e[n + t];
+			continue;
+		}
+		let u = r(l), d = 0, f = 0, p = 0;
+		for (let t = 0; t < l; t++) {
+			let n = c[t] * 3;
+			d += e[n], f += e[n + 1], p += e[n + 2];
+		}
+		let m = 1 - l * u;
+		a[n] = m * e[n] + u * d, a[n + 1] = m * e[n + 1] + u * f, a[n + 2] = m * e[n + 2] + u * p;
+	}
+	return a;
+}
+function An(e, t) {
+	let n = e.length / 3, r = On(n, t), i = r.edgeV0.length, a = kn(e, r, n, En, 1 / 8), o = new Float64Array((n + i) * 3);
+	o.set(a);
+	for (let t = 0; t < i; t++) {
+		let i = r.edgeV0[t] * 3, a = r.edgeV1[t] * 3, s = (n + t) * 3, c = r.edgeOpp1[t];
+		if (c < 0) for (let t = 0; t < 3; t++) o[s + t] = .5 * (e[i + t] + e[a + t]);
+		else {
+			let n = r.edgeOpp0[t] * 3, l = c * 3;
+			for (let t = 0; t < 3; t++) o[s + t] = .375 * (e[i + t] + e[a + t]) + .125 * (e[n + t] + e[l + t]);
+		}
+	}
+	let s = t.length / 3, c = new Int32Array(s * 12), l = (e, t) => n + r.edgeIndex.get((e < t ? e : t) * n + (e < t ? t : e));
+	for (let e = 0; e < s; e++) {
+		let n = t[e * 3], r = t[e * 3 + 1], i = t[e * 3 + 2], a = l(n, r), o = l(r, i), s = l(i, n), u = e * 12;
+		c[u] = n, c[u + 1] = a, c[u + 2] = s, c[u + 3] = a, c[u + 4] = r, c[u + 5] = o, c[u + 6] = s, c[u + 7] = o, c[u + 8] = i, c[u + 9] = a, c[u + 10] = o, c[u + 11] = s;
+	}
+	return {
+		positions: o,
+		indices: c
+	};
+}
+function jn(e, t, n, r = 2e6) {
+	let i = Float64Array.from(e), a = Int32Array.from(t), o = 0;
+	for (let e = 0; e < n && !(a.length / 3 * 4 > r); e++) {
+		let e = An(i, a);
+		i = e.positions, a = e.indices, o++;
+	}
+	let s = i.length / 3, c = kn(i, On(s, a), s, Dn, 1 / 5);
+	return {
+		positions: Float32Array.from(c),
+		indices: Uint32Array.from(a),
+		levels: o
+	};
+}
+//#endregion
+//#region src/Processor/PBRT/EqualAreaOctahedral.js
+function Mn(e, t, n) {
+	let r = Math.abs(e), i = Math.abs(t), a = Math.sqrt(Math.max(0, 1 - Math.abs(n))), o = Math.max(r, i), s = o === 0 ? 0 : Math.min(r, i) / o, c = 2 / Math.PI * Math.atan(s);
+	r < i && (c = 1 - c);
+	let l = c * a, u = a - l;
+	if (n < 0) {
+		let e = u;
+		u = 1 - l, l = 1 - e;
+	}
+	return e < 0 && (u = -u), t < 0 && (l = -l), [.5 * (u + 1), .5 * (l + 1)];
+}
+var Nn = (() => {
+	let e = new Float32Array(256);
+	for (let t = 0; t < 256; t++) {
+		let n = t / 255;
+		e[t] = n <= .04045 ? n / 12.92 : ((n + .055) / 1.055) ** 2.4;
+	}
+	return e;
+})();
+function Pn(e, t, n, r, i, a, o, s) {
+	let c = Math.min(Math.max(i * t - .5, 0), t - 1), l = Math.min(Math.max(a * n - .5, 0), n - 1), u = Math.floor(c), d = Math.floor(l), f = Math.min(u + 1, t - 1), p = Math.min(d + 1, n - 1), m = c - u, h = l - d, g = (d * t + u) * r, _ = (d * t + f) * r, v = (p * t + u) * r, y = (p * t + f) * r;
+	for (let t = 0; t < 3; t++) {
+		let n = s ? s[e[g + t]] : e[g + t], r = s ? s[e[_ + t]] : e[_ + t], i = s ? s[e[v + t]] : e[v + t], a = s ? s[e[y + t]] : e[y + t], c = n * (1 - m) + r * m, l = i * (1 - m) + a * m;
+		o[t] = c * (1 - h) + l * h;
+	}
+}
+function Fn(e, t, n = 1, r = 0) {
+	let i = r || Math.min(e.width, 4096), a = Math.max(1, i >> 1), o = new Float32Array(i * a * 4), s = t ? J(t) : null, c = e.srgb ? Nn : null, l = [
+		0,
+		0,
+		0
+	];
+	for (let t = 0; t < a; t++) {
+		let r = (1 - (t + .5) / a) * Math.PI, u = Math.sin(r), d = Math.cos(r);
+		for (let r = 0; r < i; r++) {
+			let a = ((r + .5) / i - .5) * 2 * Math.PI, f = u * Math.cos(a), p = d, m = u * Math.sin(a);
+			if (s) {
+				let e = s, t = e[0] * f + e[4] * p + e[8] * m, n = e[1] * f + e[5] * p + e[9] * m, r = e[2] * f + e[6] * p + e[10] * m, i = Math.hypot(t, n, r) || 1;
+				f = t / i, p = n / i, m = r / i;
+			}
+			let [h, g] = Mn(f, p, m);
+			Pn(e.data, e.width, e.height, e.channels, h, e.bottomUp ? 1 - g : g, l, c);
+			let _ = (t * i + r) * 4;
+			o[_] = l[0] * n, o[_ + 1] = l[1] * n, o[_ + 2] = l[2] * n, o[_ + 3] = 1;
+		}
+	}
+	return {
+		data: o,
+		width: i,
+		height: a
+	};
+}
+//#endregion
+//#region src/Processor/PBRT/PBRTCurves.js
+var In = 2;
+function Ln(e, t) {
+	let n = e * e, r = n * e;
+	t[0] = (1 - 3 * e + 3 * n - r) / 6, t[1] = (4 - 6 * n + 3 * r) / 6, t[2] = (1 + 3 * e + 3 * n - 3 * r) / 6, t[3] = r / 6;
+}
+function Rn(e, t) {
+	let n = 1 - e;
+	t[0] = n * n * n, t[1] = 3 * n * n * e, t[2] = 3 * n * e * e, t[3] = e * e * e;
+}
+function zn(e) {
+	let t = Math.hypot(e[0], e[1], e[2]);
+	return t > 0 && (e[0] /= t, e[1] /= t, e[2] /= t), e;
+}
+function Bn(e, t, n) {
+	return n[0] = e[1] * t[2] - e[2] * t[1], n[1] = e[2] * t[0] - e[0] * t[2], n[2] = e[0] * t[1] - e[1] * t[0], n;
+}
+function Vn(e, t) {
+	let n = e.length / 3;
+	return t === "bspline" ? n - 3 : Math.max(1, (n - 1) / 3);
+}
+function Hn(e, t, n, r, i, a, o) {
+	let s = Math.floor(r);
+	s >= n && (s = n - 1);
+	let c = r - s;
+	t === "bspline" ? Ln(c, i) : Rn(c, i);
+	let l = t === "bspline" ? s : s * 3, u = 0, d = 0, f = 0;
+	for (let t = 0; t < 4; t++) {
+		let n = (l + t) * 3;
+		u += i[t] * e[n], d += i[t] * e[n + 1], f += i[t] * e[n + 2];
+	}
+	a[o] = u, a[o + 1] = d, a[o + 2] = f;
+}
+function Un(e, t, n) {
+	let r = Vn(e, t);
+	if (r < 1) return null;
+	let i = Math.max(1, Math.round(n * r)), a = new Float64Array((i + 1) * 3), o = [
+		0,
+		0,
+		0,
+		0
+	];
+	for (let n = 0; n <= i; n++) Hn(e, t, r, n / i * r, o, a, n * 3);
+	return {
+		points: a,
+		count: i + 1,
+		spans: r
+	};
+}
+function Wn(e, t, n, r, i) {
+	let a = e[t * 3], o = e[t * 3 + 1], s = e[t * 3 + 2], c = n[r * 3], l = n[r * 3 + 1], u = n[r * 3 + 2], d = n[i * 3] - c, f = n[i * 3 + 1] - l, p = n[i * 3 + 2] - u, m = d * d + f * f + p * p, h = m > 0 ? ((a - c) * d + (o - l) * f + (s - u) * p) / m : 0;
+	return h = h < 0 ? 0 : h > 1 ? 1 : h, Math.hypot(a - c - h * d, o - l - h * f, s - u - h * p);
+}
+function Gn(e, t, n, r, i, a) {
+	let { points: o, count: s, spans: c } = n;
+	if (s < 3) return null;
+	let l = new Float64Array((s - 1) * 3), u = [
+		0,
+		0,
+		0,
+		0
+	], d = s - 1;
+	for (let n = 0; n < d; n++) Hn(e, t, c, (n + .5) / d * c, u, l, n * 3);
+	let f = 0;
+	for (let e = 0; e < d; e++) f = Math.max(f, Wn(l, e, o, e, e + 1));
+	let p = (e) => Math.max(f, r * .5 * (i + (a - i) * (e / d))), m = (e, t) => {
+		for (let n = e + 1; n < t; n++) if (Wn(o, n, o, e, t) > p(n)) return !1;
+		for (let n = e; n < t; n++) if (Wn(l, n, o, e, t) > p(n + .5)) return !1;
+		return !0;
+	}, h = new Int32Array(s), g = 0;
+	h[g++] = 0;
+	for (let e = 0; e < d;) {
+		let t = e + 1;
+		for (; t < d && m(e, t + 1);) t++;
+		h[g++] = t, e = t;
+	}
+	return g === s ? null : h.subarray(0, g);
+}
+function Kn(e) {
+	let { P: t, basis: n = "bezier", width0: r = 1, width1: i = 1, N: a = null } = e, o = Math.max(1, Math.round(e.steps ?? In)), s = Math.max(1, Math.round(e.sides ?? 1));
+	if (!t || t.length < 12) return null;
+	let c = Un(t, n, o);
+	if (!c) return null;
+	let { points: l, count: u } = c, d = e.tolerance > 0 ? Gn(t, n, c, e.tolerance, r, i) : null, f = d ? d.length : u, p = s >= 3 ? s : s * 2, m = new Float32Array(f * p * 3), h = [
+		0,
+		0,
+		0
+	], g = [
+		0,
+		0,
+		0
+	], _ = [
+		0,
+		0,
+		0
+	], v = [
+		0,
+		0,
+		0
+	], y = !1, b = 0;
+	for (let e = 0; e < u; e++) {
+		let t = Math.max(0, e - 1), n = Math.min(u - 1, e + 1);
+		if (h[0] = l[n * 3] - l[t * 3], h[1] = l[n * 3 + 1] - l[t * 3 + 1], h[2] = l[n * 3 + 2] - l[t * 3 + 2], zn(h), y) {
+			let e = g[0] * h[0] + g[1] * h[1] + g[2] * h[2];
+			g[0] -= e * h[0], g[1] -= e * h[1], g[2] -= e * h[2], Math.hypot(g[0], g[1], g[2]) < 1e-9 && Bn(h, [
+				0,
+				1,
+				0
+			], g), zn(g);
+		} else {
+			if (a && a.length >= 3) g[0] = a[0], g[1] = a[1], g[2] = a[2], Bn(h, g, v), g[0] = v[0], g[1] = v[1], g[2] = v[2];
+			else {
+				let e = Math.abs(h[0]), t = Math.abs(h[1]), n = Math.abs(h[2]);
+				Bn(h, e < t && e < n ? [
+					1,
+					0,
+					0
+				] : t < n ? [
+					0,
+					1,
+					0
+				] : [
+					0,
+					0,
+					1
+				], g);
+			}
+			Math.hypot(g[0], g[1], g[2]) < 1e-9 && Bn(h, [
+				0,
+				1,
+				0
+			], g), zn(g), y = !0;
+		}
+		if (d && d[b] !== e) continue;
+		Bn(h, g, _), zn(_);
+		let o = e / (u - 1 || 1), c = (r + (i - r) * o) * .5, f = l[e * 3], x = l[e * 3 + 1], S = l[e * 3 + 2];
+		for (let e = 0; e < p; e++) {
+			let t, n, r;
+			if (s >= 3) {
+				let i = e / s * Math.PI * 2, a = Math.cos(i), o = Math.sin(i);
+				t = g[0] * a + _[0] * o, n = g[1] * a + _[1] * o, r = g[2] * a + _[2] * o;
+			} else {
+				let i = e < 2 ? g : _, a = e % 2 == 0 ? -1 : 1;
+				t = i[0] * a, n = i[1] * a, r = i[2] * a;
+			}
+			let i = (b * p + e) * 3;
+			m[i] = f + t * c, m[i + 1] = x + n * c, m[i + 2] = S + r * c;
+		}
+		b++;
+	}
+	let x = s, S = new Uint32Array((f - 1) * x * 6), C = 0;
+	for (let e = 0; e < f - 1; e++) for (let t = 0; t < x; t++) {
+		let n = s >= 3 ? t : t * 2, r = s >= 3 ? (t + 1) % s : t * 2 + 1, i = e * p + n, a = e * p + r, o = (e + 1) * p + r, c = (e + 1) * p + n;
+		S[C++] = i, S[C++] = a, S[C++] = o, S[C++] = i, S[C++] = o, S[C++] = c;
+	}
+	return {
+		positions: m,
+		indices: C === S.length ? S : U(S, C)
+	};
+}
+//#endregion
+//#region src/Processor/PBRT/PBRTSceneBuilder.js
+var qn = new Set([
+	"distant",
+	"point",
+	"spot"
+]);
+async function Jn(e, t, n) {
+	let r = e[t];
+	if (r?.type === "spectrum" && typeof r.value[0] == "string" && r.value[0].startsWith("stdillum")) return [
+		1,
+		1,
+		1
+	];
+	let i = (await Q(e, t, n, [
+		1,
+		1,
+		1
+	])).rgb || [
+		1,
+		1,
+		1
+	];
+	if (!r || r.type === "rgb" || r.type === "color" || r.type === "float") return i;
+	let a = .2126 * i[0] + .7152 * i[1] + .0722 * i[2];
+	return a > 0 ? i.map((e) => e / a) : i;
+}
+var $ = [
+	1,
+	0,
+	0,
+	0,
+	0,
+	1,
+	0,
+	0,
+	0,
+	0,
+	-1,
+	0,
+	0,
+	0,
+	0,
+	1
+], Yn = 4096;
+function Xn(e) {
+	return e instanceof Uint32Array ? new I(e, 1) : ArrayBuffer.isView(e) && e.BYTES_PER_ELEMENT === 4 ? new I(new Uint32Array(e.buffer, e.byteOffset, e.length), 1) : new I(Uint32Array.from(e), 1);
+}
+function Zn(e, t) {
+	if (t <= e.length) return e;
+	let n = e.length || 1;
+	for (; n < t;) n *= 2;
+	return U(e, n);
+}
+function Qn(e) {
+	return e instanceof Float32Array ? e : Float32Array.from(e);
+}
+var $n = 1e3, er = 45e6, tr = 6e6, nr = 256, rr = 4096, ir = 5e5, ar = 2, or = {
+	flat: 1,
+	ribbon: 1,
+	cylinder: 2
+}, sr = .05;
+function cr(e, t) {
+	if (e.count !== t.count) return !1;
+	for (let n = 0, r = e.count * 16; n < r; n++) if (e.matrices[n] !== t.matrices[n]) return !1;
+	return !0;
+}
+function lr(e, t) {
+	let n = Math.min(e.width, Yn), r = null;
+	if (typeof OffscreenCanvas < "u") r = new OffscreenCanvas(n, n);
+	else if (typeof document < "u") r = document.createElement("canvas"), r.width = r.height = n;
+	else return null;
+	try {
+		let i = r.getContext("2d", { willReadFrequently: !0 });
+		if (!i) return null;
+		i.drawImage(e, 0, 0, n, n);
+		let { data: a } = i.getImageData(0, 0, n, n);
+		return {
+			data: a,
+			width: n,
+			height: n,
+			channels: 4,
+			bottomUp: !1,
+			srgb: t
+		};
+	} catch {
+		return null;
+	}
+}
+function ur(e) {
+	let t = e?.image;
+	if (!t) return null;
+	if (ArrayBuffer.isView(t.data)) return {
+		data: t.data,
+		width: t.width,
+		height: t.height,
+		channels: 4,
+		topDown: e.flipY === !0,
+		float: !(t.data instanceof Uint8Array || t.data instanceof Uint8ClampedArray)
+	};
+	let { width: n, height: r } = t;
+	if (!n || !r) return null;
+	let i = null;
+	if (typeof OffscreenCanvas < "u") i = new OffscreenCanvas(n, r);
+	else if (typeof document < "u") i = document.createElement("canvas"), i.width = n, i.height = r;
+	else return null;
+	try {
+		let e = i.getContext("2d", { willReadFrequently: !0 });
+		return e ? (e.drawImage(t, 0, 0), {
+			data: e.getImageData(0, 0, n, r).data,
+			width: n,
+			height: r,
+			channels: 4,
+			topDown: !0,
+			float: !1
+		}) : null;
+	} catch {
+		return null;
+	}
+}
+function dr(e) {
+	let t = Z(e, "encoding", "sRGB");
+	if (t === "linear") return (e) => e;
+	let n = /^gamma\s+([\d.]+)$/.exec(t);
+	return n ? (e) => e ** Number(n[1]) : yn;
+}
+function fr(e) {
+	return {
+		su: X(e, "uscale", 1),
+		sv: X(e, "vscale", 1),
+		du: X(e, "udelta", 0),
+		dv: X(e, "vdelta", 0)
+	};
+}
+function pr(e, { su: t, sv: n, du: r, dv: i }) {
+	e.repeat.set(t, n), e.offset.set(r, i);
+}
+function mr(e, { srgb: t }) {
+	let n = e?.image?.data;
+	if (!ArrayBuffer.isView(n) || n instanceof Uint8Array || n instanceof Uint8ClampedArray) return e;
+	let { width: r, height: i } = e.image, a = new Uint8Array(r * i * 4), o = n.length / (r * i);
+	for (let e = 0; e < r * i; e++) for (let r = 0; r < 4; r++) {
+		let i = r < o ? Math.min(1, Math.max(0, n[e * o + r])) : 1;
+		a[e * 4 + r] = Math.round(255 * (t && r < 3 ? bn(i) : i));
+	}
+	let s = new b(a, r, i, P);
+	return s.flipY = e.flipY, s.colorSpace = t ? F : ne, s.wrapS = s.wrapT = ue, s.needsUpdate = !0, s;
+}
+function hr({ data: e, width: t, height: n, mapping: r }) {
+	let i = new b(e, t, n, P);
+	return i.colorSpace = F, i.wrapS = i.wrapT = ue, pr(i, r), i.needsUpdate = !0, i;
+}
+function gr(e) {
+	let t = [e], n = e, r = [
+		(e) => e.replace(/-renamed-\d+$/, ""),
+		(e) => e.replace(/\d+$/, ""),
+		(e) => e.replace(/_Color$/i, ""),
+		(e) => e.replace(/\d+$/, "")
+	];
+	for (let e of r) {
+		let r = e(n);
+		r !== n && r && t.push(n = r);
+	}
+	return t;
+}
+var _r = class {
+	constructor(e = {}) {
+		this.maxTriangles = e.maxTriangles ?? er, this.maxPlacements = e.maxPlacements ?? tr, this.mergeShapesAbove = e.mergeShapesAbove ?? nr, this.curveSteps = e.curveSteps ?? ar, this.curveSides = e.curveSides ?? null, this.curveTolerance = e.curveTolerance ?? sr, this.resolvePLY = e.resolvePLY || (async () => null), this.resolveImage = e.resolveImage || (async () => null), this.resolveEnvironment = e.resolveEnvironment || e.resolveImage || (async () => null), this.convertHandedness = e.convertHandedness === !0, this.warnings = [], this.report = [], this._materialCache = /* @__PURE__ */ new Map(), this._textureCache = /* @__PURE__ */ new Map(), this._geometryCache = /* @__PURE__ */ new Map(), this._materialBySignature = /* @__PURE__ */ new Map(), this._noUVMaterials = /* @__PURE__ */ new Map(), this._plyCache = /* @__PURE__ */ new Map(), this._imageCache = /* @__PURE__ */ new Map(), this._termCache = /* @__PURE__ */ new Map(), this._mediumMaterials = /* @__PURE__ */ new Map();
+	}
+	warn(e) {
+		this.warnings.push(e);
+	}
+	async build(e) {
+		this.ir = e, this._keepShapes = /* @__PURE__ */ new Set();
+		for (let { name: t } of e.animatedInstances ?? []) for (let n of e.objects.get(t) ?? []) this._keepShapes.add(n);
+		this._plyUsers = /* @__PURE__ */ new Map(), this._plyHeld = /* @__PURE__ */ new Set();
+		for (let t of e.shapes) if (t?.type === "plymesh") {
+			let e = Z(t.params, "filename", null);
+			this._plyUsers.set(e, (this._plyUsers.get(e) ?? 0) + 1);
+		}
+		for (let t of e.objects.values()) for (let e of t) e.type === "plymesh" && this._plyHeld.add(Z(e.params, "filename", null));
+		this._recoveredColors = 0, this.reportedMeshes = 0, this.triangleCount = 0, this.placementCount = 0, this.skippedForBudget = 0, this._countedGeometries = /* @__PURE__ */ new WeakSet();
+		let t = new D();
+		t.name = "PBRTScene", this._batches = e.shapes.length >= this.mergeShapesAbove ? /* @__PURE__ */ new Map() : null, this._mergedBatches = 0, this.mergedShapes = 0, this.droppedNoTemplate = 0, this._animated = [];
+		for (let n = 0; n < e.shapes.length; n++) {
+			if (this._overBudget()) {
+				this.skippedForBudget += e.shapes.length - n;
+				break;
+			}
+			let r = e.shapes[n], [i, a] = await Promise.all([this._batches ? this._createGeometry(r) : this._buildGeometry(r), this._getMaterial(r)]);
+			if (!i) continue;
+			if (this._batches && !r.motion && i.getAttribute("position").count <= rr) {
+				this._mergeShape(r, i, a, t), e.shapes[n] = null;
+				continue;
+			}
+			r.type === "plymesh" && this._plyHeld.add(Z(r.params, "filename", null));
+			let o = this._meshFromGeometry(r, i, a, r.ctm, `shape_${n}`);
+			o && (t.add(o), r.motion && this._animate(o, r.motion));
+		}
+		if (this._batches) {
+			for (let e of this._batches.values()) this._flushBatch(e[0], t), this._flushBatch(e[1], t);
+			this._batches = null;
+		}
+		await this._buildInstances(e, t), await this._buildAnimatedPlacements(e, t), this.skippedForBudget > 0 && this.warn(`stopped at ${this.triangleCount.toLocaleString()} stored triangles (budget ${this.maxTriangles.toLocaleString()}) and ${this.placementCount.toLocaleString()} placements (budget ${this.maxPlacements.toLocaleString()}); ${this.skippedForBudget.toLocaleString()} placement(s) skipped`);
+		let n = null;
+		e.camera && (n = this._buildCamera(e.camera, e.film), n && t.add(n));
+		let r = e.animation ? this._buildClip(e, n) : [], i = await this._buildEnvironment(e.lights);
+		return await this._buildLamps(e.lights, t), this._reportUnsupportedLights(e.lights), this._recoveredColors > 0 && this.warn(`${this._recoveredColors} unreadable texture(s) fell back to the like-named material's colour`), {
+			group: t,
+			camera: n,
+			environment: i,
+			animations: r,
+			report: this.report,
+			meshCount: this.reportedMeshes,
+			triangleCount: this.triangleCount,
+			placementCount: this.placementCount,
+			mergedShapes: this.mergedShapes,
+			droppedNoTemplate: this.droppedNoTemplate,
+			skippedForBudget: this.skippedForBudget,
+			warnings: this.warnings.concat(e.warnings || [])
+		};
+	}
+	_overBudget() {
+		return this.triangleCount >= this.maxTriangles || this.placementCount >= this.maxPlacements;
+	}
+	_accountGeometry(e) {
+		let t = e.index ? e.index.count / 3 : e.getAttribute("position").count / 3;
+		return this._countedGeometries.has(e) || (this._countedGeometries.add(e), this.triangleCount += t), t;
+	}
+	async _buildInstances(e, t) {
+		let n = 0;
+		e.skippedInstances > 0 && (this.skippedForBudget += e.skippedInstances);
+		let r = new Float64Array(16), i = new N(), a = (e, a, o, s, c, l, u) => {
+			let d = Math.max(0, this.maxPlacements - this.placementCount), f = Math.min(e.count, d);
+			if (f < e.count && (this.skippedForBudget += e.count - f), f === 0) return;
+			let p = new k(a, o, f);
+			p.name = `instance_${n++}`, p.frustumCulled = !1;
+			for (let t = 0; t < f; t++) {
+				if (s) qt(r, e.matrices, t * 16, s);
+				else for (let n = 0; n < 16; n++) r[n] = e.matrices[t * 16 + n];
+				p.setMatrixAt(t, i.fromArray(this.convertHandedness ? q($, r) : r));
+			}
+			p.instanceMatrix.needsUpdate = !0, t.add(p), this.placementCount += f, this.reportedMeshes += f, this.report.length < $n && this.report.push({
+				mesh: `${p.name} ×${f}`,
+				shape: c,
+				material: l,
+				color: "#" + o.color.getHexString(),
+				map: o.map ? "yes" : "-",
+				uv: a.getAttribute("uv") ? "yes" : "NO",
+				normals: a.getAttribute("normal") ? "yes" : "NO",
+				emissive: o.emissiveIntensity > 0 ? `#${o.emissive.getHexString()}×${o.emissiveIntensity}` : "-",
+				size: "instanced",
+				tris: u
+			});
+		}, o = (e, t) => {
+			t && t.triangles > 0 && a(e, this._batchGeometry(t), t.material, null, "merged", "-", t.triangles);
+		};
+		for (let { name: t, list: n, template: r } of this._samePlacementGroups(e)) {
+			if (!r) {
+				this.droppedNoTemplate += n.count, this.warn(`ObjectInstance "${t}" has no template — ${n.count.toLocaleString()} placement(s) dropped`);
+				continue;
+			}
+			let e = 0;
+			for (let t of r) t.type !== "plymesh" && e++;
+			let i = e >= 2 ? /* @__PURE__ */ new Map() : null;
+			for (let e of r) {
+				if (this._overBudget()) {
+					this.skippedForBudget += n.count;
+					continue;
+				}
+				let [r, s] = await Promise.all([this._buildGeometry(e), this._getMaterial(e)]);
+				if (!r) continue;
+				if (i && e.type !== "plymesh" && r.getAttribute("position").count <= rr) {
+					this._geometryCache.delete(e);
+					let t = this._appendToBatch(i, e, r, s, e.relativeCTM || e.ctm);
+					this._releaseMerged(e, r), o(n, t);
+					continue;
+				}
+				let c = this._accountGeometry(r);
+				a(n, r, this._materialForGeometry(e, r, s, `instances_${t}`), e.relativeCTM || e.ctm, e.type, e.material?.type || "diffuse", c);
+			}
+			if (i) for (let e of i.values()) o(n, e[0]), o(n, e[1]);
+			H(n.matrices), H(n.matricesEnd);
+		}
+	}
+	_samePlacementGroups(e) {
+		let t = [], n = /* @__PURE__ */ new Map();
+		for (let [r, i] of e.instances) {
+			let a = e.objects.get(r);
+			if (!a || i.matricesEnd) {
+				t.push({
+					name: r,
+					list: i,
+					template: a
+				});
+				continue;
+			}
+			let o = `${i.count}:${Array.prototype.join.call(i.matrices.subarray(0, 16), ",")}`, s = n.get(o);
+			s || n.set(o, s = []);
+			let c = s.find((e) => cr(e.list, i));
+			if (c) {
+				c.template === e.objects.get(c.name) && (c.template = c.template.slice());
+				for (let e of a) c.template.push(e);
+				H(i.matrices);
+				continue;
+			}
+			let l = {
+				name: r,
+				list: i,
+				template: a
+			};
+			s.push(l), t.push(l);
+		}
+		return t;
+	}
+	async _buildAnimatedPlacements(e, t) {
+		let n = e.animatedInstances ?? [];
+		for (let r = 0; r < n.length; r++) {
+			let { name: i, motion: a } = n[r], o = e.objects.get(i);
+			if (!o) {
+				this.droppedNoTemplate++;
+				continue;
+			}
+			if (this._overBudget()) {
+				this.skippedForBudget += n.length - r;
+				break;
+			}
+			let s = new D();
+			s.name = `placement_${r}`;
+			let c = Array.from(a.matrices.subarray(0, 16));
+			new N().fromArray(this.convertHandedness ? q($, c) : c).decompose(s.position, s.quaternion, s.scale);
+			for (let e = 0; e < o.length; e++) {
+				let t = o[e], [n, r] = await Promise.all([this._buildGeometry(t), this._getMaterial(t)]);
+				if (!n) continue;
+				let i = this._meshFromGeometry(t, n, r, t.relativeCTM || t.ctm, `${s.name}_${e}`, !0);
+				i && s.add(i);
+			}
+			s.children.length !== 0 && (t.add(s), this._animate(s, a));
+		}
+	}
+	_animate(e, t) {
+		t.visible && (e.visible = t.visible[0] === 1), this._animated.push({
+			node: e,
+			motion: t
+		});
+	}
+	_buildClip(e, t) {
+		let n = [];
+		for (let { node: e, motion: t } of this._animated) if (this._transformTracks(n, e.name, t, (e, t) => {
+			let n = Array.from(e.subarray(t, t + 16));
+			return this.convertHandedness ? q($, n) : n;
+		}), t.visible) {
+			let r = t.times, i = r.map((e, t) => t === 0 ? 0 : (r[t - 1] + e) / 2);
+			n.push(new g(`${e.name}.visible`, i, Array.from(t.visible, (e) => e === 1)));
+		}
+		let r = e.camera?.motion;
+		if (t && r) {
+			let e = new oe();
+			if (this._transformTracks(n, t.name, r, (t, n) => (this._poseCamera(e, t.subarray(n, n + 16)), e.updateMatrix(), e.matrix.elements)), r.fov && t.isPerspectiveCamera) {
+				let e = Array.from(r.fov, (e) => this._verticalFov({ fov: {
+					type: "float",
+					value: [e]
+				} }, t.aspect));
+				n.push(new re(`${t.name}.fov`, r.times.slice(), e));
+			}
+		}
+		for (let e of n) e.optimize();
+		return n.length === 0 ? [] : [new h(e.animation.name, e.animation.duration, n)];
+	}
+	_transformTracks(e, t, n, r) {
+		let i = n.times.length, a = new Float32Array(i * 3), o = new Float32Array(i * 4), s = new Float32Array(i * 3), c = new N(), l = new L(), u = new ce(), d = new L();
+		for (let e = 0; e < i; e++) c.fromArray(r(n.matrices, e * 16)).decompose(l, u, d), e > 0 && u.x * o[e * 4 - 4] + u.y * o[e * 4 - 3] + u.z * o[e * 4 - 2] + u.w * o[e * 4 - 1] < 0 && u.set(-u.x, -u.y, -u.z, -u.w), l.toArray(a, e * 3), u.toArray(o, e * 4), d.toArray(s, e * 3);
+		let f = (e, t) => {
+			for (let n = t; n < e.length; n++) if (e[n] !== e[n % t]) return !0;
+			return !1;
+		};
+		f(a, 3) && e.push(new me(`${t}.position`, n.times.slice(), a)), f(o, 4) && e.push(new le(`${t}.quaternion`, n.times.slice(), o)), f(s, 3) && e.push(new me(`${t}.scale`, n.times.slice(), s));
+	}
+	async _buildShapeMesh(e, t, n) {
+		let [r, i] = await Promise.all([this._buildGeometry(e), this._getMaterial(e)]);
+		return r ? this._meshFromGeometry(e, r, i, t, n) : null;
+	}
+	_meshFromGeometry(e, t, n, r, i, a = !1) {
+		let o = !!t.getAttribute("uv"), s = this._materialForGeometry(e, t, n, i), c = new ee(t, s);
+		c.name = i;
+		let l = this.convertHandedness && !a ? q($, r) : r;
+		new N().fromArray(l).decompose(c.position, c.quaternion, c.scale), c.updateMatrix(), t.boundingBox || t.computeBoundingBox();
+		let u = t.boundingBox ? t.boundingBox.clone().applyMatrix4(c.matrix).getSize(new L()) : new L(), d = this._accountGeometry(t);
+		return this.placementCount++, this.reportedMeshes++, this.report.length < $n && this.report.push({
+			mesh: i,
+			shape: e.type,
+			material: e.material?.type || "diffuse",
+			color: "#" + s.color.getHexString(),
+			map: s.map ? "yes" : "-",
+			uv: o ? "yes" : "NO",
+			normals: t.getAttribute("normal") ? "yes" : "NO",
+			emissive: s.emissiveIntensity > 0 ? `#${s.emissive.getHexString()}×${s.emissiveIntensity}` : "-",
+			size: `${u.x.toFixed(2)}×${u.y.toFixed(2)}×${u.z.toFixed(2)}`,
+			tris: d
+		}), c;
+	}
+	_materialForGeometry(e, t, n, r) {
+		if (!n.map || t.getAttribute("uv")) return n;
+		let i = this._noUVMaterials.get(n);
+		return i || (this.warn(`${r} (${e.type}, "${e.material?.type || "diffuse"}") has a texture map but no UVs — dropping map, using base color`), i = n.clone(), i.map = null, this._noUVMaterials.set(n, i)), i;
+	}
+	_mergeShape(e, t, n, r) {
+		this.reportedMeshes++;
+		let i = this.convertHandedness ? q($, e.ctm) : e.ctm, a = this._appendToBatch(this._batches, e, t, n, i);
+		this._releaseMerged(e, t), a && this._flushBatch(a, r);
+	}
+	_releaseMerged(e, t) {
+		if (!this._keepShapes?.has(e) && !(e.type === "plymesh" && !this._lastPlyUse(Z(e.params, "filename", null)))) {
+			for (let e in t.attributes) H(t.attributes[e].array);
+			H(t.index?.array);
+			for (let t in e.params) ArrayBuffer.isView(e.params[t]?.value) && H(e.params[t].value);
+		}
+	}
+	_lastPlyUse(e) {
+		let t = (this._plyUsers.get(e) ?? 1) - 1;
+		return this._plyUsers.set(e, t), t > 0 || this._plyHeld.has(e) ? !1 : (this._plyCache.delete(e), !0);
+	}
+	_appendToBatch(e, t, n, r, i) {
+		let a = this._materialForGeometry(t, n, r, "merged shape"), o = n.getAttribute("position"), s = n.getAttribute("normal"), c = n.getAttribute("uv"), l = n.index, u = o.count;
+		this.triangleCount += (l ? l.count : u) / 3, this.mergedShapes++;
+		let d = e.get(a);
+		d || e.set(a, d = [null, null]);
+		let f = +!!c, p = d[f];
+		p || (d[f] = p = {
+			material: a,
+			positions: new Float32Array(3072),
+			normals: new Float32Array(3072),
+			uvs: c ? new Float32Array(2048) : null,
+			indices: new Uint32Array(3072),
+			vertexCount: 0,
+			indexCount: 0,
+			triangles: 0
+		});
+		let m = i, h = J(m), g = p.vertexCount;
+		p.positions = Zn(p.positions, (g + u) * 3), p.normals = Zn(p.normals, (g + u) * 3), c && (p.uvs = Zn(p.uvs, (g + u) * 2));
+		let _ = o.array, v = p.positions, y = s ? s.array : null, b = p.normals;
+		for (let e = 0; e < u; e++) {
+			let t = e * 3, n = (g + e) * 3, r = _[t], i = _[t + 1], a = _[t + 2];
+			if (v[n] = m[0] * r + m[4] * i + m[8] * a + m[12], v[n + 1] = m[1] * r + m[5] * i + m[9] * a + m[13], v[n + 2] = m[2] * r + m[6] * i + m[10] * a + m[14], !y) continue;
+			let o = y[t], s = y[t + 1], c = y[t + 2], l = h[0] * o + h[1] * s + h[2] * c, u = h[4] * o + h[5] * s + h[6] * c, d = h[8] * o + h[9] * s + h[10] * c, f = Math.hypot(l, u, d);
+			f > 0 && (l /= f, u /= f, d /= f), b[n] = l, b[n + 1] = u, b[n + 2] = d;
+		}
+		c && p.uvs.set(c.array.subarray(0, u * 2), g * 2);
+		let x = l ? l.count : u;
+		p.indices = Zn(p.indices, p.indexCount + x);
+		let S = p.indices, C = l ? l.array : null;
+		for (let e = 0; e < x; e++) S[p.indexCount + e] = g + (C ? C[e] : e);
+		return p.vertexCount += u, p.indexCount += x, p.triangles += x / 3, p.triangles >= ir ? (d[f] = null, p) : null;
+	}
+	_batchGeometry(e) {
+		let t = new v();
+		return t.setAttribute("position", new w(U(e.positions, e.vertexCount * 3), 3)), t.setAttribute("normal", new w(U(e.normals, e.vertexCount * 3), 3)), e.uvs && t.setAttribute("uv", new w(U(e.uvs, e.vertexCount * 2), 2)), t.setIndex(new I(U(e.indices, e.indexCount), 1)), e.positions = e.normals = e.uvs = e.indices = null, t;
+	}
+	_flushBatch(e, t) {
+		if (!e || e.triangles === 0) return;
+		let n = new ee(this._batchGeometry(e), e.material);
+		n.name = `merged_${this._mergedBatches++}`, n.frustumCulled = !1, t.add(n), this.placementCount++, this.report.length < $n && this.report.push({
+			mesh: n.name,
+			shape: "merged",
+			material: "-",
+			color: "#" + e.material.color.getHexString(),
+			map: e.material.map ? "yes" : "-",
+			uv: e.uvs ? "yes" : "NO",
+			normals: "yes",
+			emissive: e.material.emissiveIntensity > 0 ? `#${e.material.emissive.getHexString()}×${e.material.emissiveIntensity}` : "-",
+			size: "merged",
+			tris: e.triangles
+		});
+	}
+	_buildGeometry(e) {
+		let t = this._geometryCache.get(e);
+		return t || this._geometryCache.set(e, t = this._createGeometry(e)), t;
+	}
+	async _createGeometry(e) {
+		let t = await this._shapeGeometry(e);
+		return t && e.areaLight && !fn(e.areaLight.params, "twosided", !1) ? this._facingEmission(e, t) : t;
+	}
+	_facingEmission(e, t) {
+		let n = t.userData.pbrtNormals ? t.getAttribute("normal") : null;
+		if (!n && !e.reverseOrientation) return t;
+		let r = t.getAttribute("position").array, i = n?.array, a = t.index?.array ?? null, o = a ? a.length : t.getAttribute("position").count, s = new Uint32Array(o), c = 0;
+		for (let t = 0; t + 2 < o; t += 3) {
+			let n = a ? a[t] : t, o = a ? a[t + 1] : t + 1, l = a ? a[t + 2] : t + 2, u = e.reverseOrientation;
+			if (i) {
+				let e = r[o * 3] - r[n * 3], t = r[o * 3 + 1] - r[n * 3 + 1], a = r[o * 3 + 2] - r[n * 3 + 2], s = r[l * 3] - r[n * 3], c = r[l * 3 + 1] - r[n * 3 + 1], d = r[l * 3 + 2] - r[n * 3 + 2], f = i[n * 3] + i[o * 3] + i[l * 3], p = i[n * 3 + 1] + i[o * 3 + 1] + i[l * 3 + 1], m = i[n * 3 + 2] + i[o * 3 + 2] + i[l * 3 + 2];
+				u = (t * d - a * c) * f + (a * s - e * d) * p + (e * c - t * s) * m < 0;
+			}
+			s[t] = n, s[t + 1] = u ? l : o, s[t + 2] = u ? o : l, u && c++;
+		}
+		if (c === 0) return t;
+		let l = new v();
+		for (let e in t.attributes) l.setAttribute(e, t.getAttribute(e));
+		return l.setIndex(new I(s, 1)), l;
+	}
+	_shapeGeometry(e) {
+		switch (e.type) {
+			case "trianglemesh": return this._triangleMesh(e.params);
+			case "bilinearmesh": return this._bilinearMesh(e.params);
+			case "loopsubdiv": return this._loopSubdiv(e.params);
+			case "curve": return this._curve(e.params);
+			case "plymesh": return this._plyMesh(e.params);
+			case "sphere": return this._sphere(e.params);
+			case "disk": return this._disk(e.params);
+			default: return this.warn(`shape "${e.type}" not supported — skipped`), null;
+		}
+	}
+	_triangleMesh(e) {
+		let t = e.P?.value;
+		if (!t || t.length < 9) return this.warn("trianglemesh missing P"), null;
+		let n = new v();
+		n.setAttribute("position", new w(Qn(t), 3));
+		let r = e.N?.value;
+		r && r.length === t.length && (n.setAttribute("normal", new w(Qn(r), 3)), n.userData.pbrtNormals = !0);
+		let i = (e.uv || e.st)?.value;
+		i && i.length === t.length / 3 * 2 && n.setAttribute("uv", new w(Qn(i), 2));
+		let a = e.indices?.value;
+		return a && a.length && n.setIndex(Xn(a)), r || n.computeVertexNormals(), n;
+	}
+	_curve(e) {
+		let t = e.P?.value;
+		if (!t || t.length < 12) return this.warn("curve needs at least 4 control points"), null;
+		let n = Math.round(X(e, "degree", 3));
+		if (n !== 3) return this.warn(`curve degree ${n} not supported — only cubic`), null;
+		let r = Z(e, "type", "flat"), i = X(e, "width", 1), a = Kn({
+			P: t,
+			basis: Z(e, "basis", "bezier"),
+			width0: X(e, "width0", i),
+			width1: X(e, "width1", i),
+			N: e.N?.value || null,
+			steps: this.curveSteps,
+			sides: this.curveSides ?? or[r] ?? 1,
+			tolerance: this.curveTolerance
+		});
+		if (!a) return this.warn("curve could not be tessellated"), null;
+		let o = new v();
+		return o.setAttribute("position", new w(a.positions, 3)), o.setIndex(new I(a.indices, 1)), o.computeVertexNormals(), o;
+	}
+	_loopSubdiv(e) {
+		let t = e.P?.value, n = e.indices?.value;
+		if (!t || t.length < 9 || !n || n.length < 3) return this.warn("loopsubdiv missing P/indices"), null;
+		let r = Math.max(0, Math.min(6, Math.round(X(e, "levels", 3)))), { positions: i, indices: a, levels: o } = jn(t, n, r);
+		o < r && this.warn(`loopsubdiv refined ${o}/${r} levels — the control mesh is too dense for the triangle budget`);
+		let s = new v();
+		return s.setAttribute("position", new w(i, 3)), s.setIndex(new I(a, 1)), s.computeVertexNormals(), s;
+	}
+	_bilinearMesh(e) {
+		let t = e.P?.value, n = e.indices?.value;
+		if (!t || !n) return this.warn("bilinearmesh missing P/indices"), null;
+		let r = [];
+		for (let e = 0; e + 3 < n.length; e += 4) {
+			let [t, i, a, o] = [
+				n[e],
+				n[e + 1],
+				n[e + 2],
+				n[e + 3]
+			];
+			r.push(t, i, a, t, a, o);
+		}
+		let i = new v();
+		return i.setAttribute("position", new w(Float32Array.from(t), 3)), i.setIndex(r), i.computeVertexNormals(), i;
+	}
+	_plyMesh(e) {
+		let t = Z(e, "filename", null);
+		if (!t) return this.warn("plymesh missing filename"), null;
+		let n = this._plyCache.get(t);
+		return n || this._plyCache.set(t, n = this._decodePly(t)), n;
+	}
+	async _decodePly(e) {
+		try {
+			let t = await this.resolvePLY(e);
+			return t ? (t.getAttribute("normal") ? t.userData.pbrtNormals = !0 : t.computeVertexNormals(), t) : (this.warn(`plymesh file not found: ${e}`), null);
+		} catch (t) {
+			return this.warn(`failed to load plymesh ${e}: ${t.message}`), null;
+		}
+	}
+	_sphere(e) {
+		return new de(X(e, "radius", 1), 48, 32);
+	}
+	_disk(e) {
+		let t = X(e, "radius", 1), n = X(e, "innerradius", 0), r = X(e, "height", 0), i = [], a = [];
+		for (let e = 0; e < 48; e++) {
+			let o = e / 48 * Math.PI * 2, s = (e + 1) / 48 * Math.PI * 2, c = i.length / 3;
+			i.push(Math.cos(o) * n, Math.sin(o) * n, r), i.push(Math.cos(o) * t, Math.sin(o) * t, r), i.push(Math.cos(s) * t, Math.sin(s) * t, r), i.push(Math.cos(s) * n, Math.sin(s) * n, r), a.push(c, c + 1, c + 2, c, c + 2, c + 3);
+		}
+		let o = new v();
+		return o.setAttribute("position", new w(Float32Array.from(i), 3)), o.setIndex(a), o.computeVertexNormals(), o;
+	}
+	async _getMaterial(e) {
+		let t = await this._surfaceMaterial(e);
+		return e.interior ? this._inMedium(t, e.interior) : t;
+	}
+	async _surfaceMaterial(e) {
+		let t = this._materialCache.get(e.material);
+		if (t || (t = /* @__PURE__ */ new Map(), this._materialCache.set(e.material, t)), t.has(e.areaLight)) return t.get(e.areaLight);
+		let n = this._materialContext(), r = await _n(e.material, n);
+		e.areaLight && await this._applyAreaLight(r, e.areaLight, n);
+		let i = this._dedupeMaterial(r);
+		return t.set(e.areaLight, i), i;
+	}
+	_materialContext() {
+		return this._ctx ??= {
+			resolveNamedTexture: (e) => this._resolveNamedTexture(e),
+			namedMaterials: this.ir.namedMaterials,
+			warn: (e) => this.warn(e),
+			floatTextureMean: async (e) => {
+				let t = await this._bakeTerm(e, 1);
+				return t ? t.layer ? Sn(t.layer) : t.rgb[0] : null;
+			},
+			bakeMaterialMix: (e, t, n) => this._bakeMaterialMix(e, t, n),
+			resolveNormalMap: async (e) => {
+				let t = await this._image(e);
+				if (!t) return null;
+				let n = mr(t, { srgb: !1 }), r = n === t ? t.clone() : n;
+				return r.colorSpace = ne, r;
+			}
+		};
+	}
+	async _inMedium(e, t) {
+		if (!(e.transmission > 0)) return e;
+		let n = this._mediumMaterials.get(e);
+		return n || this._mediumMaterials.set(e, n = /* @__PURE__ */ new Map()), n.has(t) || n.set(t, this._attenuated(e, t)), n.get(t);
+	}
+	async _attenuated(e, t) {
+		let n = this.ir.media?.get(t), r = n && Z(n, "type", "");
+		if (r !== "homogeneous") return this.warn(n ? `medium "${t}" (${r}) is not supported — "${t}" glass left clear` : `medium "${t}" not defined`), e;
+		n.preset && this.warn(`medium preset "${Z(n, "preset", "")}" is not supported — using sigma_a / sigma_s`);
+		let i = this._materialContext(), a = (await Q(n, "sigma_a", i, [
+			1,
+			1,
+			1
+		])).rgb, o = (await Q(n, "sigma_s", i, [
+			1,
+			1,
+			1
+		])).rgb, s = X(n, "scale", 1), c = [
+			0,
+			1,
+			2
+		].map((e) => (a[e] + o[e]) * s), l = Math.max(...c);
+		if (!(l > 0)) return e;
+		let u = e.clone();
+		return u.attenuationDistance = 1 / l, u.attenuationColor.setRGB(...c.map((e) => Math.exp(-e / l))), this._dedupeMaterial(u);
+	}
+	_dedupeMaterial(e) {
+		let t = e.color, n = e.emissive, r = `${t.r},${t.g},${t.b}|${n.r},${n.g},${n.b}|${e.emissiveIntensity}|${e.map ? e.map.uuid : "-"}|${e.roughness}|${e.metalness}|${e.transmission}|${e.ior}|${e.thickness}|${e.clearcoat}|${e.clearcoatRoughness}|${e.opacity}|${e.side}|${e.normalMap ? e.normalMap.uuid : "-"}|${e.attenuationDistance}|${e.attenuationColor.toArray()}|${e.specularIntensity}|${e.diffuseTransmission ?? 0}|${e.diffuseTransmissionColor?.toArray() ?? "-"}`;
+		return this._materialBySignature.get(r) || (this._materialBySignature.set(r, e), e);
+	}
+	async _applyAreaLight(e, t, n) {
+		let r = await Jn(t.params, "L", n), i = X(t.params, "scale", 1);
+		e.emissive.setRGB(r[0], r[1], r[2]), e.emissiveIntensity = i, e.side = fn(t.params, "twosided", !1) ? S : E;
+	}
+	async _resolveNamedTexture(e) {
+		if (this._textureCache.has(e)) return this._textureCache.get(e);
+		let t = this.ir.namedTextures.get(e), n = null;
+		if (!t) this.warn(`named texture "${e}" not defined`);
+		else if (t.class === "imagemap") n = await this._imageMapTexture(e, t);
+		else if (t.class === "mix") n = await this._mixTexture(e, t);
+		else if (t.class === "constant") {
+			let e = t.params.value;
+			e && e.type === "rgb" ? n = { constant: [
+				e.value[0],
+				e.value[1],
+				e.value[2]
+			] } : e && (n = { constant: [
+				e.value[0],
+				e.value[0],
+				e.value[0]
+			] });
+		} else if (t.class === "scale") n = await this._resolveScaleTexture(e, t);
+		else {
+			let r = this._colorFromLikeNamedMaterial(e);
+			r ? (n = { constant: r.rgb }, this._recoveredColors++) : this.warn(`texture class "${t.class}" not supported (texture "${e}")`);
+		}
+		return this._textureCache.set(e, n), n;
+	}
+	_image(e) {
+		let t = this._imageCache.get(e);
+		return t || (t = Promise.resolve().then(() => this.resolveImage(e)).catch((t) => (this.warn(`failed to load image ${e}: ${t.message}`), null)), this._imageCache.set(e, t)), t;
+	}
+	async _imageMapTexture(e, t) {
+		let n = Z(t.params, "filename", null);
+		if (!n) return null;
+		let r = await this._image(n);
+		if (!r) return this.warn(`image not found for texture "${e}": ${n}`), null;
+		let i = Z(t.params, "mapping", "uv");
+		i !== "uv" && this.warn(`texture "${e}": "${i}" mapping is not supported — using the mesh's uv`);
+		let a = X(t.params, "scale", 1);
+		if (a > 1 || fn(t.params, "invert", !1)) {
+			let t = await this._bakeTerm(e, 3), n = t?.layer && wn([{
+				...t,
+				clamp: !0
+			}], ([e]) => e);
+			if (n) return { texture: hr(n) };
+			this.warn(`texture "${e}": its scale or invert could not be baked here — ignored`);
+		}
+		let o = mr(r, { srgb: !0 }), s = o === r ? r.clone() : o;
+		return pr(s, fr(t.params)), s.needsUpdate = !0, a < 1 ? {
+			texture: s,
+			constant: [
+				a,
+				a,
+				a
+			]
+		} : { texture: s };
+	}
+	async _mixTexture(e, t) {
+		let [n, r, i] = await Promise.all([
+			this._paramTerm(t.params, "tex1", 3, [
+				0,
+				0,
+				0
+			]),
+			this._paramTerm(t.params, "tex2", 3, [
+				1,
+				1,
+				1
+			]),
+			this._paramTerm(t.params, "amount", 1, [
+				.5,
+				.5,
+				.5
+			])
+		]);
+		if (!n || !r || !i) return this.warn(`texture "${e}": a "mix" input could not be read here`), null;
+		let a = (e) => e.map((e) => Math.min(1, Math.max(0, e))), o = wn([
+			{
+				...n,
+				clamp: !0
+			},
+			{
+				...r,
+				clamp: !0
+			},
+			i
+		], Tn);
+		return o ? { texture: hr(o) } : { constant: Tn([
+			a(n.rgb),
+			a(r.rgb),
+			i.rgb
+		]) };
+	}
+	async _paramTerm(e, t, n, r) {
+		let i = e[t];
+		if (!i) return { rgb: r };
+		if (i.type === "texture") return this._bakeTerm(i.value[0], n);
+		let a = (await Q(e, t, this._materialContext(), r)).rgb;
+		return a ? { rgb: a } : null;
+	}
+	_bakeTerm(e, t) {
+		let n = `${e}\0${t}`, r = this._termCache.get(n);
+		return r || this._termCache.set(n, r = this._createBakeTerm(e, t)), r;
+	}
+	async _createBakeTerm(e, t) {
+		let n = this.ir.namedTextures.get(e);
+		if (n?.class === "imagemap") {
+			if (Z(n.params, "mapping", "uv") !== "uv") return null;
+			let e = Z(n.params, "filename", null), r = ur(e && await this._image(e));
+			return r ? { layer: xn(r, {
+				channels: t,
+				decode: r.float ? null : dr(n.params),
+				scale: X(n.params, "scale", 1),
+				invert: fn(n.params, "invert", !1),
+				mapping: fr(n.params)
+			}) } : null;
+		}
+		let r = await this._resolveNamedTexture(e);
+		if (!r) return null;
+		if (!r.texture) return r.constant ? { rgb: r.constant } : null;
+		let i = this._textureLayer(r.texture, t);
+		return i ? {
+			layer: i,
+			tint: r.constant ?? null
+		} : null;
+	}
+	_textureLayer(e, t) {
+		let n = ur(e);
+		if (!n) return null;
+		let r = !n.float && e.colorSpace === F;
+		return xn(n, {
+			channels: t,
+			decode: n.float ? null : r ? yn : (e) => e,
+			mapping: {
+				su: e.repeat.x,
+				sv: e.repeat.y,
+				du: e.offset.x,
+				dv: e.offset.y
+			}
+		});
+	}
+	async _bakeMaterialMix(e, t, n) {
+		let r = await this._bakeTerm(n, 1);
+		if (!r) return null;
+		if (!r.layer) return {
+			mean: r.rgb[0],
+			texture: null
+		};
+		let i = Sn(r.layer), a = (e) => {
+			if (!e.map) return {
+				rgb: e.color.toArray(),
+				clamp: !0
+			};
+			let t = this._textureLayer(e.map, 3);
+			return t && {
+				layer: t,
+				tint: e.color.toArray(),
+				clamp: !0
+			};
+		}, o = a(e), s = a(t);
+		if (!o || !s) return {
+			mean: i,
+			texture: null
+		};
+		let c = wn([
+			o,
+			s,
+			r
+		], Tn);
+		return {
+			mean: i,
+			texture: c ? hr(c) : null
+		};
+	}
+	_colorFromLikeNamedMaterial(e) {
+		for (let t of gr(e)) {
+			let e = (this.ir?.namedMaterials?.get(t))?.params?.reflectance;
+			if (e && (e.type === "rgb" || e.type === "color")) return {
+				name: t,
+				rgb: [
+					e.value[0],
+					e.value[1],
+					e.value[2]
+				]
+			};
+		}
+		return null;
+	}
+	async _resolveScaleTexture(e, t) {
+		if (t.params.scale?.type === "texture") {
+			let [n, r] = await Promise.all([this._paramTerm(t.params, "tex", 3, [
+				1,
+				1,
+				1
+			]), this._paramTerm(t.params, "scale", 1, [
+				1,
+				1,
+				1
+			])]), i = ([e, t]) => [
+				e[0] * t[0],
+				e[1] * t[0],
+				e[2] * t[0]
+			];
+			if (n && r) {
+				let e = wn([{
+					...n,
+					clamp: !0
+				}, r], i);
+				return e ? { texture: hr(e) } : { constant: i([n.rgb, r.rgb]) };
+			}
+			this.warn(`texture "${e}": its "scale" texture could not be read here — ignored`);
+		}
+		let n = t.params.tex, r = null;
+		if (n?.type === "texture" && typeof n.value[0] == "string") r = await this._resolveNamedTexture(n.value[0]);
+		else if (n?.type === "rgb" || n?.type === "color") r = { constant: [
+			n.value[0],
+			n.value[1],
+			n.value[2]
+		] };
+		else if (n?.type === "float") {
+			let e = n.value[0];
+			r = { constant: [
+				e,
+				e,
+				e
+			] };
+		}
+		let i = t.params.scale, a = [
+			1,
+			1,
+			1
+		];
+		if (i?.type === "rgb" || i?.type === "color") a = [
+			i.value[0],
+			i.value[1],
+			i.value[2]
+		];
+		else if (i?.type === "float") {
+			let e = i.value[0];
+			a = [
+				e,
+				e,
+				e
+			];
+		}
+		if (r?.texture) {
+			let e = r.constant || [
+				1,
+				1,
+				1
+			];
+			return {
+				texture: r.texture,
+				constant: [
+					e[0] * a[0],
+					e[1] * a[1],
+					e[2] * a[2]
+				]
+			};
+		}
+		let o = r?.constant || [
+			1,
+			1,
+			1
+		];
+		return { constant: [
+			o[0] * a[0],
+			o[1] * a[1],
+			o[2] * a[2]
+		] };
+	}
+	_buildCamera(e, t) {
+		let n = t && t.yresolution ? t.xresolution / t.yresolution : 16 / 9, r;
+		if (e.type === "orthographic") {
+			let t = e.params?.screenwindow?.value, i = t?.length === 4 ? (t[3] - t[2]) / 2 : Math.max(1, 1 / n);
+			r = new ae(-i * n, i * n, i, -i, .01, 1e4);
+		} else r = new oe(this._verticalFov(e.params, n), n, .01, 1e4);
+		return r.name = "PBRT Camera", this._poseCamera(r, e.cameraToWorld), r.updateMatrixWorld(!0), r;
+	}
+	_poseCamera(e, t) {
+		let n = t, r = new L(n[12], n[13], n[14]), i = new L(n[8], n[9], n[10]), a = new L(n[4], n[5], n[6]);
+		this.convertHandedness && (r.z *= -1, i.z *= -1, a.z *= -1), e.up.copy(a.normalize()), e.position.copy(r), e.scale.set(1, 1, 1), e.lookAt(r.clone().add(i)), Kt(t) > 0 !== this.convertHandedness && (e.scale.x = -1);
+	}
+	_verticalFov(e, t) {
+		let n = X(e, "fov", 90);
+		if (t >= 1) return n;
+		let r = n * Math.PI / 180;
+		return 2 * Math.atan(Math.tan(r / 2) / t) * 180 / Math.PI;
+	}
+	_equirectFromInfiniteLight(e, t, n, r) {
+		let i = e.image;
+		if (!i?.width || i.width !== i.height) return i?.width !== i?.height && this.warn(`infinite-light image "${r}" is ${i?.width}x${i?.height}, not square — read as equirectangular, but pbrt would read it as equal-area octahedral`), null;
+		let a = null;
+		if (i.data) {
+			let e = i.data.length / (i.width * i.height);
+			if (!Number.isInteger(e) || e < 3) return null;
+			a = {
+				data: i.data,
+				width: i.width,
+				height: i.height,
+				channels: e,
+				bottomUp: !0
+			};
+		} else if (a = lr(i, e.colorSpace === F), !a) return this.warn(`infinite-light image "${r}" could not be read back for octahedral conversion`), null;
+		let { data: o, width: s, height: c } = Fn(a, t.ctm, n), l = new b(o, s, c, P, T);
+		return l.mapping = C, l.minFilter = A, l.magFilter = A, l.needsUpdate = !0, l;
+	}
+	async _buildEnvironment(e) {
+		let t = e.find((e) => e.type === "infinite");
+		if (!t) return null;
+		let n = X(t.params, "scale", 1), r = Z(t.params, "filename", null);
+		if (r) try {
+			let e = await this.resolveEnvironment(r);
+			if (e) {
+				let i = this._equirectFromInfiniteLight(e, t, n, r);
+				return i ? { texture: i } : (e.mapping = C, { texture: e });
+			}
+			this.warn(`infinite-light image not found: ${r}`);
+		} catch (e) {
+			this.warn(`failed to load infinite-light image ${r}: ${e.message}`);
+		}
+		let i = (await Jn(t.params, "L", {
+			resolveNamedTexture: async () => null,
+			warn: (e) => this.warn(e)
+		})).map((e) => e * n), a = new Float32Array(8);
+		for (let e = 0; e < 2; e++) a[e * 4 + 0] = i[0], a[e * 4 + 1] = i[1], a[e * 4 + 2] = i[2], a[e * 4 + 3] = 1;
+		let o = new b(a, 2, 1, P, T);
+		return o.mapping = C, o.minFilter = A, o.magFilter = A, o.needsUpdate = !0, { texture: o };
+	}
+	async _buildLamps(e, t) {
+		let n = {
+			resolveNamedTexture: async () => null,
+			warn: (e) => this.warn(e)
+		};
+		for (let r of e) {
+			if (!qn.has(r.type)) continue;
+			let e = new N().fromArray(this.convertHandedness ? q($, r.ctm) : r.ctm), i = (t, n) => {
+				let i = r.params[t]?.value;
+				return new L().fromArray(i?.length >= 3 ? i : n).applyMatrix4(e);
+			}, a = await Jn(r.params, r.type === "distant" ? "L" : "I", n), o = X(r.params, "scale", 1), s = i("from", [
+				0,
+				0,
+				0
+			]), c = i("to", [
+				0,
+				0,
+				1
+			]), l;
+			if (r.type === "distant") {
+				let e = X(r.params, "illuminance", -1);
+				e > 0 && (o *= e), l = new x(), l.userData.__luxConverted = !0;
+			} else if (r.type === "point") {
+				let e = X(r.params, "power", -1);
+				o *= e > 0 ? e : 4 * Math.PI, l = new se(), l.userData.__candelaConverted = !0;
+			} else {
+				let e = Math.min(Math.max(X(r.params, "coneangle", 30), 0), 90) * Math.PI / 180, t = Math.min(Math.max(X(r.params, "conedeltaangle", 5) * Math.PI / 180, 0), e), n = Math.cos(e), i = Math.cos(e - t), a = X(r.params, "power", -1);
+				a > 0 && (o *= a / (2 * Math.PI * (1 - i + (i - n) / 2))), o *= 4 * Math.PI, l = new fe(), l.angle = e, l.penumbra = n < 1 ? Math.min((i - n) / (1 - n), 1) : 0, l.userData.__candelaConverted = !0;
+			}
+			let u = Math.max(a[0], a[1], a[2]);
+			!(u > 0) || !(o > 0) || (l.color.setRGB(a[0] / u, a[1] / u, a[2] / u), l.intensity = u * o, l.name = `pbrt ${r.type}`, l.position.copy(s), l.decay = 2, l.distance = 0, l.target && (l.target.position.subVectors(c, s), l.add(l.target)), t.add(l));
+		}
+	}
+	_reportUnsupportedLights(e) {
+		for (let t of e) t.type !== "infinite" && !qn.has(t.type) && this.warn(`light "${t.type}" not supported (only infinite, distant, point and spot lights and emissive area lights are mapped)`);
+	}
+}, vr = 1e3, yr = 2048, br = 1e5;
+function xr(e) {
+	let t = e[0], n = (e) => {
+		let t = e.lastIndexOf("/"), n = /^(.*?)(\d+)\.pbrt$/i.exec(e.slice(t + 1));
+		return n ? {
+			group: e.slice(0, t + 1) + "\0" + n[1].toLowerCase(),
+			number: parseInt(n[2], 10)
+		} : null;
+	}, r = t ? n(t) : null;
+	if (!r) return null;
+	let i = /* @__PURE__ */ new Map();
+	for (let t of e) {
+		let e = n(t);
+		e && e.group === r.group && !i.has(e.number) && i.set(e.number, t);
+	}
+	return i.size < 2 ? null : [...i].sort((e, t) => e[0] - t[0]).slice(0, vr).map(([e, t]) => ({
+		path: t,
+		number: e
+	}));
+}
+function Sr(e) {
+	let t = e instanceof Float32Array || e instanceof Int32Array || e instanceof Uint32Array ? new Uint32Array(e.buffer, e.byteOffset, e.length) : null;
+	t ||= new Uint32Array(Float32Array.from(e).buffer);
+	let n = 2166136261;
+	for (let e = 0; e < t.length; e++) n = Math.imul(n ^ t[e], 16777619), n ^= n >>> 15;
+	return (n >>> 0).toString(36) + ":" + e.length;
+}
+function Cr(e) {
+	let t = "";
+	for (let n of Object.keys(e).sort()) {
+		let { type: r, value: i } = e[n], a = ArrayBuffer.isView(i) || i.length > 16 && typeof i[0] == "number";
+		t += `${r} ${n}=${a ? "#" + Sr(i) : i.join(",")};`;
+	}
+	return t;
+}
+var wr = class {
+	constructor(e) {
+		this.materialNames = /* @__PURE__ */ new Map();
+		for (let [t, n] of e.namedMaterials) this.materialNames.set(n, t);
+		this.cache = /* @__PURE__ */ new Map();
+	}
+	of(e) {
+		return `${e.type}|${+!!e.reverseOrientation}|${Cr(e.params)}|${this._material(e.material)}|${this._light(e.areaLight)}`;
+	}
+	_material(e) {
+		if (!e) return "-";
+		let t = this.cache.get(e);
+		if (t === void 0) {
+			let n = this.materialNames.get(e) ?? e._missingRef;
+			t = n === void 0 ? "I:" + e.type + ":" + Cr(e.params) : "N:" + n, this.cache.set(e, t);
+		}
+		return t;
+	}
+	_light(e) {
+		if (!e) return "-";
+		let t = this.cache.get(e);
+		return t === void 0 && this.cache.set(e, t = "L:" + e.type + ":" + Cr(e.params)), t;
+	}
+};
+function Tr(e, t) {
+	let n = new Int32Array(t.length).fill(-1), r = 0;
+	for (; r < e.length && r < t.length && e[r] === t[r];) n[r] = r, r++;
+	let i = e.length, a = t.length;
+	for (; i > r && a > r && e[i - 1] === t[a - 1];) n[--a] = --i;
+	return r < i && r < a && !Er(e, r, i, t, r, a, n) && Or(e, r, i, t, r, a, n), n;
+}
+function Er(e, t, n, r, i, a, o) {
+	let s = n - t, c = a - i, l = Math.min(s + c, yr), u = l + 1, d = new Int32Array(2 * l + 3), f = [];
+	for (let n = 0; n <= l; n++) {
+		for (let a = -n; a <= n; a += 2) {
+			let l = a === -n || a !== n && d[u + a - 1] < d[u + a + 1] ? d[u + a + 1] : d[u + a - 1] + 1, p = l - a;
+			for (; l < s && p < c && e[t + l] === r[i + p];) l++, p++;
+			if (d[u + a] = l, l >= s && p >= c) return f.push(d.slice(u - n, u + n + 1)), Dr(f, s, c, t, i, o), !0;
+		}
+		f.push(d.slice(u - n, u + n + 1));
+	}
+	return !1;
+}
+function Dr(e, t, n, r, i, a) {
+	let o = t, s = n;
+	for (let t = e.length - 1; t > 0; t--) {
+		let n = e[t - 1], c = (e) => n[e + t - 1], l = o - s, u = l === -t || l !== t && c(l - 1) < c(l + 1) ? l + 1 : l - 1, d = c(u), f = d - u;
+		for (; o > d && s > f;) a[i + --s] = r + --o;
+		o = d, s = f;
+	}
+	for (; o > 0 && s > 0;) a[i + --s] = r + --o;
+}
+function Or(e, t, n, r, i, a, o) {
+	let s = /* @__PURE__ */ new Map();
+	for (let r = t; r < n; r++) {
+		let t = s.get(e[r]);
+		t ? t.push(r) : s.set(e[r], [r]);
+	}
+	let c = /* @__PURE__ */ new Map();
+	for (let e = i; e < a; e++) {
+		let t = s.get(r[e]);
+		if (!t) continue;
+		let n = c.get(r[e]) ?? 0;
+		n < t.length && (o[e] = t[n], c.set(r[e], n + 1));
+	}
+}
+function kr(e, t, n, r) {
+	for (let i = 0; i < 16; i++) if (e[t + i] !== n[r + i]) return !1;
+	return !0;
+}
+function Ar(e, t, n) {
+	let r = e.length, i = new Float32Array(16 * r), a = null, o = -1;
+	for (let e = 0; e < r; e++) if (t(e)) {
+		if (i.set(n(e), e * 16), o < 0) for (let t = 0; t < e; t++) i.copyWithin(t * 16, e * 16, e * 16 + 16);
+		o = e;
+	} else a ??= new Uint8Array(r).fill(1), a[e] = 0, o >= 0 && i.copyWithin(e * 16, o * 16, o * 16 + 16);
+	return {
+		times: e,
+		matrices: i,
+		visible: a
+	};
+}
+function jr(e) {
+	if (e.visible) return !1;
+	let t = e.matrices;
+	for (let e = 16; e < t.length; e += 16) if (!kr(t, 0, t, e)) return !1;
+	return !0;
+}
+var Mr = class {
+	constructor(e, t) {
+		this.times = Float32Array.from(e), this.name = t, this.base = null, this.frame = -1, this.keyIds = /* @__PURE__ */ new Map(), this.tracks = [], this.prev = null, this.placements = /* @__PURE__ */ new Map(), this.templates = /* @__PURE__ */ new Map(), this.cameras = [], this.warnings = /* @__PURE__ */ new Set();
+	}
+	addFrame(e) {
+		let t = ++this.frame;
+		t === 0 ? this.base = e : this._adoptDefinitions(e);
+		for (let t of e.warnings) this.warnings.add(t);
+		let n = new wr(e), r = new Int32Array(e.shapes.length);
+		for (let t = 0; t < r.length; t++) {
+			let i = n.of(e.shapes[t]), a = this.keyIds.get(i);
+			a === void 0 && this.keyIds.set(i, a = this.keyIds.size), r[t] = a;
+		}
+		let i = this.prev ? Tr(this.prev.keys, r) : null, a = Array(r.length);
+		for (let o = 0; o < r.length; o++) {
+			let r = e.shapes[o], s = i && i[o] >= 0 ? this.prev.tracks[i[o]] : null;
+			s ? (s.last = t, s.ctms ? s.ctms.push(r.ctm) : r.ctm !== s.shape.ctm && !kr(r.ctm, 0, s.shape.ctm, 0) && (s.ctms = Array(t - s.first).fill(s.shape.ctm), s.ctms.push(r.ctm))) : (s = {
+				shape: r,
+				first: t,
+				last: t,
+				ctms: null
+			}, t > 0 && this._adoptMaterial(r, n.materialNames), this.tracks.push(s)), a[o] = s;
+		}
+		this.prev = {
+			keys: r,
+			tracks: a
+		}, this._addPlacements(e, t, this._resolveTemplates(e, t, n)), this.cameras.push(e.camera ? {
+			cameraToWorld: e.camera.cameraToWorld,
+			fov: e.camera.params?.fov?.value?.[0]
+		} : null);
+	}
+	_adoptDefinitions(e) {
+		for (let [t, n] of e.namedMaterials) this.base.namedMaterials.has(t) || this.base.namedMaterials.set(t, n);
+		for (let [t, n] of e.namedTextures) this.base.namedTextures.has(t) || this.base.namedTextures.set(t, n);
+	}
+	_resolveTemplates(e, t, n) {
+		let r = /* @__PURE__ */ new Map();
+		for (let [i, a] of e.objects) {
+			let e = "";
+			for (let t of a) e += n.of(t) + "@" + Array.prototype.join.call(t.relativeCTM || t.ctm, ",") + ";";
+			let o = i + "\0" + e, s = this.templates.get(o);
+			if (s === void 0 && (s = t === 0 || !this.base.objects.has(i) ? i : `${i} @${t}`, this.templates.set(o, s), t > 0)) {
+				for (let e of a) this._adoptMaterial(e, n.materialNames);
+				this.base.objects.set(s, a);
+			}
+			r.set(i, s);
+		}
+		return r;
+	}
+	_adoptMaterial(e, t) {
+		let n = e.material && t.get(e.material);
+		n !== void 0 && (e.material = this.base.namedMaterials.get(n) ?? e.material);
+	}
+	_addPlacements(e, t, n) {
+		for (let [r, i] of e.instances) {
+			let e = n.get(r) ?? r, a = this.placements.get(e);
+			if (a || this.placements.set(e, a = {
+				counts: new Int32Array(this.times.length),
+				diffs: /* @__PURE__ */ new Map()
+			}), a.counts[t] = i.count, t === 0) continue;
+			let o = this.base.instances.get(e), s = o?.count ?? 0;
+			for (let e = 0; e < i.count; e++) {
+				let n = e * 16;
+				if (e < s && kr(i.matrices, n, o.matrices, n)) continue;
+				let r = a.diffs.get(e);
+				r || a.diffs.set(e, r = /* @__PURE__ */ new Map()), r.set(t, i.matrices.slice(n, n + 16));
+			}
+		}
+	}
+	finish() {
+		let e = this.base, t = this.times, n = this.frame + 1;
+		e.shapes = this.tracks.map((e) => {
+			let { shape: r, first: i, last: a, ctms: o } = e;
+			return (i > 0 || a < n - 1 || o) && (r.motion = Ar(t, (e) => e >= i && e <= a, (e) => o ? o[e - i] : r.ctm)), r;
+		}), e.warnings = [...this.warnings], e.animatedInstances = this._finishPlacements(e, t, n);
+		let r = this.cameras;
+		if (r[0] && r.every(Boolean)) {
+			let n = Ar(t, () => !0, (e) => r[e].cameraToWorld), i = r.map((e) => e.fov ?? r[0].fov), a = i.some((e) => e !== i[0]);
+			(!jr(n) || a) && (e.camera.motion = {
+				...n,
+				fov: a ? Float32Array.from(i) : null
+			});
+		}
+		return e.animation = {
+			name: this.name,
+			duration: t[n - 1],
+			frames: n
+		}, e;
+	}
+	_finishPlacements(e, t, n) {
+		let r = [], i = 0;
+		for (let [a, { counts: o, diffs: s }] of this.placements) {
+			let c = e.instances.get(a), l = c?.count ?? 0, u = Math.max(...o.subarray(0, n)), d = [];
+			for (let e = 0; e < u; e++) {
+				let u = s.get(e), f = !!u;
+				for (let t = 0; t < n && !f; t++) f = e >= o[t];
+				if (f && r.length < br) {
+					let n = Ar(t, (t) => e < o[t], (t) => u?.get(t) ?? c.matrices.subarray(e * 16, e * 16 + 16));
+					r.push({
+						name: a,
+						motion: n
+					});
+				} else f && i++, e < l && d.push(e);
+			}
+			if (c && d.length !== l) {
+				let t = new Float32Array(d.length * 16);
+				d.forEach((e, n) => t.set(c.matrices.subarray(e * 16, e * 16 + 16), n * 16)), e.instanceCount -= l - d.length, c.matrices = t, c.matricesEnd = null, c.count = d.length;
+			}
+		}
+		return i > 0 && e.warnings.push(`${i.toLocaleString()} moving placement(s) past ${br.toLocaleString()} left static`), r;
+	}
+};
+function Nr(e) {
+	if (!e.hasMotion) return e;
+	let { start: t, end: n } = e.transformTimes, r = n - t;
+	if (!(r > 0)) return e;
+	let i = Float32Array.of(0, r), a = (e, t, n, r) => {
+		let a = new Float32Array(32);
+		for (let i = 0; i < 16; i++) a[i] = e[t + i], a[16 + i] = n[r + i];
+		return {
+			times: i,
+			matrices: a,
+			visible: null
+		};
+	};
+	for (let t of e.shapes) t.ctmEnd && (t.motion = a(t.ctm, 0, t.ctmEnd, 0));
+	e.animatedInstances = [];
+	for (let t of e.instances.values()) {
+		if (!t.matricesEnd) continue;
+		let n = [];
+		for (let r = 0; r < t.count; r++) {
+			let i = r * 16;
+			kr(t.matrices, i, t.matricesEnd, i) || e.animatedInstances.length >= br ? n.push(r) : e.animatedInstances.push({
+				name: t.name,
+				motion: a(t.matrices, i, t.matricesEnd, i)
+			});
+		}
+		if (n.length !== t.count) {
+			let r = new Float32Array(n.length * 16);
+			n.forEach((e, n) => r.set(t.matrices.subarray(e * 16, e * 16 + 16), n * 16)), e.instanceCount -= t.count - n.length, t.matrices = r, t.count = n.length;
+		}
+		t.matricesEnd = null;
+	}
+	return e.camera?.cameraToWorldEnd && (e.camera.motion = {
+		...a(e.camera.cameraToWorld, 0, e.camera.cameraToWorldEnd, 0),
+		fov: null
+	}), e.animation = {
+		name: "Shutter motion",
+		duration: r,
+		frames: 2
+	}, e;
+}
+//#endregion
+//#region src/Processor/PBRT/index.js
+var Pr = 2e6, Fr = new TextDecoder();
+function Ir(e) {
+	let t = e.replace(/\\/g, "/").split("/"), n = [];
+	for (let e of t) e === "" || e === "." || (e === ".." ? n.pop() : n.push(e));
+	return n.join("/");
+}
+function Lr(e, t) {
+	return !e || t.startsWith("/") ? Ir(t) : Ir(`${e}/${t}`);
+}
+var Rr = class {
+	constructor(e, t = null) {
+		this.entries = e, this.source = t, this.records = [], this.byPath = /* @__PURE__ */ new Map(), this.byBase = /* @__PURE__ */ new Map();
+		let n = (e, t, n) => {
+			let r = Ir(e).toLowerCase();
+			if (this.byPath.has(r)) return;
+			let i = {
+				key: e,
+				norm: r,
+				bytes: t,
+				lazy: n
+			};
+			this.records.push(i), this.byPath.set(r, i);
+			let a = r.split("/").pop(), o = this.byBase.get(a);
+			o ? o.push(i) : this.byBase.set(a, [i]);
+		};
+		for (let t in e) n(t, e[t], !1);
+		for (let e of t?.listing ?? []) e.offset !== void 0 && n(e.path, null, !0);
+	}
+	async read(e) {
+		return e ? e.bytes ? e.bytes : !e.lazy || !this.source ? null : this.source.read(e.key) : null;
+	}
+	async readHead(e, t) {
+		return e ? e.bytes ? e.bytes.subarray(0, t) : !e.lazy || !this.source ? null : this.source.readHead ? this.source.readHead(e.key, t) : this.source.read(e.key) : null;
+	}
+	async readPath(e, t = null) {
+		let n = t !== null && this.findRecord(Lr(t, e)) || this.findRecord(e);
+		return this.read(n);
+	}
+	release(e) {
+		e.bytes = null, delete this.entries[e.key];
+	}
+	releasePath(e, t = null, n = null) {
+		let r = t !== null && this.findRecord(Lr(t, e)) || this.findRecord(e);
+		r?.lazy && (this.release(r), H(n));
+	}
+	releaseScenes() {
+		for (let e of this.records) e.norm.endsWith(".pbrt") && this.release(e);
+	}
+	findRecord(e) {
+		let t = Ir(e).toLowerCase();
+		if (this.byPath.has(t)) return this.byPath.get(t);
+		let n = this.byBase.get(t.split("/").pop());
+		return n ? n.find((e) => e.norm.endsWith("/" + t)) || (n.length === 1 ? n[0] : null) : null;
+	}
+	find(e) {
+		return this.findRecord(e)?.bytes ?? null;
+	}
+};
+function zr(e, t, n = 0) {
+	let r = t[0], i = e.length - t.length;
+	outer: for (let a = n; a <= i; a++) if (e[a] === r) {
+		for (let n = 1; n < t.length; n++) if (e[a + n] !== t[n]) continue outer;
+		return a;
+	}
+	return -1;
+}
+var Br = (e) => Uint8Array.from(e, (e) => e.charCodeAt(0)), Vr = 4 * 1024 * 1024, Hr = Br("WorldBegin"), Ur = [Br("Include"), Br("Import")];
+function Wr(e, t) {
+	for (let n = t - 1; n >= 0; n--) {
+		let t = e[n];
+		if (t === 10) return !0;
+		if (t !== 32 && t !== 9) return !1;
+	}
+	return !0;
+}
+function Gr(e) {
+	for (let t = zr(e, Hr); t >= 0; t = zr(e, Hr, t + 1)) if (Wr(e, t)) return !0;
+	return !1;
+}
+function Kr(e, t) {
+	for (let n of Ur) for (let r = zr(e, n); r >= 0; r = zr(e, n, r + 1)) {
+		if (!Wr(e, r)) continue;
+		let i = r + n.length;
+		for (; i < e.length && (e[i] === 32 || e[i] === 9);) i++;
+		if (e[i] !== 34) continue;
+		let a = ++i;
+		for (; i < e.length && e[i] !== 34 && e[i] !== 10;) i++;
+		if (e[i] !== 34) continue;
+		let o = Fr.decode(e.subarray(a, i));
+		t.add(Ir(o).toLowerCase().split("/").pop());
+	}
+}
+function qr(e) {
+	let t = Object.keys(e).filter((e) => e.toLowerCase().endsWith(".pbrt"));
+	if (t.length <= 1) return t;
+	let n = /* @__PURE__ */ new Set(), r = /* @__PURE__ */ new Map();
+	for (let i of t) {
+		let t = e[i];
+		r.set(i, Gr(t)), Kr(t, n);
+	}
+	return Jr(t, r, n);
+}
+function Jr(e, t, n) {
+	let r = (e, t) => {
+		let n = e.filter(t);
+		return n.length ? n : e;
+	}, i = r(e, (e) => t.get(e));
+	return i = r(i, (e) => !n.has(e.toLowerCase().split("/").pop())), i = r(i, (e) => /(^|\/)(scene|main)\.pbrt$/i.test(e)), i.sort((e, t) => {
+		let n = e.split("/").length, r = t.split("/").length;
+		return n === r ? e.length === t.length ? e < t ? -1 : +(e > t) : e.length - t.length : n - r;
+	});
+}
+function Yr(e) {
+	return qr(e)[0] || null;
+}
+async function Xr(e) {
+	let t = e.records.filter((e) => e.norm.endsWith(".pbrt"));
+	if (t.length === 0) return [];
+	if (t.length === 1) return [t[0].key];
+	let n = async (n) => {
+		let r = /* @__PURE__ */ new Set(), i = /* @__PURE__ */ new Map(), a = !1;
+		for (let o of t) {
+			let t = await n(o);
+			t && (i.set(o.key, Gr(t)), Kr(t, r), t.length >= Vr && (a = !0), o.lazy && (e.release(o), H(t)));
+		}
+		return {
+			included: r,
+			worlds: i,
+			cut: a
+		};
+	}, r = await n((t) => e.readHead(t, Vr)), { included: i, worlds: a } = [...r.worlds.values()].filter(Boolean).length === 1 || !r.cut ? r : await n((t) => e.read(t));
+	return Jr(t.map((e) => e.key), a, i);
+}
+async function Zr(e) {
+	let { vfs: t, source: n, plyParser: r, imageFromBytes: i, envFromBytes: a, convertHandedness: o } = e, s = new Rr(t, n), c = [], l = await Xr(s);
+	if (l.length === 0) throw Error("PBRT loader: no .pbrt file found in archive");
+	let u = e.entryPath && l.includes(e.entryPath) ? e.entryPath : null;
+	e.entryPath && !u && c.push(`PBRT entry "${e.entryPath}" is not a scene in this archive — auto-detecting instead`);
+	let d = u || l[0], f = async (t) => {
+		let n = await s.readPath(t);
+		if (!n) throw Error(`PBRT loader: entry "${t}" not readable`);
+		let r = await new cn({
+			resolveInclude: (e, t) => s.readPath(e, t),
+			releaseInclude: (e, t, n) => s.releasePath(e, t, n),
+			maxPlacements: e.maxPlacements,
+			instanceIncludes: e.instanceIncludes
+		}).parse(n, t.includes("/") ? t.slice(0, t.lastIndexOf("/")) : "");
+		return s.releasePath(t, null, n), r;
+	}, p = performance.now(), m = !u && e.animation !== !1 ? xr(l) : null, h;
+	if (m) {
+		let e = await f(m[0].path);
+		if (e.shapes.length + e.instanceCount > Pr) c.push(`${m.length} animation frames found, but the scene is too large to parse once per frame — loaded "${m[0].path}" only`), m = null, h = Nr(e);
+		else {
+			let t = new Mr(m.map((e) => (e.number - m[0].number) / 30), Qr(m));
+			t.addFrame(e);
+			for (let e = 1; e < m.length; e++) t.addFrame(await f(m[e].path));
+			h = t.finish();
+		}
+	} else h = Nr(await f(d));
+	let g = performance.now() - p;
+	s.releaseScenes();
+	let _ = (e) => e.byteOffset === 0 && e.byteLength === e.buffer.byteLength ? e.buffer : e.buffer.slice(e.byteOffset, e.byteOffset + e.byteLength), v = /* @__PURE__ */ new Map(), y = async (e) => {
+		let t = await s.read(e);
+		return t ? (s.release(e), r(_(t))) : null;
+	}, b = new _r({
+		convertHandedness: o,
+		maxTriangles: e.maxTriangles,
+		maxPlacements: e.maxPlacements,
+		mergeShapesAbove: e.mergeShapesAbove,
+		curveSteps: e.curveSteps,
+		curveSides: e.curveSides,
+		curveTolerance: e.curveTolerance,
+		resolvePLY: async (e) => {
+			let t = s.findRecord(e);
+			return t ? (v.has(t.norm) || v.set(t.norm, await y(t)), v.get(t.norm)) : null;
+		},
+		resolveImage: async (e) => {
+			let t = await s.readPath(e);
+			return t ? i(t, e) : null;
+		},
+		resolveEnvironment: async (e) => {
+			let t = await s.readPath(e);
+			return t ? (a || i)(t, e) : null;
+		}
+	}), x = performance.now(), S = await b.build(h);
+	return {
+		...S,
+		entryPath: m ? m[0].path : d,
+		frames: m ? m.map((e) => e.path) : null,
+		candidates: l,
+		warnings: [...c, ...S.warnings ?? []],
+		parseMs: g,
+		buildMs: performance.now() - x
+	};
+}
+function Qr(e) {
+	let t = e[0].path.split("/");
+	return `${t.length > 1 ? t[t.length - 2] : t[0].replace(/\d+\.pbrt$/i, "") || "frames"} · frames ${e[0].number}–${e[e.length - 1].number}`;
+}
+//#endregion
+//#region src/Processor/PBRT/PFM.js
+function $r(e) {
+	let t = 0, n = () => {
+		for (; t < e.length && e[t] <= 32;) t++;
+		let n = t;
+		for (; t < e.length && e[t] > 32;) t++;
+		return String.fromCharCode(...e.subarray(n, t));
+	}, r = n();
+	if (r !== "PF" && r !== "Pf") throw Error("not a PFM image");
+	let i = parseInt(n(), 10), a = parseInt(n(), 10), o = parseFloat(n());
+	t++;
+	let s = r === "PF" ? 3 : 1, c = i * a;
+	if (!(i > 0 && a > 0) || !Number.isFinite(o) || o === 0) throw Error("bad PFM header");
+	if (e.length - t < c * s * 4) throw Error("PFM image is truncated");
+	let l = new DataView(e.buffer, e.byteOffset + t, c * s * 4), u = o < 0, d = Math.abs(o), f = new Float32Array(c * 4);
+	for (let e = 0; e < c; e++) {
+		for (let t = 0; t < 3; t++) f[e * 4 + t] = l.getFloat32((e * s + (s === 3 ? t : 0)) * 4, u) * d;
+		f[e * 4 + 3] = 1;
+	}
+	return {
+		data: f,
+		width: i,
+		height: a
+	};
+}
+function ei(e) {
+	let { data: t, width: n, height: r } = $r(e), i = new b(t, n, r, P, T);
+	return i.minFilter = A, i.magFilter = A, i.needsUpdate = !0, i;
+}
+//#endregion
+//#region src/Processor/ArchiveImporter.js
+var ti = /* @__PURE__ */ e({
+	ARCHIVE_ELEMENT_PROMPT_BYTES: () => ai,
+	ArchiveImporter: () => oi
+}), ni = /\.(usd|usda|usdc)$/i, ri = /\.(png|jpg|jpeg|avif)$/i, ii = 3e4, ai = 4e9, oi = class e {
+	static FORMATS = f;
+	constructor(e) {
+		this.loader = e, this._pendingGraph = null, this.lastPBRTStats = null;
+	}
+	release() {
+		this._pendingGraph = null;
+	}
+	async _readHead(e, t = 512) {
+		return e instanceof Uint8Array ? e.subarray(0, t) : typeof e.slice == "function" && typeof e.arrayBuffer == "function" ? new Uint8Array(await e.slice(0, t).arrayBuffer()) : new Uint8Array((await this.loader.readFileAsArrayBuffer(e)).slice(0, t));
+	}
+	async inspectArchive(e) {
+		let n = Te(await this._readHead(e)), r = (e) => t({
+			isLoading: !0,
+			status: `Scanning archive… ${(e.bytes / 1e9).toFixed(1)} GB`,
+			progress: 4
+		}), i;
+		if (n === "gzip") {
+			let t = await this._unpackGzip(e, e.name);
+			t ? (i = t.index.listing, t.release()) : {listing: i} = await Le(e, {
+				filter: () => !1,
+				onProgress: r
+			});
+		} else i = n === "tar" ? (await Je(e, this.loader.storage))?.listing ?? await ze(e, { onProgress: r }) : (await p(e)).map((e) => ({
+			path: e.name,
+			size: e.size
+		}));
+		let { root: a, elements: o } = Ue(i);
+		return {
+			kind: n ?? "zip",
+			root: a,
+			elements: o,
+			entryCount: i.length,
+			totalBytes: i.reduce((e, t) => e + t.size, 0)
+		};
+	}
+	async _unpackGzip(e, n) {
+		try {
+			return await qe(e, {
+				storage: this.loader.storage,
+				label: n,
+				onProgress: (e) => t({
+					isLoading: !0,
+					status: `Unpacking archive… ${(e / 1e9).toFixed(1)} GB`,
+					progress: 4
+				})
+			});
+		} catch (e) {
+			return console.warn(`Unpacking "${n}" to storage failed, reading it in memory: ${e.message}`), null;
+		}
+	}
+	async loadArchiveFromFile(e, t, { pbrtEntry: n = null, element: r = null, byteBudget: i, promptBytes: a, ...o } = {}) {
+		try {
+			let s = Te(await this._readHead(e)), c = this.loader.storage ? u(await l(e)) : null, d = {
+				element: r,
+				promptBytes: a,
+				pbrtEntry: n,
+				pbrt: o,
+				archiveId: c
+			};
+			if (s === "tar") return await this._loadSeekable(e, t, d);
+			if (s === "gzip") {
+				let a = await this._unpackGzip(e, t);
+				if (a) try {
+					return await this._loadSeekable(a.file, t, {
+						...d,
+						index: a.index
+					});
+				} finally {
+					a.release();
+				}
+				let l = await this._readStreamedArchive(e, t, s, r, i);
+				if (Yr(l)) return await this.loadPBRTFromZip(l, t, n, o);
+				let u = await this._loadNonPBRTArchive(l, t);
+				return this.loader._sourceKey = this.loader._keyed("archive", c), u;
+			}
+			return await this._loadSeekable(e, t, {
+				...d,
+				zip: !0
+			});
+		} catch (e) {
+			throw e?.code !== "ARCHIVE_NEEDS_ELEMENT" && console.error("Error loading archive:", e), e;
+		}
+	}
+	async _loadNonPBRTArchive(e, t) {
+		return await this.processObjMtlPairsInZip(e, t) || await this.findAndLoadModelFromZip(e, t);
+	}
+	async _loadSeekable(e, t, { element: n, promptBytes: r, pbrtEntry: i, pbrt: a, index: o = null, zip: s = !1, archiveId: c = null }) {
+		let l = await this._openSeekableArchive(e, t, n, r, {
+			index: o,
+			zip: s
+		});
+		if (l.archiveId = c, l.elements = (Array.isArray(n) ? n : [n]).filter(Boolean), l.listing.some((e) => e.path.toLowerCase().endsWith(".pbrt"))) return await this.loadPBRTFromZip({}, t, i, a, l);
+		for (let e of l.listing) e.offset !== void 0 && (l.entries[e.path] ??= await l.read(e.path));
+		let u = await this._loadNonPBRTArchive(l.entries, t);
+		return this.loader._sourceKey = this.loader._keyed("archive", c), u;
+	}
+	async _loadStoredGraph(e, n, { imageFromBytes: r, envFromBytes: i }) {
+		let o = this.loader.storage?.area(s.SCENES), c = o ? await o.open(e) : null;
+		if (!c) return null;
+		let l = performance.now(), u = null;
+		try {
+			t({
+				isLoading: !0,
+				status: "Opening the stored scene...",
+				progress: 6
+			});
+			let e = await c.json("graph.json"), a = await c.file("data.bin"), o = new Rr({}, n), s = await xt(e, a, { loadTexture: async (e, t) => {
+				let n = await o.readPath(e);
+				return n ? t === "environment" ? i(n, e) : r(n, e) : null;
+			} });
+			return {
+				...s.stats,
+				group: s.root,
+				environment: s.environment ? { texture: s.environment } : null,
+				animations: s.animations,
+				report: null,
+				parseMs: 0,
+				buildMs: performance.now() - l,
+				fromStorage: !0
+			};
+		} catch (e) {
+			return u = e, null;
+		} finally {
+			c.release(), u && (console.warn(`The stored scene could not be used, parsing the archive instead: ${u.message}`), this.loader._issues?.warn(a.STORAGE_ENTRY_CORRUPT, `stored scene unusable: ${u.message}`, { key: e }), o.remove(e).catch(() => {}));
+		}
+	}
+	_storeGraph(e, t, r) {
+		let i = this.loader.storage?.area(s.SCENES);
+		if (!i) return;
+		let a;
+		try {
+			a = mt(t.group, {
+				environment: t.environment?.texture ?? null,
+				animations: t.animations ?? [],
+				stats: {
+					meshCount: t.meshCount,
+					entryPath: t.entryPath,
+					candidates: t.candidates,
+					frames: t.frames,
+					warnings: t.warnings,
+					triangleCount: t.triangleCount,
+					placementCount: t.placementCount,
+					mergedShapes: t.mergedShapes,
+					skippedForBudget: t.skippedForBudget,
+					droppedNoTemplate: t.droppedNoTemplate
+				}
+			});
+		} catch (e) {
+			e instanceof V ? console.info(`Scene not stored for next time: ${e.message}`) : console.warn("Scene not stored for next time:", e);
+			return;
+		}
+		let o = {
+			key: e,
+			encoded: a,
+			label: r,
+			parseMs: (t.parseMs ?? 0) + (t.buildMs ?? 0),
+			triangles: t.triangleCount ?? null
+		};
+		n(o.parseMs, a.byteLength) ? this._writeGraph(i, o) : this._pendingGraph = o;
+	}
+	flushPendingGraph(e) {
+		let t = this._pendingGraph;
+		this._pendingGraph = null;
+		let r = this.loader.storage?.area(s.SCENES);
+		!t || !r || !n(t.parseMs + e, t.encoded.byteLength) || this._writeGraph(r, t);
+	}
+	_writeGraph(e, t) {
+		(async () => {
+			let n = await e.create(t.key, {
+				label: `${t.label} (scene)`,
+				expectedBytes: t.encoded.byteLength
+			});
+			if (n) try {
+				await ht(n, t.encoded, { release: !0 }), await n.commit({ triangles: t.triangles });
+			} catch (e) {
+				await n.abort(), console.warn("Storing the scene failed:", e);
+			}
+		})().catch((e) => console.warn("Storing the scene failed:", e));
+	}
+	async _openSeekableArchive(e, n, r, i, { index: a = null, zip: o = !1 } = {}) {
+		let s = Array.isArray(r) ? r.filter(Boolean) : r ? [r] : [], c = s.length ? He(s) : null, l;
+		if (o) l = await m(e, { filter: c });
+		else {
+			let n = a ?? await Je(e, this.loader.storage);
+			l = await Ve(e, {
+				index: n,
+				headersOnly: !0,
+				filter: c,
+				onProgress: (e) => t({
+					isLoading: !0,
+					status: `Indexing archive… ${(e.bytes / 1e9).toFixed(1)} GB`,
+					progress: 4
+				})
+			}), n || Ye(e, this.loader.storage, l.index).catch(() => {});
+		}
+		let u = l.listing.reduce((e, t) => e + t.size, 0);
+		return s.length === 0 && this._requireElementChoice(n, l.listing, u, i), console.info(`Archive "${n}": indexed ${l.indexed} entries, ${(u / 1e9).toFixed(1)} GB, none resident` + (s.length ? `, ${s.length} part${s.length > 1 ? "s" : ""} selected.` : ".")), l;
+	}
+	_requireElementChoice(e, t, n, r = ai) {
+		if (n < r) return;
+		let { root: i, elements: s } = Ue(t);
+		if (s.length < 2) return;
+		let c = /* @__PURE__ */ Error(`"${e}" holds ${(n / 1e9).toFixed(1)} GB across ${s.length} parts. Choose which to load — loading all of them at once may exhaust memory.`);
+		throw c.code = "ARCHIVE_NEEDS_ELEMENT", c.root = i, c.elements = s, c.totalBytes = n, this.loader._issues?.record(a.ASSET_ARCHIVE_TOO_LARGE, `archive holds ${(n / 1e9).toFixed(1)} GB across ${s.length} parts; choose which to load`, {
+			root: i,
+			elements: s.map((e) => e.prefix),
+			totalBytes: n
+		}, o.WARNING), c;
+	}
+	async _readStreamedArchive(e, n, r, i, s) {
+		let c = Array.isArray(i) ? i.filter(Boolean) : i ? [i] : [], { entries: l, listing: u, retainedBytes: d, truncated: f } = await Le(e, {
+			filter: c.length ? He(c) : null,
+			...s === void 0 ? {} : { byteBudget: s },
+			onProgress: (e) => t({
+				isLoading: !0,
+				status: `Reading archive… ${(e.bytes / 1e9).toFixed(1)} GB`,
+				progress: 4
+			})
+		});
+		if (f && c.length === 0) {
+			let { root: e, elements: t } = Ue(u), r = u.reduce((e, t) => e + t.size, 0), i = /* @__PURE__ */ Error(`"${n}" unpacks to ${(r / 1e9).toFixed(1)} GB, past the load budget. Load one of its ${t.length} parts instead.`);
+			throw i.code = "ARCHIVE_NEEDS_ELEMENT", i.root = e, i.elements = t, i.totalBytes = r, this.loader._issues?.record(a.ASSET_ARCHIVE_TOO_LARGE, `archive unpacks to ${(r / 1e9).toFixed(1)} GB; choose one of ${t.length} parts`, {
+				root: e,
+				elements: t.map((e) => e.prefix),
+				totalBytes: r
+			}, o.WARNING), i;
+		}
+		if (f) {
+			let e = He(c), t = u.filter((t) => e(t.path, t.size) && !l[t.path]).length;
+			this.loader._issues?.record(a.ASSET_ARCHIVE_TOO_LARGE, `${t} files of the chosen parts were left out: they did not fit the ${((s ?? 15e8) / 1e9).toFixed(1)} GB in-memory read budget`, {
+				elements: c,
+				missing: t,
+				retainedBytes: d
+			}, o.WARNING);
+		}
+		return c.length && console.info(`Archive "${n}": loaded ${c.map((e) => `"${e}"`).join(", ")} — ${Object.keys(l).length} of ${u.length} files, ${(d / 1048576).toFixed(1)} MB.`), l;
+	}
+	async loadPBRTFromZip(e, n, s = null, l = {}, u = null) {
+		if (t({
+			isLoading: !0,
+			status: "Parsing PBRT scene...",
+			progress: 5
+		}), !this.loader.loaderCache.ply) {
+			let { PLYLoader: e } = await import("three/examples/jsm/loaders/PLYLoader.js");
+			this.loader.loaderCache.ply = new e();
+		}
+		let d = (e) => this.loader.loaderCache.ply.parse(e), f = async (e, t) => {
+			let n = await this._pbrtTextureFromBytes(e, t);
+			return n && (n.userData[Ze] = t), n;
+		}, p = async (e, t) => {
+			let n = t.split(".").pop().toLowerCase(), i = new Blob([e]), a = n === "pfm" ? null : URL.createObjectURL(i);
+			try {
+				let o = a ? await this.loader.loadEnvironmentByExtension(a, n, { loader: n === "exr" ? this._exrLoader() : null }) : ei(e);
+				return o.mapping = C, r(o, `bytes:${await c(i)}`), o.userData[Ze] = t, o.userData[Qe] = "environment", o;
+			} finally {
+				a && URL.revokeObjectURL(a);
+			}
+		}, m = performance.now(), h = {
+			animation: l.animation,
+			maxTriangles: l.maxTriangles,
+			maxPlacements: l.maxPlacements,
+			mergeShapesAbove: l.mergeShapesAbove,
+			curveSteps: l.curveSteps,
+			curveSides: l.curveSides,
+			curveTolerance: l.curveTolerance,
+			instanceIncludes: l.instanceIncludes
+		}, g = u?.archiveId ? this.loader._keyed(`pbrt:2.8:${i}`, `${u.archiveId}|${s ?? ""}|${[...u.elements ?? []].sort().join(",")}|${JSON.stringify(h)}`) : null, _ = g ? await this._loadStoredGraph(g, u, {
+			imageFromBytes: f,
+			envFromBytes: p
+		}) : null, v = _ ?? await Zr({
+			vfs: e,
+			source: u,
+			entryPath: s,
+			plyParser: d,
+			imageFromBytes: f,
+			envFromBytes: p,
+			...h
+		}), { group: y, environment: b, animations: x, report: S, warnings: w, meshCount: T, entryPath: E, candidates: D, frames: O, parseMs: k, buildMs: A, triangleCount: j, placementCount: M, mergedShapes: N, skippedForBudget: ee, droppedNoTemplate: te } = v;
+		_ && console.info(`PBRT scene "${E}" opened from storage in ${(A / 1e3).toFixed(1)} s, skipping the parse`), this.lastPBRTStats = {
+			parseMs: k,
+			buildMs: A,
+			loaderMs: performance.now() - m,
+			triangleCount: j,
+			placementCount: M,
+			mergedShapes: N,
+			skippedForBudget: ee,
+			droppedNoTemplate: te,
+			meshCount: T,
+			frames: O?.length ?? 1
+		};
+		let ne = new Set(O ?? [E]), re = D.filter((e) => !ne.has(e));
+		if (re.length > 0 && (console.warn(`PBRT archive holds ${D.length} scenes; loaded "${E}". Others: ${re.join(", ")}`), this.loader._issues?.record(a.ASSET_AMBIGUOUS_ENTRY, `archive holds ${D.length} pbrt scenes; loaded "${E}"`, {
+			loaded: E,
+			alternatives: re
+		}, o.WARNING)), S && S.length && typeof console.table == "function") {
+			let e = S.length < T ? ` (first ${S.length} of ${T})` : "";
+			console.groupCollapsed(`PBRT loader: ${T} mesh(es) from "${E}"${e}`), console.table(S), console.groupEnd();
+		}
+		return w && w.length && (console.warn(`PBRT loader: ${w.length} warning(s) parsing "${E}"`), w.forEach((e) => console.warn("  •", e))), b?.texture && (b.texture.generateMipmaps = !0, this.loader.applyEnvironmentToScene(b.texture)), y.name = E || n, this.loader.releaseTargetModel(), this.loader._sourceKey = g, g && !_ && this._storeGraph(g, v, n), this.loader.targetModel = y, this.loader.animations = x ?? [], this.loader.sceneMetadata = { environment: b?.texture ? {
+			rotation: 0,
+			intensity: 1
+		} : { enabled: !1 } }, t({
+			isLoading: !0,
+			status: "Processing PBRT geometry...",
+			progress: 10
+		}), await this.loader.onModelLoad(this.loader.targetModel), this.loader.dispatchEvent({
+			type: "load",
+			model: y,
+			filename: `${E} (from ZIP)`
+		}), y;
+	}
+	_exrLoader() {
+		return this.loader.loaderCache.exr ??= new ve().setDataType(T);
+	}
+	async _pbrtTextureFromBytes(e, t) {
+		let n = t.split(".").pop().toLowerCase(), r;
+		if (n === "exr" || n === "hdr") {
+			let t = n === "hdr" ? this.loader.loaderCache.hdr || (this.loader.loaderCache.hdr = new he().setDataType(T)) : this._exrLoader();
+			r = await this._loadViaObjectURL(t, e);
+		} else if (n === "pfm") r = ei(e);
+		else if (n === "tga") {
+			if (!this.loader.loaderCache.tga) {
+				let { TGALoader: e } = await import("three/examples/jsm/loaders/TGALoader.js");
+				this.loader.loaderCache.tga = new e();
+			}
+			r = await this._loadViaObjectURL(this.loader.loaderCache.tga, e), r.colorSpace = F;
+		} else r = new pe(await createImageBitmap(new Blob([e]))), r.colorSpace = F;
+		return r.wrapS = r.wrapT = ue, r.needsUpdate = !0, r;
+	}
+	async _loadViaObjectURL(e, t) {
+		let n = URL.createObjectURL(new Blob([t]));
+		try {
+			return await e.loadAsync(n);
+		} finally {
+			URL.revokeObjectURL(n);
+		}
+	}
+	async processObjMtlPairsInZip(e, t) {
+		let n = [], r = [];
+		for (let t in e) {
+			let i = t.toLowerCase();
+			i.endsWith(".obj") ? n.push({
+				path: t,
+				content: e[t]
+			}) : i.endsWith(".mtl") && r.push({
+				path: t,
+				content: e[t]
+			});
+		}
+		if (n.length > 0 && r.length > 0) {
+			console.log(`Found ${n.length} OBJ files and ${r.length} MTL files in ZIP`);
+			let i = this.findMatchingObjMtlPairs(n, r);
+			if (i.length > 0) return console.log(`Found ${i.length} matching OBJ+MTL pairs`), await this.loadOBJMTLPairFromZip(i[0].obj, i[0].mtl, e, t);
+			if (i.length === 0) return console.log("No matching pairs by name, using first OBJ and MTL files"), await this.loadOBJMTLPairFromZip(n[0], r[0], e, t);
+		}
+		return null;
+	}
+	findMatchingObjMtlPairs(e, t) {
+		let n = [];
+		for (let r of e) {
+			let e = r.path.split("/").pop().replace(/\.obj$/i, "").toLowerCase();
+			for (let i of t) {
+				let t = i.path.split("/").pop().replace(/\.mtl$/i, "").toLowerCase();
+				if (e === t || e.includes(t) || t.includes(e)) {
+					n.push({
+						obj: r,
+						mtl: i
+					});
+					break;
+				}
+			}
+		}
+		return n;
+	}
+	async findAndLoadModelFromZip(e) {
+		for (let t of [
+			"scene.gltf",
+			"scene.glb",
+			"model.gltf",
+			"model.glb",
+			"main.gltf",
+			"main.glb",
+			"asset.gltf",
+			"asset.glb"
+		]) if (e[t]) {
+			console.log(`Found main model file: ${t}`);
+			let n = t.split(".").pop().toLowerCase();
+			return await this.loadModelFromZipEntry(e[t], t, n, e);
+		}
+		for (let t in e) {
+			let n = t.split(".").pop().toLowerCase();
+			if (n === "obj" || this.loader.getFileFormat(t)?.type === "model") return ni.test(t) ? await this.loadUSDHierarchyFromZip(e) : (console.log(`Loading model file from ZIP: ${t}`), await this.loadModelFromZipEntry(e[t], t, n, e));
+		}
+		throw Error("No supported model files found in the ZIP archive");
+	}
+	async loadUSDHierarchyFromZip(t) {
+		let n = Object.keys(t).filter((e) => ni.test(e));
+		if (n.length === 0) throw Error("No USD layers found in the ZIP archive");
+		let r = e._pickUSDRootLayer(n);
+		console.log(`Loading USD scene from ZIP: ${r} (${n.length} layers)`);
+		let i = { [r]: [t[r], { level: 0 }] };
+		for (let e of Object.keys(t)) e !== r && (ni.test(e) || ri.test(e)) && (i[e] = [t[e], { level: 0 }]);
+		return await this.loader._loadModelFileByExtension(new File([_e(i)], r), r);
+	}
+	static _pickUSDRootLayer(e) {
+		let t = (e) => e.split("/").length, n = Math.min(...e.map(t)), r = e.filter((e) => t(e) === n);
+		return r.find((e) => {
+			let t = e.split("/");
+			return t.length > 1 && t[t.length - 1].replace(ni, "") === t[t.length - 2];
+		}) || r[0];
+	}
+	async loadModelFromZipEntry(e, n, r, i) {
+		try {
+			t({
+				isLoading: !0,
+				status: `Processing ${r.toUpperCase()} from ZIP...`,
+				progress: 5
+			});
+			let a = new Blob([e.buffer], { type: "application/octet-stream" }), o = URL.createObjectURL(a), s;
+			switch (r) {
+				case "glb":
+				case "gltf":
+					s = await this.handleGltfFromZip(r, e, n, i);
+					break;
+				case "obj":
+					s = await this.handleObjFromZip(e, n, i);
+					break;
+				default: s = await this.loader._loadModelFileByExtension(new File([e], n), n);
+			}
+			return URL.revokeObjectURL(o), this.loader.dispatchEvent({
+				type: "load",
+				model: this.loader.targetModel,
+				filename: `${n} (from ZIP)`
+			}), s;
+		} catch (e) {
+			throw console.error(`Error loading ${r} from ZIP:`, e), this.loader.dispatchEvent({
+				type: "error",
+				message: e.message,
+				filename: n
+			}), e;
+		}
+	}
+	async handleGltfFromZip(e, t, n, r) {
+		if (e === "gltf") {
+			let e = R(t), i = new j(), a = n.split("/").slice(0, -1).join("/");
+			i.setURLModifier((e) => this.resolveZipResource(e, a, r));
+			let o = await this.loader.createGLTFLoader();
+			o.manager = i;
+			try {
+				return await new Promise((t, n) => {
+					o.parse(e, "", (e) => {
+						try {
+							this.loader._throwDeferred();
+						} catch (e) {
+							n(e);
+							return;
+						}
+						this.loader.releaseTargetModel(), this.loader.targetModel = e.scene, this.loader.sceneMetadata = d(e), this.loader.onModelLoad(this.loader.targetModel).then(() => t(e));
+					}, (e) => n(e));
+				});
+			} finally {
+				this.loader._disposeGLTFLoader(o);
+			}
+		} else return await this.loader.loadGLBFromArrayBuffer(t.buffer, n);
+	}
+	async handleObjFromZip(e, t, n) {
+		let r = R(e), i = r.match(/mtllib\s+([^\s]+)/), a = null;
+		i && i[1] && (a = await this.loadMtlFromZip(i[1], t, n));
+		let { OBJLoader: o } = await import("three/examples/jsm/loaders/OBJLoader.js"), s = new o();
+		a && s.setMaterials(a);
+		let c = s.parse(r);
+		return c.name = t, this.loader.releaseTargetModel(), this.loader.targetModel = c, await this.loader.onModelLoad(this.loader.targetModel), c;
+	}
+	async preloadMtlTextures(e) {
+		let t = [], n = e.loadTexture.bind(e);
+		if (e.loadTexture = (e, r, i, a, o) => {
+			let s;
+			return t.push(new Promise((e) => s = e)), n(e, r, (e) => {
+				s(), i?.(e);
+			}, a, (e) => {
+				s(), o?.(e);
+			});
+		}, e.preload(), t.length === 0) return e;
+		let r, i = await Promise.race([Promise.all(t).then(() => !0), new Promise((e) => r = setTimeout(() => e(!1), ii))]);
+		return clearTimeout(r), i || this.loader._issues?.record(a.TEXTURE_BUILD_FAILED, `MTL textures did not decode within ${ii}ms; affected materials render untextured`, { pending: t.length }), e;
+	}
+	async loadMtlFromZip(e, t, n) {
+		let r = t.split("/").slice(0, -1).join("/"), i = [
+			e,
+			`${r}/${e}`,
+			e.split("/").pop()
+		];
+		for (let e of i) if (n[e]) {
+			let { MTLLoader: t } = await import("three/examples/jsm/loaders/MTLLoader.js"), i = R(n[e]), a = new j();
+			a.setURLModifier((e) => this.resolveZipResource(e, r, n));
+			let o = new t(a).parse(i, r);
+			return await this.preloadMtlTextures(o), o;
+		}
+		return null;
+	}
+	resolveZipResource(e, t, n) {
+		let r = e.replace(/^\.\/|^\//, ""), i = [
+			r,
+			`${t}/${r}`,
+			r.split("/").pop()
+		];
+		for (let e of i) if (n[e]) {
+			let t = new Blob([n[e].buffer], { type: "application/octet-stream" });
+			return URL.createObjectURL(t);
+		}
+		return console.warn(`Resource not found in ZIP: ${e}`), e;
+	}
+	async loadOBJMTLPairFromZip(e, t, n, r) {
+		let { MTLLoader: i } = await import("three/examples/jsm/loaders/MTLLoader.js"), { OBJLoader: a } = await import("three/examples/jsm/loaders/OBJLoader.js"), o = [], s = new j(), c = e.path.split("/").slice(0, -1).join("/"), l = t.path.split("/").slice(0, -1).join("/");
+		s.setURLModifier((e) => this.resolveTextureInZip(e, c, l, t, n, o));
+		let u = this.prepareFixedMtlContent(t), d = new i(s).parse(u, l);
+		await this.preloadMtlTextures(d);
+		let f = new a(s);
+		f.setMaterials(d);
+		let p = R(e.content), m = f.parse(p);
+		return this.loader.releaseTargetModel(), this.loader.targetModel = m, await this.loader.onModelLoad(this.loader.targetModel), o.forEach((e) => URL.revokeObjectURL(e)), this.loader.dispatchEvent({
+			type: "load",
+			model: m,
+			filename: `${e.path} (from ${r})`
+		}), m;
+	}
+	prepareFixedMtlContent(e) {
+		return R(e.content).replace(RegExp(`${e.path.split("/").pop()}\\s+`, "g"), " ").replace(/([a-zA-Z_]+)([\\/])/g, "$1 $2");
+	}
+	resolveTextureInZip(e, t, n, r, i, a) {
+		let o = e.split("?")[0].split("#")[0].replace(/^\.\/|^\//, ""), s = r.path.split("/").pop();
+		o.startsWith(s) && (o = o.substring(s.length).replace(/^\.\/|^\/|^\./, ""));
+		let c = [
+			o,
+			`${t}/${o}`,
+			`${n}/${o}`,
+			`textures/${o}`,
+			`texture/${o}`,
+			`materials/${o}`,
+			o.split("/").pop()
+		];
+		for (let e of c) if (i[e]) {
+			let t = new Blob([i[e].buffer], { type: "application/octet-stream" }), n = URL.createObjectURL(t);
+			return a.push(n), n;
+		}
+		return this.findTextureWithFuzzyMatch(o, i, a) || e;
+	}
+	findTextureWithFuzzyMatch(e, t, n) {
+		let r = e.split("/").pop();
+		for (let e in t) if (e.endsWith(r)) {
+			let r = new Blob([t[e].buffer], { type: "application/octet-stream" }), i = URL.createObjectURL(r);
+			return n.push(i), i;
+		}
+		if (r && r.length > 5) for (let e in t) {
+			let i = e.split("/").pop();
+			if (i.includes(r) || r.includes(i)) {
+				let r = new Blob([t[e].buffer], { type: "application/octet-stream" }), i = URL.createObjectURL(r);
+				return n.push(i), i;
+			}
+		}
+		return null;
+	}
+};
+//#endregion
+export { oi as n, ti as r, ai as t };