@takram/three-geospatial 0.0.1-alpha.6 → 0.0.1-alpha.7

package/build/index.js

@@ -1,216 +1,259 @@
-var k = Object.defineProperty;
-var Q = (s, t, e) => t in s ? k(s, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : s[t] = e;
-var l = (s, t, e) => Q(s, typeof t != "symbol" ? t + "" : t, e);
-import { Loader as b, FileLoader as Y, BufferAttribute as F, Box3 as $, Vector3 as p, Sphere as J, BufferGeometry as K, UnsignedByteType as Z, ByteType as tt, FloatType as et, Data3DTexture as st, DataTexture as nt, RGBAFormat as it, ClampToEdgeWrapping as v, LinearFilter as _, MathUtils as d, Matrix4 as rt, Quaternion as ot, Ray as at, Vector2 as C } from "three";
-import { E as B, G as w } from "./shared.js";
-import { a as ce } from "./shared.js";
-var ht = process.env.NODE_ENV === "production", N = "Invariant failed";
-function R(s, t) {
-  if (!s) {
-    if (ht)
-      throw new Error(N);
-    var e = N;
+var J = Object.defineProperty;
+var Z = (n, t, e) => t in n ? J(n, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[t] = e;
+var d = (n, t, e) => Z(n, typeof t != "symbol" ? t + "" : t, e);
+import { Loader as P, FileLoader as K, BufferGeometry as tt, BufferAttribute as B, Box3 as et, Vector3 as p, Sphere as nt, UnsignedByteType as st, ByteType as rt, FloatType as it, LinearFilter as N, ClampToEdgeWrapping as O, RGBAFormat as ot, Data3DTexture as at, DataTexture as ht, MathUtils as l, Quaternion as ct, Matrix4 as lt, Ray as dt, RepeatWrapping as D, NearestFilter as R, RedFormat as ut, Vector2 as H } from "three";
+import { E as C, G as w } from "./shared.js";
+import { a as xe } from "./shared.js";
+var pt = process.env.NODE_ENV === "production", G = "Invariant failed";
+function W(n, t) {
+  if (!n) {
+    if (pt)
+      throw new Error(G);
+    var e = G;
     throw new Error(e);
   }
 }
-class ct extends b {
-  load(t, e, n, i) {
-    const r = new Y(this.manager);
-    r.setResponseType("arraybuffer"), r.setRequestHeader(this.requestHeader), r.setPath(this.path), r.setWithCredentials(this.withCredentials), r.load(
+class ft extends P {
+  load(t, e, s, r) {
+    const i = new K(this.manager);
+    i.setResponseType("arraybuffer"), i.setRequestHeader(this.requestHeader), i.setPath(this.path), i.setWithCredentials(this.withCredentials), i.load(
       t,
       (o) => {
-        R(o instanceof ArrayBuffer);
+        W(o instanceof ArrayBuffer);
         try {
           e(o);
         } catch (a) {
-          i != null ? i(a) : console.error(a), this.manager.itemError(t);
+          r != null ? r(a) : console.error(a), this.manager.itemError(t);
         }
       },
-      n,
-      i
+      s,
+      r
     );
   }
 }
-function It(s) {
+function Bt(n) {
 }
-function Dt(s) {
-  var r;
-  const { attributes: t, index: e, boundingBox: n, boundingSphere: i } = s;
+function Nt(n) {
+  var i;
+  const { attributes: t, index: e, boundingBox: s, boundingSphere: r } = n;
   return [
-    { attributes: t, index: e, boundingBox: n, boundingSphere: i },
+    { attributes: t, index: e, boundingBox: s, boundingSphere: r },
     [
-      ...Object.values(s.attributes).map(
+      ...Object.values(n.attributes).map(
         (o) => o.array.buffer
       ),
-      (r = s.index) == null ? void 0 : r.array.buffer
+      (i = n.index) == null ? void 0 : i.array.buffer
     ].filter((o) => o != null)
   ];
 }
-function zt(s, t = new K()) {
-  for (const [e, n] of Object.entries(s.attributes))
+function Ot(n, t = new tt()) {
+  for (const [e, s] of Object.entries(n.attributes))
     t.setAttribute(
       e,
-      new F(
-        n.array,
-        n.itemSize,
-        n.normalized
+      new B(
+        s.array,
+        s.itemSize,
+        s.normalized
       )
     );
-  if (t.index = s.index != null ? new F(
-    s.index.array,
-    s.index.itemSize,
-    s.index.normalized
-  ) : null, s.boundingBox != null) {
-    const { min: e, max: n } = s.boundingBox;
-    t.boundingBox = new $(
+  if (t.index = n.index != null ? new B(
+    n.index.array,
+    n.index.itemSize,
+    n.index.normalized
+  ) : null, n.boundingBox != null) {
+    const { min: e, max: s } = n.boundingBox;
+    t.boundingBox = new et(
       new p(e.x, e.y, e.z),
-      new p(n.x, n.y, n.z)
+      new p(s.x, s.y, s.z)
     );
   }
-  if (s.boundingSphere != null) {
-    const { center: e, radius: n } = s.boundingSphere;
-    t.boundingSphere = new J(
+  if (n.boundingSphere != null) {
+    const { center: e, radius: s } = n.boundingSphere;
+    t.boundingSphere = new nt(
       new p(e.x, e.y, e.z),
-      n
+      s
     );
   }
   return t;
 }
-const bt = 128, Ut = 128, Pt = 64;
-function lt(s) {
-  const t = s instanceof Int8Array ? "int8" : s instanceof Uint8Array || s instanceof Uint8ClampedArray ? "uint8" : s instanceof Int16Array ? "int16" : s instanceof Uint16Array ? "uint16" : s instanceof Int32Array ? "int32" : s instanceof Uint32Array ? "uint32" : s instanceof Float32Array ? "float32" : s instanceof Float64Array ? "float64" : null;
-  return R(t != null), t;
+const yt = 128, gt = 128, wt = 64, Rt = "https://media.githubusercontent.com/media/takram-design-engineering/three-geospatial/9627216cc50057994c98a2118f3c4a23765d43b9/packages/core/assets/stbn.bin";
+function mt(n) {
+  const t = n instanceof Int8Array ? "int8" : n instanceof Uint8Array || n instanceof Uint8ClampedArray ? "uint8" : n instanceof Int16Array ? "int16" : n instanceof Uint16Array ? "uint16" : n instanceof Int32Array ? "int32" : n instanceof Uint32Array ? "uint32" : n instanceof Float32Array ? "float32" : n instanceof Float64Array ? "float64" : null;
+  return W(t != null), t;
 }
-function y(s, t, e, n = !0) {
-  const i = new DataView(s), r = new t(i.byteLength / t.BYTES_PER_ELEMENT);
-  for (let o = 0, a = 0; o < r.length; ++o, a += t.BYTES_PER_ELEMENT)
-    r[o] = i[e](a, n);
-  return r;
+let L;
+function xt() {
+  if (L != null)
+    return L;
+  const n = new Uint32Array([268435456]);
+  return L = new Uint8Array(n.buffer, n.byteOffset, n.byteLength)[0] === 0, L;
 }
-const Ft = (s, t) => y(s, Uint8Array, "getUint8", t), vt = (s, t) => y(s, Int8Array, "getInt8", t), G = (s, t) => y(s, Uint16Array, "getUint16", t), q = (s, t) => y(s, Int16Array, "getInt16", t), _t = (s, t) => y(s, Int32Array, "getInt32", t), Bt = (s, t) => y(s, Uint32Array, "getUint32", t), U = (s, t) => y(s, Float32Array, "getFloat32", t), Nt = (s, t) => y(s, Float64Array, "getFloat64", t);
-class dt extends b {
-  load(t, e, n, i) {
-    const r = new ct(this.manager);
-    r.setRequestHeader(this.requestHeader), r.setPath(this.path), r.setWithCredentials(this.withCredentials), r.load(
+function g(n, t, e, s = !0) {
+  if (s === xt())
+    return new t(n);
+  const r = new DataView(n), i = new t(r.byteLength / t.BYTES_PER_ELEMENT);
+  for (let o = 0, a = 0; o < i.length; ++o, a += t.BYTES_PER_ELEMENT)
+    i[o] = r[e](a, s);
+  return i;
+}
+const Tt = (n) => new Uint8Array(n), Ct = (n) => new Int8Array(n), X = (n, t) => g(n, Uint16Array, "getUint16", t), k = (n, t) => g(n, Int16Array, "getInt16", t), Gt = (n, t) => g(n, Int32Array, "getInt32", t), qt = (n, t) => g(n, Uint32Array, "getUint32", t), F = (n, t) => g(n, Float32Array, "getFloat32", t), Ht = (n, t) => g(n, Float64Array, "getFloat64", t);
+class At extends P {
+  load(t, e, s, r) {
+    const i = new ft(this.manager);
+    i.setRequestHeader(this.requestHeader), i.setPath(this.path), i.setWithCredentials(this.withCredentials), i.load(
       t,
       (o) => {
         try {
           e(this.parseTypedArray(o));
         } catch (a) {
-          i != null ? i(a) : console.error(a), this.manager.itemError(t);
+          r != null ? r(a) : console.error(a), this.manager.itemError(t);
         }
       },
-      n,
-      i
+      s,
+      r
     );
   }
 }
-function A(s) {
-  return class extends dt {
+function A(n) {
+  return class extends At {
     constructor() {
       super(...arguments);
-      l(this, "parseTypedArray", s);
+      d(this, "parseTypedArray", n);
     }
   };
 }
-function Ot(s) {
-  return new (A(s))();
+function Wt(n) {
+  return new (A(n))();
 }
-const Ct = /* @__PURE__ */ A(q), Rt = /* @__PURE__ */ A(G), Gt = /* @__PURE__ */ A(U), ut = {
-  format: it,
-  wrapS: v,
-  wrapT: v,
-  minFilter: _,
-  magFilter: _
+const Xt = /* @__PURE__ */ A(k), kt = /* @__PURE__ */ A(X), jt = /* @__PURE__ */ A(F), Lt = {
+  format: ot,
+  wrapS: O,
+  wrapT: O,
+  minFilter: N,
+  magFilter: N
 };
-class pt extends b {
+class St extends P {
   constructor() {
     super(...arguments);
-    l(this, "parameters", {});
+    d(this, "parameters", {});
   }
-  load(e, n, i, r) {
+  load(e, s, r, i) {
     const o = new this.Texture(), a = new this.TypedArrayLoader(this.manager);
     a.setRequestHeader(this.requestHeader), a.setPath(this.path), a.setWithCredentials(this.withCredentials), a.load(
       e,
       (h) => {
         o.image.data = h;
-        const { width: c, height: f, depth: g, ...I } = this.parameters;
-        c != null && (o.image.width = c), f != null && (o.image.height = f), "depth" in o.image && g != null && (o.image.depth = g);
-        const P = lt(h);
-        o.type = P === "uint8" ? Z : P === "int8" ? tt : et, Object.assign(o, I), o.needsUpdate = !0, n(o);
+        const { width: c, height: f, depth: y, ...I } = this.parameters;
+        c != null && (o.image.width = c), f != null && (o.image.height = f), "depth" in o.image && y != null && (o.image.depth = y);
+        const _ = mt(h);
+        o.type = _ === "uint8" ? st : _ === "int8" ? rt : it, Object.assign(o, I), o.needsUpdate = !0, s(o);
       },
-      i,
-      r
+      r,
+      i
     );
   }
 }
-function H(s, t, e) {
-  return class extends pt {
+function j(n, t, e) {
+  return class extends St {
     constructor() {
       super(...arguments);
-      l(this, "Texture", s);
-      l(this, "TypedArrayLoader", A(t));
-      l(this, "parameters", {
-        ...ut,
+      d(this, "Texture", n);
+      d(this, "TypedArrayLoader", A(t));
+      d(this, "parameters", {
+        ...Lt,
         ...e
       });
     }
   };
 }
-function X(s, t) {
-  return H(st, s, t);
+function v(n, t) {
+  return j(at, n, t);
 }
-function E(s, t) {
-  return H(nt, s, t);
+function E(n, t) {
+  return j(ht, n, t);
 }
-function qt(s, t) {
-  return new (X(s, t))();
+function Vt(n, t) {
+  return new (v(n, t))();
 }
-function Ht(s, t) {
-  return new (E(s, t))();
+function Qt(n, t) {
+  return new (E(n, t))();
 }
-const Xt = /* @__PURE__ */ E(q), Wt = /* @__PURE__ */ E(G), Vt = /* @__PURE__ */ E(U), jt = /* @__PURE__ */ X(U), yt = d.clamp, kt = d.euclideanModulo, Qt = d.inverseLerp, Yt = d.lerp, $t = d.degToRad, Jt = d.radToDeg, Kt = d.isPowerOfTwo, Zt = d.ceilPowerOfTwo, te = d.floorPowerOfTwo, ee = d.normalize, se = d.mapLinear;
-function ne(s, t, e) {
-  return e <= s ? 0 : e >= t ? 1 : (e = (e - s) / (t - s), e * e * (3 - 2 * e));
+const Yt = /* @__PURE__ */ E(k), $t = /* @__PURE__ */ E(X), Jt = /* @__PURE__ */ E(F), Zt = /* @__PURE__ */ v(F);
+function Kt(n, ...t) {
+  const e = {};
+  for (let s = 0; s < t.length; s += 2) {
+    const r = t[s], i = t[s + 1];
+    for (const o of i)
+      e[o] = {
+        enumerable: !0,
+        get: () => r[o],
+        set: (a) => {
+          r[o] = a;
+        }
+      };
+  }
+  return Object.defineProperties(n, e), n;
+}
+function te(n, t, e) {
+  const s = {};
+  for (const r of e)
+    s[r] = {
+      enumerable: !0,
+      get: () => t.uniforms[r].value,
+      set: (i) => {
+        t.uniforms[r].value = i;
+      }
+    };
+  return Object.defineProperties(n, s), n;
+}
+const V = l.clamp, ee = l.euclideanModulo, ne = l.inverseLerp, se = l.lerp, re = l.degToRad, ie = l.radToDeg, oe = l.isPowerOfTwo, ae = l.ceilPowerOfTwo, he = l.floorPowerOfTwo, ce = l.normalize;
+function le(n, t, e, s = 0, r = 1) {
+  return l.mapLinear(n, t, e, s, r);
+}
+function de(n, t, e, s = 0, r = 1) {
+  return V(l.mapLinear(n, t, e, s, r), s, r);
 }
-function ie(s) {
-  return Math.min(Math.max(s, 0), 1);
+function ue(n, t, e) {
+  return e <= n ? 0 : e >= t ? 1 : (e = (e - n) / (t - n), e * e * (3 - 2 * e));
 }
-function re(s, t, e, n = e) {
-  const i = Math.abs(s - t);
-  return i <= n || i <= e * Math.max(Math.abs(s), Math.abs(t));
+function pe(n) {
+  return Math.min(Math.max(n, 0), 1);
 }
-const D = 1e-6, L = /* @__PURE__ */ new p(), S = /* @__PURE__ */ new p(), u = /* @__PURE__ */ new p(), m = /* @__PURE__ */ new p(), z = /* @__PURE__ */ new p(), ft = /* @__PURE__ */ new p(), gt = /* @__PURE__ */ new rt(), wt = /* @__PURE__ */ new ot(), mt = /* @__PURE__ */ new at();
-class W {
-  constructor(t = 0, e = 0, n = 0, i = 0) {
+function fe(n, t, e, s = e) {
+  const r = Math.abs(n - t);
+  return r <= s || r <= e * Math.max(Math.abs(n), Math.abs(t));
+}
+const U = 1e-6, S = /* @__PURE__ */ new p(), b = /* @__PURE__ */ new p(), u = /* @__PURE__ */ new p(), m = /* @__PURE__ */ new p(), z = /* @__PURE__ */ new p(), bt = /* @__PURE__ */ new p(), Mt = /* @__PURE__ */ new lt(), Et = /* @__PURE__ */ new ct(), It = /* @__PURE__ */ new dt();
+class Q {
+  constructor(t = 0, e = 0, s = 0, r = 0) {
     // Distance from the target.
-    l(this, "_distance");
+    d(this, "_distance");
     // Radians from the local east direction relative from true north, measured
     // clockwise (90 degrees is true north, and -90 is true south).
-    l(this, "heading");
+    d(this, "heading");
     // Radians from the local horizon plane, measured with positive values looking
     // up (90 degrees is straight up, -90 is straight down).
-    l(this, "_pitch");
-    l(this, "roll");
-    this.distance = t, this.heading = e, this.pitch = n, this.roll = i;
+    d(this, "_pitch");
+    d(this, "roll");
+    this.distance = t, this.heading = e, this.pitch = s, this.roll = r;
   }
   get distance() {
     return this._distance;
   }
   set distance(t) {
-    this._distance = Math.max(t, D);
+    this._distance = Math.max(t, U);
   }
   get pitch() {
     return this._pitch;
   }
   set pitch(t) {
-    this._pitch = yt(t, -Math.PI / 2 + D, Math.PI / 2 - D);
+    this._pitch = V(t, -Math.PI / 2 + U, Math.PI / 2 - U);
   }
-  set(t, e, n, i) {
-    return this.distance = t, this.heading = e, this.pitch = n, i != null && (this.roll = i), this;
+  set(t, e, s, r) {
+    return this.distance = t, this.heading = e, this.pitch = s, r != null && (this.roll = r), this;
   }
   clone() {
-    return new W(this.distance, this.heading, this.pitch, this.roll);
+    return new Q(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;
@@ -218,46 +261,46 @@ class W {
   equals(t) {
     return t.distance === this.distance && t.heading === this.heading && t.pitch === this.pitch && t.roll === this.roll;
   }
-  decompose(t, e, n, i, r = B.WGS84) {
-    r.getEastNorthUpVectors(
+  decompose(t, e, s, r, i = C.WGS84) {
+    i.getEastNorthUpVectors(
       t,
-      L,
       S,
+      b,
       u
-    ), i == null || i.copy(u);
-    const o = m.copy(L).multiplyScalar(Math.cos(this.heading)).add(
-      z.copy(S).multiplyScalar(Math.sin(this.heading))
+    ), r == null || r.copy(u);
+    const o = m.copy(S).multiplyScalar(Math.cos(this.heading)).add(
+      z.copy(b).multiplyScalar(Math.sin(this.heading))
     ).multiplyScalar(Math.cos(this.pitch)).add(z.copy(u).multiplyScalar(Math.sin(this.pitch))).normalize().multiplyScalar(this.distance);
     if (e.copy(t).sub(o), this.roll !== 0) {
       const a = m.copy(t).sub(e).normalize();
       u.applyQuaternion(
-        wt.setFromAxisAngle(a, this.roll)
+        Et.setFromAxisAngle(a, this.roll)
       );
     }
-    n.setFromRotationMatrix(
-      gt.lookAt(e, t, u)
+    s.setFromRotationMatrix(
+      Mt.lookAt(e, t, u)
     );
   }
-  setFromCamera(t, e = B.WGS84) {
-    const n = m.setFromMatrixPosition(t.matrixWorld), i = z.set(0, 0, 0.5).unproject(t).sub(n).normalize(), r = e.getIntersection(mt.set(n, i));
-    if (r == null)
+  setFromCamera(t, e = C.WGS84) {
+    const s = m.setFromMatrixPosition(t.matrixWorld), r = z.set(0, 0, 0.5).unproject(t).sub(s).normalize(), i = e.getIntersection(It.set(s, r));
+    if (i == null)
       return;
-    this.distance = n.distanceTo(r), e.getEastNorthUpVectors(
-      r,
-      L,
+    this.distance = s.distanceTo(i), e.getEastNorthUpVectors(
+      i,
       S,
+      b,
       u
     ), this.heading = Math.atan2(
-      S.dot(i),
-      L.dot(i)
-    ), this.pitch = Math.asin(u.dot(i));
-    const o = m.copy(t.up).applyQuaternion(t.quaternion), a = ft.copy(i).multiplyScalar(-o.dot(i)).add(o).normalize(), h = m.copy(i).multiplyScalar(-u.dot(i)).add(u).normalize(), c = h.dot(a), f = i.dot(h.cross(a));
+      b.dot(r),
+      S.dot(r)
+    ), this.pitch = Math.asin(u.dot(r));
+    const o = m.copy(t.up).applyQuaternion(t.quaternion), a = bt.copy(r).multiplyScalar(-o.dot(r)).add(o).normalize(), h = m.copy(r).multiplyScalar(-u.dot(r)).add(u).normalize(), c = h.dot(a), f = r.dot(h.cross(a));
     return this.roll = Math.atan2(f, c), this;
   }
 }
 const x = class x {
-  constructor(t = 0, e = 0, n = 0, i = 0) {
-    this.west = t, this.south = e, this.east = n, this.north = i;
+  constructor(t = 0, e = 0, s = 0, r = 0) {
+    this.west = t, this.south = e, this.east = s, this.north = r;
   }
   get width() {
     let t = this.east;
@@ -266,8 +309,8 @@ const x = class x {
   get height() {
     return this.north - this.south;
   }
-  set(t, e, n, i) {
-    return this.west = t, this.south = e, this.east = n, this.north = i, this;
+  set(t, e, s, r) {
+    return this.west = t, this.south = e, this.east = s, this.north = r, this;
   }
   clone() {
     return new x(this.west, this.south, this.east, this.north);
@@ -278,8 +321,8 @@ const x = class x {
   equals(t) {
     return t.west === this.west && t.south === this.south && t.east === this.east && t.north === this.north;
   }
-  at(t, e, n = new w()) {
-    return n.set(
+  at(t, e, s = new w()) {
+    return s.set(
       this.west + (this.east - this.west) * t,
       this.north + (this.south - this.north) * e
     );
@@ -294,48 +337,59 @@ const x = class x {
     yield this.west, yield this.south, yield this.east, yield this.north;
   }
 };
-l(x, "MAX", /* @__PURE__ */ new x(
+d(x, "MAX", /* @__PURE__ */ new x(
   w.MIN_LONGITUDE,
   w.MIN_LATITUDE,
   w.MAX_LONGITUDE,
   w.MAX_LATITUDE
 ));
 let M = x;
-const xt = /^[ \t]*#include +"([\w\d./]+)"/gm;
-function Tt(s, t) {
-  return s.replace(xt, (e, n) => {
-    const r = n.split("/").reduce(
+const Dt = /^[ \t]*#include +"([\w\d./]+)"/gm;
+function Ut(n, t) {
+  return n.replace(Dt, (e, s) => {
+    const i = s.split("/").reduce(
       (o, a) => typeof o != "string" && o != null ? o[a] : void 0,
       t
     );
-    if (typeof r != "string")
-      throw new Error(`Could not find include for ${n}.`);
-    return Tt(r, t);
+    if (typeof i != "string")
+      throw new Error(`Could not find include for ${s}.`);
+    return Ut(i, t);
   });
 }
-function* V(s, t, e, n, i) {
-  if (e >= n)
+const ye = v(Tt, {
+  format: ut,
+  minFilter: R,
+  magFilter: R,
+  wrapS: D,
+  wrapT: D,
+  wrapR: D,
+  width: yt,
+  height: gt,
+  depth: wt
+});
+function* Y(n, t, e, s, r) {
+  if (e >= s)
     return;
-  const r = 2 ** e, o = e + 1, a = 2 ** o, h = Math.floor(s / r * a), c = Math.floor(t / r * a), f = [
+  const i = 2 ** e, o = e + 1, a = 2 ** o, h = Math.floor(n / i * a), c = Math.floor(t / i * a), f = [
     [h, c, o],
     [h + 1, c, o],
     [h, c + 1, o],
     [h + 1, c + 1, o]
   ];
-  if (o < n)
-    for (const g of f)
-      for (const I of V(...g, n, i))
+  if (o < s)
+    for (const y of f)
+      for (const I of Y(...y, s, r))
         yield I;
   else
-    for (const g of f)
-      yield (i ?? new T()).set(...g);
+    for (const y of f)
+      yield (r ?? new T()).set(...y);
 }
 class T {
-  constructor(t = 0, e = 0, n = 0) {
-    this.x = t, this.y = e, this.z = n;
+  constructor(t = 0, e = 0, s = 0) {
+    this.x = t, this.y = e, this.z = s;
   }
-  set(t, e, n) {
-    return this.x = t, this.y = e, n != null && (this.z = n), this;
+  set(t, e, s) {
+    return this.x = t, this.y = e, s != null && (this.z = s), this;
   }
   clone() {
     return new T(this.x, this.y, this.z);
@@ -347,12 +401,12 @@ class T {
     return t.x === this.x && t.y === this.y && t.z === this.z;
   }
   getParent(t = new T()) {
-    const e = 2 ** this.z, n = this.x / e, i = this.y / e, r = this.z - 1, o = 2 ** r;
-    return t.set(Math.floor(n * o), Math.floor(i * o), r);
+    const e = 2 ** this.z, s = this.x / e, r = this.y / e, i = this.z - 1, o = 2 ** i;
+    return t.set(Math.floor(s * o), Math.floor(r * o), i);
   }
   *traverseChildren(t, e) {
-    const { x: n, y: i, z: r } = this;
-    for (const o of V(n, i, r, r + t, e))
+    const { x: s, y: r, z: i } = this;
+    for (const o of Y(s, r, i, i + t, e))
       yield o;
   }
   fromArray(t, e = 0) {
@@ -365,100 +419,105 @@ class T {
     yield this.x, yield this.y, yield this.z;
   }
 }
-const O = /* @__PURE__ */ new C();
-class j {
-  constructor(t = 2, e = 1, n = M.MAX) {
-    this.width = t, this.height = e, this.rectangle = n;
+const q = /* @__PURE__ */ new H();
+class $ {
+  constructor(t = 2, e = 1, s = M.MAX) {
+    this.width = t, this.height = e, this.rectangle = s;
   }
   clone() {
-    return new j(this.width, this.height, this.rectangle.clone());
+    return new $(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, e = new C()) {
+  getSize(t, e = new H()) {
     return e.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, e, n = new T()) {
-    const i = this.getSize(e, O), r = this.rectangle.width / i.x, o = this.rectangle.height / i.y;
+  getTile(t, e, s = new T()) {
+    const r = this.getSize(e, q), i = this.rectangle.width / r.x, o = this.rectangle.height / r.y;
     let a = t.longitude;
     this.rectangle.east < this.rectangle.west && (a += Math.PI * 2);
-    let h = Math.floor((a - this.rectangle.west) / r);
-    h >= i.x && (h = i.x - 1);
+    let h = Math.floor((a - this.rectangle.west) / i);
+    h >= r.x && (h = r.x - 1);
     let c = Math.floor((t.latitude - this.rectangle.south) / o);
-    return c >= i.y && (c = i.y - 1), n.x = h, n.y = c, n.z = e, n;
+    return c >= r.y && (c = r.y - 1), s.x = h, s.y = c, s.z = e, s;
   }
   // Reference: https://github.com/CesiumGS/cesium/blob/1.122/packages/engine/Source/Core/GeographicTilingScheme.js#L169
   getRectangle(t, e = new M()) {
-    const n = this.getSize(t.z, O), i = this.rectangle.width / n.x, r = this.rectangle.height / n.y;
-    return e.west = t.x * i + this.rectangle.west, e.east = (t.x + 1) * i + this.rectangle.west, e.north = this.rectangle.north - (n.y - t.y - 1) * r, e.south = this.rectangle.north - (n.y - t.y) * r, e;
+    const s = this.getSize(t.z, q), r = this.rectangle.width / s.x, i = this.rectangle.height / s.y;
+    return e.west = t.x * r + this.rectangle.west, e.east = (t.x + 1) * r + this.rectangle.west, e.north = this.rectangle.north - (s.y - t.y - 1) * i, e.south = this.rectangle.north - (s.y - t.y) * i, e;
   }
 }
-const At = /#pragma unroll_loop_start\s+for\s*\(\s*int\s+i\s*=\s*(\d+)\s*;\s*i\s*<\s*(\d+)\s*;\s*(?:i\s*\+\+|\+\+\s*i)\s*\)\s*{([\s\S]+?)}\s+#pragma unroll_loop_end/g;
-function Lt(s, t, e, n) {
-  let i = "";
-  for (let r = parseInt(t); r < parseInt(e); ++r)
-    i += n.replace(/\[\s*i\s*\]/g, "[" + r + "]").replace(/UNROLLED_LOOP_INDEX/g, `${r}`);
-  return i;
+const zt = /#pragma unroll_loop_start\s+for\s*\(\s*int\s+i\s*=\s*(\d+)\s*;\s*i\s*<\s*(\d+)\s*;\s*(?:i\s*\+\+|\+\+\s*i)\s*\)\s*{([\s\S]+?)}\s+#pragma unroll_loop_end/g;
+function Pt(n, t, e, s) {
+  let r = "";
+  for (let i = parseInt(t); i < parseInt(e); ++i)
+    r += s.replace(/\[\s*i\s*\]/g, "[" + i + "]").replace(/UNROLLED_LOOP_INDEX/g, `${i}`);
+  return r;
 }
-function oe(s) {
-  return s.replace(At, Lt);
+function ge(n) {
+  return n.replace(zt, Pt);
 }
 export {
-  ct as ArrayBufferLoader,
-  pt as DataLoader,
-  B as Ellipsoid,
-  ce as EllipsoidGeometry,
-  Gt as Float32ArrayLoader,
-  Vt as Float32Data2DLoader,
-  jt as Float32Data3DLoader,
+  ft as ArrayBufferLoader,
+  Rt as DEFAULT_STBN_URL,
+  St as DataLoader,
+  C as Ellipsoid,
+  xe as EllipsoidGeometry,
+  jt as Float32ArrayLoader,
+  Jt as Float32Data2DLoader,
+  Zt as Float32Data3DLoader,
   w as Geodetic,
-  Ct as Int16ArrayLoader,
-  Xt as Int16Data2DLoader,
-  W as PointOfView,
+  Xt as Int16ArrayLoader,
+  Yt as Int16Data2DLoader,
+  Q as PointOfView,
   M as Rectangle,
-  Pt as STBN_TEXTURE_DEPTH,
-  Ut as STBN_TEXTURE_HEIGHT,
-  bt as STBN_TEXTURE_WIDTH,
+  ye as STBNLoader,
+  wt as STBN_TEXTURE_DEPTH,
+  gt as STBN_TEXTURE_HEIGHT,
+  yt as STBN_TEXTURE_WIDTH,
   T as TileCoordinate,
-  j as TilingScheme,
-  dt as TypedArrayLoader,
-  Rt as Uint16ArrayLoader,
-  Wt as Uint16Data2DLoader,
-  It as assertType,
-  Zt as ceilPowerOfTwo,
-  yt as clamp,
-  re as closeTo,
-  qt as createData3DTextureLoader,
-  X as createData3DTextureLoaderClass,
-  Ht as createDataTextureLoader,
+  $ as TilingScheme,
+  At as TypedArrayLoader,
+  kt as Uint16ArrayLoader,
+  $t as Uint16Data2DLoader,
+  Bt as assertType,
+  ae as ceilPowerOfTwo,
+  V as clamp,
+  fe as closeTo,
+  Vt as createData3DTextureLoader,
+  v as createData3DTextureLoaderClass,
+  Qt as createDataTextureLoader,
   E as createDataTextureLoaderClass,
-  Ot as createTypedArrayLoader,
+  Wt as createTypedArrayLoader,
   A as createTypedArrayLoaderClass,
-  Jt as degrees,
-  kt as euclideanModulo,
-  te as floorPowerOfTwo,
-  zt as fromBufferGeometryLike,
-  lt as getTypedArrayElementType,
-  Qt as inverseLerp,
-  Kt as isPowerOfTwo,
-  Yt as lerp,
-  ee as normalize,
-  U as parseFloat32Array,
-  Nt as parseFloat64Array,
-  q as parseInt16Array,
-  _t as parseInt32Array,
-  vt as parseInt8Array,
-  G as parseUint16Array,
-  Bt as parseUint32Array,
-  Ft as parseUint8Array,
-  $t as radians,
-  se as remap,
-  Tt as resolveIncludes,
-  ie as saturate,
-  ne as smoothstep,
-  Dt as toBufferGeometryLike,
-  oe as unrollLoops
+  Kt as definePropertyShorthand,
+  te as defineUniformShorthand,
+  ie as degrees,
+  ee as euclideanModulo,
+  he as floorPowerOfTwo,
+  Ot as fromBufferGeometryLike,
+  mt as getTypedArrayElementType,
+  ne as inverseLerp,
+  oe as isPowerOfTwo,
+  se as lerp,
+  ce as normalize,
+  F as parseFloat32Array,
+  Ht as parseFloat64Array,
+  k as parseInt16Array,
+  Gt as parseInt32Array,
+  Ct as parseInt8Array,
+  X as parseUint16Array,
+  qt as parseUint32Array,
+  Tt as parseUint8Array,
+  re as radians,
+  le as remap,
+  de as remapClamped,
+  Ut as resolveIncludes,
+  pe as saturate,
+  ue as smoothstep,
+  Nt as toBufferGeometryLike,
+  ge as unrollLoops
 };
 //# sourceMappingURL=index.js.map