create-swdg-frontend 0.1.0

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

@@ -0,0 +1,773 @@
+/**
+ * @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 tt } from "./chunk-BMHPVZ4H.js";
+import { a as At } from "./chunk-EFZKO5RU.js";
+import { a as yt } from "./chunk-QB3MDM4J.js";
+import { a as G } from "./chunk-ILGBPNP6.js";
+import { a as z } from "./chunk-HEEMUCG6.js";
+import { a as at } from "./chunk-P37AI2DW.js";
+import { a as ht } from "./chunk-T6BE4RZK.js";
+import { b as mt, c as st, d as S } from "./chunk-X5IHHI6X.js";
+import { a as dt, d as rt } from "./chunk-TMSETF7M.js";
+import { f as it, h as bt } from "./chunk-7Z5IIKOJ.js";
+import { a as F } from "./chunk-KZNJOCYU.js";
+import { a, b as _t, c as W, d as v, e as R } from "./chunk-POASMU2N.js";
+import { a as I } from "./chunk-R6KGAEF6.js";
+import { a as T } from "./chunk-IUA6FAOZ.js";
+import { a as nt, b as H } from "./chunk-UH2WFNTA.js";
+import { e as K } from "./chunk-PEYJTJPE.js";
+var et = new a(),
+  pt = new a(),
+  xt = new a(),
+  wt = new a(),
+  w = new W(),
+  Mt = new R(),
+  Vt = new R(),
+  gt = new it(),
+  Tt = new a(),
+  Nt = new a(),
+  Et = new a(),
+  lt = new _t(),
+  Pt = new a(),
+  Ft = new W(),
+  St = new W();
+function Ot(o, e, t) {
+  let n = e.vertexFormat,
+    s = e.center,
+    i = e.semiMajorAxis,
+    r = e.semiMinorAxis,
+    f = e.ellipsoid,
+    h = e.stRotation,
+    E = t ? (o.length / 3) * 2 : o.length / 3,
+    g = e.shadowVolume,
+    c = n.st ? new Float32Array(E * 2) : void 0,
+    l = n.normal ? new Float32Array(E * 3) : void 0,
+    A = n.tangent ? new Float32Array(E * 3) : void 0,
+    x = n.bitangent ? new Float32Array(E * 3) : void 0,
+    O = g ? new Float32Array(E * 3) : void 0,
+    B = 0,
+    b = Tt,
+    M = Nt,
+    d = Et,
+    _ = new dt(f),
+    L = _.project(f.cartesianToCartographic(s, lt), Pt),
+    J = f.scaleToGeodeticSurface(s, et);
+  f.geodeticSurfaceNormal(J, J);
+  let Z = Mt,
+    q = Vt;
+  if (h !== 0) {
+    let m = it.fromAxisAngle(J, h, gt);
+    ((Z = R.fromQuaternion(m, Z)),
+      (m = it.fromAxisAngle(J, -h, gt)),
+      (q = R.fromQuaternion(m, q)));
+  } else ((Z = R.clone(R.IDENTITY, Z)), (q = R.clone(R.IDENTITY, q)));
+  let k = W.fromElements(
+      Number.POSITIVE_INFINITY,
+      Number.POSITIVE_INFINITY,
+      Ft,
+    ),
+    Q = W.fromElements(Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY, St),
+    j = o.length,
+    y = t ? j : 0,
+    p = (y / 3) * 2;
+  for (let m = 0; m < j; m += 3) {
+    let u = m + 1,
+      N = m + 2,
+      D = a.fromArray(o, m, et);
+    if (n.st) {
+      let P = R.multiplyByVector(Z, D, pt),
+        C = _.project(f.cartesianToCartographic(P, lt), xt);
+      (a.subtract(C, L, C),
+        (w.x = (C.x + i) / (2 * i)),
+        (w.y = (C.y + r) / (2 * r)),
+        (k.x = Math.min(w.x, k.x)),
+        (k.y = Math.min(w.y, k.y)),
+        (Q.x = Math.max(w.x, Q.x)),
+        (Q.y = Math.max(w.y, Q.y)),
+        t && ((c[B + p] = w.x), (c[B + 1 + p] = w.y)),
+        (c[B++] = w.x),
+        (c[B++] = w.y));
+    }
+    (n.normal || n.tangent || n.bitangent || g) &&
+      ((b = f.geodeticSurfaceNormal(D, b)),
+      g && ((O[m + y] = -b.x), (O[u + y] = -b.y), (O[N + y] = -b.z)),
+      (n.normal || n.tangent || n.bitangent) &&
+        ((n.tangent || n.bitangent) &&
+          ((M = a.normalize(a.cross(a.UNIT_Z, b, M), M)),
+          R.multiplyByVector(q, M, M)),
+        n.normal &&
+          ((l[m] = b.x),
+          (l[u] = b.y),
+          (l[N] = b.z),
+          t && ((l[m + y] = -b.x), (l[u + y] = -b.y), (l[N + y] = -b.z))),
+        n.tangent &&
+          ((A[m] = M.x),
+          (A[u] = M.y),
+          (A[N] = M.z),
+          t && ((A[m + y] = -M.x), (A[u + y] = -M.y), (A[N + y] = -M.z))),
+        n.bitangent &&
+          ((d = a.normalize(a.cross(b, M, d), d)),
+          (x[m] = d.x),
+          (x[u] = d.y),
+          (x[N] = d.z),
+          t && ((x[m + y] = d.x), (x[u + y] = d.y), (x[N + y] = d.z)))));
+  }
+  if (n.st) {
+    j = c.length;
+    for (let m = 0; m < j; m += 2)
+      ((c[m] = (c[m] - k.x) / (Q.x - k.x)),
+        (c[m + 1] = (c[m + 1] - k.y) / (Q.y - k.y)));
+  }
+  let V = new ht();
+  if (n.position) {
+    let m = tt.raisePositionsToHeight(o, e, t);
+    V.position = new S({
+      componentDatatype: F.DOUBLE,
+      componentsPerAttribute: 3,
+      values: m,
+    });
+  }
+  if (
+    (n.st &&
+      (V.st = new S({
+        componentDatatype: F.FLOAT,
+        componentsPerAttribute: 2,
+        values: c,
+      })),
+    n.normal &&
+      (V.normal = new S({
+        componentDatatype: F.FLOAT,
+        componentsPerAttribute: 3,
+        values: l,
+      })),
+    n.tangent &&
+      (V.tangent = new S({
+        componentDatatype: F.FLOAT,
+        componentsPerAttribute: 3,
+        values: A,
+      })),
+    n.bitangent &&
+      (V.bitangent = new S({
+        componentDatatype: F.FLOAT,
+        componentsPerAttribute: 3,
+        values: x,
+      })),
+    g &&
+      (V.extrudeDirection = new S({
+        componentDatatype: F.FLOAT,
+        componentsPerAttribute: 3,
+        values: O,
+      })),
+    t && K(e.offsetAttribute))
+  ) {
+    let m = new Uint8Array(E);
+    if (e.offsetAttribute === G.TOP) m = m.fill(1, 0, E / 2);
+    else {
+      let u = e.offsetAttribute === G.NONE ? 0 : 1;
+      m = m.fill(u);
+    }
+    V.applyOffset = new S({
+      componentDatatype: F.UNSIGNED_BYTE,
+      componentsPerAttribute: 1,
+      values: m,
+    });
+  }
+  return V;
+}
+function jt(o) {
+  let e = new Array(12 * (o * (o + 1)) - 6),
+    t = 0,
+    n,
+    s,
+    i,
+    r,
+    f;
+  for (n = 0, i = 1, r = 0; r < 3; r++)
+    ((e[t++] = i++), (e[t++] = n), (e[t++] = i));
+  for (r = 2; r < o + 1; ++r) {
+    for (
+      i = r * (r + 1) - 1,
+        n = (r - 1) * r - 1,
+        e[t++] = i++,
+        e[t++] = n,
+        e[t++] = i,
+        s = 2 * r,
+        f = 0;
+      f < s - 1;
+      ++f
+    )
+      ((e[t++] = i),
+        (e[t++] = n++),
+        (e[t++] = n),
+        (e[t++] = i++),
+        (e[t++] = n),
+        (e[t++] = i));
+    ((e[t++] = i++), (e[t++] = n), (e[t++] = i));
+  }
+  for (s = o * 2, ++i, ++n, r = 0; r < s - 1; ++r)
+    ((e[t++] = i),
+      (e[t++] = n++),
+      (e[t++] = n),
+      (e[t++] = i++),
+      (e[t++] = n),
+      (e[t++] = i));
+  for (
+    e[t++] = i,
+      e[t++] = n++,
+      e[t++] = n,
+      e[t++] = i++,
+      e[t++] = n++,
+      e[t++] = n,
+      ++n,
+      r = o - 1;
+    r > 1;
+    --r
+  ) {
+    for (e[t++] = n++, e[t++] = n, e[t++] = i, s = 2 * r, f = 0; f < s - 1; ++f)
+      ((e[t++] = i),
+        (e[t++] = n++),
+        (e[t++] = n),
+        (e[t++] = i++),
+        (e[t++] = n),
+        (e[t++] = i));
+    ((e[t++] = n++), (e[t++] = n++), (e[t++] = i++));
+  }
+  for (r = 0; r < 3; r++) ((e[t++] = n++), (e[t++] = n), (e[t++] = i));
+  return e;
+}
+var X = new a();
+function Dt(o) {
+  let e = o.center;
+  ((X = a.multiplyByScalar(
+    o.ellipsoid.geodeticSurfaceNormal(e, X),
+    o.height,
+    X,
+  )),
+    (X = a.add(e, X, X)));
+  let t = new rt(X, o.semiMajorAxis),
+    n = tt.computeEllipsePositions(o, !0, !1),
+    s = n.positions,
+    i = n.numPts,
+    r = Ot(s, o, !1),
+    f = jt(i);
+  return (
+    (f = at.createTypedArray(s.length / 3, f)),
+    { boundingSphere: t, attributes: r, indices: f }
+  );
+}
+function vt(o, e) {
+  let t = e.vertexFormat,
+    n = e.center,
+    s = e.semiMajorAxis,
+    i = e.semiMinorAxis,
+    r = e.ellipsoid,
+    f = e.height,
+    h = e.extrudedHeight,
+    E = e.stRotation,
+    g = (o.length / 3) * 2,
+    c = new Float64Array(g * 3),
+    l = t.st ? new Float32Array(g * 2) : void 0,
+    A = t.normal ? new Float32Array(g * 3) : void 0,
+    x = t.tangent ? new Float32Array(g * 3) : void 0,
+    O = t.bitangent ? new Float32Array(g * 3) : void 0,
+    B = e.shadowVolume,
+    b = B ? new Float32Array(g * 3) : void 0,
+    M = 0,
+    d = Tt,
+    _ = Nt,
+    L = Et,
+    J = new dt(r),
+    Z = J.project(r.cartesianToCartographic(n, lt), Pt),
+    q = r.scaleToGeodeticSurface(n, et);
+  r.geodeticSurfaceNormal(q, q);
+  let k = it.fromAxisAngle(q, E, gt),
+    Q = R.fromQuaternion(k, Mt),
+    j = W.fromElements(Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY, Ft),
+    y = W.fromElements(Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY, St),
+    p = o.length,
+    V = (p / 3) * 2;
+  for (let u = 0; u < p; u += 3) {
+    let N = u + 1,
+      D = u + 2,
+      P = a.fromArray(o, u, et),
+      C;
+    if (t.st) {
+      let ot = R.multiplyByVector(Q, P, pt),
+        $ = J.project(r.cartesianToCartographic(ot, lt), xt);
+      (a.subtract($, Z, $),
+        (w.x = ($.x + s) / (2 * s)),
+        (w.y = ($.y + i) / (2 * i)),
+        (j.x = Math.min(w.x, j.x)),
+        (j.y = Math.min(w.y, j.y)),
+        (y.x = Math.max(w.x, y.x)),
+        (y.y = Math.max(w.y, y.y)),
+        (l[M + V] = w.x),
+        (l[M + 1 + V] = w.y),
+        (l[M++] = w.x),
+        (l[M++] = w.y));
+    }
+    ((P = r.scaleToGeodeticSurface(P, P)),
+      (C = a.clone(P, pt)),
+      (d = r.geodeticSurfaceNormal(P, d)),
+      B && ((b[u + p] = -d.x), (b[N + p] = -d.y), (b[D + p] = -d.z)));
+    let ct = a.multiplyByScalar(d, f, wt);
+    if (
+      ((P = a.add(P, ct, P)),
+      (ct = a.multiplyByScalar(d, h, ct)),
+      (C = a.add(C, ct, C)),
+      t.position &&
+        ((c[u + p] = C.x),
+        (c[N + p] = C.y),
+        (c[D + p] = C.z),
+        (c[u] = P.x),
+        (c[N] = P.y),
+        (c[D] = P.z)),
+      t.normal || t.tangent || t.bitangent)
+    ) {
+      L = a.clone(d, L);
+      let ot = a.fromArray(o, (u + 3) % p, wt);
+      a.subtract(ot, P, ot);
+      let $ = a.subtract(C, P, xt);
+      ((d = a.normalize(a.cross($, ot, d), d)),
+        t.normal &&
+          ((A[u] = d.x),
+          (A[N] = d.y),
+          (A[D] = d.z),
+          (A[u + p] = d.x),
+          (A[N + p] = d.y),
+          (A[D + p] = d.z)),
+        t.tangent &&
+          ((_ = a.normalize(a.cross(L, d, _), _)),
+          (x[u] = _.x),
+          (x[N] = _.y),
+          (x[D] = _.z),
+          (x[u + p] = _.x),
+          (x[u + 1 + p] = _.y),
+          (x[u + 2 + p] = _.z)),
+        t.bitangent &&
+          ((O[u] = L.x),
+          (O[N] = L.y),
+          (O[D] = L.z),
+          (O[u + p] = L.x),
+          (O[N + p] = L.y),
+          (O[D + p] = L.z)));
+    }
+  }
+  if (t.st) {
+    p = l.length;
+    for (let u = 0; u < p; u += 2)
+      ((l[u] = (l[u] - j.x) / (y.x - j.x)),
+        (l[u + 1] = (l[u + 1] - j.y) / (y.y - j.y)));
+  }
+  let m = new ht();
+  if (
+    (t.position &&
+      (m.position = new S({
+        componentDatatype: F.DOUBLE,
+        componentsPerAttribute: 3,
+        values: c,
+      })),
+    t.st &&
+      (m.st = new S({
+        componentDatatype: F.FLOAT,
+        componentsPerAttribute: 2,
+        values: l,
+      })),
+    t.normal &&
+      (m.normal = new S({
+        componentDatatype: F.FLOAT,
+        componentsPerAttribute: 3,
+        values: A,
+      })),
+    t.tangent &&
+      (m.tangent = new S({
+        componentDatatype: F.FLOAT,
+        componentsPerAttribute: 3,
+        values: x,
+      })),
+    t.bitangent &&
+      (m.bitangent = new S({
+        componentDatatype: F.FLOAT,
+        componentsPerAttribute: 3,
+        values: O,
+      })),
+    B &&
+      (m.extrudeDirection = new S({
+        componentDatatype: F.FLOAT,
+        componentsPerAttribute: 3,
+        values: b,
+      })),
+    K(e.offsetAttribute))
+  ) {
+    let u = new Uint8Array(g);
+    if (e.offsetAttribute === G.TOP) u = u.fill(1, 0, g / 2);
+    else {
+      let N = e.offsetAttribute === G.NONE ? 0 : 1;
+      u = u.fill(N);
+    }
+    m.applyOffset = new S({
+      componentDatatype: F.UNSIGNED_BYTE,
+      componentsPerAttribute: 1,
+      values: u,
+    });
+  }
+  return m;
+}
+function zt(o) {
+  let e = o.length / 3,
+    t = at.createTypedArray(e, e * 6),
+    n = 0;
+  for (let s = 0; s < e; s++) {
+    let i = s,
+      r = s + e,
+      f = (i + 1) % e,
+      h = f + e;
+    ((t[n++] = i),
+      (t[n++] = r),
+      (t[n++] = f),
+      (t[n++] = f),
+      (t[n++] = r),
+      (t[n++] = h));
+  }
+  return t;
+}
+var ut = new rt(),
+  ft = new rt();
+function Bt(o) {
+  let e = o.center,
+    t = o.ellipsoid,
+    n = o.semiMajorAxis,
+    s = a.multiplyByScalar(t.geodeticSurfaceNormal(e, et), o.height, et);
+  ((ut.center = a.add(e, s, ut.center)),
+    (ut.radius = n),
+    (s = a.multiplyByScalar(
+      t.geodeticSurfaceNormal(e, s),
+      o.extrudedHeight,
+      s,
+    )),
+    (ft.center = a.add(e, s, ft.center)),
+    (ft.radius = n));
+  let i = tt.computeEllipsePositions(o, !0, !0),
+    r = i.positions,
+    f = i.numPts,
+    h = i.outerPositions,
+    E = rt.union(ut, ft),
+    g = Ot(r, o, !0),
+    c = jt(f),
+    l = c.length;
+  c.length = l * 2;
+  let A = r.length / 3;
+  for (let _ = 0; _ < l; _ += 3)
+    ((c[_ + l] = c[_ + 2] + A),
+      (c[_ + 1 + l] = c[_ + 1] + A),
+      (c[_ + 2 + l] = c[_] + A));
+  let x = at.createTypedArray((A * 2) / 3, c),
+    O = new st({ attributes: g, indices: x, primitiveType: mt.TRIANGLES }),
+    B = vt(h, o);
+  c = zt(h);
+  let b = at.createTypedArray((h.length * 2) / 3, c),
+    M = new st({ attributes: B, indices: b, primitiveType: mt.TRIANGLES }),
+    d = yt.combineInstances([new At({ geometry: O }), new At({ geometry: M })]);
+  return {
+    boundingSphere: E,
+    attributes: d[0].attributes,
+    indices: d[0].indices,
+  };
+}
+function Ct(o, e, t, n, s, i, r) {
+  let h = tt.computeEllipsePositions(
+      {
+        center: o,
+        semiMajorAxis: e,
+        semiMinorAxis: t,
+        rotation: n,
+        granularity: s,
+      },
+      !1,
+      !0,
+    ).outerPositions,
+    E = h.length / 3,
+    g = new Array(E);
+  for (let l = 0; l < E; ++l) g[l] = a.fromArray(h, l * 3);
+  let c = bt.fromCartesianArray(g, i, r);
+  return (
+    c.width > I.PI &&
+      ((c.north = c.north > 0 ? I.PI_OVER_TWO - I.EPSILON7 : c.north),
+      (c.south = c.south < 0 ? I.EPSILON7 - I.PI_OVER_TWO : c.south),
+      (c.east = I.PI),
+      (c.west = -I.PI)),
+    c
+  );
+}
+function U(o) {
+  o = T(o, T.EMPTY_OBJECT);
+  let e = o.center,
+    t = T(o.ellipsoid, v.default),
+    n = o.semiMajorAxis,
+    s = o.semiMinorAxis,
+    i = T(o.granularity, I.RADIANS_PER_DEGREE),
+    r = T(o.vertexFormat, z.DEFAULT);
+  if (
+    (H.defined("options.center", e),
+    H.typeOf.number("options.semiMajorAxis", n),
+    H.typeOf.number("options.semiMinorAxis", s),
+    n < s)
+  )
+    throw new nt(
+      "semiMajorAxis must be greater than or equal to the semiMinorAxis.",
+    );
+  if (i <= 0) throw new nt("granularity must be greater than zero.");
+  let f = T(o.height, 0),
+    h = T(o.extrudedHeight, f);
+  ((this._center = a.clone(e)),
+    (this._semiMajorAxis = n),
+    (this._semiMinorAxis = s),
+    (this._ellipsoid = v.clone(t)),
+    (this._rotation = T(o.rotation, 0)),
+    (this._stRotation = T(o.stRotation, 0)),
+    (this._height = Math.max(h, f)),
+    (this._granularity = i),
+    (this._vertexFormat = z.clone(r)),
+    (this._extrudedHeight = Math.min(h, f)),
+    (this._shadowVolume = T(o.shadowVolume, !1)),
+    (this._workerName = "createEllipseGeometry"),
+    (this._offsetAttribute = o.offsetAttribute),
+    (this._rectangle = void 0),
+    (this._textureCoordinateRotationPoints = void 0));
+}
+U.packedLength = a.packedLength + v.packedLength + z.packedLength + 9;
+U.pack = function (o, e, t) {
+  return (
+    H.defined("value", o),
+    H.defined("array", e),
+    (t = T(t, 0)),
+    a.pack(o._center, e, t),
+    (t += a.packedLength),
+    v.pack(o._ellipsoid, e, t),
+    (t += v.packedLength),
+    z.pack(o._vertexFormat, e, t),
+    (t += z.packedLength),
+    (e[t++] = o._semiMajorAxis),
+    (e[t++] = o._semiMinorAxis),
+    (e[t++] = o._rotation),
+    (e[t++] = o._stRotation),
+    (e[t++] = o._height),
+    (e[t++] = o._granularity),
+    (e[t++] = o._extrudedHeight),
+    (e[t++] = o._shadowVolume ? 1 : 0),
+    (e[t] = T(o._offsetAttribute, -1)),
+    e
+  );
+};
+var Rt = new a(),
+  It = new v(),
+  Lt = new z(),
+  Y = {
+    center: Rt,
+    ellipsoid: It,
+    vertexFormat: Lt,
+    semiMajorAxis: void 0,
+    semiMinorAxis: void 0,
+    rotation: void 0,
+    stRotation: void 0,
+    height: void 0,
+    granularity: void 0,
+    extrudedHeight: void 0,
+    shadowVolume: void 0,
+    offsetAttribute: void 0,
+  };
+U.unpack = function (o, e, t) {
+  (H.defined("array", o), (e = T(e, 0)));
+  let n = a.unpack(o, e, Rt);
+  e += a.packedLength;
+  let s = v.unpack(o, e, It);
+  e += v.packedLength;
+  let i = z.unpack(o, e, Lt);
+  e += z.packedLength;
+  let r = o[e++],
+    f = o[e++],
+    h = o[e++],
+    E = o[e++],
+    g = o[e++],
+    c = o[e++],
+    l = o[e++],
+    A = o[e++] === 1,
+    x = o[e];
+  return K(t)
+    ? ((t._center = a.clone(n, t._center)),
+      (t._ellipsoid = v.clone(s, t._ellipsoid)),
+      (t._vertexFormat = z.clone(i, t._vertexFormat)),
+      (t._semiMajorAxis = r),
+      (t._semiMinorAxis = f),
+      (t._rotation = h),
+      (t._stRotation = E),
+      (t._height = g),
+      (t._granularity = c),
+      (t._extrudedHeight = l),
+      (t._shadowVolume = A),
+      (t._offsetAttribute = x === -1 ? void 0 : x),
+      t)
+    : ((Y.height = g),
+      (Y.extrudedHeight = l),
+      (Y.granularity = c),
+      (Y.stRotation = E),
+      (Y.rotation = h),
+      (Y.semiMajorAxis = r),
+      (Y.semiMinorAxis = f),
+      (Y.shadowVolume = A),
+      (Y.offsetAttribute = x === -1 ? void 0 : x),
+      new U(Y));
+};
+U.computeRectangle = function (o, e) {
+  o = T(o, T.EMPTY_OBJECT);
+  let t = o.center,
+    n = T(o.ellipsoid, v.default),
+    s = o.semiMajorAxis,
+    i = o.semiMinorAxis,
+    r = T(o.granularity, I.RADIANS_PER_DEGREE),
+    f = T(o.rotation, 0);
+  if (
+    (H.defined("options.center", t),
+    H.typeOf.number("options.semiMajorAxis", s),
+    H.typeOf.number("options.semiMinorAxis", i),
+    s < i)
+  )
+    throw new nt(
+      "semiMajorAxis must be greater than or equal to the semiMinorAxis.",
+    );
+  if (r <= 0) throw new nt("granularity must be greater than zero.");
+  return Ct(t, s, i, f, r, n, e);
+};
+U.createGeometry = function (o) {
+  if (o._semiMajorAxis <= 0 || o._semiMinorAxis <= 0) return;
+  let e = o._height,
+    t = o._extrudedHeight,
+    n = !I.equalsEpsilon(e, t, 0, I.EPSILON2);
+  o._center = o._ellipsoid.scaleToGeodeticSurface(o._center, o._center);
+  let s = {
+      center: o._center,
+      semiMajorAxis: o._semiMajorAxis,
+      semiMinorAxis: o._semiMinorAxis,
+      ellipsoid: o._ellipsoid,
+      rotation: o._rotation,
+      height: e,
+      granularity: o._granularity,
+      vertexFormat: o._vertexFormat,
+      stRotation: o._stRotation,
+    },
+    i;
+  if (n)
+    ((s.extrudedHeight = t),
+      (s.shadowVolume = o._shadowVolume),
+      (s.offsetAttribute = o._offsetAttribute),
+      (i = Bt(s)));
+  else if (((i = Dt(s)), K(o._offsetAttribute))) {
+    let r = i.attributes.position.values.length,
+      f = o._offsetAttribute === G.NONE ? 0 : 1,
+      h = new Uint8Array(r / 3).fill(f);
+    i.attributes.applyOffset = new S({
+      componentDatatype: F.UNSIGNED_BYTE,
+      componentsPerAttribute: 1,
+      values: h,
+    });
+  }
+  return new st({
+    attributes: i.attributes,
+    indices: i.indices,
+    primitiveType: mt.TRIANGLES,
+    boundingSphere: i.boundingSphere,
+    offsetAttribute: o._offsetAttribute,
+  });
+};
+U.createShadowVolume = function (o, e, t) {
+  let n = o._granularity,
+    s = o._ellipsoid,
+    i = e(n, s),
+    r = t(n, s);
+  return new U({
+    center: o._center,
+    semiMajorAxis: o._semiMajorAxis,
+    semiMinorAxis: o._semiMinorAxis,
+    ellipsoid: s,
+    rotation: o._rotation,
+    stRotation: o._stRotation,
+    granularity: n,
+    extrudedHeight: i,
+    height: r,
+    vertexFormat: z.POSITION_ONLY,
+    shadowVolume: !0,
+  });
+};
+function kt(o) {
+  let e = -o._stRotation;
+  if (e === 0) return [0, 0, 0, 1, 1, 0];
+  let n = tt.computeEllipsePositions(
+      {
+        center: o._center,
+        semiMajorAxis: o._semiMajorAxis,
+        semiMinorAxis: o._semiMinorAxis,
+        rotation: o._rotation,
+        granularity: o._granularity,
+      },
+      !1,
+      !0,
+    ).outerPositions,
+    s = n.length / 3,
+    i = new Array(s);
+  for (let h = 0; h < s; ++h) i[h] = a.fromArray(n, h * 3);
+  let r = o._ellipsoid,
+    f = o.rectangle;
+  return st._textureCoordinateRotationPoints(i, e, r, f);
+}
+Object.defineProperties(U.prototype, {
+  rectangle: {
+    get: function () {
+      return (
+        K(this._rectangle) ||
+          (this._rectangle = Ct(
+            this._center,
+            this._semiMajorAxis,
+            this._semiMinorAxis,
+            this._rotation,
+            this._granularity,
+            this._ellipsoid,
+          )),
+        this._rectangle
+      );
+    },
+  },
+  textureCoordinateRotationPoints: {
+    get: function () {
+      return (
+        K(this._textureCoordinateRotationPoints) ||
+          (this._textureCoordinateRotationPoints = kt(this)),
+        this._textureCoordinateRotationPoints
+      );
+    },
+  },
+});
+var de = U;
+export { de as a };