three-stdlib 2.35.7 → 2.35.9

package/objects/GroundProjectedEnv.d.cts

@@ -0,0 +1,12 @@
+import type { Mesh, ShaderMaterial, Texture, CubeTexture, BufferGeometry } from 'three';
+export interface GroundProjectedEnvParameters {
+    height?: number;
+    radius?: number;
+}
+export type declare class GroundProjectedEnv extends Mesh<BufferGeometry, ShaderMaterial> {
+    constructor(texture: CubeTexture | Texture, options?: GroundProjectedEnvParameters);
+    set radius(radius: number);
+    get radius(): number;
+    set height(height: number);
+    get height(): number;
+}

package/objects/GroundProjectedEnv.d.ts

@@ -1,9 +1,9 @@
-import { Mesh, ShaderMaterial, Texture, CubeTexture, BufferGeometry } from 'three';
+import type { Mesh, ShaderMaterial, Texture, CubeTexture, BufferGeometry } from 'three';
 export interface GroundProjectedEnvParameters {
     height?: number;
     radius?: number;
 }
-export declare class GroundProjectedEnv extends Mesh<BufferGeometry, ShaderMaterial> {
+export type declare class GroundProjectedEnv extends Mesh<BufferGeometry, ShaderMaterial> {
     constructor(texture: CubeTexture | Texture, options?: GroundProjectedEnvParameters);
     set radius(radius: number);
     get radius(): number;

package/objects/Lensflare.d.cts

@@ -0,0 +1,17 @@
+import type { Mesh, Texture, Color } from 'three'
+
+export class LensflareElement {
+  constructor(texture: Texture, size?: number, distance?: number, color?: Color)
+  texture: Texture
+  size: number
+  distance: number
+  color: Color
+}
+
+export class Lensflare extends Mesh {
+  constructor()
+  readonly isLensflare: true
+
+  addElement(element: LensflareElement): void
+  dispose(): void
+}

package/objects/Lensflare.d.ts

@@ -1,4 +1,4 @@
-import { Mesh, Texture, Color } from 'three'
+import type { Mesh, Texture, Color } from 'three'
 
 export class LensflareElement {
   constructor(texture: Texture, size?: number, distance?: number, color?: Color)

package/objects/LightningStorm.d.cts

@@ -0,0 +1,32 @@
+import type { Material, Object3D, Vector3 } from 'three'
+
+import type { LightningStrike, RayParameters } from '../geometries/LightningStrike.d.cts'
+
+export interface StormParams {
+  size?: number
+  minHeight?: number
+  maxHeight?: number
+  maxSlope?: number
+
+  maxLightnings?: number
+
+  lightningMinPeriod?: number
+  lightningMaxPeriod?: number
+  lightningMinDuration?: number
+  lightningMaxDuration?: number
+
+  lightningParameters?: RayParameters
+  lightningMaterial?: Material
+
+  isEternal?: boolean
+
+  onRayPosition?: (source: Vector3, dest: Vector3) => void
+  onLightningDown?: (lightning: LightningStrike) => void
+}
+
+export class LightningStorm extends Object3D {
+  constructor(stormParams?: StormParams)
+  update(time: number): void
+  copy(source: LightningStorm, recursive?: boolean): this
+  clone(): this
+}

package/objects/LightningStorm.d.ts

@@ -1,6 +1,6 @@
-import { Material, Object3D, Vector3 } from 'three'
+import type { Material, Object3D, Vector3 } from 'three'
 
-import { LightningStrike, RayParameters } from '../geometries/LightningStrike'
+import type { LightningStrike, RayParameters } from '../geometries/LightningStrike.d.ts'
 
 export interface StormParams {
   size?: number

package/objects/MarchingCubes.d.cts

@@ -0,0 +1,76 @@
+import type { BufferGeometry, Material, Mesh, Color } from 'three'
+
+export class MarchingCubes extends Mesh {
+  constructor(
+    resolution: number,
+    material: Material,
+    enableUvs?: boolean,
+    enableColors?: boolean,
+    maxPolyCount?: number,
+  )
+
+  enableUvs: boolean
+  enableColors: boolean
+
+  resolution: number
+
+  // parameters
+
+  isolation: number
+
+  // size of field, 32 is pushing it in Javascript :)
+
+  size: number
+  size2: number
+  size3: number
+  halfsize: number
+
+  // deltas
+
+  delta: number
+  yd: number
+  zd: number
+
+  field: Float32Array
+  normal_cache: Float32Array
+  palette: Float32Array
+
+  maxCount: number
+  count: number
+
+  hasPositions: boolean
+  hasNormals: boolean
+  hasColors: boolean
+  hasUvs: boolean
+
+  positionArray: Float32Array
+  normalArray: Float32Array
+
+  uvArray: Float32Array
+  colorArray: Float32Array
+
+  begin(): void
+  end(): void
+
+  init(resolution: number): void
+
+  addBall(ballx: number, bally: number, ballz: number, strength: number, subtract: number, colors?: Color): void
+
+  addPlaneX(strength: number, subtract: number): void
+  addPlaneY(strength: number, subtract: number): void
+  addPlaneZ(strength: number, subtract: number): void
+
+  setCell(x: number, y: number, z: number, value: number): void
+  getCell(x: number, y: number, z: number): number
+
+  blur(intensity: number): void
+
+  reset(): void
+  update(): void
+  render(renderCallback: any): void
+  generateGeometry(): BufferGeometry
+  generateBufferGeometry(): BufferGeometry
+}
+
+export const edgeTable: Int32Array[]
+export const triTable: Int32Array[]

package/objects/MarchingCubes.d.ts

@@ -1,4 +1,4 @@
-import { BufferGeometry, Material, Mesh, Color } from 'three'
+import type { BufferGeometry, Material, Mesh, Color } from 'three'
 
 export class MarchingCubes extends Mesh {
   constructor(

package/objects/Reflector.d.cts

@@ -0,0 +1,23 @@
+import type { Mesh, BufferGeometry, Color, WebGLRenderTarget, PerspectiveCamera } from 'three'
+import type { TextureEncoding } from '../types/shared.d.cts'
+
+export interface ReflectorOptions {
+  color?: Color | string | number
+  textureWidth?: number
+  textureHeight?: number
+  clipBias?: number
+  shader?: object
+  encoding?: TextureEncoding
+  multisample?: number
+}
+
+export class Reflector extends Mesh {
+  type: 'Reflector'
+  camera: PerspectiveCamera
+
+  constructor(geometry?: BufferGeometry, options?: ReflectorOptions)
+
+  getRenderTarget(): WebGLRenderTarget
+
+  dispose(): void
+}

package/objects/Reflector.d.ts

@@ -1,5 +1,5 @@
-import { Mesh, BufferGeometry, Color, WebGLRenderTarget, PerspectiveCamera } from 'three'
-import { TextureEncoding } from '../types/shared'
+import type { Mesh, BufferGeometry, Color, WebGLRenderTarget, PerspectiveCamera } from 'three'
+import type { TextureEncoding } from '../types/shared.d.ts'
 
 export interface ReflectorOptions {
   color?: Color | string | number

package/objects/ReflectorForSSRPass.d.cts

@@ -0,0 +1,48 @@
+import type { Mesh, ShaderMaterial, WebGLRenderTarget, BufferGeometry, WebGLRenderer, Scene, Camera, IUniform } from 'three'
+
+export interface ReflectorShader {
+  defines: {
+    DISTANCE_ATTENUATION: boolean
+    FRESNEL: boolean
+  }
+  uniforms: {
+    [key: string]: IUniform
+  }
+  vertexShader: string
+  fragmentShader: string
+}
+
+export interface ReflectorForSSRPassOptions {
+  clipBias?: number | undefined
+  textureWidth?: number | undefined
+  textureHeight?: number | undefined
+  color?: number | undefined
+  useDepthTexture?: boolean | undefined
+  shader?: ReflectorShader | undefined
+}
+
+export class ReflectorForSSRPass<TGeometry extends BufferGeometry = BufferGeometry> extends Mesh<TGeometry> {
+  type: 'ReflectorForSSRPass'
+  options: ReflectorForSSRPassOptions
+
+  static ReflectorShader: ReflectorShader
+
+  needsUpdate: boolean
+  maxDistance: number
+  opacity: number
+
+  get distanceAttenuation(): boolean
+  set distanceAttenuation(val: boolean)
+  get fresnel(): boolean
+  set fresnel(val: boolean)
+
+  material: ShaderMaterial
+
+  renderTarget: WebGLRenderTarget
+
+  constructor(geometry: TGeometry, options: ReflectorForSSRPassOptions)
+
+  doRender: (renderer: WebGLRenderer, scene: Scene, camera: Camera) => void
+
+  getRenderTarget: () => WebGLRenderTarget
+}

package/objects/ReflectorForSSRPass.d.ts

@@ -1,4 +1,4 @@
-import { Mesh, ShaderMaterial, WebGLRenderTarget, BufferGeometry, WebGLRenderer, Scene, Camera, IUniform } from 'three'
+import type { Mesh, ShaderMaterial, WebGLRenderTarget, BufferGeometry, WebGLRenderer, Scene, Camera, IUniform } from 'three'
 
 export interface ReflectorShader {
   defines: {

package/objects/ReflectorRTT.d.cts

@@ -0,0 +1,6 @@
+import type { BufferGeometry } from 'three';
+import type { Reflector, ReflectorOptions } from '../objects/Reflector.d.cts';
+declare class ReflectorRTT extends Reflector {
+    constructor(geometry?: BufferGeometry, options?: ReflectorOptions);
+}
+export type { ReflectorRTT };

package/objects/ReflectorRTT.d.ts

@@ -1,6 +1,6 @@
-import { BufferGeometry } from 'three';
-import { Reflector, ReflectorOptions } from '../objects/Reflector';
+import type { BufferGeometry } from 'three';
+import type { Reflector, ReflectorOptions } from '../objects/Reflector.d.ts';
 declare class ReflectorRTT extends Reflector {
     constructor(geometry?: BufferGeometry, options?: ReflectorOptions);
 }
-export { ReflectorRTT };
+export type { ReflectorRTT };

package/objects/Refractor.d.cts

@@ -0,0 +1,23 @@
+import type { Mesh, BufferGeometry, Color, WebGLRenderTarget, PerspectiveCamera } from 'three'
+import type { TextureEncoding } from '../types/shared.d.cts'
+
+export interface RefractorOptions {
+  color?: Color | string | number
+  textureWidth?: number
+  textureHeight?: number
+  clipBias?: number
+  shader?: object
+  encoding?: TextureEncoding
+  multisample?: number
+}
+
+export class Refractor extends Mesh {
+  type: 'Refractor'
+  camera: PerspectiveCamera
+
+  constructor(geometry?: BufferGeometry, options?: RefractorOptions)
+
+  getRenderTarget(): WebGLRenderTarget
+
+  dispose(): void
+}

package/objects/Refractor.d.ts

@@ -1,5 +1,5 @@
-import { Mesh, BufferGeometry, Color, WebGLRenderTarget, PerspectiveCamera } from 'three'
-import { TextureEncoding } from '../types/shared'
+import type { Mesh, BufferGeometry, Color, WebGLRenderTarget, PerspectiveCamera } from 'three'
+import type { TextureEncoding } from '../types/shared.d.ts'
 
 export interface RefractorOptions {
   color?: Color | string | number

package/objects/ShadowMesh.d.cts

@@ -0,0 +1,10 @@
+import type { Mesh, Plane, Vector4, Matrix4, MeshBasicMaterial, BufferGeometry } from 'three'
+
+export class ShadowMesh extends Mesh<BufferGeometry, MeshBasicMaterial> {
+  readonly isShadowMesh: true
+  meshMatrix: Matrix4
+
+  constructor(mesh: Mesh)
+
+  update(plane: Plane, lightPosition4D: Vector4): void
+}

package/objects/ShadowMesh.d.ts

@@ -1,4 +1,4 @@
-import { Mesh, Plane, Vector4, Matrix4, MeshBasicMaterial, BufferGeometry } from 'three'
+import type { Mesh, Plane, Vector4, Matrix4, MeshBasicMaterial, BufferGeometry } from 'three'
 
 export class ShadowMesh extends Mesh<BufferGeometry, MeshBasicMaterial> {
   readonly isShadowMesh: true

package/objects/Sky.d.cts

@@ -0,0 +1,18 @@
+import type { Mesh, BoxGeometry, ShaderMaterial, Vector3 } from 'three'
+
+declare class Sky extends Mesh<BoxGeometry, ShaderMaterial> {
+  static SkyShader: {
+    uniforms: {
+      turbidity: { value: number }
+      rayleigh: { value: number }
+      mieCoefficient: { value: number }
+      mieDirectionalG: { value: number }
+      sunPosition: { value: Vector3 }
+      up: { value: Vector3 }
+    }
+  }
+
+  static material: ShaderMaterial
+}
+
+export type { Sky }

package/objects/Sky.d.ts

@@ -1,4 +1,4 @@
-import { Mesh, BoxGeometry, ShaderMaterial, Vector3 } from 'three'
+import type { Mesh, BoxGeometry, ShaderMaterial, Vector3 } from 'three'
 
 declare class Sky extends Mesh<BoxGeometry, ShaderMaterial> {
   static SkyShader: {
@@ -15,4 +15,4 @@ declare class Sky extends Mesh<BoxGeometry, ShaderMaterial> {
   static material: ShaderMaterial
 }
 
-export { Sky }
+export type { Sky }

package/objects/Water.d.cts

@@ -0,0 +1,22 @@
+import type { BufferGeometry, Color, Mesh, ShaderMaterial, Side, Texture, Vector3 } from 'three'
+
+export interface WaterOptions {
+  textureWidth?: number
+  textureHeight?: number
+  clipBias?: number
+  alpha?: number
+  time?: number
+  waterNormals?: Texture
+  sunDirection?: Vector3
+  sunColor?: Color | string | number
+  waterColor?: Color | string | number
+  eye?: Vector3
+  distortionScale?: number
+  side?: Side
+  fog?: boolean
+}
+
+export class Water extends Mesh {
+  material: ShaderMaterial
+  constructor(geometry: BufferGeometry, options: WaterOptions)
+}

package/objects/Water.d.ts

@@ -1,4 +1,4 @@
-import { BufferGeometry, Color, Mesh, ShaderMaterial, Side, Texture, Vector3 } from 'three'
+import type { BufferGeometry, Color, Mesh, ShaderMaterial, Side, Texture, Vector3 } from 'three'
 
 export interface WaterOptions {
   textureWidth?: number

package/objects/Water2.d.cts

@@ -0,0 +1,23 @@
+import type { BufferGeometry, Color, Mesh, ShaderMaterial, Texture, Vector2 } from 'three'
+import type { TextureEncoding } from '../types/shared.d.cts'
+
+export interface Water2Options {
+  color?: Color | string | number
+  textureWidth?: number
+  textureHeight?: number
+  clipBias?: number
+  flowDirection?: Vector2
+  flowSpeed?: number
+  reflectivity?: number
+  scale?: number
+  shader?: object
+  flowMap?: Texture
+  normalMap0?: Texture
+  normalMap1?: Texture
+  encoding?: TextureEncoding
+}
+
+export class Water2 extends Mesh {
+  material: ShaderMaterial
+  constructor(geometry: BufferGeometry, options: Water2Options)
+}

package/objects/Water2.d.ts

@@ -1,5 +1,5 @@
-import { BufferGeometry, Color, Mesh, ShaderMaterial, Texture, Vector2 } from 'three'
-import { TextureEncoding } from '../types/shared'
+import type { BufferGeometry, Color, Mesh, ShaderMaterial, Texture, Vector2 } from 'three'
+import type { TextureEncoding } from '../types/shared.d.ts'
 
 export interface Water2Options {
   color?: Color | string | number

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "three-stdlib",
-  "version": "2.35.7",
+  "version": "2.35.9",
   "description": "stand-alone library of threejs examples",
   "keywords": [
     "three",
@@ -22,9 +22,14 @@
   "main": "./index.cjs",
   "module": "./index.js",
   "exports": {
-    "types": "./index.d.ts",
-    "require": "./index.cjs",
-    "import": "./index.js"
+    "require": {
+      "types": "./index.d.cts",
+      "default": "./index.cjs"
+    },
+    "default": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    }
   },
   "sideEffects": false,
   "devDependencies": {
@@ -34,6 +39,7 @@
     "json": "^11.0.0",
     "prettier": "^2.2.1",
     "rimraf": "^3.0.2",
+    "shelljs": "^0.8.5",
     "three": "^0.128.0",
     "typescript": "^4.7.4",
     "vite": "^4.3.8"
@@ -50,7 +56,7 @@
     "three": ">=0.128.0"
   },
   "scripts": {
-    "build": "rimraf dist && vite build && tsc --emitDeclarationOnly && copyfiles -u 1 \"src/**/*.d.ts\" dist && copyfiles package.json README.md LICENSE dist && json -I -f dist/package.json -e \"this.private=undefined;this.type=\\\"module\\\";\"",
+    "build": "rimraf dist && vite build && tsc --emitDeclarationOnly && copyfiles -u 1 \"src/**/*.d.ts\" dist && copyfiles package.json README.md LICENSE dist && json -I -f dist/package.json -e \"this.private=undefined;this.type=\\\"module\\\";\" && node patch-ts.js",
     "lint": "tsc --noEmit"
   },
   "type": "module"

package/physics/AmmoPhysics.d.cts

@@ -0,0 +1,7 @@
+import type { Mesh, Vector3 } from 'three'
+
+export class AmmoPhysics {
+  constructor()
+  addMesh(mesh: Mesh, mass: number): void
+  setMeshPosition(mesh: Mesh, position: Vector3, index: number): void
+}

package/physics/AmmoPhysics.d.ts

@@ -1,4 +1,4 @@
-import { Mesh, Vector3 } from 'three'
+import type { Mesh, Vector3 } from 'three'
 
 export class AmmoPhysics {
   constructor()

package/postprocessing/AdaptiveToneMappingPass.d.cts

@@ -0,0 +1,29 @@
+import type { WebGLRenderTarget, ShaderMaterial } from 'three'
+
+import type { Pass, FullScreenQuad } from './Pass.d.cts'
+
+export class AdaptiveToneMappingPass extends Pass {
+  constructor(adaptive?: boolean, resolution?: number)
+  adaptive: boolean
+  resolution: number
+  needsInit: number
+  luminanceRT: WebGLRenderTarget
+  previousLuminanceRT: WebGLRenderTarget
+  currentLuminanceRT: WebGLRenderTarget
+  copyUniforms: object
+  materialCopy: ShaderMaterial
+  materialLuminance: ShaderMaterial
+  adaptLuminanceShader: object
+  materialAdaptiveLum: ShaderMaterial
+  materialToneMap: ShaderMaterial
+  fsQuad: FullScreenQuad
+
+  reset(): void
+  setAdaptive(adaptive: boolean): void
+  setAdaptionRate(rate: number): void
+  setMinLuminance(minLum: number): void
+  setMaxLuminance(maxLum: number): void
+  setAverageLuminance(avgLum: number): void
+  setMiddleGrey(middleGrey: number): void
+  dispose(): void
+}

package/postprocessing/AdaptiveToneMappingPass.d.ts

@@ -1,6 +1,6 @@
-import { WebGLRenderTarget, ShaderMaterial } from 'three'
+import type { WebGLRenderTarget, ShaderMaterial } from 'three'
 
-import { Pass, FullScreenQuad } from './Pass'
+import type { Pass, FullScreenQuad } from './Pass.d.ts'
 
 export class AdaptiveToneMappingPass extends Pass {
   constructor(adaptive?: boolean, resolution?: number)

package/postprocessing/AfterimagePass.d.cts

@@ -0,0 +1,15 @@
+import type { MeshBasicMaterial, WebGLRenderer, ShaderMaterial, WebGLRenderTarget } from 'three';
+import type { Pass, FullScreenQuad } from './Pass.d.cts';
+declare class AfterimagePass extends Pass {
+    shader: import("../shaders/AfterimageShader").IAfterimageShader;
+    uniforms: any;
+    textureComp: WebGLRenderTarget;
+    textureOld: WebGLRenderTarget;
+    shaderMaterial: ShaderMaterial;
+    compFsQuad: FullScreenQuad<ShaderMaterial>;
+    copyFsQuad: FullScreenQuad<MeshBasicMaterial>;
+    constructor(damp?: number, shader?: import("../shaders/AfterimageShader").IAfterimageShader);
+    render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget, readBuffer: WebGLRenderTarget): void;
+    setSize(width: number, height: number): void;
+}
+export type { AfterimagePass };

package/postprocessing/AfterimagePass.d.ts

@@ -1,5 +1,5 @@
-import { MeshBasicMaterial, WebGLRenderer, ShaderMaterial, WebGLRenderTarget } from 'three';
-import { Pass, FullScreenQuad } from './Pass';
+import type { MeshBasicMaterial, WebGLRenderer, ShaderMaterial, WebGLRenderTarget } from 'three';
+import type { Pass, FullScreenQuad } from './Pass.d.ts';
 declare class AfterimagePass extends Pass {
     shader: import("../shaders/AfterimageShader").IAfterimageShader;
     uniforms: any;
@@ -12,4 +12,4 @@ declare class AfterimagePass extends Pass {
     render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget, readBuffer: WebGLRenderTarget): void;
     setSize(width: number, height: number): void;
 }
-export { AfterimagePass };
+export type { AfterimagePass };

package/postprocessing/BloomPass.d.cts

@@ -0,0 +1,29 @@
+import type { Pass, FullScreenQuad } from './Pass.d.cts';
+import type { IUniform, ShaderMaterial, Vector2, WebGLRenderer, WebGLRenderTarget } from 'three';
+import type { ConvolutionShader } from '../shaders/ConvolutionShader.d.cts';
+declare class BloomPass extends Pass {
+    renderTargetX: WebGLRenderTarget;
+    renderTargetY: WebGLRenderTarget;
+    materialCombine: ShaderMaterial;
+    materialConvolution: ShaderMaterial;
+    fsQuad: FullScreenQuad;
+    combineUniforms: Record<keyof typeof CombineShader['uniforms'], IUniform<any>>;
+    convolutionUniforms: Record<keyof typeof ConvolutionShader['uniforms'], IUniform<any>>;
+    blurX: Vector2;
+    blurY: Vector2;
+    constructor(strength?: number, kernelSize?: number, sigma?: number, resolution?: number);
+    render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget, readBuffer: WebGLRenderTarget, deltaTime: number, maskActive: boolean): void;
+}
+declare const CombineShader: {
+    uniforms: {
+        tDiffuse: {
+            value: null;
+        };
+        strength: {
+            value: number;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};
+export type { BloomPass };

package/postprocessing/BloomPass.d.ts

@@ -1,6 +1,6 @@
-import { Pass, FullScreenQuad } from './Pass';
-import { IUniform, ShaderMaterial, Vector2, WebGLRenderer, WebGLRenderTarget } from 'three';
-import { ConvolutionShader } from '../shaders/ConvolutionShader';
+import type { Pass, FullScreenQuad } from './Pass.d.ts';
+import type { IUniform, ShaderMaterial, Vector2, WebGLRenderer, WebGLRenderTarget } from 'three';
+import type { ConvolutionShader } from '../shaders/ConvolutionShader.d.ts';
 declare class BloomPass extends Pass {
     renderTargetX: WebGLRenderTarget;
     renderTargetY: WebGLRenderTarget;
@@ -26,4 +26,4 @@ declare const CombineShader: {
     vertexShader: string;
     fragmentShader: string;
 };
-export { BloomPass };
+export type { BloomPass };

package/postprocessing/BokehPass.d.cts

@@ -0,0 +1,26 @@
+/**
+ * Depth-of-field post-process with bokeh shader
+ */
+import type { Pass, FullScreenQuad } from './Pass.d.cts';
+import type { MeshDepthMaterial, PerspectiveCamera, Scene, ShaderMaterial, WebGLRenderer, WebGLRenderTarget } from 'three';
+type BokehPassParams = {
+    focus?: number;
+    aspect?: number;
+    aperture?: number;
+    maxblur?: number;
+    width?: number;
+    height?: number;
+};
+declare class BokehPass extends Pass {
+    scene: Scene;
+    camera: PerspectiveCamera;
+    renderTargetDepth: WebGLRenderTarget;
+    materialDepth: MeshDepthMaterial;
+    materialBokeh: ShaderMaterial;
+    fsQuad: FullScreenQuad;
+    private _oldClearColor;
+    uniforms: any;
+    constructor(scene: Scene, camera: PerspectiveCamera, params: BokehPassParams);
+    render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget, readBuffer: WebGLRenderTarget): void;
+}
+export type { BokehPass };

package/postprocessing/BokehPass.d.ts

@@ -1,8 +1,8 @@
 /**
  * Depth-of-field post-process with bokeh shader
  */
-import { Pass, FullScreenQuad } from './Pass';
-import { MeshDepthMaterial, PerspectiveCamera, Scene, ShaderMaterial, WebGLRenderer, WebGLRenderTarget } from 'three';
+import type { Pass, FullScreenQuad } from './Pass.d.ts';
+import type { MeshDepthMaterial, PerspectiveCamera, Scene, ShaderMaterial, WebGLRenderer, WebGLRenderTarget } from 'three';
 type BokehPassParams = {
     focus?: number;
     aspect?: number;
@@ -23,4 +23,4 @@ declare class BokehPass extends Pass {
     constructor(scene: Scene, camera: PerspectiveCamera, params: BokehPassParams);
     render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget, readBuffer: WebGLRenderTarget): void;
 }
-export { BokehPass };
+export type { BokehPass };