@loaders.gl/pointclouds 0.0.0-stage → 5.0.0-beta.1

package/dist/las/laz-rs-loader.js

@@ -0,0 +1,38 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { convertMeshToTable, convertTableToMesh } from '@loaders.gl/core/schema-utils';
+import { formatLASMeshColors, getLASShape, LAS_LOADER_METADATA } from "./las-loader-shared.js";
+import { parseLAS, parseLASInBatches } from "./lib/laz-rs-wasm/parse-las.js";
+import initLazRsWasm from "./libs/laz-rs-wasm/laz_rs_wasm.js";
+/**
+ * Loader for the LAS (LASer) point cloud format
+ */
+export const LAZRsLoaderWithParser = {
+    ...LAS_LOADER_METADATA,
+    name: 'LAS (laz-rs)',
+    parse: async (arrayBuffer, options) => {
+        await initLazRsWasm();
+        return convertLASMesh(parseLAS(arrayBuffer, { ...options }), options);
+    },
+    parseInBatches: async function* (arrayBufferIterator, options) {
+        await initLazRsWasm();
+        for await (const mesh of parseLASInBatches(arrayBufferIterator, options)) {
+            yield convertLASMesh(mesh, options);
+        }
+    }
+};
+function convertLASMesh(mesh, options) {
+    const formattedMesh = formatLASMeshColors(mesh, options?.las?.colorFormat || 'uint8norm');
+    const table = convertMeshToTable(formattedMesh, 'arrow-table');
+    if (getLASShape(options) === 'arrow-table') {
+        return table;
+    }
+    return {
+        ...convertTableToMesh(table),
+        loader: mesh.loader,
+        loaderData: mesh.loaderData,
+        progress: mesh.progress
+    };
+}
+//# sourceMappingURL=laz-rs-loader.js.map

package/dist/las/laz-rs-loader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"laz-rs-loader.js","sourceRoot":"","sources":["../../src/las/laz-rs-loader.ts"],"names":[],"mappings":"AAAA,aAAa;AACb,+BAA+B;AAC/B,oCAAoC;AAKpC,OAAO,EAAC,kBAAkB,EAAE,kBAAkB,EAAC,MAAM,+BAA+B,CAAC;AACrF,OAAO,EACL,mBAAmB,EACnB,WAAW,EACX,mBAAmB,EAEpB,+BAA4B;AAE7B,OAAO,EAAC,QAAQ,EAAE,iBAAiB,EAAC,uCAAoC;AACxE,OAAO,aAAa,0CAAuC;AAE3D;;GAEG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG;IACnC,GAAG,mBAAmB;IACtB,IAAI,EAAE,cAAc;IACpB,KAAK,EAAE,KAAK,EAAE,WAAwB,EAAE,OAA0B,EAAE,EAAE;QACpE,MAAM,aAAa,EAAE,CAAC;QACtB,OAAO,cAAc,CAAC,QAAQ,CAAC,WAAW,EAAE,EAAC,GAAG,OAAO,EAAC,CAAC,EAAE,OAAO,CAAC,CAAC;IACtE,CAAC;IACD,cAAc,EAAE,KAAK,SAAS,CAAC,EAAE,mBAAmB,EAAE,OAA0B;QAC9E,MAAM,aAAa,EAAE,CAAC;QACtB,IAAI,KAAK,EAAE,MAAM,IAAI,IAAI,iBAAiB,CAAC,mBAAmB,EAAE,OAAO,CAAC,EAAE,CAAC;YACzE,MAAM,cAAc,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;QACtC,CAAC;IACH,CAAC;CAKF,CAAC;AAEF,SAAS,cAAc,CAAC,IAAa,EAAE,OAA0B;IAC/D,MAAM,aAAa,GAAG,mBAAmB,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,WAAW,IAAI,WAAW,CAAC,CAAC;IAC1F,MAAM,KAAK,GAAG,kBAAkB,CAAC,aAAa,EAAE,aAAa,CAAmB,CAAC;IACjF,IAAI,WAAW,CAAC,OAAO,CAAC,KAAK,aAAa,EAAE,CAAC;QAC3C,OAAO,KAAK,CAAC;IACf,CAAC;IACD,OAAO;QACL,GAAI,kBAAkB,CAAC,KAAK,CAAa;QACzC,MAAM,EAAE,IAAI,CAAC,MAAM;QACnB,UAAU,EAAE,IAAI,CAAC,UAAU;QAC3B,QAAQ,EAAG,IAAsC,CAAC,QAAQ;KAC1B,CAAC;AACrC,CAAC"}

package/dist/las/lazperf-loader-types.cjs

@@ -0,0 +1,49 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/las/lazperf-loader-types.ts
+var lazperf_loader_types_exports = {};
+__export(lazperf_loader_types_exports, {
+  LAZPerfLoader: () => LAZPerfLoader
+});
+module.exports = __toCommonJS(lazperf_loader_types_exports);
+var import_las_loader_shared = require("./las-loader-shared.cjs");
+var LAZPerfLoader = {
+  ...import_las_loader_shared.LAS_LOADER_METADATA,
+  name: "LAS (laz-perf)",
+  preload: async () => {
+    const { LAZPerfLoaderWithParser } = await import("@loaders.gl/pointclouds/las/lazperf-loader");
+    return LAZPerfLoaderWithParser;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LAZPerfLoader
+});
+//# sourceMappingURL=lazperf-loader-types.cjs.map

package/dist/las/lazperf-loader-types.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/las/lazperf-loader-types.ts"],
+  "sourcesContent": ["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\n// LASER (LAS) FILE FORMAT\nimport type {Loader} from '@loaders.gl/core/loader-utils';\nimport type {MeshArrowTable} from '@loaders.gl/core/schema';\nimport {LAS_LOADER_METADATA, type LASLoaderOptions} from './las-loader-shared';\nimport type {LASMesh} from './lib/las-types';\n\n/**\n * Metadata-only loader for the LAS (LASer) point cloud format.\n * @note Does not support LAS v1.4\n */\nexport const LAZPerfLoader = {\n  ...LAS_LOADER_METADATA,\n  name: 'LAS (laz-perf)',\n  preload: async () => {\n    const {LAZPerfLoaderWithParser} = await import('@loaders.gl/pointclouds/las/lazperf-loader');\n    return LAZPerfLoaderWithParser;\n  }\n} as const satisfies Loader<LASMesh | MeshArrowTable, LASMesh | MeshArrowTable, LASLoaderOptions>;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAOA,+BAAyD;AAOlD,IAAM,gBAAgB;AAAA,EAC3B,GAAG;AAAA,EACH,MAAM;AAAA,EACN,SAAS,YAAY;AACnB,UAAM,EAAC,wBAAuB,IAAI,MAAM,OAAO,4CAA4C;AAC3F,WAAO;AAAA,EACT;AACF;",
+  "names": []
+}

package/dist/las/lazperf-loader-types.d.ts

@@ -0,0 +1,67 @@
+import type { MeshArrowTable } from '@loaders.gl/core/schema';
+import { type LASLoaderOptions } from "./las-loader-shared.js";
+import type { LASMesh } from "./lib/las-types.js";
+/**
+ * Metadata-only loader for the LAS (LASer) point cloud format.
+ * @note Does not support LAS v1.4
+ */
+export declare const LAZPerfLoader: {
+    readonly name: "LAS (laz-perf)";
+    readonly preload: () => Promise<{
+        readonly name: "LAS (laz-perf)";
+        readonly parse: (arrayBuffer: ArrayBuffer, options?: LASLoaderOptions) => Promise<LASMesh | MeshArrowTable>;
+        readonly parseSync: (arrayBuffer: ArrayBuffer, options?: LASLoaderOptions) => LASMesh | MeshArrowTable;
+        readonly parseInBatches: (arrayBufferIterator: AsyncIterable<ArrayBufferLike | ArrayBufferView<ArrayBufferLike>> | Iterable<ArrayBufferLike | ArrayBufferView<ArrayBufferLike>>, options?: LASLoaderOptions) => AsyncGenerator<LASMesh | MeshArrowTable, void, any>;
+        readonly dataType: LASMesh | MeshArrowTable;
+        readonly batchType: LASMesh | MeshArrowTable;
+        readonly version: any;
+        readonly worker: false;
+        readonly options: {
+            readonly las: {
+                readonly shape: "arrow-table";
+                readonly fp64: false;
+                readonly colorDepth: 8;
+                readonly colorFormat: "uint8norm";
+                readonly columns: undefined;
+                readonly extraBytes: "raw";
+                readonly recoverMissingChunkTable: false;
+                readonly compatibilityMode: "auto";
+            };
+        };
+        readonly id: "las";
+        readonly module: "pointclouds";
+        readonly encoding: "binary";
+        readonly format: "las";
+        readonly extensions: ["las", "laz"];
+        readonly mimeTypes: ["application/octet-stream"];
+        readonly text: false;
+        readonly binary: true;
+        readonly tests: ["LASF"];
+    }>;
+    readonly dataType: LASMesh | MeshArrowTable;
+    readonly batchType: LASMesh | MeshArrowTable;
+    readonly version: any;
+    readonly worker: false;
+    readonly options: {
+        readonly las: {
+            readonly shape: "arrow-table";
+            readonly fp64: false;
+            readonly colorDepth: 8;
+            readonly colorFormat: "uint8norm";
+            readonly columns: undefined;
+            readonly extraBytes: "raw";
+            readonly recoverMissingChunkTable: false;
+            readonly compatibilityMode: "auto";
+        };
+    };
+    readonly id: "las";
+    readonly module: "pointclouds";
+    readonly encoding: "binary";
+    readonly format: "las";
+    readonly extensions: ["las", "laz"];
+    readonly mimeTypes: ["application/octet-stream"];
+    readonly text: false;
+    readonly binary: true;
+    readonly tests: ["LASF"];
+};
+//# sourceMappingURL=lazperf-loader-types.d.ts.map

package/dist/las/lazperf-loader-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazperf-loader-types.d.ts","sourceRoot":"","sources":["../../src/las/lazperf-loader-types.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,yBAAyB,CAAC;AAC5D,OAAO,EAAsB,KAAK,gBAAgB,EAAC,+BAA4B;AAC/E,OAAO,KAAK,EAAC,OAAO,EAAC,2BAAwB;AAE7C;;;GAGG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAOuE,CAAC"}

package/dist/las/lazperf-loader-types.js

@@ -0,0 +1,17 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { LAS_LOADER_METADATA } from "./las-loader-shared.js";
+/**
+ * Metadata-only loader for the LAS (LASer) point cloud format.
+ * @note Does not support LAS v1.4
+ */
+export const LAZPerfLoader = {
+    ...LAS_LOADER_METADATA,
+    name: 'LAS (laz-perf)',
+    preload: async () => {
+        const { LAZPerfLoaderWithParser } = await import('@loaders.gl/pointclouds/las/lazperf-loader');
+        return LAZPerfLoaderWithParser;
+    }
+};
+//# sourceMappingURL=lazperf-loader-types.js.map

package/dist/las/lazperf-loader-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazperf-loader-types.js","sourceRoot":"","sources":["../../src/las/lazperf-loader-types.ts"],"names":[],"mappings":"AAAA,aAAa;AACb,+BAA+B;AAC/B,oCAAoC;AAKpC,OAAO,EAAC,mBAAmB,EAAwB,+BAA4B;AAG/E;;;GAGG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,GAAG,mBAAmB;IACtB,IAAI,EAAE,gBAAgB;IACtB,OAAO,EAAE,KAAK,IAAI,EAAE;QAClB,MAAM,EAAC,uBAAuB,EAAC,GAAG,MAAM,MAAM,CAAC,4CAA4C,CAAC,CAAC;QAC7F,OAAO,uBAAuB,CAAC;IACjC,CAAC;CAC8F,CAAC"}

package/dist/las/lazperf-loader.cjs

@@ -0,0 +1,60 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/las/lazperf-loader.ts
+var lazperf_loader_exports = {};
+__export(lazperf_loader_exports, {
+  LAZPerfLoaderWithParser: () => LAZPerfLoaderWithParser
+});
+module.exports = __toCommonJS(lazperf_loader_exports);
+var import_schema_utils = require("@loaders.gl/core/schema-utils");
+var import_las_loader_shared = require("./las-loader-shared.cjs");
+var import_parse_las = require("./lib/laz-perf/parse-las.cjs");
+var LAZPerfLoaderWithParser = {
+  ...import_las_loader_shared.LAS_LOADER_METADATA,
+  name: "LAS (laz-perf)",
+  parse: async (arrayBuffer, options) => convertLASMesh((0, import_parse_las.parseLAS)(arrayBuffer, options), options),
+  parseSync: (arrayBuffer, options) => convertLASMesh((0, import_parse_las.parseLAS)(arrayBuffer, options), options),
+  parseInBatches: async function* (arrayBufferIterator, options) {
+    yield* convertLASMeshBatches((0, import_parse_las.parseLASInBatches)(arrayBufferIterator, options), options);
+  }
+};
+function convertLASMesh(mesh, options) {
+  const formattedMesh = (0, import_las_loader_shared.formatLASMeshColors)(mesh, options?.las?.colorFormat || "uint8norm");
+  const table = (0, import_schema_utils.convertMeshToTable)(formattedMesh, "arrow-table");
+  if ((0, import_las_loader_shared.getLASShape)(options) === "arrow-table") {
+    return table;
+  }
+  return {
+    ...(0, import_schema_utils.convertTableToMesh)(table),
+    loader: mesh.loader,
+    loaderData: mesh.loaderData,
+    progress: mesh.progress
+  };
+}
+async function* convertLASMeshBatches(meshBatches, options) {
+  for await (const mesh of meshBatches) {
+    yield convertLASMesh(mesh, options);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LAZPerfLoaderWithParser
+});
+//# sourceMappingURL=lazperf-loader.cjs.map

package/dist/las/lazperf-loader.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/las/lazperf-loader.ts"],
+  "sourcesContent": ["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\n// LASER (LAS) FILE FORMAT\nimport type {LoaderWithParser} from '@loaders.gl/core/loader-utils';\nimport type {MeshArrowTable} from '@loaders.gl/core/schema';\nimport {convertMeshToTable, convertTableToMesh} from '@loaders.gl/core/schema-utils';\nimport {\n  formatLASMeshColors,\n  getLASShape,\n  LAS_LOADER_METADATA,\n  type LASLoaderOptions\n} from './las-loader-shared';\nimport type {LASMesh} from './lib/las-types';\nimport {parseLAS, parseLASInBatches} from './lib/laz-perf/parse-las';\n\n/**\n * Loader for the LAS (LASer) point cloud format\n * @note Does not support LAS v1.4\n */\nexport const LAZPerfLoaderWithParser = {\n  ...LAS_LOADER_METADATA,\n  name: 'LAS (laz-perf)',\n  parse: async (arrayBuffer: ArrayBuffer, options?: LASLoaderOptions) =>\n    convertLASMesh(parseLAS(arrayBuffer, options), options),\n  parseSync: (arrayBuffer: ArrayBuffer, options?: LASLoaderOptions) =>\n    convertLASMesh(parseLAS(arrayBuffer, options), options),\n  parseInBatches: async function* (arrayBufferIterator, options?: LASLoaderOptions) {\n    yield* convertLASMeshBatches(parseLASInBatches(arrayBufferIterator, options), options);\n  }\n} as const satisfies LoaderWithParser<\n  LASMesh | MeshArrowTable,\n  LASMesh | MeshArrowTable,\n  LASLoaderOptions\n>;\n\nfunction convertLASMesh(mesh: LASMesh, options?: LASLoaderOptions): LASMesh | MeshArrowTable {\n  const formattedMesh = formatLASMeshColors(mesh, options?.las?.colorFormat || 'uint8norm');\n  const table = convertMeshToTable(formattedMesh, 'arrow-table') as MeshArrowTable;\n  if (getLASShape(options) === 'arrow-table') {\n    return table;\n  }\n  return {\n    ...(convertTableToMesh(table) as LASMesh),\n    loader: mesh.loader,\n    loaderData: mesh.loaderData,\n    progress: (mesh as LASMesh & {progress?: number}).progress\n  } as LASMesh & {progress?: number};\n}\n\n/**\n * Convert LAS mesh batches to the requested output shape.\n * @param meshBatches Decoded LAS mesh batches\n * @param options LAS loader options\n * @returns Converted LAS batches\n */\nasync function* convertLASMeshBatches(\n  meshBatches: AsyncIterable<LASMesh>,\n  options?: LASLoaderOptions\n): AsyncIterable<LASMesh | MeshArrowTable> {\n  for await (const mesh of meshBatches) {\n    yield convertLASMesh(mesh, options);\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAOA,0BAAqD;AACrD,+BAKO;AAEP,uBAA0C;AAMnC,IAAM,0BAA0B;AAAA,EACrC,GAAG;AAAA,EACH,MAAM;AAAA,EACN,OAAO,OAAO,aAA0B,YACtC,mBAAe,2BAAS,aAAa,OAAO,GAAG,OAAO;AAAA,EACxD,WAAW,CAAC,aAA0B,YACpC,mBAAe,2BAAS,aAAa,OAAO,GAAG,OAAO;AAAA,EACxD,gBAAgB,iBAAiB,qBAAqB,SAA4B;AAChF,WAAO,0BAAsB,oCAAkB,qBAAqB,OAAO,GAAG,OAAO;AAAA,EACvF;AACF;AAMA,SAAS,eAAe,MAAe,SAAsD;AAC3F,QAAM,oBAAgB,8CAAoB,MAAM,SAAS,KAAK,eAAe,WAAW;AACxF,QAAM,YAAQ,wCAAmB,eAAe,aAAa;AAC7D,UAAI,sCAAY,OAAO,MAAM,eAAe;AAC1C,WAAO;AAAA,EACT;AACA,SAAO;AAAA,IACL,OAAI,wCAAmB,KAAK;AAAA,IAC5B,QAAQ,KAAK;AAAA,IACb,YAAY,KAAK;AAAA,IACjB,UAAW,KAAuC;AAAA,EACpD;AACF;AAQA,gBAAgB,sBACd,aACA,SACyC;AACzC,mBAAiB,QAAQ,aAAa;AACpC,UAAM,eAAe,MAAM,OAAO;AAAA,EACpC;AACF;",
+  "names": []
+}

package/dist/las/lazperf-loader.d.ts

@@ -0,0 +1,39 @@
+import type { MeshArrowTable } from '@loaders.gl/core/schema';
+import { type LASLoaderOptions } from "./las-loader-shared.js";
+import type { LASMesh } from "./lib/las-types.js";
+/**
+ * Loader for the LAS (LASer) point cloud format
+ * @note Does not support LAS v1.4
+ */
+export declare const LAZPerfLoaderWithParser: {
+    readonly name: "LAS (laz-perf)";
+    readonly parse: (arrayBuffer: ArrayBuffer, options?: LASLoaderOptions) => Promise<LASMesh | MeshArrowTable>;
+    readonly parseSync: (arrayBuffer: ArrayBuffer, options?: LASLoaderOptions) => LASMesh | MeshArrowTable;
+    readonly parseInBatches: (arrayBufferIterator: AsyncIterable<ArrayBufferLike | ArrayBufferView<ArrayBufferLike>> | Iterable<ArrayBufferLike | ArrayBufferView<ArrayBufferLike>>, options?: LASLoaderOptions) => AsyncGenerator<LASMesh | MeshArrowTable, void, any>;
+    readonly dataType: LASMesh | MeshArrowTable;
+    readonly batchType: LASMesh | MeshArrowTable;
+    readonly version: any;
+    readonly worker: false;
+    readonly options: {
+        readonly las: {
+            readonly shape: "arrow-table";
+            readonly fp64: false;
+            readonly colorDepth: 8;
+            readonly colorFormat: "uint8norm";
+            readonly columns: undefined;
+            readonly extraBytes: "raw";
+            readonly recoverMissingChunkTable: false;
+            readonly compatibilityMode: "auto";
+        };
+    };
+    readonly id: "las";
+    readonly module: "pointclouds";
+    readonly encoding: "binary";
+    readonly format: "las";
+    readonly extensions: ["las", "laz"];
+    readonly mimeTypes: ["application/octet-stream"];
+    readonly text: false;
+    readonly binary: true;
+    readonly tests: ["LASF"];
+};
+//# sourceMappingURL=lazperf-loader.d.ts.map

package/dist/las/lazperf-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazperf-loader.d.ts","sourceRoot":"","sources":["../../src/las/lazperf-loader.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,yBAAyB,CAAC;AAE5D,OAAO,EAIL,KAAK,gBAAgB,EACtB,+BAA4B;AAC7B,OAAO,KAAK,EAAC,OAAO,EAAC,2BAAwB;AAG7C;;;GAGG;AACH,eAAO,MAAM,uBAAuB;;kCAGP,WAAW,YAAY,gBAAgB;sCAEzC,WAAW,YAAY,gBAAgB;+LAEA,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;CAOjF,CAAC"}

package/dist/las/lazperf-loader.js

@@ -0,0 +1,44 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { convertMeshToTable, convertTableToMesh } from '@loaders.gl/core/schema-utils';
+import { formatLASMeshColors, getLASShape, LAS_LOADER_METADATA } from "./las-loader-shared.js";
+import { parseLAS, parseLASInBatches } from "./lib/laz-perf/parse-las.js";
+/**
+ * Loader for the LAS (LASer) point cloud format
+ * @note Does not support LAS v1.4
+ */
+export const LAZPerfLoaderWithParser = {
+    ...LAS_LOADER_METADATA,
+    name: 'LAS (laz-perf)',
+    parse: async (arrayBuffer, options) => convertLASMesh(parseLAS(arrayBuffer, options), options),
+    parseSync: (arrayBuffer, options) => convertLASMesh(parseLAS(arrayBuffer, options), options),
+    parseInBatches: async function* (arrayBufferIterator, options) {
+        yield* convertLASMeshBatches(parseLASInBatches(arrayBufferIterator, options), options);
+    }
+};
+function convertLASMesh(mesh, options) {
+    const formattedMesh = formatLASMeshColors(mesh, options?.las?.colorFormat || 'uint8norm');
+    const table = convertMeshToTable(formattedMesh, 'arrow-table');
+    if (getLASShape(options) === 'arrow-table') {
+        return table;
+    }
+    return {
+        ...convertTableToMesh(table),
+        loader: mesh.loader,
+        loaderData: mesh.loaderData,
+        progress: mesh.progress
+    };
+}
+/**
+ * Convert LAS mesh batches to the requested output shape.
+ * @param meshBatches Decoded LAS mesh batches
+ * @param options LAS loader options
+ * @returns Converted LAS batches
+ */
+async function* convertLASMeshBatches(meshBatches, options) {
+    for await (const mesh of meshBatches) {
+        yield convertLASMesh(mesh, options);
+    }
+}
+//# sourceMappingURL=lazperf-loader.js.map

package/dist/las/lazperf-loader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazperf-loader.js","sourceRoot":"","sources":["../../src/las/lazperf-loader.ts"],"names":[],"mappings":"AAAA,aAAa;AACb,+BAA+B;AAC/B,oCAAoC;AAKpC,OAAO,EAAC,kBAAkB,EAAE,kBAAkB,EAAC,MAAM,+BAA+B,CAAC;AACrF,OAAO,EACL,mBAAmB,EACnB,WAAW,EACX,mBAAmB,EAEpB,+BAA4B;AAE7B,OAAO,EAAC,QAAQ,EAAE,iBAAiB,EAAC,oCAAiC;AAErE;;;GAGG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG;IACrC,GAAG,mBAAmB;IACtB,IAAI,EAAE,gBAAgB;IACtB,KAAK,EAAE,KAAK,EAAE,WAAwB,EAAE,OAA0B,EAAE,EAAE,CACpE,cAAc,CAAC,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC;IACzD,SAAS,EAAE,CAAC,WAAwB,EAAE,OAA0B,EAAE,EAAE,CAClE,cAAc,CAAC,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC;IACzD,cAAc,EAAE,KAAK,SAAS,CAAC,EAAE,mBAAmB,EAAE,OAA0B;QAC9E,KAAK,CAAC,CAAC,qBAAqB,CAAC,iBAAiB,CAAC,mBAAmB,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,CAAC;IACzF,CAAC;CAKF,CAAC;AAEF,SAAS,cAAc,CAAC,IAAa,EAAE,OAA0B;IAC/D,MAAM,aAAa,GAAG,mBAAmB,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,WAAW,IAAI,WAAW,CAAC,CAAC;IAC1F,MAAM,KAAK,GAAG,kBAAkB,CAAC,aAAa,EAAE,aAAa,CAAmB,CAAC;IACjF,IAAI,WAAW,CAAC,OAAO,CAAC,KAAK,aAAa,EAAE,CAAC;QAC3C,OAAO,KAAK,CAAC;IACf,CAAC;IACD,OAAO;QACL,GAAI,kBAAkB,CAAC,KAAK,CAAa;QACzC,MAAM,EAAE,IAAI,CAAC,MAAM;QACnB,UAAU,EAAE,IAAI,CAAC,UAAU;QAC3B,QAAQ,EAAG,IAAsC,CAAC,QAAQ;KAC1B,CAAC;AACrC,CAAC;AAED;;;;;GAKG;AACH,KAAK,SAAS,CAAC,CAAC,qBAAqB,CACnC,WAAmC,EACnC,OAA0B;IAE1B,IAAI,KAAK,EAAE,MAAM,IAAI,IAAI,WAAW,EAAE,CAAC;QACrC,MAAM,cAAc,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IACtC,CAAC;AACH,CAAC"}

package/dist/las/lib/copc/parse-las.cjs

@@ -0,0 +1,177 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/las/lib/copc/parse-las.ts
+var parse_las_exports = {};
+__export(parse_las_exports, {
+  parseCOPCLAS: () => parseCOPCLAS,
+  parseCOPCLASInBatches: () => parseCOPCLASInBatches
+});
+module.exports = __toCommonJS(parse_las_exports);
+var import_loader_utils = require("@loaders.gl/core/loader-utils");
+var import_schema_utils = require("@loaders.gl/core/schema-utils");
+var import_copc = require("copc");
+var import_get_las_schema = require("../get-las-schema.cjs");
+var DEFAULT_BATCH_SIZE = 1e3 * 100;
+async function parseCOPCLAS(arrayBuffer, options = {}) {
+  const header = import_copc.Las.Header.parse(new Uint8Array(arrayBuffer));
+  const batches = parseCOPCLASBatches(arrayBuffer, options, header.pointCount)[Symbol.asyncIterator]();
+  const firstBatch = await batches.next();
+  if (!firstBatch.value) {
+    throw new Error("LAS file contained no points");
+  }
+  return firstBatch.value;
+}
+async function* parseCOPCLASInBatches(arrayBufferIterator, options = {}) {
+  const arrayBuffer = await (0, import_loader_utils.concatenateArrayBuffersAsync)(arrayBufferIterator);
+  yield* parseCOPCLASBatches(arrayBuffer, options, getBatchSize(options));
+}
+async function* parseCOPCLASBatches(arrayBuffer, options, batchSize) {
+  const header = import_copc.Las.Header.parse(new Uint8Array(arrayBuffer));
+  const pointData = await getCOPCPointData(arrayBuffer, header);
+  const view = import_copc.Las.View.create(pointData, header);
+  const totalToRead = view.pointCount;
+  const lasHeader = getLASHeader(arrayBuffer, header, totalToRead);
+  for (let pointIndex = 0; pointIndex < totalToRead; pointIndex += batchSize) {
+    const batchPointCount = Math.min(batchSize, totalToRead - pointIndex);
+    lasHeader.totalRead = pointIndex + batchPointCount;
+    yield getLASMeshBatch(view, lasHeader, options, pointIndex, batchPointCount);
+  }
+}
+async function getCOPCPointData(arrayBuffer, header) {
+  if (isCompressedLAS(arrayBuffer)) {
+    return await import_copc.Las.PointData.decompressFile(new Uint8Array(arrayBuffer));
+  }
+  const byteOffset = header.pointDataOffset;
+  const byteLength = header.pointCount * header.pointDataRecordLength;
+  return new Uint8Array(arrayBuffer, byteOffset, byteLength);
+}
+function getLASHeader(arrayBuffer, header, totalToRead) {
+  return {
+    pointsOffset: header.pointDataOffset,
+    pointsFormatId: header.pointDataRecordFormat,
+    pointsStructSize: header.pointDataRecordLength,
+    pointsCount: header.pointCount,
+    scale: header.scale,
+    offset: header.offset,
+    maxs: header.max,
+    mins: header.min,
+    totalToRead,
+    totalRead: 0,
+    hasColor: hasCOPCColor(header.pointDataRecordFormat),
+    versionAsString: `${header.majorVersion}.${header.minorVersion}`,
+    isCompressed: isCompressedLAS(arrayBuffer)
+  };
+}
+function isCompressedLAS(arrayBuffer) {
+  const rawPointFormat = new DataView(arrayBuffer).getUint8(104);
+  return Boolean(rawPointFormat & 192);
+}
+function hasCOPCColor(pointDataRecordFormat) {
+  return pointDataRecordFormat === 2 || pointDataRecordFormat === 3 || pointDataRecordFormat >= 7;
+}
+function getLASMeshBatch(view, lasHeader, options, pointOffset, batchPointCount) {
+  const PositionsType = options.las?.fp64 ? Float64Array : Float32Array;
+  const positions = new PositionsType(batchPointCount * 3);
+  const colors = lasHeader.hasColor ? new Uint8Array(batchPointCount * 4) : null;
+  const intensities = new Uint16Array(batchPointCount);
+  const classifications = new Uint8Array(batchPointCount);
+  const getX = view.getter("X");
+  const getY = view.getter("Y");
+  const getZ = view.getter("Z");
+  const getIntensity = view.getter("Intensity");
+  const getClassification = view.getter("Classification");
+  const getRed = colors ? view.getter("Red") : null;
+  const getGreen = colors ? view.getter("Green") : null;
+  const getBlue = colors ? view.getter("Blue") : null;
+  const twoByteColor = detectTwoByteColors(view, pointOffset, batchPointCount, options);
+  for (let i = 0; i < batchPointCount; i++) {
+    const sourcePointIndex = pointOffset + i;
+    positions[i * 3] = getX(sourcePointIndex);
+    positions[i * 3 + 1] = getY(sourcePointIndex);
+    positions[i * 3 + 2] = getZ(sourcePointIndex);
+    intensities[i] = getIntensity(sourcePointIndex);
+    classifications[i] = getClassification(sourcePointIndex);
+    if (colors && getRed && getGreen && getBlue) {
+      const red = getRed(sourcePointIndex);
+      const green = getGreen(sourcePointIndex);
+      const blue = getBlue(sourcePointIndex);
+      colors[i * 4] = twoByteColor ? red / 256 : red;
+      colors[i * 4 + 1] = twoByteColor ? green / 256 : green;
+      colors[i * 4 + 2] = twoByteColor ? blue / 256 : blue;
+      colors[i * 4 + 3] = 255;
+    }
+  }
+  const attributes = {
+    POSITION: { value: positions, size: 3 },
+    intensity: { value: intensities, size: 1 },
+    classification: { value: classifications, size: 1 }
+  };
+  if (colors) {
+    attributes.COLOR_0 = { value: colors, size: 4 };
+  }
+  const batchHeader = { ...lasHeader };
+  const lasMesh = {
+    loader: "las",
+    loaderData: batchHeader,
+    schema: { fields: [], metadata: {} },
+    header: {
+      vertexCount: batchPointCount,
+      boundingBox: (0, import_schema_utils.getMeshBoundingBox)(attributes)
+    },
+    attributes,
+    topology: "point-list",
+    mode: 0,
+    progress: lasHeader.totalRead / lasHeader.totalToRead
+  };
+  lasMesh.schema = (0, import_get_las_schema.getLASSchema)(batchHeader, lasMesh.attributes);
+  return lasMesh;
+}
+function detectTwoByteColors(view, pointOffset, batchPointCount, options) {
+  switch (options.las?.colorDepth) {
+    case 8:
+      return false;
+    case 16:
+      return true;
+    case "auto": {
+      const getRed = view.getter("Red");
+      const getGreen = view.getter("Green");
+      const getBlue = view.getter("Blue");
+      for (let i = 0; i < batchPointCount; i++) {
+        const sourcePointIndex = pointOffset + i;
+        if (getRed(sourcePointIndex) > 255 || getGreen(sourcePointIndex) > 255 || getBlue(sourcePointIndex) > 255) {
+          return true;
+        }
+      }
+      return false;
+    }
+    default:
+      return false;
+  }
+}
+function getBatchSize(options) {
+  const batchSize = options.batchSize ?? options.core?.batchSize;
+  return typeof batchSize === "number" ? batchSize : DEFAULT_BATCH_SIZE;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseCOPCLAS,
+  parseCOPCLASInBatches
+});
+//# sourceMappingURL=parse-las.cjs.map

package/dist/las/lib/copc/parse-las.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/las/lib/copc/parse-las.ts"],
+  "sourcesContent": ["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport type {MeshAttributes} from '@loaders.gl/core/schema';\nimport {concatenateArrayBuffersAsync} from '@loaders.gl/core/loader-utils';\nimport {getMeshBoundingBox} from '@loaders.gl/core/schema-utils';\nimport {Las} from 'copc';\nimport type {LASLoaderOptions} from '../../las-loader-types';\nimport {getLASSchema} from '../get-las-schema';\nimport type {LASHeader, LASMesh} from '../las-types';\n\nconst DEFAULT_BATCH_SIZE = 1000 * 100;\n\n/**\n * Parse LAS/LAZ data using the laz-perf decoder shipped by the COPC package.\n * @param arrayBuffer Complete LAS/LAZ file data\n * @param options LAS loader options\n * @returns Parsed LAS mesh\n */\nexport async function parseCOPCLAS(\n  arrayBuffer: ArrayBuffer,\n  options: LASLoaderOptions = {}\n): Promise<LASMesh> {\n  const header = Las.Header.parse(new Uint8Array(arrayBuffer));\n  const batches = parseCOPCLASBatches(arrayBuffer, options, header.pointCount)[\n    Symbol.asyncIterator\n  ]();\n  const firstBatch = await batches.next();\n\n  if (!firstBatch.value) {\n    throw new Error('LAS file contained no points');\n  }\n  return firstBatch.value;\n}\n\n/**\n * Parse LAS/LAZ data in decoded point batches using the COPC package.\n * @param arrayBufferIterator Iterator yielding LAS/LAZ binary chunks\n * @param options LAS loader options\n * @returns Async iterable of mesh batches\n */\nexport async function* parseCOPCLASInBatches(\n  arrayBufferIterator:\n    | AsyncIterable<ArrayBufferLike | ArrayBufferView>\n    | Iterable<ArrayBufferLike | ArrayBufferView>,\n  options: LASLoaderOptions = {}\n): AsyncIterable<LASMesh> {\n  const arrayBuffer = await concatenateArrayBuffersAsync(arrayBufferIterator);\n  yield* parseCOPCLASBatches(arrayBuffer, options, getBatchSize(options));\n}\n\n/**\n * Parse LAS/LAZ data in decoded point batches using the COPC package.\n * @param arrayBuffer Complete LAS/LAZ file data\n * @param options LAS loader options\n * @param batchSize Number of returned points per batch\n * @returns Async iterable of mesh batches\n */\nasync function* parseCOPCLASBatches(\n  arrayBuffer: ArrayBuffer,\n  options: LASLoaderOptions,\n  batchSize: number\n): AsyncIterable<LASMesh> {\n  const header = Las.Header.parse(new Uint8Array(arrayBuffer));\n  const pointData = await getCOPCPointData(arrayBuffer, header);\n  const view = Las.View.create(pointData, header);\n  const totalToRead = view.pointCount;\n  const lasHeader = getLASHeader(arrayBuffer, header, totalToRead);\n\n  for (let pointIndex = 0; pointIndex < totalToRead; pointIndex += batchSize) {\n    const batchPointCount = Math.min(batchSize, totalToRead - pointIndex);\n    lasHeader.totalRead = pointIndex + batchPointCount;\n    yield getLASMeshBatch(view, lasHeader, options, pointIndex, batchPointCount);\n  }\n}\n\n/**\n * Decompress or slice LAS point records for the COPC package parser.\n * @param arrayBuffer Complete LAS/LAZ file data\n * @param header COPC package LAS header\n * @returns Uncompressed point records\n */\nasync function getCOPCPointData(arrayBuffer: ArrayBuffer, header: any): Promise<Uint8Array> {\n  if (isCompressedLAS(arrayBuffer)) {\n    return await Las.PointData.decompressFile(new Uint8Array(arrayBuffer));\n  }\n\n  const byteOffset = header.pointDataOffset;\n  const byteLength = header.pointCount * header.pointDataRecordLength;\n  return new Uint8Array(arrayBuffer, byteOffset, byteLength);\n}\n\n/**\n * Convert a COPC package header into loaders.gl LAS header metadata.\n * @param arrayBuffer Complete LAS/LAZ file data\n * @param header COPC package LAS header\n * @param totalToRead Number of output points\n * @returns loaders.gl LAS header\n */\nfunction getLASHeader(arrayBuffer: ArrayBuffer, header: any, totalToRead: number): LASHeader {\n  return {\n    pointsOffset: header.pointDataOffset,\n    pointsFormatId: header.pointDataRecordFormat,\n    pointsStructSize: header.pointDataRecordLength,\n    pointsCount: header.pointCount,\n    scale: header.scale,\n    offset: header.offset,\n    maxs: header.max,\n    mins: header.min,\n    totalToRead,\n    totalRead: 0,\n    hasColor: hasCOPCColor(header.pointDataRecordFormat),\n    versionAsString: `${header.majorVersion}.${header.minorVersion}`,\n    isCompressed: isCompressedLAS(arrayBuffer)\n  };\n}\n\n/**\n * Return true when the LAS point format includes compressed LAZ flags.\n * @param arrayBuffer Complete LAS/LAZ file data\n * @returns Whether the file uses LAZ compression\n */\nfunction isCompressedLAS(arrayBuffer: ArrayBuffer): boolean {\n  const rawPointFormat = new DataView(arrayBuffer).getUint8(104);\n  return Boolean(rawPointFormat & 0xc0);\n}\n\n/**\n * Return true when a COPC-supported LAS point format includes RGB color.\n * @param pointDataRecordFormat LAS point data record format\n * @returns Whether the point format has color\n */\nfunction hasCOPCColor(pointDataRecordFormat: number): boolean {\n  return pointDataRecordFormat === 2 || pointDataRecordFormat === 3 || pointDataRecordFormat >= 7;\n}\n\n/**\n * Build one LAS mesh batch from a COPC package point view.\n * @param view COPC package point view\n * @param lasHeader LAS header metadata\n * @param options LAS loader options\n * @param pointOffset Output point offset\n * @param batchPointCount Number of points in this batch\n * @returns LAS mesh batch\n */\nfunction getLASMeshBatch(\n  view: any,\n  lasHeader: LASHeader,\n  options: LASLoaderOptions,\n  pointOffset: number,\n  batchPointCount: number\n): LASMesh {\n  const PositionsType = options.las?.fp64 ? Float64Array : Float32Array;\n  const positions = new PositionsType(batchPointCount * 3);\n  const colors = lasHeader.hasColor ? new Uint8Array(batchPointCount * 4) : null;\n  const intensities = new Uint16Array(batchPointCount);\n  const classifications = new Uint8Array(batchPointCount);\n  const getX = view.getter('X');\n  const getY = view.getter('Y');\n  const getZ = view.getter('Z');\n  const getIntensity = view.getter('Intensity');\n  const getClassification = view.getter('Classification');\n  const getRed = colors ? view.getter('Red') : null;\n  const getGreen = colors ? view.getter('Green') : null;\n  const getBlue = colors ? view.getter('Blue') : null;\n  const twoByteColor = detectTwoByteColors(view, pointOffset, batchPointCount, options);\n\n  for (let i = 0; i < batchPointCount; i++) {\n    const sourcePointIndex = pointOffset + i;\n    positions[i * 3] = getX(sourcePointIndex);\n    positions[i * 3 + 1] = getY(sourcePointIndex);\n    positions[i * 3 + 2] = getZ(sourcePointIndex);\n    intensities[i] = getIntensity(sourcePointIndex);\n    classifications[i] = getClassification(sourcePointIndex);\n\n    if (colors && getRed && getGreen && getBlue) {\n      const red = getRed(sourcePointIndex);\n      const green = getGreen(sourcePointIndex);\n      const blue = getBlue(sourcePointIndex);\n      colors[i * 4] = twoByteColor ? red / 256 : red;\n      colors[i * 4 + 1] = twoByteColor ? green / 256 : green;\n      colors[i * 4 + 2] = twoByteColor ? blue / 256 : blue;\n      colors[i * 4 + 3] = 255;\n    }\n  }\n\n  const attributes: MeshAttributes = {\n    POSITION: {value: positions, size: 3},\n    intensity: {value: intensities, size: 1},\n    classification: {value: classifications, size: 1}\n  };\n\n  if (colors) {\n    attributes.COLOR_0 = {value: colors, size: 4};\n  }\n\n  const batchHeader = {...lasHeader};\n  const lasMesh: LASMesh = {\n    loader: 'las',\n    loaderData: batchHeader,\n    schema: {fields: [], metadata: {}},\n    header: {\n      vertexCount: batchPointCount,\n      boundingBox: getMeshBoundingBox(attributes)\n    },\n    attributes,\n    topology: 'point-list',\n    mode: 0,\n    progress: lasHeader.totalRead / lasHeader.totalToRead\n  } as LASMesh & {progress: number};\n\n  lasMesh.schema = getLASSchema(batchHeader, lasMesh.attributes);\n  return lasMesh;\n}\n\n/**\n * Detect whether color values use 16-bit LAS color range.\n * @param view COPC package point view\n * @param pointOffset Output point offset\n * @param batchPointCount Number of points in this batch\n * @param options LAS loader options\n * @returns Whether color values should be downscaled from 16-bit to 8-bit\n */\nfunction detectTwoByteColors(\n  view: any,\n  pointOffset: number,\n  batchPointCount: number,\n  options: LASLoaderOptions\n): boolean {\n  switch (options.las?.colorDepth) {\n    case 8:\n      return false;\n    case 16:\n      return true;\n    case 'auto': {\n      const getRed = view.getter('Red');\n      const getGreen = view.getter('Green');\n      const getBlue = view.getter('Blue');\n      for (let i = 0; i < batchPointCount; i++) {\n        const sourcePointIndex = pointOffset + i;\n        if (\n          getRed(sourcePointIndex) > 255 ||\n          getGreen(sourcePointIndex) > 255 ||\n          getBlue(sourcePointIndex) > 255\n        ) {\n          return true;\n        }\n      }\n      return false;\n    }\n    default:\n      return false;\n  }\n}\n\n/**\n * Get the requested LAS point batch size.\n * @param options LAS loader options\n * @returns Point count per decoded batch\n */\nfunction getBatchSize(options: LASLoaderOptions): number {\n  const batchSize = options.batchSize ?? options.core?.batchSize;\n  return typeof batchSize === 'number' ? batchSize : DEFAULT_BATCH_SIZE;\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/las/lib/copc/parse-las.d.ts

@@ -0,0 +1,17 @@
+import type { LASLoaderOptions } from "../../las-loader-types.js";
+import type { LASMesh } from "../las-types.js";
+/**
+ * Parse LAS/LAZ data using the laz-perf decoder shipped by the COPC package.
+ * @param arrayBuffer Complete LAS/LAZ file data
+ * @param options LAS loader options
+ * @returns Parsed LAS mesh
+ */
+export declare function parseCOPCLAS(arrayBuffer: ArrayBuffer, options?: LASLoaderOptions): Promise<LASMesh>;
+/**
+ * Parse LAS/LAZ data in decoded point batches using the COPC package.
+ * @param arrayBufferIterator Iterator yielding LAS/LAZ binary chunks
+ * @param options LAS loader options
+ * @returns Async iterable of mesh batches
+ */
+export declare function parseCOPCLASInBatches(arrayBufferIterator: AsyncIterable<ArrayBufferLike | ArrayBufferView> | Iterable<ArrayBufferLike | ArrayBufferView>, options?: LASLoaderOptions): AsyncIterable<LASMesh>;
+//# sourceMappingURL=parse-las.d.ts.map

package/dist/las/lib/copc/parse-las.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-las.d.ts","sourceRoot":"","sources":["../../../../src/las/lib/copc/parse-las.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAC,gBAAgB,EAAC,kCAA+B;AAE7D,OAAO,KAAK,EAAY,OAAO,EAAC,wBAAqB;AAIrD;;;;;GAKG;AACH,wBAAsB,YAAY,CAChC,WAAW,EAAE,WAAW,EACxB,OAAO,GAAE,gBAAqB,GAC7B,OAAO,CAAC,OAAO,CAAC,CAWlB;AAED;;;;;GAKG;AACH,wBAAuB,qBAAqB,CAC1C,mBAAmB,EACf,aAAa,CAAC,eAAe,GAAG,eAAe,CAAC,GAChD,QAAQ,CAAC,eAAe,GAAG,eAAe,CAAC,EAC/C,OAAO,GAAE,gBAAqB,GAC7B,aAAa,CAAC,OAAO,CAAC,CAGxB"}