@loaders.gl/ply 4.0.0-alpha.5 → 4.0.0-alpha.6

package/dist/dist.min.js

@@ -22,7 +22,6 @@
         name: "PLY",
         id: "ply",
         module: "ply",
-        shapes: ["mesh", "gltf", "columnar-table"],
         version: VERSION,
         worker: true,
         extensions: ["ply"],
@@ -37,7 +36,36 @@
     }
   });
 
-  // ../schema/src/category/mesh/mesh-utils.ts
+  // ../schema/src/lib/table/simple-table/data-type.ts
+  function getDataTypeFromTypedArray(array) {
+    switch (array.constructor) {
+      case Int8Array:
+        return "int8";
+      case Uint8Array:
+      case Uint8ClampedArray:
+        return "uint8";
+      case Int16Array:
+        return "int16";
+      case Uint16Array:
+        return "uint16";
+      case Int32Array:
+        return "int32";
+      case Uint32Array:
+        return "uint32";
+      case Float32Array:
+        return "float32";
+      case Float64Array:
+        return "float64";
+      default:
+        return "null";
+    }
+  }
+  var init_data_type = __esm({
+    "../schema/src/lib/table/simple-table/data-type.ts"() {
+    }
+  });
+
+  // ../schema/src/lib/mesh/mesh-utils.ts
   function getMeshBoundingBox(attributes) {
     let minX = Infinity;
     let minY = Infinity;
@@ -64,529 +92,24 @@
     ];
   }
   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, Int8, Int16, Int32, Uint8, Uint16, Uint32, Precision, Float, Float32, Float64, 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}`;
-        }
-      };
-      Int8 = class extends Int {
-        constructor() {
-          super(true, 8);
-        }
-      };
-      Int16 = class extends Int {
-        constructor() {
-          super(true, 16);
-        }
-      };
-      Int32 = class extends Int {
-        constructor() {
-          super(true, 32);
-        }
-      };
-      Uint8 = class extends Int {
-        constructor() {
-          super(false, 8);
-        }
-      };
-      Uint16 = class extends Int {
-        constructor() {
-          super(false, 16);
-        }
-      };
-      Uint32 = class extends Int {
-        constructor() {
-          super(false, 32);
-        }
-      };
-      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);
-        }
-      };
-      Float64 = class extends Float {
-        constructor() {
-          super(Precision.DOUBLE);
-        }
-      };
-      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/lib/arrow/arrow-like-type-utils.ts
-  function getArrowTypeFromTypedArray(array) {
-    switch (array.constructor) {
-      case Int8Array:
-        return new Int8();
-      case Uint8Array:
-        return new Uint8();
-      case Int16Array:
-        return new Int16();
-      case Uint16Array:
-        return new Uint16();
-      case Int32Array:
-        return new Int32();
-      case Uint32Array:
-        return new Uint32();
-      case Float32Array:
-        return new Float32();
-      case Float64Array:
-        return new Float64();
-      default:
-        throw new Error("array type not supported");
-    }
-  }
-  var init_arrow_like_type_utils = __esm({
-    "../schema/src/lib/arrow/arrow-like-type-utils.ts"() {
-      init_schema2();
+    "../schema/src/lib/mesh/mesh-utils.ts"() {
     }
   });
 
-  // ../schema/src/category/mesh/deduce-mesh-schema.ts
-  function deduceMeshSchema(attributes, metadata) {
+  // ../schema/src/lib/mesh/deduce-mesh-schema.ts
+  function deduceMeshSchema(attributes, metadata = {}) {
     const fields = deduceMeshFields(attributes);
-    return new Schema(fields, metadata);
+    return { fields, metadata };
   }
-  function deduceMeshField(attributeName, attribute, optionalMetadata) {
-    const type = getArrowTypeFromTypedArray(attribute.value);
+  function deduceMeshField(name, attribute, optionalMetadata) {
+    const type = getDataTypeFromTypedArray(attribute.value);
     const metadata = optionalMetadata ? optionalMetadata : makeMeshAttributeMetadata(attribute);
-    const field = new Field(attributeName, new FixedSizeList(attribute.size, new Field("value", type)), false, metadata);
-    return field;
+    return {
+      name,
+      type: { type: "fixed-size-list", listSize: attribute.size, children: [{ name: "value", type }] },
+      nullable: false,
+      metadata
+    };
   }
   function deduceMeshFields(attributes) {
     const fields = [];
@@ -597,22 +120,21 @@
     return fields;
   }
   function makeMeshAttributeMetadata(attribute) {
-    const result = new Map();
+    const result = {};
     if ("byteOffset" in attribute) {
-      result.set("byteOffset", attribute.byteOffset.toString(10));
+      result.byteOffset = attribute.byteOffset.toString(10);
     }
     if ("byteStride" in attribute) {
-      result.set("byteStride", attribute.byteStride.toString(10));
+      result.byteStride = attribute.byteStride.toString(10);
     }
     if ("normalized" in attribute) {
-      result.set("normalized", attribute.normalized.toString());
+      result.normalized = attribute.normalized.toString();
     }
     return result;
   }
   var init_deduce_mesh_schema = __esm({
-    "../schema/src/category/mesh/deduce-mesh-schema.ts"() {
-      init_schema2();
-      init_arrow_like_type_utils();
+    "../schema/src/lib/mesh/deduce-mesh-schema.ts"() {
+      init_data_type();
     }
   });
 
@@ -626,24 +148,24 @@
 
   // src/lib/get-ply-schema.ts
   function getPLYSchema(plyHeader, attributes) {
-    const metadataMap = makeMetadataFromPlyHeader(plyHeader);
-    const schema = deduceMeshSchema(attributes, metadataMap);
+    const metadata = makeMetadataFromPlyHeader(plyHeader);
+    const schema = deduceMeshSchema(attributes, metadata);
     return schema;
   }
   function makeMetadataFromPlyHeader(plyHeader) {
-    const metadataMap = new Map();
-    metadataMap.set("ply_comments", JSON.stringify(plyHeader.comments));
-    metadataMap.set("ply_elements", JSON.stringify(plyHeader.elements));
+    const metadata = {};
+    metadata.ply_comments = JSON.stringify(plyHeader.comments);
+    metadata.ply_elements = JSON.stringify(plyHeader.elements);
     if (plyHeader.format !== void 0) {
-      metadataMap.set("ply_format", plyHeader.format);
+      metadata.ply_format = plyHeader.format;
     }
     if (plyHeader.version !== void 0) {
-      metadataMap.set("ply_version", plyHeader.version);
+      metadata.ply_version = plyHeader.version;
     }
     if (plyHeader.headerLength !== void 0) {
-      metadataMap.set("ply_headerLength", plyHeader.headerLength.toString(10));
+      metadata.ply_headerLength = plyHeader.headerLength.toString(10);
     }
-    return metadataMap;
+    return metadata;
   }
   var init_get_ply_schema = __esm({
     "src/lib/get-ply-schema.ts"() {
@@ -680,15 +202,36 @@
   }
   function getMeshAttributes(attributes) {
     const accessors = {};
-    accessors.POSITION = { value: new Float32Array(attributes.vertices), size: 3 };
-    if (attributes.normals.length > 0) {
-      accessors.NORMAL = { value: new Float32Array(attributes.normals), size: 3 };
-    }
-    if (attributes.uvs.length > 0) {
-      accessors.TEXCOORD_0 = { value: new Float32Array(attributes.uvs), size: 2 };
-    }
-    if (attributes.colors.length > 0) {
-      accessors.COLOR_0 = { value: new Uint8Array(attributes.colors), size: 3, normalized: true };
+    for (const attributeName of Object.keys(attributes)) {
+      switch (attributeName) {
+        case "vertices":
+          if (attributes.vertices.length > 0) {
+            accessors.POSITION = { value: new Float32Array(attributes.vertices), size: 3 };
+          }
+          break;
+        case "normals":
+          if (attributes.normals.length > 0) {
+            accessors.NORMAL = { value: new Float32Array(attributes.normals), size: 3 };
+          }
+          break;
+        case "uvs":
+          if (attributes.uvs.length > 0) {
+            accessors.TEXCOORD_0 = { value: new Float32Array(attributes.uvs), size: 2 };
+          }
+          break;
+        case "colors":
+          if (attributes.colors.length > 0) {
+            accessors.COLOR_0 = { value: new Uint8Array(attributes.colors), size: 3, normalized: true };
+          }
+          break;
+        case "indices":
+          break;
+        default:
+          if (attributes[attributeName].length > 0) {
+            accessors[attributeName] = { value: new Float32Array(attributes[attributeName]), size: 1 };
+          }
+          break;
+      }
     }
     return accessors;
   }
@@ -763,35 +306,72 @@
           };
           break;
         case "property":
-          if (!currentElement2) {
-            break;
+          if (currentElement2) {
+            const property = makePLYElementProperty(lineValues);
+            if (options?.propertyNameMapping && property.name in options?.propertyNameMapping) {
+              property.name = options?.propertyNameMapping[property.name];
+            }
+            currentElement2.properties.push(property);
           }
-          currentElement2.properties.push(makePLYElementProperty(lineValues, options.propertyNameMapping));
           break;
         default:
           console.log("unhandled", lineType, lineValues);
       }
     }
-    if (currentElement2 !== void 0) {
+    if (currentElement2) {
       header.elements.push(currentElement2);
     }
     return header;
   }
-  function makePLYElementProperty(propertValues, propertyNameMapping) {
-    const property = {
-      type: propertValues[0]
+  function getPLYAttributes(header) {
+    const attributes = {
+      indices: [],
+      vertices: [],
+      normals: [],
+      uvs: [],
+      colors: []
     };
-    if (property.type === "list") {
-      property.name = propertValues[3];
-      property.countType = propertValues[1];
-      property.itemType = propertValues[2];
-    } else {
-      property.name = propertValues[1];
+    for (const element of header.elements) {
+      if (element.name === "vertex") {
+        for (const property of element.properties) {
+          switch (property.name) {
+            case "x":
+            case "y":
+            case "z":
+            case "nx":
+            case "ny":
+            case "nz":
+            case "s":
+            case "t":
+            case "red":
+            case "green":
+            case "blue":
+              break;
+            default:
+              attributes[property.name] = [];
+              break;
+          }
+        }
+      }
     }
-    if (propertyNameMapping && property.name in propertyNameMapping) {
-      property.name = propertyNameMapping[property.name];
+    return attributes;
+  }
+  function makePLYElementProperty(propertyValues) {
+    const type = propertyValues[0];
+    switch (type) {
+      case "list":
+        return {
+          type,
+          name: propertyValues[3],
+          countType: propertyValues[1],
+          itemType: propertyValues[2]
+        };
+      default:
+        return {
+          type,
+          name: propertyValues[1]
+        };
     }
-    return property;
   }
   function parseASCIINumber(n, type) {
     switch (type) {
@@ -817,7 +397,7 @@
         throw new Error(type);
     }
   }
-  function parseASCIIElement(properties, line) {
+  function parsePLYElement(properties, line) {
     const values = line.split(/\s+/);
     const element = {};
     for (let i = 0; i < properties.length; i++) {
@@ -835,13 +415,7 @@
     return element;
   }
   function parseASCII(data, header) {
-    const attributes = {
-      indices: [],
-      vertices: [],
-      normals: [],
-      uvs: [],
-      colors: []
-    };
+    const attributes = getPLYAttributes(header);
     let result;
     const patternBody = /end_header\s([\s\S]*)$/;
     let body = "";
@@ -859,7 +433,7 @@
           currentElement2++;
           currentElementCount = 0;
         }
-        const element = parseASCIIElement(header.elements[currentElement2].properties, line);
+        const element = parsePLYElement(header.elements[currentElement2].properties, line);
         handleElement(attributes, header.elements[currentElement2].name, element);
         currentElementCount++;
       }
@@ -868,15 +442,40 @@
   }
   function handleElement(buffer, elementName, element = {}) {
     if (elementName === "vertex") {
-      buffer.vertices.push(element.x, element.y, element.z);
-      if ("nx" in element && "ny" in element && "nz" in element) {
-        buffer.normals.push(element.nx, element.ny, element.nz);
-      }
-      if ("s" in element && "t" in element) {
-        buffer.uvs.push(element.s, element.t);
-      }
-      if ("red" in element && "green" in element && "blue" in element) {
-        buffer.colors.push(element.red, element.green, element.blue);
+      for (const propertyName of Object.keys(element)) {
+        switch (propertyName) {
+          case "x":
+            buffer.vertices.push(element.x, element.y, element.z);
+            break;
+          case "y":
+          case "z":
+            break;
+          case "nx":
+            if ("nx" in element && "ny" in element && "nz" in element) {
+              buffer.normals.push(element.nx, element.ny, element.nz);
+            }
+            break;
+          case "ny":
+          case "nz":
+            break;
+          case "s":
+            if ("s" in element && "t" in element) {
+              buffer.uvs.push(element.s, element.t);
+            }
+            break;
+          case "t":
+            break;
+          case "red":
+            if ("red" in element && "green" in element && "blue" in element) {
+              buffer.colors.push(element.red, element.green, element.blue);
+            }
+            break;
+          case "green":
+          case "blue":
+            break;
+          default:
+            buffer[propertyName].push(element[propertyName]);
+        }
       }
     } else if (elementName === "face") {
       const vertexIndices = element.vertex_indices || element.vertex_index;
@@ -943,13 +542,7 @@
     return [element, read];
   }
   function parseBinary(data, header) {
-    const attributes = {
-      indices: [],
-      vertices: [],
-      normals: [],
-      uvs: [],
-      colors: []
-    };
+    const attributes = getPLYAttributes(header);
     const littleEndian = header.format === "binary_little_endian";
     const body = new DataView(data, header.headerLength);
     let result;
@@ -1089,21 +682,22 @@
     }
     return header;
   }
-  function makePLYElementProperty2(propertValues, propertyNameMapping) {
-    const property = {
-      type: propertValues[0]
-    };
-    if (property.type === "list") {
-      property.name = propertValues[3];
-      property.countType = propertValues[1];
-      property.itemType = propertValues[2];
-    } else {
-      property.name = propertValues[1];
-    }
-    if (propertyNameMapping && property.name in propertyNameMapping) {
-      property.name = propertyNameMapping[property.name];
+  function makePLYElementProperty2(propertyValues, propertyNameMapping) {
+    const type = propertyValues[0];
+    switch (type) {
+      case "list":
+        return {
+          type,
+          name: propertyValues[3],
+          countType: propertyValues[1],
+          itemType: propertyValues[2]
+        };
+      default:
+        return {
+          type,
+          name: propertyValues[1]
+        };
     }
-    return property;
   }
   async function parseASCII2(lineIterator, header) {
     const attributes = {
@@ -1122,7 +716,7 @@
           currentElement2++;
           currentElementCount = 0;
         }
-        const element = parseASCIIElement2(header.elements[currentElement2].properties, line);
+        const element = parsePLYElement2(header.elements[currentElement2].properties, line);
         handleElement2(attributes, header.elements[currentElement2].name, element);
         currentElementCount++;
       }
@@ -1153,7 +747,7 @@
         throw new Error(type);
     }
   }
-  function parseASCIIElement2(properties, line) {
+  function parsePLYElement2(properties, line) {
     const values = line.split(/\s+/);
     const element = {};
     for (let i = 0; i < properties.length; i++) {
@@ -1209,10 +803,9 @@
   var src_exports = {};
   __export(src_exports, {
     PLYLoader: () => PLYLoader2,
-    PLYWorkerLoader: () => PLYLoader,
-    _typecheckPLYLoader: () => _typecheckPLYLoader
+    PLYWorkerLoader: () => PLYLoader
   });
-  var PLYLoader2, _typecheckPLYLoader;
+  var PLYLoader2;
   var init_src3 = __esm({
     "src/index.ts"() {
       init_ply_loader();
@@ -1220,12 +813,11 @@
       init_parse_ply_in_batches();
       PLYLoader2 = {
         ...PLYLoader,
-        parse: async (arrayBuffer, options) => parsePLY(arrayBuffer, options),
-        parseTextSync: parsePLY,
-        parseSync: parsePLY,
-        parseInBatches: parsePLYInBatches
+        parse: async (arrayBuffer, options) => parsePLY(arrayBuffer, options?.ply),
+        parseTextSync: (arrayBuffer, options) => parsePLY(arrayBuffer, options?.ply),
+        parseSync: (arrayBuffer, options) => parsePLY(arrayBuffer, options?.ply),
+        parseInBatches: (arrayBuffer, options) => parsePLYInBatches(arrayBuffer, options?.ply)
       };
-      _typecheckPLYLoader = PLYLoader2;
     }
   });