/**
 * @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 };
