rayzee 11.2.1 → 11.3.0

package/dist/sceneCachePolicy-BAib5fCp.js

@@ -0,0 +1,1602 @@
+import { t as e } from "./EngineEvents-Ci8dVWCP.js";
+import { a as t, i as n, r } from "./Logger-dDDGj9Av.js";
+import { f as i, v as a, y as o } from "./BufferLayout-xPRH9jYD.js";
+import { n as s } from "./EngineIssues-CIZnXHsF.js";
+import { n as c, r as l } from "./shared-BGBcSxBQ.js";
+import { n as u } from "./AssetConfig-DSEntE65.js";
+import { BackSide as d, BufferAttribute as f, Color as p, DoubleSide as m, FrontSide as h, Matrix3 as g, Matrix4 as _, RGBAFormat as v, Vector2 as y, Vector3 as b } from "three";
+//#region src/Processor/utils.js
+var x = null;
+function S(e) {
+	x = e;
+}
+var C = () => x?.({ type: e.LOADING_RESET }), w = (t) => {
+	x?.({
+		type: e.LOADING_UPDATE,
+		...t
+	});
+}, T = (t) => {
+	x?.({
+		type: e.STATS_UPDATE,
+		...t
+	});
+};
+function ee(e) {
+	return e.frameCount || 0;
+}
+function te(e) {
+	if (Array.isArray(e)) e.forEach((e) => {
+		e.userData && e.userData.isFallback || (ne(e), e.dispose());
+	});
+	else {
+		if (e.userData && e.userData.isFallback) return;
+		ne(e), e.dispose();
+	}
+}
+function ne(e) {
+	e && [
+		"alphaMap",
+		"aoMap",
+		"bumpMap",
+		"clearcoatMap",
+		"clearcoatNormalMap",
+		"clearcoatRoughnessMap",
+		"displacementMap",
+		"emissiveMap",
+		"envMap",
+		"gradientMap",
+		"lightMap",
+		"map",
+		"metalnessMap",
+		"normalMap",
+		"roughnessMap",
+		"specularMap",
+		"sheenColorMap",
+		"sheenRoughnessMap",
+		"specularIntensityMap",
+		"specularColorMap",
+		"thicknessMap",
+		"transmissionMap",
+		"diffuseTransmissionMap",
+		"diffuseTransmissionColorMap"
+	].forEach((t) => {
+		e[t] && (e[t].dispose(), e[t] = null);
+	});
+}
+function re({ material: e, geometry: t, children: n }) {
+	if (e && te(e), t && t.dispose(), n.length > 0) for (let e of n) re(e);
+}
+function ie(e) {
+	if (!e) return;
+	e._canvasTarget && e._onCanvasTargetResize && e._canvasTarget.removeEventListener("resize", e._onCanvasTargetResize);
+	let t = e.dispose();
+	return e._canvasTarget = null, t;
+}
+function ae(e, t = []) {
+	if (e && !(t.includes(e.name) || e.isScene)) {
+		if (e.isMaterial) {
+			te(e);
+			return;
+		}
+		for (; e.children.length > 0;) for (let t of e.children) ae(t);
+		re(e), e.removeFromParent(), e.clear();
+	}
+}
+function oe(e) {
+	e?.traverse((e) => {
+		e.geometry?.userData?.__rayzeeOwned && e.geometry.dispose();
+	});
+}
+function se(e, t) {
+	return t;
+}
+function ce(e, t = !1) {
+	return t ? 1 : 1 / (e + 1);
+}
+function le() {
+	let e = 0, t = 0, n = 0, r = 0;
+	return {
+		start() {
+			e = performance.now();
+		},
+		end() {
+			t = performance.now();
+			let i = t - e;
+			return r += i, n++, i;
+		},
+		getAverageFrameTime() {
+			return n > 0 ? r / n : 0;
+		},
+		getFPS() {
+			let e = this.getAverageFrameTime();
+			return e > 0 ? 1e3 / e : 0;
+		},
+		reset() {
+			n = 0, r = 0;
+		}
+	};
+}
+//#endregion
+//#region src/EngineDefaults.js
+var E = de({
+	maxBounces: 3,
+	transmissiveBounces: 5,
+	maxSubsurfaceSteps: 8,
+	maxTransparentBounces: 32,
+	integrator: "path",
+	shadowRays: "two",
+	samplingTechnique: 2,
+	enableEmissiveTriangleSampling: !1,
+	emissiveBoost: 1,
+	enableAlphaShadows: !1,
+	fireflyThreshold: 3,
+	shadowTerminatorOffset: .1,
+	globalIlluminationIntensity: 1,
+	wavefrontSortMaterials: !0,
+	maxSamples: 60,
+	renderLimitMode: "frames",
+	renderTimeLimit: 30,
+	renderMode: 0,
+	useAdaptiveSampling: !0,
+	noiseThreshold: .1,
+	adaptiveMinSamples: 8,
+	adaptiveStopFraction: .9,
+	usePixelFreeze: !0,
+	pixelFreezeThreshold: .02,
+	pixelFreezeStability: 8,
+	convergenceOverlay: !1,
+	interactionModeEnabled: !0,
+	exposure: 1,
+	saturation: 1,
+	transparentBackground: !1,
+	backgroundColor: "#000000",
+	enableEnvironment: !0,
+	environmentIntensity: 1,
+	environmentRotation: 0,
+	showBackground: !0,
+	backgroundIntensity: 1,
+	backgroundBlurriness: 0,
+	backgroundBlurSamples: 8,
+	groundProjectionEnabled: !1,
+	groundProjectionRadius: 100,
+	groundProjectionHeight: 15,
+	groundProjectionLevel: 0,
+	enableGroundCatcher: !1,
+	groundCatcherHeight: 0,
+	cameraProjection: "perspective",
+	panoramaLonRange: [-180, 180],
+	panoramaLatRange: [-90, 90],
+	panoramaLevelHorizon: !0,
+	enableDOF: !1,
+	dofMode: "look",
+	dofBlur: .05,
+	focusDistance: .8,
+	aperture: 5.6,
+	focalLength: 50,
+	apertureScale: 1,
+	anamorphicRatio: 1,
+	unitsPerMetre: 1,
+	maxTextureSize: 4096,
+	areaLightIntensityScale: .1,
+	visMode: 0,
+	debugVisScale: 100
+}), ue = Object.freeze({
+	perspective: 0,
+	equirectangular: 1,
+	orthographic: 2
+}), D = de({
+	color: [
+		1,
+		1,
+		1
+	],
+	emissive: [
+		0,
+		0,
+		0
+	],
+	emissiveIntensity: 1,
+	roughness: 1,
+	metalness: 0,
+	ior: 1.5,
+	opacity: 1,
+	transmission: 0,
+	thickness: 0,
+	attenuationColor: [
+		1,
+		1,
+		1
+	],
+	attenuationDistance: Infinity,
+	dispersion: 0,
+	sheen: 0,
+	sheenRoughness: 1,
+	sheenColor: [
+		0,
+		0,
+		0
+	],
+	specularIntensity: 1,
+	specularColor: [
+		1,
+		1,
+		1
+	],
+	clearcoat: 0,
+	clearcoatRoughness: 0,
+	iridescence: 0,
+	iridescenceIOR: 1.3,
+	iridescenceThicknessRange: [100, 400],
+	normalScale: [1, 1],
+	bumpScale: 1,
+	displacementScale: 1,
+	transparent: 0,
+	alphaTest: 0,
+	alphaMode: 0,
+	side: 0,
+	depthWrite: 1,
+	subsurface: 0,
+	subsurfaceColor: [
+		1,
+		1,
+		1
+	],
+	subsurfaceRadius: [
+		1,
+		.2,
+		.1
+	],
+	subsurfaceRadiusScale: 1,
+	subsurfaceAnisotropy: 0,
+	anisotropy: 0,
+	anisotropyRotation: 0,
+	diffuseTransmission: 0,
+	diffuseTransmissionColor: [
+		1,
+		1,
+		1
+	]
+});
+function de(e) {
+	for (let t of Object.values(e)) typeof t == "object" && Object.freeze(t);
+	return Object.freeze(e);
+}
+var fe = {
+	maxSamples: 30,
+	bounces: 20,
+	transmissiveBounces: 24,
+	maxSubsurfaceSteps: 64,
+	renderMode: 1,
+	enableAlphaShadows: !0,
+	enableOIDN: !0,
+	oidnQuality: "high",
+	interactionModeEnabled: !1,
+	useAdaptiveSampling: !0,
+	noiseThreshold: .02,
+	adaptiveStopFraction: .94,
+	usePixelFreeze: !0
+}, pe = {
+	maxSamples: E.maxSamples,
+	bounces: E.maxBounces,
+	renderMode: E.renderMode,
+	enableAlphaShadows: E.enableAlphaShadows,
+	transmissiveBounces: 12,
+	maxSubsurfaceSteps: E.maxSubsurfaceSteps,
+	enableOIDN: !0,
+	oidnQuality: "fast",
+	interactionModeEnabled: !0,
+	useAdaptiveSampling: !0,
+	noiseThreshold: .1,
+	usePixelFreeze: !0
+};
+function me(e) {
+	return {
+		maxSamples: e.maxSamples,
+		maxBounces: e.bounces,
+		transmissiveBounces: e.transmissiveBounces,
+		maxSubsurfaceSteps: e.maxSubsurfaceSteps,
+		enableAlphaShadows: e.enableAlphaShadows ?? !1,
+		useAdaptiveSampling: e.useAdaptiveSampling ?? !1,
+		noiseThreshold: e.noiseThreshold ?? E.noiseThreshold,
+		adaptiveStopFraction: e.adaptiveStopFraction ?? E.adaptiveStopFraction,
+		adaptiveMinSamples: e.adaptiveMinSamples ?? E.adaptiveMinSamples,
+		usePixelFreeze: e.usePixelFreeze ?? !1,
+		pixelFreezeThreshold: e.pixelFreezeThreshold ?? E.pixelFreezeThreshold,
+		pixelFreezeStability: e.pixelFreezeStability ?? E.pixelFreezeStability,
+		interactionModeEnabled: e.interactionModeEnabled ?? E.interactionModeEnabled
+	};
+}
+//#endregion
+//#region src/Processor/TextureBuckets.js
+var O = {
+	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
+}, he = 64;
+function k(e, t) {
+	let n = Math.ceil(Math.max(1, e) / he) * he;
+	return Math.min(t, Math.max(O.MIN_TEXTURE_WIDTH, n));
+}
+function A(e) {
+	let t = 0, n = 0, r = 0;
+	for (let i of e) t = Math.max(t, i.width), n = Math.max(n, i.height), r += i.count;
+	return {
+		units: e,
+		width: t,
+		height: n,
+		count: r
+	};
+}
+function j(e, t) {
+	return k(e.width, t) * e.height * e.count * 4;
+}
+function M(e, t) {
+	return e.reduce((e, n) => e + j(n, t), 0);
+}
+function ge(e, t, n) {
+	let r = e.slice();
+	for (; r.length > t;) {
+		let e = null;
+		for (let t = 0; t < r.length; t++) for (let i = t + 1; i < r.length; i++) {
+			let a = A(r[t].units.concat(r[i].units)), o = j(a, n) - j(r[t], n) - j(r[i], n);
+			(!e || o < e.delta) && (e = {
+				i: t,
+				j: i,
+				delta: o,
+				fused: a
+			});
+		}
+		r = r.filter((t, n) => n !== e.i && n !== e.j).concat([e.fused]);
+	}
+	return r;
+}
+function _e(e, t, n) {
+	let r = [];
+	for (let e = t - 1; e >= 0; e--) r.push(Math.max(O.MIN_TEXTURE_WIDTH, Math.round(n / 2 ** e)));
+	let i = r.map(() => []);
+	for (let t of e) {
+		let e = 2 ** Math.ceil(Math.log2(Math.max(t.width, t.height))), n = r.findIndex((t) => e <= t);
+		n < 0 && (n = r.length - 1), i[n].push(t);
+	}
+	return i.filter((e) => e.length).map(A);
+}
+function ve(e, t) {
+	let n = e;
+	for (let e = 0; e < 8; e++) {
+		let e = !1;
+		for (let r of n.flatMap((e) => e.units)) {
+			let i = n.findIndex((e) => e.units.includes(r));
+			if (!(i < 0)) for (let a = 0; a < n.length; a++) {
+				if (a === i) continue;
+				let o = [];
+				for (let e = 0; e < n.length; e++) if (e === i) {
+					let t = n[e].units.filter((e) => e !== r);
+					t.length && o.push(A(t));
+				} else e === a ? o.push(A(n[e].units.concat([r]))) : o.push(n[e]);
+				if (M(o, t) < M(n, t)) {
+					n = o, e = !0;
+					break;
+				}
+			}
+		}
+		if (!e) break;
+	}
+	return n;
+}
+function ye(e, t, n = O.MATERIAL_BUCKET_COUNT) {
+	let r = /* @__PURE__ */ new Map();
+	for (let { width: n, height: i } of e) {
+		let e = Math.min(t, Math.max(1, n || 1)), a = Math.min(t, Math.max(1, i || 1)), o = `${e}x${a}`, s = r.get(o);
+		s ? s.count++ : r.set(o, {
+			width: e,
+			height: a,
+			count: 1
+		});
+	}
+	let i = [...r.values()], a = i.map((e) => A([e]));
+	if (a.length > n) {
+		let e = _e(i, n, t), r = ge(a, n, t);
+		a = M(e, t) < M(r, t) ? e : r, a = ve(a, t);
+	}
+	return a.map((e) => ({
+		width: k(e.width, t),
+		height: e.height
+	})).sort((e, t) => e.width * e.height - t.width * t.height);
+}
+function be(e, t, n) {
+	let r = Math.max(1, e || 1), i = Math.max(1, t || 1);
+	for (let e = 0; e < n.length; e++) if (n[e].width >= r && n[e].height >= i) return e;
+	return Math.max(0, n.length - 1);
+}
+function xe(e, t) {
+	return e * O.BUCKET_LAYER_STRIDE + t;
+}
+//#endregion
+//#region src/Processor/ChunkedRecords.js
+var N = 64 * 1024 * 1024, P = typeof SharedArrayBuffer < "u", F = null;
+function Se(e) {
+	F = e;
+}
+function I(e, t, n) {
+	let r = n ? new e(new SharedArrayBuffer(t * e.BYTES_PER_ELEMENT)) : new e(t);
+	return F && r.byteLength > 0 && F(r.byteLength, n), r;
+}
+var L = class e {
+	constructor(e, t, n, r = N, 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(I(n, e * t, i)), s -= e;
+		}
+		this.chunks.length === 0 && this.chunks.push(I(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 = N, 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] = I(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 = I(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 = I(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;
+	}
+}, Ce = 32 * 1024 * 1024, R = "chunks.bin", we = class e {
+	static async create(t, n, r, { label: i = "", expectedBytes: a = 0 } = {}) {
+		let o = t?.area(l.SPILL), s = await o?.create(n, {
+			label: i,
+			expectedBytes: a,
+			growable: [R]
+		});
+		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(R, n.subarray(r, Math.min(n.length, r + Ce)), { at: e + r }), r += Ce;
+		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(R), !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);
+	}
+}, z = 32 * 1024 * 1024, Te = z / 4, Ee = 64 * 1024 * 1024, De = /* @__PURE__ */ new Map(), B = /* @__PURE__ */ new WeakSet();
+function V(e) {
+	B.delete(e), e.transfer?.(0);
+}
+function Oe(e) {
+	let t = De.get(e);
+	return t || De.set(e, t = new e(0)), t;
+}
+var ke = class e {
+	static async create(t, n, r = 0) {
+		let i = await we.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 = Oe(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 >= Te ? (n.at = this._end, n.array = e, this._end += t.byteLength, this._queue(n.at, t, [n]), n) : (this._pack && this._packUsed + t.byteLength > z && this._flushPack(), this._pack || (this._pack = new Uint8Array(z), this._packAt = this._end, this._packUsed = 0, this._end += z), 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), B.has(e.buffer) && V(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, B.has(t) && V(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 > Ee ? e = new r.Type(await this._store.readAt(r.at, r.byteLength)) : ((!t || r.at + r.byteLength > n + t.byteLength) && (t && V(t), n = r.at, t = await this._store.readAt(r.at, Ee)), 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 && B.add(e.buffer);
+			for (let t of r.attributes) t.array = e;
+		}
+		t && V(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();
+	}
+}, Ae = r("geometry"), H = O.MAX_TEXTURES_LIMIT, je = new Set([
+	"color",
+	"emissive",
+	"attenuationColor",
+	"sheenColor",
+	"specularColor",
+	"subsurfaceColor",
+	"diffuseTransmissionColor"
+]), U = Object.freeze({
+	MATERIAL: "material",
+	MAPPED: "mapped",
+	DEFAULT: "default",
+	HOST: "host"
+}), Me = [
+	1,
+	0,
+	0,
+	0,
+	0,
+	1,
+	0,
+	0,
+	0,
+	0,
+	1,
+	0,
+	0,
+	0,
+	0,
+	1
+];
+function Ne(e) {
+	for (let t = 0; t < 16; t++) if (e[t] !== Me[t]) return !1;
+	return !0;
+}
+function W(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,
+		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
+	};
+}
+function Pe(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 === v && e.transparent ? 2 : 0;
+}
+function Fe(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 Ie(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 G(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 K(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 q = 1 << 21;
+function J(e) {
+	return !!(e.isSkinnedMesh || Object.keys(e.geometry?.morphAttributes ?? {}).length);
+}
+function Le(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 Re(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 ze(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 f(i, n.itemSize, !0));
+}
+var Be = class {
+	constructor({ issues: e = null } = {}) {
+		this._issues = e, this._droppedTextures = 0, this._vectorPool = {
+			vec3: Array(9).fill().map(() => new b()),
+			vec2: [
+				,
+				,
+				,
+				,
+				,
+				,
+			].fill().map(() => new y())
+		}, this._geometryRanges = /* @__PURE__ */ new Map(), this.expandedTriangleCount = 0, this._allocatePlacements(0), this._matrixPool = {
+			mat3: new g(),
+			mat4: new _()
+		}, 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 && !J(e) && i * c <= q) n += i * c;
+				else if (s || J(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)) {
+					ke.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 || J(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: Fe(e),
+			instanceBytes: Ie(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"
+			]) ze(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 ? L.lazy : (...e) => new L(...e))(e, i.FLOATS_PER_TRIANGLE, Uint32Array, void 0, P), 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 = J(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
+		}), this._recordPlacements(e, n, l, c, u.count > 0 && a), u.count > 0 && 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 = Ne(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 <= q ? !0 : (this._issues?.record(s.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: q
+		}), !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(e) {
+		let n = this._materialUuidMap.get(e.uuid) ?? -1;
+		if (n === -1) {
+			e.depthWrite === !1 && (e.depthWrite = !0, t(Ae, "depthWrite", "material had depthWrite disabled — enabled for rastered rendering"));
+			let r = this.createMaterialObject(e);
+			this.materials.push(r), n = this.materials.length - 1, this._materialUuidMap.set(e.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(D)) e[t] = je.has(t) ? new p().fromArray(n) : Array.isArray(n) ? [...n] : n;
+		return e.normalScale = {
+			x: D.normalScale[0],
+			y: D.normalScale[1]
+		}, e;
+	}
+	mapLegacyMaterialToPhysical(e, t) {
+		let n = {};
+		switch (t) {
+			case "basic":
+				n.emissive = e.color.clone(), n.emissiveIntensity = 1, n.color = new p(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 p(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 = W(e), a = {}, o = (n) => r[n] === void 0 ? e[n] !== void 0 && e[n] !== null ? (a[n] = U.MATERIAL, e[n]) : (a[n] = U.DEFAULT, t[n]) : (a[n] = U.MAPPED, r[n]);
+		for (let e of [
+			"transparent",
+			"alphaMode",
+			"side",
+			"depthWrite"
+		]) a[e] = U.MATERIAL;
+		return {
+			uuid: e.uuid,
+			color: o("color"),
+			emissive: o("emissive"),
+			emissiveIntensity: o("emissiveIntensity"),
+			roughness: Math.max(.02, o("roughness")),
+			metalness: o("metalness"),
+			ior: o("ior"),
+			opacity: o("opacity"),
+			transmission: o("transmission"),
+			thickness: o("thickness"),
+			attenuationColor: o("attenuationColor"),
+			attenuationDistance: o("attenuationDistance"),
+			dispersion: o("dispersion"),
+			sheen: o("sheen"),
+			sheenRoughness: o("sheenRoughness"),
+			sheenColor: o("sheenColor"),
+			clearcoat: o("clearcoat"),
+			clearcoatRoughness: o("clearcoatRoughness"),
+			iridescence: o("iridescence"),
+			iridescenceIOR: o("iridescenceIOR"),
+			iridescenceThicknessRange: o("iridescenceThicknessRange"),
+			subsurface: o("subsurface"),
+			subsurfaceColor: o("subsurfaceColor"),
+			subsurfaceRadius: o("subsurfaceRadius"),
+			subsurfaceRadiusScale: o("subsurfaceRadiusScale"),
+			subsurfaceAnisotropy: o("subsurfaceAnisotropy"),
+			anisotropy: o("anisotropy"),
+			anisotropyRotation: o("anisotropyRotation"),
+			specularIntensity: o("specularIntensity"),
+			specularColor: o("specularColor"),
+			diffuseTransmission: o("diffuseTransmission"),
+			diffuseTransmissionColor: o("diffuseTransmissionColor"),
+			normalScale: o("normalScale"),
+			bumpScale: o("bumpScale"),
+			displacementScale: o("displacementScale"),
+			transparent: +!!e.transparent,
+			alphaTest: o("alphaTest"),
+			alphaMode: Pe(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),
+			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),
+			mapMatrix: this.getTextureMatrix(i.map),
+			normalMapMatrices: this.getTextureMatrix(i.normalMap),
+			bumpMapMatrices: this.getTextureMatrix(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 g().elements;
+	}
+	getMaterialSide(e) {
+		if (e.transmission > 0) return 2;
+		switch (e.side) {
+			case h: return 0;
+			case d: return 1;
+			case m: 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 < H) {
+			t.push(e);
+			let i = t.length - 1;
+			return n.set(r, i), i;
+		}
+		return this._droppedTextures++, this._droppedTextures === 1 && this._issues?.record(s.TEXTURE_LIMIT_EXCEEDED, `scene needs more than ${H} distinct textures for one map type; the rest render untextured`, {
+			limit: H,
+			firstDropped: e.name || e.source?.uuid
+		}), -1;
+	}
+	extractGeometry(e, t, n, r = !1, i = !1) {
+		e.updateMatrix(), e.updateMatrixWorld();
+		let a = e.geometry;
+		a.attributes.normal || a.computeVertexNormals();
+		let o = a.attributes.position, s = a.attributes.normal, c = a.attributes.uv, l = a.index ? a.index.array : null, u = l ? l.length / 3 : o.count / 3;
+		if (i) {
+			let r = e.count ?? e.instanceMatrix.array.length / 16, i = this._matrixPool.mat4, a = new _();
+			for (let d = 0; d < r; d++) {
+				i.fromArray(e.instanceMatrix.array, d * 16), a.multiplyMatrices(e.matrixWorld, i);
+				let r = new g().getNormalMatrix(a);
+				this.extractTrianglesInBatch(o, s, c, l, u, t, n, a, r, Le(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 && Le(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 && (G(u, y), G(d, y), G(f, y), K(p, b), K(m, b), K(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, s, c, l, u, d, f, p, m) {
+		let h = i, g = this.triangles.baseOf(e), _ = this.triangleFloatChunks.chunkFor(e), v = this.triangles.chunkFor(e);
+		_[g + h.POSITION_A_OFFSET + 0] = t.x, _[g + h.POSITION_A_OFFSET + 1] = t.y, _[g + h.POSITION_A_OFFSET + 2] = t.z, v[g + h.NORMAL_A_PACKED_OFFSET] = a(s.x, s.y, s.z), _[g + h.POSITION_B_OFFSET + 0] = n.x, _[g + h.POSITION_B_OFFSET + 1] = n.y, _[g + h.POSITION_B_OFFSET + 2] = n.z, v[g + h.NORMAL_B_PACKED_OFFSET] = a(c.x, c.y, c.z), _[g + h.POSITION_C_OFFSET + 0] = r.x, _[g + h.POSITION_C_OFFSET + 1] = r.y, _[g + h.POSITION_C_OFFSET + 2] = r.z, v[g + h.NORMAL_C_PACKED_OFFSET] = a(l.x, l.y, l.z), _[g + h.UV_AB_OFFSET + 0] = u.x, _[g + h.UV_AB_OFFSET + 1] = u.y, _[g + h.UV_AB_OFFSET + 2] = d.x, _[g + h.UV_AB_OFFSET + 3] = d.y, _[g + h.UV_C_OFFSET + 0] = f.x, _[g + h.UV_C_OFFSET + 1] = f.y, v[g + h.MATERIAL_FLAGS_OFFSET] = o(p, this.materials[p]), v[g + h.MESH_INDEX_OFFSET] = m;
+	}
+	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 * i.FLOATS_PER_TRIANGLE * 4;
+		Ae.debug(n.list([
+			`${n.count(this.currentTriangleIndex, "tri")} (${n.mb(e)})`,
+			n.count(this.materials.length, "material"),
+			n.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.sheenColorMaps = [], this.sheenRoughnessMaps = [], this.iridescenceMaps = [], this.iridescenceThicknessMaps = [], this.specularIntensityMaps = [], this.specularColorMaps = [], this.diffuseTransmissionMaps = [], this.diffuseTransmissionColorMaps = [], 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,
+			sheenColorMaps: this.sheenColorMaps,
+			sheenRoughnessMaps: this.sheenRoughnessMaps,
+			iridescenceMaps: this.iridescenceMaps,
+			iridescenceThicknessMaps: this.iridescenceThicknessMaps,
+			specularIntensityMaps: this.specularIntensityMaps,
+			specularColorMaps: this.specularColorMaps,
+			diffuseTransmissionMaps: this.diffuseTransmissionMaps,
+			diffuseTransmissionColorMaps: this.diffuseTransmissionColorMaps,
+			directionalLights: this.directionalLights,
+			cameras: this.cameras
+		};
+	}
+}, Y = {
+	Worker: null,
+	decodeImage: null
+};
+function Ve(e) {
+	e && Object.assign(Y, e);
+}
+function He() {
+	return Y;
+}
+function Ue() {
+	return typeof navigator < "u" && navigator.hardwareConcurrency || 4;
+}
+function We() {
+	return !!Y.decodeImage || typeof self < "u" && (typeof createImageBitmap < "u" || typeof document < "u");
+}
+function Ge() {
+	return !!Y.Worker || typeof Worker < "u";
+}
+var X = 0;
+async function Ke(e) {
+	if (!Y.Worker || X === 0 && globalThis.Worker !== void 0) return e();
+	X++ === 0 && (globalThis.Worker = Y.Worker);
+	try {
+		return await e();
+	} finally {
+		--X === 0 && globalThis.Worker === Y.Worker && delete globalThis.Worker;
+	}
+}
+function qe(e, t) {
+	let n = Y.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;
+	}
+}
+//#endregion
+//#region src/Storage/CDFCache.js
+var Je = 5;
+function Ye(e, t) {
+	e && t && (e.userData.__rayzeeSource = t);
+}
+function Xe(e) {
+	let t = e?.userData?.__rayzeeSource;
+	if (!t) return null;
+	let { width: n = 0, height: r = 0 } = e.image ?? {};
+	return `cdf:${Je}:${t}|${n}x${r}|${e.userData.__rayzeeColorSpace ?? "native"}`;
+}
+var Ze = () => c(u().cacheNamespace)?.area(l.CDF) ?? null, Z = [
+	"exactConditional",
+	"exactMarginal",
+	"exactRowGuide",
+	"exactMarginalGuide"
+], Q = Z.map((e) => `${e}.f32`);
+async function Qe(e) {
+	let t = Xe(e), n = t ? await Ze()?.open(t) : null;
+	if (!n) return null;
+	try {
+		let e = await Promise.all(Q.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(Z.map((e, n) => [e, t[n]])),
+			totalSum: r,
+			width: i,
+			height: a,
+			exactWidth: o,
+			exactHeight: s,
+			radianceIntegral: c
+		};
+	} finally {
+		n.release();
+	}
+}
+async function $e(e, t) {
+	let { totalSum: n, width: r, height: i, exactWidth: a, exactHeight: o, radianceIntegral: s } = t, c = Z.map((e) => t[e]), l = Xe(e), u = l ? Ze() : 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 < Q.length; e++) await d.write(Q[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/Processor/HostMemory.js
+var et = i.FLOATS_PER_TRIANGLE * 4, tt = 64, nt = .9, rt = 28, it = 45, at = 4, ot = 1536 * 1024 * 1024, st = 7040 * 1024 * 1024, ct = 9216 * 1024 * 1024, lt = 12e7, ut = 6e7, dt = 8192;
+function ft(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 pt = 1.15, mt = 12 * 1024 * 1024 * 1024;
+function ht({ triangles: e, placements: t, geometryBytes: n = 0, instanceBytes: r = 0 }) {
+	let i = {
+		triangles: e * et,
+		bvh: Math.ceil(e * nt) * tt,
+		geometry: n,
+		instances: r,
+		placements: t * rt,
+		orderMaps: e * at
+	};
+	return i.total = i.triangles + i.bvh + i.geometry + i.instances + i.placements + i.orderMaps, i;
+}
+function gt(e, t, n) {
+	let r = e.geometry + e.instances + t * 4 + n, i = e.instances + e.placements + t * it + e.orderMaps;
+	return Math.max(r, i);
+}
+function _t(e, { chunkBytes: t = N, 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 vt = 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()
+		};
+	}
+}, yt = "11.3.0", $ = 1e4, bt = 15e5;
+function xt(e, t, n = $) {
+	return e >= n && t / bt < e / 3;
+}
+//#endregion
+export { ae as $, ze as A, k as B, We as C, U as D, Be as E, L as F, E as G, xe as H, N as I, fe as J, pe as K, P as L, Re as M, ke as N, Pe as O, we as P, oe as Q, Se as R, Ue as S, Ke as T, ye as U, be as V, ue as W, ce as X, me as Y, le as Z, $e as _, vt as a, w as at, qe as b, st as c, lt as d, ie as et, ft as f, Qe as g, gt as h, ct as i, se as it, W as j, Fe as k, dt as l, _t as m, xt as n, C as nt, ot as o, T as ot, ht as p, D as q, yt as r, S as rt, pt as s, $ as t, ee as tt, ut as u, Ye as v, Ge as w, He as x, Ve as y, O as z };