@loaders.gl/pointclouds 5.0.0-beta.1 → 5.0.0-beta.2

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

@@ -38,7 +38,7 @@ var LASCOPCLoader = {
   ...import_las_loader_shared.LAS_LOADER_METADATA,
   name: "LAS (COPC)",
   preload: async () => {
-    const { LASCOPCLoaderWithParser } = await import("@loaders.gl/pointclouds/las/las-copc-loader");
+    const { LASCOPCLoaderWithParser } = await import("@loaders.gl/pointclouds/las-copc-loader");
     return LASCOPCLoaderWithParser;
   }
 };

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

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/las/las-copc-loader-types.ts"],
-  "sourcesContent": ["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\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/** Metadata-only LAS/LAZ loader variant using the COPC package decoder. */\nexport const LASCOPCLoader = {\n  ...LAS_LOADER_METADATA,\n  name: 'LAS (COPC)',\n  preload: async () => {\n    const {LASCOPCLoaderWithParser} = await import('@loaders.gl/pointclouds/las/las-copc-loader');\n    return LASCOPCLoaderWithParser;\n  }\n} as const satisfies Loader<LASMesh | MeshArrowTable, LASMesh | MeshArrowTable, LASLoaderOptions>;\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,+BAAyD;AAIlD,IAAM,gBAAgB;AAAA,EAC3B,GAAG;AAAA,EACH,MAAM;AAAA,EACN,SAAS,YAAY;AACnB,UAAM,EAAC,wBAAuB,IAAI,MAAM,OAAO,6CAA6C;AAC5F,WAAO;AAAA,EACT;AACF;",
+  "sourcesContent": ["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\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/** Metadata-only LAS/LAZ loader variant using the COPC package decoder. */\nexport const LASCOPCLoader = {\n  ...LAS_LOADER_METADATA,\n  name: 'LAS (COPC)',\n  preload: async () => {\n    const {LASCOPCLoaderWithParser} = await import('@loaders.gl/pointclouds/las-copc-loader');\n    return LASCOPCLoaderWithParser;\n  }\n} as const satisfies Loader<LASMesh | MeshArrowTable, LASMesh | MeshArrowTable, LASLoaderOptions>;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,+BAAyD;AAIlD,IAAM,gBAAgB;AAAA,EAC3B,GAAG;AAAA,EACH,MAAM;AAAA,EACN,SAAS,YAAY;AACnB,UAAM,EAAC,wBAAuB,IAAI,MAAM,OAAO,yCAAyC;AACxF,WAAO;AAAA,EACT;AACF;",
   "names": []
 }

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

@@ -7,7 +7,7 @@ export const LASCOPCLoader = {
     ...LAS_LOADER_METADATA,
     name: 'LAS (COPC)',
     preload: async () => {
-        const { LASCOPCLoaderWithParser } = await import('@loaders.gl/pointclouds/las/las-copc-loader');
+        const { LASCOPCLoaderWithParser } = await import('@loaders.gl/pointclouds/las-copc-loader');
         return LASCOPCLoaderWithParser;
     }
 };

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

@@ -1 +1 @@
-{"version":3,"file":"las-copc-loader-types.js","sourceRoot":"","sources":["../../src/las/las-copc-loader-types.ts"],"names":[],"mappings":"AAAA,aAAa;AACb,+BAA+B;AAC/B,oCAAoC;AAIpC,OAAO,EAAC,mBAAmB,EAAwB,+BAA4B;AAG/E,2EAA2E;AAC3E,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,GAAG,mBAAmB;IACtB,IAAI,EAAE,YAAY;IAClB,OAAO,EAAE,KAAK,IAAI,EAAE;QAClB,MAAM,EAAC,uBAAuB,EAAC,GAAG,MAAM,MAAM,CAAC,6CAA6C,CAAC,CAAC;QAC9F,OAAO,uBAAuB,CAAC;IACjC,CAAC;CAC8F,CAAC"}
+{"version":3,"file":"las-copc-loader-types.js","sourceRoot":"","sources":["../../src/las/las-copc-loader-types.ts"],"names":[],"mappings":"AAAA,aAAa;AACb,+BAA+B;AAC/B,oCAAoC;AAIpC,OAAO,EAAC,mBAAmB,EAAwB,+BAA4B;AAG/E,2EAA2E;AAC3E,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,GAAG,mBAAmB;IACtB,IAAI,EAAE,YAAY;IAClB,OAAO,EAAE,KAAK,IAAI,EAAE;QAClB,MAAM,EAAC,uBAAuB,EAAC,GAAG,MAAM,MAAM,CAAC,yCAAyC,CAAC,CAAC;QAC1F,OAAO,uBAAuB,CAAC;IACjC,CAAC;CAC8F,CAAC"}

package/dist/las/las-loader-shared.cjs

@@ -28,7 +28,7 @@ __export(las_loader_shared_exports, {
 module.exports = __toCommonJS(las_loader_shared_exports);
 var import_schema = require("@loaders.gl/core/schema");
 var import_las_format = require("./las-format.cjs");
-var VERSION = true ? "5.0.0-beta.1" : "latest";
+var VERSION = true ? "5.0.0-beta.2" : "latest";
 var DEFAULT_LAS_SHAPE = "arrow-table";
 function getLASShape(options) {
   return options?.las?.shape || DEFAULT_LAS_SHAPE;

package/dist/las/las-loader-shared.js

@@ -5,7 +5,7 @@ import { convertColorArrayToFloat16, convertColorArrayToFloat32 } from '@loaders
 import { LASFormat } from "./las-format.js";
 // __VERSION__ is injected by babel-plugin-version-inline
 // @ts-ignore TS2304: Cannot find name '__VERSION__'.
-const VERSION = typeof "5.0.0-beta.1" !== 'undefined' ? "5.0.0-beta.1" : 'latest';
+const VERSION = typeof "5.0.0-beta.2" !== 'undefined' ? "5.0.0-beta.2" : 'latest';
 /** Default output shape for LAS and LAZ loaders. */
 export const DEFAULT_LAS_SHAPE = 'arrow-table';
 /** Resolve the LAS output shape, including the Arrow-primary default. */

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

@@ -36,7 +36,7 @@ __export(las_loader_types_exports, {
 module.exports = __toCommonJS(las_loader_types_exports);
 var import_las_loader_shared = require("./las-loader-shared.cjs");
 async function preload() {
-  const { LASLoaderWithParser } = await import("@loaders.gl/pointclouds/las/las-loader");
+  const { LASLoaderWithParser } = await import("@loaders.gl/pointclouds/las-loader");
   return LASLoaderWithParser;
 }
 var LASLoader = {

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

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/las/las-loader-types.ts"],
-  "sourcesContent": ["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport type {Loader} from '@loaders.gl/core/loader-utils';\nimport type {MeshArrowTable} from '@loaders.gl/core/schema';\nimport type {LASMesh} from './lib/las-types';\nimport {LAS_LOADER_METADATA, type LASLoaderOptions} from './las-loader-shared';\n\nexport type {LASColumnName, LASLoaderOptions} from './las-loader-shared';\n\n/** Preloads the parser-bearing primary TypeScript LAS loader implementation. */\nasync function preload() {\n  const {LASLoaderWithParser} = await import('@loaders.gl/pointclouds/las/las-loader');\n  return LASLoaderWithParser;\n}\n\n/** Metadata-only loader for the LAS (LASer) point cloud format. */\nexport const LASLoader = {\n  ...LAS_LOADER_METADATA,\n  worker: true,\n  workerInBatches: true,\n  preload\n} as const satisfies Loader<LASMesh | MeshArrowTable, LASMesh | MeshArrowTable, LASLoaderOptions>;\n\n/** @deprecated Use LASLoader. */\nexport const LASWorkerLoader = LASLoader;\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAOA,+BAAyD;AAKzD,eAAe,UAAU;AACvB,QAAM,EAAC,oBAAmB,IAAI,MAAM,OAAO,wCAAwC;AACnF,SAAO;AACT;AAGO,IAAM,YAAY;AAAA,EACvB,GAAG;AAAA,EACH,QAAQ;AAAA,EACR,iBAAiB;AAAA,EACjB;AACF;AAGO,IAAM,kBAAkB;",
+  "sourcesContent": ["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport type {Loader} from '@loaders.gl/core/loader-utils';\nimport type {MeshArrowTable} from '@loaders.gl/core/schema';\nimport type {LASMesh} from './lib/las-types';\nimport {LAS_LOADER_METADATA, type LASLoaderOptions} from './las-loader-shared';\n\nexport type {LASColumnName, LASLoaderOptions} from './las-loader-shared';\n\n/** Preloads the parser-bearing primary TypeScript LAS loader implementation. */\nasync function preload() {\n  const {LASLoaderWithParser} = await import('@loaders.gl/pointclouds/las-loader');\n  return LASLoaderWithParser;\n}\n\n/** Metadata-only loader for the LAS (LASer) point cloud format. */\nexport const LASLoader = {\n  ...LAS_LOADER_METADATA,\n  worker: true,\n  workerInBatches: true,\n  preload\n} as const satisfies Loader<LASMesh | MeshArrowTable, LASMesh | MeshArrowTable, LASLoaderOptions>;\n\n/** @deprecated Use LASLoader. */\nexport const LASWorkerLoader = LASLoader;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAOA,+BAAyD;AAKzD,eAAe,UAAU;AACvB,QAAM,EAAC,oBAAmB,IAAI,MAAM,OAAO,oCAAoC;AAC/E,SAAO;AACT;AAGO,IAAM,YAAY;AAAA,EACvB,GAAG;AAAA,EACH,QAAQ;AAAA,EACR,iBAAiB;AAAA,EACjB;AACF;AAGO,IAAM,kBAAkB;",
   "names": []
 }

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

@@ -4,7 +4,7 @@
 import { LAS_LOADER_METADATA } from "./las-loader-shared.js";
 /** Preloads the parser-bearing primary TypeScript LAS loader implementation. */
 async function preload() {
-    const { LASLoaderWithParser } = await import('@loaders.gl/pointclouds/las/las-loader');
+    const { LASLoaderWithParser } = await import('@loaders.gl/pointclouds/las-loader');
     return LASLoaderWithParser;
 }
 /** Metadata-only loader for the LAS (LASer) point cloud format. */

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

@@ -1 +1 @@
-{"version":3,"file":"las-loader-types.js","sourceRoot":"","sources":["../../src/las/las-loader-types.ts"],"names":[],"mappings":"AAAA,aAAa;AACb,+BAA+B;AAC/B,oCAAoC;AAKpC,OAAO,EAAC,mBAAmB,EAAwB,+BAA4B;AAI/E,gFAAgF;AAChF,KAAK,UAAU,OAAO;IACpB,MAAM,EAAC,mBAAmB,EAAC,GAAG,MAAM,MAAM,CAAC,wCAAwC,CAAC,CAAC;IACrF,OAAO,mBAAmB,CAAC;AAC7B,CAAC;AAED,mEAAmE;AACnE,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,GAAG,mBAAmB;IACtB,MAAM,EAAE,IAAI;IACZ,eAAe,EAAE,IAAI;IACrB,OAAO;CACwF,CAAC;AAElG,iCAAiC;AACjC,MAAM,CAAC,MAAM,eAAe,GAAG,SAAS,CAAC"}
+{"version":3,"file":"las-loader-types.js","sourceRoot":"","sources":["../../src/las/las-loader-types.ts"],"names":[],"mappings":"AAAA,aAAa;AACb,+BAA+B;AAC/B,oCAAoC;AAKpC,OAAO,EAAC,mBAAmB,EAAwB,+BAA4B;AAI/E,gFAAgF;AAChF,KAAK,UAAU,OAAO;IACpB,MAAM,EAAC,mBAAmB,EAAC,GAAG,MAAM,MAAM,CAAC,oCAAoC,CAAC,CAAC;IACjF,OAAO,mBAAmB,CAAC;AAC7B,CAAC;AAED,mEAAmE;AACnE,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,GAAG,mBAAmB;IACtB,MAAM,EAAE,IAAI;IACZ,eAAe,EAAE,IAAI;IACrB,OAAO;CACwF,CAAC;AAElG,iCAAiC;AACjC,MAAM,CAAC,MAAM,eAAe,GAAG,SAAS,CAAC"}

package/dist/las/las-writer.cjs

@@ -26,7 +26,7 @@ module.exports = __toCommonJS(las_writer_exports);
 var import_loader_utils = require("@loaders.gl/core/loader-utils");
 var import_schema_utils = require("@loaders.gl/core/schema-utils");
 var import_las_format = require("./las-format.cjs");
-var VERSION = true ? "5.0.0-beta.1" : "latest";
+var VERSION = true ? "5.0.0-beta.2" : "latest";
 var LAS_HEADER_LENGTH = 227;
 var LAS_1_4_HEADER_LENGTH = 375;
 var LAS_1_5_HEADER_LENGTH = 393;

package/dist/las/las-writer.js

@@ -6,7 +6,7 @@ import { convertMeshToTable, convertTableToMesh } from '@loaders.gl/core/schema-
 import { LASFormat } from "./las-format.js";
 // __VERSION__ is injected by babel-plugin-version-inline
 // @ts-ignore TS2304: Cannot find name '__VERSION__'.
-const VERSION = typeof "5.0.0-beta.1" !== 'undefined' ? "5.0.0-beta.1" : 'latest';
+const VERSION = typeof "5.0.0-beta.2" !== 'undefined' ? "5.0.0-beta.2" : 'latest';
 const LAS_HEADER_LENGTH = 227;
 const LAS_1_4_HEADER_LENGTH = 375;
 const LAS_1_5_HEADER_LENGTH = 393;

package/dist/las/laz-rs-loader-types.cjs

@@ -38,7 +38,7 @@ var LAZRsLoader = {
   ...import_las_loader_shared.LAS_LOADER_METADATA,
   name: "LAS (laz-rs)",
   preload: async () => {
-    const { LAZRsLoaderWithParser } = await import("@loaders.gl/pointclouds/las/laz-rs-loader");
+    const { LAZRsLoaderWithParser } = await import("@loaders.gl/pointclouds/laz-rs-loader");
     return LAZRsLoaderWithParser;
   }
 };

package/dist/las/laz-rs-loader-types.cjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/las/laz-rs-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 */\nexport const LAZRsLoader = {\n  ...LAS_LOADER_METADATA,\n  name: 'LAS (laz-rs)',\n  preload: async () => {\n    const {LAZRsLoaderWithParser} = await import('@loaders.gl/pointclouds/las/laz-rs-loader');\n    return LAZRsLoaderWithParser;\n  }\n} as const satisfies Loader<LASMesh | MeshArrowTable, LASMesh | MeshArrowTable, LASLoaderOptions>;\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAOA,+BAAyD;AAMlD,IAAM,cAAc;AAAA,EACzB,GAAG;AAAA,EACH,MAAM;AAAA,EACN,SAAS,YAAY;AACnB,UAAM,EAAC,sBAAqB,IAAI,MAAM,OAAO,2CAA2C;AACxF,WAAO;AAAA,EACT;AACF;",
+  "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 */\nexport const LAZRsLoader = {\n  ...LAS_LOADER_METADATA,\n  name: 'LAS (laz-rs)',\n  preload: async () => {\n    const {LAZRsLoaderWithParser} = await import('@loaders.gl/pointclouds/laz-rs-loader');\n    return LAZRsLoaderWithParser;\n  }\n} as const satisfies Loader<LASMesh | MeshArrowTable, LASMesh | MeshArrowTable, LASLoaderOptions>;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAOA,+BAAyD;AAMlD,IAAM,cAAc;AAAA,EACzB,GAAG;AAAA,EACH,MAAM;AAAA,EACN,SAAS,YAAY;AACnB,UAAM,EAAC,sBAAqB,IAAI,MAAM,OAAO,uCAAuC;AACpF,WAAO;AAAA,EACT;AACF;",
   "names": []
 }

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

@@ -9,7 +9,7 @@ export const LAZRsLoader = {
     ...LAS_LOADER_METADATA,
     name: 'LAS (laz-rs)',
     preload: async () => {
-        const { LAZRsLoaderWithParser } = await import('@loaders.gl/pointclouds/las/laz-rs-loader');
+        const { LAZRsLoaderWithParser } = await import('@loaders.gl/pointclouds/laz-rs-loader');
         return LAZRsLoaderWithParser;
     }
 };

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

@@ -1 +1 @@
-{"version":3,"file":"laz-rs-loader-types.js","sourceRoot":"","sources":["../../src/las/laz-rs-loader-types.ts"],"names":[],"mappings":"AAAA,aAAa;AACb,+BAA+B;AAC/B,oCAAoC;AAKpC,OAAO,EAAC,mBAAmB,EAAwB,+BAA4B;AAG/E;;GAEG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB,GAAG,mBAAmB;IACtB,IAAI,EAAE,cAAc;IACpB,OAAO,EAAE,KAAK,IAAI,EAAE;QAClB,MAAM,EAAC,qBAAqB,EAAC,GAAG,MAAM,MAAM,CAAC,2CAA2C,CAAC,CAAC;QAC1F,OAAO,qBAAqB,CAAC;IAC/B,CAAC;CAC8F,CAAC"}
+{"version":3,"file":"laz-rs-loader-types.js","sourceRoot":"","sources":["../../src/las/laz-rs-loader-types.ts"],"names":[],"mappings":"AAAA,aAAa;AACb,+BAA+B;AAC/B,oCAAoC;AAKpC,OAAO,EAAC,mBAAmB,EAAwB,+BAA4B;AAG/E;;GAEG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB,GAAG,mBAAmB;IACtB,IAAI,EAAE,cAAc;IACpB,OAAO,EAAE,KAAK,IAAI,EAAE;QAClB,MAAM,EAAC,qBAAqB,EAAC,GAAG,MAAM,MAAM,CAAC,uCAAuC,CAAC,CAAC;QACtF,OAAO,qBAAqB,CAAC;IAC/B,CAAC;CAC8F,CAAC"}

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

@@ -38,7 +38,7 @@ 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");
+    const { LAZPerfLoaderWithParser } = await import("@loaders.gl/pointclouds/lazperf-loader");
     return LAZPerfLoaderWithParser;
   }
 };

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

@@ -1,7 +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;",
+  "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/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,wCAAwC;AACvF,WAAO;AAAA,EACT;AACF;",
   "names": []
 }

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

@@ -10,7 +10,7 @@ export const LAZPerfLoader = {
     ...LAS_LOADER_METADATA,
     name: 'LAS (laz-perf)',
     preload: async () => {
-        const { LAZPerfLoaderWithParser } = await import('@loaders.gl/pointclouds/las/lazperf-loader');
+        const { LAZPerfLoaderWithParser } = await import('@loaders.gl/pointclouds/lazperf-loader');
         return LAZPerfLoaderWithParser;
     }
 };

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

@@ -1 +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"}
+{"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,wCAAwC,CAAC,CAAC;QACzF,OAAO,uBAAuB,CAAC;IACjC,CAAC;CAC8F,CAAC"}

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

@@ -0,0 +1,51 @@
+"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-copc-loader-types.ts
+var las_copc_loader_types_exports = {};
+__export(las_copc_loader_types_exports, {
+  LASCOPCLoader: () => LASCOPCLoader
+});
+module.exports = __toCommonJS(las_copc_loader_types_exports);
+
+// src/las/las-copc-loader-types.ts
+var import_las_loader_shared = require("./las-loader-shared.cjs");
+var LASCOPCLoader = {
+  ...import_las_loader_shared.LAS_LOADER_METADATA,
+  name: "LAS (COPC)",
+  preload: async () => {
+    const { LASCOPCLoaderWithParser } = await import("@loaders.gl/pointclouds/las-copc-loader");
+    return LASCOPCLoaderWithParser;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LASCOPCLoader
+});
+//# sourceMappingURL=las-copc-loader-types.cjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/las-copc-loader-types.ts", "../src/las/las-copc-loader-types.ts"],
+  "sourcesContent": ["export * from './las/las-copc-loader-types.js';\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\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/** Metadata-only LAS/LAZ loader variant using the COPC package decoder. */\nexport const LASCOPCLoader = {\n  ...LAS_LOADER_METADATA,\n  name: 'LAS (COPC)',\n  preload: async () => {\n    const {LASCOPCLoaderWithParser} = await import('@loaders.gl/pointclouds/las-copc-loader');\n    return LASCOPCLoaderWithParser;\n  }\n} as const satisfies Loader<LASMesh | MeshArrowTable, LASMesh | MeshArrowTable, LASLoaderOptions>;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACMA,+BAAyD;AAIlD,IAAM,gBAAgB;AAAA,EAC3B,GAAG;AAAA,EACH,MAAM;AAAA,EACN,SAAS,YAAY;AACnB,UAAM,EAAC,wBAAuB,IAAI,MAAM,OAAO,yCAAyC;AACxF,WAAO;AAAA,EACT;AACF;",
+  "names": []
+}

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

@@ -0,0 +1,2 @@
+export * from './las/las-copc-loader-types.js';
+//# sourceMappingURL=las-copc-loader-types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"las-copc-loader-types.d.ts","sourceRoot":"","sources":["../src/las-copc-loader-types.ts"],"names":[],"mappings":"AAAA,cAAc,gCAAgC,CAAC"}

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

@@ -0,0 +1,2 @@
+export * from './las/las-copc-loader-types.js';
+//# sourceMappingURL=las-copc-loader-types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"las-copc-loader-types.js","sourceRoot":"","sources":["../src/las-copc-loader-types.ts"],"names":[],"mappings":"AAAA,cAAc,gCAAgC,CAAC"}

package/dist/las-copc-loader.cjs

@@ -0,0 +1,59 @@
+"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-copc-loader.ts
+var las_copc_loader_exports = {};
+__export(las_copc_loader_exports, {
+  LASCOPCLoaderWithParser: () => LASCOPCLoaderWithParser
+});
+module.exports = __toCommonJS(las_copc_loader_exports);
+
+// src/las/las-copc-loader.ts
+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/copc/parse-las.cjs");
+var LASCOPCLoaderWithParser = {
+  ...import_las_loader_shared.LAS_LOADER_METADATA,
+  name: "LAS (COPC)",
+  parse: async (arrayBuffer, options) => convertLASMesh(await (0, import_parse_las.parseCOPCLAS)(arrayBuffer, options), options),
+  parseInBatches: (arrayBufferIterator, options) => convertLASMeshBatches((0, import_parse_las.parseCOPCLASInBatches)(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 = {
+  LASCOPCLoaderWithParser
+});
+//# sourceMappingURL=las-copc-loader.cjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/las-copc-loader.ts", "../src/las/las-copc-loader.ts"],
+  "sourcesContent": ["export * from './las/las-copc-loader.js';\n", "// 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 {parseCOPCLAS, parseCOPCLASInBatches} from './lib/copc/parse-las';\n\n/**\n * LAS/LAZ loader variant using the laz-perf decoder from the COPC package.\n */\nexport const LASCOPCLoaderWithParser = {\n  ...LAS_LOADER_METADATA,\n  name: 'LAS (COPC)',\n  parse: async (arrayBuffer: ArrayBuffer, options?: LASLoaderOptions) =>\n    convertLASMesh(await parseCOPCLAS(arrayBuffer, options), options),\n  parseInBatches: (arrayBufferIterator, options?: LASLoaderOptions) =>\n    convertLASMeshBatches(parseCOPCLASInBatches(arrayBufferIterator, options), options)\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;;;ACOA,0BAAqD;AACrD,+BAKO;AAEP,uBAAkD;AAK3C,IAAM,0BAA0B;AAAA,EACrC,GAAG;AAAA,EACH,MAAM;AAAA,EACN,OAAO,OAAO,aAA0B,YACtC,eAAe,UAAM,+BAAa,aAAa,OAAO,GAAG,OAAO;AAAA,EAClE,gBAAgB,CAAC,qBAAqB,YACpC,0BAAsB,wCAAsB,qBAAqB,OAAO,GAAG,OAAO;AACtF;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-copc-loader.d.ts

@@ -0,0 +1,2 @@
+export * from './las/las-copc-loader.js';
+//# sourceMappingURL=las-copc-loader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"las-copc-loader.d.ts","sourceRoot":"","sources":["../src/las-copc-loader.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC"}

package/dist/las-copc-loader.js

@@ -0,0 +1,2 @@
+export * from './las/las-copc-loader.js';
+//# sourceMappingURL=las-copc-loader.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"las-copc-loader.js","sourceRoot":"","sources":["../src/las-copc-loader.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC"}

package/dist/las-loader-types.cjs

@@ -0,0 +1,56 @@
+"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-loader-types.ts
+var las_loader_types_exports = {};
+__export(las_loader_types_exports, {
+  LASLoader: () => LASLoader,
+  LASWorkerLoader: () => LASWorkerLoader
+});
+module.exports = __toCommonJS(las_loader_types_exports);
+
+// src/las/las-loader-types.ts
+var import_las_loader_shared = require("./las-loader-shared.cjs");
+async function preload() {
+  const { LASLoaderWithParser } = await import("@loaders.gl/pointclouds/las-loader");
+  return LASLoaderWithParser;
+}
+var LASLoader = {
+  ...import_las_loader_shared.LAS_LOADER_METADATA,
+  worker: true,
+  workerInBatches: true,
+  preload
+};
+var LASWorkerLoader = LASLoader;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LASLoader,
+  LASWorkerLoader
+});
+//# sourceMappingURL=las-loader-types.cjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/las-loader-types.ts", "../src/las/las-loader-types.ts"],
+  "sourcesContent": ["export * from './las/las-loader-types.js';\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport type {Loader} from '@loaders.gl/core/loader-utils';\nimport type {MeshArrowTable} from '@loaders.gl/core/schema';\nimport type {LASMesh} from './lib/las-types';\nimport {LAS_LOADER_METADATA, type LASLoaderOptions} from './las-loader-shared';\n\nexport type {LASColumnName, LASLoaderOptions} from './las-loader-shared';\n\n/** Preloads the parser-bearing primary TypeScript LAS loader implementation. */\nasync function preload() {\n  const {LASLoaderWithParser} = await import('@loaders.gl/pointclouds/las-loader');\n  return LASLoaderWithParser;\n}\n\n/** Metadata-only loader for the LAS (LASer) point cloud format. */\nexport const LASLoader = {\n  ...LAS_LOADER_METADATA,\n  worker: true,\n  workerInBatches: true,\n  preload\n} as const satisfies Loader<LASMesh | MeshArrowTable, LASMesh | MeshArrowTable, LASLoaderOptions>;\n\n/** @deprecated Use LASLoader. */\nexport const LASWorkerLoader = LASLoader;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACOA,+BAAyD;AAKzD,eAAe,UAAU;AACvB,QAAM,EAAC,oBAAmB,IAAI,MAAM,OAAO,oCAAoC;AAC/E,SAAO;AACT;AAGO,IAAM,YAAY;AAAA,EACvB,GAAG;AAAA,EACH,QAAQ;AAAA,EACR,iBAAiB;AAAA,EACjB;AACF;AAGO,IAAM,kBAAkB;",
+  "names": []
+}

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

@@ -0,0 +1,2 @@
+export * from './las/las-loader-types.js';
+//# sourceMappingURL=las-loader-types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"las-loader-types.d.ts","sourceRoot":"","sources":["../src/las-loader-types.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC"}

package/dist/las-loader-types.js

@@ -0,0 +1,2 @@
+export * from './las/las-loader-types.js';
+//# sourceMappingURL=las-loader-types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"las-loader-types.js","sourceRoot":"","sources":["../src/las-loader-types.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC"}

package/dist/las-loader.cjs

@@ -0,0 +1,82 @@
+"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-loader.ts
+var las_loader_exports = {};
+__export(las_loader_exports, {
+  LASLoaderWithParser: () => LASLoaderWithParser
+});
+module.exports = __toCommonJS(las_loader_exports);
+
+// src/las/las-loader.ts
+var import_schema_utils = require("@loaders.gl/core/schema-utils");
+var import_las_loader_shared = require("./las-loader-shared.cjs");
+var import_arrow_transport = require("@loaders.gl/core/schema-utils/arrow-transport");
+var import_parse_las = require("./lib/typescript/parse-las.cjs");
+var LASLoaderWithParser = {
+  ...import_las_loader_shared.LAS_LOADER_METADATA,
+  worker: true,
+  workerInBatches: true,
+  serializeWorkerResult: import_arrow_transport.serializeArrowWorkerTable,
+  serializeWorkerBatch: import_arrow_transport.serializeArrowWorkerTable,
+  deserializeWorkerResult: deserializeLASWorkerTable,
+  deserializeWorkerBatch: deserializeLASWorkerTable,
+  parse: async (arrayBuffer, options) => convertLASMesh(parseLASTable(arrayBuffer, options), options),
+  parseSync: (arrayBuffer, options) => convertLASMesh(parseLASTable(arrayBuffer, options), options),
+  parseInBatches: async function* (arrayBufferIterator, options) {
+    yield* convertLASMeshBatches((0, import_parse_las.parseLASInBatches)(arrayBufferIterator, options), options);
+  }
+};
+function parseLASTable(arrayBuffer, options) {
+  const chunkRequest = options?.las?._chunk;
+  return chunkRequest ? (0, import_parse_las.decodeLAZChunkToArrowTable)(arrayBuffer, chunkRequest.metadata, options || {}) : (0, import_parse_las.parseLAS)(arrayBuffer, options);
+}
+function convertLASMesh(table, options) {
+  const formattedTable = options?.las?.colorFormat === void 0 || options.las.colorFormat === "uint8norm" ? table : {
+    ...(0, import_schema_utils.convertMeshToTable)(
+      (0, import_las_loader_shared.formatLASMeshColors)((0, import_schema_utils.convertTableToMesh)(table), options.las.colorFormat),
+      "arrow-table"
+    ),
+    loader: table.loader,
+    loaderData: table.loaderData,
+    progress: table.progress
+  };
+  if ((0, import_las_loader_shared.getLASShape)(options) === "arrow-table") {
+    return formattedTable;
+  }
+  return {
+    ...(0, import_schema_utils.convertTableToMesh)(formattedTable),
+    loader: formattedTable.loader,
+    loaderData: formattedTable.loaderData,
+    progress: formattedTable.progress
+  };
+}
+async function* convertLASMeshBatches(tableBatches, options) {
+  for await (const table of tableBatches) {
+    yield convertLASMesh(table, options);
+  }
+}
+function deserializeLASWorkerTable(result, options) {
+  return convertLASMesh((0, import_arrow_transport.deserializeArrowWorkerTable)(result), options);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LASLoaderWithParser
+});
+//# sourceMappingURL=las-loader.cjs.map

package/dist/las-loader.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/las-loader.ts", "../src/las/las-loader.ts"],
+  "sourcesContent": ["export * from './las/las-loader.js';\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\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 {\n  serializeArrowWorkerTable,\n  deserializeArrowWorkerTable\n} from '@loaders.gl/core/schema-utils/arrow-transport';\nimport type {LASMesh} from './lib/las-types';\nimport {\n  decodeLAZChunkToArrowTable,\n  parseLAS,\n  parseLASInBatches,\n  type LASArrowTable,\n  type LAZChunkArrowTableMetadata\n} from './lib/typescript/parse-las';\n\ntype LASWorkerChunkRequest = {\n  metadata: LAZChunkArrowTableMetadata;\n};\n\ntype LASWorkerOptions = LASLoaderOptions & {\n  las?: LASLoaderOptions['las'] & {\n    _chunk?: LASWorkerChunkRequest;\n  };\n};\n\n/** Parser-bearing TypeScript-only LAS loader implementation. */\nexport const LASLoaderWithParser = {\n  ...LAS_LOADER_METADATA,\n  worker: true,\n  workerInBatches: true,\n  serializeWorkerResult: serializeArrowWorkerTable,\n  serializeWorkerBatch: serializeArrowWorkerTable,\n  deserializeWorkerResult: deserializeLASWorkerTable,\n  deserializeWorkerBatch: deserializeLASWorkerTable,\n  parse: async (arrayBuffer: ArrayBuffer, options?: LASLoaderOptions) =>\n    convertLASMesh(parseLASTable(arrayBuffer, options), options),\n  parseSync: (arrayBuffer: ArrayBuffer, options?: LASLoaderOptions) =>\n    convertLASMesh(parseLASTable(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\n/** Parse a complete LAS file or an internal standalone worker chunk request. */\nfunction parseLASTable(arrayBuffer: ArrayBuffer, options?: LASLoaderOptions): LASArrowTable {\n  const chunkRequest = (options as LASWorkerOptions | undefined)?.las?._chunk;\n  return chunkRequest\n    ? decodeLAZChunkToArrowTable(arrayBuffer, chunkRequest.metadata, options || {})\n    : parseLAS(arrayBuffer, options);\n}\n\nfunction convertLASMesh(\n  table: LASArrowTable,\n  options?: LASLoaderOptions\n): LASMesh | MeshArrowTable {\n  const formattedTable =\n    options?.las?.colorFormat === undefined || options.las.colorFormat === 'uint8norm'\n      ? table\n      : {\n          ...convertMeshToTable(\n            formatLASMeshColors(convertTableToMesh(table) as LASMesh, options.las.colorFormat),\n            'arrow-table'\n          ),\n          loader: table.loader,\n          loaderData: table.loaderData,\n          progress: table.progress\n        };\n  if (getLASShape(options) === 'arrow-table') {\n    return formattedTable;\n  }\n  return {\n    ...(convertTableToMesh(formattedTable) as LASMesh),\n    loader: formattedTable.loader,\n    loaderData: formattedTable.loaderData,\n    progress: formattedTable.progress\n  } as LASMesh & {progress?: number};\n}\n\nasync function* convertLASMeshBatches(\n  tableBatches: AsyncIterable<LASArrowTable>,\n  options?: LASLoaderOptions\n): AsyncIterable<LASMesh | MeshArrowTable> {\n  for await (const table of tableBatches) {\n    yield convertLASMesh(table, options);\n  }\n}\n\n/** Hydrates transferred columns and applies the requested mesh and color representation on the caller. */\nfunction deserializeLASWorkerTable(\n  result: unknown,\n  options?: LASLoaderOptions\n): LASMesh | MeshArrowTable {\n  return convertLASMesh(deserializeArrowWorkerTable(result), options);\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACMA,0BAAqD;AACrD,+BAKO;AACP,6BAGO;AAEP,uBAMO;AAaA,IAAM,sBAAsB;AAAA,EACjC,GAAG;AAAA,EACH,QAAQ;AAAA,EACR,iBAAiB;AAAA,EACjB,uBAAuB;AAAA,EACvB,sBAAsB;AAAA,EACtB,yBAAyB;AAAA,EACzB,wBAAwB;AAAA,EACxB,OAAO,OAAO,aAA0B,YACtC,eAAe,cAAc,aAAa,OAAO,GAAG,OAAO;AAAA,EAC7D,WAAW,CAAC,aAA0B,YACpC,eAAe,cAAc,aAAa,OAAO,GAAG,OAAO;AAAA,EAC7D,gBAAgB,iBAAiB,qBAAqB,SAA4B;AAChF,WAAO,0BAAsB,oCAAkB,qBAAqB,OAAO,GAAG,OAAO;AAAA,EACvF;AACF;AAOA,SAAS,cAAc,aAA0B,SAA2C;AAC1F,QAAM,eAAgB,SAA0C,KAAK;AACrE,SAAO,mBACH,6CAA2B,aAAa,aAAa,UAAU,WAAW,CAAC,CAAC,QAC5E,2BAAS,aAAa,OAAO;AACnC;AAEA,SAAS,eACP,OACA,SAC0B;AAC1B,QAAM,iBACJ,SAAS,KAAK,gBAAgB,UAAa,QAAQ,IAAI,gBAAgB,cACnE,QACA;AAAA,IACE,OAAG;AAAA,UACD,kDAAoB,wCAAmB,KAAK,GAAc,QAAQ,IAAI,WAAW;AAAA,MACjF;AAAA,IACF;AAAA,IACA,QAAQ,MAAM;AAAA,IACd,YAAY,MAAM;AAAA,IAClB,UAAU,MAAM;AAAA,EAClB;AACN,UAAI,sCAAY,OAAO,MAAM,eAAe;AAC1C,WAAO;AAAA,EACT;AACA,SAAO;AAAA,IACL,OAAI,wCAAmB,cAAc;AAAA,IACrC,QAAQ,eAAe;AAAA,IACvB,YAAY,eAAe;AAAA,IAC3B,UAAU,eAAe;AAAA,EAC3B;AACF;AAEA,gBAAgB,sBACd,cACA,SACyC;AACzC,mBAAiB,SAAS,cAAc;AACtC,UAAM,eAAe,OAAO,OAAO;AAAA,EACrC;AACF;AAGA,SAAS,0BACP,QACA,SAC0B;AAC1B,SAAO,mBAAe,oDAA4B,MAAM,GAAG,OAAO;AACpE;",
+  "names": []
+}

package/dist/las-loader.d.ts

@@ -0,0 +1,2 @@
+export * from './las/las-loader.js';
+//# sourceMappingURL=las-loader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"las-loader.d.ts","sourceRoot":"","sources":["../src/las-loader.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC"}

package/dist/las-loader.js

@@ -0,0 +1,2 @@
+export * from './las/las-loader.js';
+//# sourceMappingURL=las-loader.js.map

package/dist/las-loader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"las-loader.js","sourceRoot":"","sources":["../src/las-loader.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC"}