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

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

@@ -0,0 +1,40 @@
+// 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 { parseCOPCLAS, parseCOPCLASInBatches } from "./lib/copc/parse-las.js";
+/**
+ * LAS/LAZ loader variant using the laz-perf decoder from the COPC package.
+ */
+export const LASCOPCLoaderWithParser = {
+    ...LAS_LOADER_METADATA,
+    name: 'LAS (COPC)',
+    parse: async (arrayBuffer, options) => convertLASMesh(await parseCOPCLAS(arrayBuffer, options), options),
+    parseInBatches: (arrayBufferIterator, options) => convertLASMeshBatches(parseCOPCLASInBatches(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=las-copc-loader.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"las-copc-loader.js","sourceRoot":"","sources":["../../src/las/las-copc-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,YAAY,EAAE,qBAAqB,EAAC,gCAA6B;AAEzE;;GAEG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG;IACrC,GAAG,mBAAmB;IACtB,IAAI,EAAE,YAAY;IAClB,KAAK,EAAE,KAAK,EAAE,WAAwB,EAAE,OAA0B,EAAE,EAAE,CACpE,cAAc,CAAC,MAAM,YAAY,CAAC,WAAW,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC;IACnE,cAAc,EAAE,CAAC,mBAAmB,EAAE,OAA0B,EAAE,EAAE,CAClE,qBAAqB,CAAC,qBAAqB,CAAC,mBAAmB,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC;CAKtF,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/las-format.cjs

@@ -0,0 +1,44 @@
+"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/las-format.ts
+var las_format_exports = {};
+__export(las_format_exports, {
+  LASFormat: () => LASFormat
+});
+module.exports = __toCommonJS(las_format_exports);
+var LASFormat = {
+  name: "LAS",
+  id: "las",
+  module: "pointclouds",
+  encoding: "binary",
+  format: "las",
+  extensions: ["las", "laz"],
+  // LAZ is the "compressed" flavor of LAS,
+  mimeTypes: ["application/octet-stream"],
+  // TODO - text version?
+  text: false,
+  binary: true,
+  tests: ["LASF"]
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LASFormat
+});
+//# sourceMappingURL=las-format.cjs.map

package/dist/las/las-format.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/las/las-format.ts"],
+  "sourcesContent": ["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport type {Format} from '@loaders.gl/core/loader-utils';\n\n/**\n * LAS (LASer) point cloud format\n */\nexport const LASFormat = {\n  name: 'LAS',\n  id: 'las',\n  module: 'pointclouds',\n  encoding: 'binary',\n  format: 'las',\n  extensions: ['las', 'laz'], // LAZ is the \"compressed\" flavor of LAS,\n  mimeTypes: ['application/octet-stream'], // TODO - text version?\n  text: false,\n  binary: true,\n  tests: ['LASF']\n} as const satisfies Format;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AASO,IAAM,YAAY;AAAA,EACvB,MAAM;AAAA,EACN,IAAI;AAAA,EACJ,QAAQ;AAAA,EACR,UAAU;AAAA,EACV,QAAQ;AAAA,EACR,YAAY,CAAC,OAAO,KAAK;AAAA;AAAA,EACzB,WAAW,CAAC,0BAA0B;AAAA;AAAA,EACtC,MAAM;AAAA,EACN,QAAQ;AAAA,EACR,OAAO,CAAC,MAAM;AAChB;",
+  "names": []
+}

package/dist/las/las-format.d.ts

@@ -0,0 +1,16 @@
+/**
+ * LAS (LASer) point cloud format
+ */
+export declare const LASFormat: {
+    readonly name: "LAS";
+    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=las-format.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"las-format.d.ts","sourceRoot":"","sources":["../../src/las/las-format.ts"],"names":[],"mappings":"AAMA;;GAEG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;CAWK,CAAC"}

package/dist/las/las-format.js

@@ -0,0 +1,19 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+/**
+ * LAS (LASer) point cloud format
+ */
+export const LASFormat = {
+    name: 'LAS',
+    id: 'las',
+    module: 'pointclouds',
+    encoding: 'binary',
+    format: 'las',
+    extensions: ['las', 'laz'], // LAZ is the "compressed" flavor of LAS,
+    mimeTypes: ['application/octet-stream'], // TODO - text version?
+    text: false,
+    binary: true,
+    tests: ['LASF']
+};
+//# sourceMappingURL=las-format.js.map

package/dist/las/las-format.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"las-format.js","sourceRoot":"","sources":["../../src/las/las-format.ts"],"names":[],"mappings":"AAAA,aAAa;AACb,+BAA+B;AAC/B,oCAAoC;AAIpC;;GAEG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,IAAI,EAAE,KAAK;IACX,EAAE,EAAE,KAAK;IACT,MAAM,EAAE,aAAa;IACrB,QAAQ,EAAE,QAAQ;IAClB,MAAM,EAAE,KAAK;IACb,UAAU,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,yCAAyC;IACrE,SAAS,EAAE,CAAC,0BAA0B,CAAC,EAAE,uBAAuB;IAChE,IAAI,EAAE,KAAK;IACX,MAAM,EAAE,IAAI;IACZ,KAAK,EAAE,CAAC,MAAM,CAAC;CACU,CAAC"}

package/dist/las/las-loader-shared.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/las-loader-shared.ts
+var las_loader_shared_exports = {};
+__export(las_loader_shared_exports, {
+  DEFAULT_LAS_SHAPE: () => DEFAULT_LAS_SHAPE,
+  LAS_LOADER_METADATA: () => LAS_LOADER_METADATA,
+  formatLASMeshColors: () => formatLASMeshColors,
+  getLASShape: () => getLASShape
+});
+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 DEFAULT_LAS_SHAPE = "arrow-table";
+function getLASShape(options) {
+  return options?.las?.shape || DEFAULT_LAS_SHAPE;
+}
+var LAS_LOADER_METADATA = {
+  ...import_las_format.LASFormat,
+  dataType: null,
+  batchType: null,
+  version: VERSION,
+  worker: false,
+  options: {
+    las: {
+      shape: DEFAULT_LAS_SHAPE,
+      fp64: false,
+      colorDepth: 8,
+      colorFormat: "uint8norm",
+      columns: void 0,
+      extraBytes: "raw",
+      recoverMissingChunkTable: false,
+      compatibilityMode: "auto"
+    }
+  }
+};
+function formatLASMeshColors(mesh, colorFormat) {
+  if (colorFormat === "uint8norm" || !mesh.attributes.COLOR_0) {
+    return mesh;
+  }
+  const colorAttribute = mesh.attributes.COLOR_0;
+  const sourceScale = colorAttribute.value instanceof Uint16Array ? 65535 : 255;
+  const value = colorFormat === "float16" ? (0, import_schema.convertColorArrayToFloat16)(colorAttribute.value, sourceScale) : (0, import_schema.convertColorArrayToFloat32)(colorAttribute.value, sourceScale);
+  const attributes = { ...mesh.attributes };
+  for (const [attributeName, attribute] of Object.entries(attributes)) {
+    if (attribute.value === colorAttribute.value) {
+      attributes[attributeName] = {
+        ...attribute,
+        value,
+        normalized: false,
+        ...colorFormat === "float16" ? { componentType: "float16" } : {}
+      };
+    }
+  }
+  return { ...mesh, attributes };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_LAS_SHAPE,
+  LAS_LOADER_METADATA,
+  formatLASMeshColors,
+  getLASShape
+});
+//# sourceMappingURL=las-loader-shared.cjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/las/las-loader-shared.ts"],
+  "sourcesContent": ["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport type {Loader, LoaderOptions} from '@loaders.gl/core/loader-utils';\nimport {convertColorArrayToFloat16, convertColorArrayToFloat32} from '@loaders.gl/core/schema';\nimport type {MeshArrowTable} from '@loaders.gl/core/schema';\nimport {LASFormat} from './las-format';\nimport type {LASMesh} from './lib/las-types';\n\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n\n/** Arrow column names that can be selected from LAS point records. */\nexport type LASColumnName =\n  | 'POSITION'\n  | 'intensity'\n  | 'classification'\n  | 'synthetic'\n  | 'keyPoint'\n  | 'withheld'\n  | 'overlap'\n  | 'COLOR_0'\n  | 'GPS_TIME'\n  | 'NIR'\n  | 'scanAngle'\n  | 'userData'\n  | 'pointSourceId'\n  | 'returnNumber'\n  | 'numberOfReturns'\n  | 'scannerChannel'\n  | 'scanDirectionFlag'\n  | 'edgeOfFlightLine'\n  | 'WAVEFORM'\n  | 'EXTRA_BYTES';\n\n/** Options accepted by LAS loader implementations. */\nexport type LASLoaderOptions = LoaderOptions & {\n  las?: {\n    /** Output representation. */\n    shape?: 'mesh' | 'columnar-table' | 'arrow-table';\n    /** Store positions in 64-bit floating point arrays. */\n    fp64?: boolean;\n    /** Output color depth or automatic source-depth detection. */\n    colorDepth?: number | string;\n    /** Color storage format. Defaults to uint8norm for backwards compatibility. */\n    colorFormat?: 'uint8norm' | 'float16' | 'float32';\n    /** Arrow columns to decode. POSITION is always included. */\n    columns?: readonly LASColumnName[];\n    /** Decode Extra Bytes descriptors into typed attributes instead of raw bytes. */\n    extraBytes?: 'raw' | 'typed';\n    /** Recover fixed-size LAZ chunks when the LASzip pointer marks an interrupted writer. */\n    recoverMissingChunkTable?: boolean;\n    /** Restore modern fields in LASzip compatibility-mode files, or retain their legacy columns. */\n    compatibilityMode?: 'auto' | 'raw';\n    /** Override the URL to the worker bundle. */\n    workerUrl?: string;\n  };\n  /** Called as point data is decoded on the main thread. */\n  onProgress?: Function;\n};\n\n/** Default output shape for LAS and LAZ loaders. */\nexport const DEFAULT_LAS_SHAPE = 'arrow-table' as const;\n\n/** Resolve the LAS output shape, including the Arrow-primary default. */\nexport function getLASShape(options?: LASLoaderOptions): 'mesh' | 'columnar-table' | 'arrow-table' {\n  return options?.las?.shape || DEFAULT_LAS_SHAPE;\n}\n\n/** Parser-independent LAS loader metadata shared by each loader variant. */\nexport const LAS_LOADER_METADATA = {\n  ...LASFormat,\n\n  dataType: null as unknown as LASMesh | MeshArrowTable,\n  batchType: null as unknown as LASMesh | MeshArrowTable,\n\n  version: VERSION,\n  worker: false,\n  options: {\n    las: {\n      shape: DEFAULT_LAS_SHAPE,\n      fp64: false,\n      colorDepth: 8,\n      colorFormat: 'uint8norm',\n      columns: undefined,\n      extraBytes: 'raw',\n      recoverMissingChunkTable: false,\n      compatibilityMode: 'auto'\n    }\n  }\n} as const satisfies Loader<LASMesh | MeshArrowTable, LASMesh | MeshArrowTable, LASLoaderOptions>;\n\n/** Apply the requested normalized color representation to a decoded LAS mesh. */\nexport function formatLASMeshColors(\n  mesh: LASMesh,\n  colorFormat: 'uint8norm' | 'float16' | 'float32'\n): LASMesh {\n  if (colorFormat === 'uint8norm' || !mesh.attributes.COLOR_0) {\n    return mesh;\n  }\n\n  const colorAttribute = mesh.attributes.COLOR_0;\n  const sourceScale = colorAttribute.value instanceof Uint16Array ? 65535 : 255;\n  const value =\n    colorFormat === 'float16'\n      ? convertColorArrayToFloat16(colorAttribute.value, sourceScale)\n      : convertColorArrayToFloat32(colorAttribute.value, sourceScale);\n  const attributes = {...mesh.attributes};\n\n  for (const [attributeName, attribute] of Object.entries(attributes)) {\n    if (attribute.value === colorAttribute.value) {\n      attributes[attributeName] = {\n        ...attribute,\n        value,\n        normalized: false,\n        ...(colorFormat === 'float16' ? {componentType: 'float16' as const} : {})\n      };\n    }\n  }\n\n  return {...mesh, attributes};\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAKA,oBAAqE;AAErE,wBAAwB;AAKxB,IAAM,UAAU,OAAqC,iBAAc;AAoD5D,IAAM,oBAAoB;AAG1B,SAAS,YAAY,SAAuE;AACjG,SAAO,SAAS,KAAK,SAAS;AAChC;AAGO,IAAM,sBAAsB;AAAA,EACjC,GAAG;AAAA,EAEH,UAAU;AAAA,EACV,WAAW;AAAA,EAEX,SAAS;AAAA,EACT,QAAQ;AAAA,EACR,SAAS;AAAA,IACP,KAAK;AAAA,MACH,OAAO;AAAA,MACP,MAAM;AAAA,MACN,YAAY;AAAA,MACZ,aAAa;AAAA,MACb,SAAS;AAAA,MACT,YAAY;AAAA,MACZ,0BAA0B;AAAA,MAC1B,mBAAmB;AAAA,IACrB;AAAA,EACF;AACF;AAGO,SAAS,oBACd,MACA,aACS;AACT,MAAI,gBAAgB,eAAe,CAAC,KAAK,WAAW,SAAS;AAC3D,WAAO;AAAA,EACT;AAEA,QAAM,iBAAiB,KAAK,WAAW;AACvC,QAAM,cAAc,eAAe,iBAAiB,cAAc,QAAQ;AAC1E,QAAM,QACJ,gBAAgB,gBACZ,0CAA2B,eAAe,OAAO,WAAW,QAC5D,0CAA2B,eAAe,OAAO,WAAW;AAClE,QAAM,aAAa,EAAC,GAAG,KAAK,WAAU;AAEtC,aAAW,CAAC,eAAe,SAAS,KAAK,OAAO,QAAQ,UAAU,GAAG;AACnE,QAAI,UAAU,UAAU,eAAe,OAAO;AAC5C,iBAAW,aAAa,IAAI;AAAA,QAC1B,GAAG;AAAA,QACH;AAAA,QACA,YAAY;AAAA,QACZ,GAAI,gBAAgB,YAAY,EAAC,eAAe,UAAkB,IAAI,CAAC;AAAA,MACzE;AAAA,IACF;AAAA,EACF;AAEA,SAAO,EAAC,GAAG,MAAM,WAAU;AAC7B;",
+  "names": []
+}

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

@@ -0,0 +1,66 @@
+import type { LoaderOptions } from '@loaders.gl/core/loader-utils';
+import type { MeshArrowTable } from '@loaders.gl/core/schema';
+import type { LASMesh } from "./lib/las-types.js";
+/** Arrow column names that can be selected from LAS point records. */
+export type LASColumnName = 'POSITION' | 'intensity' | 'classification' | 'synthetic' | 'keyPoint' | 'withheld' | 'overlap' | 'COLOR_0' | 'GPS_TIME' | 'NIR' | 'scanAngle' | 'userData' | 'pointSourceId' | 'returnNumber' | 'numberOfReturns' | 'scannerChannel' | 'scanDirectionFlag' | 'edgeOfFlightLine' | 'WAVEFORM' | 'EXTRA_BYTES';
+/** Options accepted by LAS loader implementations. */
+export type LASLoaderOptions = LoaderOptions & {
+    las?: {
+        /** Output representation. */
+        shape?: 'mesh' | 'columnar-table' | 'arrow-table';
+        /** Store positions in 64-bit floating point arrays. */
+        fp64?: boolean;
+        /** Output color depth or automatic source-depth detection. */
+        colorDepth?: number | string;
+        /** Color storage format. Defaults to uint8norm for backwards compatibility. */
+        colorFormat?: 'uint8norm' | 'float16' | 'float32';
+        /** Arrow columns to decode. POSITION is always included. */
+        columns?: readonly LASColumnName[];
+        /** Decode Extra Bytes descriptors into typed attributes instead of raw bytes. */
+        extraBytes?: 'raw' | 'typed';
+        /** Recover fixed-size LAZ chunks when the LASzip pointer marks an interrupted writer. */
+        recoverMissingChunkTable?: boolean;
+        /** Restore modern fields in LASzip compatibility-mode files, or retain their legacy columns. */
+        compatibilityMode?: 'auto' | 'raw';
+        /** Override the URL to the worker bundle. */
+        workerUrl?: string;
+    };
+    /** Called as point data is decoded on the main thread. */
+    onProgress?: Function;
+};
+/** Default output shape for LAS and LAZ loaders. */
+export declare const DEFAULT_LAS_SHAPE: "arrow-table";
+/** Resolve the LAS output shape, including the Arrow-primary default. */
+export declare function getLASShape(options?: LASLoaderOptions): 'mesh' | 'columnar-table' | 'arrow-table';
+/** Parser-independent LAS loader metadata shared by each loader variant. */
+export declare const LAS_LOADER_METADATA: {
+    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 name: "LAS";
+    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"];
+};
+/** Apply the requested normalized color representation to a decoded LAS mesh. */
+export declare function formatLASMeshColors(mesh: LASMesh, colorFormat: 'uint8norm' | 'float16' | 'float32'): LASMesh;
+//# sourceMappingURL=las-loader-shared.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"las-loader-shared.d.ts","sourceRoot":"","sources":["../../src/las/las-loader-shared.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAS,aAAa,EAAC,MAAM,+BAA+B,CAAC;AAEzE,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,yBAAyB,CAAC;AAE5D,OAAO,KAAK,EAAC,OAAO,EAAC,2BAAwB;AAM7C,sEAAsE;AACtE,MAAM,MAAM,aAAa,GACrB,UAAU,GACV,WAAW,GACX,gBAAgB,GAChB,WAAW,GACX,UAAU,GACV,UAAU,GACV,SAAS,GACT,SAAS,GACT,UAAU,GACV,KAAK,GACL,WAAW,GACX,UAAU,GACV,eAAe,GACf,cAAc,GACd,iBAAiB,GACjB,gBAAgB,GAChB,mBAAmB,GACnB,kBAAkB,GAClB,UAAU,GACV,aAAa,CAAC;AAElB,sDAAsD;AACtD,MAAM,MAAM,gBAAgB,GAAG,aAAa,GAAG;IAC7C,GAAG,CAAC,EAAE;QACJ,6BAA6B;QAC7B,KAAK,CAAC,EAAE,MAAM,GAAG,gBAAgB,GAAG,aAAa,CAAC;QAClD,uDAAuD;QACvD,IAAI,CAAC,EAAE,OAAO,CAAC;QACf,8DAA8D;QAC9D,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;QAC7B,+EAA+E;QAC/E,WAAW,CAAC,EAAE,WAAW,GAAG,SAAS,GAAG,SAAS,CAAC;QAClD,4DAA4D;QAC5D,OAAO,CAAC,EAAE,SAAS,aAAa,EAAE,CAAC;QACnC,iFAAiF;QACjF,UAAU,CAAC,EAAE,KAAK,GAAG,OAAO,CAAC;QAC7B,yFAAyF;QACzF,wBAAwB,CAAC,EAAE,OAAO,CAAC;QACnC,gGAAgG;QAChG,iBAAiB,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;QACnC,6CAA6C;QAC7C,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB,CAAC;IACF,0DAA0D;IAC1D,UAAU,CAAC,EAAE,QAAQ,CAAC;CACvB,CAAC;AAEF,oDAAoD;AACpD,eAAO,MAAM,iBAAiB,EAAG,aAAsB,CAAC;AAExD,yEAAyE;AACzE,wBAAgB,WAAW,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,MAAM,GAAG,gBAAgB,GAAG,aAAa,CAEjG;AAED,4EAA4E;AAC5E,eAAO,MAAM,mBAAmB;uBAGD,OAAO,GAAG,cAAc;wBACvB,OAAO,GAAG,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;CAgByC,CAAC;AAElG,iFAAiF;AACjF,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,OAAO,EACb,WAAW,EAAE,WAAW,GAAG,SAAS,GAAG,SAAS,GAC/C,OAAO,CAyBT"}

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

@@ -0,0 +1,58 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { convertColorArrayToFloat16, convertColorArrayToFloat32 } 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';
+/** 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. */
+export function getLASShape(options) {
+    return options?.las?.shape || DEFAULT_LAS_SHAPE;
+}
+/** Parser-independent LAS loader metadata shared by each loader variant. */
+export const LAS_LOADER_METADATA = {
+    ...LASFormat,
+    dataType: null,
+    batchType: null,
+    version: VERSION,
+    worker: false,
+    options: {
+        las: {
+            shape: DEFAULT_LAS_SHAPE,
+            fp64: false,
+            colorDepth: 8,
+            colorFormat: 'uint8norm',
+            columns: undefined,
+            extraBytes: 'raw',
+            recoverMissingChunkTable: false,
+            compatibilityMode: 'auto'
+        }
+    }
+};
+/** Apply the requested normalized color representation to a decoded LAS mesh. */
+export function formatLASMeshColors(mesh, colorFormat) {
+    if (colorFormat === 'uint8norm' || !mesh.attributes.COLOR_0) {
+        return mesh;
+    }
+    const colorAttribute = mesh.attributes.COLOR_0;
+    const sourceScale = colorAttribute.value instanceof Uint16Array ? 65535 : 255;
+    const value = colorFormat === 'float16'
+        ? convertColorArrayToFloat16(colorAttribute.value, sourceScale)
+        : convertColorArrayToFloat32(colorAttribute.value, sourceScale);
+    const attributes = { ...mesh.attributes };
+    for (const [attributeName, attribute] of Object.entries(attributes)) {
+        if (attribute.value === colorAttribute.value) {
+            attributes[attributeName] = {
+                ...attribute,
+                value,
+                normalized: false,
+                ...(colorFormat === 'float16' ? { componentType: 'float16' } : {})
+            };
+        }
+    }
+    return { ...mesh, attributes };
+}
+//# sourceMappingURL=las-loader-shared.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"las-loader-shared.js","sourceRoot":"","sources":["../../src/las/las-loader-shared.ts"],"names":[],"mappings":"AAAA,aAAa;AACb,+BAA+B;AAC/B,oCAAoC;AAGpC,OAAO,EAAC,0BAA0B,EAAE,0BAA0B,EAAC,MAAM,yBAAyB,CAAC;AAE/F,OAAO,EAAC,SAAS,EAAC,wBAAqB;AAGvC,yDAAyD;AACzD,qDAAqD;AACrD,MAAM,OAAO,GAAG,qBAAkB,KAAK,WAAW,CAAC,CAAC,gBAAa,CAAC,CAAC,QAAQ,CAAC;AAmD5E,oDAAoD;AACpD,MAAM,CAAC,MAAM,iBAAiB,GAAG,aAAsB,CAAC;AAExD,yEAAyE;AACzE,MAAM,UAAU,WAAW,CAAC,OAA0B;IACpD,OAAO,OAAO,EAAE,GAAG,EAAE,KAAK,IAAI,iBAAiB,CAAC;AAClD,CAAC;AAED,4EAA4E;AAC5E,MAAM,CAAC,MAAM,mBAAmB,GAAG;IACjC,GAAG,SAAS;IAEZ,QAAQ,EAAE,IAA2C;IACrD,SAAS,EAAE,IAA2C;IAEtD,OAAO,EAAE,OAAO;IAChB,MAAM,EAAE,KAAK;IACb,OAAO,EAAE;QACP,GAAG,EAAE;YACH,KAAK,EAAE,iBAAiB;YACxB,IAAI,EAAE,KAAK;YACX,UAAU,EAAE,CAAC;YACb,WAAW,EAAE,WAAW;YACxB,OAAO,EAAE,SAAS;YAClB,UAAU,EAAE,KAAK;YACjB,wBAAwB,EAAE,KAAK;YAC/B,iBAAiB,EAAE,MAAM;SAC1B;KACF;CAC8F,CAAC;AAElG,iFAAiF;AACjF,MAAM,UAAU,mBAAmB,CACjC,IAAa,EACb,WAAgD;IAEhD,IAAI,WAAW,KAAK,WAAW,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC;QAC5D,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,cAAc,GAAG,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC;IAC/C,MAAM,WAAW,GAAG,cAAc,CAAC,KAAK,YAAY,WAAW,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC;IAC9E,MAAM,KAAK,GACT,WAAW,KAAK,SAAS;QACvB,CAAC,CAAC,0BAA0B,CAAC,cAAc,CAAC,KAAK,EAAE,WAAW,CAAC;QAC/D,CAAC,CAAC,0BAA0B,CAAC,cAAc,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;IACpE,MAAM,UAAU,GAAG,EAAC,GAAG,IAAI,CAAC,UAAU,EAAC,CAAC;IAExC,KAAK,MAAM,CAAC,aAAa,EAAE,SAAS,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE,CAAC;QACpE,IAAI,SAAS,CAAC,KAAK,KAAK,cAAc,CAAC,KAAK,EAAE,CAAC;YAC7C,UAAU,CAAC,aAAa,CAAC,GAAG;gBAC1B,GAAG,SAAS;gBACZ,KAAK;gBACL,UAAU,EAAE,KAAK;gBACjB,GAAG,CAAC,WAAW,KAAK,SAAS,CAAC,CAAC,CAAC,EAAC,aAAa,EAAE,SAAkB,EAAC,CAAC,CAAC,CAAC,EAAE,CAAC;aAC1E,CAAC;QACJ,CAAC;IACH,CAAC;IAED,OAAO,EAAC,GAAG,IAAI,EAAE,UAAU,EAAC,CAAC;AAC/B,CAAC"}

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

@@ -0,0 +1,54 @@
+"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/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);
+var import_las_loader_shared = require("./las-loader-shared.cjs");
+async function preload() {
+  const { LASLoaderWithParser } = await import("@loaders.gl/pointclouds/las/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/las-loader-types.cjs.map

@@ -0,0 +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;",
+  "names": []
+}

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

@@ -0,0 +1,104 @@
+import type { MeshArrowTable } from '@loaders.gl/core/schema';
+import type { LASMesh } from "./lib/las-types.js";
+import { type LASLoaderOptions } from "./las-loader-shared.js";
+export type { LASColumnName, LASLoaderOptions } from "./las-loader-shared.js";
+/** Preloads the parser-bearing primary TypeScript LAS loader implementation. */
+declare function preload(): Promise<{
+    readonly worker: true;
+    readonly workerInBatches: true;
+    readonly serializeWorkerResult: typeof import("@loaders.gl/core/schema-utils/arrow-transport").serializeArrowWorkerTable;
+    readonly serializeWorkerBatch: typeof import("@loaders.gl/core/schema-utils/arrow-transport").serializeArrowWorkerTable;
+    readonly deserializeWorkerResult: (result: unknown, options?: LASLoaderOptions) => LASMesh | MeshArrowTable;
+    readonly deserializeWorkerBatch: (result: unknown, options?: LASLoaderOptions) => LASMesh | MeshArrowTable;
+    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 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 name: "LAS";
+    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"];
+}>;
+/** Metadata-only loader for the LAS (LASer) point cloud format. */
+export declare const LASLoader: {
+    readonly worker: true;
+    readonly workerInBatches: true;
+    readonly preload: typeof preload;
+    readonly dataType: LASMesh | MeshArrowTable;
+    readonly batchType: LASMesh | MeshArrowTable;
+    readonly version: any;
+    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 name: "LAS";
+    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"];
+};
+/** @deprecated Use LASLoader. */
+export declare const LASWorkerLoader: {
+    readonly worker: true;
+    readonly workerInBatches: true;
+    readonly preload: typeof preload;
+    readonly dataType: LASMesh | MeshArrowTable;
+    readonly batchType: LASMesh | MeshArrowTable;
+    readonly version: any;
+    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 name: "LAS";
+    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=las-loader-types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"las-loader-types.d.ts","sourceRoot":"","sources":["../../src/las/las-loader-types.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,yBAAyB,CAAC;AAC5D,OAAO,KAAK,EAAC,OAAO,EAAC,2BAAwB;AAC7C,OAAO,EAAsB,KAAK,gBAAgB,EAAC,+BAA4B;AAE/E,YAAY,EAAC,aAAa,EAAE,gBAAgB,EAAC,+BAA4B;AAEzE,gFAAgF;AAChF,iBAAe,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAGrB;AAED,mEAAmE;AACnE,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAK2E,CAAC;AAElG,iCAAiC;AACjC,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAY,CAAC"}

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

@@ -0,0 +1,19 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+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');
+    return LASLoaderWithParser;
+}
+/** Metadata-only loader for the LAS (LASer) point cloud format. */
+export const LASLoader = {
+    ...LAS_LOADER_METADATA,
+    worker: true,
+    workerInBatches: true,
+    preload
+};
+/** @deprecated Use LASLoader. */
+export const LASWorkerLoader = LASLoader;
+//# sourceMappingURL=las-loader-types.js.map

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

@@ -0,0 +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"}