create-swdg-frontend 0.1.0

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

@@ -0,0 +1,417 @@
+/**
+ * @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 S } from "./chunk-XHX2UPDO.js";
+import { a as W } from "./chunk-K4ASOM65.js";
+import "./chunk-AMQUWUD4.js";
+import "./chunk-W23CU777.js";
+import { a as K } from "./chunk-ILGBPNP6.js";
+import "./chunk-KF5NF354.js";
+import "./chunk-4WRMLZA7.js";
+import { b as Q } from "./chunk-O5IJ3OGP.js";
+import { a as it } from "./chunk-RXTBM4OI.js";
+import "./chunk-FYOYUPXG.js";
+import "./chunk-TAMCUKAR.js";
+import "./chunk-PDMQLSBL.js";
+import { a as Z } from "./chunk-P37AI2DW.js";
+import { a as et } from "./chunk-T6BE4RZK.js";
+import { b as I, c as tt, d as J } from "./chunk-X5IHHI6X.js";
+import { d as x } from "./chunk-TMSETF7M.js";
+import "./chunk-7Z5IIKOJ.js";
+import { a as z } from "./chunk-KZNJOCYU.js";
+import { a as A, d as P } from "./chunk-POASMU2N.js";
+import { a as q } from "./chunk-R6KGAEF6.js";
+import "./chunk-3C7WC463.js";
+import "./chunk-II4VNKYR.js";
+import { a as H } from "./chunk-IUA6FAOZ.js";
+import { b as M } from "./chunk-UH2WFNTA.js";
+import { e as C } from "./chunk-PEYJTJPE.js";
+var ot = new A(),
+  nt = new A(),
+  rt = new A();
+function ft(t, i) {
+  for (let e = 0; e < t.length; e++)
+    t[e] = i.scaleToGeodeticSurface(t[e], t[e]);
+  return t;
+}
+function st(t, i) {
+  let e = [],
+    l = t.positions,
+    h = t.corners,
+    m = t.endPositions,
+    D = new et(),
+    y,
+    u = 0,
+    p = 0,
+    o,
+    g = 0,
+    d;
+  for (o = 0; o < l.length; o += 2)
+    ((d = l[o].length - 3),
+      (u += d),
+      (g += (d / 3) * 4),
+      (p += l[o + 1].length - 3));
+  for (u += 3, p += 3, o = 0; o < h.length; o++) {
+    y = h[o];
+    let c = h[o].leftPositions;
+    C(c)
+      ? ((d = c.length), (u += d), (g += (d / 3) * 2))
+      : ((d = h[o].rightPositions.length), (p += d), (g += (d / 3) * 2));
+  }
+  let _ = C(m),
+    w;
+  _ && ((w = m[0].length - 3), (u += w), (p += w), (w /= 3), (g += w * 4));
+  let T = u + p,
+    b = new Float64Array(T),
+    n = 0,
+    s = T - 1,
+    a,
+    E,
+    L,
+    k,
+    U,
+    O,
+    j = w / 2,
+    r = Z.createTypedArray(T / 3, g + 4),
+    f = 0;
+  if (((r[f++] = n / 3), (r[f++] = (s - 2) / 3), _)) {
+    (e.push(n / 3), (O = ot), (U = nt));
+    let c = m[0];
+    for (o = 0; o < j; o++)
+      ((O = A.fromArray(c, (j - 1 - o) * 3, O)),
+        (U = A.fromArray(c, (j + o) * 3, U)),
+        S.addAttribute(b, U, n),
+        S.addAttribute(b, O, void 0, s),
+        (E = n / 3),
+        (k = E + 1),
+        (a = (s - 2) / 3),
+        (L = a - 1),
+        (r[f++] = a),
+        (r[f++] = L),
+        (r[f++] = E),
+        (r[f++] = k),
+        (n += 3),
+        (s -= 3));
+  }
+  let G = 0,
+    F = l[G++],
+    N = l[G++];
+  for (
+    b.set(F, n),
+      b.set(N, s - N.length + 1),
+      d = N.length - 3,
+      e.push(n / 3, (s - 2) / 3),
+      o = 0;
+    o < d;
+    o += 3
+  )
+    ((E = n / 3),
+      (k = E + 1),
+      (a = (s - 2) / 3),
+      (L = a - 1),
+      (r[f++] = a),
+      (r[f++] = L),
+      (r[f++] = E),
+      (r[f++] = k),
+      (n += 3),
+      (s -= 3));
+  for (o = 0; o < h.length; o++) {
+    let c;
+    y = h[o];
+    let Y = y.leftPositions,
+      X = y.rightPositions,
+      v,
+      B = rt;
+    if (C(Y)) {
+      for (s -= 3, v = L, e.push(k), c = 0; c < Y.length / 3; c++)
+        ((B = A.fromArray(Y, c * 3, B)),
+          (r[f++] = v - c - 1),
+          (r[f++] = v - c),
+          S.addAttribute(b, B, void 0, s),
+          (s -= 3));
+      (e.push(v - Math.floor(Y.length / 6)),
+        i === W.BEVELED && e.push((s - 2) / 3 + 1),
+        (n += 3));
+    } else {
+      for (n += 3, v = k, e.push(L), c = 0; c < X.length / 3; c++)
+        ((B = A.fromArray(X, c * 3, B)),
+          (r[f++] = v + c),
+          (r[f++] = v + c + 1),
+          S.addAttribute(b, B, n),
+          (n += 3));
+      (e.push(v + Math.floor(X.length / 6)),
+        i === W.BEVELED && e.push(n / 3 - 1),
+        (s -= 3));
+    }
+    for (
+      F = l[G++],
+        N = l[G++],
+        F.splice(0, 3),
+        N.splice(N.length - 3, 3),
+        b.set(F, n),
+        b.set(N, s - N.length + 1),
+        d = N.length - 3,
+        c = 0;
+      c < N.length;
+      c += 3
+    )
+      ((k = n / 3),
+        (E = k - 1),
+        (L = (s - 2) / 3),
+        (a = L + 1),
+        (r[f++] = a),
+        (r[f++] = L),
+        (r[f++] = E),
+        (r[f++] = k),
+        (n += 3),
+        (s -= 3));
+    ((n -= 3), (s += 3), e.push(n / 3, (s - 2) / 3));
+  }
+  if (_) {
+    ((n += 3), (s -= 3), (O = ot), (U = nt));
+    let c = m[1];
+    for (o = 0; o < j; o++)
+      ((O = A.fromArray(c, (w - o - 1) * 3, O)),
+        (U = A.fromArray(c, o * 3, U)),
+        S.addAttribute(b, O, void 0, s),
+        S.addAttribute(b, U, n),
+        (k = n / 3),
+        (E = k - 1),
+        (L = (s - 2) / 3),
+        (a = L + 1),
+        (r[f++] = a),
+        (r[f++] = L),
+        (r[f++] = E),
+        (r[f++] = k),
+        (n += 3),
+        (s -= 3));
+    e.push(n / 3);
+  } else e.push(n / 3, (s - 2) / 3);
+  return (
+    (r[f++] = n / 3),
+    (r[f++] = (s - 2) / 3),
+    (D.position = new J({
+      componentDatatype: z.DOUBLE,
+      componentsPerAttribute: 3,
+      values: b,
+    })),
+    { attributes: D, indices: r, wallIndices: e }
+  );
+}
+function ct(t) {
+  let i = t.ellipsoid,
+    e = S.computePositions(t),
+    l = st(e, t.cornerType),
+    h = l.wallIndices,
+    m = t.height,
+    D = t.extrudedHeight,
+    y = l.attributes,
+    u = l.indices,
+    p = y.position.values,
+    o = p.length,
+    g = new Float64Array(o);
+  g.set(p);
+  let d = new Float64Array(o * 2);
+  if (
+    ((p = Q.scaleToGeodeticHeight(p, m, i)),
+    (g = Q.scaleToGeodeticHeight(g, D, i)),
+    d.set(p),
+    d.set(g, o),
+    (y.position.values = d),
+    (o /= 3),
+    C(t.offsetAttribute))
+  ) {
+    let a = new Uint8Array(o * 2);
+    if (t.offsetAttribute === K.TOP) a = a.fill(1, 0, o);
+    else {
+      let E = t.offsetAttribute === K.NONE ? 0 : 1;
+      a = a.fill(E);
+    }
+    y.applyOffset = new J({
+      componentDatatype: z.UNSIGNED_BYTE,
+      componentsPerAttribute: 1,
+      values: a,
+    });
+  }
+  let _,
+    w = u.length,
+    T = Z.createTypedArray(d.length / 3, (w + h.length) * 2);
+  T.set(u);
+  let b = w;
+  for (_ = 0; _ < w; _ += 2) {
+    let a = u[_],
+      E = u[_ + 1];
+    ((T[b++] = a + o), (T[b++] = E + o));
+  }
+  let n, s;
+  for (_ = 0; _ < h.length; _++)
+    ((n = h[_]), (s = n + o), (T[b++] = n), (T[b++] = s));
+  return { attributes: y, indices: T };
+}
+function V(t) {
+  t = H(t, H.EMPTY_OBJECT);
+  let i = t.positions,
+    e = t.width;
+  (M.typeOf.object("options.positions", i),
+    M.typeOf.number("options.width", e));
+  let l = H(t.height, 0),
+    h = H(t.extrudedHeight, l);
+  ((this._positions = i),
+    (this._ellipsoid = P.clone(H(t.ellipsoid, P.default))),
+    (this._width = e),
+    (this._height = Math.max(l, h)),
+    (this._extrudedHeight = Math.min(l, h)),
+    (this._cornerType = H(t.cornerType, W.ROUNDED)),
+    (this._granularity = H(t.granularity, q.RADIANS_PER_DEGREE)),
+    (this._offsetAttribute = t.offsetAttribute),
+    (this._workerName = "createCorridorOutlineGeometry"),
+    (this.packedLength = 1 + i.length * A.packedLength + P.packedLength + 6));
+}
+V.pack = function (t, i, e) {
+  (M.typeOf.object("value", t), M.typeOf.object("array", i), (e = H(e, 0)));
+  let l = t._positions,
+    h = l.length;
+  i[e++] = h;
+  for (let m = 0; m < h; ++m, e += A.packedLength) A.pack(l[m], i, e);
+  return (
+    P.pack(t._ellipsoid, i, e),
+    (e += P.packedLength),
+    (i[e++] = t._width),
+    (i[e++] = t._height),
+    (i[e++] = t._extrudedHeight),
+    (i[e++] = t._cornerType),
+    (i[e++] = t._granularity),
+    (i[e] = H(t._offsetAttribute, -1)),
+    i
+  );
+};
+var lt = P.clone(P.UNIT_SPHERE),
+  R = {
+    positions: void 0,
+    ellipsoid: lt,
+    width: void 0,
+    height: void 0,
+    extrudedHeight: void 0,
+    cornerType: void 0,
+    granularity: void 0,
+    offsetAttribute: void 0,
+  };
+V.unpack = function (t, i, e) {
+  (M.typeOf.object("array", t), (i = H(i, 0)));
+  let l = t[i++],
+    h = new Array(l);
+  for (let d = 0; d < l; ++d, i += A.packedLength) h[d] = A.unpack(t, i);
+  let m = P.unpack(t, i, lt);
+  i += P.packedLength;
+  let D = t[i++],
+    y = t[i++],
+    u = t[i++],
+    p = t[i++],
+    o = t[i++],
+    g = t[i];
+  return C(e)
+    ? ((e._positions = h),
+      (e._ellipsoid = P.clone(m, e._ellipsoid)),
+      (e._width = D),
+      (e._height = y),
+      (e._extrudedHeight = u),
+      (e._cornerType = p),
+      (e._granularity = o),
+      (e._offsetAttribute = g === -1 ? void 0 : g),
+      e)
+    : ((R.positions = h),
+      (R.width = D),
+      (R.height = y),
+      (R.extrudedHeight = u),
+      (R.cornerType = p),
+      (R.granularity = o),
+      (R.offsetAttribute = g === -1 ? void 0 : g),
+      new V(R));
+};
+V.createGeometry = function (t) {
+  let i = t._positions,
+    e = t._width,
+    l = t._ellipsoid;
+  i = ft(i, l);
+  let h = it(i, A.equalsEpsilon);
+  if (h.length < 2 || e <= 0) return;
+  let m = t._height,
+    D = t._extrudedHeight,
+    y = !q.equalsEpsilon(m, D, 0, q.EPSILON2),
+    u = {
+      ellipsoid: l,
+      positions: h,
+      width: e,
+      cornerType: t._cornerType,
+      granularity: t._granularity,
+      saveAttributes: !1,
+    },
+    p;
+  if (y)
+    ((u.height = m),
+      (u.extrudedHeight = D),
+      (u.offsetAttribute = t._offsetAttribute),
+      (p = ct(u)));
+  else {
+    let d = S.computePositions(u);
+    if (
+      ((p = st(d, u.cornerType)),
+      (p.attributes.position.values = Q.scaleToGeodeticHeight(
+        p.attributes.position.values,
+        m,
+        l,
+      )),
+      C(t._offsetAttribute))
+    ) {
+      let _ = p.attributes.position.values.length,
+        w = t._offsetAttribute === K.NONE ? 0 : 1,
+        T = new Uint8Array(_ / 3).fill(w);
+      p.attributes.applyOffset = new J({
+        componentDatatype: z.UNSIGNED_BYTE,
+        componentsPerAttribute: 1,
+        values: T,
+      });
+    }
+  }
+  let o = p.attributes,
+    g = x.fromVertices(o.position.values, void 0, 3);
+  return new tt({
+    attributes: o,
+    indices: p.indices,
+    primitiveType: I.LINES,
+    boundingSphere: g,
+    offsetAttribute: t._offsetAttribute,
+  });
+};
+var $ = V;
+function ht(t, i) {
+  return (
+    C(i) && (t = $.unpack(t, i)),
+    (t._ellipsoid = P.clone(t._ellipsoid)),
+    $.createGeometry(t)
+  );
+}
+var Ot = ht;
+export { Ot as default };

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

@@ -0,0 +1,47 @@
+/**
+ * @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-IAC5XVZV.js";
+import "./chunk-GFN7NNSJ.js";
+import "./chunk-ILGBPNP6.js";
+import "./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 "./chunk-POASMU2N.js";
+import "./chunk-R6KGAEF6.js";
+import "./chunk-3C7WC463.js";
+import "./chunk-II4VNKYR.js";
+import "./chunk-IUA6FAOZ.js";
+import "./chunk-UH2WFNTA.js";
+import { e as o } from "./chunk-PEYJTJPE.js";
+function i(e, t) {
+  return (o(t) && (e = r.unpack(e, t)), r.createGeometry(e));
+}
+var a = i;
+export { a as default };

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

@@ -0,0 +1,170 @@
+/**
+ * @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 M } from "./chunk-GFN7NNSJ.js";
+import { a as V } from "./chunk-ILGBPNP6.js";
+import { a as N } from "./chunk-P37AI2DW.js";
+import { a as k } from "./chunk-T6BE4RZK.js";
+import { b as D, c as P, d as L } from "./chunk-X5IHHI6X.js";
+import { d as y } from "./chunk-TMSETF7M.js";
+import "./chunk-7Z5IIKOJ.js";
+import { a as A } from "./chunk-KZNJOCYU.js";
+import { a as S, c as R } from "./chunk-POASMU2N.js";
+import "./chunk-R6KGAEF6.js";
+import "./chunk-3C7WC463.js";
+import "./chunk-II4VNKYR.js";
+import { a as c } from "./chunk-IUA6FAOZ.js";
+import { a as T, b as m } from "./chunk-UH2WFNTA.js";
+import { e as d } from "./chunk-PEYJTJPE.js";
+var w = new R();
+function a(t) {
+  t = c(t, c.EMPTY_OBJECT);
+  let e = t.length,
+    i = t.topRadius,
+    f = t.bottomRadius,
+    o = c(t.slices, 128),
+    r = Math.max(c(t.numberOfVerticalLines, 16), 0);
+  if (
+    (m.typeOf.number("options.positions", e),
+    m.typeOf.number("options.topRadius", i),
+    m.typeOf.number("options.bottomRadius", f),
+    m.typeOf.number.greaterThanOrEquals("options.slices", o, 3),
+    d(t.offsetAttribute) && t.offsetAttribute === V.TOP)
+  )
+    throw new T(
+      "GeometryOffsetAttribute.TOP is not a supported options.offsetAttribute for this geometry.",
+    );
+  ((this._length = e),
+    (this._topRadius = i),
+    (this._bottomRadius = f),
+    (this._slices = o),
+    (this._numberOfVerticalLines = r),
+    (this._offsetAttribute = t.offsetAttribute),
+    (this._workerName = "createCylinderOutlineGeometry"));
+}
+a.packedLength = 6;
+a.pack = function (t, e, i) {
+  return (
+    m.typeOf.object("value", t),
+    m.defined("array", e),
+    (i = c(i, 0)),
+    (e[i++] = t._length),
+    (e[i++] = t._topRadius),
+    (e[i++] = t._bottomRadius),
+    (e[i++] = t._slices),
+    (e[i++] = t._numberOfVerticalLines),
+    (e[i] = c(t._offsetAttribute, -1)),
+    e
+  );
+};
+var b = {
+  length: void 0,
+  topRadius: void 0,
+  bottomRadius: void 0,
+  slices: void 0,
+  numberOfVerticalLines: void 0,
+  offsetAttribute: void 0,
+};
+a.unpack = function (t, e, i) {
+  (m.defined("array", t), (e = c(e, 0)));
+  let f = t[e++],
+    o = t[e++],
+    r = t[e++],
+    h = t[e++],
+    l = t[e++],
+    p = t[e];
+  return d(i)
+    ? ((i._length = f),
+      (i._topRadius = o),
+      (i._bottomRadius = r),
+      (i._slices = h),
+      (i._numberOfVerticalLines = l),
+      (i._offsetAttribute = p === -1 ? void 0 : p),
+      i)
+    : ((b.length = f),
+      (b.topRadius = o),
+      (b.bottomRadius = r),
+      (b.slices = h),
+      (b.numberOfVerticalLines = l),
+      (b.offsetAttribute = p === -1 ? void 0 : p),
+      new a(b));
+};
+a.createGeometry = function (t) {
+  let e = t._length,
+    i = t._topRadius,
+    f = t._bottomRadius,
+    o = t._slices,
+    r = t._numberOfVerticalLines;
+  if (e <= 0 || i < 0 || f < 0 || (i === 0 && f === 0)) return;
+  let h = o * 2,
+    l = M.computePositions(e, i, f, o, !1),
+    p = o * 2,
+    E;
+  if (r > 0) {
+    let O = Math.min(r, o);
+    ((E = Math.round(o / O)), (p += O));
+  }
+  let s = N.createTypedArray(h, p * 2),
+    u = 0,
+    n;
+  for (n = 0; n < o - 1; n++)
+    ((s[u++] = n), (s[u++] = n + 1), (s[u++] = n + o), (s[u++] = n + 1 + o));
+  if (
+    ((s[u++] = o - 1), (s[u++] = 0), (s[u++] = o + o - 1), (s[u++] = o), r > 0)
+  )
+    for (n = 0; n < o; n += E) ((s[u++] = n), (s[u++] = n + o));
+  let _ = new k();
+  ((_.position = new L({
+    componentDatatype: A.DOUBLE,
+    componentsPerAttribute: 3,
+    values: l,
+  })),
+    (w.x = e * 0.5),
+    (w.y = Math.max(f, i)));
+  let g = new y(S.ZERO, R.magnitude(w));
+  if (d(t._offsetAttribute)) {
+    e = l.length;
+    let O = t._offsetAttribute === V.NONE ? 0 : 1,
+      B = new Uint8Array(e / 3).fill(O);
+    _.applyOffset = new L({
+      componentDatatype: A.UNSIGNED_BYTE,
+      componentsPerAttribute: 1,
+      values: B,
+    });
+  }
+  return new P({
+    attributes: _,
+    indices: s,
+    primitiveType: D.LINES,
+    boundingSphere: g,
+    offsetAttribute: t._offsetAttribute,
+  });
+};
+var C = a;
+function G(t, e) {
+  return (d(e) && (t = C.unpack(t, e)), C.createGeometry(t));
+}
+var et = G;
+export { et as default };

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

@@ -0,0 +1,58 @@
+/**
+ * @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 o } from "./chunk-KRKI6AAO.js";
+import "./chunk-BMHPVZ4H.js";
+import "./chunk-EFZKO5RU.js";
+import "./chunk-QB3MDM4J.js";
+import "./chunk-ABGXSJNX.js";
+import "./chunk-DQO6B4EQ.js";
+import "./chunk-ILGBPNP6.js";
+import "./chunk-HEEMUCG6.js";
+import "./chunk-TAMCUKAR.js";
+import "./chunk-PDMQLSBL.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 t, d as c } from "./chunk-POASMU2N.js";
+import "./chunk-R6KGAEF6.js";
+import "./chunk-3C7WC463.js";
+import "./chunk-II4VNKYR.js";
+import "./chunk-IUA6FAOZ.js";
+import "./chunk-UH2WFNTA.js";
+import { e as n } from "./chunk-PEYJTJPE.js";
+function a(r, i) {
+  return (
+    n(i) && (r = o.unpack(r, i)),
+    (r._center = t.clone(r._center)),
+    (r._ellipsoid = c.clone(r._ellipsoid)),
+    o.createGeometry(r)
+  );
+}
+var u = a;
+export { u as default };