create-swdg-frontend 0.1.7 → 0.2.0

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

@@ -1,787 +0,0 @@
-/**
- * @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 J } from "./chunk-OO23RBLX.js";
-import { a as Nt } from "./chunk-EFZKO5RU.js";
-import { a as zt } from "./chunk-QB3MDM4J.js";
-import "./chunk-ABGXSJNX.js";
-import "./chunk-DQO6B4EQ.js";
-import { a as ut } from "./chunk-ILGBPNP6.js";
-import { a as X } from "./chunk-HEEMUCG6.js";
-import { b as Rt } from "./chunk-O5IJ3OGP.js";
-import "./chunk-FYOYUPXG.js";
-import "./chunk-TAMCUKAR.js";
-import "./chunk-PDMQLSBL.js";
-import { a as yt } from "./chunk-P37AI2DW.js";
-import { a as Vt } from "./chunk-T6BE4RZK.js";
-import { b as Mt, c as Pt, d as q } from "./chunk-X5IHHI6X.js";
-import { d as st } from "./chunk-TMSETF7M.js";
-import { f as Lt, h as E, i as At } from "./chunk-7Z5IIKOJ.js";
-import { a as Y } from "./chunk-KZNJOCYU.js";
-import { a as _, b as wt, c as G, d as H, e as ft } from "./chunk-POASMU2N.js";
-import { a as W } from "./chunk-R6KGAEF6.js";
-import "./chunk-3C7WC463.js";
-import "./chunk-II4VNKYR.js";
-import { a as L } from "./chunk-IUA6FAOZ.js";
-import { a as St, b as lt } from "./chunk-UH2WFNTA.js";
-import { e as $ } from "./chunk-PEYJTJPE.js";
-var Tt = new _(),
-  Bt = new _(),
-  Ut = new _(),
-  Yt = new _(),
-  qt = new E(),
-  Zt = new G(),
-  Kt = new st(),
-  $t = new st();
-function Xt(t, e) {
-  let n = new Pt({ attributes: new Vt(), primitiveType: Mt.TRIANGLES });
-  return (
-    (n.attributes.position = new q({
-      componentDatatype: Y.DOUBLE,
-      componentsPerAttribute: 3,
-      values: e.positions,
-    })),
-    t.normal &&
-      (n.attributes.normal = new q({
-        componentDatatype: Y.FLOAT,
-        componentsPerAttribute: 3,
-        values: e.normals,
-      })),
-    t.tangent &&
-      (n.attributes.tangent = new q({
-        componentDatatype: Y.FLOAT,
-        componentsPerAttribute: 3,
-        values: e.tangents,
-      })),
-    t.bitangent &&
-      (n.attributes.bitangent = new q({
-        componentDatatype: Y.FLOAT,
-        componentsPerAttribute: 3,
-        values: e.bitangents,
-      })),
-    n
-  );
-}
-function Gt(t, e, n, r) {
-  let a = t.length,
-    c = e.normal ? new Float32Array(a) : void 0,
-    l = e.tangent ? new Float32Array(a) : void 0,
-    u = e.bitangent ? new Float32Array(a) : void 0,
-    d = 0,
-    p = Yt,
-    o = Ut,
-    i = Bt;
-  if (e.normal || e.tangent || e.bitangent)
-    for (let f = 0; f < a; f += 3) {
-      let s = _.fromArray(t, f, Tt),
-        h = d + 1,
-        g = d + 2;
-      ((i = n.geodeticSurfaceNormal(s, i)),
-        (e.tangent || e.bitangent) &&
-          (_.cross(_.UNIT_Z, i, o),
-          ft.multiplyByVector(r, o, o),
-          _.normalize(o, o),
-          e.bitangent && _.normalize(_.cross(i, o, p), p)),
-        e.normal && ((c[d] = i.x), (c[h] = i.y), (c[g] = i.z)),
-        e.tangent && ((l[d] = o.x), (l[h] = o.y), (l[g] = o.z)),
-        e.bitangent && ((u[d] = p.x), (u[h] = p.y), (u[g] = p.z)),
-        (d += 3));
-    }
-  return Xt(e, { positions: t, normals: c, tangents: l, bitangents: u });
-}
-var Ct = new _(),
-  jt = new _();
-function te(t, e, n) {
-  let r = t.length,
-    a = e.normal ? new Float32Array(r) : void 0,
-    c = e.tangent ? new Float32Array(r) : void 0,
-    l = e.bitangent ? new Float32Array(r) : void 0,
-    u = 0,
-    d = 0,
-    p = 0,
-    o = !0,
-    i = Yt,
-    f = Ut,
-    s = Bt;
-  if (e.normal || e.tangent || e.bitangent)
-    for (let h = 0; h < r; h += 6) {
-      let g = _.fromArray(t, h, Tt),
-        A = _.fromArray(t, (h + 6) % r, Ct);
-      if (o) {
-        let b = _.fromArray(t, (h + 3) % r, jt);
-        (_.subtract(A, g, A),
-          _.subtract(b, g, b),
-          (s = _.normalize(_.cross(b, A, s), s)),
-          (o = !1));
-      }
-      (_.equalsEpsilon(A, g, W.EPSILON10) && (o = !0),
-        (e.tangent || e.bitangent) &&
-          ((i = n.geodeticSurfaceNormal(g, i)),
-          e.tangent && (f = _.normalize(_.cross(i, s, f), f))),
-        e.normal &&
-          ((a[u++] = s.x),
-          (a[u++] = s.y),
-          (a[u++] = s.z),
-          (a[u++] = s.x),
-          (a[u++] = s.y),
-          (a[u++] = s.z)),
-        e.tangent &&
-          ((c[d++] = f.x),
-          (c[d++] = f.y),
-          (c[d++] = f.z),
-          (c[d++] = f.x),
-          (c[d++] = f.y),
-          (c[d++] = f.z)),
-        e.bitangent &&
-          ((l[p++] = i.x),
-          (l[p++] = i.y),
-          (l[p++] = i.z),
-          (l[p++] = i.x),
-          (l[p++] = i.y),
-          (l[p++] = i.z)));
-    }
-  return Xt(e, { positions: t, normals: a, tangents: c, bitangents: l });
-}
-function It(t, e) {
-  let n = t._vertexFormat,
-    r = t._ellipsoid,
-    a = e.height,
-    c = e.width,
-    l = e.northCap,
-    u = e.southCap,
-    d = 0,
-    p = a,
-    o = a,
-    i = 0;
-  (l && ((d = 1), (o -= 1), (i += 1)),
-    u && ((p -= 1), (o -= 1), (i += 1)),
-    (i += c * o));
-  let f = n.position ? new Float64Array(i * 3) : void 0,
-    s = n.st ? new Float32Array(i * 2) : void 0,
-    h = 0,
-    g = 0,
-    A = Tt,
-    b = Zt,
-    z = Number.MAX_VALUE,
-    F = Number.MAX_VALUE,
-    j = -Number.MAX_VALUE,
-    T = -Number.MAX_VALUE;
-  for (let x = d; x < p; ++x)
-    for (let k = 0; k < c; ++k)
-      (J.computePosition(e, r, n.st, x, k, A, b),
-        (f[h++] = A.x),
-        (f[h++] = A.y),
-        (f[h++] = A.z),
-        n.st &&
-          ((s[g++] = b.x),
-          (s[g++] = b.y),
-          (z = Math.min(z, b.x)),
-          (F = Math.min(F, b.y)),
-          (j = Math.max(j, b.x)),
-          (T = Math.max(T, b.y))));
-  if (
-    (l &&
-      (J.computePosition(e, r, n.st, 0, 0, A, b),
-      (f[h++] = A.x),
-      (f[h++] = A.y),
-      (f[h++] = A.z),
-      n.st &&
-        ((s[g++] = b.x),
-        (s[g++] = b.y),
-        (z = b.x),
-        (F = b.y),
-        (j = b.x),
-        (T = b.y))),
-    u &&
-      (J.computePosition(e, r, n.st, a - 1, 0, A, b),
-      (f[h++] = A.x),
-      (f[h++] = A.y),
-      (f[h] = A.z),
-      n.st &&
-        ((s[g++] = b.x),
-        (s[g] = b.y),
-        (z = Math.min(z, b.x)),
-        (F = Math.min(F, b.y)),
-        (j = Math.max(j, b.x)),
-        (T = Math.max(T, b.y)))),
-    n.st && (z < 0 || F < 0 || j > 1 || T > 1))
-  )
-    for (let x = 0; x < s.length; x += 2)
-      ((s[x] = (s[x] - z) / (j - z)), (s[x + 1] = (s[x + 1] - F) / (T - F)));
-  let m = Gt(f, n, r, e.tangentRotationMatrix),
-    K = 6 * (c - 1) * (o - 1);
-  (l && (K += 3 * (c - 1)), u && (K += 3 * (c - 1)));
-  let P = yt.createTypedArray(i, K),
-    D = 0,
-    N = 0,
-    O;
-  for (O = 0; O < o - 1; ++O) {
-    for (let x = 0; x < c - 1; ++x) {
-      let k = D,
-        M = k + c,
-        I = M + 1,
-        rt = k + 1;
-      ((P[N++] = k),
-        (P[N++] = M),
-        (P[N++] = rt),
-        (P[N++] = rt),
-        (P[N++] = M),
-        (P[N++] = I),
-        ++D);
-    }
-    ++D;
-  }
-  if (l || u) {
-    let x = i - 1,
-      k = i - 1;
-    l && u && (x = i - 2);
-    let M, I;
-    if (((D = 0), l))
-      for (O = 0; O < c - 1; O++)
-        ((M = D), (I = M + 1), (P[N++] = x), (P[N++] = M), (P[N++] = I), ++D);
-    if (u)
-      for (D = (o - 1) * c, O = 0; O < c - 1; O++)
-        ((M = D), (I = M + 1), (P[N++] = M), (P[N++] = k), (P[N++] = I), ++D);
-  }
-  return (
-    (m.indices = P),
-    n.st &&
-      (m.attributes.st = new q({
-        componentDatatype: Y.FLOAT,
-        componentsPerAttribute: 2,
-        values: s,
-      })),
-    m
-  );
-}
-function ht(t, e, n, r, a) {
-  return (
-    (t[e++] = r[n]),
-    (t[e++] = r[n + 1]),
-    (t[e++] = r[n + 2]),
-    (t[e++] = a[n]),
-    (t[e++] = a[n + 1]),
-    (t[e] = a[n + 2]),
-    t
-  );
-}
-function dt(t, e, n, r) {
-  return (
-    (t[e++] = r[n]),
-    (t[e++] = r[n + 1]),
-    (t[e++] = r[n]),
-    (t[e] = r[n + 1]),
-    t
-  );
-}
-var Dt = new X();
-function ee(t, e) {
-  let n = t._shadowVolume,
-    r = t._offsetAttribute,
-    a = t._vertexFormat,
-    c = t._extrudedHeight,
-    l = t._surfaceHeight,
-    u = t._ellipsoid,
-    d = e.height,
-    p = e.width,
-    o;
-  if (n) {
-    let R = X.clone(a, Dt);
-    ((R.normal = !0), (t._vertexFormat = R));
-  }
-  let i = It(t, e);
-  n && (t._vertexFormat = a);
-  let f = Rt.scaleToGeodeticHeight(i.attributes.position.values, l, u, !1);
-  f = new Float64Array(f);
-  let s = f.length,
-    h = s * 2,
-    g = new Float64Array(h);
-  g.set(f);
-  let A = Rt.scaleToGeodeticHeight(i.attributes.position.values, c, u);
-  (g.set(A, s), (i.attributes.position.values = g));
-  let b = a.normal ? new Float32Array(h) : void 0,
-    z = a.tangent ? new Float32Array(h) : void 0,
-    F = a.bitangent ? new Float32Array(h) : void 0,
-    j = a.st ? new Float32Array((h / 3) * 2) : void 0,
-    T,
-    m;
-  if (a.normal) {
-    for (m = i.attributes.normal.values, b.set(m), o = 0; o < s; o++)
-      m[o] = -m[o];
-    (b.set(m, s), (i.attributes.normal.values = b));
-  }
-  if (n) {
-    ((m = i.attributes.normal.values),
-      a.normal || (i.attributes.normal = void 0));
-    let R = new Float32Array(h);
-    for (o = 0; o < s; o++) m[o] = -m[o];
-    (R.set(m, s),
-      (i.attributes.extrudeDirection = new q({
-        componentDatatype: Y.FLOAT,
-        componentsPerAttribute: 3,
-        values: R,
-      })));
-  }
-  let K,
-    P = $(r);
-  if (P) {
-    let R = (s / 3) * 2,
-      at = new Uint8Array(R);
-    (r === ut.TOP
-      ? (at = at.fill(1, 0, R / 2))
-      : ((K = r === ut.NONE ? 0 : 1), (at = at.fill(K))),
-      (i.attributes.applyOffset = new q({
-        componentDatatype: Y.UNSIGNED_BYTE,
-        componentsPerAttribute: 1,
-        values: at,
-      })));
-  }
-  if (a.tangent) {
-    let R = i.attributes.tangent.values;
-    for (z.set(R), o = 0; o < s; o++) R[o] = -R[o];
-    (z.set(R, s), (i.attributes.tangent.values = z));
-  }
-  if (a.bitangent) {
-    let R = i.attributes.bitangent.values;
-    (F.set(R), F.set(R, s), (i.attributes.bitangent.values = F));
-  }
-  a.st &&
-    ((T = i.attributes.st.values),
-    j.set(T),
-    j.set(T, (s / 3) * 2),
-    (i.attributes.st.values = j));
-  let D = i.indices,
-    N = D.length,
-    O = s / 3,
-    x = yt.createTypedArray(h / 3, N * 2);
-  for (x.set(D), o = 0; o < N; o += 3)
-    ((x[o + N] = D[o + 2] + O),
-      (x[o + 1 + N] = D[o + 1] + O),
-      (x[o + 2 + N] = D[o] + O));
-  i.indices = x;
-  let k = e.northCap,
-    M = e.southCap,
-    I = d,
-    rt = 2,
-    pt = 0,
-    xt = 4,
-    Et = 4;
-  (k && ((rt -= 1), (I -= 1), (pt += 1), (xt -= 2), (Et -= 1)),
-    M && ((rt -= 1), (I -= 1), (pt += 1), (xt -= 2), (Et -= 1)),
-    (pt += rt * p + 2 * I - xt));
-  let gt = (pt + Et) * 2,
-    C = new Float64Array(gt * 3),
-    S = n ? new Float32Array(gt * 3) : void 0,
-    Z = P ? new Uint8Array(gt) : void 0,
-    V = a.st ? new Float32Array(gt * 2) : void 0,
-    et = r === ut.TOP;
-  P && !et && ((K = r === ut.ALL ? 1 : 0), (Z = Z.fill(K)));
-  let v = 0,
-    B = 0,
-    y = 0,
-    U = 0,
-    nt = p * I,
-    w;
-  for (o = 0; o < nt; o += p)
-    ((w = o * 3),
-      (C = ht(C, v, w, f, A)),
-      (v += 6),
-      a.st && ((V = dt(V, B, o * 2, T)), (B += 4)),
-      n &&
-        ((y += 3), (S[y++] = m[w]), (S[y++] = m[w + 1]), (S[y++] = m[w + 2])),
-      et && ((Z[U++] = 1), (U += 1)));
-  if (M) {
-    let R = k ? nt + 1 : nt;
-    for (w = R * 3, o = 0; o < 2; o++)
-      ((C = ht(C, v, w, f, A)),
-        (v += 6),
-        a.st && ((V = dt(V, B, R * 2, T)), (B += 4)),
-        n &&
-          ((y += 3), (S[y++] = m[w]), (S[y++] = m[w + 1]), (S[y++] = m[w + 2])),
-        et && ((Z[U++] = 1), (U += 1)));
-  } else
-    for (o = nt - p; o < nt; o++)
-      ((w = o * 3),
-        (C = ht(C, v, w, f, A)),
-        (v += 6),
-        a.st && ((V = dt(V, B, o * 2, T)), (B += 4)),
-        n &&
-          ((y += 3), (S[y++] = m[w]), (S[y++] = m[w + 1]), (S[y++] = m[w + 2])),
-        et && ((Z[U++] = 1), (U += 1)));
-  for (o = nt - 1; o > 0; o -= p)
-    ((w = o * 3),
-      (C = ht(C, v, w, f, A)),
-      (v += 6),
-      a.st && ((V = dt(V, B, o * 2, T)), (B += 4)),
-      n &&
-        ((y += 3), (S[y++] = m[w]), (S[y++] = m[w + 1]), (S[y++] = m[w + 2])),
-      et && ((Z[U++] = 1), (U += 1)));
-  if (k) {
-    let R = nt;
-    for (w = R * 3, o = 0; o < 2; o++)
-      ((C = ht(C, v, w, f, A)),
-        (v += 6),
-        a.st && ((V = dt(V, B, R * 2, T)), (B += 4)),
-        n &&
-          ((y += 3), (S[y++] = m[w]), (S[y++] = m[w + 1]), (S[y++] = m[w + 2])),
-        et && ((Z[U++] = 1), (U += 1)));
-  } else
-    for (o = p - 1; o >= 0; o--)
-      ((w = o * 3),
-        (C = ht(C, v, w, f, A)),
-        (v += 6),
-        a.st && ((V = dt(V, B, o * 2, T)), (B += 4)),
-        n &&
-          ((y += 3), (S[y++] = m[w]), (S[y++] = m[w + 1]), (S[y++] = m[w + 2])),
-        et && ((Z[U++] = 1), (U += 1)));
-  let ot = te(C, a, u);
-  (a.st &&
-    (ot.attributes.st = new q({
-      componentDatatype: Y.FLOAT,
-      componentsPerAttribute: 2,
-      values: V,
-    })),
-    n &&
-      (ot.attributes.extrudeDirection = new q({
-        componentDatatype: Y.FLOAT,
-        componentsPerAttribute: 3,
-        values: S,
-      })),
-    P &&
-      (ot.attributes.applyOffset = new q({
-        componentDatatype: Y.UNSIGNED_BYTE,
-        componentsPerAttribute: 1,
-        values: Z,
-      })));
-  let it = yt.createTypedArray(gt, pt * 6),
-    mt,
-    _t,
-    kt,
-    bt;
-  s = C.length / 3;
-  let ct = 0;
-  for (o = 0; o < s - 1; o += 2) {
-    ((mt = o), (bt = (mt + 2) % s));
-    let R = _.fromArray(C, mt * 3, Ct),
-      at = _.fromArray(C, bt * 3, jt);
-    _.equalsEpsilon(R, at, W.EPSILON10) ||
-      ((_t = (mt + 1) % s),
-      (kt = (_t + 2) % s),
-      (it[ct++] = mt),
-      (it[ct++] = _t),
-      (it[ct++] = bt),
-      (it[ct++] = bt),
-      (it[ct++] = _t),
-      (it[ct++] = kt));
-  }
-  return (
-    (ot.indices = it),
-    (ot = zt.combineInstances([
-      new Nt({ geometry: i }),
-      new Nt({ geometry: ot }),
-    ])),
-    ot[0]
-  );
-}
-var ne = [new _(), new _(), new _(), new _()],
-  Wt = new wt(),
-  oe = new wt();
-function Ht(t, e, n, r, a) {
-  if (n === 0) return E.clone(t, a);
-  let c = J.computeOptions(t, e, n, 0, qt, Wt),
-    l = c.height,
-    u = c.width,
-    d = ne;
-  return (
-    J.computePosition(c, r, !1, 0, 0, d[0]),
-    J.computePosition(c, r, !1, 0, u - 1, d[1]),
-    J.computePosition(c, r, !1, l - 1, 0, d[2]),
-    J.computePosition(c, r, !1, l - 1, u - 1, d[3]),
-    E.fromCartesianArray(d, r, a)
-  );
-}
-function Q(t) {
-  t = L(t, L.EMPTY_OBJECT);
-  let e = t.rectangle;
-  if ((lt.typeOf.object("rectangle", e), E.validate(e), e.north < e.south))
-    throw new St(
-      "options.rectangle.north must be greater than or equal to options.rectangle.south",
-    );
-  let n = L(t.height, 0),
-    r = L(t.extrudedHeight, n);
-  ((this._rectangle = E.clone(e)),
-    (this._granularity = L(t.granularity, W.RADIANS_PER_DEGREE)),
-    (this._ellipsoid = H.clone(L(t.ellipsoid, H.default))),
-    (this._surfaceHeight = Math.max(n, r)),
-    (this._rotation = L(t.rotation, 0)),
-    (this._stRotation = L(t.stRotation, 0)),
-    (this._vertexFormat = X.clone(L(t.vertexFormat, X.DEFAULT))),
-    (this._extrudedHeight = Math.min(n, r)),
-    (this._shadowVolume = L(t.shadowVolume, !1)),
-    (this._workerName = "createRectangleGeometry"),
-    (this._offsetAttribute = t.offsetAttribute),
-    (this._rotatedRectangle = void 0),
-    (this._textureCoordinateRotationPoints = void 0));
-}
-Q.packedLength = E.packedLength + H.packedLength + X.packedLength + 7;
-Q.pack = function (t, e, n) {
-  return (
-    lt.typeOf.object("value", t),
-    lt.defined("array", e),
-    (n = L(n, 0)),
-    E.pack(t._rectangle, e, n),
-    (n += E.packedLength),
-    H.pack(t._ellipsoid, e, n),
-    (n += H.packedLength),
-    X.pack(t._vertexFormat, e, n),
-    (n += X.packedLength),
-    (e[n++] = t._granularity),
-    (e[n++] = t._surfaceHeight),
-    (e[n++] = t._rotation),
-    (e[n++] = t._stRotation),
-    (e[n++] = t._extrudedHeight),
-    (e[n++] = t._shadowVolume ? 1 : 0),
-    (e[n] = L(t._offsetAttribute, -1)),
-    e
-  );
-};
-var Jt = new E(),
-  Qt = H.clone(H.UNIT_SPHERE),
-  tt = {
-    rectangle: Jt,
-    ellipsoid: Qt,
-    vertexFormat: Dt,
-    granularity: void 0,
-    height: void 0,
-    rotation: void 0,
-    stRotation: void 0,
-    extrudedHeight: void 0,
-    shadowVolume: void 0,
-    offsetAttribute: void 0,
-  };
-Q.unpack = function (t, e, n) {
-  (lt.defined("array", t), (e = L(e, 0)));
-  let r = E.unpack(t, e, Jt);
-  e += E.packedLength;
-  let a = H.unpack(t, e, Qt);
-  e += H.packedLength;
-  let c = X.unpack(t, e, Dt);
-  e += X.packedLength;
-  let l = t[e++],
-    u = t[e++],
-    d = t[e++],
-    p = t[e++],
-    o = t[e++],
-    i = t[e++] === 1,
-    f = t[e];
-  return $(n)
-    ? ((n._rectangle = E.clone(r, n._rectangle)),
-      (n._ellipsoid = H.clone(a, n._ellipsoid)),
-      (n._vertexFormat = X.clone(c, n._vertexFormat)),
-      (n._granularity = l),
-      (n._surfaceHeight = u),
-      (n._rotation = d),
-      (n._stRotation = p),
-      (n._extrudedHeight = o),
-      (n._shadowVolume = i),
-      (n._offsetAttribute = f === -1 ? void 0 : f),
-      n)
-    : ((tt.granularity = l),
-      (tt.height = u),
-      (tt.rotation = d),
-      (tt.stRotation = p),
-      (tt.extrudedHeight = o),
-      (tt.shadowVolume = i),
-      (tt.offsetAttribute = f === -1 ? void 0 : f),
-      new Q(tt));
-};
-Q.computeRectangle = function (t, e) {
-  t = L(t, L.EMPTY_OBJECT);
-  let n = t.rectangle;
-  if ((lt.typeOf.object("rectangle", n), E.validate(n), n.north < n.south))
-    throw new St(
-      "options.rectangle.north must be greater than or equal to options.rectangle.south",
-    );
-  let r = L(t.granularity, W.RADIANS_PER_DEGREE),
-    a = L(t.ellipsoid, H.default),
-    c = L(t.rotation, 0);
-  return Ht(n, r, c, a, e);
-};
-var ie = new ft(),
-  Ft = new Lt(),
-  ae = new wt();
-Q.createGeometry = function (t) {
-  if (
-    W.equalsEpsilon(t._rectangle.north, t._rectangle.south, W.EPSILON10) ||
-    W.equalsEpsilon(t._rectangle.east, t._rectangle.west, W.EPSILON10)
-  )
-    return;
-  let e = t._rectangle,
-    n = t._ellipsoid,
-    r = t._rotation,
-    a = t._stRotation,
-    c = t._vertexFormat,
-    l = J.computeOptions(e, t._granularity, r, a, qt, Wt, oe),
-    u = ie;
-  if (a !== 0 || r !== 0) {
-    let s = E.center(e, ae),
-      h = n.geodeticSurfaceNormalCartographic(s, Ct);
-    (Lt.fromAxisAngle(h, -a, Ft), ft.fromQuaternion(Ft, u));
-  } else ft.clone(ft.IDENTITY, u);
-  let d = t._surfaceHeight,
-    p = t._extrudedHeight,
-    o = !W.equalsEpsilon(d, p, 0, W.EPSILON2);
-  ((l.lonScalar = 1 / t._rectangle.width),
-    (l.latScalar = 1 / t._rectangle.height),
-    (l.tangentRotationMatrix = u));
-  let i, f;
-  if (((e = t._rectangle), o)) {
-    i = ee(t, l);
-    let s = st.fromRectangle3D(e, n, d, $t),
-      h = st.fromRectangle3D(e, n, p, Kt);
-    f = st.union(s, h);
-  } else {
-    if (
-      ((i = It(t, l)),
-      (i.attributes.position.values = Rt.scaleToGeodeticHeight(
-        i.attributes.position.values,
-        d,
-        n,
-        !1,
-      )),
-      $(t._offsetAttribute))
-    ) {
-      let s = i.attributes.position.values.length,
-        h = t._offsetAttribute === ut.NONE ? 0 : 1,
-        g = new Uint8Array(s / 3).fill(h);
-      i.attributes.applyOffset = new q({
-        componentDatatype: Y.UNSIGNED_BYTE,
-        componentsPerAttribute: 1,
-        values: g,
-      });
-    }
-    f = st.fromRectangle3D(e, n, d);
-  }
-  return (
-    c.position || delete i.attributes.position,
-    new Pt({
-      attributes: i.attributes,
-      indices: i.indices,
-      primitiveType: i.primitiveType,
-      boundingSphere: f,
-      offsetAttribute: t._offsetAttribute,
-    })
-  );
-};
-Q.createShadowVolume = function (t, e, n) {
-  let r = t._granularity,
-    a = t._ellipsoid,
-    c = e(r, a),
-    l = n(r, a);
-  return new Q({
-    rectangle: t._rectangle,
-    rotation: t._rotation,
-    ellipsoid: a,
-    stRotation: t._stRotation,
-    granularity: r,
-    extrudedHeight: l,
-    height: c,
-    vertexFormat: X.POSITION_ONLY,
-    shadowVolume: !0,
-  });
-};
-var vt = new E(),
-  se = [new G(), new G(), new G()],
-  re = new At(),
-  ce = new wt();
-function le(t) {
-  if (t._stRotation === 0) return [0, 0, 0, 1, 1, 0];
-  let e = E.clone(t._rectangle, vt),
-    n = t._granularity,
-    r = t._ellipsoid,
-    a = t._rotation - t._stRotation,
-    c = Ht(e, n, a, r, vt),
-    l = se;
-  ((l[0].x = c.west),
-    (l[0].y = c.south),
-    (l[1].x = c.west),
-    (l[1].y = c.north),
-    (l[2].x = c.east),
-    (l[2].y = c.south));
-  let u = t.rectangle,
-    d = At.fromRotation(t._stRotation, re),
-    p = E.center(u, ce);
-  for (let h = 0; h < 3; ++h) {
-    let g = l[h];
-    ((g.x -= p.longitude),
-      (g.y -= p.latitude),
-      At.multiplyByVector(d, g, g),
-      (g.x += p.longitude),
-      (g.y += p.latitude),
-      (g.x = (g.x - u.west) / u.width),
-      (g.y = (g.y - u.south) / u.height));
-  }
-  let o = l[0],
-    i = l[1],
-    f = l[2],
-    s = new Array(6);
-  return (G.pack(o, s), G.pack(i, s, 2), G.pack(f, s, 4), s);
-}
-Object.defineProperties(Q.prototype, {
-  rectangle: {
-    get: function () {
-      return (
-        $(this._rotatedRectangle) ||
-          (this._rotatedRectangle = Ht(
-            this._rectangle,
-            this._granularity,
-            this._rotation,
-            this._ellipsoid,
-          )),
-        this._rotatedRectangle
-      );
-    },
-  },
-  textureCoordinateRotationPoints: {
-    get: function () {
-      return (
-        $(this._textureCoordinateRotationPoints) ||
-          (this._textureCoordinateRotationPoints = le(this)),
-        this._textureCoordinateRotationPoints
-      );
-    },
-  },
-});
-var Ot = Q;
-function fe(t, e) {
-  return (
-    $(e) && (t = Ot.unpack(t, e)),
-    (t._ellipsoid = H.clone(t._ellipsoid)),
-    (t._rectangle = E.clone(t._rectangle)),
-    Ot.createGeometry(t)
-  );
-}
-var Ye = fe;
-export { Ye as default };