@cearth/tools 2.5.0 → 2.7.0

package/dist/tools.js

@@ -1,599 +1,599 @@
-import { WebGLConstants as P, Cartesian3 as l, HeadingPitchRoll as I, Quaternion as w, Matrix3 as g, Matrix4 as a, TranslationRotationScale as M, Plane as rt, Transforms as E, BoundingSphere as C, JulianDate as h, Cartesian2 as x, ComponentDatatype as Z, Cartographic as D, Cartesian4 as O, Rectangle as v, Matrix2 as F } from "cesium";
-import { MatrixComposeOrder as _, mat4_decompose_quat as at, mat4_compose_quat as st, getMatrixOfQuantizedMeshTerrainData as ct, Geometry as lt, workerApi as ut, GeometricRelation as z, computeSignAreaOfPolygon3 as K, computeRelationAreaOfPolygon2Terrain as ft } from "@web-3d/tools";
-function Lt(t) {
-  return q(t) || J(t) || mt(t);
+import { WebGLConstants as M, Cartesian3 as u, HeadingPitchRoll as I, Quaternion as w, Matrix3 as g, Matrix4 as s, TranslationRotationScale as R, Plane as an, Transforms as E, BoundingSphere as C, JulianDate as h, Cartesian2 as x, ComponentDatatype as Z, Cartographic as D, Cartesian4 as O, Rectangle as v, Matrix2 as N } from "cesium";
+import { MatrixComposeOrder as F, mat4_decompose_quat as cn, mat4_compose_quat as ln, getMatrixOfQuantizedMeshTerrainData as un, Geometry as fn, workerApi as mn, GeometricRelation as z, computeSignAreaOfPolygon3 as K, computeRelationAreaOfPolygon2Terrain as pn } from "@web-3d/tools";
+function Yn(n) {
+  return q(n) || J(n) || dn(n);
 }
-function q(t) {
-  return "modelMatrix" in t;
+function q(n) {
+  return "modelMatrix" in n;
 }
-function J(t) {
-  return "position" in t;
+function J(n) {
+  return "position" in n;
 }
-function mt(t) {
-  return "positions" in t;
+function dn(n) {
+  return "positions" in n;
 }
-const pt = {
+const yn = {
   /**
    * 8-bit signed byte corresponding to <code>gl.BYTE</code> and the type
    * of an element in <code>Int8Array</code>.
    */
-  [P.BYTE]: Int8Array,
+  [M.BYTE]: Int8Array,
   /**
    * 8-bit unsigned byte corresponding to <code>UNSIGNED_BYTE</code> and the type
    * of an element in <code>Uint8Array</code>.
    */
-  [P.UNSIGNED_BYTE]: Uint8Array,
+  [M.UNSIGNED_BYTE]: Uint8Array,
   /**
    * 16-bit signed short corresponding to <code>SHORT</code> and the type
    * of an element in <code>Int16Array</code>.
    */
-  [P.SHORT]: Int16Array,
+  [M.SHORT]: Int16Array,
   /**
    * 16-bit unsigned short corresponding to <code>UNSIGNED_SHORT</code> and the type
    * of an element in <code>Uint16Array</code>.
    */
-  [P.UNSIGNED_SHORT]: Uint16Array,
+  [M.UNSIGNED_SHORT]: Uint16Array,
   /**
    * 32-bit signed int corresponding to <code>INT</code> and the type
    * of an element in <code>Int32Array</code>.
    */
-  [P.INT]: Int32Array,
+  [M.INT]: Int32Array,
   /**
    * 32-bit unsigned int corresponding to <code>UNSIGNED_INT</code> and the type
    * of an element in <code>Uint32Array</code>.
    */
-  [P.UNSIGNED_INT]: Uint32Array,
+  [M.UNSIGNED_INT]: Uint32Array,
   /**
    * 32-bit floating-point corresponding to <code>FLOAT</code> and the type
    * of an element in <code>Float32Array</code>.
    */
-  [P.FLOAT]: Float32Array,
+  [M.FLOAT]: Float32Array,
   /**
    * 64-bit floating-point corresponding to <code>gl.DOUBLE</code> (in Desktop OpenGL;
    * this is not supported in WebGL, and is emulated in Cesium via {@link GeometryPipeline.encodeAttribute})
    * and the type of an element in <code>Float64Array</code>.
    */
-  [P.DOUBLE]: Float64Array
+  [M.DOUBLE]: Float64Array
 };
-var dt = /* @__PURE__ */ ((t) => (t[t.x = 0] = "x", t[t.y = 1] = "y", t[t.z = 2] = "z", t))(dt || {}), b = /* @__PURE__ */ ((t) => (t.x = "roll", t.y = "pitch", t.z = "heading", t))(b || {});
-((t) => {
+var wn = /* @__PURE__ */ ((n) => (n[n.x = 0] = "x", n[n.y = 1] = "y", n[n.z = 2] = "z", n))(wn || {}), b = /* @__PURE__ */ ((n) => (n.x = "roll", n.y = "pitch", n.z = "heading", n))(b || {});
+((n) => {
   function o(i) {
-    for (let [r, s] of Object.entries(t))
-      if (i === s)
+    for (let [r, a] of Object.entries(n))
+      if (i === a)
         return r;
   }
-  t.toKey = o;
-  function n(i) {
-    return new l(i.roll, -i.pitch, -i.heading);
+  n.toKey = o;
+  function t(i) {
+    return new u(i.roll, -i.pitch, -i.heading);
   }
-  t.toCartesian3 = n;
+  n.toCartesian3 = t;
   function e(i) {
     return new I(-i[o("heading")], -i[o("pitch")], i[o("roll")]);
   }
-  t.toHeadingPitchRoll = e;
+  n.toHeadingPitchRoll = e;
 })(b || (b = {}));
-var yt = /* @__PURE__ */ ((t) => (t[t.heading = 0] = "heading", t[t.pitch = 1] = "pitch", t[t.roll = 2] = "roll", t))(yt || {});
-function $(t) {
-  const o = t?.world, { translation: n, rotation: e, scale: i } = o && typeof o == "object" ? o : { translation: o, rotation: o, scale: o };
-  return { ...t, worldTranslation: n, worldRotation: e, worldScale: i };
+var gn = /* @__PURE__ */ ((n) => (n[n.heading = 0] = "heading", n[n.pitch = 1] = "pitch", n[n.roll = 2] = "roll", n))(gn || {});
+function $(n) {
+  const o = n?.world, { translation: t, rotation: e, scale: i } = o && typeof o == "object" ? o : { translation: o, rotation: o, scale: o };
+  return { ...n, worldTranslation: t, worldRotation: e, worldScale: i };
 }
-function G(t) {
-  if (t.axis) {
-    const { axis: n, angle: e } = t;
-    return w.fromAxisAngle(n, e);
+function G(n) {
+  if (n.axis) {
+    const { axis: t, angle: e } = n;
+    return w.fromAxisAngle(t, e);
   }
-  const o = b.toHeadingPitchRoll(t);
+  const o = b.toHeadingPitchRoll(n);
   return w.fromHeadingPitchRoll(o);
 }
-function Ut(t, o, n) {
-  const e = g.fromQuaternion(t), i = a.fromRotation(e), r = a.inverseTransformation(o, new a()), s = a.multiply(r, i, i);
-  return tt(s);
+function jn(n, o, t) {
+  const e = g.fromQuaternion(n), i = s.fromRotation(e), r = s.inverseTransformation(o, new s()), a = s.multiply(r, i, i);
+  return nn(a);
 }
-function tt(t, o) {
-  const n = a.getMatrix3(t, new g()), e = w.fromRotationMatrix(n);
+function nn(n, o) {
+  const t = s.getMatrix3(n, new g()), e = w.fromRotationMatrix(t);
   return I.fromQuaternion(e, o);
 }
-function Yt(t, o, n) {
-  n = n ?? new a();
-  const e = a.inverse(o, new a());
-  return a.multiply(e, t, n);
-}
-function wt(t, o, n) {
-  let e = w.computeAxis(t, new l());
-  if (e.equals(l.ZERO)) return null;
-  const i = w.computeAngle(t);
-  return e = a.multiplyByPointAsVector(o, e, e), w.fromAxisAngle(e, i);
-}
-function jt(t, o, n) {
-  let e = w.computeAxis(t, new l());
-  if (e.equals(l.ZERO)) return null;
-  const i = w.computeAngle(t), r = a.inverse(o, new a());
-  return e = a.multiplyByPointAsVector(r, e, e), w.fromAxisAngle(e, i);
-}
-function L(t, o) {
-  let { translation: n, rotation: e, scale: i } = t;
-  const { referFrame: r, worldTranslation: s, worldRotation: c, worldScale: u } = $(o);
-  let f = null;
-  return n && (s || (n = a.multiplyByPointAsVector(r, n, new l()))), e && (f = G(e), c || (f = wt(f, r))), i && (u || (i = a.multiplyByPointAsVector(r, i, new l()))), { translation: n, rotation: f, scale: i };
-}
-function gt(t, o) {
-  let { translation: n, rotation: e, scale: i } = t;
-  const { referFrame: r, worldTranslation: s, worldRotation: c, worldScale: u } = $(o), f = r ? a.inverse(r, new a()) : null;
+function Wn(n, o, t) {
+  t = t ?? new s();
+  const e = s.inverse(o, new s());
+  return s.multiply(e, n, t);
+}
+function hn(n, o, t) {
+  let e = w.computeAxis(n, new u());
+  if (e.equals(u.ZERO)) return null;
+  const i = w.computeAngle(n);
+  return e = s.multiplyByPointAsVector(o, e, e), w.fromAxisAngle(e, i);
+}
+function Xn(n, o, t) {
+  let e = w.computeAxis(n, new u());
+  if (e.equals(u.ZERO)) return null;
+  const i = w.computeAngle(n), r = s.inverse(o, new s());
+  return e = s.multiplyByPointAsVector(r, e, e), w.fromAxisAngle(e, i);
+}
+function L(n, o) {
+  let { translation: t, rotation: e, scale: i } = n;
+  const { referFrame: r, worldTranslation: a, worldRotation: c, worldScale: f } = $(o);
+  let l = null;
+  return t && (a || (t = s.multiplyByPointAsVector(r, t, new u()))), e && (l = G(e), c || (l = hn(l, r))), i && (f || (i = s.multiplyByPointAsVector(r, i, new u()))), { translation: t, rotation: l, scale: i };
+}
+function xn(n, o) {
+  let { translation: t, rotation: e, scale: i } = n;
+  const { referFrame: r, worldTranslation: a, worldRotation: c, worldScale: f } = $(o), l = r ? s.inverse(r, new s()) : null;
   let m = null;
-  if (n && s && (n = a.multiplyByPointAsVector(f, n, new l())), e && (m = G(e), c)) {
-    let p = w.computeAxis(m, new l());
-    if (!p.equals(l.ZERO)) {
+  if (t && a && (t = s.multiplyByPointAsVector(l, t, new u())), e && (m = G(e), c)) {
+    let p = w.computeAxis(m, new u());
+    if (!p.equals(u.ZERO)) {
       const d = w.computeAngle(m);
-      p = a.multiplyByPointAsVector(f, p, p), m = w.fromAxisAngle(p, d);
+      p = s.multiplyByPointAsVector(l, p, p), m = w.fromAxisAngle(p, d);
     }
   }
-  return i && u && (i = a.multiplyByPointAsVector(f, i, new l())), { translation: n, rotation: m, scale: i };
+  return i && f && (i = s.multiplyByPointAsVector(l, i, new u())), { translation: t, rotation: m, scale: i };
 }
-function ht(t, o) {
-  const n = o?.defaultMatrix;
-  let { translation: e, rotation: i, scale: r } = L(t, o);
-  if (n) {
-    if (e || (e = a.getTranslation(n, new l())), !i) {
-      const c = a.getMatrix3(n, new g());
+function Tn(n, o) {
+  const t = o?.defaultMatrix;
+  let { translation: e, rotation: i, scale: r } = L(n, o);
+  if (t) {
+    if (e || (e = s.getTranslation(t, new u())), !i) {
+      const c = s.getMatrix3(t, new g());
       i = w.fromRotationMatrix(c);
     }
-    r || (r = a.getScale(n, new l()));
+    r || (r = s.getScale(t, new u()));
   }
-  const s = new M(e ?? void 0, i ?? void 0, r ?? void 0);
-  return a.fromTranslationRotationScale(s);
+  const a = new R(e ?? void 0, i ?? void 0, r ?? void 0);
+  return s.fromTranslationRotationScale(a);
 }
-function Wt(t) {
-  const { translation: o, rotation: n, scale: e } = t, i = n ? G(n) : void 0, r = new M(o ?? void 0, i, e ?? void 0);
-  return a.fromTranslationRotationScale(r);
+function Zn(n) {
+  const { translation: o, rotation: t, scale: e } = n, i = t ? G(t) : void 0, r = new R(o ?? void 0, i, e ?? void 0);
+  return s.fromTranslationRotationScale(r);
 }
-function xt(t, o, n) {
-  const e = l.subtract(o, t, new l()), i = l.subtract(n, t, new l()), r = l.cross(e, i, e);
-  return l.normalize(r, e);
+function vn(n, o, t) {
+  const e = u.subtract(o, n, new u()), i = u.subtract(t, n, new u()), r = u.cross(e, i, e);
+  return u.normalize(r, e);
 }
-function Xt(t, o, n) {
-  const e = xt(t, o, n);
-  return rt.fromPointNormal(e, t);
+function Kn(n, o, t) {
+  const e = vn(n, o, t);
+  return an.fromPointNormal(e, n);
 }
-function* Zt(t, o = !0, n, e) {
-  const i = t.length, r = o ? i : i - 1, s = n || e ? l.prototype.equalsEpsilon : l.prototype.equals;
+function* $n(n, o = !0, t, e) {
+  const i = n.length, r = o ? i : i - 1, a = t || e ? u.prototype.equalsEpsilon : u.prototype.equals;
   for (let c = 0; c < r; c++) {
-    const u = t[c];
-    let f = (c + 1) % i, m = t[f], p = c;
-    for (; s.call(u, m, n, e); ) {
-      if (f = (++p + 1) % i, f === c)
+    const f = n[c];
+    let l = (c + 1) % i, m = n[l], p = c;
+    for (; a.call(f, m, t, e); ) {
+      if (l = (++p + 1) % i, l === c)
         return;
-      m = t[f];
+      m = n[l];
     }
-    c = p, yield [u, m];
+    c = p, yield [f, m];
   }
 }
-function H(t, o, n) {
-  n = n ?? new a();
-  const e = a.inverse(o, new a()), i = a.multiply(t, e, e);
-  return a.multiply(o, i, n);
+function H(n, o, t) {
+  t = t ?? new s();
+  const e = s.inverse(o, new s()), i = s.multiply(n, e, e);
+  return s.multiply(o, i, t);
 }
-function Kt(t, o, n, e) {
-  e = e ?? new a();
-  const i = a.inverse(n, new a());
-  let r = a.multiply(i, t, i);
-  return r = a.multiply(o, r, r), a.multiply(n, r, e);
+function nt(n, o, t, e) {
+  e = e ?? new s();
+  const i = s.inverse(t, new s());
+  let r = s.multiply(i, n, i);
+  return r = s.multiply(o, r, r), s.multiply(t, r, e);
 }
-function $t(t, o, n) {
-  const e = a.fromTranslation(t);
-  return H(e, o, n);
+function tt(n, o, t) {
+  const e = s.fromTranslation(n);
+  return H(e, o, t);
 }
-function tn(t, o, n, e) {
-  const i = w.fromAxisAngle(t, o), r = g.fromQuaternion(i), s = a.fromRotation(r);
-  return H(s, n, e);
+function ot(n, o, t, e) {
+  const i = w.fromAxisAngle(n, o), r = g.fromQuaternion(i), a = s.fromRotation(r);
+  return H(a, t, e);
 }
-function nn(t, o, n) {
-  const e = a.fromScale(t);
-  return H(e, o, n);
+function et(n, o, t) {
+  const e = s.fromScale(n);
+  return H(e, o, t);
 }
-function on(t, o, n) {
+function it(n, o, t) {
   const e = g.fromScale(o);
-  if (n)
-    for (const i of t)
-      l.subtract(i, n, i), g.multiplyByVector(e, i, i), l.add(i, n, i);
+  if (t)
+    for (const i of n)
+      u.subtract(i, t, i), g.multiplyByVector(e, i, i), u.add(i, t, i);
   else {
     const i = g.fromScale(o);
-    for (const r of t)
+    for (const r of n)
       g.multiplyByVector(i, r, r);
   }
-  return t;
+  return n;
 }
-function en(t, o) {
-  const { translation: n, rotation: e, scale: i } = t;
+function rt(n, o) {
+  const { translation: t, rotation: e, scale: i } = n;
   let r;
   if (e) {
-    const { axis: c, angle: u } = e;
-    r = w.fromAxisAngle(c, u);
+    const { axis: c, angle: f } = e;
+    r = w.fromAxisAngle(c, f);
   }
-  const s = new M(n ?? void 0, r, i ?? void 0);
-  return a.fromTranslationRotationScale(s, o ?? void 0);
+  const a = new R(t ?? void 0, r, i ?? void 0);
+  return s.fromTranslationRotationScale(a, o ?? void 0);
 }
-function nt(t, o, n) {
-  n ??= new M();
-  const e = a.pack(t, []), i = [], r = [], s = [], c = o ? _[o] : _.trs;
-  return at(i, s, r, e, c), l.unpack(i, 0, n.translation), l.unpack(r, 0, n.scale), w.unpack(s, 0, n.rotation), n;
+function tn(n, o, t) {
+  t ??= new R();
+  const e = s.pack(n, []), i = [], r = [], a = [], c = o ? F[o] : F.trs;
+  return cn(i, a, r, e, c), u.unpack(i, 0, t.translation), u.unpack(r, 0, t.scale), w.unpack(a, 0, t.rotation), t;
 }
-function rn(t, o) {
-  return nt(t, null, o);
+function st(n, o) {
+  return tn(n, null, o);
 }
-function Tt(t, o, n) {
-  const e = l.pack(t.translation, []), i = l.pack(t.scale, []), r = w.pack(t.rotation, []), s = o ? _[o] : _.trs, c = st([], e, r, i, s);
-  return a.unpack(c, 0, n);
+function An(n, o, t) {
+  const e = u.pack(n.translation, []), i = u.pack(n.scale, []), r = w.pack(n.rotation, []), a = o ? F[o] : F.trs, c = ln([], e, r, i, a);
+  return s.unpack(c, 0, t);
 }
-const an = a.fromTranslationRotationScale;
-function vt(t, o) {
-  const n = a.inverse(t, new a()), e = new a();
-  function i(s, c) {
-    return c = Tt(s, o, c), a.multiply(t, c, c);
+const at = s.fromTranslationRotationScale;
+function Mn(n, o) {
+  const t = s.inverse(n, new s()), e = new s();
+  function i(a, c) {
+    return c = An(a, o, c), s.multiply(n, c, c);
   }
-  function r(s, c) {
-    return a.multiply(n, s, e), nt(e, o, c);
+  function r(a, c) {
+    return s.multiply(t, a, e), tn(e, o, c);
   }
-  return { compose: i, decompose: r, referInverse: n };
+  return { compose: i, decompose: r, referInverse: t };
 }
-function sn(t, o, n) {
-  const e = E.eastNorthUpToFixedFrame(t, n ?? void 0);
-  return { ...vt(e, o), refer: e };
+function on(n, o, t) {
+  const e = E.eastNorthUpToFixedFrame(n, t ?? void 0);
+  return { ...Mn(e, o), refer: e };
 }
-function cn(t) {
-  let o = t.boundingSphere;
+function ct(n) {
+  let o = n.boundingSphere;
   if (o)
     return o;
-  let n = t.geometryInstances;
-  if (n) {
-    n = Array.isArray(n) ? n : [n];
-    const i = n.map((r) => r.geometry.boundingSphere);
+  let t = n.geometryInstances;
+  if (t) {
+    t = Array.isArray(t) ? t : [t];
+    const i = t.map((r) => r.geometry.boundingSphere);
     return C.fromBoundingSpheres(i);
   }
-  const e = t.positions;
+  const e = n.positions;
   return e?.length > 0 ? C.fromPoints(e) : null;
 }
-function ln(t, o) {
-  o = o ?? new l();
-  const n = t.position;
-  if (n)
-    return n instanceof l ? n : n.getValue(h.now(), o);
-  const e = t.modelMatrix;
+function lt(n, o) {
+  o = o ?? new u();
+  const t = n.position;
+  if (t)
+    return t instanceof u ? t : t.getValue(h.now(), o);
+  const e = n.modelMatrix;
   if (e)
-    return a.getTranslation(e, o);
-  const i = t.positions;
+    return s.getTranslation(e, o);
+  const i = n.positions;
   return i?.length > 0 ? C.fromPoints(i).center : null;
 }
-function un(t, o, n) {
-  let { translation: e, rotation: i, scale: r } = L(o, n);
-  const s = new M(e ?? void 0, i ?? void 0, r ?? void 0), c = a.fromTranslationRotationScale(s);
-  return At(t, c);
+function ut(n, o, t) {
+  let { translation: e, rotation: i, scale: r } = L(o, t);
+  const a = new R(e ?? void 0, i ?? void 0, r ?? void 0), c = s.fromTranslationRotationScale(a);
+  return Rn(n, c);
 }
-function At(t, o) {
-  const n = t.modelMatrix;
-  if (n)
-    return a.multiply(o, n, n), t.modelMatrix = n, !0;
-  const e = t.position;
+function Rn(n, o) {
+  const t = n.modelMatrix;
+  if (t)
+    return s.multiply(o, t, t), n.modelMatrix = t, !0;
+  const e = n.position;
   if (e) {
-    if ("scale" in t) {
-      const r = a.getTranslation(o, new l());
-      l.add(e, r, e);
-      const s = t.scale ?? 1, c = a.getScale(o, new l());
-      t.scale = l.maximumComponent(c) * s;
+    if ("scale" in n) {
+      const r = s.getTranslation(o, new u());
+      u.add(e, r, e);
+      const a = n.scale ?? 1, c = s.getScale(o, new u());
+      n.scale = u.maximumComponent(c) * a;
     } else
-      a.multiplyByPoint(o, e, e);
-    return t.position = e, !0;
+      s.multiplyByPoint(o, e, e);
+    return n.position = e, !0;
   }
-  const i = t.positions;
+  const i = n.positions;
   if (i?.length > 0) {
     for (const r of i)
-      a.multiplyByPoint(o, r, r);
-    return t.positions = i, !0;
+      s.multiplyByPoint(o, r, r);
+    return n.positions = i, !0;
   }
   return !1;
 }
-function fn(t, o, n) {
-  const e = Mt(t), i = ht(o, { ...n, defaultMatrix: e });
-  return Pt(t, i);
-}
-function Pt(t, o) {
-  if (q(t))
-    return t.modelMatrix = o, !0;
-  const n = a.getTranslation(o, new l());
-  if (J(t)) {
-    if (t.position = n, "scale" in t) {
-      const i = a.getScale(o, new l());
-      t.scale = l.maximumComponent(i);
+function ft(n, o, t) {
+  const e = Sn(n), i = Tn(o, { ...t, defaultMatrix: e });
+  return Pn(n, i);
+}
+function Pn(n, o) {
+  if (q(n))
+    return n.modelMatrix = o, !0;
+  const t = s.getTranslation(o, new u());
+  if (J(n)) {
+    if (n.position = t, "scale" in n) {
+      const i = s.getScale(o, new u());
+      n.scale = u.maximumComponent(i);
     }
     return !0;
   }
-  const e = t.positions;
+  const e = n.positions;
   if (e?.length > 0) {
     const i = C.fromPoints(e);
-    l.subtract(n, i.center, n);
+    u.subtract(t, i.center, t);
     for (const r of e)
-      l.add(r, n, r);
-    return t.positions = e, !0;
+      u.add(r, t, r);
+    return n.positions = e, !0;
   }
   return !1;
 }
-function Mt(t) {
-  if (q(t))
-    return t.modelMatrix;
-  if (J(t)) {
-    const n = t.position, e = t.scale ?? 1, i = new M(n, void 0, new l(e, e, e));
-    return a.fromTranslationRotationScale(i);
+function Sn(n) {
+  if (q(n))
+    return n.modelMatrix;
+  if (J(n)) {
+    const t = n.position, e = n.scale ?? 1, i = new R(t, void 0, new u(e, e, e));
+    return s.fromTranslationRotationScale(i);
   }
-  const o = t.positions;
+  const o = n.positions;
   if (o?.length > 0) {
-    const n = C.fromPoints(o);
-    return a.fromTranslation(n.center);
+    const t = C.fromPoints(o);
+    return s.fromTranslation(t.center);
   }
   return null;
 }
-function mn(t, o) {
-  let { translation: n, rotation: e, scale: i } = L(o, o);
-  const { reset: r, referFrame: s } = o, c = h.now(), u = !r;
+function mt(n, o) {
+  let { translation: t, rotation: e, scale: i } = L(o, o);
+  const { reset: r, referFrame: a } = o, c = h.now(), f = !r;
   if (e) {
     let A = e;
-    if (u) {
-      const T = t.orientation?.getValue(c);
+    if (f) {
+      const T = n.orientation?.getValue(c);
       T && (A = w.multiply(e, T, T));
     }
-    t.orientation = A;
+    n.orientation = A;
   }
-  if (n) {
-    let A = n;
-    if (u) {
-      const T = t.position?.getValue(c);
-      T && (A = l.add(T, n, T));
+  if (t) {
+    let A = t;
+    if (f) {
+      const T = n.position?.getValue(c);
+      T && (A = u.add(T, t, T));
     }
-    t.position = A;
-  }
-  if (!s) return;
-  const { translation: f, rotation: m, scale: p } = gt(o, o), d = new M(f ?? void 0, m ?? void 0, p ?? void 0);
-  let y = a.fromTranslationRotationScale(d);
-  if (y = H(y, s, y), p) {
-    const A = t.box;
-    A && Rt(A, p);
-    const T = t.cylinder;
-    T && St(T, p);
-    const Y = t.ellipse;
-    Y && Dt(Y, p);
-    const j = t.ellipsoid;
-    j && Vt(j, p);
-    const W = t.model;
-    W && Bt(W, p, r);
-    const X = t.plane;
-    X && It(X, p);
-  }
-  const R = t.corridor;
-  R && Ot(R, y, p);
-  const V = t.polygon;
-  V && Ct(V, y, p);
-  const S = t.polyline;
-  S && bt(S, y, p);
-  const B = t.polylineVolume;
-  B && Nt(B, y, p);
-  const N = t.wall;
-  N && Ft(N, y, p);
-}
-function Rt(t, o) {
-  const n = h.now(), e = t.dimensions?.getValue(n);
-  e && (t.dimensions = l.multiplyComponents(e, o, e));
-}
-function St(t, o) {
-  const n = h.now(), e = t.length?.getValue(n);
-  e != null && (t.length = e * o.z);
-  const i = Math.max(o.x, o.y), r = t.topRadius?.getValue(n);
-  r != null && (t.topRadius = r * i);
-  const s = o.z, c = t.bottomRadius?.getValue(n);
-  c != null && (t.bottomRadius = c * s);
-}
-function Dt(t, o) {
-  const n = h.now(), e = Math.max(o.x, o.y), i = o.z, r = t.semiMajorAxis?.getValue(n);
-  r != null && (t.semiMajorAxis = r * e);
-  const s = t.semiMinorAxis?.getValue(n);
-  s != null && (t.semiMinorAxis = s * e);
-  const c = t.height?.getValue(n);
-  c != null && (t.height = c * i);
-  const u = t.extrudedHeight?.getValue(n);
-  u != null && (t.extrudedHeight = u * i);
-}
-function Vt(t, o) {
-  const n = h.now(), e = t.radii?.getValue(n);
-  e != null && (t.radii = l.multiplyComponents(e, o, e));
-  const i = t.innerRadii?.getValue(n);
-  i != null && (t.innerRadii = l.multiplyComponents(i, o, i));
-}
-function Bt(t, o, n) {
-  let e = l.maximumComponent(o);
-  if (!n) {
-    const i = h.now(), r = t.scale?.getValue(i) ?? 1;
+    n.position = A;
+  }
+  if (!a) return;
+  const { translation: l, rotation: m, scale: p } = xn(o, o), d = new R(l ?? void 0, m ?? void 0, p ?? void 0);
+  let y = s.fromTranslationRotationScale(d);
+  if (y = H(y, a, y), p) {
+    const A = n.box;
+    A && Dn(A, p);
+    const T = n.cylinder;
+    T && Vn(T, p);
+    const Y = n.ellipse;
+    Y && Bn(Y, p);
+    const j = n.ellipsoid;
+    j && In(j, p);
+    const W = n.model;
+    W && On(W, p, r);
+    const X = n.plane;
+    X && Cn(X, p);
+  }
+  const P = n.corridor;
+  P && bn(P, y, p);
+  const V = n.polygon;
+  V && _n(V, y, p);
+  const S = n.polyline;
+  S && Nn(S, y, p);
+  const B = n.polylineVolume;
+  B && Fn(B, y, p);
+  const _ = n.wall;
+  _ && zn(_, y, p);
+}
+function Dn(n, o) {
+  const t = h.now(), e = n.dimensions?.getValue(t);
+  e && (n.dimensions = u.multiplyComponents(e, o, e));
+}
+function Vn(n, o) {
+  const t = h.now(), e = n.length?.getValue(t);
+  e != null && (n.length = e * o.z);
+  const i = Math.max(o.x, o.y), r = n.topRadius?.getValue(t);
+  r != null && (n.topRadius = r * i);
+  const a = o.z, c = n.bottomRadius?.getValue(t);
+  c != null && (n.bottomRadius = c * a);
+}
+function Bn(n, o) {
+  const t = h.now(), e = Math.max(o.x, o.y), i = o.z, r = n.semiMajorAxis?.getValue(t);
+  r != null && (n.semiMajorAxis = r * e);
+  const a = n.semiMinorAxis?.getValue(t);
+  a != null && (n.semiMinorAxis = a * e);
+  const c = n.height?.getValue(t);
+  c != null && (n.height = c * i);
+  const f = n.extrudedHeight?.getValue(t);
+  f != null && (n.extrudedHeight = f * i);
+}
+function In(n, o) {
+  const t = h.now(), e = n.radii?.getValue(t);
+  e != null && (n.radii = u.multiplyComponents(e, o, e));
+  const i = n.innerRadii?.getValue(t);
+  i != null && (n.innerRadii = u.multiplyComponents(i, o, i));
+}
+function On(n, o, t) {
+  let e = u.maximumComponent(o);
+  if (!t) {
+    const i = h.now(), r = n.scale?.getValue(i) ?? 1;
     e *= r;
   }
-  t.scale = e;
+  n.scale = e;
 }
-function It(t, o) {
-  const n = h.now(), e = x.fromCartesian3(o), i = t.dimensions?.getValue(n);
-  i && (t.dimensions = x.multiplyComponents(i, e, i));
+function Cn(n, o) {
+  const t = h.now(), e = x.fromCartesian3(o), i = n.dimensions?.getValue(t);
+  i && (n.dimensions = x.multiplyComponents(i, e, i));
 }
-function Ot(t, o, n) {
-  const e = h.now(), i = new l(), r = t.positions?.getValue(e);
+function bn(n, o, t) {
+  const e = h.now(), i = new u(), r = n.positions?.getValue(e);
   if (r?.length > 0) {
     for (const p of r)
-      a.multiplyByPoint(o, p, p);
-    t.dimensions = r;
-  }
-  const s = n ?? a.getScale(o, i), c = Math.max(s.x, s.y);
-  t.width?.getValue(e) != null && (t.width = c * scale);
-  const f = t.height?.getValue(e), m = s.z;
-  f != null && (t.height = f * m);
-}
-function Ct(t, o, n) {
-  const e = h.now(), i = new l(), r = t.hierarchy?.getValue(e);
-  r && (ot(r, o), t.hierarchy = r);
-  const c = (n ?? a.getScale(o, i)).z, u = t.height?.getValue(e);
-  u != null && (t.height = u * c);
-  const f = t.extrudedHeight?.getValue(e);
-  f != null && (t.extrudedHeight = f * c);
-}
-function ot(t, o) {
-  const { positions: n, holes: e } = t;
-  for (const i of n)
-    a.multiplyByPoint(o, i, i);
-  t.positions = n;
+      s.multiplyByPoint(o, p, p);
+    n.dimensions = r;
+  }
+  const a = t ?? s.getScale(o, i), c = Math.max(a.x, a.y);
+  n.width?.getValue(e) != null && (n.width = c * scale);
+  const l = n.height?.getValue(e), m = a.z;
+  l != null && (n.height = l * m);
+}
+function _n(n, o, t) {
+  const e = h.now(), i = new u(), r = n.hierarchy?.getValue(e);
+  r && (en(r, o), n.hierarchy = r);
+  const c = (t ?? s.getScale(o, i)).z, f = n.height?.getValue(e);
+  f != null && (n.height = f * c);
+  const l = n.extrudedHeight?.getValue(e);
+  l != null && (n.extrudedHeight = l * c);
+}
+function en(n, o) {
+  const { positions: t, holes: e } = n;
+  for (const i of t)
+    s.multiplyByPoint(o, i, i);
+  n.positions = t;
   for (const i of e)
-    ot(i, o);
+    en(i, o);
 }
-function bt(t, o, n) {
-  const e = h.now(), i = new l(), r = t.positions?.getValue(e);
+function Nn(n, o, t) {
+  const e = h.now(), i = new u(), r = n.positions?.getValue(e);
   if (r?.length > 0) {
-    for (const f of r)
-      a.multiplyByPoint(o, f, f);
-    t.positions = r;
+    for (const l of r)
+      s.multiplyByPoint(o, l, l);
+    n.positions = r;
   }
-  const s = n ?? a.getScale(o, i), c = Math.max(s.x, s.y);
-  t.width?.getValue(e) != null && (t.width = c * scale);
+  const a = t ?? s.getScale(o, i), c = Math.max(a.x, a.y);
+  n.width?.getValue(e) != null && (n.width = c * scale);
 }
-function Nt(t, o, n) {
-  const e = h.now(), i = new l(), r = t.positions?.getValue(e);
+function Fn(n, o, t) {
+  const e = h.now(), i = new u(), r = n.positions?.getValue(e);
   if (r?.length > 0) {
-    for (const f of r)
-      a.multiplyByPoint(o, f, f);
-    t.positions = r;
+    for (const l of r)
+      s.multiplyByPoint(o, l, l);
+    n.positions = r;
   }
-  const s = n ?? a.getScale(o, i), c = x.fromCartesian3(s), u = t.shape?.getValue(e);
-  if (u != null) {
-    for (const f of u)
-      x.multiplyComponents(f, c, f);
-    t.shape = u;
+  const a = t ?? s.getScale(o, i), c = x.fromCartesian3(a), f = n.shape?.getValue(e);
+  if (f != null) {
+    for (const l of f)
+      x.multiplyComponents(l, c, l);
+    n.shape = f;
   }
 }
-function Ft(t, o, n) {
-  const e = h.now(), i = new l(), r = t.positions?.getValue(e);
+function zn(n, o, t) {
+  const e = h.now(), i = new u(), r = n.positions?.getValue(e);
   if (r?.length > 0) {
     for (const m of r)
-      a.multiplyByPoint(o, m, m);
-    t.positions = r;
+      s.multiplyByPoint(o, m, m);
+    n.positions = r;
   }
-  const c = (n ?? a.getScale(o, i)).z, u = t.minimumHeights?.getValue(e);
-  u != null && (graphicsgraphics.minimumHeights = u.map((m) => m * c));
-  const f = t.maximumHeights?.getValue(e);
-  f != null && (graphicsgraphics.maximumHeights = f.map((m) => m * c));
+  const c = (t ?? s.getScale(o, i)).z, f = n.minimumHeights?.getValue(e);
+  f != null && (graphicsgraphics.minimumHeights = f.map((m) => m * c));
+  const l = n.maximumHeights?.getValue(e);
+  l != null && (graphicsgraphics.maximumHeights = l.map((m) => m * c));
 }
-function pn(t, o, n) {
-  const e = h.now(), i = t.position?.getValue(e);
+function pt(n, o, t) {
+  const e = h.now(), i = n.position?.getValue(e);
   if (!i) return null;
-  const r = t.orientation?.getValue(e), s = t.model?.scale?.getValue(e) ?? 1, c = new l(s, s, s), u = o(i, n), f = a.inverse(u, new a()), m = a.multiplyByPoint(f, i, new l()), p = { translation: m, position: i, scale: c, rotation: new l() };
+  const r = n.orientation?.getValue(e), a = n.model?.scale?.getValue(e) ?? 1, c = new u(a, a, a), f = o(i, t), l = s.inverse(f, new s()), m = s.multiplyByPoint(l, i, new u()), p = { translation: m, position: i, scale: c, rotation: new u() };
   let d;
   if (r) {
-    const V = g.fromQuaternion(r), S = a.fromRotation(V), B = a.multiply(f, S, S), N = tt(B);
-    d = b.toCartesian3(N), p.rotation = d;
+    const V = g.fromQuaternion(r), S = s.fromRotation(V), B = s.multiply(l, S, S), _ = nn(B);
+    d = b.toCartesian3(_), p.rotation = d;
   }
-  const y = new M(m ?? void 0, d ? G(d) : void 0, c ?? void 0);
-  let R = a.fromTranslationRotationScale(y);
-  return p.matrix = R, p;
+  const y = new R(m ?? void 0, d ? G(d) : void 0, c ?? void 0);
+  let P = s.fromTranslationRotationScale(y);
+  return p.matrix = P, p;
 }
-function dn(t) {
-  return t.values.length / t.componentsPerAttribute;
+function dt(n) {
+  return n.values.length / n.componentsPerAttribute;
 }
-function yn(t) {
-  return Z.getSizeInBytes(t.componentDatatype) * t.componentsPerAttribute;
+function yt(n) {
+  return Z.getSizeInBytes(n.componentDatatype) * n.componentsPerAttribute;
 }
-function wn(t) {
-  const { componentDatatype: o, vertexBuffer: n } = t, e = pt[o];
+function wt(n) {
+  const { componentDatatype: o, vertexBuffer: t } = n, e = yn[o];
   if (!e) throw new Error("不支持的数据类型");
-  const i = n.sizeInBytes, r = Z.getSizeInBytes(o), s = i / r;
-  let c = new e(s);
-  return n.getBufferData(c, 0, 0, i), c;
+  const i = t.sizeInBytes, r = Z.getSizeInBytes(o), a = i / r;
+  let c = new e(a);
+  return t.getBufferData(c, 0, 0, i), c;
 }
-new x(), new l(), new O();
-const Q = [new x(), new x(), new x(), new x()], k = [new l(), new l(), new l(), new l()];
+new x(), new u(), new O();
+const Q = [new x(), new x(), new x(), new x()], k = [new u(), new u(), new u(), new u()];
 new O(), new O(), new O(), new O();
-const _t = [new D(), new D(), new D(), new D()];
+const Gn = [new D(), new D(), new D(), new D()];
 new v(), new v(), new v(), new v();
-new F(), new F(), new F(), new F();
+new N(), new N(), new N(), new N();
 new g(), new g(), new g(), new g();
-new a(), new a(), new a(), new a();
+new s(), new s(), new s(), new s();
 new w(), new w(), new w(), new w();
 new I(), new I(), new I(), new I();
-function gn(t, o = []) {
-  const { stride: n, vertexArray: e } = t, i = e.length / n, r = k[0];
-  for (let s = 0; s < i; s++)
-    t.encoding.decodePosition(e, s, r), l.pack(r, o, o.length);
+function gt(n, o = []) {
+  const { stride: t, vertexArray: e } = n, i = e.length / t, r = k[0];
+  for (let a = 0; a < i; a++)
+    n.encoding.decodePosition(e, a, r), u.pack(r, o, o.length);
   return o;
 }
-function hn(t, o, n) {
-  return t.encoding.decodePosition(t.vertexArray, o, n);
+function ht(n, o, t) {
+  return n.encoding.decodePosition(n.vertexArray, o, t);
 }
-function zt(t) {
-  const { stride: o, vertices: n, indices: e, encoding: i } = t, r = n.length / o, s = k[0], c = new Float32Array(r * 3), u = Q[0], f = new Float32Array(r * 2), m = new Float32Array(r);
+function Hn(n) {
+  const { stride: o, vertices: t, indices: e, encoding: i } = n, r = t.length / o, a = k[0], c = new Float32Array(r * 3), f = Q[0], l = new Float32Array(r * 2), m = new Float32Array(r);
   for (let p = 0; p < r; p++) {
-    i.decodePosition(n, p, s), l.pack(s, c, p * 3);
-    const d = i.decodeHeight(n, p);
-    m[p] = d, i.decodeTextureCoordinates(n, p, u), x.pack(u, f, p * 2);
+    i.decodePosition(t, p, a), u.pack(a, c, p * 3);
+    const d = i.decodeHeight(t, p);
+    m[p] = d, i.decodeTextureCoordinates(t, p, f), x.pack(f, l, p * 2);
   }
   return {
     attributes: {
       position: { array: c, vectorSize: 3 },
-      uv: { array: f, vectorSize: 2 },
+      uv: { array: l, vectorSize: 2 },
       height: { array: m, vectorSize: 1 }
     },
     indices: e.slice(),
     count: r
   };
 }
-function et(t, o) {
-  const n = t._surface._tilesToRender, e = [], i = new v();
-  for (const r of n) {
-    const { rectangle: s } = r;
-    v.intersection(o, s, i) && e.push(r);
+function rn(n, o) {
+  const t = n._surface._tilesToRender, e = [], i = new v();
+  for (const r of t) {
+    const { rectangle: a } = r;
+    v.intersection(o, a, i) && e.push(r);
   }
   return e;
 }
-function xn(t) {
-  const o = t._surface._tilesToRender;
-  return Gt(o);
+function xt(n) {
+  const o = n._surface._tilesToRender;
+  return kn(o);
 }
-function Gt(t) {
+function kn(n) {
   const o = /* @__PURE__ */ new Set();
-  for (const r of t)
+  for (const r of n)
     o.add(r.level);
-  const n = [...o], e = Math.min.apply(Math, n), i = Math.max.apply(Math, n);
+  const t = [...o], e = Math.min.apply(Math, t), i = Math.max.apply(Math, t);
   return { min: e, max: i };
 }
-function it(t) {
-  return t.map((o) => {
-    const { mesh: n, terrainData: e } = o.data, i = zt(n), { x: r, y: s, level: c } = o, u = [e._minimumHeight, e._maximumHeight];
-    return { data: i, encoding: n.encoding, rectangle: o.rectangle, heightRange: u, x: r, y: s, level: c };
+function sn(n) {
+  return n.map((o) => {
+    const { mesh: t, terrainData: e } = o.data, i = Hn(t), { x: r, y: a, level: c } = o, f = [e._minimumHeight, e._maximumHeight];
+    return { data: i, encoding: t.encoding, rectangle: o.rectangle, heightRange: f, x: r, y: a, level: c };
   });
 }
-function Tn(t) {
-  const { x: o, y: n, level: e } = t;
-  return t.data.terrainData.upsample(t.tilingScheme, o, n, e, o, n, e);
+function Tt(n) {
+  const { x: o, y: t, level: e } = n;
+  return n.data.terrainData.upsample(n.tilingScheme, o, t, e, o, t, e);
 }
-function Ht(t, o, n) {
-  const { east: e, north: i, south: r, west: s } = o, c = _t[0];
-  c.longitude = s, c.latitude = r;
-  const u = t.positionToTileXY(c, n, Q[0]);
+function Qn(n, o, t) {
+  const { east: e, north: i, south: r, west: a } = o, c = Gn[0];
+  c.longitude = a, c.latitude = r;
+  const f = n.positionToTileXY(c, t, Q[0]);
   c.longitude = e, c.latitude = i;
-  const f = t.positionToTileXY(c, n, Q[1]), [m, p] = u.x < f.x ? [u.x, f.x] : [f.x, u.x], [d, y] = u.y < f.y ? [u.y, f.y] : [f.y, u.y];
+  const l = n.positionToTileXY(c, t, Q[1]), [m, p] = f.x < l.x ? [f.x, l.x] : [l.x, f.x], [d, y] = f.y < l.y ? [f.y, l.y] : [l.y, f.y];
   return { min: [m, d], max: [p, y] };
 }
-const kt = 32767;
-function vn(t, o = new l()) {
-  return g.getScale(t.halfAxes, o), l.multiplyByScalar(o, 2 * kt, o), o;
+const En = 32767;
+function vt(n, o = new u()) {
+  return g.getScale(n.halfAxes, o), u.multiplyByScalar(o, 2 * En, o), o;
 }
-function U(t, o, n) {
-  return n = t.getLocalCurvature(o, n), n.x = 1 / n.x, n.y = 1 / n.y, n;
+function U(n, o, t) {
+  return t = n.getLocalCurvature(o, t), t.x = 1 / t.x, t.y = 1 / t.y, t;
 }
-function An(t, o, n) {
-  n = U(t, o, n);
+function At(n, o, t) {
+  t = U(n, o, t);
   const e = Math.PI / 180;
-  return x.multiplyByScalar(n, e, n);
+  return x.multiplyByScalar(t, e, t);
 }
-function Qt(t) {
-  const { _quantizedVertices: o, _indices: n } = t, e = o.length / 3, i = {
+function qn(n) {
+  const { _quantizedVertices: o, _indices: t } = n, e = o.length / 3, i = {
     type: "Float32Array",
     start: 0,
     vectorSize: 1
@@ -601,57 +601,57 @@ function Qt(t) {
     type: "Float32Array",
     start: e,
     vectorSize: 1
-  }, s = {
+  }, a = {
     type: "Float32Array",
     start: e * 2,
     vectorSize: 1
   };
   return {
     array: new Float32Array(o),
-    attributes: { u: i, v: r, height: s },
+    attributes: { u: i, v: r, height: a },
     count: e,
-    indices: n
+    indices: t
   };
 }
-async function Pn(t, o, n, e) {
-  const i = await t.requestTileGeometry(o, n, e);
+async function Mt(n, o, t, e) {
+  const i = await n.requestTileGeometry(o, t, e);
   if (!i) return null;
-  const r = Qt(i), s = [data._minimumHeight, data._maximumHeight], c = t.tilingScheme.tileXYToRectangle(o, n, e), u = ct(c, s), f = a.fromArray(u, void 0), m = ["u", "v", "height"], p = new lt({ ...r, positionNames: m }), d = new l();
-  return p.mapForAggregate(m, (y, R) => (l.fromArray(y, 0, d), a.multiplyByPoint(f, d, d), new D(d.x, d.y, d.z)));
-}
-async function Mn(t, o, n) {
-  const { min: e, max: i } = Ht(t.tilingScheme, o, n), r = [], s = [];
-  for (let u = e[0]; u <= i[0]; u++)
-    for (let f = e[1]; f <= i[1]; f++) {
-      const m = Et(t, u, f, n);
-      m && (r.push(m), s.push({ x: u, y: f }));
+  const r = qn(i), a = [data._minimumHeight, data._maximumHeight], c = n.tilingScheme.tileXYToRectangle(o, t, e), f = un(c, a), l = s.fromArray(f, void 0), m = ["u", "v", "height"], p = new fn({ ...r, positionNames: m }), d = new u();
+  return p.mapForAggregate(m, (y, P) => (u.fromArray(y, 0, d), s.multiplyByPoint(l, d, d), new D(d.x, d.y, d.z)));
+}
+async function Rt(n, o, t) {
+  const { min: e, max: i } = Qn(n.tilingScheme, o, t), r = [], a = [];
+  for (let f = e[0]; f <= i[0]; f++)
+    for (let l = e[1]; l <= i[1]; l++) {
+      const m = Jn(n, f, l, t);
+      m && (r.push(m), a.push({ x: f, y: l }));
     }
-  return (await Promise.all(r)).map(function(u, f) {
-    const { x: m, y: p } = s[f];
-    return { x: m, y: p, level: n, data: u };
+  return (await Promise.all(r)).map(function(f, l) {
+    const { x: m, y: p } = a[l];
+    return { x: m, y: p, level: t, data: f };
   });
 }
-async function Et(t, o, n, e) {
-  return t.getTileDataAvailable(o, n, e) ? (await t.loadTileDataAvailability(o, n, e), t.requestTileGeometry(o, n, e)) : Promise.reject("不可用");
+async function Jn(n, o, t, e) {
+  return n.getTileDataAvailable(o, t, e) ? (await n.loadTileDataAvailability(o, t, e), n.requestTileGeometry(o, t, e)) : Promise.reject("不可用");
 }
-async function Rn(t, o) {
-  const n = v.fromCartesianArray(o), e = D.toCartesian(v.center(n)), i = U(t.ellipsoid, e), r = [i.x, i.y, 1], s = et(t, n), c = it(s), u = E.eastNorthUpToFixedFrame(e);
-  a.inverseTransformation(u, u);
-  const f = o.map((d) => {
-    const y = a.multiplyByPoint(u, d, k[2]);
+async function Pt(n, o) {
+  const t = v.fromCartesianArray(o), e = D.toCartesian(v.center(t)), i = U(n.ellipsoid, e), r = [i.x, i.y, 1], a = rn(n, t), c = sn(a), f = E.eastNorthUpToFixedFrame(e);
+  s.inverseTransformation(f, f);
+  const l = o.map((d) => {
+    const y = s.multiplyByPoint(f, d, k[2]);
     return [y.x, y.y];
   });
   let m = 0;
   const p = c.map(async (d) => {
-    const { data: y, ...R } = d, { position: V, uv: S, height: B } = y.attributes;
-    m += await ut.computeRelationAreaOfPolygon2Terrain({
+    const { data: y, ...P } = d, { position: V, uv: S, height: B } = y.attributes;
+    m += await mn.computeRelationAreaOfPolygon2Terrain({
       args: [{
         ...y,
-        ...R,
+        ...P,
         positionNames: ["position"],
-        region: f,
+        region: l,
         // @ts-ignore
-        matrix: a.pack(u, []),
+        matrix: s.pack(f, []),
         relation: z.Contain | z.Intersect,
         scale: r
       }],
@@ -660,115 +660,137 @@ async function Rn(t, o) {
   });
   if (await Promise.all(p), m === 0 || isNaN(m)) {
     console.warn("贴地面积计算异常，已回退到椭球面投影面积", m);
-    const d = o.map((y) => l.pack(y, []));
+    const d = o.map((y) => u.pack(y, []));
     return m = K(d), Math.abs(m);
   }
   return m;
 }
-function Sn(t, o) {
-  const n = v.fromCartesianArray(o), e = D.toCartesian(v.center(n)), i = U(t.ellipsoid, e), r = [i.x, i.y, 1], s = et(t, n), c = it(s), u = E.eastNorthUpToFixedFrame(e);
-  a.inverseTransformation(u, u);
-  const f = o.map((p) => {
-    const d = a.multiplyByPoint(u, p, k[2]);
+function St(n, o) {
+  const t = v.fromCartesianArray(o), e = D.toCartesian(v.center(t)), i = U(n.ellipsoid, e), r = [i.x, i.y, 1], a = rn(n, t), c = sn(a), f = E.eastNorthUpToFixedFrame(e);
+  s.inverseTransformation(f, f);
+  const l = o.map((p) => {
+    const d = s.multiplyByPoint(f, p, k[2]);
     return [d.x, d.y];
   });
   let m = 0;
   for (const p of c) {
     const { data: d, ...y } = p;
-    m += ft({
+    m += pn({
       ...d,
       ...y,
       positionNames: ["position"],
-      region: f,
+      region: l,
       // @ts-ignore
-      matrix: a.pack(u, []),
+      matrix: s.pack(f, []),
       relation: z.Contain | z.Intersect,
       scale: r
     });
   }
   if (m === 0 || isNaN(m)) {
     console.warn("贴地面积计算异常，已回退到椭球面投影面积", m);
-    const p = o.map((d) => l.pack(d, []));
+    const p = o.map((d) => u.pack(d, []));
     return m = K(p), Math.abs(m);
   }
   return m;
 }
+function Dt(n, o, t) {
+  const e = n.transform.clone(), i = s.inverse(e, new s()), r = new s(), { compose: a, decompose: c, ...f } = on(n.boundingSphere.center, o, t);
+  function l(p, d) {
+    return d = a(p, d), s.multiply(d, i, d);
+  }
+  function m(p, d) {
+    return s.multiply(p, e, r), c(r, d);
+  }
+  return { ...f, right: i, compose: l, decompose: m };
+}
+function Vt(n, o, t) {
+  const e = s.inverse(n.root.transform, new s()), { compose: i, decompose: r, ...a } = on(n.boundingSphere.center, o, t);
+  function c(l, m) {
+    return m = i(l, m), s.multiply(m, e, m);
+  }
+  function f(l) {
+    return r(n.root.computedTransform, l);
+  }
+  return { ...a, right: e, compose: c, decompose: f };
+}
 export {
-  dt as CartesianAxis,
-  yt as HeadingPitchRollComponent,
+  wn as CartesianAxis,
+  gn as HeadingPitchRollComponent,
   b as Xyz_Hpr,
-  Kt as applyMatrixReferFrame,
-  At as applyTransformInPrimitive,
-  un as applyTransformInfoPrimitive,
-  pt as componentDatatypeTypedArrayMap,
-  yn as computeAttributeSizeInBytes,
-  xt as computeNormalOfCoplanars,
-  Sn as computeTerrainAreaOfPolygon,
-  Rn as computeTerrainAreaOfPolygon_worker,
-  dn as computeVertexNumOfAttribute,
-  Xt as createPlaneOfCoplanars,
+  nt as applyMatrixReferFrame,
+  Rn as applyTransformInPrimitive,
+  ut as applyTransformInfoPrimitive,
+  yn as componentDatatypeTypedArrayMap,
+  yt as computeAttributeSizeInBytes,
+  vn as computeNormalOfCoplanars,
+  St as computeTerrainAreaOfPolygon,
+  Pt as computeTerrainAreaOfPolygon_worker,
+  dt as computeVertexNumOfAttribute,
+  Kn as createPlaneOfCoplanars,
   $ as flatTransformInfoOptions,
-  wn as getAttributeData,
-  cn as getBoundingSphere,
-  gn as getDecodePositionsOfTerrainMesh,
-  pn as getEntityInfo,
-  Qt as getGeometryDataOfQuantizedMeshTerrainData,
-  zt as getGeometryDataOfTerrainMesh,
-  Gt as getLevelRangeOfQuadtreeTiles,
+  wt as getAttributeData,
+  ct as getBoundingSphere,
+  gt as getDecodePositionsOfTerrainMesh,
+  pt as getEntityInfo,
+  qn as getGeometryDataOfQuantizedMeshTerrainData,
+  Hn as getGeometryDataOfTerrainMesh,
+  kn as getLevelRangeOfQuadtreeTiles,
   U as getLocalCurvatureRadius,
-  An as getLocalSizePerDegrees,
-  gt as getLocalTransformInfo,
-  en as getMatrix4OfTransformInfo,
-  Zt as getNeighborPairs,
-  ln as getPosition,
-  hn as getPositionOfTerrainMesh,
-  et as getRenderedQuadtreeTilesOfIntersectRectangle,
-  xn as getRenderedTileLevelRange,
-  vn as getScaleOfTerrainDataByOrientedBoundingBox,
-  Et as getTerrainData,
-  Tn as getTerrainDataOfQuadtreeTile,
-  Mn as getTerrainDatasOfIntersectRectangle,
-  it as getTerrainDatasOfQuadtreeTiles,
-  Ht as getTileRangeOfIntersectRectangle,
-  Mt as getTransform,
-  Pn as getWorldDataOfQuantizedMeshTerrainData,
-  ht as getWorldMatrix,
+  At as getLocalSizePerDegrees,
+  xn as getLocalTransformInfo,
+  rt as getMatrix4OfTransformInfo,
+  $n as getNeighborPairs,
+  lt as getPosition,
+  ht as getPositionOfTerrainMesh,
+  rn as getRenderedQuadtreeTilesOfIntersectRectangle,
+  xt as getRenderedTileLevelRange,
+  vt as getScaleOfTerrainDataByOrientedBoundingBox,
+  Jn as getTerrainData,
+  Tt as getTerrainDataOfQuadtreeTile,
+  Rt as getTerrainDatasOfIntersectRectangle,
+  sn as getTerrainDatasOfQuadtreeTiles,
+  Qn as getTileRangeOfIntersectRectangle,
+  Sn as getTransform,
+  Mt as getWorldDataOfQuantizedMeshTerrainData,
+  Tn as getWorldMatrix,
   L as getWorldTransformInfo,
   q as isMatrixPrimitive,
-  mt as isPositionListPrimitive,
+  dn as isPositionListPrimitive,
   J as isPositionPrimitive,
-  Lt as isPrimitiveObject,
-  wt as localQuaternionToWorld,
-  vt as localTRS_WorldMatrix4_Convert,
-  sn as localTRS_WorldMatrix4_ENU_Convert,
+  Yn as isPrimitiveObject,
+  hn as localQuaternionToWorld,
+  Mn as localTRS_WorldMatrix4_Convert,
+  on as localTRS_WorldMatrix4_ENU_Convert,
   H as makeMatrixReferFrame,
-  an as mat4_compose,
-  Tt as mat4_composeByOrder,
-  rn as mat4_decompose,
-  nt as mat4_decomposeByOrder,
-  tt as matrix4ToHeadingPitchRoll,
-  Ut as quaternionToHeadingPitchRoll,
-  Pt as resetTransformInPrimitive,
-  fn as resetTransformInfoPrimitive,
-  tn as rotateMatrixReferFrame,
+  at as mat4_compose,
+  An as mat4_composeByOrder,
+  st as mat4_decompose,
+  tn as mat4_decomposeByOrder,
+  nn as matrix4ToHeadingPitchRoll,
+  jn as quaternionToHeadingPitchRoll,
+  Pn as resetTransformInPrimitive,
+  ft as resetTransformInfoPrimitive,
+  ot as rotateMatrixReferFrame,
   G as rotationInfoToQuaternion,
-  Rt as scaleBoxGraphics,
-  St as scaleCylinderGraphics,
-  Dt as scaleEllipseGraphics,
-  Vt as scaleEllipsoidGraphics,
-  nn as scaleMatrixReferFrame,
-  Bt as scaleModelGraphics,
-  It as scalePlaneGraphics,
-  on as scalePoints,
-  Ot as transformCorridorGraphics,
-  mn as transformEntity,
-  Wt as transformInfoToMatrix,
-  Ct as transformPolygonGraphics,
-  ot as transformPolygonHierarchy,
-  bt as transformPolylineGraphics,
-  Nt as transformPolylineVolumeGraphics,
-  Ft as transformWallGraphics,
-  $t as translationMatrixReferFrame,
-  Yt as worldMatrixToLocal,
-  jt as worldQuaternionToLocal
+  Dn as scaleBoxGraphics,
+  Vn as scaleCylinderGraphics,
+  Bn as scaleEllipseGraphics,
+  In as scaleEllipsoidGraphics,
+  et as scaleMatrixReferFrame,
+  On as scaleModelGraphics,
+  Cn as scalePlaneGraphics,
+  it as scalePoints,
+  Dt as tile_enuTRS_modelMatrix_Convert,
+  Vt as tileset_enuTRS_modelMatrix_Convert,
+  bn as transformCorridorGraphics,
+  mt as transformEntity,
+  Zn as transformInfoToMatrix,
+  _n as transformPolygonGraphics,
+  en as transformPolygonHierarchy,
+  Nn as transformPolylineGraphics,
+  Fn as transformPolylineVolumeGraphics,
+  zn as transformWallGraphics,
+  tt as translationMatrixReferFrame,
+  Wn as worldMatrixToLocal,
+  Xn as worldQuaternionToLocal
 };