@loaders.gl/pointclouds 0.0.0-stage → 5.0.0-beta.10

package/dist/ply/lib/parse-ply.cjs

@@ -0,0 +1,758 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/ply/lib/parse-ply.ts
+var parse_ply_exports = {};
+__export(parse_ply_exports, {
+  getPLYBinaryPointCloudParsePlan: () => getPLYBinaryPointCloudParsePlan,
+  parsePLY: () => parsePLY,
+  parsePLYBinaryPointCloudRecordsToArrowTable: () => parsePLYBinaryPointCloudRecordsToArrowTable,
+  parsePLYBinaryPointCloudToArrowTable: () => parsePLYBinaryPointCloudToArrowTable,
+  parsePLYHeader: () => parsePLYHeader,
+  parsePLYToArrowTable: () => parsePLYToArrowTable
+});
+module.exports = __toCommonJS(parse_ply_exports);
+var arrow = __toESM(require("apache-arrow"), 1);
+var import_schema_utils = require("@loaders.gl/core/schema-utils");
+var import_normalize_ply = __toESM(require("./normalize-ply.cjs"), 1);
+var import_get_ply_schema = require("./get-ply-schema.cjs");
+var PLY_END_HEADER = "end_header";
+function parsePLY(data, options = {}) {
+  let header;
+  let attributes;
+  if (data instanceof ArrayBuffer) {
+    header = parsePLYHeader(data, options);
+    attributes = header.format === "ascii" ? parseASCII(new TextDecoder().decode(data), header) : parseBinary(data, header, options);
+  } else {
+    header = parsePLYHeader(data, options);
+    attributes = parseASCII(data, header);
+  }
+  return (0, import_normalize_ply.default)(header, attributes);
+}
+function parsePLYToArrowTable(data, options = {}) {
+  if (!(data instanceof ArrayBuffer)) {
+    return null;
+  }
+  const header = parsePLYHeader(data, options);
+  if (header.format === "ascii") {
+    return null;
+  }
+  const attributes = parseBinaryPointCloud(data, header, options);
+  if (!attributes) {
+    return null;
+  }
+  return makePLYArrowTable(header, attributes);
+}
+function parsePLYBinaryPointCloudToArrowTable(data, header, options = {}) {
+  const attributes = parseBinaryPointCloud(data, header, options);
+  return attributes ? makePLYArrowTable(header, attributes) : null;
+}
+function parsePLYBinaryPointCloudRecordsToArrowTable(records, header, options = {}, plan) {
+  const attributes = parseBinaryPointCloudRecords(records, header, options, plan);
+  return attributes ? makePLYArrowTable(header, attributes) : null;
+}
+function parsePLYHeader(data, options) {
+  const { headerText, headerLength } = data instanceof ArrayBuffer ? getBinaryHeader(data) : getTextHeader(data);
+  const headerStart = headerText.indexOf("ply");
+  const headerEndMarker = headerText.lastIndexOf("end_header");
+  const headerEnd = headerEndMarker + "end_header".length;
+  if (headerStart >= 0 && headerEndMarker >= headerStart + 3 && headerEnd < headerText.length && /\s/.test(headerText[headerEnd])) {
+    const lines = headerText.slice(headerStart + 3, headerEndMarker).split("\n");
+    const header = parseHeaderLines(lines, headerLength || headerEnd + 1 - headerStart, options);
+    return header;
+  }
+  return parseHeaderLines([], headerLength, options);
+}
+function getBinaryHeader(data) {
+  const bytes = new Uint8Array(data);
+  const headerEnd = findHeaderEnd(bytes);
+  return {
+    headerText: new TextDecoder().decode(bytes.subarray(0, headerEnd)),
+    headerLength: headerEnd
+  };
+}
+function getTextHeader(data) {
+  const headerEnd = data.indexOf(PLY_END_HEADER);
+  if (headerEnd === -1) {
+    return { headerText: "", headerLength: 0 };
+  }
+  let headerLength = headerEnd + PLY_END_HEADER.length;
+  if (data[headerLength] === "\r" && data[headerLength + 1] === "\n") {
+    headerLength += 2;
+  } else if (headerLength < data.length && /\s/.test(data[headerLength])) {
+    headerLength += 1;
+  }
+  return { headerText: data.slice(0, headerLength), headerLength };
+}
+function findHeaderEnd(bytes) {
+  const pattern = new TextEncoder().encode(PLY_END_HEADER);
+  const lastPatternStart = bytes.length - pattern.length;
+  for (let byteIndex = 0; byteIndex <= lastPatternStart; byteIndex++) {
+    let matches = true;
+    for (let patternIndex = 0; patternIndex < pattern.length; patternIndex++) {
+      if (bytes[byteIndex + patternIndex] !== pattern[patternIndex]) {
+        matches = false;
+        break;
+      }
+    }
+    if (matches) {
+      let headerEnd = byteIndex + pattern.length;
+      if (bytes[headerEnd] === 13 && bytes[headerEnd + 1] === 10) {
+        headerEnd += 2;
+      } else if (headerEnd < bytes.length && isWhitespaceByte(bytes[headerEnd])) {
+        headerEnd += 1;
+      }
+      return headerEnd;
+    }
+  }
+  return bytes.length;
+}
+function isWhitespaceByte(byte) {
+  return byte === 10 || byte === 13 || byte === 9 || byte === 32;
+}
+function parseHeaderLines(lines, headerLength, options) {
+  const header = {
+    comments: [],
+    elements: [],
+    headerLength
+  };
+  let lineType;
+  let lineValues;
+  let currentElement = 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 (currentElement) {
+          header.elements.push(currentElement);
+        }
+        currentElement = {
+          name: lineValues[0],
+          count: parseInt(lineValues[1], 10),
+          properties: []
+        };
+        break;
+      case "property":
+        if (currentElement) {
+          const property = makePLYElementProperty(lineValues);
+          if (options?.propertyNameMapping && property.name in options?.propertyNameMapping) {
+            property.name = options?.propertyNameMapping[property.name];
+          }
+          currentElement.properties.push(property);
+        }
+        break;
+      default:
+    }
+  }
+  if (currentElement) {
+    header.elements.push(currentElement);
+  }
+  return header;
+}
+function getPLYAttributes(header) {
+  const attributes = {
+    indices: [],
+    vertices: [],
+    normals: [],
+    uvs: [],
+    colors: []
+  };
+  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;
+        }
+      }
+    }
+  }
+  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]
+      };
+  }
+}
+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 parsePLYElement(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 = getPLYAttributes(header);
+  const patternBody = /end_header\s([\s\S]*)$/;
+  let body = "";
+  const result = patternBody.exec(data);
+  if (result !== null) {
+    body = result[1];
+  }
+  const lines = body.split("\n");
+  let currentElement = 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[currentElement].count) {
+        currentElement++;
+        currentElementCount = 0;
+      }
+      const element = parsePLYElement(header.elements[currentElement].properties, line);
+      handleElement(attributes, header.elements[currentElement].name, element);
+      currentElementCount++;
+    }
+  }
+  return attributes;
+}
+function handleElement(buffer, elementName, element = {}) {
+  if (elementName === "vertex") {
+    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;
+    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) {
+    // corespondences for non-specific length types here match rply:
+    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 makePLYArrowTable(header, attributes) {
+  const meshAttributes = getPLYMeshAttributes(attributes);
+  const schema = (0, import_get_ply_schema.getPLYSchema)(header, meshAttributes);
+  schema.metadata.topology = "point-list";
+  schema.metadata.mode = "0";
+  const boundingBox = (0, import_schema_utils.getMeshBoundingBox)(meshAttributes);
+  if (boundingBox) schema.metadata.boundingBox = JSON.stringify(boundingBox);
+  const columns = {};
+  const fields = [];
+  for (const field of schema.fields) {
+    const attribute = meshAttributes[field.name];
+    if (!attribute) {
+      continue;
+    }
+    const column = getPLYArrowVector(attribute);
+    columns[field.name] = column;
+    fields.push(new arrow.Field(field.name, column.type, false, getArrowMetadata(field.metadata)));
+  }
+  const arrowSchema = new arrow.Schema(fields, getArrowMetadata(schema.metadata));
+  return {
+    shape: "arrow-table",
+    schema,
+    data: new arrow.Table(arrowSchema, columns),
+    topology: "point-list"
+  };
+}
+function getPLYMeshAttributes(attributes) {
+  const meshAttributes = {};
+  for (const attributeName of Object.keys(attributes)) {
+    switch (attributeName) {
+      case "vertices":
+        if (attributes.vertices.length > 0) {
+          meshAttributes.POSITION = { value: getFloat32Array(attributes.vertices), size: 3 };
+        }
+        break;
+      case "normals":
+        if (attributes.normals.length > 0) {
+          meshAttributes.NORMAL = { value: getFloat32Array(attributes.normals), size: 3 };
+        }
+        break;
+      case "uvs":
+        if (attributes.uvs.length > 0) {
+          meshAttributes.TEXCOORD_0 = { value: getFloat32Array(attributes.uvs), size: 2 };
+        }
+        break;
+      case "colors":
+        if (attributes.colors.length > 0) {
+          meshAttributes.COLOR_0 = {
+            value: getUint8Array(attributes.colors),
+            size: 3,
+            normalized: true
+          };
+        }
+        break;
+      case "indices":
+        break;
+      default:
+        if (attributes[attributeName].length > 0) {
+          meshAttributes[attributeName] = {
+            value: getFloat32Array(attributes[attributeName]),
+            size: 1
+          };
+        }
+        break;
+    }
+  }
+  return meshAttributes;
+}
+function getPLYArrowVector(attribute) {
+  const { value, size } = attribute;
+  if (size === 1) {
+    return arrow.makeVector(value);
+  }
+  const values = arrow.makeVector(value);
+  const child = values.data[0];
+  const type = new arrow.FixedSizeList(size, new arrow.Field("value", child.type, false));
+  const data = new arrow.Data(type, 0, value.length / size, 0, {}, [child]);
+  return new arrow.Vector([data]);
+}
+function getArrowMetadata(metadata) {
+  return new Map(Object.entries(metadata || {}));
+}
+function getFloat32Array(attribute) {
+  return attribute instanceof Float32Array ? attribute : new Float32Array(attribute);
+}
+function getUint8Array(attribute) {
+  return attribute instanceof Uint8Array ? attribute : new Uint8Array(attribute);
+}
+function parseBinary(data, header, options) {
+  const directAttributes = parseBinaryPointCloud(data, header, options);
+  if (directAttributes) {
+    return directAttributes;
+  }
+  const attributes = getPLYAttributes(header);
+  const littleEndian = header.format === "binary_little_endian";
+  const body = new DataView(data, header.headerLength);
+  let result;
+  let loc = 0;
+  for (let currentElement = 0; currentElement < header.elements.length; currentElement++) {
+    const count = header.elements[currentElement].count;
+    for (let currentElementCount = 0; currentElementCount < count; currentElementCount++) {
+      result = binaryReadElement(
+        body,
+        loc,
+        header.elements[currentElement].properties,
+        littleEndian
+      );
+      loc += result[1];
+      const element = result[0];
+      handleElement(attributes, header.elements[currentElement].name, element);
+    }
+  }
+  return attributes;
+}
+function parseBinaryPointCloud(data, header, options) {
+  const records = new Uint8Array(data, header.headerLength || 0);
+  return parseBinaryPointCloudRecords(records, header, options);
+}
+function parseBinaryPointCloudRecords(records, header, options, parsePlan) {
+  const vertexElement = header.elements[0];
+  if (!parsePlan && (options?._useLegacyBinaryPointCloudParser || !options?.pointCloud && header.elements.length !== 1 || vertexElement?.name !== "vertex" || vertexElement.properties.some((property) => property.type === "list"))) {
+    return null;
+  }
+  const plan = parsePlan || getPLYBinaryPointCloudParsePlan(header, options);
+  if (!plan || !vertexElement) {
+    return null;
+  }
+  const attributes = getBinaryPointCloudAttributes(vertexElement);
+  const dataView = new DataView(records.buffer, records.byteOffset, records.byteLength);
+  let vertexOffset = 0;
+  for (let vertexIndex = 0; vertexIndex < vertexElement.count; vertexIndex++) {
+    for (const property of plan.properties) {
+      const value = property.read(dataView, vertexOffset + property.offset, plan.littleEndian);
+      writeBinaryPointCloudProperty(attributes, property.name, value, vertexIndex);
+    }
+    vertexOffset += plan.vertexStride;
+  }
+  return attributes;
+}
+function getPLYBinaryPointCloudParsePlan(header, options) {
+  const vertexElement = header.elements[0];
+  if (options?._useLegacyBinaryPointCloudParser || !options?.pointCloud && header.elements.length !== 1 || vertexElement?.name !== "vertex" || vertexElement.properties.some((property) => property.type === "list")) {
+    return null;
+  }
+  const properties = getBinaryPointCloudProperties(vertexElement);
+  return {
+    properties,
+    vertexStride: getPLYElementSize(properties),
+    littleEndian: header.format === "binary_little_endian"
+  };
+}
+function getBinaryPointCloudAttributes(vertexElement) {
+  const attributes = {
+    indices: [],
+    vertices: [],
+    normals: [],
+    uvs: [],
+    colors: []
+  };
+  const propertyNames = new Set(vertexElement.properties.map((property) => property.name));
+  const vertexCount = vertexElement.count;
+  if (propertyNames.has("x") && propertyNames.has("y") && propertyNames.has("z")) {
+    attributes.vertices = new Float32Array(vertexCount * 3);
+  }
+  if (propertyNames.has("nx") && propertyNames.has("ny") && propertyNames.has("nz")) {
+    attributes.normals = new Float32Array(vertexCount * 3);
+  }
+  if (propertyNames.has("s") && propertyNames.has("t")) {
+    attributes.uvs = new Float32Array(vertexCount * 2);
+  }
+  if (propertyNames.has("red") && propertyNames.has("green") && propertyNames.has("blue")) {
+    attributes.colors = new Uint8Array(vertexCount * 3);
+  }
+  for (const property of vertexElement.properties) {
+    if (!isNormalizedPLYAttributeProperty(property.name)) {
+      attributes[property.name] = new Float32Array(vertexCount);
+    }
+  }
+  return attributes;
+}
+function isNormalizedPLYAttributeProperty(propertyName) {
+  switch (propertyName) {
+    case "x":
+    case "y":
+    case "z":
+    case "nx":
+    case "ny":
+    case "nz":
+    case "s":
+    case "t":
+    case "red":
+    case "green":
+    case "blue":
+      return true;
+    default:
+      return false;
+  }
+}
+function writeBinaryPointCloudProperty(attributes, propertyName, value, vertexIndex) {
+  switch (propertyName) {
+    case "x":
+      attributes.vertices[vertexIndex * 3] = value;
+      break;
+    case "y":
+      attributes.vertices[vertexIndex * 3 + 1] = value;
+      break;
+    case "z":
+      attributes.vertices[vertexIndex * 3 + 2] = value;
+      break;
+    case "nx":
+      attributes.normals[vertexIndex * 3] = value;
+      break;
+    case "ny":
+      attributes.normals[vertexIndex * 3 + 1] = value;
+      break;
+    case "nz":
+      attributes.normals[vertexIndex * 3 + 2] = value;
+      break;
+    case "s":
+      attributes.uvs[vertexIndex * 2] = value;
+      break;
+    case "t":
+      attributes.uvs[vertexIndex * 2 + 1] = value;
+      break;
+    case "red":
+      attributes.colors[vertexIndex * 3] = value;
+      break;
+    case "green":
+      attributes.colors[vertexIndex * 3 + 1] = value;
+      break;
+    case "blue":
+      attributes.colors[vertexIndex * 3 + 2] = value;
+      break;
+    default:
+      attributes[propertyName][vertexIndex] = value;
+  }
+}
+function getBinaryPointCloudProperties(element) {
+  const properties = [];
+  let offset = 0;
+  for (const property of element.properties) {
+    properties.push({
+      name: property.name,
+      offset,
+      read: getBinaryScalarReader(property.type),
+      size: getPLYTypeSize(property.type)
+    });
+    offset += properties[properties.length - 1].size;
+  }
+  return properties;
+}
+function getPLYElementSize(properties) {
+  if (properties.length === 0) {
+    return 0;
+  }
+  const lastProperty = properties[properties.length - 1];
+  return lastProperty.offset + lastProperty.size;
+}
+function getPLYTypeSize(type) {
+  switch (type) {
+    case "int8":
+    case "uint8":
+    case "char":
+    case "uchar":
+      return 1;
+    case "int16":
+    case "uint16":
+    case "short":
+    case "ushort":
+      return 2;
+    case "int32":
+    case "uint32":
+    case "int":
+    case "uint":
+    case "float32":
+    case "float":
+      return 4;
+    case "float64":
+    case "double":
+      return 8;
+    default:
+      throw new Error(type);
+  }
+}
+function getBinaryScalarReader(type) {
+  switch (type) {
+    case "int8":
+    case "char":
+      return readInt8;
+    case "uint8":
+    case "uchar":
+      return readUint8;
+    case "int16":
+    case "short":
+      return readInt16;
+    case "uint16":
+    case "ushort":
+      return readUint16;
+    case "int32":
+    case "int":
+      return readInt32;
+    case "uint32":
+    case "uint":
+      return readUint32;
+    case "float32":
+    case "float":
+      return readFloat32;
+    case "float64":
+    case "double":
+      return readFloat64;
+    default:
+      throw new Error(type);
+  }
+}
+function readInt8(dataView, at) {
+  return dataView.getInt8(at);
+}
+function readUint8(dataView, at) {
+  return dataView.getUint8(at);
+}
+function readInt16(dataView, at, littleEndian) {
+  return dataView.getInt16(at, littleEndian);
+}
+function readUint16(dataView, at, littleEndian) {
+  return dataView.getUint16(at, littleEndian);
+}
+function readInt32(dataView, at, littleEndian) {
+  return dataView.getInt32(at, littleEndian);
+}
+function readUint32(dataView, at, littleEndian) {
+  return dataView.getUint32(at, littleEndian);
+}
+function readFloat32(dataView, at, littleEndian) {
+  return dataView.getFloat32(at, littleEndian);
+}
+function readFloat64(dataView, at, littleEndian) {
+  return dataView.getFloat64(at, littleEndian);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getPLYBinaryPointCloudParsePlan,
+  parsePLY,
+  parsePLYBinaryPointCloudRecordsToArrowTable,
+  parsePLYBinaryPointCloudToArrowTable,
+  parsePLYHeader,
+  parsePLYToArrowTable
+});
+//# sourceMappingURL=parse-ply.cjs.map