@loaders.gl/las 4.4.0-alpha.1 → 4.4.0-alpha.10

package/dist/dist.dev.js

@@ -62,8 +62,10 @@ var __exports__ = (() => {
   __export(bundle_exports, {
     LASArrowLoader: () => LASArrowLoader,
     LASFormat: () => LASFormat,
-    LASLoader: () => LASLoader2,
-    LASWorkerLoader: () => LASWorkerLoader
+    LASLoader: () => LAZPerfLoader,
+    LASWorkerLoader: () => LASWorkerLoader,
+    LAZPerfLoader: () => LAZPerfLoader,
+    LAZRsLoader: () => LAZRsLoader
   });
   __reExport(bundle_exports, __toESM(require_core(), 1));
 
@@ -76,9 +78,27 @@ var __exports__ = (() => {
     // LAZ is the "compressed" flavor of LAS,
     mimeTypes: ["application/octet-stream"],
     // TODO - text version?
-    text: true,
+    text: false,
     binary: true,
-    tests: ["LAS"]
+    tests: ["LASF"]
+  };
+
+  // src/las-loader.ts
+  var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var LASWorkerLoader = {
+    ...LASFormat,
+    dataType: null,
+    batchType: null,
+    version: VERSION,
+    worker: true,
+    options: {
+      las: {
+        shape: "mesh",
+        fp64: false,
+        skip: 1,
+        colorDepth: 8
+      }
+    }
   };
 
   // ../schema-utils/src/lib/schema/data-type.ts
@@ -12107,7 +12127,38 @@ return true;`);
     return result;
   }
 
-  // src/lib/libs/laz-perf.ts
+  // src/lib/get-las-schema.ts
+  function getLASSchema(lasHeader, attributes) {
+    const metadataMap = makeMetadataFromLasHeader(lasHeader);
+    const schema = deduceMeshSchema(attributes, metadataMap);
+    return schema;
+  }
+  function makeMetadataFromLasHeader(lasHeader) {
+    const metadata = {};
+    metadata.las_pointsOffset = lasHeader.pointsOffset.toString(10);
+    metadata.las_pointsFormatId = lasHeader.pointsFormatId.toString(10);
+    metadata.las_pointsStructSize = lasHeader.pointsStructSize.toString(10);
+    metadata.las_pointsCount = lasHeader.pointsCount.toString(10);
+    metadata.las_scale = JSON.stringify(lasHeader.scale);
+    metadata.las_offset = JSON.stringify(lasHeader.offset);
+    if (lasHeader.maxs !== void 0) {
+      metadata.las_maxs = JSON.stringify(lasHeader.maxs);
+    }
+    if (lasHeader.mins !== void 0) {
+      metadata.las_mins = JSON.stringify(lasHeader.mins);
+    }
+    metadata.las_totalToRead = lasHeader.totalToRead.toString(10);
+    metadata.las_pointsFortotalReadmatId = lasHeader.totalRead.toString(10);
+    if (lasHeader.versionAsString !== void 0) {
+      metadata.las_versionAsString = lasHeader.versionAsString;
+    }
+    if (lasHeader.isCompressed !== void 0) {
+      metadata.las_isCompressed = lasHeader.isCompressed.toString();
+    }
+    return metadata;
+  }
+
+  // src/libs/laz-perf/laz-perf.ts
   function getModule() {
     var Module2 = typeof Module2 !== "undefined" ? Module2 : {};
     var moduleOverrides = {};
@@ -14201,10 +14252,10 @@ return true;`);
     }
     function __embind_register_std_wstring(rawType, charSize, name) {
       name = readLatin1String(name);
-      var decodeString, encodeString, getHeap, lengthBytesUTF, shift;
+      var decodeString, encodeString2, getHeap, lengthBytesUTF, shift;
       if (charSize === 2) {
         decodeString = UTF16ToString;
-        encodeString = stringToUTF16;
+        encodeString2 = stringToUTF16;
         lengthBytesUTF = lengthBytesUTF16;
         getHeap = function() {
           return HEAPU16;
@@ -14212,7 +14263,7 @@ return true;`);
         shift = 1;
       } else if (charSize === 4) {
         decodeString = UTF32ToString;
-        encodeString = stringToUTF32;
+        encodeString2 = stringToUTF32;
         lengthBytesUTF = lengthBytesUTF32;
         getHeap = function() {
           return HEAPU32;
@@ -14250,7 +14301,7 @@ return true;`);
           var length = lengthBytesUTF(value);
           var ptr = _malloc(4 + length + charSize);
           HEAPU32[ptr >> 2] = length >> shift;
-          encodeString(value, ptr + 4, length + charSize);
+          encodeString2(value, ptr + 4, length + charSize);
           if (destructors !== null) {
             destructors.push(_free, ptr);
           }
@@ -30725,7 +30776,7 @@ return true;`);
     return Module2;
   }
 
-  // src/lib/laslaz-decoder.ts
+  // src/lib/laz-perf/laslaz-decoder.ts
   var Module = null;
   var POINT_FORMAT_READERS = {
     0: (dv) => {
@@ -30805,7 +30856,8 @@ return true;`);
       totalToRead: 0,
       totalRead: 0,
       versionAsString: "",
-      isCompressed: true
+      isCompressed: true,
+      hasColor: false
     };
     constructor(arraybuffer) {
       this.arraybuffer = arraybuffer;
@@ -31094,38 +31146,7 @@ return true;`);
     }
   };
 
-  // src/lib/get-las-schema.ts
-  function getLASSchema(lasHeader, attributes) {
-    const metadataMap = makeMetadataFromLasHeader(lasHeader);
-    const schema = deduceMeshSchema(attributes, metadataMap);
-    return schema;
-  }
-  function makeMetadataFromLasHeader(lasHeader) {
-    const metadata = {};
-    metadata.las_pointsOffset = lasHeader.pointsOffset.toString(10);
-    metadata.las_pointsFormatId = lasHeader.pointsFormatId.toString(10);
-    metadata.las_pointsStructSize = lasHeader.pointsStructSize.toString(10);
-    metadata.las_pointsCount = lasHeader.pointsCount.toString(10);
-    metadata.las_scale = JSON.stringify(lasHeader.scale);
-    metadata.las_offset = JSON.stringify(lasHeader.offset);
-    if (lasHeader.maxs !== void 0) {
-      metadata.las_maxs = JSON.stringify(lasHeader.maxs);
-    }
-    if (lasHeader.mins !== void 0) {
-      metadata.las_mins = JSON.stringify(lasHeader.mins);
-    }
-    metadata.las_totalToRead = lasHeader.totalToRead.toString(10);
-    metadata.las_pointsFortotalReadmatId = lasHeader.totalRead.toString(10);
-    if (lasHeader.versionAsString !== void 0) {
-      metadata.las_versionAsString = lasHeader.versionAsString;
-    }
-    if (lasHeader.isCompressed !== void 0) {
-      metadata.las_isCompressed = lasHeader.isCompressed.toString();
-    }
-    return metadata;
-  }
-
-  // src/lib/parse-las.ts
+  // src/lib/laz-perf/parse-las.ts
   function parseLAS(arrayBuffer, options) {
     return parseLASMesh(arrayBuffer, options);
   }
@@ -31159,7 +31180,7 @@ return true;`);
         const total = lasHeader.totalToRead;
         const PositionsType = options.las?.fp64 ? Float64Array : Float32Array;
         positions = new PositionsType(total * 3);
-        colors = lasHeader.pointsFormatId >= 2 ? new Uint8Array(total * 4) : null;
+        colors = lasHeader.hasColor ? new Uint8Array(total * 4) : null;
         intensities = new Uint16Array(total);
         classifications = new Uint8Array(total);
         lasMesh.loaderData = lasHeader;
@@ -31228,11 +31249,9 @@ return true;`);
       header.totalToRead = totalToRead;
       let totalRead = 0;
       while (true) {
-        const chunk = dataHandler.readData(1e3 * 100, 0, skip);
+        const chunk = dataHandler.readData(1e3 * 100, skip);
         totalRead += chunk.count;
         header.totalRead = totalRead;
-        header.versionAsString = chunk.versionAsString;
-        header.isCompressed = chunk.isCompressed;
         const unpacker = new Unpacker(chunk.buffer, chunk.count, header);
         onParseData(unpacker, header);
         if (!chunk.hasMoreData || totalRead >= totalToRead) {
@@ -31271,34 +31290,8 @@ return true;`);
     return twoByteColor;
   }
 
-  // src/las-loader.ts
-  var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
-  var LASWorkerLoader = {
-    ...LASFormat,
-    dataType: null,
-    batchType: null,
-    name: "LAS",
-    id: "las",
-    module: "las",
-    version: VERSION,
-    worker: true,
-    extensions: ["las", "laz"],
-    // LAZ is the "compressed" flavor of LAS,
-    mimeTypes: ["application/octet-stream"],
-    // TODO - text version?
-    text: true,
-    binary: true,
-    tests: ["LAS"],
-    options: {
-      las: {
-        shape: "mesh",
-        fp64: false,
-        skip: 1,
-        colorDepth: 8
-      }
-    }
-  };
-  var LASLoader2 = {
+  // src/lazperf-loader.ts
+  var LAZPerfLoader = {
     ...LASWorkerLoader,
     parse: async (arrayBuffer, options) => parseLAS(arrayBuffer, options),
     parseSync: (arrayBuffer, options) => parseLAS(arrayBuffer, options)
@@ -31306,15 +31299,967 @@ return true;`);
 
   // src/las-arrow-loader.ts
   var LASArrowLoader = {
-    ...LASWorkerLoader,
+    ...LAZPerfLoader,
     dataType: null,
     batchType: null,
     worker: false,
     parse: async (arrayBuffer) => {
-      const mesh = parseLAS(arrayBuffer);
+      const mesh = await LAZPerfLoader.parse(arrayBuffer);
       const arrowTable = convertMeshToTable(mesh, "arrow-table");
       return arrowTable;
     }
+    // @ts-expect-error parseSync
+  };
+
+  // src/libs/laz-rs-wasm/laz_rs_wasm.js
+  var import_meta = {};
+  var wasm;
+  var cachedUint8ArrayMemory0 = null;
+  function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+      cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+  }
+  function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+  }
+  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();
+  }
+  function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+  }
+  function _assertClass(instance8, klass) {
+    if (!(instance8 instanceof klass)) {
+      throw new Error(`expected instance of ${klass.name}`);
+    }
+    return instance8.ptr;
+  }
+  function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_export_0.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+  }
+  var WASM_VECTOR_LEN = 0;
+  function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+  }
+  var cachedTextEncoder = typeof TextEncoder !== "undefined" ? new TextEncoder("utf-8") : { encode: () => {
+    throw Error("TextEncoder not available");
+  } };
+  var encodeString = typeof cachedTextEncoder.encodeInto === "function" ? function(arg, view) {
+    return cachedTextEncoder.encodeInto(arg, view);
+  } : function(arg, view) {
+    const buf = cachedTextEncoder.encode(arg);
+    view.set(buf);
+    return {
+      read: arg.length,
+      written: buf.length
+    };
+  };
+  function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === void 0) {
+      const buf = cachedTextEncoder.encode(arg);
+      const ptr2 = malloc(buf.length, 1) >>> 0;
+      getUint8ArrayMemory0().subarray(ptr2, ptr2 + buf.length).set(buf);
+      WASM_VECTOR_LEN = buf.length;
+      return ptr2;
+    }
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+    const mem = getUint8ArrayMemory0();
+    let offset = 0;
+    for (; offset < len; offset++) {
+      const code = arg.charCodeAt(offset);
+      if (code > 127)
+        break;
+      mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+      if (offset !== 0) {
+        arg = arg.slice(offset);
+      }
+      ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+      const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+      const ret = encodeString(arg, view);
+      offset += ret.written;
+      ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+  }
+  var cachedDataViewMemory0 = null;
+  function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || cachedDataViewMemory0.buffer.detached === void 0 && cachedDataViewMemory0.buffer !== wasm.memory.buffer) {
+      cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+  }
+  var WasmLasZipDecompressorFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+  }, unregister: () => {
+  } } : new FinalizationRegistry((ptr) => wasm.__wbg_wasmlaszipdecompressor_free(ptr >>> 0, 1));
+  var WasmLasZipDecompressor = class {
+    __destroy_into_raw() {
+      const ptr = this.__wbg_ptr;
+      this.__wbg_ptr = 0;
+      WasmLasZipDecompressorFinalization.unregister(this);
+      return ptr;
+    }
+    free() {
+      const ptr = this.__destroy_into_raw();
+      wasm.__wbg_wasmlaszipdecompressor_free(ptr, 0);
+    }
+    /**
+     * @returns {WasmQuickHeader}
+     */
+    get header() {
+      const ret = wasm.__wbg_get_wasmlaszipdecompressor_header(this.__wbg_ptr);
+      return WasmQuickHeader.__wrap(ret);
+    }
+    /**
+     * @param {WasmQuickHeader} arg0
+     */
+    set header(arg0) {
+      _assertClass(arg0, WasmQuickHeader);
+      var ptr0 = arg0.__destroy_into_raw();
+      wasm.__wbg_set_wasmlaszipdecompressor_header(this.__wbg_ptr, ptr0);
+    }
+    /**
+     * @param {Uint8Array} buf
+     */
+    constructor(buf) {
+      const ret = wasm.wasmlaszipdecompressor_new(buf);
+      if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+      }
+      this.__wbg_ptr = ret[0] >>> 0;
+      WasmLasZipDecompressorFinalization.register(this, this.__wbg_ptr, this);
+      return this;
+    }
+    /**
+     * @param {Uint8Array} out
+     */
+    decompress_many(out) {
+      var ptr0 = passArray8ToWasm0(out, wasm.__wbindgen_malloc);
+      var len0 = WASM_VECTOR_LEN;
+      const ret = wasm.wasmlaszipdecompressor_decompress_many(this.__wbg_ptr, ptr0, len0, out);
+      if (ret[1]) {
+        throw takeFromExternrefTable0(ret[0]);
+      }
+    }
+  };
+  var WasmQuickHeaderFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+  }, unregister: () => {
+  } } : new FinalizationRegistry((ptr) => wasm.__wbg_wasmquickheader_free(ptr >>> 0, 1));
+  var WasmQuickHeader = class {
+    static __wrap(ptr) {
+      ptr = ptr >>> 0;
+      const obj = Object.create(WasmQuickHeader.prototype);
+      obj.__wbg_ptr = ptr;
+      WasmQuickHeaderFinalization.register(obj, obj.__wbg_ptr, obj);
+      return obj;
+    }
+    __destroy_into_raw() {
+      const ptr = this.__wbg_ptr;
+      this.__wbg_ptr = 0;
+      WasmQuickHeaderFinalization.unregister(this);
+      return ptr;
+    }
+    free() {
+      const ptr = this.__destroy_into_raw();
+      wasm.__wbg_wasmquickheader_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    get major() {
+      const ret = wasm.__wbg_get_wasmquickheader_major(this.__wbg_ptr);
+      return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set major(arg0) {
+      wasm.__wbg_set_wasmquickheader_major(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get minor() {
+      const ret = wasm.__wbg_get_wasmquickheader_minor(this.__wbg_ptr);
+      return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set minor(arg0) {
+      wasm.__wbg_set_wasmquickheader_minor(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get offset_to_points() {
+      const ret = wasm.__wbg_get_wasmquickheader_offset_to_points(this.__wbg_ptr);
+      return ret >>> 0;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set offset_to_points(arg0) {
+      wasm.__wbg_set_wasmquickheader_offset_to_points(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get num_vlrs() {
+      const ret = wasm.__wbg_get_wasmquickheader_num_vlrs(this.__wbg_ptr);
+      return ret >>> 0;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set num_vlrs(arg0) {
+      wasm.__wbg_set_wasmquickheader_num_vlrs(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get point_format_id() {
+      const ret = wasm.__wbg_get_wasmquickheader_point_format_id(this.__wbg_ptr);
+      return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set point_format_id(arg0) {
+      wasm.__wbg_set_wasmquickheader_point_format_id(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get point_size() {
+      const ret = wasm.__wbg_get_wasmquickheader_point_size(this.__wbg_ptr);
+      return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set point_size(arg0) {
+      wasm.__wbg_set_wasmquickheader_point_size(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {bigint}
+     */
+    get num_points() {
+      const ret = wasm.__wbg_get_wasmquickheader_num_points(this.__wbg_ptr);
+      return BigInt.asUintN(64, ret);
+    }
+    /**
+     * @param {bigint} arg0
+     */
+    set num_points(arg0) {
+      wasm.__wbg_set_wasmquickheader_num_points(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get header_size() {
+      const ret = wasm.__wbg_get_wasmquickheader_header_size(this.__wbg_ptr);
+      return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set header_size(arg0) {
+      wasm.__wbg_set_wasmquickheader_header_size(this.__wbg_ptr, arg0);
+    }
+  };
+  async function __wbg_load(module2, imports) {
+    if (typeof Response === "function" && module2 instanceof Response) {
+      if (typeof WebAssembly.instantiateStreaming === "function") {
+        try {
+          return await WebAssembly.instantiateStreaming(module2, imports);
+        } catch (e) {
+          if (module2.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 module2.arrayBuffer();
+      return await WebAssembly.instantiate(bytes, imports);
+    } else {
+      const instance8 = await WebAssembly.instantiate(module2, imports);
+      if (instance8 instanceof WebAssembly.Instance) {
+        return { instance: instance8, module: module2 };
+      } else {
+        return instance8;
+      }
+    }
+  }
+  function __wbg_get_imports() {
+    const imports = {};
+    imports.wbg = {};
+    imports.wbg.__wbindgen_copy_to_typed_array = function(arg0, arg1, arg2) {
+      new Uint8Array(arg2.buffer, arg2.byteOffset, arg2.byteLength).set(getArrayU8FromWasm0(arg0, arg1));
+    };
+    imports.wbg.__wbg_buffer_ccaed51a635d8a2d = function(arg0) {
+      const ret = arg0.buffer;
+      return ret;
+    };
+    imports.wbg.__wbg_new_fec2611eb9180f95 = function(arg0) {
+      const ret = new Uint8Array(arg0);
+      return ret;
+    };
+    imports.wbg.__wbg_set_ec2fcf81bc573fd9 = function(arg0, arg1, arg2) {
+      arg0.set(arg1, arg2 >>> 0);
+    };
+    imports.wbg.__wbg_length_9254c4bd3b9f23c4 = function(arg0) {
+      const ret = arg0.length;
+      return ret;
+    };
+    imports.wbg.__wbg_new_abda76e883ba8a5f = function() {
+      const ret = new Error();
+      return ret;
+    };
+    imports.wbg.__wbg_stack_658279fe44541cf6 = function(arg0, arg1) {
+      const ret = arg1.stack;
+      const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      const len1 = WASM_VECTOR_LEN;
+      getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+      getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    };
+    imports.wbg.__wbg_error_f851667af71bcfc6 = function(arg0, arg1) {
+      let deferred0_0;
+      let deferred0_1;
+      try {
+        deferred0_0 = arg0;
+        deferred0_1 = arg1;
+        console.error(getStringFromWasm0(arg0, arg1));
+      } finally {
+        wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+      }
+    };
+    imports.wbg.__wbindgen_throw = function(arg0, arg1) {
+      throw new Error(getStringFromWasm0(arg0, arg1));
+    };
+    imports.wbg.__wbindgen_memory = function() {
+      const ret = wasm.memory;
+      return ret;
+    };
+    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);
+      ;
+    };
+    return imports;
+  }
+  function __wbg_init_memory(imports, memory) {
+  }
+  function __wbg_finalize_init(instance8, module2) {
+    wasm = instance8.exports;
+    __wbg_init.__wbindgen_wasm_module = module2;
+    cachedDataViewMemory0 = null;
+    cachedUint8ArrayMemory0 = null;
+    wasm.__wbindgen_start();
+    return wasm;
+  }
+  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("laz_rs_wasm_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: instance8, module: module2 } = await __wbg_load(await module_or_path, imports);
+    return __wbg_finalize_init(instance8, module2);
+  }
+  var laz_rs_wasm_default = __wbg_init;
+
+  // src/lib/laz-rs-wasm/laslaz-decoder.ts
+  var POINT_FORMAT_READERS2 = {
+    0: (dv) => {
+      return {
+        position: [dv.getInt32(0, true), dv.getInt32(4, true), dv.getInt32(8, true)],
+        intensity: dv.getUint16(12, true),
+        classification: dv.getUint8(15)
+      };
+    },
+    1: (dv) => {
+      return {
+        position: [dv.getInt32(0, true), dv.getInt32(4, true), dv.getInt32(8, true)],
+        intensity: dv.getUint16(12, true),
+        classification: dv.getUint8(15)
+      };
+    },
+    2: (dv) => {
+      return {
+        position: [dv.getInt32(0, true), dv.getInt32(4, true), dv.getInt32(8, true)],
+        intensity: dv.getUint16(12, true),
+        classification: dv.getUint8(15),
+        color: [dv.getUint16(20, true), dv.getUint16(22, true), dv.getUint16(24, true)]
+      };
+    },
+    3: (dv) => {
+      return {
+        position: [dv.getInt32(0, true), dv.getInt32(4, true), dv.getInt32(8, true)],
+        intensity: dv.getUint16(12, true),
+        classification: dv.getUint8(15),
+        color: [dv.getUint16(28, true), dv.getUint16(30, true), dv.getUint16(32, true)]
+      };
+    },
+    4: (dv) => {
+      return {
+        position: [dv.getInt32(0, true), dv.getInt32(4, true), dv.getInt32(8, true)],
+        intensity: dv.getUint16(12, true),
+        classification: dv.getUint8(15)
+      };
+    },
+    5: (dv) => {
+      return {
+        position: [dv.getInt32(0, true), dv.getInt32(4, true), dv.getInt32(8, true)],
+        intensity: dv.getUint16(12, true),
+        classification: dv.getUint8(15),
+        color: [dv.getUint16(28, true), dv.getUint16(30, true), dv.getUint16(32, true)]
+      };
+    },
+    6: (dv) => {
+      return {
+        position: [dv.getInt32(0, true), dv.getInt32(4, true), dv.getInt32(8, true)],
+        intensity: dv.getUint16(12, true),
+        classification: dv.getUint8(16)
+      };
+    },
+    7: (dv) => {
+      return {
+        position: [dv.getInt32(0, true), dv.getInt32(4, true), dv.getInt32(8, true)],
+        intensity: dv.getUint16(12, true),
+        classification: dv.getUint8(16),
+        color: [dv.getUint16(30, true), dv.getUint16(32, true), dv.getUint16(34, true)]
+      };
+    },
+    8: (dv) => {
+      return {
+        position: [dv.getInt32(0, true), dv.getInt32(4, true), dv.getInt32(8, true)],
+        intensity: dv.getUint16(12, true),
+        classification: dv.getUint8(16),
+        color: [dv.getUint16(30, true), dv.getUint16(32, true), dv.getUint16(34, true)]
+      };
+    },
+    9: (dv) => {
+      return {
+        position: [dv.getInt32(0, true), dv.getInt32(4, true), dv.getInt32(8, true)],
+        intensity: dv.getUint16(12, true),
+        classification: dv.getUint8(16)
+      };
+    },
+    10: (dv) => {
+      return {
+        position: [dv.getInt32(0, true), dv.getInt32(4, true), dv.getInt32(8, true)],
+        intensity: dv.getUint16(12, true),
+        classification: dv.getUint8(16),
+        color: [dv.getUint16(30, true), dv.getUint16(32, true), dv.getUint16(34, true)]
+      };
+    }
+  };
+  function readAs2(buf, Type3 = {}, offset, count) {
+    count = count === void 0 || count === 0 ? 1 : count;
+    const sub = buf.slice(offset, offset + Type3.BYTES_PER_ELEMENT * count);
+    const r = new Type3(sub);
+    if (count === 1) {
+      return r[0];
+    }
+    const ret = [];
+    for (let i = 0; i < count; i++) {
+      ret.push(r[i]);
+    }
+    return ret;
+  }
+  function parseLASHeader2(arraybuffer) {
+    const ver = new Uint8Array(arraybuffer, 24, 2);
+    const version = ver[0] * 10 + ver[1];
+    const versionAsString = `${ver[0]}.${ver[1]}`;
+    const rawPointsFormatId = readAs2(arraybuffer, Uint8Array, 32 * 3 + 8);
+    const bit7 = (rawPointsFormatId & 128) >> 7;
+    const bit6 = (rawPointsFormatId & 64) >> 6;
+    const isCompressed = bit7 === 1 || bit6 === 1;
+    const pointsFormatId = rawPointsFormatId & 63;
+    const o = {
+      pointsOffset: readAs2(arraybuffer, Uint32Array, 32 * 3),
+      pointsFormatId,
+      pointsStructSize: readAs2(arraybuffer, Uint16Array, 32 * 3 + 8 + 1),
+      pointsCount: readAs2(arraybuffer, Uint32Array, 32 * 3 + 11),
+      versionAsString,
+      isCompressed
+    };
+    let start = 32 * 3 + 35;
+    o.scale = readAs2(arraybuffer, Float64Array, start, 3);
+    start += 24;
+    o.offset = readAs2(arraybuffer, Float64Array, start, 3);
+    start += 24;
+    const bounds = readAs2(arraybuffer, Float64Array, start, 6);
+    start += 48;
+    o.maxs = [bounds[0], bounds[2], bounds[4]];
+    o.mins = [bounds[1], bounds[3], bounds[5]];
+    start += 20;
+    if (version === 14) {
+      o.pointsCount = Number(readAs2(arraybuffer, BigUint64Array, start));
+    }
+    const colorPointFormats = /* @__PURE__ */ new Set([2, 3, 5, 7, 8, 10]);
+    o.hasColor = colorPointFormats.has(pointsFormatId);
+    return o;
+  }
+  var LASLoader2 = class {
+    arraybuffer;
+    readOffset = 0;
+    header = null;
+    constructor(arraybuffer) {
+      this.arraybuffer = arraybuffer;
+    }
+    /**
+     * @returns boolean
+     */
+    open() {
+      return true;
+    }
+    /**
+     * Parsing of incoming binary
+     * @returns LASHeader
+     */
+    getHeader() {
+      this.header = parseLASHeader2(this.arraybuffer);
+      return this.header;
+    }
+    /**
+     * Reading data
+     * @param count
+     * @param skip
+     * @returns LasData
+     */
+    readData(count, skip) {
+      const { header, arraybuffer } = this;
+      if (!header) {
+        throw new Error("Cannot start reading data till a header request is issued");
+      }
+      let { readOffset } = this;
+      let start;
+      if (skip <= 1) {
+        count = Math.min(count, header.pointsCount - readOffset);
+        start = header.pointsOffset + readOffset * header.pointsStructSize;
+        const end = start + count * header.pointsStructSize;
+        readOffset += count;
+        this.readOffset = readOffset;
+        return {
+          buffer: arraybuffer.slice(start, end),
+          count,
+          hasMoreData: readOffset < header.pointsCount
+        };
+      }
+      const pointsToRead = Math.min(count * skip, header.pointsCount - readOffset);
+      const bufferSize = Math.ceil(pointsToRead / skip);
+      let pointsRead = 0;
+      const buf = new Uint8Array(bufferSize * header.pointsStructSize);
+      for (let i = 0; i < pointsToRead; i++) {
+        if (i % skip === 0) {
+          start = header.pointsOffset + readOffset * header.pointsStructSize;
+          const src = new Uint8Array(arraybuffer, start, header.pointsStructSize);
+          buf.set(src, pointsRead * header.pointsStructSize);
+          pointsRead++;
+        }
+        readOffset++;
+      }
+      this.readOffset = readOffset;
+      return {
+        buffer: buf.buffer,
+        count: pointsRead,
+        hasMoreData: readOffset < header.pointsCount
+      };
+    }
+    /**
+     * Method which brings data to null to close the file
+     * @returns
+     */
+    close() {
+      this.arraybuffer = null;
+      return true;
+    }
+  };
+  var LAZLoader2 = class {
+    arraybuffer;
+    readOffset = 0;
+    instance = null;
+    header = null;
+    constructor(arraybuffer) {
+      this.arraybuffer = arraybuffer;
+    }
+    /**
+     * Opens the file
+     * @returns boolean
+     */
+    open() {
+      try {
+        const abInt = new Uint8Array(this.arraybuffer);
+        this.instance = new WasmLasZipDecompressor(abInt);
+        return true;
+      } catch (error) {
+        throw new Error(`Failed to open file: ${error.message}`);
+      }
+    }
+    getHeader() {
+      try {
+        this.header = parseLASHeader2(this.arraybuffer);
+        return this.header;
+      } catch (error) {
+        throw new Error(`Failed to get header: ${error.message}`);
+      }
+    }
+    /**
+     * @param count
+     * @param offset
+     * @param skip
+     * @returns LASData
+     */
+    readData(count, skip) {
+      if (!this.instance) {
+        throw new Error("You need to open the file before trying to read stuff");
+      }
+      const { header, instance: instance8 } = this;
+      if (!header) {
+        throw new Error(
+          "You need to query header before reading, I maintain state that way, sorry :("
+        );
+      }
+      try {
+        const pointsToRead = Math.min(count * skip, header.pointsCount - this.readOffset);
+        const bufferSize = Math.ceil(pointsToRead / skip);
+        let pointsRead = 0;
+        const buf = new Uint8Array(bufferSize * header.pointsStructSize);
+        const bufRead = new Uint8Array(header.pointsStructSize);
+        for (let i = 0; i < pointsToRead; i++) {
+          instance8.decompress_many(bufRead);
+          if (i % skip === 0) {
+            buf.set(bufRead, pointsRead * header.pointsStructSize);
+            pointsRead++;
+          }
+          this.readOffset++;
+        }
+        return {
+          buffer: buf.buffer,
+          count: pointsRead,
+          hasMoreData: this.readOffset < header.pointsCount
+        };
+      } catch (error) {
+        throw new Error(`Failed to read data: ${error.message}`);
+      }
+    }
+    /**
+     * Deletes the instance
+     * @returns boolean
+     */
+    close() {
+      try {
+        if (this.instance !== null) {
+          this.instance.free();
+          this.instance = null;
+        }
+        this.arraybuffer = null;
+        return true;
+      } catch (error) {
+        throw new Error(`Failed to close file: ${error.message}`);
+      }
+    }
+  };
+  var LASDecoder2 = class {
+    arrayb;
+    decoder;
+    pointsCount;
+    pointSize;
+    constructor(buffer, len, header) {
+      this.arrayb = buffer;
+      this.decoder = POINT_FORMAT_READERS2[header.pointsFormatId];
+      this.pointsCount = len;
+      this.pointSize = header.pointsStructSize;
+    }
+    /**
+     * Decodes data depends on this point size
+     * @param index
+     * @returns New object
+     */
+    getPoint(index) {
+      if (index < 0 || index >= this.pointsCount) {
+        throw new Error("Point index out of range");
+      }
+      const dv = new DataView(this.arrayb, index * this.pointSize, this.pointSize);
+      return this.decoder(dv);
+    }
+  };
+  var LASFile2 = class {
+    arraybuffer;
+    formatId = 0;
+    loader;
+    isCompressed = true;
+    isOpen = false;
+    version = 0;
+    versionAsString = "";
+    constructor(arraybuffer) {
+      this.arraybuffer = arraybuffer;
+      this.validate();
+      this.loader = this.isCompressed ? new LAZLoader2(this.arraybuffer) : new LASLoader2(this.arraybuffer);
+    }
+    validate() {
+      const signature = readAs2(this.arraybuffer, Uint8Array, 0, 4);
+      const check = String.fromCharCode(...signature);
+      if (check !== "LASF") {
+        throw new Error("Invalid LAS file");
+      }
+      if (this.determineVersion() > 14) {
+        throw new Error("Only file versions <= 1.4 are supported");
+      }
+      this.determineFormat();
+      if (POINT_FORMAT_READERS2[this.formatId] === void 0) {
+        throw new Error("The point format ID is not supported");
+      }
+    }
+    /**
+     * Determines format in parameters of LASHeader
+     */
+    determineFormat() {
+      const formatId = readAs2(this.arraybuffer, Uint8Array, 32 * 3 + 8);
+      const bit7 = (formatId & 128) >> 7;
+      const bit6 = (formatId & 64) >> 6;
+      if (bit7 === 1 && bit6 === 1) {
+        throw new Error("Old style compression not supported");
+      }
+      this.formatId = formatId & 63;
+      this.isCompressed = bit7 === 1 || bit6 === 1;
+    }
+    /**
+     * Determines version
+     * @returns version
+     */
+    determineVersion() {
+      const ver = new Uint8Array(this.arraybuffer, 24, 2);
+      this.version = ver[0] * 10 + ver[1];
+      this.versionAsString = `${ver[0]}.${ver[1]}`;
+      return this.version;
+    }
+    /**
+     * Reads if the file is open
+     * @returns boolean
+     */
+    open() {
+      if (this.loader.open()) {
+        this.isOpen = true;
+      }
+    }
+    /**
+     * Gets the header
+     * @returns Header
+     */
+    getHeader() {
+      return this.loader.getHeader();
+    }
+    /**
+     * @param count
+     * @param start
+     * @param skip
+     * @returns LASData
+     */
+    readData(count, skip) {
+      return this.loader.readData(count, skip);
+    }
+    /**
+     * Closes the file
+     */
+    close() {
+      if (this.loader.close()) {
+        this.isOpen = false;
+      }
+    }
+    /**
+     */
+    getUnpacker() {
+      return LASDecoder2;
+    }
+  };
+
+  // src/lib/laz-rs-wasm/parse-las.ts
+  function parseLAS2(arrayBuffer, options) {
+    return parseLASMesh2(arrayBuffer, options);
+  }
+  function parseLASMesh2(arrayBuffer, options = {}) {
+    let pointIndex = 0;
+    let positions;
+    let colors;
+    let intensities;
+    let classifications;
+    let originalHeader;
+    const lasMesh = {
+      loader: "las",
+      loaderData: {},
+      // shape: 'mesh',
+      schema: { fields: [], metadata: {} },
+      header: {
+        vertexCount: 0,
+        boundingBox: [
+          [0, 0, 0],
+          [0, 0, 0]
+        ]
+      },
+      attributes: {},
+      topology: "point-list",
+      mode: 0
+      // GL.POINTS
+    };
+    parseLASChunked2(arrayBuffer, options.las?.skip, (decoder2 = {}, lasHeader) => {
+      if (!originalHeader) {
+        originalHeader = lasHeader;
+        const total = lasHeader.totalToRead;
+        const PositionsType = options.las?.fp64 ? Float64Array : Float32Array;
+        positions = new PositionsType(total * 3);
+        colors = lasHeader.hasColor ? new Uint8Array(total * 4) : null;
+        intensities = new Uint16Array(total);
+        classifications = new Uint8Array(total);
+        lasMesh.loaderData = lasHeader;
+        lasMesh.attributes = {
+          POSITION: { value: positions, size: 3 },
+          // non-gltf attributes, use non-capitalized names for now
+          intensity: { value: intensities, size: 1 },
+          classification: { value: classifications, size: 1 }
+        };
+        if (colors) {
+          lasMesh.attributes.COLOR_0 = { value: colors, size: 4 };
+        }
+      }
+      const batchSize = decoder2.pointsCount;
+      const {
+        scale: [scaleX, scaleY, scaleZ],
+        offset: [offsetX, offsetY, offsetZ]
+      } = lasHeader;
+      const twoByteColor = detectTwoByteColors2(decoder2, batchSize, options.las?.colorDepth);
+      for (let i = 0; i < batchSize; i++) {
+        const { position, color, intensity, classification } = decoder2.getPoint(i);
+        positions[pointIndex * 3] = position[0] * scaleX + offsetX;
+        positions[pointIndex * 3 + 1] = position[1] * scaleY + offsetY;
+        positions[pointIndex * 3 + 2] = position[2] * scaleZ + offsetZ;
+        if (color && colors) {
+          if (twoByteColor) {
+            colors[pointIndex * 4] = color[0] / 256;
+            colors[pointIndex * 4 + 1] = color[1] / 256;
+            colors[pointIndex * 4 + 2] = color[2] / 256;
+          } else {
+            colors[pointIndex * 4] = color[0];
+            colors[pointIndex * 4 + 1] = color[1];
+            colors[pointIndex * 4 + 2] = color[2];
+          }
+          colors[pointIndex * 4 + 3] = 255;
+        }
+        intensities[pointIndex] = intensity;
+        classifications[pointIndex] = classification;
+        pointIndex++;
+      }
+      const meshBatch = {
+        ...lasMesh,
+        header: {
+          vertexCount: lasHeader.totalRead
+        },
+        progress: lasHeader.totalRead / lasHeader.totalToRead
+      };
+      options?.onProgress?.(meshBatch);
+    });
+    lasMesh.header = {
+      vertexCount: originalHeader.totalToRead,
+      boundingBox: getMeshBoundingBox(lasMesh?.attributes || {})
+    };
+    if (lasMesh) {
+      lasMesh.schema = getLASSchema(lasMesh.loaderData, lasMesh.attributes);
+    }
+    return lasMesh;
+  }
+  function parseLASChunked2(rawData, skip, onParseData = {}) {
+    const dataHandler = new LASFile2(rawData);
+    try {
+      dataHandler.open();
+      const header = dataHandler.getHeader();
+      const Unpacker = dataHandler.getUnpacker();
+      const totalToRead = Math.ceil(header.pointsCount / Math.max(1, skip));
+      header.totalToRead = totalToRead;
+      let totalRead = 0;
+      while (true) {
+        const chunk = dataHandler.readData(1e3 * 100, skip);
+        totalRead += chunk.count;
+        header.totalRead = totalRead;
+        const unpacker = new Unpacker(chunk.buffer, chunk.count, header);
+        onParseData(unpacker, header);
+        if (!chunk.hasMoreData || totalRead >= totalToRead) {
+          break;
+        }
+      }
+    } catch (e) {
+      throw e;
+    } finally {
+      dataHandler.close();
+    }
+  }
+  function detectTwoByteColors2(decoder2 = {}, batchSize, colorDepth) {
+    let twoByteColor = false;
+    switch (colorDepth) {
+      case 8:
+        twoByteColor = false;
+        break;
+      case 16:
+        twoByteColor = true;
+        break;
+      case "auto":
+        if (decoder2.getPoint(0).color) {
+          for (let i = 0; i < batchSize; i++) {
+            const { color } = decoder2.getPoint(i);
+            if (color[0] > 255 || color[1] > 255 || color[2] > 255) {
+              twoByteColor = true;
+            }
+          }
+        }
+        break;
+      default:
+        console.warn("las: illegal value for options.las.colorDepth");
+        break;
+    }
+    return twoByteColor;
+  }
+
+  // src/laz-rs-loader.ts
+  var LAZRsLoader = {
+    ...LASWorkerLoader,
+    parse: async (arrayBuffer, options) => {
+      await laz_rs_wasm_default();
+      return parseLAS2(arrayBuffer, { ...options });
+    }
   };
   return __toCommonJS(bundle_exports);
 })();