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

package/dist/pcd-worker.js

@@ -35,16 +35,33 @@
   }
 
   // ../worker-utils/src/lib/worker-farm/worker-body.ts
+  function getParentPort() {
+    let parentPort;
+    try {
+      eval("globalThis.parentPort = require('worker_threads').parentPort");
+      parentPort = globalThis.parentPort;
+    } catch {
+    }
+    return parentPort;
+  }
   var onMessageWrapperMap = new Map();
   var WorkerBody = class {
+    static inWorkerThread() {
+      return typeof self !== "undefined" || Boolean(getParentPort());
+    }
     static set onmessage(onMessage) {
-      self.onmessage = (message) => {
-        if (!isKnownMessage(message)) {
-          return;
-        }
-        const { type, payload } = message.data;
+      function handleMessage(message) {
+        const parentPort3 = getParentPort();
+        const { type, payload } = parentPort3 ? message : message.data;
         onMessage(type, payload);
-      };
+      }
+      const parentPort2 = getParentPort();
+      if (parentPort2) {
+        parentPort2.on("message", handleMessage);
+        parentPort2.on("exit", () => console.debug("Node worker closing"));
+      } else {
+        globalThis.onmessage = handleMessage;
+      }
     }
     static addEventListener(onMessage) {
       let onMessageWrapper = onMessageWrapperMap.get(onMessage);
@@ -53,22 +70,36 @@
           if (!isKnownMessage(message)) {
             return;
           }
-          const { type, payload } = message.data;
+          const parentPort3 = getParentPort();
+          const { type, payload } = parentPort3 ? message : message.data;
           onMessage(type, payload);
         };
       }
-      self.addEventListener("message", onMessageWrapper);
+      const parentPort2 = getParentPort();
+      if (parentPort2) {
+        console.error("not implemented");
+      } else {
+        globalThis.addEventListener("message", onMessageWrapper);
+      }
     }
     static removeEventListener(onMessage) {
       const onMessageWrapper = onMessageWrapperMap.get(onMessage);
       onMessageWrapperMap.delete(onMessage);
-      self.removeEventListener("message", onMessageWrapper);
+      const parentPort2 = getParentPort();
+      if (parentPort2) {
+        console.error("not implemented");
+      } else {
+        globalThis.removeEventListener("message", onMessageWrapper);
+      }
     }
     static postMessage(type, payload) {
-      if (self) {
-        const data = { source: "loaders.gl", type, payload };
-        const transferList = getTransferList(payload);
-        self.postMessage(data, transferList);
+      const data = { source: "loaders.gl", type, payload };
+      const transferList = getTransferList(payload);
+      const parentPort2 = getParentPort();
+      if (parentPort2) {
+        parentPort2.postMessage(data, transferList);
+      } else {
+        globalThis.postMessage(data, transferList);
       }
     }
   };
@@ -80,19 +111,20 @@
   // ../loader-utils/src/lib/worker-loader-utils/create-loader-worker.ts
   var requestId = 0;
   function createLoaderWorker(loader) {
-    if (typeof self === "undefined") {
+    if (!WorkerBody.inWorkerThread()) {
       return;
     }
     WorkerBody.onmessage = async (type, payload) => {
       switch (type) {
         case "process":
           try {
-            const { input, options = {} } = payload;
+            const { input, options = {}, context = {} } = payload;
             const result = await parseData({
               loader,
               arrayBuffer: input,
               options,
               context: {
+                ...context,
                 parse: parseOnMainThread
               }
             });
@@ -151,7 +183,7 @@
     return await parser(data, { ...options }, context, loader);
   }
 
-  // ../schema/src/category/mesh/mesh-utils.ts
+  // ../schema/src/lib/mesh/mesh-utils.ts
   function getMeshBoundingBox(attributes) {
     let minX = Infinity;
     let minY = Infinity;
@@ -178,436 +210,81 @@
     ];
   }
 
-  // ../schema/src/lib/utils/assert.ts
-  function assert(condition, message) {
-    if (!condition) {
-      throw new Error(message || "loader assertion failed.");
-    }
-  }
-
-  // ../schema/src/lib/schema/impl/schema.ts
-  var Schema = class {
-    constructor(fields, metadata) {
-      assert(Array.isArray(fields));
-      checkNames(fields);
-      this.fields = fields;
-      this.metadata = metadata || new Map();
-    }
-    compareTo(other) {
-      if (this.metadata !== other.metadata) {
-        return false;
-      }
-      if (this.fields.length !== other.fields.length) {
-        return false;
-      }
-      for (let i = 0; i < this.fields.length; ++i) {
-        if (!this.fields[i].compareTo(other.fields[i])) {
-          return false;
+  // 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");
         }
-      }
-      return true;
-    }
-    select(...columnNames) {
-      const nameMap = Object.create(null);
-      for (const name of columnNames) {
-        nameMap[name] = true;
-      }
-      const selectedFields = this.fields.filter((field) => nameMap[field.name]);
-      return new Schema(selectedFields, this.metadata);
-    }
-    selectAt(...columnIndices) {
-      const selectedFields = columnIndices.map((index) => this.fields[index]).filter(Boolean);
-      return new Schema(selectedFields, this.metadata);
-    }
-    assign(schemaOrFields) {
-      let fields;
-      let metadata = this.metadata;
-      if (schemaOrFields instanceof Schema) {
-        const otherSchema = schemaOrFields;
-        fields = otherSchema.fields;
-        metadata = mergeMaps(mergeMaps(new Map(), this.metadata), otherSchema.metadata);
+        if (inPtr + ctrl > inLength) {
+          throw new Error("Invalid compressed data");
+        }
+        do {
+          outData[outPtr++] = inData[inPtr++];
+        } while (--ctrl);
       } else {
-        fields = schemaOrFields;
-      }
-      const fieldMap = Object.create(null);
-      for (const field of this.fields) {
-        fieldMap[field.name] = field;
-      }
-      for (const field of fields) {
-        fieldMap[field.name] = field;
-      }
-      const mergedFields = Object.values(fieldMap);
-      return new Schema(mergedFields, metadata);
-    }
-  };
-  function checkNames(fields) {
-    const usedNames = {};
-    for (const field of fields) {
-      if (usedNames[field.name]) {
-        console.warn("Schema: duplicated field name", field.name, field);
+        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);
       }
-      usedNames[field.name] = true;
-    }
+    } while (inPtr < inLength);
+    return outData;
   }
-  function mergeMaps(m1, m2) {
-    return new Map([...m1 || new Map(), ...m2 || new Map()]);
-  }
-
-  // ../schema/src/lib/schema/impl/field.ts
-  var Field = class {
-    constructor(name, type, nullable = false, metadata = new Map()) {
-      this.name = name;
-      this.type = type;
-      this.nullable = nullable;
-      this.metadata = metadata;
-    }
-    get typeId() {
-      return this.type && this.type.typeId;
-    }
-    clone() {
-      return new Field(this.name, this.type, this.nullable, this.metadata);
-    }
-    compareTo(other) {
-      return this.name === other.name && this.type === other.type && this.nullable === other.nullable && this.metadata === other.metadata;
-    }
-    toString() {
-      return `${this.type}${this.nullable ? ", nullable" : ""}${this.metadata ? `, metadata: ${this.metadata}` : ""}`;
-    }
-  };
-
-  // ../schema/src/lib/schema/impl/enum.ts
-  var Type;
-  (function(Type2) {
-    Type2[Type2["NONE"] = 0] = "NONE";
-    Type2[Type2["Null"] = 1] = "Null";
-    Type2[Type2["Int"] = 2] = "Int";
-    Type2[Type2["Float"] = 3] = "Float";
-    Type2[Type2["Binary"] = 4] = "Binary";
-    Type2[Type2["Utf8"] = 5] = "Utf8";
-    Type2[Type2["Bool"] = 6] = "Bool";
-    Type2[Type2["Decimal"] = 7] = "Decimal";
-    Type2[Type2["Date"] = 8] = "Date";
-    Type2[Type2["Time"] = 9] = "Time";
-    Type2[Type2["Timestamp"] = 10] = "Timestamp";
-    Type2[Type2["Interval"] = 11] = "Interval";
-    Type2[Type2["List"] = 12] = "List";
-    Type2[Type2["Struct"] = 13] = "Struct";
-    Type2[Type2["Union"] = 14] = "Union";
-    Type2[Type2["FixedSizeBinary"] = 15] = "FixedSizeBinary";
-    Type2[Type2["FixedSizeList"] = 16] = "FixedSizeList";
-    Type2[Type2["Map"] = 17] = "Map";
-    Type2[Type2["Dictionary"] = -1] = "Dictionary";
-    Type2[Type2["Int8"] = -2] = "Int8";
-    Type2[Type2["Int16"] = -3] = "Int16";
-    Type2[Type2["Int32"] = -4] = "Int32";
-    Type2[Type2["Int64"] = -5] = "Int64";
-    Type2[Type2["Uint8"] = -6] = "Uint8";
-    Type2[Type2["Uint16"] = -7] = "Uint16";
-    Type2[Type2["Uint32"] = -8] = "Uint32";
-    Type2[Type2["Uint64"] = -9] = "Uint64";
-    Type2[Type2["Float16"] = -10] = "Float16";
-    Type2[Type2["Float32"] = -11] = "Float32";
-    Type2[Type2["Float64"] = -12] = "Float64";
-    Type2[Type2["DateDay"] = -13] = "DateDay";
-    Type2[Type2["DateMillisecond"] = -14] = "DateMillisecond";
-    Type2[Type2["TimestampSecond"] = -15] = "TimestampSecond";
-    Type2[Type2["TimestampMillisecond"] = -16] = "TimestampMillisecond";
-    Type2[Type2["TimestampMicrosecond"] = -17] = "TimestampMicrosecond";
-    Type2[Type2["TimestampNanosecond"] = -18] = "TimestampNanosecond";
-    Type2[Type2["TimeSecond"] = -19] = "TimeSecond";
-    Type2[Type2["TimeMillisecond"] = -20] = "TimeMillisecond";
-    Type2[Type2["TimeMicrosecond"] = -21] = "TimeMicrosecond";
-    Type2[Type2["TimeNanosecond"] = -22] = "TimeNanosecond";
-    Type2[Type2["DenseUnion"] = -23] = "DenseUnion";
-    Type2[Type2["SparseUnion"] = -24] = "SparseUnion";
-    Type2[Type2["IntervalDayTime"] = -25] = "IntervalDayTime";
-    Type2[Type2["IntervalYearMonth"] = -26] = "IntervalYearMonth";
-  })(Type || (Type = {}));
-
-  // ../schema/src/lib/schema/impl/type.ts
-  var DataType = class {
-    static isNull(x) {
-      return x && x.typeId === Type.Null;
-    }
-    static isInt(x) {
-      return x && x.typeId === Type.Int;
-    }
-    static isFloat(x) {
-      return x && x.typeId === Type.Float;
-    }
-    static isBinary(x) {
-      return x && x.typeId === Type.Binary;
-    }
-    static isUtf8(x) {
-      return x && x.typeId === Type.Utf8;
-    }
-    static isBool(x) {
-      return x && x.typeId === Type.Bool;
-    }
-    static isDecimal(x) {
-      return x && x.typeId === Type.Decimal;
-    }
-    static isDate(x) {
-      return x && x.typeId === Type.Date;
-    }
-    static isTime(x) {
-      return x && x.typeId === Type.Time;
-    }
-    static isTimestamp(x) {
-      return x && x.typeId === Type.Timestamp;
-    }
-    static isInterval(x) {
-      return x && x.typeId === Type.Interval;
-    }
-    static isList(x) {
-      return x && x.typeId === Type.List;
-    }
-    static isStruct(x) {
-      return x && x.typeId === Type.Struct;
-    }
-    static isUnion(x) {
-      return x && x.typeId === Type.Union;
-    }
-    static isFixedSizeBinary(x) {
-      return x && x.typeId === Type.FixedSizeBinary;
-    }
-    static isFixedSizeList(x) {
-      return x && x.typeId === Type.FixedSizeList;
-    }
-    static isMap(x) {
-      return x && x.typeId === Type.Map;
-    }
-    static isDictionary(x) {
-      return x && x.typeId === Type.Dictionary;
-    }
-    get typeId() {
-      return Type.NONE;
-    }
-    compareTo(other) {
-      return this === other;
-    }
-  };
-  var Null = class extends DataType {
-    get typeId() {
-      return Type.Null;
-    }
-    get [Symbol.toStringTag]() {
-      return "Null";
-    }
-    toString() {
-      return "Null";
-    }
-  };
-  var Bool = class extends DataType {
-    get typeId() {
-      return Type.Bool;
-    }
-    get [Symbol.toStringTag]() {
-      return "Bool";
-    }
-    toString() {
-      return "Bool";
-    }
-  };
-  var Int = class extends DataType {
-    constructor(isSigned, bitWidth) {
-      super();
-      this.isSigned = isSigned;
-      this.bitWidth = bitWidth;
-    }
-    get typeId() {
-      return Type.Int;
-    }
-    get [Symbol.toStringTag]() {
-      return "Int";
-    }
-    toString() {
-      return `${this.isSigned ? "I" : "Ui"}nt${this.bitWidth}`;
-    }
-  };
-  var Uint8 = class extends Int {
-    constructor() {
-      super(false, 8);
-    }
-  };
-  var Precision = {
-    HALF: 16,
-    SINGLE: 32,
-    DOUBLE: 64
-  };
-  var Float = class extends DataType {
-    constructor(precision) {
-      super();
-      this.precision = precision;
-    }
-    get typeId() {
-      return Type.Float;
-    }
-    get [Symbol.toStringTag]() {
-      return "Float";
-    }
-    toString() {
-      return `Float${this.precision}`;
-    }
-  };
-  var Float32 = class extends Float {
-    constructor() {
-      super(Precision.SINGLE);
-    }
-  };
-  var Binary = class extends DataType {
-    constructor() {
-      super();
-    }
-    get typeId() {
-      return Type.Binary;
-    }
-    toString() {
-      return "Binary";
-    }
-    get [Symbol.toStringTag]() {
-      return "Binary";
-    }
-  };
-  var Utf8 = class extends DataType {
-    get typeId() {
-      return Type.Utf8;
-    }
-    get [Symbol.toStringTag]() {
-      return "Utf8";
-    }
-    toString() {
-      return "Utf8";
-    }
-  };
-  var DateUnit = {
-    DAY: 0,
-    MILLISECOND: 1
-  };
-  var Date = class extends DataType {
-    constructor(unit) {
-      super();
-      this.unit = unit;
-    }
-    get typeId() {
-      return Type.Date;
-    }
-    get [Symbol.toStringTag]() {
-      return "Date";
-    }
-    toString() {
-      return `Date${(this.unit + 1) * 32}<${DateUnit[this.unit]}>`;
-    }
-  };
-  var TimeUnit = {
-    SECOND: 1,
-    MILLISECOND: 1e3,
-    MICROSECOND: 1e6,
-    NANOSECOND: 1e9
-  };
-  var Time = class extends DataType {
-    constructor(unit, bitWidth) {
-      super();
-      this.unit = unit;
-      this.bitWidth = bitWidth;
-    }
-    get typeId() {
-      return Type.Time;
-    }
-    toString() {
-      return `Time${this.bitWidth}<${TimeUnit[this.unit]}>`;
-    }
-    get [Symbol.toStringTag]() {
-      return "Time";
-    }
-  };
-  var Timestamp = class extends DataType {
-    constructor(unit, timezone = null) {
-      super();
-      this.unit = unit;
-      this.timezone = timezone;
-    }
-    get typeId() {
-      return Type.Timestamp;
-    }
-    get [Symbol.toStringTag]() {
-      return "Timestamp";
-    }
-    toString() {
-      return `Timestamp<${TimeUnit[this.unit]}${this.timezone ? `, ${this.timezone}` : ""}>`;
-    }
-  };
-  var IntervalUnit = {
-    DAY_TIME: 0,
-    YEAR_MONTH: 1
-  };
-  var Interval = class extends DataType {
-    constructor(unit) {
-      super();
-      this.unit = unit;
-    }
-    get typeId() {
-      return Type.Interval;
-    }
-    get [Symbol.toStringTag]() {
-      return "Interval";
-    }
-    toString() {
-      return `Interval<${IntervalUnit[this.unit]}>`;
-    }
-  };
-  var FixedSizeList = class extends DataType {
-    constructor(listSize, child) {
-      super();
-      this.listSize = listSize;
-      this.children = [child];
-    }
-    get typeId() {
-      return Type.FixedSizeList;
-    }
-    get valueType() {
-      return this.children[0].type;
-    }
-    get valueField() {
-      return this.children[0];
-    }
-    get [Symbol.toStringTag]() {
-      return "FixedSizeList";
-    }
-    toString() {
-      return `FixedSizeList[${this.listSize}]<${this.valueType}>`;
-    }
-  };
-  var Struct = class extends DataType {
-    constructor(children) {
-      super();
-      this.children = children;
-    }
-    get typeId() {
-      return Type.Struct;
-    }
-    toString() {
-      return `Struct<{${this.children.map((f) => `${f.name}:${f.type}`).join(", ")}}>`;
-    }
-    get [Symbol.toStringTag]() {
-      return "Struct";
-    }
-  };
 
   // src/lib/get-pcd-schema.ts
   function getPCDSchema(PCDheader, metadata) {
     const offset = PCDheader.offset;
     const fields = [];
     if (offset.x !== void 0) {
-      fields.push(new Field("POSITION", new FixedSizeList(3, new Field("xyz", new Float32())), false));
+      fields.push({
+        name: "POSITION",
+        type: { type: "fixed-size-list", listSize: 3, children: [{ name: "xyz", type: "float32" }] }
+      });
     }
     if (offset.normal_x !== void 0) {
-      fields.push(new Field("NORMAL", new FixedSizeList(3, new Field("xyz", new Float32())), false));
+      fields.push({
+        name: "NORMAL",
+        type: { type: "fixed-size-list", listSize: 3, children: [{ name: "xyz", type: "float32" }] }
+      });
     }
     if (offset.rgb !== void 0) {
-      fields.push(new Field("COLOR_0", new FixedSizeList(3, new Field("rgb", new Uint8())), false));
+      fields.push({
+        name: "COLOR_0",
+        type: { type: "fixed-size-list", listSize: 3, children: [{ name: "rgb", type: "uint8" }] }
+      });
     }
-    return new Schema(fields, metadata);
+    return { fields, metadata };
   }
 
   // src/lib/parse-pcd.ts
@@ -624,24 +301,25 @@
         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 = new Map([
+    const metadata = Object.fromEntries([
       ["mode", "0"],
       ["boundingBox", JSON.stringify(header.boundingBox)]
     ]);
     const schema = getPCDSchema(pcdHeader, metadata);
     return {
-      loaderData: {
-        header: pcdHeader
-      },
+      loader: "pcd",
+      loaderData: pcdHeader,
       header,
       schema,
       mode: 0,
-      indices: null,
+      topology: "point-list",
       attributes
     };
   }
@@ -653,7 +331,10 @@
         boundingBox: getMeshBoundingBox(attributes)
       };
     }
-    return pcdHeader;
+    return {
+      vertexCount: pcdHeader.vertexCount,
+      boundingBox: pcdHeader.boundingBox
+    };
   }
   function getMeshAttributes(attributes) {
     const normalizedAttributes = {
@@ -674,6 +355,18 @@
         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) {
@@ -751,6 +444,8 @@
     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");
@@ -775,6 +470,12 @@
           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 };
@@ -783,6 +484,8 @@
     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) {
@@ -801,12 +504,63 @@
         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 };
+    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
+    };
   }
 
   // src/pcd-loader.ts
-  var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var VERSION = true ? "4.0.0-alpha.6" : "latest";
   var PCDLoader = {
     name: "PCD (Point Cloud Data)",
     id: "pcd",
@@ -830,3 +584,10 @@
   // src/workers/pcd-worker.ts
   createLoaderWorker(PCDLoader2);
 })();
+/** 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]
+ */