create-swdg-frontend 0.1.0

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

@@ -0,0 +1,830 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.119
+ *
+ * Copyright 2011-2022 Cesium Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Columbus View (Pat. Pend.)
+ *
+ * Portions licensed separately.
+ * See https://github.com/CesiumGS/cesium/blob/main/LICENSE.md for full licensing details.
+ */
+
+import { a as M } from "./chunk-XHX2UPDO.js";
+import { a as ht } from "./chunk-K4ASOM65.js";
+import "./chunk-AMQUWUD4.js";
+import "./chunk-W23CU777.js";
+import { a as _t } from "./chunk-ILGBPNP6.js";
+import { a as G } from "./chunk-HEEMUCG6.js";
+import "./chunk-KF5NF354.js";
+import "./chunk-4WRMLZA7.js";
+import { b as yt } from "./chunk-O5IJ3OGP.js";
+import { a as Pt } from "./chunk-RXTBM4OI.js";
+import "./chunk-FYOYUPXG.js";
+import "./chunk-TAMCUKAR.js";
+import "./chunk-PDMQLSBL.js";
+import { a as Nt } from "./chunk-P37AI2DW.js";
+import { a as Ct } from "./chunk-T6BE4RZK.js";
+import { b as Mt, c as Vt, d as x } from "./chunk-X5IHHI6X.js";
+import { d as St } from "./chunk-TMSETF7M.js";
+import { h as Et } from "./chunk-7Z5IIKOJ.js";
+import { a as F } from "./chunk-KZNJOCYU.js";
+import { a as o, b as bt, d as I } from "./chunk-POASMU2N.js";
+import { a as st } from "./chunk-R6KGAEF6.js";
+import "./chunk-3C7WC463.js";
+import "./chunk-II4VNKYR.js";
+import { a as B } from "./chunk-IUA6FAOZ.js";
+import { b as it } from "./chunk-UH2WFNTA.js";
+import { e as X } from "./chunk-PEYJTJPE.js";
+var zt = new o(),
+  kt = new o(),
+  wt = new o(),
+  Tt = new o(),
+  jt = new o(),
+  Ht = new o(),
+  at = new o(),
+  ft = new o();
+function Ut(t, e) {
+  for (let i = 0; i < t.length; i++)
+    t[i] = e.scaleToGeodeticSurface(t[i], t[i]);
+  return t;
+}
+function Z(t, e, i, l, d, f) {
+  let h = t.normals,
+    O = t.tangents,
+    g = t.bitangents,
+    r = o.normalize(o.cross(i, e, at), at);
+  (f.normal && M.addAttribute(h, e, l, d),
+    f.tangent && M.addAttribute(O, r, l, d),
+    f.bitangent && M.addAttribute(g, i, l, d));
+}
+function Bt(t, e, i) {
+  let l = t.positions,
+    d = t.corners,
+    f = t.endPositions,
+    h = t.lefts,
+    O = t.normals,
+    g = new Ct(),
+    r,
+    a = 0,
+    s = 0,
+    n,
+    A = 0,
+    u;
+  for (n = 0; n < l.length; n += 2)
+    ((u = l[n].length - 3), (a += u), (A += u * 2), (s += l[n + 1].length - 3));
+  for (a += 3, s += 3, n = 0; n < d.length; n++) {
+    r = d[n];
+    let c = d[n].leftPositions;
+    X(c)
+      ? ((u = c.length), (a += u), (A += u))
+      : ((u = d[n].rightPositions.length), (s += u), (A += u));
+  }
+  let b = X(f),
+    p;
+  b && ((p = f[0].length - 3), (a += p), (s += p), (p /= 3), (A += p * 6));
+  let R = a + s,
+    m = new Float64Array(R),
+    C = e.normal ? new Float32Array(R) : void 0,
+    D = e.tangent ? new Float32Array(R) : void 0,
+    lt = e.bitangent ? new Float32Array(R) : void 0,
+    z = { normals: C, tangents: D, bitangents: lt },
+    y = 0,
+    E = R - 1,
+    S,
+    V,
+    H,
+    J,
+    P = zt,
+    w = kt,
+    nt,
+    ot,
+    mt = p / 2,
+    _ = Nt.createTypedArray(R / 3, A),
+    T = 0;
+  if (b) {
+    ((ot = wt), (nt = Tt));
+    let c = f[0];
+    for (P = o.fromArray(O, 0, P), w = o.fromArray(h, 0, w), n = 0; n < mt; n++)
+      ((ot = o.fromArray(c, (mt - 1 - n) * 3, ot)),
+        (nt = o.fromArray(c, (mt + n) * 3, nt)),
+        M.addAttribute(m, nt, y),
+        M.addAttribute(m, ot, void 0, E),
+        Z(z, P, w, y, E, e),
+        (V = y / 3),
+        (J = V + 1),
+        (S = (E - 2) / 3),
+        (H = S - 1),
+        (_[T++] = S),
+        (_[T++] = V),
+        (_[T++] = H),
+        (_[T++] = H),
+        (_[T++] = V),
+        (_[T++] = J),
+        (y += 3),
+        (E -= 3));
+  }
+  let At = 0,
+    ut = 0,
+    rt = l[At++],
+    q = l[At++];
+  (m.set(rt, y), m.set(q, E - q.length + 1), (w = o.fromArray(h, ut, w)));
+  let ct, dt;
+  for (u = q.length - 3, n = 0; n < u; n += 3)
+    ((ct = i.geodeticSurfaceNormal(o.fromArray(rt, n, at), at)),
+      (dt = i.geodeticSurfaceNormal(o.fromArray(q, u - n, ft), ft)),
+      (P = o.normalize(o.add(ct, dt, P), P)),
+      Z(z, P, w, y, E, e),
+      (V = y / 3),
+      (J = V + 1),
+      (S = (E - 2) / 3),
+      (H = S - 1),
+      (_[T++] = S),
+      (_[T++] = V),
+      (_[T++] = H),
+      (_[T++] = H),
+      (_[T++] = V),
+      (_[T++] = J),
+      (y += 3),
+      (E -= 3));
+  for (
+    ct = i.geodeticSurfaceNormal(o.fromArray(rt, u, at), at),
+      dt = i.geodeticSurfaceNormal(o.fromArray(q, u, ft), ft),
+      P = o.normalize(o.add(ct, dt, P), P),
+      ut += 3,
+      n = 0;
+    n < d.length;
+    n++
+  ) {
+    let c;
+    r = d[n];
+    let $ = r.leftPositions,
+      v = r.rightPositions,
+      L,
+      U,
+      N = Ht,
+      k = wt,
+      Y = Tt;
+    if (((P = o.fromArray(O, ut, P)), X($))) {
+      for (
+        Z(z, P, w, void 0, E, e), E -= 3, L = J, U = H, c = 0;
+        c < $.length / 3;
+        c++
+      )
+        ((N = o.fromArray($, c * 3, N)),
+          (_[T++] = L),
+          (_[T++] = U - c - 1),
+          (_[T++] = U - c),
+          M.addAttribute(m, N, void 0, E),
+          (k = o.fromArray(m, (U - c - 1) * 3, k)),
+          (Y = o.fromArray(m, L * 3, Y)),
+          (w = o.normalize(o.subtract(k, Y, w), w)),
+          Z(z, P, w, void 0, E, e),
+          (E -= 3));
+      ((N = o.fromArray(m, L * 3, N)),
+        (k = o.subtract(o.fromArray(m, U * 3, k), N, k)),
+        (Y = o.subtract(o.fromArray(m, (U - c) * 3, Y), N, Y)),
+        (w = o.normalize(o.add(k, Y, w), w)),
+        Z(z, P, w, y, void 0, e),
+        (y += 3));
+    } else {
+      for (
+        Z(z, P, w, y, void 0, e), y += 3, L = H, U = J, c = 0;
+        c < v.length / 3;
+        c++
+      )
+        ((N = o.fromArray(v, c * 3, N)),
+          (_[T++] = L),
+          (_[T++] = U + c),
+          (_[T++] = U + c + 1),
+          M.addAttribute(m, N, y),
+          (k = o.fromArray(m, L * 3, k)),
+          (Y = o.fromArray(m, (U + c) * 3, Y)),
+          (w = o.normalize(o.subtract(k, Y, w), w)),
+          Z(z, P, w, y, void 0, e),
+          (y += 3));
+      ((N = o.fromArray(m, L * 3, N)),
+        (k = o.subtract(o.fromArray(m, (U + c) * 3, k), N, k)),
+        (Y = o.subtract(o.fromArray(m, U * 3, Y), N, Y)),
+        (w = o.normalize(o.negate(o.add(Y, k, w), w), w)),
+        Z(z, P, w, void 0, E, e),
+        (E -= 3));
+    }
+    for (
+      rt = l[At++],
+        q = l[At++],
+        rt.splice(0, 3),
+        q.splice(q.length - 3, 3),
+        m.set(rt, y),
+        m.set(q, E - q.length + 1),
+        u = q.length - 3,
+        ut += 3,
+        w = o.fromArray(h, ut, w),
+        c = 0;
+      c < q.length;
+      c += 3
+    )
+      ((ct = i.geodeticSurfaceNormal(o.fromArray(rt, c, at), at)),
+        (dt = i.geodeticSurfaceNormal(o.fromArray(q, u - c, ft), ft)),
+        (P = o.normalize(o.add(ct, dt, P), P)),
+        Z(z, P, w, y, E, e),
+        (J = y / 3),
+        (V = J - 1),
+        (H = (E - 2) / 3),
+        (S = H + 1),
+        (_[T++] = S),
+        (_[T++] = V),
+        (_[T++] = H),
+        (_[T++] = H),
+        (_[T++] = V),
+        (_[T++] = J),
+        (y += 3),
+        (E -= 3));
+    ((y -= 3), (E += 3));
+  }
+  if (((P = o.fromArray(O, O.length - 3, P)), Z(z, P, w, y, E, e), b)) {
+    ((y += 3), (E -= 3), (ot = wt), (nt = Tt));
+    let c = f[1];
+    for (n = 0; n < mt; n++)
+      ((ot = o.fromArray(c, (p - n - 1) * 3, ot)),
+        (nt = o.fromArray(c, n * 3, nt)),
+        M.addAttribute(m, ot, void 0, E),
+        M.addAttribute(m, nt, y),
+        Z(z, P, w, y, E, e),
+        (J = y / 3),
+        (V = J - 1),
+        (H = (E - 2) / 3),
+        (S = H + 1),
+        (_[T++] = S),
+        (_[T++] = V),
+        (_[T++] = H),
+        (_[T++] = H),
+        (_[T++] = V),
+        (_[T++] = J),
+        (y += 3),
+        (E -= 3));
+  }
+  if (
+    ((g.position = new x({
+      componentDatatype: F.DOUBLE,
+      componentsPerAttribute: 3,
+      values: m,
+    })),
+    e.st)
+  ) {
+    let c = new Float32Array((R / 3) * 2),
+      $,
+      v,
+      L = 0;
+    if (b) {
+      ((a /= 3), (s /= 3));
+      let U = Math.PI / (p + 1);
+      ((v = 1 / (a - p + 1)), ($ = 1 / (s - p + 1)));
+      let N,
+        k = p / 2;
+      for (n = k + 1; n < p + 1; n++)
+        ((N = st.PI_OVER_TWO + U * n),
+          (c[L++] = $ * (1 + Math.cos(N))),
+          (c[L++] = 0.5 * (1 + Math.sin(N))));
+      for (n = 1; n < s - p + 1; n++) ((c[L++] = n * $), (c[L++] = 0));
+      for (n = p; n > k; n--)
+        ((N = st.PI_OVER_TWO - n * U),
+          (c[L++] = 1 - $ * (1 + Math.cos(N))),
+          (c[L++] = 0.5 * (1 + Math.sin(N))));
+      for (n = k; n > 0; n--)
+        ((N = st.PI_OVER_TWO - U * n),
+          (c[L++] = 1 - v * (1 + Math.cos(N))),
+          (c[L++] = 0.5 * (1 + Math.sin(N))));
+      for (n = a - p; n > 0; n--) ((c[L++] = n * v), (c[L++] = 1));
+      for (n = 1; n < k + 1; n++)
+        ((N = st.PI_OVER_TWO + U * n),
+          (c[L++] = v * (1 + Math.cos(N))),
+          (c[L++] = 0.5 * (1 + Math.sin(N))));
+    } else {
+      for (a /= 3, s /= 3, v = 1 / (a - 1), $ = 1 / (s - 1), n = 0; n < s; n++)
+        ((c[L++] = n * $), (c[L++] = 0));
+      for (n = a; n > 0; n--) ((c[L++] = (n - 1) * v), (c[L++] = 1));
+    }
+    g.st = new x({
+      componentDatatype: F.FLOAT,
+      componentsPerAttribute: 2,
+      values: c,
+    });
+  }
+  return (
+    e.normal &&
+      (g.normal = new x({
+        componentDatatype: F.FLOAT,
+        componentsPerAttribute: 3,
+        values: z.normals,
+      })),
+    e.tangent &&
+      (g.tangent = new x({
+        componentDatatype: F.FLOAT,
+        componentsPerAttribute: 3,
+        values: z.tangents,
+      })),
+    e.bitangent &&
+      (g.bitangent = new x({
+        componentDatatype: F.FLOAT,
+        componentsPerAttribute: 3,
+        values: z.bitangents,
+      })),
+    { attributes: g, indices: _ }
+  );
+}
+function qt(t, e) {
+  if (!e.normal && !e.tangent && !e.bitangent && !e.st) return t;
+  let i = t.position.values,
+    l,
+    d;
+  (e.normal || e.bitangent) &&
+    ((l = t.normal.values), (d = t.bitangent.values));
+  let f = t.position.values.length / 18,
+    h = f * 3,
+    O = f * 2,
+    g = h * 2,
+    r;
+  if (e.normal || e.bitangent || e.tangent) {
+    let a = e.normal ? new Float32Array(h * 6) : void 0,
+      s = e.tangent ? new Float32Array(h * 6) : void 0,
+      n = e.bitangent ? new Float32Array(h * 6) : void 0,
+      A = zt,
+      u = kt,
+      b = wt,
+      p = Tt,
+      R = jt,
+      m = Ht,
+      C = g;
+    for (r = 0; r < h; r += 3) {
+      let D = C + g;
+      ((A = o.fromArray(i, r, A)),
+        (u = o.fromArray(i, r + h, u)),
+        (b = o.fromArray(i, (r + 3) % h, b)),
+        (u = o.subtract(u, A, u)),
+        (b = o.subtract(b, A, b)),
+        (p = o.normalize(o.cross(u, b, p), p)),
+        e.normal &&
+          (M.addAttribute(a, p, D),
+          M.addAttribute(a, p, D + 3),
+          M.addAttribute(a, p, C),
+          M.addAttribute(a, p, C + 3)),
+        (e.tangent || e.bitangent) &&
+          ((m = o.fromArray(l, r, m)),
+          e.bitangent &&
+            (M.addAttribute(n, m, D),
+            M.addAttribute(n, m, D + 3),
+            M.addAttribute(n, m, C),
+            M.addAttribute(n, m, C + 3)),
+          e.tangent &&
+            ((R = o.normalize(o.cross(m, p, R), R)),
+            M.addAttribute(s, R, D),
+            M.addAttribute(s, R, D + 3),
+            M.addAttribute(s, R, C),
+            M.addAttribute(s, R, C + 3))),
+        (C += 6));
+    }
+    if (e.normal) {
+      for (a.set(l), r = 0; r < h; r += 3)
+        ((a[r + h] = -l[r]),
+          (a[r + h + 1] = -l[r + 1]),
+          (a[r + h + 2] = -l[r + 2]));
+      t.normal.values = a;
+    } else t.normal = void 0;
+    if (
+      (e.bitangent
+        ? (n.set(d), n.set(d, h), (t.bitangent.values = n))
+        : (t.bitangent = void 0),
+      e.tangent)
+    ) {
+      let D = t.tangent.values;
+      (s.set(D), s.set(D, h), (t.tangent.values = s));
+    }
+  }
+  if (e.st) {
+    let a = t.st.values,
+      s = new Float32Array(O * 6);
+    (s.set(a), s.set(a, O));
+    let n = O * 2;
+    for (let A = 0; A < 2; A++) {
+      for (s[n++] = a[0], s[n++] = a[1], r = 2; r < O; r += 2) {
+        let u = a[r],
+          b = a[r + 1];
+        ((s[n++] = u), (s[n++] = b), (s[n++] = u), (s[n++] = b));
+      }
+      ((s[n++] = a[0]), (s[n++] = a[1]));
+    }
+    t.st.values = s;
+  }
+  return t;
+}
+function Ot(t, e, i) {
+  ((i[e++] = t[0]), (i[e++] = t[1]), (i[e++] = t[2]));
+  for (let l = 3; l < t.length; l += 3) {
+    let d = t[l],
+      f = t[l + 1],
+      h = t[l + 2];
+    ((i[e++] = d),
+      (i[e++] = f),
+      (i[e++] = h),
+      (i[e++] = d),
+      (i[e++] = f),
+      (i[e++] = h));
+  }
+  return ((i[e++] = t[0]), (i[e++] = t[1]), (i[e++] = t[2]), i);
+}
+function Jt(t, e) {
+  let i = new G({
+      position: e.position,
+      normal: e.normal || e.bitangent || t.shadowVolume,
+      tangent: e.tangent,
+      bitangent: e.normal || e.bitangent,
+      st: e.st,
+    }),
+    l = t.ellipsoid,
+    d = M.computePositions(t),
+    f = Bt(d, i, l),
+    h = t.height,
+    O = t.extrudedHeight,
+    g = f.attributes,
+    r = f.indices,
+    a = g.position.values,
+    s = a.length,
+    n = new Float64Array(s * 6),
+    A = new Float64Array(s);
+  A.set(a);
+  let u = new Float64Array(s * 4);
+  ((a = yt.scaleToGeodeticHeight(a, h, l)),
+    (u = Ot(a, 0, u)),
+    (A = yt.scaleToGeodeticHeight(A, O, l)),
+    (u = Ot(A, s * 2, u)),
+    n.set(a),
+    n.set(A, s),
+    n.set(u, s * 2),
+    (g.position.values = n),
+    (g = qt(g, e)));
+  let b,
+    p = s / 3;
+  if (t.shadowVolume) {
+    let S = g.normal.values;
+    s = S.length;
+    let V = new Float32Array(s * 6);
+    for (b = 0; b < s; b++) S[b] = -S[b];
+    (V.set(S, s),
+      (V = Ot(S, s * 4, V)),
+      (g.extrudeDirection = new x({
+        componentDatatype: F.FLOAT,
+        componentsPerAttribute: 3,
+        values: V,
+      })),
+      e.normal || (g.normal = void 0));
+  }
+  if (X(t.offsetAttribute)) {
+    let S = new Uint8Array(p * 6);
+    if (t.offsetAttribute === _t.TOP) S = S.fill(1, 0, p).fill(1, p * 2, p * 4);
+    else {
+      let V = t.offsetAttribute === _t.NONE ? 0 : 1;
+      S = S.fill(V);
+    }
+    g.applyOffset = new x({
+      componentDatatype: F.UNSIGNED_BYTE,
+      componentsPerAttribute: 1,
+      values: S,
+    });
+  }
+  let R = r.length,
+    m = p + p,
+    C = Nt.createTypedArray(n.length / 3, R * 2 + m * 3);
+  C.set(r);
+  let D = R;
+  for (b = 0; b < R; b += 3) {
+    let S = r[b],
+      V = r[b + 1],
+      H = r[b + 2];
+    ((C[D++] = H + p), (C[D++] = V + p), (C[D++] = S + p));
+  }
+  let lt, z, y, E;
+  for (b = 0; b < m; b += 2)
+    ((lt = b + m),
+      (z = lt + m),
+      (y = lt + 1),
+      (E = z + 1),
+      (C[D++] = lt),
+      (C[D++] = z),
+      (C[D++] = y),
+      (C[D++] = y),
+      (C[D++] = z),
+      (C[D++] = E));
+  return { attributes: g, indices: C };
+}
+var Dt = new o(),
+  gt = new o(),
+  Q = new bt();
+function Rt(t, e, i, l, d, f) {
+  let h = o.subtract(e, t, Dt);
+  o.normalize(h, h);
+  let O = i.geodeticSurfaceNormal(t, gt),
+    g = o.cross(h, O, Dt);
+  o.multiplyByScalar(g, l, g);
+  let r = d.latitude,
+    a = d.longitude,
+    s = f.latitude,
+    n = f.longitude;
+  (o.add(t, g, gt), i.cartesianToCartographic(gt, Q));
+  let A = Q.latitude,
+    u = Q.longitude;
+  ((r = Math.min(r, A)),
+    (a = Math.min(a, u)),
+    (s = Math.max(s, A)),
+    (n = Math.max(n, u)),
+    o.subtract(t, g, gt),
+    i.cartesianToCartographic(gt, Q),
+    (A = Q.latitude),
+    (u = Q.longitude),
+    (r = Math.min(r, A)),
+    (a = Math.min(a, u)),
+    (s = Math.max(s, A)),
+    (n = Math.max(n, u)),
+    (d.latitude = r),
+    (d.longitude = a),
+    (f.latitude = s),
+    (f.longitude = n));
+}
+var K = new o(),
+  pt = new o(),
+  W = new bt(),
+  j = new bt();
+function Yt(t, e, i, l, d) {
+  t = Ut(t, e);
+  let f = Pt(t, o.equalsEpsilon),
+    h = f.length;
+  if (h < 2 || i <= 0) return new Et();
+  let O = i * 0.5;
+  ((W.latitude = Number.POSITIVE_INFINITY),
+    (W.longitude = Number.POSITIVE_INFINITY),
+    (j.latitude = Number.NEGATIVE_INFINITY),
+    (j.longitude = Number.NEGATIVE_INFINITY));
+  let g, r;
+  if (l === ht.ROUNDED) {
+    let n = f[0];
+    (o.subtract(n, f[1], K),
+      o.normalize(K, K),
+      o.multiplyByScalar(K, O, K),
+      o.add(n, K, pt),
+      e.cartesianToCartographic(pt, Q),
+      (g = Q.latitude),
+      (r = Q.longitude),
+      (W.latitude = Math.min(W.latitude, g)),
+      (W.longitude = Math.min(W.longitude, r)),
+      (j.latitude = Math.max(j.latitude, g)),
+      (j.longitude = Math.max(j.longitude, r)));
+  }
+  for (let n = 0; n < h - 1; ++n) Rt(f[n], f[n + 1], e, O, W, j);
+  let a = f[h - 1];
+  (o.subtract(a, f[h - 2], K),
+    o.normalize(K, K),
+    o.multiplyByScalar(K, O, K),
+    o.add(a, K, pt),
+    Rt(a, pt, e, O, W, j),
+    l === ht.ROUNDED &&
+      (e.cartesianToCartographic(pt, Q),
+      (g = Q.latitude),
+      (r = Q.longitude),
+      (W.latitude = Math.min(W.latitude, g)),
+      (W.longitude = Math.min(W.longitude, r)),
+      (j.latitude = Math.max(j.latitude, g)),
+      (j.longitude = Math.max(j.longitude, r))));
+  let s = X(d) ? d : new Et();
+  return (
+    (s.north = j.latitude),
+    (s.south = W.latitude),
+    (s.east = j.longitude),
+    (s.west = W.longitude),
+    s
+  );
+}
+function et(t) {
+  t = B(t, B.EMPTY_OBJECT);
+  let e = t.positions,
+    i = t.width;
+  (it.defined("options.positions", e), it.defined("options.width", i));
+  let l = B(t.height, 0),
+    d = B(t.extrudedHeight, l);
+  ((this._positions = e),
+    (this._ellipsoid = I.clone(B(t.ellipsoid, I.default))),
+    (this._vertexFormat = G.clone(B(t.vertexFormat, G.DEFAULT))),
+    (this._width = i),
+    (this._height = Math.max(l, d)),
+    (this._extrudedHeight = Math.min(l, d)),
+    (this._cornerType = B(t.cornerType, ht.ROUNDED)),
+    (this._granularity = B(t.granularity, st.RADIANS_PER_DEGREE)),
+    (this._shadowVolume = B(t.shadowVolume, !1)),
+    (this._workerName = "createCorridorGeometry"),
+    (this._offsetAttribute = t.offsetAttribute),
+    (this._rectangle = void 0),
+    (this.packedLength =
+      1 + e.length * o.packedLength + I.packedLength + G.packedLength + 7));
+}
+et.pack = function (t, e, i) {
+  (it.defined("value", t), it.defined("array", e), (i = B(i, 0)));
+  let l = t._positions,
+    d = l.length;
+  e[i++] = d;
+  for (let f = 0; f < d; ++f, i += o.packedLength) o.pack(l[f], e, i);
+  return (
+    I.pack(t._ellipsoid, e, i),
+    (i += I.packedLength),
+    G.pack(t._vertexFormat, e, i),
+    (i += G.packedLength),
+    (e[i++] = t._width),
+    (e[i++] = t._height),
+    (e[i++] = t._extrudedHeight),
+    (e[i++] = t._cornerType),
+    (e[i++] = t._granularity),
+    (e[i++] = t._shadowVolume ? 1 : 0),
+    (e[i] = B(t._offsetAttribute, -1)),
+    e
+  );
+};
+var It = I.clone(I.UNIT_SPHERE),
+  Wt = new G(),
+  tt = {
+    positions: void 0,
+    ellipsoid: It,
+    vertexFormat: Wt,
+    width: void 0,
+    height: void 0,
+    extrudedHeight: void 0,
+    cornerType: void 0,
+    granularity: void 0,
+    shadowVolume: void 0,
+    offsetAttribute: void 0,
+  };
+et.unpack = function (t, e, i) {
+  (it.defined("array", t), (e = B(e, 0)));
+  let l = t[e++],
+    d = new Array(l);
+  for (let u = 0; u < l; ++u, e += o.packedLength) d[u] = o.unpack(t, e);
+  let f = I.unpack(t, e, It);
+  e += I.packedLength;
+  let h = G.unpack(t, e, Wt);
+  e += G.packedLength;
+  let O = t[e++],
+    g = t[e++],
+    r = t[e++],
+    a = t[e++],
+    s = t[e++],
+    n = t[e++] === 1,
+    A = t[e];
+  return X(i)
+    ? ((i._positions = d),
+      (i._ellipsoid = I.clone(f, i._ellipsoid)),
+      (i._vertexFormat = G.clone(h, i._vertexFormat)),
+      (i._width = O),
+      (i._height = g),
+      (i._extrudedHeight = r),
+      (i._cornerType = a),
+      (i._granularity = s),
+      (i._shadowVolume = n),
+      (i._offsetAttribute = A === -1 ? void 0 : A),
+      i)
+    : ((tt.positions = d),
+      (tt.width = O),
+      (tt.height = g),
+      (tt.extrudedHeight = r),
+      (tt.cornerType = a),
+      (tt.granularity = s),
+      (tt.shadowVolume = n),
+      (tt.offsetAttribute = A === -1 ? void 0 : A),
+      new et(tt));
+};
+et.computeRectangle = function (t, e) {
+  t = B(t, B.EMPTY_OBJECT);
+  let i = t.positions,
+    l = t.width;
+  (it.defined("options.positions", i), it.defined("options.width", l));
+  let d = B(t.ellipsoid, I.default),
+    f = B(t.cornerType, ht.ROUNDED);
+  return Yt(i, d, l, f, e);
+};
+et.createGeometry = function (t) {
+  let e = t._positions,
+    i = t._width,
+    l = t._ellipsoid;
+  e = Ut(e, l);
+  let d = Pt(e, o.equalsEpsilon);
+  if (d.length < 2 || i <= 0) return;
+  let f = t._height,
+    h = t._extrudedHeight,
+    O = !st.equalsEpsilon(f, h, 0, st.EPSILON2),
+    g = t._vertexFormat,
+    r = {
+      ellipsoid: l,
+      positions: d,
+      width: i,
+      cornerType: t._cornerType,
+      granularity: t._granularity,
+      saveAttributes: !0,
+    },
+    a;
+  if (O)
+    ((r.height = f),
+      (r.extrudedHeight = h),
+      (r.shadowVolume = t._shadowVolume),
+      (r.offsetAttribute = t._offsetAttribute),
+      (a = Jt(r, g)));
+  else {
+    let A = M.computePositions(r);
+    if (
+      ((a = Bt(A, g, l)),
+      (a.attributes.position.values = yt.scaleToGeodeticHeight(
+        a.attributes.position.values,
+        f,
+        l,
+      )),
+      X(t._offsetAttribute))
+    ) {
+      let u = t._offsetAttribute === _t.NONE ? 0 : 1,
+        b = a.attributes.position.values.length,
+        p = new Uint8Array(b / 3).fill(u);
+      a.attributes.applyOffset = new x({
+        componentDatatype: F.UNSIGNED_BYTE,
+        componentsPerAttribute: 1,
+        values: p,
+      });
+    }
+  }
+  let s = a.attributes,
+    n = St.fromVertices(s.position.values, void 0, 3);
+  return (
+    g.position || (a.attributes.position.values = void 0),
+    new Vt({
+      attributes: s,
+      indices: a.indices,
+      primitiveType: Mt.TRIANGLES,
+      boundingSphere: n,
+      offsetAttribute: t._offsetAttribute,
+    })
+  );
+};
+et.createShadowVolume = function (t, e, i) {
+  let l = t._granularity,
+    d = t._ellipsoid,
+    f = e(l, d),
+    h = i(l, d);
+  return new et({
+    positions: t._positions,
+    width: t._width,
+    cornerType: t._cornerType,
+    ellipsoid: d,
+    granularity: l,
+    extrudedHeight: f,
+    height: h,
+    vertexFormat: G.POSITION_ONLY,
+    shadowVolume: !0,
+  });
+};
+Object.defineProperties(et.prototype, {
+  rectangle: {
+    get: function () {
+      return (
+        X(this._rectangle) ||
+          (this._rectangle = Yt(
+            this._positions,
+            this._ellipsoid,
+            this._width,
+            this._cornerType,
+          )),
+        this._rectangle
+      );
+    },
+  },
+  textureCoordinateRotationPoints: {
+    get: function () {
+      return [0, 0, 0, 1, 1, 0];
+    },
+  },
+});
+var Lt = et;
+function Gt(t, e) {
+  return (
+    X(e) && (t = Lt.unpack(t, e)),
+    (t._ellipsoid = I.clone(t._ellipsoid)),
+    Lt.createGeometry(t)
+  );
+}
+var Ae = Gt;
+export { Ae as default };