@takram/three-geospatial 0.0.1-alpha.1

package/build/index.js

@@ -0,0 +1,932 @@
+var Tt = Object.defineProperty;
+var St = (e, t, n) => t in e ? Tt(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n;
+var c = (e, t, n) => St(e, typeof t != "symbol" ? t + "" : t, n);
+import { Loader as R, FileLoader as Pt, BufferAttribute as J, Box3 as Ot, Vector3 as f, Sphere as Mt, BufferGeometry as At, DataTexture as H, FloatType as I, Data3DTexture as zt, RGBAFormat as Et, ClampToEdgeWrapping as k, LinearFilter as tt, MathUtils as u, Matrix4 as It, Quaternion as Nt, Ray as Ct, Vector2 as ut } from "three";
+import { E as et, G as m } from "./shared.js";
+import { a as xr } from "./shared.js";
+var Lt = `float reverseLogDepth(const float depth, const float near, const float far) {
+  #ifdef USE_LOGDEPTHBUF
+  float d = pow(2.0, depth * log2(far + 1.0)) - 1.0;
+  float a = far / (far - near);
+  float b = far * near / (near - far);
+  return a + b / d;
+  #else
+  return depth;
+  #endif 
+}
+
+float linearizeDepth(const float depth, const float near, const float far) {
+  float ndc = depth * 2.0 - 1.0;
+  return 2.0 * near * far / (far + near - ndc * (far - near));
+}`, Dt = `vec2 signNotZero(vec2 v) {
+  return vec2(v.x >= 0.0 ? 1.0 : -1.0, v.y >= 0.0 ? 1.0 : -1.0);
+}
+
+vec2 packNormalToVec2(vec3 v) {
+  vec2 p = v.xy * (1.0 / (abs(v.x) + abs(v.y) + abs(v.z)));
+  return v.z <= 0.0
+    ? (1.0 - abs(p.yx)) * signNotZero(p)
+    : p;
+}
+
+vec3 unpackVec2ToNormal(vec2 e) {
+  vec3 v = vec3(e.xy, 1.0 - abs(e.x) - abs(e.y));
+  if (v.z < 0.0) {
+    v.xy = (1.0 - abs(v.yx)) * signNotZero(v.xy);
+  }
+  return normalize(v);
+}`, Ft = `vec3 screenToView(
+  const vec2 uv,
+  const float depth,
+  const float viewZ,
+  const mat4 projectionMatrix,
+  const mat4 inverseProjectionMatrix
+) {
+  vec4 clip = vec4(vec3(uv, depth) * 2.0 - 1.0, 1.0);
+  float clipW = projectionMatrix[2][3] * viewZ + projectionMatrix[3][3];
+  clip *= clipW;
+  return (inverseProjectionMatrix * clip).xyz;
+}`, $t = process.env.NODE_ENV === "production", nt = "Invariant failed";
+function jt(e, t) {
+  if (!e) {
+    if ($t)
+      throw new Error(nt);
+    var n = nt;
+    throw new Error(n);
+  }
+}
+class Ut extends R {
+  load(t, n, r, i) {
+    const a = new Pt(this.manager);
+    a.setResponseType("arraybuffer"), a.setRequestHeader(this.requestHeader), a.setPath(this.path), a.setWithCredentials(this.withCredentials), a.load(
+      t,
+      (s) => {
+        jt(s instanceof ArrayBuffer);
+        try {
+          n(s);
+        } catch (o) {
+          i != null ? i(o) : console.error(o), this.manager.itemError(t);
+        }
+      },
+      r,
+      i
+    );
+  }
+}
+function Zn(e) {
+}
+function Gt(e) {
+  return e != null;
+}
+function Yn(e) {
+  return e !== void 0;
+}
+function Kn(e) {
+  return e !== !1;
+}
+var Rt = typeof global == "object" && global && global.Object === Object && global, Ht = typeof self == "object" && self && self.Object === Object && self, B = Rt || Ht || Function("return this")(), p = B.Symbol, dt = Object.prototype, Bt = dt.hasOwnProperty, qt = dt.toString, x = p ? p.toStringTag : void 0;
+function Vt(e) {
+  var t = Bt.call(e, x), n = e[x];
+  try {
+    e[x] = void 0;
+    var r = !0;
+  } catch {
+  }
+  var i = qt.call(e);
+  return r && (t ? e[x] = n : delete e[x]), i;
+}
+var Wt = Object.prototype, Xt = Wt.toString;
+function Zt(e) {
+  return Xt.call(e);
+}
+var Yt = "[object Null]", Kt = "[object Undefined]", rt = p ? p.toStringTag : void 0;
+function q(e) {
+  return e == null ? e === void 0 ? Kt : Yt : rt && rt in Object(e) ? Vt(e) : Zt(e);
+}
+function V(e) {
+  return e != null && typeof e == "object";
+}
+var Qt = "[object Symbol]";
+function W(e) {
+  return typeof e == "symbol" || V(e) && q(e) == Qt;
+}
+function Jt(e, t) {
+  for (var n = -1, r = e == null ? 0 : e.length, i = Array(r); ++n < r; )
+    i[n] = t(e[n], n, e);
+  return i;
+}
+var P = Array.isArray, kt = 1 / 0, it = p ? p.prototype : void 0, at = it ? it.toString : void 0;
+function ft(e) {
+  if (typeof e == "string")
+    return e;
+  if (P(e))
+    return Jt(e, ft) + "";
+  if (W(e))
+    return at ? at.call(e) : "";
+  var t = e + "";
+  return t == "0" && 1 / e == -kt ? "-0" : t;
+}
+function A(e) {
+  var t = typeof e;
+  return e != null && (t == "object" || t == "function");
+}
+function te(e) {
+  return e;
+}
+var ee = "[object AsyncFunction]", ne = "[object Function]", re = "[object GeneratorFunction]", ie = "[object Proxy]";
+function ae(e) {
+  if (!A(e))
+    return !1;
+  var t = q(e);
+  return t == ne || t == re || t == ee || t == ie;
+}
+var j = B["__core-js_shared__"], st = function() {
+  var e = /[^.]+$/.exec(j && j.keys && j.keys.IE_PROTO || "");
+  return e ? "Symbol(src)_1." + e : "";
+}();
+function se(e) {
+  return !!st && st in e;
+}
+var oe = Function.prototype, ce = oe.toString;
+function he(e) {
+  if (e != null) {
+    try {
+      return ce.call(e);
+    } catch {
+    }
+    try {
+      return e + "";
+    } catch {
+    }
+  }
+  return "";
+}
+var le = /[\\^$.*+?()[\]{}|]/g, ue = /^\[object .+?Constructor\]$/, de = Function.prototype, fe = Object.prototype, pe = de.toString, ye = fe.hasOwnProperty, ge = RegExp(
+  "^" + pe.call(ye).replace(le, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
+);
+function we(e) {
+  if (!A(e) || se(e))
+    return !1;
+  var t = ae(e) ? ge : ue;
+  return t.test(he(e));
+}
+function ve(e, t) {
+  return e == null ? void 0 : e[t];
+}
+function X(e, t) {
+  var n = ve(e, t);
+  return we(n) ? n : void 0;
+}
+function me(e, t, n) {
+  switch (n.length) {
+    case 0:
+      return e.call(t);
+    case 1:
+      return e.call(t, n[0]);
+    case 2:
+      return e.call(t, n[0], n[1]);
+    case 3:
+      return e.call(t, n[0], n[1], n[2]);
+  }
+  return e.apply(t, n);
+}
+var xe = 800, _e = 16, be = Date.now;
+function Te(e) {
+  var t = 0, n = 0;
+  return function() {
+    var r = be(), i = _e - (r - n);
+    if (n = r, i > 0) {
+      if (++t >= xe)
+        return arguments[0];
+    } else
+      t = 0;
+    return e.apply(void 0, arguments);
+  };
+}
+function Se(e) {
+  return function() {
+    return e;
+  };
+}
+var z = function() {
+  try {
+    var e = X(Object, "defineProperty");
+    return e({}, "", {}), e;
+  } catch {
+  }
+}(), Pe = z ? function(e, t) {
+  return z(e, "toString", {
+    configurable: !0,
+    enumerable: !1,
+    value: Se(t),
+    writable: !0
+  });
+} : te, Oe = Te(Pe), Me = 9007199254740991, Ae = /^(?:0|[1-9]\d*)$/;
+function pt(e, t) {
+  var n = typeof e;
+  return t = t ?? Me, !!t && (n == "number" || n != "symbol" && Ae.test(e)) && e > -1 && e % 1 == 0 && e < t;
+}
+function ze(e, t, n) {
+  t == "__proto__" && z ? z(e, t, {
+    configurable: !0,
+    enumerable: !0,
+    value: n,
+    writable: !0
+  }) : e[t] = n;
+}
+function yt(e, t) {
+  return e === t || e !== e && t !== t;
+}
+var Ee = Object.prototype, Ie = Ee.hasOwnProperty;
+function Ne(e, t, n) {
+  var r = e[t];
+  (!(Ie.call(e, t) && yt(r, n)) || n === void 0 && !(t in e)) && ze(e, t, n);
+}
+var ot = Math.max;
+function Ce(e, t, n) {
+  return t = ot(t === void 0 ? e.length - 1 : t, 0), function() {
+    for (var r = arguments, i = -1, a = ot(r.length - t, 0), s = Array(a); ++i < a; )
+      s[i] = r[t + i];
+    i = -1;
+    for (var o = Array(t + 1); ++i < t; )
+      o[i] = r[i];
+    return o[t] = n(s), me(e, this, o);
+  };
+}
+var Le = 9007199254740991;
+function De(e) {
+  return typeof e == "number" && e > -1 && e % 1 == 0 && e <= Le;
+}
+var Fe = "[object Arguments]";
+function ct(e) {
+  return V(e) && q(e) == Fe;
+}
+var gt = Object.prototype, $e = gt.hasOwnProperty, je = gt.propertyIsEnumerable, wt = ct(/* @__PURE__ */ function() {
+  return arguments;
+}()) ? ct : function(e) {
+  return V(e) && $e.call(e, "callee") && !je.call(e, "callee");
+}, Ue = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, Ge = /^\w*$/;
+function Re(e, t) {
+  if (P(e))
+    return !1;
+  var n = typeof e;
+  return n == "number" || n == "symbol" || n == "boolean" || e == null || W(e) ? !0 : Ge.test(e) || !Ue.test(e) || t != null && e in Object(t);
+}
+var T = X(Object, "create");
+function He() {
+  this.__data__ = T ? T(null) : {}, this.size = 0;
+}
+function Be(e) {
+  var t = this.has(e) && delete this.__data__[e];
+  return this.size -= t ? 1 : 0, t;
+}
+var qe = "__lodash_hash_undefined__", Ve = Object.prototype, We = Ve.hasOwnProperty;
+function Xe(e) {
+  var t = this.__data__;
+  if (T) {
+    var n = t[e];
+    return n === qe ? void 0 : n;
+  }
+  return We.call(t, e) ? t[e] : void 0;
+}
+var Ze = Object.prototype, Ye = Ze.hasOwnProperty;
+function Ke(e) {
+  var t = this.__data__;
+  return T ? t[e] !== void 0 : Ye.call(t, e);
+}
+var Qe = "__lodash_hash_undefined__";
+function Je(e, t) {
+  var n = this.__data__;
+  return this.size += this.has(e) ? 0 : 1, n[e] = T && t === void 0 ? Qe : t, this;
+}
+function g(e) {
+  var t = -1, n = e == null ? 0 : e.length;
+  for (this.clear(); ++t < n; ) {
+    var r = e[t];
+    this.set(r[0], r[1]);
+  }
+}
+g.prototype.clear = He;
+g.prototype.delete = Be;
+g.prototype.get = Xe;
+g.prototype.has = Ke;
+g.prototype.set = Je;
+function ke() {
+  this.__data__ = [], this.size = 0;
+}
+function N(e, t) {
+  for (var n = e.length; n--; )
+    if (yt(e[n][0], t))
+      return n;
+  return -1;
+}
+var tn = Array.prototype, en = tn.splice;
+function nn(e) {
+  var t = this.__data__, n = N(t, e);
+  if (n < 0)
+    return !1;
+  var r = t.length - 1;
+  return n == r ? t.pop() : en.call(t, n, 1), --this.size, !0;
+}
+function rn(e) {
+  var t = this.__data__, n = N(t, e);
+  return n < 0 ? void 0 : t[n][1];
+}
+function an(e) {
+  return N(this.__data__, e) > -1;
+}
+function sn(e, t) {
+  var n = this.__data__, r = N(n, e);
+  return r < 0 ? (++this.size, n.push([e, t])) : n[r][1] = t, this;
+}
+function v(e) {
+  var t = -1, n = e == null ? 0 : e.length;
+  for (this.clear(); ++t < n; ) {
+    var r = e[t];
+    this.set(r[0], r[1]);
+  }
+}
+v.prototype.clear = ke;
+v.prototype.delete = nn;
+v.prototype.get = rn;
+v.prototype.has = an;
+v.prototype.set = sn;
+var on = X(B, "Map");
+function cn() {
+  this.size = 0, this.__data__ = {
+    hash: new g(),
+    map: new (on || v)(),
+    string: new g()
+  };
+}
+function hn(e) {
+  var t = typeof e;
+  return t == "string" || t == "number" || t == "symbol" || t == "boolean" ? e !== "__proto__" : e === null;
+}
+function C(e, t) {
+  var n = e.__data__;
+  return hn(t) ? n[typeof t == "string" ? "string" : "hash"] : n.map;
+}
+function ln(e) {
+  var t = C(this, e).delete(e);
+  return this.size -= t ? 1 : 0, t;
+}
+function un(e) {
+  return C(this, e).get(e);
+}
+function dn(e) {
+  return C(this, e).has(e);
+}
+function fn(e, t) {
+  var n = C(this, e), r = n.size;
+  return n.set(e, t), this.size += n.size == r ? 0 : 1, this;
+}
+function w(e) {
+  var t = -1, n = e == null ? 0 : e.length;
+  for (this.clear(); ++t < n; ) {
+    var r = e[t];
+    this.set(r[0], r[1]);
+  }
+}
+w.prototype.clear = cn;
+w.prototype.delete = ln;
+w.prototype.get = un;
+w.prototype.has = dn;
+w.prototype.set = fn;
+var pn = "Expected a function";
+function Z(e, t) {
+  if (typeof e != "function" || t != null && typeof t != "function")
+    throw new TypeError(pn);
+  var n = function() {
+    var r = arguments, i = t ? t.apply(this, r) : r[0], a = n.cache;
+    if (a.has(i))
+      return a.get(i);
+    var s = e.apply(this, r);
+    return n.cache = a.set(i, s) || a, s;
+  };
+  return n.cache = new (Z.Cache || w)(), n;
+}
+Z.Cache = w;
+var yn = 500;
+function gn(e) {
+  var t = Z(e, function(r) {
+    return n.size === yn && n.clear(), r;
+  }), n = t.cache;
+  return t;
+}
+var wn = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g, vn = /\\(\\)?/g, mn = gn(function(e) {
+  var t = [];
+  return e.charCodeAt(0) === 46 && t.push(""), e.replace(wn, function(n, r, i, a) {
+    t.push(i ? a.replace(vn, "$1") : r || n);
+  }), t;
+});
+function xn(e) {
+  return e == null ? "" : ft(e);
+}
+function L(e, t) {
+  return P(e) ? e : Re(e, t) ? [e] : mn(xn(e));
+}
+var _n = 1 / 0;
+function Y(e) {
+  if (typeof e == "string" || W(e))
+    return e;
+  var t = e + "";
+  return t == "0" && 1 / e == -_n ? "-0" : t;
+}
+function bn(e, t) {
+  t = L(t, e);
+  for (var n = 0, r = t.length; e != null && n < r; )
+    e = e[Y(t[n++])];
+  return n && n == r ? e : void 0;
+}
+function Tn(e, t) {
+  for (var n = -1, r = t.length, i = e.length; ++n < r; )
+    e[i + n] = t[n];
+  return e;
+}
+var ht = p ? p.isConcatSpreadable : void 0;
+function Sn(e) {
+  return P(e) || wt(e) || !!(ht && e && e[ht]);
+}
+function Pn(e, t, n, r, i) {
+  var a = -1, s = e.length;
+  for (n || (n = Sn), i || (i = []); ++a < s; ) {
+    var o = e[a];
+    n(o) ? Tn(i, o) : i[i.length] = o;
+  }
+  return i;
+}
+function On(e) {
+  var t = e == null ? 0 : e.length;
+  return t ? Pn(e) : [];
+}
+function Mn(e) {
+  return Oe(Ce(e, void 0, On), e + "");
+}
+function An(e, t) {
+  return e != null && t in Object(e);
+}
+function zn(e, t, n) {
+  t = L(t, e);
+  for (var r = -1, i = t.length, a = !1; ++r < i; ) {
+    var s = Y(t[r]);
+    if (!(a = e != null && n(e, s)))
+      break;
+    e = e[s];
+  }
+  return a || ++r != i ? a : (i = e == null ? 0 : e.length, !!i && De(i) && pt(s, i) && (P(e) || wt(e)));
+}
+function En(e, t) {
+  return e != null && zn(e, t, An);
+}
+function In(e, t, n, r) {
+  if (!A(e))
+    return e;
+  t = L(t, e);
+  for (var i = -1, a = t.length, s = a - 1, o = e; o != null && ++i < a; ) {
+    var h = Y(t[i]), l = n;
+    if (h === "__proto__" || h === "constructor" || h === "prototype")
+      return e;
+    if (i != s) {
+      var y = o[h];
+      l = void 0, l === void 0 && (l = A(y) ? y : pt(t[i + 1]) ? [] : {});
+    }
+    Ne(o, h, l), o = o[h];
+  }
+  return e;
+}
+function Nn(e, t, n) {
+  for (var r = -1, i = t.length, a = {}; ++r < i; ) {
+    var s = t[r], o = bn(e, s);
+    n(o, s) && In(a, L(s, e), o);
+  }
+  return a;
+}
+function Cn(e, t) {
+  return Nn(e, t, function(n, r) {
+    return En(e, r);
+  });
+}
+var Ln = Mn(function(e, t) {
+  return e == null ? {} : Cn(e, t);
+});
+function Qn(e) {
+  var t;
+  return [
+    Ln(e, ["attributes", "index", "boundingBox", "boundingSphere"]),
+    [
+      ...Object.values(e.attributes).map(
+        (n) => n.array.buffer
+      ),
+      (t = e.index) == null ? void 0 : t.array.buffer
+    ].filter(Gt)
+  ];
+}
+function Jn(e, t = new At()) {
+  for (const [n, r] of Object.entries(e.attributes))
+    t.setAttribute(
+      n,
+      new J(
+        r.array,
+        r.itemSize,
+        r.normalized
+      )
+    );
+  if (t.index = e.index != null ? new J(
+    e.index.array,
+    e.index.itemSize,
+    e.index.normalized
+  ) : null, e.boundingBox != null) {
+    const { min: n, max: r } = e.boundingBox;
+    t.boundingBox = new Ot(
+      new f(n.x, n.y, n.z),
+      new f(r.x, r.y, r.z)
+    );
+  }
+  if (e.boundingSphere != null) {
+    const { center: n, radius: r } = e.boundingSphere;
+    t.boundingSphere = new Mt(
+      new f(n.x, n.y, n.z),
+      r
+    );
+  }
+  return t;
+}
+function K(e, t, n, r = !0) {
+  const i = new DataView(e), a = new t(i.byteLength / t.BYTES_PER_ELEMENT);
+  for (let s = 0, o = 0; s < a.length; ++s, o += t.BYTES_PER_ELEMENT)
+    a[s] = i[n](o, r);
+  return a;
+}
+function Dn(e, t) {
+  return K(e, Int16Array, "getInt16", t);
+}
+function Fn(e, t) {
+  return K(e, Uint16Array, "getUint16", t);
+}
+function $n(e, t) {
+  return K(e, Float32Array, "getFloat32", t);
+}
+class Q extends R {
+  load(t, n, r, i) {
+    const a = new Ut(this.manager);
+    a.setRequestHeader(this.requestHeader), a.setPath(this.path), a.setWithCredentials(this.withCredentials), a.load(
+      t,
+      (s) => {
+        try {
+          n(this.parseTypedArray(s));
+        } catch (o) {
+          i != null ? i(o) : console.error(o), this.manager.itemError(t);
+        }
+      },
+      r,
+      i
+    );
+  }
+}
+class jn extends Q {
+  constructor() {
+    super(...arguments);
+    c(this, "parseTypedArray", Dn);
+  }
+}
+class Un extends Q {
+  constructor() {
+    super(...arguments);
+    c(this, "parseTypedArray", Fn);
+  }
+}
+class vt extends Q {
+  constructor() {
+    super(...arguments);
+    c(this, "parseTypedArray", $n);
+  }
+}
+const D = {
+  format: Et,
+  wrapS: k,
+  wrapT: k,
+  minFilter: tt,
+  magFilter: tt
+};
+class F extends R {
+  constructor() {
+    super(...arguments);
+    c(this, "parameters");
+  }
+  load(n, r, i, a) {
+    const s = new this.Texture(), o = new this.TypedArrayLoader(this.manager);
+    o.setRequestHeader(this.requestHeader), o.setPath(this.path), o.setWithCredentials(this.withCredentials), o.load(
+      n,
+      (h) => {
+        s.image.data = h, Object.assign(s, this.parameters), s.needsUpdate = !0, r(s);
+      },
+      i,
+      a
+    );
+  }
+}
+class kn extends F {
+  constructor() {
+    super(...arguments);
+    c(this, "Texture", H);
+    c(this, "TypedArrayLoader", jn);
+    c(this, "parameters", {
+      ...D,
+      type: I
+    });
+  }
+}
+class tr extends F {
+  constructor() {
+    super(...arguments);
+    c(this, "Texture", H);
+    c(this, "TypedArrayLoader", Un);
+    c(this, "parameters", {
+      ...D,
+      type: I
+    });
+  }
+}
+class er extends F {
+  constructor() {
+    super(...arguments);
+    c(this, "Texture", H);
+    c(this, "TypedArrayLoader", vt);
+    c(this, "parameters", {
+      ...D,
+      type: I
+    });
+  }
+}
+class nr extends F {
+  constructor() {
+    super(...arguments);
+    c(this, "Texture", zt);
+    c(this, "TypedArrayLoader", vt);
+    c(this, "parameters", {
+      ...D,
+      type: I
+    });
+  }
+}
+const Gn = u.clamp, rr = u.euclideanModulo, ir = u.inverseLerp, ar = u.lerp, sr = u.degToRad, or = u.radToDeg, cr = u.isPowerOfTwo, hr = u.ceilPowerOfTwo, lr = u.floorPowerOfTwo, ur = u.normalize;
+function dr(e, t, n) {
+  return n <= e ? 0 : n >= t ? 1 : (n = (n - e) / (t - e), n * n * (3 - 2 * n));
+}
+function fr(e) {
+  return Math.min(Math.max(e, 0), 1);
+}
+function pr(e, t, n, r = n) {
+  const i = Math.abs(e - t);
+  return i <= r || i <= n * Math.max(Math.abs(e), Math.abs(t));
+}
+const U = 1e-6, O = /* @__PURE__ */ new f(), M = /* @__PURE__ */ new f(), d = /* @__PURE__ */ new f(), _ = /* @__PURE__ */ new f(), G = /* @__PURE__ */ new f(), Rn = /* @__PURE__ */ new f(), Hn = /* @__PURE__ */ new It(), Bn = /* @__PURE__ */ new Nt(), qn = /* @__PURE__ */ new Ct();
+class mt {
+  constructor(t = 0, n = 0, r = 0, i = 0) {
+    // Distance from the target.
+    c(this, "_distance");
+    // Radians from the local east direction relative from true north, measured
+    // clockwise (90 degrees is true north, and -90 is true south).
+    c(this, "heading");
+    // Radians from the local horizon plane, measured with positive values looking
+    // up (90 degrees is straight up, -90 is straight down).
+    c(this, "_pitch");
+    c(this, "roll");
+    this.distance = t, this.heading = n, this.pitch = r, this.roll = i;
+  }
+  get distance() {
+    return this._distance;
+  }
+  set distance(t) {
+    this._distance = Math.max(t, U);
+  }
+  get pitch() {
+    return this._pitch;
+  }
+  set pitch(t) {
+    this._pitch = Gn(t, -Math.PI / 2 + U, Math.PI / 2 - U);
+  }
+  set(t, n, r, i) {
+    return this.distance = t, this.heading = n, this.pitch = r, i != null && (this.roll = i), this;
+  }
+  clone() {
+    return new mt(this.distance, this.heading, this.pitch, this.roll);
+  }
+  copy(t) {
+    return this.distance = t.distance, this.heading = t.heading, this.pitch = t.pitch, this.roll = t.roll, this;
+  }
+  equals(t) {
+    return t.distance === this.distance && t.heading === this.heading && t.pitch === this.pitch && t.roll === this.roll;
+  }
+  decompose(t, n, r, i, a = et.WGS84) {
+    a.getEastNorthUpVectors(
+      t,
+      O,
+      M,
+      d
+    ), i == null || i.copy(d);
+    const s = _.copy(O).multiplyScalar(Math.cos(this.heading)).add(
+      G.copy(M).multiplyScalar(Math.sin(this.heading))
+    ).multiplyScalar(Math.cos(this.pitch)).add(G.copy(d).multiplyScalar(Math.sin(this.pitch))).normalize().multiplyScalar(this.distance);
+    if (n.copy(t).sub(s), this.roll !== 0) {
+      const o = _.copy(t).sub(n).normalize();
+      d.applyQuaternion(
+        Bn.setFromAxisAngle(o, this.roll)
+      );
+    }
+    r.setFromRotationMatrix(
+      Hn.lookAt(n, t, d)
+    );
+  }
+  setFromCamera(t, n = et.WGS84) {
+    const r = _.setFromMatrixPosition(t.matrixWorld), i = G.set(0, 0, 0.5).unproject(t).sub(r).normalize(), a = n.getIntersection(qn.set(r, i));
+    if (a == null)
+      return;
+    this.distance = r.distanceTo(a), n.getEastNorthUpVectors(
+      a,
+      O,
+      M,
+      d
+    ), this.heading = Math.atan2(
+      M.dot(i),
+      O.dot(i)
+    ), this.pitch = Math.asin(d.dot(i));
+    const s = _.copy(t.up).applyQuaternion(t.quaternion), o = Rn.copy(i).multiplyScalar(-s.dot(i)).add(s).normalize(), h = _.copy(i).multiplyScalar(-d.dot(i)).add(d).normalize(), l = h.dot(o), y = i.dot(h.cross(o));
+    return this.roll = Math.atan2(y, l), this;
+  }
+}
+const b = class b {
+  constructor(t = 0, n = 0, r = 0, i = 0) {
+    this.west = t, this.south = n, this.east = r, this.north = i;
+  }
+  get width() {
+    let t = this.east;
+    return t < this.west && (t += Math.PI * 2), t - this.west;
+  }
+  get height() {
+    return this.north - this.south;
+  }
+  set(t, n, r, i) {
+    return this.west = t, this.south = n, this.east = r, this.north = i, this;
+  }
+  clone() {
+    return new b(this.west, this.south, this.east, this.north);
+  }
+  copy(t) {
+    return this.west = t.west, this.south = t.south, this.east = t.east, this.north = t.north, this;
+  }
+  equals(t) {
+    return t.west === this.west && t.south === this.south && t.east === this.east && t.north === this.north;
+  }
+  at(t, n, r = new m()) {
+    return r.set(
+      this.west + (this.east - this.west) * t,
+      this.north + (this.south - this.north) * n
+    );
+  }
+  fromArray(t, n = 0) {
+    return this.west = t[n], this.south = t[n + 1], this.east = t[n + 2], this.north = t[n + 3], this;
+  }
+  toArray(t = [], n = 0) {
+    return t[n] = this.west, t[n + 1] = this.south, t[n + 2] = this.east, t[n + 3] = this.north, t;
+  }
+  *[Symbol.iterator]() {
+    yield this.west, yield this.south, yield this.east, yield this.north;
+  }
+};
+c(b, "MAX", /* @__PURE__ */ new b(
+  m.MIN_LONGITUDE,
+  m.MIN_LATITUDE,
+  m.MAX_LONGITUDE,
+  m.MAX_LATITUDE
+));
+let E = b;
+function* xt(e, t, n, r, i) {
+  if (n >= r)
+    return;
+  const a = 2 ** n, s = n + 1, o = 2 ** s, h = Math.floor(e / a * o), l = Math.floor(t / a * o), y = [
+    [h, l, s],
+    [h + 1, l, s],
+    [h, l + 1, s],
+    [h + 1, l + 1, s]
+  ];
+  if (s < r)
+    for (const $ of y)
+      for (const bt of xt(...$, r, i))
+        yield bt;
+  else
+    for (const $ of y)
+      yield (i ?? new S()).set(...$);
+}
+class S {
+  constructor(t = 0, n = 0, r = 0) {
+    this.x = t, this.y = n, this.z = r;
+  }
+  set(t, n, r) {
+    return this.x = t, this.y = n, r != null && (this.z = r), this;
+  }
+  clone() {
+    return new S(this.x, this.y, this.z);
+  }
+  copy(t) {
+    return this.x = t.x, this.y = t.y, this.z = t.z, this;
+  }
+  equals(t) {
+    return t.x === this.x && t.y === this.y && t.z === this.z;
+  }
+  getParent(t = new S()) {
+    const n = 2 ** this.z, r = this.x / n, i = this.y / n, a = this.z - 1, s = 2 ** a;
+    return t.set(Math.floor(r * s), Math.floor(i * s), a);
+  }
+  *traverseChildren(t, n) {
+    const { x: r, y: i, z: a } = this;
+    for (const s of xt(r, i, a, a + t, n))
+      yield s;
+  }
+  fromArray(t, n = 0) {
+    return this.x = t[n], this.y = t[n + 1], this.z = t[n + 2], this;
+  }
+  toArray(t = [], n = 0) {
+    return t[n] = this.x, t[n + 1] = this.y, t[n + 2] = this.z, t;
+  }
+  *[Symbol.iterator]() {
+    yield this.x, yield this.y, yield this.z;
+  }
+}
+const lt = /* @__PURE__ */ new ut();
+class _t {
+  constructor(t = 2, n = 1, r = E.MAX) {
+    this.width = t, this.height = n, this.rectangle = r;
+  }
+  clone() {
+    return new _t(this.width, this.height, this.rectangle.clone());
+  }
+  copy(t) {
+    return this.width = t.width, this.height = t.height, this.rectangle.copy(t.rectangle), this;
+  }
+  getSize(t, n = new ut()) {
+    return n.set(this.width << t, this.height << t);
+  }
+  // Reference: https://github.com/CesiumGS/cesium/blob/1.122/packages/engine/Source/Core/GeographicTilingScheme.js#L210
+  getTile(t, n, r = new S()) {
+    const i = this.getSize(n, lt), a = this.rectangle.width / i.x, s = this.rectangle.height / i.y;
+    let o = t.longitude;
+    this.rectangle.east < this.rectangle.west && (o += Math.PI * 2);
+    let h = Math.floor((o - this.rectangle.west) / a);
+    h >= i.x && (h = i.x - 1);
+    let l = Math.floor((t.latitude - this.rectangle.south) / s);
+    return l >= i.y && (l = i.y - 1), r.x = h, r.y = l, r.z = n, r;
+  }
+  // Reference: https://github.com/CesiumGS/cesium/blob/1.122/packages/engine/Source/Core/GeographicTilingScheme.js#L169
+  getRectangle(t, n = new E()) {
+    const r = this.getSize(t.z, lt), i = this.rectangle.width / r.x, a = this.rectangle.height / r.y;
+    return n.west = t.x * i + this.rectangle.west, n.east = (t.x + 1) * i + this.rectangle.west, n.north = this.rectangle.north - (r.y - t.y - 1) * a, n.south = this.rectangle.north - (r.y - t.y) * a, n;
+  }
+}
+const yr = Lt, gr = Dt, wr = Ft;
+export {
+  Ut as ArrayBufferLoader,
+  F as DataLoader,
+  et as Ellipsoid,
+  xr as EllipsoidGeometry,
+  vt as Float32ArrayLoader,
+  er as Float32Data2DLoader,
+  nr as Float32Data3DLoader,
+  m as Geodetic,
+  jn as Int16ArrayLoader,
+  kn as Int16Data2DLoader,
+  mt as PointOfView,
+  E as Rectangle,
+  S as TileCoordinate,
+  _t as TilingScheme,
+  Q as TypedArrayLoader,
+  Un as Uint16ArrayLoader,
+  tr as Uint16Data2DLoader,
+  Zn as assertType,
+  hr as ceilPowerOfTwo,
+  Gn as clamp,
+  pr as closeTo,
+  or as degrees,
+  yr as depthShader,
+  rr as euclideanModulo,
+  lr as floorPowerOfTwo,
+  Jn as fromBufferGeometryLike,
+  ir as inverseLerp,
+  Kn as isNotFalse,
+  Gt as isNotNullish,
+  Yn as isNotUndefined,
+  cr as isPowerOfTwo,
+  ar as lerp,
+  ur as normalize,
+  gr as packingShader,
+  $n as parseFloat32Array,
+  Dn as parseInt16Array,
+  K as parseTypedArray,
+  Fn as parseUint16Array,
+  sr as radians,
+  fr as saturate,
+  dr as smoothstep,
+  Qn as toBufferGeometryLike,
+  wr as transformShader
+};