create-swdg-frontend 0.1.0

package/template/public/Cesium1.119/Workers/createRectangleOutlineGeometry.js

@@ -0,0 +1,299 @@
+/**
+ * @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 C } from "./chunk-OO23RBLX.js";
+import { a as v } from "./chunk-ILGBPNP6.js";
+import { b as z } from "./chunk-O5IJ3OGP.js";
+import "./chunk-FYOYUPXG.js";
+import { a as O } from "./chunk-P37AI2DW.js";
+import { a as Y } from "./chunk-T6BE4RZK.js";
+import { b as B, c as q, d as y } from "./chunk-X5IHHI6X.js";
+import { d as R } from "./chunk-TMSETF7M.js";
+import { h as b } from "./chunk-7Z5IIKOJ.js";
+import { a as T } from "./chunk-KZNJOCYU.js";
+import { a as U, b as M, d as w } from "./chunk-POASMU2N.js";
+import { a as P } from "./chunk-R6KGAEF6.js";
+import "./chunk-3C7WC463.js";
+import "./chunk-II4VNKYR.js";
+import { a as E } from "./chunk-IUA6FAOZ.js";
+import { a as N } from "./chunk-UH2WFNTA.js";
+import { e as S } from "./chunk-PEYJTJPE.js";
+var j = new R(),
+  K = new R(),
+  Q = new U(),
+  W = new b();
+function F(t, e) {
+  let i = t._ellipsoid,
+    m = e.height,
+    s = e.width,
+    h = e.northCap,
+    a = e.southCap,
+    _ = m,
+    A = 2,
+    o = 0,
+    g = 4;
+  (h && ((A -= 1), (_ -= 1), (o += 1), (g -= 2)),
+    a && ((A -= 1), (_ -= 1), (o += 1), (g -= 2)),
+    (o += A * s + 2 * _ - g));
+  let n = new Float64Array(o * 3),
+    l = 0,
+    f = 0,
+    p,
+    r = Q;
+  if (h)
+    (C.computePosition(e, i, !1, f, 0, r),
+      (n[l++] = r.x),
+      (n[l++] = r.y),
+      (n[l++] = r.z));
+  else
+    for (p = 0; p < s; p++)
+      (C.computePosition(e, i, !1, f, p, r),
+        (n[l++] = r.x),
+        (n[l++] = r.y),
+        (n[l++] = r.z));
+  for (p = s - 1, f = 1; f < m; f++)
+    (C.computePosition(e, i, !1, f, p, r),
+      (n[l++] = r.x),
+      (n[l++] = r.y),
+      (n[l++] = r.z));
+  if (((f = m - 1), !a))
+    for (p = s - 2; p >= 0; p--)
+      (C.computePosition(e, i, !1, f, p, r),
+        (n[l++] = r.x),
+        (n[l++] = r.y),
+        (n[l++] = r.z));
+  for (p = 0, f = m - 2; f > 0; f--)
+    (C.computePosition(e, i, !1, f, p, r),
+      (n[l++] = r.x),
+      (n[l++] = r.y),
+      (n[l++] = r.z));
+  let u = (n.length / 3) * 2,
+    c = O.createTypedArray(n.length / 3, u),
+    H = 0;
+  for (let D = 0; D < n.length / 3 - 1; D++) ((c[H++] = D), (c[H++] = D + 1));
+  ((c[H++] = n.length / 3 - 1), (c[H++] = 0));
+  let d = new q({ attributes: new Y(), primitiveType: B.LINES });
+  return (
+    (d.attributes.position = new y({
+      componentDatatype: T.DOUBLE,
+      componentsPerAttribute: 3,
+      values: n,
+    })),
+    (d.indices = c),
+    d
+  );
+}
+function X(t, e) {
+  let i = t._surfaceHeight,
+    m = t._extrudedHeight,
+    s = t._ellipsoid,
+    h = F(t, e),
+    a = e.height,
+    _ = e.width,
+    A = z.scaleToGeodeticHeight(h.attributes.position.values, i, s, !1),
+    o = A.length,
+    g = new Float64Array(o * 2);
+  g.set(A);
+  let n = z.scaleToGeodeticHeight(h.attributes.position.values, m, s);
+  (g.set(n, o), (h.attributes.position.values = g));
+  let l = e.northCap,
+    f = e.southCap,
+    p = 4;
+  (l && (p -= 1), f && (p -= 1));
+  let r = (g.length / 3 + p) * 2,
+    u = O.createTypedArray(g.length / 3, r);
+  o = g.length / 6;
+  let c = 0;
+  for (let d = 0; d < o - 1; d++)
+    ((u[c++] = d), (u[c++] = d + 1), (u[c++] = d + o), (u[c++] = d + o + 1));
+  ((u[c++] = o - 1),
+    (u[c++] = 0),
+    (u[c++] = o + o - 1),
+    (u[c++] = o),
+    (u[c++] = 0),
+    (u[c++] = o));
+  let H;
+  if (l) H = a - 1;
+  else {
+    let d = _ - 1;
+    ((u[c++] = d), (u[c++] = d + o), (H = _ + a - 2));
+  }
+  if (((u[c++] = H), (u[c++] = H + o), !f)) {
+    let d = _ + H - 1;
+    ((u[c++] = d), (u[c] = d + o));
+  }
+  return ((h.indices = u), h);
+}
+function L(t) {
+  t = E(t, E.EMPTY_OBJECT);
+  let e = t.rectangle,
+    i = E(t.granularity, P.RADIANS_PER_DEGREE),
+    m = E(t.ellipsoid, w.default),
+    s = E(t.rotation, 0);
+  if (!S(e)) throw new N("rectangle is required.");
+  if ((b.validate(e), e.north < e.south))
+    throw new N(
+      "options.rectangle.north must be greater than options.rectangle.south",
+    );
+  let h = E(t.height, 0),
+    a = E(t.extrudedHeight, h);
+  ((this._rectangle = b.clone(e)),
+    (this._granularity = i),
+    (this._ellipsoid = m),
+    (this._surfaceHeight = Math.max(h, a)),
+    (this._rotation = s),
+    (this._extrudedHeight = Math.min(h, a)),
+    (this._offsetAttribute = t.offsetAttribute),
+    (this._workerName = "createRectangleOutlineGeometry"));
+}
+L.packedLength = b.packedLength + w.packedLength + 5;
+L.pack = function (t, e, i) {
+  if (!S(t)) throw new N("value is required");
+  if (!S(e)) throw new N("array is required");
+  return (
+    (i = E(i, 0)),
+    b.pack(t._rectangle, e, i),
+    (i += b.packedLength),
+    w.pack(t._ellipsoid, e, i),
+    (i += w.packedLength),
+    (e[i++] = t._granularity),
+    (e[i++] = t._surfaceHeight),
+    (e[i++] = t._rotation),
+    (e[i++] = t._extrudedHeight),
+    (e[i] = E(t._offsetAttribute, -1)),
+    e
+  );
+};
+var V = new b(),
+  J = w.clone(w.UNIT_SPHERE),
+  k = {
+    rectangle: V,
+    ellipsoid: J,
+    granularity: void 0,
+    height: void 0,
+    rotation: void 0,
+    extrudedHeight: void 0,
+    offsetAttribute: void 0,
+  };
+L.unpack = function (t, e, i) {
+  if (!S(t)) throw new N("array is required");
+  e = E(e, 0);
+  let m = b.unpack(t, e, V);
+  e += b.packedLength;
+  let s = w.unpack(t, e, J);
+  e += w.packedLength;
+  let h = t[e++],
+    a = t[e++],
+    _ = t[e++],
+    A = t[e++],
+    o = t[e];
+  return S(i)
+    ? ((i._rectangle = b.clone(m, i._rectangle)),
+      (i._ellipsoid = w.clone(s, i._ellipsoid)),
+      (i._surfaceHeight = a),
+      (i._rotation = _),
+      (i._extrudedHeight = A),
+      (i._offsetAttribute = o === -1 ? void 0 : o),
+      i)
+    : ((k.granularity = h),
+      (k.height = a),
+      (k.rotation = _),
+      (k.extrudedHeight = A),
+      (k.offsetAttribute = o === -1 ? void 0 : o),
+      new L(k));
+};
+var Z = new M();
+L.createGeometry = function (t) {
+  let e = t._rectangle,
+    i = t._ellipsoid,
+    m = C.computeOptions(e, t._granularity, t._rotation, 0, W, Z),
+    s,
+    h;
+  if (
+    P.equalsEpsilon(e.north, e.south, P.EPSILON10) ||
+    P.equalsEpsilon(e.east, e.west, P.EPSILON10)
+  )
+    return;
+  let a = t._surfaceHeight,
+    _ = t._extrudedHeight,
+    A = !P.equalsEpsilon(a, _, 0, P.EPSILON2),
+    o;
+  if (A) {
+    if (((s = X(t, m)), S(t._offsetAttribute))) {
+      let l = s.attributes.position.values.length / 3,
+        f = new Uint8Array(l);
+      (t._offsetAttribute === v.TOP
+        ? (f = f.fill(1, 0, l / 2))
+        : ((o = t._offsetAttribute === v.NONE ? 0 : 1), (f = f.fill(o))),
+        (s.attributes.applyOffset = new y({
+          componentDatatype: T.UNSIGNED_BYTE,
+          componentsPerAttribute: 1,
+          values: f,
+        })));
+    }
+    let g = R.fromRectangle3D(e, i, a, K),
+      n = R.fromRectangle3D(e, i, _, j);
+    h = R.union(g, n);
+  } else {
+    if (
+      ((s = F(t, m)),
+      (s.attributes.position.values = z.scaleToGeodeticHeight(
+        s.attributes.position.values,
+        a,
+        i,
+        !1,
+      )),
+      S(t._offsetAttribute))
+    ) {
+      let g = s.attributes.position.values.length;
+      o = t._offsetAttribute === v.NONE ? 0 : 1;
+      let n = new Uint8Array(g / 3).fill(o);
+      s.attributes.applyOffset = new y({
+        componentDatatype: T.UNSIGNED_BYTE,
+        componentsPerAttribute: 1,
+        values: n,
+      });
+    }
+    h = R.fromRectangle3D(e, i, a);
+  }
+  return new q({
+    attributes: s.attributes,
+    indices: s.indices,
+    primitiveType: B.LINES,
+    boundingSphere: h,
+    offsetAttribute: t._offsetAttribute,
+  });
+};
+var x = L;
+function $(t, e) {
+  return (
+    S(e) && (t = x.unpack(t, e)),
+    (t._ellipsoid = w.clone(t._ellipsoid)),
+    (t._rectangle = b.clone(t._rectangle)),
+    x.createGeometry(t)
+  );
+}
+var Et = $;
+export { Et as default };

package/template/public/Cesium1.119/Workers/createSimplePolylineGeometry.js

@@ -0,0 +1,294 @@
+/**
+ * @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 r } from "./chunk-V7JEDBOE.js";
+import { a as S } from "./chunk-ATPDRNKI.js";
+import { a as E } from "./chunk-AMQUWUD4.js";
+import "./chunk-W23CU777.js";
+import "./chunk-FYOYUPXG.js";
+import "./chunk-TAMCUKAR.js";
+import "./chunk-PDMQLSBL.js";
+import { a as X } from "./chunk-P37AI2DW.js";
+import { a as W } from "./chunk-T6BE4RZK.js";
+import { b as K, c as Q, d as Y } from "./chunk-X5IHHI6X.js";
+import { d as j } from "./chunk-TMSETF7M.js";
+import "./chunk-7Z5IIKOJ.js";
+import { a as H } from "./chunk-KZNJOCYU.js";
+import { a as k, d as b } from "./chunk-POASMU2N.js";
+import { a as q } from "./chunk-R6KGAEF6.js";
+import "./chunk-3C7WC463.js";
+import "./chunk-II4VNKYR.js";
+import { a as w } from "./chunk-IUA6FAOZ.js";
+import { a as L } from "./chunk-UH2WFNTA.js";
+import { e as u } from "./chunk-PEYJTJPE.js";
+function Z(t, e, o, i, s, l, p) {
+  let g = E.numberOfPoints(t, e, s),
+    f,
+    n = o.red,
+    m = o.green,
+    d = o.blue,
+    T = o.alpha,
+    c = i.red,
+    h = i.green,
+    y = i.blue,
+    V = i.alpha;
+  if (r.equals(o, i)) {
+    for (f = 0; f < g; f++)
+      ((l[p++] = r.floatToByte(n)),
+        (l[p++] = r.floatToByte(m)),
+        (l[p++] = r.floatToByte(d)),
+        (l[p++] = r.floatToByte(T)));
+    return p;
+  }
+  let M = (c - n) / g,
+    C = (h - m) / g,
+    G = (y - d) / g,
+    _ = (V - T) / g,
+    a = p;
+  for (f = 0; f < g; f++)
+    ((l[a++] = r.floatToByte(n + f * M)),
+      (l[a++] = r.floatToByte(m + f * C)),
+      (l[a++] = r.floatToByte(d + f * G)),
+      (l[a++] = r.floatToByte(T + f * _)));
+  return a;
+}
+function R(t) {
+  t = w(t, w.EMPTY_OBJECT);
+  let e = t.positions,
+    o = t.colors,
+    i = w(t.colorsPerVertex, !1);
+  if (!u(e) || e.length < 2)
+    throw new L("At least two positions are required.");
+  if (u(o) && ((i && o.length < e.length) || (!i && o.length < e.length - 1)))
+    throw new L("colors has an invalid length.");
+  ((this._positions = e),
+    (this._colors = o),
+    (this._colorsPerVertex = i),
+    (this._arcType = w(t.arcType, S.GEODESIC)),
+    (this._granularity = w(t.granularity, q.RADIANS_PER_DEGREE)),
+    (this._ellipsoid = w(t.ellipsoid, b.default)),
+    (this._workerName = "createSimplePolylineGeometry"));
+  let s = 1 + e.length * k.packedLength;
+  ((s += u(o) ? 1 + o.length * r.packedLength : 1),
+    (this.packedLength = s + b.packedLength + 3));
+}
+R.pack = function (t, e, o) {
+  if (!u(t)) throw new L("value is required");
+  if (!u(e)) throw new L("array is required");
+  o = w(o, 0);
+  let i,
+    s = t._positions,
+    l = s.length;
+  for (e[o++] = l, i = 0; i < l; ++i, o += k.packedLength) k.pack(s[i], e, o);
+  let p = t._colors;
+  for (
+    l = u(p) ? p.length : 0, e[o++] = l, i = 0;
+    i < l;
+    ++i, o += r.packedLength
+  )
+    r.pack(p[i], e, o);
+  return (
+    b.pack(t._ellipsoid, e, o),
+    (o += b.packedLength),
+    (e[o++] = t._colorsPerVertex ? 1 : 0),
+    (e[o++] = t._arcType),
+    (e[o] = t._granularity),
+    e
+  );
+};
+R.unpack = function (t, e, o) {
+  if (!u(t)) throw new L("array is required");
+  e = w(e, 0);
+  let i,
+    s = t[e++],
+    l = new Array(s);
+  for (i = 0; i < s; ++i, e += k.packedLength) l[i] = k.unpack(t, e);
+  s = t[e++];
+  let p = s > 0 ? new Array(s) : void 0;
+  for (i = 0; i < s; ++i, e += r.packedLength) p[i] = r.unpack(t, e);
+  let g = b.unpack(t, e);
+  e += b.packedLength;
+  let f = t[e++] === 1,
+    n = t[e++],
+    m = t[e];
+  return u(o)
+    ? ((o._positions = l),
+      (o._colors = p),
+      (o._ellipsoid = g),
+      (o._colorsPerVertex = f),
+      (o._arcType = n),
+      (o._granularity = m),
+      o)
+    : new R({
+        positions: l,
+        colors: p,
+        ellipsoid: g,
+        colorsPerVertex: f,
+        arcType: n,
+        granularity: m,
+      });
+};
+var F = new Array(2),
+  N = new Array(2),
+  $ = {
+    positions: F,
+    height: N,
+    ellipsoid: void 0,
+    minDistance: void 0,
+    granularity: void 0,
+  };
+R.createGeometry = function (t) {
+  let e = t._positions,
+    o = t._colors,
+    i = t._colorsPerVertex,
+    s = t._arcType,
+    l = t._granularity,
+    p = t._ellipsoid,
+    g = q.chordLength(l, p.maximumRadius),
+    f = u(o) && !i,
+    n,
+    m = e.length,
+    d,
+    T,
+    c,
+    h,
+    y = 0;
+  if (s === S.GEODESIC || s === S.RHUMB) {
+    let _, a, P;
+    s === S.GEODESIC
+      ? ((_ = q.chordLength(l, p.maximumRadius)),
+        (a = E.numberOfPoints),
+        (P = E.generateArc))
+      : ((_ = l), (a = E.numberOfPointsRhumbLine), (P = E.generateRhumbArc));
+    let v = E.extractHeights(e, p),
+      B = $;
+    if (
+      (s === S.GEODESIC ? (B.minDistance = g) : (B.granularity = l),
+      (B.ellipsoid = p),
+      f)
+    ) {
+      let A = 0;
+      for (n = 0; n < m - 1; n++) A += a(e[n], e[n + 1], _) + 1;
+      ((d = new Float64Array(A * 3)),
+        (c = new Uint8Array(A * 4)),
+        (B.positions = F),
+        (B.height = N));
+      let D = 0;
+      for (n = 0; n < m - 1; ++n) {
+        ((F[0] = e[n]), (F[1] = e[n + 1]), (N[0] = v[n]), (N[1] = v[n + 1]));
+        let O = P(B);
+        if (u(o)) {
+          let z = O.length / 3;
+          h = o[n];
+          for (let U = 0; U < z; ++U)
+            ((c[D++] = r.floatToByte(h.red)),
+              (c[D++] = r.floatToByte(h.green)),
+              (c[D++] = r.floatToByte(h.blue)),
+              (c[D++] = r.floatToByte(h.alpha)));
+        }
+        (d.set(O, y), (y += O.length));
+      }
+    } else if (
+      ((B.positions = e), (B.height = v), (d = new Float64Array(P(B))), u(o))
+    ) {
+      for (c = new Uint8Array((d.length / 3) * 4), n = 0; n < m - 1; ++n) {
+        let D = e[n],
+          O = e[n + 1],
+          z = o[n],
+          U = o[n + 1];
+        y = Z(D, O, z, U, g, c, y);
+      }
+      let A = o[m - 1];
+      ((c[y++] = r.floatToByte(A.red)),
+        (c[y++] = r.floatToByte(A.green)),
+        (c[y++] = r.floatToByte(A.blue)),
+        (c[y++] = r.floatToByte(A.alpha)));
+    }
+  } else {
+    ((T = f ? m * 2 - 2 : m),
+      (d = new Float64Array(T * 3)),
+      (c = u(o) ? new Uint8Array(T * 4) : void 0));
+    let _ = 0,
+      a = 0;
+    for (n = 0; n < m; ++n) {
+      let P = e[n];
+      if (
+        (f &&
+          n > 0 &&
+          (k.pack(P, d, _),
+          (_ += 3),
+          (h = o[n - 1]),
+          (c[a++] = r.floatToByte(h.red)),
+          (c[a++] = r.floatToByte(h.green)),
+          (c[a++] = r.floatToByte(h.blue)),
+          (c[a++] = r.floatToByte(h.alpha))),
+        f && n === m - 1)
+      )
+        break;
+      (k.pack(P, d, _),
+        (_ += 3),
+        u(o) &&
+          ((h = o[n]),
+          (c[a++] = r.floatToByte(h.red)),
+          (c[a++] = r.floatToByte(h.green)),
+          (c[a++] = r.floatToByte(h.blue)),
+          (c[a++] = r.floatToByte(h.alpha))));
+    }
+  }
+  let V = new W();
+  ((V.position = new Y({
+    componentDatatype: H.DOUBLE,
+    componentsPerAttribute: 3,
+    values: d,
+  })),
+    u(o) &&
+      (V.color = new Y({
+        componentDatatype: H.UNSIGNED_BYTE,
+        componentsPerAttribute: 4,
+        values: c,
+        normalize: !0,
+      })),
+    (T = d.length / 3));
+  let M = (T - 1) * 2,
+    C = X.createTypedArray(T, M),
+    G = 0;
+  for (n = 0; n < T - 1; ++n) ((C[G++] = n), (C[G++] = n + 1));
+  return new Q({
+    attributes: V,
+    indices: C,
+    primitiveType: K.LINES,
+    boundingSphere: j.fromPoints(e),
+  });
+};
+var J = R;
+function x(t, e) {
+  return (
+    u(e) && (t = J.unpack(t, e)),
+    (t._ellipsoid = b.clone(t._ellipsoid)),
+    J.createGeometry(t)
+  );
+}
+var _e = x;
+export { _e as default };

package/template/public/Cesium1.119/Workers/createSphereGeometry.js

@@ -0,0 +1,84 @@
+/**
+ * @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 r } from "./chunk-TOGHF3VN.js";
+import "./chunk-ILGBPNP6.js";
+import { a as m } from "./chunk-HEEMUCG6.js";
+import "./chunk-P37AI2DW.js";
+import "./chunk-T6BE4RZK.js";
+import "./chunk-X5IHHI6X.js";
+import "./chunk-TMSETF7M.js";
+import "./chunk-7Z5IIKOJ.js";
+import "./chunk-KZNJOCYU.js";
+import { a as s } from "./chunk-POASMU2N.js";
+import "./chunk-R6KGAEF6.js";
+import "./chunk-3C7WC463.js";
+import "./chunk-II4VNKYR.js";
+import { a as l } from "./chunk-IUA6FAOZ.js";
+import { b as p } from "./chunk-UH2WFNTA.js";
+import { e as c } from "./chunk-PEYJTJPE.js";
+function n(e) {
+  let t = l(e.radius, 1),
+    o = {
+      radii: new s(t, t, t),
+      stackPartitions: e.stackPartitions,
+      slicePartitions: e.slicePartitions,
+      vertexFormat: e.vertexFormat,
+    };
+  ((this._ellipsoidGeometry = new r(o)),
+    (this._workerName = "createSphereGeometry"));
+}
+n.packedLength = r.packedLength;
+n.pack = function (e, t, a) {
+  return (p.typeOf.object("value", e), r.pack(e._ellipsoidGeometry, t, a));
+};
+var f = new r(),
+  i = {
+    radius: void 0,
+    radii: new s(),
+    vertexFormat: new m(),
+    stackPartitions: void 0,
+    slicePartitions: void 0,
+  };
+n.unpack = function (e, t, a) {
+  let o = r.unpack(e, t, f);
+  return (
+    (i.vertexFormat = m.clone(o._vertexFormat, i.vertexFormat)),
+    (i.stackPartitions = o._stackPartitions),
+    (i.slicePartitions = o._slicePartitions),
+    c(a)
+      ? (s.clone(o._radii, i.radii), (a._ellipsoidGeometry = new r(i)), a)
+      : ((i.radius = o._radii.x), new n(i))
+  );
+};
+n.createGeometry = function (e) {
+  return r.createGeometry(e._ellipsoidGeometry);
+};
+var d = n;
+function u(e, t) {
+  return (c(t) && (e = d.unpack(e, t)), d.createGeometry(e));
+}
+var v = u;
+export { v as default };