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

package/dist/dist.min.js

@@ -0,0 +1,1241 @@
+(() => {
+  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 });
+  };
+
+  // src/ply-loader.ts
+  var VERSION, PLYLoader;
+  var init_ply_loader = __esm({
+    "src/ply-loader.ts"() {
+      VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      PLYLoader = {
+        name: "PLY",
+        id: "ply",
+        module: "ply",
+        shapes: ["mesh", "gltf", "columnar-table"],
+        version: VERSION,
+        worker: true,
+        extensions: ["ply"],
+        mimeTypes: ["text/plain", "application/octet-stream"],
+        text: true,
+        binary: true,
+        tests: ["ply"],
+        options: {
+          ply: {}
+        }
+      };
+    }
+  });
+
+  // ../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, 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/category/mesh/deduce-mesh-schema.ts
+  function deduceMeshSchema(attributes, metadata) {
+    const fields = deduceMeshFields(attributes);
+    return new Schema(fields, metadata);
+  }
+  function deduceMeshField(attributeName, attribute, optionalMetadata) {
+    const type = getArrowTypeFromTypedArray(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;
+  }
+  function deduceMeshFields(attributes) {
+    const fields = [];
+    for (const attributeName in attributes) {
+      const attribute = attributes[attributeName];
+      fields.push(deduceMeshField(attributeName, attribute));
+    }
+    return fields;
+  }
+  function makeMeshAttributeMetadata(attribute) {
+    const result = new Map();
+    if ("byteOffset" in attribute) {
+      result.set("byteOffset", attribute.byteOffset.toString(10));
+    }
+    if ("byteStride" in attribute) {
+      result.set("byteStride", attribute.byteStride.toString(10));
+    }
+    if ("normalized" in attribute) {
+      result.set("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/index.ts
+  var init_src = __esm({
+    "../schema/src/index.ts"() {
+      init_mesh_utils();
+      init_deduce_mesh_schema();
+    }
+  });
+
+  // src/lib/get-ply-schema.ts
+  function getPLYSchema(plyHeader, attributes) {
+    const metadataMap = makeMetadataFromPlyHeader(plyHeader);
+    const schema = deduceMeshSchema(attributes, metadataMap);
+    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));
+    if (plyHeader.format !== void 0) {
+      metadataMap.set("ply_format", plyHeader.format);
+    }
+    if (plyHeader.version !== void 0) {
+      metadataMap.set("ply_version", plyHeader.version);
+    }
+    if (plyHeader.headerLength !== void 0) {
+      metadataMap.set("ply_headerLength", plyHeader.headerLength.toString(10));
+    }
+    return metadataMap;
+  }
+  var init_get_ply_schema = __esm({
+    "src/lib/get-ply-schema.ts"() {
+      init_src();
+    }
+  });
+
+  // src/lib/normalize-ply.ts
+  function normalizePLY(plyHeader, plyAttributes, options) {
+    const attributes = getMeshAttributes(plyAttributes);
+    const boundingBox = getMeshBoundingBox(attributes);
+    const vertexCount = plyAttributes.indices.length || plyAttributes.vertices.length / 3;
+    const isTriangles = plyAttributes.indices && plyAttributes.indices.length > 0;
+    const mode = isTriangles ? 4 : 0;
+    const topology = isTriangles ? "triangle-list" : "point-list";
+    const schema = getPLYSchema(plyHeader, attributes);
+    const plyMesh = {
+      loader: "ply",
+      loaderData: plyHeader,
+      header: {
+        vertexCount,
+        boundingBox
+      },
+      schema,
+      attributes,
+      indices: { value: new Uint32Array(0), size: 0 },
+      mode,
+      topology
+    };
+    if (plyAttributes.indices.length > 0) {
+      plyMesh.indices = { value: new Uint32Array(plyAttributes.indices), size: 1 };
+    }
+    return plyMesh;
+  }
+  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 };
+    }
+    return accessors;
+  }
+  var init_normalize_ply = __esm({
+    "src/lib/normalize-ply.ts"() {
+      init_src();
+      init_get_ply_schema();
+    }
+  });
+
+  // src/lib/parse-ply.ts
+  function parsePLY(data, options = {}) {
+    let header;
+    let attributes;
+    if (data instanceof ArrayBuffer) {
+      const text = new TextDecoder().decode(data);
+      header = parseHeader(text, options);
+      attributes = header.format === "ascii" ? parseASCII(text, header) : parseBinary(data, header);
+    } else {
+      header = parseHeader(data, options);
+      attributes = parseASCII(data, header);
+    }
+    return normalizePLY(header, attributes);
+  }
+  function parseHeader(data, options) {
+    const PLY_HEADER_PATTERN = /ply([\s\S]*)end_header\s/;
+    let headerText = "";
+    let headerLength = 0;
+    const result = PLY_HEADER_PATTERN.exec(data);
+    if (result !== null) {
+      headerText = result[1];
+      headerLength = result[0].length;
+    }
+    const lines = headerText.split("\n");
+    const header = parseHeaderLines(lines, headerLength, options);
+    return header;
+  }
+  function parseHeaderLines(lines, headerLength, options) {
+    const header = {
+      comments: [],
+      elements: [],
+      headerLength
+    };
+    let lineType;
+    let lineValues;
+    let currentElement2 = null;
+    for (let i = 0; i < lines.length; i++) {
+      let line = lines[i];
+      line = line.trim();
+      if (line === "") {
+        continue;
+      }
+      lineValues = line.split(/\s+/);
+      lineType = lineValues.shift();
+      line = lineValues.join(" ");
+      switch (lineType) {
+        case "format":
+          header.format = lineValues[0];
+          header.version = lineValues[1];
+          break;
+        case "comment":
+          header.comments.push(line);
+          break;
+        case "element":
+          if (currentElement2) {
+            header.elements.push(currentElement2);
+          }
+          currentElement2 = {
+            name: lineValues[0],
+            count: parseInt(lineValues[1], 10),
+            properties: []
+          };
+          break;
+        case "property":
+          if (!currentElement2) {
+            break;
+          }
+          currentElement2.properties.push(makePLYElementProperty(lineValues, options.propertyNameMapping));
+          break;
+        default:
+          console.log("unhandled", lineType, lineValues);
+      }
+    }
+    if (currentElement2 !== void 0) {
+      header.elements.push(currentElement2);
+    }
+    return header;
+  }
+  function makePLYElementProperty(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];
+    }
+    return property;
+  }
+  function parseASCIINumber(n, type) {
+    switch (type) {
+      case "char":
+      case "uchar":
+      case "short":
+      case "ushort":
+      case "int":
+      case "uint":
+      case "int8":
+      case "uint8":
+      case "int16":
+      case "uint16":
+      case "int32":
+      case "uint32":
+        return parseInt(n, 10);
+      case "float":
+      case "double":
+      case "float32":
+      case "float64":
+        return parseFloat(n);
+      default:
+        throw new Error(type);
+    }
+  }
+  function parseASCIIElement(properties, line) {
+    const values = line.split(/\s+/);
+    const element = {};
+    for (let i = 0; i < properties.length; i++) {
+      if (properties[i].type === "list") {
+        const list = [];
+        const n = parseASCIINumber(values.shift(), properties[i].countType);
+        for (let j = 0; j < n; j++) {
+          list.push(parseASCIINumber(values.shift(), properties[i].itemType));
+        }
+        element[properties[i].name] = list;
+      } else {
+        element[properties[i].name] = parseASCIINumber(values.shift(), properties[i].type);
+      }
+    }
+    return element;
+  }
+  function parseASCII(data, header) {
+    const attributes = {
+      indices: [],
+      vertices: [],
+      normals: [],
+      uvs: [],
+      colors: []
+    };
+    let result;
+    const patternBody = /end_header\s([\s\S]*)$/;
+    let body = "";
+    if ((result = patternBody.exec(data)) !== null) {
+      body = result[1];
+    }
+    const lines = body.split("\n");
+    let currentElement2 = 0;
+    let currentElementCount = 0;
+    for (let i = 0; i < lines.length; i++) {
+      let line = lines[i];
+      line = line.trim();
+      if (line !== "") {
+        if (currentElementCount >= header.elements[currentElement2].count) {
+          currentElement2++;
+          currentElementCount = 0;
+        }
+        const element = parseASCIIElement(header.elements[currentElement2].properties, line);
+        handleElement(attributes, header.elements[currentElement2].name, element);
+        currentElementCount++;
+      }
+    }
+    return attributes;
+  }
+  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);
+      }
+    } else if (elementName === "face") {
+      const vertexIndices = element.vertex_indices || element.vertex_index;
+      if (vertexIndices.length === 3) {
+        buffer.indices.push(vertexIndices[0], vertexIndices[1], vertexIndices[2]);
+      } else if (vertexIndices.length === 4) {
+        buffer.indices.push(vertexIndices[0], vertexIndices[1], vertexIndices[3]);
+        buffer.indices.push(vertexIndices[1], vertexIndices[2], vertexIndices[3]);
+      }
+    }
+  }
+  function binaryRead(dataview, at, type, littleEndian) {
+    switch (type) {
+      case "int8":
+      case "char":
+        return [dataview.getInt8(at), 1];
+      case "uint8":
+      case "uchar":
+        return [dataview.getUint8(at), 1];
+      case "int16":
+      case "short":
+        return [dataview.getInt16(at, littleEndian), 2];
+      case "uint16":
+      case "ushort":
+        return [dataview.getUint16(at, littleEndian), 2];
+      case "int32":
+      case "int":
+        return [dataview.getInt32(at, littleEndian), 4];
+      case "uint32":
+      case "uint":
+        return [dataview.getUint32(at, littleEndian), 4];
+      case "float32":
+      case "float":
+        return [dataview.getFloat32(at, littleEndian), 4];
+      case "float64":
+      case "double":
+        return [dataview.getFloat64(at, littleEndian), 8];
+      default:
+        throw new Error(type);
+    }
+  }
+  function binaryReadElement(dataview, at, properties, littleEndian) {
+    const element = {};
+    let result;
+    let read = 0;
+    for (let i = 0; i < properties.length; i++) {
+      if (properties[i].type === "list") {
+        const list = [];
+        result = binaryRead(dataview, at + read, properties[i].countType, littleEndian);
+        const n = result[0];
+        read += result[1];
+        for (let j = 0; j < n; j++) {
+          result = binaryRead(dataview, at + read, properties[i].itemType, littleEndian);
+          list.push(result[0]);
+          read += result[1];
+        }
+        element[properties[i].name] = list;
+      } else {
+        result = binaryRead(dataview, at + read, properties[i].type, littleEndian);
+        element[properties[i].name] = result[0];
+        read += result[1];
+      }
+    }
+    return [element, read];
+  }
+  function parseBinary(data, header) {
+    const attributes = {
+      indices: [],
+      vertices: [],
+      normals: [],
+      uvs: [],
+      colors: []
+    };
+    const littleEndian = header.format === "binary_little_endian";
+    const body = new DataView(data, header.headerLength);
+    let result;
+    let loc = 0;
+    for (let currentElement2 = 0; currentElement2 < header.elements.length; currentElement2++) {
+      const count = header.elements[currentElement2].count;
+      for (let currentElementCount = 0; currentElementCount < count; currentElementCount++) {
+        result = binaryReadElement(body, loc, header.elements[currentElement2].properties, littleEndian);
+        loc += result[1];
+        const element = result[0];
+        handleElement(attributes, header.elements[currentElement2].name, element);
+      }
+    }
+    return attributes;
+  }
+  var init_parse_ply = __esm({
+    "src/lib/parse-ply.ts"() {
+      init_normalize_ply();
+    }
+  });
+
+  // ../loader-utils/src/lib/iterators/text-iterators.ts
+  async function* makeTextDecoderIterator(arrayBufferIterator, options = {}) {
+    const textDecoder = new TextDecoder(void 0, options);
+    for await (const arrayBuffer of arrayBufferIterator) {
+      yield typeof arrayBuffer === "string" ? arrayBuffer : textDecoder.decode(arrayBuffer, { stream: true });
+    }
+  }
+  async function* makeLineIterator(textIterator) {
+    let previous = "";
+    for await (const textChunk of textIterator) {
+      previous += textChunk;
+      let eolIndex;
+      while ((eolIndex = previous.indexOf("\n")) >= 0) {
+        const line = previous.slice(0, eolIndex + 1);
+        previous = previous.slice(eolIndex + 1);
+        yield line;
+      }
+    }
+    if (previous.length > 0) {
+      yield previous;
+    }
+  }
+  var init_text_iterators = __esm({
+    "../loader-utils/src/lib/iterators/text-iterators.ts"() {
+    }
+  });
+
+  // ../loader-utils/src/lib/iterators/async-iteration.ts
+  async function forEach(iterator, visitor) {
+    while (true) {
+      const { done, value } = await iterator.next();
+      if (done) {
+        iterator.return();
+        return;
+      }
+      const cancel = visitor(value);
+      if (cancel) {
+        return;
+      }
+    }
+  }
+  var init_async_iteration = __esm({
+    "../loader-utils/src/lib/iterators/async-iteration.ts"() {
+    }
+  });
+
+  // ../loader-utils/src/index.ts
+  var init_src2 = __esm({
+    "../loader-utils/src/index.ts"() {
+      init_text_iterators();
+      init_async_iteration();
+    }
+  });
+
+  // src/lib/parse-ply-in-batches.ts
+  async function* parsePLYInBatches(iterator, options) {
+    const lineIterator = makeLineIterator(makeTextDecoderIterator(iterator));
+    const header = await parsePLYHeader(lineIterator, options);
+    let attributes;
+    switch (header.format) {
+      case "ascii":
+        attributes = await parseASCII2(lineIterator, header);
+        break;
+      default:
+        throw new Error("Binary PLY can not yet be parsed in streaming mode");
+    }
+    yield normalizePLY(header, attributes, options);
+  }
+  async function parsePLYHeader(lineIterator, options) {
+    const header = {
+      comments: [],
+      elements: []
+    };
+    await forEach(lineIterator, (line) => {
+      line = line.trim();
+      if (line === "end_header") {
+        return true;
+      }
+      if (line === "") {
+        return false;
+      }
+      const lineValues = line.split(/\s+/);
+      const lineType = lineValues.shift();
+      line = lineValues.join(" ");
+      switch (lineType) {
+        case "ply":
+          break;
+        case "format":
+          header.format = lineValues[0];
+          header.version = lineValues[1];
+          break;
+        case "comment":
+          header.comments.push(line);
+          break;
+        case "element":
+          if (currentElement) {
+            header.elements.push(currentElement);
+          }
+          currentElement = {
+            name: lineValues[0],
+            count: parseInt(lineValues[1], 10),
+            properties: []
+          };
+          break;
+        case "property":
+          const property = makePLYElementProperty2(lineValues, options.propertyNameMapping);
+          currentElement.properties.push(property);
+          break;
+        default:
+          console.log("unhandled", lineType, lineValues);
+      }
+      return false;
+    });
+    if (currentElement) {
+      header.elements.push(currentElement);
+    }
+    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];
+    }
+    return property;
+  }
+  async function parseASCII2(lineIterator, header) {
+    const attributes = {
+      indices: [],
+      vertices: [],
+      normals: [],
+      uvs: [],
+      colors: []
+    };
+    let currentElement2 = 0;
+    let currentElementCount = 0;
+    for await (let line of lineIterator) {
+      line = line.trim();
+      if (line !== "") {
+        if (currentElementCount >= header.elements[currentElement2].count) {
+          currentElement2++;
+          currentElementCount = 0;
+        }
+        const element = parseASCIIElement2(header.elements[currentElement2].properties, line);
+        handleElement2(attributes, header.elements[currentElement2].name, element);
+        currentElementCount++;
+      }
+    }
+    return attributes;
+  }
+  function parseASCIINumber2(n, type) {
+    switch (type) {
+      case "char":
+      case "uchar":
+      case "short":
+      case "ushort":
+      case "int":
+      case "uint":
+      case "int8":
+      case "uint8":
+      case "int16":
+      case "uint16":
+      case "int32":
+      case "uint32":
+        return parseInt(n, 10);
+      case "float":
+      case "double":
+      case "float32":
+      case "float64":
+        return parseFloat(n);
+      default:
+        throw new Error(type);
+    }
+  }
+  function parseASCIIElement2(properties, line) {
+    const values = line.split(/\s+/);
+    const element = {};
+    for (let i = 0; i < properties.length; i++) {
+      if (properties[i].type === "list") {
+        const list = [];
+        const n = parseASCIINumber2(values.shift(), properties[i].countType);
+        for (let j = 0; j < n; j++) {
+          list.push(parseASCIINumber2(values.shift(), properties[i].itemType));
+        }
+        element[properties[i].name] = list;
+      } else {
+        element[properties[i].name] = parseASCIINumber2(values.shift(), properties[i].type);
+      }
+    }
+    return element;
+  }
+  function handleElement2(buffer, elementName, element = {}) {
+    switch (elementName) {
+      case "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 / 255, element.green / 255, element.blue / 255);
+        }
+        break;
+      case "face":
+        const vertexIndices = element.vertex_indices || element.vertex_index;
+        if (vertexIndices.length === 3) {
+          buffer.indices.push(vertexIndices[0], vertexIndices[1], vertexIndices[2]);
+        } else if (vertexIndices.length === 4) {
+          buffer.indices.push(vertexIndices[0], vertexIndices[1], vertexIndices[3]);
+          buffer.indices.push(vertexIndices[1], vertexIndices[2], vertexIndices[3]);
+        }
+        break;
+      default:
+        break;
+    }
+  }
+  var currentElement;
+  var init_parse_ply_in_batches = __esm({
+    "src/lib/parse-ply-in-batches.ts"() {
+      init_src2();
+      init_normalize_ply();
+    }
+  });
+
+  // src/index.ts
+  var src_exports = {};
+  __export(src_exports, {
+    PLYLoader: () => PLYLoader2,
+    PLYWorkerLoader: () => PLYLoader,
+    _typecheckPLYLoader: () => _typecheckPLYLoader
+  });
+  var PLYLoader2, _typecheckPLYLoader;
+  var init_src3 = __esm({
+    "src/index.ts"() {
+      init_ply_loader();
+      init_parse_ply();
+      init_parse_ply_in_batches();
+      PLYLoader2 = {
+        ...PLYLoader,
+        parse: async (arrayBuffer, options) => parsePLY(arrayBuffer, options),
+        parseTextSync: parsePLY,
+        parseSync: parsePLY,
+        parseInBatches: parsePLYInBatches
+      };
+      _typecheckPLYLoader = PLYLoader2;
+    }
+  });
+
+  // src/bundle.ts
+  var require_bundle = __commonJS({
+    "src/bundle.ts"(exports, module) {
+      var moduleExports = (init_src3(), src_exports);
+      globalThis.loaders = globalThis.loaders || {};
+      module.exports = Object.assign(globalThis.loaders, moduleExports);
+    }
+  });
+  require_bundle();
+})();