@loaders.gl/pcd 4.0.0-alpha.4 → 4.0.0-alpha.6

package/dist/bundle.d.ts

@@ -0,0 +1,2 @@
+declare const moduleExports: any;
+//# sourceMappingURL=bundle.d.ts.map

package/dist/bundle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle.d.ts","sourceRoot":"","sources":["../src/bundle.ts"],"names":[],"mappings":"AACA,QAAA,MAAM,aAAa,KAAqB,CAAC"}

package/dist/bundle.js

@@ -1,5 +1,5 @@
+"use strict";
+// @ts-nocheck
 const moduleExports = require('./index');
-
 globalThis.loaders = globalThis.loaders || {};
 module.exports = Object.assign(globalThis.loaders, moduleExports);
-//# sourceMappingURL=bundle.js.map

package/dist/dist.min.js

@@ -0,0 +1,476 @@
+(() => {
+  var __defProp = Object.defineProperty;
+  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+  var __esm = (fn, res) => function __init() {
+    return fn && (res = (0, fn[Object.keys(fn)[0]])(fn = 0)), res;
+  };
+  var __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[Object.keys(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+  var __export = (target, all) => {
+    __markAsModule(target);
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+
+  // ../schema/src/lib/mesh/mesh-utils.ts
+  function getMeshBoundingBox(attributes) {
+    let minX = Infinity;
+    let minY = Infinity;
+    let minZ = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    let maxZ = -Infinity;
+    const positions = attributes.POSITION ? attributes.POSITION.value : [];
+    const len = positions && positions.length;
+    for (let i = 0; i < len; i += 3) {
+      const x = positions[i];
+      const y = positions[i + 1];
+      const z = positions[i + 2];
+      minX = x < minX ? x : minX;
+      minY = y < minY ? y : minY;
+      minZ = z < minZ ? z : minZ;
+      maxX = x > maxX ? x : maxX;
+      maxY = y > maxY ? y : maxY;
+      maxZ = z > maxZ ? z : maxZ;
+    }
+    return [
+      [minX, minY, minZ],
+      [maxX, maxY, maxZ]
+    ];
+  }
+  var init_mesh_utils = __esm({
+    "../schema/src/lib/mesh/mesh-utils.ts"() {
+    }
+  });
+
+  // ../schema/src/index.ts
+  var init_src = __esm({
+    "../schema/src/index.ts"() {
+      init_mesh_utils();
+    }
+  });
+
+  // src/lib/decompress-lzf.ts
+  function decompressLZF(inData, outLength) {
+    const inLength = inData.length;
+    const outData = new Uint8Array(outLength);
+    let inPtr = 0;
+    let outPtr = 0;
+    let ctrl;
+    let len;
+    let ref;
+    do {
+      ctrl = inData[inPtr++];
+      if (ctrl < 1 << 5) {
+        ctrl++;
+        if (outPtr + ctrl > outLength) {
+          throw new Error("Output buffer is not large enough");
+        }
+        if (inPtr + ctrl > inLength) {
+          throw new Error("Invalid compressed data");
+        }
+        do {
+          outData[outPtr++] = inData[inPtr++];
+        } while (--ctrl);
+      } else {
+        len = ctrl >> 5;
+        ref = outPtr - ((ctrl & 31) << 8) - 1;
+        if (inPtr >= inLength) {
+          throw new Error("Invalid compressed data");
+        }
+        if (len === 7) {
+          len += inData[inPtr++];
+          if (inPtr >= inLength) {
+            throw new Error("Invalid compressed data");
+          }
+        }
+        ref -= inData[inPtr++];
+        if (outPtr + len + 2 > outLength) {
+          throw new Error("Output buffer is not large enough");
+        }
+        if (ref < 0) {
+          throw new Error("Invalid compressed data");
+        }
+        if (ref >= outPtr) {
+          throw new Error("Invalid compressed data");
+        }
+        do {
+          outData[outPtr++] = outData[ref++];
+        } while (--len + 2);
+      }
+    } while (inPtr < inLength);
+    return outData;
+  }
+  var init_decompress_lzf = __esm({
+    "src/lib/decompress-lzf.ts"() {
+    }
+  });
+
+  // src/lib/get-pcd-schema.ts
+  function getPCDSchema(PCDheader, metadata) {
+    const offset = PCDheader.offset;
+    const fields = [];
+    if (offset.x !== void 0) {
+      fields.push({
+        name: "POSITION",
+        type: { type: "fixed-size-list", listSize: 3, children: [{ name: "xyz", type: "float32" }] }
+      });
+    }
+    if (offset.normal_x !== void 0) {
+      fields.push({
+        name: "NORMAL",
+        type: { type: "fixed-size-list", listSize: 3, children: [{ name: "xyz", type: "float32" }] }
+      });
+    }
+    if (offset.rgb !== void 0) {
+      fields.push({
+        name: "COLOR_0",
+        type: { type: "fixed-size-list", listSize: 3, children: [{ name: "rgb", type: "uint8" }] }
+      });
+    }
+    return { fields, metadata };
+  }
+  var init_get_pcd_schema = __esm({
+    "src/lib/get-pcd-schema.ts"() {
+    }
+  });
+
+  // src/lib/parse-pcd.ts
+  function parsePCD(data) {
+    const textData = new TextDecoder().decode(data);
+    const pcdHeader = parsePCDHeader(textData);
+    let attributes = {};
+    switch (pcdHeader.data) {
+      case "ascii":
+        attributes = parsePCDASCII(pcdHeader, textData);
+        break;
+      case "binary":
+        attributes = parsePCDBinary(pcdHeader, data);
+        break;
+      case "binary_compressed":
+        attributes = parsePCDBinaryCompressed(pcdHeader, data);
+        break;
+      default:
+        throw new Error(`PCD: ${pcdHeader.data} files are not supported`);
+    }
+    attributes = getMeshAttributes(attributes);
+    const header = getMeshHeader(pcdHeader, attributes);
+    const metadata = Object.fromEntries([
+      ["mode", "0"],
+      ["boundingBox", JSON.stringify(header.boundingBox)]
+    ]);
+    const schema = getPCDSchema(pcdHeader, metadata);
+    return {
+      loader: "pcd",
+      loaderData: pcdHeader,
+      header,
+      schema,
+      mode: 0,
+      topology: "point-list",
+      attributes
+    };
+  }
+  function getMeshHeader(pcdHeader, attributes) {
+    if (typeof pcdHeader.width === "number" && typeof pcdHeader.height === "number") {
+      const pointCount = pcdHeader.width * pcdHeader.height;
+      return {
+        vertexCount: pointCount,
+        boundingBox: getMeshBoundingBox(attributes)
+      };
+    }
+    return {
+      vertexCount: pcdHeader.vertexCount,
+      boundingBox: pcdHeader.boundingBox
+    };
+  }
+  function getMeshAttributes(attributes) {
+    const normalizedAttributes = {
+      POSITION: {
+        value: new Float32Array(attributes.position),
+        size: 3
+      }
+    };
+    if (attributes.normal && attributes.normal.length > 0) {
+      normalizedAttributes.NORMAL = {
+        value: new Float32Array(attributes.normal),
+        size: 3
+      };
+    }
+    if (attributes.color && attributes.color.length > 0) {
+      normalizedAttributes.COLOR_0 = {
+        value: new Uint8Array(attributes.color),
+        size: 3
+      };
+    }
+    if (attributes.intensity && attributes.intensity.length > 0) {
+      normalizedAttributes.COLOR_0 = {
+        value: new Uint8Array(attributes.color),
+        size: 3
+      };
+    }
+    if (attributes.label && attributes.label.length > 0) {
+      normalizedAttributes.COLOR_0 = {
+        value: new Uint8Array(attributes.label),
+        size: 3
+      };
+    }
+    return normalizedAttributes;
+  }
+  function parsePCDHeader(data) {
+    const result1 = data.search(/[\r\n]DATA\s(\S*)\s/i);
+    const result2 = /[\r\n]DATA\s(\S*)\s/i.exec(data.substr(result1 - 1));
+    const pcdHeader = {};
+    pcdHeader.data = result2 && result2[1];
+    if (result2 !== null) {
+      pcdHeader.headerLen = (result2 && result2[0].length) + result1;
+    }
+    pcdHeader.str = data.substr(0, pcdHeader.headerLen);
+    pcdHeader.str = pcdHeader.str.replace(/\#.*/gi, "");
+    pcdHeader.version = /VERSION (.*)/i.exec(pcdHeader.str);
+    pcdHeader.fields = /FIELDS (.*)/i.exec(pcdHeader.str);
+    pcdHeader.size = /SIZE (.*)/i.exec(pcdHeader.str);
+    pcdHeader.type = /TYPE (.*)/i.exec(pcdHeader.str);
+    pcdHeader.count = /COUNT (.*)/i.exec(pcdHeader.str);
+    pcdHeader.width = /WIDTH (.*)/i.exec(pcdHeader.str);
+    pcdHeader.height = /HEIGHT (.*)/i.exec(pcdHeader.str);
+    pcdHeader.viewpoint = /VIEWPOINT (.*)/i.exec(pcdHeader.str);
+    pcdHeader.points = /POINTS (.*)/i.exec(pcdHeader.str);
+    if (pcdHeader.version !== null) {
+      pcdHeader.version = parseFloat(pcdHeader.version[1]);
+    }
+    if (pcdHeader.fields !== null) {
+      pcdHeader.fields = pcdHeader.fields[1].split(" ");
+    }
+    if (pcdHeader.type !== null) {
+      pcdHeader.type = pcdHeader.type[1].split(" ");
+    }
+    if (pcdHeader.width !== null) {
+      pcdHeader.width = parseInt(pcdHeader.width[1], 10);
+    }
+    if (pcdHeader.height !== null) {
+      pcdHeader.height = parseInt(pcdHeader.height[1], 10);
+    }
+    if (pcdHeader.viewpoint !== null) {
+      pcdHeader.viewpoint = pcdHeader.viewpoint[1];
+    }
+    if (pcdHeader.points !== null) {
+      pcdHeader.points = parseInt(pcdHeader.points[1], 10);
+    }
+    if (pcdHeader.points === null && typeof pcdHeader.width === "number" && typeof pcdHeader.height === "number") {
+      pcdHeader.points = pcdHeader.width * pcdHeader.height;
+    }
+    if (pcdHeader.size !== null) {
+      pcdHeader.size = pcdHeader.size[1].split(" ").map((x) => parseInt(x, 10));
+    }
+    if (pcdHeader.count !== null) {
+      pcdHeader.count = pcdHeader.count[1].split(" ").map((x) => parseInt(x, 10));
+    } else {
+      pcdHeader.count = [];
+      if (pcdHeader.fields !== null) {
+        for (let i = 0; i < pcdHeader.fields.length; i++) {
+          pcdHeader.count.push(1);
+        }
+      }
+    }
+    pcdHeader.offset = {};
+    let sizeSum = 0;
+    if (pcdHeader.fields !== null && pcdHeader.size !== null) {
+      for (let i = 0; i < pcdHeader.fields.length; i++) {
+        if (pcdHeader.data === "ascii") {
+          pcdHeader.offset[pcdHeader.fields[i]] = i;
+        } else {
+          pcdHeader.offset[pcdHeader.fields[i]] = sizeSum;
+          sizeSum += pcdHeader.size[i];
+        }
+      }
+    }
+    pcdHeader.rowSize = sizeSum;
+    return pcdHeader;
+  }
+  function parsePCDASCII(pcdHeader, textData) {
+    const position = [];
+    const normal = [];
+    const color = [];
+    const intensity = [];
+    const label = [];
+    const offset = pcdHeader.offset;
+    const pcdData = textData.substr(pcdHeader.headerLen);
+    const lines = pcdData.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i] !== "") {
+        const line = lines[i].split(" ");
+        if (offset.x !== void 0) {
+          position.push(parseFloat(line[offset.x]));
+          position.push(parseFloat(line[offset.y]));
+          position.push(parseFloat(line[offset.z]));
+        }
+        if (offset.rgb !== void 0) {
+          const floatValue = parseFloat(line[offset.rgb]);
+          const binaryColor = new Float32Array([floatValue]);
+          const dataview = new DataView(binaryColor.buffer, 0);
+          color.push(dataview.getUint8(0));
+          color.push(dataview.getUint8(1));
+          color.push(dataview.getUint8(2));
+        }
+        if (offset.normal_x !== void 0) {
+          normal.push(parseFloat(line[offset.normal_x]));
+          normal.push(parseFloat(line[offset.normal_y]));
+          normal.push(parseFloat(line[offset.normal_z]));
+        }
+        if (offset.intensity !== void 0) {
+          intensity.push(parseFloat(line[offset.intensity]));
+        }
+        if (offset.label !== void 0) {
+          label.push(parseInt(line[offset.label]));
+        }
+      }
+    }
+    return { position, normal, color };
+  }
+  function parsePCDBinary(pcdHeader, data) {
+    const position = [];
+    const normal = [];
+    const color = [];
+    const intensity = [];
+    const label = [];
+    const dataview = new DataView(data, pcdHeader.headerLen);
+    const offset = pcdHeader.offset;
+    for (let i = 0, row = 0; i < pcdHeader.points; i++, row += pcdHeader.rowSize) {
+      if (offset.x !== void 0) {
+        position.push(dataview.getFloat32(row + offset.x, LITTLE_ENDIAN));
+        position.push(dataview.getFloat32(row + offset.y, LITTLE_ENDIAN));
+        position.push(dataview.getFloat32(row + offset.z, LITTLE_ENDIAN));
+      }
+      if (offset.rgb !== void 0) {
+        color.push(dataview.getUint8(row + offset.rgb + 0));
+        color.push(dataview.getUint8(row + offset.rgb + 1));
+        color.push(dataview.getUint8(row + offset.rgb + 2));
+      }
+      if (offset.normal_x !== void 0) {
+        normal.push(dataview.getFloat32(row + offset.normal_x, LITTLE_ENDIAN));
+        normal.push(dataview.getFloat32(row + offset.normal_y, LITTLE_ENDIAN));
+        normal.push(dataview.getFloat32(row + offset.normal_z, LITTLE_ENDIAN));
+      }
+      if (offset.intensity !== void 0) {
+        intensity.push(dataview.getFloat32(row + offset.intensity, LITTLE_ENDIAN));
+      }
+      if (offset.label !== void 0) {
+        label.push(dataview.getInt32(row + offset.label, LITTLE_ENDIAN));
+      }
+    }
+    return { position, normal, color, intensity, label };
+  }
+  function parsePCDBinaryCompressed(pcdHeader, data) {
+    const position = [];
+    const normal = [];
+    const color = [];
+    const intensity = [];
+    const label = [];
+    const sizes = new Uint32Array(data.slice(pcdHeader.headerLen, pcdHeader.headerLen + 8));
+    const compressedSize = sizes[0];
+    const decompressedSize = sizes[1];
+    const decompressed = decompressLZF(new Uint8Array(data, pcdHeader.headerLen + 8, compressedSize), decompressedSize);
+    const dataview = new DataView(decompressed.buffer);
+    const offset = pcdHeader.offset;
+    for (let i = 0; i < pcdHeader.points; i++) {
+      if (offset.x !== void 0) {
+        position.push(dataview.getFloat32(pcdHeader.points * offset.x + pcdHeader.size[0] * i, LITTLE_ENDIAN));
+        position.push(dataview.getFloat32(pcdHeader.points * offset.y + pcdHeader.size[1] * i, LITTLE_ENDIAN));
+        position.push(dataview.getFloat32(pcdHeader.points * offset.z + pcdHeader.size[2] * i, LITTLE_ENDIAN));
+      }
+      if (offset.rgb !== void 0) {
+        color.push(dataview.getUint8(pcdHeader.points * offset.rgb + pcdHeader.size[3] * i + 0) / 255);
+        color.push(dataview.getUint8(pcdHeader.points * offset.rgb + pcdHeader.size[3] * i + 1) / 255);
+        color.push(dataview.getUint8(pcdHeader.points * offset.rgb + pcdHeader.size[3] * i + 2) / 255);
+      }
+      if (offset.normal_x !== void 0) {
+        normal.push(dataview.getFloat32(pcdHeader.points * offset.normal_x + pcdHeader.size[4] * i, LITTLE_ENDIAN));
+        normal.push(dataview.getFloat32(pcdHeader.points * offset.normal_y + pcdHeader.size[5] * i, LITTLE_ENDIAN));
+        normal.push(dataview.getFloat32(pcdHeader.points * offset.normal_z + pcdHeader.size[6] * i, LITTLE_ENDIAN));
+      }
+      if (offset.intensity !== void 0) {
+        const intensityIndex = pcdHeader.fields.indexOf("intensity");
+        intensity.push(dataview.getFloat32(pcdHeader.points * offset.intensity + pcdHeader.size[intensityIndex] * i, LITTLE_ENDIAN));
+      }
+      if (offset.label !== void 0) {
+        const labelIndex = pcdHeader.fields.indexOf("label");
+        label.push(dataview.getInt32(pcdHeader.points * offset.label + pcdHeader.size[labelIndex] * i, LITTLE_ENDIAN));
+      }
+    }
+    return {
+      position,
+      normal,
+      color,
+      intensity,
+      label
+    };
+  }
+  var LITTLE_ENDIAN;
+  var init_parse_pcd = __esm({
+    "src/lib/parse-pcd.ts"() {
+      init_src();
+      init_decompress_lzf();
+      init_get_pcd_schema();
+      LITTLE_ENDIAN = true;
+    }
+  });
+
+  // src/pcd-loader.ts
+  var VERSION, PCDLoader;
+  var init_pcd_loader = __esm({
+    "src/pcd-loader.ts"() {
+      VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      PCDLoader = {
+        name: "PCD (Point Cloud Data)",
+        id: "pcd",
+        module: "pcd",
+        version: VERSION,
+        worker: true,
+        extensions: ["pcd"],
+        mimeTypes: ["text/plain"],
+        options: {
+          pcd: {}
+        }
+      };
+    }
+  });
+
+  // src/index.ts
+  var src_exports = {};
+  __export(src_exports, {
+    PCDLoader: () => PCDLoader2,
+    PCDWorkerLoader: () => PCDLoader,
+    _typecheckPCDLoader: () => _typecheckPCDLoader
+  });
+  var PCDLoader2, _typecheckPCDLoader;
+  var init_src2 = __esm({
+    "src/index.ts"() {
+      init_parse_pcd();
+      init_pcd_loader();
+      PCDLoader2 = {
+        ...PCDLoader,
+        parse: async (arrayBuffer) => parsePCD(arrayBuffer),
+        parseSync: parsePCD
+      };
+      _typecheckPCDLoader = PCDLoader2;
+    }
+  });
+
+  // src/bundle.ts
+  var require_bundle = __commonJS({
+    "src/bundle.ts"(exports, module) {
+      var moduleExports = (init_src2(), src_exports);
+      globalThis.loaders = globalThis.loaders || {};
+      module.exports = Object.assign(globalThis.loaders, moduleExports);
+    }
+  });
+  require_bundle();
+})();
+/** Parse compressed PCD data in in binary_compressed form ( https://pointclouds.org/documentation/tutorials/pcd_file_format.html)
+ * from https://github.com/mrdoob/three.js/blob/master/examples/jsm/loaders/PCDLoader.js
+ * @license MIT (http://opensource.org/licenses/MIT)
+ * @param pcdHeader
+ * @param data
+ * @returns [attributes]
+ */

package/dist/es5/bundle.js

@@ -0,0 +1,6 @@
+"use strict";
+
+var moduleExports = require('./index');
+globalThis.loaders = globalThis.loaders || {};
+module.exports = Object.assign(globalThis.loaders, moduleExports);
+//# sourceMappingURL=bundle.js.map

package/dist/es5/bundle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle.js","names":["moduleExports","require","globalThis","loaders","module","exports","Object","assign"],"sources":["../../src/bundle.ts"],"sourcesContent":["// @ts-nocheck\nconst moduleExports = require('./index');\nglobalThis.loaders = globalThis.loaders || {};\nmodule.exports = Object.assign(globalThis.loaders, moduleExports);\n"],"mappings":";;AACA,IAAMA,aAAa,GAAGC,OAAO,CAAC,SAAS,CAAC;AACxCC,UAAU,CAACC,OAAO,GAAGD,UAAU,CAACC,OAAO,IAAI,CAAC,CAAC;AAC7CC,MAAM,CAACC,OAAO,GAAGC,MAAM,CAACC,MAAM,CAACL,UAAU,CAACC,OAAO,EAAEH,aAAa,CAAC"}

package/dist/es5/index.js

@@ -0,0 +1,45 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PCDLoader = void 0;
+Object.defineProperty(exports, "PCDWorkerLoader", {
+  enumerable: true,
+  get: function get() {
+    return _pcdLoader.PCDLoader;
+  }
+});
+exports._typecheckPCDLoader = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _parsePcd = _interopRequireDefault(require("./lib/parse-pcd"));
+var _pcdLoader = require("./pcd-loader");
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+var PCDLoader = _objectSpread(_objectSpread({}, _pcdLoader.PCDLoader), {}, {
+  parse: function () {
+    var _parse = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(arrayBuffer) {
+      return _regenerator.default.wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            return _context.abrupt("return", (0, _parsePcd.default)(arrayBuffer));
+          case 1:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }));
+    function parse(_x) {
+      return _parse.apply(this, arguments);
+    }
+    return parse;
+  }(),
+  parseSync: _parsePcd.default
+});
+exports.PCDLoader = PCDLoader;
+var _typecheckPCDLoader = PCDLoader;
+exports._typecheckPCDLoader = _typecheckPCDLoader;
+//# sourceMappingURL=index.js.map

package/dist/es5/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["_parsePcd","_interopRequireDefault","require","_pcdLoader","ownKeys","object","enumerableOnly","keys","Object","getOwnPropertySymbols","symbols","filter","sym","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","target","i","arguments","length","source","forEach","key","_defineProperty2","default","getOwnPropertyDescriptors","defineProperties","defineProperty","PCDLoader","PCDWorkerLoader","parse","_parse","_asyncToGenerator2","_regenerator","mark","_callee","arrayBuffer","wrap","_callee$","_context","prev","next","abrupt","parsePCDSync","stop","_x","parseSync","exports","_typecheckPCDLoader"],"sources":["../../src/index.ts"],"sourcesContent":["import type {LoaderOptions, LoaderWithParser} from '@loaders.gl/loader-utils';\nimport parsePCDSync from './lib/parse-pcd';\nimport {PCDLoader as PCDWorkerLoader} from './pcd-loader';\nimport {PCDMesh} from './lib/pcd-types';\n\nexport {PCDWorkerLoader};\n\n/**\n * Loader for PCD - Point Cloud Data\n */\nexport const PCDLoader: LoaderWithParser<PCDMesh, never, LoaderOptions> = {\n  ...PCDWorkerLoader,\n  parse: async (arrayBuffer) => parsePCDSync(arrayBuffer),\n  parseSync: parsePCDSync\n};\n\nexport const _typecheckPCDLoader: LoaderWithParser = PCDLoader;\n"],"mappings":";;;;;;;;;;;;;;;;;AACA,IAAAA,SAAA,GAAAC,sBAAA,CAAAC,OAAA;AACA,IAAAC,UAAA,GAAAD,OAAA;AAA0D,SAAAE,QAAAC,MAAA,EAAAC,cAAA,QAAAC,IAAA,GAAAC,MAAA,CAAAD,IAAA,CAAAF,MAAA,OAAAG,MAAA,CAAAC,qBAAA,QAAAC,OAAA,GAAAF,MAAA,CAAAC,qBAAA,CAAAJ,MAAA,GAAAC,cAAA,KAAAI,OAAA,GAAAA,OAAA,CAAAC,MAAA,WAAAC,GAAA,WAAAJ,MAAA,CAAAK,wBAAA,CAAAR,MAAA,EAAAO,GAAA,EAAAE,UAAA,OAAAP,IAAA,CAAAQ,IAAA,CAAAC,KAAA,CAAAT,IAAA,EAAAG,OAAA,YAAAH,IAAA;AAAA,SAAAU,cAAAC,MAAA,aAAAC,CAAA,MAAAA,CAAA,GAAAC,SAAA,CAAAC,MAAA,EAAAF,CAAA,UAAAG,MAAA,WAAAF,SAAA,CAAAD,CAAA,IAAAC,SAAA,CAAAD,CAAA,QAAAA,CAAA,OAAAf,OAAA,CAAAI,MAAA,CAAAc,MAAA,OAAAC,OAAA,WAAAC,GAAA,QAAAC,gBAAA,CAAAC,OAAA,EAAAR,MAAA,EAAAM,GAAA,EAAAF,MAAA,CAAAE,GAAA,SAAAhB,MAAA,CAAAmB,yBAAA,GAAAnB,MAAA,CAAAoB,gBAAA,CAAAV,MAAA,EAAAV,MAAA,CAAAmB,yBAAA,CAAAL,MAAA,KAAAlB,OAAA,CAAAI,MAAA,CAAAc,MAAA,GAAAC,OAAA,WAAAC,GAAA,IAAAhB,MAAA,CAAAqB,cAAA,CAAAX,MAAA,EAAAM,GAAA,EAAAhB,MAAA,CAAAK,wBAAA,CAAAS,MAAA,EAAAE,GAAA,iBAAAN,MAAA;AAQnD,IAAMY,SAA0D,GAAAb,aAAA,CAAAA,aAAA,KAClEc,oBAAe;EAClBC,KAAK;IAAA,IAAAC,MAAA,OAAAC,kBAAA,CAAAR,OAAA,EAAAS,YAAA,CAAAT,OAAA,CAAAU,IAAA,CAAE,SAAAC,QAAOC,WAAW;MAAA,OAAAH,YAAA,CAAAT,OAAA,CAAAa,IAAA,UAAAC,SAAAC,QAAA;QAAA,kBAAAA,QAAA,CAAAC,IAAA,GAAAD,QAAA,CAAAE,IAAA;UAAA;YAAA,OAAAF,QAAA,CAAAG,MAAA,WAAK,IAAAC,iBAAY,EAACP,WAAW,CAAC;UAAA;UAAA;YAAA,OAAAG,QAAA,CAAAK,IAAA;QAAA;MAAA,GAAAT,OAAA;IAAA;IAAA,SAAAL,MAAAe,EAAA;MAAA,OAAAd,MAAA,CAAAjB,KAAA,OAAAI,SAAA;IAAA;IAAA,OAAAY,KAAA;EAAA;EACvDgB,SAAS,EAAEH;AAAY,EACxB;AAACI,OAAA,CAAAnB,SAAA,GAAAA,SAAA;AAEK,IAAMoB,mBAAqC,GAAGpB,SAAS;AAACmB,OAAA,CAAAC,mBAAA,GAAAA,mBAAA"}

package/dist/es5/lib/decompress-lzf.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.decompressLZF = decompressLZF;
+function decompressLZF(inData, outLength) {
+  var inLength = inData.length;
+  var outData = new Uint8Array(outLength);
+  var inPtr = 0;
+  var outPtr = 0;
+  var ctrl;
+  var len;
+  var ref;
+  do {
+    ctrl = inData[inPtr++];
+    if (ctrl < 1 << 5) {
+      ctrl++;
+      if (outPtr + ctrl > outLength) {
+        throw new Error('Output buffer is not large enough');
+      }
+      if (inPtr + ctrl > inLength) {
+        throw new Error('Invalid compressed data');
+      }
+      do {
+        outData[outPtr++] = inData[inPtr++];
+      } while (--ctrl);
+    } else {
+      len = ctrl >> 5;
+      ref = outPtr - ((ctrl & 0x1f) << 8) - 1;
+      if (inPtr >= inLength) {
+        throw new Error('Invalid compressed data');
+      }
+      if (len === 7) {
+        len += inData[inPtr++];
+        if (inPtr >= inLength) {
+          throw new Error('Invalid compressed data');
+        }
+      }
+      ref -= inData[inPtr++];
+      if (outPtr + len + 2 > outLength) {
+        throw new Error('Output buffer is not large enough');
+      }
+      if (ref < 0) {
+        throw new Error('Invalid compressed data');
+      }
+      if (ref >= outPtr) {
+        throw new Error('Invalid compressed data');
+      }
+      do {
+        outData[outPtr++] = outData[ref++];
+      } while (--len + 2);
+    }
+  } while (inPtr < inLength);
+  return outData;
+}
+//# sourceMappingURL=decompress-lzf.js.map

package/dist/es5/lib/decompress-lzf.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decompress-lzf.js","names":["decompressLZF","inData","outLength","inLength","length","outData","Uint8Array","inPtr","outPtr","ctrl","len","ref","Error"],"sources":["../../../src/lib/decompress-lzf.ts"],"sourcesContent":["/* eslint-disable */\n/**\n * from https://gitlab.com/taketwo/three-pcd-loader/blob/master/decompress-lzf.js\n * @param inData\n * @param outLength\n * @returns\n */\nexport function decompressLZF(inData: Uint8Array, outLength: number): Uint8Array {\n  const inLength = inData.length;\n  const outData = new Uint8Array(outLength);\n  let inPtr = 0;\n  let outPtr = 0;\n  let ctrl;\n  let len;\n  let ref;\n\n  do {\n    ctrl = inData[inPtr++];\n\n    if (ctrl < 1 << 5) {\n      ctrl++;\n      if (outPtr + ctrl > outLength) {\n        throw new Error('Output buffer is not large enough');\n      }\n      if (inPtr + ctrl > inLength) {\n        throw new Error('Invalid compressed data');\n      }\n\n      do {\n        outData[outPtr++] = inData[inPtr++];\n      } while (--ctrl);\n    } else {\n      len = ctrl >> 5;\n      ref = outPtr - ((ctrl & 0x1f) << 8) - 1;\n      if (inPtr >= inLength) {\n        throw new Error('Invalid compressed data');\n      }\n\n      if (len === 7) {\n        len += inData[inPtr++];\n        if (inPtr >= inLength) {\n          throw new Error('Invalid compressed data');\n        }\n      }\n\n      ref -= inData[inPtr++];\n      if (outPtr + len + 2 > outLength) {\n        throw new Error('Output buffer is not large enough');\n      }\n      if (ref < 0) {\n        throw new Error('Invalid compressed data');\n      }\n      if (ref >= outPtr) {\n        throw new Error('Invalid compressed data');\n      }\n\n      do {\n        outData[outPtr++] = outData[ref++];\n      } while (--len + 2);\n    }\n  } while (inPtr < inLength);\n\n  return outData;\n}\n"],"mappings":";;;;;;AAOO,SAASA,aAAaA,CAACC,MAAkB,EAAEC,SAAiB,EAAc;EAC/E,IAAMC,QAAQ,GAAGF,MAAM,CAACG,MAAM;EAC9B,IAAMC,OAAO,GAAG,IAAIC,UAAU,CAACJ,SAAS,CAAC;EACzC,IAAIK,KAAK,GAAG,CAAC;EACb,IAAIC,MAAM,GAAG,CAAC;EACd,IAAIC,IAAI;EACR,IAAIC,GAAG;EACP,IAAIC,GAAG;EAEP,GAAG;IACDF,IAAI,GAAGR,MAAM,CAACM,KAAK,EAAE,CAAC;IAEtB,IAAIE,IAAI,GAAG,CAAC,IAAI,CAAC,EAAE;MACjBA,IAAI,EAAE;MACN,IAAID,MAAM,GAAGC,IAAI,GAAGP,SAAS,EAAE;QAC7B,MAAM,IAAIU,KAAK,CAAC,mCAAmC,CAAC;MACtD;MACA,IAAIL,KAAK,GAAGE,IAAI,GAAGN,QAAQ,EAAE;QAC3B,MAAM,IAAIS,KAAK,CAAC,yBAAyB,CAAC;MAC5C;MAEA,GAAG;QACDP,OAAO,CAACG,MAAM,EAAE,CAAC,GAAGP,MAAM,CAACM,KAAK,EAAE,CAAC;MACrC,CAAC,QAAQ,EAAEE,IAAI;IACjB,CAAC,MAAM;MACLC,GAAG,GAAGD,IAAI,IAAI,CAAC;MACfE,GAAG,GAAGH,MAAM,IAAI,CAACC,IAAI,GAAG,IAAI,KAAK,CAAC,CAAC,GAAG,CAAC;MACvC,IAAIF,KAAK,IAAIJ,QAAQ,EAAE;QACrB,MAAM,IAAIS,KAAK,CAAC,yBAAyB,CAAC;MAC5C;MAEA,IAAIF,GAAG,KAAK,CAAC,EAAE;QACbA,GAAG,IAAIT,MAAM,CAACM,KAAK,EAAE,CAAC;QACtB,IAAIA,KAAK,IAAIJ,QAAQ,EAAE;UACrB,MAAM,IAAIS,KAAK,CAAC,yBAAyB,CAAC;QAC5C;MACF;MAEAD,GAAG,IAAIV,MAAM,CAACM,KAAK,EAAE,CAAC;MACtB,IAAIC,MAAM,GAAGE,GAAG,GAAG,CAAC,GAAGR,SAAS,EAAE;QAChC,MAAM,IAAIU,KAAK,CAAC,mCAAmC,CAAC;MACtD;MACA,IAAID,GAAG,GAAG,CAAC,EAAE;QACX,MAAM,IAAIC,KAAK,CAAC,yBAAyB,CAAC;MAC5C;MACA,IAAID,GAAG,IAAIH,MAAM,EAAE;QACjB,MAAM,IAAII,KAAK,CAAC,yBAAyB,CAAC;MAC5C;MAEA,GAAG;QACDP,OAAO,CAACG,MAAM,EAAE,CAAC,GAAGH,OAAO,CAACM,GAAG,EAAE,CAAC;MACpC,CAAC,QAAQ,EAAED,GAAG,GAAG,CAAC;IACpB;EACF,CAAC,QAAQH,KAAK,GAAGJ,QAAQ;EAEzB,OAAOE,OAAO;AAChB"}

package/dist/es5/lib/get-pcd-schema.js

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getPCDSchema = getPCDSchema;
+function getPCDSchema(PCDheader, metadata) {
+  var offset = PCDheader.offset;
+  var fields = [];
+  if (offset.x !== undefined) {
+    fields.push({
+      name: 'POSITION',
+      type: {
+        type: 'fixed-size-list',
+        listSize: 3,
+        children: [{
+          name: 'xyz',
+          type: 'float32'
+        }]
+      }
+    });
+  }
+  if (offset.normal_x !== undefined) {
+    fields.push({
+      name: 'NORMAL',
+      type: {
+        type: 'fixed-size-list',
+        listSize: 3,
+        children: [{
+          name: 'xyz',
+          type: 'float32'
+        }]
+      }
+    });
+  }
+  if (offset.rgb !== undefined) {
+    fields.push({
+      name: 'COLOR_0',
+      type: {
+        type: 'fixed-size-list',
+        listSize: 3,
+        children: [{
+          name: 'rgb',
+          type: 'uint8'
+        }]
+      }
+    });
+  }
+  return {
+    fields: fields,
+    metadata: metadata
+  };
+}
+//# sourceMappingURL=get-pcd-schema.js.map

package/dist/es5/lib/get-pcd-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-pcd-schema.js","names":["getPCDSchema","PCDheader","metadata","offset","fields","x","undefined","push","name","type","listSize","children","normal_x","rgb"],"sources":["../../../src/lib/get-pcd-schema.ts"],"sourcesContent":["import {Schema, Field} from '@loaders.gl/schema';\nimport type {PCDHeader} from './pcd-types';\n\n/**\n * Gets schema from PCD header\n * @param PCDheader\n * @param metadata\n * @returns Schema\n */\nexport function getPCDSchema(PCDheader: PCDHeader, metadata: Record<string, string>): Schema {\n  const offset = PCDheader.offset;\n\n  const fields: Field[] = [];\n\n  if (offset.x !== undefined) {\n    fields.push({\n      name: 'POSITION',\n      type: {type: 'fixed-size-list', listSize: 3, children: [{name: 'xyz', type: 'float32'}]}\n    });\n  }\n\n  if (offset.normal_x !== undefined) {\n    fields.push({\n      name: 'NORMAL',\n      type: {type: 'fixed-size-list', listSize: 3, children: [{name: 'xyz', type: 'float32'}]}\n    });\n  }\n\n  if (offset.rgb !== undefined) {\n    fields.push({\n      name: 'COLOR_0',\n      type: {type: 'fixed-size-list', listSize: 3, children: [{name: 'rgb', type: 'uint8'}]}\n    });\n  }\n\n  return {fields, metadata};\n}\n"],"mappings":";;;;;;AASO,SAASA,YAAYA,CAACC,SAAoB,EAAEC,QAAgC,EAAU;EAC3F,IAAMC,MAAM,GAAGF,SAAS,CAACE,MAAM;EAE/B,IAAMC,MAAe,GAAG,EAAE;EAE1B,IAAID,MAAM,CAACE,CAAC,KAAKC,SAAS,EAAE;IAC1BF,MAAM,CAACG,IAAI,CAAC;MACVC,IAAI,EAAE,UAAU;MAChBC,IAAI,EAAE;QAACA,IAAI,EAAE,iBAAiB;QAAEC,QAAQ,EAAE,CAAC;QAAEC,QAAQ,EAAE,CAAC;UAACH,IAAI,EAAE,KAAK;UAAEC,IAAI,EAAE;QAAS,CAAC;MAAC;IACzF,CAAC,CAAC;EACJ;EAEA,IAAIN,MAAM,CAACS,QAAQ,KAAKN,SAAS,EAAE;IACjCF,MAAM,CAACG,IAAI,CAAC;MACVC,IAAI,EAAE,QAAQ;MACdC,IAAI,EAAE;QAACA,IAAI,EAAE,iBAAiB;QAAEC,QAAQ,EAAE,CAAC;QAAEC,QAAQ,EAAE,CAAC;UAACH,IAAI,EAAE,KAAK;UAAEC,IAAI,EAAE;QAAS,CAAC;MAAC;IACzF,CAAC,CAAC;EACJ;EAEA,IAAIN,MAAM,CAACU,GAAG,KAAKP,SAAS,EAAE;IAC5BF,MAAM,CAACG,IAAI,CAAC;MACVC,IAAI,EAAE,SAAS;MACfC,IAAI,EAAE;QAACA,IAAI,EAAE,iBAAiB;QAAEC,QAAQ,EAAE,CAAC;QAAEC,QAAQ,EAAE,CAAC;UAACH,IAAI,EAAE,KAAK;UAAEC,IAAI,EAAE;QAAO,CAAC;MAAC;IACvF,CAAC,CAAC;EACJ;EAEA,OAAO;IAACL,MAAM,EAANA,MAAM;IAAEF,QAAQ,EAARA;EAAQ,CAAC;AAC3B"}