create-swdg-frontend 0.1.0

package/template/public/Cesium1.119/Workers/createPolygonOutlineGeometry.js

@@ -0,0 +1,359 @@
+/**
+ * @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 } from "./chunk-HSWA4OEL.js";
+import { a as b } from "./chunk-ATPDRNKI.js";
+import { a as F } from "./chunk-EFZKO5RU.js";
+import { a as V } from "./chunk-QB3MDM4J.js";
+import "./chunk-ABGXSJNX.js";
+import "./chunk-DQO6B4EQ.js";
+import { a as D } from "./chunk-ILGBPNP6.js";
+import { a as W } from "./chunk-KF5NF354.js";
+import "./chunk-4WRMLZA7.js";
+import { a as j, b as k } from "./chunk-O5IJ3OGP.js";
+import "./chunk-RXTBM4OI.js";
+import "./chunk-FYOYUPXG.js";
+import "./chunk-TAMCUKAR.js";
+import "./chunk-PDMQLSBL.js";
+import { a as M } from "./chunk-P37AI2DW.js";
+import { a as G } from "./chunk-T6BE4RZK.js";
+import { b as B, c as C, d as v } from "./chunk-X5IHHI6X.js";
+import { d as z } from "./chunk-TMSETF7M.js";
+import "./chunk-7Z5IIKOJ.js";
+import { a as w } from "./chunk-KZNJOCYU.js";
+import { a as S, d as y } from "./chunk-POASMU2N.js";
+import { a as T } from "./chunk-R6KGAEF6.js";
+import "./chunk-3C7WC463.js";
+import "./chunk-II4VNKYR.js";
+import { a as P } from "./chunk-IUA6FAOZ.js";
+import { a as U, b as A } from "./chunk-UH2WFNTA.js";
+import { e as O } from "./chunk-PEYJTJPE.js";
+var Y = [],
+  R = [];
+function K(e, t, r, H, l) {
+  let p = W.fromPoints(t, e).projectPointsOntoPlane(t, Y);
+  k.computeWindingOrder2D(p) === j.CLOCKWISE &&
+    (p.reverse(), (t = t.slice().reverse()));
+  let n,
+    i,
+    o = t.length,
+    c = 0;
+  if (H)
+    for (n = new Float64Array(o * 2 * 3), i = 0; i < o; i++) {
+      let u = t[i],
+        h = t[(i + 1) % o];
+      ((n[c++] = u.x),
+        (n[c++] = u.y),
+        (n[c++] = u.z),
+        (n[c++] = h.x),
+        (n[c++] = h.y),
+        (n[c++] = h.z));
+    }
+  else {
+    let u = 0;
+    if (l === b.GEODESIC)
+      for (i = 0; i < o; i++)
+        u += a.subdivideLineCount(t[i], t[(i + 1) % o], r);
+    else if (l === b.RHUMB)
+      for (i = 0; i < o; i++)
+        u += a.subdivideRhumbLineCount(e, t[i], t[(i + 1) % o], r);
+    for (n = new Float64Array(u * 3), i = 0; i < o; i++) {
+      let h;
+      l === b.GEODESIC
+        ? (h = a.subdivideLine(t[i], t[(i + 1) % o], r, R))
+        : l === b.RHUMB &&
+          (h = a.subdivideRhumbLine(e, t[i], t[(i + 1) % o], r, R));
+      let g = h.length;
+      for (let d = 0; d < g; ++d) n[c++] = h[d];
+    }
+  }
+  o = n.length / 3;
+  let f = o * 2,
+    m = M.createTypedArray(o, f);
+  for (c = 0, i = 0; i < o - 1; i++) ((m[c++] = i), (m[c++] = i + 1));
+  return (
+    (m[c++] = o - 1),
+    (m[c++] = 0),
+    new F({
+      geometry: new C({
+        attributes: new G({
+          position: new v({
+            componentDatatype: w.DOUBLE,
+            componentsPerAttribute: 3,
+            values: n,
+          }),
+        }),
+        indices: m,
+        primitiveType: B.LINES,
+      }),
+    })
+  );
+}
+function q(e, t, r, H, l) {
+  let p = W.fromPoints(t, e).projectPointsOntoPlane(t, Y);
+  k.computeWindingOrder2D(p) === j.CLOCKWISE &&
+    (p.reverse(), (t = t.slice().reverse()));
+  let n,
+    i,
+    o = t.length,
+    c = new Array(o),
+    f = 0;
+  if (H)
+    for (n = new Float64Array(o * 2 * 3 * 2), i = 0; i < o; ++i) {
+      c[i] = f / 3;
+      let g = t[i],
+        d = t[(i + 1) % o];
+      ((n[f++] = g.x),
+        (n[f++] = g.y),
+        (n[f++] = g.z),
+        (n[f++] = d.x),
+        (n[f++] = d.y),
+        (n[f++] = d.z));
+    }
+  else {
+    let g = 0;
+    if (l === b.GEODESIC)
+      for (i = 0; i < o; i++)
+        g += a.subdivideLineCount(t[i], t[(i + 1) % o], r);
+    else if (l === b.RHUMB)
+      for (i = 0; i < o; i++)
+        g += a.subdivideRhumbLineCount(e, t[i], t[(i + 1) % o], r);
+    for (n = new Float64Array(g * 3 * 2), i = 0; i < o; ++i) {
+      c[i] = f / 3;
+      let d;
+      l === b.GEODESIC
+        ? (d = a.subdivideLine(t[i], t[(i + 1) % o], r, R))
+        : l === b.RHUMB &&
+          (d = a.subdivideRhumbLine(e, t[i], t[(i + 1) % o], r, R));
+      let E = d.length;
+      for (let N = 0; N < E; ++N) n[f++] = d[N];
+    }
+  }
+  o = n.length / (3 * 2);
+  let m = c.length,
+    u = (o * 2 + m) * 2,
+    h = M.createTypedArray(o + m, u);
+  for (f = 0, i = 0; i < o; ++i)
+    ((h[f++] = i),
+      (h[f++] = (i + 1) % o),
+      (h[f++] = i + o),
+      (h[f++] = ((i + 1) % o) + o));
+  for (i = 0; i < m; i++) {
+    let g = c[i];
+    ((h[f++] = g), (h[f++] = g + o));
+  }
+  return new F({
+    geometry: new C({
+      attributes: new G({
+        position: new v({
+          componentDatatype: w.DOUBLE,
+          componentsPerAttribute: 3,
+          values: n,
+        }),
+      }),
+      indices: h,
+      primitiveType: B.LINES,
+    }),
+  });
+}
+function L(e) {
+  if (
+    (A.typeOf.object("options", e),
+    A.typeOf.object("options.polygonHierarchy", e.polygonHierarchy),
+    e.perPositionHeight && O(e.height))
+  )
+    throw new U("Cannot use both options.perPositionHeight and options.height");
+  if (O(e.arcType) && e.arcType !== b.GEODESIC && e.arcType !== b.RHUMB)
+    throw new U(
+      "Invalid arcType. Valid options are ArcType.GEODESIC and ArcType.RHUMB.",
+    );
+  let t = e.polygonHierarchy,
+    r = P(e.ellipsoid, y.default),
+    H = P(e.granularity, T.RADIANS_PER_DEGREE),
+    l = P(e.perPositionHeight, !1),
+    _ = l && O(e.extrudedHeight),
+    p = P(e.arcType, b.GEODESIC),
+    s = P(e.height, 0),
+    n = P(e.extrudedHeight, s);
+  if (!_) {
+    let i = Math.max(s, n);
+    ((n = Math.min(s, n)), (s = i));
+  }
+  ((this._ellipsoid = y.clone(r)),
+    (this._granularity = H),
+    (this._height = s),
+    (this._extrudedHeight = n),
+    (this._arcType = p),
+    (this._polygonHierarchy = t),
+    (this._perPositionHeight = l),
+    (this._perPositionHeightExtrude = _),
+    (this._offsetAttribute = e.offsetAttribute),
+    (this._workerName = "createPolygonOutlineGeometry"),
+    (this.packedLength =
+      a.computeHierarchyPackedLength(t, S) + y.packedLength + 8));
+}
+L.pack = function (e, t, r) {
+  return (
+    A.typeOf.object("value", e),
+    A.defined("array", t),
+    (r = P(r, 0)),
+    (r = a.packPolygonHierarchy(e._polygonHierarchy, t, r, S)),
+    y.pack(e._ellipsoid, t, r),
+    (r += y.packedLength),
+    (t[r++] = e._height),
+    (t[r++] = e._extrudedHeight),
+    (t[r++] = e._granularity),
+    (t[r++] = e._perPositionHeightExtrude ? 1 : 0),
+    (t[r++] = e._perPositionHeight ? 1 : 0),
+    (t[r++] = e._arcType),
+    (t[r++] = P(e._offsetAttribute, -1)),
+    (t[r] = e.packedLength),
+    t
+  );
+};
+var J = y.clone(y.UNIT_SPHERE),
+  Q = { polygonHierarchy: {} };
+L.unpack = function (e, t, r) {
+  (A.defined("array", e), (t = P(t, 0)));
+  let H = a.unpackPolygonHierarchy(e, t, S);
+  ((t = H.startingIndex), delete H.startingIndex);
+  let l = y.unpack(e, t, J);
+  t += y.packedLength;
+  let _ = e[t++],
+    p = e[t++],
+    s = e[t++],
+    n = e[t++] === 1,
+    i = e[t++] === 1,
+    o = e[t++],
+    c = e[t++],
+    f = e[t];
+  return (
+    O(r) || (r = new L(Q)),
+    (r._polygonHierarchy = H),
+    (r._ellipsoid = y.clone(l, r._ellipsoid)),
+    (r._height = _),
+    (r._extrudedHeight = p),
+    (r._granularity = s),
+    (r._perPositionHeight = i),
+    (r._perPositionHeightExtrude = n),
+    (r._arcType = o),
+    (r._offsetAttribute = c === -1 ? void 0 : c),
+    (r.packedLength = f),
+    r
+  );
+};
+L.fromPositions = function (e) {
+  ((e = P(e, P.EMPTY_OBJECT)), A.defined("options.positions", e.positions));
+  let t = {
+    polygonHierarchy: { positions: e.positions },
+    height: e.height,
+    extrudedHeight: e.extrudedHeight,
+    ellipsoid: e.ellipsoid,
+    granularity: e.granularity,
+    perPositionHeight: e.perPositionHeight,
+    arcType: e.arcType,
+    offsetAttribute: e.offsetAttribute,
+  };
+  return new L(t);
+};
+L.createGeometry = function (e) {
+  let t = e._ellipsoid,
+    r = e._granularity,
+    H = e._polygonHierarchy,
+    l = e._perPositionHeight,
+    _ = e._arcType,
+    p = a.polygonOutlinesFromHierarchy(H, !l, t);
+  if (p.length === 0) return;
+  let s,
+    n = [],
+    i = T.chordLength(r, t.maximumRadius),
+    o = e._height,
+    c = e._extrudedHeight,
+    f = e._perPositionHeightExtrude || !T.equalsEpsilon(o, c, 0, T.EPSILON2),
+    m,
+    u;
+  if (f)
+    for (u = 0; u < p.length; u++) {
+      if (
+        ((s = q(t, p[u], i, l, _)),
+        (s.geometry = a.scaleToGeodeticHeightExtruded(s.geometry, o, c, t, l)),
+        O(e._offsetAttribute))
+      ) {
+        let d = s.geometry.attributes.position.values.length / 3,
+          E = new Uint8Array(d);
+        (e._offsetAttribute === D.TOP
+          ? (E = E.fill(1, 0, d / 2))
+          : ((m = e._offsetAttribute === D.NONE ? 0 : 1), (E = E.fill(m))),
+          (s.geometry.attributes.applyOffset = new v({
+            componentDatatype: w.UNSIGNED_BYTE,
+            componentsPerAttribute: 1,
+            values: E,
+          })));
+      }
+      n.push(s);
+    }
+  else
+    for (u = 0; u < p.length; u++) {
+      if (
+        ((s = K(t, p[u], i, l, _)),
+        (s.geometry.attributes.position.values = k.scaleToGeodeticHeight(
+          s.geometry.attributes.position.values,
+          o,
+          t,
+          !l,
+        )),
+        O(e._offsetAttribute))
+      ) {
+        let d = s.geometry.attributes.position.values.length;
+        m = e._offsetAttribute === D.NONE ? 0 : 1;
+        let E = new Uint8Array(d / 3).fill(m);
+        s.geometry.attributes.applyOffset = new v({
+          componentDatatype: w.UNSIGNED_BYTE,
+          componentsPerAttribute: 1,
+          values: E,
+        });
+      }
+      n.push(s);
+    }
+  let h = V.combineInstances(n)[0],
+    g = z.fromVertices(h.attributes.position.values);
+  return new C({
+    attributes: h.attributes,
+    indices: h.indices,
+    primitiveType: h.primitiveType,
+    boundingSphere: g,
+    offsetAttribute: e._offsetAttribute,
+  });
+};
+var x = L;
+function X(e, t) {
+  return (
+    O(t) && (e = x.unpack(e, t)),
+    (e._ellipsoid = y.clone(e._ellipsoid)),
+    x.createGeometry(e)
+  );
+}
+var Oe = X;
+export { Oe as default };

package/template/public/Cesium1.119/Workers/createPolylineGeometry.js

@@ -0,0 +1,349 @@
+/**
+ * @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 m } from "./chunk-V7JEDBOE.js";
+import { a as N } from "./chunk-ATPDRNKI.js";
+import { a as U } from "./chunk-AMQUWUD4.js";
+import "./chunk-W23CU777.js";
+import { a as k } from "./chunk-HEEMUCG6.js";
+import { a as le } from "./chunk-RXTBM4OI.js";
+import "./chunk-FYOYUPXG.js";
+import "./chunk-TAMCUKAR.js";
+import "./chunk-PDMQLSBL.js";
+import { a as se } from "./chunk-P37AI2DW.js";
+import { a as ce } from "./chunk-T6BE4RZK.js";
+import { a as ne, b as re, c as ie, d as O } from "./chunk-X5IHHI6X.js";
+import { d as oe } from "./chunk-TMSETF7M.js";
+import "./chunk-7Z5IIKOJ.js";
+import { a as x } from "./chunk-KZNJOCYU.js";
+import { a as p, d as u } from "./chunk-POASMU2N.js";
+import { a as J } from "./chunk-R6KGAEF6.js";
+import "./chunk-3C7WC463.js";
+import "./chunk-II4VNKYR.js";
+import { a as A } from "./chunk-IUA6FAOZ.js";
+import { a as V } from "./chunk-UH2WFNTA.js";
+import { e as h } from "./chunk-PEYJTJPE.js";
+var me = [];
+function Ae(e, o, t, n, c) {
+  let s = me;
+  s.length = c;
+  let l,
+    E = t.red,
+    a = t.green,
+    r = t.blue,
+    w = t.alpha,
+    b = n.red,
+    i = n.green,
+    f = n.blue,
+    L = n.alpha;
+  if (m.equals(t, n)) {
+    for (l = 0; l < c; l++) s[l] = m.clone(t);
+    return s;
+  }
+  let M = (b - E) / c,
+    z = (i - a) / c,
+    H = (f - r) / c,
+    B = (L - w) / c;
+  for (l = 0; l < c; l++)
+    s[l] = new m(E + l * M, a + l * z, r + l * H, w + l * B);
+  return s;
+}
+function G(e) {
+  e = A(e, A.EMPTY_OBJECT);
+  let o = e.positions,
+    t = e.colors,
+    n = A(e.width, 1),
+    c = A(e.colorsPerVertex, !1);
+  if (!h(o) || o.length < 2)
+    throw new V("At least two positions are required.");
+  if (typeof n != "number") throw new V("width must be a number");
+  if (h(t) && ((c && t.length < o.length) || (!c && t.length < o.length - 1)))
+    throw new V("colors has an invalid length.");
+  ((this._positions = o),
+    (this._colors = t),
+    (this._width = n),
+    (this._colorsPerVertex = c),
+    (this._vertexFormat = k.clone(A(e.vertexFormat, k.DEFAULT))),
+    (this._arcType = A(e.arcType, N.GEODESIC)),
+    (this._granularity = A(e.granularity, J.RADIANS_PER_DEGREE)),
+    (this._ellipsoid = u.clone(A(e.ellipsoid, u.default))),
+    (this._workerName = "createPolylineGeometry"));
+  let s = 1 + o.length * p.packedLength;
+  ((s += h(t) ? 1 + t.length * m.packedLength : 1),
+    (this.packedLength = s + u.packedLength + k.packedLength + 4));
+}
+G.pack = function (e, o, t) {
+  if (!h(e)) throw new V("value is required");
+  if (!h(o)) throw new V("array is required");
+  t = A(t, 0);
+  let n,
+    c = e._positions,
+    s = c.length;
+  for (o[t++] = s, n = 0; n < s; ++n, t += p.packedLength) p.pack(c[n], o, t);
+  let l = e._colors;
+  for (
+    s = h(l) ? l.length : 0, o[t++] = s, n = 0;
+    n < s;
+    ++n, t += m.packedLength
+  )
+    m.pack(l[n], o, t);
+  return (
+    u.pack(e._ellipsoid, o, t),
+    (t += u.packedLength),
+    k.pack(e._vertexFormat, o, t),
+    (t += k.packedLength),
+    (o[t++] = e._width),
+    (o[t++] = e._colorsPerVertex ? 1 : 0),
+    (o[t++] = e._arcType),
+    (o[t] = e._granularity),
+    o
+  );
+};
+var de = u.clone(u.UNIT_SPHERE),
+  ue = new k(),
+  S = {
+    positions: void 0,
+    colors: void 0,
+    ellipsoid: de,
+    vertexFormat: ue,
+    width: void 0,
+    colorsPerVertex: void 0,
+    arcType: void 0,
+    granularity: void 0,
+  };
+G.unpack = function (e, o, t) {
+  if (!h(e)) throw new V("array is required");
+  o = A(o, 0);
+  let n,
+    c = e[o++],
+    s = new Array(c);
+  for (n = 0; n < c; ++n, o += p.packedLength) s[n] = p.unpack(e, o);
+  c = e[o++];
+  let l = c > 0 ? new Array(c) : void 0;
+  for (n = 0; n < c; ++n, o += m.packedLength) l[n] = m.unpack(e, o);
+  let E = u.unpack(e, o, de);
+  o += u.packedLength;
+  let a = k.unpack(e, o, ue);
+  o += k.packedLength;
+  let r = e[o++],
+    w = e[o++] === 1,
+    b = e[o++],
+    i = e[o];
+  return h(t)
+    ? ((t._positions = s),
+      (t._colors = l),
+      (t._ellipsoid = u.clone(E, t._ellipsoid)),
+      (t._vertexFormat = k.clone(a, t._vertexFormat)),
+      (t._width = r),
+      (t._colorsPerVertex = w),
+      (t._arcType = b),
+      (t._granularity = i),
+      t)
+    : ((S.positions = s),
+      (S.colors = l),
+      (S.width = r),
+      (S.colorsPerVertex = w),
+      (S.arcType = b),
+      (S.granularity = i),
+      new G(S));
+};
+var pe = new p(),
+  ae = new p(),
+  fe = new p(),
+  he = new p();
+G.createGeometry = function (e) {
+  let o = e._width,
+    t = e._vertexFormat,
+    n = e._colors,
+    c = e._colorsPerVertex,
+    s = e._arcType,
+    l = e._granularity,
+    E = e._ellipsoid,
+    a,
+    r,
+    w,
+    b = [],
+    i = le(e._positions, p.equalsEpsilon, !1, b);
+  if (h(n) && b.length > 0) {
+    let d = 0,
+      P = b[0];
+    n = n.filter(function (q, T) {
+      let g = !1;
+      return (
+        c ? (g = T === P || (T === 0 && P === 1)) : (g = T + 1 === P),
+        g ? (d++, (P = b[d]), !1) : !0
+      );
+    });
+  }
+  let f = i.length;
+  if (f < 2 || o <= 0) return;
+  if (s === N.GEODESIC || s === N.RHUMB) {
+    let d, P;
+    s === N.GEODESIC
+      ? ((d = J.chordLength(l, E.maximumRadius)), (P = U.numberOfPoints))
+      : ((d = l), (P = U.numberOfPointsRhumbLine));
+    let q = U.extractHeights(i, E);
+    if (h(n)) {
+      let T = 1;
+      for (a = 0; a < f - 1; ++a) T += P(i[a], i[a + 1], d);
+      let g = new Array(T),
+        D = 0;
+      for (a = 0; a < f - 1; ++a) {
+        let Z = i[a],
+          $ = i[a + 1],
+          I = n[a],
+          ee = P(Z, $, d);
+        if (c && a < T) {
+          let _e = n[a + 1],
+            te = Ae(Z, $, I, _e, ee),
+            Pe = te.length;
+          for (r = 0; r < Pe; ++r) g[D++] = te[r];
+        } else for (r = 0; r < ee; ++r) g[D++] = m.clone(I);
+      }
+      ((g[D] = m.clone(n[n.length - 1])), (n = g), (me.length = 0));
+    }
+    s === N.GEODESIC
+      ? (i = U.generateCartesianArc({
+          positions: i,
+          minDistance: d,
+          ellipsoid: E,
+          height: q,
+        }))
+      : (i = U.generateCartesianRhumbArc({
+          positions: i,
+          granularity: d,
+          ellipsoid: E,
+          height: q,
+        }));
+  }
+  f = i.length;
+  let L = f * 4 - 4,
+    M = new Float64Array(L * 3),
+    z = new Float64Array(L * 3),
+    H = new Float64Array(L * 3),
+    B = new Float32Array(L * 2),
+    K = t.st ? new Float32Array(L * 2) : void 0,
+    y = h(n) ? new Uint8Array(L * 4) : void 0,
+    W = 0,
+    j = 0,
+    X = 0,
+    Y = 0,
+    _;
+  for (r = 0; r < f; ++r) {
+    (r === 0
+      ? ((_ = pe), p.subtract(i[0], i[1], _), p.add(i[0], _, _))
+      : (_ = i[r - 1]),
+      p.clone(_, fe),
+      p.clone(i[r], ae),
+      r === f - 1
+        ? ((_ = pe), p.subtract(i[f - 1], i[f - 2], _), p.add(i[f - 1], _, _))
+        : (_ = i[r + 1]),
+      p.clone(_, he));
+    let d, P;
+    h(y) &&
+      (r !== 0 && !c ? (d = n[r - 1]) : (d = n[r]), r !== f - 1 && (P = n[r]));
+    let q = r === 0 ? 2 : 0,
+      T = r === f - 1 ? 2 : 4;
+    for (w = q; w < T; ++w) {
+      (p.pack(ae, M, W), p.pack(fe, z, W), p.pack(he, H, W), (W += 3));
+      let g = w - 2 < 0 ? -1 : 1;
+      if (
+        ((B[j++] = 2 * (w % 2) - 1),
+        (B[j++] = g * o),
+        t.st && ((K[X++] = r / (f - 1)), (K[X++] = Math.max(B[j - 2], 0))),
+        h(y))
+      ) {
+        let D = w < 2 ? d : P;
+        ((y[Y++] = m.floatToByte(D.red)),
+          (y[Y++] = m.floatToByte(D.green)),
+          (y[Y++] = m.floatToByte(D.blue)),
+          (y[Y++] = m.floatToByte(D.alpha)));
+      }
+    }
+  }
+  let v = new ce();
+  ((v.position = new O({
+    componentDatatype: x.DOUBLE,
+    componentsPerAttribute: 3,
+    values: M,
+  })),
+    (v.prevPosition = new O({
+      componentDatatype: x.DOUBLE,
+      componentsPerAttribute: 3,
+      values: z,
+    })),
+    (v.nextPosition = new O({
+      componentDatatype: x.DOUBLE,
+      componentsPerAttribute: 3,
+      values: H,
+    })),
+    (v.expandAndWidth = new O({
+      componentDatatype: x.FLOAT,
+      componentsPerAttribute: 2,
+      values: B,
+    })),
+    t.st &&
+      (v.st = new O({
+        componentDatatype: x.FLOAT,
+        componentsPerAttribute: 2,
+        values: K,
+      })),
+    h(y) &&
+      (v.color = new O({
+        componentDatatype: x.UNSIGNED_BYTE,
+        componentsPerAttribute: 4,
+        values: y,
+        normalize: !0,
+      })));
+  let C = se.createTypedArray(L, f * 6 - 6),
+    F = 0,
+    R = 0,
+    we = f - 1;
+  for (r = 0; r < we; ++r)
+    ((C[R++] = F),
+      (C[R++] = F + 2),
+      (C[R++] = F + 1),
+      (C[R++] = F + 1),
+      (C[R++] = F + 2),
+      (C[R++] = F + 3),
+      (F += 4));
+  return new ie({
+    attributes: v,
+    indices: C,
+    primitiveType: re.TRIANGLES,
+    boundingSphere: oe.fromPoints(i),
+    geometryType: ne.POLYLINES,
+  });
+};
+var Q = G;
+function ge(e, o) {
+  return (
+    h(o) && (e = Q.unpack(e, o)),
+    (e._ellipsoid = u.clone(e._ellipsoid)),
+    Q.createGeometry(e)
+  );
+}
+var We = ge;
+export { We as default };