create-swdg-frontend 0.1.0

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

@@ -0,0 +1,672 @@
+/**
+ * @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 R } from "./chunk-ATPDRNKI.js";
+import { a as st } from "./chunk-QB3MDM4J.js";
+import { a as Z, b as H } from "./chunk-O5IJ3OGP.js";
+import { a as V } from "./chunk-RXTBM4OI.js";
+import { a as U } from "./chunk-FYOYUPXG.js";
+import { b as it } from "./chunk-TAMCUKAR.js";
+import { a as ct } from "./chunk-PDMQLSBL.js";
+import { a as ot } from "./chunk-P37AI2DW.js";
+import { a as nt } from "./chunk-T6BE4RZK.js";
+import { b as J, c as X, d as z } from "./chunk-X5IHHI6X.js";
+import { f as K } from "./chunk-7Z5IIKOJ.js";
+import { a as k } from "./chunk-KZNJOCYU.js";
+import { a as w, b as q, c as M, d as et, e as F } from "./chunk-POASMU2N.js";
+import { a as I } from "./chunk-R6KGAEF6.js";
+import { a as tt } from "./chunk-IUA6FAOZ.js";
+import { e as x } from "./chunk-PEYJTJPE.js";
+function dt(n, i) {
+  ((this.positions = x(n) ? n : []), (this.holes = x(i) ? i : []));
+}
+var rt = dt;
+function S() {
+  ((this._array = []), (this._offset = 0), (this._length = 0));
+}
+Object.defineProperties(S.prototype, {
+  length: {
+    get: function () {
+      return this._length;
+    },
+  },
+});
+S.prototype.enqueue = function (n) {
+  (this._array.push(n), this._length++);
+};
+S.prototype.dequeue = function () {
+  if (this._length === 0) return;
+  let n = this._array,
+    i = this._offset,
+    u = n[i];
+  return (
+    (n[i] = void 0),
+    i++,
+    i > 10 && i * 2 > n.length && ((this._array = n.slice(i)), (i = 0)),
+    (this._offset = i),
+    this._length--,
+    u
+  );
+};
+S.prototype.peek = function () {
+  if (this._length !== 0) return this._array[this._offset];
+};
+S.prototype.contains = function (n) {
+  return this._array.indexOf(n) !== -1;
+};
+S.prototype.clear = function () {
+  this._array.length = this._offset = this._length = 0;
+};
+S.prototype.sort = function (n) {
+  (this._offset > 0 &&
+    ((this._array = this._array.slice(this._offset)), (this._offset = 0)),
+    this._array.sort(n));
+};
+var $ = S;
+var b = {};
+b.computeHierarchyPackedLength = function (n, i) {
+  let u = 0,
+    c = [n];
+  for (; c.length > 0; ) {
+    let r = c.pop();
+    if (!x(r)) continue;
+    u += 2;
+    let a = r.positions,
+      t = r.holes;
+    if ((x(a) && a.length > 0 && (u += a.length * i.packedLength), x(t))) {
+      let o = t.length;
+      for (let e = 0; e < o; ++e) c.push(t[e]);
+    }
+  }
+  return u;
+};
+b.packPolygonHierarchy = function (n, i, u, c) {
+  let r = [n];
+  for (; r.length > 0; ) {
+    let a = r.pop();
+    if (!x(a)) continue;
+    let t = a.positions,
+      o = a.holes;
+    if (
+      ((i[u++] = x(t) ? t.length : 0), (i[u++] = x(o) ? o.length : 0), x(t))
+    ) {
+      let e = t.length;
+      for (let s = 0; s < e; ++s, u += c.packedLength) c.pack(t[s], i, u);
+    }
+    if (x(o)) {
+      let e = o.length;
+      for (let s = 0; s < e; ++s) r.push(o[s]);
+    }
+  }
+  return u;
+};
+b.unpackPolygonHierarchy = function (n, i, u) {
+  let c = n[i++],
+    r = n[i++],
+    a = new Array(c),
+    t = r > 0 ? new Array(r) : void 0;
+  for (let o = 0; o < c; ++o, i += u.packedLength) a[o] = u.unpack(n, i);
+  for (let o = 0; o < r; ++o)
+    ((t[o] = b.unpackPolygonHierarchy(n, i, u)),
+      (i = t[o].startingIndex),
+      delete t[o].startingIndex);
+  return { positions: a, holes: t, startingIndex: i };
+};
+var O = new M();
+function ht(n, i, u, c) {
+  return (
+    M.subtract(i, n, O),
+    M.multiplyByScalar(O, u / c, O),
+    M.add(n, O, O),
+    [O.x, O.y]
+  );
+}
+var G = new w();
+function gt(n, i, u, c) {
+  return (
+    w.subtract(i, n, G),
+    w.multiplyByScalar(G, u / c, G),
+    w.add(n, G, G),
+    [G.x, G.y, G.z]
+  );
+}
+b.subdivideLineCount = function (n, i, u) {
+  let r = w.distance(n, i) / u,
+    a = Math.max(0, Math.ceil(I.log2(r)));
+  return Math.pow(2, a);
+};
+var j = new q(),
+  Q = new q(),
+  pt = new q(),
+  mt = new w(),
+  Y = new U();
+b.subdivideRhumbLineCount = function (n, i, u, c) {
+  let r = n.cartesianToCartographic(i, j),
+    a = n.cartesianToCartographic(u, Q),
+    o = new U(r, a, n).surfaceDistance / c,
+    e = Math.max(0, Math.ceil(I.log2(o)));
+  return Math.pow(2, e);
+};
+b.subdivideTexcoordLine = function (n, i, u, c, r, a) {
+  let t = b.subdivideLineCount(u, c, r),
+    o = M.distance(n, i),
+    e = o / t,
+    s = a;
+  s.length = t * 2;
+  let l = 0;
+  for (let h = 0; h < t; h++) {
+    let f = ht(n, i, h * e, o);
+    ((s[l++] = f[0]), (s[l++] = f[1]));
+  }
+  return s;
+};
+b.subdivideLine = function (n, i, u, c) {
+  let r = b.subdivideLineCount(n, i, u),
+    a = w.distance(n, i),
+    t = a / r;
+  x(c) || (c = []);
+  let o = c;
+  o.length = r * 3;
+  let e = 0;
+  for (let s = 0; s < r; s++) {
+    let l = gt(n, i, s * t, a);
+    ((o[e++] = l[0]), (o[e++] = l[1]), (o[e++] = l[2]));
+  }
+  return o;
+};
+b.subdivideTexcoordRhumbLine = function (n, i, u, c, r, a, t) {
+  let o = u.cartesianToCartographic(c, j),
+    e = u.cartesianToCartographic(r, Q);
+  Y.setEndPoints(o, e);
+  let s = Y.surfaceDistance / a,
+    l = Math.max(0, Math.ceil(I.log2(s))),
+    h = Math.pow(2, l),
+    f = M.distance(n, i),
+    g = f / h,
+    m = t;
+  m.length = h * 2;
+  let p = 0;
+  for (let d = 0; d < h; d++) {
+    let y = ht(n, i, d * g, f);
+    ((m[p++] = y[0]), (m[p++] = y[1]));
+  }
+  return m;
+};
+b.subdivideRhumbLine = function (n, i, u, c, r) {
+  let a = n.cartesianToCartographic(i, j),
+    t = n.cartesianToCartographic(u, Q),
+    o = new U(a, t, n),
+    e = o.surfaceDistance / c,
+    s = Math.max(0, Math.ceil(I.log2(e))),
+    l = Math.pow(2, s),
+    h = o.surfaceDistance / l;
+  x(r) || (r = []);
+  let f = r;
+  f.length = l * 3;
+  let g = 0;
+  for (let m = 0; m < l; m++) {
+    let p = o.interpolateUsingSurfaceDistance(m * h, pt),
+      d = n.cartographicToCartesian(p, mt);
+    ((f[g++] = d.x), (f[g++] = d.y), (f[g++] = d.z));
+  }
+  return f;
+};
+var yt = new w(),
+  xt = new w(),
+  wt = new w(),
+  bt = new w();
+b.scaleToGeodeticHeightExtruded = function (n, i, u, c, r) {
+  c = tt(c, et.default);
+  let a = yt,
+    t = xt,
+    o = wt,
+    e = bt;
+  if (x(n) && x(n.attributes) && x(n.attributes.position)) {
+    let s = n.attributes.position.values,
+      l = s.length / 2;
+    for (let h = 0; h < l; h += 3)
+      (w.fromArray(s, h, o),
+        c.geodeticSurfaceNormal(o, a),
+        (e = c.scaleToGeodeticSurface(o, e)),
+        (t = w.multiplyByScalar(a, u, t)),
+        (t = w.add(e, t, t)),
+        (s[h + l] = t.x),
+        (s[h + 1 + l] = t.y),
+        (s[h + 2 + l] = t.z),
+        r && (e = w.clone(o, e)),
+        (t = w.multiplyByScalar(a, i, t)),
+        (t = w.add(e, t, t)),
+        (s[h] = t.x),
+        (s[h + 1] = t.y),
+        (s[h + 2] = t.z));
+  }
+  return n;
+};
+b.polygonOutlinesFromHierarchy = function (n, i, u) {
+  let c = [],
+    r = new $();
+  r.enqueue(n);
+  let a, t, o;
+  for (; r.length !== 0; ) {
+    let e = r.dequeue(),
+      s = e.positions;
+    if (i)
+      for (o = s.length, a = 0; a < o; a++)
+        u.scaleToGeodeticSurface(s[a], s[a]);
+    if (((s = V(s, w.equalsEpsilon, !0)), s.length < 3)) continue;
+    let l = e.holes ? e.holes.length : 0;
+    for (a = 0; a < l; a++) {
+      let h = e.holes[a],
+        f = h.positions;
+      if (i)
+        for (o = f.length, t = 0; t < o; ++t)
+          u.scaleToGeodeticSurface(f[t], f[t]);
+      if (((f = V(f, w.equalsEpsilon, !0)), f.length < 3)) continue;
+      c.push(f);
+      let g = 0;
+      for (x(h.holes) && (g = h.holes.length), t = 0; t < g; t++)
+        r.enqueue(h.holes[t]);
+    }
+    c.push(s);
+  }
+  return c;
+};
+var Lt = new q();
+function Tt(n, i, u) {
+  let c = u.cartesianToCartographic(n, j),
+    r = u.cartesianToCartographic(i, Q);
+  if (Math.sign(c.latitude) === Math.sign(r.latitude)) return;
+  Y.setEndPoints(c, r);
+  let a = Y.findIntersectionWithLatitude(0, Lt);
+  if (!x(a)) return;
+  let t = Math.min(c.longitude, r.longitude),
+    o = Math.max(c.longitude, r.longitude);
+  if (Math.abs(o - t) > I.PI) {
+    let e = t;
+    ((t = o), (o = e));
+  }
+  if (!(a.longitude < t || a.longitude > o))
+    return u.cartographicToCartesian(a);
+}
+function Et(n, i, u, c) {
+  if (c === R.RHUMB) return Tt(n, i, u);
+  let r = it.lineSegmentPlane(n, i, ct.ORIGIN_XY_PLANE);
+  if (x(r)) return u.scaleToGeodeticSurface(r, r);
+}
+var vt = new q();
+function Ct(n, i, u) {
+  let c = [],
+    r,
+    a,
+    t,
+    o,
+    e,
+    s = 0;
+  for (; s < n.length; ) {
+    ((r = n[s]),
+      (a = n[(s + 1) % n.length]),
+      (t = I.sign(r.z)),
+      (o = I.sign(a.z)));
+    let l = (h) => i.cartesianToCartographic(h, vt).longitude;
+    if (t === 0)
+      c.push({ position: s, type: t, visited: !1, next: o, theta: l(r) });
+    else if (o !== 0) {
+      if (((e = Et(r, a, i, u)), ++s, !x(e))) continue;
+      (n.splice(s, 0, e),
+        c.push({ position: s, type: t, visited: !1, next: o, theta: l(e) }));
+    }
+    ++s;
+  }
+  return c;
+}
+function lt(n, i, u, c, r, a, t) {
+  let o = [],
+    e = a,
+    s = (h) => (f) => f.position === h,
+    l = [];
+  do {
+    let h = u[e];
+    o.push(h);
+    let f = c.findIndex(s(e)),
+      g = c[f];
+    if (!x(g)) {
+      ++e;
+      continue;
+    }
+    let { visited: m, type: p, next: d } = g;
+    if (((g.visited = !0), p === 0)) {
+      if (d === 0) {
+        let C = c[f - (t ? 1 : -1)];
+        if (C?.position === e + 1) C.visited = !0;
+        else {
+          ++e;
+          continue;
+        }
+      }
+      if ((!m && t && d > 0) || (a === e && !t && d < 0)) {
+        ++e;
+        continue;
+      }
+    }
+    if (!(t ? p >= 0 : p <= 0)) {
+      ++e;
+      continue;
+    }
+    m || l.push(e);
+    let L = f + (t ? 1 : -1),
+      _ = c[L];
+    if (!x(_)) {
+      ++e;
+      continue;
+    }
+    e = _.position;
+  } while (e < u.length && e >= 0 && e !== a && o.length < u.length);
+  n.splice(i, r, o);
+  for (let h of l) i = lt(n, ++i, u, c, 0, h, !t);
+  return i;
+}
+b.splitPolygonsOnEquator = function (n, i, u, c) {
+  (x(c) || (c = []), c.splice(0, 0, ...n), (c.length = n.length));
+  let r = 0;
+  for (; r < c.length; ) {
+    let a = c[r],
+      t = a.slice();
+    if (a.length < 3) {
+      ((c[r] = t), ++r);
+      continue;
+    }
+    let o = Ct(t, i, u);
+    if (t.length === a.length || o.length <= 1) {
+      ((c[r] = t), ++r);
+      continue;
+    }
+    o.sort((s, l) => s.theta - l.theta);
+    let e = t[0].z >= 0;
+    r = lt(c, r, t, o, 1, 0, e);
+  }
+  return c;
+};
+b.polygonsFromHierarchy = function (n, i, u, c, r, a) {
+  let t = [],
+    o = [],
+    e = new $();
+  e.enqueue(n);
+  let s = x(a);
+  for (; e.length !== 0; ) {
+    let l = e.dequeue(),
+      h = l.positions,
+      f = l.holes,
+      g,
+      m;
+    if (c)
+      for (m = h.length, g = 0; g < m; g++)
+        r.scaleToGeodeticSurface(h[g], h[g]);
+    if ((i || (h = V(h, w.equalsEpsilon, !0)), h.length < 3)) continue;
+    let p = u(h);
+    if (!x(p)) continue;
+    let d = [],
+      y = H.computeWindingOrder2D(p);
+    if ((y === Z.CLOCKWISE && (p.reverse(), (h = h.slice().reverse())), s)) {
+      s = !1;
+      let P = [h];
+      if (((P = a(P, P)), P.length > 1)) {
+        for (let v of P) e.enqueue(new rt(v, f));
+        continue;
+      }
+    }
+    let L = h.slice(),
+      _ = x(f) ? f.length : 0,
+      C = [],
+      T;
+    for (g = 0; g < _; g++) {
+      let P = f[g],
+        v = P.positions;
+      if (c)
+        for (m = v.length, T = 0; T < m; ++T)
+          r.scaleToGeodeticSurface(v[T], v[T]);
+      if ((i || (v = V(v, w.equalsEpsilon, !0)), v.length < 3)) continue;
+      let E = u(v);
+      if (!x(E)) continue;
+      ((y = H.computeWindingOrder2D(E)),
+        y === Z.CLOCKWISE && (E.reverse(), (v = v.slice().reverse())),
+        C.push(v),
+        d.push(L.length),
+        (L = L.concat(v)),
+        (p = p.concat(E)));
+      let D = 0;
+      for (x(P.holes) && (D = P.holes.length), T = 0; T < D; T++)
+        e.enqueue(P.holes[T]);
+    }
+    (t.push({ outerRing: h, holes: C }),
+      o.push({ positions: L, positions2D: p, holes: d }));
+  }
+  return { hierarchy: t, polygons: o };
+};
+var Pt = new M(),
+  Dt = new w(),
+  It = new K(),
+  _t = new F();
+b.computeBoundingRectangle = function (n, i, u, c, r) {
+  let a = K.fromAxisAngle(n, c, It),
+    t = F.fromQuaternion(a, _t),
+    o = Number.POSITIVE_INFINITY,
+    e = Number.NEGATIVE_INFINITY,
+    s = Number.POSITIVE_INFINITY,
+    l = Number.NEGATIVE_INFINITY,
+    h = u.length;
+  for (let f = 0; f < h; ++f) {
+    let g = w.clone(u[f], Dt);
+    F.multiplyByVector(t, g, g);
+    let m = i(g, Pt);
+    x(m) &&
+      ((o = Math.min(o, m.x)),
+      (e = Math.max(e, m.x)),
+      (s = Math.min(s, m.y)),
+      (l = Math.max(l, m.y)));
+  }
+  return ((r.x = o), (r.y = s), (r.width = e - o), (r.height = l - s), r);
+};
+b.createGeometryFromPositions = function (n, i, u, c, r, a, t) {
+  let o = H.triangulate(i.positions2D, i.holes);
+  o.length < 3 && (o = [0, 1, 2]);
+  let e = i.positions,
+    s = x(u),
+    l = s ? u.positions : void 0;
+  if (r) {
+    let h = e.length,
+      f = new Array(h * 3),
+      g = 0;
+    for (let d = 0; d < h; d++) {
+      let y = e[d];
+      ((f[g++] = y.x), (f[g++] = y.y), (f[g++] = y.z));
+    }
+    let m = {
+      attributes: {
+        position: new z({
+          componentDatatype: k.DOUBLE,
+          componentsPerAttribute: 3,
+          values: f,
+        }),
+      },
+      indices: o,
+      primitiveType: J.TRIANGLES,
+    };
+    s &&
+      (m.attributes.st = new z({
+        componentDatatype: k.FLOAT,
+        componentsPerAttribute: 2,
+        values: M.packArray(l),
+      }));
+    let p = new X(m);
+    return a.normal ? st.computeNormal(p) : p;
+  }
+  if (t === R.GEODESIC) return H.computeSubdivision(n, e, o, l, c);
+  if (t === R.RHUMB) return H.computeRhumbLineSubdivision(n, e, o, l, c);
+};
+var ut = [],
+  at = [],
+  At = new w(),
+  Mt = new w();
+b.computeWallGeometry = function (n, i, u, c, r, a) {
+  let t,
+    o,
+    e,
+    s,
+    l,
+    h,
+    f,
+    g,
+    m,
+    p = n.length,
+    d = 0,
+    y = 0,
+    L = x(i),
+    _ = L ? i.positions : void 0;
+  if (r)
+    for (
+      o = p * 3 * 2,
+        t = new Array(o * 2),
+        L && ((m = p * 2 * 2), (g = new Array(m * 2))),
+        e = 0;
+      e < p;
+      e++
+    )
+      ((s = n[e]),
+        (l = n[(e + 1) % p]),
+        (t[d] = t[d + o] = s.x),
+        ++d,
+        (t[d] = t[d + o] = s.y),
+        ++d,
+        (t[d] = t[d + o] = s.z),
+        ++d,
+        (t[d] = t[d + o] = l.x),
+        ++d,
+        (t[d] = t[d + o] = l.y),
+        ++d,
+        (t[d] = t[d + o] = l.z),
+        ++d,
+        L &&
+          ((h = _[e]),
+          (f = _[(e + 1) % p]),
+          (g[y] = g[y + m] = h.x),
+          ++y,
+          (g[y] = g[y + m] = h.y),
+          ++y,
+          (g[y] = g[y + m] = f.x),
+          ++y,
+          (g[y] = g[y + m] = f.y),
+          ++y));
+  else {
+    let E = I.chordLength(c, u.maximumRadius),
+      D = 0;
+    if (a === R.GEODESIC)
+      for (e = 0; e < p; e++)
+        D += b.subdivideLineCount(n[e], n[(e + 1) % p], E);
+    else if (a === R.RHUMB)
+      for (e = 0; e < p; e++)
+        D += b.subdivideRhumbLineCount(u, n[e], n[(e + 1) % p], E);
+    for (
+      o = (D + p) * 3,
+        t = new Array(o * 2),
+        L && ((m = (D + p) * 2), (g = new Array(m * 2))),
+        e = 0;
+      e < p;
+      e++
+    ) {
+      ((s = n[e]), (l = n[(e + 1) % p]));
+      let A, N;
+      (L && ((h = _[e]), (f = _[(e + 1) % p])),
+        a === R.GEODESIC
+          ? ((A = b.subdivideLine(s, l, E, at)),
+            L && (N = b.subdivideTexcoordLine(h, f, s, l, E, ut)))
+          : a === R.RHUMB &&
+            ((A = b.subdivideRhumbLine(u, s, l, E, at)),
+            L && (N = b.subdivideTexcoordRhumbLine(h, f, u, s, l, E, ut))));
+      let ft = A.length;
+      for (let B = 0; B < ft; ++B, ++d) ((t[d] = A[B]), (t[d + o] = A[B]));
+      if (
+        ((t[d] = l.x),
+        (t[d + o] = l.x),
+        ++d,
+        (t[d] = l.y),
+        (t[d + o] = l.y),
+        ++d,
+        (t[d] = l.z),
+        (t[d + o] = l.z),
+        ++d,
+        L)
+      ) {
+        let B = N.length;
+        for (let W = 0; W < B; ++W, ++y) ((g[y] = N[W]), (g[y + m] = N[W]));
+        ((g[y] = f.x),
+          (g[y + m] = f.x),
+          ++y,
+          (g[y] = f.y),
+          (g[y + m] = f.y),
+          ++y);
+      }
+    }
+  }
+  p = t.length;
+  let C = ot.createTypedArray(p / 3, p - n.length * 6),
+    T = 0;
+  for (p /= 6, e = 0; e < p; e++) {
+    let E = e,
+      D = E + 1,
+      A = E + p,
+      N = A + 1;
+    ((s = w.fromArray(t, E * 3, At)),
+      (l = w.fromArray(t, D * 3, Mt)),
+      !w.equalsEpsilon(s, l, I.EPSILON10, I.EPSILON10) &&
+        ((C[T++] = E),
+        (C[T++] = A),
+        (C[T++] = D),
+        (C[T++] = D),
+        (C[T++] = A),
+        (C[T++] = N)));
+  }
+  let P = {
+    attributes: new nt({
+      position: new z({
+        componentDatatype: k.DOUBLE,
+        componentsPerAttribute: 3,
+        values: t,
+      }),
+    }),
+    indices: C,
+    primitiveType: J.TRIANGLES,
+  };
+  return (
+    L &&
+      (P.attributes.st = new z({
+        componentDatatype: k.FLOAT,
+        componentsPerAttribute: 2,
+        values: g,
+      })),
+    new X(P)
+  );
+};
+var se = b;
+export { se as a };