@loaders.gl/las 4.4.0-alpha.2 → 4.4.0-alpha.9

package/dist/index.cjs

@@ -22,8 +22,10 @@ var dist_exports = {};
 __export(dist_exports, {
   LASArrowLoader: () => LASArrowLoader,
   LASFormat: () => LASFormat,
-  LASLoader: () => LASLoader2,
-  LASWorkerLoader: () => LASWorkerLoader
+  LASLoader: () => LAZPerfLoader,
+  LASWorkerLoader: () => LASWorkerLoader,
+  LAZPerfLoader: () => LAZPerfLoader,
+  LAZRsLoader: () => LAZRsLoader
 });
 module.exports = __toCommonJS(dist_exports);
 
@@ -36,15 +38,65 @@ var LASFormat = {
   // LAZ is the "compressed" flavor of LAS,
   mimeTypes: ["application/octet-stream"],
   // TODO - text version?
-  text: true,
+  text: false,
   binary: true,
-  tests: ["LAS"]
+  tests: ["LASF"]
 };
 
-// dist/lib/parse-las.js
+// dist/las-loader.js
+var VERSION = true ? "4.4.0-alpha.9" : "latest";
+var LASWorkerLoader = {
+  ...LASFormat,
+  dataType: null,
+  batchType: null,
+  version: VERSION,
+  worker: true,
+  options: {
+    las: {
+      shape: "mesh",
+      fp64: false,
+      skip: 1,
+      colorDepth: 8
+    }
+  }
+};
+
+// dist/lib/laz-perf/parse-las.js
 var import_schema_utils2 = require("@loaders.gl/schema-utils");
 
-// dist/lib/libs/laz-perf.js
+// dist/lib/get-las-schema.js
+var import_schema_utils = require("@loaders.gl/schema-utils");
+function getLASSchema(lasHeader, attributes) {
+  const metadataMap = makeMetadataFromLasHeader(lasHeader);
+  const schema = (0, import_schema_utils.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;
+}
+
+// dist/libs/laz-perf/laz-perf.js
 function getModule() {
   var Module2 = typeof Module2 !== "undefined" ? Module2 : {};
   var moduleOverrides = {};
@@ -2064,10 +2116,10 @@ function getModule() {
   }
   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;
@@ -2075,7 +2127,7 @@ function getModule() {
       shift = 1;
     } else if (charSize === 4) {
       decodeString = UTF32ToString;
-      encodeString = stringToUTF32;
+      encodeString2 = stringToUTF32;
       lengthBytesUTF = lengthBytesUTF32;
       getHeap = function() {
         return HEAPU32;
@@ -2113,7 +2165,7 @@ function getModule() {
         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);
         }
@@ -18459,7 +18511,7 @@ function getModule() {
   return Module2;
 }
 
-// dist/lib/laslaz-decoder.js
+// dist/lib/laz-perf/laslaz-decoder.js
 var Module = null;
 var POINT_FORMAT_READERS = {
   0: (dv) => {
@@ -18539,7 +18591,8 @@ var LASLoader = class {
     totalToRead: 0,
     totalRead: 0,
     versionAsString: "",
-    isCompressed: true
+    isCompressed: true,
+    hasColor: false
   };
   constructor(arraybuffer) {
     this.arraybuffer = arraybuffer;
@@ -18826,39 +18879,7 @@ var LASFile = class {
   }
 };
 
-// dist/lib/get-las-schema.js
-var import_schema_utils = require("@loaders.gl/schema-utils");
-function getLASSchema(lasHeader, attributes) {
-  const metadataMap = makeMetadataFromLasHeader(lasHeader);
-  const schema = (0, import_schema_utils.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;
-}
-
-// dist/lib/parse-las.js
+// dist/lib/laz-perf/parse-las.js
 function parseLAS(arrayBuffer, options) {
   return parseLASMesh(arrayBuffer, options);
 }
@@ -18894,7 +18915,7 @@ function parseLASMesh(arrayBuffer, options = {}) {
       const total = lasHeader.totalToRead;
       const PositionsType = ((_a2 = options.las) == null ? void 0 : _a2.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;
@@ -18960,11 +18981,9 @@ function parseLASChunked(rawData, skip, onParseData = {}) {
     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) {
@@ -19003,34 +19022,8 @@ function detectTwoByteColors(decoder = {}, batchSize, colorDepth) {
   return twoByteColor;
 }
 
-// dist/las-loader.js
-var VERSION = true ? "4.4.0-alpha.1" : "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 = {
+// dist/lazperf-loader.js
+var LAZPerfLoader = {
   ...LASWorkerLoader,
   parse: async (arrayBuffer, options) => parseLAS(arrayBuffer, options),
   parseSync: (arrayBuffer, options) => parseLAS(arrayBuffer, options)
@@ -19039,14 +19032,966 @@ var LASLoader2 = {
 // dist/las-arrow-loader.js
 var import_schema_utils3 = require("@loaders.gl/schema-utils");
 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 = (0, import_schema_utils3.convertMeshToTable)(mesh, "arrow-table");
     return arrowTable;
   }
+  // @ts-expect-error parseSync
+};
+
+// dist/lib/laz-rs-wasm/parse-las.js
+var import_schema_utils4 = require("@loaders.gl/schema-utils");
+
+// dist/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(instance, klass) {
+  if (!(instance instanceof klass)) {
+    throw new Error(`expected instance of ${klass.name}`);
+  }
+  return instance.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 instance = await WebAssembly.instantiate(module2, imports);
+    if (instance instanceof WebAssembly.Instance) {
+      return { instance, module: module2 };
+    } else {
+      return instance;
+    }
+  }
+}
+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(instance, module2) {
+  wasm = instance.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, module: module2 } = await __wbg_load(await module_or_path, imports);
+  return __wbg_finalize_init(instance, module2);
+}
+var laz_rs_wasm_default = __wbg_init;
+
+// dist/lib/laz-rs-wasm/laslaz-decoder.js
+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, Type = {}, offset, count) {
+  count = count === void 0 || count === 0 ? 1 : count;
+  const sub = buf.slice(offset, offset + Type.BYTES_PER_ELEMENT * count);
+  const r = new Type(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 } = 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++) {
+        instance.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;
+  }
+};
+
+// dist/lib/laz-rs-wasm/parse-las.js
+function parseLAS2(arrayBuffer, options) {
+  return parseLASMesh2(arrayBuffer, options);
+}
+function parseLASMesh2(arrayBuffer, options = {}) {
+  var _a;
+  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, (_a = options.las) == null ? void 0 : _a.skip, (decoder = {}, lasHeader) => {
+    var _a2, _b, _c;
+    if (!originalHeader) {
+      originalHeader = lasHeader;
+      const total = lasHeader.totalToRead;
+      const PositionsType = ((_a2 = options.las) == null ? void 0 : _a2.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 = decoder.pointsCount;
+    const { scale: [scaleX, scaleY, scaleZ], offset: [offsetX, offsetY, offsetZ] } = lasHeader;
+    const twoByteColor = detectTwoByteColors2(decoder, batchSize, (_b = options.las) == null ? void 0 : _b.colorDepth);
+    for (let i = 0; i < batchSize; i++) {
+      const { position, color, intensity, classification } = decoder.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
+    };
+    (_c = options == null ? void 0 : options.onProgress) == null ? void 0 : _c.call(options, meshBatch);
+  });
+  lasMesh.header = {
+    vertexCount: originalHeader.totalToRead,
+    boundingBox: (0, import_schema_utils4.getMeshBoundingBox)((lasMesh == null ? void 0 : 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(decoder = {}, batchSize, colorDepth) {
+  let twoByteColor = false;
+  switch (colorDepth) {
+    case 8:
+      twoByteColor = false;
+      break;
+    case 16:
+      twoByteColor = true;
+      break;
+    case "auto":
+      if (decoder.getPoint(0).color) {
+        for (let i = 0; i < batchSize; i++) {
+          const { color } = decoder.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;
+}
+
+// dist/laz-rs-loader.js
+var LAZRsLoader = {
+  ...LASWorkerLoader,
+  parse: async (arrayBuffer, options) => {
+    await laz_rs_wasm_default();
+    return parseLAS2(arrayBuffer, { ...options });
+  }
 };
 //# sourceMappingURL=index.cjs.map