create-swdg-frontend 0.1.0

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

@@ -0,0 +1,331 @@
+/**
+ * @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 _ } from "./chunk-AMQUWUD4.js";
+import { a as te } from "./chunk-KF5NF354.js";
+import { a as fe, b as j, f as Z, g as me } from "./chunk-7Z5IIKOJ.js";
+import { a as e, b as ie, c as ee, e as O } from "./chunk-POASMU2N.js";
+import { a as Q } from "./chunk-R6KGAEF6.js";
+import { a as se } from "./chunk-IUA6FAOZ.js";
+import { a as le } from "./chunk-UH2WFNTA.js";
+import { e as $ } from "./chunk-PEYJTJPE.js";
+var Se = { ROUNDED: 0, MITERED: 1, BEVELED: 2 },
+  G = Object.freeze(Se);
+var ue = {};
+function P(r, n) {
+  if (!$(r)) throw new le("identifier is required.");
+  $(ue[r]) || ((ue[r] = !0), console.warn(se(n, r)));
+}
+P.geometryOutlines =
+  "Entity geometry outlines are unsupported on terrain. Outlines will be disabled. To enable outlines, disable geometry terrain clamping by explicitly setting height to 0.";
+P.geometryZIndex =
+  "Entity geometry with zIndex are unsupported when height or extrudedHeight are defined.  zIndex will be ignored";
+P.geometryHeightReference =
+  "Entity corridor, ellipse, polygon or rectangle with heightReference must also have a defined height.  heightReference will be ignored";
+P.geometryExtrudedHeightReference =
+  "Entity corridor, ellipse, polygon or rectangle with extrudedHeightReference must also have a defined extrudedHeight.  extrudedHeightReference will be ignored";
+var he = P;
+var w = [new e(), new e()],
+  Te = new e(),
+  Be = new e(),
+  Ce = new e(),
+  ze = new e(),
+  Ae = new e(),
+  be = new e(),
+  Oe = new e(),
+  ve = new e(),
+  De = new e(),
+  I = new e(),
+  W = new e(),
+  R = {},
+  re = new ie();
+function je(r, n) {
+  let a = new Array(r.length);
+  for (let o = 0; o < r.length; o++) {
+    let t = r[o];
+    ((re = n.cartesianToCartographic(t, re)),
+      (a[o] = re.height),
+      (r[o] = n.scaleToGeodeticSurface(t, t)));
+  }
+  return a;
+}
+function ne(r, n, a, o) {
+  let t = r[0],
+    c = r[1],
+    f = e.angleBetween(t, c),
+    l = Math.ceil(f / o),
+    m = new Array(l),
+    s;
+  if (n === a) {
+    for (s = 0; s < l; s++) m[s] = n;
+    return (m.push(a), m);
+  }
+  let d = (a - n) / l;
+  for (s = 1; s < l; s++) {
+    let x = n + s * d;
+    m[s] = x;
+  }
+  return ((m[0] = n), m.push(a), m);
+}
+var X = new e(),
+  Y = new e();
+function He(r, n, a, o) {
+  let t = new te(a, o),
+    c = t.projectPointOntoPlane(e.add(a, r, X), X),
+    f = t.projectPointOntoPlane(e.add(a, n, Y), Y),
+    l = ee.angleBetween(c, f);
+  return f.x * c.y - f.y * c.x >= 0 ? -l : l;
+}
+var Me = new e(-1, 0, 0),
+  H = new j(),
+  Ve = new j(),
+  oe = new O(),
+  Ne = O.IDENTITY.clone(),
+  Fe = new e(),
+  Ge = new fe(),
+  de = new e();
+function v(r, n, a, o, t, c, f, l) {
+  let m = Fe,
+    s = Ge;
+  ((H = me.eastNorthUpToFixedFrame(r, t, H)),
+    (m = j.multiplyByPointAsVector(H, Me, m)),
+    (m = e.normalize(m, m)));
+  let S = He(m, n, r, t);
+  ((oe = O.fromRotationZ(S, oe)),
+    (de.z = c),
+    (H = j.multiplyTransformation(
+      H,
+      j.fromRotationTranslation(oe, de, Ve),
+      H,
+    )));
+  let d = Ne;
+  d[0] = f;
+  for (let x = 0; x < l; x++)
+    for (let i = 0; i < a.length; i += 3)
+      ((s = e.fromArray(a, i, s)),
+        (s = O.multiplyByVector(d, s, s)),
+        (s = j.multiplyByPoint(H, s, s)),
+        o.push(s.x, s.y, s.z));
+  return o;
+}
+var Ie = new e();
+function ce(r, n, a, o, t, c, f) {
+  for (let l = 0; l < r.length; l += 3) {
+    let m = e.fromArray(r, l, Ie);
+    o = v(m, n, a, o, t, c[l / 3], f, 1);
+  }
+  return o;
+}
+function Le(r, n) {
+  let a = r.length,
+    o = new Array(a * 6),
+    t = 0,
+    c = n.x + n.width / 2,
+    f = n.y + n.height / 2,
+    l = r[0];
+  ((o[t++] = l.x - c), (o[t++] = 0), (o[t++] = l.y - f));
+  for (let m = 1; m < a; m++) {
+    l = r[m];
+    let s = l.x - c,
+      S = l.y - f;
+    ((o[t++] = s),
+      (o[t++] = 0),
+      (o[t++] = S),
+      (o[t++] = s),
+      (o[t++] = 0),
+      (o[t++] = S));
+  }
+  return ((l = r[0]), (o[t++] = l.x - c), (o[t++] = 0), (o[t++] = l.y - f), o);
+}
+function ge(r, n) {
+  let a = r.length,
+    o = new Array(a * 3),
+    t = 0,
+    c = n.x + n.width / 2,
+    f = n.y + n.height / 2;
+  for (let l = 0; l < a; l++)
+    ((o[t++] = r[l].x - c), (o[t++] = 0), (o[t++] = r[l].y - f));
+  return o;
+}
+var ye = new Z(),
+  we = new e(),
+  pe = new O();
+function xe(r, n, a, o, t, c, f, l, m, s) {
+  let S = e.angleBetween(e.subtract(n, r, I), e.subtract(a, r, W)),
+    d = o === G.BEVELED ? 0 : Math.ceil(S / Q.toRadians(5)),
+    x;
+  t
+    ? (x = O.fromQuaternion(
+        Z.fromAxisAngle(e.negate(r, I), S / (d + 1), ye),
+        pe,
+      ))
+    : (x = O.fromQuaternion(Z.fromAxisAngle(r, S / (d + 1), ye), pe));
+  let i, g;
+  if (((n = e.clone(n, we)), d > 0)) {
+    let D = s ? 2 : 1;
+    for (let y = 0; y < d; y++)
+      ((n = O.multiplyByVector(x, n, n)),
+        (i = e.subtract(n, r, I)),
+        (i = e.normalize(i, i)),
+        t || (i = e.negate(i, i)),
+        (g = c.scaleToGeodeticSurface(n, W)),
+        (f = v(g, i, l, f, c, m, 1, D)));
+  } else
+    ((i = e.subtract(n, r, I)),
+      (i = e.normalize(i, i)),
+      t || (i = e.negate(i, i)),
+      (g = c.scaleToGeodeticSurface(n, W)),
+      (f = v(g, i, l, f, c, m, 1, 1)),
+      (a = e.clone(a, we)),
+      (i = e.subtract(a, r, I)),
+      (i = e.normalize(i, i)),
+      t || (i = e.negate(i, i)),
+      (g = c.scaleToGeodeticSurface(a, W)),
+      (f = v(g, i, l, f, c, m, 1, 1)));
+  return f;
+}
+R.removeDuplicatesFromShape = function (r) {
+  let n = r.length,
+    a = [];
+  for (let o = n - 1, t = 0; t < n; o = t++) {
+    let c = r[o],
+      f = r[t];
+    ee.equals(c, f) || a.push(f);
+  }
+  return a;
+};
+R.angleIsGreaterThanPi = function (r, n, a, o) {
+  let t = new te(a, o),
+    c = t.projectPointOntoPlane(e.add(a, r, X), X),
+    f = t.projectPointOntoPlane(e.add(a, n, Y), Y);
+  return f.x * c.y - f.y * c.x >= 0;
+};
+var qe = new e(),
+  Pe = new e();
+R.computePositions = function (r, n, a, o, t) {
+  let c = o._ellipsoid,
+    f = je(r, c),
+    l = o._granularity,
+    m = o._cornerType,
+    s = t ? Le(n, a) : ge(n, a),
+    S = t ? ge(n, a) : void 0,
+    d = a.height / 2,
+    x = a.width / 2,
+    i = r.length,
+    g = [],
+    D = t ? [] : void 0,
+    y = Te,
+    b = Be,
+    h = Ce,
+    E = ze,
+    B = Ae,
+    C = be,
+    z = Oe,
+    u = ve,
+    T = De,
+    p = r[0],
+    M = r[1];
+  ((E = c.geodeticSurfaceNormal(p, E)),
+    (y = e.subtract(M, p, y)),
+    (y = e.normalize(y, y)),
+    (u = e.cross(E, y, u)),
+    (u = e.normalize(u, u)));
+  let V = f[0],
+    A = f[1];
+  (t && (D = v(p, u, S, D, c, V + d, 1, 1)),
+    (T = e.clone(p, T)),
+    (p = M),
+    (b = e.negate(y, b)));
+  let N, F;
+  for (let U = 1; U < i - 1; U++) {
+    let ae = t ? 2 : 1;
+    if (((M = r[U + 1]), p.equals(M))) {
+      he(
+        "Positions are too close and are considered equivalent with rounding error.",
+      );
+      continue;
+    }
+    ((y = e.subtract(M, p, y)),
+      (y = e.normalize(y, y)),
+      (h = e.add(y, b, h)),
+      (h = e.normalize(h, h)),
+      (E = c.geodeticSurfaceNormal(p, E)));
+    let L = e.multiplyByScalar(E, e.dot(y, E), qe);
+    (e.subtract(y, L, L), e.normalize(L, L));
+    let q = e.multiplyByScalar(E, e.dot(b, E), Pe);
+    if (
+      (e.subtract(b, q, q),
+      e.normalize(q, q),
+      !Q.equalsEpsilon(Math.abs(e.dot(L, q)), 1, Q.EPSILON7))
+    ) {
+      ((h = e.cross(h, E, h)), (h = e.cross(E, h, h)), (h = e.normalize(h, h)));
+      let k = 1 / Math.max(0.25, e.magnitude(e.cross(h, b, I))),
+        K = R.angleIsGreaterThanPi(y, b, p, c);
+      (K
+        ? ((B = e.add(p, e.multiplyByScalar(h, k * x, h), B)),
+          (C = e.add(B, e.multiplyByScalar(u, x, C), C)),
+          (w[0] = e.clone(T, w[0])),
+          (w[1] = e.clone(C, w[1])),
+          (N = ne(w, V + d, A + d, l)),
+          (F = _.generateArc({ positions: w, granularity: l, ellipsoid: c })),
+          (g = ce(F, u, s, g, c, N, 1)),
+          (u = e.cross(E, y, u)),
+          (u = e.normalize(u, u)),
+          (z = e.add(B, e.multiplyByScalar(u, x, z), z)),
+          m === G.ROUNDED || m === G.BEVELED
+            ? xe(B, C, z, m, K, c, g, s, A + d, t)
+            : ((h = e.negate(h, h)), (g = v(p, h, s, g, c, A + d, k, ae))),
+          (T = e.clone(z, T)))
+        : ((B = e.add(p, e.multiplyByScalar(h, k * x, h), B)),
+          (C = e.add(B, e.multiplyByScalar(u, -x, C), C)),
+          (w[0] = e.clone(T, w[0])),
+          (w[1] = e.clone(C, w[1])),
+          (N = ne(w, V + d, A + d, l)),
+          (F = _.generateArc({ positions: w, granularity: l, ellipsoid: c })),
+          (g = ce(F, u, s, g, c, N, 1)),
+          (u = e.cross(E, y, u)),
+          (u = e.normalize(u, u)),
+          (z = e.add(B, e.multiplyByScalar(u, -x, z), z)),
+          m === G.ROUNDED || m === G.BEVELED
+            ? xe(B, C, z, m, K, c, g, s, A + d, t)
+            : (g = v(p, h, s, g, c, A + d, k, ae)),
+          (T = e.clone(z, T))),
+        (b = e.negate(y, b)));
+    } else ((g = v(T, u, s, g, c, V + d, 1, 1)), (T = p));
+    ((V = A), (A = f[U + 1]), (p = M));
+  }
+  ((w[0] = e.clone(T, w[0])),
+    (w[1] = e.clone(p, w[1])),
+    (N = ne(w, V + d, A + d, l)),
+    (F = _.generateArc({ positions: w, granularity: l, ellipsoid: c })),
+    (g = ce(F, u, s, g, c, N, 1)),
+    t && (D = v(p, u, S, D, c, A + d, 1, 1)),
+    (i = g.length));
+  let Ee = t ? i + D.length : i,
+    J = new Float64Array(Ee);
+  return (J.set(g), t && J.set(D, i), J);
+};
+var lt = R;
+export { G as a, he as b, lt as c };

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

@@ -0,0 +1,258 @@
+/**
+ * @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 W } from "./chunk-ILGBPNP6.js";
+import { a as Z } from "./chunk-P37AI2DW.js";
+import { a as X } from "./chunk-T6BE4RZK.js";
+import { b as K, c as Q, d as V } from "./chunk-X5IHHI6X.js";
+import { d as H } from "./chunk-TMSETF7M.js";
+import { a as U } from "./chunk-KZNJOCYU.js";
+import { a as r, d as J } from "./chunk-POASMU2N.js";
+import { a as B } from "./chunk-R6KGAEF6.js";
+import { a as u } from "./chunk-IUA6FAOZ.js";
+import { a as P } from "./chunk-UH2WFNTA.js";
+import { e as T } from "./chunk-PEYJTJPE.js";
+var ii = new r(1, 1, 1),
+  S = Math.cos,
+  q = Math.sin;
+function x(t) {
+  t = u(t, u.EMPTY_OBJECT);
+  let o = u(t.radii, ii),
+    n = u(t.innerRadii, o),
+    k = u(t.minimumClock, 0),
+    w = u(t.maximumClock, B.TWO_PI),
+    d = u(t.minimumCone, 0),
+    l = u(t.maximumCone, B.PI),
+    s = Math.round(u(t.stackPartitions, 10)),
+    A = Math.round(u(t.slicePartitions, 8)),
+    m = Math.round(u(t.subdivisions, 128));
+  if (s < 1) throw new P("options.stackPartitions cannot be less than 1");
+  if (A < 0) throw new P("options.slicePartitions cannot be less than 0");
+  if (m < 0)
+    throw new P("options.subdivisions must be greater than or equal to zero.");
+  if (T(t.offsetAttribute) && t.offsetAttribute === W.TOP)
+    throw new P(
+      "GeometryOffsetAttribute.TOP is not a supported options.offsetAttribute for this geometry.",
+    );
+  ((this._radii = r.clone(o)),
+    (this._innerRadii = r.clone(n)),
+    (this._minimumClock = k),
+    (this._maximumClock = w),
+    (this._minimumCone = d),
+    (this._maximumCone = l),
+    (this._stackPartitions = s),
+    (this._slicePartitions = A),
+    (this._subdivisions = m),
+    (this._offsetAttribute = t.offsetAttribute),
+    (this._workerName = "createEllipsoidOutlineGeometry"));
+}
+x.packedLength = 2 * r.packedLength + 8;
+x.pack = function (t, o, n) {
+  if (!T(t)) throw new P("value is required");
+  if (!T(o)) throw new P("array is required");
+  return (
+    (n = u(n, 0)),
+    r.pack(t._radii, o, n),
+    (n += r.packedLength),
+    r.pack(t._innerRadii, o, n),
+    (n += r.packedLength),
+    (o[n++] = t._minimumClock),
+    (o[n++] = t._maximumClock),
+    (o[n++] = t._minimumCone),
+    (o[n++] = t._maximumCone),
+    (o[n++] = t._stackPartitions),
+    (o[n++] = t._slicePartitions),
+    (o[n++] = t._subdivisions),
+    (o[n] = u(t._offsetAttribute, -1)),
+    o
+  );
+};
+var $ = new r(),
+  G = new r(),
+  b = {
+    radii: $,
+    innerRadii: G,
+    minimumClock: void 0,
+    maximumClock: void 0,
+    minimumCone: void 0,
+    maximumCone: void 0,
+    stackPartitions: void 0,
+    slicePartitions: void 0,
+    subdivisions: void 0,
+    offsetAttribute: void 0,
+  };
+x.unpack = function (t, o, n) {
+  if (!T(t)) throw new P("array is required");
+  o = u(o, 0);
+  let k = r.unpack(t, o, $);
+  o += r.packedLength;
+  let w = r.unpack(t, o, G);
+  o += r.packedLength;
+  let d = t[o++],
+    l = t[o++],
+    s = t[o++],
+    A = t[o++],
+    m = t[o++],
+    f = t[o++],
+    E = t[o++],
+    h = t[o];
+  return T(n)
+    ? ((n._radii = r.clone(k, n._radii)),
+      (n._innerRadii = r.clone(w, n._innerRadii)),
+      (n._minimumClock = d),
+      (n._maximumClock = l),
+      (n._minimumCone = s),
+      (n._maximumCone = A),
+      (n._stackPartitions = m),
+      (n._slicePartitions = f),
+      (n._subdivisions = E),
+      (n._offsetAttribute = h === -1 ? void 0 : h),
+      n)
+    : ((b.minimumClock = d),
+      (b.maximumClock = l),
+      (b.minimumCone = s),
+      (b.maximumCone = A),
+      (b.stackPartitions = m),
+      (b.slicePartitions = f),
+      (b.subdivisions = E),
+      (b.offsetAttribute = h === -1 ? void 0 : h),
+      new x(b));
+};
+x.createGeometry = function (t) {
+  let o = t._radii;
+  if (o.x <= 0 || o.y <= 0 || o.z <= 0) return;
+  let n = t._innerRadii;
+  if (n.x <= 0 || n.y <= 0 || n.z <= 0) return;
+  let k = t._minimumClock,
+    w = t._maximumClock,
+    d = t._minimumCone,
+    l = t._maximumCone,
+    s = t._subdivisions,
+    A = J.fromCartesian3(o),
+    m = t._slicePartitions + 1,
+    f = t._stackPartitions + 1;
+  ((m = Math.round((m * Math.abs(w - k)) / B.TWO_PI)),
+    (f = Math.round((f * Math.abs(l - d)) / B.PI)),
+    m < 2 && (m = 2),
+    f < 2 && (f = 2));
+  let E = 0,
+    h = 1,
+    L = n.x !== o.x || n.y !== o.y || n.z !== o.z,
+    Y = !1,
+    j = !1;
+  L &&
+    ((h = 2),
+    d > 0 && ((Y = !0), (E += m)),
+    l < Math.PI && ((j = !0), (E += m)));
+  let y = s * h * (f + m),
+    a = new Float64Array(y * 3),
+    g = 2 * (y + E - (m + f) * h),
+    _ = Z.createTypedArray(y, g),
+    i,
+    e,
+    v,
+    z,
+    c = 0,
+    C = new Array(f),
+    O = new Array(f);
+  for (i = 0; i < f; i++)
+    ((z = d + (i * (l - d)) / (f - 1)), (C[i] = q(z)), (O[i] = S(z)));
+  let M = new Array(s),
+    R = new Array(s);
+  for (i = 0; i < s; i++)
+    ((v = k + (i * (w - k)) / (s - 1)), (M[i] = q(v)), (R[i] = S(v)));
+  for (i = 0; i < f; i++)
+    for (e = 0; e < s; e++)
+      ((a[c++] = o.x * C[i] * R[e]),
+        (a[c++] = o.y * C[i] * M[e]),
+        (a[c++] = o.z * O[i]));
+  if (L)
+    for (i = 0; i < f; i++)
+      for (e = 0; e < s; e++)
+        ((a[c++] = n.x * C[i] * R[e]),
+          (a[c++] = n.y * C[i] * M[e]),
+          (a[c++] = n.z * O[i]));
+  for (C.length = s, O.length = s, i = 0; i < s; i++)
+    ((z = d + (i * (l - d)) / (s - 1)), (C[i] = q(z)), (O[i] = S(z)));
+  for (M.length = m, R.length = m, i = 0; i < m; i++)
+    ((v = k + (i * (w - k)) / (m - 1)), (M[i] = q(v)), (R[i] = S(v)));
+  for (i = 0; i < s; i++)
+    for (e = 0; e < m; e++)
+      ((a[c++] = o.x * C[i] * R[e]),
+        (a[c++] = o.y * C[i] * M[e]),
+        (a[c++] = o.z * O[i]));
+  if (L)
+    for (i = 0; i < s; i++)
+      for (e = 0; e < m; e++)
+        ((a[c++] = n.x * C[i] * R[e]),
+          (a[c++] = n.y * C[i] * M[e]),
+          (a[c++] = n.z * O[i]));
+  for (c = 0, i = 0; i < f * h; i++) {
+    let p = i * s;
+    for (e = 0; e < s - 1; e++) ((_[c++] = p + e), (_[c++] = p + e + 1));
+  }
+  let D = f * s * h;
+  for (i = 0; i < m; i++)
+    for (e = 0; e < s - 1; e++)
+      ((_[c++] = D + i + e * m), (_[c++] = D + i + (e + 1) * m));
+  if (L)
+    for (D = f * s * h + m * s, i = 0; i < m; i++)
+      for (e = 0; e < s - 1; e++)
+        ((_[c++] = D + i + e * m), (_[c++] = D + i + (e + 1) * m));
+  if (L) {
+    let p = f * s * h,
+      N = p + s * m;
+    if (Y) for (i = 0; i < m; i++) ((_[c++] = p + i), (_[c++] = N + i));
+    if (j)
+      for (p += s * m - m, N += s * m - m, i = 0; i < m; i++)
+        ((_[c++] = p + i), (_[c++] = N + i));
+  }
+  let F = new X({
+    position: new V({
+      componentDatatype: U.DOUBLE,
+      componentsPerAttribute: 3,
+      values: a,
+    }),
+  });
+  if (T(t._offsetAttribute)) {
+    let p = a.length,
+      N = t._offsetAttribute === W.NONE ? 0 : 1,
+      I = new Uint8Array(p / 3).fill(N);
+    F.applyOffset = new V({
+      componentDatatype: U.UNSIGNED_BYTE,
+      componentsPerAttribute: 1,
+      values: I,
+    });
+  }
+  return new Q({
+    attributes: F,
+    indices: _,
+    primitiveType: K.LINES,
+    boundingSphere: H.fromEllipsoid(A),
+    offsetAttribute: t._offsetAttribute,
+  });
+};
+var Ci = x;
+export { Ci as a };