rayzee 11.16.0 → 11.17.0

package/dist/ArchiveFormats-_WrBUn7t.js

@@ -0,0 +1,2796 @@
+import { a as e, i as t, r as n } from "./Logger-D7hic8LA.js";
+import { a as r, i, l as a, n as o, r as s, t as c } from "./TextureBuckets-BfkUIWK6.js";
+import { _ as l, f as u, h as d, l as f, m as p, r as m, v as h, y as g } from "./BufferLayout-QzWWnb3A.js";
+import { n as _, t as v } from "./EngineIssues-pnvWClTX.js";
+import { d as y, s as b } from "./FileIdentity-BXmPNvJP.js";
+import { r as x } from "./ActiveColor-DakLCifA.js";
+import { a as S, p as C, u as w, y as T } from "./ViewTransforms-BjMXpgR2.js";
+import { BackSide as ee, Box3 as E, BufferAttribute as D, Color as O, DataArrayTexture as k, DataTexture as te, DataUtils as ne, DoubleSide as re, FloatType as ie, FrontSide as ae, HalfFloatType as oe, LinearFilter as A, LinearSRGBColorSpace as se, LoaderUtils as ce, Matrix3 as le, Matrix4 as ue, NoToneMapping as de, RGBAFormat as j, RGFormat as fe, RedFormat as pe, RepeatWrapping as me, SRGBColorSpace as M, Texture as he, UnsignedByteType as ge, UnsignedShortType as _e, Vector2 as ve, Vector3 as ye } from "three";
+//#region src/materials/MaterialPacking.js
+var be = [
+	1,
+	0,
+	0,
+	0,
+	1,
+	0,
+	0,
+	0
+], xe = [
+	["mapMatrix", f.ALBEDO_TRANSFORM],
+	["normalMapMatrices", f.NORMAL_TRANSFORM],
+	["roughnessMapMatrices", f.ROUGHNESS_TRANSFORM],
+	["metalnessMapMatrices", f.METALNESS_TRANSFORM],
+	["emissiveMapMatrices", f.EMISSIVE_TRANSFORM],
+	["bumpMapMatrices", f.BUMP_TRANSFORM],
+	["displacementMapMatrices", f.DISPLACEMENT_TRANSFORM]
+], Se = Object.freeze(new Set([
+	"metalness",
+	"roughness",
+	"transmission",
+	"opacity",
+	"clearcoat",
+	"clearcoatRoughness",
+	"sheen",
+	"sheenRoughness",
+	"specularIntensity",
+	"iridescence",
+	"subsurface",
+	"anisotropy",
+	"diffuseTransmission",
+	"diffuseRoughness"
+])), Ce = (e) => Math.min(Math.max(e, 0), 1);
+function N(e, t) {
+	let n = typeof e == "boolean" ? +e : e;
+	return Number.isFinite(n) ? n : t;
+}
+function P(e) {
+	return Number.isInteger(e) ? e : -1;
+}
+function F(e, t, n, r) {
+	let i = n?.r ?? n?.[0] ?? n?.x, a = n?.g ?? n?.[1] ?? n?.y, o = n?.b ?? n?.[2] ?? n?.z;
+	e[t] = N(i, r[0]), e[t + 1] = N(a, r[1]), e[t + 2] = N(o, r[2]);
+}
+function we(e, t, n) {
+	let r = (n, r, i) => {
+		e[t + n] = N(r, i);
+	}, i = (n, r, i) => {
+		e[t + n] = Ce(N(r, i));
+	};
+	r(f.IOR, n.ior, a.ior), i(f.TRANSMISSION, n.transmission, a.transmission), r(f.THICKNESS, n.thickness, a.thickness), r(f.EMISSIVE_INTENSITY, n.emissiveIntensity, a.emissiveIntensity), F(e, t + f.ATTENUATION_COLOR, n.attenuationColor, a.attenuationColor), e[t + f.ATTENUATION_DISTANCE] = l(n.attenuationDistance ?? a.attenuationDistance), i(f.OPACITY, n.opacity, a.opacity), r(f.SIDE, n.side, a.side), r(f.TRANSPARENT, n.transparent, a.transparent), r(f.ALPHA_TEST, n.alphaTest, a.alphaTest), r(f.ALPHA_MODE, n.alphaMode, a.alphaMode), r(f.DEPTH_WRITE, n.depthWrite, a.depthWrite);
+	let o = n.normalScale, s = typeof o == "number" ? o : void 0;
+	r(f.NORMAL_SCALE, s ?? o?.x ?? o?.[0], a.normalScale[0]), F(e, t + f.COLOR, n.color, a.color), i(f.METALNESS, n.metalness, a.metalness), F(e, t + f.EMISSIVE, n.emissive, a.emissive), i(f.ROUGHNESS, n.roughness, a.roughness), e[t + f.ALBEDO_MAP_INDEX] = P(n.map), e[t + f.NORMAL_MAP_INDEX] = P(n.normalMap), e[t + f.ROUGHNESS_MAP_INDEX] = P(n.roughnessMap), e[t + f.METALNESS_MAP_INDEX] = P(n.metalnessMap), e[t + f.EMISSIVE_MAP_INDEX] = P(n.emissiveMap), e[t + f.BUMP_MAP_INDEX] = P(n.bumpMap), e[t + f.DIFFUSE_ROUGHNESS_MAP_INDEX] = P(n.diffuseRoughnessMap), i(f.CLEARCOAT, n.clearcoat, a.clearcoat), i(f.CLEARCOAT_ROUGHNESS, n.clearcoatRoughness, a.clearcoatRoughness), r(f.DISPERSION, n.dispersion, a.dispersion), i(f.DIFFUSE_ROUGHNESS, n.diffuseRoughness, a.diffuseRoughness), i(f.SHEEN, n.sheen, a.sheen), i(f.SHEEN_ROUGHNESS, n.sheenRoughness, a.sheenRoughness), F(e, t + f.SHEEN_COLOR, n.sheenColor, a.sheenColor), i(f.DIFFUSE_TRANSMISSION, n.diffuseTransmission, a.diffuseTransmission), i(f.SPECULAR_INTENSITY, n.specularIntensity, a.specularIntensity), F(e, t + f.SPECULAR_COLOR, n.specularColor, a.specularColor), i(f.IRIDESCENCE, n.iridescence, a.iridescence), r(f.IRIDESCENCE_IOR, n.iridescenceIOR, a.iridescenceIOR), r(f.IRIDESCENCE_THICKNESS_RANGE, n.iridescenceThicknessRange?.[0], a.iridescenceThicknessRange[0]), r(f.IRIDESCENCE_THICKNESS_RANGE + 1, n.iridescenceThicknessRange?.[1], a.iridescenceThicknessRange[1]), r(f.BUMP_SCALE, n.bumpScale, a.bumpScale), r(f.DISPLACEMENT_SCALE, n.displacementScale, a.displacementScale), e[t + f.DISPLACEMENT_MAP_INDEX] = P(n.displacementMap), r(f.DISPLACEMENT_BIAS, n.displacementBias, a.displacementBias);
+	for (let [r, i] of xe) {
+		let a = n[r];
+		for (let n = 0; n < 8; n++) e[t + i + n] = N(a?.[n], be[n]);
+	}
+	e[t + f.BUMP_MAP_WIDTH] = N(n.bumpMapSize?.[0], 0), e[t + f.BUMP_MAP_HEIGHT] = N(n.bumpMapSize?.[1], 0), F(e, t + f.SUBSURFACE_COLOR, n.subsurfaceColor, a.subsurfaceColor), i(f.SUBSURFACE, n.subsurface, a.subsurface), F(e, t + f.SUBSURFACE_RADIUS, n.subsurfaceRadius, a.subsurfaceRadius), r(f.SUBSURFACE_RADIUS_SCALE, n.subsurfaceRadiusScale, a.subsurfaceRadiusScale), r(f.SUBSURFACE_ANISOTROPY, n.subsurfaceAnisotropy, a.subsurfaceAnisotropy), i(f.ANISOTROPY, n.anisotropy, a.anisotropy), r(f.ANISOTROPY_ROTATION, n.anisotropyRotation, a.anisotropyRotation), e[t + f.ANISOTROPY_MAP_INDEX] = P(n.anisotropyMap), e[t + f.TRANSMISSION_MAP_INDEX] = P(n.transmissionMap), e[t + f.CLEARCOAT_MAP_INDEX] = P(n.clearcoatMap), e[t + f.CLEARCOAT_ROUGHNESS_MAP_INDEX] = P(n.clearcoatRoughnessMap), e[t + f.SHEEN_COLOR_MAP_INDEX] = P(n.sheenColorMap), e[t + f.SHEEN_ROUGHNESS_MAP_INDEX] = P(n.sheenRoughnessMap), e[t + f.IRIDESCENCE_MAP_INDEX] = P(n.iridescenceMap), e[t + f.IRIDESCENCE_THICKNESS_MAP_INDEX] = P(n.iridescenceThicknessMap), e[t + f.SPECULAR_INTENSITY_MAP_INDEX] = P(n.specularIntensityMap), e[t + f.SPECULAR_COLOR_MAP_INDEX] = P(n.specularColorMap), F(e, t + f.DIFFUSE_TRANSMISSION_COLOR, n.diffuseTransmissionColor, a.diffuseTransmissionColor), e[t + f.DIFFUSE_TRANSMISSION_MAP_INDEX] = P(n.diffuseTransmissionMap), e[t + f.DIFFUSE_TRANSMISSION_COLOR_MAP_INDEX] = P(n.diffuseTransmissionColorMap), e[t + f.CLEARCOAT_NORMAL_MAP_INDEX] = P(n.clearcoatNormalMap);
+	let c = n.clearcoatNormalScale;
+	r(f.CLEARCOAT_NORMAL_SCALE, typeof c == "number" ? c : c?.x ?? c?.[0], a.clearcoatNormalScale[0]);
+}
+//#endregion
+//#region src/memory/ChunkedRecords.js
+var I = 64 * 1024 * 1024, Te = typeof SharedArrayBuffer < "u", Ee = null;
+function De(e) {
+	Ee = e;
+}
+function L(e, t, n) {
+	let r = n ? new e(new SharedArrayBuffer(t * e.BYTES_PER_ELEMENT)) : new e(t);
+	return Ee && r.byteLength > 0 && Ee(r.byteLength, n), r;
+}
+var Oe = class e {
+	constructor(e, t, n, r = I, i = !1) {
+		let a = t * n.BYTES_PER_ELEMENT, o = Math.max(1, Math.floor(r / a));
+		this.recordCount = e, this.lanesPerRecord = t, this.LaneType = n, this.recordsPerChunk = e <= o ? Math.max(e, 1) : o, this.shared = i, this.chunks = [];
+		let s = e;
+		for (; s > 0;) {
+			let e = Math.min(s, this.recordsPerChunk);
+			this.chunks.push(L(n, e * t, i)), s -= e;
+		}
+		this.chunks.length === 0 && this.chunks.push(L(n, 0, i));
+	}
+	static adopt(t, n, r, i) {
+		let a = Object.create(e.prototype);
+		return a.recordCount = n, a.lanesPerRecord = r, a.LaneType = t[0]?.constructor ?? null, a.recordsPerChunk = i, a.chunks = t, a.shared = typeof SharedArrayBuffer < "u" && t[0]?.buffer instanceof SharedArrayBuffer, a;
+	}
+	static lazy(t, n, r, i = I, a = !1) {
+		let o = Math.max(1, Math.floor(i / (n * r.BYTES_PER_ELEMENT))), s = Object.create(e.prototype);
+		return s.recordCount = t, s.lanesPerRecord = n, s.LaneType = r, s.recordsPerChunk = t <= o ? Math.max(t, 1) : o, s.shared = a, s.chunks = Array(Math.max(1, Math.ceil(t / s.recordsPerChunk))), s._views = [], s;
+	}
+	_materialize(e) {
+		if (this._owner) return this._owner._materialize(e), this.chunks[e];
+		let t = e * this.recordsPerChunk, n = Math.min(this.recordsPerChunk, this.recordCount - t) * this.lanesPerRecord, r = this.chunks[e] = L(this.LaneType, n, this.shared);
+		for (let t of this._liveViews()) t.chunks[e] = new t.LaneType(r.buffer, r.byteOffset, r.byteLength / t.LaneType.BYTES_PER_ELEMENT);
+		return r;
+	}
+	materializeAll() {
+		for (let e = 0; e < this.chunks.length; e++) !this.chunks[e] && !this._spilled?.has(e) && this._materialize(e);
+		return this;
+	}
+	get chunkCount() {
+		return this.chunks.length;
+	}
+	get single() {
+		return this.chunks.length === 1 ? this.chunks[0] : null;
+	}
+	get byteLength() {
+		let e = 0;
+		for (let t of this.chunks) t && (e += t.byteLength);
+		return e;
+	}
+	chunkFor(e) {
+		let t = e / this.recordsPerChunk | 0, n = this.chunks[t];
+		if (n) return n;
+		if (this._spilled?.has(t)) throw Error(`ChunkedRecords: chunk ${t} is on disk — await ensureResident() before touching record ${e}`);
+		return this._materialize(t);
+	}
+	async spill(e, { keep: t = () => !1 } = {}) {
+		if (this._owner) throw Error("ChunkedRecords: spill the storage, not a view of it");
+		this._store = e, this._spilled ??= /* @__PURE__ */ new Set();
+		let n = 0;
+		for (let r = 0; r < this.chunks.length; r++) {
+			let i = this.chunks[r];
+			if (!(!i || t(r))) {
+				await e.write(r, i), this.chunks[r] = null;
+				for (let e of this._liveViews()) e.chunks[r] = null;
+				this._spilled.add(r), n += i.byteLength;
+			}
+		}
+		return n;
+	}
+	async spillChunk(e, t) {
+		let n = this.chunks[e];
+		if (!n) return 0;
+		this._store = t, this._spilled ??= /* @__PURE__ */ new Set(), await t.write(e, n), this.chunks[e] = null;
+		for (let t of this._liveViews()) t.chunks[e] = null;
+		return this._spilled.add(e), n.byteLength;
+	}
+	async ensureResident(e = 0, t = this.recordCount) {
+		if (!this._spilled?.size || t <= 0) return;
+		let n = e / this.recordsPerChunk | 0, r = (e + t - 1) / this.recordsPerChunk | 0;
+		for (let e = n; e <= r; e++) {
+			if (!this._spilled.has(e)) continue;
+			let t = Math.min(this.recordsPerChunk, this.recordCount - e * this.recordsPerChunk) * this.lanesPerRecord, n = L(this.LaneType, t, this.shared), r = new Uint8Array(n.buffer, n.byteOffset, n.byteLength);
+			this._store.readInto ? await this._store.readInto(e, r) : r.set(new Uint8Array(await this._store.read(e, r.byteLength))), this.chunks[e] = n;
+			for (let t of this._liveViews()) t.chunks[e] = new t.LaneType(n.buffer, n.byteOffset, n.byteLength / t.LaneType.BYTES_PER_ELEMENT);
+			this._spilled.delete(e);
+		}
+	}
+	_liveViews() {
+		return this._weakViews &&= this._weakViews.filter((e) => e.deref()), [...this._views ?? [], ...(this._weakViews ?? []).map((e) => e.deref())];
+	}
+	isResident(e = 0, t = this.recordCount) {
+		if (!this._spilled?.size || t <= 0) return !0;
+		let n = e / this.recordsPerChunk | 0, r = (e + t - 1) / this.recordsPerChunk | 0;
+		for (let e = n; e <= r; e++) if (this._spilled.has(e)) return !1;
+		return !0;
+	}
+	get spilledChunks() {
+		return this._spilled?.size ?? 0;
+	}
+	baseOf(e) {
+		return e % this.recordsPerChunk * this.lanesPerRecord;
+	}
+	isContiguous(e, t) {
+		return t <= 0 ? !0 : (e / this.recordsPerChunk | 0) == ((e + t - 1) / this.recordsPerChunk | 0);
+	}
+	slice(e, t) {
+		let n = this.baseOf(e), r = t * this.lanesPerRecord;
+		if (this.isContiguous(e, t)) return this.chunkFor(e).subarray(n, n + r);
+		let i = new this.LaneType(r);
+		return this.readRecords(e, t, i), i;
+	}
+	readRecords(e, t, n) {
+		let r = 0;
+		for (; r < t;) {
+			let i = e + r, a = this.chunkFor(i), o = this.baseOf(i), s = this.recordsPerChunk - i % this.recordsPerChunk, c = Math.min(s, t - r);
+			n.set(a.subarray(o, o + c * this.lanesPerRecord), r * this.lanesPerRecord), r += c;
+		}
+		return n;
+	}
+	setRecords(e, t) {
+		let n = t.length / this.lanesPerRecord, r = 0;
+		for (; r < n;) {
+			let i = e + r, a = this.chunkFor(i), o = this.baseOf(i), s = this.recordsPerChunk - i % this.recordsPerChunk, c = Math.min(s, n - r);
+			a.set(t.subarray(r * this.lanesPerRecord, (r + c) * this.lanesPerRecord), o), r += c;
+		}
+	}
+	copyOf(e, t) {
+		return this.readRecords(e, t, new this.LaneType(t * this.lanesPerRecord));
+	}
+	trimTo(t) {
+		let n = Math.max(1, Math.ceil(t / this.recordsPerChunk)), r = this.chunks.slice(0, n), i = (t - (n - 1) * this.recordsPerChunk) * this.lanesPerRecord, a = r[n - 1];
+		return a.length > i && (r[n - 1] = a.subarray(0, Math.max(0, i))), e.adopt(r, t, this.lanesPerRecord, this.recordsPerChunk);
+	}
+	grow(e) {
+		if (e <= this.recordCount) return;
+		let t = this.chunks.length - 1, n = (e, t) => Math.min(this.recordsPerChunk, t - e * this.recordsPerChunk) * this.lanesPerRecord, r = this.chunks[t];
+		this.recordCount = e;
+		for (let t of this._liveViews()) t.recordCount = e;
+		if (this.chunks.length * this.recordsPerChunk < e) {
+			this.chunks.length = Math.ceil(e / this.recordsPerChunk);
+			for (let e of this._liveViews()) e.chunks.length = this.chunks.length;
+		}
+		if (r && r.length < n(t, e)) {
+			let i = L(this.LaneType, n(t, e), this.shared);
+			i.set(r), this.chunks[t] = i;
+			for (let e of this._liveViews()) e.chunks[t] = new e.LaneType(i.buffer, i.byteOffset, i.byteLength / e.LaneType.BYTES_PER_ELEMENT);
+		} else if (!r && this._spilled?.has(t)) throw Error(`ChunkedRecords: cannot grow past chunk ${t}, which is on disk`);
+	}
+	release(e, t) {
+		let n = this.recordsPerChunk, r = Math.ceil(e / n), i = Math.floor((e + t) / n), a = 0;
+		for (let e = r; e < i; e++) {
+			let t = this.chunks[e];
+			if (t) {
+				a += t.byteLength, this.chunks[e] = void 0;
+				for (let t of this._liveViews()) t.chunks[e] = void 0;
+			}
+		}
+		return a;
+	}
+	trimInPlace(e) {
+		let t = Math.max(1, Math.ceil(e / this.recordsPerChunk)), n = Math.max(0, (e - (t - 1) * this.recordsPerChunk) * this.lanesPerRecord), r = [this, ...this._liveViews()];
+		for (let i of r) {
+			i.chunks.length = t;
+			let r = i.chunks[t - 1];
+			r && r.length > n && (i.chunks[t - 1] = r.subarray(0, n)), i.recordCount = e;
+		}
+		if (this._spilled) for (let e of this._spilled) e >= t && this._spilled.delete(e);
+		return this;
+	}
+	viewAs(t) {
+		let n = (e) => new t(e.buffer, e.byteOffset, e.byteLength / t.BYTES_PER_ELEMENT), r = e.adopt(this.chunks.map((e) => e ? n(e) : void 0), this.recordCount, this.lanesPerRecord, this.recordsPerChunk);
+		return r.LaneType = t, r._owner = this, this._views ? this._views.push(r) : (this._weakViews ??= []).push(new WeakRef(r)), r._spilled = this._spilled ??= /* @__PURE__ */ new Set(), r;
+	}
+}, ke = 32 * 1024 * 1024, Ae = "chunks.bin", je = class e {
+	static async create(t, n, r, { label: i = "", expectedBytes: a = 0 } = {}) {
+		let o = t?.area(b.SPILL), s = await o?.create(n, {
+			label: i,
+			expectedBytes: a,
+			growable: [Ae]
+		});
+		return s ? new e(o, n, r, s) : null;
+	}
+	constructor(e, t, n, r) {
+		this._area = e, this._key = t, this._chunkBytes = n, this._writer = r, this._entry = null, this._file = null;
+	}
+	write(e, t) {
+		return this.writeAt(e * this._chunkBytes, t);
+	}
+	async writeAt(e, t) {
+		if (!this._writer && (this._entry?.release(), this._entry = this._file = null, this._writer = await this._area.edit(this._key), !this._writer)) throw Error("spill: its storage entry is gone");
+		let n = new Uint8Array(t.buffer, t.byteOffset, t.byteLength), r = 0;
+		do
+			await this._writer.write(Ae, n.subarray(r, Math.min(n.length, r + ke)), { at: e + r }), r += ke;
+		while (r < n.length);
+	}
+	async flush() {
+		if (this._writer &&= (await this._writer.commit(), null), !this._entry && (this._entry = await this._area.open(this._key, { wait: !0 }), this._file = await this._entry?.file(Ae), !this._file)) throw Error("spill: its storage entry is gone");
+	}
+	read(e, t) {
+		return this.readAt(e * this._chunkBytes, t);
+	}
+	async readAt(e, t) {
+		return await this.flush(), await this._file.slice(e, e + t).arrayBuffer();
+	}
+	async readInto(e, t) {
+		let n = await this.read(e, t.byteLength);
+		t.set(new Uint8Array(n)), n.transfer?.(0);
+	}
+	async dispose() {
+		this._writer && await this._writer.abort(), this._writer = null, this._entry?.release(), this._entry = this._file = null, await this._area.remove(this._key);
+	}
+}, R = 32 * 1024 * 1024, Me = R / 4, Ne = 64 * 1024 * 1024, Pe = /* @__PURE__ */ new Map(), z = /* @__PURE__ */ new WeakSet();
+function B(e) {
+	z.delete(e), e.transfer?.(0);
+}
+function Fe(e) {
+	let t = Pe.get(e);
+	return t || Pe.set(e, t = new e(0)), t;
+}
+var Ie = class e {
+	static async create(t, n, r = 0) {
+		let i = await je.create(t, n, 0, {
+			label: "Scene geometry (while building)",
+			expectedBytes: r
+		});
+		return i ? new e(i) : null;
+	}
+	static canTake(e) {
+		if (Object.keys(e.morphAttributes ?? {}).length) return !1;
+		for (let t in e.attributes) if (!e.attributes[t].isBufferAttribute) return !1;
+		return !e.index || e.index.isBufferAttribute === !0;
+	}
+	constructor(e) {
+		this._store = e, this._records = [], this._geometries = [], this._end = 0, this._pack = null, this._packAt = 0, this._packUsed = 0, this._packRecords = [], this._chain = Promise.resolve(), this._queued = 0, this.bytes = 0, this.error = null;
+	}
+	get queuedBytes() {
+		return this._queued;
+	}
+	add(e) {
+		e.boundingBox || e.computeBoundingBox(), e.boundingSphere || e.computeBoundingSphere();
+		let t = Object.values(e.attributes);
+		e.index && t.push(e.index), this.addAttributes(t), this._geometries.push({
+			geometry: e,
+			box: e.boundingBox.clone(),
+			sphere: e.boundingSphere.clone()
+		});
+	}
+	addAttributes(e) {
+		let t = /* @__PURE__ */ new Map();
+		for (let n of e) {
+			let e = n.array;
+			if (!e?.byteLength) continue;
+			let r = t.get(e);
+			r || t.set(e, r = this._write(e)), r.attributes.push(n), n.array = Fe(e.constructor);
+		}
+	}
+	_write(e) {
+		let t = new Uint8Array(e.buffer, e.byteOffset, e.byteLength), n = {
+			at: 0,
+			byteLength: t.byteLength,
+			Type: e.constructor,
+			attributes: [],
+			array: null,
+			pack: null,
+			offset: 0
+		};
+		return this._records.push(n), this.bytes += t.byteLength, t.byteLength >= Me ? (n.at = this._end, n.array = e, this._end += t.byteLength, this._queue(n.at, t, [n]), n) : (this._pack && this._packUsed + t.byteLength > R && this._flushPack(), this._pack || (this._pack = new Uint8Array(R), this._packAt = this._end, this._packUsed = 0, this._end += R), this._pack.set(t, this._packUsed), n.at = this._packAt + this._packUsed, n.pack = this._pack, n.offset = this._packUsed, this._packUsed += n.byteLength, this._packRecords.push(n), z.has(e.buffer) && B(e.buffer), n);
+	}
+	_flushPack() {
+		this._pack && (this._queue(this._packAt, this._pack.subarray(0, this._packUsed), this._packRecords, !0), this._pack = null, this._packRecords = []);
+	}
+	_queue(e, t, n, r = !1) {
+		let i = t.byteLength;
+		this._queued += i, this._chain = this._chain.then(async () => {
+			if (!this.error) {
+				await this._store.writeAt(e, t);
+				for (let e of n) {
+					let t = e.array?.buffer;
+					e.array = e.pack = null, z.has(t) && B(t);
+				}
+				r && t.buffer.transfer?.(0);
+			}
+		}).catch((e) => void (this.error ??= e)).finally(() => void (this._queued -= i));
+	}
+	written() {
+		return this._flushPack(), this._chain;
+	}
+	async restore() {
+		await this.written();
+		let e = this._records.sort((e, t) => e.at - t.at);
+		e.some((e) => !e.array && !e.pack) && await this._store.flush();
+		let t = null, n = 0;
+		for (let r of e) {
+			let e;
+			if (r.array ? e = r.array : r.pack ? e = new r.Type(r.pack.slice(r.offset, r.offset + r.byteLength).buffer) : r.byteLength > Ne ? e = new r.Type(await this._store.readAt(r.at, r.byteLength)) : ((!t || r.at + r.byteLength > n + t.byteLength) && (t && B(t), n = r.at, t = await this._store.readAt(r.at, Ne)), e = new r.Type(t.slice(r.at - n, r.at - n + r.byteLength))), e.byteLength !== r.byteLength) throw Error("geometry spill: an array came back short");
+			e !== r.array && z.add(e.buffer);
+			for (let t of r.attributes) t.array = e;
+		}
+		t && B(t);
+		for (let { geometry: e, box: t, sphere: n } of this._geometries) e.boundingBox = t, e.boundingSphere = n;
+		this._records = [], this._geometries = [], this.bytes = 0;
+	}
+	async dispose() {
+		await this._chain, this._records = [], this._geometries = [], this._pack = null, this._packRecords = [], await this._store.dispose();
+	}
+}, Le = n("geometry");
+function Re(e) {
+	e.traverse((e) => {
+		if (!e.isInstancedMesh || e.boundingBox !== null) return;
+		let t = e.geometry;
+		t.boundingBox === null && t.computeBoundingBox();
+		let n = e.boundingBox = new E(), r = t.boundingBox;
+		if (r.isEmpty()) return;
+		let i = [r.min.x, r.max.x], a = [r.min.y, r.max.y], o = [r.min.z, r.max.z], s = e.instanceMatrix.array, c = Infinity, l = Infinity, u = Infinity, d = -Infinity, f = -Infinity, p = -Infinity;
+		for (let t = 0, n = 0; t < e.count; t++, n += 16) {
+			let e = s[n], t = s[n + 1], r = s[n + 2], m = s[n + 3], h = s[n + 4], g = s[n + 5], _ = s[n + 6], v = s[n + 7], y = s[n + 8], b = s[n + 9], x = s[n + 10], S = s[n + 11], C = s[n + 12], w = s[n + 13], T = s[n + 14], ee = s[n + 15];
+			for (let n = 0; n < 8; n++) {
+				let s = i[n >> 2], E = a[n >> 1 & 1], D = o[n & 1], O = 1 / (m * s + v * E + S * D + ee), k = (e * s + h * E + y * D + C) * O, te = (t * s + g * E + b * D + w) * O, ne = (r * s + _ * E + x * D + T) * O;
+				c = Math.min(c, k), l = Math.min(l, te), u = Math.min(u, ne), d = Math.max(d, k), f = Math.max(f, te), p = Math.max(p, ne);
+			}
+		}
+		n.min.set(c, l, u), n.max.set(d, f, p);
+	});
+}
+var ze = c.MAX_TEXTURES_LIMIT, Be = new Set([
+	"color",
+	"emissive",
+	"attenuationColor",
+	"sheenColor",
+	"specularColor",
+	"subsurfaceColor",
+	"diffuseTransmissionColor"
+]), V = Object.freeze({
+	MATERIAL: "material",
+	MAPPED: "mapped",
+	DEFAULT: "default",
+	HOST: "host"
+}), Ve = [
+	1,
+	0,
+	0,
+	0,
+	0,
+	1,
+	0,
+	0,
+	0,
+	0,
+	1,
+	0,
+	0,
+	0,
+	0,
+	1
+];
+function He(e) {
+	for (let t = 0; t < 16; t++) if (e[t] !== Ve[t]) return !1;
+	return !0;
+}
+function Ue(e) {
+	let t = e?.image, n = t?.width || t?.naturalWidth, r = t?.height || t?.naturalHeight;
+	return n > 0 && r > 0 ? [n, r] : null;
+}
+function We(e) {
+	return {
+		map: e.map,
+		normalMap: e.normalMap,
+		bumpMap: e.bumpMap,
+		roughnessMap: e.roughnessMap,
+		metalnessMap: e.metalnessMap,
+		emissiveMap: e.emissiveMap ?? (e.isMeshBasicMaterial ? e.map : void 0),
+		displacementMap: e.displacementMap,
+		anisotropyMap: e.anisotropyMap,
+		clearcoatMap: e.clearcoatMap,
+		clearcoatRoughnessMap: e.clearcoatRoughnessMap,
+		clearcoatNormalMap: e.clearcoatNormalMap,
+		transmissionMap: e.transmissionMap,
+		sheenColorMap: e.sheenColorMap,
+		sheenRoughnessMap: e.sheenRoughnessMap,
+		specularIntensityMap: e.specularIntensityMap,
+		specularColorMap: e.specularColorMap,
+		diffuseTransmissionMap: e.diffuseTransmissionMap,
+		diffuseTransmissionColorMap: e.diffuseTransmissionColorMap,
+		iridescenceMap: e.iridescenceMap,
+		iridescenceThicknessMap: e.iridescenceThicknessMap,
+		diffuseRoughnessMap: e.diffuseRoughnessMap
+	};
+}
+function Ge(e) {
+	if (e.userData?.gltfExtensions?.KHR_materials_unlit?.alphaMode) {
+		let t = e.userData.gltfExtensions.KHR_materials_unlit.alphaMode;
+		return t === "BLEND" ? 2 : +(t === "MASK");
+	}
+	return e.alphaTest > 0 ? 1 : e.transparent && e.opacity < 1 || e.map && e.map.format === j && e.transparent ? 2 : 0;
+}
+function Ke(e) {
+	let t = 0, n = /* @__PURE__ */ new Set(), r = (e) => {
+		let i = e.isMesh && e.material ? e.geometry : null;
+		if (i && !n.has(i.uuid)) {
+			n.add(i.uuid);
+			for (let e in i.attributes) t += i.attributes[e].array?.byteLength ?? 0;
+			t += i.index?.array?.byteLength ?? 0;
+		}
+		if (e.children) for (let t of e.children) r(t);
+	};
+	return r(e), t;
+}
+function qe(e) {
+	let t = 0, n = /* @__PURE__ */ new Set();
+	return e.traverse?.((e) => {
+		let r = e.isInstancedMesh ? e.instanceMatrix?.array : null;
+		r && !n.has(r) && (n.add(r), t += r.byteLength);
+	}), t;
+}
+function Je(e, t) {
+	let n = e.x, r = e.y, i = e.z;
+	e.x = t[0] * n + t[4] * r + t[8] * i + t[12], e.y = t[1] * n + t[5] * r + t[9] * i + t[13], e.z = t[2] * n + t[6] * r + t[10] * i + t[14];
+}
+function Ye(e, t) {
+	let n = e.x, r = e.y, i = e.z;
+	e.x = t[0] * n + t[3] * r + t[6] * i, e.y = t[1] * n + t[4] * r + t[7] * i, e.z = t[2] * n + t[5] * r + t[8] * i;
+}
+var Xe = 1 << 21;
+function H(e) {
+	return !!(e.isSkinnedMesh || Object.keys(e.geometry?.morphAttributes ?? {}).length);
+}
+function Ze(e) {
+	return e[0] * (e[5] * e[10] - e[9] * e[6]) - e[4] * (e[1] * e[10] - e[9] * e[2]) + e[8] * (e[1] * e[6] - e[5] * e[2]);
+}
+function Qe(e) {
+	let t = !1, n = /* @__PURE__ */ new Set();
+	return e.traverse((e) => {
+		if (!(t || !e.isMesh || !e.material)) {
+			for (let r of Array.isArray(e.material) ? e.material : [e.material]) if (!n.has(r)) {
+				n.add(r);
+				for (let e in r) r[e]?.isTexture && (t = !0);
+			}
+		}
+	}), t;
+}
+function $e(e, t) {
+	let n = e.getAttribute(t);
+	if (!n || n.normalized || !(n.array instanceof Float32Array) || e.morphAttributes?.[t]?.length) return;
+	let r = n.array;
+	for (let e = 0; e < r.length; e++) {
+		let t = r[e];
+		if (!(t >= -1.0001 && t <= 1.0001)) return;
+	}
+	let i = new Int16Array(r.length);
+	for (let e = 0; e < r.length; e++) i[e] = Math.round(Math.max(-1, Math.min(1, r[e])) * 32767);
+	e.setAttribute(t, new D(i, n.itemSize, !0));
+}
+var et = class {
+	constructor({ issues: e = null } = {}) {
+		this._issues = e, this._droppedTextures = 0, this._vectorPool = {
+			vec3: Array(9).fill().map(() => new ye()),
+			vec2: [
+				,
+				,
+				,
+				,
+				,
+				,
+			].fill().map(() => new ve())
+		}, this._geometryRanges = /* @__PURE__ */ new Map(), this.expandedTriangleCount = 0, this._allocatePlacements(0), this._matrixPool = {
+			mat3: new le(),
+			mat4: new ue()
+		}, this.resetArrays(), this.triangleCount = 0, this.currentTriangleIndex = 0;
+	}
+	_getVec3(e = 0) {
+		return this._vectorPool.vec3[e % this._vectorPool.vec3.length];
+	}
+	_getVec2(e = 0) {
+		return this._vectorPool.vec2[e % this._vectorPool.vec2.length];
+	}
+	extract(e) {
+		this.resetArrays();
+		let t = this._countTriangles(e);
+		return this._triangleCapacity = Math.max(1024, t), this._allocateTriangles(this._triangleCapacity), this.currentTriangleIndex = 0, this._allocatePlacements(this._countPlacements(e)), this._geometryUses = this._countGeometryUses(e), this.bakeInverse = /* @__PURE__ */ new Map(), this.traverseObject(e), this._compressAttributes(e), this.logStats(), this.getExtractedData();
+	}
+	async extractStreaming(e, { onStore: t, onRange: n, pause: r, yieldEvery: i = 1 << 20, releaseGeometry: a = null }) {
+		this.resetArrays(), this._triangleCapacity = Math.max(1, this._countStoredTriangles(e)), this._allocateTriangles(this._triangleCapacity, !0), t?.(this.triangles), this.currentTriangleIndex = 0, this._allocatePlacements(this._countPlacements(e)), this._geometryUses = this._countGeometryUses(e), this.bakeInverse = /* @__PURE__ */ new Map(), this._onRange = n, this._releaseAfterRead = a ? this._geometryReleaser(e, a) : null;
+		try {
+			let t = [e], n = 0;
+			for (; t.length;) {
+				let e = t.pop();
+				if (this._visit(e), e.children) for (let n = e.children.length - 1; n >= 0; n--) t.push(e.children[n]);
+				this.currentTriangleIndex - n >= i && (n = this.currentTriangleIndex, await r(this.currentTriangleIndex));
+			}
+		} finally {
+			this._onRange = null, this._releaseAfterRead = null;
+		}
+		return this._compressAttributes(e), this.triangles.trimInPlace(this.currentTriangleIndex), this._streamedStore = !0, this.logStats(), this.getExtractedData();
+	}
+	_countStoredTriangles(e) {
+		let t = /* @__PURE__ */ new Set(), n = 0, r = (e) => {
+			if (e.isMesh && e.geometry && e.material) {
+				let r = e.geometry, i = Math.ceil((r.index ? r.index.count : r.attributes.position?.count ?? 0) / 3), a = Array.isArray(e.material) ? e.material[0] : e.material, o = a?.emissive, s = a?.emissiveIntensity > 0 && !!o && (o.r > 0 || o.g > 0 || o.b > 0), c = e.isInstancedMesh ? e.count ?? 0 : 1;
+				if (s && e.isInstancedMesh && !H(e) && i * c <= Xe) n += i * c;
+				else if (s || H(e)) n += i;
+				else {
+					let e = `${r.uuid}|${a?.uuid}`;
+					t.has(e) || (t.add(e), n += i);
+				}
+			}
+			if (e.children) for (let t of e.children) r(t);
+		};
+		return r(e), n;
+	}
+	_geometryReleaser(e, t) {
+		let n = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Set(), a = (e, t) => {
+			t ||= !!e.userData?.__rayzeeExternal;
+			let o = e.isMesh && e.material ? e.geometry : null;
+			if (o) {
+				if (!n.has(o)) {
+					Ie.canTake(o) || i.add(o);
+					for (let e of [...Object.values(o.attributes), o.index]) {
+						let t = e?.array;
+						if (!t) continue;
+						let n = r.get(t);
+						n && n !== o ? i.add(o).add(n) : r.set(t, o);
+					}
+				}
+				n.set(o, (n.get(o) ?? 0) + 1), (t || H(e)) && i.add(o);
+			}
+			if (e.children) for (let n of e.children) a(n, t);
+		};
+		return a(e, !1), (e) => {
+			let r = e.material ? e.geometry : null;
+			if (!r || !n.has(r)) return;
+			let a = n.get(r) - 1;
+			if (a > 0) return void n.set(r, a);
+			n.delete(r), !i.has(r) && (this._compressGeometry(r), t(r));
+		};
+	}
+	surveyScene(e) {
+		let t = 0, n = (e) => {
+			if (e.isMesh && e.geometry && e.material && t++, e.children) for (let t of e.children) n(t);
+		};
+		return n(e), {
+			triangles: this._countTriangles(e),
+			placements: this._countPlacements(e),
+			meshes: t,
+			geometryBytes: Ke(e),
+			instanceBytes: qe(e)
+		};
+	}
+	_countGeometryUses(e) {
+		let t = /* @__PURE__ */ new Map();
+		return e.traverse((e) => {
+			if (!e.isMesh || !e.geometry || !e.material) return;
+			let n = `${e.geometry.uuid}|${e.material.uuid}`;
+			t.set(n, (t.get(n) ?? 0) + 1);
+		}), t;
+	}
+	_countPlacements(e) {
+		let t = 0;
+		if (e.isMesh && e.geometry && e.material && (t += e.isInstancedMesh && e.instanceMatrix ? e.count ?? e.instanceMatrix.array.length / 16 : 1), e.children) for (let n of e.children) t += this._countPlacements(n);
+		return t;
+	}
+	_allocatePlacements(e) {
+		this.instanceCount = 0, this.instanceCapacity = e, this.instanceSource = new Int32Array(e), this._runs = {
+			first: [],
+			arrays: [],
+			arrayOf: [],
+			base: [],
+			owned: []
+		}, this._runArrayIndex = /* @__PURE__ */ new Map(), this._singles = null, this._singlesUsed = 0, this._singlesRun = null, this._compressed = /* @__PURE__ */ new Set(), this._matrixLists = /* @__PURE__ */ new Map();
+	}
+	_beginRun(e, t, n) {
+		let r = this._runs, i = this._runArrayIndex.get(e);
+		i === void 0 && this._runArrayIndex.set(e, i = r.arrays.push(e) - 1), r.first.push(this.instanceCount), r.arrayOf.push(i), r.base.push(t), r.owned.push(n);
+	}
+	_singleRow() {
+		let e = this._runs;
+		if (this._singles || (this._singles = new Float32Array(1024 * 16), this._singlesIndex = e.arrays.push(this._singles) - 1), this._singlesUsed + 16 > this._singles.length) {
+			let t = new Float32Array(this._singles.length * 2);
+			t.set(this._singles), this._singles = e.arrays[this._singlesIndex] = t;
+		}
+		this._singlesRun !== e.first.length - 1 && (e.first.push(this.instanceCount), e.arrayOf.push(this._singlesIndex), e.base.push(this._singlesUsed), e.owned.push(1), this._singlesRun = e.first.length - 1);
+		let t = this._singlesUsed;
+		return this._singlesUsed += 16, t;
+	}
+	_matrixRuns() {
+		let e = this._runs;
+		return {
+			first: [...e.first, this.instanceCount],
+			arrays: e.arrays,
+			arrayOf: e.arrayOf,
+			base: e.base,
+			owned: e.owned
+		};
+	}
+	_compressAttributes(e) {
+		let t = (e, n) => {
+			if (!e.userData?.__rayzeeExternal) {
+				n(e);
+				for (let r of e.children) t(r, n);
+			}
+		};
+		t(e, (e) => {
+			e.isMesh && e.geometry && this._compressGeometry(e.geometry);
+		});
+	}
+	_compressGeometry(e) {
+		if (!this._compressed.has(e.uuid)) {
+			this._compressed.add(e.uuid);
+			for (let t of [
+				"normal",
+				"tangent",
+				"color"
+			]) $e(e, t);
+		}
+	}
+	_countTriangles(e) {
+		let t = 0;
+		if (e.isMesh && e.geometry && e.material) {
+			let n = e.geometry.index, r = e.geometry.attributes.position;
+			n ? t += Math.ceil(n.count / 3) : r && (t += Math.ceil(r.count / 3));
+		}
+		if (e.children) for (let n of e.children) t += this._countTriangles(n);
+		return t;
+	}
+	_ensureCapacity(e) {
+		if (e <= this._triangleCapacity) return;
+		if (this._onRange) {
+			this.triangles.grow(e), this._triangleCapacity = e;
+			return;
+		}
+		let t = this.triangles, n = this.currentTriangleIndex;
+		this._allocateTriangles(e);
+		for (let e = 0; e < n; e++) this.triangles.chunkFor(e).set(t.chunkFor(e).subarray(t.baseOf(e), t.baseOf(e) + t.lanesPerRecord), this.triangles.baseOf(e));
+		this._triangleCapacity = e;
+	}
+	_allocateTriangles(e, t = !1) {
+		this.triangles = (t ? Oe.lazy : (...e) => new Oe(...e))(e, u.FLOATS_PER_TRIANGLE, Uint32Array, void 0, Te), this.triangleFloatChunks = this.triangles.viewAs(Float32Array), this.triangleData = this.triangles.single, this.triangleFloats = this.triangleFloatChunks.single;
+	}
+	traverseObject(e) {
+		if (this._visit(e), e.children) for (let t of e.children) this.traverseObject(t);
+	}
+	_visit(e) {
+		e.isMesh ? (this.processMesh(e), this._releaseAfterRead?.(e)) : e.isDirectionalLight ? this.directionalLights.push(e) : e.isCamera && this.cameras.push(e);
+	}
+	processMesh(e) {
+		if (!e.geometry || !e.material) {
+			console.warn("Skipping mesh with missing geometry or material:", e);
+			return;
+		}
+		let t = this.processMaterial(e.material);
+		e.userData.materialIndex = t;
+		let n = this.meshes.length;
+		this.meshes.push(e), e.userData.meshIndex = n;
+		let r = `${e.geometry.uuid}|${t}`, i = H(e), a = !this._emissiveMaterial(t) && !i, o = a ? this._geometryRanges.get(r) : null;
+		if (o) {
+			let t = {
+				start: o.start,
+				count: o.count,
+				expandedStart: this.expandedTriangleCount,
+				sharedFrom: o.meshIndex
+			};
+			this.expandedTriangleCount += o.count, this.meshTriangleRanges.push(t), this._recordPlacements(e, n, !1, !1, o.count > 0);
+			return;
+		}
+		let s = this.currentTriangleIndex, c = e.isInstancedMesh && !i && this._emissiveMaterial(t) && this._canExpand(e), l = c || !e.isInstancedMesh && !i && (this._geometryUses.get(`${e.geometry.uuid}|${e.material?.uuid}`) === 1 || this._emissiveMaterial(t));
+		this.extractGeometry(e, t, n, l, c);
+		let u = {
+			start: s,
+			count: this.currentTriangleIndex - s,
+			expandedStart: this.expandedTriangleCount
+		};
+		this.expandedTriangleCount += u.count, this.meshTriangleRanges.push(u), u.count > 0 && !l && a && this._geometryRanges.set(r, {
+			...u,
+			meshIndex: n
+		}), u.count > 0 && (this._recordPlacements(e, n, l, c, a), this._onRange?.(n, u));
+	}
+	_recordPlacements(e, t, n = !1, r = !1, i = !1) {
+		let a = e.matrixWorld.elements, o = this.instanceSource;
+		if (!e.isInstancedMesh || !e.instanceMatrix || r) {
+			let r = this._singleRow(), i = this._singles, s = this._nextPlacement();
+			if (o[s] = t, n) {
+				for (let e = 0; e < 16; e++) i[r + e] = +(e % 5 == 0);
+				this.bakeInverse.set(t, Float32Array.from(this._matrixPool.mat4.copy(e.matrixWorld).invert().elements));
+			} else for (let e = 0; e < 16; e++) i[r + e] = a[e];
+			return;
+		}
+		let s = e.instanceMatrix.array, c = e.count ?? s.length / 16;
+		if (i && c > 0) {
+			let n = this._matrixLists.get(e.instanceMatrix);
+			n || this._matrixLists.set(e.instanceMatrix, n = []), n.push({
+				meshIndex: t,
+				start: this.instanceCount,
+				count: c,
+				world: Float32Array.from(a)
+			});
+		}
+		if (c <= 0) return;
+		let l = He(a) && s.length >= c * 16, u = l ? s : new Float32Array(c * 16);
+		this._beginRun(l ? e.instanceMatrix : u, 0, +!l);
+		for (let e = 0; e < c; e++) {
+			let n = e * 16, r = this._nextPlacement(), i = e * 16;
+			if (o[r] = t, !l) for (let e = 0; e < 4; e++) for (let t = 0; t < 4; t++) u[i + e * 4 + t] = a[t] * s[n + e * 4] + a[4 + t] * s[n + e * 4 + 1] + a[8 + t] * s[n + e * 4 + 2] + a[12 + t] * s[n + e * 4 + 3];
+		}
+	}
+	_instanceGroups() {
+		let e = [];
+		for (let t of this._matrixLists.values()) {
+			let n = [];
+			for (let e of t) {
+				let t = n.find((t) => t.count === e.count && t.world.every((t, n) => t === e.world[n]));
+				t ? (t.members.push(e.meshIndex), t.starts.push(e.start)) : n.push({
+					world: e.world,
+					count: e.count,
+					members: [e.meshIndex],
+					starts: [e.start]
+				});
+			}
+			for (let t of n) t.members.length >= 2 && e.push({
+				members: t.members,
+				starts: t.starts,
+				count: t.count
+			});
+		}
+		return this._matrixLists.clear(), e;
+	}
+	_nextPlacement() {
+		if (this.instanceCount >= this.instanceCapacity) {
+			let e = Math.max(16, this.instanceCapacity * 2), t = new Int32Array(e);
+			t.set(this.instanceSource), this.instanceSource = t, this.instanceCapacity = e;
+		}
+		return this.instanceCount++;
+	}
+	_canExpand(e) {
+		let t = e.geometry, n = (t.index ? t.index.count : t.attributes.position.count) / 3, r = e.count ?? (e.instanceMatrix?.array.length ?? 0) / 16;
+		return n * r <= Xe ? !0 : (this._issues?.record(_.EMISSIVE_INSTANCES_COLLAPSED, `"${e.name || "instanced mesh"}" would need ${Math.round(n * r).toLocaleString()} triangles to light every instance; lighting the first one only`, {
+			instances: r,
+			trianglesPerInstance: n,
+			limit: Xe
+		}), !1);
+	}
+	_emissiveMaterial(e) {
+		let t = this.materials[e];
+		if (!t || !(t.emissiveIntensity > 0)) return !1;
+		let n = t.emissive;
+		return !!n && (n.r > 0 || n.g > 0 || n.b > 0);
+	}
+	processMaterial(t) {
+		let n = this._materialUuidMap.get(t.uuid) ?? -1;
+		if (n === -1) {
+			t.depthWrite === !1 && (t.depthWrite = !0, e(Le, "depthWrite", "material had depthWrite disabled — enabled for rastered rendering"));
+			let r = this.createMaterialObject(t);
+			this.materials.push(r), n = this.materials.length - 1, this._materialUuidMap.set(t.uuid, n);
+		}
+		return n;
+	}
+	getMaterialType(e) {
+		return e.isMeshPhysicalMaterial ? "physical" : e.isMeshStandardMaterial ? "standard" : e.isMeshPhongMaterial ? "phong" : e.isMeshLambertMaterial ? "lambert" : e.isMeshBasicMaterial ? "basic" : e.isMeshToonMaterial ? "toon" : "unknown";
+	}
+	getPhysicalDefaults() {
+		let e = {};
+		for (let [t, n] of Object.entries(a)) e[t] = Be.has(t) ? new O().fromArray(n) : Array.isArray(n) ? [...n] : n;
+		return e.normalScale = {
+			x: a.normalScale[0],
+			y: a.normalScale[1]
+		}, e;
+	}
+	mapLegacyMaterialToPhysical(e, t) {
+		let n = {};
+		switch (t) {
+			case "basic":
+				n.emissive = e.color.clone(), n.emissiveIntensity = 1, n.color = new O(0), n.roughness = 1, n.metalness = 0, n.specularIntensity = 0;
+				break;
+			case "lambert":
+				n.roughness = 1, n.metalness = 0, n.specularIntensity = 0;
+				break;
+			case "phong":
+				{
+					let t = e.shininess || 30;
+					n.roughness = Math.sqrt(2 / (t + 2)), n.metalness = 0;
+				}
+				if (e.specular) {
+					let t = e.specular, r = t.r * .299 + t.g * .587 + t.b * .114, i = Math.max(t.r, t.g, t.b);
+					n.specularIntensity = Math.min(r * 2, 1), n.specularColor = i > 0 ? t.clone().multiplyScalar(1 / i) : new O(1, 1, 1);
+				}
+				break;
+			case "toon":
+				n.roughness = .9, n.metalness = 0;
+				break;
+			case "standard":
+			case "physical": break;
+		}
+		return n;
+	}
+	createMaterialObject(e) {
+		let t = this.getPhysicalDefaults(), n = this.getMaterialType(e), r = this.mapLegacyMaterialToPhysical(e, n), i = We(e), a = {}, o = (t) => t === "iridescenceThicknessRange" && e.iridescenceThicknessMinimum !== void 0 ? [e.iridescenceThicknessMinimum, e.iridescenceThicknessMaximum] : e[t], s = (e) => {
+			if (r[e] !== void 0) return a[e] = V.MAPPED, r[e];
+			let n = o(e);
+			return n == null ? (a[e] = V.DEFAULT, t[e]) : (a[e] = V.MATERIAL, n);
+		};
+		for (let e of [
+			"transparent",
+			"alphaMode",
+			"side",
+			"depthWrite"
+		]) a[e] = V.MATERIAL;
+		return {
+			uuid: e.uuid,
+			color: s("color"),
+			emissive: s("emissive"),
+			emissiveIntensity: s("emissiveIntensity"),
+			roughness: Math.max(.02, s("roughness")),
+			metalness: s("metalness"),
+			ior: s("ior"),
+			opacity: s("opacity"),
+			transmission: s("transmission"),
+			thickness: s("thickness"),
+			attenuationColor: s("attenuationColor"),
+			attenuationDistance: s("attenuationDistance"),
+			dispersion: s("dispersion"),
+			sheen: s("sheen"),
+			sheenRoughness: s("sheenRoughness"),
+			sheenColor: s("sheenColor"),
+			clearcoat: s("clearcoat"),
+			clearcoatRoughness: s("clearcoatRoughness"),
+			clearcoatNormalScale: s("clearcoatNormalScale"),
+			iridescence: s("iridescence"),
+			iridescenceIOR: s("iridescenceIOR"),
+			iridescenceThicknessRange: s("iridescenceThicknessRange"),
+			subsurface: s("subsurface"),
+			subsurfaceColor: s("subsurfaceColor"),
+			subsurfaceRadius: s("subsurfaceRadius"),
+			subsurfaceRadiusScale: s("subsurfaceRadiusScale"),
+			subsurfaceAnisotropy: s("subsurfaceAnisotropy"),
+			anisotropy: s("anisotropy"),
+			anisotropyRotation: s("anisotropyRotation"),
+			specularIntensity: s("specularIntensity"),
+			specularColor: s("specularColor"),
+			diffuseTransmission: s("diffuseTransmission"),
+			diffuseTransmissionColor: s("diffuseTransmissionColor"),
+			diffuseRoughness: s("diffuseRoughness"),
+			normalScale: s("normalScale"),
+			bumpScale: s("bumpScale"),
+			displacementScale: s("displacementScale"),
+			displacementBias: s("displacementBias"),
+			transparent: +!!e.transparent,
+			alphaTest: s("alphaTest"),
+			alphaMode: Ge(e),
+			side: this.getMaterialSide(e),
+			depthWrite: e.depthWrite ?? !0 ? 1 : 0,
+			map: this.processTexture(i.map, this.maps),
+			normalMap: this.processTexture(i.normalMap, this.normalMaps),
+			bumpMap: this.processTexture(i.bumpMap, this.bumpMaps),
+			roughnessMap: this.processTexture(i.roughnessMap, this.roughnessMaps),
+			metalnessMap: this.processTexture(i.metalnessMap, this.metalnessMaps),
+			emissiveMap: this.processTexture(i.emissiveMap, this.emissiveMaps),
+			displacementMap: this.processTexture(i.displacementMap, this.displacementMaps),
+			anisotropyMap: this.processTexture(i.anisotropyMap, this.anisotropyMaps),
+			clearcoatMap: this.processTexture(i.clearcoatMap, this.clearcoatMaps),
+			clearcoatRoughnessMap: this.processTexture(i.clearcoatRoughnessMap, this.clearcoatRoughnessMaps),
+			clearcoatNormalMap: this.processTexture(i.clearcoatNormalMap, this.clearcoatNormalMaps),
+			transmissionMap: this.processTexture(i.transmissionMap, this.transmissionMaps),
+			thicknessMap: this.processTexture(e.thicknessMap, []),
+			sheenColorMap: this.processTexture(i.sheenColorMap, this.sheenColorMaps),
+			sheenRoughnessMap: this.processTexture(i.sheenRoughnessMap, this.sheenRoughnessMaps),
+			specularIntensityMap: this.processTexture(i.specularIntensityMap, this.specularIntensityMaps),
+			specularColorMap: this.processTexture(i.specularColorMap, this.specularColorMaps),
+			diffuseTransmissionMap: this.processTexture(i.diffuseTransmissionMap, this.diffuseTransmissionMaps),
+			diffuseTransmissionColorMap: this.processTexture(i.diffuseTransmissionColorMap, this.diffuseTransmissionColorMaps),
+			iridescenceMap: this.processTexture(i.iridescenceMap, this.iridescenceMaps),
+			iridescenceThicknessMap: this.processTexture(i.iridescenceThicknessMap, this.iridescenceThicknessMaps),
+			diffuseRoughnessMap: this.processTexture(i.diffuseRoughnessMap, this.diffuseRoughnessMaps),
+			mapMatrix: this.getTextureMatrix(i.map),
+			normalMapMatrices: this.getTextureMatrix(i.normalMap ?? i.clearcoatNormalMap),
+			bumpMapMatrices: this.getTextureMatrix(i.bumpMap),
+			bumpMapSize: Ue(i.bumpMap),
+			roughnessMapMatrices: this.getTextureMatrix(i.roughnessMap),
+			metalnessMapMatrices: this.getTextureMatrix(i.metalnessMap),
+			emissiveMapMatrices: this.getTextureMatrix(i.emissiveMap),
+			displacementMapMatrices: this.getTextureMatrix(i.displacementMap),
+			sources: a,
+			originalType: n
+		};
+	}
+	getTextureMatrix(e) {
+		return e ? (e.matrixAutoUpdate && e.updateMatrix(), e.matrix.elements) : new le().elements;
+	}
+	getMaterialSide(e) {
+		if (e.transmission > 0) return 2;
+		switch (e.side) {
+			case ae: return 0;
+			case ee: return 1;
+			case re: return 2;
+			default: return 0;
+		}
+	}
+	processTexture(e, t) {
+		if (!e) return -1;
+		let n = this._textureIndexCache.get(t);
+		n || (n = /* @__PURE__ */ new Map(), this._textureIndexCache.set(t, n));
+		let r = e.source.uuid, i = n.get(r);
+		if (i !== void 0) return i;
+		if (t.length < ze) {
+			t.push(e);
+			let i = t.length - 1;
+			return n.set(r, i), i;
+		}
+		return this._droppedTextures++, this._droppedTextures === 1 && this._issues?.record(_.TEXTURE_LIMIT_EXCEEDED, `scene needs more than ${ze} distinct textures for one map type; the rest render untextured`, {
+			limit: ze,
+			firstDropped: e.name || e.source?.uuid
+		}), -1;
+	}
+	extractGeometry(e, t, n, r = !1, i = !1) {
+		e.updateMatrix(), e.updateMatrixWorld();
+		let a = e.geometry, o = a.attributes.position;
+		if (!o) return;
+		a.attributes.normal || a.computeVertexNormals();
+		let s = a.attributes.normal, c = a.attributes.uv, l = a.index ? a.index.array : null, u = Math.floor((l ? l.length : o.count) / 3);
+		if (i) {
+			let r = e.count ?? e.instanceMatrix.array.length / 16, i = this._matrixPool.mat4, a = new ue();
+			for (let d = 0; d < r; d++) {
+				i.fromArray(e.instanceMatrix.array, d * 16), a.multiplyMatrices(e.matrixWorld, i);
+				let r = new le().getNormalMatrix(a);
+				this.extractTrianglesInBatch(o, s, c, l, u, t, n, a, r, Ze(a.elements) < 0);
+			}
+			return;
+		}
+		let d = r ? this._matrixPool.mat4.copy(e.matrixWorld) : null, f = r ? this._matrixPool.mat3.getNormalMatrix(e.matrixWorld) : null, p = r && Ze(d.elements) < 0;
+		this.extractTrianglesInBatch(o, s, c, l, u, t, n, d, f, p);
+	}
+	extractTrianglesInBatch(e, t, n, r, i, a, o, s = null, c = null, l = !1) {
+		for (; this.materialTriangleCounts.length <= a;) this.materialTriangleCounts.push(0);
+		this.materialTriangleCounts[a] += i;
+		let u = this._getVec3(0), d = this._getVec3(1), f = this._getVec3(2), p = this._getVec3(3), m = this._getVec3(4), h = this._getVec3(5), g = this._getVec2(0), _ = this._getVec2(1), v = this._getVec2(2);
+		this._ensureCapacity(this.currentTriangleIndex + i);
+		let y = s?.elements, b = c?.elements;
+		for (let c = 0; c < i; c++) {
+			let i = c * 3, x = r ? r[i + 0] : i + 0, S = l ? 2 : 1, C = l ? 1 : 2, w = r ? r[i + S] : i + S, T = r ? r[i + C] : i + C;
+			this.getVertex(e, x, u), this.getVertex(e, w, d), this.getVertex(e, T, f), this.getVertex(t, x, p), this.getVertex(t, w, m), this.getVertex(t, T, h), n ? (this.getVertex(n, x, g), this.getVertex(n, w, _), this.getVertex(n, T, v)) : (g.set(0, 0), _.set(0, 0), v.set(0, 0)), s && (Je(u, y), Je(d, y), Je(f, y), Ye(p, b), Ye(m, b), Ye(h, b)), p.normalize(), m.normalize(), h.normalize(), this.packTriangleDataTextureFormat(this.currentTriangleIndex, u, d, f, p, m, h, g, _, v, a, o), this.currentTriangleIndex++;
+		}
+	}
+	packTriangleDataTextureFormat(e, t, n, r, i, a, o, s, c, l, d, f) {
+		let p = u, m = this.triangles.baseOf(e), _ = this.triangleFloatChunks.chunkFor(e), v = this.triangles.chunkFor(e);
+		_[m + p.POSITION_A_OFFSET + 0] = t.x, _[m + p.POSITION_A_OFFSET + 1] = t.y, _[m + p.POSITION_A_OFFSET + 2] = t.z, v[m + p.NORMAL_A_PACKED_OFFSET] = h(i.x, i.y, i.z), _[m + p.POSITION_B_OFFSET + 0] = n.x, _[m + p.POSITION_B_OFFSET + 1] = n.y, _[m + p.POSITION_B_OFFSET + 2] = n.z, v[m + p.NORMAL_B_PACKED_OFFSET] = h(a.x, a.y, a.z), _[m + p.POSITION_C_OFFSET + 0] = r.x, _[m + p.POSITION_C_OFFSET + 1] = r.y, _[m + p.POSITION_C_OFFSET + 2] = r.z, v[m + p.NORMAL_C_PACKED_OFFSET] = h(o.x, o.y, o.z), _[m + p.UV_AB_OFFSET + 0] = s.x, _[m + p.UV_AB_OFFSET + 1] = s.y, _[m + p.UV_AB_OFFSET + 2] = c.x, _[m + p.UV_AB_OFFSET + 3] = c.y, _[m + p.UV_C_OFFSET + 0] = l.x, _[m + p.UV_C_OFFSET + 1] = l.y, v[m + p.MATERIAL_FLAGS_OFFSET] = g(d, this.materials[d]), v[m + p.MESH_INDEX_OFFSET] = f;
+	}
+	releaseTriangles() {
+		this.triangles = null, this.triangleData = null, this.triangleFloatChunks = null, this.triangleFloats = null;
+	}
+	getTriangleData() {
+		return this.triangles ? this._streamedStore ? this.triangles : this.triangles.trimTo(this.currentTriangleIndex) : null;
+	}
+	getTriangleCount() {
+		return this.currentTriangleIndex;
+	}
+	getVertex(e, t, n) {
+		return e.itemSize === 2 ? (n.x = e.getX(t), n.y = e.getY(t)) : e.itemSize >= 3 && (n.x = e.getX(t), n.y = e.getY(t), n.z = e.getZ(t)), n;
+	}
+	logStats() {
+		let e = this.currentTriangleIndex * u.FLOATS_PER_TRIANGLE * 4;
+		Le.debug(t.list([
+			`${t.count(this.currentTriangleIndex, "tri")} (${t.mb(e)})`,
+			t.count(this.materials.length, "material"),
+			t.count(this.maps.length, "map")
+		]));
+	}
+	extractMaterialsOnly(e) {
+		return this.resetArrays(), this._traverseMaterialsOnly(e), this.getExtractedData();
+	}
+	_traverseMaterialsOnly(e) {
+		if (e.isMesh && e.geometry && e.material) {
+			let t = this.processMaterial(e.material);
+			e.userData.materialIndex = t;
+			let n = this.meshes.length;
+			this.meshes.push(e), e.userData.meshIndex = n;
+		} else e.isDirectionalLight ? this.directionalLights.push(e) : e.isCamera && this.cameras.push(e);
+		if (e.children) for (let t of e.children) this._traverseMaterialsOnly(t);
+	}
+	resetArrays() {
+		this._droppedTextures = 0, this.triangles = null, this._streamedStore = !1, this.triangleData = null, this.triangleFloatChunks = null, this.triangleFloats = null, this.triangleCount = 0, this.currentTriangleIndex = 0, this.materials = [], this.materialTriangleCounts = [], this.meshes = [], this.meshTriangleRanges = [], this._geometryRanges = /* @__PURE__ */ new Map(), this.expandedTriangleCount = 0, this._allocatePlacements(0), this.maps = [], this.normalMaps = [], this.bumpMaps = [], this.metalnessMaps = [], this.emissiveMaps = [], this.roughnessMaps = [], this.displacementMaps = [], this.anisotropyMaps = [], this.transmissionMaps = [], this.clearcoatMaps = [], this.clearcoatRoughnessMaps = [], this.clearcoatNormalMaps = [], this.sheenColorMaps = [], this.sheenRoughnessMaps = [], this.iridescenceMaps = [], this.iridescenceThicknessMaps = [], this.specularIntensityMaps = [], this.specularColorMaps = [], this.diffuseTransmissionMaps = [], this.diffuseTransmissionColorMaps = [], this.diffuseRoughnessMaps = [], this.directionalLights = [], this.cameras = [], this._materialUuidMap = /* @__PURE__ */ new Map(), this._textureIndexCache = /* @__PURE__ */ new WeakMap();
+	}
+	getExtractedData() {
+		return {
+			triangleData: this.getTriangleData(),
+			triangleCount: this.getTriangleCount(),
+			materials: this.materials,
+			materialTriangleCounts: this.materialTriangleCounts,
+			meshes: this.meshes,
+			meshTriangleRanges: this.meshTriangleRanges,
+			expandedTriangleCount: this.expandedTriangleCount,
+			instanceSource: this.instanceSource.subarray(0, this.instanceCount),
+			matrixRuns: this._matrixRuns(),
+			instanceCount: this.instanceCount,
+			instanceGroups: this._instanceGroups(),
+			bakeInverse: this.bakeInverse,
+			maps: this.maps,
+			normalMaps: this.normalMaps,
+			bumpMaps: this.bumpMaps,
+			metalnessMaps: this.metalnessMaps,
+			emissiveMaps: this.emissiveMaps,
+			roughnessMaps: this.roughnessMaps,
+			displacementMaps: this.displacementMaps,
+			anisotropyMaps: this.anisotropyMaps,
+			transmissionMaps: this.transmissionMaps,
+			clearcoatMaps: this.clearcoatMaps,
+			clearcoatRoughnessMaps: this.clearcoatRoughnessMaps,
+			clearcoatNormalMaps: this.clearcoatNormalMaps,
+			sheenColorMaps: this.sheenColorMaps,
+			sheenRoughnessMaps: this.sheenRoughnessMaps,
+			iridescenceMaps: this.iridescenceMaps,
+			iridescenceThicknessMaps: this.iridescenceThicknessMaps,
+			specularIntensityMaps: this.specularIntensityMaps,
+			specularColorMaps: this.specularColorMaps,
+			diffuseTransmissionMaps: this.diffuseTransmissionMaps,
+			diffuseTransmissionColorMaps: this.diffuseTransmissionColorMaps,
+			diffuseRoughnessMaps: this.diffuseRoughnessMaps,
+			directionalLights: this.directionalLights,
+			cameras: this.cameras
+		};
+	}
+}, U = {
+	Worker: null,
+	decodeImage: null,
+	readFile: null
+};
+function tt(e) {
+	e && Object.assign(U, e);
+}
+function nt() {
+	return U;
+}
+function rt() {
+	return typeof navigator < "u" && navigator.hardwareConcurrency || 4;
+}
+function it() {
+	return !!U.decodeImage || typeof self < "u" && (typeof createImageBitmap < "u" || typeof document < "u");
+}
+function at() {
+	return !!U.Worker || typeof Worker < "u";
+}
+var ot = 0;
+async function st(e) {
+	if (!U.Worker || ot === 0 && globalThis.Worker !== void 0) return e();
+	ot++ === 0 && (globalThis.Worker = U.Worker);
+	try {
+		return await e();
+	} finally {
+		--ot === 0 && globalThis.Worker === U.Worker && delete globalThis.Worker;
+	}
+}
+function W(e, t) {
+	let n = U.Worker;
+	if (!n) return new e(t);
+	let r = Object.prototype.hasOwnProperty.call(globalThis, "Worker"), i = globalThis.Worker;
+	globalThis.Worker = n;
+	try {
+		return new e(t);
+	} finally {
+		r ? globalThis.Worker = i : delete globalThis.Worker;
+	}
+}
+function ct() {
+	return typeof MessageChannel > "u" ? new Promise((e) => setTimeout(e, 0)) : new Promise((e) => {
+		let { port1: t, port2: n } = new MessageChannel();
+		t.onmessage = () => {
+			t.close(), e();
+		}, n.postMessage(null);
+	});
+}
+function lt(e = 50) {
+	let t = performance.now(), n = () => {
+		t = performance.now();
+	};
+	return () => performance.now() - t < e ? null : ct().then(n);
+}
+//#endregion
+//#region src/storage/CDFCache.js
+var ut = 5;
+function dt(e, t) {
+	e && t && (e.userData.__rayzeeSource = t);
+}
+function ft(e) {
+	let t = e?.userData?.__rayzeeSource;
+	if (!t) return null;
+	let { width: n = 0, height: r = 0 } = e.image ?? {};
+	return `cdf:${ut}:${t}|${n}x${r}|${e.userData.__rayzeeColorSpace ?? "native"}`;
+}
+var pt = () => y(T().cacheNamespace)?.area(b.CDF) ?? null, mt = [
+	"exactConditional",
+	"exactMarginal",
+	"exactRowGuide",
+	"exactMarginalGuide"
+], ht = mt.map((e) => `${e}.f32`);
+async function gt(e) {
+	let t = ft(e), n = t ? await pt()?.open(t) : null;
+	if (!n) return null;
+	try {
+		let e = await Promise.all(ht.map((e) => n.file(e)));
+		if (e.some((e) => !e)) return null;
+		let t = await Promise.all(e.map(async (e) => new Float32Array(await e.arrayBuffer()))), { totalSum: r, width: i, height: a, exactWidth: o, exactHeight: s, radianceIntegral: c } = n.extra;
+		return {
+			...Object.fromEntries(mt.map((e, n) => [e, t[n]])),
+			totalSum: r,
+			width: i,
+			height: a,
+			exactWidth: o,
+			exactHeight: s,
+			radianceIntegral: c
+		};
+	} finally {
+		n.release();
+	}
+}
+async function _t(e, t) {
+	let { totalSum: n, width: r, height: i, exactWidth: a, exactHeight: o, radianceIntegral: s } = t, c = mt.map((e) => t[e]), l = ft(e), u = l ? pt() : null;
+	if (!u || c.some((e) => !e)) return !1;
+	let d = await u.create(l, {
+		label: e.name || "environment",
+		expectedBytes: c.reduce((e, t) => e + t.byteLength, 0)
+	});
+	if (!d) return !1;
+	try {
+		for (let e = 0; e < ht.length; e++) await d.write(ht[e], c[e]);
+		return await d.commit({
+			totalSum: n,
+			width: r,
+			height: i,
+			exactWidth: a,
+			exactHeight: o,
+			radianceIntegral: s
+		}), !0;
+	} catch {
+		return await d.abort(), !1;
+	}
+}
+//#endregion
+//#region src/memory/HostMemory.js
+var vt = u.FLOATS_PER_TRIANGLE * 4, yt = 64, bt = .9, xt = 28, St = 45, Ct = 4, wt = 1536 * 1024 * 1024, Tt = 7040 * 1024 * 1024, Et = 9216 * 1024 * 1024, Dt = 12e7, Ot = 6e7, kt = 8192;
+function At(e) {
+	if (e > 0) return {
+		gb: e,
+		assumed: !1
+	};
+	let t = typeof navigator < "u" ? navigator.deviceMemory : void 0;
+	return t > 0 ? {
+		gb: t,
+		assumed: !1
+	} : {
+		gb: 4,
+		assumed: !0
+	};
+}
+var jt = 1.15, Mt = 12 * 1024 * 1024 * 1024;
+function Nt({ triangles: e, placements: t, geometryBytes: n = 0, instanceBytes: r = 0 }) {
+	let i = {
+		triangles: e * vt,
+		bvh: Math.ceil(e * bt) * yt,
+		geometry: n,
+		instances: r,
+		placements: t * xt,
+		orderMaps: e * Ct
+	};
+	return i.total = i.triangles + i.bvh + i.geometry + i.instances + i.placements + i.orderMaps, i;
+}
+function Pt(e, t, n) {
+	let r = e.geometry + e.instances + t * 4 + n, i = e.instances + e.placements + t * St + e.orderMaps;
+	return Math.max(r, i);
+}
+function Ft(e, { chunkBytes: t = I, shared: n = !1, allocate: r = null } = {}) {
+	let i = Math.min(e, Mt), a = r ?? (n ? (e) => new SharedArrayBuffer(e) : (e) => new ArrayBuffer(e)), o = [], s = 0;
+	try {
+		for (; s < i;) {
+			let e = Math.min(t, i - s);
+			o.push(a(e)), s += e;
+		}
+	} catch {}
+	for (let e = o.length - 1; e >= 0; e--) o[e] = null;
+	return o.length = 0, {
+		placed: s,
+		want: i,
+		exhausted: s < i,
+		capped: e > i
+	};
+}
+var It = class {
+	constructor() {
+		this.reset();
+	}
+	reset() {
+		this.phase = "idle", this.events = [], this.samples = [], this.allocatedBytes = 0, this.peakLiveBytes = 0, this.byPhase = Object.create(null);
+	}
+	mark(e) {
+		return this.phase = e, this.byPhase[e] ??= {
+			allocated: 0,
+			chunks: 0
+		}, this;
+	}
+	alloc(e, t = "chunk") {
+		if (!(e > 0)) return;
+		let n = this.byPhase[this.phase] ??= {
+			allocated: 0,
+			chunks: 0
+		};
+		n.allocated += e, n.chunks++, this.allocatedBytes += e, this.events.push({
+			phase: this.phase,
+			bytes: e,
+			what: t,
+			at: performance.now()
+		});
+	}
+	sample(e, t) {
+		let n = 0;
+		for (let e in t) n += t[e] || 0;
+		return n > this.peakLiveBytes && (this.peakLiveBytes = n), this.samples.push({
+			label: e,
+			phase: this.phase,
+			total: n,
+			parts: t,
+			at: performance.now()
+		}), n;
+	}
+	get report() {
+		return {
+			allocatedBytes: this.allocatedBytes,
+			peakLiveBytes: this.peakLiveBytes,
+			byPhase: { ...this.byPhase },
+			samples: this.samples.slice()
+		};
+	}
+}, Lt = "const e={VEC4_PER_BVH_NODE:4,FLOATS_PER_VEC4:4,MIN_TEXTURE_WIDTH:4,MAX_CONCURRENT_WORKERS:Math.min(typeof navigator<`u`&&navigator.hardwareConcurrency||4,6),BUFFER_POOL_SIZE:20,CANVAS_POOL_SIZE:12,CACHE_SIZE_LIMIT:50,MAX_TEXTURE_SIZE:8192,DEFAULT_MAX_TEXTURE_SIZE:4096,MAX_TEXTURES_LIMIT:4*256,MATERIAL_BUCKET_COUNT:4,BUCKET_LAYER_STRIDE:256};function t(t,n){let r=Math.ceil(Math.max(1,t)/64)*64;return Math.min(n,Math.max(e.MIN_TEXTURE_WIDTH,r))}let n,r;const i={CHUNK_SIZE:8,ADAPTIVE_CHUNK_SIZE:!0,MEMORY_SAFETY_FACTOR:.8};let a=null;function o(e){if(e.stream===`begin`){let{width:t,height:n,depth:r}=e;a={width:t,height:n,depth:r,context:new OffscreenCanvas(t,n).getContext(`2d`,{willReadFrequently:!0,alpha:!0,desynchronized:!0}),data:new Uint8Array(t*n*r*4)};return}let{width:t,height:n,depth:r,context:i,data:o}=a;if(e.stream===`layer`){i.clearRect(0,0,t,n),i.drawImage(e.bitmap,0,0),e.bitmap.close(),o.set(i.getImageData(0,0,t,n).data,t*n*4*e.index),self.postMessage({stream:`ack`,index:e.index});return}a=null,self.postMessage({data:o.buffer,width:t,height:n,depth:r},[o.buffer])}async function s({shared:e,width:t,height:i,layers:a}){(n.width!==t||n.height!==i)&&(n.width=t,n.height=i),r.imageSmoothingEnabled=!0,r.imageSmoothingQuality=`high`;let o=new Uint8Array(e),s=t*i*4;for(let{index:e,texture:n}of a)try{await p(n,o,e*s,t,i)}catch(t){console.warn(`Failed to process texture ${e}:`,t),o.fill(0,e*s,(e+1)*s)}}self.onmessage=async function(e){if(e.data.shared){try{n||c(e.data.maxTextureSize),await s(e.data),self.postMessage({done:!0})}catch(e){self.postMessage({error:e.message})}return}if(e.data.stream){try{o(e.data)}catch(e){self.postMessage({error:e.message})}return}let{textures:t,maxTextureSize:r,method:i=`direct-transfer`,dims:a=null}=e.data;try{n||c(r);let e=await l(t,r,i,a);self.postMessage(e,[e.data])}catch(e){console.error(`Worker processing failed:`,e),self.postMessage({error:e.message})}};function c(t){let i=Math.min(t,e.MAX_TEXTURE_SIZE);n=new OffscreenCanvas(i,i),r=n.getContext(`2d`,{willReadFrequently:!0,alpha:!0,desynchronized:!0})}async function l(e,t,n,r=null){switch(n){case`direct-transfer`:return await g(e,t,r);case`offscreen-optimized`:return await v(e,t);case`imageBitmap-batch`:return await y(e,t);default:return await g(e,t,r)}}async function u(e,t,n){let{maxWidth:r,maxHeight:i}=b(e,t),a=e.length,o=d(r,i,a),s=Math.ceil(a/o);console.log(`Processing ${a} textures in ${s} chunks of up to ${o} textures each`),console.log(`Texture dimensions: ${r}x${i}, Est. memory per chunk: ${(r*i*o*4/1024/1024).toFixed(2)}MB`);let c;try{c=new Uint8Array(r*i*a*4)}catch{return console.warn(`Failed to allocate full texture array, reducing dimensions`),await _(e,x(e,t),n)}let l=r*i*o*4,u;try{u=new Uint8Array(l)}catch{return console.warn(`Failed to allocate chunk buffer, reducing dimensions`),await _(e,x(e,t),n)}for(let t=0;t<s;t++){let n=t*o,s=Math.min(n+o,a),l=s-n,d=await f(e.slice(n,s),r,i,u.subarray(0,r*i*l*4)),p=n*r*i*4,m=l*r*i*4;c.set(new Uint8Array(d.data.slice(0,m)),p),t%2==1&&await new Promise(e=>setTimeout(e,0))}return{data:c.buffer,width:r,height:i,depth:a}}function d(e,t,n){if(!i.ADAPTIVE_CHUNK_SIZE)return Math.min(i.CHUNK_SIZE,n);let r=e*t*4/(1024*1024),a;return a=r<=1?16:r<=4?8:r<=16?4:2,Math.min(a,n,i.CHUNK_SIZE*2)}async function f(e,t,i,a){(n.width!==t||n.height!==i)&&(n.width=t,n.height=i);let o=t*i*4;r.imageSmoothingEnabled=!0,r.imageSmoothingQuality=`high`;for(let n=0;n<e.length;n++){let r=e[n];try{await p(r,a,n*o,t,i)}catch(e){console.warn(`Failed to process texture ${n}:`,e);let t=n*o;a.fill(0,t,t+o)}}return{data:a.buffer,width:t,height:i,depth:e.length}}async function p(e,t,n,i,a){let o;if(e.isDirect&&e.bitmap)o=e.bitmap;else if(e.isImageData&&e.data){let t=new ImageData(new Uint8ClampedArray(e.data),e.width,e.height);o=await createImageBitmap(t,{resizeWidth:i,resizeHeight:a,resizeQuality:`high`})}else if(e.isBlob){let t=new Blob([e.data]);o=await createImageBitmap(t,{resizeWidth:i,resizeHeight:a,resizeQuality:`high`})}else throw Error(`Unknown texture data format`);r.clearRect(0,0,i,a),r.drawImage(o,0,0,i,a);let s=r.getImageData(0,0,i,a);t.set(s.data,n),o.close()}async function m(e,t,n){let r;try{r=new Uint8Array(t*n*e.length*4)}catch(r){console.warn(`Failed to allocate texture array in processTextureChunk, reducing dimensions`);let i=Math.max(1,Math.floor(t/2)),a=Math.max(1,Math.floor(n/2));if(i===t&&a===n)throw r;return await m(e,i,a)}return await f(e,t,n,r)}async function h(e,t,n,r,i){await p(e,n,r*i*4*t,r,i)}async function g(e,t,i=null){let{maxWidth:a,maxHeight:o}=i??b(e,t);(n.width!==a||n.height!==o)&&(n.width=a,n.height=o);let s=e.length,c;try{c=new Uint8Array(a*o*s*4)}catch(n){return console.error(`Failed to allocate texture array:`,n),await u(e,t,`direct-transfer`)}r.imageSmoothingEnabled=!0,r.imageSmoothingQuality=`high`;for(let t=0;t<e.length;t++){let n=e[t];try{await h(n,t,c,a,o)}catch(e){console.warn(`Failed to process texture ${t}:`,e);let n=a*o*4*t;c.fill(0,n,n+a*o*4)}}return{data:c.buffer,width:a,height:o,depth:s}}async function _(e,t,n){let{maxWidth:r,maxHeight:i}=t;return console.log(`Using reduced dimensions: ${r}x${i}`),await m(e,r,i,n)}async function v(e,t){let{maxWidth:i,maxHeight:a}=b(e,t);(n.width!==i||n.height!==a)&&(n.width=i,n.height=a);let o=e.length,s;try{s=new Uint8Array(i*a*o*4)}catch(n){return console.error(`Failed to allocate texture array:`,n),await u(e,t,`offscreen-optimized`)}r.imageSmoothingEnabled=!0,r.imageSmoothingQuality=`high`;for(let t=0;t<e.length;t++){let n=e[t];try{let e;if(n.isBlob){let t=new Blob([n.data]);e=await createImageBitmap(t,{resizeWidth:i,resizeHeight:a,resizeQuality:`high`})}else{let t=new ImageData(new Uint8ClampedArray(n.data),n.width,n.height);e=await createImageBitmap(t,{resizeWidth:i,resizeHeight:a,resizeQuality:`high`})}r.clearRect(0,0,i,a),r.drawImage(e,0,0);let o=r.getImageData(0,0,i,a),c=i*a*4*t;s.set(o.data,c),e.close()}catch(e){console.warn(`Failed to process texture ${t}:`,e);let n=i*a*4*t;s.fill(0,n,n+i*a*4)}}return{data:s.buffer,width:i,height:a,depth:o}}async function y(e,t){let{maxWidth:i,maxHeight:a}=b(e,t),o=e.length,s;try{s=new Uint8Array(i*a*o*4)}catch(n){return console.error(`Failed to allocate texture array:`,n),await u(e,t,`imageBitmap-batch`)}let c=Math.min(d(i,a,e.length),e.length);for(let t=0;t<e.length;t+=c){let o=Math.min(t+c,e.length),l=[];for(let n=t;n<o;n++){let t=e[n],r;if(t.isBlob){let e=new Blob([t.data]);r=createImageBitmap(e,{resizeWidth:i,resizeHeight:a,resizeQuality:`high`})}else{let e=new ImageData(new Uint8ClampedArray(t.data),t.width,t.height);r=createImageBitmap(e,{resizeWidth:i,resizeHeight:a,resizeQuality:`high`})}l.push(r.then(e=>({bitmap:e,index:n})))}let u=await Promise.all(l);n.width=i,n.height=a,r.imageSmoothingEnabled=!1;for(let{bitmap:e,index:t}of u){r.clearRect(0,0,i,a),r.drawImage(e,0,0);let n=r.getImageData(0,0,i,a),o=i*a*4*t;s.set(n.data,o),e.close()}}return{data:s.buffer,width:i,height:a,depth:o}}function b(n,r){let i=0,a=0;for(let e of n)i=Math.max(i,e.width||0),a=Math.max(a,e.height||0);let o=Math.min(r,e.MAX_TEXTURE_SIZE),s=Math.max(i,a);if(s>o){let e=o/s;i=Math.round(i*e),a=Math.round(a*e)}return i=t(i,o),{maxWidth:i,maxHeight:Math.max(1,a)}}function x(e,t){let n=b(e,t);return{maxWidth:Math.max(64,Math.ceil(n.maxWidth/128)*64),maxHeight:Math.max(1,Math.floor(n.maxHeight/2))}}", Rt = typeof self < "u" && self.Blob && new Blob(["URL.revokeObjectURL(import.meta.url);", Lt], { type: "text/javascript;charset=utf-8" });
+function zt(e) {
+	let t;
+	try {
+		if (t = Rt && (self.URL || self.webkitURL).createObjectURL(Rt), !t) throw "";
+		let n = new Worker(t, {
+			type: "module",
+			name: e?.name
+		});
+		return n.addEventListener("error", () => {
+			(self.URL || self.webkitURL).revokeObjectURL(t);
+		}), n;
+	} catch {
+		return new Worker("data:text/javascript;charset=utf-8," + encodeURIComponent(Lt), {
+			type: "module",
+			name: e?.name
+		});
+	}
+}
+//#endregion
+//#region src/materials/PackWorker.js?worker&inline
+var Bt = "function e({data:e,width:t,height:n,flipY:r},i,a,o,s){let c=o*4;if(t===o&&n===s){if(!r){i.set(e.subarray(0,s*c),a);return}for(let t=0;t<s;t++)i.set(e.subarray(t*c,(t+1)*c),a+(s-1-t)*c);return}let l=new Int32Array(o),u=new Int32Array(o),d=new Float64Array(o);for(let e=0;e<o;e++){let n=Math.min(Math.max((e+.5)*t/o-.5,0),t-1),r=Math.floor(n);l[e]=r*4,u[e]=Math.min(r+1,t-1)*4,d[e]=n-r}if(s<=n){for(let f=0;f<s;f++){let p=Math.min(Math.max((f+.5)*n/s-.5,0),n-1),m=Math.floor(p),h=Math.min(m+1,n-1),g=p-m,_=m*t*4,v=h*t*4,y=a+(r?s-1-f:f)*c;for(let t=0;t<o;t++,y+=4){let n=_+l[t],r=_+u[t],a=v+l[t],o=v+u[t],s=d[t];for(let t=0;t<4;t++){let c=e[n+t]+(e[r+t]-e[n+t])*s,l=e[a+t]+(e[o+t]-e[a+t])*s;i[y+t]=Math.round(c+(l-c)*g)}}}return}let f=[{row:-1,data:new Float64Array(c)},{row:-1,data:new Float64Array(c)}],p=(n,r)=>{for(let e of f)if(e.row===n)return e.data;let i=f[0].row===r?f[1]:f[0],a=n*t*4,s=i.data;for(let t=0,n=0;t<o;t++,n+=4){let r=a+l[t],i=a+u[t],o=d[t];s[n]=e[r]+(e[i]-e[r])*o,s[n+1]=e[r+1]+(e[i+1]-e[r+1])*o,s[n+2]=e[r+2]+(e[i+2]-e[r+2])*o,s[n+3]=e[r+3]+(e[i+3]-e[r+3])*o}return i.row=n,s};for(let e=0;e<s;e++){let t=Math.min(Math.max((e+.5)*n/s-.5,0),n-1),o=Math.floor(t),l=Math.min(o+1,n-1),u=t-o,d=p(o,l),f=l===o?d:p(l,o),m=a+(r?s-1-e:e)*c;for(let e=0;e<c;e++)i[m+e]=Math.round(d[e]+(f[e]-d[e])*u)}}self.onmessage=function(t){let{layers:n,width:r,height:i}=t.data;try{let t=r*i*4,a=new Uint8Array(t*n.length);n.forEach((n,o)=>e(n,a,o*t,r,i)),self.postMessage({data:a},[a.buffer])}catch(e){self.postMessage({error:e.message})}};", Vt = typeof self < "u" && self.Blob && new Blob(["URL.revokeObjectURL(import.meta.url);", Bt], { type: "text/javascript;charset=utf-8" });
+function Ht(e) {
+	let t;
+	try {
+		if (t = Vt && (self.URL || self.webkitURL).createObjectURL(Vt), !t) throw "";
+		let n = new Worker(t, {
+			type: "module",
+			name: e?.name
+		});
+		return n.addEventListener("error", () => {
+			(self.URL || self.webkitURL).revokeObjectURL(t);
+		}), n;
+	} catch {
+		return new Worker("data:text/javascript;charset=utf-8," + encodeURIComponent(Bt), {
+			type: "module",
+			name: e?.name
+		});
+	}
+}
+//#endregion
+//#region src/materials/ResampleRGBA8.js
+function Ut({ data: e, width: t, height: n, flipY: r }, i, a, o, s) {
+	let c = o * 4;
+	if (t === o && n === s) {
+		if (!r) {
+			i.set(e.subarray(0, s * c), a);
+			return;
+		}
+		for (let t = 0; t < s; t++) i.set(e.subarray(t * c, (t + 1) * c), a + (s - 1 - t) * c);
+		return;
+	}
+	let l = new Int32Array(o), u = new Int32Array(o), d = new Float64Array(o);
+	for (let e = 0; e < o; e++) {
+		let n = Math.min(Math.max((e + .5) * t / o - .5, 0), t - 1), r = Math.floor(n);
+		l[e] = r * 4, u[e] = Math.min(r + 1, t - 1) * 4, d[e] = n - r;
+	}
+	if (s <= n) {
+		for (let f = 0; f < s; f++) {
+			let p = Math.min(Math.max((f + .5) * n / s - .5, 0), n - 1), m = Math.floor(p), h = Math.min(m + 1, n - 1), g = p - m, _ = m * t * 4, v = h * t * 4, y = a + (r ? s - 1 - f : f) * c;
+			for (let t = 0; t < o; t++, y += 4) {
+				let n = _ + l[t], r = _ + u[t], a = v + l[t], o = v + u[t], s = d[t];
+				for (let t = 0; t < 4; t++) {
+					let c = e[n + t] + (e[r + t] - e[n + t]) * s, l = e[a + t] + (e[o + t] - e[a + t]) * s;
+					i[y + t] = Math.round(c + (l - c) * g);
+				}
+			}
+		}
+		return;
+	}
+	let f = [{
+		row: -1,
+		data: new Float64Array(c)
+	}, {
+		row: -1,
+		data: new Float64Array(c)
+	}], p = (n, r) => {
+		for (let e of f) if (e.row === n) return e.data;
+		let i = f[0].row === r ? f[1] : f[0], a = n * t * 4, s = i.data;
+		for (let t = 0, n = 0; t < o; t++, n += 4) {
+			let r = a + l[t], i = a + u[t], o = d[t];
+			s[n] = e[r] + (e[i] - e[r]) * o, s[n + 1] = e[r + 1] + (e[i + 1] - e[r + 1]) * o, s[n + 2] = e[r + 2] + (e[i + 2] - e[r + 2]) * o, s[n + 3] = e[r + 3] + (e[i + 3] - e[r + 3]) * o;
+		}
+		return i.row = n, s;
+	};
+	for (let e = 0; e < s; e++) {
+		let t = Math.min(Math.max((e + .5) * n / s - .5, 0), n - 1), o = Math.floor(t), l = Math.min(o + 1, n - 1), u = t - o, d = p(o, l), f = l === o ? d : p(l, o), m = a + (r ? s - 1 - e : e) * c;
+		for (let e = 0; e < c; e++) i[m + e] = Math.round(d[e] + (f[e] - d[e]) * u);
+	}
+}
+//#endregion
+//#region src/output/ToneMapCPU.js
+var Wt = (e) => (t, n, r, i, a) => e(t > 0 ? t : 0, n > 0 ? n : 0, r > 0 ? r : 0, i, a), G = /* @__PURE__ */ new Map();
+function Gt() {
+	G.clear();
+	for (let e of S.values()) G.set(e.id, Wt(e.cpu));
+}
+Gt(), C(Gt);
+function Kt(e) {
+	return w(e)?.outputEncoded === !0;
+}
+function K(e) {
+	return e <= .0031308 ? 12.92 * e : 1.055 * e ** (1 / 2.4) - .055;
+}
+function qt(e, t) {
+	let n = w(t);
+	return n ? n.appliesExposure ? e : 1 : t === de ? 1 : e;
+}
+function Jt(e, t, n) {
+	return qt(e, n) / qt(t, n);
+}
+function Yt(e, t, n) {
+	return e + (t - e) * (1 - Math.min(Math.max(n, 0), 1));
+}
+var Xt = .2126, Zt = .7152, Qt = .0722;
+function $t(e, t) {
+	if (t === 1) return;
+	let n = e[0] * Xt + e[1] * Zt + e[2] * Qt;
+	e[0] = n + (e[0] - n) * t, e[1] = n + (e[1] - n) * t, e[2] = n + (e[2] - n) * t;
+}
+function en(e, t) {
+	return on(new Uint8ClampedArray(e.length), e, t);
+}
+function tn(e, t) {
+	return on(new Uint16Array(e.length), e, t);
+}
+function nn(e, t) {
+	return on(new Float32Array(e.length), e, t);
+}
+var rn = (e) => e > 0 ? e < 1 ? e : 1 : 0, an = (e) => e <= .04045 ? e / 12.92 : ((e + .055) / 1.055) ** 2.4;
+function on(e, t, { exposure: n, toneMapping: r, saturation: i = 1, preserveAlpha: a = !1, pixelGain: o = null }) {
+	let s = G.get(r) ?? G.get(de), c = qt(n, r), l = Kt(r), u = e instanceof Float32Array ? (e) => an(rn(e)) : e instanceof Uint16Array ? (e) => Math.round(rn(e) * 65535) : (e) => e * 255 + .5, d = e instanceof Float32Array ? 1 : e instanceof Uint16Array ? 65535 : 255, f = [
+		0,
+		0,
+		0
+	], p = Math.log2(n);
+	for (let n = 0; n < t.length; n += 4) {
+		let r = c;
+		if (o) {
+			let e = 1;
+			if (o.fn) {
+				let r = n >> 2, i = r % o.width, a = (r - i) / o.width, s = t[n] * .2126 + t[n + 1] * .7152 + t[n + 2] * .0722;
+				e = o.fn((i + .5) / o.width, (a + .5) / o.height, s, p);
+			}
+			o.backdrop > 0 && (e = Yt(e, o.backdrop, t[n + 3])), r *= e;
+		}
+		f[0] = t[n] * r, f[1] = t[n + 1] * r, f[2] = t[n + 2] * r, $t(f, i), s(f[0], f[1], f[2], 1, f), l ? (e[n] = u(f[0]), e[n + 1] = u(f[1]), e[n + 2] = u(f[2])) : (e[n] = u(K(f[0])), e[n + 1] = u(K(f[1])), e[n + 2] = u(K(f[2]))), e[n + 3] = a ? e instanceof Float32Array ? rn(t[n + 3]) : u(t[n + 3]) : d;
+	}
+	return e;
+}
+//#endregion
+//#region src/materials/TextureCreator.js
+var q = n("textures"), J = {
+	MAX_BUFFER_MEMORY: 1024 * 1024 * 1024,
+	MAX_TEXTURE_MEMORY: 2048 * 1024 * 1024,
+	CLEANUP_THRESHOLD: .8,
+	STREAM_BATCH_SIZE: 4
+}, sn = 8 * 2 ** 20, cn = 16, ln = 4, un = 8192 * 8192, Y = {
+	busy: 0,
+	waiting: []
+};
+async function dn() {
+	return Y.busy < Math.max(1, rt() - 1) ? Y.busy++ : await new Promise((e) => Y.waiting.push(e)), () => {
+		let e = Y.waiting.shift();
+		e ? e() : Y.busy--;
+	};
+}
+var fn = 256 * 2 ** 20, pn = {
+	toSRGB: null,
+	toLinear: null
+};
+function mn(e) {
+	if (!pn[e]) {
+		let t = new Uint8Array(256);
+		for (let n = 0; n < 256; n++) {
+			let r = n / 255, i = e === "toSRGB" ? K(r) : r <= .04045 ? r / 12.92 : ((r + .055) / 1.055) ** 2.4;
+			t[n] = Math.max(0, Math.min(255, Math.round(i * 255)));
+		}
+		pn[e] = t;
+	}
+	return pn[e];
+}
+var hn = class {
+	constructor() {
+		this.canvasContextPairs = [], this.maxPoolSize = c.CANVAS_POOL_SIZE;
+	}
+	getCanvasWithContext(e, t, n = !1, r = {}) {
+		let i = {
+			willReadFrequently: !0,
+			alpha: !0,
+			desynchronized: !0,
+			...r
+		}, a = this.canvasContextPairs.pop();
+		if (!a) {
+			let r;
+			r = n && typeof OffscreenCanvas < "u" ? new OffscreenCanvas(e, t) : document.createElement("canvas");
+			let o = r.getContext("2d", i);
+			a = {
+				canvas: r,
+				context: o
+			};
+		}
+		return a.canvas.width = e, a.canvas.height = t, a;
+	}
+	releaseCanvasWithContext(e) {
+		this.canvasContextPairs.length < this.maxPoolSize && (e.context.globalAlpha = 1, e.context.globalCompositeOperation = "source-over", e.context.imageSmoothingEnabled = !0, e.context.clearRect(0, 0, e.canvas.width, e.canvas.height), e.canvas.width = 1, e.canvas.height = 1, this.canvasContextPairs.push(e));
+	}
+	getCanvas(e, t, n = !1) {
+		return this.getCanvasWithContext(e, t, n).canvas;
+	}
+	getContext(e, t = {}) {
+		let n = this.canvasContextPairs.find((t) => t.canvas === e);
+		return n ? n.context : e.getContext("2d", {
+			willReadFrequently: !0,
+			alpha: !0,
+			desynchronized: !0,
+			...t
+		});
+	}
+	dispose() {
+		this.canvasContextPairs = [];
+	}
+}, gn = class {
+	constructor(e = {}) {
+		this.pools = /* @__PURE__ */ new Map(), this.memoryUsage = 0, this.maxMemoryUsage = e.maxMemory || J.MAX_BUFFER_MEMORY, this.allocatedBuffers = /* @__PURE__ */ new WeakMap(), this.sizeStrategy = e.sizeStrategy || "adaptive";
+	}
+	getOptimalSize(e) {
+		switch (this.sizeStrategy) {
+			case "exact": return e;
+			case "power2": return 2 ** Math.ceil(Math.log2(e));
+			default: return e < 1024 ? e : e < 1024 * 1024 ? Math.ceil(e / 1024) * 1024 : e < 64 * 2 ** 20 ? 2 ** Math.ceil(Math.log2(e)) : Math.ceil(e / 2 ** 20) * 2 ** 20;
+		}
+	}
+	getBuffer(e, t = Float32Array) {
+		let n = this.getOptimalSize(e), r = `${t.name}-${n}`, i = (this.pools.get(r) || []).pop();
+		if (!i) try {
+			i = new t(n), this.memoryUsage += i.byteLength, this.allocatedBuffers.set(i, !0);
+		} catch {
+			this.cleanup();
+			try {
+				i = new t(n), this.memoryUsage += i.byteLength, this.allocatedBuffers.set(i, !0);
+			} catch (e) {
+				let r = n * t.BYTES_PER_ELEMENT / (1024 * 1024), i = this.memoryUsage / (1024 * 1024);
+				throw Error(`Buffer allocation failed: requested ${r.toFixed(1)}MB, current usage: ${i.toFixed(1)}MB, max: ${(this.maxMemoryUsage / (1024 * 1024)).toFixed(1)}MB. Original error: ${e.message}`);
+			}
+		}
+		return this.memoryUsage > this.maxMemoryUsage * J.CLEANUP_THRESHOLD && this.cleanup(), this.checkMemoryHealth(), i.byteOffset + e * t.BYTES_PER_ELEMENT > i.buffer.byteLength && (i = new t(e), this.memoryUsage += i.byteLength), new t(i.buffer, i.byteOffset, e);
+	}
+	forget(e) {
+		this.memoryUsage = Math.max(0, this.memoryUsage - e.buffer.byteLength);
+	}
+	releaseBuffer(e, t = Float32Array) {
+		let n = (e.buffer.byteLength - e.byteOffset) / t.BYTES_PER_ELEMENT, r = this.getOptimalSize(n), i = `${t.name}-${r}`, a = this.pools.get(i) || [];
+		a.length < c.BUFFER_POOL_SIZE ? (a.push(new t(e.buffer, e.byteOffset, n)), this.pools.set(i, a)) : this.allocatedBuffers.has(e) && (this.memoryUsage -= e.byteLength, this.allocatedBuffers.delete(e));
+	}
+	cleanup() {
+		let e = Array.from(this.pools.entries());
+		e.slice(0, Math.floor(e.length / 2)).forEach(([e, t]) => {
+			t.forEach((e) => {
+				this.allocatedBuffers.has(e) && (this.memoryUsage -= e.byteLength, this.allocatedBuffers.delete(e));
+			}), this.pools.delete(e);
+		});
+	}
+	dispose() {
+		this.pools.forEach((e) => {
+			e.forEach((e) => {
+				this.allocatedBuffers.has(e) && this.allocatedBuffers.delete(e);
+			});
+		}), this.pools.clear(), this.memoryUsage = 0;
+	}
+	getMemoryStats() {
+		return {
+			currentUsage: this.memoryUsage,
+			maxUsage: this.maxMemoryUsage,
+			utilizationPercentage: this.memoryUsage / this.maxMemoryUsage * 100,
+			poolCount: this.pools.size,
+			allocatedBufferCount: this.allocatedBuffers && this.allocatedBuffers.size || 0
+		};
+	}
+	checkMemoryHealth() {
+		let e = this.getMemoryStats();
+		return e.utilizationPercentage > 90 ? (console.warn(`Memory pool critical: ${e.utilizationPercentage.toFixed(1)}% used (${(e.currentUsage / (1024 * 1024)).toFixed(1)}MB / ${(e.maxUsage / (1024 * 1024)).toFixed(1)}MB)`), "critical") : e.utilizationPercentage > 70 ? (console.warn(`Memory pool high: ${e.utilizationPercentage.toFixed(1)}% used (${(e.currentUsage / (1024 * 1024)).toFixed(1)}MB / ${(e.maxUsage / (1024 * 1024)).toFixed(1)}MB)`), "high") : "normal";
+	}
+}, X = class {
+	constructor(e = c.CACHE_SIZE_LIMIT) {
+		this.cache = /* @__PURE__ */ new Map(), this.accessOrder = [], this.maxSize = e;
+	}
+	generateHash(e) {
+		let t = "";
+		for (let n of e) if (n?.image) {
+			let e = n.image.width || 0, r = n.image.height || 0, i = n.image.src || n.uuid || "", a = n.flipY === !1 ? "n" : "f", o = `${n.colorSpace ?? ""}|${n.userData?.ocioColorSpace ?? ""}`;
+			t += `${e}x${r}_${i.slice(-8)}_${a}_${o}_`;
+		}
+		return t + e.length;
+	}
+	get(e) {
+		if (this.cache.has(e)) {
+			let t = this.cache.get(e);
+			if (t?.userData && t.userData.buffer === null) {
+				this.cache.delete(e);
+				let t = this.accessOrder.indexOf(e);
+				return t > -1 && this.accessOrder.splice(t, 1), null;
+			}
+			let n = this.accessOrder.indexOf(e);
+			return n > -1 && this.accessOrder.splice(n, 1), this.accessOrder.push(e), t;
+		}
+		return null;
+	}
+	set(e, t) {
+		if (this.cache.has(e)) {
+			let t = this.accessOrder.indexOf(e);
+			t > -1 && this.accessOrder.splice(t, 1);
+		} else this.cache.size >= this.maxSize && this.evictLRU();
+		this.cache.set(e, t), this.accessOrder.push(e);
+	}
+	evictLRU() {
+		if (this.accessOrder.length > 0) {
+			let e = this.accessOrder.shift(), t = this.cache.get(e);
+			t && t.dispose && t.dispose(), this.cache.delete(e);
+		}
+	}
+	dispose() {
+		this.cache.forEach((e) => {
+			e && e.dispose && e.dispose();
+		}), this.cache.clear(), this.accessOrder = [];
+	}
+}, _n = class {
+	constructor(e = {}) {
+		this.useWorkers = typeof Worker < "u", this.maxConcurrentWorkers = c.MAX_CONCURRENT_WORKERS, this.activeWorkers = 0, this._issues = e.issues ?? null, this.layerSink = e.layerSink ?? null, this.groupBytes = e.groupBytes ?? fn, this.maxTextureSize = this._clampTextureSize(e.maxTextureSize ?? c.DEFAULT_MAX_TEXTURE_SIZE), this.canvasPool = new hn(), this.bufferPool = new gn({
+			maxMemory: e.maxBufferMemory || J.MAX_BUFFER_MEMORY,
+			sizeStrategy: e.bufferSizeStrategy || "adaptive"
+		}), this.textureCache = new X(), this.capabilities = this.detectCapabilities(), this.optimalMethod = this.selectOptimalMethod();
+	}
+	_reportTextureFailure(e, t) {
+		if (t instanceof v) throw t;
+		this._issues?.record(_.TEXTURE_BUILD_FAILED, `${e} texture array failed to build — those surfaces render untextured`, {
+			map: e,
+			cause: String(t?.message ?? t)
+		});
+	}
+	_reportTextureLayer(e, t) {
+		this._issues?.record(_.TEXTURE_BUILD_FAILED, `texture ${e} could not be read — its surfaces show a white placeholder`, {
+			layer: e,
+			cause: String(t?.message ?? t)
+		});
+	}
+	_clampTextureSize(e) {
+		let t = Math.floor(Number(e) || c.DEFAULT_MAX_TEXTURE_SIZE);
+		return Math.max(c.MIN_TEXTURE_WIDTH, Math.min(t, c.MAX_TEXTURE_SIZE));
+	}
+	setMaxTextureSize(e) {
+		let t = this._clampTextureSize(e);
+		return t === this.maxTextureSize ? t : (this.maxTextureSize = t, this.textureCache?.dispose(), this.textureCache = new X(), this.maxTextureSize);
+	}
+	detectCapabilities() {
+		return {
+			offscreenCanvas: typeof OffscreenCanvas < "u",
+			imageBitmap: typeof createImageBitmap < "u",
+			workers: typeof Worker < "u",
+			hardwareConcurrency: rt()
+		};
+	}
+	selectOptimalMethod() {
+		return this.capabilities.workers && this.capabilities.offscreenCanvas ? "worker-offscreen" : this.capabilities.imageBitmap ? "imageBitmap" : "canvas";
+	}
+	_applyColorManagement(e, t, n, r = /* @__PURE__ */ new Set(), i = null) {
+		let a = x();
+		if (!a?.hasConfig) return;
+		let o = e?.image?.data;
+		if (!o || !n) return;
+		let s = t.filter((e) => e?.image), c = e.image.width * e.image.height * 4, l = 0, u = 0, d = [];
+		for (let e = 0; e < s.length; e++) {
+			let t = e * c, n = Math.min(t + c, o.length);
+			if (t >= o.length) break;
+			let i = s[e], f = o.subarray(t, n), p = null;
+			try {
+				p = a.resolveTexture(i);
+			} catch (t) {
+				q.warn(`could not resolve the colour space of layer ${e}: ${t.message}`);
+			}
+			let m = p && p.via !== "three" ? p.colorSpace : null, h = i.type === ie || i.type === oe;
+			m && (r.has(e) || h) && (d.push(`${i.name || `layer ${e}`} (${m})`), m = null);
+			try {
+				a.convertTextureBytes(f, {
+					space: m,
+					encoding: "srgb"
+				}) && (m ? l++ : u++);
+			} catch (t) {
+				this._issues?.warn(_.TEXTURE_PROCESSING_FALLBACK, `colour conversion failed for layer ${e} — left in its original space`, {
+					cause: String(t?.message ?? t),
+					space: m
+				});
+			}
+		}
+		l + u > 0 && (e.needsUpdate = !0), i ? (i.named += l, i.primaries += u, i.refused.push(...d)) : this._reportColorManaged({
+			named: l,
+			primaries: u,
+			refused: d
+		}, s.length);
+	}
+	_reportColorManaged({ named: e, primaries: t, refused: n }, r) {
+		n.length && this._issues?.warn(_.TEXTURE_PROCESSING_FALLBACK, `${n.length} colour map(s) name a colour space their stored bytes are no longer in (re-encoded or quantized on the way in); converted by primaries only`, { textures: n.slice(0, 8) }), e + t !== 0 && q.info(`colour maps into ${x().workingSpace}: ${e} by named space, ${t} by primaries, of ${r}`);
+	}
+	_harmonizeTransfer(e, t, n, r = null) {
+		let i = /* @__PURE__ */ new Set(), a = e?.image?.data;
+		if (!a) return i;
+		let o = t.filter((e) => e?.image), s = n ? M : se, c = e.image.width * e.image.height * 4, l = [];
+		for (let e = 0; e < o.length; e++) {
+			let t = o[e].colorSpace;
+			if (t !== M && t !== se || t === s) continue;
+			let r = mn(n ? "toSRGB" : "toLinear"), u = e * c, d = Math.min(u + c, a.length);
+			for (let e = u; e < d; e += 4) a[e] = r[a[e]], a[e + 1] = r[a[e + 1]], a[e + 2] = r[a[e + 2]];
+			l.push(o[e].name || o[e].source?.uuid?.slice(0, 8) || `layer ${e}`), i.add(e);
+		}
+		return l.length > 0 && (e.needsUpdate = !0), r ? r.converted.push(...l) : this._reportHarmonized(l, o.length, n), i;
+	}
+	_reportHarmonized(e, t, n) {
+		if (e.length === 0) return;
+		let r = e.slice(0, 4).join(", ") + (e.length > 4 ? `, +${e.length - 4} more` : "");
+		n ? q.info(`re-encoded ${e.length}/${t} linear-declared colour map(s) to sRGB so the GPU decode round-trips: ${r}`) : q.warn(`decoded ${e.length}/${t} sRGB-declared data map(s) to linear — precision is lost in the darks, check the asset: ${r}`);
+	}
+	async createTexturesToDataTexture(e, { srgbPool: t = !1 } = {}) {
+		if (!e || e.length === 0) return null;
+		let n = x()?.inputKey ?? "-", r = `${t ? "s" : "l"}:${n}:${this.textureCache.generateHash(e)}`, i = this.textureCache.get(r);
+		if (i) return i;
+		let a = e.filter((e) => e?.image), o = this.calculateOptimalDimensions(a);
+		if (this.layerSink && o.maxWidth * o.maxHeight * a.length * 4 > this.groupBytes) return this._packInGroups(a, t, o);
+		let s;
+		try {
+			await this._holdImages(e), s = await this._packTextures(e, t);
+		} finally {
+			Tn(e);
+		}
+		return s && this.textureCache.set(r, s), s;
+	}
+	_holdImages(e) {
+		return wn(e, (e) => this._issues?.record(_.TEXTURE_BUILD_FAILED, "a material map could not be read again — its surfaces show a white placeholder", { cause: String(e?.message ?? e) }));
+	}
+	async _packInGroups(e, t, n) {
+		let { maxWidth: r, maxHeight: i } = n, a = r * i * 4, o = Math.max(1, Math.floor(this.groupBytes / a)), s = typeof createImageBitmap > "u" ? null : this.selectProcessingStrategy(e), c = {
+			converted: [],
+			named: 0,
+			primaries: 0,
+			refused: []
+		}, l = { shared: null }, u = this.createDataArrayTextureFromBuffer(null, r, i, e.length);
+		u.source.dataReady = !1, t && (u.colorSpace = M), this.layerSink.allocate(u);
+		try {
+			for (let a = 0; a < e.length; a += o) {
+				let d = e.slice(a, a + o), f;
+				try {
+					await this._holdImages(d), f = await this._packTextures(d, t, {
+						dims: n,
+						strategy: s,
+						tally: c,
+						scratch: l
+					});
+				} finally {
+					Tn(d);
+				}
+				let { data: p } = f.image;
+				if (f.image.width !== r || f.image.height !== i || f.image.depth !== d.length) throw Error(`texture group packed at ${f.image.width}x${f.image.height}x${f.image.depth}, not ${r}x${i}x${d.length}`);
+				await this.layerSink.write(u, a, p, d.length), this.bufferPool.forget(p), p.byteLength === p.buffer.byteLength && p.buffer.transfer && p.buffer.transfer(0);
+			}
+		} catch (e) {
+			throw u.dispose(), e;
+		}
+		return this._reportHarmonized(c.converted, e.length, t), this._reportColorManaged(c, e.length), u;
+	}
+	async _packTextures(e, t, { dims: n, strategy: r, tally: i, scratch: a } = {}) {
+		if (typeof createImageBitmap > "u") {
+			let r = await this.processOnCPU(e, n), a = this._harmonizeTransfer(r, e, t, i);
+			return this._applyColorManagement(r, e, t, a, i), r;
+		}
+		let { normalized: o, bitmapsToClose: s } = await this._normalizeTexturesForProcessing(e);
+		r ??= this.selectProcessingStrategy(o);
+		let c;
+		try {
+			switch (r.method) {
+				case "worker-direct":
+					c = await this.processWithWorkerDirect(o, n, a);
+					break;
+				case "worker-streaming":
+					c = await this.processInWorkerStreaming(o, n);
+					break;
+				case "main-batch":
+					c = await this.processOnMainThreadBatch(o, r.batchSize, n);
+					break;
+				case "main-streaming":
+					c = await this.processOnMainThreadStreaming(o, n);
+					break;
+				default: c = await this.processOnMainThreadSync(o, n);
+			}
+			if (n && c && (c.image.width !== n.maxWidth || c.image.height !== n.maxHeight)) throw Error(`packed at ${c.image.width}x${c.image.height}, not the bucket's ${n.maxWidth}x${n.maxHeight}`);
+			if (c) {
+				let n = this._harmonizeTransfer(c, e, t, i);
+				this._applyColorManagement(c, e, t, n, i);
+			}
+			return c;
+		} catch (r) {
+			if (r instanceof v) throw r;
+			this._issues?.warn(_.TEXTURE_PROCESSING_FALLBACK, "worker texture processing failed — retrying on the main thread", { cause: String(r?.message ?? r) });
+			let a = await this.processOnMainThreadSync(o, n), s = this._harmonizeTransfer(a, e, t, i);
+			return this._applyColorManagement(a, e, t, s, i), a;
+		} finally {
+			for (let e of s) e.close();
+		}
+	}
+	selectProcessingStrategy(e) {
+		let t = e.reduce((e, t) => e + (t.image?.width || 0) * (t.image?.height || 0), 0), n = t * 4;
+		return this.capabilities.workers && n > J.MAX_TEXTURE_MEMORY ? { method: "worker-streaming" } : this.capabilities.workers && t > 2097152 ? { method: "worker-direct" } : t > 524288 ? {
+			method: "main-batch",
+			batchSize: Math.min(4, e.length)
+		} : e.length > 8 ? { method: "main-streaming" } : { method: "main-sync" };
+	}
+	async processWithWorkerDirect(e, t = null, n = null) {
+		for (; this.activeWorkers >= this.maxConcurrentWorkers;) await new Promise((e) => setTimeout(e, 10));
+		this.activeWorkers++;
+		let r = 1, i = null;
+		try {
+			let a = await this.prepareTexturesForWorkerDirect(e), o = this._sharedPackSlots(a);
+			if (o > 0) return r += o, this.activeWorkers += o, this.createDataArrayTextureFromResult(await this._packAcrossWorkers(a, r, t, n));
+			i = new zt();
+			let s = await new Promise((e, n) => {
+				i.onmessage = (t) => {
+					t.data.error ? n(Error(t.data.error)) : e(t.data);
+				}, i.onerror = n;
+				let r = [];
+				a.forEach((e) => {
+					e.data instanceof ArrayBuffer ? r.push(e.data) : e.bitmap && r.push(e.bitmap);
+				}), i.postMessage({
+					textures: a,
+					maxTextureSize: this.maxTextureSize,
+					method: "direct-transfer",
+					dims: t
+				}, r);
+			});
+			return this.createDataArrayTextureFromResult(s);
+		} finally {
+			i?.terminate(), this.activeWorkers -= r;
+		}
+	}
+	_sharedPackSlots(e) {
+		if (typeof SharedArrayBuffer > "u" || !globalThis.crossOriginIsolated || e.reduce((e, t) => e + t.width * t.height, 0) < un) return 0;
+		let t = this.maxConcurrentWorkers - this.activeWorkers;
+		return Math.max(0, Math.min(e.length, ln, t + 1) - 1);
+	}
+	async _packAcrossWorkers(e, t, n = null, r = null) {
+		let { maxWidth: i, maxHeight: a } = n ?? this.calculateOptimalDimensions(e.map((e) => ({ image: e }))), o = e.length, s = i * a * o * 4, c = r?.shared?.byteLength >= s ? r.shared : new SharedArrayBuffer(s);
+		r && (r.shared = c);
+		let l = Array.from({ length: t }, () => ({
+			cost: 0,
+			layers: [],
+			transfer: []
+		})), u = e.map((e, t) => t), d = (t) => e[t].width * e[t].height;
+		u.sort((e, t) => d(t) - d(e));
+		for (let t of u) {
+			let n = l.reduce((e, t) => t.cost < e.cost ? t : e), r = e[t];
+			n.layers.push({
+				index: t,
+				texture: r
+			}), n.cost += d(t), r.data instanceof ArrayBuffer ? n.transfer.push(r.data) : r.bitmap && n.transfer.push(r.bitmap);
+		}
+		let f = [];
+		try {
+			await Promise.all(l.filter((e) => e.layers.length).map((e) => new Promise((t, n) => {
+				let r = W(zt);
+				f.push(r), r.onmessage = ({ data: e }) => e.error ? n(Error(e.error)) : t(), r.onerror = (e) => n(Error(e.message || "texture worker failed")), r.postMessage({
+					shared: c,
+					width: i,
+					height: a,
+					layers: e.layers,
+					maxTextureSize: this.maxTextureSize
+				}, e.transfer);
+			})));
+		} finally {
+			for (let e of f) e.terminate();
+		}
+		return {
+			data: new Uint8Array(c, 0, s),
+			width: i,
+			height: a,
+			depth: o
+		};
+	}
+	async processInWorkerStreaming(e, t = null) {
+		let n = e.filter((e) => e?.image);
+		if (n.length === 0) return this.createFallbackTexture();
+		let { maxWidth: r, maxHeight: i } = t ?? this.calculateOptimalDimensions(n), a = n.length;
+		for (; this.activeWorkers >= this.maxConcurrentWorkers;) await new Promise((e) => setTimeout(e, 10));
+		this.activeWorkers++;
+		let o = W(zt);
+		try {
+			let e = 0, t = null, s, c = new Promise((e, t) => s = {
+				resolve: e,
+				reject: t
+			});
+			c.catch(() => {}), o.onmessage = ({ data: n }) => {
+				n.error ? s.reject(Error(n.error)) : n.stream === "ack" ? e++ : s.resolve(n), t?.();
+			}, o.onerror = (e) => {
+				s.reject(Error(e.message || "texture worker failed")), t?.();
+			}, o.postMessage({
+				stream: "begin",
+				width: r,
+				height: i,
+				depth: a
+			});
+			let l = performance.now();
+			for (let s = 0; s < a; s++) {
+				for (; s - e >= J.STREAM_BATCH_SIZE;) await Promise.race([new Promise((e) => t = e), c]), l = performance.now();
+				let a = n[s], u = await createImageBitmap(a.image, {
+					resizeWidth: r,
+					resizeHeight: i,
+					resizeQuality: "high",
+					imageOrientation: a.flipY === !1 ? "none" : "flipY"
+				});
+				o.postMessage({
+					stream: "layer",
+					index: s,
+					bitmap: u
+				}, [u]), performance.now() - l > cn && (await new Promise((e) => setTimeout(e, 0)), l = performance.now());
+			}
+			return o.postMessage({ stream: "end" }), this.createDataArrayTextureFromResult(await c);
+		} finally {
+			o.terminate(), this.activeWorkers--;
+		}
+	}
+	async prepareTexturesForWorkerDirect(e) {
+		let t = [], n = () => ({
+			data: new Uint8ClampedArray([
+				255,
+				255,
+				255,
+				255
+			]).buffer,
+			width: 1,
+			height: 1,
+			isImageData: !0
+		});
+		for (let r = 0; r < e.length; r++) {
+			let i = e[r];
+			if (!i?.image) {
+				this._reportTextureLayer(r, "no image"), t.push(n());
+				continue;
+			}
+			let a = i.flipY !== !1;
+			try {
+				let e = i.image;
+				if (typeof createImageBitmap < "u" && (typeof HTMLImageElement < "u" && e instanceof HTMLImageElement || typeof ImageBitmap < "u" && e instanceof ImageBitmap || typeof HTMLCanvasElement < "u" && e instanceof HTMLCanvasElement || typeof OffscreenCanvas < "u" && e instanceof OffscreenCanvas)) {
+					let e = await createImageBitmap(i.image, { imageOrientation: a ? "flipY" : "none" });
+					t.push({
+						bitmap: e,
+						width: i.image.width,
+						height: i.image.height,
+						isDirect: !0
+					});
+				} else {
+					let e = i.image.width, n = i.image.height, r = await createImageBitmap(i.image, { imageOrientation: a ? "flipY" : "none" }), o = this.canvasPool.getCanvasWithContext(e, n);
+					o.context.drawImage(r, 0, 0), r.close();
+					let s = o.context.getImageData(0, 0, e, n);
+					t.push({
+						data: s.data.buffer,
+						width: e,
+						height: n,
+						isImageData: !0
+					}), this.canvasPool.releaseCanvasWithContext(o);
+				}
+			} catch (e) {
+				this._reportTextureLayer(r, e), t.push(n());
+			}
+		}
+		return t;
+	}
+	async processOnCPU(e, t = null) {
+		let n = e.map((e, t) => {
+			let n = e?.image, r = e?.isCompressedTexture ? e.mipmaps?.[0] : n, i = e?.isCompressedTexture ? r?.data : yn(e);
+			return i && r.width > 0 && r.height > 0 && i.byteLength >= r.width * r.height * 4 ? {
+				data: new Uint8Array(i.buffer, i.byteOffset, r.width * r.height * 4),
+				width: r.width,
+				height: r.height,
+				flipY: e.flipY !== !1
+			} : (this._reportTextureLayer(t, n ? "not decoded to pixels, and there is no browser to decode it" : "no image"), {
+				data: new Uint8Array([
+					255,
+					255,
+					255,
+					255
+				]),
+				width: 1,
+				height: 1,
+				flipY: !1
+			});
+		}), { maxWidth: r, maxHeight: i } = t ?? this.calculateOptimalDimensions(n.map((e) => ({ image: e }))), a = r * i * 4, o = at() && a * n.length >= sn ? await this._packInWorker(n, r, i) : null;
+		if (o) return this.createDataArrayTextureFromBuffer(o, r, i, n.length);
+		let s = this.bufferPool.getBuffer(a * n.length, Uint8Array);
+		return n.forEach((e, t) => Ut(e, s, t * a, r, i)), this.createDataArrayTextureFromBuffer(s, r, i, n.length);
+	}
+	async _packInWorker(e, t, n) {
+		let r = await dn(), i = null;
+		try {
+			let r = [], a = e.map((e) => {
+				if (typeof SharedArrayBuffer < "u" && e.data.buffer instanceof SharedArrayBuffer) return e;
+				let t = e.data.slice();
+				return r.push(t.buffer), {
+					...e,
+					data: t
+				};
+			});
+			return i = W(Ht), await new Promise((e, o) => {
+				i.onmessage = (t) => t.data.error ? o(Error(t.data.error)) : e(t.data.data), i.onerror = (e) => o(e.error ?? Error(e.message ?? "texture pack worker failed")), i.postMessage({
+					layers: a,
+					width: t,
+					height: n
+				}, r);
+			});
+		} catch (e) {
+			return this._issues?.warn(_.TEXTURE_PROCESSING_FALLBACK, "worker texture packing failed — packing on the main thread", { cause: String(e?.message ?? e) }), null;
+		} finally {
+			i?.terminate(), r();
+		}
+	}
+	async processOnMainThreadBatch(e, t, n = null) {
+		let r = e.filter((e) => e?.image);
+		if (r.length === 0) return this.createFallbackTexture();
+		let { maxWidth: i, maxHeight: a } = n ?? this.calculateOptimalDimensions(r), o = r.length, s = this.bufferPool.getBuffer(i * a * o * 4, Uint8Array);
+		for (let e = 0; e < r.length; e += t) {
+			let n = Math.min(e + t, r.length), o = [];
+			for (let t = e; t < n; t++) {
+				let e = r[t], n = e.flipY !== !1, s = createImageBitmap(e.image, {
+					resizeWidth: i,
+					resizeHeight: a,
+					resizeQuality: "high",
+					imageOrientation: n ? "flipY" : "none"
+				});
+				o.push(s.then((e) => ({
+					bitmap: e,
+					index: t
+				})));
+			}
+			let c = await Promise.all(o), l = this.canvasPool.getCanvasWithContext(i, a);
+			l.context.imageSmoothingEnabled = !1;
+			for (let { bitmap: e, index: t } of c) {
+				l.context.clearRect(0, 0, i, a), l.context.drawImage(e, 0, 0);
+				let n = l.context.getImageData(0, 0, i, a), r = i * a * 4 * t;
+				s.set(n.data, r), e.close();
+			}
+			this.canvasPool.releaseCanvasWithContext(l);
+		}
+		return this.createDataArrayTextureFromBuffer(s, i, a, o);
+	}
+	async processOnMainThreadStreaming(e, t = null) {
+		let n = e.filter((e) => e?.image);
+		if (n.length === 0) return this.createFallbackTexture();
+		let { maxWidth: r, maxHeight: i } = t ?? this.calculateOptimalDimensions(n), a = n.length, o = this.bufferPool.getBuffer(r * i * a * 4, Uint8Array), s = this.canvasPool.getCanvasWithContext(r, i);
+		s.context.imageSmoothingEnabled = !0, s.context.imageSmoothingQuality = "high";
+		for (let e = 0; e < n.length; e++) {
+			let t = n[e], a = await createImageBitmap(t.image, {
+				resizeWidth: r,
+				resizeHeight: i,
+				resizeQuality: "high",
+				imageOrientation: t.flipY === !1 ? "none" : "flipY"
+			});
+			s.context.clearRect(0, 0, r, i), s.context.drawImage(a, 0, 0), a.close();
+			let c = s.context.getImageData(0, 0, r, i), l = r * i * 4 * e;
+			o.set(c.data, l), e % J.STREAM_BATCH_SIZE === 0 && await new Promise((e) => setTimeout(e, 0));
+		}
+		return this.canvasPool.releaseCanvasWithContext(s), this.createDataArrayTextureFromBuffer(o, r, i, a);
+	}
+	async processOnMainThreadSync(e, t = null) {
+		let n = e.filter((e) => e?.image);
+		if (n.length === 0) return this.createFallbackTexture();
+		let { maxWidth: r, maxHeight: i } = t ?? this.calculateOptimalDimensions(n), a = n.length, o = this.bufferPool.getBuffer(r * i * a * 4, Uint8Array), s = this.canvasPool.getCanvasWithContext(r, i);
+		s.context.imageSmoothingEnabled = !0, s.context.imageSmoothingQuality = "high";
+		for (let e = 0; e < n.length; e++) {
+			let t = n[e], a = await createImageBitmap(t.image, {
+				resizeWidth: r,
+				resizeHeight: i,
+				resizeQuality: "high",
+				imageOrientation: t.flipY === !1 ? "none" : "flipY"
+			});
+			s.context.clearRect(0, 0, r, i), s.context.drawImage(a, 0, 0), a.close();
+			let c = s.context.getImageData(0, 0, r, i), l = r * i * 4 * e;
+			o.set(c.data, l);
+		}
+		return this.canvasPool.releaseCanvasWithContext(s), this.createDataArrayTextureFromBuffer(o, r, i, a);
+	}
+	createMaterialRawData(e) {
+		let t = f.FLOATS_PER_MATERIAL, n = new Float32Array(e.length * t);
+		for (let r = 0; r < e.length; r++) we(n, r * t, e[r]);
+		return n;
+	}
+	createBVHRawData(e) {
+		let t = [], n = (e) => {
+			let r = t.length;
+			if (t.push(e), e.leftChild) {
+				let t = n(e.leftChild), r = n(e.rightChild);
+				e.leftChild = t, e.rightChild = r;
+			}
+			return r;
+		};
+		n(e);
+		let r = c.VEC4_PER_BVH_NODE * c.FLOATS_PER_VEC4;
+		p(t.length, "BVH node count");
+		let i = t.length * r, a = new Float32Array(i), o = d(a);
+		for (let e = 0; e < t.length; e++) {
+			let n = e * r, i = t[e];
+			if (i.leftChild !== null) {
+				let e = i.leftChild, r = i.rightChild, s = t[e], c = t[r];
+				a[n] = s.boundsMin.x, a[n + 1] = s.boundsMin.y, a[n + 2] = s.boundsMin.z, o[n + 3] = e, a[n + 4] = s.boundsMax.x, a[n + 5] = s.boundsMax.y, a[n + 6] = s.boundsMax.z, o[n + 7] = r, a[n + 8] = c.boundsMin.x, a[n + 9] = c.boundsMin.y, a[n + 10] = c.boundsMin.z, a[n + 12] = c.boundsMax.x, a[n + 13] = c.boundsMax.y, a[n + 14] = c.boundsMax.z;
+			} else o[n] = i.triangleOffset, o[n + 1] = i.triangleCount, o[n + 3] = m.TRIANGLE_LEAF;
+		}
+		return a;
+	}
+	async createMaterialTextures(e) {
+		let { materials: t, maps: n, normalMaps: r, bumpMaps: i, roughnessMaps: a, metalnessMaps: o, emissiveMaps: s, displacementMaps: c } = e;
+		console.log("[TextureCreator] Creating material textures only");
+		let l = performance.now();
+		try {
+			if (!t || t.length === 0) throw Error("No materials provided for texture creation");
+			this.textureCache.dispose(), this.textureCache = new X();
+			let e = [];
+			for (let [t, l] of [
+				["albedo", n],
+				["normal", r],
+				["bump", i],
+				["roughness", a],
+				["metalness", o],
+				["emissive", s],
+				["displacement", c]
+			]) !l || l.length === 0 || e.push(this.createTexturesToDataTexture(l).then((e) => ({
+				type: t,
+				texture: e
+			})).catch((e) => (this._reportTextureFailure(t, e), {
+				type: t,
+				texture: null
+			})));
+			let u = await Promise.allSettled(e), d = u.find((e) => e.status === "rejected");
+			if (d) throw d.reason;
+			let f = {};
+			u.forEach((e) => {
+				if (e.status === "fulfilled" && e.value) {
+					let { type: t, texture: n } = e.value;
+					if (n) switch (t) {
+						case "albedo":
+							n.colorSpace = M, f.albedoTexture = n;
+							break;
+						case "normal":
+							f.normalTexture = n;
+							break;
+						case "bump":
+							f.bumpTexture = n;
+							break;
+						case "roughness":
+							f.roughnessTexture = n;
+							break;
+						case "metalness":
+							f.metalnessTexture = n;
+							break;
+						case "emissive":
+							n.colorSpace = M, f.emissiveTexture = n;
+							break;
+						case "displacement":
+							f.displacementTexture = n;
+							break;
+					}
+				}
+			});
+			let p = performance.now() - l;
+			return console.log(`[TextureCreator] Material texture creation complete (${p.toFixed(2)}ms)`), f;
+		} catch (e) {
+			throw console.error("[TextureCreator] Material texture creation error:", e), Error(`Material texture creation failed: ${e.message}`);
+		}
+	}
+	calculateOptimalDimensions(e) {
+		let t = 0, n = 0;
+		for (let r of e) t = Math.max(t, r.image.width), n = Math.max(n, r.image.height);
+		let r = Math.max(t, n);
+		if (r > this.maxTextureSize) {
+			let e = this.maxTextureSize / r;
+			t = Math.round(t * e), n = Math.round(n * e);
+		}
+		return {
+			maxWidth: o(t, this.maxTextureSize),
+			maxHeight: Math.max(1, n)
+		};
+	}
+	createDataArrayTextureFromResult(e) {
+		let t = ArrayBuffer.isView(e.data) ? e.data : new Uint8Array(e.data);
+		return this.createDataArrayTextureFromBuffer(t, e.width, e.height, e.depth);
+	}
+	createDataArrayTextureFromBuffer(e, t, n, r) {
+		let i = new k(e, t, n, r);
+		i.minFilter = A, i.magFilter = A, i.wrapS = me, i.wrapT = me, i.format = j, i.type = ge, i.needsUpdate = !0, i.generateMipmaps = !1, i.userData = {
+			buffer: e,
+			bufferType: Uint8Array
+		}, i.onUpdate = () => {
+			let e = i.userData.buffer;
+			e && (this.bufferPool.forget(e), i.userData.buffer = null, i.image.data = null);
+		};
+		let a = i.dispose.bind(i);
+		return i.dispose = () => {
+			i.userData.buffer && (this.bufferPool.releaseBuffer(i.userData.buffer, i.userData.bufferType), i.userData.buffer = null), a();
+		}, i;
+	}
+	async _normalizeTexturesForProcessing(e) {
+		let t = [], n = [], r = [];
+		for (let n of e) {
+			if (!n?.image) {
+				this._reportTextureLayer(t.length, "no image"), t.push(null);
+				continue;
+			}
+			if (n.isCompressedTexture && n.format === j && n.mipmaps?.[0]?.data) {
+				let e = n.mipmaps[0], i = t.length;
+				t.push(null), r.push({
+					index: i,
+					flipY: n.flipY,
+					promise: vn(e.data, e.width, e.height)
+				});
+				continue;
+			}
+			if (n.isCompressedTexture) {
+				console.warn("[TextureCreator] GPU-compressed texture in mixed group — using placeholder"), t.push(null);
+				continue;
+			}
+			if (n.image.data && !(typeof HTMLImageElement < "u" && n.image instanceof HTMLImageElement) && !(typeof HTMLCanvasElement < "u" && n.image instanceof HTMLCanvasElement) && !(typeof ImageBitmap < "u" && n.image instanceof ImageBitmap)) {
+				let e = t.length;
+				t.push(null);
+				let i = yn(n);
+				r.push({
+					index: e,
+					flipY: n.flipY,
+					promise: i ? vn(i, n.image.width, n.image.height) : Promise.reject(/* @__PURE__ */ Error("pixels in a layout the texture arrays cannot take"))
+				});
+				continue;
+			}
+			t.push(n);
+		}
+		if (r.length > 0) {
+			let e = await Promise.allSettled(r.map((e) => e.promise));
+			for (let i = 0; i < r.length; i++) {
+				let { index: a, flipY: o } = r[i], s = e[i];
+				if (s.status === "fulfilled") {
+					let e = s.value;
+					n.push(e), t[a] = {
+						image: e,
+						flipY: o
+					};
+				} else this._reportTextureLayer(a, s.reason);
+			}
+		}
+		for (let e = 0; e < t.length; e++) if (t[e] === null) {
+			let r = new Uint8ClampedArray([
+				255,
+				255,
+				255,
+				255
+			]), i = await createImageBitmap(new ImageData(r, 1, 1));
+			n.push(i), t[e] = {
+				image: i,
+				flipY: !1
+			};
+		}
+		return {
+			normalized: t,
+			bitmapsToClose: n
+		};
+	}
+	createFallbackTexture() {
+		let e = new k(new Uint8Array([
+			255,
+			255,
+			255,
+			255
+		]), 1, 1, 1);
+		return e.minFilter = A, e.magFilter = A, e.format = j, e.type = ge, e.needsUpdate = !0, e.generateMipmaps = !1, e;
+	}
+	dispose() {
+		this.canvasPool.dispose(), this.bufferPool.dispose(), this.textureCache.dispose();
+	}
+};
+async function vn(e, t, n) {
+	let r = new Uint8ClampedArray(e.buffer, e.byteOffset, e.byteLength);
+	return createImageBitmap(new ImageData(r, t, n));
+}
+function yn(e) {
+	let t = e?.image, n = t?.data;
+	if (!n || !(t.width > 0) || !(t.height > 0)) return null;
+	let r = t.width * t.height;
+	if (n instanceof Uint8Array || n instanceof Uint8ClampedArray) return n.byteLength >= r * 4 ? new Uint8Array(n.buffer, n.byteOffset, r * 4) : null;
+	let i = {
+		[j]: 4,
+		[fe]: 2,
+		[pe]: 1
+	}[e.format] ?? Math.round(n.length / r);
+	if (!(i >= 1 && i <= 4) || n.length < r * i) return null;
+	let a = e.type === oe, o = e.type === _e ? 1 / 65535 : 1, s = new Uint8Array(r * 4);
+	for (let e = 0; e < r; e++) for (let t = 0; t < 4; t++) {
+		let r = t < i ? n[e * i + t] : null, c = r === null ? t === 3 ? 1 : s[e * 4] / 255 : a ? ne.fromHalfFloat(r) : r * o;
+		s[e * 4 + t] = Math.max(0, Math.min(255, Math.round(c * 255)));
+	}
+	return s;
+}
+var bn = /* @__PURE__ */ new WeakMap(), xn = 128;
+function Sn(e, t, { resident: n = !0 } = {}) {
+	let r = e?.source, i = r?.data;
+	i?.width > 0 && i?.height > 0 && bn.set(r, {
+		read: t,
+		users: 0,
+		loading: null,
+		stub: n ? null : Object.assign(i, { thumbnail: null })
+	});
+}
+function Cn(e) {
+	let t = /* @__PURE__ */ new Map();
+	for (let n of e) {
+		let e = n?.source && bn.get(n.source);
+		e && t.set(n.source, e);
+	}
+	return t;
+}
+async function wn(e, t = null) {
+	await Promise.all([...Cn(e)].map(async ([e, n]) => {
+		n.users++, e.data === n.stub && (n.loading ??= n.read().catch((e) => (t?.(e), {
+			data: new Uint8Array([
+				255,
+				255,
+				255,
+				255
+			]),
+			width: 1,
+			height: 1
+		})).then((t) => {
+			e.data = t;
+		}).finally(() => {
+			n.loading = null;
+		}), await n.loading);
+	}));
+}
+function Tn(e) {
+	for (let [t, n] of Cn(e)) {
+		if (n.users = Math.max(0, n.users - 1), n.users > 0 || t.data === n.stub) continue;
+		let e = t.data, r = n.stub ??= {
+			width: e.width,
+			height: e.height,
+			data: null,
+			thumbnail: null
+		};
+		if (t.data = r, typeof e?.close != "function") continue;
+		if (r.thumbnail || typeof createImageBitmap != "function") {
+			e.close();
+			continue;
+		}
+		let i = Math.min(1, xn / Math.max(e.width, e.height));
+		createImageBitmap(e, {
+			resizeWidth: Math.max(1, Math.round(e.width * i)),
+			resizeHeight: Math.max(1, Math.round(e.height * i)),
+			resizeQuality: "medium"
+		}).then((e) => {
+			r.thumbnail = e;
+		}, () => {}).finally(() => e.close());
+	}
+}
+var Z = n("scene"), En = Object.freeze([
+	"maps",
+	"normalMaps",
+	"bumpMaps",
+	"roughnessMaps",
+	"metalnessMaps",
+	"emissiveMaps",
+	"displacementMaps",
+	"anisotropyMaps",
+	"transmissionMaps",
+	"clearcoatMaps",
+	"clearcoatRoughnessMaps",
+	"clearcoatNormalMaps",
+	"sheenColorMaps",
+	"sheenRoughnessMaps",
+	"iridescenceMaps",
+	"iridescenceThicknessMaps",
+	"specularIntensityMaps",
+	"specularColorMaps",
+	"diffuseTransmissionMaps",
+	"diffuseTransmissionColorMaps",
+	"diffuseRoughnessMaps"
+]);
+function Dn(e, t) {
+	return e.config.maxTextureSize = t, e.textureCreator?.setMaxTextureSize(t);
+}
+async function On(e) {
+	e._log("Creating material textures (parallel with BVH)");
+	try {
+		let { srgbLists: t, linearLists: n, remap: r } = e._bucketTextures();
+		An(e, r), e.materials?.length && (e.materialData = e.textureCreator.createMaterialRawData(e.materials));
+		let i = (t, n) => t.length === 0 ? Promise.resolve(null) : e.textureCreator.createTexturesToDataTexture(t, { srgbPool: n }).then((e) => (e && n && (e.colorSpace = M), e)), [a, o] = await Promise.all([Promise.all(t.map((e) => i(e, !0))), Promise.all(n.map((e) => i(e, !1)))]);
+		e.srgbBucketTextures = a, e.linearBucketTextures = o, e._log("Material textures complete", {
+			materialData: !!e.materialData,
+			srgbBuckets: a.map((e) => e ? `${e.image.width}x${e.image.height}x${e.image.depth}` : "-").join(","),
+			linearBuckets: o.map((e) => e ? `${e.image.width}x${e.image.height}x${e.image.depth}` : "-").join(",")
+		});
+	} catch (e) {
+		throw Z.error("texture creation failed:", e), e;
+	}
+}
+function kn(e) {
+	let t = e.config.maxTextureSize, n = c.MATERIAL_BUCKET_COUNT, a = c.BUCKET_LAYER_STRIDE, o = (e) => {
+		let t = /* @__PURE__ */ new Set(), n = [];
+		for (let r of e) for (let e of r || []) {
+			if (!e?.image) continue;
+			let r = e.source?.uuid ?? e.uuid;
+			t.has(r) || (t.add(r), n.push({
+				width: e.image.width,
+				height: e.image.height
+			}));
+		}
+		return n;
+	}, l = [
+		e.maps,
+		e.emissiveMaps,
+		e.sheenColorMaps,
+		e.specularColorMaps,
+		e.diffuseTransmissionColorMaps
+	], u = [
+		e.normalMaps,
+		e.bumpMaps,
+		e.roughnessMaps,
+		e.metalnessMaps,
+		e.displacementMaps,
+		e.anisotropyMaps,
+		e.transmissionMaps,
+		e.clearcoatMaps,
+		e.clearcoatRoughnessMaps,
+		e.clearcoatNormalMaps,
+		e.sheenRoughnessMaps,
+		e.iridescenceMaps,
+		e.iridescenceThicknessMaps,
+		e.specularIntensityMaps,
+		e.diffuseTransmissionMaps,
+		e.diffuseRoughnessMaps
+	], d = r(o(l), t, n), f = r(o(u), t, n);
+	e._srgbBucketShapes = d, e._linearBucketShapes = f;
+	let p = Array.from({ length: n }, () => []), m = Array.from({ length: n }, () => []), h = Array.from({ length: n }, () => /* @__PURE__ */ new Map()), g = Array.from({ length: n }, () => /* @__PURE__ */ new Map());
+	e._srgbTexPacked = /* @__PURE__ */ new Map(), e._linearTexPacked = /* @__PURE__ */ new Map();
+	let v = !1, y = !1, b = (t, n, r, o, c) => {
+		if (!t) return -1;
+		if (!t.image) return y || e.config.issues?.record(_.TEXTURE_BUILD_FAILED, "a material map had not finished decoding when the scene was packed; it renders untextured", { texture: t.name || t.source?.uuid || t.uuid }), y = !0, -1;
+		let l = s(t.image.width, t.image.height, c), u = t.source?.uuid ?? t.uuid, d = r[l].get(u);
+		if (d !== void 0) return i(l, d);
+		if (n[l].length >= a) return Z.warn(`texture bucket ${l} full (${a}); dropping a map`), v || e.config.issues?.record(_.TEXTURE_LIMIT_EXCEEDED, `texture bucket ${l} full (${a} layers); the rest render untextured`, {
+			bucket: l,
+			limit: a
+		}), v = !0, -1;
+		n[l].push(t);
+		let f = n[l].length - 1;
+		r[l].set(u, f);
+		let p = i(l, f);
+		return o.set(u, p), p;
+	}, x = (e, t, n, r, i) => (e || []).map((e) => b(e, t, n, r, i));
+	return {
+		srgbLists: p,
+		linearLists: m,
+		remap: {
+			albedo: x(e.maps, p, h, e._srgbTexPacked, d),
+			emissive: x(e.emissiveMaps, p, h, e._srgbTexPacked, d),
+			normal: x(e.normalMaps, m, g, e._linearTexPacked, f),
+			bump: x(e.bumpMaps, m, g, e._linearTexPacked, f),
+			roughness: x(e.roughnessMaps, m, g, e._linearTexPacked, f),
+			metalness: x(e.metalnessMaps, m, g, e._linearTexPacked, f),
+			displacement: x(e.displacementMaps, m, g, e._linearTexPacked, f),
+			anisotropy: x(e.anisotropyMaps, m, g, e._linearTexPacked, f),
+			transmission: x(e.transmissionMaps, m, g, e._linearTexPacked, f),
+			clearcoat: x(e.clearcoatMaps, m, g, e._linearTexPacked, f),
+			clearcoatRoughness: x(e.clearcoatRoughnessMaps, m, g, e._linearTexPacked, f),
+			clearcoatNormal: x(e.clearcoatNormalMaps, m, g, e._linearTexPacked, f),
+			sheenColor: x(e.sheenColorMaps, p, h, e._srgbTexPacked, d),
+			sheenRoughness: x(e.sheenRoughnessMaps, m, g, e._linearTexPacked, f),
+			iridescence: x(e.iridescenceMaps, m, g, e._linearTexPacked, f),
+			iridescenceThickness: x(e.iridescenceThicknessMaps, m, g, e._linearTexPacked, f),
+			specularIntensity: x(e.specularIntensityMaps, m, g, e._linearTexPacked, f),
+			specularColor: x(e.specularColorMaps, p, h, e._srgbTexPacked, d),
+			diffuseTransmission: x(e.diffuseTransmissionMaps, m, g, e._linearTexPacked, f),
+			diffuseTransmissionColor: x(e.diffuseTransmissionColorMaps, p, h, e._srgbTexPacked, d),
+			diffuseRoughness: x(e.diffuseRoughnessMaps, m, g, e._linearTexPacked, f)
+		}
+	};
+}
+function An(e, t) {
+	let n = (e, t) => e >= 0 && e < t.length ? t[e] : -1;
+	for (let r of e.materials) r.map = n(r.map, t.albedo), r.emissiveMap = n(r.emissiveMap, t.emissive), r.normalMap = n(r.normalMap, t.normal), r.bumpMap = n(r.bumpMap, t.bump), r.roughnessMap = n(r.roughnessMap, t.roughness), r.metalnessMap = n(r.metalnessMap, t.metalness), r.displacementMap = n(r.displacementMap, t.displacement), r.anisotropyMap = n(r.anisotropyMap, t.anisotropy), r.transmissionMap = n(r.transmissionMap, t.transmission), r.clearcoatMap = n(r.clearcoatMap, t.clearcoat), r.clearcoatRoughnessMap = n(r.clearcoatRoughnessMap, t.clearcoatRoughness), r.clearcoatNormalMap = n(r.clearcoatNormalMap, t.clearcoatNormal), r.sheenColorMap = n(r.sheenColorMap, t.sheenColor), r.sheenRoughnessMap = n(r.sheenRoughnessMap, t.sheenRoughness), r.iridescenceMap = n(r.iridescenceMap, t.iridescence), r.iridescenceThicknessMap = n(r.iridescenceThicknessMap, t.iridescenceThickness), r.specularIntensityMap = n(r.specularIntensityMap, t.specularIntensity), r.specularColorMap = n(r.specularColorMap, t.specularColor), r.diffuseTransmissionMap = n(r.diffuseTransmissionMap, t.diffuseTransmission), r.diffuseTransmissionColorMap = n(r.diffuseTransmissionColorMap, t.diffuseTransmissionColor), r.diffuseRoughnessMap = n(r.diffuseRoughnessMap, t.diffuseRoughness);
+}
+function jn(e) {
+	e._disposeBucketTextures();
+}
+function Mn(e) {
+	for (let t of ["srgbBucketTextures", "linearBucketTextures"]) {
+		let n = e[t];
+		if (n) {
+			for (let e of n) if (e && typeof e.dispose == "function") try {
+				e.dispose();
+			} catch (e) {
+				Z.warn(`error disposing ${t}:`, e);
+			}
+			e[t] = null;
+		}
+	}
+}
+async function Nn(e, t) {
+	if (e.isProcessing) throw Error("Already processing. Cannot rebuild materials during processing.");
+	e._log("Rebuilding materials and textures");
+	let n = performance.now();
+	try {
+		e.isProcessing = !0;
+		let r = e.geometryExtractor.extractMaterialsOnly(t);
+		e.srgbBucketTextures = e.linearBucketTextures = null, e.textureCreator.textureCache = new X(), e.materials = r.materials, e.meshes = r.meshes, e._adoptTextureLists(r), await e._createMaterialTextures();
+		let i = performance.now() - n;
+		return e._log(`Material rebuild complete (${i.toFixed(2)}ms)`, {
+			materials: e.materials.length,
+			textures: e.maps.length
+		}), e;
+	} catch (e) {
+		throw Z.error("material rebuild failed:", e), e;
+	} finally {
+		e.isProcessing = !1;
+	}
+}
+function Pn(e, t) {
+	for (let n of En) e[n] = t[n] ?? [];
+}
+//#endregion
+//#region src/Version.js
+var Fn = "11.17.0", In = 256 * 1024, Ln = [
+	[/\.jpe?g(\?|#|$)/i, "image/jpeg"],
+	[/\.webp(\?|#|$)/i, "image/webp"],
+	[/\.avif(\?|#|$)/i, "image/avif"]
+];
+function Q(e) {
+	return e.mimeType ? e.mimeType : e.uri?.startsWith("data:") ? e.uri.slice(5, e.uri.indexOf(";")) : Ln.find(([t]) => t.test(e.uri ?? ""))?.[1] ?? "image/png";
+}
+function Rn(e) {
+	for (let t = 8; t + 12 <= e.length;) {
+		let n = (e[t] << 24 | e[t + 1] << 16 | e[t + 2] << 8 | e[t + 3]) >>> 0, r = t + 12 + n;
+		if (e[t + 4] === 73 && e[t + 5] === 69 && e[t + 6] === 78 && e[t + 7] === 68) return e.subarray(0, r);
+		t = r;
+	}
+	return e;
+}
+function zn(e) {
+	let t = (t) => (e[t] << 24 | e[t + 1] << 16 | e[t + 2] << 8 | e[t + 3]) >>> 0, n = (t) => e[t] << 8 | e[t + 1], r = (t, n) => String.fromCharCode(e[t], e[t + 1], e[t + 2], e[t + 3]) === n;
+	if (e.length >= 24 && t(0) === 2303741511 && r(12, "IHDR")) {
+		for (let n = 8; n + 8 <= e.length; n += 12 + t(n)) {
+			if (r(n + 4, "eXIf")) return null;
+			if (r(n + 4, "IDAT")) return {
+				width: t(16),
+				height: t(20)
+			};
+		}
+		return null;
+	}
+	if (e.length < 4 || n(0) !== 65496) return null;
+	for (let t = 2; t + 4 <= e.length;) {
+		if (e[t] !== 255) return null;
+		let i = e[t + 1];
+		if (i === 255) {
+			t++;
+			continue;
+		}
+		if (i === 1 || i >= 208 && i <= 215) {
+			t += 2;
+			continue;
+		}
+		if (i === 225 && t + 10 <= e.length && r(t + 4, "Exif")) return null;
+		if (i >= 192 && i <= 207 && i !== 196 && i !== 200 && i !== 204) return t + 9 <= e.length ? {
+			width: n(t + 7),
+			height: n(t + 5)
+		} : null;
+		if (i === 218 || i === 217) return null;
+		t += 2 + n(t + 2);
+	}
+	return null;
+}
+function Bn({ data: e, width: t, height: n }, { shared: r = !1 } = {}) {
+	let i = new Uint8Array(e.buffer, e.byteOffset, t * n * 4), a = i;
+	return r && typeof SharedArrayBuffer < "u" && !(i.buffer instanceof SharedArrayBuffer) && (a = new Uint8Array(new SharedArrayBuffer(i.byteLength)), a.set(i)), {
+		data: a,
+		width: t,
+		height: n
+	};
+}
+function $(e, { width: t = e.width, height: n = e.height } = {}) {
+	let r = new te(e?.data ?? null, t, n, j, ge);
+	return r.needsUpdate = !0, r;
+}
+function Vn(e, t) {
+	return nt().decodeImage(t === "image/png" ? Rn(e) : e, t);
+}
+async function Hn(e) {
+	let t = await fetch(e);
+	if (!t.ok) throw Error(`HTTP ${t.status}`);
+	return new Uint8Array(await t.arrayBuffer());
+}
+function Un(e, t) {
+	return e.options.manager.resolveURL(ce.resolveURL(t.uri, e.options.path));
+}
+function Wn(e, t) {
+	return t.bufferView === void 0 ? Hn(Un(e, t)) : e.getDependency("bufferView", t.bufferView).then((e) => new Uint8Array(e));
+}
+function Gn(e, t, n) {
+	if (t.bufferView !== void 0) return e.getDependency("bufferView", t.bufferView).then((e) => new Blob([e], { type: t.mimeType }));
+	let { manager: r } = e.options, i = Un(e, t);
+	return r.itemStart(i), fetch(i, {
+		credentials: n.crossOrigin === "anonymous" ? "same-origin" : "include",
+		headers: n.requestHeader,
+		signal: r.abortController?.signal
+	}).then((e) => {
+		if (!e.ok) throw Error(`HTTP ${e.status}`);
+		return e.blob();
+	}).catch((e) => {
+		throw r.itemError(i), e;
+	}).finally(() => r.itemEnd(i));
+}
+var Kn = (e, t) => !!t && t !== e.textureLoader && typeof t.parse == "function";
+function qn(e, t, n) {
+	if (e.sourceCache[t] !== void 0) return e.sourceCache[t].then((e) => e.clone());
+	let r = Wn(e, e.json.images[t]).then((e) => new Promise((t, r) => {
+		n.parse(e.buffer.slice(e.byteOffset, e.byteOffset + e.byteLength), t, r);
+	}));
+	return e.sourceCache[t] = r, r;
+}
+async function Jn(e, t = Q({ uri: e })) {
+	let n = $(Bn(await Vn(await Hn(e), t)));
+	return n.flipY = !0, n;
+}
+async function Yn(e, t) {
+	let n = $(Bn(await Vn(e, Q({ uri: t })), { shared: !0 }));
+	return n.flipY = !0, n;
+}
+function Xn(e, t) {
+	let n = $(null, {
+		width: e,
+		height: t
+	});
+	return n.flipY = !0, n;
+}
+async function Zn(e, t, n, r) {
+	let i = zn(e.subarray(0, In)), a;
+	try {
+		a = await t(i);
+	} catch (e) {
+		throw r?.(n.uri ?? `bufferView ${n.bufferView}`, e), e;
+	}
+	return Sn(a, () => t(null).then((e) => e.image), { resident: !i }), n.extras && typeof n.extras == "object" && Object.assign(a.userData, n.extras), a.userData.mimeType = Q(n), a;
+}
+function Qn(e, t = null) {
+	let n = e.loadImageSource;
+	return e.loadImageSource = function(e, r) {
+		let i = this.json.images[e];
+		if (this.sourceCache[e] !== void 0 || i.bufferView === void 0 && i.uri === void 0 || !r?.isImageBitmapLoader) return n.call(this, e, r);
+		let a = Gn(this, i, r).then(async (e) => Zn(new Uint8Array(await e.slice(0, In).arrayBuffer()), async (t) => {
+			let n = new he(t ? {
+				...t,
+				data: null
+			} : await createImageBitmap(e, {
+				...r.options,
+				colorSpaceConversion: "none"
+			}));
+			return n.needsUpdate = !0, n;
+		}, i, t));
+		return this.sourceCache[e] = a, a;
+	}, { name: "RAYZEE_browser_images" };
+}
+function $n(e, t = null) {
+	return e.loadImageSource = function(e, n) {
+		if (Kn(this, n)) return qn(this, e, n);
+		let r = this.json.images[e], i = /* @__PURE__ */ Error("no image decoder in this runtime: configurePlatform( nodePlatform( { decodeImage } ) ) — see \"Running in Node\"");
+		return t?.(r.uri ?? `bufferView ${r.bufferView}`, i), Promise.reject(i);
+	}, { name: "RAYZEE_missing_image_decoder" };
+}
+function er(e, t = null) {
+	return e.loadImageSource = function(e, n) {
+		if (Kn(this, n)) return qn(this, e, n);
+		if (this.sourceCache[e] !== void 0) return this.sourceCache[e].then((e) => e.clone());
+		let r = this.json.images[e], i = Q(r), a = r.uri ?? `bufferView ${r.bufferView}`, o = Wn(this, r).then((e) => {
+			let n = new Blob([e]);
+			return Zn(e, async (e) => $(e ? null : Bn(await Vn(new Uint8Array(await n.arrayBuffer()), i), { shared: !0 }), e ?? {}), r, t);
+		}, (e) => {
+			throw t?.(a, e), e;
+		});
+		return this.sourceCache[e] = o, o;
+	}, { name: "RAYZEE_platform_images" };
+}
+//#endregion
+//#region src/loaders/SceneMetadata.js
+var tr = [
+	"sourceFile",
+	"url",
+	"file"
+];
+function nr(e) {
+	if (typeof e == "string") try {
+		let t = JSON.parse(e);
+		return t && typeof t == "object" ? t : null;
+	} catch {
+		return null;
+	}
+	return e && typeof e == "object" ? e : null;
+}
+function rr(e) {
+	let t = typeof e == "string" ? parseFloat(e) : e;
+	return Number.isFinite(t) ? t : void 0;
+}
+function ir(e) {
+	let t = nr(e);
+	if (!t) return null;
+	let n = (e) => e && (e.environment !== void 0 || e.render !== void 0), r = nr(t.rayzee);
+	return n(r) ? r : n(t) ? t : null;
+}
+function ar(e) {
+	let t = nr(e);
+	if (!t) return null;
+	let n = tr.map((e) => t[e]).find((e) => typeof e == "string" && e.trim());
+	if (!n) return null;
+	let r = rr(t.rotation), i = rr(t.intensity), a = { sourceFile: n.trim() };
+	return r !== void 0 && (a.rotation = r), i !== void 0 && (a.intensity = Math.max(0, i)), a;
+}
+var or = [
+	"maxBounces",
+	"samples",
+	"width",
+	"height"
+];
+function sr(e) {
+	let t = nr(e);
+	if (!t) return null;
+	let n = {};
+	for (let e of or) {
+		let r = rr(t[e]);
+		r !== void 0 && r > 0 && (n[e] = Math.round(r));
+	}
+	return Object.keys(n).length ? n : null;
+}
+function cr(e) {
+	let t = ir(e);
+	if (!t) return null;
+	let n = ar(t.environment), r = sr(t.render);
+	return !n && !r ? null : {
+		...n ? { environment: n } : {},
+		...r ? { render: r } : {}
+	};
+}
+function lr(e) {
+	if (!e) return null;
+	let t = [
+		e.userData,
+		e.asset?.extras,
+		e.scene?.userData
+	];
+	Array.isArray(e.scenes) && t.push(...e.scenes.map((e) => e?.userData));
+	for (let e of t) {
+		let t = cr(e);
+		if (t) return t;
+	}
+	return null;
+}
+//#endregion
+//#region src/loaders/ArchiveFormats.js
+var ur = Object.freeze({
+	zip: {
+		type: "archive",
+		name: "ZIP Archive"
+	},
+	gz: {
+		type: "archive",
+		name: "Gzipped TAR Archive"
+	},
+	tgz: {
+		type: "archive",
+		name: "Gzipped TAR Archive"
+	},
+	tar: {
+		type: "archive",
+		name: "TAR Archive"
+	}
+}), dr = (e) => typeof Blob < "u" && e instanceof Blob, fr = (e) => !!e && typeof e == "object" && !dr(e) && e.files != null, pr = (e) => e.startsWith(".") || e === "__MACOSX";
+function mr({ name: e = null, files: t }, { isModel: n = () => !1 } = {}) {
+	let r = /* @__PURE__ */ new Map();
+	for (let e of t) {
+		let t = dr(e) ? e : e.file, n = dr(e) ? e.webkitRelativePath || e.name : e.path, i = String(n ?? "").replace(/\\/g, "/").split("/").filter((e) => e && e !== ".").join("/");
+		!i || !t || i.split("/").some(pr) || r.set(i, {
+			path: i,
+			file: t
+		});
+	}
+	let i = [...r.values()].sort((e, t) => e.path < t.path ? -1 : +(e.path > t.path)), a = i[0]?.path.split("/")[0], o = i.length > 0 && i.every((e) => e.path.startsWith(a + "/")) ? a : null;
+	return {
+		name: e ?? o ?? (i.find((e) => n(e.path)) ?? i[0])?.path.split("/").pop() ?? "Folder",
+		files: i,
+		flat: o === null && i.every((e) => !e.path.includes("/"))
+	};
+}
+//#endregion
+export { et as $, Et as A, Ft as B, Tn as C, nn as D, Jt as E, kt as F, tt as G, gt as H, Ot as I, rt as J, W as K, Dt as L, wt as M, jt as N, tn as O, Tt as P, st as Q, At as R, Nn as S, Dn as T, _t as U, Pt as V, dt as W, at as X, it as Y, lt as Z, kn as _, cr as a, We as at, jn as b, zn as c, je as ct, Yn as d, Te as dt, V as et, Xn as f, De as ft, Pn as g, _n as h, we as ht, lr as i, $e as it, It as j, en as k, Jn as l, Oe as lt, Fn as m, Ce as mt, fr as n, Ge as nt, In as o, Qe as ot, er as p, Se as pt, nt as q, mr as r, Ke as rt, Qn as s, Ie as st, ur as t, Re as tt, $n as u, I as ut, On as v, Sn as w, wn as x, Mn as y, Nt as z };