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

package/dist/dist.min.js

@@ -0,0 +1,870 @@
+(() => {
+  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/category/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/category/mesh/mesh-utils.ts"() {
+    }
+  });
+
+  // ../schema/src/lib/utils/assert.ts
+  function assert(condition, message) {
+    if (!condition) {
+      throw new Error(message || "loader assertion failed.");
+    }
+  }
+  var init_assert = __esm({
+    "../schema/src/lib/utils/assert.ts"() {
+    }
+  });
+
+  // ../schema/src/lib/schema/impl/schema.ts
+  function checkNames(fields) {
+    const usedNames = {};
+    for (const field of fields) {
+      if (usedNames[field.name]) {
+        console.warn("Schema: duplicated field name", field.name, field);
+      }
+      usedNames[field.name] = true;
+    }
+  }
+  function mergeMaps(m1, m2) {
+    return new Map([...m1 || new Map(), ...m2 || new Map()]);
+  }
+  var Schema;
+  var init_schema = __esm({
+    "../schema/src/lib/schema/impl/schema.ts"() {
+      init_assert();
+      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;
+            }
+          }
+          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);
+          } 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);
+        }
+      };
+    }
+  });
+
+  // ../schema/src/lib/schema/impl/field.ts
+  var Field;
+  var init_field = __esm({
+    "../schema/src/lib/schema/impl/field.ts"() {
+      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;
+  var init_enum = __esm({
+    "../schema/src/lib/schema/impl/enum.ts"() {
+      (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, Null, Bool, Int, Uint8, Precision, Float, Float32, Binary, Utf8, DateUnit, Date, TimeUnit, Time, Timestamp, IntervalUnit, Interval, FixedSizeList, Struct;
+  var init_type = __esm({
+    "../schema/src/lib/schema/impl/type.ts"() {
+      init_enum();
+      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;
+        }
+      };
+      Null = class extends DataType {
+        get typeId() {
+          return Type.Null;
+        }
+        get [Symbol.toStringTag]() {
+          return "Null";
+        }
+        toString() {
+          return "Null";
+        }
+      };
+      Bool = class extends DataType {
+        get typeId() {
+          return Type.Bool;
+        }
+        get [Symbol.toStringTag]() {
+          return "Bool";
+        }
+        toString() {
+          return "Bool";
+        }
+      };
+      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}`;
+        }
+      };
+      Uint8 = class extends Int {
+        constructor() {
+          super(false, 8);
+        }
+      };
+      Precision = {
+        HALF: 16,
+        SINGLE: 32,
+        DOUBLE: 64
+      };
+      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}`;
+        }
+      };
+      Float32 = class extends Float {
+        constructor() {
+          super(Precision.SINGLE);
+        }
+      };
+      Binary = class extends DataType {
+        constructor() {
+          super();
+        }
+        get typeId() {
+          return Type.Binary;
+        }
+        toString() {
+          return "Binary";
+        }
+        get [Symbol.toStringTag]() {
+          return "Binary";
+        }
+      };
+      Utf8 = class extends DataType {
+        get typeId() {
+          return Type.Utf8;
+        }
+        get [Symbol.toStringTag]() {
+          return "Utf8";
+        }
+        toString() {
+          return "Utf8";
+        }
+      };
+      DateUnit = {
+        DAY: 0,
+        MILLISECOND: 1
+      };
+      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]}>`;
+        }
+      };
+      TimeUnit = {
+        SECOND: 1,
+        MILLISECOND: 1e3,
+        MICROSECOND: 1e6,
+        NANOSECOND: 1e9
+      };
+      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";
+        }
+      };
+      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}` : ""}>`;
+        }
+      };
+      IntervalUnit = {
+        DAY_TIME: 0,
+        YEAR_MONTH: 1
+      };
+      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]}>`;
+        }
+      };
+      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}>`;
+        }
+      };
+      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";
+        }
+      };
+    }
+  });
+
+  // ../schema/src/lib/schema/schema.ts
+  var init_schema2 = __esm({
+    "../schema/src/lib/schema/schema.ts"() {
+      init_schema();
+      init_field();
+      init_type();
+    }
+  });
+
+  // ../schema/src/index.ts
+  var init_src = __esm({
+    "../schema/src/index.ts"() {
+      init_mesh_utils();
+      init_schema2();
+    }
+  });
+
+  // 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(new Field("POSITION", new FixedSizeList(3, new Field("xyz", new Float32())), false));
+    }
+    if (offset.normal_x !== void 0) {
+      fields.push(new Field("NORMAL", new FixedSizeList(3, new Field("xyz", new Float32())), false));
+    }
+    if (offset.rgb !== void 0) {
+      fields.push(new Field("COLOR_0", new FixedSizeList(3, new Field("rgb", new Uint8())), false));
+    }
+    return new Schema(fields, metadata);
+  }
+  var init_get_pcd_schema = __esm({
+    "src/lib/get-pcd-schema.ts"() {
+      init_src();
+    }
+  });
+
+  // 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 = new Map([
+      ["mode", "0"],
+      ["boundingBox", JSON.stringify(header.boundingBox)]
+    ]);
+    const schema = getPCDSchema(pcdHeader, metadata);
+    return {
+      loaderData: {
+        header: pcdHeader
+      },
+      header,
+      schema,
+      mode: 0,
+      indices: null,
+      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 pcdHeader;
+  }
+  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
+      };
+    }
+    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 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]));
+        }
+      }
+    }
+    return { position, normal, color };
+  }
+  function parsePCDBinary(pcdHeader, data) {
+    const position = [];
+    const normal = [];
+    const color = [];
+    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));
+      }
+    }
+    return { position, normal, color };
+  }
+  function parsePCDBinaryCompressed(PCDheader, data) {
+    const position = [];
+    const normal = [];
+    const color = [];
+    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));
+      }
+    }
+    return {
+      position,
+      normal,
+      color
+    };
+  }
+  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]
+ */