create-swdg-frontend 0.1.7 → 0.2.0

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

@@ -1,884 +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 dt } from "./chunk-3JW36LZF.js";
-import { a as F } from "./chunk-HSWA4OEL.js";
-import { a as at } from "./chunk-ATPDRNKI.js";
-import { a as st } from "./chunk-EFZKO5RU.js";
-import { a as bt } from "./chunk-QB3MDM4J.js";
-import "./chunk-ABGXSJNX.js";
-import "./chunk-DQO6B4EQ.js";
-import { a as ht } from "./chunk-ILGBPNP6.js";
-import { a as Q } from "./chunk-HEEMUCG6.js";
-import { a as K } from "./chunk-KF5NF354.js";
-import "./chunk-4WRMLZA7.js";
-import { a as gt, b as nt } from "./chunk-O5IJ3OGP.js";
-import "./chunk-RXTBM4OI.js";
-import "./chunk-FYOYUPXG.js";
-import { a as wt, b as yt } from "./chunk-TAMCUKAR.js";
-import "./chunk-PDMQLSBL.js";
-import { a as lt } from "./chunk-P37AI2DW.js";
-import "./chunk-T6BE4RZK.js";
-import { c as mt, d as tt } from "./chunk-X5IHHI6X.js";
-import { d as Tt } from "./chunk-TMSETF7M.js";
-import { f as ct, h as _t } from "./chunk-7Z5IIKOJ.js";
-import { a as $ } from "./chunk-KZNJOCYU.js";
-import { a as c, b as ot, c as O, d as V, e as U } from "./chunk-POASMU2N.js";
-import { a as l } from "./chunk-R6KGAEF6.js";
-import "./chunk-3C7WC463.js";
-import "./chunk-II4VNKYR.js";
-import { a as L } from "./chunk-IUA6FAOZ.js";
-import { a as ut, b as q } from "./chunk-UH2WFNTA.js";
-import { e as P } from "./chunk-PEYJTJPE.js";
-function b(t, e) {
-  ((this.position = t),
-    P(this.position) || (this.position = new O()),
-    (this.tangentPlane = e),
-    P(this.tangentPlane) || (this.tangentPlane = b.NORTH_POLE_TANGENT_PLANE));
-}
-Object.defineProperties(b.prototype, {
-  ellipsoid: {
-    get: function () {
-      return this.tangentPlane.ellipsoid;
-    },
-  },
-  x: {
-    get: function () {
-      return this.position.x;
-    },
-  },
-  y: {
-    get: function () {
-      return this.position.y;
-    },
-  },
-  conformalLatitude: {
-    get: function () {
-      let t = O.magnitude(this.position),
-        e = 2 * this.ellipsoid.maximumRadius;
-      return (
-        this.tangentPlane.plane.normal.z *
-        (l.PI_OVER_TWO - 2 * Math.atan2(t, e))
-      );
-    },
-  },
-  longitude: {
-    get: function () {
-      let t = l.PI_OVER_TWO + Math.atan2(this.y, this.x);
-      return (t > Math.PI && (t -= l.TWO_PI), t);
-    },
-  },
-});
-var it = new ot(),
-  Rt = new c();
-b.prototype.getLatitude = function (t) {
-  (P(t) || (t = V.default),
-    (it.latitude = this.conformalLatitude),
-    (it.longitude = this.longitude),
-    (it.height = 0));
-  let e = this.ellipsoid.cartographicToCartesian(it, Rt);
-  return (t.cartesianToCartographic(e, it), it.latitude);
-};
-var It = new wt(),
-  Lt = new c(),
-  Ft = new c();
-b.fromCartesian = function (t, e) {
-  q.defined("cartesian", t);
-  let o = l.signNotZero(t.z),
-    n = b.NORTH_POLE_TANGENT_PLANE,
-    s = b.SOUTH_POLE;
-  o < 0 && ((n = b.SOUTH_POLE_TANGENT_PLANE), (s = b.NORTH_POLE));
-  let i = It;
-  ((i.origin = n.ellipsoid.scaleToGeocentricSurface(t, i.origin)),
-    (i.direction = c.subtract(i.origin, s, Lt)),
-    c.normalize(i.direction, i.direction));
-  let r = yt.rayPlane(i, n.plane, Ft),
-    f = c.subtract(r, s, r),
-    d = c.dot(n.xAxis, f),
-    p = o * c.dot(n.yAxis, f);
-  return P(e)
-    ? ((e.position = new O(d, p)), (e.tangentPlane = n), e)
-    : new b(new O(d, p), n);
-};
-b.fromCartesianArray = function (t, e) {
-  q.defined("cartesians", t);
-  let o = t.length;
-  P(e) ? (e.length = o) : (e = new Array(o));
-  for (let n = 0; n < o; n++) e[n] = b.fromCartesian(t[n], e[n]);
-  return e;
-};
-b.clone = function (t, e) {
-  if (P(t))
-    return P(e)
-      ? ((e.position = t.position), (e.tangentPlane = t.tangentPlane), e)
-      : new b(t.position, t.tangentPlane);
-};
-b.HALF_UNIT_SPHERE = Object.freeze(new V(0.5, 0.5, 0.5));
-b.NORTH_POLE = Object.freeze(new c(0, 0, 0.5));
-b.SOUTH_POLE = Object.freeze(new c(0, 0, -0.5));
-b.NORTH_POLE_TANGENT_PLANE = Object.freeze(
-  new K(b.NORTH_POLE, b.HALF_UNIT_SPHERE),
-);
-b.SOUTH_POLE_TANGENT_PLANE = Object.freeze(
-  new K(b.SOUTH_POLE, b.HALF_UNIT_SPHERE),
-);
-var D = b;
-var vt = new ot(),
-  Ot = new ot();
-function St(t, e, o, n) {
-  let i = n.cartesianToCartographic(t, vt).height,
-    r = n.cartesianToCartographic(e, Ot);
-  ((r.height = i), n.cartographicToCartesian(r, e));
-  let f = n.cartesianToCartographic(o, Ot);
-  ((f.height = i - 100), n.cartographicToCartesian(f, o));
-}
-var Et = new dt(),
-  Vt = new c(),
-  Bt = new c(),
-  Mt = new c(),
-  jt = new c(),
-  kt = new c(),
-  zt = new c(),
-  ft = new c(),
-  Z = new c(),
-  rt = new c(),
-  Dt = new O(),
-  Ut = new O(),
-  Wt = new c(),
-  At = new ct(),
-  Gt = new U(),
-  Yt = new U();
-function pt(t) {
-  let e = t.vertexFormat,
-    o = t.geometry,
-    n = t.shadowVolume,
-    s = o.attributes.position.values,
-    i = P(o.attributes.st) ? o.attributes.st.values : void 0,
-    r = s.length,
-    f = t.wall,
-    d = t.top || f,
-    p = t.bottom || f;
-  if (e.st || e.normal || e.tangent || e.bitangent || n) {
-    let w = t.boundingRectangle,
-      a = t.rotationAxis,
-      H = t.projectTo2d,
-      x = t.ellipsoid,
-      j = t.stRotation,
-      C = t.perPositionHeight,
-      R = Dt;
-    ((R.x = w.x), (R.y = w.y));
-    let B = e.st ? new Float32Array(2 * (r / 3)) : void 0,
-      u;
-    e.normal &&
-      (C && d && !f
-        ? (u = o.attributes.normal.values)
-        : (u = new Float32Array(r)));
-    let E = e.tangent ? new Float32Array(r) : void 0,
-      A = e.bitangent ? new Float32Array(r) : void 0,
-      v = n ? new Float32Array(r) : void 0,
-      T = 0,
-      y = 0,
-      _ = Bt,
-      h = Mt,
-      g = jt,
-      k = !0,
-      Y = Gt,
-      J = Yt;
-    if (j !== 0) {
-      let M = ct.fromAxisAngle(a, j, At);
-      ((Y = U.fromQuaternion(M, Y)),
-        (M = ct.fromAxisAngle(a, -j, At)),
-        (J = U.fromQuaternion(M, J)));
-    } else ((Y = U.clone(U.IDENTITY, Y)), (J = U.clone(U.IDENTITY, J)));
-    let m = 0,
-      I = 0;
-    d && p && ((m = r / 2), (I = r / 3), (r /= 2));
-    for (let M = 0; M < r; M += 3) {
-      let z = c.fromArray(s, M, Wt);
-      if (e.st && !P(i)) {
-        let N = U.multiplyByVector(Y, z, Vt);
-        N = x.scaleToGeodeticSurface(N, N);
-        let S = H([N], Ut)[0];
-        O.subtract(S, R, S);
-        let X = l.clamp(S.x / w.width, 0, 1),
-          et = l.clamp(S.y / w.height, 0, 1);
-        (p && ((B[T + I] = X), (B[T + 1 + I] = et)),
-          d && ((B[T] = X), (B[T + 1] = et)),
-          (T += 2));
-      }
-      if (e.normal || e.tangent || e.bitangent || n) {
-        let N = y + 1,
-          S = y + 2;
-        if (f) {
-          if (M + 3 < r) {
-            let X = c.fromArray(s, M + 3, kt);
-            if (k) {
-              let et = c.fromArray(s, M + r, zt);
-              (C && St(z, X, et, x),
-                c.subtract(X, z, X),
-                c.subtract(et, z, et),
-                (_ = c.normalize(c.cross(et, X, _), _)),
-                (k = !1));
-            }
-            c.equalsEpsilon(X, z, l.EPSILON10) && (k = !0);
-          }
-          (e.tangent || e.bitangent) &&
-            ((g = x.geodeticSurfaceNormal(z, g)),
-            e.tangent && (h = c.normalize(c.cross(g, _, h), h)));
-        } else
-          ((_ = x.geodeticSurfaceNormal(z, _)),
-            (e.tangent || e.bitangent) &&
-              (C &&
-                ((ft = c.fromArray(u, y, ft)),
-                (Z = c.cross(c.UNIT_Z, ft, Z)),
-                (Z = c.normalize(U.multiplyByVector(J, Z, Z), Z)),
-                e.bitangent && (rt = c.normalize(c.cross(ft, Z, rt), rt))),
-              (h = c.cross(c.UNIT_Z, _, h)),
-              (h = c.normalize(U.multiplyByVector(J, h, h), h)),
-              e.bitangent && (g = c.normalize(c.cross(_, h, g), g))));
-        (e.normal &&
-          (t.wall
-            ? ((u[y + m] = _.x), (u[N + m] = _.y), (u[S + m] = _.z))
-            : p && ((u[y + m] = -_.x), (u[N + m] = -_.y), (u[S + m] = -_.z)),
-          ((d && !C) || f) && ((u[y] = _.x), (u[N] = _.y), (u[S] = _.z))),
-          n &&
-            (f && (_ = x.geodeticSurfaceNormal(z, _)),
-            (v[y + m] = -_.x),
-            (v[N + m] = -_.y),
-            (v[S + m] = -_.z)),
-          e.tangent &&
-            (t.wall
-              ? ((E[y + m] = h.x), (E[N + m] = h.y), (E[S + m] = h.z))
-              : p && ((E[y + m] = -h.x), (E[N + m] = -h.y), (E[S + m] = -h.z)),
-            d &&
-              (C
-                ? ((E[y] = Z.x), (E[N] = Z.y), (E[S] = Z.z))
-                : ((E[y] = h.x), (E[N] = h.y), (E[S] = h.z)))),
-          e.bitangent &&
-            (p && ((A[y + m] = g.x), (A[N + m] = g.y), (A[S + m] = g.z)),
-            d &&
-              (C
-                ? ((A[y] = rt.x), (A[N] = rt.y), (A[S] = rt.z))
-                : ((A[y] = g.x), (A[N] = g.y), (A[S] = g.z)))),
-          (y += 3));
-      }
-    }
-    (e.st &&
-      !P(i) &&
-      (o.attributes.st = new tt({
-        componentDatatype: $.FLOAT,
-        componentsPerAttribute: 2,
-        values: B,
-      })),
-      e.normal &&
-        (o.attributes.normal = new tt({
-          componentDatatype: $.FLOAT,
-          componentsPerAttribute: 3,
-          values: u,
-        })),
-      e.tangent &&
-        (o.attributes.tangent = new tt({
-          componentDatatype: $.FLOAT,
-          componentsPerAttribute: 3,
-          values: E,
-        })),
-      e.bitangent &&
-        (o.attributes.bitangent = new tt({
-          componentDatatype: $.FLOAT,
-          componentsPerAttribute: 3,
-          values: A,
-        })),
-      n &&
-        (o.attributes.extrudeDirection = new tt({
-          componentDatatype: $.FLOAT,
-          componentsPerAttribute: 3,
-          values: v,
-        })));
-  }
-  if (t.extrude && P(t.offsetAttribute)) {
-    let w = s.length / 3,
-      a = new Uint8Array(w);
-    if (t.offsetAttribute === ht.TOP)
-      (d && p) || f ? (a = a.fill(1, 0, w / 2)) : d && (a = a.fill(1));
-    else {
-      let H = t.offsetAttribute === ht.NONE ? 0 : 1;
-      a = a.fill(H);
-    }
-    o.attributes.applyOffset = new tt({
-      componentDatatype: $.UNSIGNED_BYTE,
-      componentsPerAttribute: 1,
-      values: a,
-    });
-  }
-  return o;
-}
-var Ht = [];
-function qt(t, e, o, n, s, i, r, f, d, p) {
-  let w = { walls: [] },
-    a;
-  if (r || f) {
-    let u = F.createGeometryFromPositions(t, e, o, n, i, d, p),
-      E = u.attributes.position.values,
-      A = u.indices,
-      v,
-      T;
-    if (r && f) {
-      let y = E.concat(E);
-      ((v = y.length / 3),
-        (T = lt.createTypedArray(v, A.length * 2)),
-        T.set(A));
-      let _ = A.length,
-        h = v / 2;
-      for (a = 0; a < _; a += 3) {
-        let g = T[a] + h,
-          k = T[a + 1] + h,
-          Y = T[a + 2] + h;
-        ((T[a + _] = Y), (T[a + 1 + _] = k), (T[a + 2 + _] = g));
-      }
-      if (((u.attributes.position.values = y), i && d.normal)) {
-        let g = u.attributes.normal.values;
-        ((u.attributes.normal.values = new Float32Array(y.length)),
-          u.attributes.normal.values.set(g));
-      }
-      if (d.st && P(o)) {
-        let g = u.attributes.st.values;
-        ((u.attributes.st.values = new Float32Array(v * 2)),
-          (u.attributes.st.values = g.concat(g)));
-      }
-      u.indices = T;
-    } else if (f) {
-      for (
-        v = E.length / 3, T = lt.createTypedArray(v, A.length), a = 0;
-        a < A.length;
-        a += 3
-      )
-        ((T[a] = A[a + 2]), (T[a + 1] = A[a + 1]), (T[a + 2] = A[a]));
-      u.indices = T;
-    }
-    w.topAndBottom = new st({ geometry: u });
-  }
-  let H = s.outerRing,
-    x = K.fromPoints(H, t),
-    j = x.projectPointsOntoPlane(H, Ht),
-    C = nt.computeWindingOrder2D(j);
-  C === gt.CLOCKWISE && (H = H.slice().reverse());
-  let R = F.computeWallGeometry(H, o, t, n, i, p);
-  w.walls.push(new st({ geometry: R }));
-  let B = s.holes;
-  for (a = 0; a < B.length; a++) {
-    let u = B[a];
-    ((j = x.projectPointsOntoPlane(u, Ht)),
-      (C = nt.computeWindingOrder2D(j)),
-      C === gt.COUNTER_CLOCKWISE && (u = u.slice().reverse()),
-      (R = F.computeWallGeometry(u, o, t, n, i, p)),
-      w.walls.push(new st({ geometry: R })));
-  }
-  return w;
-}
-function G(t) {
-  if (
-    (q.typeOf.object("options", t),
-    q.typeOf.object("options.polygonHierarchy", t.polygonHierarchy),
-    P(t.perPositionHeight) && t.perPositionHeight && P(t.height))
-  )
-    throw new ut(
-      "Cannot use both options.perPositionHeight and options.height",
-    );
-  if (P(t.arcType) && t.arcType !== at.GEODESIC && t.arcType !== at.RHUMB)
-    throw new ut(
-      "Invalid arcType. Valid options are ArcType.GEODESIC and ArcType.RHUMB.",
-    );
-  let e = t.polygonHierarchy,
-    o = L(t.vertexFormat, Q.DEFAULT),
-    n = L(t.ellipsoid, V.default),
-    s = L(t.granularity, l.RADIANS_PER_DEGREE),
-    i = L(t.stRotation, 0),
-    r = t.textureCoordinates,
-    f = L(t.perPositionHeight, !1),
-    d = f && P(t.extrudedHeight),
-    p = L(t.height, 0),
-    w = L(t.extrudedHeight, p);
-  if (!d) {
-    let a = Math.max(p, w);
-    ((w = Math.min(p, w)), (p = a));
-  }
-  ((this._vertexFormat = Q.clone(o)),
-    (this._ellipsoid = V.clone(n)),
-    (this._granularity = s),
-    (this._stRotation = i),
-    (this._height = p),
-    (this._extrudedHeight = w),
-    (this._closeTop = L(t.closeTop, !0)),
-    (this._closeBottom = L(t.closeBottom, !0)),
-    (this._polygonHierarchy = e),
-    (this._perPositionHeight = f),
-    (this._perPositionHeightExtrude = d),
-    (this._shadowVolume = L(t.shadowVolume, !1)),
-    (this._workerName = "createPolygonGeometry"),
-    (this._offsetAttribute = t.offsetAttribute),
-    (this._arcType = L(t.arcType, at.GEODESIC)),
-    (this._rectangle = void 0),
-    (this._textureCoordinateRotationPoints = void 0),
-    (this._textureCoordinates = r),
-    (this.packedLength =
-      F.computeHierarchyPackedLength(e, c) +
-      V.packedLength +
-      Q.packedLength +
-      (r ? F.computeHierarchyPackedLength(r, O) : 1) +
-      12));
-}
-G.fromPositions = function (t) {
-  ((t = L(t, L.EMPTY_OBJECT)), q.defined("options.positions", t.positions));
-  let e = {
-    polygonHierarchy: { positions: t.positions },
-    height: t.height,
-    extrudedHeight: t.extrudedHeight,
-    vertexFormat: t.vertexFormat,
-    stRotation: t.stRotation,
-    ellipsoid: t.ellipsoid,
-    granularity: t.granularity,
-    perPositionHeight: t.perPositionHeight,
-    closeTop: t.closeTop,
-    closeBottom: t.closeBottom,
-    offsetAttribute: t.offsetAttribute,
-    arcType: t.arcType,
-    textureCoordinates: t.textureCoordinates,
-  };
-  return new G(e);
-};
-G.pack = function (t, e, o) {
-  return (
-    q.typeOf.object("value", t),
-    q.defined("array", e),
-    (o = L(o, 0)),
-    (o = F.packPolygonHierarchy(t._polygonHierarchy, e, o, c)),
-    V.pack(t._ellipsoid, e, o),
-    (o += V.packedLength),
-    Q.pack(t._vertexFormat, e, o),
-    (o += Q.packedLength),
-    (e[o++] = t._height),
-    (e[o++] = t._extrudedHeight),
-    (e[o++] = t._granularity),
-    (e[o++] = t._stRotation),
-    (e[o++] = t._perPositionHeightExtrude ? 1 : 0),
-    (e[o++] = t._perPositionHeight ? 1 : 0),
-    (e[o++] = t._closeTop ? 1 : 0),
-    (e[o++] = t._closeBottom ? 1 : 0),
-    (e[o++] = t._shadowVolume ? 1 : 0),
-    (e[o++] = L(t._offsetAttribute, -1)),
-    (e[o++] = t._arcType),
-    P(t._textureCoordinates)
-      ? (o = F.packPolygonHierarchy(t._textureCoordinates, e, o, O))
-      : (e[o++] = -1),
-    (e[o++] = t.packedLength),
-    e
-  );
-};
-var Qt = V.clone(V.UNIT_SPHERE),
-  Zt = new Q(),
-  Kt = { polygonHierarchy: {} };
-G.unpack = function (t, e, o) {
-  (q.defined("array", t), (e = L(e, 0)));
-  let n = F.unpackPolygonHierarchy(t, e, c);
-  ((e = n.startingIndex), delete n.startingIndex);
-  let s = V.unpack(t, e, Qt);
-  e += V.packedLength;
-  let i = Q.unpack(t, e, Zt);
-  e += Q.packedLength;
-  let r = t[e++],
-    f = t[e++],
-    d = t[e++],
-    p = t[e++],
-    w = t[e++] === 1,
-    a = t[e++] === 1,
-    H = t[e++] === 1,
-    x = t[e++] === 1,
-    j = t[e++] === 1,
-    C = t[e++],
-    R = t[e++],
-    B = t[e] === -1 ? void 0 : F.unpackPolygonHierarchy(t, e, O);
-  P(B) ? ((e = B.startingIndex), delete B.startingIndex) : e++;
-  let u = t[e++];
-  return (
-    P(o) || (o = new G(Kt)),
-    (o._polygonHierarchy = n),
-    (o._ellipsoid = V.clone(s, o._ellipsoid)),
-    (o._vertexFormat = Q.clone(i, o._vertexFormat)),
-    (o._height = r),
-    (o._extrudedHeight = f),
-    (o._granularity = d),
-    (o._stRotation = p),
-    (o._perPositionHeightExtrude = w),
-    (o._perPositionHeight = a),
-    (o._closeTop = H),
-    (o._closeBottom = x),
-    (o._shadowVolume = j),
-    (o._offsetAttribute = C === -1 ? void 0 : C),
-    (o._arcType = R),
-    (o._textureCoordinates = B),
-    (o.packedLength = u),
-    o
-  );
-};
-var Jt = new O(),
-  Xt = new O(),
-  $t = new D();
-function xt(t, e, o, n, s, i) {
-  let r = t.longitude,
-    f = r >= 0 ? r : r + l.TWO_PI;
-  ((s.westOverIdl = Math.min(s.westOverIdl, f)),
-    (s.eastOverIdl = Math.max(s.eastOverIdl, f)),
-    (i.west = Math.min(i.west, r)),
-    (i.east = Math.max(i.east, r)));
-  let d = t.getLatitude(o),
-    p = d;
-  if (
-    ((i.south = Math.min(i.south, d)),
-    (i.north = Math.max(i.north, d)),
-    n !== at.RHUMB)
-  ) {
-    let H = O.subtract(e.position, t.position, Jt),
-      x = O.dot(e.position, H) / O.dot(H, H);
-    if (x > 0 && x < 1) {
-      let j = O.add(e.position, O.multiplyByScalar(H, -x, H), Xt),
-        C = D.clone(e, $t);
-      C.position = j;
-      let R = C.getLatitude(o);
-      ((i.south = Math.min(i.south, R)),
-        (i.north = Math.max(i.north, R)),
-        Math.abs(d) > Math.abs(R) && (p = R));
-    }
-  }
-  let w = e.x * t.y - t.x * e.y,
-    a = Math.sign(w);
-  (a !== 0 && (a *= O.angleBetween(e.position, t.position)),
-    p >= 0 && (s.northAngle += a),
-    p <= 0 && (s.southAngle += a));
-}
-var Ct = new D(),
-  te = new D(),
-  W = { northAngle: 0, southAngle: 0, westOverIdl: 0, eastOverIdl: 0 };
-G.computeRectangleFromPositions = function (t, e, o, n) {
-  if ((q.defined("positions", t), P(n) || (n = new _t()), t.length < 3))
-    return n;
-  ((n.west = Number.POSITIVE_INFINITY),
-    (n.east = Number.NEGATIVE_INFINITY),
-    (n.south = Number.POSITIVE_INFINITY),
-    (n.north = Number.NEGATIVE_INFINITY),
-    (W.northAngle = 0),
-    (W.southAngle = 0),
-    (W.westOverIdl = Number.POSITIVE_INFINITY),
-    (W.eastOverIdl = Number.NEGATIVE_INFINITY));
-  let s = t.length,
-    i = D.fromCartesian(t[0], te);
-  for (let r = 1; r < s; r++) {
-    let f = D.fromCartesian(t[r], Ct);
-    (xt(f, i, e, o, W, n), (i = D.clone(f, i)));
-  }
-  return (
-    xt(D.fromCartesian(t[0], Ct), i, e, o, W, n),
-    n.east - n.west > W.eastOverIdl - W.westOverIdl &&
-      ((n.west = W.westOverIdl),
-      (n.east = W.eastOverIdl),
-      n.east > l.PI && (n.east = n.east - l.TWO_PI),
-      n.west > l.PI && (n.west = n.west - l.TWO_PI)),
-    l.equalsEpsilon(Math.abs(W.northAngle), l.TWO_PI, l.EPSILON10) &&
-      ((n.north = l.PI_OVER_TWO), (n.east = l.PI), (n.west = -l.PI)),
-    l.equalsEpsilon(Math.abs(W.southAngle), l.TWO_PI, l.EPSILON10) &&
-      ((n.south = -l.PI_OVER_TWO), (n.east = l.PI), (n.west = -l.PI)),
-    n
-  );
-};
-var ee = new D();
-function oe(t, e, o) {
-  return t.height >= l.PI || t.width >= l.PI
-    ? D.fromCartesian(e[0], ee).tangentPlane
-    : K.fromPoints(e, o);
-}
-var Nt = new ot();
-function ne(t, e, o) {
-  return (n, s) => {
-    if (t.height >= l.PI || t.width >= l.PI) {
-      if (t.south < 0 && t.north > 0) {
-        P(s) || (s = []);
-        for (let r = 0; r < n.length; ++r) {
-          let f = o.cartesianToCartographic(n[r], Nt);
-          s[r] = new O(f.longitude / l.PI, f.latitude / l.PI_OVER_TWO);
-        }
-        return ((s.length = n.length), s);
-      }
-      return D.fromCartesianArray(n, s);
-    }
-    return K.fromPoints(e, o).projectPointsOntoPlane(n, s);
-  };
-}
-function ie(t, e, o) {
-  if (t.height >= l.PI || t.width >= l.PI)
-    return (s, i) => {
-      if (t.south < 0 && t.north > 0) {
-        let r = o.cartesianToCartographic(s, Nt);
-        return (
-          P(i) || (i = new O()),
-          (i.x = r.longitude / l.PI),
-          (i.y = r.latitude / l.PI_OVER_TWO),
-          i
-        );
-      }
-      return D.fromCartesian(s, i);
-    };
-  let n = K.fromPoints(e, o);
-  return (s, i) => n.projectPointsOntoPlane(s, i);
-}
-function re(t, e, o, n) {
-  return (s, i) =>
-    !n && (t.height >= l.PI_OVER_TWO || t.width >= 2 * l.PI_OVER_THREE)
-      ? F.splitPolygonsOnEquator(s, e, o, i)
-      : s;
-}
-function se(t, e, o, n) {
-  if (e.height >= l.PI || e.width >= l.PI)
-    return dt.fromRectangle(e, void 0, Et);
-  let s = t,
-    i = K.fromPoints(s, o);
-  return F.computeBoundingRectangle(
-    i.plane.normal,
-    i.projectPointOntoPlane.bind(i),
-    s,
-    n,
-    Et,
-  );
-}
-G.createGeometry = function (t) {
-  let e = t._vertexFormat,
-    o = t._ellipsoid,
-    n = t._granularity,
-    s = t._stRotation,
-    i = t._polygonHierarchy,
-    r = t._perPositionHeight,
-    f = t._closeTop,
-    d = t._closeBottom,
-    p = t._arcType,
-    w = t._textureCoordinates,
-    a = P(w),
-    H = i.positions;
-  if (H.length < 3) return;
-  let x = t.rectangle,
-    j = F.polygonsFromHierarchy(i, a, ne(x, H, o), !r, o, re(x, o, p, r)),
-    C = j.hierarchy,
-    R = j.polygons,
-    B = function (m) {
-      return m;
-    },
-    u = a ? F.polygonsFromHierarchy(w, !0, B, !1, o).polygons : void 0;
-  if (C.length === 0) return;
-  let E = C[0].outerRing,
-    A = se(E, x, o, s),
-    v = [],
-    T = t._height,
-    y = t._extrudedHeight,
-    _ = t._perPositionHeightExtrude || !l.equalsEpsilon(T, y, 0, l.EPSILON2),
-    h = {
-      perPositionHeight: r,
-      vertexFormat: e,
-      geometry: void 0,
-      rotationAxis: oe(x, E, o).plane.normal,
-      projectTo2d: ie(x, E, o),
-      boundingRectangle: A,
-      ellipsoid: o,
-      stRotation: s,
-      textureCoordinates: void 0,
-      bottom: !1,
-      top: !0,
-      wall: !1,
-      extrude: !1,
-      arcType: p,
-    },
-    g;
-  if (_)
-    for (
-      h.extrude = !0,
-        h.top = f,
-        h.bottom = d,
-        h.shadowVolume = t._shadowVolume,
-        h.offsetAttribute = t._offsetAttribute,
-        g = 0;
-      g < R.length;
-      g++
-    ) {
-      let m = qt(o, R[g], a ? u[g] : void 0, n, C[g], r, f, d, e, p),
-        I;
-      (f && d
-        ? ((I = m.topAndBottom),
-          (h.geometry = F.scaleToGeodeticHeightExtruded(
-            I.geometry,
-            T,
-            y,
-            o,
-            r,
-          )))
-        : f
-          ? ((I = m.topAndBottom),
-            (I.geometry.attributes.position.values = nt.scaleToGeodeticHeight(
-              I.geometry.attributes.position.values,
-              T,
-              o,
-              !r,
-            )),
-            (h.geometry = I.geometry))
-          : d &&
-            ((I = m.topAndBottom),
-            (I.geometry.attributes.position.values = nt.scaleToGeodeticHeight(
-              I.geometry.attributes.position.values,
-              y,
-              o,
-              !0,
-            )),
-            (h.geometry = I.geometry)),
-        (f || d) && ((h.wall = !1), (I.geometry = pt(h)), v.push(I)));
-      let M = m.walls;
-      h.wall = !0;
-      for (let z = 0; z < M.length; z++) {
-        let N = M[z];
-        ((h.geometry = F.scaleToGeodeticHeightExtruded(N.geometry, T, y, o, r)),
-          (N.geometry = pt(h)),
-          v.push(N));
-      }
-    }
-  else
-    for (g = 0; g < R.length; g++) {
-      let m = new st({
-        geometry: F.createGeometryFromPositions(
-          o,
-          R[g],
-          a ? u[g] : void 0,
-          n,
-          r,
-          e,
-          p,
-        ),
-      });
-      if (
-        ((m.geometry.attributes.position.values = nt.scaleToGeodeticHeight(
-          m.geometry.attributes.position.values,
-          T,
-          o,
-          !r,
-        )),
-        (h.geometry = m.geometry),
-        (m.geometry = pt(h)),
-        P(t._offsetAttribute))
-      ) {
-        let I = m.geometry.attributes.position.values.length,
-          M = t._offsetAttribute === ht.NONE ? 0 : 1,
-          z = new Uint8Array(I / 3).fill(M);
-        m.geometry.attributes.applyOffset = new tt({
-          componentDatatype: $.UNSIGNED_BYTE,
-          componentsPerAttribute: 1,
-          values: z,
-        });
-      }
-      v.push(m);
-    }
-  let k = bt.combineInstances(v)[0];
-  ((k.attributes.position.values = new Float64Array(
-    k.attributes.position.values,
-  )),
-    (k.indices = lt.createTypedArray(
-      k.attributes.position.values.length / 3,
-      k.indices,
-    )));
-  let Y = k.attributes,
-    J = Tt.fromVertices(Y.position.values);
-  return (
-    e.position || delete Y.position,
-    new mt({
-      attributes: Y,
-      indices: k.indices,
-      primitiveType: k.primitiveType,
-      boundingSphere: J,
-      offsetAttribute: t._offsetAttribute,
-    })
-  );
-};
-G.createShadowVolume = function (t, e, o) {
-  let n = t._granularity,
-    s = t._ellipsoid,
-    i = e(n, s),
-    r = o(n, s);
-  return new G({
-    polygonHierarchy: t._polygonHierarchy,
-    ellipsoid: s,
-    stRotation: t._stRotation,
-    granularity: n,
-    perPositionHeight: !1,
-    extrudedHeight: i,
-    height: r,
-    vertexFormat: Q.POSITION_ONLY,
-    shadowVolume: !0,
-    arcType: t._arcType,
-  });
-};
-function ae(t) {
-  let e = -t._stRotation;
-  if (e === 0) return [0, 0, 0, 1, 1, 0];
-  let o = t._ellipsoid,
-    n = t._polygonHierarchy.positions,
-    s = t.rectangle;
-  return mt._textureCoordinateRotationPoints(n, e, o, s);
-}
-Object.defineProperties(G.prototype, {
-  rectangle: {
-    get: function () {
-      if (!P(this._rectangle)) {
-        let t = this._polygonHierarchy.positions;
-        this._rectangle = G.computeRectangleFromPositions(
-          t,
-          this._ellipsoid,
-          this._arcType,
-        );
-      }
-      return this._rectangle;
-    },
-  },
-  textureCoordinateRotationPoints: {
-    get: function () {
-      return (
-        P(this._textureCoordinateRotationPoints) ||
-          (this._textureCoordinateRotationPoints = ae(this)),
-        this._textureCoordinateRotationPoints
-      );
-    },
-  },
-});
-var Pt = G;
-function ce(t, e) {
-  return (
-    P(e) && (t = Pt.unpack(t, e)),
-    (t._ellipsoid = V.clone(t._ellipsoid)),
-    Pt.createGeometry(t)
-  );
-}
-var Xe = ce;
-export { Xe as default };