create-swdg-frontend 0.1.0

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

@@ -0,0 +1,341 @@
+/**
+ * @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, b as z, i as S } from "./chunk-7Z5IIKOJ.js";
+import { a as y } from "./chunk-KZNJOCYU.js";
+import { a as C, c as T, e as x } from "./chunk-POASMU2N.js";
+import { a as h } from "./chunk-R6KGAEF6.js";
+import { a as u, b as a } from "./chunk-UH2WFNTA.js";
+import { e as b } from "./chunk-PEYJTJPE.js";
+var c = {
+  SCALAR: "SCALAR",
+  VEC2: "VEC2",
+  VEC3: "VEC3",
+  VEC4: "VEC4",
+  MAT2: "MAT2",
+  MAT3: "MAT3",
+  MAT4: "MAT4",
+};
+c.getMathType = function (e) {
+  switch (e) {
+    case c.SCALAR:
+      return Number;
+    case c.VEC2:
+      return T;
+    case c.VEC3:
+      return C;
+    case c.VEC4:
+      return w;
+    case c.MAT2:
+      return S;
+    case c.MAT3:
+      return x;
+    case c.MAT4:
+      return z;
+    default:
+      throw new u("attributeType is not a valid value.");
+  }
+};
+c.getNumberOfComponents = function (e) {
+  switch (e) {
+    case c.SCALAR:
+      return 1;
+    case c.VEC2:
+      return 2;
+    case c.VEC3:
+      return 3;
+    case c.VEC4:
+    case c.MAT2:
+      return 4;
+    case c.MAT3:
+      return 9;
+    case c.MAT4:
+      return 16;
+    default:
+      throw new u("attributeType is not a valid value.");
+  }
+};
+c.getAttributeLocationCount = function (e) {
+  switch (e) {
+    case c.SCALAR:
+    case c.VEC2:
+    case c.VEC3:
+    case c.VEC4:
+      return 1;
+    case c.MAT2:
+      return 2;
+    case c.MAT3:
+      return 3;
+    case c.MAT4:
+      return 4;
+    default:
+      throw new u("attributeType is not a valid value.");
+  }
+};
+c.getGlslType = function (e) {
+  switch ((a.typeOf.string("attributeType", e), e)) {
+    case c.SCALAR:
+      return "float";
+    case c.VEC2:
+      return "vec2";
+    case c.VEC3:
+      return "vec3";
+    case c.VEC4:
+      return "vec4";
+    case c.MAT2:
+      return "mat2";
+    case c.MAT3:
+      return "mat3";
+    case c.MAT4:
+      return "mat4";
+    default:
+      throw new u("attributeType is not a valid value.");
+  }
+};
+var N = Object.freeze(c);
+var V = 1 / 256,
+  D = 256,
+  r = {};
+r.octEncodeInRange = function (e, t, n) {
+  (a.defined("vector", e), a.defined("result", n));
+  let o = C.magnitudeSquared(e);
+  if (Math.abs(o - 1) > h.EPSILON6) throw new u("vector must be normalized.");
+  if (
+    ((n.x = e.x / (Math.abs(e.x) + Math.abs(e.y) + Math.abs(e.z))),
+    (n.y = e.y / (Math.abs(e.x) + Math.abs(e.y) + Math.abs(e.z))),
+    e.z < 0)
+  ) {
+    let i = n.x,
+      d = n.y;
+    ((n.x = (1 - Math.abs(d)) * h.signNotZero(i)),
+      (n.y = (1 - Math.abs(i)) * h.signNotZero(d)));
+  }
+  return ((n.x = h.toSNorm(n.x, t)), (n.y = h.toSNorm(n.y, t)), n);
+};
+r.octEncode = function (e, t) {
+  return r.octEncodeInRange(e, 255, t);
+};
+var A = new T(),
+  F = new Uint8Array(1);
+function E(e) {
+  return ((F[0] = e), F[0]);
+}
+r.octEncodeToCartesian4 = function (e, t) {
+  return (
+    r.octEncodeInRange(e, 65535, A),
+    (t.x = E(A.x * V)),
+    (t.y = E(A.x)),
+    (t.z = E(A.y * V)),
+    (t.w = E(A.y)),
+    t
+  );
+};
+r.octDecodeInRange = function (e, t, n, o) {
+  if ((a.defined("result", o), e < 0 || e > n || t < 0 || t > n))
+    throw new u(
+      `x and y must be unsigned normalized integers between 0 and ${n}`,
+    );
+  if (
+    ((o.x = h.fromSNorm(e, n)),
+    (o.y = h.fromSNorm(t, n)),
+    (o.z = 1 - (Math.abs(o.x) + Math.abs(o.y))),
+    o.z < 0)
+  ) {
+    let i = o.x;
+    ((o.x = (1 - Math.abs(o.y)) * h.signNotZero(i)),
+      (o.y = (1 - Math.abs(i)) * h.signNotZero(o.y)));
+  }
+  return C.normalize(o, o);
+};
+r.octDecode = function (e, t, n) {
+  return r.octDecodeInRange(e, t, 255, n);
+};
+r.octDecodeFromCartesian4 = function (e, t) {
+  (a.typeOf.object("encoded", e), a.typeOf.object("result", t));
+  let n = e.x,
+    o = e.y,
+    i = e.z,
+    d = e.w;
+  if (
+    n < 0 ||
+    n > 255 ||
+    o < 0 ||
+    o > 255 ||
+    i < 0 ||
+    i > 255 ||
+    d < 0 ||
+    d > 255
+  )
+    throw new u(
+      "x, y, z, and w must be unsigned normalized integers between 0 and 255",
+    );
+  let f = n * D + o,
+    s = i * D + d;
+  return r.octDecodeInRange(f, s, 65535, t);
+};
+r.octPackFloat = function (e) {
+  return (a.defined("encoded", e), 256 * e.x + e.y);
+};
+var l = new T();
+r.octEncodeFloat = function (e) {
+  return (r.octEncode(e, l), r.octPackFloat(l));
+};
+r.octDecodeFloat = function (e, t) {
+  a.defined("value", e);
+  let n = e / 256,
+    o = Math.floor(n),
+    i = (n - o) * 256;
+  return r.octDecode(o, i, t);
+};
+r.octPack = function (e, t, n, o) {
+  (a.defined("v1", e),
+    a.defined("v2", t),
+    a.defined("v3", n),
+    a.defined("result", o));
+  let i = r.octEncodeFloat(e),
+    d = r.octEncodeFloat(t),
+    f = r.octEncode(n, l);
+  return ((o.x = 65536 * f.x + i), (o.y = 65536 * f.y + d), o);
+};
+r.octUnpack = function (e, t, n, o) {
+  (a.defined("packed", e),
+    a.defined("v1", t),
+    a.defined("v2", n),
+    a.defined("v3", o));
+  let i = e.x / 65536,
+    d = Math.floor(i),
+    f = (i - d) * 65536;
+  i = e.y / 65536;
+  let s = Math.floor(i),
+    m = (i - s) * 65536;
+  (r.octDecodeFloat(f, t), r.octDecodeFloat(m, n), r.octDecode(d, s, o));
+};
+r.compressTextureCoordinates = function (e) {
+  a.defined("textureCoordinates", e);
+  let t = (e.x * 4095) | 0,
+    n = (e.y * 4095) | 0;
+  return 4096 * t + n;
+};
+r.decompressTextureCoordinates = function (e, t) {
+  (a.defined("compressed", e), a.defined("result", t));
+  let n = e / 4096,
+    o = Math.floor(n);
+  return ((t.x = o / 4095), (t.y = (e - o * 4096) / 4095), t);
+};
+function g(e) {
+  return (e >> 1) ^ -(e & 1);
+}
+r.zigZagDeltaDecode = function (e, t, n) {
+  (a.defined("uBuffer", e),
+    a.defined("vBuffer", t),
+    a.typeOf.number.equals(
+      "uBuffer.length",
+      "vBuffer.length",
+      e.length,
+      t.length,
+    ),
+    b(n) &&
+      a.typeOf.number.equals(
+        "uBuffer.length",
+        "heightBuffer.length",
+        e.length,
+        n.length,
+      ));
+  let o = e.length,
+    i = 0,
+    d = 0,
+    f = 0;
+  for (let s = 0; s < o; ++s)
+    ((i += g(e[s])),
+      (d += g(t[s])),
+      (e[s] = i),
+      (t[s] = d),
+      b(n) && ((f += g(n[s])), (n[s] = f)));
+};
+r.dequantize = function (e, t, n, o) {
+  (a.defined("typedArray", e),
+    a.defined("componentDatatype", t),
+    a.defined("type", n),
+    a.defined("count", o));
+  let i = N.getNumberOfComponents(n),
+    d;
+  switch (t) {
+    case y.BYTE:
+      d = 127;
+      break;
+    case y.UNSIGNED_BYTE:
+      d = 255;
+      break;
+    case y.SHORT:
+      d = 32767;
+      break;
+    case y.UNSIGNED_SHORT:
+      d = 65535;
+      break;
+    case y.INT:
+      d = 2147483647;
+      break;
+    case y.UNSIGNED_INT:
+      d = 4294967295;
+      break;
+    default:
+      throw new u(`Cannot dequantize component datatype: ${t}`);
+  }
+  let f = new Float32Array(o * i);
+  for (let s = 0; s < o; s++)
+    for (let m = 0; m < i; m++) {
+      let p = s * i + m;
+      f[p] = Math.max(e[p] / d, -1);
+    }
+  return f;
+};
+r.decodeRGB565 = function (e, t) {
+  a.defined("typedArray", e);
+  let n = e.length * 3;
+  b(t) &&
+    a.typeOf.number.equals(
+      "result.length",
+      "typedArray.length * 3",
+      t.length,
+      n,
+    );
+  let o = e.length;
+  b(t) || (t = new Float32Array(o * 3));
+  let i = 31,
+    d = 63,
+    f = 1 / 31,
+    s = 1 / 63;
+  for (let m = 0; m < o; m++) {
+    let p = e[m],
+      R = p >> 11,
+      I = (p >> 5) & d,
+      O = p & i,
+      M = 3 * m;
+    ((t[M] = R * f), (t[M + 1] = I * s), (t[M + 2] = O * f));
+  }
+  return t;
+};
+var W = r;
+export { W as a };

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

@@ -0,0 +1,269 @@
+/**
+ * @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-W23CU777.js";
+import { a as M } from "./chunk-FYOYUPXG.js";
+import { b as G } from "./chunk-TAMCUKAR.js";
+import { a as b } from "./chunk-PDMQLSBL.js";
+import { b as R } from "./chunk-7Z5IIKOJ.js";
+import { a, b as L, d as z } from "./chunk-POASMU2N.js";
+import { a as E } from "./chunk-R6KGAEF6.js";
+import { a as C } from "./chunk-IUA6FAOZ.js";
+import { a as I } from "./chunk-UH2WFNTA.js";
+import { e as T } from "./chunk-PEYJTJPE.js";
+var p = {};
+p.numberOfPoints = function (r, n, o) {
+  let e = a.distance(r, n);
+  return Math.ceil(e / o);
+};
+p.numberOfPointsRhumbLine = function (r, n, o) {
+  let e =
+    Math.pow(r.longitude - n.longitude, 2) +
+    Math.pow(r.latitude - n.latitude, 2);
+  return Math.max(1, Math.ceil(Math.sqrt(e / (o * o))));
+};
+var V = new L();
+p.extractHeights = function (r, n) {
+  let o = r.length,
+    e = new Array(o);
+  for (let t = 0; t < o; t++) {
+    let l = r[t];
+    e[t] = n.cartesianToCartographic(l, V).height;
+  }
+  return e;
+};
+var Y = new R(),
+  F = new a(),
+  v = new a(),
+  j = new b(a.UNIT_X, 0),
+  H = new a(),
+  J = new b(a.UNIT_X, 0),
+  K = new a(),
+  Q = new a(),
+  k = [];
+function q(r, n, o) {
+  let e = k;
+  e.length = r;
+  let t;
+  if (n === o) {
+    for (t = 0; t < r; t++) e[t] = n;
+    return e;
+  }
+  let u = (o - n) / r;
+  for (t = 0; t < r; t++) {
+    let d = n + t * u;
+    e[t] = d;
+  }
+  return e;
+}
+var x = new L(),
+  N = new L(),
+  D = new a(),
+  B = new a(),
+  W = new a(),
+  O = new _(),
+  S = new M();
+function $(r, n, o, e, t, l, u, d) {
+  let i = e.scaleToGeodeticSurface(r, B),
+    w = e.scaleToGeodeticSurface(n, W),
+    h = p.numberOfPoints(r, n, o),
+    f = e.cartesianToCartographic(i, x),
+    y = e.cartesianToCartographic(w, N),
+    g = q(h, t, l);
+  O.setEndPoints(f, y);
+  let P = O.surfaceDistance / h,
+    c = d;
+  f.height = t;
+  let s = e.cartographicToCartesian(f, D);
+  (a.pack(s, u, c), (c += 3));
+  for (let m = 1; m < h; m++) {
+    let A = O.interpolateUsingSurfaceDistance(m * P, N);
+    ((A.height = g[m]),
+      (s = e.cartographicToCartesian(A, D)),
+      a.pack(s, u, c),
+      (c += 3));
+  }
+  return c;
+}
+function tt(r, n, o, e, t, l, u, d) {
+  let i = e.cartesianToCartographic(r, x),
+    w = e.cartesianToCartographic(n, N),
+    h = p.numberOfPointsRhumbLine(i, w, o);
+  ((i.height = 0), (w.height = 0));
+  let f = q(h, t, l);
+  (S.ellipsoid.equals(e) || (S = new M(void 0, void 0, e)),
+    S.setEndPoints(i, w));
+  let y = S.surfaceDistance / h,
+    g = d;
+  i.height = t;
+  let P = e.cartographicToCartesian(i, D);
+  (a.pack(P, u, g), (g += 3));
+  for (let c = 1; c < h; c++) {
+    let s = S.interpolateUsingSurfaceDistance(c * y, N);
+    ((s.height = f[c]),
+      (P = e.cartographicToCartesian(s, D)),
+      a.pack(P, u, g),
+      (g += 3));
+  }
+  return g;
+}
+p.wrapLongitude = function (r, n) {
+  let o = [],
+    e = [];
+  if (T(r) && r.length > 0) {
+    n = C(n, R.IDENTITY);
+    let t = R.inverseTransformation(n, Y),
+      l = R.multiplyByPoint(t, a.ZERO, F),
+      u = a.normalize(R.multiplyByPointAsVector(t, a.UNIT_Y, v), v),
+      d = b.fromPointNormal(l, u, j),
+      i = a.normalize(R.multiplyByPointAsVector(t, a.UNIT_X, H), H),
+      w = b.fromPointNormal(l, i, J),
+      h = 1;
+    o.push(a.clone(r[0]));
+    let f = o[0],
+      y = r.length;
+    for (let g = 1; g < y; ++g) {
+      let P = r[g];
+      if (b.getPointDistance(w, f) < 0 || b.getPointDistance(w, P) < 0) {
+        let c = G.lineSegmentPlane(f, P, d, K);
+        if (T(c)) {
+          let s = a.multiplyByScalar(u, 5e-9, Q);
+          (b.getPointDistance(d, f) < 0 && a.negate(s, s),
+            o.push(a.add(c, s, new a())),
+            e.push(h + 1),
+            a.negate(s, s),
+            o.push(a.add(c, s, new a())),
+            (h = 1));
+        }
+      }
+      (o.push(a.clone(r[g])), h++, (f = P));
+    }
+    e.push(h);
+  }
+  return { positions: o, lengths: e };
+};
+p.generateArc = function (r) {
+  T(r) || (r = {});
+  let n = r.positions;
+  if (!T(n)) throw new I("options.positions is required.");
+  let o = n.length,
+    e = C(r.ellipsoid, z.default),
+    t = C(r.height, 0),
+    l = Array.isArray(t);
+  if (o < 1) return [];
+  if (o === 1) {
+    let c = e.scaleToGeodeticSurface(n[0], B);
+    if (((t = l ? t[0] : t), t !== 0)) {
+      let s = e.geodeticSurfaceNormal(c, D);
+      (a.multiplyByScalar(s, t, s), a.add(c, s, c));
+    }
+    return [c.x, c.y, c.z];
+  }
+  let u = r.minDistance;
+  if (!T(u)) {
+    let c = C(r.granularity, E.RADIANS_PER_DEGREE);
+    u = E.chordLength(c, e.maximumRadius);
+  }
+  let d = 0,
+    i;
+  for (i = 0; i < o - 1; i++) d += p.numberOfPoints(n[i], n[i + 1], u);
+  let w = (d + 1) * 3,
+    h = new Array(w),
+    f = 0;
+  for (i = 0; i < o - 1; i++) {
+    let c = n[i],
+      s = n[i + 1],
+      m = l ? t[i] : t,
+      A = l ? t[i + 1] : t;
+    f = $(c, s, u, e, m, A, h, f);
+  }
+  k.length = 0;
+  let y = n[o - 1],
+    g = e.cartesianToCartographic(y, x);
+  g.height = l ? t[o - 1] : t;
+  let P = e.cartographicToCartesian(g, D);
+  return (a.pack(P, h, w - 3), h);
+};
+var U = new L(),
+  et = new L();
+p.generateRhumbArc = function (r) {
+  T(r) || (r = {});
+  let n = r.positions;
+  if (!T(n)) throw new I("options.positions is required.");
+  let o = n.length,
+    e = C(r.ellipsoid, z.default),
+    t = C(r.height, 0),
+    l = Array.isArray(t);
+  if (o < 1) return [];
+  if (o === 1) {
+    let m = e.scaleToGeodeticSurface(n[0], B);
+    if (((t = l ? t[0] : t), t !== 0)) {
+      let A = e.geodeticSurfaceNormal(m, D);
+      (a.multiplyByScalar(A, t, A), a.add(m, A, m));
+    }
+    return [m.x, m.y, m.z];
+  }
+  let u = C(r.granularity, E.RADIANS_PER_DEGREE),
+    d = 0,
+    i,
+    w = e.cartesianToCartographic(n[0], U),
+    h;
+  for (i = 0; i < o - 1; i++)
+    ((h = e.cartesianToCartographic(n[i + 1], et)),
+      (d += p.numberOfPointsRhumbLine(w, h, u)),
+      (w = L.clone(h, U)));
+  let f = (d + 1) * 3,
+    y = new Array(f),
+    g = 0;
+  for (i = 0; i < o - 1; i++) {
+    let m = n[i],
+      A = n[i + 1],
+      X = l ? t[i] : t,
+      Z = l ? t[i + 1] : t;
+    g = tt(m, A, u, e, X, Z, y, g);
+  }
+  k.length = 0;
+  let P = n[o - 1],
+    c = e.cartesianToCartographic(P, x);
+  c.height = l ? t[o - 1] : t;
+  let s = e.cartographicToCartesian(c, D);
+  return (a.pack(s, y, f - 3), y);
+};
+p.generateCartesianArc = function (r) {
+  let n = p.generateArc(r),
+    o = n.length / 3,
+    e = new Array(o);
+  for (let t = 0; t < o; t++) e[t] = a.unpack(n, t * 3);
+  return e;
+};
+p.generateCartesianRhumbArc = function (r) {
+  let n = p.generateRhumbArc(r),
+    o = n.length / 3,
+    e = new Array(o);
+  for (let t = 0; t < o; t++) e[t] = a.unpack(n, t * 3);
+  return e;
+};
+var mt = p;
+export { mt as a };

package/template/public/Cesium1.119/Workers/chunk-ATPDRNKI.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, GEODESIC: 1, RHUMB: 2 },
+  t = Object.freeze(e);
+export { t as a };