create-swdg-frontend 0.1.0

package/template/public/Cesium1.119/Workers/chunk-W23CU777.js

@@ -0,0 +1,271 @@
+/**
+ * @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 y, b as P, d as k } from "./chunk-POASMU2N.js";
+import { a as L } from "./chunk-R6KGAEF6.js";
+import { a as B } from "./chunk-IUA6FAOZ.js";
+import { b as q } from "./chunk-UH2WFNTA.js";
+import { e as T } from "./chunk-PEYJTJPE.js";
+function Y(n) {
+  let a = n._uSquared,
+    t = n._ellipsoid.maximumRadius,
+    e = n._ellipsoid.minimumRadius,
+    f = (t - e) / t,
+    m = Math.cos(n._startHeading),
+    _ = Math.sin(n._startHeading),
+    r = (1 - f) * Math.tan(n._start.latitude),
+    p = 1 / Math.sqrt(1 + r * r),
+    R = p * r,
+    M = Math.atan2(r, m),
+    l = p * _,
+    U = l * l,
+    i = 1 - U,
+    A = Math.sqrt(i),
+    c = a / 4,
+    o = c * c,
+    h = o * c,
+    S = o * o,
+    u = 1 + c - (3 * o) / 4 + (5 * h) / 4 - (175 * S) / 64,
+    C = 1 - c + (15 * o) / 8 - (35 * h) / 8,
+    d = 1 - 3 * c + (35 * o) / 4,
+    g = 1 - 5 * c,
+    w =
+      u * M -
+      (C * Math.sin(2 * M) * c) / 2 -
+      (d * Math.sin(4 * M) * o) / 16 -
+      (g * Math.sin(6 * M) * h) / 48 -
+      (Math.sin(8 * M) * 5 * S) / 512,
+    s = n._constants;
+  ((s.a = t),
+    (s.b = e),
+    (s.f = f),
+    (s.cosineHeading = m),
+    (s.sineHeading = _),
+    (s.tanU = r),
+    (s.cosineU = p),
+    (s.sineU = R),
+    (s.sigma = M),
+    (s.sineAlpha = l),
+    (s.sineSquaredAlpha = U),
+    (s.cosineSquaredAlpha = i),
+    (s.cosineAlpha = A),
+    (s.u2Over4 = c),
+    (s.u4Over16 = o),
+    (s.u6Over64 = h),
+    (s.u8Over256 = S),
+    (s.a0 = u),
+    (s.a1 = C),
+    (s.a2 = d),
+    (s.a3 = g),
+    (s.distanceRatio = w));
+}
+function Z(n, a) {
+  return (n * a * (4 + n * (4 - 3 * a))) / 16;
+}
+function N(n, a, t, e, f, m, _) {
+  let r = Z(n, t);
+  return (1 - r) * n * a * (e + r * f * (_ + r * m * (2 * _ * _ - 1)));
+}
+function $(n, a, t, e, f, m, _) {
+  let r = (a - t) / a,
+    p = m - e,
+    R = Math.atan((1 - r) * Math.tan(f)),
+    M = Math.atan((1 - r) * Math.tan(_)),
+    l = Math.cos(R),
+    U = Math.sin(R),
+    i = Math.cos(M),
+    A = Math.sin(M),
+    c = l * i,
+    o = l * A,
+    h = U * A,
+    S = U * i,
+    u = p,
+    C = L.TWO_PI,
+    d = Math.cos(u),
+    g = Math.sin(u),
+    w,
+    s,
+    O,
+    H,
+    b;
+  do {
+    ((d = Math.cos(u)), (g = Math.sin(u)));
+    let z = o - S * d;
+    ((O = Math.sqrt(i * i * g * g + z * z)),
+      (s = h + c * d),
+      (w = Math.atan2(O, s)));
+    let D;
+    (O === 0 ? ((D = 0), (H = 1)) : ((D = (c * g) / O), (H = 1 - D * D)),
+      (C = u),
+      (b = s - (2 * h) / H),
+      isFinite(b) || (b = 0),
+      (u = p + N(r, D, H, w, O, s, b)));
+  } while (Math.abs(u - C) > L.EPSILON12);
+  let v = (H * (a * a - t * t)) / (t * t),
+    W = 1 + (v * (4096 + v * (v * (320 - 175 * v) - 768))) / 16384,
+    I = (v * (256 + v * (v * (74 - 47 * v) - 128))) / 1024,
+    F = b * b,
+    J =
+      I *
+      O *
+      (b +
+        (I * (s * (2 * F - 1) - (I * b * (4 * O * O - 3) * (4 * F - 3)) / 6)) /
+          4),
+    K = t * W * (w - J),
+    Q = Math.atan2(i * g, o - S * d),
+    X = Math.atan2(l * g, o * d - S);
+  ((n._distance = K),
+    (n._startHeading = Q),
+    (n._endHeading = X),
+    (n._uSquared = v));
+}
+var j = new y(),
+  x = new y();
+function V(n, a, t, e) {
+  let f = y.normalize(e.cartographicToCartesian(a, x), j),
+    m = y.normalize(e.cartographicToCartesian(t, x), x);
+  (q.typeOf.number.greaterThanOrEquals(
+    "value",
+    Math.abs(Math.abs(y.angleBetween(f, m)) - Math.PI),
+    0.0125,
+  ),
+    $(
+      n,
+      e.maximumRadius,
+      e.minimumRadius,
+      a.longitude,
+      a.latitude,
+      t.longitude,
+      t.latitude,
+    ),
+    (n._start = P.clone(a, n._start)),
+    (n._end = P.clone(t, n._end)),
+    (n._start.height = 0),
+    (n._end.height = 0),
+    Y(n));
+}
+function E(n, a, t) {
+  let e = B(t, k.default);
+  ((this._ellipsoid = e),
+    (this._start = new P()),
+    (this._end = new P()),
+    (this._constants = {}),
+    (this._startHeading = void 0),
+    (this._endHeading = void 0),
+    (this._distance = void 0),
+    (this._uSquared = void 0),
+    T(n) && T(a) && V(this, n, a, e));
+}
+Object.defineProperties(E.prototype, {
+  ellipsoid: {
+    get: function () {
+      return this._ellipsoid;
+    },
+  },
+  surfaceDistance: {
+    get: function () {
+      return (q.defined("distance", this._distance), this._distance);
+    },
+  },
+  start: {
+    get: function () {
+      return this._start;
+    },
+  },
+  end: {
+    get: function () {
+      return this._end;
+    },
+  },
+  startHeading: {
+    get: function () {
+      return (q.defined("distance", this._distance), this._startHeading);
+    },
+  },
+  endHeading: {
+    get: function () {
+      return (q.defined("distance", this._distance), this._endHeading);
+    },
+  },
+});
+E.prototype.setEndPoints = function (n, a) {
+  (q.defined("start", n), q.defined("end", a), V(this, n, a, this._ellipsoid));
+};
+E.prototype.interpolateUsingFraction = function (n, a) {
+  return this.interpolateUsingSurfaceDistance(this._distance * n, a);
+};
+E.prototype.interpolateUsingSurfaceDistance = function (n, a) {
+  q.defined("distance", this._distance);
+  let t = this._constants,
+    e = t.distanceRatio + n / t.b,
+    f = Math.cos(2 * e),
+    m = Math.cos(4 * e),
+    _ = Math.cos(6 * e),
+    r = Math.sin(2 * e),
+    p = Math.sin(4 * e),
+    R = Math.sin(6 * e),
+    M = Math.sin(8 * e),
+    l = e * e,
+    U = e * l,
+    i = t.u8Over256,
+    A = t.u2Over4,
+    c = t.u6Over64,
+    o = t.u4Over16,
+    h =
+      (2 * U * i * f) / 3 +
+      e *
+        (1 -
+          A +
+          (7 * o) / 4 -
+          (15 * c) / 4 +
+          (579 * i) / 64 -
+          (o - (15 * c) / 4 + (187 * i) / 16) * f -
+          ((5 * c) / 4 - (115 * i) / 16) * m -
+          (29 * i * _) / 16) +
+      (A / 2 - o + (71 * c) / 32 - (85 * i) / 16) * r +
+      ((5 * o) / 16 - (5 * c) / 4 + (383 * i) / 96) * p -
+      l * ((c - (11 * i) / 2) * r + (5 * i * p) / 2) +
+      ((29 * c) / 96 - (29 * i) / 16) * R +
+      (539 * i * M) / 1536,
+    S = Math.asin(Math.sin(h) * t.cosineAlpha),
+    u = Math.atan((t.a / t.b) * Math.tan(S));
+  h = h - t.sigma;
+  let C = Math.cos(2 * t.sigma + h),
+    d = Math.sin(h),
+    g = Math.cos(h),
+    w = t.cosineU * g,
+    s = t.sineU * d,
+    H =
+      Math.atan2(d * t.sineHeading, w - s * t.cosineHeading) -
+      N(t.f, t.sineAlpha, t.cosineSquaredAlpha, h, d, g, C);
+  return T(a)
+    ? ((a.longitude = this._start.longitude + H),
+      (a.latitude = u),
+      (a.height = 0),
+      a)
+    : new P(this._start.longitude + H, u, 0);
+};
+var ct = E;
+export { ct as a };

package/template/public/Cesium1.119/Workers/chunk-X5IHHI6X.js

@@ -0,0 +1,173 @@
+/**
+ * @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 { b as l, f as O, g as R, h as G, i as L } from "./chunk-7Z5IIKOJ.js";
+import { a as A, b as h, c as a, e as y } from "./chunk-POASMU2N.js";
+import { a as c } from "./chunk-3C7WC463.js";
+import { a as s } from "./chunk-IUA6FAOZ.js";
+import { a as N, b as w } from "./chunk-UH2WFNTA.js";
+import { e as I } from "./chunk-PEYJTJPE.js";
+var U = { NONE: 0, TRIANGLES: 1, LINES: 2, POLYLINES: 3 },
+  M = Object.freeze(U);
+var r = {
+  POINTS: c.POINTS,
+  LINES: c.LINES,
+  LINE_LOOP: c.LINE_LOOP,
+  LINE_STRIP: c.LINE_STRIP,
+  TRIANGLES: c.TRIANGLES,
+  TRIANGLE_STRIP: c.TRIANGLE_STRIP,
+  TRIANGLE_FAN: c.TRIANGLE_FAN,
+};
+r.isLines = function (t) {
+  return t === r.LINES || t === r.LINE_LOOP || t === r.LINE_STRIP;
+};
+r.isTriangles = function (t) {
+  return t === r.TRIANGLES || t === r.TRIANGLE_STRIP || t === r.TRIANGLE_FAN;
+};
+r.validate = function (t) {
+  return (
+    t === r.POINTS ||
+    t === r.LINES ||
+    t === r.LINE_LOOP ||
+    t === r.LINE_STRIP ||
+    t === r.TRIANGLES ||
+    t === r.TRIANGLE_STRIP ||
+    t === r.TRIANGLE_FAN
+  );
+};
+var F = Object.freeze(r);
+function _(t) {
+  ((t = s(t, s.EMPTY_OBJECT)),
+    w.typeOf.object("options.attributes", t.attributes),
+    (this.attributes = t.attributes),
+    (this.indices = t.indices),
+    (this.primitiveType = s(t.primitiveType, F.TRIANGLES)),
+    (this.boundingSphere = t.boundingSphere),
+    (this.geometryType = s(t.geometryType, M.NONE)),
+    (this.boundingSphereCV = t.boundingSphereCV),
+    (this.offsetAttribute = t.offsetAttribute));
+}
+_.computeNumberOfVertices = function (t) {
+  w.typeOf.object("geometry", t);
+  let m = -1;
+  for (let u in t.attributes)
+    if (
+      t.attributes.hasOwnProperty(u) &&
+      I(t.attributes[u]) &&
+      I(t.attributes[u].values)
+    ) {
+      let o = t.attributes[u],
+        e = o.values.length / o.componentsPerAttribute;
+      if (m !== e && m !== -1)
+        throw new N(
+          "All attribute lists must have the same number of attributes.",
+        );
+      m = e;
+    }
+  return m;
+};
+var W = new h(),
+  H = new A(),
+  V = new l(),
+  Z = [new h(), new h(), new h()],
+  K = [new a(), new a(), new a()],
+  $ = [new a(), new a(), new a()],
+  tt = new A(),
+  et = new O(),
+  rt = new l(),
+  nt = new L();
+_._textureCoordinateRotationPoints = function (t, m, u, o) {
+  let e,
+    g = G.center(o, W),
+    D = h.toCartesian(g, u, H),
+    Y = R.eastNorthUpToFixedFrame(D, u, V),
+    C = l.inverse(Y, V),
+    b = K,
+    f = Z;
+  ((f[0].longitude = o.west),
+    (f[0].latitude = o.south),
+    (f[1].longitude = o.west),
+    (f[1].latitude = o.north),
+    (f[2].longitude = o.east),
+    (f[2].latitude = o.south));
+  let n = tt;
+  for (e = 0; e < 3; e++)
+    (h.toCartesian(f[e], u, n),
+      (n = l.multiplyByPointAsVector(C, n, n)),
+      (b[e].x = n.x),
+      (b[e].y = n.y));
+  let B = O.fromAxisAngle(A.UNIT_Z, -m, et),
+    v = y.fromQuaternion(B, rt),
+    j = t.length,
+    T = Number.POSITIVE_INFINITY,
+    p = Number.POSITIVE_INFINITY,
+    d = Number.NEGATIVE_INFINITY,
+    x = Number.NEGATIVE_INFINITY;
+  for (e = 0; e < j; e++)
+    ((n = l.multiplyByPointAsVector(C, t[e], n)),
+      (n = y.multiplyByVector(v, n, n)),
+      (T = Math.min(T, n.x)),
+      (p = Math.min(p, n.y)),
+      (d = Math.max(d, n.x)),
+      (x = Math.max(x, n.y)));
+  let k = L.fromRotation(m, nt),
+    i = $;
+  ((i[0].x = T),
+    (i[0].y = p),
+    (i[1].x = T),
+    (i[1].y = x),
+    (i[2].x = d),
+    (i[2].y = p));
+  let P = b[0],
+    z = b[2].x - P.x,
+    X = b[1].y - P.y;
+  for (e = 0; e < 3; e++) {
+    let E = i[e];
+    (L.multiplyByVector(k, E, E),
+      (E.x = (E.x - P.x) / z),
+      (E.y = (E.y - P.y) / X));
+  }
+  let q = i[0],
+    J = i[1],
+    Q = i[2],
+    S = new Array(6);
+  return (a.pack(q, S), a.pack(J, S, 2), a.pack(Q, S, 4), S);
+};
+var Lt = _;
+function ot(t) {
+  if (((t = s(t, s.EMPTY_OBJECT)), !I(t.componentDatatype)))
+    throw new N("options.componentDatatype is required.");
+  if (!I(t.componentsPerAttribute))
+    throw new N("options.componentsPerAttribute is required.");
+  if (t.componentsPerAttribute < 1 || t.componentsPerAttribute > 4)
+    throw new N("options.componentsPerAttribute must be between 1 and 4.");
+  if (!I(t.values)) throw new N("options.values is required.");
+  ((this.componentDatatype = t.componentDatatype),
+    (this.componentsPerAttribute = t.componentsPerAttribute),
+    (this.normalize = s(t.normalize, !1)),
+    (this.values = t.values));
+}
+var Ot = ot;
+export { M as a, F as b, Lt as c, Ot as d };

package/template/public/Cesium1.119/Workers/chunk-XHX2UPDO.js

@@ -0,0 +1,217 @@
+/**
+ * @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 z, c as q } from "./chunk-K4ASOM65.js";
+import { a as U } from "./chunk-AMQUWUD4.js";
+import { f as I } from "./chunk-7Z5IIKOJ.js";
+import { a as e, e as C } from "./chunk-POASMU2N.js";
+import { a as O } from "./chunk-R6KGAEF6.js";
+import { e as j } from "./chunk-PEYJTJPE.js";
+var G = {},
+  B = new e(),
+  J = new e(),
+  _ = new e(),
+  v = new e(),
+  g = [new e(), new e()],
+  K = new e(),
+  W = new e(),
+  X = new e(),
+  $ = new e(),
+  ee = new e(),
+  te = new e(),
+  ne = new e(),
+  oe = new e(),
+  re = new e(),
+  se = new e(),
+  F = new I(),
+  k = new C();
+function V(o, s, a, c, r) {
+  let d = e.angleBetween(e.subtract(s, o, B), e.subtract(a, o, J)),
+    y = c === z.BEVELED ? 1 : Math.ceil(d / O.toRadians(5)) + 1,
+    n = y * 3,
+    l = new Array(n);
+  ((l[n - 3] = a.x), (l[n - 2] = a.y), (l[n - 1] = a.z));
+  let m;
+  r
+    ? (m = C.fromQuaternion(I.fromAxisAngle(e.negate(o, B), d / y, F), k))
+    : (m = C.fromQuaternion(I.fromAxisAngle(o, d / y, F), k));
+  let t = 0;
+  s = e.clone(s, B);
+  for (let i = 0; i < y; i++)
+    ((s = C.multiplyByVector(m, s, s)),
+      (l[t++] = s.x),
+      (l[t++] = s.y),
+      (l[t++] = s.z));
+  return l;
+}
+function ae(o) {
+  let s = K,
+    a = W,
+    c = X,
+    r = o[1];
+  ((a = e.fromArray(o[1], r.length - 3, a)),
+    (c = e.fromArray(o[0], 0, c)),
+    (s = e.midpoint(a, c, s)));
+  let d = V(s, a, c, z.ROUNDED, !1),
+    y = o.length - 1,
+    n = o[y - 1];
+  ((r = o[y]),
+    (a = e.fromArray(n, n.length - 3, a)),
+    (c = e.fromArray(r, 0, c)),
+    (s = e.midpoint(a, c, s)));
+  let l = V(s, a, c, z.ROUNDED, !1);
+  return [d, l];
+}
+function H(o, s, a, c) {
+  let r = B;
+  return (
+    c ? (r = e.add(o, s, r)) : ((s = e.negate(s, s)), (r = e.add(o, s, r))),
+    [r.x, r.y, r.z, a.x, a.y, a.z]
+  );
+}
+function T(o, s, a, c) {
+  let r = new Array(o.length),
+    d = new Array(o.length),
+    y = e.multiplyByScalar(s, a, B),
+    n = e.negate(y, J),
+    l = 0,
+    m = o.length - 1;
+  for (let t = 0; t < o.length; t += 3) {
+    let i = e.fromArray(o, t, _),
+      w = e.add(i, n, v);
+    ((r[l++] = w.x), (r[l++] = w.y), (r[l++] = w.z));
+    let f = e.add(i, y, v);
+    ((d[m--] = f.z), (d[m--] = f.y), (d[m--] = f.x));
+  }
+  return (c.push(r, d), c);
+}
+G.addAttribute = function (o, s, a, c) {
+  let r = s.x,
+    d = s.y,
+    y = s.z;
+  (j(a) && ((o[a] = r), (o[a + 1] = d), (o[a + 2] = y)),
+    j(c) && ((o[c] = y), (o[c - 1] = d), (o[c - 2] = r)));
+};
+var le = new e(),
+  ce = new e();
+G.computePositions = function (o) {
+  let s = o.granularity,
+    a = o.positions,
+    c = o.ellipsoid,
+    r = o.width / 2,
+    d = o.cornerType,
+    y = o.saveAttributes,
+    n = K,
+    l = W,
+    m = X,
+    t = $,
+    i = ee,
+    w = te,
+    f = ne,
+    u = oe,
+    p = re,
+    x = se,
+    E = [],
+    S = y ? [] : void 0,
+    D = y ? [] : void 0,
+    h = a[0],
+    N = a[1];
+  ((l = e.normalize(e.subtract(N, h, l), l)),
+    (n = c.geodeticSurfaceNormal(h, n)),
+    (t = e.normalize(e.cross(n, l, t), t)),
+    y && (S.push(t.x, t.y, t.z), D.push(n.x, n.y, n.z)),
+    (f = e.clone(h, f)),
+    (h = N),
+    (m = e.negate(l, m)));
+  let A,
+    P = [],
+    M,
+    Y = a.length;
+  for (M = 1; M < Y - 1; M++) {
+    ((n = c.geodeticSurfaceNormal(h, n)),
+      (N = a[M + 1]),
+      (l = e.normalize(e.subtract(N, h, l), l)),
+      (i = e.normalize(e.add(l, m, i), i)));
+    let L = e.multiplyByScalar(n, e.dot(l, n), le);
+    (e.subtract(l, L, L), e.normalize(L, L));
+    let R = e.multiplyByScalar(n, e.dot(m, n), ce);
+    if (
+      (e.subtract(m, R, R),
+      e.normalize(R, R),
+      !O.equalsEpsilon(Math.abs(e.dot(L, R)), 1, O.EPSILON7))
+    ) {
+      ((i = e.cross(i, n, i)), (i = e.cross(n, i, i)), (i = e.normalize(i, i)));
+      let Z = r / Math.max(0.25, e.magnitude(e.cross(i, m, B))),
+        b = q.angleIsGreaterThanPi(l, m, h, c);
+      ((i = e.multiplyByScalar(i, Z, i)),
+        b
+          ? ((u = e.add(h, i, u)),
+            (x = e.add(u, e.multiplyByScalar(t, r, x), x)),
+            (p = e.add(u, e.multiplyByScalar(t, r * 2, p), p)),
+            (g[0] = e.clone(f, g[0])),
+            (g[1] = e.clone(x, g[1])),
+            (A = U.generateArc({ positions: g, granularity: s, ellipsoid: c })),
+            (E = T(A, t, r, E)),
+            y && (S.push(t.x, t.y, t.z), D.push(n.x, n.y, n.z)),
+            (w = e.clone(p, w)),
+            (t = e.normalize(e.cross(n, l, t), t)),
+            (p = e.add(u, e.multiplyByScalar(t, r * 2, p), p)),
+            (f = e.add(u, e.multiplyByScalar(t, r, f), f)),
+            d === z.ROUNDED || d === z.BEVELED
+              ? P.push({ leftPositions: V(u, w, p, d, b) })
+              : P.push({ leftPositions: H(h, e.negate(i, i), p, b) }))
+          : ((p = e.add(h, i, p)),
+            (x = e.add(p, e.negate(e.multiplyByScalar(t, r, x), x), x)),
+            (u = e.add(p, e.negate(e.multiplyByScalar(t, r * 2, u), u), u)),
+            (g[0] = e.clone(f, g[0])),
+            (g[1] = e.clone(x, g[1])),
+            (A = U.generateArc({ positions: g, granularity: s, ellipsoid: c })),
+            (E = T(A, t, r, E)),
+            y && (S.push(t.x, t.y, t.z), D.push(n.x, n.y, n.z)),
+            (w = e.clone(u, w)),
+            (t = e.normalize(e.cross(n, l, t), t)),
+            (u = e.add(p, e.negate(e.multiplyByScalar(t, r * 2, u), u), u)),
+            (f = e.add(p, e.negate(e.multiplyByScalar(t, r, f), f), f)),
+            d === z.ROUNDED || d === z.BEVELED
+              ? P.push({ rightPositions: V(p, w, u, d, b) })
+              : P.push({ rightPositions: H(h, i, u, b) })),
+        (m = e.negate(l, m)));
+    }
+    h = N;
+  }
+  ((n = c.geodeticSurfaceNormal(h, n)),
+    (g[0] = e.clone(f, g[0])),
+    (g[1] = e.clone(h, g[1])),
+    (A = U.generateArc({ positions: g, granularity: s, ellipsoid: c })),
+    (E = T(A, t, r, E)),
+    y && (S.push(t.x, t.y, t.z), D.push(n.x, n.y, n.z)));
+  let Q;
+  return (
+    d === z.ROUNDED && (Q = ae(E)),
+    { positions: E, corners: P, lefts: S, normals: D, endPositions: Q }
+  );
+};
+var we = G;
+export { we as a };

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

@@ -0,0 +1,53 @@
+/**
+ * @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 e } from "./chunk-FKRG4HDY.js";
+import { a as r } from "./chunk-PXCJYT2S.js";
+import "./chunk-SB224QGV.js";
+import "./chunk-QB3MDM4J.js";
+import "./chunk-ABGXSJNX.js";
+import "./chunk-DQO6B4EQ.js";
+import "./chunk-TAMCUKAR.js";
+import "./chunk-PDMQLSBL.js";
+import "./chunk-P37AI2DW.js";
+import "./chunk-T6BE4RZK.js";
+import "./chunk-X5IHHI6X.js";
+import "./chunk-TMSETF7M.js";
+import "./chunk-7Z5IIKOJ.js";
+import "./chunk-KZNJOCYU.js";
+import "./chunk-POASMU2N.js";
+import "./chunk-R6KGAEF6.js";
+import "./chunk-3C7WC463.js";
+import "./chunk-II4VNKYR.js";
+import "./chunk-IUA6FAOZ.js";
+import "./chunk-UH2WFNTA.js";
+import "./chunk-PEYJTJPE.js";
+function n(o, t) {
+  let m = e.unpackCombineGeometryParameters(o),
+    i = e.combineGeometry(m);
+  return e.packCombineGeometryResults(i, t);
+}
+var c = r(n);
+export { c as default };