create-swdg-frontend 0.1.0

package/template/public/Cesium1.119/Workers/chunk-QB3MDM4J.js

@@ -0,0 +1,1670 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.119
+ *
+ * Copyright 2011-2022 Cesium Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Columbus View (Pat. Pend.)
+ *
+ * Portions licensed separately.
+ * See https://github.com/CesiumGS/cesium/blob/main/LICENSE.md for full licensing details.
+ */
+
+import { a as et } from "./chunk-ABGXSJNX.js";
+import { a as jt } from "./chunk-DQO6B4EQ.js";
+import { b as Lt } from "./chunk-TAMCUKAR.js";
+import { a as Et } from "./chunk-PDMQLSBL.js";
+import { a as j } from "./chunk-P37AI2DW.js";
+import { a as mt, b as D, c as B, d as U } from "./chunk-X5IHHI6X.js";
+import { a as _t, b as Ut, d as rt } from "./chunk-TMSETF7M.js";
+import { a as dt, b as H } from "./chunk-7Z5IIKOJ.js";
+import { a as k } from "./chunk-KZNJOCYU.js";
+import { a as r, b as Mt, c as R, e as Ot } from "./chunk-POASMU2N.js";
+import { a as N } from "./chunk-R6KGAEF6.js";
+import { a as K } from "./chunk-IUA6FAOZ.js";
+import { a as I, b as pt } from "./chunk-UH2WFNTA.js";
+import { e as f } from "./chunk-PEYJTJPE.js";
+var Yt = new r(),
+  Zt = new r(),
+  Xt = new r();
+function pe(t, e, n, s, i) {
+  (pt.defined("point", t),
+    pt.defined("p0", e),
+    pt.defined("p1", n),
+    pt.defined("p2", s),
+    f(i) || (i = new r()));
+  let c, o, a, p, u, d, m, l;
+  if (f(e.z)) {
+    if (r.equalsEpsilon(t, e, N.EPSILON14)) return r.clone(r.UNIT_X, i);
+    if (r.equalsEpsilon(t, n, N.EPSILON14)) return r.clone(r.UNIT_Y, i);
+    if (r.equalsEpsilon(t, s, N.EPSILON14)) return r.clone(r.UNIT_Z, i);
+    ((c = r.subtract(n, e, Yt)),
+      (o = r.subtract(s, e, Zt)),
+      (a = r.subtract(t, e, Xt)),
+      (p = r.dot(c, c)),
+      (u = r.dot(c, o)),
+      (d = r.dot(c, a)),
+      (m = r.dot(o, o)),
+      (l = r.dot(o, a)));
+  } else {
+    if (R.equalsEpsilon(t, e, N.EPSILON14)) return r.clone(r.UNIT_X, i);
+    if (R.equalsEpsilon(t, n, N.EPSILON14)) return r.clone(r.UNIT_Y, i);
+    if (R.equalsEpsilon(t, s, N.EPSILON14)) return r.clone(r.UNIT_Z, i);
+    ((c = R.subtract(n, e, Yt)),
+      (o = R.subtract(s, e, Zt)),
+      (a = R.subtract(t, e, Xt)),
+      (p = R.dot(c, c)),
+      (u = R.dot(c, o)),
+      (d = R.dot(c, a)),
+      (m = R.dot(o, o)),
+      (l = R.dot(o, a)));
+  }
+  ((i.y = m * d - u * l), (i.z = p * l - u * d));
+  let h = p * m - u * u;
+  if (h !== 0) return ((i.y /= h), (i.z /= h), (i.x = 1 - i.y - i.z), i);
+}
+var Ht = pe;
+var Nt = {};
+Nt.calculateACMR = function (t) {
+  t = K(t, K.EMPTY_OBJECT);
+  let e = t.indices,
+    n = t.maximumIndex,
+    s = K(t.cacheSize, 24);
+  if (!f(e)) throw new I("indices is required.");
+  let i = e.length;
+  if (i < 3 || i % 3 !== 0)
+    throw new I("indices length must be a multiple of three.");
+  if (n <= 0) throw new I("maximumIndex must be greater than zero.");
+  if (s < 3) throw new I("cacheSize must be greater than two.");
+  if (!f(n)) {
+    n = 0;
+    let a = 0,
+      p = e[a];
+    for (; a < i; ) (p > n && (n = p), ++a, (p = e[a]));
+  }
+  let c = [];
+  for (let a = 0; a < n + 1; a++) c[a] = 0;
+  let o = s + 1;
+  for (let a = 0; a < i; ++a) o - c[e[a]] > s && ((c[e[a]] = o), ++o);
+  return (o - s + 1) / (i / 3);
+};
+Nt.tipsify = function (t) {
+  t = K(t, K.EMPTY_OBJECT);
+  let e = t.indices,
+    n = t.maximumIndex,
+    s = K(t.cacheSize, 24),
+    i;
+  function c(C, z, q, V) {
+    for (; z.length >= 1; ) {
+      let G = z[z.length - 1];
+      if ((z.splice(z.length - 1, 1), C[G].numLiveTriangles > 0)) return G;
+    }
+    for (; i < V; ) {
+      if (C[i].numLiveTriangles > 0) return (++i, i - 1);
+      ++i;
+    }
+    return -1;
+  }
+  function o(C, z, q, V, G, M, J) {
+    let Y = -1,
+      _,
+      Pt = -1,
+      gt = 0;
+    for (; gt < q.length; ) {
+      let ft = q[gt];
+      (V[ft].numLiveTriangles &&
+        ((_ = 0),
+        G - V[ft].timeStamp + 2 * V[ft].numLiveTriangles <= z &&
+          (_ = G - V[ft].timeStamp),
+        (_ > Pt || Pt === -1) && ((Pt = _), (Y = ft))),
+        ++gt);
+    }
+    return Y === -1 ? c(V, M, C, J) : Y;
+  }
+  if (!f(e)) throw new I("indices is required.");
+  let a = e.length;
+  if (a < 3 || a % 3 !== 0)
+    throw new I("indices length must be a multiple of three.");
+  if (n <= 0) throw new I("maximumIndex must be greater than zero.");
+  if (s < 3) throw new I("cacheSize must be greater than two.");
+  let p = 0,
+    u = 0,
+    d = e[u],
+    m = a;
+  if (f(n)) p = n + 1;
+  else {
+    for (; u < m; ) (d > p && (p = d), ++u, (d = e[u]));
+    if (p === -1) return 0;
+    ++p;
+  }
+  let l = [],
+    h;
+  for (h = 0; h < p; h++)
+    l[h] = { numLiveTriangles: 0, timeStamp: 0, vertexTriangles: [] };
+  u = 0;
+  let y = 0;
+  for (; u < m; )
+    (l[e[u]].vertexTriangles.push(y),
+      ++l[e[u]].numLiveTriangles,
+      l[e[u + 1]].vertexTriangles.push(y),
+      ++l[e[u + 1]].numLiveTriangles,
+      l[e[u + 2]].vertexTriangles.push(y),
+      ++l[e[u + 2]].numLiveTriangles,
+      ++y,
+      (u += 3));
+  let v = 0,
+    b = s + 1;
+  i = 1;
+  let S = [],
+    x = [],
+    w,
+    A,
+    E = 0,
+    P = [],
+    O = a / 3,
+    L = [];
+  for (h = 0; h < O; h++) L[h] = !1;
+  let g, T;
+  for (; v !== -1; ) {
+    ((S = []), (A = l[v]), (T = A.vertexTriangles.length));
+    for (let C = 0; C < T; ++C)
+      if (((y = A.vertexTriangles[C]), !L[y])) {
+        ((L[y] = !0), (u = y + y + y));
+        for (let z = 0; z < 3; ++z)
+          ((g = e[u]),
+            S.push(g),
+            x.push(g),
+            (P[E] = g),
+            ++E,
+            (w = l[g]),
+            --w.numLiveTriangles,
+            b - w.timeStamp > s && ((w.timeStamp = b), ++b),
+            ++u);
+      }
+    v = o(e, s, S, l, b, x, p);
+  }
+  return P;
+};
+var Wt = Nt;
+var F = {};
+function St(t, e, n, s, i) {
+  ((t[e++] = n),
+    (t[e++] = s),
+    (t[e++] = s),
+    (t[e++] = i),
+    (t[e++] = i),
+    (t[e] = n));
+}
+function de(t) {
+  let e = t.length,
+    n = (e / 3) * 6,
+    s = j.createTypedArray(e, n),
+    i = 0;
+  for (let c = 0; c < e; c += 3, i += 6) St(s, i, t[c], t[c + 1], t[c + 2]);
+  return s;
+}
+function me(t) {
+  let e = t.length;
+  if (e >= 3) {
+    let n = (e - 2) * 6,
+      s = j.createTypedArray(e, n);
+    St(s, 0, t[0], t[1], t[2]);
+    let i = 6;
+    for (let c = 3; c < e; ++c, i += 6) St(s, i, t[c - 1], t[c], t[c - 2]);
+    return s;
+  }
+  return new Uint16Array();
+}
+function he(t) {
+  if (t.length > 0) {
+    let e = t.length - 1,
+      n = (e - 1) * 6,
+      s = j.createTypedArray(e, n),
+      i = t[0],
+      c = 0;
+    for (let o = 1; o < e; ++o, c += 6) St(s, c, i, t[o], t[o + 1]);
+    return s;
+  }
+  return new Uint16Array();
+}
+F.toWireframe = function (t) {
+  if (!f(t)) throw new I("geometry is required.");
+  let e = t.indices;
+  if (f(e)) {
+    switch (t.primitiveType) {
+      case D.TRIANGLES:
+        t.indices = de(e);
+        break;
+      case D.TRIANGLE_STRIP:
+        t.indices = me(e);
+        break;
+      case D.TRIANGLE_FAN:
+        t.indices = he(e);
+        break;
+      default:
+        throw new I(
+          "geometry.primitiveType must be TRIANGLES, TRIANGLE_STRIP, or TRIANGLE_FAN.",
+        );
+    }
+    t.primitiveType = D.LINES;
+  }
+  return t;
+};
+F.createLineSegmentsForVectors = function (t, e, n) {
+  if (((e = K(e, "normal")), !f(t))) throw new I("geometry is required.");
+  if (!f(t.attributes.position))
+    throw new I("geometry.attributes.position is required.");
+  if (!f(t.attributes[e]))
+    throw new I(
+      `geometry.attributes must have an attribute with the same name as the attributeName parameter, ${e}.`,
+    );
+  n = K(n, 1e4);
+  let s = t.attributes.position.values,
+    i = t.attributes[e].values,
+    c = s.length,
+    o = new Float64Array(2 * c),
+    a = 0;
+  for (let d = 0; d < c; d += 3)
+    ((o[a++] = s[d]),
+      (o[a++] = s[d + 1]),
+      (o[a++] = s[d + 2]),
+      (o[a++] = s[d] + i[d] * n),
+      (o[a++] = s[d + 1] + i[d + 1] * n),
+      (o[a++] = s[d + 2] + i[d + 2] * n));
+  let p,
+    u = t.boundingSphere;
+  return (
+    f(u) && (p = new rt(u.center, u.radius + n)),
+    new B({
+      attributes: {
+        position: new U({
+          componentDatatype: k.DOUBLE,
+          componentsPerAttribute: 3,
+          values: o,
+        }),
+      },
+      primitiveType: D.LINES,
+      boundingSphere: p,
+    })
+  );
+};
+F.createAttributeLocations = function (t) {
+  if (!f(t)) throw new I("geometry is required.");
+  let e = [
+      "position",
+      "positionHigh",
+      "positionLow",
+      "position3DHigh",
+      "position3DLow",
+      "position2DHigh",
+      "position2DLow",
+      "pickColor",
+      "normal",
+      "st",
+      "tangent",
+      "bitangent",
+      "extrudeDirection",
+      "compressedAttributes",
+    ],
+    n = t.attributes,
+    s = {},
+    i = 0,
+    c,
+    o = e.length;
+  for (c = 0; c < o; ++c) {
+    let a = e[c];
+    f(n[a]) && (s[a] = i++);
+  }
+  for (let a in n) n.hasOwnProperty(a) && !f(s[a]) && (s[a] = i++);
+  return s;
+};
+F.reorderForPreVertexCache = function (t) {
+  if (!f(t)) throw new I("geometry is required.");
+  let e = B.computeNumberOfVertices(t),
+    n = t.indices;
+  if (f(n)) {
+    let s = new Int32Array(e);
+    for (let l = 0; l < e; l++) s[l] = -1;
+    let i = n,
+      c = i.length,
+      o = j.createTypedArray(e, c),
+      a = 0,
+      p = 0,
+      u = 0,
+      d;
+    for (; a < c; )
+      ((d = s[i[a]]),
+        d !== -1 ? (o[p] = d) : ((d = i[a]), (s[d] = u), (o[p] = u), ++u),
+        ++a,
+        ++p);
+    t.indices = o;
+    let m = t.attributes;
+    for (let l in m)
+      if (m.hasOwnProperty(l) && f(m[l]) && f(m[l].values)) {
+        let h = m[l],
+          y = h.values,
+          v = 0,
+          b = h.componentsPerAttribute,
+          S = k.createTypedArray(h.componentDatatype, u * b);
+        for (; v < e; ) {
+          let x = s[v];
+          if (x !== -1) for (let w = 0; w < b; w++) S[b * x + w] = y[b * v + w];
+          ++v;
+        }
+        h.values = S;
+      }
+  }
+  return t;
+};
+F.reorderForPostVertexCache = function (t, e) {
+  if (!f(t)) throw new I("geometry is required.");
+  let n = t.indices;
+  if (t.primitiveType === D.TRIANGLES && f(n)) {
+    let s = n.length,
+      i = 0;
+    for (let c = 0; c < s; c++) n[c] > i && (i = n[c]);
+    t.indices = Wt.tipsify({ indices: n, maximumIndex: i, cacheSize: e });
+  }
+  return t;
+};
+function $t(t) {
+  let e = {};
+  for (let n in t)
+    if (t.hasOwnProperty(n) && f(t[n]) && f(t[n].values)) {
+      let s = t[n];
+      e[n] = new U({
+        componentDatatype: s.componentDatatype,
+        componentsPerAttribute: s.componentsPerAttribute,
+        normalize: s.normalize,
+        values: [],
+      });
+    }
+  return e;
+}
+function be(t, e, n) {
+  for (let s in e)
+    if (e.hasOwnProperty(s) && f(e[s]) && f(e[s].values)) {
+      let i = e[s];
+      for (let c = 0; c < i.componentsPerAttribute; ++c)
+        t[s].values.push(i.values[n * i.componentsPerAttribute + c]);
+    }
+}
+F.fitToUnsignedShortIndices = function (t) {
+  if (!f(t)) throw new I("geometry is required.");
+  if (
+    f(t.indices) &&
+    t.primitiveType !== D.TRIANGLES &&
+    t.primitiveType !== D.LINES &&
+    t.primitiveType !== D.POINTS
+  )
+    throw new I(
+      "geometry.primitiveType must equal to PrimitiveType.TRIANGLES, PrimitiveType.LINES, or PrimitiveType.POINTS.",
+    );
+  let e = [],
+    n = B.computeNumberOfVertices(t);
+  if (f(t.indices) && n >= N.SIXTY_FOUR_KILOBYTES) {
+    let s = [],
+      i = [],
+      c = 0,
+      o = $t(t.attributes),
+      a = t.indices,
+      p = a.length,
+      u;
+    t.primitiveType === D.TRIANGLES
+      ? (u = 3)
+      : t.primitiveType === D.LINES
+        ? (u = 2)
+        : t.primitiveType === D.POINTS && (u = 1);
+    for (let d = 0; d < p; d += u) {
+      for (let m = 0; m < u; ++m) {
+        let l = a[d + m],
+          h = s[l];
+        (f(h) || ((h = c++), (s[l] = h), be(o, t.attributes, l)), i.push(h));
+      }
+      c + u >= N.SIXTY_FOUR_KILOBYTES &&
+        (e.push(
+          new B({
+            attributes: o,
+            indices: i,
+            primitiveType: t.primitiveType,
+            boundingSphere: t.boundingSphere,
+            boundingSphereCV: t.boundingSphereCV,
+          }),
+        ),
+        (s = []),
+        (i = []),
+        (c = 0),
+        (o = $t(t.attributes)));
+    }
+    i.length !== 0 &&
+      e.push(
+        new B({
+          attributes: o,
+          indices: i,
+          primitiveType: t.primitiveType,
+          boundingSphere: t.boundingSphere,
+          boundingSphereCV: t.boundingSphereCV,
+        }),
+      );
+  } else e.push(t);
+  return e;
+};
+var Jt = new r(),
+  we = new Mt();
+F.projectTo2D = function (t, e, n, s, i) {
+  if (!f(t)) throw new I("geometry is required.");
+  if (!f(e)) throw new I("attributeName is required.");
+  if (!f(n)) throw new I("attributeName3D is required.");
+  if (!f(s)) throw new I("attributeName2D is required.");
+  if (!f(t.attributes[e]))
+    throw new I(
+      `geometry must have attribute matching the attributeName argument: ${e}.`,
+    );
+  if (t.attributes[e].componentDatatype !== k.DOUBLE)
+    throw new I(
+      "The attribute componentDatatype must be ComponentDatatype.DOUBLE.",
+    );
+  let c = t.attributes[e];
+  i = f(i) ? i : new _t();
+  let o = i.ellipsoid,
+    a = c.values,
+    p = new Float64Array(a.length),
+    u = 0;
+  for (let d = 0; d < a.length; d += 3) {
+    let m = r.fromArray(a, d, Jt),
+      l = o.cartesianToCartographic(m, we);
+    if (!f(l))
+      throw new I(`Could not project point (${m.x}, ${m.y}, ${m.z}) to 2D.`);
+    let h = i.project(l, Jt);
+    ((p[u++] = h.x), (p[u++] = h.y), (p[u++] = h.z));
+  }
+  return (
+    (t.attributes[n] = c),
+    (t.attributes[s] = new U({
+      componentDatatype: k.DOUBLE,
+      componentsPerAttribute: 3,
+      values: p,
+    })),
+    delete t.attributes[e],
+    t
+  );
+};
+var zt = { high: 0, low: 0 };
+F.encodeAttribute = function (t, e, n, s) {
+  if (!f(t)) throw new I("geometry is required.");
+  if (!f(e)) throw new I("attributeName is required.");
+  if (!f(n)) throw new I("attributeHighName is required.");
+  if (!f(s)) throw new I("attributeLowName is required.");
+  if (!f(t.attributes[e]))
+    throw new I(
+      `geometry must have attribute matching the attributeName argument: ${e}.`,
+    );
+  if (t.attributes[e].componentDatatype !== k.DOUBLE)
+    throw new I(
+      "The attribute componentDatatype must be ComponentDatatype.DOUBLE.",
+    );
+  let i = t.attributes[e],
+    c = i.values,
+    o = c.length,
+    a = new Float32Array(o),
+    p = new Float32Array(o);
+  for (let d = 0; d < o; ++d)
+    (jt.encode(c[d], zt), (a[d] = zt.high), (p[d] = zt.low));
+  let u = i.componentsPerAttribute;
+  return (
+    (t.attributes[n] = new U({
+      componentDatatype: k.FLOAT,
+      componentsPerAttribute: u,
+      values: a,
+    })),
+    (t.attributes[s] = new U({
+      componentDatatype: k.FLOAT,
+      componentsPerAttribute: u,
+      values: p,
+    })),
+    delete t.attributes[e],
+    t
+  );
+};
+var $ = new r();
+function Dt(t, e) {
+  if (f(e)) {
+    let n = e.values,
+      s = n.length;
+    for (let i = 0; i < s; i += 3)
+      (r.unpack(n, i, $), H.multiplyByPoint(t, $, $), r.pack($, n, i));
+  }
+}
+function qt(t, e) {
+  if (f(e)) {
+    let n = e.values,
+      s = n.length;
+    for (let i = 0; i < s; i += 3)
+      (r.unpack(n, i, $),
+        Ot.multiplyByVector(t, $, $),
+        ($ = r.normalize($, $)),
+        r.pack($, n, i));
+  }
+}
+var vt = new H(),
+  yt = new Ot();
+F.transformToWorldCoordinates = function (t) {
+  if (!f(t)) throw new I("instance is required.");
+  let e = t.modelMatrix;
+  if (H.equals(e, H.IDENTITY)) return t;
+  let n = t.geometry.attributes;
+  (Dt(e, n.position),
+    Dt(e, n.prevPosition),
+    Dt(e, n.nextPosition),
+    (f(n.normal) || f(n.tangent) || f(n.bitangent)) &&
+      (H.inverse(e, vt),
+      H.transpose(vt, vt),
+      H.getMatrix3(vt, yt),
+      qt(yt, n.normal),
+      qt(yt, n.tangent),
+      qt(yt, n.bitangent)));
+  let s = t.geometry.boundingSphere;
+  return (
+    f(s) && (t.geometry.boundingSphere = rt.transform(s, e, s)),
+    (t.modelMatrix = H.clone(H.IDENTITY)),
+    t
+  );
+};
+function ve(t, e) {
+  let n = t.length,
+    s = {},
+    i = t[0][e].attributes,
+    c;
+  for (c in i)
+    if (i.hasOwnProperty(c) && f(i[c]) && f(i[c].values)) {
+      let o = i[c],
+        a = o.values.length,
+        p = !0;
+      for (let u = 1; u < n; ++u) {
+        let d = t[u][e].attributes[c];
+        if (
+          !f(d) ||
+          o.componentDatatype !== d.componentDatatype ||
+          o.componentsPerAttribute !== d.componentsPerAttribute ||
+          o.normalize !== d.normalize
+        ) {
+          p = !1;
+          break;
+        }
+        a += d.values.length;
+      }
+      p &&
+        (s[c] = new U({
+          componentDatatype: o.componentDatatype,
+          componentsPerAttribute: o.componentsPerAttribute,
+          normalize: o.normalize,
+          values: k.createTypedArray(o.componentDatatype, a),
+        }));
+    }
+  return s;
+}
+var ye = new r();
+function Vt(t, e) {
+  let n = t.length,
+    s,
+    i,
+    c,
+    o,
+    a = t[0].modelMatrix,
+    p = f(t[0][e].indices),
+    u = t[0][e].primitiveType;
+  for (i = 1; i < n; ++i) {
+    if (!H.equals(t[i].modelMatrix, a))
+      throw new I("All instances must have the same modelMatrix.");
+    if (f(t[i][e].indices) !== p)
+      throw new I(
+        "All instance geometries must have an indices or not have one.",
+      );
+    if (t[i][e].primitiveType !== u)
+      throw new I("All instance geometries must have the same primitiveType.");
+  }
+  let d = ve(t, e),
+    m,
+    l,
+    h;
+  for (s in d)
+    if (d.hasOwnProperty(s))
+      for (m = d[s].values, o = 0, i = 0; i < n; ++i)
+        for (l = t[i][e].attributes[s].values, h = l.length, c = 0; c < h; ++c)
+          m[o++] = l[c];
+  let y;
+  if (p) {
+    let x = 0;
+    for (i = 0; i < n; ++i) x += t[i][e].indices.length;
+    let w = B.computeNumberOfVertices(
+        new B({ attributes: d, primitiveType: D.POINTS }),
+      ),
+      A = j.createTypedArray(w, x),
+      E = 0,
+      P = 0;
+    for (i = 0; i < n; ++i) {
+      let O = t[i][e].indices,
+        L = O.length;
+      for (o = 0; o < L; ++o) A[E++] = P + O[o];
+      P += B.computeNumberOfVertices(t[i][e]);
+    }
+    y = A;
+  }
+  let v = new r(),
+    b = 0,
+    S;
+  for (i = 0; i < n; ++i) {
+    if (((S = t[i][e].boundingSphere), !f(S))) {
+      v = void 0;
+      break;
+    }
+    r.add(S.center, v, v);
+  }
+  if (f(v))
+    for (r.divideByScalar(v, n, v), i = 0; i < n; ++i) {
+      S = t[i][e].boundingSphere;
+      let x = r.magnitude(r.subtract(S.center, v, ye)) + S.radius;
+      x > b && (b = x);
+    }
+  return new B({
+    attributes: d,
+    indices: y,
+    primitiveType: u,
+    boundingSphere: f(v) ? new rt(v, b) : void 0,
+  });
+}
+F.combineInstances = function (t) {
+  if (!f(t) || t.length < 1)
+    throw new I(
+      "instances is required and must have length greater than zero.",
+    );
+  let e = [],
+    n = [],
+    s = t.length;
+  for (let c = 0; c < s; ++c) {
+    let o = t[c];
+    f(o.geometry)
+      ? e.push(o)
+      : f(o.westHemisphereGeometry) && f(o.eastHemisphereGeometry) && n.push(o);
+  }
+  let i = [];
+  return (
+    e.length > 0 && i.push(Vt(e, "geometry")),
+    n.length > 0 &&
+      (i.push(Vt(n, "westHemisphereGeometry")),
+      i.push(Vt(n, "eastHemisphereGeometry"))),
+    i
+  );
+};
+var Z = new r(),
+  ht = new r(),
+  ct = new r(),
+  at = new r();
+F.computeNormal = function (t) {
+  if (!f(t)) throw new I("geometry is required.");
+  if (!f(t.attributes.position) || !f(t.attributes.position.values))
+    throw new I("geometry.attributes.position.values is required.");
+  if (!f(t.indices)) throw new I("geometry.indices is required.");
+  if (t.indices.length < 2 || t.indices.length % 3 !== 0)
+    throw new I(
+      "geometry.indices length must be greater than 0 and be a multiple of 3.",
+    );
+  if (t.primitiveType !== D.TRIANGLES)
+    throw new I("geometry.primitiveType must be PrimitiveType.TRIANGLES.");
+  let e = t.indices,
+    n = t.attributes,
+    s = n.position.values,
+    i = n.position.values.length / 3,
+    c = e.length,
+    o = new Array(i),
+    a = new Array(c / 3),
+    p = new Array(c),
+    u;
+  for (u = 0; u < i; u++) o[u] = { indexOffset: 0, count: 0, currentCount: 0 };
+  let d = 0;
+  for (u = 0; u < c; u += 3) {
+    let y = e[u],
+      v = e[u + 1],
+      b = e[u + 2],
+      S = y * 3,
+      x = v * 3,
+      w = b * 3;
+    ((ht.x = s[S]),
+      (ht.y = s[S + 1]),
+      (ht.z = s[S + 2]),
+      (ct.x = s[x]),
+      (ct.y = s[x + 1]),
+      (ct.z = s[x + 2]),
+      (at.x = s[w]),
+      (at.y = s[w + 1]),
+      (at.z = s[w + 2]),
+      o[y].count++,
+      o[v].count++,
+      o[b].count++,
+      r.subtract(ct, ht, ct),
+      r.subtract(at, ht, at),
+      (a[d] = r.cross(ct, at, new r())),
+      d++);
+  }
+  let m = 0;
+  for (u = 0; u < i; u++) ((o[u].indexOffset += m), (m += o[u].count));
+  d = 0;
+  let l;
+  for (u = 0; u < c; u += 3) {
+    l = o[e[u]];
+    let y = l.indexOffset + l.currentCount;
+    ((p[y] = d),
+      l.currentCount++,
+      (l = o[e[u + 1]]),
+      (y = l.indexOffset + l.currentCount),
+      (p[y] = d),
+      l.currentCount++,
+      (l = o[e[u + 2]]),
+      (y = l.indexOffset + l.currentCount),
+      (p[y] = d),
+      l.currentCount++,
+      d++);
+  }
+  let h = new Float32Array(i * 3);
+  for (u = 0; u < i; u++) {
+    let y = u * 3;
+    if (((l = o[u]), r.clone(r.ZERO, Z), l.count > 0)) {
+      for (d = 0; d < l.count; d++) r.add(Z, a[p[l.indexOffset + d]], Z);
+      r.equalsEpsilon(r.ZERO, Z, N.EPSILON10) &&
+        r.clone(a[p[l.indexOffset]], Z);
+    }
+    (r.equalsEpsilon(r.ZERO, Z, N.EPSILON10) && (Z.z = 1),
+      r.normalize(Z, Z),
+      (h[y] = Z.x),
+      (h[y + 1] = Z.y),
+      (h[y + 2] = Z.z));
+  }
+  return (
+    (t.attributes.normal = new U({
+      componentDatatype: k.FLOAT,
+      componentsPerAttribute: 3,
+      values: h,
+    })),
+    t
+  );
+};
+var xe = new r(),
+  Kt = new r(),
+  Te = new r();
+F.computeTangentAndBitangent = function (t) {
+  if (!f(t)) throw new I("geometry is required.");
+  let e = t.attributes,
+    n = t.indices;
+  if (!f(e.position) || !f(e.position.values))
+    throw new I("geometry.attributes.position.values is required.");
+  if (!f(e.normal) || !f(e.normal.values))
+    throw new I("geometry.attributes.normal.values is required.");
+  if (!f(e.st) || !f(e.st.values))
+    throw new I("geometry.attributes.st.values is required.");
+  if (!f(n)) throw new I("geometry.indices is required.");
+  if (n.length < 2 || n.length % 3 !== 0)
+    throw new I(
+      "geometry.indices length must be greater than 0 and be a multiple of 3.",
+    );
+  if (t.primitiveType !== D.TRIANGLES)
+    throw new I("geometry.primitiveType must be PrimitiveType.TRIANGLES.");
+  let s = t.attributes.position.values,
+    i = t.attributes.normal.values,
+    c = t.attributes.st.values,
+    o = t.attributes.position.values.length / 3,
+    a = n.length,
+    p = new Array(o * 3),
+    u;
+  for (u = 0; u < p.length; u++) p[u] = 0;
+  let d, m, l;
+  for (u = 0; u < a; u += 3) {
+    let v = n[u],
+      b = n[u + 1],
+      S = n[u + 2];
+    ((d = v * 3), (m = b * 3), (l = S * 3));
+    let x = v * 2,
+      w = b * 2,
+      A = S * 2,
+      E = s[d],
+      P = s[d + 1],
+      O = s[d + 2],
+      L = c[x],
+      g = c[x + 1],
+      T = c[w + 1] - g,
+      C = c[A + 1] - g,
+      z = 1 / ((c[w] - L) * C - (c[A] - L) * T),
+      q = (C * (s[m] - E) - T * (s[l] - E)) * z,
+      V = (C * (s[m + 1] - P) - T * (s[l + 1] - P)) * z,
+      G = (C * (s[m + 2] - O) - T * (s[l + 2] - O)) * z;
+    ((p[d] += q),
+      (p[d + 1] += V),
+      (p[d + 2] += G),
+      (p[m] += q),
+      (p[m + 1] += V),
+      (p[m + 2] += G),
+      (p[l] += q),
+      (p[l + 1] += V),
+      (p[l + 2] += G));
+  }
+  let h = new Float32Array(o * 3),
+    y = new Float32Array(o * 3);
+  for (u = 0; u < o; u++) {
+    ((d = u * 3), (m = d + 1), (l = d + 2));
+    let v = r.fromArray(i, d, xe),
+      b = r.fromArray(p, d, Te),
+      S = r.dot(v, b);
+    (r.multiplyByScalar(v, S, Kt),
+      r.normalize(r.subtract(b, Kt, b), b),
+      (h[d] = b.x),
+      (h[m] = b.y),
+      (h[l] = b.z),
+      r.normalize(r.cross(v, b, b), b),
+      (y[d] = b.x),
+      (y[m] = b.y),
+      (y[l] = b.z));
+  }
+  return (
+    (t.attributes.tangent = new U({
+      componentDatatype: k.FLOAT,
+      componentsPerAttribute: 3,
+      values: h,
+    })),
+    (t.attributes.bitangent = new U({
+      componentDatatype: k.FLOAT,
+      componentsPerAttribute: 3,
+      values: y,
+    })),
+    t
+  );
+};
+var bt = new R(),
+  W = new r(),
+  Qt = new r(),
+  te = new r(),
+  xt = new R();
+F.compressVertices = function (t) {
+  if (!f(t)) throw new I("geometry is required.");
+  let e = t.attributes.extrudeDirection,
+    n,
+    s;
+  if (f(e)) {
+    let P = e.values;
+    s = P.length / 3;
+    let O = new Float32Array(s * 2),
+      L = 0;
+    for (n = 0; n < s; ++n) {
+      if ((r.fromArray(P, n * 3, W), r.equals(W, r.ZERO))) {
+        L += 2;
+        continue;
+      }
+      ((xt = et.octEncodeInRange(W, 65535, xt)),
+        (O[L++] = xt.x),
+        (O[L++] = xt.y));
+    }
+    return (
+      (t.attributes.compressedAttributes = new U({
+        componentDatatype: k.FLOAT,
+        componentsPerAttribute: 2,
+        values: O,
+      })),
+      delete t.attributes.extrudeDirection,
+      t
+    );
+  }
+  let i = t.attributes.normal,
+    c = t.attributes.st,
+    o = f(i),
+    a = f(c);
+  if (!o && !a) return t;
+  let p = t.attributes.tangent,
+    u = t.attributes.bitangent,
+    d = f(p),
+    m = f(u),
+    l,
+    h,
+    y,
+    v;
+  (o && (l = i.values),
+    a && (h = c.values),
+    d && (y = p.values),
+    m && (v = u.values),
+    (s = (o ? l.length : h.length) / (o ? 3 : 2)));
+  let x = s,
+    w = a && o ? 2 : 1;
+  ((w += d || m ? 1 : 0), (x *= w));
+  let A = new Float32Array(x),
+    E = 0;
+  for (n = 0; n < s; ++n) {
+    a &&
+      (R.fromArray(h, n * 2, bt), (A[E++] = et.compressTextureCoordinates(bt)));
+    let P = n * 3;
+    o && f(y) && f(v)
+      ? (r.fromArray(l, P, W),
+        r.fromArray(y, P, Qt),
+        r.fromArray(v, P, te),
+        et.octPack(W, Qt, te, bt),
+        (A[E++] = bt.x),
+        (A[E++] = bt.y))
+      : (o && (r.fromArray(l, P, W), (A[E++] = et.octEncodeFloat(W))),
+        d && (r.fromArray(y, P, W), (A[E++] = et.octEncodeFloat(W))),
+        m && (r.fromArray(v, P, W), (A[E++] = et.octEncodeFloat(W))));
+  }
+  return (
+    (t.attributes.compressedAttributes = new U({
+      componentDatatype: k.FLOAT,
+      componentsPerAttribute: w,
+      values: A,
+    })),
+    o && delete t.attributes.normal,
+    a && delete t.attributes.st,
+    m && delete t.attributes.bitangent,
+    d && delete t.attributes.tangent,
+    t
+  );
+};
+function Ae(t) {
+  if (f(t.indices)) return t;
+  let e = B.computeNumberOfVertices(t);
+  if (e < 3) throw new I("The number of vertices must be at least three.");
+  if (e % 3 !== 0)
+    throw new I("The number of vertices must be a multiple of three.");
+  let n = j.createTypedArray(e, e);
+  for (let s = 0; s < e; ++s) n[s] = s;
+  return ((t.indices = n), t);
+}
+function Ie(t) {
+  let e = B.computeNumberOfVertices(t);
+  if (e < 3) throw new I("The number of vertices must be at least three.");
+  let n = j.createTypedArray(e, (e - 2) * 3);
+  ((n[0] = 1), (n[1] = 0), (n[2] = 2));
+  let s = 3;
+  for (let i = 3; i < e; ++i) ((n[s++] = i - 1), (n[s++] = 0), (n[s++] = i));
+  return ((t.indices = n), (t.primitiveType = D.TRIANGLES), t);
+}
+function Se(t) {
+  let e = B.computeNumberOfVertices(t);
+  if (e < 3) throw new I("The number of vertices must be at least 3.");
+  let n = j.createTypedArray(e, (e - 2) * 3);
+  ((n[0] = 0),
+    (n[1] = 1),
+    (n[2] = 2),
+    e > 3 && ((n[3] = 0), (n[4] = 2), (n[5] = 3)));
+  let s = 6;
+  for (let i = 3; i < e - 1; i += 2)
+    ((n[s++] = i),
+      (n[s++] = i - 1),
+      (n[s++] = i + 1),
+      i + 2 < e && ((n[s++] = i), (n[s++] = i + 1), (n[s++] = i + 2)));
+  return ((t.indices = n), (t.primitiveType = D.TRIANGLES), t);
+}
+function Pe(t) {
+  if (f(t.indices)) return t;
+  let e = B.computeNumberOfVertices(t);
+  if (e < 2) throw new I("The number of vertices must be at least two.");
+  if (e % 2 !== 0)
+    throw new I("The number of vertices must be a multiple of 2.");
+  let n = j.createTypedArray(e, e);
+  for (let s = 0; s < e; ++s) n[s] = s;
+  return ((t.indices = n), t);
+}
+function ge(t) {
+  let e = B.computeNumberOfVertices(t);
+  if (e < 2) throw new I("The number of vertices must be at least two.");
+  let n = j.createTypedArray(e, (e - 1) * 2);
+  ((n[0] = 0), (n[1] = 1));
+  let s = 2;
+  for (let i = 2; i < e; ++i) ((n[s++] = i - 1), (n[s++] = i));
+  return ((t.indices = n), (t.primitiveType = D.LINES), t);
+}
+function Oe(t) {
+  let e = B.computeNumberOfVertices(t);
+  if (e < 2) throw new I("The number of vertices must be at least two.");
+  let n = j.createTypedArray(e, e * 2);
+  ((n[0] = 0), (n[1] = 1));
+  let s = 2;
+  for (let i = 2; i < e; ++i) ((n[s++] = i - 1), (n[s++] = i));
+  return (
+    (n[s++] = e - 1),
+    (n[s] = 0),
+    (t.indices = n),
+    (t.primitiveType = D.LINES),
+    t
+  );
+}
+function Le(t) {
+  switch (t.primitiveType) {
+    case D.TRIANGLE_FAN:
+      return Ie(t);
+    case D.TRIANGLE_STRIP:
+      return Se(t);
+    case D.TRIANGLES:
+      return Ae(t);
+    case D.LINE_STRIP:
+      return ge(t);
+    case D.LINE_LOOP:
+      return Oe(t);
+    case D.LINES:
+      return Pe(t);
+  }
+  return t;
+}
+function tt(t, e) {
+  Math.abs(t.y) < N.EPSILON6 && (e ? (t.y = -N.EPSILON6) : (t.y = N.EPSILON6));
+}
+function Ee(t, e, n) {
+  if (t.y !== 0 && e.y !== 0 && n.y !== 0) {
+    (tt(t, t.y < 0), tt(e, e.y < 0), tt(n, n.y < 0));
+    return;
+  }
+  let s = Math.abs(t.y),
+    i = Math.abs(e.y),
+    c = Math.abs(n.y),
+    o;
+  s > i
+    ? s > c
+      ? (o = N.sign(t.y))
+      : (o = N.sign(n.y))
+    : i > c
+      ? (o = N.sign(e.y))
+      : (o = N.sign(n.y));
+  let a = o < 0;
+  (tt(t, a), tt(e, a), tt(n, a));
+}
+var ee = new r();
+function X(t, e, n, s) {
+  (r.add(t, r.multiplyByScalar(r.subtract(e, t, ee), t.y / (t.y - e.y), ee), n),
+    r.clone(n, s),
+    tt(n, !0),
+    tt(s, !1));
+}
+var nt = new r(),
+  it = new r(),
+  st = new r(),
+  ot = new r(),
+  Rt = { positions: new Array(7), indices: new Array(3 * 3) };
+function Ne(t, e, n) {
+  if (t.x >= 0 || e.x >= 0 || n.x >= 0) return;
+  Ee(t, e, n);
+  let s = t.y < 0,
+    i = e.y < 0,
+    c = n.y < 0,
+    o = 0;
+  ((o += s ? 1 : 0), (o += i ? 1 : 0), (o += c ? 1 : 0));
+  let a = Rt.indices;
+  o === 1
+    ? ((a[1] = 3),
+      (a[2] = 4),
+      (a[5] = 6),
+      (a[7] = 6),
+      (a[8] = 5),
+      s
+        ? (X(t, e, nt, st),
+          X(t, n, it, ot),
+          (a[0] = 0),
+          (a[3] = 1),
+          (a[4] = 2),
+          (a[6] = 1))
+        : i
+          ? (X(e, n, nt, st),
+            X(e, t, it, ot),
+            (a[0] = 1),
+            (a[3] = 2),
+            (a[4] = 0),
+            (a[6] = 2))
+          : c &&
+            (X(n, t, nt, st),
+            X(n, e, it, ot),
+            (a[0] = 2),
+            (a[3] = 0),
+            (a[4] = 1),
+            (a[6] = 0)))
+    : o === 2 &&
+      ((a[2] = 4),
+      (a[4] = 4),
+      (a[5] = 3),
+      (a[7] = 5),
+      (a[8] = 6),
+      s
+        ? i
+          ? c ||
+            (X(n, t, nt, st),
+            X(n, e, it, ot),
+            (a[0] = 0),
+            (a[1] = 1),
+            (a[3] = 0),
+            (a[6] = 2))
+          : (X(e, n, nt, st),
+            X(e, t, it, ot),
+            (a[0] = 2),
+            (a[1] = 0),
+            (a[3] = 2),
+            (a[6] = 1))
+        : (X(t, e, nt, st),
+          X(t, n, it, ot),
+          (a[0] = 1),
+          (a[1] = 2),
+          (a[3] = 1),
+          (a[6] = 0)));
+  let p = Rt.positions;
+  return (
+    (p[0] = t),
+    (p[1] = e),
+    (p[2] = n),
+    (p.length = 3),
+    (o === 1 || o === 2) &&
+      ((p[3] = nt), (p[4] = it), (p[5] = st), (p[6] = ot), (p.length = 7)),
+    Rt
+  );
+}
+function ne(t, e) {
+  let n = t.attributes;
+  if (n.position.values.length === 0) return;
+  for (let i in n)
+    if (n.hasOwnProperty(i) && f(n[i]) && f(n[i].values)) {
+      let c = n[i];
+      c.values = k.createTypedArray(c.componentDatatype, c.values);
+    }
+  let s = B.computeNumberOfVertices(t);
+  return (
+    (t.indices = j.createTypedArray(s, t.indices)),
+    e && (t.boundingSphere = rt.fromVertices(n.position.values)),
+    t
+  );
+}
+function lt(t) {
+  let e = t.attributes,
+    n = {};
+  for (let s in e)
+    if (e.hasOwnProperty(s) && f(e[s]) && f(e[s].values)) {
+      let i = e[s];
+      n[s] = new U({
+        componentDatatype: i.componentDatatype,
+        componentsPerAttribute: i.componentsPerAttribute,
+        normalize: i.normalize,
+        values: [],
+      });
+    }
+  return new B({ attributes: n, indices: [], primitiveType: t.primitiveType });
+}
+function kt(t, e, n) {
+  let s = f(t.geometry.boundingSphere);
+  ((e = ne(e, s)),
+    (n = ne(n, s)),
+    f(n) && !f(e)
+      ? (t.geometry = n)
+      : !f(n) && f(e)
+        ? (t.geometry = e)
+        : ((t.westHemisphereGeometry = e),
+          (t.eastHemisphereGeometry = n),
+          (t.geometry = void 0)));
+}
+function Ft(t, e) {
+  let n = new t(),
+    s = new t(),
+    i = new t();
+  return function (c, o, a, p, u, d, m, l) {
+    let h = t.fromArray(u, c * e, n),
+      y = t.fromArray(u, o * e, s),
+      v = t.fromArray(u, a * e, i);
+    (t.multiplyByScalar(h, p.x, h),
+      t.multiplyByScalar(y, p.y, y),
+      t.multiplyByScalar(v, p.z, v));
+    let b = t.add(h, y, h);
+    (t.add(b, v, b), l && t.normalize(b, b), t.pack(b, d, m * e));
+  };
+}
+var ze = Ft(dt, 4),
+  It = Ft(r, 3),
+  ae = Ft(R, 2),
+  De = function (t, e, n, s, i, c, o) {
+    let a = i[t] * s.x,
+      p = i[e] * s.y,
+      u = i[n] * s.z;
+    c[o] = a + p + u > N.EPSILON6 ? 1 : 0;
+  },
+  wt = new r(),
+  Gt = new r(),
+  Ct = new r(),
+  qe = new r();
+function Tt(t, e, n, s, i, c, o, a, p, u, d, m, l, h, y, v) {
+  if (!f(c) && !f(o) && !f(a) && !f(p) && !f(u) && h === 0) return;
+  let b = r.fromArray(i, t * 3, wt),
+    S = r.fromArray(i, e * 3, Gt),
+    x = r.fromArray(i, n * 3, Ct),
+    w = Ht(s, b, S, x, qe);
+  if (f(w)) {
+    if ((f(c) && It(t, e, n, w, c, m.normal.values, v, !0), f(u))) {
+      let A = r.fromArray(u, t * 3, wt),
+        E = r.fromArray(u, e * 3, Gt),
+        P = r.fromArray(u, n * 3, Ct);
+      (r.multiplyByScalar(A, w.x, A),
+        r.multiplyByScalar(E, w.y, E),
+        r.multiplyByScalar(P, w.z, P));
+      let O;
+      (!r.equals(A, r.ZERO) || !r.equals(E, r.ZERO) || !r.equals(P, r.ZERO)
+        ? ((O = r.add(A, E, A)), r.add(O, P, O), r.normalize(O, O))
+        : ((O = wt), (O.x = 0), (O.y = 0), (O.z = 0)),
+        r.pack(O, m.extrudeDirection.values, v * 3));
+    }
+    if (
+      (f(d) && De(t, e, n, w, d, m.applyOffset.values, v),
+      f(o) && It(t, e, n, w, o, m.tangent.values, v, !0),
+      f(a) && It(t, e, n, w, a, m.bitangent.values, v, !0),
+      f(p) && ae(t, e, n, w, p, m.st.values, v),
+      h > 0)
+    )
+      for (let A = 0; A < h; A++) {
+        let E = l[A];
+        Ve(t, e, n, w, v, y[E], m[E]);
+      }
+  }
+}
+function Ve(t, e, n, s, i, c, o) {
+  let a = c.componentsPerAttribute,
+    p = c.values,
+    u = o.values;
+  switch (a) {
+    case 4:
+      ze(t, e, n, s, p, u, i, !1);
+      break;
+    case 3:
+      It(t, e, n, s, p, u, i, !1);
+      break;
+    case 2:
+      ae(t, e, n, s, p, u, i, !1);
+      break;
+    default:
+      u[i] = p[t] * s.x + p[e] * s.y + p[n] * s.z;
+  }
+}
+function Q(t, e, n, s, i, c) {
+  let o = t.position.values.length / 3;
+  if (i !== -1) {
+    let a = s[i],
+      p = n[a];
+    return p === -1
+      ? ((n[a] = o), t.position.values.push(c.x, c.y, c.z), e.push(o), o)
+      : (e.push(p), p);
+  }
+  return (t.position.values.push(c.x, c.y, c.z), e.push(o), o);
+}
+var Re = {
+  position: !0,
+  normal: !0,
+  bitangent: !0,
+  tangent: !0,
+  st: !0,
+  extrudeDirection: !0,
+  applyOffset: !0,
+};
+function ie(t) {
+  let e = t.geometry,
+    n = e.attributes,
+    s = n.position.values,
+    i = f(n.normal) ? n.normal.values : void 0,
+    c = f(n.bitangent) ? n.bitangent.values : void 0,
+    o = f(n.tangent) ? n.tangent.values : void 0,
+    a = f(n.st) ? n.st.values : void 0,
+    p = f(n.extrudeDirection) ? n.extrudeDirection.values : void 0,
+    u = f(n.applyOffset) ? n.applyOffset.values : void 0,
+    d = e.indices,
+    m = [];
+  for (let O in n) n.hasOwnProperty(O) && !Re[O] && f(n[O]) && m.push(O);
+  let l = m.length,
+    h = lt(e),
+    y = lt(e),
+    v,
+    b,
+    S,
+    x,
+    w,
+    A = [];
+  A.length = s.length / 3;
+  let E = [];
+  for (E.length = s.length / 3, w = 0; w < A.length; ++w)
+    ((A[w] = -1), (E[w] = -1));
+  let P = d.length;
+  for (w = 0; w < P; w += 3) {
+    let O = d[w],
+      L = d[w + 1],
+      g = d[w + 2],
+      T = r.fromArray(s, O * 3),
+      C = r.fromArray(s, L * 3),
+      z = r.fromArray(s, g * 3),
+      q = Ne(T, C, z);
+    if (f(q) && q.positions.length > 3) {
+      let V = q.positions,
+        G = q.indices,
+        M = G.length;
+      for (let J = 0; J < M; ++J) {
+        let Y = G[J],
+          _ = V[Y];
+        (_.y < 0
+          ? ((v = y.attributes), (b = y.indices), (S = A))
+          : ((v = h.attributes), (b = h.indices), (S = E)),
+          (x = Q(v, b, S, d, Y < 3 ? w + Y : -1, _)),
+          Tt(O, L, g, _, s, i, o, c, a, p, u, v, m, l, n, x));
+      }
+    } else
+      (f(q) &&
+        ((T = q.positions[0]), (C = q.positions[1]), (z = q.positions[2])),
+        T.y < 0
+          ? ((v = y.attributes), (b = y.indices), (S = A))
+          : ((v = h.attributes), (b = h.indices), (S = E)),
+        (x = Q(v, b, S, d, w, T)),
+        Tt(O, L, g, T, s, i, o, c, a, p, u, v, m, l, n, x),
+        (x = Q(v, b, S, d, w + 1, C)),
+        Tt(O, L, g, C, s, i, o, c, a, p, u, v, m, l, n, x),
+        (x = Q(v, b, S, d, w + 2, z)),
+        Tt(O, L, g, z, s, i, o, c, a, p, u, v, m, l, n, x));
+  }
+  kt(t, y, h);
+}
+var ue = Et.fromPointNormal(r.ZERO, r.UNIT_Y),
+  Ge = new r(),
+  Ce = new r();
+function ut(t, e, n, s, i, c, o) {
+  if (!f(o)) return;
+  let a = r.fromArray(s, t * 3, wt);
+  r.equalsEpsilon(a, n, N.EPSILON10)
+    ? (c.applyOffset.values[i] = o[t])
+    : (c.applyOffset.values[i] = o[e]);
+}
+function se(t) {
+  let e = t.geometry,
+    n = e.attributes,
+    s = n.position.values,
+    i = f(n.applyOffset) ? n.applyOffset.values : void 0,
+    c = e.indices,
+    o = lt(e),
+    a = lt(e),
+    p,
+    u = c.length,
+    d = [];
+  d.length = s.length / 3;
+  let m = [];
+  for (m.length = s.length / 3, p = 0; p < d.length; ++p)
+    ((d[p] = -1), (m[p] = -1));
+  for (p = 0; p < u; p += 2) {
+    let l = c[p],
+      h = c[p + 1],
+      y = r.fromArray(s, l * 3, wt),
+      v = r.fromArray(s, h * 3, Gt),
+      b;
+    (Math.abs(y.y) < N.EPSILON6 &&
+      (y.y < 0 ? (y.y = -N.EPSILON6) : (y.y = N.EPSILON6)),
+      Math.abs(v.y) < N.EPSILON6 &&
+        (v.y < 0 ? (v.y = -N.EPSILON6) : (v.y = N.EPSILON6)));
+    let S = o.attributes,
+      x = o.indices,
+      w = m,
+      A = a.attributes,
+      E = a.indices,
+      P = d,
+      O = Lt.lineSegmentPlane(y, v, ue, Ct);
+    if (f(O)) {
+      let L = r.multiplyByScalar(r.UNIT_Y, 5 * N.EPSILON9, Ge);
+      y.y < 0 &&
+        (r.negate(L, L),
+        (S = a.attributes),
+        (x = a.indices),
+        (w = d),
+        (A = o.attributes),
+        (E = o.indices),
+        (P = m));
+      let g = r.add(O, L, Ce);
+      ((b = Q(S, x, w, c, p, y)),
+        ut(l, h, y, s, b, S, i),
+        (b = Q(S, x, w, c, -1, g)),
+        ut(l, h, g, s, b, S, i),
+        r.negate(L, L),
+        r.add(O, L, g),
+        (b = Q(A, E, P, c, -1, g)),
+        ut(l, h, g, s, b, A, i),
+        (b = Q(A, E, P, c, p + 1, v)),
+        ut(l, h, v, s, b, A, i));
+    } else {
+      let L, g, T;
+      (y.y < 0
+        ? ((L = a.attributes), (g = a.indices), (T = d))
+        : ((L = o.attributes), (g = o.indices), (T = m)),
+        (b = Q(L, g, T, c, p, y)),
+        ut(l, h, y, s, b, L, i),
+        (b = Q(L, g, T, c, p + 1, v)),
+        ut(l, h, v, s, b, L, i));
+    }
+  }
+  kt(t, a, o);
+}
+var oe = new R(),
+  Be = new R(),
+  le = new r(),
+  fe = new r(),
+  Bt = new r(),
+  ke = new r(),
+  Fe = new r(),
+  Me = new r(),
+  re = new dt();
+function ce(t) {
+  let e = t.attributes,
+    n = e.position.values,
+    s = e.prevPosition.values,
+    i = e.nextPosition.values,
+    c = n.length;
+  for (let o = 0; o < c; o += 3) {
+    let a = r.unpack(n, o, le);
+    if (a.x > 0) continue;
+    let p = r.unpack(s, o, fe);
+    ((a.y < 0 && p.y > 0) || (a.y > 0 && p.y < 0)) &&
+      (o - 3 > 0
+        ? ((s[o] = n[o - 3]), (s[o + 1] = n[o - 2]), (s[o + 2] = n[o - 1]))
+        : r.pack(a, s, o));
+    let u = r.unpack(i, o, Bt);
+    ((a.y < 0 && u.y > 0) || (a.y > 0 && u.y < 0)) &&
+      (o + 3 < c
+        ? ((i[o] = n[o + 3]), (i[o + 1] = n[o + 4]), (i[o + 2] = n[o + 5]))
+        : r.pack(a, i, o));
+  }
+}
+var _e = 5 * N.EPSILON9,
+  At = N.EPSILON6;
+function Ue(t) {
+  let e = t.geometry,
+    n = e.attributes,
+    s = n.position.values,
+    i = n.prevPosition.values,
+    c = n.nextPosition.values,
+    o = n.expandAndWidth.values,
+    a = f(n.st) ? n.st.values : void 0,
+    p = f(n.color) ? n.color.values : void 0,
+    u = lt(e),
+    d = lt(e),
+    m,
+    l,
+    h,
+    y = !1,
+    v = s.length / 3;
+  for (m = 0; m < v; m += 4) {
+    let b = m,
+      S = m + 2,
+      x = r.fromArray(s, b * 3, le),
+      w = r.fromArray(s, S * 3, fe);
+    if (Math.abs(x.y) < At)
+      for (
+        x.y = At * (w.y < 0 ? -1 : 1),
+          s[m * 3 + 1] = x.y,
+          s[(m + 1) * 3 + 1] = x.y,
+          l = b * 3;
+        l < b * 3 + 4 * 3;
+        l += 3
+      )
+        ((i[l] = s[m * 3]),
+          (i[l + 1] = s[m * 3 + 1]),
+          (i[l + 2] = s[m * 3 + 2]));
+    if (Math.abs(w.y) < At)
+      for (
+        w.y = At * (x.y < 0 ? -1 : 1),
+          s[(m + 2) * 3 + 1] = w.y,
+          s[(m + 3) * 3 + 1] = w.y,
+          l = b * 3;
+        l < b * 3 + 4 * 3;
+        l += 3
+      )
+        ((c[l] = s[(m + 2) * 3]),
+          (c[l + 1] = s[(m + 2) * 3 + 1]),
+          (c[l + 2] = s[(m + 2) * 3 + 2]));
+    let A = u.attributes,
+      E = u.indices,
+      P = d.attributes,
+      O = d.indices,
+      L = Lt.lineSegmentPlane(x, w, ue, ke);
+    if (f(L)) {
+      y = !0;
+      let g = r.multiplyByScalar(r.UNIT_Y, _e, Fe);
+      x.y < 0 &&
+        (r.negate(g, g),
+        (A = d.attributes),
+        (E = d.indices),
+        (P = u.attributes),
+        (O = u.indices));
+      let T = r.add(L, g, Me);
+      (A.position.values.push(x.x, x.y, x.z, x.x, x.y, x.z),
+        A.position.values.push(T.x, T.y, T.z),
+        A.position.values.push(T.x, T.y, T.z),
+        A.prevPosition.values.push(i[b * 3], i[b * 3 + 1], i[b * 3 + 2]),
+        A.prevPosition.values.push(i[b * 3 + 3], i[b * 3 + 4], i[b * 3 + 5]),
+        A.prevPosition.values.push(x.x, x.y, x.z, x.x, x.y, x.z),
+        A.nextPosition.values.push(T.x, T.y, T.z),
+        A.nextPosition.values.push(T.x, T.y, T.z),
+        A.nextPosition.values.push(T.x, T.y, T.z),
+        A.nextPosition.values.push(T.x, T.y, T.z),
+        r.negate(g, g),
+        r.add(L, g, T),
+        P.position.values.push(T.x, T.y, T.z),
+        P.position.values.push(T.x, T.y, T.z),
+        P.position.values.push(w.x, w.y, w.z, w.x, w.y, w.z),
+        P.prevPosition.values.push(T.x, T.y, T.z),
+        P.prevPosition.values.push(T.x, T.y, T.z),
+        P.prevPosition.values.push(T.x, T.y, T.z),
+        P.prevPosition.values.push(T.x, T.y, T.z),
+        P.nextPosition.values.push(w.x, w.y, w.z, w.x, w.y, w.z),
+        P.nextPosition.values.push(c[S * 3], c[S * 3 + 1], c[S * 3 + 2]),
+        P.nextPosition.values.push(c[S * 3 + 3], c[S * 3 + 4], c[S * 3 + 5]));
+      let C = R.fromArray(o, b * 2, oe),
+        z = Math.abs(C.y);
+      (A.expandAndWidth.values.push(-1, z, 1, z),
+        A.expandAndWidth.values.push(-1, -z, 1, -z),
+        P.expandAndWidth.values.push(-1, z, 1, z),
+        P.expandAndWidth.values.push(-1, -z, 1, -z));
+      let q = r.magnitudeSquared(r.subtract(L, x, Bt));
+      if (((q /= r.magnitudeSquared(r.subtract(w, x, Bt))), f(p))) {
+        let V = dt.fromArray(p, b * 4, re),
+          G = dt.fromArray(p, S * 4, re),
+          M = N.lerp(V.x, G.x, q),
+          J = N.lerp(V.y, G.y, q),
+          Y = N.lerp(V.z, G.z, q),
+          _ = N.lerp(V.w, G.w, q);
+        for (l = b * 4; l < b * 4 + 2 * 4; ++l) A.color.values.push(p[l]);
+        for (
+          A.color.values.push(M, J, Y, _),
+            A.color.values.push(M, J, Y, _),
+            P.color.values.push(M, J, Y, _),
+            P.color.values.push(M, J, Y, _),
+            l = S * 4;
+          l < S * 4 + 2 * 4;
+          ++l
+        )
+          P.color.values.push(p[l]);
+      }
+      if (f(a)) {
+        let V = R.fromArray(a, b * 2, oe),
+          G = R.fromArray(a, (m + 3) * 2, Be),
+          M = N.lerp(V.x, G.x, q);
+        for (l = b * 2; l < b * 2 + 2 * 2; ++l) A.st.values.push(a[l]);
+        for (
+          A.st.values.push(M, V.y),
+            A.st.values.push(M, G.y),
+            P.st.values.push(M, V.y),
+            P.st.values.push(M, G.y),
+            l = S * 2;
+          l < S * 2 + 2 * 2;
+          ++l
+        )
+          P.st.values.push(a[l]);
+      }
+      ((h = A.position.values.length / 3 - 4),
+        E.push(h, h + 2, h + 1),
+        E.push(h + 1, h + 2, h + 3),
+        (h = P.position.values.length / 3 - 4),
+        O.push(h, h + 2, h + 1),
+        O.push(h + 1, h + 2, h + 3));
+    } else {
+      let g, T;
+      for (
+        x.y < 0
+          ? ((g = d.attributes), (T = d.indices))
+          : ((g = u.attributes), (T = u.indices)),
+          g.position.values.push(x.x, x.y, x.z),
+          g.position.values.push(x.x, x.y, x.z),
+          g.position.values.push(w.x, w.y, w.z),
+          g.position.values.push(w.x, w.y, w.z),
+          l = m * 3;
+        l < m * 3 + 4 * 3;
+        ++l
+      )
+        (g.prevPosition.values.push(i[l]), g.nextPosition.values.push(c[l]));
+      for (l = m * 2; l < m * 2 + 4 * 2; ++l)
+        (g.expandAndWidth.values.push(o[l]), f(a) && g.st.values.push(a[l]));
+      if (f(p))
+        for (l = m * 4; l < m * 4 + 4 * 4; ++l) g.color.values.push(p[l]);
+      ((h = g.position.values.length / 3 - 4),
+        T.push(h, h + 2, h + 1),
+        T.push(h + 1, h + 2, h + 3));
+    }
+  }
+  (y && (ce(d), ce(u)), kt(t, d, u));
+}
+F.splitLongitude = function (t) {
+  if (!f(t)) throw new I("instance is required.");
+  let e = t.geometry,
+    n = e.boundingSphere;
+  if (
+    f(n) &&
+    (n.center.x - n.radius > 0 ||
+      rt.intersectPlane(n, Et.ORIGIN_ZX_PLANE) !== Ut.INTERSECTING)
+  )
+    return t;
+  if (e.geometryType !== mt.NONE)
+    switch (e.geometryType) {
+      case mt.POLYLINES:
+        Ue(t);
+        break;
+      case mt.TRIANGLES:
+        ie(t);
+        break;
+      case mt.LINES:
+        se(t);
+        break;
+    }
+  else
+    (Le(e),
+      e.primitiveType === D.TRIANGLES
+        ? ie(t)
+        : e.primitiveType === D.LINES && se(t));
+  return t;
+};
+var gn = F;
+export { gn as a };