create-swdg-frontend 0.1.7 → 0.2.0

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

@@ -1,830 +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 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 };