@threepipe/plugins-extra-importers 0.2.2 → 0.2.4

package/CHANGELOG.md

@@ -0,0 +1,20 @@
+# Changelog for @threepipe/extra-importers
+
+All notable changes to this plugin will be documented in this file.
+
+[//]: # (The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).)
+
+## [Unreleased]
+
+### Added
+
+- NA
+
+## [0.2.4] - 2025-09-01
+
+### Changed
+
+- Update [threepipe](https://threepipe.org/) `peerDependency` to [0.1.0](https://github.com/repalash/threepipe/releases/tag/v0.1.0)
+
+[unreleased]: https://github.com/repalash/threepipe/tree/dev/plugins/extra-importers
+[0.2.4]: https://github.com/repalash/threepipe/releases/tag/@threepipe/plugin-extra-importers-v0.2.4

package/README.md

@@ -0,0 +1,12 @@
+# @threepipe/extra-importers
+
+Additional importers for [threepipe](https://threepipe.org/) to handle various 3D file formats.
+
+[Github](https://github.com/repalash/threepipe/tree/dev/plugins/extra-importers) —
+[Examples](https://threepipe.org/examples/?q=extra#extra-importer-plugins/) —
+[API Reference](https://threepipe.org/docs/)
+
+[![NPM Package](https://img.shields.io/npm/v/@threepipe/plugin-extra-importers.svg)](https://www.npmjs.com/package/@threepipe/plugin-extra-importers)
+[![License: Apache 2.0](https://img.shields.io/badge/License-Apache%202.0-green.svg)](https://opensource.org/license/apache-2-0/)
+
+**Documentation and Guides**: [threepipe.org/package/plugin-extra-importers](https://threepipe.org/package/plugin-extra-importers.html)

package/dist/dependencies.txt

@@ -1,5 +1,5 @@
 Name: three
-Version: 0.153.1006
+Version: 0.160.1006
 License: MIT
 Private: false
 Description: JavaScript 3D library

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { AnyOptions, BaseImporterPlugin, BufferGeometry, Group, Importer, Mesh, Object3D, Points, Scene } from 'threepipe';
+import { AnyOptions, BaseImporterPlugin, BufferGeometry, Group, ImportAddOptions, Importer, Mesh, Object3D, Points, PointsMaterial, Scene } from 'threepipe';
 import { TDSLoader } from 'three/examples/jsm/loaders/TDSLoader.js';
 import { ThreeMFLoader } from 'three/examples/jsm/loaders/3MFLoader.js';
 import { Collada } from 'three/examples/jsm/loaders/ColladaLoader.js';
@@ -30,17 +30,17 @@ export declare class ColladaLoadPlugin extends BaseImporterPlugin {
     static readonly PluginType = "ColladaLoadPlugin";
     protected _importer: Importer<{
         transform(res: Collada, _: AnyOptions): Scene;
-        load(url: string, onLoad: (collada: Collada) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
-        loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Collada>;
         parse(text: string, path: string): Collada;
         crossOrigin: string;
         withCredentials: boolean;
         path: string;
         resourcePath: string;
-        manager: import('threepipe').LoadingManager;
+        manager: import('./threepipe').LoadingManager;
         requestHeader: {
             [header: string]: string;
         };
+        load(url: string, onLoad: (data: Collada) => void, onProgress?: (event: ProgressEvent) => void, onError?: (err: unknown) => void): void;
+        loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Collada>;
         setCrossOrigin(crossOrigin: string): /*elided*/ any;
         setWithCredentials(value: boolean): /*elided*/ any;
         setPath(path: string): /*elided*/ any;
@@ -73,17 +73,17 @@ export declare class BVHLoadPlugin extends BaseImporterPlugin {
         transform(res: BVH, _: AnyOptions): Object3D;
         animateBonePositions: boolean;
         animateBoneRotations: boolean;
-        load(url: string, onLoad: (bvh: BVH) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
-        loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<BVH>;
         parse(text: string): BVH;
         crossOrigin: string;
         withCredentials: boolean;
         path: string;
         resourcePath: string;
-        manager: import('threepipe').LoadingManager;
+        manager: import('./threepipe').LoadingManager;
         requestHeader: {
             [header: string]: string;
         };
+        load(url: string, onLoad: (data: BVH) => void, onProgress?: (event: ProgressEvent) => void, onError?: (err: unknown) => void): void;
+        loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<BVH>;
         setCrossOrigin(crossOrigin: string): /*elided*/ any;
         setWithCredentials(value: boolean): /*elided*/ any;
         setPath(path: string): /*elided*/ any;
@@ -100,17 +100,17 @@ export declare class VOXLoadPlugin extends BaseImporterPlugin {
     static readonly PluginType = "VOXLoadPlugin";
     protected _importer: Importer<{
         transform(chunks: Chunk[], _: AnyOptions): Object3D;
-        load(url: string, onLoad: (chunks: Chunk[]) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
-        loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Chunk[]>;
         parse(data: ArrayBuffer): object[];
         crossOrigin: string;
         withCredentials: boolean;
         path: string;
         resourcePath: string;
-        manager: import('threepipe').LoadingManager;
+        manager: import('./threepipe').LoadingManager;
         requestHeader: {
             [header: string]: string;
         };
+        load(url: string, onLoad: (data: Chunk[]) => void, onProgress?: (event: ProgressEvent) => void, onError?: (err: unknown) => void): void;
+        loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Chunk[]>;
         setCrossOrigin(crossOrigin: string): /*elided*/ any;
         setWithCredentials(value: boolean): /*elided*/ any;
         setPath(path: string): /*elided*/ any;
@@ -127,17 +127,17 @@ export declare class MDDLoadPlugin extends BaseImporterPlugin {
     static readonly PluginType = "MDDLoadPlugin";
     protected _importer: Importer<{
         transform(res: MDD, _: AnyOptions): Object3D;
-        load(url: string, onLoad: (result: MDD) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
-        loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<MDD>;
         parse(data: ArrayBuffer): MDD;
         crossOrigin: string;
         withCredentials: boolean;
         path: string;
         resourcePath: string;
-        manager: import('threepipe').LoadingManager;
+        manager: import('./threepipe').LoadingManager;
         requestHeader: {
             [header: string]: string;
         };
+        load(url: string, onLoad: (data: MDD) => void, onProgress?: (event: ProgressEvent) => void, onError?: (err: unknown) => void): void;
+        loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<MDD>;
         setCrossOrigin(crossOrigin: string): /*elided*/ any;
         setWithCredentials(value: boolean): /*elided*/ any;
         setPath(path: string): /*elided*/ any;
@@ -153,19 +153,19 @@ export declare class MDDLoadPlugin extends BaseImporterPlugin {
 export declare class PCDLoadPlugin extends BaseImporterPlugin {
     static readonly PluginType = "PCDLoadPlugin";
     protected _importer: Importer<{
-        transform(points: Points, options: AnyOptions): any;
+        transform(points: Points, options: ImportAddOptions): any;
         littleEndian: boolean;
-        load(url: string, onLoad: (points: Points) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
-        loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Points>;
-        parse(data: ArrayBuffer | string): Points;
+        parse(data: ArrayBuffer | string): Points<BufferGeometry, PointsMaterial>;
         crossOrigin: string;
         withCredentials: boolean;
         path: string;
         resourcePath: string;
-        manager: import('threepipe').LoadingManager;
+        manager: import('./threepipe').LoadingManager;
         requestHeader: {
             [header: string]: string;
         };
+        load(url: string, onLoad: (data: Points<BufferGeometry<import('./threepipe').NormalBufferAttributes, import('./threepipe').BufferGeometryEventMap>, PointsMaterial>) => void, onProgress?: (event: ProgressEvent) => void, onError?: (err: unknown) => void): void;
+        loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Points<BufferGeometry<import('./threepipe').NormalBufferAttributes, import('./threepipe').BufferGeometryEventMap>, PointsMaterial>>;
         setCrossOrigin(crossOrigin: string): /*elided*/ any;
         setWithCredentials(value: boolean): /*elided*/ any;
         setPath(path: string): /*elided*/ any;
@@ -196,26 +196,26 @@ export declare class LDrawLoadPlugin extends BaseImporterPlugin {
     static readonly PluginType = "LDrawLoadPlugin";
     protected _importer: Importer<{
         transform(res: Group, _: AnyOptions): any;
-        materials: import('threepipe').Material[];
-        materialsLibrary: Record<string, import('threepipe').Material>;
+        materials: import('./threepipe').Material[];
+        materialsLibrary: Record<string, import('./threepipe').Material>;
         fileMap: Record<string, string>;
         smoothNormals: boolean;
-        load(url: string, onLoad: (data: Group) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
-        loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Group>;
         preloadMaterials(url: string): Promise<void>;
         setFileMap(fileMap: Record<string, string>): void;
-        setMaterials(materials: import('threepipe').Material[]): void;
+        setMaterials(materials: import('./threepipe').Material[]): void;
         parse(text: string, path: string, onLoad: (data: Group) => void): void;
-        addMaterial(material: import('threepipe').Material): void;
-        getMaterial(colourCode: string): import('threepipe').Material | null;
+        addMaterial(material: import('./threepipe').Material): void;
+        getMaterial(colourCode: string): import('./threepipe').Material | null;
         crossOrigin: string;
         withCredentials: boolean;
         path: string;
         resourcePath: string;
-        manager: import('threepipe').LoadingManager;
+        manager: import('./threepipe').LoadingManager;
         requestHeader: {
             [header: string]: string;
         };
+        load(url: string, onLoad: (data: Group<import('./threepipe').Object3DEventMap>) => void, onProgress?: (event: ProgressEvent) => void, onError?: (err: unknown) => void): void;
+        loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Group<import('./threepipe').Object3DEventMap>>;
         setCrossOrigin(crossOrigin: string): /*elided*/ any;
         setWithCredentials(value: boolean): /*elided*/ any;
         setPath(path: string): /*elided*/ any;
@@ -232,17 +232,17 @@ export declare class VTKLoadPlugin extends BaseImporterPlugin {
     static readonly PluginType = "VTKLoadPlugin";
     protected _importer: Importer<{
         transform(res: BufferGeometry, _: AnyOptions): Mesh | undefined;
-        load(url: string, onLoad: (geometry: BufferGeometry) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
-        loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<BufferGeometry>;
         parse(data: ArrayBuffer | string, path: string): BufferGeometry;
         crossOrigin: string;
         withCredentials: boolean;
         path: string;
         resourcePath: string;
-        manager: import('threepipe').LoadingManager;
+        manager: import('./threepipe').LoadingManager;
         requestHeader: {
             [header: string]: string;
         };
+        load(url: string, onLoad: (data: BufferGeometry<import('./threepipe').NormalBufferAttributes, import('./threepipe').BufferGeometryEventMap>) => void, onProgress?: (event: ProgressEvent) => void, onError?: (err: unknown) => void): void;
+        loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<BufferGeometry<import('./threepipe').NormalBufferAttributes, import('./threepipe').BufferGeometryEventMap>>;
         setCrossOrigin(crossOrigin: string): /*elided*/ any;
         setWithCredentials(value: boolean): /*elided*/ any;
         setPath(path: string): /*elided*/ any;
@@ -258,18 +258,18 @@ export declare class VTKLoadPlugin extends BaseImporterPlugin {
 export declare class XYZLoadPlugin extends BaseImporterPlugin {
     static readonly PluginType = "XYZLoadPlugin";
     protected _importer: Importer<{
-        transform(res: BufferGeometry, options: AnyOptions): Points | undefined;
-        load(url: string, onLoad: (geometry: BufferGeometry) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
-        loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<BufferGeometry>;
+        transform(res: BufferGeometry, options: ImportAddOptions): Points | undefined;
         parse(data: string, onLoad: (geometry: BufferGeometry) => void): object;
         crossOrigin: string;
         withCredentials: boolean;
         path: string;
         resourcePath: string;
-        manager: import('threepipe').LoadingManager;
+        manager: import('./threepipe').LoadingManager;
         requestHeader: {
             [header: string]: string;
         };
+        load(url: string, onLoad: (data: BufferGeometry<import('./threepipe').NormalBufferAttributes, import('./threepipe').BufferGeometryEventMap>) => void, onProgress?: (event: ProgressEvent) => void, onError?: (err: unknown) => void): void;
+        loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<BufferGeometry<import('./threepipe').NormalBufferAttributes, import('./threepipe').BufferGeometryEventMap>>;
         setCrossOrigin(crossOrigin: string): /*elided*/ any;
         setWithCredentials(value: boolean): /*elided*/ any;
         setPath(path: string): /*elided*/ any;

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -1,11 +1,11 @@
 /**
  * @license
- * @threepipe/plugins-extra-importers v0.2.2
+ * @threepipe/plugins-extra-importers v0.2.4
  * Copyright 2022-2025 repalash <palash@shaders.app>
  * Apache-2.0 License
  * See ./dependencies.txt for any bundled third-party dependencies and licenses.
  */
-import { Loader, LoaderUtils, FileLoader, Group, MeshPhongMaterial, DoubleSide, AdditiveBlending, BufferGeometry, Mesh, Float32BufferAttribute, Matrix4, TextureLoader, Color, SRGBColorSpace, BufferAttribute, MeshStandardMaterial, RepeatWrapping, ClampToEdgeWrapping, MirroredRepeatWrapping, LinearFilter, LinearMipmapLinearFilter, NearestFilter, DataTextureLoader, Vector3, Quaternion, MeshBasicMaterial, Scene, MathUtils, AnimationClip, VectorKeyframeTrack, QuaternionKeyframeTrack, MeshLambertMaterial, Vector2, FrontSide, PerspectiveCamera, OrthographicCamera, AmbientLight, SpotLight, PointLight, DirectionalLight, Bone, LineBasicMaterial, SkinnedMesh, Line, LineSegments, Skeleton, NumberKeyframeTrack, Int32BufferAttribute, PointsMaterial, Points, RawShaderMaterial, Object3D, SphereGeometry, BackSide, DataTexture, BoxGeometry, ConeGeometry, CylinderGeometry, ShapeUtils, Ray, ShaderMaterial, UniformsUtils, UniformsLib, BaseImporterPlugin, Importer, SkeletonHelper, PhysicalMaterial } from "threepipe";
+import { Loader, LoaderUtils, FileLoader, Group, MeshPhongMaterial, DoubleSide, AdditiveBlending, BufferGeometry, Mesh, Float32BufferAttribute, Matrix4, TextureLoader, Color, SRGBColorSpace, BufferAttribute, RepeatWrapping, ClampToEdgeWrapping, MirroredRepeatWrapping, LinearFilter, LinearMipmapLinearFilter, NearestFilter, MeshStandardMaterial, DataTextureLoader, Vector3, Quaternion, MeshBasicMaterial, Scene, MathUtils, AnimationClip, MeshLambertMaterial, Vector2, FrontSide, PerspectiveCamera, OrthographicCamera, AmbientLight, SpotLight, PointLight, DirectionalLight, VectorKeyframeTrack, QuaternionKeyframeTrack, Bone, LineBasicMaterial, SkinnedMesh, Line, LineSegments, Skeleton, NumberKeyframeTrack, Int32BufferAttribute, PointsMaterial, Points, RawShaderMaterial, Object3D, SphereGeometry, BackSide, DataTexture, BoxGeometry, ConeGeometry, CylinderGeometry, ShapeUtils, ShaderMaterial, UniformsUtils, UniformsLib, Ray, BaseImporterPlugin, Importer, SkeletonHelper, PhysicalMaterial } from "threepipe";
 class TDSLoader extends Loader {
   constructor(manager) {
     super(manager);
@@ -1660,7 +1660,11 @@ class ThreeMFLoader extends Loader {
       const geometry = new BufferGeometry();
       geometry.setIndex(new BufferAttribute(meshData["triangles"], 1));
       geometry.setAttribute("position", new BufferAttribute(meshData["vertices"], 3));
-      const material = new MeshPhongMaterial({ color: 16777215, flatShading: true });
+      const material = new MeshPhongMaterial({
+        name: Loader.DEFAULT_MATERIAL_NAME,
+        color: 16777215,
+        flatShading: true
+      });
       const mesh = new Mesh(geometry, material);
       return mesh;
     }
@@ -1882,7 +1886,7 @@ class TGALoader extends DataTextureLoader {
         case TGA_TYPE_INDEXED:
         case TGA_TYPE_RLE_INDEXED:
           if (header2.colormap_length > 256 || header2.colormap_size !== 24 || header2.colormap_type !== 1) {
-            console.error("THREE.TGALoader: Invalid type colormap data for indexed type.");
+            throw new Error("THREE.TGALoader: Invalid type colormap data for indexed type.");
           }
           break;
         // check colormap type
@@ -1891,21 +1895,21 @@ class TGALoader extends DataTextureLoader {
         case TGA_TYPE_RLE_RGB:
         case TGA_TYPE_RLE_GREY:
           if (header2.colormap_type) {
-            console.error("THREE.TGALoader: Invalid type colormap data for colormap type.");
+            throw new Error("THREE.TGALoader: Invalid type colormap data for colormap type.");
           }
           break;
         // What the need of a file without data ?
         case TGA_TYPE_NO_DATA:
-          console.error("THREE.TGALoader: No data.");
+          throw new Error("THREE.TGALoader: No data.");
         // Invalid type ?
         default:
-          console.error('THREE.TGALoader: Invalid type "%s".', header2.image_type);
+          throw new Error("THREE.TGALoader: Invalid type " + header2.image_type);
       }
       if (header2.width <= 0 || header2.height <= 0) {
-        console.error("THREE.TGALoader: Invalid image size.");
+        throw new Error("THREE.TGALoader: Invalid image size.");
       }
       if (header2.pixel_size !== 8 && header2.pixel_size !== 16 && header2.pixel_size !== 24 && header2.pixel_size !== 32) {
-        console.error('THREE.TGALoader: Invalid pixel size "%s".', header2.pixel_size);
+        throw new Error("THREE.TGALoader: Invalid pixel size " + header2.pixel_size);
       }
     }
     function tgaParse(use_rle2, use_pal2, header2, offset2, data) {
@@ -2078,8 +2082,7 @@ class TGALoader extends DataTextureLoader {
             tgaGetImageDataGrey16bits(data, y_start, y_step, y_end, x_start, x_step, x_end, image);
             break;
           default:
-            console.error("THREE.TGALoader: Format not supported.");
-            break;
+            throw new Error("THREE.TGALoader: Format not supported.");
         }
       } else {
         switch (header.pixel_size) {
@@ -2096,14 +2099,13 @@ class TGALoader extends DataTextureLoader {
             tgaGetImageData32bits(data, y_start, y_step, y_end, x_start, x_step, x_end, image);
             break;
           default:
-            console.error("THREE.TGALoader: Format not supported.");
-            break;
+            throw new Error("THREE.TGALoader: Format not supported.");
         }
       }
       return data;
     }
     const TGA_TYPE_NO_DATA = 0, TGA_TYPE_INDEXED = 1, TGA_TYPE_RGB = 2, TGA_TYPE_GREY = 3, TGA_TYPE_RLE_INDEXED = 9, TGA_TYPE_RLE_RGB = 10, TGA_TYPE_RLE_GREY = 11, TGA_ORIGIN_MASK = 48, TGA_ORIGIN_SHIFT = 4, TGA_ORIGIN_BL = 0, TGA_ORIGIN_BR = 1, TGA_ORIGIN_UL = 2, TGA_ORIGIN_UR = 3;
-    if (buffer.length < 19) console.error("THREE.TGALoader: Not enough data to contain header.");
+    if (buffer.length < 19) throw new Error("THREE.TGALoader: Not enough data to contain header.");
     let offset = 0;
     const content = new Uint8Array(buffer), header = {
       id_length: content[offset++],
@@ -2123,7 +2125,7 @@ class TGALoader extends DataTextureLoader {
     };
     tgaCheckHeader(header);
     if (header.id_length + offset > buffer.length) {
-      console.error("THREE.TGALoader: No data.");
+      throw new Error("THREE.TGALoader: No data.");
     }
     offset += header.id_length;
     let use_rle = false, use_pal = false, use_grey = false;
@@ -2162,9 +2164,6 @@ class TGALoader extends DataTextureLoader {
   }
 }
 class ColladaLoader extends Loader {
-  constructor(manager) {
-    super(manager);
-  }
   load(url, onLoad, onProgress, onError) {
     const scope = this;
     const path = scope.path === "" ? LoaderUtils.extractUrlBase(url) : scope.path;
@@ -4268,7 +4267,10 @@ class ColladaLoader extends Loader {
       object.matrix.decompose(object.position, object.quaternion, object.scale);
       return object;
     }
-    const fallbackMaterial = new MeshBasicMaterial({ color: 16711935 });
+    const fallbackMaterial = new MeshBasicMaterial({
+      name: Loader.DEFAULT_MATERIAL_NAME,
+      color: 16711935
+    });
     function resolveMaterialBinding(keys, instanceMaterials) {
       const materials = [];
       for (let i = 0, l = keys.length; i < l; i++) {
@@ -4423,7 +4425,7 @@ class ColladaLoader extends Loader {
     const textureLoader = new TextureLoader(this.manager);
     textureLoader.setPath(this.resourcePath || path).setCrossOrigin(this.crossOrigin);
     let tgaLoader;
-    {
+    if (TGALoader) {
       tgaLoader = new TGALoader(this.manager);
       tgaLoader.setPath(this.resourcePath || path);
     }
@@ -4717,7 +4719,11 @@ class AMFLoader extends Loader {
       }
     }
     const sceneObject = new Group();
-    const defaultMaterial = new MeshPhongMaterial({ color: 11184895, flatShading: true });
+    const defaultMaterial = new MeshPhongMaterial({
+      name: Loader.DEFAULT_MATERIAL_NAME,
+      color: 11184895,
+      flatShading: true
+    });
     sceneObject.name = amfName;
     sceneObject.userData.author = amfAuthor;
     sceneObject.userData.loader = "AMF";
@@ -11387,7 +11393,10 @@ class VRMLLoader extends Loader {
     }
     function buildShapeNode(node) {
       const fields = node.fields;
-      let material = new MeshBasicMaterial({ color: 0 });
+      let material = new MeshBasicMaterial({
+        name: Loader.DEFAULT_MATERIAL_NAME,
+        color: 0
+      });
       let geometry;
       for (let i = 0, l = fields.length; i < l; i++) {
         const field = fields[i];
@@ -11413,7 +11422,10 @@ class VRMLLoader extends Loader {
       if (geometry && geometry.attributes.position) {
         const type = geometry._type;
         if (type === "points") {
-          const pointsMaterial = new PointsMaterial({ color: 16777215 });
+          const pointsMaterial = new PointsMaterial({
+            name: Loader.DEFAULT_MATERIAL_NAME,
+            color: 16777215
+          });
           if (geometry.attributes.color !== void 0) {
             pointsMaterial.vertexColors = true;
           } else {
@@ -11423,7 +11435,10 @@ class VRMLLoader extends Loader {
           }
           object = new Points(geometry, pointsMaterial);
         } else if (type === "line") {
-          const lineMaterial = new LineBasicMaterial({ color: 16777215 });
+          const lineMaterial = new LineBasicMaterial({
+            name: Loader.DEFAULT_MATERIAL_NAME,
+            color: 16777215
+          });
           if (geometry.attributes.color !== void 0) {
             lineMaterial.vertexColors = true;
           } else {
@@ -11466,7 +11481,10 @@ class VRMLLoader extends Loader {
               if (materialData.transparency) material.opacity = 1 - materialData.transparency;
               if (materialData.transparency > 0) material.transparent = true;
             } else {
-              material = new MeshBasicMaterial({ color: 0 });
+              material = new MeshBasicMaterial({
+                name: Loader.DEFAULT_MATERIAL_NAME,
+                color: 0
+              });
             }
             break;
           case "texture":
@@ -12924,7 +12942,7 @@ class LDrawConditionalLineMaterial extends ShaderMaterial {
 				outgoingLight = diffuseColor.rgb; // simple shader
 				gl_FragColor = vec4( outgoingLight, diffuseColor.a );
 				#include <tonemapping_fragment>
-				#include <encodings_fragment>
+				#include <colorspace_fragment>
 				#include <fog_fragment>
 				#include <premultiplied_alpha_fragment>
 			}
@@ -13285,7 +13303,7 @@ class LDrawParsedCache {
       try {
         const text = await fileLoader.loadAsync(subobjectURL);
         return text;
-      } catch {
+      } catch (_) {
         continue;
       }
     }
@@ -13755,13 +13773,13 @@ class LDrawPartsGeometryCache {
     }
     const group = info.group;
     if (info.faces.length > 0) {
-      group.add(createObject(info.faces, 3, false, info.totalFaces));
+      group.add(createObject(this.loader, info.faces, 3, false, info.totalFaces));
     }
     if (info.lineSegments.length > 0) {
-      group.add(createObject(info.lineSegments, 2));
+      group.add(createObject(this.loader, info.lineSegments, 2));
     }
     if (info.conditionalSegments.length > 0) {
-      group.add(createObject(info.conditionalSegments, 2, true));
+      group.add(createObject(this.loader, info.conditionalSegments, 2, true));
     }
     return group;
   }
@@ -13816,7 +13834,7 @@ function sortByMaterial(a, b) {
   }
   return 1;
 }
-function createObject(elements, elementSize, isConditionalSegments = false, totalElements = null) {
+function createObject(loader, elements, elementSize, isConditionalSegments = false, totalElements = null) {
   elements.sort(sortByMaterial);
   if (totalElements === null) {
     totalElements = elements.length;
@@ -13889,9 +13907,10 @@ function createObject(elements, elementSize, isConditionalSegments = false, tota
           materials.push(material);
         } else if (elementSize === 2) {
           if (isConditionalSegments) {
-            materials.push(material.userData.edgeMaterial.userData.conditionalEdgeMaterial);
+            const edgeMaterial = loader.edgeMaterialCache.get(material);
+            materials.push(loader.conditionalEdgeMaterialCache.get(edgeMaterial));
           } else {
-            materials.push(material.userData.edgeMaterial);
+            materials.push(loader.edgeMaterialCache.get(material));
           }
         }
       } else {
@@ -13966,19 +13985,18 @@ class LDrawLoader extends Loader {
     super(manager);
     this.materials = [];
     this.materialLibrary = {};
+    this.edgeMaterialCache = /* @__PURE__ */ new WeakMap();
+    this.conditionalEdgeMaterialCache = /* @__PURE__ */ new WeakMap();
     this.partsCache = new LDrawPartsGeometryCache(this);
     this.fileMap = {};
     this.setMaterials([]);
     this.smoothNormals = true;
     this.partsLibraryPath = "";
-    this.missingColorMaterial = new MeshStandardMaterial({ color: 16711935, roughness: 0.3, metalness: 0 });
-    this.missingColorMaterial.name = "Missing material";
-    this.missingEdgeColorMaterial = new LineBasicMaterial({ color: 16711935 });
-    this.missingEdgeColorMaterial.name = "Missing material - Edge";
-    this.missingConditionalEdgeColorMaterial = new LDrawConditionalLineMaterial({ fog: true, color: 16711935 });
-    this.missingConditionalEdgeColorMaterial.name = "Missing material - Conditional Edge";
-    this.missingColorMaterial.userData.edgeMaterial = this.missingEdgeColorMaterial;
-    this.missingEdgeColorMaterial.userData.conditionalEdgeMaterial = this.missingConditionalEdgeColorMaterial;
+    this.missingColorMaterial = new MeshStandardMaterial({ name: Loader.DEFAULT_MATERIAL_NAME, color: 16711935, roughness: 0.3, metalness: 0 });
+    this.missingEdgeColorMaterial = new LineBasicMaterial({ name: Loader.DEFAULT_MATERIAL_NAME, color: 16711935 });
+    this.missingConditionalEdgeColorMaterial = new LDrawConditionalLineMaterial({ name: Loader.DEFAULT_MATERIAL_NAME, fog: true, color: 16711935 });
+    this.edgeMaterialCache.set(this.missingColorMaterial, this.missingEdgeColorMaterial);
+    this.conditionalEdgeMaterialCache.set(this.missingEdgeColorMaterial, this.missingConditionalEdgeColorMaterial);
   }
   setPartsLibraryPath(path) {
     this.partsLibraryPath = path;
@@ -14094,9 +14112,9 @@ class LDrawLoader extends Loader {
         return colorCode;
       }
       if (c.isLineSegments) {
-        material = material.userData.edgeMaterial;
+        material = loader.edgeMaterialCache.get(material);
         if (c.isConditionalLine) {
-          material = material.userData.conditionalEdgeMaterial;
+          material = loader.conditionalEdgeMaterialCache.get(material);
         }
       }
       return material;
@@ -14107,7 +14125,7 @@ class LDrawLoader extends Loader {
   }
   getMainEdgeMaterial() {
     const mat = this.getMaterial(MAIN_EDGE_COLOUR_CODE);
-    return mat ? mat.userData.edgeMaterial : null;
+    return mat ? this.edgeMaterialCache.get(mat) : null;
   }
   parseColorMetaDirective(lineParser) {
     let code = null;
@@ -14150,7 +14168,7 @@ class LDrawLoader extends Loader {
               if (!edgeMaterial) {
                 throw new Error("LDrawLoader: Invalid edge color while parsing material" + lineParser.getLineNumberString() + ".");
               }
-              edgeMaterial = edgeMaterial.userData.edgeMaterial;
+              edgeMaterial = this.edgeMaterialCache.get(edgeMaterial);
             }
             break;
           case "ALPHA":
@@ -14232,19 +14250,20 @@ class LDrawLoader extends Loader {
       edgeMaterial.color;
       edgeMaterial.userData.code = code;
       edgeMaterial.name = name + " - Edge";
-      edgeMaterial.userData.conditionalEdgeMaterial = new LDrawConditionalLineMaterial({
+      const conditionalEdgeMaterial = new LDrawConditionalLineMaterial({
         fog: true,
         transparent: isTransparent,
         depthWrite: !isTransparent,
         color: new Color().setStyle(edgeColor, COLOR_SPACE_LDRAW),
         opacity: alpha
       });
-      edgeMaterial.userData.conditionalEdgeMaterial.userData.code = code;
-      edgeMaterial.userData.conditionalEdgeMaterial.name = name + " - Conditional Edge";
+      conditionalEdgeMaterial.userData.code = code;
+      conditionalEdgeMaterial.name = name + " - Conditional Edge";
+      this.conditionalEdgeMaterialCache.set(edgeMaterial, conditionalEdgeMaterial);
     }
     material.userData.code = code;
     material.name = name;
-    material.userData.edgeMaterial = edgeMaterial;
+    this.edgeMaterialCache.set(material, edgeMaterial);
     this.addMaterial(material);
     return material;
     function parseLuminance(token2) {