create-swdg-frontend 0.1.0

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

@@ -0,0 +1,516 @@
+/**
+ * @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-SB224QGV.js";
+import { a as b } from "./chunk-QB3MDM4J.js";
+import { a as U } from "./chunk-P37AI2DW.js";
+import { a as E } from "./chunk-T6BE4RZK.js";
+import { c as z, d as L } from "./chunk-X5IHHI6X.js";
+import { a as D, d as y } from "./chunk-TMSETF7M.js";
+import { b as G } from "./chunk-7Z5IIKOJ.js";
+import { a as k } from "./chunk-KZNJOCYU.js";
+import { d as B } from "./chunk-POASMU2N.js";
+import { a as v } from "./chunk-IUA6FAOZ.js";
+import { a as F, b as I } from "./chunk-UH2WFNTA.js";
+import { e as a } from "./chunk-PEYJTJPE.js";
+function w(e, n, t) {
+  ((e = v(e, 0)),
+    (n = v(n, 0)),
+    (t = v(t, 0)),
+    (this.value = new Float32Array([e, n, t])));
+}
+Object.defineProperties(w.prototype, {
+  componentDatatype: {
+    get: function () {
+      return k.FLOAT;
+    },
+  },
+  componentsPerAttribute: {
+    get: function () {
+      return 3;
+    },
+  },
+  normalize: {
+    get: function () {
+      return !1;
+    },
+  },
+});
+w.fromCartesian3 = function (e) {
+  return (I.defined("offset", e), new w(e.x, e.y, e.z));
+};
+w.toValue = function (e, n) {
+  return (
+    I.defined("offset", e),
+    a(n) || (n = new Float32Array([e.x, e.y, e.z])),
+    (n[0] = e.x),
+    (n[1] = e.y),
+    (n[2] = e.z),
+    n
+  );
+};
+var j = w;
+function K(e, n, t) {
+  let i = !t,
+    r = e.length,
+    c;
+  if (!i && r > 1) {
+    let o = e[0].modelMatrix;
+    for (c = 1; c < r; ++c)
+      if (!G.equals(o, e[c].modelMatrix)) {
+        i = !0;
+        break;
+      }
+  }
+  if (i)
+    for (c = 0; c < r; ++c)
+      a(e[c].geometry) && b.transformToWorldCoordinates(e[c]);
+  else G.multiplyTransformation(n, e[0].modelMatrix, n);
+}
+function P(e, n) {
+  let t = e.attributes,
+    i = t.position,
+    r = i.values.length / i.componentsPerAttribute;
+  t.batchId = new L({
+    componentDatatype: k.FLOAT,
+    componentsPerAttribute: 1,
+    values: new Float32Array(r),
+  });
+  let c = t.batchId.values;
+  for (let o = 0; o < r; ++o) c[o] = n;
+}
+function N(e) {
+  let n = e.length;
+  for (let t = 0; t < n; ++t) {
+    let i = e[t];
+    a(i.geometry)
+      ? P(i.geometry, t)
+      : a(i.westHemisphereGeometry) &&
+        a(i.eastHemisphereGeometry) &&
+        (P(i.westHemisphereGeometry, t), P(i.eastHemisphereGeometry, t));
+  }
+}
+function Q(e) {
+  let n = e.instances,
+    t = e.projection,
+    i = e.elementIndexUintSupported,
+    r = e.scene3DOnly,
+    c = e.vertexCacheOptimize,
+    o = e.compressVertices,
+    g = e.modelMatrix,
+    s,
+    u,
+    m,
+    p = n.length;
+  for (s = 0; s < p; ++s)
+    if (a(n[s].geometry)) {
+      m = n[s].geometry.primitiveType;
+      break;
+    }
+  for (s = 1; s < p; ++s)
+    if (a(n[s].geometry) && n[s].geometry.primitiveType !== m)
+      throw new F("All instance geometries must have the same primitiveType.");
+  if ((K(n, g, r), !r))
+    for (s = 0; s < p; ++s) a(n[s].geometry) && b.splitLongitude(n[s]);
+  if ((N(n), c))
+    for (s = 0; s < p; ++s) {
+      let f = n[s];
+      a(f.geometry)
+        ? (b.reorderForPostVertexCache(f.geometry),
+          b.reorderForPreVertexCache(f.geometry))
+        : a(f.westHemisphereGeometry) &&
+          a(f.eastHemisphereGeometry) &&
+          (b.reorderForPostVertexCache(f.westHemisphereGeometry),
+          b.reorderForPreVertexCache(f.westHemisphereGeometry),
+          b.reorderForPostVertexCache(f.eastHemisphereGeometry),
+          b.reorderForPreVertexCache(f.eastHemisphereGeometry));
+    }
+  let l = b.combineInstances(n);
+  for (p = l.length, s = 0; s < p; ++s) {
+    u = l[s];
+    let f = u.attributes;
+    if (r)
+      for (let d in f)
+        f.hasOwnProperty(d) &&
+          f[d].componentDatatype === k.DOUBLE &&
+          b.encodeAttribute(u, d, `${d}3DHigh`, `${d}3DLow`);
+    else
+      for (let d in f)
+        if (f.hasOwnProperty(d) && f[d].componentDatatype === k.DOUBLE) {
+          let h = `${d}3D`,
+            x = `${d}2D`;
+          (b.projectTo2D(u, d, h, x, t),
+            a(u.boundingSphere) &&
+              d === "position" &&
+              (u.boundingSphereCV = y.fromVertices(
+                u.attributes.position2D.values,
+              )),
+            b.encodeAttribute(u, h, `${h}High`, `${h}Low`),
+            b.encodeAttribute(u, x, `${x}High`, `${x}Low`));
+        }
+    o && b.compressVertices(u);
+  }
+  if (!i) {
+    let f = [];
+    for (p = l.length, s = 0; s < p; ++s)
+      ((u = l[s]), (f = f.concat(b.fitToUnsignedShortIndices(u))));
+    l = f;
+  }
+  return l;
+}
+function T(e, n, t, i) {
+  let r,
+    c,
+    o,
+    g = i.length - 1;
+  if (g >= 0) {
+    let u = i[g];
+    ((r = u.offset + u.count), (o = u.index), (c = t[o].indices.length));
+  } else ((r = 0), (o = 0), (c = t[o].indices.length));
+  let s = e.length;
+  for (let u = 0; u < s; ++u) {
+    let p = e[u][n];
+    if (!a(p)) continue;
+    let l = p.indices.length;
+    (r + l > c && ((r = 0), (c = t[++o].indices.length)),
+      i.push({ index: o, offset: r, count: l }),
+      (r += l));
+  }
+}
+function X(e, n) {
+  let t = [];
+  return (
+    T(e, "geometry", n, t),
+    T(e, "westHemisphereGeometry", n, t),
+    T(e, "eastHemisphereGeometry", n, t),
+    t
+  );
+}
+var S = {};
+S.combineGeometry = function (e) {
+  let n,
+    t,
+    i = e.instances,
+    r = i.length,
+    c,
+    o,
+    g = !1;
+  r > 0 &&
+    ((n = Q(e)),
+    n.length > 0 &&
+      ((t = b.createAttributeLocations(n[0])),
+      e.createPickOffsets && (c = X(i, n))),
+    a(i[0].attributes) &&
+      a(i[0].attributes.offset) &&
+      ((o = new Array(r)), (g = !0)));
+  let s = new Array(r),
+    u = new Array(r);
+  for (let m = 0; m < r; ++m) {
+    let p = i[m],
+      l = p.geometry;
+    a(l) &&
+      ((s[m] = l.boundingSphere),
+      (u[m] = l.boundingSphereCV),
+      g && (o[m] = p.geometry.offsetAttribute));
+    let f = p.eastHemisphereGeometry,
+      d = p.westHemisphereGeometry;
+    a(f) &&
+      a(d) &&
+      (a(f.boundingSphere) &&
+        a(d.boundingSphere) &&
+        (s[m] = y.union(f.boundingSphere, d.boundingSphere)),
+      a(f.boundingSphereCV) &&
+        a(d.boundingSphereCV) &&
+        (u[m] = y.union(f.boundingSphereCV, d.boundingSphereCV)));
+  }
+  return {
+    geometries: n,
+    modelMatrix: e.modelMatrix,
+    attributeLocations: t,
+    pickOffsets: c,
+    offsetInstanceExtend: o,
+    boundingSpheres: s,
+    boundingSpheresCV: u,
+  };
+};
+function Y(e, n) {
+  let t = e.attributes;
+  for (let i in t)
+    if (t.hasOwnProperty(i)) {
+      let r = t[i];
+      a(r) && a(r.values) && n.push(r.values.buffer);
+    }
+  a(e.indices) && n.push(e.indices.buffer);
+}
+function Z(e, n) {
+  let t = e.length;
+  for (let i = 0; i < t; ++i) Y(e[i], n);
+}
+function _(e) {
+  let n = 1,
+    t = e.length;
+  for (let i = 0; i < t; i++) {
+    let r = e[i];
+    if ((++n, !a(r))) continue;
+    let c = r.attributes;
+    n += 7 + 2 * y.packedLength + (a(r.indices) ? r.indices.length : 0);
+    for (let o in c)
+      if (c.hasOwnProperty(o) && a(c[o])) {
+        let g = c[o];
+        n += 5 + g.values.length;
+      }
+  }
+  return n;
+}
+S.packCreateGeometryResults = function (e, n) {
+  let t = new Float64Array(_(e)),
+    i = [],
+    r = {},
+    c = e.length,
+    o = 0;
+  t[o++] = c;
+  for (let g = 0; g < c; g++) {
+    let s = e[g],
+      u = a(s);
+    if (((t[o++] = u ? 1 : 0), !u)) continue;
+    ((t[o++] = s.primitiveType),
+      (t[o++] = s.geometryType),
+      (t[o++] = v(s.offsetAttribute, -1)));
+    let m = a(s.boundingSphere) ? 1 : 0;
+    ((t[o++] = m), m && y.pack(s.boundingSphere, t, o), (o += y.packedLength));
+    let p = a(s.boundingSphereCV) ? 1 : 0;
+    ((t[o++] = p),
+      p && y.pack(s.boundingSphereCV, t, o),
+      (o += y.packedLength));
+    let l = s.attributes,
+      f = [];
+    for (let h in l)
+      l.hasOwnProperty(h) &&
+        a(l[h]) &&
+        (f.push(h), a(r[h]) || ((r[h] = i.length), i.push(h)));
+    t[o++] = f.length;
+    for (let h = 0; h < f.length; h++) {
+      let x = f[h],
+        C = l[x];
+      ((t[o++] = r[x]),
+        (t[o++] = C.componentDatatype),
+        (t[o++] = C.componentsPerAttribute),
+        (t[o++] = C.normalize ? 1 : 0),
+        (t[o++] = C.values.length),
+        t.set(C.values, o),
+        (o += C.values.length));
+    }
+    let d = a(s.indices) ? s.indices.length : 0;
+    ((t[o++] = d), d > 0 && (t.set(s.indices, o), (o += d)));
+  }
+  return (n.push(t.buffer), { stringTable: i, packedData: t });
+};
+S.unpackCreateGeometryResults = function (e) {
+  let n = e.stringTable,
+    t = e.packedData,
+    i,
+    r = new Array(t[0]),
+    c = 0,
+    o = 1;
+  for (; o < t.length; ) {
+    if (!(t[o++] === 1)) {
+      r[c++] = void 0;
+      continue;
+    }
+    let s = t[o++],
+      u = t[o++],
+      m = t[o++];
+    m === -1 && (m = void 0);
+    let p, l;
+    (t[o++] === 1 && (p = y.unpack(t, o)),
+      (o += y.packedLength),
+      t[o++] === 1 && (l = y.unpack(t, o)),
+      (o += y.packedLength));
+    let h,
+      x,
+      C,
+      H = new E(),
+      q = t[o++];
+    for (i = 0; i < q; i++) {
+      let A = n[t[o++]],
+        M = t[o++];
+      C = t[o++];
+      let J = t[o++] !== 0;
+      ((h = t[o++]), (x = k.createTypedArray(M, h)));
+      for (let O = 0; O < h; O++) x[O] = t[o++];
+      H[A] = new L({
+        componentDatatype: M,
+        componentsPerAttribute: C,
+        normalize: J,
+        values: x,
+      });
+    }
+    let V;
+    if (((h = t[o++]), h > 0)) {
+      let A = x.length / C;
+      for (V = U.createTypedArray(A, h), i = 0; i < h; i++) V[i] = t[o++];
+    }
+    r[c++] = new z({
+      primitiveType: s,
+      geometryType: u,
+      boundingSphere: p,
+      boundingSphereCV: l,
+      indices: V,
+      attributes: H,
+      offsetAttribute: m,
+    });
+  }
+  return r;
+};
+function ee(e, n) {
+  let t = e.length,
+    i = new Float64Array(1 + t * 19),
+    r = 0;
+  i[r++] = t;
+  for (let c = 0; c < t; c++) {
+    let o = e[c];
+    if (
+      (G.pack(o.modelMatrix, i, r),
+      (r += G.packedLength),
+      a(o.attributes) && a(o.attributes.offset))
+    ) {
+      let g = o.attributes.offset.value;
+      ((i[r] = g[0]), (i[r + 1] = g[1]), (i[r + 2] = g[2]));
+    }
+    r += 3;
+  }
+  return (n.push(i.buffer), i);
+}
+function te(e) {
+  let n = e,
+    t = new Array(n[0]),
+    i = 0,
+    r = 1;
+  for (; r < n.length; ) {
+    let c = G.unpack(n, r),
+      o;
+    ((r += G.packedLength),
+      a(n[r]) && (o = { offset: new j(n[r], n[r + 1], n[r + 2]) }),
+      (r += 3),
+      (t[i++] = { modelMatrix: c, attributes: o }));
+  }
+  return t;
+}
+S.packCombineGeometryParameters = function (e, n) {
+  let t = e.createGeometryResults,
+    i = t.length;
+  for (let r = 0; r < i; r++) n.push(t[r].packedData.buffer);
+  return {
+    createGeometryResults: e.createGeometryResults,
+    packedInstances: ee(e.instances, n),
+    ellipsoid: e.ellipsoid,
+    isGeographic: e.projection instanceof D,
+    elementIndexUintSupported: e.elementIndexUintSupported,
+    scene3DOnly: e.scene3DOnly,
+    vertexCacheOptimize: e.vertexCacheOptimize,
+    compressVertices: e.compressVertices,
+    modelMatrix: e.modelMatrix,
+    createPickOffsets: e.createPickOffsets,
+  };
+};
+S.unpackCombineGeometryParameters = function (e) {
+  let n = te(e.packedInstances),
+    t = e.createGeometryResults,
+    i = t.length,
+    r = 0;
+  for (let g = 0; g < i; g++) {
+    let s = S.unpackCreateGeometryResults(t[g]),
+      u = s.length;
+    for (let m = 0; m < u; m++) {
+      let p = s[m],
+        l = n[r];
+      ((l.geometry = p), ++r);
+    }
+  }
+  let c = B.clone(e.ellipsoid),
+    o = e.isGeographic ? new D(c) : new $(c);
+  return {
+    instances: n,
+    ellipsoid: c,
+    projection: o,
+    elementIndexUintSupported: e.elementIndexUintSupported,
+    scene3DOnly: e.scene3DOnly,
+    vertexCacheOptimize: e.vertexCacheOptimize,
+    compressVertices: e.compressVertices,
+    modelMatrix: G.clone(e.modelMatrix),
+    createPickOffsets: e.createPickOffsets,
+  };
+};
+function R(e) {
+  let n = e.length,
+    t = 1 + (y.packedLength + 1) * n,
+    i = new Float32Array(t),
+    r = 0;
+  i[r++] = n;
+  for (let c = 0; c < n; ++c) {
+    let o = e[c];
+    (a(o) ? ((i[r++] = 1), y.pack(e[c], i, r)) : (i[r++] = 0),
+      (r += y.packedLength));
+  }
+  return i;
+}
+function W(e) {
+  let n = new Array(e[0]),
+    t = 0,
+    i = 1;
+  for (; i < e.length; )
+    (e[i++] === 1 && (n[t] = y.unpack(e, i)), ++t, (i += y.packedLength));
+  return n;
+}
+S.packCombineGeometryResults = function (e, n) {
+  a(e.geometries) && Z(e.geometries, n);
+  let t = R(e.boundingSpheres),
+    i = R(e.boundingSpheresCV);
+  return (
+    n.push(t.buffer, i.buffer),
+    {
+      geometries: e.geometries,
+      attributeLocations: e.attributeLocations,
+      modelMatrix: e.modelMatrix,
+      pickOffsets: e.pickOffsets,
+      offsetInstanceExtend: e.offsetInstanceExtend,
+      boundingSpheres: t,
+      boundingSpheresCV: i,
+    }
+  );
+};
+S.unpackCombineGeometryResults = function (e) {
+  return {
+    geometries: e.geometries,
+    attributeLocations: e.attributeLocations,
+    modelMatrix: e.modelMatrix,
+    pickOffsets: e.pickOffsets,
+    offsetInstanceExtend: e.offsetInstanceExtend,
+    boundingSpheres: W(e.boundingSpheres),
+    boundingSpheresCV: W(e.boundingSpheresCV),
+  };
+};
+var Ge = S;
+export { Ge as a };