create-swdg-frontend 0.1.0

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

@@ -0,0 +1,399 @@
+/**
+ * @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 p, b as P, d as q } from "./chunk-POASMU2N.js";
+import { a } from "./chunk-R6KGAEF6.js";
+import { a as T } from "./chunk-IUA6FAOZ.js";
+import { a as I, b as g } from "./chunk-UH2WFNTA.js";
+import { e as l } from "./chunk-PEYJTJPE.js";
+function y(n, i, o) {
+  if (n === 0) return i * o;
+  let t = n * n,
+    e = t * t,
+    c = e * t,
+    r = c * t,
+    h = r * t,
+    s = h * t,
+    d = o,
+    u = Math.sin(2 * d),
+    f = Math.sin(4 * d),
+    M = Math.sin(6 * d),
+    _ = Math.sin(8 * d),
+    E = Math.sin(10 * d),
+    S = Math.sin(12 * d);
+  return (
+    i *
+    ((1 -
+      t / 4 -
+      (3 * e) / 64 -
+      (5 * c) / 256 -
+      (175 * r) / 16384 -
+      (441 * h) / 65536 -
+      (4851 * s) / 1048576) *
+      d -
+      ((3 * t) / 8 +
+        (3 * e) / 32 +
+        (45 * c) / 1024 +
+        (105 * r) / 4096 +
+        (2205 * h) / 131072 +
+        (6237 * s) / 524288) *
+        u +
+      ((15 * e) / 256 +
+        (45 * c) / 1024 +
+        (525 * r) / 16384 +
+        (1575 * h) / 65536 +
+        (155925 * s) / 8388608) *
+        f -
+      ((35 * c) / 3072 +
+        (175 * r) / 12288 +
+        (3675 * h) / 262144 +
+        (13475 * s) / 1048576) *
+        M +
+      ((315 * r) / 131072 + (2205 * h) / 524288 + (43659 * s) / 8388608) * _ -
+      ((693 * h) / 1310720 + (6237 * s) / 5242880) * E +
+      ((1001 * s) / 8388608) * S)
+  );
+}
+function z(n, i, o) {
+  let t = n / o;
+  if (i === 0) return t;
+  let e = t * t,
+    c = e * t,
+    r = c * t,
+    h = i,
+    s = h * h,
+    d = s * s,
+    u = d * s,
+    f = u * s,
+    M = f * s,
+    _ = M * s,
+    E = Math.sin(2 * t),
+    S = Math.cos(2 * t),
+    W = Math.sin(4 * t),
+    V = Math.cos(4 * t),
+    C = Math.sin(6 * t),
+    N = Math.cos(6 * t),
+    R = Math.sin(8 * t),
+    b = Math.cos(8 * t),
+    x = Math.sin(10 * t),
+    U = Math.cos(10 * t),
+    H = Math.sin(12 * t);
+  return (
+    t +
+    (t * s) / 4 +
+    (7 * t * d) / 64 +
+    (15 * t * u) / 256 +
+    (579 * t * f) / 16384 +
+    (1515 * t * M) / 65536 +
+    (16837 * t * _) / 1048576 +
+    ((3 * t * d) / 16 +
+      (45 * t * u) / 256 -
+      (t * (32 * e - 561) * f) / 4096 -
+      (t * (232 * e - 1677) * M) / 16384 +
+      (t * (399985 - 90560 * e + 512 * r) * _) / 5242880) *
+      S +
+    ((21 * t * u) / 256 +
+      (483 * t * f) / 4096 -
+      (t * (224 * e - 1969) * M) / 16384 -
+      (t * (33152 * e - 112599) * _) / 1048576) *
+      V +
+    ((151 * t * f) / 4096 +
+      (4681 * t * M) / 65536 +
+      (1479 * t * _) / 16384 -
+      (453 * c * _) / 32768) *
+      N +
+    ((1097 * t * M) / 65536 + (42783 * t * _) / 1048576) * b +
+    ((8011 * t * _) / 1048576) * U +
+    ((3 * s) / 8 +
+      (3 * d) / 16 +
+      (213 * u) / 2048 -
+      (3 * e * u) / 64 +
+      (255 * f) / 4096 -
+      (33 * e * f) / 512 +
+      (20861 * M) / 524288 -
+      (33 * e * M) / 512 +
+      (r * M) / 1024 +
+      (28273 * _) / 1048576 -
+      (471 * e * _) / 8192 +
+      (9 * r * _) / 4096) *
+      E +
+    ((21 * d) / 256 +
+      (21 * u) / 256 +
+      (533 * f) / 8192 -
+      (21 * e * f) / 512 +
+      (197 * M) / 4096 -
+      (315 * e * M) / 4096 +
+      (584039 * _) / 16777216 -
+      (12517 * e * _) / 131072 +
+      (7 * r * _) / 2048) *
+      W +
+    ((151 * u) / 6144 +
+      (151 * f) / 4096 +
+      (5019 * M) / 131072 -
+      (453 * e * M) / 16384 +
+      (26965 * _) / 786432 -
+      (8607 * e * _) / 131072) *
+      C +
+    ((1097 * f) / 131072 +
+      (1097 * M) / 65536 +
+      (225797 * _) / 10485760 -
+      (1097 * e * _) / 65536) *
+      R +
+    ((8011 * M) / 2621440 + (8011 * _) / 1048576) * x +
+    ((293393 * _) / 251658240) * H
+  );
+}
+function O(n, i) {
+  if (n === 0) return Math.log(Math.tan(0.5 * (a.PI_OVER_TWO + i)));
+  let o = n * Math.sin(i);
+  return (
+    Math.log(Math.tan(0.5 * (a.PI_OVER_TWO + i))) -
+    (n / 2) * Math.log((1 + o) / (1 - o))
+  );
+}
+function k(n, i, o, t, e) {
+  let c = O(n._ellipticity, o),
+    r = O(n._ellipticity, e);
+  return Math.atan2(a.negativePiToPi(t - i), r - c);
+}
+function A(n, i, o, t, e, c, r) {
+  let h = n._heading,
+    s = c - t,
+    d = 0;
+  if (a.equalsEpsilon(Math.abs(h), a.PI_OVER_TWO, a.EPSILON8))
+    if (i === o) d = i * Math.cos(e) * a.negativePiToPi(s);
+    else {
+      let u = Math.sin(e);
+      d =
+        (i * Math.cos(e) * a.negativePiToPi(s)) /
+        Math.sqrt(1 - n._ellipticitySquared * u * u);
+    }
+  else {
+    let u = y(n._ellipticity, i, e);
+    d = (y(n._ellipticity, i, r) - u) / Math.cos(h);
+  }
+  return Math.abs(d);
+}
+var B = new p(),
+  w = new p();
+function D(n, i, o, t) {
+  let e = p.normalize(t.cartographicToCartesian(i, w), B),
+    c = p.normalize(t.cartographicToCartesian(o, w), w);
+  g.typeOf.number.greaterThanOrEquals(
+    "value",
+    Math.abs(Math.abs(p.angleBetween(e, c)) - Math.PI),
+    0.0125,
+  );
+  let r = t.maximumRadius,
+    h = t.minimumRadius,
+    s = r * r,
+    d = h * h;
+  ((n._ellipticitySquared = (s - d) / s),
+    (n._ellipticity = Math.sqrt(n._ellipticitySquared)),
+    (n._start = P.clone(i, n._start)),
+    (n._start.height = 0),
+    (n._end = P.clone(o, n._end)),
+    (n._end.height = 0),
+    (n._heading = k(n, i.longitude, i.latitude, o.longitude, o.latitude)),
+    (n._distance = A(
+      n,
+      t.maximumRadius,
+      t.minimumRadius,
+      i.longitude,
+      i.latitude,
+      o.longitude,
+      o.latitude,
+    )));
+}
+function v(n, i, o, t, e, c) {
+  if (o === 0) return P.clone(n, c);
+  let r = e * e,
+    h,
+    s,
+    d;
+  if (Math.abs(a.PI_OVER_TWO - Math.abs(i)) > a.EPSILON8) {
+    let u = y(e, t, n.latitude),
+      f = o * Math.cos(i),
+      M = u + f;
+    if (((s = z(M, e, t)), Math.abs(i) < a.EPSILON10))
+      h = a.negativePiToPi(n.longitude);
+    else {
+      let _ = O(e, n.latitude),
+        E = O(e, s);
+      ((d = Math.tan(i) * (E - _)), (h = a.negativePiToPi(n.longitude + d)));
+    }
+  } else {
+    s = n.latitude;
+    let u;
+    if (e === 0) u = t * Math.cos(n.latitude);
+    else {
+      let f = Math.sin(n.latitude);
+      u = (t * Math.cos(n.latitude)) / Math.sqrt(1 - r * f * f);
+    }
+    ((d = o / u),
+      i > 0
+        ? (h = a.negativePiToPi(n.longitude + d))
+        : (h = a.negativePiToPi(n.longitude - d)));
+  }
+  return l(c)
+    ? ((c.longitude = h), (c.latitude = s), (c.height = 0), c)
+    : new P(h, s, 0);
+}
+function m(n, i, o) {
+  let t = T(o, q.default);
+  ((this._ellipsoid = t),
+    (this._start = new P()),
+    (this._end = new P()),
+    (this._heading = void 0),
+    (this._distance = void 0),
+    (this._ellipticity = void 0),
+    (this._ellipticitySquared = void 0),
+    l(n) && l(i) && D(this, n, i, t));
+}
+Object.defineProperties(m.prototype, {
+  ellipsoid: {
+    get: function () {
+      return this._ellipsoid;
+    },
+  },
+  surfaceDistance: {
+    get: function () {
+      return (g.defined("distance", this._distance), this._distance);
+    },
+  },
+  start: {
+    get: function () {
+      return this._start;
+    },
+  },
+  end: {
+    get: function () {
+      return this._end;
+    },
+  },
+  heading: {
+    get: function () {
+      return (g.defined("distance", this._distance), this._heading);
+    },
+  },
+});
+m.fromStartHeadingDistance = function (n, i, o, t, e) {
+  (g.defined("start", n),
+    g.defined("heading", i),
+    g.defined("distance", o),
+    g.typeOf.number.greaterThan("distance", o, 0));
+  let c = T(t, q.default),
+    r = c.maximumRadius,
+    h = c.minimumRadius,
+    s = r * r,
+    d = h * h,
+    u = Math.sqrt((s - d) / s);
+  i = a.negativePiToPi(i);
+  let f = v(n, i, o, c.maximumRadius, u);
+  return !l(e) || (l(t) && !t.equals(e.ellipsoid))
+    ? new m(n, f, c)
+    : (e.setEndPoints(n, f), e);
+};
+m.prototype.setEndPoints = function (n, i) {
+  (g.defined("start", n), g.defined("end", i), D(this, n, i, this._ellipsoid));
+};
+m.prototype.interpolateUsingFraction = function (n, i) {
+  return this.interpolateUsingSurfaceDistance(n * this._distance, i);
+};
+m.prototype.interpolateUsingSurfaceDistance = function (n, i) {
+  if (
+    (g.typeOf.number("distance", n), !l(this._distance) || this._distance === 0)
+  )
+    throw new I("EllipsoidRhumbLine must have distinct start and end set.");
+  return v(
+    this._start,
+    this._heading,
+    n,
+    this._ellipsoid.maximumRadius,
+    this._ellipticity,
+    i,
+  );
+};
+m.prototype.findIntersectionWithLongitude = function (n, i) {
+  if (
+    (g.typeOf.number("intersectionLongitude", n),
+    !l(this._distance) || this._distance === 0)
+  )
+    throw new I("EllipsoidRhumbLine must have distinct start and end set.");
+  let o = this._ellipticity,
+    t = this._heading,
+    e = Math.abs(t),
+    c = this._start;
+  if (
+    ((n = a.negativePiToPi(n)),
+    a.equalsEpsilon(Math.abs(n), Math.PI, a.EPSILON14) &&
+      (n = a.sign(c.longitude) * Math.PI),
+    l(i) || (i = new P()),
+    Math.abs(a.PI_OVER_TWO - e) <= a.EPSILON8)
+  )
+    return ((i.longitude = n), (i.latitude = c.latitude), (i.height = 0), i);
+  if (a.equalsEpsilon(Math.abs(a.PI_OVER_TWO - e), a.PI_OVER_TWO, a.EPSILON8))
+    return a.equalsEpsilon(n, c.longitude, a.EPSILON12)
+      ? void 0
+      : ((i.longitude = n),
+        (i.latitude = a.PI_OVER_TWO * a.sign(a.PI_OVER_TWO - t)),
+        (i.height = 0),
+        i);
+  let r = c.latitude,
+    h = o * Math.sin(r),
+    s =
+      Math.tan(0.5 * (a.PI_OVER_TWO + r)) *
+      Math.exp((n - c.longitude) / Math.tan(t)),
+    d = (1 + h) / (1 - h),
+    u = c.latitude,
+    f;
+  do {
+    f = u;
+    let M = o * Math.sin(f),
+      _ = (1 + M) / (1 - M);
+    u = 2 * Math.atan(s * Math.pow(_ / d, o / 2)) - a.PI_OVER_TWO;
+  } while (!a.equalsEpsilon(u, f, a.EPSILON12));
+  return ((i.longitude = n), (i.latitude = u), (i.height = 0), i);
+};
+m.prototype.findIntersectionWithLatitude = function (n, i) {
+  if (
+    (g.typeOf.number("intersectionLatitude", n),
+    !l(this._distance) || this._distance === 0)
+  )
+    throw new I("EllipsoidRhumbLine must have distinct start and end set.");
+  let o = this._ellipticity,
+    t = this._heading,
+    e = this._start;
+  if (a.equalsEpsilon(Math.abs(t), a.PI_OVER_TWO, a.EPSILON8)) return;
+  let c = O(o, e.latitude),
+    r = O(o, n),
+    h = Math.tan(t) * (r - c),
+    s = a.negativePiToPi(e.longitude + h);
+  return l(i)
+    ? ((i.longitude = s), (i.latitude = n), (i.height = 0), i)
+    : new P(s, n, 0);
+};
+var $ = m;
+export { $ as a };

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

@@ -0,0 +1,65 @@
+/**
+ * @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-R6KGAEF6.js";
+var C = {};
+C.computePositions = function (I, f, b, n, e) {
+  let m = I * 0.5,
+    i = -m,
+    s = n + n,
+    P = e ? 2 * s : s,
+    t = new Float64Array(P * 3),
+    r,
+    c = 0,
+    o = 0,
+    p = e ? s * 3 : 0,
+    a = e ? (s + n) * 3 : n * 3;
+  for (r = 0; r < n; r++) {
+    let y = (r / n) * w.TWO_PI,
+      x = Math.cos(y),
+      h = Math.sin(y),
+      u = x * b,
+      M = h * b,
+      O = x * f,
+      d = h * f;
+    ((t[o + p] = u),
+      (t[o + p + 1] = M),
+      (t[o + p + 2] = i),
+      (t[o + a] = O),
+      (t[o + a + 1] = d),
+      (t[o + a + 2] = m),
+      (o += 3),
+      e &&
+        ((t[c++] = u),
+        (t[c++] = M),
+        (t[c++] = i),
+        (t[c++] = O),
+        (t[c++] = d),
+        (t[c++] = m)));
+  }
+  return t;
+};
+var Y = C;
+export { Y as a };

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

@@ -0,0 +1,92 @@
+/**
+ * @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 t } from "./chunk-IUA6FAOZ.js";
+import { a as O } from "./chunk-UH2WFNTA.js";
+import { e as f } from "./chunk-PEYJTJPE.js";
+function n(e) {
+  ((e = t(e, t.EMPTY_OBJECT)),
+    (this.position = t(e.position, !1)),
+    (this.normal = t(e.normal, !1)),
+    (this.st = t(e.st, !1)),
+    (this.bitangent = t(e.bitangent, !1)),
+    (this.tangent = t(e.tangent, !1)),
+    (this.color = t(e.color, !1)));
+}
+n.POSITION_ONLY = Object.freeze(new n({ position: !0 }));
+n.POSITION_AND_NORMAL = Object.freeze(new n({ position: !0, normal: !0 }));
+n.POSITION_NORMAL_AND_ST = Object.freeze(
+  new n({ position: !0, normal: !0, st: !0 }),
+);
+n.POSITION_AND_ST = Object.freeze(new n({ position: !0, st: !0 }));
+n.POSITION_AND_COLOR = Object.freeze(new n({ position: !0, color: !0 }));
+n.ALL = Object.freeze(
+  new n({ position: !0, normal: !0, st: !0, tangent: !0, bitangent: !0 }),
+);
+n.DEFAULT = n.POSITION_NORMAL_AND_ST;
+n.packedLength = 6;
+n.pack = function (e, o, i) {
+  if (!f(e)) throw new O("value is required");
+  if (!f(o)) throw new O("array is required");
+  return (
+    (i = t(i, 0)),
+    (o[i++] = e.position ? 1 : 0),
+    (o[i++] = e.normal ? 1 : 0),
+    (o[i++] = e.st ? 1 : 0),
+    (o[i++] = e.tangent ? 1 : 0),
+    (o[i++] = e.bitangent ? 1 : 0),
+    (o[i] = e.color ? 1 : 0),
+    o
+  );
+};
+n.unpack = function (e, o, i) {
+  if (!f(e)) throw new O("array is required");
+  return (
+    (o = t(o, 0)),
+    f(i) || (i = new n()),
+    (i.position = e[o++] === 1),
+    (i.normal = e[o++] === 1),
+    (i.st = e[o++] === 1),
+    (i.tangent = e[o++] === 1),
+    (i.bitangent = e[o++] === 1),
+    (i.color = e[o] === 1),
+    i
+  );
+};
+n.clone = function (e, o) {
+  if (f(e))
+    return (
+      f(o) || (o = new n()),
+      (o.position = e.position),
+      (o.normal = e.normal),
+      (o.st = e.st),
+      (o.tangent = e.tangent),
+      (o.bitangent = e.bitangent),
+      (o.color = e.color),
+      o
+    );
+};
+var _ = n;
+export { _ as a };