create-swdg-frontend 0.1.0

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

@@ -0,0 +1,376 @@
+/**
+ * @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 wt } from "./chunk-ILGBPNP6.js";
+import { a as k } from "./chunk-HEEMUCG6.js";
+import { a as kt } from "./chunk-P37AI2DW.js";
+import { a as Ct } from "./chunk-T6BE4RZK.js";
+import { b as dt, c as _t, d as R } from "./chunk-X5IHHI6X.js";
+import { d as ht } from "./chunk-TMSETF7M.js";
+import { a as N } from "./chunk-KZNJOCYU.js";
+import { a as s, c as pt, d as ot } from "./chunk-POASMU2N.js";
+import { a as M } from "./chunk-R6KGAEF6.js";
+import { a as p } from "./chunk-IUA6FAOZ.js";
+import { a as z } from "./chunk-UH2WFNTA.js";
+import { e as E } from "./chunk-PEYJTJPE.js";
+var yt = new s(),
+  vt = new s(),
+  Et = new s(),
+  Mt = new s(),
+  Nt = new s(),
+  Rt = new s(1, 1, 1),
+  Pt = Math.cos,
+  At = Math.sin;
+function O(n) {
+  n = p(n, p.EMPTY_OBJECT);
+  let m = p(n.radii, Rt),
+    i = p(n.innerRadii, m),
+    P = p(n.minimumClock, 0),
+    T = p(n.maximumClock, M.TWO_PI),
+    A = p(n.minimumCone, 0),
+    b = p(n.maximumCone, M.PI),
+    a = Math.round(p(n.stackPartitions, 64)),
+    u = Math.round(p(n.slicePartitions, 64)),
+    h = p(n.vertexFormat, k.DEFAULT);
+  if (u < 3) throw new z("options.slicePartitions cannot be less than three.");
+  if (a < 3) throw new z("options.stackPartitions cannot be less than three.");
+  ((this._radii = s.clone(m)),
+    (this._innerRadii = s.clone(i)),
+    (this._minimumClock = P),
+    (this._maximumClock = T),
+    (this._minimumCone = A),
+    (this._maximumCone = b),
+    (this._stackPartitions = a),
+    (this._slicePartitions = u),
+    (this._vertexFormat = k.clone(h)),
+    (this._offsetAttribute = n.offsetAttribute),
+    (this._workerName = "createEllipsoidGeometry"));
+}
+O.packedLength = 2 * s.packedLength + k.packedLength + 7;
+O.pack = function (n, m, i) {
+  if (!E(n)) throw new z("value is required");
+  if (!E(m)) throw new z("array is required");
+  return (
+    (i = p(i, 0)),
+    s.pack(n._radii, m, i),
+    (i += s.packedLength),
+    s.pack(n._innerRadii, m, i),
+    (i += s.packedLength),
+    k.pack(n._vertexFormat, m, i),
+    (i += k.packedLength),
+    (m[i++] = n._minimumClock),
+    (m[i++] = n._maximumClock),
+    (m[i++] = n._minimumCone),
+    (m[i++] = n._maximumCone),
+    (m[i++] = n._stackPartitions),
+    (m[i++] = n._slicePartitions),
+    (m[i] = p(n._offsetAttribute, -1)),
+    m
+  );
+};
+var bt = new s(),
+  xt = new s(),
+  Ot = new k(),
+  y = {
+    radii: bt,
+    innerRadii: xt,
+    vertexFormat: Ot,
+    minimumClock: void 0,
+    maximumClock: void 0,
+    minimumCone: void 0,
+    maximumCone: void 0,
+    stackPartitions: void 0,
+    slicePartitions: void 0,
+    offsetAttribute: void 0,
+  };
+O.unpack = function (n, m, i) {
+  if (!E(n)) throw new z("array is required");
+  m = p(m, 0);
+  let P = s.unpack(n, m, bt);
+  m += s.packedLength;
+  let T = s.unpack(n, m, xt);
+  m += s.packedLength;
+  let A = k.unpack(n, m, Ot);
+  m += k.packedLength;
+  let b = n[m++],
+    a = n[m++],
+    u = n[m++],
+    h = n[m++],
+    t = n[m++],
+    o = n[m++],
+    e = n[m];
+  return E(i)
+    ? ((i._radii = s.clone(P, i._radii)),
+      (i._innerRadii = s.clone(T, i._innerRadii)),
+      (i._vertexFormat = k.clone(A, i._vertexFormat)),
+      (i._minimumClock = b),
+      (i._maximumClock = a),
+      (i._minimumCone = u),
+      (i._maximumCone = h),
+      (i._stackPartitions = t),
+      (i._slicePartitions = o),
+      (i._offsetAttribute = e === -1 ? void 0 : e),
+      i)
+    : ((y.minimumClock = b),
+      (y.maximumClock = a),
+      (y.minimumCone = u),
+      (y.maximumCone = h),
+      (y.stackPartitions = t),
+      (y.slicePartitions = o),
+      (y.offsetAttribute = e === -1 ? void 0 : e),
+      new O(y));
+};
+O.createGeometry = function (n) {
+  let m = n._radii;
+  if (m.x <= 0 || m.y <= 0 || m.z <= 0) return;
+  let i = n._innerRadii;
+  if (i.x <= 0 || i.y <= 0 || i.z <= 0) return;
+  let P = n._minimumClock,
+    T = n._maximumClock,
+    A = n._minimumCone,
+    b = n._maximumCone,
+    a = n._vertexFormat,
+    u = n._slicePartitions + 1,
+    h = n._stackPartitions + 1;
+  ((u = Math.round((u * Math.abs(T - P)) / M.TWO_PI)),
+    (h = Math.round((h * Math.abs(b - A)) / M.PI)),
+    u < 2 && (u = 2),
+    h < 2 && (h = 2));
+  let t,
+    o,
+    e = 0,
+    D = [A],
+    S = [P];
+  for (t = 0; t < h; t++) D.push(A + (t * (b - A)) / (h - 1));
+  for (D.push(b), o = 0; o < u; o++) S.push(P + (o * (T - P)) / (u - 1));
+  S.push(T);
+  let f = D.length,
+    c = S.length,
+    U = 0,
+    B = 1,
+    q = i.x !== m.x || i.y !== m.y || i.z !== m.z,
+    J = !1,
+    rt = !1,
+    ct = !1;
+  q &&
+    ((B = 2),
+    A > 0 && ((J = !0), (U += u - 1)),
+    b < Math.PI && ((rt = !0), (U += u - 1)),
+    (T - P) % M.TWO_PI ? ((ct = !0), (U += (h - 1) * 2 + 1)) : (U += 1));
+  let w = c * f * B,
+    x = new Float64Array(w * 3),
+    X = new Array(w).fill(!1),
+    st = new Array(w).fill(!1),
+    at = u * h * B,
+    Tt = 6 * (at + U + 1 - (u + h) * B),
+    r = kt.createTypedArray(at, Tt),
+    Y = a.normal ? new Float32Array(w * 3) : void 0,
+    j = a.tangent ? new Float32Array(w * 3) : void 0,
+    H = a.bitangent ? new Float32Array(w * 3) : void 0,
+    Z = a.st ? new Float32Array(w * 2) : void 0,
+    V = new Array(f),
+    G = new Array(f);
+  for (t = 0; t < f; t++) ((V[t] = At(D[t])), (G[t] = Pt(D[t])));
+  let K = new Array(c),
+    Q = new Array(c);
+  for (o = 0; o < c; o++) ((Q[o] = Pt(S[o])), (K[o] = At(S[o])));
+  for (t = 0; t < f; t++)
+    for (o = 0; o < c; o++)
+      ((x[e++] = m.x * V[t] * Q[o]),
+        (x[e++] = m.y * V[t] * K[o]),
+        (x[e++] = m.z * G[t]));
+  let $ = w / 2;
+  if (q)
+    for (t = 0; t < f; t++)
+      for (o = 0; o < c; o++)
+        ((x[e++] = i.x * V[t] * Q[o]),
+          (x[e++] = i.y * V[t] * K[o]),
+          (x[e++] = i.z * G[t]),
+          (X[$] = !0),
+          t > 0 && t !== f - 1 && o !== 0 && o !== c - 1 && (st[$] = !0),
+          $++);
+  e = 0;
+  let F, L;
+  for (t = 1; t < f - 2; t++)
+    for (F = t * c, L = (t + 1) * c, o = 1; o < c - 2; o++)
+      ((r[e++] = L + o),
+        (r[e++] = L + o + 1),
+        (r[e++] = F + o + 1),
+        (r[e++] = L + o),
+        (r[e++] = F + o + 1),
+        (r[e++] = F + o));
+  if (q) {
+    let g = f * c;
+    for (t = 1; t < f - 2; t++)
+      for (F = g + t * c, L = g + (t + 1) * c, o = 1; o < c - 2; o++)
+        ((r[e++] = L + o),
+          (r[e++] = F + o),
+          (r[e++] = F + o + 1),
+          (r[e++] = L + o),
+          (r[e++] = F + o + 1),
+          (r[e++] = L + o + 1));
+  }
+  let d, l;
+  if (q) {
+    if (J)
+      for (l = f * c, t = 1; t < c - 2; t++)
+        ((r[e++] = t),
+          (r[e++] = t + 1),
+          (r[e++] = l + t + 1),
+          (r[e++] = t),
+          (r[e++] = l + t + 1),
+          (r[e++] = l + t));
+    if (rt)
+      for (d = f * c - c, l = f * c * B - c, t = 1; t < c - 2; t++)
+        ((r[e++] = d + t + 1),
+          (r[e++] = d + t),
+          (r[e++] = l + t),
+          (r[e++] = d + t + 1),
+          (r[e++] = l + t),
+          (r[e++] = l + t + 1));
+  }
+  if (ct) {
+    for (t = 1; t < f - 2; t++)
+      ((l = c * f + c * t),
+        (d = c * t),
+        (r[e++] = l),
+        (r[e++] = d + c),
+        (r[e++] = d),
+        (r[e++] = l),
+        (r[e++] = l + c),
+        (r[e++] = d + c));
+    for (t = 1; t < f - 2; t++)
+      ((l = c * f + c * (t + 1) - 1),
+        (d = c * (t + 1) - 1),
+        (r[e++] = d + c),
+        (r[e++] = l),
+        (r[e++] = d),
+        (r[e++] = d + c),
+        (r[e++] = l + c),
+        (r[e++] = l));
+  }
+  let v = new Ct();
+  a.position &&
+    (v.position = new R({
+      componentDatatype: N.DOUBLE,
+      componentsPerAttribute: 3,
+      values: x,
+    }));
+  let ft = 0,
+    I = 0,
+    tt = 0,
+    nt = 0,
+    Ft = w / 2,
+    ut,
+    lt = ot.fromCartesian3(m),
+    Lt = ot.fromCartesian3(i);
+  if (a.st || a.normal || a.tangent || a.bitangent) {
+    for (t = 0; t < w; t++) {
+      ut = X[t] ? Lt : lt;
+      let g = s.fromArray(x, t * 3, yt),
+        C = ut.geodeticSurfaceNormal(g, vt);
+      if ((st[t] && s.negate(C, C), a.st)) {
+        let _ = pt.negate(C, Nt);
+        ((Z[ft++] = Math.atan2(_.y, _.x) / M.TWO_PI + 0.5),
+          (Z[ft++] = Math.asin(C.z) / Math.PI + 0.5));
+      }
+      if (
+        (a.normal && ((Y[I++] = C.x), (Y[I++] = C.y), (Y[I++] = C.z)),
+        a.tangent || a.bitangent)
+      ) {
+        let _ = Et,
+          et = 0,
+          it;
+        if (
+          (X[t] && (et = Ft),
+          !J && t >= et && t < et + c * 2 ? (it = s.UNIT_X) : (it = s.UNIT_Z),
+          s.cross(it, C, _),
+          s.normalize(_, _),
+          a.tangent && ((j[tt++] = _.x), (j[tt++] = _.y), (j[tt++] = _.z)),
+          a.bitangent)
+        ) {
+          let W = s.cross(C, _, Mt);
+          (s.normalize(W, W),
+            (H[nt++] = W.x),
+            (H[nt++] = W.y),
+            (H[nt++] = W.z));
+        }
+      }
+    }
+    (a.st &&
+      (v.st = new R({
+        componentDatatype: N.FLOAT,
+        componentsPerAttribute: 2,
+        values: Z,
+      })),
+      a.normal &&
+        (v.normal = new R({
+          componentDatatype: N.FLOAT,
+          componentsPerAttribute: 3,
+          values: Y,
+        })),
+      a.tangent &&
+        (v.tangent = new R({
+          componentDatatype: N.FLOAT,
+          componentsPerAttribute: 3,
+          values: j,
+        })),
+      a.bitangent &&
+        (v.bitangent = new R({
+          componentDatatype: N.FLOAT,
+          componentsPerAttribute: 3,
+          values: H,
+        })));
+  }
+  if (E(n._offsetAttribute)) {
+    let g = x.length,
+      C = n._offsetAttribute === wt.NONE ? 0 : 1,
+      _ = new Uint8Array(g / 3).fill(C);
+    v.applyOffset = new R({
+      componentDatatype: N.UNSIGNED_BYTE,
+      componentsPerAttribute: 1,
+      values: _,
+    });
+  }
+  return new _t({
+    attributes: v,
+    indices: r,
+    primitiveType: dt.TRIANGLES,
+    boundingSphere: ht.fromEllipsoid(lt),
+    offsetAttribute: n._offsetAttribute,
+  });
+};
+var mt;
+O.getUnitEllipsoid = function () {
+  return (
+    E(mt) ||
+      (mt = O.createGeometry(
+        new O({ radii: new s(1, 1, 1), vertexFormat: k.POSITION_ONLY }),
+      )),
+    mt
+  );
+};
+var Kt = O;
+export { Kt as a };

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

@@ -0,0 +1,111 @@
+/**
+ * @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 as u } from "./chunk-PEYJTJPE.js";
+function f(t) {
+  ((this.name = "DeveloperError"), (this.message = t));
+  let e;
+  try {
+    throw new Error();
+  } catch (o) {
+    e = o.stack;
+  }
+  this.stack = e;
+}
+u(Object.create) &&
+  ((f.prototype = Object.create(Error.prototype)),
+  (f.prototype.constructor = f));
+f.prototype.toString = function () {
+  let t = `${this.name}: ${this.message}`;
+  return (
+    u(this.stack) &&
+      (t += `
+${this.stack.toString()}`),
+    t
+  );
+};
+f.throwInstantiationError = function () {
+  throw new f(
+    "This function defines an interface and should not be called directly.",
+  );
+};
+var r = f;
+var n = {};
+n.typeOf = {};
+function c(t) {
+  return `${t} is required, actual value was undefined`;
+}
+function a(t, e, o) {
+  return `Expected ${o} to be typeof ${e}, actual typeof was ${t}`;
+}
+n.defined = function (t, e) {
+  if (!u(e)) throw new r(c(t));
+};
+n.typeOf.func = function (t, e) {
+  if (typeof e != "function") throw new r(a(typeof e, "function", t));
+};
+n.typeOf.string = function (t, e) {
+  if (typeof e != "string") throw new r(a(typeof e, "string", t));
+};
+n.typeOf.number = function (t, e) {
+  if (typeof e != "number") throw new r(a(typeof e, "number", t));
+};
+n.typeOf.number.lessThan = function (t, e, o) {
+  if ((n.typeOf.number(t, e), e >= o))
+    throw new r(`Expected ${t} to be less than ${o}, actual value was ${e}`);
+};
+n.typeOf.number.lessThanOrEquals = function (t, e, o) {
+  if ((n.typeOf.number(t, e), e > o))
+    throw new r(
+      `Expected ${t} to be less than or equal to ${o}, actual value was ${e}`,
+    );
+};
+n.typeOf.number.greaterThan = function (t, e, o) {
+  if ((n.typeOf.number(t, e), e <= o))
+    throw new r(`Expected ${t} to be greater than ${o}, actual value was ${e}`);
+};
+n.typeOf.number.greaterThanOrEquals = function (t, e, o) {
+  if ((n.typeOf.number(t, e), e < o))
+    throw new r(
+      `Expected ${t} to be greater than or equal to ${o}, actual value was ${e}`,
+    );
+};
+n.typeOf.object = function (t, e) {
+  if (typeof e != "object") throw new r(a(typeof e, "object", t));
+};
+n.typeOf.bool = function (t, e) {
+  if (typeof e != "boolean") throw new r(a(typeof e, "boolean", t));
+};
+n.typeOf.bigint = function (t, e) {
+  if (typeof e != "bigint") throw new r(a(typeof e, "bigint", t));
+};
+n.typeOf.number.equals = function (t, e, o, i) {
+  if ((n.typeOf.number(t, o), n.typeOf.number(e, i), o !== i))
+    throw new r(
+      `${t} must be equal to ${e}, the actual values are ${o} and ${i}`,
+    );
+};
+var l = n;
+export { r as a, l as b };