three-stdlib 2.8.2 → 2.8.3

package/{BufferGeometryUtils-582025b8.js → BufferGeometryUtils-1a7a235c.js}

@@ -485,7 +485,8 @@ function computeMorphedAttributes(object) {
 
     const morphInfluences = object.morphTargetInfluences;
 
-    if (material.morphTargets && morphAttribute && morphInfluences) {
+    if ( // @ts-expect-error
+    material.morphTargets && morphAttribute && morphInfluences) {
       _morphA.set(0, 0, 0);
 
       _morphB.set(0, 0, 0);

package/animation/MMDAnimationHelper.d.ts

@@ -14,34 +14,34 @@ import { CCDIKSolver } from './CCDIKSolver';
 import { MMDPhysics } from './MMDPhysics';
 
 export interface MMDAnimationHelperParameter {
-    sync?: boolean;
-    afterglow?: number;
-    resetPhysicsOnLoop?: boolean;
+    sync?: boolean | undefined;
+    afterglow?: number | undefined;
+    resetPhysicsOnLoop?: boolean | undefined;
 }
 
 export interface MMDAnimationHelperAddParameter {
-    animation?: AnimationClip | AnimationClip[];
-    physics?: boolean;
-    warmup?: number;
-    unitStep?: number;
-    maxStepNum?: number;
-    gravity?: number;
-    delayTime?: number;
+    animation?: AnimationClip | AnimationClip[] | undefined;
+    physics?: boolean | undefined;
+    warmup?: number | undefined;
+    unitStep?: number | undefined;
+    maxStepNum?: number | undefined;
+    gravity?: number | undefined;
+    delayTime?: number | undefined;
 }
 
 export interface MMDAnimationHelperPoseParameter {
-    resetPose?: boolean;
-    ik?: boolean;
-    grant?: boolean;
+    resetPose?: boolean | undefined;
+    ik?: boolean | undefined;
+    grant?: boolean | undefined;
 }
 
 export interface MMDAnimationHelperMixer {
     looped: boolean;
-    mixer?: AnimationMixer;
+    mixer?: AnimationMixer | undefined;
     ikSolver: CCDIKSolver;
     grantSolver: GrantSolver;
-    physics?: MMDPhysics;
-    duration?: number;
+    physics?: MMDPhysics | undefined;
+    duration?: number | undefined;
 }
 
 export class MMDAnimationHelper {
@@ -77,7 +77,7 @@ export class MMDAnimationHelper {
 }
 
 export interface AudioManagerParameter {
-    delayTime?: number;
+    delayTime?: number | undefined;
 }
 
 export class AudioManager {

package/animation/MMDPhysics.d.ts

@@ -1,9 +1,9 @@
 import { Bone, Euler, Matrix4, Object3D, Quaternion, SkinnedMesh, Vector3 } from 'three';
 
 export interface MMDPhysicsParameter {
-    unitStep?: number;
-    maxStepNum?: number;
-    gravity?: Vector3;
+    unitStep?: number | undefined;
+    maxStepNum?: number | undefined;
+    gravity?: Vector3 | undefined;
 }
 
 export class MMDPhysics {

package/csm/CSM.d.ts

@@ -1,36 +1,61 @@
+import { Camera, Vector3, DirectionalLight, Material, Vector2, Object3D } from 'three';
+
+export enum CMSMode {
+    practical = 'practical',
+    uniform = 'uniform',
+    logarithmic = 'logarithmic',
+    custom = 'custom',
+}
+
+export interface CMSParameters {
+    camera?: Camera;
+    parent?: Object3D;
+    cascades?: number;
+    maxFar?: number;
+    mode?: CMSMode;
+    shadowMapSize?: number;
+    shadowBias?: number;
+    lightDirection?: Vector3;
+    lightIntensity?: number;
+    lightNear?: number;
+    lightFar?: number;
+    lightMargin?: number;
+    customSplitsCallback?: (cascades: number, cameraNear: number, cameraFar: number, breaks: number[]) => void;
+}
+
 export class CSM {
-    constructor(data: any);
-    camera: any;
-    parent: any;
-    cascades: any;
-    maxFar: any;
-    mode: any;
-    shadowMapSize: any;
-    shadowBias: any;
-    lightDirection: any;
-    lightIntensity: any;
-    lightNear: any;
-    lightFar: any;
-    lightMargin: any;
-    customSplitsCallback: any;
+    constructor(data?: CMSParameters);
+    camera: Camera;
+    parent: Object3D;
+    cascades: number;
+    maxFar: number;
+    mode: CMSMode;
+    shadowMapSize: number;
+    shadowBias: number;
+    lightDirection: Vector3;
+    lightIntensity: number;
+    lightNear: number;
+    lightFar: number;
+    lightMargin: number;
+    customSplitsCallback: (cascades: number, cameraNear: number, cameraFar: number, breaks: number[]) => void;
     fade: boolean;
-    mainFrustum: Frustum;
-    frustums: any[];
-    breaks: any[];
-    lights: any[];
-    shaders: Map<any, any>;
+    mainFrustum: CSMFrustrum;
+    frustums: CSMFrustrum[];
+    breaks: number[];
+    lights: DirectionalLight[];
+    shaders: Map<unknown, string>;
     createLights(): void;
     initCascades(): void;
     updateShadowBounds(): void;
     getBreaks(): void;
     update(): void;
     injectInclude(): void;
-    setupMaterial(material: any): void;
+    setupMaterial(material: Material): void;
     updateUniforms(): void;
-    getExtendedBreaks(target: any): void;
+    getExtendedBreaks(target: Vector2[]): void;
     updateFrustums(): void;
     remove(): void;
     dispose(): void;
 }
 
-import Frustum from './Frustum.js';
+import CSMFrustrum from './CSMFrustum.js';

package/csm/CSMHelper.d.ts

@@ -1,13 +1,26 @@
-export class CSMHelper {
-    constructor(csm: any);
-    csm: any;
+import {
+    Box3Helper,
+    BufferGeometry,
+    Group,
+    LineBasicMaterial,
+    LineSegments,
+    Mesh,
+    MeshBasicMaterial,
+    PlaneGeometry,
+} from 'three';
+
+import { CSM } from './CSM';
+
+export class CSMHelper<TCSM extends CSM = CSM> extends Group {
+    constructor(csm: TCSM);
+    csm: TCSM;
     displayFrustum: boolean;
     displayPlanes: boolean;
     displayShadowBounds: boolean;
-    frustumLines: any;
-    cascadeLines: any[];
-    cascadePlanes: any[];
-    shadowLines: any[];
+    frustumLines: LineSegments<BufferGeometry, LineBasicMaterial>;
+    cascadeLines: Box3Helper[];
+    cascadePlanes: Array<Mesh<PlaneGeometry, MeshBasicMaterial>>;
+    shadowLines: Box3Helper[];
     updateVisibility(): void;
     update(): void;
 }

package/effects/OutlineEffect.d.ts

@@ -1,10 +1,10 @@
 import { Camera, Scene, Vector2, Vector4, WebGLRenderer, WebGLRenderTarget, WebGLShadowMap } from 'three';
 
 export interface OutlineEffectParameters {
-    defaultThickness?: number;
-    defaultColor?: number[];
-    defaultAlpha?: number;
-    defaultKeepAlive?: boolean;
+    defaultThickness?: number | undefined;
+    defaultColor?: number[] | undefined;
+    defaultAlpha?: number | undefined;
+    defaultKeepAlive?: boolean | undefined;
 }
 
 export class OutlineEffect {

package/effects/OutlineEffect.js

@@ -185,7 +185,10 @@ const OutlineEffect = function (renderer, parameters) {
     material.uniforms.outlineAlpha.value = originalMaterial.opacity;
 
     if (outlineParameters !== undefined) {
-      if (outlineParameters.thickness !== undefined) material.uniforms.outlineThickness.value = outlineParameters.thickness;
+      if (outlineParameters.thickness !== undefined) {
+        material.uniforms.outlineThickness.value = outlineParameters.thickness;
+      }
+
       if (outlineParameters.color !== undefined) material.uniforms.outlineColor.value.fromArray(outlineParameters.color);
       if (outlineParameters.alpha !== undefined) material.uniforms.outlineAlpha.value = outlineParameters.alpha;
     }
@@ -216,7 +219,10 @@ const OutlineEffect = function (renderer, parameters) {
       }
 
       material.transparent = outlineParameters.alpha !== undefined && outlineParameters.alpha < 1.0 ? true : originalMaterial.transparent;
-      if (outlineParameters.keepAlive !== undefined) cache[originalMaterial.uuid].keepAlive = outlineParameters.keepAlive;
+
+      if (outlineParameters.keepAlive !== undefined) {
+        cache[originalMaterial.uuid].keepAlive = outlineParameters.keepAlive;
+      }
     } else {
       material.transparent = originalMaterial.transparent;
       material.visible = originalMaterial.visible;

package/exporters/GLTFExporter.js

@@ -1902,29 +1902,24 @@ class GLTFMaterialsVolumeExtension {
 
   writeMaterial(material, materialDef) {
     if (!(material instanceof MeshPhysicalMaterial && // @ts-expect-error
-    material.isMeshPhysicalMaterial) || // @ts-expect-error
-    material.thickness === 0) {
+    material.isMeshPhysicalMaterial) || material.thickness === 0) {
       return;
     }
 
     const writer = this.writer;
     const extensionsUsed = writer.extensionsUsed;
     const extensionDef = {};
-    extensionDef.thickness = // @ts-expect-error
-    material.thickness; // @ts-expect-error
+    extensionDef.thickness = material.thickness;
 
     if (material.thicknessMap) {
       const thicknessMapDef = {
-        index: writer.processTexture( // @ts-expect-error
-        material.thicknessMap)
+        index: writer.processTexture(material.thicknessMap)
       };
-      writer.applyTextureTransform(thicknessMapDef, // @ts-expect-error
-      material.thicknessMap);
+      writer.applyTextureTransform(thicknessMapDef, material.thicknessMap);
       extensionDef.thicknessTexture = thicknessMapDef;
     }
 
-    extensionDef.attenuationDistance = //@ts-expect-error
-    material.attenuationDistance;
+    extensionDef.attenuationDistance = material.attenuationDistance;
     extensionDef.attenuationColor = //@ts-expect-error
     material.attenuationTint.toArray();
     materialDef.extensions = materialDef.extensions || {};

package/geometries/ConvexGeometry.d.ts

@@ -1,5 +1,5 @@
 import { BufferGeometry, Vector3 } from 'three';
 
 export class ConvexGeometry extends BufferGeometry {
-    constructor(points: Vector3[]);
+    constructor(points?: Vector3[]);
 }

package/geometries/ParametricGeometries.d.ts

@@ -1,8 +1,10 @@
-import { Curve, ParametricGeometry, Vector3 } from 'three';
+import { Curve, Vector3 } from 'three';
+
+import { ParametricGeometry } from './ParametricGeometry';
 
 export namespace ParametricGeometries {
     function klein(v: number, u: number, target: Vector3): Vector3;
-    function plane(width: number, height: number, target: Vector3): Vector3;
+    function plane(width: number, height: number): (u: number, v: number, target: Vector3) => Vector3;
     function mobius(u: number, t: number, target: Vector3): Vector3;
     function mobius3d(u: number, t: number, target: Vector3): Vector3;
 

package/helpers/RectAreaLightHelper.d.ts

@@ -1,10 +1,10 @@
-import { Color, Line, RectAreaLight } from 'three';
+import { Line, RectAreaLight, ColorRepresentation } from 'three';
 
 export class RectAreaLightHelper extends Line {
-    constructor(light: RectAreaLight, color?: Color | string | number);
+    constructor(light: RectAreaLight, color?: ColorRepresentation);
 
     light: RectAreaLight;
-    color: Color | string | number | undefined;
+    color: ColorRepresentation | undefined;
 
     dispose(): void;
 }

package/loaders/AssimpLoader.js

@@ -568,12 +568,30 @@ AssimpLoader.prototype = Object.assign(Object.create(Loader.prototype), {
         if (scene.mMaterials[this.mMaterialIndex]) mat = scene.mMaterials[this.mMaterialIndex].toTHREE(scene);else mat = new MeshLambertMaterial();
         geometry.setIndex(new BufferAttribute(new Uint32Array(this.mIndexArray), 1));
         geometry.setAttribute('position', new BufferAttribute(this.mVertexBuffer, 3));
-        if (this.mNormalBuffer && this.mNormalBuffer.length > 0) geometry.setAttribute('normal', new BufferAttribute(this.mNormalBuffer, 3));
-        if (this.mColorBuffer && this.mColorBuffer.length > 0) geometry.setAttribute('color', new BufferAttribute(this.mColorBuffer, 4));
-        if (this.mTexCoordsBuffers[0] && this.mTexCoordsBuffers[0].length > 0) geometry.setAttribute('uv', new BufferAttribute(new Float32Array(this.mTexCoordsBuffers[0]), 2));
-        if (this.mTexCoordsBuffers[1] && this.mTexCoordsBuffers[1].length > 0) geometry.setAttribute('uv1', new BufferAttribute(new Float32Array(this.mTexCoordsBuffers[1]), 2));
-        if (this.mTangentBuffer && this.mTangentBuffer.length > 0) geometry.setAttribute('tangents', new BufferAttribute(this.mTangentBuffer, 3));
-        if (this.mBitangentBuffer && this.mBitangentBuffer.length > 0) geometry.setAttribute('bitangents', new BufferAttribute(this.mBitangentBuffer, 3));
+
+        if (this.mNormalBuffer && this.mNormalBuffer.length > 0) {
+          geometry.setAttribute('normal', new BufferAttribute(this.mNormalBuffer, 3));
+        }
+
+        if (this.mColorBuffer && this.mColorBuffer.length > 0) {
+          geometry.setAttribute('color', new BufferAttribute(this.mColorBuffer, 4));
+        }
+
+        if (this.mTexCoordsBuffers[0] && this.mTexCoordsBuffers[0].length > 0) {
+          geometry.setAttribute('uv', new BufferAttribute(new Float32Array(this.mTexCoordsBuffers[0]), 2));
+        }
+
+        if (this.mTexCoordsBuffers[1] && this.mTexCoordsBuffers[1].length > 0) {
+          geometry.setAttribute('uv1', new BufferAttribute(new Float32Array(this.mTexCoordsBuffers[1]), 2));
+        }
+
+        if (this.mTangentBuffer && this.mTangentBuffer.length > 0) {
+          geometry.setAttribute('tangents', new BufferAttribute(this.mTangentBuffer, 3));
+        }
+
+        if (this.mBitangentBuffer && this.mBitangentBuffer.length > 0) {
+          geometry.setAttribute('bitangents', new BufferAttribute(this.mBitangentBuffer, 3));
+        }
 
         if (this.mBones.length > 0) {
           var weights = [];
@@ -824,10 +842,21 @@ AssimpLoader.prototype = Object.assign(Object.create(Loader.prototype), {
         var mat = new MeshPhongMaterial();
 
         for (let i = 0; i < this.mProperties.length; i++) {
-          if (nameTypeMapping[this.mProperties[i].mKey] == 'float') mat[namePropMapping[this.mProperties[i].mKey]] = this.mProperties[i].dataAsFloat();
-          if (nameTypeMapping[this.mProperties[i].mKey] == 'color') mat[namePropMapping[this.mProperties[i].mKey]] = this.mProperties[i].dataAsColor();
-          if (nameTypeMapping[this.mProperties[i].mKey] == 'bool') mat[namePropMapping[this.mProperties[i].mKey]] = this.mProperties[i].dataAsBool();
-          if (nameTypeMapping[this.mProperties[i].mKey] == 'string') mat[namePropMapping[this.mProperties[i].mKey]] = this.mProperties[i].dataAsString();
+          if (nameTypeMapping[this.mProperties[i].mKey] == 'float') {
+            mat[namePropMapping[this.mProperties[i].mKey]] = this.mProperties[i].dataAsFloat();
+          }
+
+          if (nameTypeMapping[this.mProperties[i].mKey] == 'color') {
+            mat[namePropMapping[this.mProperties[i].mKey]] = this.mProperties[i].dataAsColor();
+          }
+
+          if (nameTypeMapping[this.mProperties[i].mKey] == 'bool') {
+            mat[namePropMapping[this.mProperties[i].mKey]] = this.mProperties[i].dataAsBool();
+          }
+
+          if (nameTypeMapping[this.mProperties[i].mKey] == 'string') {
+            mat[namePropMapping[this.mProperties[i].mKey]] = this.mProperties[i].dataAsString();
+          }
 
           if (nameTypeMapping[this.mProperties[i].mKey] == 'map') {
             var prop = this.mProperties[i];

package/loaders/ColladaLoader.js

@@ -370,7 +370,11 @@ class ColladaLoader extends Loader {
       }
 
       if (positionData.length > 0) tracks.push(new VectorKeyframeTrack(name + '.position', times, positionData));
-      if (quaternionData.length > 0) tracks.push(new QuaternionKeyframeTrack(name + '.quaternion', times, quaternionData));
+
+      if (quaternionData.length > 0) {
+        tracks.push(new QuaternionKeyframeTrack(name + '.quaternion', times, quaternionData));
+      }
+
       if (scaleData.length > 0) tracks.push(new VectorKeyframeTrack(name + '.scale', times, scaleData));
       return tracks;
     }
@@ -1835,13 +1839,26 @@ class ColladaLoader extends Loader {
       } // build geometry
 
 
-      if (position.array.length > 0) geometry.setAttribute('position', new Float32BufferAttribute(position.array, position.stride));
-      if (normal.array.length > 0) geometry.setAttribute('normal', new Float32BufferAttribute(normal.array, normal.stride));
+      if (position.array.length > 0) {
+        geometry.setAttribute('position', new Float32BufferAttribute(position.array, position.stride));
+      }
+
+      if (normal.array.length > 0) {
+        geometry.setAttribute('normal', new Float32BufferAttribute(normal.array, normal.stride));
+      }
+
       if (color.array.length > 0) geometry.setAttribute('color', new Float32BufferAttribute(color.array, color.stride));
       if (uv.array.length > 0) geometry.setAttribute('uv', new Float32BufferAttribute(uv.array, uv.stride));
       if (uv2.array.length > 0) geometry.setAttribute('uv2', new Float32BufferAttribute(uv2.array, uv2.stride));
-      if (skinIndex.array.length > 0) geometry.setAttribute('skinIndex', new Float32BufferAttribute(skinIndex.array, skinIndex.stride));
-      if (skinWeight.array.length > 0) geometry.setAttribute('skinWeight', new Float32BufferAttribute(skinWeight.array, skinWeight.stride));
+
+      if (skinIndex.array.length > 0) {
+        geometry.setAttribute('skinIndex', new Float32BufferAttribute(skinIndex.array, skinIndex.stride));
+      }
+
+      if (skinWeight.array.length > 0) {
+        geometry.setAttribute('skinWeight', new Float32BufferAttribute(skinWeight.array, skinWeight.stride));
+      }
+
       build.data = geometry;
       build.type = primitives[0].type;
       build.materialKeys = materialKeys;

package/loaders/EXRLoader.js

@@ -1067,7 +1067,11 @@ class EXRLoader extends DataTextureLoader {
         totalDcUncompressedCount: parseInt64(inDataView, inOffset),
         acCompression: parseInt64(inDataView, inOffset)
       };
-      if (dwaHeader.version < 2) throw 'EXRLoader.parse: ' + EXRHeader.compression + ' version ' + dwaHeader.version + ' is unsupported'; // Read channel ruleset information
+
+      if (dwaHeader.version < 2) {
+        throw 'EXRLoader.parse: ' + EXRHeader.compression + ' version ' + dwaHeader.version + ' is unsupported';
+      } // Read channel ruleset information
+
 
       var channelRules = new Array();
       var ruleSize = parseUint16(inDataView, inOffset) - INT16_SIZE;

package/loaders/FBXLoader.js

@@ -514,7 +514,11 @@ class FBXTreeParser {
         if (deformerNode.attrType === 'Skin') {
           const skeleton = this.parseSkeleton(relationships, DeformerNodes);
           skeleton.ID = nodeID;
-          if (relationships.parents.length > 1) console.warn('THREE.FBXLoader: skeleton attached to more than one geometry is not supported.');
+
+          if (relationships.parents.length > 1) {
+            console.warn('THREE.FBXLoader: skeleton attached to more than one geometry is not supported.');
+          }
+
           skeleton.geometryID = relationships.parents[0].ID;
           skeletons[nodeID] = skeleton;
         } else if (deformerNode.attrType === 'BlendShape') {
@@ -523,7 +527,11 @@ class FBXTreeParser {
           };
           morphTarget.rawTargets = this.parseMorphTargets(relationships, DeformerNodes);
           morphTarget.id = nodeID;
-          if (relationships.parents.length > 1) console.warn('THREE.FBXLoader: morph target attached to more than one geometry is not supported.');
+
+          if (relationships.parents.length > 1) {
+            console.warn('THREE.FBXLoader: morph target attached to more than one geometry is not supported.');
+          }
+
           morphTargets[nodeID] = morphTarget;
         }
       }

package/loaders/GLTFLoader.d.ts

@@ -13,6 +13,9 @@ import {
     Material,
     SkinnedMesh,
     Texture,
+    TextureLoader,
+    FileLoader,
+    ImageBitmapLoader,
 } from 'three';
 
 import { DRACOLoader } from './DRACOLoader';
@@ -24,10 +27,10 @@ export interface GLTF {
     scenes: Group[];
     cameras: Camera[];
     asset: {
-        copyright?: string;
-        generator?: string;
-        version?: string;
-        minVersion?: string;
+        copyright?: string | undefined;
+        generator?: string | undefined;
+        version?: string | undefined;
+        minVersion?: string | undefined;
         extensions?: any;
         extras?: any;
     };
@@ -61,16 +64,35 @@ export class GLTFLoader extends Loader {
         onLoad: (gltf: GLTF) => void,
         onError?: (event: ErrorEvent) => void,
     ): void;
+
+    parseAsync(data: ArrayBuffer | string, path: string): Promise<void>;
 }
 
+export type GLTFReferenceType = 'materials' | 'nodes' | 'textures' | 'meshes';
+
 export interface GLTFReference {
-    type: 'materials' | 'nodes' | 'textures';
-    index: number;
+    materials?: number;
+    nodes?: number;
+    textures?: number;
+    meshes?: number;
 }
 
 export class GLTFParser {
     json: any;
 
+    options: {
+        path: string;
+        manager: LoadingManager;
+        ktx2Loader: KTX2Loader;
+        meshoptDecoder: /* MeshoptDecoder */ any;
+        crossOrigin: string;
+        requestHeader: { [header: string]: string };
+    };
+
+    fileLoader: FileLoader;
+    textureLoader: TextureLoader | ImageBitmapLoader;
+    plugins: GLTFLoaderPlugin;
+    extensions: { [name: string]: any };
     associations: Map<Object3D | Material | Texture, GLTFReference>;
 
     getDependency: (type: string, index: number) => Promise<any>;
@@ -93,7 +115,7 @@ export class GLTFParser {
         mapName: string,
         mapDef: {
             index: number;
-            texCoord?: number;
+            texCoord?: number | undefined;
             extensions?: any;
         },
     ) => Promise<void>;
@@ -101,6 +123,7 @@ export class GLTFParser {
     getMaterialType: () => typeof MeshStandardMaterial;
     loadMaterial: (materialIndex: number) => Promise<Material>;
     createUniqueName: (originalName: string) => string;
+    createNodeMesh: (nodeIndex: number) => Promise<Group | Mesh | SkinnedMesh>;
     loadGeometries: (
         /**
          * GLTF.Primitive[]
@@ -110,11 +133,9 @@ export class GLTFParser {
     ) => Promise<BufferGeometry[]>;
     loadMesh: (meshIndex: number) => Promise<Group | Mesh | SkinnedMesh>;
     loadCamera: (cameraIndex: number) => Promise<Camera>;
-    loadSkin: (
-        skinIndex: number,
-    ) => Promise<{
+    loadSkin: (skinIndex: number) => Promise<{
         joints: number[];
-        inverseBindMatrices?: BufferAttribute | InterleavedBufferAttribute;
+        inverseBindMatrices?: BufferAttribute | InterleavedBufferAttribute | undefined;
     }>;
     loadAnimation: (animationIndex: number) => Promise<AnimationClip>;
     loadNode: (nodeIndex: number) => Promise<Object3D>;
@@ -122,13 +143,16 @@ export class GLTFParser {
 }
 
 export interface GLTFLoaderPlugin {
-    beforeRoot?: () => Promise<void> | null;
-    afterRoot?: (result: GLTF) => Promise<void> | null;
-    loadMesh?: (meshIndex: number) => Promise<Group | Mesh | SkinnedMesh> | null;
-    loadBufferView?: (bufferViewIndex: number) => Promise<ArrayBuffer> | null;
-    loadMaterial?: (materialIndex: number) => Promise<Material> | null;
-    loadTexture?: (textureIndex: number) => Promise<Texture> | null;
-    getMaterialType?: (materialIndex: number) => typeof Material | null;
-    extendMaterialParams?: (materialIndex: number, materialParams: { [key: string]: any }) => Promise<any> | null;
-    createNodeAttachment?: (nodeIndex: number) => Promise<Object3D> | null;
+    beforeRoot?: (() => Promise<void> | null) | undefined;
+    afterRoot?: ((result: GLTF) => Promise<void> | null) | undefined;
+    loadMesh?: ((meshIndex: number) => Promise<Group | Mesh | SkinnedMesh> | null) | undefined;
+    loadBufferView?: ((bufferViewIndex: number) => Promise<ArrayBuffer> | null) | undefined;
+    loadMaterial?: ((materialIndex: number) => Promise<Material> | null) | undefined;
+    loadTexture?: ((textureIndex: number) => Promise<Texture> | null) | undefined;
+    getMaterialType?: ((materialIndex: number) => typeof Material | null) | undefined;
+    extendMaterialParams?:
+        | ((materialIndex: number, materialParams: { [key: string]: any }) => Promise<any> | null)
+        | undefined;
+    createNodeMesh?: ((nodeIndex: number) => Promise<Group | Mesh | SkinnedMesh> | null) | undefined;
+    createNodeAttachment?: ((nodeIndex: number) => Promise<Object3D> | null) | undefined;
 }

package/loaders/LDrawLoader.d.ts

@@ -1,6 +1,11 @@
 import { Loader, LoadingManager, Group, Material } from 'three';
 
 export class LDrawLoader extends Loader {
+    materials: Material[];
+    materialsLibrary: Record<string, Material>;
+    fileMap: Record<string, string>;
+    smoothNormals: boolean;
+
     constructor(manager?: LoadingManager);
 
     load(
@@ -10,6 +15,7 @@ export class LDrawLoader extends Loader {
         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: Material[]): void;