u-space 0.0.26 → 0.0.28

package/dist/plugins/atmosphere/index.js

@@ -1,20 +1,3146 @@
-import { Matrix4 as M, Vector3 as m, NoToneMapping as g } from "three/webgpu";
-import { mat3 as u, vec3 as i, add as E, log2 as S, float as c, pow as T, cdl as F, context as b, toneMapping as P, renderOutput as A } from "three/tsl";
-import { FnVar as R, FnLayout as p, highpVelocity as D, lensFlare as L, temporalAntialias as k, dithering as O } from "@takram/three-geospatial/webgpu";
-import { getECIToECEFRotationMatrix as U, getSunDirectionECI as B, getMoonDirectionECI as I } from "@takram/three-atmosphere";
-import { AtmosphereParameters as V, AtmosphereContext as _, AtmosphereLightNode as G, AtmosphereLight as v, skyBackground as z, skyEnvironment as W } from "@takram/three-atmosphere/webgpu";
-import { Geodetic as H, radians as w, Ellipsoid as j } from "@takram/three-geospatial";
-const q = u(
-  i(1.6605, -0.1246, -0.0182),
-  i(-0.5876, 1.1329, -0.1006),
-  i(-0.0728, -83e-4, 1.1187)
-), X = u(
-  i(0.6274, 0.0691, 0.0164),
-  i(0.3293, 0.9195, 0.088),
-  i(0.0433, 0.0113, 0.8956)
-), J = R((s) => {
+import { RendererUtils as K, StructTypeNode as ui, NodeBuilder as li, TextureNode as ci, Texture3DNode as di, TempNode as se, NodeUpdateType as ee, NodeMaterial as Ce, QuadMesh as We, IndirectStorageBufferAttribute as hi, MeshBasicNodeMaterial as mi, Node as pi, StorageTexture as gi, Storage3DTexture as xi, AnalyticLightNode as yi, PointsNodeMaterial as Ti, RenderTarget as wi, Matrix4 as fi, Vector3 as Xt, NoToneMapping as Yt } from "three/webgpu";
+import { Fn as O, positionView as Cs, nodeImmutable as Si, convertToTexture as Lt, vec2 as b, screenCoordinate as Ae, time as vi, vec3 as g, uniform as w, positionLocal as Ci, positionPrevious as Ni, sub as $e, rtt as Mi, add as k, texture as X, ivec2 as Ne, screenUV as Ns, step as Ri, and as bi, If as I, mix as he, textureSize as zi, PI2 as Ei, PI as qe, cos as ne, sin as ie, OnBeforeObjectUpdate as Ai, luminance as Fi, smoothstep as ut, vec4 as v, uv as Me, min as Ms, abs as Vi, mul as te, fract as Li, distance as Di, instancedArray as es, storage as Pi, uvec2 as st, globalId as G, Return as Oe, atomicAdd as Bi, instanceIndex as Ui, mat3 as He, positionGeometry as It, float as A, logarithmicDepthToViewZ as Rs, viewZToPerspectiveDepth as Ii, cameraFar as bs, cameraNear as zs, sqrt as $, max as Re, cameraProjectionMatrix as Oi, cameraProjectionMatrixInverse as ki, cameraWorldMatrix as $i, struct as Y, reference as _e, viewZToLogarithmicDepth as ji, perspectiveDepthToViewZ as Gi, orthographicDepthToViewZ as Wi, log as qi, uint as fe, textureStore as we, acos as Es, workgroupArray as ts, workgroupBarrier as ss, uvec3 as Hi, texture3D as it, mrt as Xe, Loop as Pe, exp as lt, bool as Ve, clamp as Ot, floor as kt, div as $t, normalWorld as _i, positionWorld as Zi, cameraViewMatrix as Ki, nodeProxy as As, pmremTexture as Qi, fwidth as Fs, equirectUV as Ji, dFdx as is, dFdy as rs, instancedBufferAttribute as mt, screenSize as Xi, pow as Vs, log2 as Yi, cdl as er, context as tr, toneMapping as sr, renderOutput as ir } from "three/tsl";
+import { Matrix4 as Dt, DepthTexture as rr, RenderTarget as jt, RGBAFormat as be, HalfFloatType as Ze, LinearFilter as Z, Vector2 as re, AdditiveBlending as Ls, Mesh as Ds, PlaneGeometry as nr, PerspectiveCamera as ar, SRGBColorSpace as or, CanvasTexture as ur, Vector3 as H, FloatType as lr, NoColorSpace as ct, RenderTarget3D as cr, Matrix3 as dr, DirectionalLight as hr, WebGLCubeRenderTarget as mr, CubeCamera as pr, Sprite as gr, InstancedBufferAttribute as pt, Texture as xr, Data3DTexture as yr } from "three";
+import "three/examples/jsm/csm/CSMShadowNode.js";
+import { hash as Gt } from "three/src/nodes/core/NodeUtils.js";
+import { getECIToECEFRotationMatrix as Tr, getSunDirectionECI as wr, getMoonDirectionECI as fr } from "@takram/three-atmosphere";
+import { Geodetic as Ps, Ellipsoid as Bs, radians as rt, isFloatLinearSupported as Sr, reinterpretType as Wt, QuadGeometry as vr, ArrayBufferLoader as Cr } from "@takram/three-geospatial";
+var Nr = "Invariant failed";
+function D(s, e) {
+  if (!s)
+    throw new Error(Nr);
+}
+let gt;
+function Ke(s, e, t) {
+  gt ??= /* @__PURE__ */ new WeakMap();
+  let i = gt.get(s);
+  return i == null && (i = {}, gt.set(s, i)), i[e] ??= t();
+}
+const Mr = (s) => s != null ? Ke(
+  s,
+  "projectionMatrix",
+  () => _e("projectionMatrix", "mat4", s).setName(
+    "projectionMatrix"
+  )
+) : Oi, Rr = (s) => s != null ? Ke(
+  s,
+  "inverseProjectionMatrix",
+  () => _e("projectionMatrixInverse", "mat4", s).setName(
+    "inverseProjectionMatrix"
+  )
+) : ki, br = (s) => s != null ? Ke(
+  s,
+  "inverseViewMatrix",
+  () => _e("matrixWorld", "mat4", s).setName("inverseViewMatrix")
+) : $i, je = (s) => s != null ? Ke(
+  s,
+  "cameraNear",
+  () => _e("near", "float", s).setName("cameraNear")
+) : zs, Ge = (s) => s != null ? Ke(
+  s,
+  "cameraFar",
+  () => _e("far", "float", s).setName("cameraFar")
+) : bs;
+O(() => Cs.z).once()().toVar("viewZ");
+class zr extends ci {
+  static get type() {
+    return "OutputTextureNode";
+  }
+  constructor(e, t) {
+    super(t), this.owner = e, this.setUpdateMatrix(!1);
+  }
+  setup(e) {
+    return this.owner.build(e), super.setup(e);
+  }
+  clone() {
+    const e = new this.constructor(this.owner, this.value);
+    return e.uvNode = this.uvNode, e.levelNode = this.levelNode, e.biasNode = this.biasNode, e.sampler = this.sampler, e.depthNode = this.depthNode, e.compareNode = this.compareNode, e.gradNode = this.gradNode, e.offsetNode = this.offsetNode, e;
+  }
+}
+const Le = (...s) => new zr(...s);
+let dt = class extends se {
+  constructor(e) {
+    super("vec4"), this.resolutionScale = 1, this.renderTargets = [], this.updateBeforeType = ee.FRAME, this.inputNode = e;
+  }
+  static get type() {
+    return "FilterNode";
+  }
+  createRenderTarget(e) {
+    const t = new jt(1, 1, {
+      depthBuffer: !1,
+      type: Ze,
+      format: be
+    }), i = t.texture;
+    i.minFilter = Z, i.magFilter = Z, i.generateMipmaps = !1;
+    const r = this.constructor.type;
+    return i.name = e != null ? `${r}_${e}` : r, this.renderTargets.push(t), t;
+  }
+  getTextureNode() {
+    return D(
+      this.textureNode != null
+    ), this.textureNode;
+  }
+  get outputTexture() {
+    return this.textureNode?.value ?? null;
+  }
+  set outputTexture(e) {
+    this.textureNode = e != null ? Le(this, e) : void 0;
+  }
+  setup(e) {
+    const { inputNode: t, textureNode: i } = this;
+    return D(
+      t != null
+    ), D(
+      i != null
+    ), i.uvNode = t.uvNode, i;
+  }
+  dispose() {
+    for (const e of this.renderTargets)
+      e.dispose();
+    super.dispose();
+  }
+};
+const { resetRendererState: Er, restoreRendererState: Ar } = K;
+let Fr = class extends dt {
+  constructor(e, t) {
+    super(e), this.downsampleRTs = [], this.upsampleRTs = [], this.downsampleMaterial = new Ce(), this.upsampleMaterial = new Ce(), this.mesh = new We(), this.inputTexelSize = w("vec2"), this.downsampleNode = X();
+    const i = this.constructor.type.replace(/Node$/, "");
+    this.downsampleMaterial.name = `${i}_downsample`, this.upsampleMaterial.name = `${i}_upsample`, this.mesh.name = i;
+    for (let r = 0; r < t; ++r)
+      this.downsampleRTs[r] = this.createRenderTarget(`downsample${r}`), r < t - 1 && (this.upsampleRTs[r] = this.createRenderTarget(`upsample${r}`));
+    this.outputTexture = this.upsampleRTs[0].texture;
+  }
+  setSize(e, t) {
+    const { resolutionScale: i } = this;
+    let r = Math.max(Math.round(e * i), 1), n = Math.max(Math.round(t * i), 1);
+    const { downsampleRTs: a, upsampleRTs: o } = this;
+    for (let u = 0; u < a.length; ++u)
+      r = Math.max(Math.round(r / 2), 1), n = Math.max(Math.round(n / 2), 1), a[u].setSize(r, n), u < o.length && o[u].setSize(r, n);
+    return this;
+  }
+  updateBefore({ renderer: e }) {
+    if (e == null)
+      return;
+    const {
+      downsampleRTs: t,
+      upsampleRTs: i,
+      mesh: r,
+      inputNode: n,
+      inputTexelSize: a,
+      downsampleNode: o
+    } = this;
+    D(n != null);
+    const { width: u, height: l } = n.value;
+    this.setSize(u, l);
+    const c = n.value;
+    this.rendererState = Er(e, this.rendererState), r.material = this.downsampleMaterial;
+    for (const d of t) {
+      const { width: h, height: m } = n.value;
+      a.value.set(1 / h, 1 / m), e.setRenderTarget(d), r.render(e), n.value = d.texture;
+    }
+    r.material = this.upsampleMaterial;
+    for (let d = i.length - 1; d >= 0; --d) {
+      const h = i[d], { width: m, height: p } = n.value;
+      a.value.set(1 / m, 1 / p), o.value = t[d].texture, e.setRenderTarget(h), r.render(e), n.value = h.texture;
+    }
+    Ar(e, this.rendererState), n.value = c;
+  }
+  setup(e) {
+    const { inputNode: t } = this;
+    D(t != null);
+    const { downsampleMaterial: i, upsampleMaterial: r } = this;
+    return i.fragmentNode = this.setupDownsampleNode(e), r.fragmentNode = this.setupUpsampleNode(e), i.needsUpdate = !0, r.needsUpdate = !0, super.setup(e);
+  }
+  dispose() {
+    for (const e of this.downsampleRTs)
+      e.dispose();
+    for (const e of this.upsampleRTs)
+      e.dispose();
+    this.downsampleMaterial.dispose(), this.upsampleMaterial.dispose(), this.mesh.geometry.dispose(), super.dispose();
+  }
+};
+const Vr = (s, e) => {
+  const t = Me(), i = v(1, 1, -1, -1).mul(e.xyxy).add(t.xyxy).toVertexStage(), r = v(2, 2, -2, -2).mul(e.xyxy).add(t.xyxy).toVertexStage(), n = i.zy, a = i.xy, o = i.zw, u = i.xw, l = b(t.x, r.y), c = b(r.z, t.y), d = b(r.x, t.y), h = b(t.x, r.w), m = r.zy, p = r.xy, x = r.zw, y = r.xw;
+  return k(
+    k(
+      s.sample(t),
+      s.sample(n),
+      s.sample(a),
+      s.sample(o),
+      s.sample(u)
+    ).mul(1 / 8),
+    k(
+      s.sample(l),
+      s.sample(c),
+      s.sample(d),
+      s.sample(h)
+    ).mul(1 / 16),
+    k(
+      s.sample(m),
+      s.sample(p),
+      s.sample(x),
+      s.sample(y)
+    ).mul(1 / 32)
+  );
+}, { resetRendererState: Lr, restoreRendererState: Dr } = K;
+class Pr extends dt {
+  constructor(e) {
+    super(e), this.material = new Ce(), this.mesh = new We(this.material), this.inputTexelSize = w("vec2");
+    const t = this.constructor.type.replace(/Node$/, "");
+    this.material.name = t, this.mesh.name = t, this.renderTarget = this.createRenderTarget(), this.outputTexture = this.renderTarget.texture;
+  }
+  setSize(e, t) {
+    const { resolutionScale: i } = this, r = Math.max(Math.round(e * i), 1), n = Math.max(Math.round(t * i), 1);
+    return this.renderTarget.setSize(r, n), this;
+  }
+  updateBefore({ renderer: e }) {
+    if (e == null)
+      return;
+    const { inputNode: t } = this;
+    D(t != null);
+    const { width: i, height: r } = t.value;
+    this.setSize(i, r), this.inputTexelSize.value.set(1 / i, 1 / r), this.rendererState = Lr(e, this.rendererState), e.setRenderTarget(this.renderTarget), this.mesh.render(e), Dr(e, this.rendererState);
+  }
+  setup(e) {
+    const { inputNode: t } = this;
+    D(t != null);
+    const { material: i } = this;
+    return i.fragmentNode = this.setupOutputNode(e), i.needsUpdate = !0, super.setup(e);
+  }
+  dispose() {
+    this.renderTarget.dispose(), this.material.dispose(), this.mesh.geometry.dispose(), super.dispose();
+  }
+}
+let Br = class extends Pr {
+  constructor(e) {
+    super(e), this.thresholdLevel = w(5), this.thresholdRange = w(1), this.resolutionScale = 0.5;
+  }
+  static get type() {
+    return "DownsampleThresholdNode";
+  }
+  setupOutputNode() {
+    const { inputNode: e, thresholdLevel: t, thresholdRange: i, inputTexelSize: r } = this;
+    D(e != null);
+    const n = Vr(e, r), a = Fi(n.rgb), o = ut(
+      t,
+      t.add(i),
+      a
+    );
+    return v(n.rgb, a).mul(o);
+  }
+};
+const xt = (s) => {
+  const e = Ai(s);
+  return e.updateBeforeType = ee.FRAME, e;
+};
+function ns(s) {
+  if (typeof s == "string")
+    return s;
+  if (typeof s == "function" && typeof s.name == "string" && s.name.length > 0)
+    return s.name;
+  if ("layout" in s && s.layout instanceof ui) {
+    if (s.layout.name == null)
+      throw new Error("Struct name is required.");
+    return s.layout.name;
+  }
+  throw new Error(`Unsupported layout type: ${s}`);
+}
+function R({
+  typeOnly: s = !1,
+  ...e
+}) {
+  return s ? (t) => O(t) : (t) => O(t).setLayout({
+    ...e,
+    type: ns(e.type),
+    inputs: e.inputs?.map((i) => ({
+      ...i,
+      type: ns(i.type)
+    })) ?? []
+  });
+}
+function L(s) {
+  return O((e, t) => {
+    const i = s(...e);
+    return typeof i == "function" ? i(t) : i;
+  });
+}
+const { resetRendererState: Ur, restoreRendererState: Ir } = K;
+class Or extends dt {
+  constructor(e) {
+    super(e), this.iterations = 1, this.material = new Ce(), this.mesh = new We(this.material), this.inputTexelSize = w("vec2"), this.direction = w("vec2");
+    const t = this.constructor.type.replace(/Node$/, "");
+    this.material.name = t, this.mesh.name = t, this.horizontalRT = this.createRenderTarget("horizontal"), this.verticalRT = this.createRenderTarget("vertical"), this.outputTexture = this.verticalRT.texture;
+  }
+  setSize(e, t) {
+    const { resolutionScale: i } = this, r = Math.max(Math.round(e * i), 1), n = Math.max(Math.round(t * i), 1);
+    return this.horizontalRT.setSize(r, n), this.verticalRT.setSize(r, n), this;
+  }
+  updateBefore({ renderer: e }) {
+    if (e == null)
+      return;
+    const { horizontalRT: t, verticalRT: i, mesh: r, inputNode: n, direction: a } = this;
+    D(n != null);
+    const { width: o, height: u } = n.value;
+    this.setSize(o, u), this.inputTexelSize.value.set(1 / o, 1 / u);
+    const l = n.value;
+    this.rendererState = Ur(e, this.rendererState);
+    for (let c = 0; c < this.iterations; ++c)
+      a.value.set(1, 0), e.setRenderTarget(t), r.render(e), n.value = t.texture, a.value.set(0, 1), e.setRenderTarget(i), r.render(e), n.value = i.texture;
+    Ir(e, this.rendererState), n.value = l;
+  }
+  setup(e) {
+    const { inputNode: t } = this;
+    D(t != null);
+    const { material: i } = this;
+    return i.fragmentNode = this.setupOutputNode(e), i.needsUpdate = !0, super.setup(e);
+  }
+  dispose() {
+    this.horizontalRT.dispose(), this.verticalRT.dispose(), this.material.dispose(), this.mesh.geometry.dispose(), super.dispose();
+  }
+}
+function as(s) {
+  if (D(s >= 0), s === 0)
+    return new Float64Array(0);
+  if (s === 1)
+    return new Float64Array([1]);
+  let e = new Float64Array(s), t = new Float64Array(s), i = t;
+  for (let r = 1; r <= s; ++r) {
+    for (let n = 0; n < r; ++n)
+      t[n] = n === 0 || n === r - 1 ? 1 : e[n - 1] + e[n];
+    i = t, t = e, e = i;
+  }
+  return i;
+}
+function kr(s, e = 2) {
+  D(s >= 3);
+  const t = s + e * 2, i = e > 0 ? as(t).slice(e, -e) : as(t), r = Math.floor((i.length - 1) / 2), n = i.reduce((d, h) => d + h, 0), a = i.slice(r), o = [...Array(r + 1).keys()], u = new Float64Array(Math.floor(o.length / 2)), l = new Float64Array(u.length);
+  u[0] = a[0] / n;
+  for (let d = 1, h = 1; d < o.length - 1; d += 2, ++h) {
+    const m = o[d], p = o[d + 1], x = a[d], y = a[d + 1], T = x + y, S = (m * x + p * y) / T;
+    u[h] = T / n, l[h] = S;
+  }
+  const c = (u.reduce((d, h) => d + h, 0) - u[0] * 0.5) * 2;
+  if (c !== 0) {
+    const d = 1 / c;
+    for (let h = 0; h < u.length; ++h)
+      u[h] *= d;
+  }
+  return {
+    offsets: l,
+    weights: u
+  };
+}
+class $r extends Or {
+  static get type() {
+    return "GaussianBlurNode";
+  }
+  constructor(e, t = 35) {
+    super(e), this.kernelSize = t;
+  }
+  setupOutputNode(e) {
+    const { inputNode: t, inputTexelSize: i, direction: r } = this;
+    D(t != null);
+    const { offsets: n, weights: a } = kr(this.kernelSize);
+    return O(() => {
+      const o = Me(), u = r.mul(i).toVertexStage(), l = t.sample(o).mul(a[0]);
+      for (let c = 1; c < n.length; ++c) {
+        const d = u.mul(n[c]);
+        l.addAssign(
+          k(
+            t.sample(o.add(d)),
+            t.sample(o.sub(d))
+          ).mul(a[c])
+        );
+      }
+      return l;
+    })();
+  }
+}
+const jr = (s) => s.dot(b(0.06711056, 583715e-8)).fract().mul(52.9829189).fract(), Gr = /* @__PURE__ */ O(() => {
+  const s = b(Ae.xy).add(vi.fract().mul(1337)), e = jr(s);
+  return g(e, e.oneMinus(), e).sub(0.5).div(255);
+}).once()();
+class Wr extends se {
+  constructor() {
+    super("vec3"), this.currentProjectionMatrix = w("mat4"), this.previousProjectionMatrix = w("mat4"), this.currentModelViewMatrix = w("mat4"), this.previousModelViewMatrix = w("mat4"), this.objectModelViewMatrices = /* @__PURE__ */ new WeakMap(), this.updateType = ee.FRAME, this.updateBeforeType = ee.OBJECT, this.updateAfterType = ee.OBJECT;
+  }
+  static get type() {
+    return "HighpVelocityNode";
+  }
+  setProjectionMatrix(e) {
+    return this.projectionMatrix = e, this;
+  }
+  // Executed once per frame:
+  update({ camera: e }) {
+    if (e == null)
+      return;
+    const {
+      currentProjectionMatrix: t,
+      previousProjectionMatrix: i
+    } = this, r = this.projectionMatrix ?? e.projectionMatrix;
+    i.value == null ? i.value = new Dt().copy(r) : i.value.copy(t.value), t.value.copy(r);
+  }
+  // Executed once per object before rendering:
+  updateBefore({ object: e, camera: t }) {
+    if (e == null || t == null)
+      return;
+    const {
+      currentModelViewMatrix: i,
+      previousModelViewMatrix: r,
+      objectModelViewMatrices: n
+    } = this;
+    i.value.multiplyMatrices(
+      t.matrixWorldInverse,
+      e.matrixWorld
+    ), r.value = n.get(e) ?? i.value;
+  }
+  // Executed once per object after rendering:
+  updateAfter({ object: e }) {
+    if (e == null)
+      return;
+    const {
+      currentModelViewMatrix: t,
+      objectModelViewMatrices: i
+    } = this;
+    let r = i.get(e);
+    r == null && (r = new Dt(), i.set(e, r)), r.copy(t.value);
+  }
+  setup(e) {
+    const t = this.currentProjectionMatrix.mul(this.currentModelViewMatrix).mul(Ci).toVertexStage(), i = this.previousProjectionMatrix.mul(this.previousModelViewMatrix).mul(Ni).toVertexStage(), r = t.xyz.div(t.w), n = i.xyz.div(i.w);
+    return $e(r, n);
+  }
+}
+const Pt = /* @__PURE__ */ Si(Wr);
+class qr extends se {
+  constructor(e) {
+    super("vec3"), this.intensity = w(1e-5), this.inputNode = e;
+  }
+  static get type() {
+    return "LensGhostNode";
+  }
+  setup(e) {
+    const { inputNode: t, intensity: i } = this;
+    D(t != null);
+    const r = R({
+      name: "sampleGhost",
+      type: "vec3",
+      inputs: [
+        { name: "uv", type: "vec2" },
+        { name: "direction", type: "vec2" },
+        { name: "color", type: "vec3" },
+        { name: "offset", type: "float" }
+      ]
+    })(([o, u, l, c]) => {
+      const d = u.mul(c).add(o.oneMinus()).saturate(), h = t.sample(d).rgb.mul(l), m = $e(0.5, d).length().mul(1 / (Math.SQRT2 / 4)).saturate();
+      return h.mulAssign(m.oneMinus().pow(3)), h;
+    }), n = Me(), a = n.sub(0.5);
+    return k(
+      r(n, a, g(0.8, 0.8, 1), -5),
+      r(n, a, g(1, 0.8, 0.4), -1.5),
+      r(n, a, g(0.9, 1, 0.8), -0.4),
+      r(n, a, g(1, 0.8, 0.4), -0.2),
+      r(n, a, g(0.9, 0.7, 0.7), -0.1),
+      r(n, a, g(0.5, 1, 0.4), 0.7),
+      r(n, a, g(0.5, 0.5, 0.5), 1),
+      r(n, a, g(1, 1, 0.6), 2.5),
+      r(n, a, g(0.5, 0.8, 1), 10)
+    ).mul(i);
+  }
+}
+const { resetRendererState: Hr, restoreRendererState: _r } = K;
+function Zr() {
+  const s = document.createElement("canvas");
+  s.width = 256, s.height = 32;
+  const e = s.getContext("2d");
+  D(e != null), e.beginPath(), e.moveTo(0, 32 / 2), e.lineTo(256 / 2, 5), e.lineTo(256, 32 / 2), e.lineTo(256 / 2, 27), e.closePath();
+  const t = e.createLinearGradient(0, 0, 256, 0);
+  return t.addColorStop(0, "#000000"), t.addColorStop(0.5, "#ffffff"), t.addColorStop(1, "#000000"), e.fillStyle = t, e.fill(), new ur(s);
+}
+const os = /* @__PURE__ */ Y({
+  color: "vec3",
+  luminance: "float",
+  position: "vec2",
+  scale: "float",
+  sin: "float",
+  cos: "float"
+});
+class Kr extends dt {
+  constructor(e) {
+    super(e), this.spikePairCount = 6, this.wireframe = !1, this.intensity = w(1e-5), this.sizeScale = w(new re(1.5, 0.01)), this.luminanceThreshold = w(100), this.indirectBuffer = new hi(
+      new Uint32Array([6, 0, 0, 0, 0]),
+      1
+    ), this.instanceBuffer = es(1, os), this.renderTarget = this.createRenderTarget(), this.material = new mi({
+      depthTest: !1,
+      depthWrite: !1,
+      transparent: !0,
+      blending: Ls
+    }), this.mesh = new Ds(new nr(1, 1), this.material), this.camera = new ar(), this.inputTexelSize = w("vec2"), this.outputTexelSize = w("vec2"), this.geometryRatio = w("vec2"), this.material.name = "LensGlare", this.inputNode = e, this.resolutionScale = 0.5, this.outputTexture = this.renderTarget.texture, this.mesh.geometry.indirect = this.indirectBuffer;
+  }
+  customCacheKey() {
+    return Gt(this.spikePairCount, +this.wireframe);
+  }
+  setSize(e, t) {
+    const { resolutionScale: i } = this, r = Math.max(Math.round(e * i), 1), n = Math.max(Math.round(t * i), 1);
+    this.renderTarget.setSize(r, n);
+    const a = Math.floor(r / 2), o = Math.floor(n / 2), u = a * o;
+    return this.instanceBuffer.bufferCount < u && (this.instanceBuffer.dispose(), this.instanceBuffer = es(u, os), this.setupCompute(a, o), this.setupMaterial()), this;
+  }
+  updateBefore({ renderer: e }) {
+    if (e == null)
+      return;
+    const { inputNode: t } = this;
+    D(t != null);
+    const { width: i, height: r } = t.value;
+    this.setSize(i, r);
+    const { computeNode: n, indirectBuffer: a, renderTarget: o } = this;
+    D(n != null), this.inputTexelSize.value.set(1 / i, 1 / r);
+    const u = i / r;
+    u > 1 ? this.geometryRatio.value.set(1 / u, 1) : this.geometryRatio.value.set(1, u);
+    const { width: l, height: c } = o;
+    this.outputTexelSize.value.set(1 / l, 1 / c), a.array[1] = 0, a.needsUpdate = !0, e.compute(n), this.rendererState = Hr(e, this.rendererState), e.setRenderTarget(o), e.render(this.mesh, this.camera), _r(e, this.rendererState);
+  }
+  setupCompute(e, t) {
+    const {
+      spikePairCount: i,
+      inputNode: r,
+      indirectBuffer: n,
+      instanceBuffer: a,
+      outputTexelSize: o
+    } = this;
+    D(r != null);
+    const u = Pi(
+      n,
+      "uint",
+      n.count
+    ).toAtomic();
+    this.computeNode = O(() => {
+      const l = st(e, t);
+      I(G.xy.greaterThanEqual(l).any(), () => {
+        Oe();
+      });
+      const c = b(G.xy).mul(o).mul(2), d = r.sample(c), h = d.a;
+      I(h.greaterThan(0.1), () => {
+        const m = Bi(
+          u.element(1),
+          i
+        );
+        for (let p = 0; p < i; ++p) {
+          const x = a.element(m.add(p));
+          x.get("color").assign(d.rgb), x.get("luminance").assign(h), x.get("position").assign(G.xy), x.get("scale").assign(p % 2 === 0 ? 1 : 0.5);
+          const y = Math.PI * (3 - Math.sqrt(5)), T = Math.PI / i * p + y;
+          x.get("sin").assign(Math.sin(T)), x.get("cos").assign(Math.cos(T));
+        }
+      });
+    })().compute(
+      // @ts-expect-error "count" can be dimensional
+      [Math.ceil(e / 8), Math.ceil(t / 8), 1],
+      [8, 8, 1]
+    );
+  }
+  setupMaterial() {
+    const {
+      inputNode: e,
+      spikeNode: t,
+      instanceBuffer: i,
+      luminanceThreshold: r,
+      intensity: n,
+      sizeScale: a,
+      outputTexelSize: o,
+      geometryRatio: u
+    } = this;
+    D(e != null), D(t != null);
+    const l = i.element(Ui);
+    this.material.colorNode = this.wireframe ? v(1) : t.mul(l.get("color").mul(n)), this.material.vertexNode = O(() => {
+      const c = l.get("sin"), d = l.get("cos"), h = He(d, c, 0, c.negate(), d, 0, 0, 0, 1), m = l.get("position").mul(o).mul(2), p = m.flipY().mul(2).sub(1), x = l.get("luminance").div(r).saturate(), y = b(x, 1).mul(
+        l.get("scale"),
+        a,
+        // Make the spike to shrink at screen borders:
+        m.sub(0.5).length().mul(2).oneMinus().mul(0.5).add(0.5)
+      ), T = h.mul(It.mul(v(y, 1, 1))).mul(u).add(g(p, 0));
+      return v(T, 1);
+    })(), this.material.wireframe = this.wireframe, this.material.needsUpdate = !0;
+  }
+  setup(e) {
+    if (this.spikeNode == null) {
+      const t = Zr();
+      t.colorSpace = or, this.spikeNode = X(t);
+    }
+    return this.setupMaterial(), super.setup(e);
+  }
+  dispose() {
+    this.renderTarget.dispose(), this.material.dispose(), this.mesh.geometry.dispose(), super.dispose();
+  }
+}
+const Qr = /* @__PURE__ */ new re();
+class Jr extends se {
+  constructor(e) {
+    super("vec3"), this.intensity = w(1e-5), this.chromaticAberration = w(5e-3), this.aspectRatio = w(0), this.updateBeforeType = ee.FRAME, this.inputNode = e;
+  }
+  static get type() {
+    return "LensHaloNode";
+  }
+  updateBefore({ renderer: e }) {
+    if (e == null)
+      return;
+    const { width: t, height: i } = e.getDrawingBufferSize(Qr);
+    this.aspectRatio.value = t / i;
+  }
+  setup(e) {
+    const { inputNode: t, intensity: i, chromaticAberration: r, aspectRatio: n } = this;
+    D(t != null);
+    const a = R({
+      name: "cubicRingMask",
+      type: "float",
+      inputs: [
+        { name: "x", type: "float" },
+        { name: "radius", type: "float" },
+        { name: "thickness", type: "float" }
+      ]
+    })(([l, c, d]) => {
+      const h = Ms(Vi(l.sub(c)).div(d), 1);
+      return te(h, h, $e(3, h.mul(2))).oneMinus();
+    }), o = R({
+      name: "sampleHalo",
+      type: "vec3",
+      inputs: [
+        { name: "uv", type: "vec2" },
+        { name: "radius", type: "float" }
+      ]
+    })(([l, c]) => {
+      const d = b(n, 1), h = l.sub(0.5).mul(d).normalize().div(d), m = g(r).mul(g(-1, 0, 1)), p = Li(h.mul(c).add(l.oneMinus())), x = g(
+        t.sample(h.mul(m.r).add(p)).r,
+        t.sample(h.mul(m.g).add(p)).g,
+        t.sample(h.mul(m.b).add(p)).b
+      ), y = l.sub(b(0.5, 0)).mul(d).add(b(0.5, 0)), T = Di(y, b(0.5)).saturate();
+      return x.mulAssign(a(T, 0.45, 0.25)), x;
+    }), u = Me();
+    return o(u, 0.3).mul(i);
+  }
+}
+const J = (s) => s.greaterThanEqual(0).all().and(s.lessThanEqual(1).all()).toFloat();
+let Xr = class extends Fr {
+  constructor(e, t = 4) {
+    super(e, t), this.blendAmount = w(0.85), this.resolutionScale = 0.5;
+  }
+  static get type() {
+    return "MipmapSurfaceBlurNode";
+  }
+  setupDownsampleNode(e) {
+    const { inputNode: t, inputTexelSize: i } = this;
+    return D(t != null), O(() => {
+      const r = Me(), n = v(1, 1, -1, -1).mul(i.xyxy).add(r.xyxy).toVertexStage(), a = v(2, 2, -2, -2).mul(i.xyxy).add(r.xyxy).toVertexStage(), o = n.zy, u = n.xy, l = n.zw, c = n.xw, d = a.zy, h = a.xy, m = a.zw, p = a.xw, x = b(r.x, a.y), y = b(a.z, r.y), T = b(a.x, r.y), S = b(r.x, a.w), M = 1 / 4 / 2, C = 1 / 9 / 2, N = t.sample(r).mul(C);
+      let f;
+      return f = v(
+        J(o),
+        J(u),
+        J(l),
+        J(c)
+      ).mul(M), N.addAssign(
+        t.sample(o).mul(f.x),
+        t.sample(u).mul(f.y),
+        t.sample(l).mul(f.z),
+        t.sample(c).mul(f.w)
+      ), f = v(
+        J(d),
+        J(h),
+        J(m),
+        J(p)
+      ).mul(C), N.addAssign(
+        t.sample(d).mul(f.x),
+        t.sample(h).mul(f.y),
+        t.sample(m).mul(f.z),
+        t.sample(p).mul(f.w)
+      ), f = v(
+        J(x),
+        J(y),
+        J(T),
+        J(S)
+      ).mul(C), N.addAssign(
+        t.sample(x).mul(f.x),
+        t.sample(y).mul(f.y),
+        t.sample(T).mul(f.z),
+        t.sample(S).mul(f.w)
+      ), N;
+    })();
+  }
+  setupUpsampleNode(e) {
+    const { inputNode: t, inputTexelSize: i, downsampleNode: r } = this;
+    D(t != null);
+    const n = Me(), a = v(1, 1, -1, -1).mul(i.xyxy).add(n.xyxy).toVertexStage(), o = b(n.x, a.y), u = b(a.z, n.y), l = b(a.x, n.y), c = b(n.x, a.w), d = a.zy, h = a.xy, m = a.zw, p = a.xw, x = k(
+      t.sample(n).mul(1 / 4),
+      k(
+        t.sample(o),
+        t.sample(u),
+        t.sample(l),
+        t.sample(c)
+      ).mul(1 / 8),
+      k(
+        t.sample(d),
+        t.sample(h),
+        t.sample(m),
+        t.sample(p)
+      ).mul(1 / 16)
+    );
+    return he(r.sample(n), x, this.blendAmount);
+  }
+};
+function qt(s) {
+  return (s instanceof li ? s.renderer.backend : "backend" in s ? s.backend : s).isWebGPUBackend === !0;
+}
+class Yr extends se {
+  constructor(e) {
+    super("vec4"), this.bloomIntensity = w(0.05), this.inputNode = e, this.thresholdNode = new Br(), this.blurNode = new $r(), this.ghostNode = new qr(), this.haloNode = new Jr(), this.bloomNode = new Xr(null, 8), this.glareNode = new Kr(), this.featuresNode = Mi(k(this.ghostNode, this.haloNode)), this.featuresNode.value.name = "LensFlare_features", this.featuresNode.pixelRatio = 0.5, this.blurNode.resolutionScale = 1, this.bloomNode.resolutionScale = 1, this.glareNode.resolutionScale = 1;
+  }
+  static get type() {
+    return "LensFlareNode";
+  }
+  setup(e) {
+    const {
+      inputNode: t,
+      thresholdNode: i,
+      blurNode: r,
+      ghostNode: n,
+      haloNode: a,
+      bloomNode: o,
+      featuresNode: u,
+      glareNode: l
+    } = this;
+    D(t != null);
+    const c = i.getTextureNode(), d = r.getTextureNode();
+    i.inputNode = t, r.inputNode = c, n.inputNode = d, a.inputNode = d, o.inputNode = c, l.inputNode = c;
+    const h = o.getTextureNode().mul(this.bloomIntensity), m = l.getTextureNode();
+    return O(() => {
+      const p = t;
+      return p.addAssign(h), qt(e) && p.addAssign(m), p.add(u);
+    })();
+  }
+  dispose() {
+    this.thresholdNode.dispose(), this.blurNode.dispose(), this.ghostNode.dispose(), this.haloNode.dispose(), this.bloomNode.dispose(), this.glareNode.dispose(), this.featuresNode.dispose(), super.dispose();
+  }
+}
+const en = (s) => new Yr(s != null ? Lt(s) : null);
+let tn = class extends di {
+  static get type() {
+    return "OutputTexture3DNode";
+  }
+  constructor(e, t) {
+    super(t), this.owner = e, this.setUpdateMatrix(!1);
+  }
+  setup(e) {
+    return this.owner.build(e), super.setup(e);
+  }
+  clone() {
+    const e = new this.constructor(this.owner, this.value);
+    return e.uvNode = this.uvNode, e.levelNode = this.levelNode, e.biasNode = this.biasNode, e.sampler = this.sampler, e.depthNode = this.depthNode, e.compareNode = this.compareNode, e.gradNode = this.gradNode, e.offsetNode = this.offsetNode, e;
+  }
+};
+const yt = (...s) => new tn(...s), sn = /* @__PURE__ */ L(
+  (s, e, t, i) => (r) => {
+    t ??= je(e), i ??= Ge(e);
+    const n = e?.isPerspectiveCamera === !0;
+    return r.renderer.logarithmicDepthBuffer ? Rs(s, t, i) : n ? Gi(s, t, i) : Wi(s, t, i);
+  }
+), us = (s, e, t) => {
+  e ??= zs, t ??= bs;
+  const i = Rs(s, e, t);
+  return Ii(i, e, t);
+}, Tt = [
+  [58.1375, 2.7747, 26.8183],
+  [-150.5666, 4.2109, -88.5066],
+  [130.5887, -14.0195, 109.0745],
+  [-42.3277, 4.8052, -60.1097],
+  [4.5974, 2.1856, 12.5925],
+  [0.1357, 0.0914, 0.1067]
+], rn = /* @__PURE__ */ R({
+  name: "turbo",
+  type: "vec3",
+  inputs: [{ name: "x", type: "float" }]
+})(([s]) => {
+  const e = g(...Tt[0]).toVar();
+  for (let t = 1; t < Tt.length; ++t)
+    e.assign(g(...Tt[t]).add(s.mul(e)));
+  return e;
+});
+L(
+  (s, e, t, i) => {
+    t ??= je(e), i ??= Ge(e);
+    const r = sn(s, e, t, i);
+    return rn(ji(r, t, i));
+  }
+);
+const nn = /* @__PURE__ */ R({
+  name: "equirectToDirectionWorld",
+  type: "vec3",
+  inputs: [{ name: "uv", type: "vec2" }]
+})(([s]) => {
+  const e = $e(0.5, s.x).mul(Ei), t = $e(s.y, 0.5).mul(qe), i = ne(t);
+  return g(i.mul(ne(e)), ie(t), i.mul(ie(e)));
+});
+function ls(s, e) {
+  let t = 1, i = 0;
+  for (; s > 0; )
+    t /= e, i += t * (s % e), s = Math.floor(s / e);
+  return i;
+}
+const cs = /* @__PURE__ */ Array.from(
+  { length: 16 },
+  (s, e) => new re(ls(e + 1, 2), ls(e + 1, 3))
+), { resetRendererState: an, restoreRendererState: on } = K;
+function un(s) {
+  return s.isPerspectiveCamera === !0 || s.isOrthographicCamera === !0 || "updateProjectionMatrix" in s && "setViewOffset" in s && "clearViewOffset" in s;
+}
+const ln = /* @__PURE__ */ R({
+  name: "clipAABB",
+  type: "vec4",
+  inputs: [
+    { name: "current", type: "vec4" },
+    { name: "history", type: "vec4" },
+    { name: "minColor", type: "vec4" },
+    { name: "maxColor", type: "vec4" }
+  ]
+})(([s, e, t, i]) => {
+  const r = i.rgb.add(t.rgb).mul(0.5).toConst(), n = i.rgb.sub(t.rgb).mul(0.5).add(1e-7), a = e.sub(v(r, s.a)).toConst(), o = a.xyz.div(n).abs().toConst(), u = Re(o.x, o.y, o.z).toConst();
+  return u.greaterThan(1).select(v(r, s.a).add(a.div(u)), e);
+}), ds = [
+  [-1, -1],
+  [-1, 1],
+  [1, -1],
+  [1, 1],
+  [1, 0],
+  [0, -1],
+  [0, 1],
+  [-1, 0]
+], cn = /* @__PURE__ */ L(
+  (s, e, t, i, r) => {
+    const n = t.toVar(), a = t.pow2().toVar();
+    for (const [h, m] of ds) {
+      const p = s.load(e.add(Ne(h, m))).toConst();
+      n.addAssign(p), a.addAssign(p.pow2());
+    }
+    const o = ds.length + 1, u = n.div(o).toConst(), l = $(a.div(o).sub(u.pow2()).max(0)).mul(r).toConst(), c = u.sub(l).toConst(), d = u.add(l).toConst();
+    return ln(u.clamp(c, d), i, c, d);
+  }
+), dn = [
+  [-1, -1],
+  [-1, 0],
+  [-1, 1],
+  [0, -1],
+  [0, 0],
+  [0, 1],
+  [1, -1],
+  [1, 0],
+  [1, 1]
+], hn = /* @__PURE__ */ Y({
+  closestCoord: "ivec2",
+  closestDepth: "float"
+}), mn = /* @__PURE__ */ L(
+  (s, e) => (t) => {
+    const i = Ne(0).toVar(), r = A(1).toVar();
+    for (const [n, a] of dn) {
+      const o = e.add(Ne(n, a)).toConst();
+      let u = s.load(o).r;
+      t.renderer.reversedDepthBuffer && (u = u.oneMinus()), u = u.toConst(), I(u.lessThan(r), () => {
+        i.assign(o), r.assign(u);
+      });
+    }
+    return hn(i, r);
+  }
+), pn = /* @__PURE__ */ L(
+  (s, e) => {
+    const t = s.mul(e).fract().abs(), i = Re(t, t.oneMinus());
+    return i.x.mul(i.y).oneMinus().div(0.75);
+  }
+), hs = /* @__PURE__ */ new re(), gn = /* @__PURE__ */ new rr(1, 1);
+class ms extends se {
+  constructor(e, t, i, r) {
+    if (super("vec4"), this.temporalAlpha = w(0.05), this.varianceGamma = w(1), this.velocityThreshold = w(0.1), this.depthError = w(1e-3), this.debugShowRejection = !1, this.resolveRT = this.createRenderTarget("resolve"), this.historyRT = this.createRenderTarget("history"), this.resolveMaterial = new Ce(), this.mesh = new We(), this.needsSyncRenderPipeline = !1, this.needsClearHistory = !1, this.resolveNode = X(this.resolveRT.texture), this.historyNode = X(this.historyRT.texture), this.previousDepthNode = X(gn), this.originalProjectionMatrix = new Dt(), this.jitterIndex = 0, this.updateBeforeType = ee.FRAME, this.resolveMaterial.name = "TemporalAntialias_resolve", this.mesh.name = "TemporalAntialias", this.inputNode = e, this.depthNode = t, this.velocityNode = i, !un(r))
+      throw new Error("The provided camera is not supported.");
+    this.camera = r, this.textureNode = Le(this, this.resolveRT.texture);
+  }
+  static get type() {
+    return "TemporalAntialiasNode";
+  }
+  customCacheKey() {
+    return Gt(this.camera.id, +this.debugShowRejection);
+  }
+  createRenderTarget(e) {
+    const t = new jt(1, 1, {
+      depthBuffer: !1,
+      type: Ze,
+      format: be
+    }), i = t.texture;
+    i.minFilter = Z, i.magFilter = Z, i.generateMipmaps = !1;
+    const r = this.constructor.type;
+    return i.name = e != null ? `${r}_${e}` : r, t;
+  }
+  getTextureNode() {
+    return this.textureNode;
+  }
+  setSize(e, t) {
+    const { resolveRT: i, historyRT: r } = this;
+    return (e !== r.width || t !== r.height) && (i.setSize(e, t), r.setSize(e, t), this.needsClearHistory = !0), this;
+  }
+  clearHistory(e) {
+    e.setRenderTarget(this.resolveRT), e.clear(), e.setRenderTarget(this.historyRT), e.clear(), this.needsClearHistory = !1;
+  }
+  setViewOffset(e, t) {
+    const { camera: i } = this;
+    i.updateProjectionMatrix(), this.originalProjectionMatrix.copy(i.projectionMatrix), Pt.setProjectionMatrix(this.originalProjectionMatrix);
+    const r = cs[this.jitterIndex], n = r.x - 0.5, a = r.y - 0.5;
+    i.setViewOffset(e, t, n, a, e, t);
+  }
+  clearViewOffset() {
+    this.camera.clearViewOffset(), Pt.setProjectionMatrix(null), this.jitterIndex = (this.jitterIndex + 1) % cs.length;
+  }
+  copyDepthTexture(e) {
+    const t = this.depthNode.value, i = this.previousDepthTexture ??= t.clone();
+    (i.image.width !== t.width || i.image.height !== t.height) && (i.image.width = t.width, i.image.height = t.height, i.needsUpdate = !0), e.copyTextureToTexture(t, i), this.previousDepthNode.value = i;
+  }
+  swapBuffers() {
+    const { resolveRT: e, historyRT: t } = this;
+    this.resolveRT = t, this.historyRT = e, this.resolveNode.value = t.texture, this.historyNode.value = e.texture, this.textureNode.value = e.texture;
+  }
+  updateBefore({ renderer: e }) {
+    if (e == null)
+      return;
+    const t = e.getDrawingBufferSize(hs);
+    this.setSize(t.x, t.y), this.rendererState = an(e, this.rendererState), this.needsClearHistory && this.clearHistory(e), e.setRenderTarget(this.resolveRT), this.mesh.material = this.resolveMaterial, this.mesh.render(e), on(e, this.rendererState), qt(e) && this.copyDepthTexture(e), this.swapBuffers(), this.needsSyncRenderPipeline && this.clearViewOffset();
+  }
+  setupResolveNode({ renderer: e }) {
+    const t = (i) => {
+      const { previousDepthNode: r } = this, n = r.load(Ne(i.mul(r.size()).sub(0.5))).toConst();
+      return e.logarithmicDepthBuffer ? us(
+        n,
+        je(this.camera),
+        Ge(this.camera)
+      ) : e.reversedDepthBuffer ? n.oneMinus() : n;
+    };
+    return O(() => {
+      const i = Ne(Ae), r = Ns, n = mn(this.depthNode, i).toConst(), a = n.get("closestCoord"), o = n.get("closestDepth"), u = this.velocityNode.load(a).xyz.mul(g(0.5, -0.5, 0.5)).toConst(), l = u.xy.length().div(this.velocityThreshold).oneMinus().saturate(), c = r.sub(u.xy).toConst(), d = t(c), h = e.logarithmicDepthBuffer ? us(
+        o,
+        je(this.camera),
+        Ge(this.camera)
+      ) : o, m = Ri(
+        h.add(u.z),
+        d.add(this.depthError)
+      ), p = l.mul(m), x = bi(
+        c.greaterThanEqual(0).all(),
+        c.lessThanEqual(1).all()
+      ).toFloat(), y = o.notEqual(1).toFloat(), T = this.inputNode.load(i).toVar();
+      return I(x.mul(y).mul(p).greaterThan(0), () => {
+        const S = X(this.historyNode, c), M = cn(
+          this.inputNode,
+          i,
+          T,
+          S,
+          this.varianceGamma
+        ), C = he(
+          this.temporalAlpha,
+          0.4,
+          pn(u.xy, zi(this.inputNode))
+        ).saturate();
+        T.assign(he(M, T, C));
+      }).Else(() => {
+        this.debugShowRejection && T.assign(g(1, 0, 0));
+      }), T;
+    })();
+  }
+  setup(e) {
+    const t = () => {
+      const r = e.renderer.getDrawingBufferSize(hs);
+      this.setViewOffset(r.width, r.height);
+    };
+    if (e.context.renderPipeline != null) {
+      const { context: r } = e.context.renderPipeline;
+      r.onBeforeRenderPipeline = t, this.needsSyncRenderPipeline = !0;
+    }
+    if (e.context.postProcessing != null) {
+      const { context: r } = e.context.postProcessing;
+      r.onBeforePostProcessing = t, this.needsSyncRenderPipeline = !0;
+    }
+    const { resolveMaterial: i } = this;
+    return i.fragmentNode = this.setupResolveNode(e), i.needsUpdate = !0, this.textureNode.uvNode = this.inputNode.uvNode, this.textureNode;
+  }
+  dispose() {
+    this.resolveRT.dispose(), this.historyRT.dispose(), this.previousDepthTexture?.dispose(), this.resolveMaterial.dispose(), this.mesh.geometry.dispose(), super.dispose();
+  }
+}
+function xn(...s) {
+  if (s.length === 1)
+    return (n, a, o, u) => new ms(
+      Lt(n),
+      a,
+      o,
+      u
+    );
+  const [e, t, i, r] = s;
+  return new ms(
+    Lt(e),
+    t,
+    i,
+    r
+  );
+}
+const yn = "eac103980f20c0956f2d3215833e73514be08462", Tn = `https://media.githubusercontent.com/media/takram-design-engineering/three-geospatial/${yn}/packages/atmosphere/assets/stars.bin`, wn = /* @__PURE__ */ new H();
+function fn(s, e, t, i) {
+  const r = t.projectOnSurface(
+    s,
+    wn
+  );
+  return r != null ? t.getOsculatingSphereCenter(r, e, i).negate() : i.setScalar(0);
+}
+var Sn = "Invariant failed";
+function de(s, e) {
+  if (!s)
+    throw new Error(Sn);
+}
+const ps = typeof window < "u" && window.requestIdleCallback != null ? window.requestIdleCallback : function(s, e = {}) {
+  const t = e.timeout ?? 1, i = performance.now();
+  return setTimeout(() => {
+    s({
+      get didTimeout() {
+        return e.timeout != null ? !1 : performance.now() - i - 1 > t;
+      },
+      timeRemaining() {
+        return Math.max(0, 1 + (performance.now() - i));
+      }
+    });
+  }, 1);
+}, U = "float", vn = "float", E = "float", gs = "float", Cn = "float", Us = "float", Nn = "vec3", Se = "vec3", Be = "vec3", Is = "vec3", ge = "vec3", Os = "vec3", nt = /* @__PURE__ */ Y(
+  {
+    width: U,
+    expTerm: E,
+    expScale: gs,
+    linearTerm: gs,
+    constantTerm: E
+  },
+  "DensityProfileLayer"
+), De = /* @__PURE__ */ Y(
+  {
+    layer0: nt.name,
+    layer1: nt.name
+  },
+  "DensityProfile"
+), Bt = {
+  worldToUnit: E,
+  solarIrradiance: Be,
+  sunAngularRadius: vn,
+  bottomRadius: U,
+  topRadius: U,
+  rayleighDensity: De.name,
+  rayleighScattering: ge,
+  mieDensity: De.name,
+  mieScattering: ge,
+  mieExtinction: ge,
+  miePhaseFunctionG: E,
+  absorptionDensity: De.name,
+  absorptionExtinction: ge,
+  groundAlbedo: Se,
+  minCosLight: E,
+  sunRadianceToLuminance: Se,
+  skyRadianceToLuminance: Se,
+  luminanceScale: E,
+  transmittanceTextureSize: "uvec2",
+  irradianceTextureSize: "uvec2",
+  multipleScatteringTextureSize: "uvec2",
+  scatteringTextureRadiusSize: "uint",
+  scatteringTextureCosViewSize: "uint",
+  scatteringTextureCosLightSize: "uint",
+  scatteringTextureCosViewLightSize: "uint"
+}, q = /* @__PURE__ */ Y(
+  Bt,
+  "AtmosphereParameters"
+);
+function xs(s, e) {
+  const { width: t, expTerm: i, expScale: r, linearTerm: n, constantTerm: a } = s;
+  return nt({
+    // @ts-expect-error Object-style parameter is supported
+    width: A(t * e),
+    expTerm: A(i),
+    expScale: A(r / e),
+    linearTerm: A(n / e),
+    constantTerm: A(a)
+  });
+}
+function wt(s, e) {
+  return De({
+    // @ts-expect-error Object-style parameter is supported
+    layer0: xs(s.layers[0], e),
+    layer1: xs(s.layers[1], e)
+  });
+}
+const ys = /* @__PURE__ */ Symbol("DESTRUCTIBLE");
+function j(s) {
+  if (Wt(s), s[ys] === !0)
+    return s;
+  for (const e in Bt)
+    Object.hasOwn(Bt, e) && (s[e] = s.get(e));
+  return s[ys] = !0, s;
+}
+class Ht {
+  constructor(e) {
+    this.parameters = e;
+    const {
+      worldToUnit: t,
+      solarIrradiance: i,
+      sunAngularRadius: r,
+      bottomRadius: n,
+      topRadius: a,
+      rayleighDensity: o,
+      rayleighScattering: u,
+      mieDensity: l,
+      mieScattering: c,
+      mieExtinction: d,
+      miePhaseFunctionG: h,
+      absorptionDensity: m,
+      absorptionExtinction: p,
+      groundAlbedo: x,
+      minCosLight: y,
+      sunRadianceToLuminance: T,
+      skyRadianceToLuminance: S,
+      luminanceScale: M,
+      transmittanceTextureSize: C,
+      irradianceTextureSize: N,
+      multipleScatteringTextureSize: f,
+      scatteringTextureRadiusSize: z,
+      scatteringTextureCosViewSize: F,
+      scatteringTextureCosLightSize: P,
+      scatteringTextureCosViewLightSize: V
+    } = e;
+    this.parametersNode = j(
+      q({
+        // @ts-expect-error Object-style parameter is supported
+        worldToUnit: A(t),
+        solarIrradiance: g(i),
+        sunAngularRadius: A(r),
+        bottomRadius: A(n * t),
+        topRadius: A(a * t),
+        rayleighDensity: wt(o, t),
+        rayleighScattering: g(
+          u.x / t,
+          u.y / t,
+          u.z / t
+        ),
+        mieDensity: wt(l, t),
+        mieScattering: g(
+          c.x / t,
+          c.y / t,
+          c.z / t
+        ),
+        mieExtinction: g(
+          d.x / t,
+          d.y / t,
+          d.z / t
+        ),
+        miePhaseFunctionG: A(h),
+        absorptionDensity: wt(m, t),
+        absorptionExtinction: g(
+          p.x / t,
+          p.y / t,
+          p.z / t
+        ),
+        groundAlbedo: g(x),
+        minCosLight: A(y),
+        sunRadianceToLuminance: g(T),
+        skyRadianceToLuminance: g(S),
+        luminanceScale: A(M),
+        transmittanceTextureSize: Ne(C),
+        irradianceTextureSize: Ne(N),
+        multipleScatteringTextureSize: st(f),
+        scatteringTextureRadiusSize: fe(z),
+        scatteringTextureCosViewSize: fe(F),
+        scatteringTextureCosLightSize: fe(P),
+        scatteringTextureCosViewLightSize: fe(
+          V
+        )
+      }).toConst("atmosphereParameters")
+    );
+  }
+  // eslint-disable-next-line @typescript-eslint/class-methods-use-this
+  dispose() {
+  }
+}
+function oe(s) {
+  if (typeof s.context.getAtmosphere != "function")
+    throw new Error("getAtmosphere() was not found in the builder context.");
+  const e = s.context.getAtmosphere();
+  if (!(e instanceof Ht))
+    throw new Error(
+      "getAtmosphere() must return an instanceof AtmosphereContextBase."
+    );
+  return e;
+}
+class ks extends Ht {
+  constructor(e, t) {
+    super(e), this.lambdas = w(new H(680, 550, 440)), this.luminanceFromRadiance = w("mat3"), this.textureType = t;
+  }
+}
+class $s {
+  setup(e, t) {
+    this.parameters = e, this.textureType = t;
+  }
+  // eslint-disable-next-line @typescript-eslint/class-methods-use-this
+  dispose() {
+  }
+}
+const ce = /* @__PURE__ */ R({
+  name: "clampCosine",
+  type: E,
+  inputs: [{ name: "cosine", type: E }]
+})(([s]) => Ot(s, -1, 1)), js = /* @__PURE__ */ R({
+  name: "clampDistance",
+  type: E,
+  inputs: [{ name: "cosine", type: E }]
+})(([s]) => Re(s, 0)), ht = /* @__PURE__ */ R({
+  name: "clampRadius",
+  type: U,
+  inputs: [
+    { name: "parameters", type: q },
+    { name: "radius", type: U }
+  ]
+})(([s, e]) => {
+  const { topRadius: t, bottomRadius: i } = j(s);
+  return Ot(e, i, t);
+}), ve = /* @__PURE__ */ R({
+  name: "sqrtSafe",
+  type: E,
+  inputs: [{ name: "area", type: Cn }]
+})(([s]) => $(Re(s, 0))), Ue = /* @__PURE__ */ R({
+  name: "distanceToTopAtmosphereBoundary",
+  type: U,
+  inputs: [
+    { name: "parameters", type: q },
+    { name: "radius", type: U },
+    { name: "cosView", type: E }
+  ]
+})(([s, e, t]) => {
+  const { topRadius: i } = j(s), r = e.pow2().mul(t.pow2().sub(1)).add(i.pow2());
+  return js(e.negate().mul(t).add(ve(r)));
+}), Mn = /* @__PURE__ */ R({
+  name: "distanceToBottomAtmosphereBoundary",
+  type: U,
+  inputs: [
+    { name: "parameters", type: q },
+    { name: "radius", type: U },
+    { name: "cosView", type: E }
+  ]
+})(([s, e, t]) => {
+  const { bottomRadius: i } = j(s), r = e.pow2().mul(t.pow2().sub(1)).add(i.pow2());
+  return js(e.negate().mul(t).sub(ve(r)));
+}), Gs = /* @__PURE__ */ R({
+  name: "distanceToNearestAtmosphereBoundary",
+  type: U,
+  inputs: [
+    { name: "parameters", type: q },
+    { name: "radius", type: U },
+    { name: "cosView", type: E },
+    { name: "intersectsGround", type: "bool" }
+  ]
+})(([s, e, t, i]) => i.select(
+  Mn(s, e, t),
+  Ue(s, e, t)
+)), Ws = /* @__PURE__ */ R({
+  name: "rayIntersectsGround",
+  type: "bool",
+  inputs: [
+    { name: "parameters", type: q },
+    { name: "radius", type: U },
+    { name: "cosView", type: E }
+  ]
+})(([s, e, t]) => {
+  const { bottomRadius: i } = j(s);
+  return t.lessThan(0).and(
+    e.pow2().mul(t.pow2().sub(1)).add(i.pow2()).greaterThanEqual(0)
+  );
+}), xe = /* @__PURE__ */ R({
+  name: "getTextureCoordFromUnitRange",
+  type: "float",
+  inputs: [
+    { name: "unit", type: "float" },
+    { name: "textureSize", type: "float" }
+  ]
+})(([s, e]) => $t(0.5, e).add(
+  s.mul(e.reciprocal().oneMinus())
+)), Rn = /* @__PURE__ */ R({
+  name: "getTransmittanceTextureUV",
+  type: "vec2",
+  inputs: [
+    { name: "parameters", type: q },
+    { name: "radius", type: U },
+    { name: "cosView", type: E }
+  ]
+})(([s, e, t]) => {
+  const { topRadius: i, bottomRadius: r, transmittanceTextureSize: n } = j(s), a = $(i.pow2().sub(r.pow2())).toConst(), o = ve(
+    e.pow2().sub(r.pow2())
+  ).toConst(), u = Ue(
+    s,
+    e,
+    t
+  ), l = i.sub(e).toConst(), c = o.add(a), d = u.remap(l, c), h = o.div(a);
+  return b(
+    xe(d, n.x),
+    xe(h, n.y)
+  );
+}), Fe = /* @__PURE__ */ L(
+  (s, e, t) => (i) => {
+    const r = oe(i), { parametersNode: n } = r, a = Rn(n, e, t);
+    return s.sample(a).rgb;
+  }
+), bn = /* @__PURE__ */ L(
+  (s, e, t, i, r) => (n) => {
+    const a = oe(n), { parametersNode: o } = a, u = ht(
+      o,
+      $(
+        i.pow2().add(te(2, e, t, i)).add(e.pow2())
+      )
+    ).toConst(), l = ce(
+      e.mul(t).add(i).div(u)
+    ).toConst(), c = g(0).toVar();
+    return I(r, () => {
+      c.assign(
+        Fe(
+          s,
+          u,
+          l.negate()
+        ).div(
+          Fe(
+            s,
+            e,
+            t.negate()
+          )
+        ).min(1)
+      );
+    }).Else(() => {
+      c.assign(
+        Fe(
+          s,
+          e,
+          t
+        ).div(
+          Fe(
+            s,
+            u,
+            l
+          )
+        ).min(1)
+      );
+    }), c;
+  }
+), at = /* @__PURE__ */ L(
+  (s, e, t) => (i) => {
+    const r = oe(i), { parametersNode: n } = r, { sunAngularRadius: a, bottomRadius: o } = n, u = o.div(e).toConst(), l = $(Re(u.pow2().oneMinus(), 0)).negate();
+    return Fe(
+      s,
+      e,
+      t
+    ).mul(
+      ut(
+        u.negate().mul(a),
+        u.mul(a),
+        t.sub(l)
+      )
+    );
+  }
+), _t = /* @__PURE__ */ R({
+  name: "rayleighPhaseFunction",
+  type: Us,
+  inputs: [{ name: "cosViewLight", type: E }]
+})(([s]) => $t(3, te(16, qe)).mul(s.pow2().add(1))), qs = /* @__PURE__ */ R({
+  name: "miePhaseFunction",
+  type: Us,
+  inputs: [
+    { name: "g", type: E },
+    { name: "cosViewLight", type: E }
+  ]
+})(([s, e]) => $t(3, qe.mul(8)).mul(s.pow2().oneMinus()).div(s.pow2().add(2)).mul(e.pow2().add(1)).div(s.pow2().sub(s.mul(2).mul(e)).add(1).pow(1.5))), Hs = /* @__PURE__ */ R({
+  name: "getScatteringTextureCoord",
+  type: "vec4",
+  inputs: [
+    { name: "parameters", type: q },
+    { name: "radius", type: U },
+    { name: "cosView", type: E },
+    { name: "cosLight", type: E },
+    { name: "cosViewLight", type: E },
+    { name: "intersectsGround", type: "bool" }
+  ]
+})(([
+  s,
+  e,
+  t,
+  i,
+  r,
+  n
+]) => {
+  const {
+    topRadius: a,
+    bottomRadius: o,
+    minCosLight: u,
+    scatteringTextureRadiusSize: l,
+    scatteringTextureCosViewSize: c,
+    scatteringTextureCosLightSize: d
+  } = j(s), h = $(a.pow2().sub(o.pow2())).toConst(), m = ve(
+    e.pow2().sub(o.pow2())
+  ).toConst(), p = xe(
+    m.div(h),
+    l
+  ), x = e.mul(t).toConst(), y = x.pow2().sub(e.pow2()).add(o.pow2()).toConst(), T = A(0).toVar();
+  I(n, () => {
+    const F = x.negate().sub(ve(y)), P = e.sub(o).toConst(), V = m;
+    T.assign(
+      xe(
+        V.equal(P).select(0, F.remap(P, V)),
+        c.div(2)
+      ).oneMinus().mul(0.5)
+    );
+  }).Else(() => {
+    const F = x.negate().add(ve(y.add(h.pow2()))), P = a.sub(e).toConst(), V = m.add(h);
+    T.assign(
+      xe(
+        F.remap(P, V),
+        c.div(2)
+      ).add(1).mul(0.5)
+    );
+  });
+  const S = a.sub(o).toConst(), M = h, C = Ue(s, o, i).remap(S, M).toConst(), N = Ue(
+    s,
+    o,
+    u
+  ).remap(S, M), f = xe(
+    Re(C.div(N).oneMinus(), 0).div(C.add(1)),
+    d
+  ), z = r.add(1).mul(0.5);
+  return v(z, f, T, p);
+}), _s = /* @__PURE__ */ L(
+  (s, e, t, i, r, n) => (a) => {
+    const o = oe(a), { parametersNode: u } = o, { scatteringTextureCosViewLightSize: l } = u, c = Hs(
+      u,
+      e,
+      t,
+      i,
+      r,
+      n
+    ).toConst(), d = c.x.mul(l.sub(1)).toConst(), h = kt(d).toConst(), m = d.sub(h).toConst(), p = g(
+      h.add(c.y).div(l),
+      c.z,
+      c.w
+    ), x = g(
+      h.add(1).add(c.y).div(l),
+      c.z,
+      c.w
+    );
+    return s.sample(p).mul(m.oneMinus()).add(s.sample(x).mul(m)).rgb;
+  }
+), zn = /* @__PURE__ */ R({
+  name: "getIrradianceTextureUV",
+  type: "vec2",
+  inputs: [
+    { name: "parameters", type: q },
+    { name: "radius", type: U },
+    { name: "cosLight", type: E }
+  ]
+})(([s, e, t]) => {
+  const { topRadius: i, bottomRadius: r, irradianceTextureSize: n } = j(s), a = e.remap(r, i), o = t.mul(0.5).add(0.5);
+  return b(
+    xe(o, n.x),
+    xe(a, n.y)
+  );
+}), En = /* @__PURE__ */ L(
+  (s, e, t) => (i) => {
+    const r = oe(i), { parametersNode: n } = r, a = zn(n, e, t);
+    return s.sample(a).rgb;
+  }
+), Ts = /* @__PURE__ */ R({
+  name: "getLayerDensity",
+  type: E,
+  inputs: [
+    { name: "layer", type: nt },
+    { name: "altitude", type: U }
+  ]
+})(([s, e]) => {
+  const t = s.get("expTerm"), i = s.get("expScale"), r = s.get("linearTerm"), n = s.get("constantTerm");
+  return t.mul(lt(i.mul(e))).add(r.mul(e)).add(n).saturate();
+}), et = /* @__PURE__ */ R({
+  name: "getProfileDensity",
+  type: E,
+  inputs: [
+    { name: "layer", type: De },
+    { name: "altitude", type: U }
+  ]
+})(([s, e]) => e.lessThan(s.get("layer0").get("width")).select(
+  Ts(s.get("layer0"), e),
+  Ts(s.get("layer1"), e)
+)), ye = /* @__PURE__ */ R({
+  name: "getUnitRangeFromTextureCoord",
+  type: "float",
+  inputs: [
+    { name: "coord", type: "float" },
+    { name: "textureSize", type: "float" }
+  ]
+})(([s, e]) => {
+  const t = e.reciprocal();
+  return s.sub(t.mul(0.5)).div(t.oneMinus());
+}), ot = /* @__PURE__ */ Y(
+  {
+    radius: U,
+    cosView: E,
+    cosLight: E,
+    cosViewLight: E,
+    intersectsGround: "bool"
+  },
+  "ScatteringParams"
+), An = /* @__PURE__ */ R({
+  // BUG: Cannot access vector component inside struct in layout function
+  // https://github.com/mrdoob/three.js/issues/33345
+  typeOnly: !0,
+  name: "getParamsFromScatteringTextureCoord",
+  type: ot,
+  inputs: [
+    { name: "parameters", type: q },
+    { name: "coord", type: "vec4" }
+  ]
+})(([s, e]) => {
+  const {
+    bottomRadius: t,
+    topRadius: i,
+    minCosLight: r,
+    scatteringTextureRadiusSize: n,
+    scatteringTextureCosViewSize: a,
+    scatteringTextureCosLightSize: o
+  } = j(s), u = $(i.pow2().sub(t.pow2())).toConst(), l = u.mul(
+    ye(e.w, n)
+  ).toConst(), c = $(l.pow2().add(t.pow2())), d = A(0).toVar(), h = Ve().toVar();
+  I(e.z.lessThan(0.5), () => {
+    const N = c.sub(t).toConst(), f = l, z = N.add(
+      f.sub(N).mul(
+        ye(
+          e.z.mul(2).oneMinus(),
+          a.div(2)
+        )
+      )
+    ).toConst();
+    d.assign(
+      z.equal(0).select(
+        -1,
+        ce(
+          l.pow2().add(z.pow2()).negate().div(te(2, c, z))
+        )
+      )
+    ), h.assign(Ve(!0));
+  }).Else(() => {
+    const N = i.sub(c).toConst(), f = l.add(u), z = N.add(
+      f.sub(N).mul(
+        ye(
+          e.z.mul(2).sub(1),
+          a.div(2)
+        )
+      )
+    ).toConst();
+    d.assign(
+      z.equal(0).select(
+        1,
+        ce(
+          u.pow2().sub(l.pow2()).sub(z.pow2()).div(te(2, c, z))
+        )
+      )
+    ), h.assign(Ve(!1));
+  });
+  const m = ye(
+    e.y,
+    o
+  ).toConst(), p = i.sub(t).toConst(), x = u, y = Ue(
+    s,
+    t,
+    r
+  ).remap(p, x).toConst(), T = y.sub(m.mul(y)).div(m.mul(y).add(1)), S = p.add(Ms(T, y).mul(x.sub(p))).toConst(), M = S.equal(0).select(
+    1,
+    ce(
+      u.pow2().sub(S.pow2()).div(te(2, t, S))
+    )
+  ), C = ce(e.x.mul(2).sub(1));
+  return ot(
+    c,
+    d,
+    M,
+    C,
+    h
+  );
+}), Fn = /* @__PURE__ */ R({
+  // BUG: Cannot access vector component inside struct in layout function
+  // https://github.com/mrdoob/three.js/issues/33345
+  typeOnly: !0,
+  name: "getParamsFromScatteringTextureFragCoord",
+  type: ot,
+  inputs: [
+    { name: "parameters", type: q },
+    { name: "fragCoord", type: "vec3" }
+  ]
+})(([s, e]) => {
+  const {
+    scatteringTextureRadiusSize: t,
+    scatteringTextureCosViewSize: i,
+    scatteringTextureCosLightSize: r,
+    scatteringTextureCosViewLightSize: n
+  } = j(s), a = kt(
+    e.x.div(r)
+  ), o = e.x.mod(r), u = v(
+    n.sub(1),
+    r,
+    i,
+    t
+  ), l = v(
+    a,
+    o,
+    e.y,
+    e.z
+  ).div(u), c = An(
+    s,
+    l
+  ).toConst(), d = c.get("radius"), h = c.get("cosView"), m = c.get("cosLight"), p = c.get("cosViewLight").toVar(), x = c.get("intersectsGround"), y = $(
+    h.pow2().oneMinus().mul(m.pow2().oneMinus())
+  ).toConst();
+  return p.assign(
+    Ot(
+      p,
+      h.mul(m).sub(y),
+      h.mul(m).add(y)
+    )
+  ), ot(
+    d,
+    h,
+    m,
+    p,
+    x
+  );
+}), Vn = /* @__PURE__ */ R({
+  name: "getExtrapolatedSingleMieScattering",
+  type: Be,
+  inputs: [
+    { name: "scattering", type: "vec4" },
+    { name: "rayleighScattering", type: "vec3" },
+    { name: "mieScattering", type: "vec3" }
+  ]
+})(([s, e, t]) => {
+  const i = g(0).toVar();
+  return I(s.r.greaterThanEqual(1e-5), () => {
+    i.assign(
+      s.rgb.mul(s.a).div(s.r).mul(e.r.div(t.r)).mul(t.div(e))
+    );
+  }), i;
+}), Ln = /* @__PURE__ */ Y(
+  {
+    scattering: Be,
+    singleMieScattering: Be
+  },
+  "CombinedScattering"
+), tt = /* @__PURE__ */ L(
+  (s, e, t, i, r, n, a, o) => (u) => {
+    const l = oe(u), {
+      rayleighScattering: c,
+      mieScattering: d,
+      scatteringTextureCosViewLightSize: h
+    } = j(s), m = Hs(
+      s,
+      i,
+      r,
+      n,
+      a,
+      o
+    ).toConst(), p = m.x.mul(h.sub(1)).toConst(), x = kt(p).toConst(), y = p.sub(x).toConst(), T = g(
+      x.add(m.y).div(h),
+      m.z,
+      m.w
+    ).toConst(), S = g(
+      x.add(1).add(m.y).div(h),
+      m.z,
+      m.w
+    ).toConst(), M = g(0).toVar(), C = g(0).toVar();
+    if (l.parameters.combinedScatteringTextures) {
+      const N = k(
+        e.sample(T).mul(y.oneMinus()),
+        e.sample(S).mul(y)
+      ).toConst();
+      M.assign(N.rgb), C.assign(
+        Vn(
+          N,
+          c,
+          d
+        )
+      );
+    } else
+      M.assign(
+        k(
+          e.sample(T).mul(y.oneMinus()),
+          e.sample(S).mul(y)
+        ).rgb
+      ), C.assign(
+        k(
+          t.sample(T).mul(y.oneMinus()),
+          t.sample(S).mul(y)
+        ).rgb
+      );
+    return Ln(M, C);
+  }
+), Dn = /* @__PURE__ */ Y(
+  {
+    radiance: Is,
+    transmittance: Se
+  },
+  "RadianceTransfer"
+), Pn = /* @__PURE__ */ R({
+  name: "getSubUVFromTextureUnit",
+  type: "vec2",
+  inputs: [
+    { name: "unit", type: "vec2" },
+    { name: "textureSize", type: "vec2" }
+  ]
+})(([s, e]) => s.add(A(0.5).div(e)).mul(e.div(e.add(1)))), Zs = /* @__PURE__ */ R({
+  name: "getTextureUnitFromSubUV",
+  type: "vec2",
+  inputs: [
+    { name: "subUV", type: "vec2" },
+    { name: "textureSize", type: "vec2" }
+  ]
+})(([s, e]) => s.sub(A(0.5).div(e)).mul(e.div(e.sub(1)))), ws = /* @__PURE__ */ Y(
+  {
+    rayleighScattering: ge,
+    mieScattering: ge,
+    scattering: ge,
+    extinction: ge
+  },
+  "AtmosphereMedium"
+), Ks = /* @__PURE__ */ R({
+  name: "sampleAtmosphereMedium",
+  type: ws,
+  inputs: [
+    { name: "parameters", type: q },
+    { name: "altitude", type: U }
+  ]
+})(([s, e]) => {
+  const t = j(s), i = et(t.rayleighDensity, e), r = et(t.mieDensity, e), n = et(t.absorptionDensity, e), a = i.mul(t.rayleighScattering), o = a, u = r.mul(t.mieScattering), l = r.mul(t.mieExtinction), c = n.mul(t.absorptionExtinction), d = k(a, u), h = k(o, l, c);
+  return ws(
+    a,
+    u,
+    d,
+    h
+  );
+}), Bn = /* @__PURE__ */ Y(
+  {
+    multipleScattering: Is,
+    transferFactor: Se
+  },
+  "MultipleScattering"
+), Qs = /* @__PURE__ */ L(
+  (s, e, t, i, r, n) => {
+    const { solarIrradiance: a, bottomRadius: o, groundAlbedo: u } = j(s), l = Ws(
+      s,
+      t,
+      i
+    ).toConst(), c = Gs(
+      s,
+      t,
+      i,
+      l
+    ).toConst(), d = g(0).toVar(), h = g(0).toVar(), m = g(1).toVar(), p = A(0).toVar(), x = 20;
+    return Pe({ type: "float", start: 0, end: x }, ({ i: y }) => {
+      const T = c.mul(y.add(0.3)).div(x).toConst(), S = T.sub(p).toConst();
+      p.assign(T);
+      const M = ht(
+        s,
+        $(
+          T.pow2().add(te(2, t, i, T)).add(t.pow2())
+        )
+      ).toConst(), C = ce(
+        t.mul(r).add(T.mul(n)).div(M)
+      ).toConst(), N = M.sub(o), f = Ks(s, N).toConst(), z = f.get("scattering"), F = f.get("extinction"), P = F.mul(S).toConst(), V = lt(P.negate()).toConst(), _ = at(
+        e,
+        M,
+        C
+      ).toConst(), W = z.sub(z.mul(V)).div(F).toConst();
+      h.addAssign(m.mul(W));
+      const Q = _.mul(z.mul(1 / (4 * Math.PI))).toConst(), ue = Q.sub(Q.mul(V)).div(F).toConst();
+      d.addAssign(
+        m.mul(ue)
+      ), m.mulAssign(V);
+    }), I(l, () => {
+      const y = ce(
+        t.mul(r).add(c.mul(n)).div(o)
+      ).toConst(), T = at(
+        e,
+        o,
+        y
+      ).toConst();
+      d.addAssign(
+        a.mul(
+          T,
+          m,
+          y.saturate(),
+          u,
+          1 / Math.PI
+        )
+      );
+    }), Bn(
+      d,
+      h
+    );
+  }
+), Un = /* @__PURE__ */ L(
+  (s, e, t, i) => {
+    const { topRadius: r, bottomRadius: n, multipleScatteringTextureSize: a } = j(s), o = Pn(
+      b(
+        i.mul(0.5).add(0.5),
+        t.sub(n).div(r.sub(n))
+      ).saturate(),
+      a
+    );
+    return e.sample(o).rgb;
+  }
+), In = /* @__PURE__ */ Y(
+  {
+    scattering: Be,
+    singleMieScattering: Be,
+    higherOrderScattering: Nn
+  },
+  "Scattering"
+), Js = /* @__PURE__ */ L(
+  (s, e, t) => (i) => {
+    const r = oe(i), { parametersNode: n } = r, { solarIrradiance: a, bottomRadius: o } = n, u = Fn(
+      n,
+      t
+    ).toConst(), l = u.get("radius"), c = u.get("cosView"), d = u.get("cosLight"), h = u.get("cosViewLight"), m = u.get("intersectsGround"), p = Gs(
+      n,
+      l,
+      c,
+      m
+    ).toConst(), x = he(
+      14,
+      30,
+      p.mul(1 / 100)
+    ).toConst(), y = x.floor().toConst(), T = y.reciprocal().toConst(), S = p.mul(y).div(x).toConst(), M = _t(h).toConst(), C = g(0).toVar(), N = g(0).toVar(), f = g(0).toVar(), z = g(1).toVar();
+    return Pe({ type: "float", start: 0, end: x }, ({ i: F }) => {
+      const P = F.mul(T).toVar(), V = F.add(1).mul(T).toVar();
+      P.mulAssign(P), V.mulAssign(V), P.mulAssign(S), V.assign(
+        V.greaterThan(1).select(p, S.mul(V))
+      );
+      const _ = V.sub(P), W = P.add(_.mul(0.3)), Q = ht(
+        n,
+        $(
+          W.pow2().add(te(2, l, c, W)).add(l.pow2())
+        )
+      ).toConst(), ue = ce(
+        l.mul(d).add(W.mul(h)).div(Q)
+      ).toConst(), Ie = Q.sub(o), B = Ks(
+        n,
+        Ie
+      ).toConst(), Te = B.get("rayleighScattering"), ze = B.get("mieScattering"), me = B.get("scattering"), le = B.get("extinction"), ri = le.mul(_), Je = lt(ri.negate()).toConst(), Zt = at(
+        s,
+        Q,
+        ue
+      ).toConst(), Kt = Un(
+        n,
+        e,
+        Q,
+        ue
+      ).mul(me).toConst();
+      let Ee = Zt.mul(Te);
+      r.parameters.higherOrderScatteringTexture || (Ee = Ee.add(Kt.div(M))), Ee = a.mul(Ee).toConst();
+      const ni = Ee.sub(Ee.mul(Je)).div(le).toConst();
+      C.addAssign(z.mul(ni));
+      const Qt = a.mul(Zt.mul(ze)).toConst(), ai = Qt.sub(Qt.mul(Je)).div(le).toConst();
+      N.addAssign(z.mul(ai));
+      const Jt = a.mul(Kt), oi = Jt.sub(Jt.mul(Je)).div(le).toConst();
+      f.addAssign(z.mul(oi)), z.mulAssign(Je);
+    }), In(C, N, f);
+  }
+), ft = /* @__PURE__ */ R({
+  name: "computeOpticalDepthToTopAtmosphereBoundary",
+  type: U,
+  inputs: [
+    { name: "parameters", type: q },
+    { name: "profile", type: De },
+    { name: "radius", type: U },
+    { name: "cosView", type: E }
+  ]
+})(([s, e, t, i]) => {
+  const { bottomRadius: r } = j(s), n = 500, a = Ue(s, t, i).div(n).toConst(), o = A(0).toVar();
+  return Pe({ start: 0, end: n, condition: "<=" }, ({ i: u }) => {
+    const l = A(u).mul(a).toConst(), c = $(
+      k(l.pow2(), te(2, t, i, l), t.pow2())
+    ).toConst(), d = et(e, c.sub(r)), h = b(u).equal(b(0, n)).any().select(0.5, 1);
+    o.addAssign(d.mul(h).mul(a));
+  }), o;
+}), On = /* @__PURE__ */ R({
+  name: "computeTransmittanceToTopAtmosphereBoundary",
+  type: Se,
+  inputs: [
+    { name: "parameters", type: q },
+    { name: "radius", type: U },
+    { name: "cosView", type: E }
+  ]
+})(([s, e, t]) => {
+  const {
+    rayleighDensity: i,
+    rayleighScattering: r,
+    mieDensity: n,
+    mieExtinction: a,
+    absorptionDensity: o,
+    absorptionExtinction: u
+  } = j(s), l = ft(
+    s,
+    i,
+    e,
+    t
+  ), c = ft(
+    s,
+    n,
+    e,
+    t
+  ), d = ft(
+    s,
+    o,
+    e,
+    t
+  ), h = k(
+    r.mul(l),
+    a.mul(c),
+    u.mul(d)
+  ).toConst();
+  return lt(h.negate());
+}), kn = /* @__PURE__ */ R({
+  // BUG: Cannot access vector component inside struct in layout function
+  // https://github.com/mrdoob/three.js/issues/33345
+  typeOnly: !0,
+  name: "getParamsFromTransmittanceTextureUV",
+  type: "vec2",
+  inputs: [
+    { name: "parameters", type: q },
+    { name: "uv", type: "vec2" }
+  ]
+})(([s, e]) => {
+  const { topRadius: t, bottomRadius: i, transmittanceTextureSize: r } = j(s), n = ye(
+    e.x,
+    r.x
+  ), a = ye(
+    e.y,
+    r.y
+  ), o = $(t.pow2().sub(i.pow2())).toConst(), u = o.mul(a).toConst(), l = $(u.pow2().add(i.pow2())), c = t.sub(l).toConst(), d = u.add(o), h = c.add(n.mul(d.sub(c))).toConst(), m = h.equal(0).select(
+    1,
+    o.pow2().sub(u.pow2()).sub(h.pow2()).div(te(2, l, h))
+  );
+  return b(l, m);
+}), Xs = /* @__PURE__ */ L(
+  (s) => (e) => {
+    const t = oe(e), { parametersNode: i } = t, { transmittanceTextureSize: r } = i, n = kn(
+      i,
+      s.div(r)
+    ).toConst(), a = n.x, o = n.y;
+    return On(
+      i,
+      a,
+      o
+    );
+  }
+), $n = /* @__PURE__ */ R({
+  // BUG: Cannot access vector component inside struct in layout function
+  // https://github.com/mrdoob/three.js/issues/33345
+  typeOnly: !0,
+  name: "getParamsFromIrradianceTextureUV",
+  type: "vec2",
+  inputs: [
+    { name: "parameters", type: q },
+    { name: "uv", type: "vec2" }
+  ]
+})(([s, e]) => {
+  const { topRadius: t, bottomRadius: i, irradianceTextureSize: r } = j(s), n = ye(
+    e.x,
+    r.x
+  ), a = ye(e.y, r.y), o = i.add(a.mul(t.sub(i))), u = ce(n.mul(2).sub(1));
+  return b(o, u);
+}), Ys = /* @__PURE__ */ L(
+  (s, e, t) => (i) => {
+    const r = oe(i), { parametersNode: n } = r, { miePhaseFunctionG: a, irradianceTextureSize: o } = n, u = $n(
+      n,
+      t.div(o)
+    ).toConst(), l = u.x, c = u.y, d = 32, h = Math.PI / d, m = Math.PI / d, p = g(0).toVar(), x = g(
+      $(c.pow2().oneMinus()),
+      0,
+      c
+    ).toConst();
+    return Pe({ start: 0, end: d / 2, name: "j" }, ({ j: y }) => {
+      const T = A(y).add(0.5).mul(m).toConst();
+      Pe({ start: 0, end: d * 2 }, ({ i: S }) => {
+        const M = A(S).add(0.5).mul(h).toConst(), C = g(
+          ne(M).mul(ie(T)),
+          ie(M).mul(ie(T)),
+          ne(T)
+        ).toConst(), N = ie(T).mul(m * h), f = C.dot(x), z = tt(
+          n,
+          s,
+          s,
+          l,
+          C.z,
+          c,
+          f,
+          Ve(!1)
+        );
+        let F = g(0);
+        r.parameters.higherOrderScatteringTexture && (F = _s(
+          e,
+          l,
+          C.z,
+          c,
+          f,
+          Ve(!1)
+        ));
+        const P = z.get("scattering"), V = z.get(
+          "singleMieScattering"
+        ), _ = _t(f), W = qs(a, f);
+        p.addAssign(
+          P.mul(_).add(V.mul(W)).add(F).mul(C.z, N)
+        );
+      });
+    }), p;
+  }
+);
+function St(s) {
+  const e = new jt(1, 1, {
+    depthBuffer: !1,
+    format: be
+  }), t = e.texture;
+  return t.minFilter = Z, t.magFilter = Z, t.colorSpace = ct, t.generateMipmaps = !1, t.name = s, e;
+}
+function vt(s) {
+  const e = new cr(1, 1, 1, {
+    depthBuffer: !1,
+    format: be
+  }), t = e.texture;
+  return t.minFilter = Z, t.magFilter = Z, t.colorSpace = ct, t.generateMipmaps = !1, t.name = s, e;
+}
+function Ct(s, e, t) {
+  s.texture.type = e, s.setSize(t.x, t.y);
+}
+function Nt(s, e, t) {
+  s.texture.type = e, s.setSize(t.x, t.y, t.z), s.texture.isArrayTexture = !1;
+}
+class jn extends ks {
+}
+class Gn extends $s {
+  constructor() {
+    super(), this.mesh = new We(), this.layer = w(0), this.mesh.name = "AtmosphereLUTTexturesWebGL", this.transmittanceRT = St("transmittance"), this.multipleScatteringRT = St("multipleScattering"), this.scatteringRT = vt("scattering"), this.singleMieScatteringRT = vt("singleMieScattering"), this.higherOrderScatteringRT = vt("higherOrderScattering"), this.irradianceRT = St("irradiance");
+  }
+  get(e) {
+    return this[`${e}RT`].texture;
+  }
+  createContext() {
+    return de(this.parameters != null), de(this.textureType != null), new jn(
+      this.parameters,
+      this.textureType
+    );
+  }
+  renderToRenderTarget(e, t, i) {
+    i != null && t.textures.push(...i.filter((r) => r != null)), e.setRenderTarget(t), this.mesh.render(e), t.textures.length = 1;
+  }
+  renderToRenderTarget3D(e, t, i, r) {
+    r != null && t.textures.push(...r.filter((n) => n != null));
+    for (let n = 0; n < t.depth; ++n)
+      i.value = n, e.setRenderTarget(t, n), this.mesh.render(e);
+    t.textures.length = 1;
+  }
+  // eslint-disable-next-line @typescript-eslint/class-methods-use-this
+  createMaterial(e) {
+    const t = new Ce();
+    return t.fragmentNode = e, t.needsUpdate = !0, t;
+  }
+  computeTransmittance(e, t) {
+    this.transmittanceMaterial?.dispose(), this.transmittanceMaterial = this.createMaterial(
+      // BUG: Context is not merged unless we wrap the node by OutputStructNode.
+      Xe({
+        transmittance: Xs(Ae).context({
+          getAtmosphere: () => t
+        })
+      })
+    ), this.mesh.material = this.transmittanceMaterial, this.renderToRenderTarget(e, this.transmittanceRT);
+  }
+  computeMultipleScattering(e, t) {
+    const { parameters: i, parametersNode: r } = t, n = 64, a = L((u) => {
+      const l = A(u), c = l.mul(2 * Math.PI / ((1 + Math.sqrt(5)) / 2)), d = Es(
+        l.add(0.5).mul(2 / n).oneMinus()
+      ), h = ne(d), m = ie(d), p = ne(c), x = ie(c);
+      return g(p.mul(m), x.mul(m), h);
+    }), o = O(() => {
+      const u = b(i.multipleScatteringTextureSize), l = Zs(
+        Ae.div(u),
+        u
+      ).toConst(), { topRadius: c, bottomRadius: d } = r, h = l.x.mul(2).sub(1).toConst(), m = g(
+        0,
+        $(h.pow2().oneMinus().saturate()),
+        h
+      ).toConst(), p = 0, x = d.add(
+        l.y.add(p).saturate().mul(c.sub(d).sub(p))
+      ).toConst(), y = g(0).toVar(), T = g(0).toVar();
+      return Pe({ start: 0, end: n }, ({ i: S }) => {
+        const M = a(S).toConst(), C = M.z, N = M.dot(m).toConst(), f = Qs(
+          r,
+          X(this.transmittanceRT.texture),
+          x,
+          C,
+          h,
+          N
+        ).context({ getAtmosphere: () => t }).toConst();
+        y.addAssign(
+          f.get("multipleScattering").div(n)
+        ), T.addAssign(
+          f.get("transferFactor").div(n)
+        );
+      }), y.mul(
+        T.oneMinus().reciprocal()
+      );
+    });
+    this.multipleScatteringMaterial?.dispose(), this.multipleScatteringMaterial = this.createMaterial(
+      // BUG: Context is not merged unless we wrap the node by
+      // OutputStructNode.
+      Xe({
+        multipleScattering: v(o(), 1)
+      })
+    ), this.mesh.material = this.multipleScatteringMaterial, this.renderToRenderTarget(e, this.multipleScatteringRT);
+  }
+  computeScattering(e, t) {
+    const { parameters: i } = t;
+    this.scatteringMaterial?.dispose(), this.scatteringMaterial = this.createMaterial(
+      (() => {
+        const n = Js(
+          X(this.transmittanceRT.texture),
+          X(this.multipleScatteringRT.texture),
+          g(Ae, this.layer.add(0.5))
+        ).context({ getAtmosphere: () => t }).toConst(), a = n.get("scattering"), o = n.get("singleMieScattering"), u = n.get("higherOrderScattering"), l = {};
+        return i.combinedScatteringTextures ? l.scattering = v(a, o.r) : (l.scattering = v(a, o.r), l.singleMieScattering = v(o, 1)), i.higherOrderScatteringTexture && (l.higherOrderScattering = v(u, 1)), Xe(l);
+      })()
+    ), this.mesh.material = this.scatteringMaterial;
+    const r = [];
+    i.combinedScatteringTextures || r.push(this.singleMieScatteringRT.texture), i.higherOrderScatteringTexture && r.push(this.higherOrderScatteringRT.texture), this.renderToRenderTarget3D(
+      e,
+      this.scatteringRT,
+      this.layer,
+      r
+    );
+  }
+  computeIrradiance(e, t) {
+    this.irradianceMaterial?.dispose(), this.irradianceMaterial = this.createMaterial(
+      // BUG: Context is not merged unless we wrap the node by OutputStructNode.
+      Xe({
+        irradiance: Ys(
+          it(this.scatteringRT.texture),
+          it(this.higherOrderScatteringRT.texture),
+          Ae
+        ).context({ getAtmosphere: () => t })
+      })
+    ), this.mesh.material = this.irradianceMaterial, this.renderToRenderTarget(e, this.irradianceRT);
+  }
+  setup(e, t) {
+    Ct(
+      this.transmittanceRT,
+      t,
+      e.transmittanceTextureSize
+    ), Ct(
+      this.multipleScatteringRT,
+      t,
+      e.multipleScatteringTextureSize
+    ), Nt(
+      this.scatteringRT,
+      t,
+      e.scatteringTextureSize
+    ), e.combinedScatteringTextures || Nt(
+      this.singleMieScatteringRT,
+      t,
+      e.scatteringTextureSize
+    ), e.higherOrderScatteringTexture && Nt(
+      this.higherOrderScatteringRT,
+      t,
+      e.scatteringTextureSize
+    ), Ct(
+      this.irradianceRT,
+      t,
+      e.irradianceTextureSize
+    ), super.setup(e, t);
+  }
+  dispose() {
+    this.transmittanceRT.dispose(), this.multipleScatteringRT.dispose(), this.scatteringRT.dispose(), this.irradianceRT.dispose(), this.transmittanceMaterial?.dispose(), this.multipleScatteringMaterial?.dispose(), this.scatteringMaterial?.dispose(), this.irradianceMaterial?.dispose(), this.mesh.geometry.dispose(), super.dispose();
+  }
+}
+function Mt(s) {
+  const e = new gi(1, 1);
+  return e.minFilter = Z, e.magFilter = Z, e.colorSpace = ct, e.generateMipmaps = !1, e.name = s, e;
+}
+function Rt(s) {
+  const e = new xi(1, 1, 1);
+  return e.minFilter = Z, e.magFilter = Z, e.colorSpace = ct, e.generateMipmaps = !1, e.name = s, e;
+}
+function bt(s, e, t) {
+  s.type = e, Wt(s.image), s.image.width = t.x, s.image.height = t.y;
+}
+function zt(s, e, t) {
+  s.type = e, Wt(s.image), s.image.width = t.x, s.image.height = t.y, s.image.depth = t.z;
+}
+class Wn extends ks {
+}
+class qn extends $s {
+  constructor() {
+    super(), this.transmittance = Mt("transmittance"), this.multipleScattering = Mt("multipleScattering"), this.scattering = Rt("scattering"), this.singleMieScattering = Rt("singleMieScattering"), this.higherOrderScattering = Rt("higherOrderScattering"), this.irradiance = Mt("irradiance");
+  }
+  get(e) {
+    return this[e];
+  }
+  createContext() {
+    return de(this.parameters != null), de(this.textureType != null), new Wn(
+      this.parameters,
+      this.textureType
+    );
+  }
+  computeTransmittance(e, t) {
+    const { parameters: i } = t, { x: r, y: n } = i.transmittanceTextureSize;
+    this.transmittanceNode?.dispose(), this.transmittanceNode = O(() => {
+      const a = st(r, n);
+      I(G.xy.greaterThanEqual(a).any(), () => {
+        Oe();
+      });
+      const o = Xs(
+        b(G.xy).add(0.5)
+      );
+      we(this.transmittance, G.xy, o);
+    })().context({ getAtmosphere: () => t }).computeKernel([8, 8, 1]).setName("transmittance"), e.compute(this.transmittanceNode, [
+      Math.ceil(r / 8),
+      Math.ceil(n / 8),
+      1
+    ]);
+  }
+  computeMultipleScattering(e, t) {
+    const { parameters: i, parametersNode: r } = t, { x: n, y: a } = i.multipleScatteringTextureSize, o = 64, u = L((l) => {
+      const c = A(l), d = c.mul(2 * Math.PI / ((1 + Math.sqrt(5)) / 2)), h = Es(
+        c.add(0.5).mul(2 / o).oneMinus()
+      ), m = ne(h), p = ie(h), x = ne(d), y = ie(d);
+      return g(x.mul(p), y.mul(p), m);
+    });
+    this.multipleScatteringNode?.dispose(), this.multipleScatteringNode = O(() => {
+      const l = ts("vec3", o), c = ts("vec3", o), d = b(n, a).toConst(), h = b(G.xy).add(0.5), m = Zs(h.div(d), d).toConst(), p = G.z, { topRadius: x, bottomRadius: y } = r, T = m.x.mul(2).sub(1).toConst(), S = g(
+        0,
+        $(T.pow2().oneMinus().saturate()),
+        T
+      ).toConst(), M = 0, C = y.add(
+        m.y.add(M).saturate().mul(x.sub(y).sub(M))
+      ).toConst(), N = u(p).toConst(), f = N.z, z = N.dot(S).toConst(), F = Qs(
+        r,
+        X(this.transmittance),
+        C,
+        f,
+        T,
+        z
+      ).toConst();
+      l.element(p).assign(F.get("multipleScattering").div(o)), c.element(p).assign(F.get("transferFactor").div(o)), ss();
+      for (let _ = o >> 1; _ > 0; _ >>>= 1) {
+        const W = fe(_);
+        I(p.lessThan(W), () => {
+          l.element(p).addAssign(l.element(p.add(W))), c.element(p).addAssign(c.element(p.add(W)));
+        }), ss();
+      }
+      I(p.greaterThan(0), () => {
+        Oe();
+      });
+      const P = l.element(fe(0)), V = c.element(fe(0));
+      we(
+        this.multipleScattering,
+        G.xy,
+        // This represents the amount of radiance scattered as if the integral
+        // of scattered radiance over the sphere would be 1.
+        // For a power-series, such integral is analytically:
+        // sum_{n=0}^{n=+inf} = 1 + r + r^2 + r^3 + ... + r^n = 1 / (1 - r)
+        v(P.mul(V.oneMinus().reciprocal()), 1)
+      );
+    })().context({ getAtmosphere: () => t }).computeKernel([1, 1, o]).setName("multipleScattering"), e.compute(this.multipleScatteringNode, [n, a, 1]);
+  }
+  computeScattering(e, t) {
+    const { parameters: i } = t, { x: r, y: n, z: a } = i.scatteringTextureSize;
+    this.scatteringNode?.dispose(), this.scatteringNode = O(() => {
+      const o = Hi(r, n, a);
+      I(G.greaterThanEqual(o).any(), () => {
+        Oe();
+      });
+      const u = Js(
+        X(this.transmittance),
+        X(this.multipleScattering),
+        g(G).add(0.5)
+      ).toConst(), l = u.get("scattering"), c = u.get("singleMieScattering");
+      if (i.combinedScatteringTextures ? we(
+        this.scattering,
+        G,
+        v(l, c.r)
+      ) : (we(this.scattering, G, v(l, 1)), we(
+        this.singleMieScattering,
+        G,
+        v(c, 1)
+      )), i.higherOrderScatteringTexture) {
+        const d = u.get("higherOrderScattering");
+        we(
+          this.higherOrderScattering,
+          G,
+          v(d, 1)
+        );
+      }
+    })().context({ getAtmosphere: () => t }).computeKernel([4, 4, 4]).setName("scattering"), e.compute(this.scatteringNode, [
+      Math.ceil(r / 4),
+      Math.ceil(n / 4),
+      Math.ceil(a / 4)
+    ]);
+  }
+  computeIrradiance(e, t) {
+    const { parameters: i } = t, { x: r, y: n } = i.irradianceTextureSize;
+    this.irradianceNode?.dispose(), this.irradianceNode = O(() => {
+      const a = st(r, n);
+      I(G.xy.greaterThanEqual(a).any(), () => {
+        Oe();
+      });
+      const o = Ys(
+        it(this.scattering),
+        it(this.higherOrderScattering),
+        b(G.xy).add(0.5)
+      );
+      we(this.irradiance, G.xy, o);
+    })().context({ getAtmosphere: () => t }).computeKernel([8, 8, 1]).setName("irradiance"), e.compute(this.irradianceNode, [
+      Math.ceil(r / 8),
+      Math.ceil(n / 8),
+      1
+    ]);
+  }
+  setup(e, t) {
+    bt(
+      this.transmittance,
+      t,
+      e.transmittanceTextureSize
+    ), bt(
+      this.multipleScattering,
+      t,
+      e.multipleScatteringTextureSize
+    ), zt(
+      this.scattering,
+      t,
+      e.scatteringTextureSize
+    ), e.combinedScatteringTextures || zt(
+      this.singleMieScattering,
+      t,
+      e.scatteringTextureSize
+    ), e.higherOrderScatteringTexture && zt(
+      this.higherOrderScattering,
+      t,
+      e.scatteringTextureSize
+    ), bt(
+      this.irradiance,
+      t,
+      e.irradianceTextureSize
+    ), super.setup(e, t);
+  }
+  dispose() {
+    this.transmittance.dispose(), this.multipleScattering.dispose(), this.scattering.dispose(), this.singleMieScattering.dispose(), this.higherOrderScattering.dispose(), this.irradiance.dispose(), this.transmittanceNode?.dispose(), this.multipleScatteringNode?.dispose(), this.scatteringNode?.dispose(), this.irradianceNode?.dispose(), super.dispose();
+  }
+}
+class pe {
+  constructor(e = 0, t = 0, i = 0, r = 0, n = 0) {
+    this.width = e, this.expTerm = t, this.expScale = i, this.linearTerm = r, this.constantTerm = n;
+  }
+  copy(e) {
+    return this.width = e.width, this.expTerm = e.expTerm, this.expScale = e.expScale, this.linearTerm = e.linearTerm, this.constantTerm = e.constantTerm, this;
+  }
+  clone() {
+    return new pe().copy(this);
+  }
+}
+class ke {
+  constructor(e) {
+    this.layers = e;
+  }
+  copy(e) {
+    return this.layers = [e.layers[0].clone(), e.layers[1].clone()], this;
+  }
+  clone() {
+    return new ke([this.layers[0].clone(), this.layers[1].clone()]);
+  }
+}
+const Hn = /* @__PURE__ */ new H(0.2126, 0.7152, 0.0722);
+class Qe {
+  constructor() {
+    this.worldToUnit = 1e-3, this.solarIrradiance = new H(1.474, 1.8504, 1.91198), this.sunAngularRadius = 4675e-6, this.bottomRadius = 636e4, this.topRadius = 642e4, this.rayleighDensity = new ke([
+      new pe(),
+      new pe(0, 1, -1 / 8e3)
+    ]), this.rayleighScattering = new H(5802e-9, 13558e-9, 331e-7), this.mieDensity = new ke([
+      new pe(),
+      new pe(0, 1, -1 / 1200)
+    ]), this.mieScattering = new H().setScalar(3996e-9), this.mieExtinction = new H().setScalar(444e-8), this.miePhaseFunctionG = 0.8, this.absorptionDensity = new ke([
+      new pe(25e3, 0, 0, 1 / 15e3, -2 / 3),
+      new pe(0, 0, 0, -1 / 15e3, 8 / 3)
+    ]), this.absorptionExtinction = new H(65e-8, 1881e-9, 85e-9), this.groundAlbedo = new H().setScalar(0.3), this.minCosLight = Math.cos(rt(120)), this.sunRadianceToLuminance = new H(98242.786222, 69954.398112, 66475.012354), this.skyRadianceToLuminance = new H(114974.91644, 71305.954816, 65310.548555), this.luminanceScale = 1 / Hn.dot(this.sunRadianceToLuminance), this.combinedScatteringTextures = !0, this.higherOrderScatteringTexture = !0, this.transmittanceTextureSize = new re(256, 64), this.irradianceTextureSize = new re(64, 16), this.multipleScatteringTextureSize = new re(64, 64), this.scatteringTextureRadiusSize = 32, this.scatteringTextureCosViewSize = 128, this.scatteringTextureCosLightSize = 32, this.scatteringTextureCosViewLightSize = 8, this.scatteringTextureSize = new H(), this.update();
+  }
+  copy(e) {
+    return this.worldToUnit = e.worldToUnit, this.solarIrradiance.copy(e.solarIrradiance), this.sunAngularRadius = e.sunAngularRadius, this.bottomRadius = e.bottomRadius, this.topRadius = e.topRadius, this.rayleighDensity.copy(e.rayleighDensity), this.rayleighScattering.copy(e.rayleighScattering), this.mieDensity.copy(e.mieDensity), this.mieScattering.copy(e.mieScattering), this.mieExtinction.copy(e.mieExtinction), this.miePhaseFunctionG = e.miePhaseFunctionG, this.absorptionDensity.copy(e.absorptionDensity), this.absorptionExtinction.copy(e.absorptionExtinction), this.groundAlbedo.copy(e.groundAlbedo), this.minCosLight = e.minCosLight, this.sunRadianceToLuminance.copy(e.sunRadianceToLuminance), this.skyRadianceToLuminance.copy(e.skyRadianceToLuminance), this.luminanceScale = e.luminanceScale, this.combinedScatteringTextures = e.combinedScatteringTextures, this.transmittanceTextureSize.copy(e.transmittanceTextureSize), this.irradianceTextureSize.copy(e.irradianceTextureSize), this.multipleScatteringTextureSize.copy(e.multipleScatteringTextureSize), this.scatteringTextureRadiusSize = e.scatteringTextureRadiusSize, this.scatteringTextureCosViewSize = e.scatteringTextureCosViewSize, this.scatteringTextureCosLightSize = e.scatteringTextureCosLightSize, this.scatteringTextureCosViewLightSize = e.scatteringTextureCosViewLightSize, this.scatteringTextureSize.copy(e.scatteringTextureSize), this;
+  }
+  update() {
+    return this.scatteringTextureSize.set(
+      this.scatteringTextureCosViewLightSize * this.scatteringTextureCosLightSize,
+      this.scatteringTextureCosViewSize,
+      this.scatteringTextureRadiusSize
+    ), this;
+  }
+  clone() {
+    return new Qe().copy(this);
+  }
+  /** @deprecated Use minCosLight */
+  get minCosSun() {
+    return this.minCosLight;
+  }
+  /** @deprecated Use minCosLight */
+  set minCosSun(e) {
+    this.minCosLight = e;
+  }
+  /** @deprecated Use scatteringTextureCosLightSize */
+  get scatteringTextureCosSunSize() {
+    return this.scatteringTextureCosLightSize;
+  }
+  /** @deprecated Use scatteringTextureCosLightSize */
+  set scatteringTextureCosSunSize(e) {
+    this.scatteringTextureCosLightSize = e;
+  }
+  /** @deprecated Use scatteringTextureCosViewLightSize */
+  get scatteringTextureCosViewSunSize() {
+    return this.scatteringTextureCosViewLightSize;
+  }
+  /** @deprecated Use scatteringTextureCosViewLightSize */
+  set scatteringTextureCosViewSunSize(e) {
+    this.scatteringTextureCosViewLightSize = e;
+  }
+  /** @deprecated This option was removed. */
+  // eslint-disable-next-line @typescript-eslint/class-methods-use-this
+  get transmittancePrecisionLog() {
+    return !1;
+  }
+  /** @deprecated This option was removed. */
+  // eslint-disable-next-line @typescript-eslint/class-methods-use-this
+  set transmittancePrecisionLog(e) {
+  }
+}
+const { resetRendererState: _n, restoreRendererState: Zn } = K;
+async function Kn(s) {
+  const e = s[Symbol.iterator]();
+  return await new Promise((t, i) => {
+    const r = () => {
+      try {
+        const { value: n, done: a } = e.next();
+        a === !0 ? t(n) : ps(r);
+      } catch (n) {
+        i(n instanceof Error ? n : new Error());
+      }
+    };
+    ps(r);
+  });
+}
+let Et;
+function Ye(s, e) {
+  return Et = _n(s, Et), s.setClearColor(0, 0), s.autoClear = !1, e(), Zn(s, Et), !0;
+}
+const At = /* @__PURE__ */ new xr(), Ft = /* @__PURE__ */ (() => {
+  const s = new yr(new Uint8Array(4));
+  return s.format = be, s.needsUpdate = !0, s;
+})(), Qn = { type: "update" };
+class Jn extends pi {
+  constructor(e = new Qe(), t) {
+    super(null), this.textureNodes = {
+      transmittance: Le(this, At),
+      multipleScattering: Le(this, At),
+      scattering: yt(this, Ft),
+      singleMieScattering: yt(this, Ft),
+      higherOrderScattering: yt(this, Ft),
+      irradiance: Le(this, At)
+    }, this.updating = !1, this.updateBeforeType = ee.FRAME, this.parameters = e, this.textureType = t;
+  }
+  static get type() {
+    return "AtmosphereLUTNode";
+  }
+  getTextureNode(e) {
+    return this.textureNodes[e];
+  }
+  dispatchUpdate() {
+    this.dispatchEvent(
+      // @ts-expect-error Cannot specify the events map
+      Qn
+    );
+  }
+  *performCompute(e, t) {
+    const { textures: i } = this;
+    de(i != null), yield Ye(e, () => {
+      i.computeTransmittance(e, t), this.dispatchUpdate();
+    }), yield Ye(e, () => {
+      i.computeMultipleScattering(e, t), this.dispatchUpdate();
+    }), yield Ye(e, () => {
+      i.computeScattering(e, t), this.dispatchUpdate();
+    }), yield Ye(e, () => {
+      i.computeIrradiance(e, t), this.dispatchUpdate();
+    });
+  }
+  async updateTextures(e) {
+    de(this.textures != null);
+    const t = this.textures.createContext();
+    this.updating = !0;
+    try {
+      await Kn(this.performCompute(e, t));
+    } finally {
+      this.updating = !1, t.dispose(), this.disposeQueue?.();
+    }
+  }
+  updateBefore({ renderer: e }) {
+    e == null || this.version === this.currentVersion || (this.currentVersion = this.version, this.updateTextures(e).catch((t) => {
+      throw t instanceof Error ? t : new Error();
+    }));
+  }
+  setup(e) {
+    if (this.textures == null) {
+      this.textures = qt(e) ? new qn() : new Gn();
+      const {
+        transmittance: i,
+        irradiance: r,
+        multipleScattering: n,
+        scattering: a,
+        singleMieScattering: o,
+        higherOrderScattering: u
+      } = this.textureNodes;
+      i.value = this.textures.get("transmittance"), n.value = this.textures.get("multipleScattering"), a.value = this.textures.get("scattering"), o.value = this.textures.get("singleMieScattering"), u.value = this.textures.get("higherOrderScattering"), r.value = this.textures.get("irradiance");
+    }
+    const t = Sr(e.renderer) ? this.textureType ?? lr : Ze;
+    return this.parameters.update(), this.textures.setup(this.parameters, t), super.setup(e);
+  }
+  dispose() {
+    if (this.updating) {
+      this.disposeQueue = () => {
+        this.dispose(), this.disposeQueue = void 0;
+      };
+      return;
+    }
+    this.textures?.dispose(), this.textures = void 0, super.dispose();
+  }
+}
+const Xn = /* @__PURE__ */ new H(), Yn = /* @__PURE__ */ new Ps();
+class ei extends Ht {
+  constructor(e = new Qe(), t = new Jn(e)) {
+    super(e), this.matrixWorldToECEF = w("mat4").setName("matrixWorldToECEF"), this.matrixECIToECEF = w("mat4").setName("matrixECIToECEF"), this.sunDirectionECEF = w("vec3").setName("sunDirectionECEF"), this.moonDirectionECEF = w("vec3").setName("moonDirectionECEF"), this.matrixMoonFixedToECEF = w("mat4").setName("matrixMoonFixedToECEF"), this.scatteringSampleCount = w(new re(4, 14)), this.matrixECEFToWorld = w("mat4").setName("matrixECEFToWorld").onRenderUpdate((i, { value: r }) => {
+      r.copy(this.matrixWorldToECEF.value).transpose();
+    }), this.cameraPositionECEF = w("vec3").setName("cameraPositionECEF").onRenderUpdate((i, { value: r }) => {
+      const n = this.camera ?? i.camera;
+      n != null && r.setFromMatrixPosition(n.matrixWorld).applyMatrix4(this.matrixWorldToECEF.value);
+    }), this.altitudeCorrectionECEF = w("vec3").setName("altitudeCorrectionECEF").onRenderUpdate((i, { value: r }) => {
+      const n = this.camera ?? i.camera;
+      n != null && fn(
+        r.setFromMatrixPosition(n.matrixWorld).applyMatrix4(this.matrixWorldToECEF.value),
+        this.parameters.bottomRadius,
+        this.ellipsoid,
+        r
+      );
+    }), this.cameraHeight = w(0).setName("cameraHeight").onRenderUpdate((i, r) => {
+      const n = this.camera ?? i.camera;
+      if (n == null)
+        return;
+      const a = Xn.setFromMatrixPosition(n.matrixWorld).applyMatrix4(this.matrixWorldToECEF.value);
+      r.value = Yn.setFromECEF(a).height;
+    }), this.cameraPositionUnit = this.cameraPositionECEF.mul(this.parametersNode.worldToUnit).toConst("cameraPositionUnit"), this.altitudeCorrectionUnit = this.altitudeCorrectionECEF.mul(this.parametersNode.worldToUnit).toConst("altitudeCorrectionUnit"), this.ellipsoid = Bs.WGS84, this.correctAltitude = !0, this.constrainCamera = !0, this.showGround = !0, this.accurateShadowScattering = !0, this.raymarchScattering = !0, this.lutNode = t;
+  }
+  dispose() {
+    this.lutNode.dispose(), super.dispose();
+  }
+}
+function ae(s) {
+  if (typeof s.context.getAtmosphere != "function")
+    throw new Error("getAtmosphere() was not found in the builder context.");
+  const e = s.context.getAtmosphere();
+  if (!(e instanceof ei))
+    throw new Error(
+      "getAtmosphere() must return an instanceof AtmosphereContext."
+    );
+  return e;
+}
+O((s) => {
+  const { parametersNode: e } = ae(s), { worldToUnit: t } = e;
+  return Cs.z.mul(t);
+}).once()().toVar("viewZUnit");
+const ea = (s, e, t, i, r, n) => {
+  const a = ht(
+    s,
+    $(
+      n.pow2().add(te(2, e, t, n)).add(e.pow2())
+    )
+  ).toConst(), o = e.mul(t).add(n).div(a).toConst(), u = e.mul(i).add(n.mul(r)).div(a).toConst();
+  return {
+    radius: a,
+    cosView: o,
+    cosLight: u
+  };
+}, ta = /* @__PURE__ */ L(
+  (s, e, t, i, r) => {
+    const { lutNode: n, parametersNode: a } = s, o = n.getTextureNode("transmittance"), u = n.getTextureNode("scattering"), l = n.getTextureNode(
+      "singleMieScattering"
+    ), { topRadius: c, bottomRadius: d, miePhaseFunctionG: h } = a, m = e.length().toVar();
+    e = e.toVar(), s.constrainCamera && I(m.lessThan(d), () => {
+      m.assign(d), e.assign(e.normalize().mul(m));
+    });
+    const p = e.dot(t).toVar(), x = p.negate().sub(
+      ve(p.pow2().sub(m.pow2()).add(c.pow2()))
+    ).toConst();
+    i = i.toVar(), I(x.greaterThan(0), () => {
+      e.assign(e.add(t.mul(x))), m.assign(c), p.addAssign(x), i.y.assign(i.y.sub(x).max(0));
+    });
+    const y = g(0).toVar(), T = g(1).toVar();
+    return I(m.lessThanEqual(c), () => {
+      const S = p.div(m).toConst(), M = e.dot(r).div(m).toConst(), C = t.dot(r).toConst(), N = Ws(
+        a,
+        m,
+        S
+      ).toVar();
+      T.assign(
+        N.select(
+          0,
+          Fe(
+            o,
+            m,
+            S
+          )
+        )
+      ), s.showGround || N.assign(Ve(!1));
+      const f = g(0).toVar(), z = g(0).toVar(), F = (B) => {
+        const Te = ea(
+          a,
+          m,
+          S,
+          M,
+          C,
+          B
+        ), ze = tt(
+          a,
+          u,
+          l,
+          Te.radius,
+          Te.cosView,
+          Te.cosLight,
+          C,
+          N
+        ).toConst(), me = bn(
+          o,
+          m,
+          S,
+          B,
+          N
+        );
+        return {
+          S: ze.get("scattering"),
+          M: ze.get("singleMieScattering"),
+          T: me
+        };
+      }, P = i.y.add(i.x).toConst(), V = () => {
+        const B = F(i.x);
+        f.assign(B.T.mul(B.S)), z.assign(B.T.mul(B.M));
+      }, _ = () => {
+        const B = tt(
+          a,
+          u,
+          l,
+          m,
+          S,
+          M,
+          C,
+          N
+        ).toConst(), Te = B.get("scattering"), ze = B.get("singleMieScattering"), me = F(i.y), le = F(P);
+        f.assign(Te.sub(me.T.mul(me.S).sub(le.T.mul(le.S)).max(0))), z.assign(ze.sub(me.T.mul(me.M).sub(le.T.mul(le.M)).max(0)));
+      }, W = I(i.x.equal(0), () => {
+        const B = tt(
+          a,
+          u,
+          l,
+          m,
+          S,
+          M,
+          C,
+          N
+        ).toConst();
+        f.assign(B.get("scattering")), z.assign(
+          B.get("singleMieScattering")
+        );
+      });
+      s.accurateShadowScattering ? W.Else(_) : W.Else(V);
+      let Q = g(0);
+      if (s.parameters.higherOrderScatteringTexture) {
+        const B = n.getTextureNode(
+          "higherOrderScattering"
+        );
+        Q = _s(
+          B,
+          m,
+          S,
+          M,
+          C,
+          N
+        );
+      }
+      const ue = _t(C), Ie = qs(h, C);
+      y.assign(
+        f.mul(ue).add(z.mul(Ie)).add(Q)
+      );
+    }), Dn(y, T);
+  }
+), sa = /* @__PURE__ */ L(
+  (s, e, t, i) => {
+    const { lutNode: r } = s, n = r.getTextureNode("irradiance"), a = e.length().toConst(), o = e.dot(i).div(a).toConst();
+    return En(n, a, o).mul(
+      t.dot(e).div(a).add(1).mul(0.5)
+    );
+  }
+), ia = /* @__PURE__ */ L(
+  () => (s) => {
+    const e = oe(s), { parametersNode: t } = e, {
+      solarIrradiance: i,
+      sunAngularRadius: r,
+      sunRadianceToLuminance: n,
+      luminanceScale: a
+    } = t;
+    return i.div(qe.mul(r.pow2())).mul(n.mul(a));
+  }
+), ra = /* @__PURE__ */ Y(
+  {
+    luminance: Os,
+    transmittance: Se
+  },
+  "LuminanceTransfer"
+), fs = /* @__PURE__ */ L(
+  (s, e, t, i) => (r) => {
+    const n = ae(r), { parametersNode: a } = n, { skyRadianceToLuminance: o, luminanceScale: u } = a, l = ta(
+      n,
+      s,
+      e,
+      t,
+      i
+    ), c = l.get("radiance").mul(o.mul(u));
+    return ra(
+      c,
+      l.get("transmittance")
+    );
+  }
+), na = /* @__PURE__ */ L(
+  (s, e, t) => (i) => {
+    const r = ae(i), { parametersNode: n } = r, { skyRadianceToLuminance: a, luminanceScale: o } = n;
+    return sa(
+      r,
+      s,
+      e,
+      t
+    ).mul(a.mul(o));
+  }
+), aa = /* @__PURE__ */ R({
+  name: "getLunarRadiance",
+  type: Os,
+  inputs: [
+    { name: "parameters", type: q },
+    { name: "moonAngularRadius", type: "float" }
+  ]
+})(([s, e]) => {
+  const { solarIrradiance: t, sunRadianceToLuminance: i, luminanceScale: r } = j(s);
+  return t.mul(25e-7).div(qe.mul(e.pow2())).mul(i.mul(r));
+}), oa = /* @__PURE__ */ R({
+  name: "raySphereIntersectionNormal",
+  type: "vec3",
+  inputs: [
+    { name: "rayDirection", type: "vec3" },
+    { name: "centerDirection", type: "vec3" },
+    { name: "angularRadius", type: "float" }
+  ]
+})(([s, e, t]) => {
+  const i = e.dot(s), r = e.sub(s.mul(i)).negate().toConst(), n = $(t.pow2().sub(r.dot(r)).max(0));
+  return r.sub(s.mul(n)).div(t);
+}), ua = /* @__PURE__ */ R({
+  name: "orenNayarDiffuse",
+  type: "float",
+  inputs: [
+    { name: "lightDirection", type: "vec3" },
+    { name: "viewDirection", type: "vec3" },
+    { name: "normal", type: "vec3" }
+  ]
+})(([s, e, t]) => {
+  const i = t.dot(s).toConst(), r = t.dot(e).toConst(), n = s.dot(e).sub(i.mul(r)).toConst(), a = he(1, Re(i, r).max(0.1), n.smoothstep(0, 0.1)), o = 1 / Math.PI * (1 - 0.5 * (1 / 1.33) + 0.17 * (1 / 1.13)), u = 1 / Math.PI * (0.45 * (1 / 1.09));
+  return i.max(0).mul(n.div(a).mul(u).add(o));
+});
+class la extends se {
+  constructor() {
+    super("vec4"), this.angularRadius = w(45e-4), this.intensity = w(1), this.displacementScale = w(65535 * 0.5 / 1727400);
+  }
+  static get type() {
+    return "MoonNode";
+  }
+  setup(e) {
+    const t = ae(e), { rayDirectionECEF: i } = this;
+    if (i == null)
+      return;
+    const {
+      sunDirectionECEF: r,
+      moonDirectionECEF: n,
+      matrixMoonFixedToECEF: a
+    } = t;
+    return O(() => {
+      const o = ne(this.angularRadius).oneMinus().mul(2), u = i.sub(n), l = u.dot(u), c = Fs(l), d = b().toVar(), h = g().toVar(), m = g().toVar();
+      I(l.lessThan(o), () => {
+        h.assign(
+          oa(
+            i,
+            n,
+            this.angularRadius
+          )
+        ), m.assign(
+          a.transpose().mul(v(h, 0)).xyz
+        ), d.assign(Ji(m.xzy));
+      });
+      const p = is(d).toConst(), x = rs(d).toConst(), y = is(m).toConst(), T = rs(m).toConst(), S = v(0).toVar();
+      return I(l.lessThan(o), () => {
+        if (this.displacementNode != null) {
+          const f = this.displacementNode.sample(d.add(p)).x, z = this.displacementNode.sample(d.sub(p)).x, F = this.displacementNode.sample(d.add(x)).x, P = this.displacementNode.sample(d.sub(x)).x, V = f.sub(z).mul(0.5), _ = F.sub(P).mul(0.5), W = T.cross(m).toConst(), Q = m.cross(y).toConst(), ue = y.dot(W).toConst(), Ie = W.mul(V).add(Q.mul(_)).mul(ue.sign()), B = m.mul(ue.abs()).sub(Ie.mul(this.displacementScale)).normalize();
+          m.assign(
+            he(
+              m,
+              B,
+              // Avoid artifact at the edge:
+              h.dot(i.negate()).smoothstep(0, 0.3)
+            )
+          ), h.assign(a.mul(v(m, 0)).xyz);
+        }
+        const M = this.colorNode?.sample(d).xyz ?? 1, C = ua(
+          r,
+          i.negate(),
+          h
+        ), N = ut(
+          o,
+          o.sub(c),
+          l
+        );
+        S.assign(
+          v(
+            aa(
+              t.parametersNode,
+              this.angularRadius
+            ).mul(this.intensity).mul(M).mul(C),
+            N
+          )
+        );
+      }), S;
+    })();
+  }
+}
+const { resetRendererState: ca, restoreRendererState: da } = K;
+function ha() {
+  const s = new wi(1, 1, {
+    depthBuffer: !1,
+    type: Ze,
+    format: be
+  }), e = s.texture;
+  return e.minFilter = Z, e.magFilter = Z, e.generateMipmaps = !1, e.name = "Stars", s;
+}
+const ma = R({
+  name: "log10",
+  type: "float",
+  inputs: [{ name: "x", type: "float" }]
+})(([s]) => qi(s).mul(1 / Math.log(10))), pa = /* @__PURE__ */ L(
+  (s, e) => {
+    const t = s.add(ma(e.mul(425e8)).mul(2.5)).toConst();
+    return Vs(10, t.mul(-0.4)).mul(108e3);
+  }
+), ga = /* @__PURE__ */ new re();
+class xa extends se {
+  constructor(e = Tn) {
+    super("vec3"), this.pointSize = w(1), this.intensity = w(1e3), this.magnitudeRange = w(new re(-2, 8)), this.material = new Ti(), this.points = new gr(this.material), this.updateBeforeType = ee.FRAME, this.material.name = "Stars", this.data = e, this.renderTarget = ha(), this.textureNode = Le(this, this.renderTarget.texture);
+  }
+  static get type() {
+    return "StarsNode";
+  }
+  getTextureNode() {
+    return this.textureNode;
+  }
+  setSize(e, t) {
+    return this.renderTarget.setSize(e, t), this;
+  }
+  updateBefore(e) {
+    const { renderer: t } = e, i = this.camera ?? e.camera;
+    if (t == null || i == null)
+      return;
+    const r = t.getDrawingBufferSize(ga);
+    this.setSize(r.x, r.y), this.rendererState = ca(t, this.rendererState), this.points.position.copy(i.position), t.setRenderTarget(this.renderTarget), t.render(this.points, i), da(t, this.rendererState);
+  }
+  createBuffers(e) {
+    const t = e.byteLength / 10, i = new Float32Array(t * 3), r = new Float32Array(t), n = new Float32Array(t * 3), a = new Int16Array(e), o = new Uint8Array(e);
+    for (let u = 0, l = 0, c = 0, d = 0; u < t; ++u, l += 3, c += 5, d += 10)
+      i[l + 0] = a[c + 0] / 32767, i[l + 1] = a[c + 1] / 32767, i[l + 2] = a[c + 2] / 32767, r[u] = o[d + 6] / 255, n[l + 0] = o[d + 7] / 255, n[l + 1] = o[d + 8] / 255, n[l + 2] = o[d + 9] / 255;
+    this.positionBuffer = new pt(i, 3), this.magnitudeBuffer = new pt(r, 1), this.colorBuffer = new pt(n, 3), this.points.count = t;
+  }
+  setupMaterial(e) {
+    const t = ae(e), i = t.camera ?? e.camera;
+    if (i == null)
+      return;
+    const { material: r, positionBuffer: n, magnitudeBuffer: a, colorBuffer: o } = this;
+    de(n != null), de(a != null), de(o != null);
+    const u = mt(n, "vec3"), l = mt(a, "float"), c = mt(o, "vec3"), { matrixECIToECEF: d, matrixECEFToWorld: h, parametersNode: m } = t, { luminanceScale: p } = m, x = d.mul(v(u, 0)).xyz, y = h.mul(v(x, 0)).xyz;
+    r.positionNode = y.mul(
+      je(i).add(Ge(i)).mul(0.5)
+    );
+    const T = he(
+      this.magnitudeRange.x,
+      this.magnitudeRange.y,
+      l.x
+    ), S = this.pointSize.mul(2).div(Xi.y.mul(Mr(i)[1][1])).pow2(), M = pa(T, S);
+    r.colorNode = M.mul(p).mul(c).mul(this.intensity).toVertexStage(), r.needsUpdate = !0;
+  }
+  setup(e) {
+    typeof this.data == "string" ? this.dataPromise ??= new Cr().loadAsync(this.data).then((r) => {
+      this.createBuffers(r), this.setupMaterial(e);
+    }).catch((r) => {
+      console.error(r);
+    }) : (this.createBuffers(this.data), this.setupMaterial(e));
+    const { material: t } = this;
+    t.sizeNode = this.pointSize, t.sizeAttenuation = !1, t.depthTest = !1, t.depthWrite = !1, t.transparent = !0, t.blending = Ls, t.needsUpdate = !0, this.points.frustumCulled = !1;
+    const i = ae(e);
+    return this.camera = i.camera, this.textureNode.uvNode = Ns, this.textureNode;
+  }
+  dispose() {
+    this.renderTarget.dispose(), this.material.dispose(), super.dispose();
+  }
+}
+class ya extends se {
+  constructor() {
+    super("vec4"), this.angularRadius = w(4675e-6), this.intensity = w(1);
+  }
+  static get type() {
+    return "SunNode";
+  }
+  setup(e) {
+    const t = ae(e), { rayDirectionECEF: i } = this;
+    if (i == null)
+      return;
+    const { sunDirectionECEF: r } = t;
+    return O(() => {
+      const n = ne(this.angularRadius).oneMinus().mul(2), a = i.sub(r), o = a.dot(a), u = Fs(o), l = v(0).toVar();
+      return I(o.lessThan(n), () => {
+        const c = ut(
+          n,
+          n.sub(u),
+          o
+        );
+        l.assign(
+          v(ia().mul(this.intensity), c)
+        );
+      }), l;
+    })();
+  }
+}
+const Ta = (s) => {
+  const e = Rr(s).mul(
+    v(It, 1)
+  ).xyz;
+  return br(s).mul(
+    v(e, 0)
+  ).xyz;
+}, Ut = "CAMERA", ti = "EQUIRECTANGULAR";
+class si extends se {
+  constructor(e, t) {
+    super("vec3"), this.scope = Ut, this.showSun = !0, this.showMoon = !0, this.showStars = !0, this.moonScattering = !1, this.useContextCamera = !0, this.scope = e, this.shadowLengthNode = t, this.sunNode = new ya(), this.moonNode = new la(), this.starsNode = new xa();
+  }
+  static get type() {
+    return "SkyNode";
+  }
+  customCacheKey() {
+    return Gt(
+      +this.showSun,
+      +this.showMoon,
+      +this.showStars,
+      +this.moonScattering,
+      +this.useContextCamera
+    );
+  }
+  setup(e) {
+    const t = ae(e), {
+      matrixWorldToECEF: i,
+      sunDirectionECEF: r,
+      moonDirectionECEF: n,
+      cameraPositionUnit: a,
+      altitudeCorrectionUnit: o
+    } = t;
+    let u;
+    switch (this.scope) {
+      case Ut: {
+        u = Ta(
+          this.useContextCamera ? t.camera : null
+        );
+        break;
+      }
+      case ti:
+        u = nn(Me());
+        break;
+    }
+    if (u != null)
+      return O(() => {
+        const l = i.mul(v(u, 0)).xyz.toVertexStage().normalize().toConst(), c = fs(
+          a.add(o),
+          l,
+          this.shadowLengthNode ?? b(0),
+          r
+        ).toConst(), d = c.get("transmittance");
+        let h = c.get("luminance");
+        if (this.moonScattering) {
+          const p = fs(
+            a.add(o),
+            l,
+            this.shadowLengthNode ?? b(0),
+            n
+          );
+          h = h.add(
+            p.get("luminance").mul(25e-7)
+          );
+        }
+        const m = g(0).toVar();
+        if (this.showStars && m.addAssign(this.starsNode), this.showSun) {
+          const { sunNode: p } = this;
+          p.rayDirectionECEF = l, m.assign(he(m, p.rgb, p.a));
+        }
+        if (this.showMoon) {
+          const { moonNode: p } = this;
+          p.rayDirectionECEF = l, m.assign(he(m, p.rgb, p.a));
+        }
+        return m.mul(d).add(h);
+      })();
+  }
+}
+const wa = /* @__PURE__ */ As(si, Ut), fa = /* @__PURE__ */ As(si, ti);
+class Ss extends hr {
+  constructor(e = 1, t = "sun") {
+    super(), this.type = "AtmosphereLight", this.direct = w(!0), this.indirect = w(!0), this.distance = e, this.body = t;
+  }
+}
+const Sa = /* @__PURE__ */ new dr();
+class va extends yi {
+  constructor(e) {
+    super(e), this.intensity = w(1), this.directionECEF = w("vec3"), this.updateBeforeType = ee.FRAME;
+  }
+  static get type() {
+    return "AtmosphereLightNode";
+  }
+  updateBefore(e) {
+    const { light: t, atmosphereContext: i } = this;
+    if (t == null || i == null)
+      return;
+    const { matrixECEFToWorld: r } = i;
+    t.position.copy(this.directionECEF.value).applyMatrix3(Sa.setFromMatrix4(r.value)).multiplyScalar(t.distance).add(t.target.position);
+  }
+  update(e) {
+    super.update(e);
+    const { light: t, atmosphereContext: i } = this;
+    if (!(t == null || i == null))
+      switch (t.body) {
+        case "sun":
+          this.intensity.value = t.intensity, this.directionECEF.value.copy(i.sunDirectionECEF.value);
+          break;
+        case "moon":
+          this.intensity.value = t.intensity * 25e-7, this.directionECEF.value.copy(i.moonDirectionECEF.value);
+          break;
+      }
+  }
+  setup(e) {
+    return this.atmosphereContext = ae(e), super.setup(e);
+  }
+  setupDirect(e) {
+    const { light: t, atmosphereContext: i } = this;
+    if (t == null || i == null)
+      return;
+    const { intensity: r, directionECEF: n } = this, { direct: a, indirect: o } = t, {
+      worldToUnit: u,
+      solarIrradiance: l,
+      sunRadianceToLuminance: c,
+      luminanceScale: d
+    } = i.parametersNode, { matrixWorldToECEF: h, matrixECEFToWorld: m, altitudeCorrectionECEF: p } = i, x = h.mul(v(_i, 0)).xyz;
+    let y = h.mul(v(Zi, 1)).xyz;
+    i.correctAltitude && (y = y.add(p));
+    const T = y.mul(u).toConst(), S = na(
+      T,
+      x,
+      n
+    ).mul(o.select(1, 0));
+    e.context.irradiance.addAssign(S.mul(r));
+    const M = m.mul(v(n, 0)).xyz, C = Ki.mul(v(M, 0)).xyz, N = T.length().toConst(), f = T.dot(n).div(N), z = at(
+      i.lutNode.getTextureNode("transmittance"),
+      N,
+      f
+    ), F = l.mul(z).mul(c.mul(d)).mul(r).mul(a.select(1, 0));
+    return {
+      lightDirection: C,
+      lightColor: F.mul(this.colorNode)
+    };
+  }
+}
+const { resetRendererState: _a, restoreRendererState: Za } = K, { resetRendererState: Ka, restoreRendererState: Qa } = K, { resetRendererState: Ja, restoreRendererState: Xa } = K, { resetRendererState: Ya, restoreRendererState: eo } = K, { resetRendererState: to, restoreRendererState: so } = K, { resetRendererState: io, restoreRendererState: ro } = K;
+class Ca extends se {
+  constructor(e = 64) {
+    super("vec3"), this.distanceThreshold = 1e3, this.angularThreshold = rt(0.1), this.material = new Ce(), this.mesh = new Ds(new vr(), this.material), this.updateBeforeType = ee.FRAME, this.material.name = "SkyEnvironment", this.skyNode = wa(), this.skyNode.showSun = !1, this.skyNode.showMoon = !1, this.skyNode.showStars = !1, this.skyNode.useContextCamera = !1, this.renderTarget = new mr(e, {
+      depthBuffer: !1,
+      type: Ze,
+      format: be
+    }), this.cubeCamera = new pr(0.1, 1e3, this.renderTarget);
+  }
+  static get type() {
+    return "SkyEnvironmentNode";
+  }
+  updateBefore({ renderer: e }) {
+    e == null || this.version === this.currentVersion || (this.currentVersion = this.version, this.cubeCamera.update(e, this.mesh));
+  }
+  setup(e) {
+    const t = ae(e), { camera: i } = t;
+    if (i != null) {
+      const o = new H(), u = new H();
+      xt(() => {
+        o.copy(i.position).divideScalar(this.distanceThreshold).round(), u.equals(o) || (u.copy(o), this.needsUpdate = !0);
+      });
+    }
+    const r = t.sunDirectionECEF.value.clone();
+    xt(() => {
+      const { value: o } = t.sunDirectionECEF;
+      r.angleTo(o) > this.angularThreshold && (r.copy(o), this.needsUpdate = !0);
+    });
+    const n = t.moonDirectionECEF.value.clone();
+    xt(() => {
+      const { value: o } = t.moonDirectionECEF;
+      n.angleTo(o) > this.angularThreshold && (n.copy(o), this.needsUpdate = !0);
+    });
+    const a = () => {
+      this.needsUpdate = !0;
+    };
+    return t.lutNode.addEventListener(
+      // @ts-expect-error Cannot specify the events map
+      "update",
+      a
+    ), this.removeLUTUpdateListener?.(), this.removeLUTUpdateListener = () => {
+      t.lutNode.removeEventListener(
+        // @ts-expect-error Cannot specify the events map
+        "update",
+        a
+      );
+    }, this.material.vertexNode = v(It.xy, 0, 1), this.material.fragmentNode = this.skyNode, Qi(this.renderTarget.texture);
+  }
+  dispose() {
+    this.removeLUTUpdateListener?.(), this.renderTarget.dispose(), this.skyNode.dispose(), this.material.dispose(), this.mesh.geometry.dispose(), super.dispose();
+  }
+}
+const Na = (...s) => new Ca(...s), Ma = He(
+  g(1.6605, -0.1246, -0.0182),
+  g(-0.5876, 1.1329, -0.1006),
+  g(-0.0728, -83e-4, 1.1187)
+), Ra = He(
+  g(0.6274, 0.0691, 0.0164),
+  g(0.3293, 0.9195, 0.088),
+  g(0.0433, 0.0113, 0.8956)
+), ba = L((s) => {
   const e = s.pow2().toConst(), t = e.pow2().toConst();
-  return E(
+  return k(
     t.mul(e).mul(15.5),
     t.mul(s).mul(-40.14),
     t.mul(31.96),
@@ -23,15 +3149,15 @@ const q = u(
     s.mul(0.1191),
     -232e-5
   );
-}), K = u(
-  i(0.856627153315983, 0.137318972929847, 0.11189821299995),
-  i(0.0951212405381588, 0.761241990602591, 0.0767994186031903),
-  i(0.0482516061458583, 0.101439036467562, 0.811302368396859)
-), Q = u(
-  i(1.1271005818144368, -0.1413297634984383, -0.14132976349843826),
-  i(-0.11060664309660323, 1.157823702216272, -0.11060664309660294),
-  i(-0.016493938717834573, -0.016493938717834257, 1.2519364065950405)
-), f = -12.47393, Y = 4.026069, Z = p({
+}), za = He(
+  g(0.856627153315983, 0.137318972929847, 0.11189821299995),
+  g(0.0951212405381588, 0.761241990602591, 0.0767994186031903),
+  g(0.0482516061458583, 0.101439036467562, 0.811302368396859)
+), Ea = He(
+  g(1.1271005818144368, -0.1413297634984383, -0.14132976349843826),
+  g(-0.11060664309660323, 1.157823702216272, -0.11060664309660294),
+  g(-0.016493938717834573, -0.016493938717834257, 1.2519364065950405)
+), vs = -12.47393, Aa = 4.026069, Fa = R({
   name: "agx",
   type: "vec3",
   inputs: [
@@ -39,16 +3165,16 @@ const q = u(
     { name: "exposure", type: "float" }
   ]
 })(([s, e]) => {
-  const t = s.toVar(), n = e;
-  return t.mulAssign(n), t.assign(X.mul(t)), t.assign(K.mul(t)), t.assign(S(t.max(1e-10))), t.assign(t.sub(f).div(c(Y).sub(f))), t.assign(t.saturate()), t.assign(J(t)), t;
-}), $ = p({
+  const t = s.toVar(), i = e;
+  return t.mulAssign(i), t.assign(Ra.mul(t)), t.assign(za.mul(t)), t.assign(Yi(t.max(1e-10))), t.assign(t.sub(vs).div(A(Aa).sub(vs))), t.assign(t.saturate()), t.assign(ba(t)), t;
+}), Va = R({
   name: "agxEOTF",
   type: "vec3",
   inputs: [{ name: "color", type: "vec3" }]
 })(([s]) => {
   const e = s.toVar();
-  return e.assign(Q.mul(e)), e.assign(T(e.max(0), c(2.2))), e.assign(q.mul(e)), e.assign(e.saturate()), e;
-}), ee = p({
+  return e.assign(Ea.mul(e)), e.assign(Vs(e.max(0), A(2.2))), e.assign(Ma.mul(e)), e.assign(e.saturate()), e;
+}), La = R({
   name: "agxPunchyToneMapping",
   type: "vec3",
   inputs: [
@@ -56,14 +3182,14 @@ const q = u(
     { name: "exposure", type: "float" }
   ]
 })(([s, e]) => {
-  const t = s.toVar(), n = e;
-  return t.assign(Z(t, n.mul(1.5))), t.assign(F(t, i(1), i(0), i(1.35), c(1.2))), t.assign($(t)), t;
-}), N = 100;
-function l() {
+  const t = s.toVar(), i = e;
+  return t.assign(Fa(t, i.mul(1.5))), t.assign(er(t, g(1), g(0), g(1.35), A(1.2))), t.assign(Va(t)), t;
+}), ii = 100;
+function Vt() {
   const s = /* @__PURE__ */ new Date();
   return s.setHours(8, 0, 0, 0), s;
 }
-const te = {
+const Da = {
   longitude: 0,
   latitude: 0,
   height: 0,
@@ -81,7 +3207,7 @@ const te = {
   lensFlare: !0,
   temporalAntialias: !0,
   dithering: !0,
-  toneMapping: N,
+  toneMapping: ii,
   toneMappingExposure: 3,
   castShadow: !0,
   shadowMapSize: 4096,
@@ -93,28 +3219,28 @@ const te = {
   shadowRadius: 1.5,
   shadowDistance: 3e3
 };
-class he {
+class no {
   viewer;
   #r = !1;
   #e = {
-    ...te,
-    date: l()
+    ...Da,
+    date: Vt()
   };
-  #c = null;
-  #i = null;
-  #t = null;
+  #h = null;
   #s = null;
+  #t = null;
+  #i = null;
   #n = null;
-  #h = null;
-  #d = null;
-  #a = [];
   #u = null;
+  #l = null;
+  #a = [];
+  #c = null;
   #g;
-  #p;
-  #v = !1;
-  #l = !1;
-  #w = new M();
-  #m = new m();
+  #m;
+  #x = !1;
+  #d = !1;
+  #y = new fi();
+  #p = new Xt();
   constructor(e) {
     this.viewer = e;
   }
@@ -122,179 +3248,179 @@ class he {
     return this.#r;
   }
   get context() {
-    return this.#i;
+    return this.#s;
   }
   get light() {
     return this.#t;
   }
   enable(e = {}) {
-    return this.#r ? this.update(e) : (this.#e = this.#f(e), this.#c = new V(), this.#i = new _(this.#c), this.#i.camera = this.viewer.camera, this.#E(), this.#R(), this.#D(), this.#L(), this.#k(), this.#O(), this.#B(), this.#V(), this.updateDate(this.#e.date), this.#M(), this.#r = !0, this.viewer.render(), this);
+    return this.#r ? this.update(e) : (this.#e = this.#T(e), this.#h = new Qe(), this.#s = new ei(this.#h), this.#s.camera = this.viewer.camera, this.#w(), this.#F(), this.#V(), this.#L(), this.#D(), this.#P(), this.#U(), this.#O(), this.updateDate(this.#e.date), this.#N(), this.#r = !0, this.viewer.render(), this);
   }
   update(e = {}) {
-    return this.#e = this.#f(e), this.#i ? (this.#E(), this.#C(), this.#y(), this.#N(), this.#S(), this.#U(), this.updateDate(this.#e.date), this.#M(), this.viewer.render(), this) : this;
+    return this.#e = this.#T(e), this.#s ? (this.#w(), this.#v(), this.#C(), this.#f(), this.#M(), this.#B(), this.updateDate(this.#e.date), this.#N(), this.viewer.render(), this) : this;
   }
-  setLocation(e, t, n = this.#e.height) {
-    return this.update({ longitude: e, latitude: t, height: n });
+  setLocation(e, t, i = this.#e.height) {
+    return this.update({ longitude: e, latitude: t, height: i });
   }
   setDate(e) {
     return this.updateDate(e);
   }
-  updateDate(e = l()) {
-    return this.#e.date = e, this.#b(), this.viewer.render(), this;
+  updateDate(e = Vt()) {
+    return this.#e.date = e, this.#z(), this.viewer.render(), this;
   }
   disable() {
-    return this.#r ? (this.#I(), this.#_(), this.viewer.renderPipeline.removeOutputEffect(this.#o), this.#T(), this.#o.includesTemporalAntialias = !1, this.viewer.renderPipeline.needsUpdate = !0, this.#F(), this.#t && (this.#t.target.removeFromParent(), this.#t.removeFromParent(), this.#t.dispose(), this.#t = null), this.viewer.scene.backgroundNode = this.#g, this.viewer.scene.environmentNode = this.#p, this.#u && (this.viewer.renderer.contextNode = this.#u, this.#u = null), this.viewer.renderer.highPrecision = this.#v, this.#i?.dispose(), this.#i = null, this.#c = null, this.#s = null, this.#n = null, this.#r = !1, this.viewer.render(), this) : this;
+    return this.#r ? (this.#I(), this.#k(), this.viewer.renderPipeline.removeOutputEffect(this.#o), this.#R(), this.#o.includesTemporalAntialias = !1, this.viewer.renderPipeline.needsUpdate = !0, this.#b(), this.#t && (this.#t.target.removeFromParent(), this.#t.removeFromParent(), this.#t.dispose(), this.#t = null), this.viewer.scene.backgroundNode = this.#g, this.viewer.scene.environmentNode = this.#m, this.#c && (this.viewer.renderer.contextNode = this.#c, this.#c = null), this.viewer.renderer.highPrecision = this.#x, this.#s?.dispose(), this.#s = null, this.#h = null, this.#i = null, this.#n = null, this.#r = !1, this.viewer.render(), this) : this;
   }
   dispose() {
     return this.disable();
   }
-  #f(e) {
+  #T(e) {
     return {
       ...this.#e,
       ...e,
-      date: e.date ?? (this.#r ? this.#e.date : l())
+      date: e.date ?? (this.#r ? this.#e.date : Vt())
     };
   }
-  #E() {
-    if (!this.#i)
+  #w() {
+    if (!this.#s)
       return;
-    const t = new H(
-      w(this.#e.longitude),
-      w(this.#e.latitude),
+    const t = new Ps(
+      rt(this.#e.longitude),
+      rt(this.#e.latitude),
       this.#e.height
-    ).toECEF(new m());
-    j.WGS84.getNorthUpEastFrame(t, this.#w), this.#i.camera = this.viewer.camera, this.#i.showGround = this.#e.showGround, this.#i.raymarchScattering = this.#e.raymarchScattering, this.#i.matrixWorldToECEF.value.copy(this.#w);
+    ).toECEF(new Xt());
+    Bs.WGS84.getNorthUpEastFrame(t, this.#y), this.#s.camera = this.viewer.camera, this.#s.showGround = this.#e.showGround, this.#s.raymarchScattering = this.#e.raymarchScattering, this.#s.matrixWorldToECEF.value.copy(this.#y);
   }
-  #R() {
-    if (!this.#i)
+  #F() {
+    if (!this.#s)
       return;
     const e = this.viewer.renderer;
-    this.#u = e.contextNode, this.#v = e.highPrecision, e.highPrecision = !0, e.contextNode = b({
+    this.#c = e.contextNode, this.#x = e.highPrecision, e.highPrecision = !0, e.contextNode = tr({
       ...e.contextNode.value,
-      getAtmosphere: () => this.#i
+      getAtmosphere: () => this.#s
     });
   }
-  #D() {
+  #V() {
     const e = this.viewer.renderer;
-    e.library.addLight(G, v), e.shadowMap.enabled = !0, this.#t = new v(), this.#N(), this.viewer.scene.add(this.#t.target), this.#x(), this.viewer.scene.add(this.#t);
+    e.library.addLight(va, Ss), e.shadowMap.enabled = !0, this.#t = new Ss(), this.#f(), this.viewer.scene.add(this.#t.target), this.#S(), this.viewer.scene.add(this.#t);
   }
-  #N() {
+  #f() {
     if (!this.#t)
       return;
     const {
       castShadow: e,
       shadowMapSize: t,
-      shadowCameraSize: n,
+      shadowCameraSize: i,
       shadowCameraNear: r,
-      shadowCameraFar: h,
+      shadowCameraFar: n,
       shadowBias: a,
-      shadowNormalBias: x,
-      shadowRadius: C,
-      shadowDistance: y
-    } = this.#e, d = n / 2, o = this.#t.shadow.camera;
-    this.#t.castShadow = e, this.#t.distance = y, this.#t.shadow.mapSize.setScalar(t), this.#t.shadow.bias = a, this.#t.shadow.normalBias = x, this.#t.shadow.radius = C, o.left = -d, o.right = d, o.top = d, o.bottom = -d, o.near = r, o.far = h, o.updateProjectionMatrix(), this.#t.shadow.needsUpdate = !0;
+      shadowNormalBias: o,
+      shadowRadius: u,
+      shadowDistance: l
+    } = this.#e, c = i / 2, d = this.#t.shadow.camera;
+    this.#t.castShadow = e, this.#t.distance = l, this.#t.shadow.mapSize.setScalar(t), this.#t.shadow.bias = a, this.#t.shadow.normalBias = o, this.#t.shadow.radius = u, d.left = -c, d.right = c, d.top = c, d.bottom = -c, d.near = r, d.far = n, d.updateProjectionMatrix(), this.#t.shadow.needsUpdate = !0;
   }
-  #x() {
+  #S() {
     this.#t && (this.viewer.controls.getTarget(this.#t.target.position), this.#t.target.updateMatrixWorld());
   }
   #L() {
-    this.#g = this.viewer.scene.backgroundNode, this.#p = this.viewer.scene.environmentNode, this.#s = z(), this.#y(), this.#C(), this.viewer.scene.backgroundNode = this.#s;
+    this.#g = this.viewer.scene.backgroundNode, this.#m = this.viewer.scene.environmentNode, this.#i = fa(), this.#C(), this.#v(), this.viewer.scene.backgroundNode = this.#i;
   }
-  #C() {
-    this.#s && (this.#s.showSun = this.#e.showSun, this.#s.showMoon = this.#e.showMoon, this.#s.showStars = this.#e.showStars, this.#s.moonScattering = this.#e.moonScattering);
+  #v() {
+    this.#i && (this.#i.showSun = this.#e.showSun, this.#i.showMoon = this.#e.showMoon, this.#i.showStars = this.#e.showStars, this.#i.moonScattering = this.#e.moonScattering);
   }
-  #y() {
+  #C() {
     if (!this.#e.useSkyEnvironment) {
-      this.#n && this.viewer.scene.environmentNode === this.#n && (this.viewer.scene.environmentNode = this.#p), this.#n = null;
+      this.#n && this.viewer.scene.environmentNode === this.#n && (this.viewer.scene.environmentNode = this.#m), this.#n = null;
       return;
     }
-    this.#n ??= W(), this.viewer.scene.environmentNode = this.#n;
+    this.#n ??= Na(), this.viewer.scene.environmentNode = this.#n;
   }
-  #M() {
-    for (const e of [this.#s, this.#n])
+  #N() {
+    for (const e of [this.#i, this.#n])
       e && (e.needsUpdate = !0);
     this.viewer.renderPipeline.needsUpdateOutputNode = !0;
   }
-  #k() {
-    this.viewer.renderer.library.addToneMapping(ee, N);
+  #D() {
+    this.viewer.renderer.library.addToneMapping(La, ii);
   }
-  #O() {
-    this.#o.includesOutputTransform = !0, this.#S(), this.viewer.renderPipeline.addOutputEffect(this.#o);
+  #P() {
+    this.#o.includesOutputTransform = !0, this.#M(), this.viewer.renderPipeline.addOutputEffect(this.#o);
   }
-  #S() {
+  #M() {
     if (this.#o.includesTemporalAntialias = this.#e.temporalAntialias, this.#e.temporalAntialias) {
-      this.#l || (this.viewer.renderPipeline.addMRTChannel("atmosphereVelocity", D), this.#l = !0);
+      this.#d || (this.viewer.renderPipeline.addMRTChannel("atmosphereVelocity", Pt), this.#d = !0);
       return;
     }
-    this.#T();
+    this.#R();
   }
-  #T() {
-    this.#l && (this.viewer.renderPipeline.removeMRTChannel("atmosphereVelocity"), this.#l = !1);
+  #R() {
+    this.#d && (this.viewer.renderPipeline.removeMRTChannel("atmosphereVelocity"), this.#d = !1);
   }
-  #U() {
+  #B() {
     this.#r && (this.viewer.renderPipeline.needsUpdateOutputNode = !0);
   }
-  #F() {
+  #b() {
     for (const e of this.#a)
       e.dispose();
-    this.#a = [], this.#h = null, this.#d = null;
+    this.#a = [], this.#u = null, this.#l = null;
   }
   #o = (e, t) => {
-    const n = e.getTextureNode("depth");
-    this.#F();
+    const i = e.getTextureNode("depth");
+    this.#b();
     let r = t;
-    if (this.#e.lensFlare && (this.#h = L(r), this.#a.push(this.#h), r = this.#h), this.#e.toneMapping !== !1 && this.#e.toneMapping !== g) {
-      const a = P(this.#e.toneMapping, this.#e.toneMappingExposure, r);
+    if (this.#e.lensFlare && (this.#u = en(r), this.#a.push(this.#u), r = this.#u), this.#e.toneMapping !== !1 && this.#e.toneMapping !== Yt) {
+      const a = sr(this.#e.toneMapping, this.#e.toneMappingExposure, r);
       this.#a.push(a), r = a;
     }
     if (this.#e.temporalAntialias) {
       const a = e.getTextureNode("atmosphereVelocity");
-      this.#d = k(
+      this.#l = xn(
         r,
-        n,
+        i,
         a,
         this.viewer.camera
-      ), this.#a.push(this.#d), r = this.#d;
+      ), this.#a.push(this.#l), r = this.#l;
     }
     if (this.#e.dithering) {
-      const a = E(r, O);
+      const a = k(r, Gr);
       this.#a.push(a), r = a;
     }
-    const h = A(r, g);
-    return this.#a.push(h), h;
+    const n = ir(r, Yt);
+    return this.#a.push(n), n;
   };
-  #b() {
-    if (!this.#i)
+  #z() {
+    if (!this.#s)
       return;
-    this.viewer.camera.updateMatrixWorld(), this.#m.setFromMatrixPosition(this.viewer.camera.matrixWorld).applyMatrix4(this.#i.matrixWorldToECEF.value);
-    const e = this.#i.matrixECIToECEF.value;
-    U(this.#e.date, e), B(this.#e.date, this.#i.sunDirectionECEF.value, this.#m).applyMatrix4(
+    this.viewer.camera.updateMatrixWorld(), this.#p.setFromMatrixPosition(this.viewer.camera.matrixWorld).applyMatrix4(this.#s.matrixWorldToECEF.value);
+    const e = this.#s.matrixECIToECEF.value;
+    Tr(this.#e.date, e), wr(this.#e.date, this.#s.sunDirectionECEF.value, this.#p).applyMatrix4(
       e
-    ), I(
+    ), fr(
       this.#e.date,
-      this.#i.moonDirectionECEF.value,
-      this.#m
+      this.#s.moonDirectionECEF.value,
+      this.#p
     ).applyMatrix4(e);
   }
-  #B() {
-    this.viewer.addEventListener("cameraChange", this.#P);
+  #U() {
+    this.viewer.addEventListener("cameraChange", this.#E);
   }
   #I() {
-    this.viewer.removeEventListener("cameraChange", this.#P);
+    this.viewer.removeEventListener("cameraChange", this.#E);
   }
-  #V() {
+  #O() {
     this.viewer.addEventListener("beforeRender", this.#A);
   }
-  #_() {
+  #k() {
     this.viewer.removeEventListener("beforeRender", this.#A);
   }
-  #P = ({ camera: e }) => {
-    this.#i && (this.#i.camera = e, this.updateDate(this.#e.date));
+  #E = ({ camera: e }) => {
+    this.#s && (this.#s.camera = e, this.updateDate(this.#e.date));
   };
   #A = () => {
-    this.#x(), this.#b();
+    this.#S(), this.#z();
   };
 }
 export {
-  he as Atmosphere
+  no as Atmosphere
 };