@vcmap/ui 6.3.10 → 7.0.0-rc.1

package/dist/assets/cesium/Workers/{chunk-MMU6M3F4.js → chunk-RRJYZWF4.js}

@@ -1,7 +1,7 @@
 /**
  * @license
  * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.121.5
+ * Version 1.142.1
  *
  * Copyright 2011-2022 Cesium Contributors
  *
@@ -25,20 +25,22 @@
 
 import {
   PolylinePipeline_default
-} from "./chunk-I5ZGV4B2.js";
+} from "./chunk-7U5C6VA5.js";
 import {
   arrayRemoveDuplicates_default
-} from "./chunk-QKMMP2KM.js";
+} from "./chunk-7QWEUYQX.js";
 import {
-  Cartesian3_default,
   Cartographic_default
-} from "./chunk-L7QP6H72.js";
+} from "./chunk-PUZJ6L3M.js";
+import {
+  Cartesian3_default
+} from "./chunk-XQTAS7TZ.js";
 import {
   Math_default
-} from "./chunk-QEMZBTFR.js";
+} from "./chunk-O5KPQGWB.js";
 import {
   defined_default
-} from "./chunk-NCBLZFLY.js";
+} from "./chunk-XUW5H676.js";
 
 // packages/engine/Source/Core/WallGeometryLibrary.js
 var WallGeometryLibrary = {};

package/dist/assets/cesium/Workers/{chunk-PMC3FYPH.js → chunk-SLD6LZDJ.js}

@@ -1,7 +1,7 @@
 /**
  * @license
  * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.121.5
+ * Version 1.142.1
  *
  * Copyright 2011-2022 Cesium Contributors
  *
@@ -25,7 +25,7 @@
 
 import {
   defined_default
-} from "./chunk-NCBLZFLY.js";
+} from "./chunk-XUW5H676.js";
 
 // packages/engine/Source/Core/DeveloperError.js
 function DeveloperError(message) {

package/dist/assets/cesium/Workers/{chunk-XWGO36ZG.js → chunk-SU5PCD4V.js}

@@ -1,7 +1,7 @@
 /**
  * @license
  * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.121.5
+ * Version 1.142.1
  *
  * Copyright 2011-2022 Cesium Contributors
  *
@@ -48,7 +48,8 @@ var ArcType = {
    */
   RHUMB: 2
 };
-var ArcType_default = Object.freeze(ArcType);
+Object.freeze(ArcType);
+var ArcType_default = ArcType;
 
 export {
   ArcType_default

package/dist/assets/cesium/Workers/{chunk-PD7IJVPU.js → chunk-TJUEQC6E.js}

@@ -1,7 +1,7 @@
 /**
  * @license
  * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.121.5
+ * Version 1.142.1
  *
  * Copyright 2011-2022 Cesium Contributors
  *
@@ -24,23 +24,22 @@
  */
 
 import {
-  Cartesian3_default,
   Cartographic_default,
   Ellipsoid_default
-} from "./chunk-L7QP6H72.js";
+} from "./chunk-PUZJ6L3M.js";
 import {
-  Math_default
-} from "./chunk-QEMZBTFR.js";
+  Cartesian3_default
+} from "./chunk-XQTAS7TZ.js";
 import {
-  defaultValue_default
-} from "./chunk-4OZXCGBJ.js";
+  Math_default
+} from "./chunk-O5KPQGWB.js";
 import {
   Check_default,
   DeveloperError_default
-} from "./chunk-PMC3FYPH.js";
+} from "./chunk-SLD6LZDJ.js";
 import {
   defined_default
-} from "./chunk-NCBLZFLY.js";
+} from "./chunk-XUW5H676.js";
 
 // packages/engine/Source/Core/EllipsoidRhumbLine.js
 function calculateM(ellipticity, major, latitude) {
@@ -234,7 +233,7 @@ function interpolateUsingSurfaceDistance(start, heading, distance, major, ellipt
   return new Cartographic_default(longitude, latitude, 0);
 }
 function EllipsoidRhumbLine(start, end, ellipsoid) {
-  const e = defaultValue_default(ellipsoid, Ellipsoid_default.default);
+  const e = ellipsoid ?? Ellipsoid_default.default;
   this._ellipsoid = e;
   this._start = new Cartographic_default();
   this._end = new Cartographic_default();
@@ -310,7 +309,7 @@ EllipsoidRhumbLine.fromStartHeadingDistance = function(start, heading, distance,
   Check_default.defined("heading", heading);
   Check_default.defined("distance", distance);
   Check_default.typeOf.number.greaterThan("distance", distance, 0);
-  const e = defaultValue_default(ellipsoid, Ellipsoid_default.default);
+  const e = ellipsoid ?? Ellipsoid_default.default;
   const major = e.maximumRadius;
   const minor = e.minimumRadius;
   const majorSquared = major * major;

package/dist/assets/cesium/Workers/{chunk-O6F3JX5O.js → chunk-TLKYIN6G.js}

@@ -1,7 +1,7 @@
 /**
  * @license
  * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.121.5
+ * Version 1.142.1
  *
  * Copyright 2011-2022 Cesium Contributors
  *
@@ -25,56 +25,58 @@
 
 import {
   AttributeCompression_default
-} from "./chunk-7XCBLPDB.js";
+} from "./chunk-AMPM3GPK.js";
 import {
   EncodedCartesian3_default
-} from "./chunk-TLDJYDQA.js";
+} from "./chunk-GWZXZY4E.js";
 import {
   IntersectionTests_default
-} from "./chunk-J66MKJOE.js";
+} from "./chunk-ULPIJ2PX.js";
 import {
   Plane_default
-} from "./chunk-EGAGTCTF.js";
+} from "./chunk-YTBQGASE.js";
 import {
   IndexDatatype_default
-} from "./chunk-H7MDD63F.js";
+} from "./chunk-DQO6TXCC.js";
 import {
   GeometryAttribute_default,
   GeometryType_default,
   Geometry_default,
   PrimitiveType_default
-} from "./chunk-HCHTH3IB.js";
+} from "./chunk-U3D7L4QU.js";
 import {
   BoundingSphere_default,
-  GeographicProjection_default,
+  GeographicProjection_default
+} from "./chunk-DPG524EP.js";
+import {
   Intersect_default
-} from "./chunk-TYFDCGJA.js";
+} from "./chunk-ACHR63LC.js";
 import {
   Cartesian4_default,
   Matrix4_default
-} from "./chunk-KQZETAD4.js";
+} from "./chunk-ASJCWPAG.js";
 import {
   ComponentDatatype_default
-} from "./chunk-GULESHYV.js";
+} from "./chunk-BZUVEBLN.js";
 import {
   Cartesian2_default,
+  Cartographic_default
+} from "./chunk-PUZJ6L3M.js";
+import {
   Cartesian3_default,
-  Cartographic_default,
+  Frozen_default,
   Matrix3_default
-} from "./chunk-L7QP6H72.js";
+} from "./chunk-XQTAS7TZ.js";
 import {
   Math_default
-} from "./chunk-QEMZBTFR.js";
-import {
-  defaultValue_default
-} from "./chunk-4OZXCGBJ.js";
+} from "./chunk-O5KPQGWB.js";
 import {
   Check_default,
   DeveloperError_default
-} from "./chunk-PMC3FYPH.js";
+} from "./chunk-SLD6LZDJ.js";
 import {
   defined_default
-} from "./chunk-NCBLZFLY.js";
+} from "./chunk-XUW5H676.js";
 
 // packages/engine/Source/Core/barycentricCoordinates.js
 var scratchCartesian1 = new Cartesian3_default();
@@ -149,10 +151,10 @@ var barycentricCoordinates_default = barycentricCoordinates;
 // packages/engine/Source/Core/Tipsify.js
 var Tipsify = {};
 Tipsify.calculateACMR = function(options) {
-  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
+  options = options ?? Frozen_default.EMPTY_OBJECT;
   const indices = options.indices;
   let maximumIndex = options.maximumIndex;
-  const cacheSize = defaultValue_default(options.cacheSize, 24);
+  const cacheSize = options.cacheSize ?? 24;
   if (!defined_default(indices)) {
     throw new DeveloperError_default("indices is required.");
   }
@@ -192,10 +194,10 @@ Tipsify.calculateACMR = function(options) {
   return (s - cacheSize + 1) / (numIndices / 3);
 };
 Tipsify.tipsify = function(options) {
-  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
+  options = options ?? Frozen_default.EMPTY_OBJECT;
   const indices = options.indices;
   const maximumIndex = options.maximumIndex;
-  const cacheSize = defaultValue_default(options.cacheSize, 24);
+  const cacheSize = options.cacheSize ?? 24;
   let cursor;
   function skipDeadEnd(vertices2, deadEnd2, indices2, maximumIndexPlusOne2) {
     while (deadEnd2.length >= 1) {
@@ -427,7 +429,7 @@ GeometryPipeline.toWireframe = function(geometry) {
   return geometry;
 };
 GeometryPipeline.createLineSegmentsForVectors = function(geometry, attributeName, length) {
-  attributeName = defaultValue_default(attributeName, "normal");
+  attributeName = attributeName ?? "normal";
   if (!defined_default(geometry)) {
     throw new DeveloperError_default("geometry is required.");
   }
@@ -439,7 +441,7 @@ GeometryPipeline.createLineSegmentsForVectors = function(geometry, attributeName
       `geometry.attributes must have an attribute with the same name as the attributeName parameter, ${attributeName}.`
     );
   }
-  length = defaultValue_default(length, 1e4);
+  length = length ?? 1e4;
   const positions = geometry.attributes.position.values;
   const vectors = geometry.attributes[attributeName].values;
   const positionsLength = positions.length;

package/dist/assets/cesium/Workers/{chunk-PSCX6XFR.js → chunk-TW2O7NQI.js}

@@ -1,7 +1,7 @@
 /**
  * @license
  * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.121.5
+ * Version 1.142.1
  *
  * Copyright 2011-2022 Cesium Contributors
  *
@@ -25,59 +25,58 @@
 
 import {
   ArcType_default
-} from "./chunk-XWGO36ZG.js";
+} from "./chunk-SU5PCD4V.js";
 import {
   GeometryPipeline_default
-} from "./chunk-O6F3JX5O.js";
+} from "./chunk-TLKYIN6G.js";
 import {
   PolygonPipeline_default,
   WindingOrder_default
-} from "./chunk-UJWE4G4I.js";
+} from "./chunk-5JL55S2T.js";
 import {
   arrayRemoveDuplicates_default
-} from "./chunk-QKMMP2KM.js";
+} from "./chunk-7QWEUYQX.js";
 import {
   EllipsoidRhumbLine_default
-} from "./chunk-PD7IJVPU.js";
+} from "./chunk-TJUEQC6E.js";
 import {
   IntersectionTests_default
-} from "./chunk-J66MKJOE.js";
+} from "./chunk-ULPIJ2PX.js";
 import {
   Plane_default
-} from "./chunk-EGAGTCTF.js";
+} from "./chunk-YTBQGASE.js";
 import {
   IndexDatatype_default
-} from "./chunk-H7MDD63F.js";
+} from "./chunk-DQO6TXCC.js";
 import {
   GeometryAttributes_default
-} from "./chunk-F4TYWTLA.js";
+} from "./chunk-JBKUQ6FE.js";
 import {
   GeometryAttribute_default,
   Geometry_default,
   PrimitiveType_default
-} from "./chunk-HCHTH3IB.js";
+} from "./chunk-U3D7L4QU.js";
 import {
   Quaternion_default
-} from "./chunk-KQZETAD4.js";
+} from "./chunk-CFHMMZKU.js";
 import {
   ComponentDatatype_default
-} from "./chunk-GULESHYV.js";
+} from "./chunk-BZUVEBLN.js";
 import {
   Cartesian2_default,
-  Cartesian3_default,
   Cartographic_default,
-  Ellipsoid_default,
+  Ellipsoid_default
+} from "./chunk-PUZJ6L3M.js";
+import {
+  Cartesian3_default,
   Matrix3_default
-} from "./chunk-L7QP6H72.js";
+} from "./chunk-XQTAS7TZ.js";
 import {
   Math_default
-} from "./chunk-QEMZBTFR.js";
-import {
-  defaultValue_default
-} from "./chunk-4OZXCGBJ.js";
+} from "./chunk-O5KPQGWB.js";
 import {
   defined_default
-} from "./chunk-NCBLZFLY.js";
+} from "./chunk-XUW5H676.js";
 
 // packages/engine/Source/Core/PolygonHierarchy.js
 function PolygonHierarchy(positions, holes) {
@@ -327,13 +326,20 @@ PolygonGeometryLibrary.subdivideRhumbLine = function(ellipsoid, p0, p1, minDista
   const c0 = ellipsoid.cartesianToCartographic(p0, scratchCartographic0);
   const c1 = ellipsoid.cartesianToCartographic(p1, scratchCartographic1);
   const rhumb = new EllipsoidRhumbLine_default(c0, c1, ellipsoid);
+  if (!defined_default(result)) {
+    result = [];
+  }
+  if (rhumb.surfaceDistance <= minDistance) {
+    result.length = 3;
+    result[0] = p0.x;
+    result[1] = p0.y;
+    result[2] = p0.z;
+    return result;
+  }
   const n = rhumb.surfaceDistance / minDistance;
   const countDivide = Math.max(0, Math.ceil(Math_default.log2(n)));
   const numVertices = Math.pow(2, countDivide);
   const distanceBetweenVertices = rhumb.surfaceDistance / numVertices;
-  if (!defined_default(result)) {
-    result = [];
-  }
   const positions = result;
   positions.length = numVertices * 3;
   let index = 0;
@@ -354,7 +360,7 @@ var scaleToGeodeticHeightN2 = new Cartesian3_default();
 var scaleToGeodeticHeightP1 = new Cartesian3_default();
 var scaleToGeodeticHeightP2 = new Cartesian3_default();
 PolygonGeometryLibrary.scaleToGeodeticHeightExtruded = function(geometry, maxHeight, minHeight, ellipsoid, perPositionHeight) {
-  ellipsoid = defaultValue_default(ellipsoid, Ellipsoid_default.default);
+  ellipsoid = ellipsoid ?? Ellipsoid_default.default;
   const n1 = scaleToGeodeticHeightN1;
   let n2 = scaleToGeodeticHeightN2;
   const p = scaleToGeodeticHeightP1;
@@ -658,9 +664,7 @@ PolygonGeometryLibrary.polygonsFromHierarchy = function(polygonHierarchy, keepDu
       continue;
     }
     const holeIndices = [];
-    let originalWindingOrder = PolygonPipeline_default.computeWindingOrder2D(
-      positions2D
-    );
+    let originalWindingOrder = PolygonPipeline_default.computeWindingOrder2D(positions2D);
     if (originalWindingOrder === WindingOrder_default.CLOCKWISE) {
       positions2D.reverse();
       outerRing = outerRing.slice().reverse();
@@ -703,9 +707,7 @@ PolygonGeometryLibrary.polygonsFromHierarchy = function(polygonHierarchy, keepDu
       if (!defined_default(holePositions2D)) {
         continue;
       }
-      originalWindingOrder = PolygonPipeline_default.computeWindingOrder2D(
-        holePositions2D
-      );
+      originalWindingOrder = PolygonPipeline_default.computeWindingOrder2D(holePositions2D);
       if (originalWindingOrder === WindingOrder_default.CLOCKWISE) {
         holePositions2D.reverse();
         holePositions = holePositions.slice().reverse();

package/dist/assets/cesium/Workers/chunk-U3AXZMFD.js

@@ -0,0 +1,280 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.142.1
+ *
+ * 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.
+ */
+
+
+// node_modules/@cesium/wasm-splats/wasm_splats.js
+var wasm;
+var cachedTextDecoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf-8", { ignoreBOM: true, fatal: true }) : { decode: () => {
+  throw Error("TextDecoder not available");
+} };
+if (typeof TextDecoder !== "undefined") {
+  cachedTextDecoder.decode();
+}
+var cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+  if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+    cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+  }
+  return cachedUint8ArrayMemory0;
+}
+function getStringFromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+var cachedUint32ArrayMemory0 = null;
+function getUint32ArrayMemory0() {
+  if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
+    cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
+  }
+  return cachedUint32ArrayMemory0;
+}
+function getArrayU32FromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+var WASM_VECTOR_LEN = 0;
+function passArray32ToWasm0(arg, malloc) {
+  const ptr = malloc(arg.length * 4, 4) >>> 0;
+  getUint32ArrayMemory0().set(arg, ptr / 4);
+  WASM_VECTOR_LEN = arg.length;
+  return ptr;
+}
+function takeFromExternrefTable0(idx) {
+  const value = wasm.__wbindgen_export_0.get(idx);
+  wasm.__externref_table_dealloc(idx);
+  return value;
+}
+function generate_splat_texture(positions, scales, rotations, colors, count) {
+  const ret = wasm.generate_splat_texture(positions, scales, rotations, colors, count);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
+  }
+  return TextureData.__wrap(ret[0]);
+}
+function radix_sort_gaussians_indexes(positions_arr, model_view_arr, count) {
+  const ret = wasm.radix_sort_gaussians_indexes(positions_arr, model_view_arr, count);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
+  }
+  return takeFromExternrefTable0(ret[0]);
+}
+var TextureDataFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_texturedata_free(ptr >>> 0, 1));
+var TextureData = class _TextureData {
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(_TextureData.prototype);
+    obj.__wbg_ptr = ptr;
+    TextureDataFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    TextureDataFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_texturedata_free(ptr, 0);
+  }
+  /**
+   * Getter for the underlying texture data. Always returns a copy.
+   * @returns {Uint32Array}
+   */
+  get data() {
+    const ret = wasm.texturedata_data(this.__wbg_ptr);
+    var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v1;
+  }
+  /**
+   * Getter for the width of the texture in pixels.
+   * @returns {number}
+   */
+  get width() {
+    const ret = wasm.texturedata_width(this.__wbg_ptr);
+    return ret >>> 0;
+  }
+  /**
+   * Getter for the height of the texture in pixels.
+   * @returns {number}
+   */
+  get height() {
+    const ret = wasm.texturedata_height(this.__wbg_ptr);
+    return ret >>> 0;
+  }
+  /**
+   * Creates a new texture data object with the underlying data, width, and height.
+   * @param {Uint32Array} data
+   * @param {number} width
+   * @param {number} height
+   * @returns {TextureData}
+   */
+  static new(data, width, height) {
+    const ptr0 = passArray32ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.texturedata_new(ptr0, len0, width, height);
+    return _TextureData.__wrap(ret);
+  }
+};
+async function __wbg_load(module, imports) {
+  if (typeof Response === "function" && module instanceof Response) {
+    if (typeof WebAssembly.instantiateStreaming === "function") {
+      try {
+        return await WebAssembly.instantiateStreaming(module, imports);
+      } catch (e) {
+        if (module.headers.get("Content-Type") != "application/wasm") {
+          console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+        } else {
+          throw e;
+        }
+      }
+    }
+    const bytes = await module.arrayBuffer();
+    return await WebAssembly.instantiate(bytes, imports);
+  } else {
+    const instance = await WebAssembly.instantiate(module, imports);
+    if (instance instanceof WebAssembly.Instance) {
+      return { instance, module };
+    } else {
+      return instance;
+    }
+  }
+}
+function __wbg_get_imports() {
+  const imports = {};
+  imports.wbg = {};
+  imports.wbg.__wbg_buffer_609cc3eee51ed158 = function(arg0) {
+    const ret = arg0.buffer;
+    return ret;
+  };
+  imports.wbg.__wbg_length_3b4f022188ae8db6 = function(arg0) {
+    const ret = arg0.length;
+    return ret;
+  };
+  imports.wbg.__wbg_length_a446193dc22c12f8 = function(arg0) {
+    const ret = arg0.length;
+    return ret;
+  };
+  imports.wbg.__wbg_new_780abee5c1739fd7 = function(arg0) {
+    const ret = new Float32Array(arg0);
+    return ret;
+  };
+  imports.wbg.__wbg_new_a12002a7f91c75be = function(arg0) {
+    const ret = new Uint8Array(arg0);
+    return ret;
+  };
+  imports.wbg.__wbg_new_e3b321dcfef89fc7 = function(arg0) {
+    const ret = new Uint32Array(arg0);
+    return ret;
+  };
+  imports.wbg.__wbg_newwithbyteoffsetandlength_f1dead44d1fc7212 = function(arg0, arg1, arg2) {
+    const ret = new Uint32Array(arg0, arg1 >>> 0, arg2 >>> 0);
+    return ret;
+  };
+  imports.wbg.__wbg_set_10bad9bee0e9c58b = function(arg0, arg1, arg2) {
+    arg0.set(arg1, arg2 >>> 0);
+  };
+  imports.wbg.__wbg_set_65595bdd868b3009 = function(arg0, arg1, arg2) {
+    arg0.set(arg1, arg2 >>> 0);
+  };
+  imports.wbg.__wbindgen_init_externref_table = function() {
+    const table = wasm.__wbindgen_export_0;
+    const offset = table.grow(4);
+    table.set(0, void 0);
+    table.set(offset + 0, void 0);
+    table.set(offset + 1, null);
+    table.set(offset + 2, true);
+    table.set(offset + 3, false);
+    ;
+  };
+  imports.wbg.__wbindgen_memory = function() {
+    const ret = wasm.memory;
+    return ret;
+  };
+  imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
+    const ret = getStringFromWasm0(arg0, arg1);
+    return ret;
+  };
+  imports.wbg.__wbindgen_throw = function(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+  };
+  return imports;
+}
+function __wbg_init_memory(imports, memory) {
+}
+function __wbg_finalize_init(instance, module) {
+  wasm = instance.exports;
+  __wbg_init.__wbindgen_wasm_module = module;
+  cachedUint32ArrayMemory0 = null;
+  cachedUint8ArrayMemory0 = null;
+  wasm.__wbindgen_start();
+  return wasm;
+}
+function initSync(module) {
+  if (wasm !== void 0) return wasm;
+  if (typeof module !== "undefined") {
+    if (Object.getPrototypeOf(module) === Object.prototype) {
+      ({ module } = module);
+    } else {
+      console.warn("using deprecated parameters for `initSync()`; pass a single object instead");
+    }
+  }
+  const imports = __wbg_get_imports();
+  __wbg_init_memory(imports);
+  if (!(module instanceof WebAssembly.Module)) {
+    module = new WebAssembly.Module(module);
+  }
+  const instance = new WebAssembly.Instance(module, imports);
+  return __wbg_finalize_init(instance, module);
+}
+async function __wbg_init(module_or_path) {
+  if (wasm !== void 0) return wasm;
+  if (typeof module_or_path !== "undefined") {
+    if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+      ({ module_or_path } = module_or_path);
+    } else {
+      console.warn("using deprecated parameters for the initialization function; pass a single object instead");
+    }
+  }
+  if (typeof module_or_path === "undefined") {
+    module_or_path = new URL("wasm_splats_bg.wasm", import.meta.url);
+  }
+  const imports = __wbg_get_imports();
+  if (typeof module_or_path === "string" || typeof Request === "function" && module_or_path instanceof Request || typeof URL === "function" && module_or_path instanceof URL) {
+    module_or_path = fetch(module_or_path);
+  }
+  __wbg_init_memory(imports);
+  const { instance, module } = await __wbg_load(await module_or_path, imports);
+  return __wbg_finalize_init(instance, module);
+}
+
+export {
+  generate_splat_texture,
+  radix_sort_gaussians_indexes,
+  initSync
+};