@lingbi/studio 0.3.2 → 0.3.3

package/index.js

@@ -5,6 +5,10 @@ var ObjImportFailureCode$1 = /* @__PURE__ */ ((ObjImportFailureCode2) => {
   ObjImportFailureCode2["RenderFailed"] = "render-failed";
   return ObjImportFailureCode2;
 })(ObjImportFailureCode$1 || {});
+var ObjImportWarningCode$1 = /* @__PURE__ */ ((ObjImportWarningCode2) => {
+  ObjImportWarningCode2["IncompleteMaterial"] = "incomplete-material";
+  return ObjImportWarningCode2;
+})(ObjImportWarningCode$1 || {});
 const REVISION = "185";
 const CullFaceNone = 0;
 const CullFaceBack = 1;
@@ -7778,8 +7782,8 @@ class Color {
    * @return {number} The hexadecimal value.
    */
   getHex(colorSpace = SRGBColorSpace) {
-    ColorManagement.workingToColorSpace(_color$1.copy(this), colorSpace);
-    return Math.round(clamp(_color$1.r * 255, 0, 255)) * 65536 + Math.round(clamp(_color$1.g * 255, 0, 255)) * 256 + Math.round(clamp(_color$1.b * 255, 0, 255));
+    ColorManagement.workingToColorSpace(_color$2.copy(this), colorSpace);
+    return Math.round(clamp(_color$2.r * 255, 0, 255)) * 65536 + Math.round(clamp(_color$2.g * 255, 0, 255)) * 256 + Math.round(clamp(_color$2.b * 255, 0, 255));
   }
   /**
    * Returns the hexadecimal value of this color as a string (for example, 'FFFFFF').
@@ -7799,8 +7803,8 @@ class Color {
    * @return {{h:number,s:number,l:number}} The HSL representation of this color.
    */
   getHSL(target, colorSpace = ColorManagement.workingColorSpace) {
-    ColorManagement.workingToColorSpace(_color$1.copy(this), colorSpace);
-    const r = _color$1.r, g = _color$1.g, b = _color$1.b;
+    ColorManagement.workingToColorSpace(_color$2.copy(this), colorSpace);
+    const r = _color$2.r, g = _color$2.g, b = _color$2.b;
     const max = Math.max(r, g, b);
     const min = Math.min(r, g, b);
     let hue, saturation;
@@ -7837,10 +7841,10 @@ class Color {
    * @return {Color} The RGB representation of this color.
    */
   getRGB(target, colorSpace = ColorManagement.workingColorSpace) {
-    ColorManagement.workingToColorSpace(_color$1.copy(this), colorSpace);
-    target.r = _color$1.r;
-    target.g = _color$1.g;
-    target.b = _color$1.b;
+    ColorManagement.workingToColorSpace(_color$2.copy(this), colorSpace);
+    target.r = _color$2.r;
+    target.g = _color$2.g;
+    target.b = _color$2.b;
     return target;
   }
   /**
@@ -7850,8 +7854,8 @@ class Color {
    * @return {string} The CSS representation of this color.
    */
   getStyle(colorSpace = SRGBColorSpace) {
-    ColorManagement.workingToColorSpace(_color$1.copy(this), colorSpace);
-    const r = _color$1.r, g = _color$1.g, b = _color$1.b;
+    ColorManagement.workingToColorSpace(_color$2.copy(this), colorSpace);
+    const r = _color$2.r, g = _color$2.g, b = _color$2.b;
     if (colorSpace !== SRGBColorSpace) {
       return `color(${colorSpace} ${r.toFixed(3)} ${g.toFixed(3)} ${b.toFixed(3)})`;
     }
@@ -8085,7 +8089,7 @@ class Color {
     yield this.b;
   }
 }
-const _color$1 = /* @__PURE__ */ new Color();
+const _color$2 = /* @__PURE__ */ new Color();
 Color.NAMES = _colorKeywords;
 class Scene extends Object3D {
   /**
@@ -9468,6 +9472,42 @@ class BufferAttribute extends EventDispatcher {
     this.dispatchEvent({ type: "dispose" });
   }
 }
+class Int8BufferAttribute extends BufferAttribute {
+  /**
+   * Constructs a new buffer attribute.
+   *
+   * @param {(Array<number>|Int8Array)} array - The array holding the attribute data.
+   * @param {number} itemSize - The item size.
+   * @param {boolean} [normalized=false] - Whether the data are normalized or not.
+   */
+  constructor(array, itemSize, normalized) {
+    super(new Int8Array(array), itemSize, normalized);
+  }
+}
+class Uint8BufferAttribute extends BufferAttribute {
+  /**
+   * Constructs a new buffer attribute.
+   *
+   * @param {(Array<number>|Uint8Array)} array - The array holding the attribute data.
+   * @param {number} itemSize - The item size.
+   * @param {boolean} [normalized=false] - Whether the data are normalized or not.
+   */
+  constructor(array, itemSize, normalized) {
+    super(new Uint8Array(array), itemSize, normalized);
+  }
+}
+class Int16BufferAttribute extends BufferAttribute {
+  /**
+   * Constructs a new buffer attribute.
+   *
+   * @param {(Array<number>|Int16Array)} array - The array holding the attribute data.
+   * @param {number} itemSize - The item size.
+   * @param {boolean} [normalized=false] - Whether the data are normalized or not.
+   */
+  constructor(array, itemSize, normalized) {
+    super(new Int16Array(array), itemSize, normalized);
+  }
+}
 class Uint16BufferAttribute extends BufferAttribute {
   /**
    * Constructs a new buffer attribute.
@@ -9480,6 +9520,18 @@ class Uint16BufferAttribute extends BufferAttribute {
     super(new Uint16Array(array), itemSize, normalized);
   }
 }
+class Int32BufferAttribute extends BufferAttribute {
+  /**
+   * Constructs a new buffer attribute.
+   *
+   * @param {(Array<number>|Int32Array)} array - The array holding the attribute data.
+   * @param {number} itemSize - The item size.
+   * @param {boolean} [normalized=false] - Whether the data are normalized or not.
+   */
+  constructor(array, itemSize, normalized) {
+    super(new Int32Array(array), itemSize, normalized);
+  }
+}
 class Uint32BufferAttribute extends BufferAttribute {
   /**
    * Constructs a new buffer attribute.
@@ -29535,6 +29587,179 @@ class CanvasController {
     }
   }
 }
+class ObjResourceList {
+  mtlUrl;
+  objUrl;
+  mtlFileName;
+  textureUrls = /* @__PURE__ */ new Set();
+  textureUrlsByFileName = /* @__PURE__ */ new Map();
+  constructor(fileUrls) {
+    let mtlFileName;
+    let mtlUrl;
+    let objUrl;
+    const seenFileNames = /* @__PURE__ */ new Set();
+    const seenUrls = /* @__PURE__ */ new Set();
+    for (const fileUrl of fileUrls) {
+      const resource = this.createResourceEntry(fileUrl);
+      if (seenUrls.has(resource.url) || seenFileNames.has(resource.fileName)) {
+        throw new Error("The OBJ resource list contains a duplicate resource.");
+      }
+      seenUrls.add(resource.url);
+      seenFileNames.add(resource.fileName);
+      if (this.isObjUrl(resource.url)) {
+        if (objUrl !== void 0) {
+          throw new Error("The OBJ resource list must contain exactly one OBJ file.");
+        }
+        objUrl = resource.url;
+        continue;
+      }
+      if (this.isMtlUrl(resource.url)) {
+        if (mtlUrl !== void 0) {
+          throw new Error("The OBJ resource list cannot contain multiple MTL files.");
+        }
+        mtlFileName = resource.fileName;
+        mtlUrl = resource.url;
+        continue;
+      }
+      this.textureUrls.add(resource.url);
+      this.textureUrlsByFileName.set(resource.fileName, resource.url);
+    }
+    if (objUrl === void 0) {
+      throw new Error("The OBJ resource list must contain an OBJ file.");
+    }
+    this.mtlFileName = mtlFileName;
+    this.mtlUrl = mtlUrl;
+    this.objUrl = objUrl;
+  }
+  matchesMaterialLibraries(materialReferences) {
+    if (materialReferences.length === 0) {
+      return true;
+    }
+    const mtlUrl = this.mtlUrl;
+    const mtlFileName = this.mtlFileName;
+    const [materialReference, ...remainingReferences] = materialReferences;
+    if (materialReference === void 0 || remainingReferences.length > 0 || mtlUrl === void 0 || mtlFileName === void 0) {
+      return false;
+    }
+    const referenceUrl = new URL(materialReference, this.objUrl).href;
+    if (referenceUrl === mtlUrl || this.getFileName(new URL(referenceUrl)) === mtlFileName) {
+      return true;
+    }
+    return false;
+  }
+  resolveTextureUrl(materialBaseUrl, textureUrl) {
+    const resolvedUrl = new URL(textureUrl, materialBaseUrl).href;
+    if (this.textureUrls.has(resolvedUrl)) {
+      return resolvedUrl;
+    }
+    const mappedUrl = this.textureUrlsByFileName.get(this.getFileName(new URL(resolvedUrl)));
+    if (mappedUrl === void 0) {
+      throw new Error("The MTL texture is not present in the resource list.");
+    }
+    return mappedUrl;
+  }
+  createResourceEntry(fileUrl) {
+    const url = new URL(fileUrl);
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+      throw new Error("The OBJ resource list only accepts HTTP URLs.");
+    }
+    return {
+      fileName: this.getFileName(url),
+      url: url.href
+    };
+  }
+  getFileName(url) {
+    const fileName = decodeURIComponent(url.pathname.slice(url.pathname.lastIndexOf("/") + 1));
+    if (fileName.length === 0) {
+      throw new Error("The OBJ resource URL must include a file name.");
+    }
+    return fileName;
+  }
+  isMtlUrl(url) {
+    return new URL(url).pathname.toLowerCase().endsWith(".mtl");
+  }
+  isObjUrl(url) {
+    return new URL(url).pathname.toLowerCase().endsWith(".obj");
+  }
+}
+class PlyResourceList {
+  plyUrl;
+  resourceUrlsByFileName = /* @__PURE__ */ new Map();
+  constructor(fileUrls) {
+    let plyUrl;
+    const seenFileNames = /* @__PURE__ */ new Set();
+    const seenUrls = /* @__PURE__ */ new Set();
+    for (const fileUrl of fileUrls) {
+      const resource = this.createResourceEntry(fileUrl);
+      if (seenUrls.has(resource.url) || seenFileNames.has(resource.fileName)) {
+        throw new Error("The PLY resource list contains a duplicate resource.");
+      }
+      seenUrls.add(resource.url);
+      seenFileNames.add(resource.fileName);
+      this.resourceUrlsByFileName.set(resource.fileName, resource.url);
+      if (this.isPlyUrl(resource.url)) {
+        if (plyUrl !== void 0) {
+          throw new Error("The PLY resource list must contain exactly one PLY file.");
+        }
+        plyUrl = resource.url;
+      }
+    }
+    if (plyUrl === void 0) {
+      throw new Error("The PLY resource list must contain a PLY file.");
+    }
+    this.plyUrl = plyUrl;
+  }
+  resolveTextureUrl(reference) {
+    const normalizedReference = reference.replaceAll("\\", "/");
+    const resolvedUrl = new URL(normalizedReference, this.plyUrl);
+    const mappedUrl = this.resourceUrlsByFileName.get(this.getFileName(resolvedUrl));
+    return mappedUrl ?? resolvedUrl.href;
+  }
+  createResourceEntry(fileUrl) {
+    const url = new URL(fileUrl);
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+      throw new Error("The PLY resource list only accepts HTTP URLs.");
+    }
+    return {
+      fileName: this.getFileName(url),
+      url: url.href
+    };
+  }
+  getFileName(url) {
+    const fileName = decodeURIComponent(url.pathname.slice(url.pathname.lastIndexOf("/") + 1));
+    if (fileName.length === 0) {
+      throw new Error("The PLY resource URL must include a file name.");
+    }
+    return fileName;
+  }
+  isPlyUrl(url) {
+    return new URL(url).pathname.toLowerCase().endsWith(".ply");
+  }
+}
+class ModelResourceList {
+  resources;
+  constructor(fileUrls) {
+    let modelFileCount = 0;
+    let modelFormat;
+    for (const fileUrl of fileUrls) {
+      const path = new URL(fileUrl).pathname.toLowerCase();
+      if (path.endsWith(".obj")) {
+        modelFileCount += 1;
+        modelFormat = "obj";
+      } else if (path.endsWith(".ply")) {
+        modelFileCount += 1;
+        modelFormat = "ply";
+      }
+    }
+    if (modelFileCount !== 1 || modelFormat === void 0) {
+      throw new Error("A model resource list must contain exactly one OBJ or PLY file.");
+    }
+    this.resources = modelFormat === "obj" ? new ObjResourceList(fileUrls) : new PlyResourceList(fileUrls);
+  }
+  isObj() {
+    return this.resources instanceof ObjResourceList;
+  }
+}
 class MTLLoader extends Loader {
   constructor(manager) {
     super(manager);
@@ -29840,7 +30065,7 @@ const _vB = new Vector3();
 const _vC = new Vector3();
 const _ab = new Vector3();
 const _cb = new Vector3();
-const _color = new Color();
+const _color$1 = new Color();
 function ParserState() {
   const state = {
     objects: [],
@@ -30151,13 +30376,13 @@ class OBJLoader extends Loader {
               parseFloat(data[3])
             );
             if (data.length >= 7) {
-              _color.setRGB(
+              _color$1.setRGB(
                 parseFloat(data[4]),
                 parseFloat(data[5]),
                 parseFloat(data[6]),
                 SRGBColorSpace
               );
-              state.colors.push(_color.r, _color.g, _color.b);
+              state.colors.push(_color$1.r, _color$1.g, _color$1.b);
             } else {
               state.colors.push(void 0, void 0, void 0);
             }
@@ -30464,8 +30689,8 @@ class Model {
     return Array.isArray(values);
   }
 }
-const DEFAULT_MODEL_COLOR = 10265519;
-const DEFAULT_POINT_SIZE = 3;
+const DEFAULT_MODEL_COLOR$1 = 10265519;
+const DEFAULT_POINT_SIZE$1 = 3;
 class TextureLoadMonitor {
   completionResolver;
   completionPromise;
@@ -30573,24 +30798,33 @@ class ObjLoader {
     }
     let materialContext;
     let model;
+    let warnings = [];
     try {
       const objSource = await this.loadText(source.objUrl, signal);
       this.assertNotCancelled(signal);
       const materialReferences = this.getMaterialLibraryReferences(objSource);
-      resources?.assertMaterialLibraries(materialReferences);
-      const materialUrl = resources === void 0 ? this.getMaterialUrl(source, materialReferences) : resources.mtlUrl;
+      const hasMatchingMaterialLibrary = resources === void 0 || resources.matchesMaterialLibraries(materialReferences);
+      if (materialReferences.length > 0 && !hasMatchingMaterialLibrary) {
+        warnings = [this.createIncompleteMaterialWarning()];
+      }
+      const materialUrl = resources === void 0 ? this.getMaterialUrl(source, materialReferences) : hasMatchingMaterialLibrary ? resources.mtlUrl : void 0;
       if (materialUrl !== void 0) {
-        materialContext = await this.loadMaterialContext(
-          materialUrl,
-          source.textureUrls,
-          signal,
-          resources
-        );
+        try {
+          materialContext = await this.loadMaterialContext(
+            materialUrl,
+            source.textureUrls,
+            signal,
+            resources
+          );
+        } catch {
+          this.assertNotCancelled(signal);
+          warnings = [this.createIncompleteMaterialWarning()];
+        }
       }
       this.assertNotCancelled(signal);
-      const group = this.parseObj(objSource, materialContext?.creator);
-      const additionalMaterials = this.getMaterialArray(materialContext);
-      const additionalTextures = this.getTextureArray(materialContext);
+      let group = this.parseObj(objSource, materialContext?.creator);
+      let additionalMaterials = this.getMaterialArray(materialContext);
+      let additionalTextures = this.getTextureArray(materialContext);
       model = new Model(group, additionalMaterials, additionalTextures);
       if (!this.hasRenderablePrimitive(group) || !model.hasFiniteBounds()) {
         model.dispose();
@@ -30599,22 +30833,37 @@ class ObjLoader {
           success: false
         };
       }
-      if (materialContext === void 0) {
-        this.normalizeMaterials(group);
-      } else {
+      if (materialContext !== void 0) {
         const textureLoadOutcome = await materialContext.monitor.wait(signal);
-        if (textureLoadOutcome !== "succeeded") {
+        if (textureLoadOutcome === "cancelled") {
+          this.assertNotCancelled(signal);
+        }
+        if (textureLoadOutcome === "failed") {
           model.dispose();
-          return {
-            code: this.getTextureFailureCode(textureLoadOutcome),
-            success: false
-          };
+          model = void 0;
+          materialContext = void 0;
+          warnings = [this.createIncompleteMaterialWarning()];
+          group = this.parseObj(objSource, void 0);
+          additionalMaterials = [];
+          additionalTextures = [];
+          model = new Model(group, additionalMaterials, additionalTextures);
+          if (!this.hasRenderablePrimitive(group) || !model.hasFiniteBounds()) {
+            model.dispose();
+            return {
+              code: ObjImportFailureCode$1.InvalidSource,
+              success: false
+            };
+          }
         }
       }
+      if (materialContext === void 0) {
+        this.normalizeMaterials(group);
+      }
       this.assertNotCancelled(signal);
       return {
         model,
-        success: true
+        success: true,
+        ...warnings.length > 0 ? { warnings } : {}
       };
     } catch {
       this.disposeFailedModel(model);
@@ -30704,9 +30953,6 @@ class ObjLoader {
     }
     return objectTree;
   }
-  getTextureFailureCode(outcome) {
-    return outcome === "cancelled" ? ObjImportFailureCode$1.Cancelled : ObjImportFailureCode$1.InvalidSource;
-  }
   getMaterialLibraryReferences(objSource) {
     const materialReferences = [];
     for (const line of objSource.split(/\r?\n/u)) {
@@ -30717,6 +30963,11 @@ class ObjLoader {
     }
     return materialReferences;
   }
+  createIncompleteMaterialWarning() {
+    return {
+      code: ObjImportWarningCode$1.IncompleteMaterial
+    };
+  }
   getMaterialTextureReferences(materialSource, creator) {
     const textureReferences = [];
     for (const line of materialSource.split(/\r?\n/u)) {
@@ -30776,14 +31027,14 @@ class ObjLoader {
       side: DoubleSide
     });
     const creator = materialLoader.parse(materialSource, materialBaseUrl);
-    const pbrMaterialReferences = this.parsePbrMaterialReferences(materialSource);
-    if (resources !== void 0) {
-      this.assertMaterialTextures(resources, materialSource, materialBaseUrl, creator);
-    }
-    this.validateTextureOverrides(textureUrls);
-    this.removeLegacyPbrTextureMappings(creator);
     const monitor = new TextureLoadMonitor(manager, creator);
     try {
+      const pbrMaterialReferences = this.parsePbrMaterialReferences(materialSource);
+      if (resources !== void 0) {
+        this.assertMaterialTextures(resources, materialSource, materialBaseUrl, creator);
+      }
+      this.validateTextureOverrides(textureUrls);
+      this.removeLegacyPbrTextureMappings(creator);
       creator.preload();
       this.replaceMaterialsWithPbr(creator, pbrMaterialReferences, materialBaseUrl);
       monitor.finishScheduling();
@@ -30817,21 +31068,21 @@ class ObjLoader {
     for (const object of this.getObjectTree(group)) {
       if (this.isMesh(object)) {
         meshMaterial ??= new MeshBasicMaterial({
-          color: DEFAULT_MODEL_COLOR,
+          color: DEFAULT_MODEL_COLOR$1,
           side: DoubleSide
         });
         this.collectMaterials(object.material, materialsToDispose);
         object.material = meshMaterial;
       } else if (this.isLine(object)) {
         lineMaterial ??= new LineBasicMaterial({
-          color: DEFAULT_MODEL_COLOR
+          color: DEFAULT_MODEL_COLOR$1
         });
         this.collectMaterials(object.material, materialsToDispose);
         object.material = lineMaterial;
       } else if (this.isPoints(object)) {
         pointMaterial ??= new PointsMaterial({
-          color: DEFAULT_MODEL_COLOR,
-          size: DEFAULT_POINT_SIZE,
+          color: DEFAULT_MODEL_COLOR$1,
+          size: DEFAULT_POINT_SIZE$1,
           sizeAttenuation: false
         });
         this.collectMaterials(object.material, materialsToDispose);
@@ -31019,99 +31270,868 @@ class ObjLoader {
     }
   }
 }
-class ObjResourceList {
-  mtlUrl;
-  objUrl;
-  mtlFileName;
-  textureUrls = /* @__PURE__ */ new Set();
-  textureUrlsByFileName = /* @__PURE__ */ new Map();
-  constructor(fileUrls) {
-    let mtlFileName;
-    let mtlUrl;
-    let objUrl;
-    const seenFileNames = /* @__PURE__ */ new Set();
-    const seenUrls = /* @__PURE__ */ new Set();
-    for (const fileUrl of fileUrls) {
-      const resource = this.createResourceEntry(fileUrl);
-      if (seenUrls.has(resource.url) || seenFileNames.has(resource.fileName)) {
-        throw new Error("The OBJ resource list contains a duplicate resource.");
-      }
-      seenUrls.add(resource.url);
-      seenFileNames.add(resource.fileName);
-      if (this.isObjUrl(resource.url)) {
-        if (objUrl !== void 0) {
-          throw new Error("The OBJ resource list must contain exactly one OBJ file.");
-        }
-        objUrl = resource.url;
-        continue;
-      }
-      if (this.isMtlUrl(resource.url)) {
-        if (mtlUrl !== void 0) {
-          throw new Error("The OBJ resource list cannot contain multiple MTL files.");
+const _color = new Color();
+class PLYLoader extends Loader {
+  /**
+   * Constructs a new PLY loader.
+   *
+   * @param {LoadingManager} [manager] - The loading manager.
+   */
+  constructor(manager) {
+    super(manager);
+    this.propertyNameMapping = {};
+    this.customPropertyMapping = {};
+  }
+  /**
+   * Starts loading from the given URL and passes the loaded PLY asset
+   * to the `onLoad()` callback.
+   *
+   * @param {string} url - The path/URL of the file to be loaded. This can also be a data URI.
+   * @param {function(BufferGeometry)} onLoad - Executed when the loading process has been finished.
+   * @param {onProgressCallback} onProgress - Executed while the loading is in progress.
+   * @param {onErrorCallback} onError - Executed when errors occur.
+   */
+  load(url, onLoad, onProgress, onError) {
+    const scope = this;
+    const loader = new FileLoader(this.manager);
+    loader.setPath(this.path);
+    loader.setResponseType("arraybuffer");
+    loader.setRequestHeader(this.requestHeader);
+    loader.setWithCredentials(this.withCredentials);
+    loader.load(url, function(text) {
+      try {
+        onLoad(scope.parse(text));
+      } catch (e) {
+        if (onError) {
+          onError(e);
+        } else {
+          console.error(e);
         }
-        mtlFileName = resource.fileName;
-        mtlUrl = resource.url;
-        continue;
+        scope.manager.itemError(url);
+      }
+    }, onProgress, onError);
+  }
+  /**
+   * Sets a property name mapping that maps default property names
+   * to custom ones. For example, the following maps the properties
+   * “diffuse_(red|green|blue)” in the file to standard color names.
+   *
+   * ```js
+   * loader.setPropertyNameMapping( {
+   * 	diffuse_red: 'red',
+   * 	diffuse_green: 'green',
+   * 	diffuse_blue: 'blue'
+   * } );
+   * ```
+   *
+   * @param {Object} mapping - The mapping dictionary.
+   */
+  setPropertyNameMapping(mapping) {
+    this.propertyNameMapping = mapping;
+  }
+  /**
+   * Custom properties outside of the defaults for position, uv, normal
+   * and color attributes can be added using the setCustomPropertyNameMapping method.
+   * For example, the following maps the element properties “custom_property_a”
+   * and “custom_property_b” to an attribute “customAttribute” with an item size of 2.
+   * Attribute item sizes are set from the number of element properties in the property array.
+   *
+   * ```js
+   * loader.setCustomPropertyNameMapping( {
+   *	customAttribute: ['custom_property_a', 'custom_property_b'],
+   * } );
+   * ```
+   * @param {Object} mapping - The mapping dictionary.
+   */
+  setCustomPropertyNameMapping(mapping) {
+    this.customPropertyMapping = mapping;
+  }
+  /**
+   * Parses the given PLY data and returns the resulting geometry.
+   *
+   * @param {ArrayBuffer} data - The raw PLY data as an array buffer.
+   * @return {BufferGeometry} The parsed geometry.
+   */
+  parse(data) {
+    function parseHeader(data2, headerLength = 0) {
+      const patternHeader = /^ply([\s\S]*)end_header(\r\n|\r|\n)/;
+      let headerText = "";
+      const result = patternHeader.exec(data2);
+      if (result !== null) {
+        headerText = result[1];
+      }
+      const header = {
+        comments: [],
+        elements: [],
+        headerLength,
+        objInfo: ""
+      };
+      const lines = headerText.split(/\r\n|\r|\n/);
+      let currentElement;
+      function make_ply_element_property(propertyValues, propertyNameMapping) {
+        const property = { type: propertyValues[0] };
+        if (property.type === "list") {
+          property.name = propertyValues[3];
+          property.countType = propertyValues[1];
+          property.itemType = propertyValues[2];
+        } else {
+          property.name = propertyValues[1];
+        }
+        if (property.name in propertyNameMapping) {
+          property.name = propertyNameMapping[property.name];
+        }
+        return property;
+      }
+      for (let i = 0; i < lines.length; i++) {
+        let line = lines[i];
+        line = line.trim();
+        if (line === "") continue;
+        const lineValues = line.split(/\s+/);
+        const 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 !== void 0) {
+              header.elements.push(currentElement);
+            }
+            currentElement = {};
+            currentElement.name = lineValues[0];
+            currentElement.count = parseInt(lineValues[1]);
+            currentElement.properties = [];
+            break;
+          case "property":
+            currentElement.properties.push(make_ply_element_property(lineValues, scope.propertyNameMapping));
+            break;
+          case "obj_info":
+            header.objInfo = line;
+            break;
+          default:
+            console.log("unhandled", lineType, lineValues);
+        }
+      }
+      if (currentElement !== void 0) {
+        header.elements.push(currentElement);
+      }
+      return header;
+    }
+    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);
+        case "float":
+        case "double":
+        case "float32":
+        case "float64":
+          return parseFloat(n);
+      }
+    }
+    function parseASCIIElement(properties, tokens) {
+      const element = {};
+      for (let i = 0; i < properties.length; i++) {
+        if (tokens.empty()) return null;
+        if (properties[i].type === "list") {
+          const list = [];
+          const n = parseASCIINumber(tokens.next(), properties[i].countType);
+          for (let j = 0; j < n; j++) {
+            if (tokens.empty()) return null;
+            list.push(parseASCIINumber(tokens.next(), properties[i].itemType));
+          }
+          element[properties[i].name] = list;
+        } else {
+          element[properties[i].name] = parseASCIINumber(tokens.next(), properties[i].type);
+        }
+      }
+      return element;
+    }
+    function createBuffer() {
+      const buffer = {
+        indices: [],
+        vertices: [],
+        normals: [],
+        uvs: [],
+        faceVertexUvs: [],
+        colors: [],
+        faceVertexColors: [],
+        descriptors: {}
+      };
+      for (const customProperty of Object.keys(scope.customPropertyMapping)) {
+        buffer[customProperty] = [];
+      }
+      return buffer;
+    }
+    function getBufferAttributeClass(type) {
+      switch (type) {
+        case "int8":
+        case "char":
+          return Int8BufferAttribute;
+        case "uint8":
+        case "uchar":
+          return Uint8BufferAttribute;
+        case "int16":
+        case "short":
+          return Int16BufferAttribute;
+        case "uint16":
+        case "ushort":
+          return Uint16BufferAttribute;
+        case "int32":
+        case "int":
+          return Int32BufferAttribute;
+        case "uint32":
+        case "uint":
+          return Uint32BufferAttribute;
+        case "float32":
+        case "float":
+          return Float32BufferAttribute;
+        case "float64":
+        case "double":
+          return Float64BufferAttribute;
+      }
+    }
+    function getColorScale(type) {
+      switch (type) {
+        case "uchar":
+        case "uint8":
+          return 1 / 255;
+        case "ushort":
+        case "uint16":
+          return 1 / 65535;
+        case "float":
+        case "float32":
+        case "double":
+        case "float64":
+          return 1;
+        default:
+          return 1 / 255;
       }
-      this.textureUrls.add(resource.url);
-      this.textureUrlsByFileName.set(resource.fileName, resource.url);
     }
-    if (objUrl === void 0) {
-      throw new Error("The OBJ resource list must contain an OBJ file.");
+    function isFloatType(type) {
+      return type === "float" || type === "float32" || type === "double" || type === "float64";
     }
-    this.mtlFileName = mtlFileName;
-    this.mtlUrl = mtlUrl;
-    this.objUrl = objUrl;
+    function getAttributeDescriptor(properties) {
+      function findProperty(names) {
+        for (const name of names) {
+          const property = properties.find((p) => p.name === name);
+          if (property) return property;
+        }
+        return null;
+      }
+      const x = findProperty(["x", "px", "posx"]);
+      const y = findProperty(["y", "py", "posy"]);
+      const z = findProperty(["z", "pz", "posz"]);
+      const nx = findProperty(["nx", "normalx"]);
+      const ny = findProperty(["ny", "normaly"]);
+      const nz = findProperty(["nz", "normalz"]);
+      const s = findProperty(["s", "u", "texture_u", "tx"]);
+      const t = findProperty(["t", "v", "texture_v", "ty"]);
+      const r = findProperty(["red", "diffuse_red", "r", "diffuse_r"]);
+      const g = findProperty(["green", "diffuse_green", "g", "diffuse_g"]);
+      const b = findProperty(["blue", "diffuse_blue", "b", "diffuse_b"]);
+      const texcoord = findProperty(["texcoord"]);
+      const custom = {};
+      for (const customAttr of Object.keys(scope.customPropertyMapping)) {
+        const propNames = scope.customPropertyMapping[customAttr];
+        const matched = propNames.map((name) => properties.find((p) => p.name === name));
+        const types = matched.filter((p) => p).map((p) => p.type);
+        const uniform = types.length > 0 && types.every((type) => type === types[0]);
+        custom[customAttr] = {
+          type: uniform ? types[0] : "float32",
+          usage: matched.every((p) => p !== void 0)
+        };
+      }
+      return {
+        position: {
+          names: [x ? x.name : "x", y ? y.name : "y", z ? z.name : "z"],
+          type: x ? x.type : "float32",
+          usage: !!(x && y && z)
+        },
+        normal: {
+          names: [nx ? nx.name : "nx", ny ? ny.name : "ny", nz ? nz.name : "nz"],
+          type: nx ? nx.type : "float32",
+          usage: !!(nx && ny && nz)
+        },
+        uv: {
+          names: [s ? s.name : "s", t ? t.name : "t"],
+          type: s ? s.type : "float32",
+          usage: !!(s && t)
+        },
+        texcoord: {
+          type: texcoord ? texcoord.itemType : "float32",
+          usage: !!texcoord
+        },
+        color: {
+          names: [r ? r.name : "red", g ? g.name : "green", b ? b.name : "blue"],
+          type: r ? r.type : "uchar",
+          usage: !!(r && g && b)
+        },
+        custom
+      };
+    }
+    function parseASCII(data2, header) {
+      const buffer = createBuffer();
+      const patternBody = /end_header\s+(\S[\s\S]*\S|\S)\s*$/;
+      let body, matches;
+      if ((matches = patternBody.exec(data2)) !== null) {
+        body = matches[1].split(/\s+/);
+      } else {
+        body = [];
+      }
+      const tokens = new ArrayStream(body);
+      loop: for (let i = 0; i < header.elements.length; i++) {
+        const elementDesc = header.elements[i];
+        const attributeDescriptor = getAttributeDescriptor(elementDesc.properties);
+        buffer.descriptors[elementDesc.name] = attributeDescriptor;
+        for (let j = 0; j < elementDesc.count; j++) {
+          const element = parseASCIIElement(elementDesc.properties, tokens);
+          if (!element) break loop;
+          handleElement(buffer, elementDesc.name, element, attributeDescriptor);
+        }
+      }
+      return postProcess(buffer);
+    }
+    function postProcess(buffer) {
+      let geometry2 = new BufferGeometry();
+      const vertexDescriptor = buffer.descriptors.vertex;
+      if (buffer.indices.length > 0) {
+        geometry2.setIndex(buffer.indices);
+      }
+      const PositionClass = getBufferAttributeClass(vertexDescriptor ? vertexDescriptor.position.type : "float32");
+      geometry2.setAttribute("position", new PositionClass(buffer.vertices, 3));
+      if (buffer.normals.length > 0) {
+        const NormalClass = getBufferAttributeClass(vertexDescriptor.normal.type);
+        geometry2.setAttribute("normal", new NormalClass(buffer.normals, 3));
+      }
+      if (buffer.uvs.length > 0) {
+        const UvClass = getBufferAttributeClass(vertexDescriptor.uv.type);
+        geometry2.setAttribute("uv", new UvClass(buffer.uvs, 2));
+      }
+      if (buffer.colors.length > 0) {
+        const colorType = vertexDescriptor.color.type;
+        const normalized = !isFloatType(colorType);
+        const ColorClass = getBufferAttributeClass(colorType);
+        geometry2.setAttribute("color", new ColorClass(buffer.colors, 3, normalized));
+      }
+      if (buffer.faceVertexUvs.length > 0 || buffer.faceVertexColors.length > 0) {
+        geometry2 = geometry2.toNonIndexed();
+        if (buffer.faceVertexUvs.length > 0) {
+          const UvClass = getBufferAttributeClass(buffer.descriptors.face.texcoord.type);
+          geometry2.setAttribute("uv", new UvClass(buffer.faceVertexUvs, 2));
+        }
+        if (buffer.faceVertexColors.length > 0) {
+          const colorType = buffer.descriptors.face.color.type;
+          const normalized = !isFloatType(colorType);
+          const ColorClass = getBufferAttributeClass(colorType);
+          geometry2.setAttribute("color", new ColorClass(buffer.faceVertexColors, 3, normalized));
+        }
+      }
+      for (const customProperty of Object.keys(scope.customPropertyMapping)) {
+        if (buffer[customProperty].length > 0) {
+          const CustomClass = getBufferAttributeClass(vertexDescriptor.custom[customProperty].type);
+          geometry2.setAttribute(customProperty, new CustomClass(buffer[customProperty], scope.customPropertyMapping[customProperty].length));
+        }
+      }
+      geometry2.computeBoundingSphere();
+      return geometry2;
+    }
+    function handleElement(buffer, elementName, element, attributeDescriptor) {
+      if (elementName === "vertex") {
+        const { position, normal, uv, color } = attributeDescriptor;
+        if (position.usage) {
+          buffer.vertices.push(
+            element[position.names[0]],
+            element[position.names[1]],
+            element[position.names[2]]
+          );
+        }
+        if (normal.usage) {
+          buffer.normals.push(
+            element[normal.names[0]],
+            element[normal.names[1]],
+            element[normal.names[2]]
+          );
+        }
+        if (uv.usage) {
+          buffer.uvs.push(
+            element[uv.names[0]],
+            element[uv.names[1]]
+          );
+        }
+        if (color.usage) {
+          const scale = getColorScale(color.type);
+          const isFloat = isFloatType(color.type);
+          _color.setRGB(
+            element[color.names[0]] * scale,
+            element[color.names[1]] * scale,
+            element[color.names[2]] * scale,
+            SRGBColorSpace
+          );
+          const invScale = 1 / scale;
+          buffer.colors.push(
+            isFloat ? _color.r : Math.round(_color.r * invScale),
+            isFloat ? _color.g : Math.round(_color.g * invScale),
+            isFloat ? _color.b : Math.round(_color.b * invScale)
+          );
+        }
+        for (const customProperty of Object.keys(scope.customPropertyMapping)) {
+          for (const elementProperty of scope.customPropertyMapping[customProperty]) {
+            buffer[customProperty].push(element[elementProperty]);
+          }
+        }
+      } else if (elementName === "face") {
+        const vertex_indices = element.vertex_indices || element.vertex_index;
+        const texcoord = element.texcoord;
+        if (vertex_indices.length === 3) {
+          buffer.indices.push(vertex_indices[0], vertex_indices[1], vertex_indices[2]);
+          if (texcoord && texcoord.length === 6) {
+            buffer.faceVertexUvs.push(texcoord[0], texcoord[1]);
+            buffer.faceVertexUvs.push(texcoord[2], texcoord[3]);
+            buffer.faceVertexUvs.push(texcoord[4], texcoord[5]);
+          }
+        } else if (vertex_indices.length === 4) {
+          buffer.indices.push(vertex_indices[0], vertex_indices[1], vertex_indices[3]);
+          buffer.indices.push(vertex_indices[1], vertex_indices[2], vertex_indices[3]);
+        }
+        const { color } = attributeDescriptor;
+        if (color.usage) {
+          const scale = getColorScale(color.type);
+          _color.setRGB(
+            element[color.names[0]] * scale,
+            element[color.names[1]] * scale,
+            element[color.names[2]] * scale,
+            SRGBColorSpace
+          );
+          const invScale = 1 / scale;
+          const r = _color.r * invScale;
+          const g = _color.g * invScale;
+          const b = _color.b * invScale;
+          buffer.faceVertexColors.push(r, g, b);
+          buffer.faceVertexColors.push(r, g, b);
+          buffer.faceVertexColors.push(r, g, b);
+        }
+      }
+    }
+    function binaryReadElement(at, properties) {
+      const element = {};
+      let read = 0;
+      for (let i = 0; i < properties.length; i++) {
+        const property = properties[i];
+        const valueReader = property.valueReader;
+        if (property.type === "list") {
+          const list = [];
+          const n = property.countReader.read(at + read);
+          read += property.countReader.size;
+          for (let j = 0; j < n; j++) {
+            list.push(valueReader.read(at + read));
+            read += valueReader.size;
+          }
+          element[property.name] = list;
+        } else {
+          element[property.name] = valueReader.read(at + read);
+          read += valueReader.size;
+        }
+      }
+      return [element, read];
+    }
+    function setPropertyBinaryReaders(properties, body, little_endian) {
+      function getBinaryReader(dataview, type, little_endian2) {
+        switch (type) {
+          // correspondences for non-specific length types here match rply:
+          case "int8":
+          case "char":
+            return { read: (at) => {
+              return dataview.getInt8(at);
+            }, size: 1 };
+          case "uint8":
+          case "uchar":
+            return { read: (at) => {
+              return dataview.getUint8(at);
+            }, size: 1 };
+          case "int16":
+          case "short":
+            return { read: (at) => {
+              return dataview.getInt16(at, little_endian2);
+            }, size: 2 };
+          case "uint16":
+          case "ushort":
+            return { read: (at) => {
+              return dataview.getUint16(at, little_endian2);
+            }, size: 2 };
+          case "int32":
+          case "int":
+            return { read: (at) => {
+              return dataview.getInt32(at, little_endian2);
+            }, size: 4 };
+          case "uint32":
+          case "uint":
+            return { read: (at) => {
+              return dataview.getUint32(at, little_endian2);
+            }, size: 4 };
+          case "float32":
+          case "float":
+            return { read: (at) => {
+              return dataview.getFloat32(at, little_endian2);
+            }, size: 4 };
+          case "float64":
+          case "double":
+            return { read: (at) => {
+              return dataview.getFloat64(at, little_endian2);
+            }, size: 8 };
+        }
+      }
+      for (let i = 0, l = properties.length; i < l; i++) {
+        const property = properties[i];
+        if (property.type === "list") {
+          property.countReader = getBinaryReader(body, property.countType, little_endian);
+          property.valueReader = getBinaryReader(body, property.itemType, little_endian);
+        } else {
+          property.valueReader = getBinaryReader(body, property.type, little_endian);
+        }
+      }
+    }
+    function parseBinary(data2, header) {
+      const buffer = createBuffer();
+      const little_endian = header.format === "binary_little_endian";
+      const body = new DataView(data2, header.headerLength);
+      let result, loc = 0;
+      for (let currentElement = 0; currentElement < header.elements.length; currentElement++) {
+        const elementDesc = header.elements[currentElement];
+        const properties = elementDesc.properties;
+        const attributeDescriptor = getAttributeDescriptor(properties);
+        buffer.descriptors[elementDesc.name] = attributeDescriptor;
+        setPropertyBinaryReaders(properties, body, little_endian);
+        for (let currentElementCount = 0; currentElementCount < elementDesc.count; currentElementCount++) {
+          result = binaryReadElement(loc, properties);
+          loc += result[1];
+          const element = result[0];
+          handleElement(buffer, elementDesc.name, element, attributeDescriptor);
+        }
+      }
+      return postProcess(buffer);
+    }
+    function extractHeaderText(bytes) {
+      let i = 0;
+      let cont = true;
+      let line = "";
+      const lines = [];
+      const startLine = new TextDecoder().decode(bytes.subarray(0, 5));
+      const hasCRNL = /^ply\r\n/.test(startLine);
+      do {
+        const c = String.fromCharCode(bytes[i++]);
+        if (c !== "\n" && c !== "\r") {
+          line += c;
+        } else {
+          if (line === "end_header") cont = false;
+          if (line !== "") {
+            lines.push(line);
+            line = "";
+          }
+        }
+      } while (cont && i < bytes.length);
+      if (hasCRNL === true) i++;
+      return { headerText: lines.join("\r") + "\r", headerLength: i };
+    }
+    let geometry;
+    const scope = this;
+    if (data instanceof ArrayBuffer) {
+      const bytes = new Uint8Array(data);
+      const { headerText, headerLength } = extractHeaderText(bytes);
+      const header = parseHeader(headerText, headerLength);
+      if (header.format === "ascii") {
+        const text = new TextDecoder().decode(bytes);
+        geometry = parseASCII(text, header);
+      } else {
+        geometry = parseBinary(data, header);
+      }
+    } else {
+      geometry = parseASCII(data, parseHeader(data));
+    }
+    return geometry;
   }
-  assertMaterialLibraries(materialReferences) {
-    if (materialReferences.length === 0) {
+}
+class Float64BufferAttribute extends BufferAttribute {
+  constructor(array, itemSize, normalized) {
+    super(new Float64Array(array), itemSize, normalized);
+  }
+}
+class ArrayStream {
+  constructor(arr) {
+    this.arr = arr;
+    this.i = 0;
+  }
+  empty() {
+    return this.i >= this.arr.length;
+  }
+  next() {
+    return this.arr[this.i++];
+  }
+}
+class PlyTextureLoadOperation {
+  abortListener;
+  loader;
+  signal;
+  url;
+  resolveResult;
+  settled = false;
+  texture;
+  constructor(loader, url, signal) {
+    this.abortListener = this.handleAbort.bind(this);
+    this.loader = loader;
+    this.signal = signal;
+    this.url = url;
+  }
+  start() {
+    return new Promise(this.begin.bind(this));
+  }
+  begin(resolve) {
+    this.resolveResult = resolve;
+    this.signal.addEventListener("abort", this.abortListener, { once: true });
+    if (this.signal.aborted) {
+      this.handleAbort();
       return;
     }
-    const mtlUrl = this.mtlUrl;
-    const mtlFileName = this.mtlFileName;
-    const [materialReference, ...remainingReferences] = materialReferences;
-    if (materialReference === void 0 || remainingReferences.length > 0 || mtlUrl === void 0 || mtlFileName === void 0) {
-      throw new Error("The OBJ material library is not present in the resource list.");
+    try {
+      const requestedTexture = this.loader.load(
+        this.url,
+        this.handleLoad.bind(this),
+        void 0,
+        this.handleError.bind(this)
+      );
+      if (this.settled) {
+        if (this.texture !== requestedTexture) {
+          requestedTexture.dispose();
+        }
+        return;
+      }
+      this.texture = requestedTexture;
+    } catch {
+      this.handleError();
     }
-    const referenceUrl = new URL(materialReference, this.objUrl).href;
-    if (referenceUrl === mtlUrl || this.getFileName(new URL(referenceUrl)) === mtlFileName) {
+  }
+  finish(result) {
+    if (this.settled) {
       return;
     }
-    throw new Error("The OBJ material library does not match the resource list.");
+    this.settled = true;
+    this.signal.removeEventListener("abort", this.abortListener);
+    this.resolveResult?.(result);
+    this.resolveResult = void 0;
   }
-  resolveTextureUrl(materialBaseUrl, textureUrl) {
-    const resolvedUrl = new URL(textureUrl, materialBaseUrl).href;
-    if (this.textureUrls.has(resolvedUrl)) {
-      return resolvedUrl;
+  handleAbort() {
+    this.texture?.dispose();
+    this.texture = void 0;
+    this.finish({ outcome: "cancelled" });
+  }
+  handleError() {
+    this.texture?.dispose();
+    this.texture = void 0;
+    this.finish({ outcome: "failed" });
+  }
+  handleLoad(texture) {
+    if (this.settled) {
+      texture.dispose();
+      return;
     }
-    const mappedUrl = this.textureUrlsByFileName.get(this.getFileName(new URL(resolvedUrl)));
-    if (mappedUrl === void 0) {
-      throw new Error("The MTL texture is not present in the resource list.");
+    this.texture = texture;
+    this.finish({
+      outcome: "succeeded",
+      texture
+    });
+  }
+}
+class PlyTextureLoader {
+  loader;
+  constructor(loader = new TextureLoader()) {
+    this.loader = loader;
+  }
+  load(url, signal) {
+    return new PlyTextureLoadOperation(this.loader, url, signal).start();
+  }
+}
+const DEFAULT_MODEL_COLOR = 10265519;
+const DEFAULT_POINT_SIZE = 3;
+const MAX_HEADER_BYTES = 65536;
+class PlyLoader {
+  parser;
+  textureLoader;
+  constructor(parser = new PLYLoader(), textureLoader = new PlyTextureLoader()) {
+    this.parser = parser;
+    this.textureLoader = textureLoader;
+  }
+  async load(resources, signal) {
+    if (signal.aborted) {
+      return {
+        code: ObjImportFailureCode$1.Cancelled,
+        success: false
+      };
     }
-    return mappedUrl;
+    const source = await this.fetchSource(resources.plyUrl, signal);
+    if (!(source instanceof ArrayBuffer)) {
+      return source;
+    }
+    let geometry;
+    let metadata;
+    try {
+      metadata = this.parseMetadata(source);
+      geometry = this.parser.parse(source);
+    } catch {
+      return {
+        code: ObjImportFailureCode$1.InvalidSource,
+        success: false
+      };
+    }
+    if (this.isCancelled(signal)) {
+      geometry.dispose();
+      return {
+        code: ObjImportFailureCode$1.Cancelled,
+        success: false
+      };
+    }
+    if (!geometry.hasAttribute("position")) {
+      geometry.dispose();
+      return {
+        code: ObjImportFailureCode$1.InvalidSource,
+        success: false
+      };
+    }
+    const modelResult = metadata.hasFaces ? await this.createMeshModel(geometry, metadata.textureReference, resources, signal) : this.createPointsModel(geometry);
+    if ("success" in modelResult) {
+      return modelResult;
+    }
+    if (!modelResult.model.hasFiniteBounds()) {
+      modelResult.model.dispose();
+      return {
+        code: ObjImportFailureCode$1.InvalidSource,
+        success: false
+      };
+    }
+    return {
+      success: true,
+      ...modelResult.warnings.length === 0 ? {} : { warnings: modelResult.warnings },
+      model: modelResult.model
+    };
   }
-  createResourceEntry(fileUrl) {
-    const url = new URL(fileUrl);
-    if (url.protocol !== "http:" && url.protocol !== "https:") {
-      throw new Error("The OBJ resource list only accepts HTTP URLs.");
+  createMeshMaterial(geometry, texture) {
+    if (texture !== void 0) {
+      texture.colorSpace = SRGBColorSpace;
     }
+    return new MeshStandardMaterial({
+      color: texture !== void 0 || geometry.hasAttribute("color") ? 16777215 : DEFAULT_MODEL_COLOR,
+      map: texture ?? null,
+      side: DoubleSide,
+      vertexColors: geometry.hasAttribute("color")
+    });
+  }
+  async createMeshModel(geometry, textureReference, resources, signal) {
+    if (!geometry.hasAttribute("normal")) {
+      geometry.computeVertexNormals();
+    }
+    const warnings = [];
+    let texture;
+    if (textureReference !== void 0 && geometry.hasAttribute("uv")) {
+      const textureResult = await this.textureLoader.load(
+        resources.resolveTextureUrl(textureReference),
+        signal
+      );
+      if (textureResult.outcome === "cancelled") {
+        geometry.dispose();
+        return {
+          code: ObjImportFailureCode$1.Cancelled,
+          success: false
+        };
+      }
+      if (textureResult.outcome === "succeeded") {
+        texture = textureResult.texture;
+      } else {
+        warnings.push({ code: ObjImportWarningCode$1.IncompleteMaterial });
+      }
+    } else if (textureReference !== void 0) {
+      warnings.push({ code: ObjImportWarningCode$1.IncompleteMaterial });
+    }
+    if (signal.aborted) {
+      texture?.dispose();
+      geometry.dispose();
+      return {
+        code: ObjImportFailureCode$1.Cancelled,
+        success: false
+      };
+    }
+    const material = this.createMeshMaterial(geometry, texture);
     return {
-      fileName: this.getFileName(url),
-      url: url.href
+      model: new Model(new Mesh(geometry, material)),
+      warnings
     };
   }
-  getFileName(url) {
-    const fileName = decodeURIComponent(url.pathname.slice(url.pathname.lastIndexOf("/") + 1));
-    if (fileName.length === 0) {
-      throw new Error("The OBJ resource URL must include a file name.");
+  createPointsModel(geometry) {
+    const material = new PointsMaterial({
+      color: geometry.hasAttribute("color") ? 16777215 : DEFAULT_MODEL_COLOR,
+      size: DEFAULT_POINT_SIZE,
+      sizeAttenuation: false,
+      vertexColors: geometry.hasAttribute("color")
+    });
+    return {
+      model: new Model(new Points(geometry, material)),
+      warnings: []
+    };
+  }
+  async fetchSource(url, signal) {
+    try {
+      const response = await fetch(url, { signal });
+      if (!response.ok) {
+        return {
+          code: ObjImportFailureCode$1.InvalidSource,
+          success: false
+        };
+      }
+      return await response.arrayBuffer();
+    } catch {
+      return {
+        code: signal.aborted ? ObjImportFailureCode$1.Cancelled : ObjImportFailureCode$1.InvalidSource,
+        success: false
+      };
     }
-    return fileName;
   }
-  isMtlUrl(url) {
-    return new URL(url).pathname.toLowerCase().endsWith(".mtl");
+  parseMetadata(source) {
+    const headerLength = Math.min(source.byteLength, MAX_HEADER_BYTES);
+    const header = new TextDecoder().decode(new Uint8Array(source, 0, headerLength));
+    const endHeaderMatch = /end_header(?:\r\n|\r|\n)/u.exec(header);
+    if (endHeaderMatch === null) {
+      throw new Error("The PLY header is incomplete.");
+    }
+    const headerSource = header.slice(0, endHeaderMatch.index);
+    const faceCount = /^element\s+face\s+(\d+)\s*$/imu.exec(headerSource)?.[1];
+    const rawTextureReference = /^comment\s+TextureFile\s+(.+?)\s*$/imu.exec(headerSource)?.[1];
+    return {
+      hasFaces: faceCount !== void 0 && Number.parseInt(faceCount, 10) > 0,
+      textureReference: rawTextureReference === void 0 ? void 0 : this.removeSurroundingQuotes(rawTextureReference.trim())
+    };
   }
-  isObjUrl(url) {
-    return new URL(url).pathname.toLowerCase().endsWith(".obj");
+  isCancelled(signal) {
+    return signal.aborted;
+  }
+  removeSurroundingQuotes(value) {
+    const firstCharacter = value.at(0);
+    const lastCharacter = value.at(-1);
+    if (value.length >= 2 && (firstCharacter === '"' && lastCharacter === '"' || firstCharacter === "'" && lastCharacter === "'")) {
+      return value.slice(1, -1);
+    }
+    return value;
   }
 }
 const DEFAULT_BACKGROUND_COLOR = 3355443;
@@ -31131,6 +32151,7 @@ class Renderer {
   frameHandle;
   hemisphereLight;
   modelLoader;
+  plyLoader;
   previousScissor = new Vector4();
   previousViewport = new Vector4();
   renderer;
@@ -31172,6 +32193,7 @@ class Renderer {
       this.fillLight.position.set(4, 2, 3);
       this.scene.add(this.hemisphereLight, this.directionalLight, this.fillLight);
       this.modelLoader = new ObjLoader();
+      this.plyLoader = new PlyLoader();
       controller = new CameraController(this.camera, this.requestRender.bind(this));
       this.controller = controller;
       viewCube = new ViewCube(this.requestRender.bind(this));
@@ -31285,6 +32307,30 @@ class Renderer {
       stone: source
     });
   }
+  importModelResourceScene(source) {
+    this.assertNotDisposed();
+    if (this.contextLost) {
+      return Promise.resolve({
+        code: ObjImportFailureCode$1.RenderFailed,
+        success: false
+      });
+    }
+    try {
+      const resources = {
+        base: source.base === void 0 ? void 0 : new ModelResourceList(source.base.fileUrls),
+        stone: source.stone === void 0 ? void 0 : new ModelResourceList(source.stone.fileUrls)
+      };
+      if (this.containsOnlyObjResources(resources)) {
+        return this.importObjResourceScene(source);
+      }
+      return this.completeSceneImport(this.startImportSession(), resources);
+    } catch {
+      return Promise.resolve({
+        code: ObjImportFailureCode$1.InvalidSource,
+        success: false
+      });
+    }
+  }
   importObjResources(source) {
     this.assertNotDisposed();
     if (this.contextLost) {
@@ -31378,6 +32424,12 @@ class Renderer {
     window.cancelAnimationFrame(this.frameHandle);
     this.frameHandle = void 0;
   }
+  containsOnlyObjResources(source) {
+    const resources = [source.stone, source.base];
+    return resources.every(
+      (resource) => resource === void 0 || resource instanceof ObjResourceList || resource.isObj()
+    );
+  }
   async completeSceneImport(session, source) {
     const stoneSource = source.stone;
     const baseSource = source.base;
@@ -31399,7 +32451,7 @@ class Renderer {
     }
     const secondCandidate = await this.loadModel(session, baseSource);
     if (this.isImportResult(secondCandidate)) {
-      this.releaseModels(candidateModels);
+      this.releaseLoadedModels(candidateModels);
       return secondCandidate;
     }
     candidateModels.push(secondCandidate);
@@ -31415,7 +32467,14 @@ class Renderer {
   async loadModel(session, source) {
     let result;
     try {
-      result = source instanceof ObjResourceList ? await this.modelLoader.loadResources(source, session.controller.signal) : await this.modelLoader.load(source, session.controller.signal);
+      if (source instanceof ModelResourceList) {
+        result = source.resources instanceof ObjResourceList ? await this.modelLoader.loadResources(
+          source.resources,
+          session.controller.signal
+        ) : await this.plyLoader.load(source.resources, session.controller.signal);
+      } else {
+        result = source instanceof ObjResourceList ? await this.modelLoader.loadResources(source, session.controller.signal) : await this.modelLoader.load(source, session.controller.signal);
+      }
     } catch {
       return this.completeUnexpectedImportFailure(session);
     }
@@ -31450,7 +32509,10 @@ class Renderer {
         success: false
       };
     }
-    return result.model;
+    return {
+      model: result.model,
+      warnings: result.warnings ?? []
+    };
   }
   completeUnexpectedImportFailure(session) {
     const invalidationCode = session.invalidationCode;
@@ -31525,6 +32587,9 @@ class Renderer {
       throw errors[0];
     }
   }
+  releaseLoadedModels(models) {
+    this.releaseModels(models.map(({ model }) => model));
+  }
   releaseImportedModel(result) {
     if (result.model !== void 0) {
       this.releaseModel(result.model);
@@ -31577,7 +32642,12 @@ class Renderer {
       this.renderer.setScissorTest(previousScissorTest);
     }
   }
-  replaceActiveModels(session, models) {
+  replaceActiveModels(session, loadedModels) {
+    const [firstLoadedModel, ...remainingLoadedModels] = loadedModels;
+    const models = [
+      firstLoadedModel.model,
+      ...remainingLoadedModels.map(({ model }) => model)
+    ];
     const invalidationCode = session.invalidationCode;
     if (invalidationCode !== void 0) {
       this.finishImportSession(session);
@@ -31607,10 +32677,16 @@ class Renderer {
     this.activeModels = [...models];
     this.releaseModels(previousModels);
     this.requestRender();
+    const warnings = this.mergeWarnings(loadedModels);
     return {
-      success: true
+      success: true,
+      ...warnings === void 0 ? {} : { warnings }
     };
   }
+  mergeWarnings(models) {
+    const warnings = models.flatMap(({ warnings: modelWarnings }) => modelWarnings);
+    return warnings.length > 0 ? warnings : void 0;
+  }
   mergeBounds(models) {
     const [firstModel, ...remainingModels] = models;
     let minX = firstModel.bounds.min.x;
@@ -31694,6 +32770,10 @@ var ObjImportFailureCode = /* @__PURE__ */ ((ObjImportFailureCode2) => {
   ObjImportFailureCode2["Unavailable"] = "unavailable";
   return ObjImportFailureCode2;
 })(ObjImportFailureCode || {});
+var ObjImportWarningCode = /* @__PURE__ */ ((ObjImportWarningCode2) => {
+  ObjImportWarningCode2["IncompleteMaterial"] = "incomplete-material";
+  return ObjImportWarningCode2;
+})(ObjImportWarningCode || {});
 class Application {
   disposed = false;
   renderer;
@@ -31708,6 +32788,10 @@ class Application {
     this.assertNotDisposed();
     return this.mapAsyncObjImportResult(this.getRenderer().importObj(source));
   }
+  importModelResourceScene(source) {
+    this.assertNotDisposed();
+    return this.mapAsyncObjImportResult(this.getRenderer().importModelResourceScene(source));
+  }
   importObjResources(source) {
     this.assertNotDisposed();
     return this.mapAsyncObjImportResult(this.getRenderer().importObjResources(source));
@@ -31754,8 +32838,10 @@ class Application {
   }
   mapObjImportResult(result) {
     if (result.success) {
+      const warnings = this.mapWarnings(result.warnings);
       return {
-        success: true
+        success: true,
+        ...warnings === void 0 ? {} : { warnings }
       };
     }
     switch (result.code) {
@@ -31781,8 +32867,17 @@ class Application {
   async mapAsyncObjImportResult(resultPromise) {
     return this.mapObjImportResult(await resultPromise);
   }
+  mapWarnings(warnings) {
+    if (warnings === void 0 || warnings.length === 0) {
+      return void 0;
+    }
+    return warnings.map(() => ({
+      code: ObjImportWarningCode.IncompleteMaterial
+    }));
+  }
 }
 export {
   Application,
-  ObjImportFailureCode
+  ObjImportFailureCode,
+  ObjImportWarningCode
 };