create-swdg-frontend 0.1.0

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

@@ -0,0 +1,287 @@
+/**
+ * @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 Q } from "./chunk-GFN7NNSJ.js";
+import { a as z } from "./chunk-ILGBPNP6.js";
+import { a as _ } from "./chunk-HEEMUCG6.js";
+import { a as K } from "./chunk-P37AI2DW.js";
+import { a as H } from "./chunk-T6BE4RZK.js";
+import { b as J, c as W, d as P } from "./chunk-X5IHHI6X.js";
+import { d as j } from "./chunk-TMSETF7M.js";
+import { a as L } from "./chunk-KZNJOCYU.js";
+import { a as b, c as k } from "./chunk-POASMU2N.js";
+import { a as Z } from "./chunk-R6KGAEF6.js";
+import { a as x } from "./chunk-IUA6FAOZ.js";
+import { a as F } from "./chunk-UH2WFNTA.js";
+import { e as g } from "./chunk-PEYJTJPE.js";
+var M = new k(),
+  ot = new b(),
+  nt = new b(),
+  it = new b(),
+  st = new b();
+function O(t) {
+  t = x(t, x.EMPTY_OBJECT);
+  let n = t.length,
+    e = t.topRadius,
+    h = t.bottomRadius,
+    o = x(t.vertexFormat, _.DEFAULT),
+    r = x(t.slices, 128);
+  if (!g(n)) throw new F("options.length must be defined.");
+  if (!g(e)) throw new F("options.topRadius must be defined.");
+  if (!g(h)) throw new F("options.bottomRadius must be defined.");
+  if (r < 3) throw new F("options.slices must be greater than or equal to 3.");
+  if (g(t.offsetAttribute) && t.offsetAttribute === z.TOP)
+    throw new F(
+      "GeometryOffsetAttribute.TOP is not a supported options.offsetAttribute for this geometry.",
+    );
+  ((this._length = n),
+    (this._topRadius = e),
+    (this._bottomRadius = h),
+    (this._vertexFormat = _.clone(o)),
+    (this._slices = r),
+    (this._offsetAttribute = t.offsetAttribute),
+    (this._workerName = "createCylinderGeometry"));
+}
+O.packedLength = _.packedLength + 5;
+O.pack = function (t, n, e) {
+  if (!g(t)) throw new F("value is required");
+  if (!g(n)) throw new F("array is required");
+  return (
+    (e = x(e, 0)),
+    _.pack(t._vertexFormat, n, e),
+    (e += _.packedLength),
+    (n[e++] = t._length),
+    (n[e++] = t._topRadius),
+    (n[e++] = t._bottomRadius),
+    (n[e++] = t._slices),
+    (n[e] = x(t._offsetAttribute, -1)),
+    n
+  );
+};
+var X = new _(),
+  C = {
+    vertexFormat: X,
+    length: void 0,
+    topRadius: void 0,
+    bottomRadius: void 0,
+    slices: void 0,
+    offsetAttribute: void 0,
+  };
+O.unpack = function (t, n, e) {
+  if (!g(t)) throw new F("array is required");
+  n = x(n, 0);
+  let h = _.unpack(t, n, X);
+  n += _.packedLength;
+  let o = t[n++],
+    r = t[n++],
+    p = t[n++],
+    D = t[n++],
+    w = t[n];
+  return g(e)
+    ? ((e._vertexFormat = _.clone(h, e._vertexFormat)),
+      (e._length = o),
+      (e._topRadius = r),
+      (e._bottomRadius = p),
+      (e._slices = D),
+      (e._offsetAttribute = w === -1 ? void 0 : w),
+      e)
+    : ((C.length = o),
+      (C.topRadius = r),
+      (C.bottomRadius = p),
+      (C.slices = D),
+      (C.offsetAttribute = w === -1 ? void 0 : w),
+      new O(C));
+};
+O.createGeometry = function (t) {
+  let n = t._length,
+    e = t._topRadius,
+    h = t._bottomRadius,
+    o = t._vertexFormat,
+    r = t._slices;
+  if (n <= 0 || e < 0 || h < 0 || (e === 0 && h === 0)) return;
+  let p = r + r,
+    D = r + p,
+    w = p + p,
+    E = Q.computePositions(n, e, h, r, !0),
+    N = o.st ? new Float32Array(w * 2) : void 0,
+    c = o.normal ? new Float32Array(w * 3) : void 0,
+    m = o.tangent ? new Float32Array(w * 3) : void 0,
+    u = o.bitangent ? new Float32Array(w * 3) : void 0,
+    i,
+    U = o.normal || o.tangent || o.bitangent;
+  if (U) {
+    let T = o.tangent || o.bitangent,
+      f = 0,
+      d = 0,
+      l = 0,
+      q = Math.atan2(h - e, n),
+      A = ot;
+    A.z = Math.sin(q);
+    let B = Math.cos(q),
+      R = it,
+      y = nt;
+    for (i = 0; i < r; i++) {
+      let Y = (i / r) * Z.TWO_PI,
+        tt = B * Math.cos(Y),
+        et = B * Math.sin(Y);
+      U &&
+        ((A.x = tt),
+        (A.y = et),
+        T && (R = b.normalize(b.cross(b.UNIT_Z, A, R), R)),
+        o.normal &&
+          ((c[f++] = A.x),
+          (c[f++] = A.y),
+          (c[f++] = A.z),
+          (c[f++] = A.x),
+          (c[f++] = A.y),
+          (c[f++] = A.z)),
+        o.tangent &&
+          ((m[d++] = R.x),
+          (m[d++] = R.y),
+          (m[d++] = R.z),
+          (m[d++] = R.x),
+          (m[d++] = R.y),
+          (m[d++] = R.z)),
+        o.bitangent &&
+          ((y = b.normalize(b.cross(A, R, y), y)),
+          (u[l++] = y.x),
+          (u[l++] = y.y),
+          (u[l++] = y.z),
+          (u[l++] = y.x),
+          (u[l++] = y.y),
+          (u[l++] = y.z)));
+    }
+    for (i = 0; i < r; i++)
+      (o.normal && ((c[f++] = 0), (c[f++] = 0), (c[f++] = -1)),
+        o.tangent && ((m[d++] = 1), (m[d++] = 0), (m[d++] = 0)),
+        o.bitangent && ((u[l++] = 0), (u[l++] = -1), (u[l++] = 0)));
+    for (i = 0; i < r; i++)
+      (o.normal && ((c[f++] = 0), (c[f++] = 0), (c[f++] = 1)),
+        o.tangent && ((m[d++] = 1), (m[d++] = 0), (m[d++] = 0)),
+        o.bitangent && ((u[l++] = 0), (u[l++] = 1), (u[l++] = 0)));
+  }
+  let $ = 12 * r - 12,
+    s = K.createTypedArray(w, $),
+    a = 0,
+    v = 0;
+  for (i = 0; i < r - 1; i++)
+    ((s[a++] = v),
+      (s[a++] = v + 2),
+      (s[a++] = v + 3),
+      (s[a++] = v),
+      (s[a++] = v + 3),
+      (s[a++] = v + 1),
+      (v += 2));
+  for (
+    s[a++] = p - 2,
+      s[a++] = 0,
+      s[a++] = 1,
+      s[a++] = p - 2,
+      s[a++] = 1,
+      s[a++] = p - 1,
+      i = 1;
+    i < r - 1;
+    i++
+  )
+    ((s[a++] = p + i + 1), (s[a++] = p + i), (s[a++] = p));
+  for (i = 1; i < r - 1; i++)
+    ((s[a++] = D), (s[a++] = D + i), (s[a++] = D + i + 1));
+  let V = 0;
+  if (o.st) {
+    let T = Math.max(e, h);
+    for (i = 0; i < w; i++) {
+      let f = b.fromArray(E, i * 3, st);
+      ((N[V++] = (f.x + T) / (2 * T)), (N[V++] = (f.y + T) / (2 * T)));
+    }
+  }
+  let S = new H();
+  (o.position &&
+    (S.position = new P({
+      componentDatatype: L.DOUBLE,
+      componentsPerAttribute: 3,
+      values: E,
+    })),
+    o.normal &&
+      (S.normal = new P({
+        componentDatatype: L.FLOAT,
+        componentsPerAttribute: 3,
+        values: c,
+      })),
+    o.tangent &&
+      (S.tangent = new P({
+        componentDatatype: L.FLOAT,
+        componentsPerAttribute: 3,
+        values: m,
+      })),
+    o.bitangent &&
+      (S.bitangent = new P({
+        componentDatatype: L.FLOAT,
+        componentsPerAttribute: 3,
+        values: u,
+      })),
+    o.st &&
+      (S.st = new P({
+        componentDatatype: L.FLOAT,
+        componentsPerAttribute: 2,
+        values: N,
+      })),
+    (M.x = n * 0.5),
+    (M.y = Math.max(h, e)));
+  let I = new j(b.ZERO, k.magnitude(M));
+  if (g(t._offsetAttribute)) {
+    n = E.length;
+    let T = t._offsetAttribute === z.NONE ? 0 : 1,
+      f = new Uint8Array(n / 3).fill(T);
+    S.applyOffset = new P({
+      componentDatatype: L.UNSIGNED_BYTE,
+      componentsPerAttribute: 1,
+      values: f,
+    });
+  }
+  return new W({
+    attributes: S,
+    indices: s,
+    primitiveType: J.TRIANGLES,
+    boundingSphere: I,
+    offsetAttribute: t._offsetAttribute,
+  });
+};
+var G;
+O.getUnitCylinder = function () {
+  return (
+    g(G) ||
+      (G = O.createGeometry(
+        new O({
+          topRadius: 1,
+          bottomRadius: 1,
+          length: 1,
+          vertexFormat: _.POSITION_ONLY,
+        }),
+      )),
+    G
+  );
+};
+var yt = O;
+export { yt as a };

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

@@ -0,0 +1,50 @@
+/**
+ * @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 { e } from "./chunk-PEYJTJPE.js";
+function t(r) {
+  ((this.name = "RuntimeError"), (this.message = r));
+  let o;
+  try {
+    throw new Error();
+  } catch (s) {
+    o = s.stack;
+  }
+  this.stack = o;
+}
+e(Object.create) &&
+  ((t.prototype = Object.create(Error.prototype)),
+  (t.prototype.constructor = t));
+t.prototype.toString = function () {
+  let r = `${this.name}: ${this.message}`;
+  return (
+    e(this.stack) &&
+      (r += `
+${this.stack.toString()}`),
+    r
+  );
+};
+var c = t;
+export { c as a };

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

@@ -0,0 +1,28 @@
+/**
+ * @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.
+ */
+
+var e = { NONE: 0, TOP: 1, ALL: 2 },
+  t = Object.freeze(e);
+export { t as a };

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

@@ -0,0 +1,124 @@
+/**
+ * @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 C } from "./chunk-AMQUWUD4.js";
+import { a as P } from "./chunk-RXTBM4OI.js";
+import { a as O, b as L } from "./chunk-POASMU2N.js";
+import { a as y } from "./chunk-R6KGAEF6.js";
+import { e as S } from "./chunk-PEYJTJPE.js";
+var T = {};
+function b(a, e) {
+  return (
+    y.equalsEpsilon(a.latitude, e.latitude, y.EPSILON10) &&
+    y.equalsEpsilon(a.longitude, e.longitude, y.EPSILON10)
+  );
+}
+var q = new L(),
+  v = new L();
+function w(a, e, i, h) {
+  e = P(e, O.equalsEpsilon);
+  let p = e.length;
+  if (p < 2) return;
+  let E = S(h),
+    u = S(i),
+    l = new Array(p),
+    g = new Array(p),
+    r = new Array(p),
+    d = e[0];
+  l[0] = d;
+  let f = a.cartesianToCartographic(d, q);
+  (u && (f.height = i[0]), (g[0] = f.height), E ? (r[0] = h[0]) : (r[0] = 0));
+  let o = g[0],
+    m = r[0],
+    t = o === m,
+    n = 1;
+  for (let c = 1; c < p; ++c) {
+    let A = e[c],
+      s = a.cartesianToCartographic(A, v);
+    (u && (s.height = i[c]),
+      (t = t && s.height === 0),
+      b(f, s)
+        ? f.height < s.height && (g[n - 1] = s.height)
+        : ((l[n] = A),
+          (g[n] = s.height),
+          E ? (r[n] = h[c]) : (r[n] = 0),
+          (t = t && g[n] === r[n]),
+          L.clone(s, f),
+          ++n));
+  }
+  if (!(t || n < 2))
+    return (
+      (l.length = n),
+      (g.length = n),
+      (r.length = n),
+      { positions: l, topHeights: g, bottomHeights: r }
+    );
+}
+var D = new Array(2),
+  F = new Array(2),
+  B = {
+    positions: void 0,
+    height: void 0,
+    granularity: void 0,
+    ellipsoid: void 0,
+  };
+T.computePositions = function (a, e, i, h, p, E) {
+  let u = w(a, e, i, h);
+  if (!S(u)) return;
+  ((e = u.positions), (i = u.topHeights), (h = u.bottomHeights));
+  let l = e.length,
+    g = l - 2,
+    r,
+    d,
+    f = y.chordLength(p, a.maximumRadius),
+    o = B;
+  if (((o.minDistance = f), (o.ellipsoid = a), E)) {
+    let m = 0,
+      t;
+    for (t = 0; t < l - 1; t++) m += C.numberOfPoints(e[t], e[t + 1], f) + 1;
+    ((r = new Float64Array(m * 3)), (d = new Float64Array(m * 3)));
+    let n = D,
+      c = F;
+    ((o.positions = n), (o.height = c));
+    let A = 0;
+    for (t = 0; t < l - 1; t++) {
+      ((n[0] = e[t]), (n[1] = e[t + 1]), (c[0] = i[t]), (c[1] = i[t + 1]));
+      let s = C.generateArc(o);
+      (r.set(s, A),
+        (c[0] = h[t]),
+        (c[1] = h[t + 1]),
+        d.set(C.generateArc(o), A),
+        (A += s.length));
+    }
+  } else
+    ((o.positions = e),
+      (o.height = i),
+      (r = new Float64Array(C.generateArc(o))),
+      (o.height = h),
+      (d = new Float64Array(C.generateArc(o))));
+  return { bottomPositions: d, topPositions: r, numCorners: g };
+};
+var j = T;
+export { j as a };

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

@@ -0,0 +1,31 @@
+/**
+ * @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.
+ */
+
+function u(e, n) {
+  return e ?? n;
+}
+u.EMPTY_OBJECT = Object.freeze({});
+var t = u;
+export { t as a };