create-swdg-frontend 0.1.0

package/template/public/Cesium1.119/Workers/chunk-3JW36LZF.js

@@ -0,0 +1,166 @@
+/**
+ * @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 L, b as x } from "./chunk-TMSETF7M.js";
+import { h as R } from "./chunk-7Z5IIKOJ.js";
+import { b as d, c as O, d as g } from "./chunk-POASMU2N.js";
+import { a as w } from "./chunk-IUA6FAOZ.js";
+import { b as m } from "./chunk-UH2WFNTA.js";
+import { e as f } from "./chunk-PEYJTJPE.js";
+function t(i, h, o, n) {
+  ((this.x = w(i, 0)),
+    (this.y = w(h, 0)),
+    (this.width = w(o, 0)),
+    (this.height = w(n, 0)));
+}
+t.packedLength = 4;
+t.pack = function (i, h, o) {
+  return (
+    m.typeOf.object("value", i),
+    m.defined("array", h),
+    (o = w(o, 0)),
+    (h[o++] = i.x),
+    (h[o++] = i.y),
+    (h[o++] = i.width),
+    (h[o] = i.height),
+    h
+  );
+};
+t.unpack = function (i, h, o) {
+  return (
+    m.defined("array", i),
+    (h = w(h, 0)),
+    f(o) || (o = new t()),
+    (o.x = i[h++]),
+    (o.y = i[h++]),
+    (o.width = i[h++]),
+    (o.height = i[h]),
+    o
+  );
+};
+t.fromPoints = function (i, h) {
+  if ((f(h) || (h = new t()), !f(i) || i.length === 0))
+    return ((h.x = 0), (h.y = 0), (h.width = 0), (h.height = 0), h);
+  let o = i.length,
+    n = i[0].x,
+    c = i[0].y,
+    e = i[0].x,
+    y = i[0].y;
+  for (let p = 1; p < o; p++) {
+    let b = i[p],
+      j = b.x,
+      M = b.y;
+    ((n = Math.min(j, n)),
+      (e = Math.max(j, e)),
+      (c = Math.min(M, c)),
+      (y = Math.max(M, y)));
+  }
+  return ((h.x = n), (h.y = c), (h.width = e - n), (h.height = y - c), h);
+};
+var X = new L(),
+  Y = new d(),
+  k = new d();
+t.fromRectangle = function (i, h, o) {
+  if ((f(o) || (o = new t()), !f(i)))
+    return ((o.x = 0), (o.y = 0), (o.width = 0), (o.height = 0), o);
+  ((X._ellipsoid = g.default), (h = w(h, X)));
+  let n = h.project(R.southwest(i, Y)),
+    c = h.project(R.northeast(i, k));
+  return (
+    O.subtract(c, n, c),
+    (o.x = n.x),
+    (o.y = n.y),
+    (o.width = c.x),
+    (o.height = c.y),
+    o
+  );
+};
+t.clone = function (i, h) {
+  if (f(i))
+    return f(h)
+      ? ((h.x = i.x),
+        (h.y = i.y),
+        (h.width = i.width),
+        (h.height = i.height),
+        h)
+      : new t(i.x, i.y, i.width, i.height);
+};
+t.union = function (i, h, o) {
+  (m.typeOf.object("left", i),
+    m.typeOf.object("right", h),
+    f(o) || (o = new t()));
+  let n = Math.min(i.x, h.x),
+    c = Math.min(i.y, h.y),
+    e = Math.max(i.x + i.width, h.x + h.width),
+    y = Math.max(i.y + i.height, h.y + h.height);
+  return ((o.x = n), (o.y = c), (o.width = e - n), (o.height = y - c), o);
+};
+t.expand = function (i, h, o) {
+  (m.typeOf.object("rectangle", i),
+    m.typeOf.object("point", h),
+    (o = t.clone(i, o)));
+  let n = h.x - o.x,
+    c = h.y - o.y;
+  return (
+    n > o.width ? (o.width = n) : n < 0 && ((o.width -= n), (o.x = h.x)),
+    c > o.height ? (o.height = c) : c < 0 && ((o.height -= c), (o.y = h.y)),
+    o
+  );
+};
+t.intersect = function (i, h) {
+  (m.typeOf.object("left", i), m.typeOf.object("right", h));
+  let o = i.x,
+    n = i.y,
+    c = h.x,
+    e = h.y;
+  return o > c + h.width ||
+    o + i.width < c ||
+    n + i.height < e ||
+    n > e + h.height
+    ? x.OUTSIDE
+    : x.INTERSECTING;
+};
+t.equals = function (i, h) {
+  return (
+    i === h ||
+    (f(i) &&
+      f(h) &&
+      i.x === h.x &&
+      i.y === h.y &&
+      i.width === h.width &&
+      i.height === h.height)
+  );
+};
+t.prototype.clone = function (i) {
+  return t.clone(this, i);
+};
+t.prototype.intersect = function (i) {
+  return t.intersect(this, i);
+};
+t.prototype.equals = function (i) {
+  return t.equals(this, i);
+};
+var a = t;
+export { a };

package/template/public/Cesium1.119/Workers/chunk-4BTGX3WJ.js

@@ -0,0 +1,264 @@
+/**
+ * @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 S } from "./chunk-BMHPVZ4H.js";
+import { a as j } from "./chunk-ILGBPNP6.js";
+import { a as D } from "./chunk-P37AI2DW.js";
+import { a as V } from "./chunk-T6BE4RZK.js";
+import { b as T, c as B, d as L } from "./chunk-X5IHHI6X.js";
+import { d as O } from "./chunk-TMSETF7M.js";
+import { a as x } from "./chunk-KZNJOCYU.js";
+import { a as c, d as l } from "./chunk-POASMU2N.js";
+import { a as E } from "./chunk-R6KGAEF6.js";
+import { a as m } from "./chunk-IUA6FAOZ.js";
+import { a as _ } from "./chunk-UH2WFNTA.js";
+import { e as d } from "./chunk-PEYJTJPE.js";
+var q = new c(),
+  M = new c();
+function U(e) {
+  let t = e.center;
+  ((M = c.multiplyByScalar(
+    e.ellipsoid.geodeticSurfaceNormal(t, M),
+    e.height,
+    M,
+  )),
+    (M = c.add(t, M, M)));
+  let i = new O(M, e.semiMajorAxis),
+    f = S.computeEllipsePositions(e, !1, !0).outerPositions,
+    o = new V({
+      position: new L({
+        componentDatatype: x.DOUBLE,
+        componentsPerAttribute: 3,
+        values: S.raisePositionsToHeight(f, e, !1),
+      }),
+    }),
+    r = f.length / 3,
+    u = D.createTypedArray(r, r * 2),
+    h = 0;
+  for (let n = 0; n < r; ++n) ((u[h++] = n), (u[h++] = (n + 1) % r));
+  return { boundingSphere: i, attributes: o, indices: u };
+}
+var N = new O(),
+  P = new O();
+function R(e) {
+  let t = e.center,
+    i = e.ellipsoid,
+    f = e.semiMajorAxis,
+    o = c.multiplyByScalar(i.geodeticSurfaceNormal(t, q), e.height, q);
+  ((N.center = c.add(t, o, N.center)),
+    (N.radius = f),
+    (o = c.multiplyByScalar(
+      i.geodeticSurfaceNormal(t, o),
+      e.extrudedHeight,
+      o,
+    )),
+    (P.center = c.add(t, o, P.center)),
+    (P.radius = f));
+  let r = S.computeEllipsePositions(e, !1, !0).outerPositions,
+    u = new V({
+      position: new L({
+        componentDatatype: x.DOUBLE,
+        componentsPerAttribute: 3,
+        values: S.raisePositionsToHeight(r, e, !0),
+      }),
+    });
+  r = u.position.values;
+  let h = O.union(N, P),
+    n = r.length / 3;
+  if (d(e.offsetAttribute)) {
+    let g = new Uint8Array(n);
+    if (e.offsetAttribute === j.TOP) g = g.fill(1, 0, n / 2);
+    else {
+      let H = e.offsetAttribute === j.NONE ? 0 : 1;
+      g = g.fill(H);
+    }
+    u.applyOffset = new L({
+      componentDatatype: x.UNSIGNED_BYTE,
+      componentsPerAttribute: 1,
+      values: g,
+    });
+  }
+  let p = m(e.numberOfVerticalLines, 16);
+  p = E.clamp(p, 0, n / 2);
+  let a = D.createTypedArray(n, n * 2 + p * 2);
+  n /= 2;
+  let A = 0,
+    s;
+  for (s = 0; s < n; ++s)
+    ((a[A++] = s),
+      (a[A++] = (s + 1) % n),
+      (a[A++] = s + n),
+      (a[A++] = ((s + 1) % n) + n));
+  let k;
+  if (p > 0) {
+    let g = Math.min(p, n);
+    k = Math.round(n / g);
+    let H = Math.min(k * p, n);
+    for (s = 0; s < H; s += k) ((a[A++] = s), (a[A++] = s + n));
+  }
+  return { boundingSphere: h, attributes: u, indices: a };
+}
+function w(e) {
+  e = m(e, m.EMPTY_OBJECT);
+  let t = e.center,
+    i = m(e.ellipsoid, l.default),
+    f = e.semiMajorAxis,
+    o = e.semiMinorAxis,
+    r = m(e.granularity, E.RADIANS_PER_DEGREE);
+  if (!d(t)) throw new _("center is required.");
+  if (!d(f)) throw new _("semiMajorAxis is required.");
+  if (!d(o)) throw new _("semiMinorAxis is required.");
+  if (f < o)
+    throw new _(
+      "semiMajorAxis must be greater than or equal to the semiMinorAxis.",
+    );
+  if (r <= 0) throw new _("granularity must be greater than zero.");
+  let u = m(e.height, 0),
+    h = m(e.extrudedHeight, u);
+  ((this._center = c.clone(t)),
+    (this._semiMajorAxis = f),
+    (this._semiMinorAxis = o),
+    (this._ellipsoid = l.clone(i)),
+    (this._rotation = m(e.rotation, 0)),
+    (this._height = Math.max(h, u)),
+    (this._granularity = r),
+    (this._extrudedHeight = Math.min(h, u)),
+    (this._numberOfVerticalLines = Math.max(m(e.numberOfVerticalLines, 16), 0)),
+    (this._offsetAttribute = e.offsetAttribute),
+    (this._workerName = "createEllipseOutlineGeometry"));
+}
+w.packedLength = c.packedLength + l.packedLength + 8;
+w.pack = function (e, t, i) {
+  if (!d(e)) throw new _("value is required");
+  if (!d(t)) throw new _("array is required");
+  return (
+    (i = m(i, 0)),
+    c.pack(e._center, t, i),
+    (i += c.packedLength),
+    l.pack(e._ellipsoid, t, i),
+    (i += l.packedLength),
+    (t[i++] = e._semiMajorAxis),
+    (t[i++] = e._semiMinorAxis),
+    (t[i++] = e._rotation),
+    (t[i++] = e._height),
+    (t[i++] = e._granularity),
+    (t[i++] = e._extrudedHeight),
+    (t[i++] = e._numberOfVerticalLines),
+    (t[i] = m(e._offsetAttribute, -1)),
+    t
+  );
+};
+var y = new c(),
+  C = new l(),
+  b = {
+    center: y,
+    ellipsoid: C,
+    semiMajorAxis: void 0,
+    semiMinorAxis: void 0,
+    rotation: void 0,
+    height: void 0,
+    granularity: void 0,
+    extrudedHeight: void 0,
+    numberOfVerticalLines: void 0,
+    offsetAttribute: void 0,
+  };
+w.unpack = function (e, t, i) {
+  if (!d(e)) throw new _("array is required");
+  t = m(t, 0);
+  let f = c.unpack(e, t, y);
+  t += c.packedLength;
+  let o = l.unpack(e, t, C);
+  t += l.packedLength;
+  let r = e[t++],
+    u = e[t++],
+    h = e[t++],
+    n = e[t++],
+    p = e[t++],
+    a = e[t++],
+    A = e[t++],
+    s = e[t];
+  return d(i)
+    ? ((i._center = c.clone(f, i._center)),
+      (i._ellipsoid = l.clone(o, i._ellipsoid)),
+      (i._semiMajorAxis = r),
+      (i._semiMinorAxis = u),
+      (i._rotation = h),
+      (i._height = n),
+      (i._granularity = p),
+      (i._extrudedHeight = a),
+      (i._numberOfVerticalLines = A),
+      (i._offsetAttribute = s === -1 ? void 0 : s),
+      i)
+    : ((b.height = n),
+      (b.extrudedHeight = a),
+      (b.granularity = p),
+      (b.rotation = h),
+      (b.semiMajorAxis = r),
+      (b.semiMinorAxis = u),
+      (b.numberOfVerticalLines = A),
+      (b.offsetAttribute = s === -1 ? void 0 : s),
+      new w(b));
+};
+w.createGeometry = function (e) {
+  if (e._semiMajorAxis <= 0 || e._semiMinorAxis <= 0) return;
+  let t = e._height,
+    i = e._extrudedHeight,
+    f = !E.equalsEpsilon(t, i, 0, E.EPSILON2);
+  e._center = e._ellipsoid.scaleToGeodeticSurface(e._center, e._center);
+  let o = {
+      center: e._center,
+      semiMajorAxis: e._semiMajorAxis,
+      semiMinorAxis: e._semiMinorAxis,
+      ellipsoid: e._ellipsoid,
+      rotation: e._rotation,
+      height: t,
+      granularity: e._granularity,
+      numberOfVerticalLines: e._numberOfVerticalLines,
+    },
+    r;
+  if (f)
+    ((o.extrudedHeight = i),
+      (o.offsetAttribute = e._offsetAttribute),
+      (r = R(o)));
+  else if (((r = U(o)), d(e._offsetAttribute))) {
+    let u = r.attributes.position.values.length,
+      h = e._offsetAttribute === j.NONE ? 0 : 1,
+      n = new Uint8Array(u / 3).fill(h);
+    r.attributes.applyOffset = new L({
+      componentDatatype: x.UNSIGNED_BYTE,
+      componentsPerAttribute: 1,
+      values: n,
+    });
+  }
+  return new B({
+    attributes: r.attributes,
+    indices: r.indices,
+    primitiveType: T.LINES,
+    boundingSphere: r.boundingSphere,
+    offsetAttribute: e._offsetAttribute,
+  });
+};
+var ie = w;
+export { ie as a };

package/template/public/Cesium1.119/Workers/chunk-4WRMLZA7.js

@@ -0,0 +1,128 @@
+/**
+ * @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 d } from "./chunk-TMSETF7M.js";
+import { a as i } from "./chunk-POASMU2N.js";
+import { a as z } from "./chunk-IUA6FAOZ.js";
+import { b as r } from "./chunk-UH2WFNTA.js";
+import { e as c } from "./chunk-PEYJTJPE.js";
+function t(m, n, e) {
+  ((this.minimum = i.clone(z(m, i.ZERO))),
+    (this.maximum = i.clone(z(n, i.ZERO))),
+    c(e)
+      ? (e = i.clone(e))
+      : (e = i.midpoint(this.minimum, this.maximum, new i())),
+    (this.center = e));
+}
+t.fromCorners = function (m, n, e) {
+  return (
+    r.defined("minimum", m),
+    r.defined("maximum", n),
+    c(e) || (e = new t()),
+    (e.minimum = i.clone(m, e.minimum)),
+    (e.maximum = i.clone(n, e.maximum)),
+    (e.center = i.midpoint(m, n, e.center)),
+    e
+  );
+};
+t.fromPoints = function (m, n) {
+  if ((c(n) || (n = new t()), !c(m) || m.length === 0))
+    return (
+      (n.minimum = i.clone(i.ZERO, n.minimum)),
+      (n.maximum = i.clone(i.ZERO, n.maximum)),
+      (n.center = i.clone(i.ZERO, n.center)),
+      n
+    );
+  let e = m[0].x,
+    a = m[0].y,
+    u = m[0].z,
+    o = m[0].x,
+    y = m[0].y,
+    l = m[0].z,
+    I = m.length;
+  for (let E = 1; E < I; E++) {
+    let M = m[E],
+      p = M.x,
+      Z = M.y,
+      q = M.z;
+    ((e = Math.min(p, e)),
+      (o = Math.max(p, o)),
+      (a = Math.min(Z, a)),
+      (y = Math.max(Z, y)),
+      (u = Math.min(q, u)),
+      (l = Math.max(q, l)));
+  }
+  let f = n.minimum;
+  ((f.x = e), (f.y = a), (f.z = u));
+  let x = n.maximum;
+  return (
+    (x.x = o),
+    (x.y = y),
+    (x.z = l),
+    (n.center = i.midpoint(f, x, n.center)),
+    n
+  );
+};
+t.clone = function (m, n) {
+  if (c(m))
+    return c(n)
+      ? ((n.minimum = i.clone(m.minimum, n.minimum)),
+        (n.maximum = i.clone(m.maximum, n.maximum)),
+        (n.center = i.clone(m.center, n.center)),
+        n)
+      : new t(m.minimum, m.maximum, m.center);
+};
+t.equals = function (m, n) {
+  return (
+    m === n ||
+    (c(m) &&
+      c(n) &&
+      i.equals(m.center, n.center) &&
+      i.equals(m.minimum, n.minimum) &&
+      i.equals(m.maximum, n.maximum))
+  );
+};
+var h = new i();
+t.intersectPlane = function (m, n) {
+  (r.defined("box", m),
+    r.defined("plane", n),
+    (h = i.subtract(m.maximum, m.minimum, h)));
+  let e = i.multiplyByScalar(h, 0.5, h),
+    a = n.normal,
+    u = e.x * Math.abs(a.x) + e.y * Math.abs(a.y) + e.z * Math.abs(a.z),
+    o = i.dot(m.center, a) + n.distance;
+  return o - u > 0 ? d.INSIDE : o + u < 0 ? d.OUTSIDE : d.INTERSECTING;
+};
+t.prototype.clone = function (m) {
+  return t.clone(this, m);
+};
+t.prototype.intersectPlane = function (m) {
+  return t.intersectPlane(this, m);
+};
+t.prototype.equals = function (m) {
+  return t.equals(this, m);
+};
+var P = t;
+export { P as a };