three-stdlib 2.22.9 → 2.22.10

package/dist/shaders/SubsurfaceScatteringShader.js

@@ -1,59 +1,98 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const THREE = require("three");
-function replaceAll(string, find, replace) {
-  return string.split(find).join(replace);
-}
-const meshphong_frag_head = THREE.ShaderChunk["meshphong_frag"].slice(
-  0,
-  THREE.ShaderChunk["meshphong_frag"].indexOf("void main() {")
-);
-const meshphong_frag_body = THREE.ShaderChunk["meshphong_frag"].slice(THREE.ShaderChunk["meshphong_frag"].indexOf("void main() {"));
-const SubsurfaceScatteringShader = {
-  uniforms: THREE.UniformsUtils.merge([
-    THREE.ShaderLib["phong"].uniforms,
-    {
-      thicknessMap: { value: null },
-      thicknessColor: { value: new THREE.Color(16777215) },
-      thicknessDistortion: { value: 0.1 },
-      thicknessAmbient: { value: 0 },
-      thicknessAttenuation: { value: 0.1 },
-      thicknessPower: { value: 2 },
-      thicknessScale: { value: 10 }
+let _SubsurfaceScatteringShader;
+function get() {
+  if (_SubsurfaceScatteringShader)
+    return _SubsurfaceScatteringShader;
+  const meshphong_frag_head = THREE.ShaderChunk["meshphong_frag"].slice(
+    0,
+    THREE.ShaderChunk["meshphong_frag"].indexOf("void main() {")
+  );
+  const meshphong_frag_body = THREE.ShaderChunk["meshphong_frag"].slice(
+    THREE.ShaderChunk["meshphong_frag"].indexOf("void main() {")
+  );
+  _SubsurfaceScatteringShader = {
+    uniforms: /* @__PURE__ */ THREE.UniformsUtils.merge([
+      THREE.ShaderLib["phong"].uniforms,
+      {
+        thicknessMap: { value: null },
+        thicknessColor: { value: /* @__PURE__ */ new THREE.Color(16777215) },
+        thicknessDistortion: { value: 0.1 },
+        thicknessAmbient: { value: 0 },
+        thicknessAttenuation: { value: 0.1 },
+        thicknessPower: { value: 2 },
+        thicknessScale: { value: 10 }
+      }
+    ]),
+    vertexShader: (
+      /* glsl */
+      `
+    #define USE_UV
+    ${THREE.ShaderChunk["meshphong_vert"]}
+  `
+    ),
+    fragmentShader: (
+      /* glsl */
+      `
+    #define USE_UV',
+    #define SUBSURFACE',
+
+    ${meshphong_frag_head}
+
+    uniform sampler2D thicknessMap;
+    uniform float thicknessPower;
+    uniform float thicknessScale;
+    uniform float thicknessDistortion;
+    uniform float thicknessAmbient;
+    uniform float thicknessAttenuation;
+    uniform vec3 thicknessColor;
+
+    void RE_Direct_Scattering(const in IncidentLight directLight, const in vec2 uv, const in GeometricContext geometry, inout ReflectedLight reflectedLight) {
+    	vec3 thickness = thicknessColor * texture2D(thicknessMap, uv).r;
+    	vec3 scatteringHalf = normalize(directLight.direction + (geometry.normal * thicknessDistortion));
+    	float scatteringDot = pow(saturate(dot(geometry.viewDir, -scatteringHalf)), thicknessPower) * thicknessScale;
+    	vec3 scatteringIllu = (scatteringDot + thicknessAmbient) * thickness;
+    	reflectedLight.directDiffuse += scatteringIllu * thicknessAttenuation * directLight.color;
     }
-  ]),
-  vertexShader: ["#define USE_UV", THREE.ShaderChunk["meshphong_vert"]].join("\n"),
-  fragmentShader: [
-    "#define USE_UV",
-    "#define SUBSURFACE",
-    meshphong_frag_head,
-    "uniform sampler2D thicknessMap;",
-    "uniform float thicknessPower;",
-    "uniform float thicknessScale;",
-    "uniform float thicknessDistortion;",
-    "uniform float thicknessAmbient;",
-    "uniform float thicknessAttenuation;",
-    "uniform vec3 thicknessColor;",
-    "void RE_Direct_Scattering(const in IncidentLight directLight, const in vec2 uv, const in GeometricContext geometry, inout ReflectedLight reflectedLight) {",
-    "	vec3 thickness = thicknessColor * texture2D(thicknessMap, uv).r;",
-    "	vec3 scatteringHalf = normalize(directLight.direction + (geometry.normal * thicknessDistortion));",
-    "	float scatteringDot = pow(saturate(dot(geometry.viewDir, -scatteringHalf)), thicknessPower) * thicknessScale;",
-    "	vec3 scatteringIllu = (scatteringDot + thicknessAmbient) * thickness;",
-    "	reflectedLight.directDiffuse += scatteringIllu * thicknessAttenuation * directLight.color;",
-    "}",
-    meshphong_frag_body.replace(
-      "#include <lights_fragment_begin>",
-      replaceAll(
-        THREE.ShaderChunk["lights_fragment_begin"],
-        "RE_Direct( directLight, geometry, material, reflectedLight );",
-        [
-          "RE_Direct( directLight, geometry, material, reflectedLight );",
-          "#if defined( SUBSURFACE ) && defined( USE_UV )",
-          " RE_Direct_Scattering(directLight, vUv, geometry, reflectedLight);",
-          "#endif"
-        ].join("\n")
-      )
+
+    ${meshphong_frag_body.replace(
+        "#include <lights_fragment_begin>",
+        THREE.ShaderChunk["lights_fragment_begin"].replace(
+          /RE_Direct\( directLight, geometry, material, reflectedLight \);/g,
+          /* glsl */
+          `
+        RE_Direct( directLight, geometry, material, reflectedLight );
+
+        #if defined( SUBSURFACE ) && defined( USE_UV )
+          RE_Direct_Scattering(directLight, vUv, geometry, reflectedLight);
+        #endif
+      `
+        )
+      )}
+  `
     )
-  ].join("\n")
+  };
+  return _SubsurfaceScatteringShader;
+}
+const SubsurfaceScatteringShader = {
+  get uniforms() {
+    return get().uniforms;
+  },
+  set uniforms(value) {
+    get().uniforms = value;
+  },
+  get vertexShader() {
+    return get().vertexShader;
+  },
+  set vertexShader(value) {
+    get().vertexShader = value;
+  },
+  get fragmentShader() {
+    return get().vertexShader;
+  },
+  set fragmentShader(value) {
+    get().vertexShader = value;
+  }
 };
 exports.SubsurfaceScatteringShader = SubsurfaceScatteringShader;

package/dist/shaders/SubsurfaceScatteringShader.mjs

@@ -1,58 +1,97 @@
 import { ShaderChunk, UniformsUtils, ShaderLib, Color } from "three";
-function replaceAll(string, find, replace) {
-  return string.split(find).join(replace);
-}
-const meshphong_frag_head = ShaderChunk["meshphong_frag"].slice(
-  0,
-  ShaderChunk["meshphong_frag"].indexOf("void main() {")
-);
-const meshphong_frag_body = ShaderChunk["meshphong_frag"].slice(ShaderChunk["meshphong_frag"].indexOf("void main() {"));
-const SubsurfaceScatteringShader = {
-  uniforms: UniformsUtils.merge([
-    ShaderLib["phong"].uniforms,
-    {
-      thicknessMap: { value: null },
-      thicknessColor: { value: new Color(16777215) },
-      thicknessDistortion: { value: 0.1 },
-      thicknessAmbient: { value: 0 },
-      thicknessAttenuation: { value: 0.1 },
-      thicknessPower: { value: 2 },
-      thicknessScale: { value: 10 }
+let _SubsurfaceScatteringShader;
+function get() {
+  if (_SubsurfaceScatteringShader)
+    return _SubsurfaceScatteringShader;
+  const meshphong_frag_head = ShaderChunk["meshphong_frag"].slice(
+    0,
+    ShaderChunk["meshphong_frag"].indexOf("void main() {")
+  );
+  const meshphong_frag_body = ShaderChunk["meshphong_frag"].slice(
+    ShaderChunk["meshphong_frag"].indexOf("void main() {")
+  );
+  _SubsurfaceScatteringShader = {
+    uniforms: /* @__PURE__ */ UniformsUtils.merge([
+      ShaderLib["phong"].uniforms,
+      {
+        thicknessMap: { value: null },
+        thicknessColor: { value: /* @__PURE__ */ new Color(16777215) },
+        thicknessDistortion: { value: 0.1 },
+        thicknessAmbient: { value: 0 },
+        thicknessAttenuation: { value: 0.1 },
+        thicknessPower: { value: 2 },
+        thicknessScale: { value: 10 }
+      }
+    ]),
+    vertexShader: (
+      /* glsl */
+      `
+    #define USE_UV
+    ${ShaderChunk["meshphong_vert"]}
+  `
+    ),
+    fragmentShader: (
+      /* glsl */
+      `
+    #define USE_UV',
+    #define SUBSURFACE',
+
+    ${meshphong_frag_head}
+
+    uniform sampler2D thicknessMap;
+    uniform float thicknessPower;
+    uniform float thicknessScale;
+    uniform float thicknessDistortion;
+    uniform float thicknessAmbient;
+    uniform float thicknessAttenuation;
+    uniform vec3 thicknessColor;
+
+    void RE_Direct_Scattering(const in IncidentLight directLight, const in vec2 uv, const in GeometricContext geometry, inout ReflectedLight reflectedLight) {
+    	vec3 thickness = thicknessColor * texture2D(thicknessMap, uv).r;
+    	vec3 scatteringHalf = normalize(directLight.direction + (geometry.normal * thicknessDistortion));
+    	float scatteringDot = pow(saturate(dot(geometry.viewDir, -scatteringHalf)), thicknessPower) * thicknessScale;
+    	vec3 scatteringIllu = (scatteringDot + thicknessAmbient) * thickness;
+    	reflectedLight.directDiffuse += scatteringIllu * thicknessAttenuation * directLight.color;
     }
-  ]),
-  vertexShader: ["#define USE_UV", ShaderChunk["meshphong_vert"]].join("\n"),
-  fragmentShader: [
-    "#define USE_UV",
-    "#define SUBSURFACE",
-    meshphong_frag_head,
-    "uniform sampler2D thicknessMap;",
-    "uniform float thicknessPower;",
-    "uniform float thicknessScale;",
-    "uniform float thicknessDistortion;",
-    "uniform float thicknessAmbient;",
-    "uniform float thicknessAttenuation;",
-    "uniform vec3 thicknessColor;",
-    "void RE_Direct_Scattering(const in IncidentLight directLight, const in vec2 uv, const in GeometricContext geometry, inout ReflectedLight reflectedLight) {",
-    "	vec3 thickness = thicknessColor * texture2D(thicknessMap, uv).r;",
-    "	vec3 scatteringHalf = normalize(directLight.direction + (geometry.normal * thicknessDistortion));",
-    "	float scatteringDot = pow(saturate(dot(geometry.viewDir, -scatteringHalf)), thicknessPower) * thicknessScale;",
-    "	vec3 scatteringIllu = (scatteringDot + thicknessAmbient) * thickness;",
-    "	reflectedLight.directDiffuse += scatteringIllu * thicknessAttenuation * directLight.color;",
-    "}",
-    meshphong_frag_body.replace(
-      "#include <lights_fragment_begin>",
-      replaceAll(
-        ShaderChunk["lights_fragment_begin"],
-        "RE_Direct( directLight, geometry, material, reflectedLight );",
-        [
-          "RE_Direct( directLight, geometry, material, reflectedLight );",
-          "#if defined( SUBSURFACE ) && defined( USE_UV )",
-          " RE_Direct_Scattering(directLight, vUv, geometry, reflectedLight);",
-          "#endif"
-        ].join("\n")
-      )
+
+    ${meshphong_frag_body.replace(
+        "#include <lights_fragment_begin>",
+        ShaderChunk["lights_fragment_begin"].replace(
+          /RE_Direct\( directLight, geometry, material, reflectedLight \);/g,
+          /* glsl */
+          `
+        RE_Direct( directLight, geometry, material, reflectedLight );
+
+        #if defined( SUBSURFACE ) && defined( USE_UV )
+          RE_Direct_Scattering(directLight, vUv, geometry, reflectedLight);
+        #endif
+      `
+        )
+      )}
+  `
     )
-  ].join("\n")
+  };
+  return _SubsurfaceScatteringShader;
+}
+const SubsurfaceScatteringShader = {
+  get uniforms() {
+    return get().uniforms;
+  },
+  set uniforms(value) {
+    get().uniforms = value;
+  },
+  get vertexShader() {
+    return get().vertexShader;
+  },
+  set vertexShader(value) {
+    get().vertexShader = value;
+  },
+  get fragmentShader() {
+    return get().vertexShader;
+  },
+  set fragmentShader(value) {
+    get().vertexShader = value;
+  }
 };
 export {
   SubsurfaceScatteringShader

package/dist/shaders/ToonShader.js

@@ -3,10 +3,10 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const THREE = require("three");
 const ToonShader1 = {
   uniforms: {
-    uDirLightPos: { value: new THREE.Vector3() },
-    uDirLightColor: { value: new THREE.Color(15658734) },
-    uAmbientLightColor: { value: new THREE.Color(328965) },
-    uBaseColor: { value: new THREE.Color(16777215) }
+    uDirLightPos: { value: /* @__PURE__ */ new THREE.Vector3() },
+    uDirLightColor: { value: /* @__PURE__ */ new THREE.Color(15658734) },
+    uAmbientLightColor: { value: /* @__PURE__ */ new THREE.Color(328965) },
+    uBaseColor: { value: /* @__PURE__ */ new THREE.Color(16777215) }
   },
   vertexShader: [
     "varying vec3 vNormal;",
@@ -46,14 +46,14 @@ const ToonShader1 = {
 };
 const ToonShader2 = {
   uniforms: {
-    uDirLightPos: { value: new THREE.Vector3() },
-    uDirLightColor: { value: new THREE.Color(15658734) },
-    uAmbientLightColor: { value: new THREE.Color(328965) },
-    uBaseColor: { value: new THREE.Color(15658734) },
-    uLineColor1: { value: new THREE.Color(8421504) },
-    uLineColor2: { value: new THREE.Color(0) },
-    uLineColor3: { value: new THREE.Color(0) },
-    uLineColor4: { value: new THREE.Color(0) }
+    uDirLightPos: { value: /* @__PURE__ */ new THREE.Vector3() },
+    uDirLightColor: { value: /* @__PURE__ */ new THREE.Color(15658734) },
+    uAmbientLightColor: { value: /* @__PURE__ */ new THREE.Color(328965) },
+    uBaseColor: { value: /* @__PURE__ */ new THREE.Color(15658734) },
+    uLineColor1: { value: /* @__PURE__ */ new THREE.Color(8421504) },
+    uLineColor2: { value: /* @__PURE__ */ new THREE.Color(0) },
+    uLineColor3: { value: /* @__PURE__ */ new THREE.Color(0) },
+    uLineColor4: { value: /* @__PURE__ */ new THREE.Color(0) }
   },
   vertexShader: [
     "varying vec3 vNormal;",
@@ -87,14 +87,14 @@ const ToonShader2 = {
 };
 const ToonShaderHatching = {
   uniforms: {
-    uDirLightPos: { value: new THREE.Vector3() },
-    uDirLightColor: { value: new THREE.Color(15658734) },
-    uAmbientLightColor: { value: new THREE.Color(328965) },
-    uBaseColor: { value: new THREE.Color(16777215) },
-    uLineColor1: { value: new THREE.Color(0) },
-    uLineColor2: { value: new THREE.Color(0) },
-    uLineColor3: { value: new THREE.Color(0) },
-    uLineColor4: { value: new THREE.Color(0) }
+    uDirLightPos: { value: /* @__PURE__ */ new THREE.Vector3() },
+    uDirLightColor: { value: /* @__PURE__ */ new THREE.Color(15658734) },
+    uAmbientLightColor: { value: /* @__PURE__ */ new THREE.Color(328965) },
+    uBaseColor: { value: /* @__PURE__ */ new THREE.Color(16777215) },
+    uLineColor1: { value: /* @__PURE__ */ new THREE.Color(0) },
+    uLineColor2: { value: /* @__PURE__ */ new THREE.Color(0) },
+    uLineColor3: { value: /* @__PURE__ */ new THREE.Color(0) },
+    uLineColor4: { value: /* @__PURE__ */ new THREE.Color(0) }
   },
   vertexShader: [
     "varying vec3 vNormal;",
@@ -142,11 +142,11 @@ const ToonShaderHatching = {
 };
 const ToonShaderDotted = {
   uniforms: {
-    uDirLightPos: { value: new THREE.Vector3() },
-    uDirLightColor: { value: new THREE.Color(15658734) },
-    uAmbientLightColor: { value: new THREE.Color(328965) },
-    uBaseColor: { value: new THREE.Color(16777215) },
-    uLineColor1: { value: new THREE.Color(0) }
+    uDirLightPos: { value: /* @__PURE__ */ new THREE.Vector3() },
+    uDirLightColor: { value: /* @__PURE__ */ new THREE.Color(15658734) },
+    uAmbientLightColor: { value: /* @__PURE__ */ new THREE.Color(328965) },
+    uBaseColor: { value: /* @__PURE__ */ new THREE.Color(16777215) },
+    uLineColor1: { value: /* @__PURE__ */ new THREE.Color(0) }
   },
   vertexShader: [
     "varying vec3 vNormal;",

package/dist/shaders/ToonShader.mjs

@@ -1,10 +1,10 @@
 import { Vector3, Color } from "three";
 const ToonShader1 = {
   uniforms: {
-    uDirLightPos: { value: new Vector3() },
-    uDirLightColor: { value: new Color(15658734) },
-    uAmbientLightColor: { value: new Color(328965) },
-    uBaseColor: { value: new Color(16777215) }
+    uDirLightPos: { value: /* @__PURE__ */ new Vector3() },
+    uDirLightColor: { value: /* @__PURE__ */ new Color(15658734) },
+    uAmbientLightColor: { value: /* @__PURE__ */ new Color(328965) },
+    uBaseColor: { value: /* @__PURE__ */ new Color(16777215) }
   },
   vertexShader: [
     "varying vec3 vNormal;",
@@ -44,14 +44,14 @@ const ToonShader1 = {
 };
 const ToonShader2 = {
   uniforms: {
-    uDirLightPos: { value: new Vector3() },
-    uDirLightColor: { value: new Color(15658734) },
-    uAmbientLightColor: { value: new Color(328965) },
-    uBaseColor: { value: new Color(15658734) },
-    uLineColor1: { value: new Color(8421504) },
-    uLineColor2: { value: new Color(0) },
-    uLineColor3: { value: new Color(0) },
-    uLineColor4: { value: new Color(0) }
+    uDirLightPos: { value: /* @__PURE__ */ new Vector3() },
+    uDirLightColor: { value: /* @__PURE__ */ new Color(15658734) },
+    uAmbientLightColor: { value: /* @__PURE__ */ new Color(328965) },
+    uBaseColor: { value: /* @__PURE__ */ new Color(15658734) },
+    uLineColor1: { value: /* @__PURE__ */ new Color(8421504) },
+    uLineColor2: { value: /* @__PURE__ */ new Color(0) },
+    uLineColor3: { value: /* @__PURE__ */ new Color(0) },
+    uLineColor4: { value: /* @__PURE__ */ new Color(0) }
   },
   vertexShader: [
     "varying vec3 vNormal;",
@@ -85,14 +85,14 @@ const ToonShader2 = {
 };
 const ToonShaderHatching = {
   uniforms: {
-    uDirLightPos: { value: new Vector3() },
-    uDirLightColor: { value: new Color(15658734) },
-    uAmbientLightColor: { value: new Color(328965) },
-    uBaseColor: { value: new Color(16777215) },
-    uLineColor1: { value: new Color(0) },
-    uLineColor2: { value: new Color(0) },
-    uLineColor3: { value: new Color(0) },
-    uLineColor4: { value: new Color(0) }
+    uDirLightPos: { value: /* @__PURE__ */ new Vector3() },
+    uDirLightColor: { value: /* @__PURE__ */ new Color(15658734) },
+    uAmbientLightColor: { value: /* @__PURE__ */ new Color(328965) },
+    uBaseColor: { value: /* @__PURE__ */ new Color(16777215) },
+    uLineColor1: { value: /* @__PURE__ */ new Color(0) },
+    uLineColor2: { value: /* @__PURE__ */ new Color(0) },
+    uLineColor3: { value: /* @__PURE__ */ new Color(0) },
+    uLineColor4: { value: /* @__PURE__ */ new Color(0) }
   },
   vertexShader: [
     "varying vec3 vNormal;",
@@ -140,11 +140,11 @@ const ToonShaderHatching = {
 };
 const ToonShaderDotted = {
   uniforms: {
-    uDirLightPos: { value: new Vector3() },
-    uDirLightColor: { value: new Color(15658734) },
-    uAmbientLightColor: { value: new Color(328965) },
-    uBaseColor: { value: new Color(16777215) },
-    uLineColor1: { value: new Color(0) }
+    uDirLightPos: { value: /* @__PURE__ */ new Vector3() },
+    uDirLightColor: { value: /* @__PURE__ */ new Color(15658734) },
+    uAmbientLightColor: { value: /* @__PURE__ */ new Color(328965) },
+    uBaseColor: { value: /* @__PURE__ */ new Color(16777215) },
+    uLineColor1: { value: /* @__PURE__ */ new Color(0) }
   },
   vertexShader: [
     "varying vec3 vNormal;",

package/dist/shaders/TriangleBlurShader.js

@@ -4,7 +4,7 @@ const THREE = require("three");
 const TriangleBlurShader = {
   uniforms: {
     texture: { value: null },
-    delta: { value: new THREE.Vector2(1, 1) }
+    delta: { value: /* @__PURE__ */ new THREE.Vector2(1, 1) }
   },
   vertexShader: [
     "varying vec2 vUv;",

package/dist/shaders/TriangleBlurShader.mjs

@@ -2,7 +2,7 @@ import { Vector2 } from "three";
 const TriangleBlurShader = {
   uniforms: {
     texture: { value: null },
-    delta: { value: new Vector2(1, 1) }
+    delta: { value: /* @__PURE__ */ new Vector2(1, 1) }
   },
   vertexShader: [
     "varying vec2 vUv;",

package/dist/shaders/VerticalBlurShader.d.ts

@@ -9,7 +9,7 @@
  */
 import type { IUniform, Texture } from 'three';
 import type { IShader } from './types';
-export declare type VerticalBlurShaderUniforms = {
+export type VerticalBlurShaderUniforms = {
     tDiffuse: IUniform<Texture | null>;
     v: IUniform<number>;
 };

package/dist/shaders/VolumeShader.js

@@ -3,10 +3,10 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const THREE = require("three");
 const VolumeRenderShader1 = {
   uniforms: {
-    u_size: { value: new THREE.Vector3(1, 1, 1) },
+    u_size: { value: /* @__PURE__ */ new THREE.Vector3(1, 1, 1) },
     u_renderstyle: { value: 0 },
     u_renderthreshold: { value: 0.5 },
-    u_clim: { value: new THREE.Vector2(1, 1) },
+    u_clim: { value: /* @__PURE__ */ new THREE.Vector2(1, 1) },
     u_data: { value: null },
     u_cmdata: { value: null }
   },

package/dist/shaders/VolumeShader.mjs

@@ -1,10 +1,10 @@
 import { Vector3, Vector2 } from "three";
 const VolumeRenderShader1 = {
   uniforms: {
-    u_size: { value: new Vector3(1, 1, 1) },
+    u_size: { value: /* @__PURE__ */ new Vector3(1, 1, 1) },
     u_renderstyle: { value: 0 },
     u_renderthreshold: { value: 0.5 },
-    u_clim: { value: new Vector2(1, 1) },
+    u_clim: { value: /* @__PURE__ */ new Vector2(1, 1) },
     u_data: { value: null },
     u_cmdata: { value: null }
   },

package/dist/shaders/types.d.ts

@@ -1,8 +1,8 @@
 import type { IUniform, Shader } from 'three';
-declare type Defines = {
+type Defines = {
     [key: string]: boolean | number | string;
 };
-declare type Uniforms = {
+type Uniforms = {
     [key: string]: IUniform;
 };
 export interface IShader<U extends Uniforms, D extends Defines | undefined = undefined> extends Shader {

package/dist/types/Loader.d.ts

@@ -0,0 +1,4 @@
+import * as THREE from 'three';
+export declare class Loader extends THREE.Loader {
+    loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<any>;
+}

package/dist/types/Loader.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const THREE__namespace = /* @__PURE__ */ _interopNamespaceDefault(THREE);
+class Loader extends THREE__namespace.Loader {
+  loadAsync(url, onProgress) {
+    return super.loadAsync(url, onProgress);
+  }
+}
+exports.Loader = Loader;

package/dist/types/Loader.mjs

@@ -0,0 +1,9 @@
+import * as THREE from "three";
+class Loader extends THREE.Loader {
+  loadAsync(url, onProgress) {
+    return super.loadAsync(url, onProgress);
+  }
+}
+export {
+  Loader
+};

package/dist/types/shared.d.ts

@@ -1,2 +1,2 @@
-export declare type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array;
-export declare type TypedArrayConstructors = Int8Array['constructor'] | Uint8Array['constructor'] | Uint8ClampedArray['constructor'] | Int16Array['constructor'] | Uint16Array['constructor'] | Int32Array['constructor'] | Uint32Array['constructor'] | Float32Array['constructor'] | Float64Array['constructor'];
+export type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array;
+export type TypedArrayConstructors = Int8Array['constructor'] | Uint8Array['constructor'] | Uint8ClampedArray['constructor'] | Int16Array['constructor'] | Uint16Array['constructor'] | Int32Array['constructor'] | Uint32Array['constructor'] | Float32Array['constructor'] | Float64Array['constructor'];

package/dist/types/utils.d.ts

@@ -1,3 +1,3 @@
-export declare type Nullable<T> = {
+export type Nullable<T> = {
     [K in keyof T]: T[K] | null;
 };

package/dist/utils/BufferGeometryUtils.d.ts

@@ -4,7 +4,7 @@ import { BufferAttribute, BufferGeometry, Float32BufferAttribute, InterleavedBuf
  * @param  {Boolean} useGroups
  * @return {BufferGeometry}
  */
-export declare const mergeBufferGeometries: (geometries: BufferGeometry[], useGroups?: boolean | undefined) => BufferGeometry | null;
+export declare const mergeBufferGeometries: (geometries: BufferGeometry[], useGroups?: boolean) => BufferGeometry | null;
 /**
  * @param {Array<BufferAttribute>} attributes
  * @return {BufferAttribute}
@@ -38,7 +38,7 @@ export declare function toTrianglesDrawMode(geometry: BufferGeometry, drawMode:
  * @param {Mesh | Line | Points} object An instance of Mesh, Line or Points.
  * @return {Object} An Object with original position/normal attributes and morphed ones.
  */
-export declare type ComputedMorphedAttribute = {
+export type ComputedMorphedAttribute = {
     positionAttribute: BufferAttribute | InterleavedBufferAttribute;
     normalAttribute: BufferAttribute | InterleavedBufferAttribute;
     morphedPositionAttribute: Float32BufferAttribute;

package/dist/utils/BufferGeometryUtils.js

@@ -363,7 +363,7 @@ function computeMorphedAttributes(object) {
     _vC.fromBufferAttribute(attribute, c2);
     const morphInfluences = object2.morphTargetInfluences;
     if (
-      // @ts-expect-error
+      // @ts-ignore
       material2.morphTargets && morphAttribute && morphInfluences
     ) {
       _morphA.set(0, 0, 0);

package/dist/utils/BufferGeometryUtils.mjs

@@ -361,7 +361,7 @@ function computeMorphedAttributes(object) {
     _vC.fromBufferAttribute(attribute, c2);
     const morphInfluences = object2.morphTargetInfluences;
     if (
-      // @ts-expect-error
+      // @ts-ignore
       material2.morphTargets && morphAttribute && morphInfluences
     ) {
       _morphA.set(0, 0, 0);

package/dist/utils/RoughnessMipmapper.d.ts

@@ -0,0 +1,8 @@
+import { WebGLRenderer } from 'three'
+
+export class RoughnessMipmapper {
+  constructor(renderer: WebGLRenderer)
+
+  generateMipmaps(material: THREE.Material): void
+  dispose(): void
+}