create-swdg-frontend 0.1.0

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

@@ -0,0 +1,83 @@
+/**
+ * @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 t } from "./chunk-KCIZBVXL.js";
+import "./chunk-ILGBPNP6.js";
+import "./chunk-P37AI2DW.js";
+import "./chunk-T6BE4RZK.js";
+import "./chunk-X5IHHI6X.js";
+import "./chunk-TMSETF7M.js";
+import "./chunk-7Z5IIKOJ.js";
+import "./chunk-KZNJOCYU.js";
+import { a as d } from "./chunk-POASMU2N.js";
+import "./chunk-R6KGAEF6.js";
+import "./chunk-3C7WC463.js";
+import "./chunk-II4VNKYR.js";
+import { a as l } from "./chunk-IUA6FAOZ.js";
+import { b as u } from "./chunk-UH2WFNTA.js";
+import { e as a } from "./chunk-PEYJTJPE.js";
+function s(i) {
+  let e = l(i.radius, 1),
+    r = {
+      radii: new d(e, e, e),
+      stackPartitions: i.stackPartitions,
+      slicePartitions: i.slicePartitions,
+      subdivisions: i.subdivisions,
+    };
+  ((this._ellipsoidGeometry = new t(r)),
+    (this._workerName = "createSphereOutlineGeometry"));
+}
+s.packedLength = t.packedLength;
+s.pack = function (i, e, o) {
+  return (u.typeOf.object("value", i), t.pack(i._ellipsoidGeometry, e, o));
+};
+var m = new t(),
+  n = {
+    radius: void 0,
+    radii: new d(),
+    stackPartitions: void 0,
+    slicePartitions: void 0,
+    subdivisions: void 0,
+  };
+s.unpack = function (i, e, o) {
+  let r = t.unpack(i, e, m);
+  return (
+    (n.stackPartitions = r._stackPartitions),
+    (n.slicePartitions = r._slicePartitions),
+    (n.subdivisions = r._subdivisions),
+    a(o)
+      ? (d.clone(r._radii, n.radii), (o._ellipsoidGeometry = new t(n)), o)
+      : ((n.radius = r._radii.x), new s(n))
+  );
+};
+s.createGeometry = function (i) {
+  return t.createGeometry(i._ellipsoidGeometry);
+};
+var c = s;
+function p(i, e) {
+  return (a(e) && (i = c.unpack(i, e)), c.createGeometry(i));
+}
+var w = p;
+export { w as default };

package/template/public/Cesium1.119/Workers/createTaskProcessorWorker.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.
+ */
+
+import { a } from "./chunk-PXCJYT2S.js";
+import "./chunk-PEYJTJPE.js";
+export { a as default };

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

@@ -0,0 +1,289 @@
+/**
+ * @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 J } from "./chunk-PXCJYT2S.js";
+import { a as Y } from "./chunk-ABGXSJNX.js";
+import { a as B } from "./chunk-P37AI2DW.js";
+import { c as X, h as W } from "./chunk-7Z5IIKOJ.js";
+import "./chunk-KZNJOCYU.js";
+import { a as t, b as k, d as _ } from "./chunk-POASMU2N.js";
+import { a as v } from "./chunk-R6KGAEF6.js";
+import "./chunk-3C7WC463.js";
+import "./chunk-II4VNKYR.js";
+import "./chunk-IUA6FAOZ.js";
+import "./chunk-UH2WFNTA.js";
+import "./chunk-PEYJTJPE.js";
+var V = 32767,
+  it = Math.cos(v.toRadians(150)),
+  ct = new k(),
+  rt = new t();
+function at(e, o, c, i, s, A, h) {
+  let g = e.length,
+    f = new Float64Array(g * 3);
+  for (let d = 0; d < g; ++d) {
+    let l = e[d],
+      r = o[d],
+      E = c[d],
+      n = v.lerp(i.west, i.east, l / V),
+      p = v.lerp(i.south, i.north, r / V),
+      w = v.lerp(s, A, E / V),
+      x = k.fromRadians(n, p, w, ct),
+      P = h.cartographicToCartesian(x, rt);
+    t.pack(P, f, d * 3);
+  }
+  return f;
+}
+function dt(e) {
+  let o = e.length,
+    c = new Uint32Array(o + 1),
+    i = 0;
+  for (let s = 0; s < o; ++s) ((c[s] = i), (i += e[s]));
+  return ((c[o] = i), c);
+}
+var lt = new k(),
+  ht = new k();
+function ft(e, o, c, i) {
+  let s = i.length,
+    A = e.length,
+    h = new Uint8Array(A),
+    g = lt,
+    f = ht,
+    d = 0;
+  for (let r = 0; r < s; r++) {
+    let E = i[r],
+      n = E;
+    for (let p = 1; p < E; p++) {
+      let w = d + p,
+        x = w - 1;
+      ((f.longitude = e[w]),
+        (f.latitude = o[w]),
+        (g.longitude = e[x]),
+        (g.latitude = o[x]),
+        k.equals(f, g) && (n--, (h[x] = 1)));
+    }
+    ((i[r] = n), (d += E));
+  }
+  let l = 0;
+  for (let r = 0; r < A; r++)
+    h[r] !== 1 && ((e[l] = e[r]), (o[l] = o[r]), (c[l] = c[r]), l++);
+}
+function ot(e) {
+  let o = e * 8,
+    c = o * 3,
+    i = o * 4;
+  ((this.startEllipsoidNormals = new Float32Array(c)),
+    (this.endEllipsoidNormals = new Float32Array(c)),
+    (this.startPositionAndHeights = new Float32Array(i)),
+    (this.startFaceNormalAndVertexCornerIds = new Float32Array(i)),
+    (this.endPositionAndHeights = new Float32Array(i)),
+    (this.endFaceNormalAndHalfWidths = new Float32Array(i)),
+    (this.vertexBatchIds = new Uint16Array(o)),
+    (this.indices = B.createTypedArray(o, 36 * e)),
+    (this.vec3Offset = 0),
+    (this.vec4Offset = 0),
+    (this.batchIdOffset = 0),
+    (this.indexOffset = 0),
+    (this.volumeStartIndex = 0));
+}
+var Q = new t(),
+  pt = new t();
+function $(e, o, c, i, s) {
+  let A = t.subtract(c, o, pt),
+    h = t.subtract(o, e, Q);
+  return (
+    t.normalize(A, A),
+    t.normalize(h, h),
+    t.dot(A, h) < it && (h = t.multiplyByScalar(h, -1, Q)),
+    t.add(A, h, s),
+    t.equals(s, t.ZERO) && (s = t.subtract(e, o)),
+    t.cross(s, i, s),
+    t.cross(i, s, s),
+    t.normalize(s, s),
+    s
+  );
+}
+var st = [
+    0, 2, 6, 0, 6, 4, 0, 1, 3, 0, 3, 2, 0, 4, 5, 0, 5, 1, 5, 3, 1, 5, 7, 3, 7,
+    5, 4, 7, 4, 6, 7, 6, 2, 7, 2, 3,
+  ],
+  j = st.length,
+  tt = new t(),
+  ut = new t(),
+  mt = new t(),
+  At = new t(),
+  Nt = new t();
+ot.prototype.addVolume = function (e, o, c, i, s, A, h, g, f, d) {
+  let l = t.add(o, f, tt),
+    r = d.geodeticSurfaceNormal(l, ut);
+  l = t.add(c, f, tt);
+  let E = d.geodeticSurfaceNormal(l, At),
+    n = $(e, o, c, r, mt),
+    p = $(i, c, o, E, Nt),
+    w = this.startEllipsoidNormals,
+    x = this.endEllipsoidNormals,
+    P = this.startPositionAndHeights,
+    H = this.startFaceNormalAndVertexCornerIds,
+    b = this.endPositionAndHeights,
+    a = this.endFaceNormalAndHalfWidths,
+    F = this.vertexBatchIds,
+    m = this.batchIdOffset,
+    I = this.vec3Offset,
+    u = this.vec4Offset,
+    N;
+  for (N = 0; N < 8; N++)
+    (t.pack(r, w, I),
+      t.pack(E, x, I),
+      t.pack(o, P, u),
+      (P[u + 3] = s),
+      t.pack(c, b, u),
+      (b[u + 3] = A),
+      t.pack(n, H, u),
+      (H[u + 3] = N),
+      t.pack(p, a, u),
+      (a[u + 3] = h),
+      (F[m++] = g),
+      (I += 3),
+      (u += 4));
+  ((this.batchIdOffset = m), (this.vec3Offset = I), (this.vec4Offset = u));
+  let C = this.indices,
+    y = this.volumeStartIndex,
+    z = this.indexOffset;
+  for (N = 0; N < j; N++) C[z + N] = st[N] + y;
+  ((this.volumeStartIndex += 8), (this.indexOffset += j));
+};
+var gt = new W(),
+  Et = new _(),
+  wt = new t(),
+  M = new t(),
+  It = new t(),
+  xt = new t(),
+  T = new t();
+function Pt(e, o) {
+  let c = new Uint16Array(e.positions),
+    i = new Uint16Array(e.widths),
+    s = new Uint32Array(e.counts),
+    A = new Uint16Array(e.batchIds),
+    h = gt,
+    g = Et,
+    f = wt,
+    d = new Float64Array(e.packedBuffer),
+    l = 0,
+    r = d[l++],
+    E = d[l++];
+  (W.unpack(d, l, h),
+    (l += W.packedLength),
+    _.unpack(d, l, g),
+    (l += _.packedLength),
+    t.unpack(d, l, f));
+  let n,
+    p = c.length / 3,
+    w = c.subarray(0, p),
+    x = c.subarray(p, 2 * p),
+    P = c.subarray(2 * p, 3 * p);
+  (Y.zigZagDeltaDecode(w, x, P), ft(w, x, P, s));
+  let H = s.length,
+    b = 0;
+  for (n = 0; n < H; n++) {
+    let y = s[n];
+    b += y - 1;
+  }
+  let a = new ot(b),
+    F = at(w, x, P, h, r, E, g, f);
+  p = w.length;
+  let m = new Float32Array(p * 3);
+  for (n = 0; n < p; ++n)
+    ((m[n * 3] = F[n * 3] - f.x),
+      (m[n * 3 + 1] = F[n * 3 + 1] - f.y),
+      (m[n * 3 + 2] = F[n * 3 + 2] - f.z));
+  let I = 0,
+    u = 0;
+  for (n = 0; n < H; n++) {
+    let y = s[n] - 1,
+      z = i[n] * 0.5,
+      et = A[n],
+      q = I;
+    for (let D = 0; D < y; D++) {
+      let S = t.unpack(m, I, It),
+        O = t.unpack(m, I + 3, xt),
+        G = P[u],
+        Z = P[u + 1];
+      ((G = v.lerp(r, E, G / V)), (Z = v.lerp(r, E, Z / V)), u++);
+      let L = M,
+        R = T;
+      if (D === 0) {
+        let U = q + y * 3,
+          K = t.unpack(m, U, M);
+        if (t.equals(K, S)) t.unpack(m, U - 3, L);
+        else {
+          let nt = t.subtract(S, O, M);
+          L = t.add(nt, S, M);
+        }
+      } else t.unpack(m, I - 3, L);
+      if (D === y - 1) {
+        let U = t.unpack(m, q, T);
+        if (t.equals(U, O)) t.unpack(m, q + 3, R);
+        else {
+          let K = t.subtract(O, S, T);
+          R = t.add(K, O, T);
+        }
+      } else t.unpack(m, I + 6, R);
+      (a.addVolume(L, S, O, R, G, Z, z, et, f, g), (I += 3));
+    }
+    ((I += 3), u++);
+  }
+  let N = a.indices;
+  (o.push(a.startEllipsoidNormals.buffer),
+    o.push(a.endEllipsoidNormals.buffer),
+    o.push(a.startPositionAndHeights.buffer),
+    o.push(a.startFaceNormalAndVertexCornerIds.buffer),
+    o.push(a.endPositionAndHeights.buffer),
+    o.push(a.endFaceNormalAndHalfWidths.buffer),
+    o.push(a.vertexBatchIds.buffer),
+    o.push(N.buffer));
+  let C = {
+    indexDatatype:
+      N.BYTES_PER_ELEMENT === 2 ? B.UNSIGNED_SHORT : B.UNSIGNED_INT,
+    startEllipsoidNormals: a.startEllipsoidNormals.buffer,
+    endEllipsoidNormals: a.endEllipsoidNormals.buffer,
+    startPositionAndHeights: a.startPositionAndHeights.buffer,
+    startFaceNormalAndVertexCornerIds:
+      a.startFaceNormalAndVertexCornerIds.buffer,
+    endPositionAndHeights: a.endPositionAndHeights.buffer,
+    endFaceNormalAndHalfWidths: a.endFaceNormalAndHalfWidths.buffer,
+    vertexBatchIds: a.vertexBatchIds.buffer,
+    indices: N.buffer,
+  };
+  if (e.keepDecodedPositions) {
+    let y = dt(s);
+    (o.push(F.buffer, y.buffer),
+      (C = X(C, {
+        decodedPositions: F.buffer,
+        decodedPositionOffsets: y.buffer,
+      })));
+  }
+  return C;
+}
+var Vt = J(Pt);
+export { Vt as default };

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

@@ -0,0 +1,258 @@
+/**
+ * @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 P } from "./chunk-V7JEDBOE.js";
+import { a as z } from "./chunk-IAC5XVZV.js";
+import "./chunk-GFN7NNSJ.js";
+import { a as H } from "./chunk-TOGHF3VN.js";
+import { a as Y } from "./chunk-PXCJYT2S.js";
+import { a as j } from "./chunk-VBIROZR5.js";
+import "./chunk-ILGBPNP6.js";
+import "./chunk-HEEMUCG6.js";
+import { a as W } from "./chunk-P37AI2DW.js";
+import "./chunk-T6BE4RZK.js";
+import "./chunk-X5IHHI6X.js";
+import { d as E } from "./chunk-TMSETF7M.js";
+import { b as d } from "./chunk-7Z5IIKOJ.js";
+import "./chunk-KZNJOCYU.js";
+import { a as o } from "./chunk-POASMU2N.js";
+import "./chunk-R6KGAEF6.js";
+import "./chunk-3C7WC463.js";
+import "./chunk-II4VNKYR.js";
+import "./chunk-IUA6FAOZ.js";
+import "./chunk-UH2WFNTA.js";
+import { e as l } from "./chunk-PEYJTJPE.js";
+function X(e) {
+  ((this.offset = e.offset),
+    (this.count = e.count),
+    (this.color = e.color),
+    (this.batchIds = e.batchIds));
+}
+var J = X;
+var S = new o(),
+  $ = d.packedLength + o.packedLength,
+  ee = d.packedLength + 2,
+  ne = d.packedLength + o.packedLength,
+  te = o.packedLength + 1,
+  u = { modelMatrix: new d(), boundingVolume: new E() };
+function oe(e, c) {
+  let n = c * $,
+    i = o.unpack(e, n, S);
+  n += o.packedLength;
+  let r = d.unpack(e, n, u.modelMatrix);
+  d.multiplyByScale(r, i, r);
+  let t = u.boundingVolume;
+  return (o.clone(o.ZERO, t.center), (t.radius = Math.sqrt(3)), u);
+}
+function ce(e, c) {
+  let n = c * ee,
+    i = e[n++],
+    r = e[n++],
+    t = o.fromElements(i, i, r, S),
+    s = d.unpack(e, n, u.modelMatrix);
+  d.multiplyByScale(s, t, s);
+  let h = u.boundingVolume;
+  return (o.clone(o.ZERO, h.center), (h.radius = Math.sqrt(2)), u);
+}
+function se(e, c) {
+  let n = c * ne,
+    i = o.unpack(e, n, S);
+  n += o.packedLength;
+  let r = d.unpack(e, n, u.modelMatrix);
+  d.multiplyByScale(r, i, r);
+  let t = u.boundingVolume;
+  return (o.clone(o.ZERO, t.center), (t.radius = 1), u);
+}
+function ie(e, c) {
+  let n = c * te,
+    i = e[n++],
+    r = o.unpack(e, n, S),
+    t = d.fromTranslation(r, u.modelMatrix);
+  d.multiplyByUniformScale(t, i, t);
+  let s = u.boundingVolume;
+  return (o.clone(o.ZERO, s.center), (s.radius = 1), u);
+}
+var de = new o();
+function R(e, c, n, i, r) {
+  if (!l(c)) return;
+  let t = n.length,
+    s = i.attributes.position.values,
+    h = i.indices,
+    a = e.positions,
+    x = e.vertexBatchIds,
+    y = e.indices,
+    I = e.batchIds,
+    p = e.batchTableColors,
+    T = e.batchedIndices,
+    U = e.indexOffsets,
+    v = e.indexCounts,
+    L = e.boundingVolumes,
+    F = e.modelMatrix,
+    Z = e.center,
+    V = e.positionOffset,
+    B = e.batchIdIndex,
+    O = e.indexOffset,
+    D = e.batchedIndicesOffset;
+  for (let w = 0; w < t; ++w) {
+    let C = r(c, w),
+      k = C.modelMatrix;
+    d.multiply(F, k, k);
+    let M = n[w],
+      A = s.length;
+    for (let f = 0; f < A; f += 3) {
+      let m = o.unpack(s, f, de);
+      (d.multiplyByPoint(k, m, m),
+        o.subtract(m, Z, m),
+        o.pack(m, a, V * 3 + f),
+        (x[B++] = M));
+    }
+    let b = h.length;
+    for (let f = 0; f < b; ++f) y[O + f] = h[f] + V;
+    let g = w + D;
+    ((T[g] = new J({
+      offset: O,
+      count: b,
+      color: P.fromRgba(p[M]),
+      batchIds: [M],
+    })),
+      (I[g] = M),
+      (U[g] = O),
+      (v[g] = b),
+      (L[g] = E.transform(C.boundingVolume, k)),
+      (V += A / 3),
+      (O += b));
+  }
+  ((e.positionOffset = V),
+    (e.batchIdIndex = B),
+    (e.indexOffset = O),
+    (e.batchedIndicesOffset += t));
+}
+var K = new o(),
+  Q = new d();
+function re(e) {
+  let c = new Float64Array(e),
+    n = 0;
+  (o.unpack(c, n, K), (n += o.packedLength), d.unpack(c, n, Q));
+}
+function le(e) {
+  let c = e.length,
+    n = 0;
+  for (let i = 0; i < c; ++i) n += P.packedLength + 3 + e[i].batchIds.length;
+  return n;
+}
+function ae(e, c, n) {
+  let i = n.length,
+    r = 2 + i * E.packedLength + 1 + le(c),
+    t = new Float64Array(r),
+    s = 0;
+  ((t[s++] = e), (t[s++] = i));
+  for (let a = 0; a < i; ++a) (E.pack(n[a], t, s), (s += E.packedLength));
+  let h = c.length;
+  t[s++] = h;
+  for (let a = 0; a < h; ++a) {
+    let x = c[a];
+    (P.pack(x.color, t, s),
+      (s += P.packedLength),
+      (t[s++] = x.offset),
+      (t[s++] = x.count));
+    let y = x.batchIds,
+      I = y.length;
+    t[s++] = I;
+    for (let p = 0; p < I; ++p) t[s++] = y[p];
+  }
+  return t;
+}
+function fe(e, c) {
+  let n = l(e.boxes) ? new Float32Array(e.boxes) : void 0,
+    i = l(e.boxBatchIds) ? new Uint16Array(e.boxBatchIds) : void 0,
+    r = l(e.cylinders) ? new Float32Array(e.cylinders) : void 0,
+    t = l(e.cylinderBatchIds) ? new Uint16Array(e.cylinderBatchIds) : void 0,
+    s = l(e.ellipsoids) ? new Float32Array(e.ellipsoids) : void 0,
+    h = l(e.ellipsoidBatchIds) ? new Uint16Array(e.ellipsoidBatchIds) : void 0,
+    a = l(e.spheres) ? new Float32Array(e.spheres) : void 0,
+    x = l(e.sphereBatchIds) ? new Uint16Array(e.sphereBatchIds) : void 0,
+    y = l(n) ? i.length : 0,
+    I = l(r) ? t.length : 0,
+    p = l(s) ? h.length : 0,
+    T = l(a) ? x.length : 0,
+    U = j.getUnitBox(),
+    v = z.getUnitCylinder(),
+    L = H.getUnitEllipsoid(),
+    F = U.attributes.position.values,
+    Z = v.attributes.position.values,
+    V = L.attributes.position.values,
+    B = F.length * y;
+  ((B += Z.length * I), (B += V.length * (p + T)));
+  let O = U.indices,
+    D = v.indices,
+    w = L.indices,
+    C = O.length * y;
+  ((C += D.length * I), (C += w.length * (p + T)));
+  let k = new Float32Array(B),
+    M = new Uint16Array(B / 3),
+    A = W.createTypedArray(B / 3, C),
+    b = y + I + p + T,
+    g = new Uint16Array(b),
+    f = new Array(b),
+    m = new Uint32Array(b),
+    q = new Uint32Array(b),
+    _ = new Array(b);
+  re(e.packedBuffer);
+  let G = {
+    batchTableColors: new Uint32Array(e.batchTableColors),
+    positions: k,
+    vertexBatchIds: M,
+    indices: A,
+    batchIds: g,
+    batchedIndices: f,
+    indexOffsets: m,
+    indexCounts: q,
+    boundingVolumes: _,
+    positionOffset: 0,
+    batchIdIndex: 0,
+    indexOffset: 0,
+    batchedIndicesOffset: 0,
+    modelMatrix: Q,
+    center: K,
+  };
+  (R(G, n, i, U, oe), R(G, r, t, v, ce), R(G, s, h, L, se), R(G, a, x, L, ie));
+  let N = ae(A.BYTES_PER_ELEMENT, f, _);
+  return (
+    c.push(k.buffer, M.buffer, A.buffer),
+    c.push(g.buffer, m.buffer, q.buffer),
+    c.push(N.buffer),
+    {
+      positions: k.buffer,
+      vertexBatchIds: M.buffer,
+      indices: A.buffer,
+      indexOffsets: m.buffer,
+      indexCounts: q.buffer,
+      batchIds: g.buffer,
+      packedBuffer: N.buffer,
+    }
+  );
+}
+var Oe = Y(fe);
+export { Oe as default };